nrfdemo

75 files changed, 14420 insertions, 0 deletions

diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/adc.h b/nrfdemo/build/zephyr/include/generated/syscalls/adc.h
new file mode 100644
index 0000000..8384742
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/adc.h
@@ -0,0 +1,101 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ADC_H
+#define Z_INCLUDE_SYSCALLS_ADC_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg);
+
+__pinned_func
+static inline int adc_channel_setup(const struct device * dev, const struct adc_channel_cfg * channel_cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct adc_channel_cfg * val; } parm1 = { .val = channel_cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_CHANNEL_SETUP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_adc_channel_setup(dev, channel_cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define adc_channel_setup(dev, channel_cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg); 	syscall__retval = adc_channel_setup(dev, channel_cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_ADC_CHANNEL_SETUP, adc_channel_setup, dev, channel_cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_adc_read(const struct device * dev, const struct adc_sequence * sequence);
+
+__pinned_func
+static inline int adc_read(const struct device * dev, const struct adc_sequence * sequence)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ADC_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_adc_read(dev, sequence);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define adc_read(dev, sequence) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ, adc_read, dev, sequence); 	syscall__retval = adc_read(dev, sequence); 	sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ, adc_read, dev, sequence, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async);
+
+__pinned_func
+static inline int adc_read_async(const struct device * dev, const struct adc_sequence * sequence, struct k_poll_signal * async)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct adc_sequence * val; } parm1 = { .val = sequence };
+		union { uintptr_t x; struct k_poll_signal * val; } parm2 = { .val = async };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ADC_READ_ASYNC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_adc_read_async(dev, sequence, async);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define adc_read_async(dev, sequence, async) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async); 	syscall__retval = adc_read_async(dev, sequence, async); 	sys_port_trace_syscall_exit(K_SYSCALL_ADC_READ_ASYNC, adc_read_async, dev, sequence, async, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/arch.h b/nrfdemo/build/zephyr/include/generated/syscalls/arch.h
new file mode 100644
index 0000000..2a0836d
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/arch.h
@@ -0,0 +1,52 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ARCH_H
+#define Z_INCLUDE_SYSCALLS_ARCH_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_xtensa_user_fault(unsigned int reason);
+
+__pinned_func
+static inline void xtensa_user_fault(unsigned int reason)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_XTENSA_USER_FAULT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_xtensa_user_fault(reason);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define xtensa_user_fault(reason) do { 	sys_port_trace_syscall_enter(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); 	xtensa_user_fault(reason); 	sys_port_trace_syscall_exit(K_SYSCALL_XTENSA_USER_FAULT, xtensa_user_fault, reason); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/atomic_c.h b/nrfdemo/build/zephyr/include/generated/syscalls/atomic_c.h
new file mode 100644
index 0000000..9ddb691
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/atomic_c.h
@@ -0,0 +1,270 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ATOMIC_C_H
+#define Z_INCLUDE_SYSCALLS_ATOMIC_C_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern bool z_impl_atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value);
+
+__pinned_func
+static inline bool atomic_cas(atomic_t * target, atomic_val_t old_value, atomic_val_t new_value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = old_value };
+		union { uintptr_t x; atomic_val_t val; } parm2 = { .val = new_value };
+		return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_CAS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_cas(target, old_value, new_value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_cas(target, old_value, new_value) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value); 	syscall__retval = atomic_cas(target, old_value, new_value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_CAS, atomic_cas, target, old_value, new_value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value);
+
+__pinned_func
+static inline bool atomic_ptr_cas(atomic_ptr_t * target, atomic_ptr_val_t old_value, atomic_ptr_val_t new_value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = old_value };
+		union { uintptr_t x; atomic_ptr_val_t val; } parm2 = { .val = new_value };
+		return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ATOMIC_PTR_CAS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_ptr_cas(target, old_value, new_value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_ptr_cas(target, old_value, new_value) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value); 	syscall__retval = atomic_ptr_cas(target, old_value, new_value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_CAS, atomic_ptr_cas, target, old_value, new_value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_add(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_add(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_ADD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_add(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_add(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value); 	syscall__retval = atomic_add(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_ADD, atomic_add, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_sub(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_sub(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SUB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_sub(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_sub(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value); 	syscall__retval = atomic_sub(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SUB, atomic_sub, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_set(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_set(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_set(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_set(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_SET, atomic_set, target, value); 	syscall__retval = atomic_set(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_SET, atomic_set, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_ptr_val_t z_impl_atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value);
+
+__pinned_func
+static inline atomic_ptr_val_t atomic_ptr_set(atomic_ptr_t * target, atomic_ptr_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_ptr_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_ptr_val_t val; } parm1 = { .val = value };
+		return (atomic_ptr_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_PTR_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_ptr_set(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_ptr_set(target, value) ({ 	atomic_ptr_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value); 	syscall__retval = atomic_ptr_set(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_PTR_SET, atomic_ptr_set, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_or(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_or(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_OR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_or(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_or(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_OR, atomic_or, target, value); 	syscall__retval = atomic_or(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_OR, atomic_or, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_xor(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_xor(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_XOR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_xor(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_xor(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value); 	syscall__retval = atomic_xor(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_XOR, atomic_xor, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_and(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_and(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_AND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_and(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_and(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_AND, atomic_and, target, value); 	syscall__retval = atomic_and(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_AND, atomic_and, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern atomic_val_t z_impl_atomic_nand(atomic_t * target, atomic_val_t value);
+
+__pinned_func
+static inline atomic_val_t atomic_nand(atomic_t * target, atomic_val_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; atomic_t * val; } parm0 = { .val = target };
+		union { uintptr_t x; atomic_val_t val; } parm1 = { .val = value };
+		return (atomic_val_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ATOMIC_NAND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_atomic_nand(target, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define atomic_nand(target, value) ({ 	atomic_val_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value); 	syscall__retval = atomic_nand(target, value); 	sys_port_trace_syscall_exit(K_SYSCALL_ATOMIC_NAND, atomic_nand, target, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/auxdisplay.h b/nrfdemo/build/zephyr/include/generated/syscalls/auxdisplay.h
new file mode 100644
index 0000000..1cdfadf
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/auxdisplay.h
@@ -0,0 +1,488 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
+#define Z_INCLUDE_SYSCALLS_AUXDISPLAY_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_auxdisplay_display_on(const struct device * dev);
+
+__pinned_func
+static inline int auxdisplay_display_on(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_ON);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_display_on(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_display_on(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev); 	syscall__retval = auxdisplay_display_on(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_ON, auxdisplay_display_on, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_display_off(const struct device * dev);
+
+__pinned_func
+static inline int auxdisplay_display_off(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_DISPLAY_OFF);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_display_off(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_display_off(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev); 	syscall__retval = auxdisplay_display_off(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_OFF, auxdisplay_display_off, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled);
+
+__pinned_func
+static inline int auxdisplay_cursor_set_enabled(const struct device * dev, bool enabled)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = enabled };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_cursor_set_enabled(dev, enabled);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_cursor_set_enabled(dev, enabled) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled); 	syscall__retval = auxdisplay_cursor_set_enabled(dev, enabled); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SET_ENABLED, auxdisplay_cursor_set_enabled, dev, enabled, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled);
+
+__pinned_func
+static inline int auxdisplay_position_blinking_set_enabled(const struct device * dev, bool enabled)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = enabled };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_position_blinking_set_enabled(dev, enabled);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_position_blinking_set_enabled(dev, enabled) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled); 	syscall__retval = auxdisplay_position_blinking_set_enabled(dev, enabled); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_POSITION_BLINKING_SET_ENABLED, auxdisplay_position_blinking_set_enabled, dev, enabled, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift);
+
+__pinned_func
+static inline int auxdisplay_cursor_shift_set(const struct device * dev, uint8_t direction, bool display_shift)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = direction };
+		union { uintptr_t x; bool val; } parm2 = { .val = display_shift };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_cursor_shift_set(dev, direction, display_shift);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_cursor_shift_set(dev, direction, display_shift) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift); 	syscall__retval = auxdisplay_cursor_shift_set(dev, direction, display_shift); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_SHIFT_SET, auxdisplay_cursor_shift_set, dev, direction, display_shift, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
+
+__pinned_func
+static inline int auxdisplay_cursor_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
+		union { uintptr_t x; int16_t val; } parm2 = { .val = x };
+		union { uintptr_t x; int16_t val; } parm3 = { .val = y };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_cursor_position_set(dev, type, x, y);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_cursor_position_set(dev, type, x, y) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y); 	syscall__retval = auxdisplay_cursor_position_set(dev, type, x, y); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_SET, auxdisplay_cursor_position_set, dev, type, x, y, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y);
+
+__pinned_func
+static inline int auxdisplay_cursor_position_get(const struct device * dev, int16_t * x, int16_t * y)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
+		union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_cursor_position_get(dev, x, y);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_cursor_position_get(dev, x, y) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y); 	syscall__retval = auxdisplay_cursor_position_get(dev, x, y); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CURSOR_POSITION_GET, auxdisplay_cursor_position_get, dev, x, y, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y);
+
+__pinned_func
+static inline int auxdisplay_display_position_set(const struct device * dev, enum auxdisplay_position type, int16_t x, int16_t y)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum auxdisplay_position val; } parm1 = { .val = type };
+		union { uintptr_t x; int16_t val; } parm2 = { .val = x };
+		union { uintptr_t x; int16_t val; } parm3 = { .val = y };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_display_position_set(dev, type, x, y);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_display_position_set(dev, type, x, y) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y); 	syscall__retval = auxdisplay_display_position_set(dev, type, x, y); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_SET, auxdisplay_display_position_set, dev, type, x, y, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y);
+
+__pinned_func
+static inline int auxdisplay_display_position_get(const struct device * dev, int16_t * x, int16_t * y)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int16_t * val; } parm1 = { .val = x };
+		union { uintptr_t x; int16_t * val; } parm2 = { .val = y };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_display_position_get(dev, x, y);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_display_position_get(dev, x, y) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y); 	syscall__retval = auxdisplay_display_position_get(dev, x, y); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_DISPLAY_POSITION_GET, auxdisplay_display_position_get, dev, x, y, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities);
+
+__pinned_func
+static inline int auxdisplay_capabilities_get(const struct device * dev, struct auxdisplay_capabilities * capabilities)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct auxdisplay_capabilities * val; } parm1 = { .val = capabilities };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_capabilities_get(dev, capabilities);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_capabilities_get(dev, capabilities) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities); 	syscall__retval = auxdisplay_capabilities_get(dev, capabilities); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CAPABILITIES_GET, auxdisplay_capabilities_get, dev, capabilities, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_clear(const struct device * dev);
+
+__pinned_func
+static inline int auxdisplay_clear(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_CLEAR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_clear(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_clear(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev); 	syscall__retval = auxdisplay_clear(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CLEAR, auxdisplay_clear, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness);
+
+__pinned_func
+static inline int auxdisplay_brightness_get(const struct device * dev, uint8_t * brightness)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = brightness };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_brightness_get(dev, brightness);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_brightness_get(dev, brightness) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness); 	syscall__retval = auxdisplay_brightness_get(dev, brightness); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_GET, auxdisplay_brightness_get, dev, brightness, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_brightness_set(const struct device * dev, uint8_t brightness);
+
+__pinned_func
+static inline int auxdisplay_brightness_set(const struct device * dev, uint8_t brightness)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = brightness };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_brightness_set(dev, brightness);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_brightness_set(dev, brightness) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness); 	syscall__retval = auxdisplay_brightness_set(dev, brightness); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BRIGHTNESS_SET, auxdisplay_brightness_set, dev, brightness, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight);
+
+__pinned_func
+static inline int auxdisplay_backlight_get(const struct device * dev, uint8_t * backlight)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = backlight };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_backlight_get(dev, backlight);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_backlight_get(dev, backlight) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight); 	syscall__retval = auxdisplay_backlight_get(dev, backlight); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_GET, auxdisplay_backlight_get, dev, backlight, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_backlight_set(const struct device * dev, uint8_t backlight);
+
+__pinned_func
+static inline int auxdisplay_backlight_set(const struct device * dev, uint8_t backlight)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = backlight };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_backlight_set(dev, backlight);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_backlight_set(dev, backlight) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight); 	syscall__retval = auxdisplay_backlight_set(dev, backlight); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_BACKLIGHT_SET, auxdisplay_backlight_set, dev, backlight, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_is_busy(const struct device * dev);
+
+__pinned_func
+static inline int auxdisplay_is_busy(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_AUXDISPLAY_IS_BUSY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_is_busy(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_is_busy(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev); 	syscall__retval = auxdisplay_is_busy(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_IS_BUSY, auxdisplay_is_busy, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character);
+
+__pinned_func
+static inline int auxdisplay_custom_character_set(const struct device * dev, struct auxdisplay_character * character)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct auxdisplay_character * val; } parm1 = { .val = character };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_custom_character_set(dev, character);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_custom_character_set(dev, character) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character); 	syscall__retval = auxdisplay_custom_character_set(dev, character); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_CHARACTER_SET, auxdisplay_custom_character_set, dev, character, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len);
+
+__pinned_func
+static inline int auxdisplay_write(const struct device * dev, const uint8_t * data, uint16_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const uint8_t * val; } parm1 = { .val = data };
+		union { uintptr_t x; uint16_t val; } parm2 = { .val = len };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_AUXDISPLAY_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_write(dev, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_write(dev, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len); 	syscall__retval = auxdisplay_write(dev, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_WRITE, auxdisplay_write, dev, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data);
+
+__pinned_func
+static inline int auxdisplay_custom_command(const struct device * dev, struct auxdisplay_custom_data * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct auxdisplay_custom_data * val; } parm1 = { .val = data };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_auxdisplay_custom_command(dev, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define auxdisplay_custom_command(dev, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data); 	syscall__retval = auxdisplay_custom_command(dev, data); 	sys_port_trace_syscall_exit(K_SYSCALL_AUXDISPLAY_CUSTOM_COMMAND, auxdisplay_custom_command, dev, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/bbram.h b/nrfdemo/build/zephyr/include/generated/syscalls/bbram.h
new file mode 100644
index 0000000..2dc492d
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/bbram.h
@@ -0,0 +1,173 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_BBRAM_H
+#define Z_INCLUDE_SYSCALLS_BBRAM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_bbram_check_invalid(const struct device * dev);
+
+__pinned_func
+static inline int bbram_check_invalid(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_INVALID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_check_invalid(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_check_invalid(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev); 	syscall__retval = bbram_check_invalid(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_INVALID, bbram_check_invalid, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bbram_check_standby_power(const struct device * dev);
+
+__pinned_func
+static inline int bbram_check_standby_power(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_STANDBY_POWER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_check_standby_power(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_check_standby_power(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev); 	syscall__retval = bbram_check_standby_power(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_STANDBY_POWER, bbram_check_standby_power, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bbram_check_power(const struct device * dev);
+
+__pinned_func
+static inline int bbram_check_power(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_BBRAM_CHECK_POWER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_check_power(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_check_power(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev); 	syscall__retval = bbram_check_power(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_CHECK_POWER, bbram_check_power, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bbram_get_size(const struct device * dev, size_t * size);
+
+__pinned_func
+static inline int bbram_get_size(const struct device * dev, size_t * size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t * val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BBRAM_GET_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_get_size(dev, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_get_size(dev, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size); 	syscall__retval = bbram_get_size(dev, size); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_GET_SIZE, bbram_get_size, dev, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data);
+
+__pinned_func
+static inline int bbram_read(const struct device * dev, size_t offset, size_t size, uint8_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; size_t val; } parm2 = { .val = size };
+		union { uintptr_t x; uint8_t * val; } parm3 = { .val = data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_read(dev, offset, size, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_read(dev, offset, size, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data); 	syscall__retval = bbram_read(dev, offset, size, data); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_READ, bbram_read, dev, offset, size, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data);
+
+__pinned_func
+static inline int bbram_write(const struct device * dev, size_t offset, size_t size, const uint8_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; size_t val; } parm2 = { .val = size };
+		union { uintptr_t x; const uint8_t * val; } parm3 = { .val = data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_BBRAM_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bbram_write(dev, offset, size, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bbram_write(dev, offset, size, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data); 	syscall__retval = bbram_write(dev, offset, size, data); 	sys_port_trace_syscall_exit(K_SYSCALL_BBRAM_WRITE, bbram_write, dev, offset, size, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/cache.h b/nrfdemo/build/zephyr/include/generated/syscalls/cache.h
new file mode 100644
index 0000000..a942cfc
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/cache.h
@@ -0,0 +1,100 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_CACHE_H
+#define Z_INCLUDE_SYSCALLS_CACHE_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_sys_cache_data_flush_range(void * addr, size_t size);
+
+__pinned_func
+static inline int sys_cache_data_flush_range(void * addr, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = addr };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sys_cache_data_flush_range(addr, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_cache_data_flush_range(addr, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size); 	syscall__retval = sys_cache_data_flush_range(addr, size); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_RANGE, sys_cache_data_flush_range, addr, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sys_cache_data_invd_range(void * addr, size_t size);
+
+__pinned_func
+static inline int sys_cache_data_invd_range(void * addr, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = addr };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sys_cache_data_invd_range(addr, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_cache_data_invd_range(addr, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size); 	syscall__retval = sys_cache_data_invd_range(addr, size); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_INVD_RANGE, sys_cache_data_invd_range, addr, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sys_cache_data_flush_and_invd_range(void * addr, size_t size);
+
+__pinned_func
+static inline int sys_cache_data_flush_and_invd_range(void * addr, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = addr };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sys_cache_data_flush_and_invd_range(addr, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_cache_data_flush_and_invd_range(addr, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size); 	syscall__retval = sys_cache_data_flush_and_invd_range(addr, size); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_CACHE_DATA_FLUSH_AND_INVD_RANGE, sys_cache_data_flush_and_invd_range, addr, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/can.h b/nrfdemo/build/zephyr/include/generated/syscalls/can.h
new file mode 100644
index 0000000..ad0c301
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/can.h
@@ -0,0 +1,812 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_CAN_H
+#define Z_INCLUDE_SYSCALLS_CAN_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_can_get_core_clock(const struct device * dev, uint32_t * rate);
+
+__pinned_func
+static inline int can_get_core_clock(const struct device * dev, uint32_t * rate)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = rate };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CORE_CLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_core_clock(dev, rate);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_core_clock(dev, rate) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate); 	syscall__retval = can_get_core_clock(dev, rate); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CORE_CLOCK, can_get_core_clock, dev, rate, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_get_bitrate_min(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_get_bitrate_min(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MIN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_bitrate_min(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_bitrate_min(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev); 	syscall__retval = can_get_bitrate_min(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MIN, can_get_bitrate_min, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_get_bitrate_max(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_get_bitrate_max(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_BITRATE_MAX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_bitrate_max(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_bitrate_max(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev); 	syscall__retval = can_get_bitrate_max(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_BITRATE_MAX, can_get_bitrate_max, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct can_timing * z_impl_can_get_timing_min(const struct device * dev);
+
+__pinned_func
+static inline const struct can_timing * can_get_timing_min(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MIN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_timing_min(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_timing_min(dev) ({ 	const struct can_timing * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev); 	syscall__retval = can_get_timing_min(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MIN, can_get_timing_min, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct can_timing * z_impl_can_get_timing_max(const struct device * dev);
+
+__pinned_func
+static inline const struct can_timing * can_get_timing_max(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_MAX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_timing_max(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_timing_max(dev) ({ 	const struct can_timing * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev); 	syscall__retval = can_get_timing_max(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_MAX, can_get_timing_max, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
+
+__pinned_func
+static inline int can_calc_timing(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_calc_timing(dev, res, bitrate, sample_pnt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_calc_timing(dev, res, bitrate, sample_pnt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt); 	syscall__retval = can_calc_timing(dev, res, bitrate, sample_pnt); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING, can_calc_timing, dev, res, bitrate, sample_pnt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct can_timing * z_impl_can_get_timing_data_min(const struct device * dev);
+
+__pinned_func
+static inline const struct can_timing * can_get_timing_data_min(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MIN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_timing_data_min(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_timing_data_min(dev) ({ 	const struct can_timing * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev); 	syscall__retval = can_get_timing_data_min(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MIN, can_get_timing_data_min, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct can_timing * z_impl_can_get_timing_data_max(const struct device * dev);
+
+__pinned_func
+static inline const struct can_timing * can_get_timing_data_max(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct can_timing *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TIMING_DATA_MAX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_timing_data_max(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_timing_data_max(dev) ({ 	const struct can_timing * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev); 	syscall__retval = can_get_timing_data_max(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TIMING_DATA_MAX, can_get_timing_data_max, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt);
+
+__pinned_func
+static inline int can_calc_timing_data(const struct device * dev, struct can_timing * res, uint32_t bitrate, uint16_t sample_pnt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct can_timing * val; } parm1 = { .val = res };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = bitrate };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = sample_pnt };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_CAN_CALC_TIMING_DATA);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_calc_timing_data(dev, res, bitrate, sample_pnt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_calc_timing_data(dev, res, bitrate, sample_pnt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt); 	syscall__retval = can_calc_timing_data(dev, res, bitrate, sample_pnt); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_CALC_TIMING_DATA, can_calc_timing_data, dev, res, bitrate, sample_pnt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_set_timing_data(const struct device * dev, const struct can_timing * timing_data);
+
+__pinned_func
+static inline int can_set_timing_data(const struct device * dev, const struct can_timing * timing_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing_data };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING_DATA);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_set_timing_data(dev, timing_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_set_timing_data(dev, timing_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data); 	syscall__retval = can_set_timing_data(dev, timing_data); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING_DATA, can_set_timing_data, dev, timing_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data);
+
+__pinned_func
+static inline int can_set_bitrate_data(const struct device * dev, uint32_t bitrate_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate_data };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE_DATA);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_set_bitrate_data(dev, bitrate_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_set_bitrate_data(dev, bitrate_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data); 	syscall__retval = can_set_bitrate_data(dev, bitrate_data); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE_DATA, can_set_bitrate_data, dev, bitrate_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_set_timing(const struct device * dev, const struct can_timing * timing);
+
+__pinned_func
+static inline int can_set_timing(const struct device * dev, const struct can_timing * timing)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct can_timing * val; } parm1 = { .val = timing };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_TIMING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_set_timing(dev, timing);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_set_timing(dev, timing) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing); 	syscall__retval = can_set_timing(dev, timing); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_TIMING, can_set_timing, dev, timing, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_get_capabilities(const struct device * dev, can_mode_t * cap);
+
+__pinned_func
+static inline int can_get_capabilities(const struct device * dev, can_mode_t * cap)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; can_mode_t * val; } parm1 = { .val = cap };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_CAPABILITIES);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_capabilities(dev, cap);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_capabilities(dev, cap) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap); 	syscall__retval = can_get_capabilities(dev, cap); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_CAPABILITIES, can_get_capabilities, dev, cap, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct device * z_impl_can_get_transceiver(const struct device * dev);
+
+__pinned_func
+static inline const struct device * can_get_transceiver(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_TRANSCEIVER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_transceiver(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_transceiver(dev) ({ 	const struct device * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev); 	syscall__retval = can_get_transceiver(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_TRANSCEIVER, can_get_transceiver, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_start(const struct device * dev);
+
+__pinned_func
+static inline int can_start(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_START);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_start(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_start(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_START, can_start, dev); 	syscall__retval = can_start(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_START, can_start, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_stop(const struct device * dev);
+
+__pinned_func
+static inline int can_stop(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STOP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stop(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stop(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STOP, can_stop, dev); 	syscall__retval = can_stop(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STOP, can_stop, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_set_mode(const struct device * dev, can_mode_t mode);
+
+__pinned_func
+static inline int can_set_mode(const struct device * dev, can_mode_t mode)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; can_mode_t val; } parm1 = { .val = mode };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_MODE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_set_mode(dev, mode);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_set_mode(dev, mode) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode); 	syscall__retval = can_set_mode(dev, mode); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_MODE, can_set_mode, dev, mode, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern can_mode_t z_impl_can_get_mode(const struct device * dev);
+
+__pinned_func
+static inline can_mode_t can_get_mode(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (can_mode_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_GET_MODE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_mode(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_mode(dev) ({ 	can_mode_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev); 	syscall__retval = can_get_mode(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MODE, can_get_mode, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_set_bitrate(const struct device * dev, uint32_t bitrate);
+
+__pinned_func
+static inline int can_set_bitrate(const struct device * dev, uint32_t bitrate)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_SET_BITRATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_set_bitrate(dev, bitrate);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_set_bitrate(dev, bitrate) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate); 	syscall__retval = can_set_bitrate(dev, bitrate); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SET_BITRATE, can_set_bitrate, dev, bitrate, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data);
+
+__pinned_func
+static inline int can_send(const struct device * dev, const struct can_frame * frame, k_timeout_t timeout, can_tx_callback_t callback, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct can_frame * val; } parm1 = { .val = frame };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		union { uintptr_t x; can_tx_callback_t val; } parm3 = { .val = callback };
+		union { uintptr_t x; void * val; } parm4 = { .val = user_data };
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, parm3.x, parm4.x, K_SYSCALL_CAN_SEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_send(dev, frame, timeout, callback, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_send(dev, frame, timeout, callback, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data); 	syscall__retval = can_send(dev, frame, timeout, callback, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_SEND, can_send, dev, frame, timeout, callback, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter);
+
+__pinned_func
+static inline int can_add_rx_filter_msgq(const struct device * dev, struct k_msgq * msgq, const struct can_filter * filter)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct k_msgq * val; } parm1 = { .val = msgq };
+		union { uintptr_t x; const struct can_filter * val; } parm2 = { .val = filter };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_add_rx_filter_msgq(dev, msgq, filter);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_add_rx_filter_msgq(dev, msgq, filter) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter); 	syscall__retval = can_add_rx_filter_msgq(dev, msgq, filter); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_ADD_RX_FILTER_MSGQ, can_add_rx_filter_msgq, dev, msgq, filter, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_can_remove_rx_filter(const struct device * dev, int filter_id);
+
+__pinned_func
+static inline void can_remove_rx_filter(const struct device * dev, int filter_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int val; } parm1 = { .val = filter_id };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_REMOVE_RX_FILTER);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_can_remove_rx_filter(dev, filter_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_remove_rx_filter(dev, filter_id) do { 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); 	can_remove_rx_filter(dev, filter_id); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_REMOVE_RX_FILTER, can_remove_rx_filter, dev, filter_id); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_can_get_max_filters(const struct device * dev, bool ide);
+
+__pinned_func
+static inline int can_get_max_filters(const struct device * dev, bool ide)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = ide };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CAN_GET_MAX_FILTERS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_max_filters(dev, ide);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_max_filters(dev, ide) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide); 	syscall__retval = can_get_max_filters(dev, ide); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_MAX_FILTERS, can_get_max_filters, dev, ide, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt);
+
+__pinned_func
+static inline int can_get_state(const struct device * dev, enum can_state * state, struct can_bus_err_cnt * err_cnt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum can_state * val; } parm1 = { .val = state };
+		union { uintptr_t x; struct can_bus_err_cnt * val; } parm2 = { .val = err_cnt };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CAN_GET_STATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_get_state(dev, state, err_cnt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_get_state(dev, state, err_cnt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt); 	syscall__retval = can_get_state(dev, state, err_cnt); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_GET_STATE, can_get_state, dev, state, err_cnt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_can_recover(const struct device * dev, k_timeout_t timeout);
+
+__pinned_func
+static inline int can_recover(const struct device * dev, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_CAN_RECOVER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_recover(dev, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_recover(dev, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout); 	syscall__retval = can_recover(dev, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_RECOVER, can_recover, dev, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_bit_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_bit_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_bit_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_bit_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev); 	syscall__retval = can_stats_get_bit_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT_ERRORS, can_stats_get_bit_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_bit0_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_bit0_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_bit0_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_bit0_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev); 	syscall__retval = can_stats_get_bit0_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT0_ERRORS, can_stats_get_bit0_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_bit1_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_bit1_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_bit1_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_bit1_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev); 	syscall__retval = can_stats_get_bit1_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_BIT1_ERRORS, can_stats_get_bit1_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_stuff_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_stuff_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_stuff_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_stuff_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev); 	syscall__retval = can_stats_get_stuff_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_STUFF_ERRORS, can_stats_get_stuff_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_crc_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_crc_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_CRC_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_crc_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_crc_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev); 	syscall__retval = can_stats_get_crc_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_CRC_ERRORS, can_stats_get_crc_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_form_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_form_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_FORM_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_form_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_form_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev); 	syscall__retval = can_stats_get_form_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_FORM_ERRORS, can_stats_get_form_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_ack_errors(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_ack_errors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_ACK_ERRORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_ack_errors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_ack_errors(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev); 	syscall__retval = can_stats_get_ack_errors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_ACK_ERRORS, can_stats_get_ack_errors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_can_stats_get_rx_overruns(const struct device * dev);
+
+__pinned_func
+static inline uint32_t can_stats_get_rx_overruns(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_can_stats_get_rx_overruns(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define can_stats_get_rx_overruns(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev); 	syscall__retval = can_stats_get_rx_overruns(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_CAN_STATS_GET_RX_OVERRUNS, can_stats_get_rx_overruns, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/charger.h b/nrfdemo/build/zephyr/include/generated/syscalls/charger.h
new file mode 100644
index 0000000..c61582f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/charger.h
@@ -0,0 +1,102 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_CHARGER_H
+#define Z_INCLUDE_SYSCALLS_CHARGER_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val);
+
+__pinned_func
+static inline int charger_get_prop(const struct device * dev, const charger_prop_t prop, union charger_propval * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
+		union { uintptr_t x; union charger_propval * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_GET_PROP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_charger_get_prop(dev, prop, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define charger_get_prop(dev, prop, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val); 	syscall__retval = charger_get_prop(dev, prop, val); 	sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_GET_PROP, charger_get_prop, dev, prop, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val);
+
+__pinned_func
+static inline int charger_set_prop(const struct device * dev, const charger_prop_t prop, const union charger_propval * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const charger_prop_t val; } parm1 = { .val = prop };
+		union { uintptr_t x; const union charger_propval * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_CHARGER_SET_PROP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_charger_set_prop(dev, prop, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define charger_set_prop(dev, prop, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val); 	syscall__retval = charger_set_prop(dev, prop, val); 	sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_SET_PROP, charger_set_prop, dev, prop, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_charger_charge_enable(const struct device * dev, const bool enable);
+
+__pinned_func
+static inline int charger_charge_enable(const struct device * dev, const bool enable)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const bool val; } parm1 = { .val = enable };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_CHARGER_CHARGE_ENABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_charger_charge_enable(dev, enable);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define charger_charge_enable(dev, enable) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable); 	syscall__retval = charger_charge_enable(dev, enable); 	sys_port_trace_syscall_exit(K_SYSCALL_CHARGER_CHARGE_ENABLE, charger_charge_enable, dev, enable, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/counter.h b/nrfdemo/build/zephyr/include/generated/syscalls/counter.h
new file mode 100644
index 0000000..6fe95d7
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/counter.h
@@ -0,0 +1,432 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_COUNTER_H
+#define Z_INCLUDE_SYSCALLS_COUNTER_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern bool z_impl_counter_is_counting_up(const struct device * dev);
+
+__pinned_func
+static inline bool counter_is_counting_up(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_IS_COUNTING_UP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_is_counting_up(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_is_counting_up(dev) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_IS_COUNTING_UP, counter_is_counting_up, dev); 	syscall__retval = counter_is_counting_up(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_IS_COUNTING_UP, counter_is_counting_up, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint8_t z_impl_counter_get_num_of_channels(const struct device * dev);
+
+__pinned_func
+static inline uint8_t counter_get_num_of_channels(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint8_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_num_of_channels(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_num_of_channels(dev) ({ 	uint8_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS, counter_get_num_of_channels, dev); 	syscall__retval = counter_get_num_of_channels(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_NUM_OF_CHANNELS, counter_get_num_of_channels, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_counter_get_frequency(const struct device * dev);
+
+__pinned_func
+static inline uint32_t counter_get_frequency(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_FREQUENCY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_frequency(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_frequency(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_FREQUENCY, counter_get_frequency, dev); 	syscall__retval = counter_get_frequency(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_FREQUENCY, counter_get_frequency, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_counter_us_to_ticks(const struct device * dev, uint64_t us);
+
+__pinned_func
+static inline uint32_t counter_us_to_ticks(const struct device * dev, uint64_t us)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm1 = { .val = us };
+		return (uint32_t) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_COUNTER_US_TO_TICKS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_us_to_ticks(dev, us);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_us_to_ticks(dev, us) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_US_TO_TICKS, counter_us_to_ticks, dev, us); 	syscall__retval = counter_us_to_ticks(dev, us); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_US_TO_TICKS, counter_us_to_ticks, dev, us, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint64_t z_impl_counter_ticks_to_us(const struct device * dev, uint32_t ticks);
+
+__pinned_func
+static inline uint64_t counter_ticks_to_us(const struct device * dev, uint32_t ticks)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
+		(void) arch_syscall_invoke3(parm0.x, parm1.x, (uintptr_t)&ret64, K_SYSCALL_COUNTER_TICKS_TO_US);
+		return (uint64_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_ticks_to_us(dev, ticks);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_ticks_to_us(dev, ticks) ({ 	uint64_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_TICKS_TO_US, counter_ticks_to_us, dev, ticks); 	syscall__retval = counter_ticks_to_us(dev, ticks); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_TICKS_TO_US, counter_ticks_to_us, dev, ticks, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_counter_get_max_top_value(const struct device * dev);
+
+__pinned_func
+static inline uint32_t counter_get_max_top_value(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_max_top_value(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_max_top_value(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE, counter_get_max_top_value, dev); 	syscall__retval = counter_get_max_top_value(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_MAX_TOP_VALUE, counter_get_max_top_value, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_start(const struct device * dev);
+
+__pinned_func
+static inline int counter_start(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_START);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_start(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_start(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_START, counter_start, dev); 	syscall__retval = counter_start(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_START, counter_start, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_stop(const struct device * dev);
+
+__pinned_func
+static inline int counter_stop(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_STOP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_stop(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_stop(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_STOP, counter_stop, dev); 	syscall__retval = counter_stop(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_STOP, counter_stop, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_get_value(const struct device * dev, uint32_t * ticks);
+
+__pinned_func
+static inline int counter_get_value(const struct device * dev, uint32_t * ticks)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = ticks };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_VALUE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_value(dev, ticks);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_value(dev, ticks) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_VALUE, counter_get_value, dev, ticks); 	syscall__retval = counter_get_value(dev, ticks); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_VALUE, counter_get_value, dev, ticks, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_get_value_64(const struct device * dev, uint64_t * ticks);
+
+__pinned_func
+static inline int counter_get_value_64(const struct device * dev, uint64_t * ticks)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint64_t * val; } parm1 = { .val = ticks };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_VALUE_64);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_value_64(dev, ticks);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_value_64(dev, ticks) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_VALUE_64, counter_get_value_64, dev, ticks); 	syscall__retval = counter_get_value_64(dev, ticks); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_VALUE_64, counter_get_value_64, dev, ticks, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_set_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg);
+
+__pinned_func
+static inline int counter_set_channel_alarm(const struct device * dev, uint8_t chan_id, const struct counter_alarm_cfg * alarm_cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
+		union { uintptr_t x; const struct counter_alarm_cfg * val; } parm2 = { .val = alarm_cfg };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_CHANNEL_ALARM);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_set_channel_alarm(dev, chan_id, alarm_cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_set_channel_alarm(dev, chan_id, alarm_cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg); 	syscall__retval = counter_set_channel_alarm(dev, chan_id, alarm_cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_CHANNEL_ALARM, counter_set_channel_alarm, dev, chan_id, alarm_cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id);
+
+__pinned_func
+static inline int counter_cancel_channel_alarm(const struct device * dev, uint8_t chan_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = chan_id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_cancel_channel_alarm(dev, chan_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_cancel_channel_alarm(dev, chan_id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id); 	syscall__retval = counter_cancel_channel_alarm(dev, chan_id); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_CANCEL_CHANNEL_ALARM, counter_cancel_channel_alarm, dev, chan_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg);
+
+__pinned_func
+static inline int counter_set_top_value(const struct device * dev, const struct counter_top_cfg * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct counter_top_cfg * val; } parm1 = { .val = cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_SET_TOP_VALUE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_set_top_value(dev, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_set_top_value(dev, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg); 	syscall__retval = counter_set_top_value(dev, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_TOP_VALUE, counter_set_top_value, dev, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_get_pending_int(const struct device * dev);
+
+__pinned_func
+static inline int counter_get_pending_int(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_PENDING_INT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_pending_int(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_pending_int(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev); 	syscall__retval = counter_get_pending_int(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_PENDING_INT, counter_get_pending_int, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_counter_get_top_value(const struct device * dev);
+
+__pinned_func
+static inline uint32_t counter_get_top_value(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_COUNTER_GET_TOP_VALUE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_top_value(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_top_value(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev); 	syscall__retval = counter_get_top_value(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_TOP_VALUE, counter_get_top_value, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags);
+
+__pinned_func
+static inline int counter_set_guard_period(const struct device * dev, uint32_t ticks, uint32_t flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = ticks };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = flags };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_COUNTER_SET_GUARD_PERIOD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_set_guard_period(dev, ticks, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_set_guard_period(dev, ticks, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags); 	syscall__retval = counter_set_guard_period(dev, ticks, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_SET_GUARD_PERIOD, counter_set_guard_period, dev, ticks, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_counter_get_guard_period(const struct device * dev, uint32_t flags);
+
+__pinned_func
+static inline uint32_t counter_get_guard_period(const struct device * dev, uint32_t flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = flags };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_COUNTER_GET_GUARD_PERIOD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_counter_get_guard_period(dev, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define counter_get_guard_period(dev, flags) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags); 	syscall__retval = counter_get_guard_period(dev, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_COUNTER_GET_GUARD_PERIOD, counter_get_guard_period, dev, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/dac.h b/nrfdemo/build/zephyr/include/generated/syscalls/dac.h
new file mode 100644
index 0000000..9a23aae
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/dac.h
@@ -0,0 +1,77 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_DAC_H
+#define Z_INCLUDE_SYSCALLS_DAC_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg);
+
+__pinned_func
+static inline int dac_channel_setup(const struct device * dev, const struct dac_channel_cfg * channel_cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct dac_channel_cfg * val; } parm1 = { .val = channel_cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DAC_CHANNEL_SETUP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dac_channel_setup(dev, channel_cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dac_channel_setup(dev, channel_cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg); 	syscall__retval = dac_channel_setup(dev, channel_cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_DAC_CHANNEL_SETUP, dac_channel_setup, dev, channel_cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_dac_write_value(const struct device * dev, uint8_t channel, uint32_t value);
+
+__pinned_func
+static inline int dac_write_value(const struct device * dev, uint8_t channel, uint32_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = channel };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = value };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DAC_WRITE_VALUE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dac_write_value(dev, channel, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dac_write_value(dev, channel, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value); 	syscall__retval = dac_write_value(dev, channel, value); 	sys_port_trace_syscall_exit(K_SYSCALL_DAC_WRITE_VALUE, dac_write_value, dev, channel, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/demand_paging.h b/nrfdemo/build/zephyr/include/generated/syscalls/demand_paging.h
new file mode 100644
index 0000000..15eb89c
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/demand_paging.h
@@ -0,0 +1,149 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
+#define Z_INCLUDE_SYSCALLS_DEMAND_PAGING_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats);
+
+__pinned_func
+static inline void k_mem_paging_stats_get(struct k_mem_paging_stats_t * stats)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm0 = { .val = stats };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_STATS_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_mem_paging_stats_get(stats);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_mem_paging_stats_get(stats) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); 	k_mem_paging_stats_get(stats); 	sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_STATS_GET, k_mem_paging_stats_get, stats); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats);
+
+__pinned_func
+static inline void k_mem_paging_thread_stats_get(struct k_thread * thread, struct k_mem_paging_stats_t * stats)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
+		union { uintptr_t x; struct k_mem_paging_stats_t * val; } parm1 = { .val = stats };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_mem_paging_thread_stats_get(thread, stats);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_mem_paging_thread_stats_get(thread, stats) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); 	k_mem_paging_thread_stats_get(thread, stats); 	sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_THREAD_STATS_GET, k_mem_paging_thread_stats_get, thread, stats); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist);
+
+__pinned_func
+static inline void k_mem_paging_histogram_eviction_get(struct k_mem_paging_histogram_t * hist)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_mem_paging_histogram_eviction_get(hist);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_mem_paging_histogram_eviction_get(hist) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); 	k_mem_paging_histogram_eviction_get(hist); 	sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_EVICTION_GET, k_mem_paging_histogram_eviction_get, hist); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist);
+
+__pinned_func
+static inline void k_mem_paging_histogram_backing_store_page_in_get(struct k_mem_paging_histogram_t * hist)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_mem_paging_histogram_backing_store_page_in_get(hist);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_mem_paging_histogram_backing_store_page_in_get(hist) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); 	k_mem_paging_histogram_backing_store_page_in_get(hist); 	sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_IN_GET, k_mem_paging_histogram_backing_store_page_in_get, hist); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist);
+
+__pinned_func
+static inline void k_mem_paging_histogram_backing_store_page_out_get(struct k_mem_paging_histogram_t * hist)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mem_paging_histogram_t * val; } parm0 = { .val = hist };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_mem_paging_histogram_backing_store_page_out_get(hist);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_mem_paging_histogram_backing_store_page_out_get(hist) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); 	k_mem_paging_histogram_backing_store_page_out_get(hist); 	sys_port_trace_syscall_exit(K_SYSCALL_K_MEM_PAGING_HISTOGRAM_BACKING_STORE_PAGE_OUT_GET, k_mem_paging_histogram_backing_store_page_out_get, hist); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/device.h b/nrfdemo/build/zephyr/include/generated/syscalls/device.h
new file mode 100644
index 0000000..9912bd3
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/device.h
@@ -0,0 +1,97 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_DEVICE_H
+#define Z_INCLUDE_SYSCALLS_DEVICE_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const struct device * z_impl_device_get_binding(const char * name);
+
+__pinned_func
+static inline const struct device * device_get_binding(const char * name)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const char * val; } parm0 = { .val = name };
+		return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_GET_BINDING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_device_get_binding(name);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define device_get_binding(name) ({ 	const struct device * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name); 	syscall__retval = device_get_binding(name); 	sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_GET_BINDING, device_get_binding, name, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_device_is_ready(const struct device * dev);
+
+__pinned_func
+static inline bool device_is_ready(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_IS_READY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_device_is_ready(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define device_is_ready(dev) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev); 	syscall__retval = device_is_ready(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_IS_READY, device_is_ready, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_device_init(const struct device * dev);
+
+__pinned_func
+static inline int device_init(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVICE_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_device_init(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define device_init(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DEVICE_INIT, device_init, dev); 	syscall__retval = device_init(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_DEVICE_INIT, device_init, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/devmux.h b/nrfdemo/build/zephyr/include/generated/syscalls/devmux.h
new file mode 100644
index 0000000..0b14ab2
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/devmux.h
@@ -0,0 +1,75 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_DEVMUX_H
+#define Z_INCLUDE_SYSCALLS_DEVMUX_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern ssize_t z_impl_devmux_select_get(const struct device * dev);
+
+__pinned_func
+static inline ssize_t devmux_select_get(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (ssize_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_DEVMUX_SELECT_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_devmux_select_get(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define devmux_select_get(dev) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev); 	syscall__retval = devmux_select_get(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_GET, devmux_select_get, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_devmux_select_set(struct device * dev, size_t index);
+
+__pinned_func
+static inline int devmux_select_set(struct device * dev, size_t index)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t val; } parm1 = { .val = index };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DEVMUX_SELECT_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_devmux_select_set(dev, index);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define devmux_select_set(dev, index) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index); 	syscall__retval = devmux_select_set(dev, index); 	sys_port_trace_syscall_exit(K_SYSCALL_DEVMUX_SELECT_SET, devmux_select_set, dev, index, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/dma.h b/nrfdemo/build/zephyr/include/generated/syscalls/dma.h
new file mode 100644
index 0000000..7bb093f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/dma.h
@@ -0,0 +1,198 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_DMA_H
+#define Z_INCLUDE_SYSCALLS_DMA_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_dma_start(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int dma_start(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_START);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_start(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_start(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_START, dma_start, dev, channel); 	syscall__retval = dma_start(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_START, dma_start, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_dma_stop(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int dma_stop(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_STOP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_stop(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_stop(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_STOP, dma_stop, dev, channel); 	syscall__retval = dma_stop(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_STOP, dma_stop, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_dma_suspend(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int dma_suspend(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_SUSPEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_suspend(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_suspend(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_SUSPEND, dma_suspend, dev, channel); 	syscall__retval = dma_suspend(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_SUSPEND, dma_suspend, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_dma_resume(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int dma_resume(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_RESUME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_resume(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_resume(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_RESUME, dma_resume, dev, channel); 	syscall__retval = dma_resume(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_RESUME, dma_resume, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_dma_request_channel(const struct device * dev, void * filter_param);
+
+__pinned_func
+static inline int dma_request_channel(const struct device * dev, void * filter_param)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; void * val; } parm1 = { .val = filter_param };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_REQUEST_CHANNEL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_request_channel(dev, filter_param);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_request_channel(dev, filter_param) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_REQUEST_CHANNEL, dma_request_channel, dev, filter_param); 	syscall__retval = dma_request_channel(dev, filter_param); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_REQUEST_CHANNEL, dma_request_channel, dev, filter_param, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_dma_release_channel(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline void dma_release_channel(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_DMA_RELEASE_CHANNEL);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_dma_release_channel(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_release_channel(dev, channel) do { 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_RELEASE_CHANNEL, dma_release_channel, dev, channel); 	dma_release_channel(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_RELEASE_CHANNEL, dma_release_channel, dev, channel); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_dma_chan_filter(const struct device * dev, int channel, void * filter_param);
+
+__pinned_func
+static inline int dma_chan_filter(const struct device * dev, int channel, void * filter_param)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int val; } parm1 = { .val = channel };
+		union { uintptr_t x; void * val; } parm2 = { .val = filter_param };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_DMA_CHAN_FILTER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_dma_chan_filter(dev, channel, filter_param);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define dma_chan_filter(dev, channel, filter_param) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_DMA_CHAN_FILTER, dma_chan_filter, dev, channel, filter_param); 	syscall__retval = dma_chan_filter(dev, channel, filter_param); 	sys_port_trace_syscall_exit(K_SYSCALL_DMA_CHAN_FILTER, dma_chan_filter, dev, channel, filter_param, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/eeprom.h b/nrfdemo/build/zephyr/include/generated/syscalls/eeprom.h
new file mode 100644
index 0000000..70ea3e0
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/eeprom.h
@@ -0,0 +1,103 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_EEPROM_H
+#define Z_INCLUDE_SYSCALLS_EEPROM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_eeprom_read(const struct device * dev, off_t offset, void * data, size_t len);
+
+__pinned_func
+static inline int eeprom_read(const struct device * dev, off_t offset, void * data, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; void * val; } parm2 = { .val = data };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_eeprom_read(dev, offset, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define eeprom_read(dev, offset, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len); 	syscall__retval = eeprom_read(dev, offset, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_READ, eeprom_read, dev, offset, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len);
+
+__pinned_func
+static inline int eeprom_write(const struct device * dev, off_t offset, const void * data, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; const void * val; } parm2 = { .val = data };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_EEPROM_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_eeprom_write(dev, offset, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define eeprom_write(dev, offset, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len); 	syscall__retval = eeprom_write(dev, offset, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_WRITE, eeprom_write, dev, offset, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_eeprom_get_size(const struct device * dev);
+
+__pinned_func
+static inline size_t eeprom_get_size(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_EEPROM_GET_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_eeprom_get_size(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define eeprom_get_size(dev) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev); 	syscall__retval = eeprom_get_size(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_EEPROM_GET_SIZE, eeprom_get_size, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/emul_fuel_gauge.h b/nrfdemo/build/zephyr/include/generated/syscalls/emul_fuel_gauge.h
new file mode 100644
index 0000000..54b754c
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/emul_fuel_gauge.h
@@ -0,0 +1,77 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
+#define Z_INCLUDE_SYSCALLS_EMUL_FUEL_GAUGE_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA);
+
+__pinned_func
+static inline int emul_fuel_gauge_set_battery_charging(const struct emul * target, uint32_t uV, int uA)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = uV };
+		union { uintptr_t x; int val; } parm2 = { .val = uA };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_emul_fuel_gauge_set_battery_charging(target, uV, uA);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define emul_fuel_gauge_set_battery_charging(target, uV, uA) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA); 	syscall__retval = emul_fuel_gauge_set_battery_charging(target, uV, uA); 	sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_SET_BATTERY_CHARGING, emul_fuel_gauge_set_battery_charging, target, uV, uA, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff);
+
+__pinned_func
+static inline int emul_fuel_gauge_is_battery_cutoff(const struct emul * target, bool * cutoff)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct emul * val; } parm0 = { .val = target };
+		union { uintptr_t x; bool * val; } parm1 = { .val = cutoff };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_emul_fuel_gauge_is_battery_cutoff(target, cutoff);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define emul_fuel_gauge_is_battery_cutoff(target, cutoff) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff); 	syscall__retval = emul_fuel_gauge_is_battery_cutoff(target, cutoff); 	sys_port_trace_syscall_exit(K_SYSCALL_EMUL_FUEL_GAUGE_IS_BATTERY_CUTOFF, emul_fuel_gauge_is_battery_cutoff, target, cutoff, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/entropy.h b/nrfdemo/build/zephyr/include/generated/syscalls/entropy.h
new file mode 100644
index 0000000..e44cf95
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/entropy.h
@@ -0,0 +1,53 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ENTROPY_H
+#define Z_INCLUDE_SYSCALLS_ENTROPY_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length);
+
+__pinned_func
+static inline int entropy_get_entropy(const struct device * dev, uint8_t * buffer, uint16_t length)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = buffer };
+		union { uintptr_t x; uint16_t val; } parm2 = { .val = length };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ENTROPY_GET_ENTROPY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_entropy_get_entropy(dev, buffer, length);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define entropy_get_entropy(dev, buffer, length) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length); 	syscall__retval = entropy_get_entropy(dev, buffer, length); 	sys_port_trace_syscall_exit(K_SYSCALL_ENTROPY_GET_ENTROPY, entropy_get_entropy, dev, buffer, length, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/errno_private.h b/nrfdemo/build/zephyr/include/generated/syscalls/errno_private.h
new file mode 100644
index 0000000..28a8029
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/errno_private.h
@@ -0,0 +1,43 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
+#define Z_INCLUDE_SYSCALLS_ERRNO_PRIVATE_H
+
+
+
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int * z_impl_z_errno(void);
+
+__pinned_func
+static inline int * z_errno(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int *) arch_syscall_invoke0(K_SYSCALL_Z_ERRNO);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_z_errno();
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/error.h b/nrfdemo/build/zephyr/include/generated/syscalls/error.h
new file mode 100644
index 0000000..2a1cc57
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/error.h
@@ -0,0 +1,52 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ERROR_H
+#define Z_INCLUDE_SYSCALLS_ERROR_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_user_fault(unsigned int reason);
+
+__pinned_func
+static inline void user_fault(unsigned int reason)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; unsigned int val; } parm0 = { .val = reason };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_USER_FAULT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_user_fault(reason);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define user_fault(reason) do { 	sys_port_trace_syscall_enter(K_SYSCALL_USER_FAULT, user_fault, reason); 	user_fault(reason); 	sys_port_trace_syscall_exit(K_SYSCALL_USER_FAULT, user_fault, reason); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/espi.h b/nrfdemo/build/zephyr/include/generated/syscalls/espi.h
new file mode 100644
index 0000000..f1db415
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/espi.h
@@ -0,0 +1,344 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ESPI_H
+#define Z_INCLUDE_SYSCALLS_ESPI_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_espi_config(const struct device * dev, struct espi_cfg * cfg);
+
+__pinned_func
+static inline int espi_config(const struct device * dev, struct espi_cfg * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_cfg * val; } parm1 = { .val = cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_config(dev, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_config(dev, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg); 	syscall__retval = espi_config(dev, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_CONFIG, espi_config, dev, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_espi_get_channel_status(const struct device * dev, enum espi_channel ch);
+
+__pinned_func
+static inline bool espi_get_channel_status(const struct device * dev, enum espi_channel ch)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum espi_channel val; } parm1 = { .val = ch };
+		return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_GET_CHANNEL_STATUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_get_channel_status(dev, ch);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_get_channel_status(dev, ch) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch); 	syscall__retval = espi_get_channel_status(dev, ch); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_GET_CHANNEL_STATUS, espi_get_channel_status, dev, ch, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_read_request(const struct device * dev, struct espi_request_packet * req);
+
+__pinned_func
+static inline int espi_read_request(const struct device * dev, struct espi_request_packet * req)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_REQUEST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_read_request(dev, req);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_read_request(dev, req) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req); 	syscall__retval = espi_read_request(dev, req); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_REQUEST, espi_read_request, dev, req, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_write_request(const struct device * dev, struct espi_request_packet * req);
+
+__pinned_func
+static inline int espi_write_request(const struct device * dev, struct espi_request_packet * req)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_request_packet * val; } parm1 = { .val = req };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_REQUEST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_write_request(dev, req);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_write_request(dev, req) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req); 	syscall__retval = espi_write_request(dev, req); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_REQUEST, espi_write_request, dev, req, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
+
+__pinned_func
+static inline int espi_read_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
+		union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_READ_LPC_REQUEST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_read_lpc_request(dev, op, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_read_lpc_request(dev, op, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data); 	syscall__retval = espi_read_lpc_request(dev, op, data); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_LPC_REQUEST, espi_read_lpc_request, dev, op, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data);
+
+__pinned_func
+static inline int espi_write_lpc_request(const struct device * dev, enum lpc_peripheral_opcode op, uint32_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum lpc_peripheral_opcode val; } parm1 = { .val = op };
+		union { uintptr_t x; uint32_t * val; } parm2 = { .val = data };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_WRITE_LPC_REQUEST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_write_lpc_request(dev, op, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_write_lpc_request(dev, op, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data); 	syscall__retval = espi_write_lpc_request(dev, op, data); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_LPC_REQUEST, espi_write_lpc_request, dev, op, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level);
+
+__pinned_func
+static inline int espi_send_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t level)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = level };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_SEND_VWIRE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_send_vwire(dev, signal, level);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_send_vwire(dev, signal, level) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level); 	syscall__retval = espi_send_vwire(dev, signal, level); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_VWIRE, espi_send_vwire, dev, signal, level, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level);
+
+__pinned_func
+static inline int espi_receive_vwire(const struct device * dev, enum espi_vwire_signal signal, uint8_t * level)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum espi_vwire_signal val; } parm1 = { .val = signal };
+		union { uintptr_t x; uint8_t * val; } parm2 = { .val = level };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ESPI_RECEIVE_VWIRE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_receive_vwire(dev, signal, level);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_receive_vwire(dev, signal, level) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level); 	syscall__retval = espi_receive_vwire(dev, signal, level); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_VWIRE, espi_receive_vwire, dev, signal, level, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt);
+
+__pinned_func
+static inline int espi_send_oob(const struct device * dev, struct espi_oob_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SEND_OOB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_send_oob(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_send_oob(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt); 	syscall__retval = espi_send_oob(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SEND_OOB, espi_send_oob, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt);
+
+__pinned_func
+static inline int espi_receive_oob(const struct device * dev, struct espi_oob_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_oob_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_RECEIVE_OOB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_receive_oob(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_receive_oob(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt); 	syscall__retval = espi_receive_oob(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_RECEIVE_OOB, espi_receive_oob, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt);
+
+__pinned_func
+static inline int espi_read_flash(const struct device * dev, struct espi_flash_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_READ_FLASH);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_read_flash(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_read_flash(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt); 	syscall__retval = espi_read_flash(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_READ_FLASH, espi_read_flash, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt);
+
+__pinned_func
+static inline int espi_write_flash(const struct device * dev, struct espi_flash_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_WRITE_FLASH);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_write_flash(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_write_flash(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt); 	syscall__retval = espi_write_flash(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_WRITE_FLASH, espi_write_flash, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt);
+
+__pinned_func
+static inline int espi_flash_erase(const struct device * dev, struct espi_flash_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_flash_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_FLASH_ERASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_flash_erase(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_flash_erase(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt); 	syscall__retval = espi_flash_erase(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_FLASH_ERASE, espi_flash_erase, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/espi_saf.h b/nrfdemo/build/zephyr/include/generated/syscalls/espi_saf.h
new file mode 100644
index 0000000..40bb004
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/espi_saf.h
@@ -0,0 +1,218 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ESPI_SAF_H
+#define Z_INCLUDE_SYSCALLS_ESPI_SAF_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg);
+
+__pinned_func
+static inline int espi_saf_config(const struct device * dev, const struct espi_saf_cfg * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct espi_saf_cfg * val; } parm1 = { .val = cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_config(dev, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_config(dev, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg); 	syscall__retval = espi_saf_config(dev, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_CONFIG, espi_saf_config, dev, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr);
+
+__pinned_func
+static inline int espi_saf_set_protection_regions(const struct device * dev, const struct espi_saf_protection * pr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct espi_saf_protection * val; } parm1 = { .val = pr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_set_protection_regions(dev, pr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_set_protection_regions(dev, pr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr); 	syscall__retval = espi_saf_set_protection_regions(dev, pr); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_SET_PROTECTION_REGIONS, espi_saf_set_protection_regions, dev, pr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_activate(const struct device * dev);
+
+__pinned_func
+static inline int espi_saf_activate(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_ACTIVATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_activate(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_activate(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev); 	syscall__retval = espi_saf_activate(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_ACTIVATE, espi_saf_activate, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_espi_saf_get_channel_status(const struct device * dev);
+
+__pinned_func
+static inline bool espi_saf_get_channel_status(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (bool) arch_syscall_invoke1(parm0.x, K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_get_channel_status(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_get_channel_status(dev) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev); 	syscall__retval = espi_saf_get_channel_status(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_GET_CHANNEL_STATUS, espi_saf_get_channel_status, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt);
+
+__pinned_func
+static inline int espi_saf_flash_read(const struct device * dev, struct espi_saf_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_flash_read(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_flash_read(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt); 	syscall__retval = espi_saf_flash_read(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_READ, espi_saf_flash_read, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt);
+
+__pinned_func
+static inline int espi_saf_flash_write(const struct device * dev, struct espi_saf_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_flash_write(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_flash_write(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt); 	syscall__retval = espi_saf_flash_write(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_WRITE, espi_saf_flash_write, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt);
+
+__pinned_func
+static inline int espi_saf_flash_erase(const struct device * dev, struct espi_saf_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_ERASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_flash_erase(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_flash_erase(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt); 	syscall__retval = espi_saf_flash_erase(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_ERASE, espi_saf_flash_erase, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt);
+
+__pinned_func
+static inline int espi_saf_flash_unsuccess(const struct device * dev, struct espi_saf_packet * pckt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct espi_saf_packet * val; } parm1 = { .val = pckt };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_espi_saf_flash_unsuccess(dev, pckt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define espi_saf_flash_unsuccess(dev, pckt) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt); 	syscall__retval = espi_saf_flash_unsuccess(dev, pckt); 	sys_port_trace_syscall_exit(K_SYSCALL_ESPI_SAF_FLASH_UNSUCCESS, espi_saf_flash_unsuccess, dev, pckt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/ethernet.h b/nrfdemo/build/zephyr/include/generated/syscalls/ethernet.h
new file mode 100644
index 0000000..33b6431
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/ethernet.h
@@ -0,0 +1,51 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_ETHERNET_H
+#define Z_INCLUDE_SYSCALLS_ETHERNET_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const struct device * z_impl_net_eth_get_ptp_clock_by_index(int index);
+
+__pinned_func
+static inline const struct device * net_eth_get_ptp_clock_by_index(int index)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_eth_get_ptp_clock_by_index(index);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_eth_get_ptp_clock_by_index(index) ({ 	const struct device * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index); 	syscall__retval = net_eth_get_ptp_clock_by_index(index); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_ETH_GET_PTP_CLOCK_BY_INDEX, net_eth_get_ptp_clock_by_index, index, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/flash.h b/nrfdemo/build/zephyr/include/generated/syscalls/flash.h
new file mode 100644
index 0000000..4536ec2
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/flash.h
@@ -0,0 +1,300 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_FLASH_H
+#define Z_INCLUDE_SYSCALLS_FLASH_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_flash_read(const struct device * dev, off_t offset, void * data, size_t len);
+
+__pinned_func
+static inline int flash_read(const struct device * dev, off_t offset, void * data, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; void * val; } parm2 = { .val = data };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_read(dev, offset, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_read(dev, offset, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len); 	syscall__retval = flash_read(dev, offset, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ, flash_read, dev, offset, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_write(const struct device * dev, off_t offset, const void * data, size_t len);
+
+__pinned_func
+static inline int flash_write(const struct device * dev, off_t offset, const void * data, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; const void * val; } parm2 = { .val = data };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_write(dev, offset, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_write(dev, offset, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len); 	syscall__retval = flash_write(dev, offset, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_WRITE, flash_write, dev, offset, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_erase(const struct device * dev, off_t offset, size_t size);
+
+__pinned_func
+static inline int flash_erase(const struct device * dev, off_t offset, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; size_t val; } parm2 = { .val = size };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_ERASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_erase(dev, offset, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_erase(dev, offset, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size); 	syscall__retval = flash_erase(dev, offset, size); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_ERASE, flash_erase, dev, offset, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info);
+
+__pinned_func
+static inline int flash_get_page_info_by_offs(const struct device * dev, off_t offset, struct flash_pages_info * info)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_get_page_info_by_offs(dev, offset, info);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_get_page_info_by_offs(dev, offset, info) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info); 	syscall__retval = flash_get_page_info_by_offs(dev, offset, info); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_OFFS, flash_get_page_info_by_offs, dev, offset, info, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info);
+
+__pinned_func
+static inline int flash_get_page_info_by_idx(const struct device * dev, uint32_t page_index, struct flash_pages_info * info)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = page_index };
+		union { uintptr_t x; struct flash_pages_info * val; } parm2 = { .val = info };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_get_page_info_by_idx(dev, page_index, info);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_get_page_info_by_idx(dev, page_index, info) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info); 	syscall__retval = flash_get_page_info_by_idx(dev, page_index, info); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_INFO_BY_IDX, flash_get_page_info_by_idx, dev, page_index, info, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_flash_get_page_count(const struct device * dev);
+
+__pinned_func
+static inline size_t flash_get_page_count(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PAGE_COUNT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_get_page_count(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_get_page_count(dev) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev); 	syscall__retval = flash_get_page_count(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PAGE_COUNT, flash_get_page_count, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len);
+
+__pinned_func
+static inline int flash_sfdp_read(const struct device * dev, off_t offset, void * data, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; void * val; } parm2 = { .val = data };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_SFDP_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_sfdp_read(dev, offset, data, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_sfdp_read(dev, offset, data, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len); 	syscall__retval = flash_sfdp_read(dev, offset, data, len); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SFDP_READ, flash_sfdp_read, dev, offset, data, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_read_jedec_id(const struct device * dev, uint8_t * id);
+
+__pinned_func
+static inline int flash_read_jedec_id(const struct device * dev, uint8_t * id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_READ_JEDEC_ID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_read_jedec_id(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_read_jedec_id(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id); 	syscall__retval = flash_read_jedec_id(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_READ_JEDEC_ID, flash_read_jedec_id, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_flash_get_write_block_size(const struct device * dev);
+
+__pinned_func
+static inline size_t flash_get_write_block_size(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_get_write_block_size(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_get_write_block_size(dev) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev); 	syscall__retval = flash_get_write_block_size(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_WRITE_BLOCK_SIZE, flash_get_write_block_size, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern const struct flash_parameters * z_impl_flash_get_parameters(const struct device * dev);
+
+__pinned_func
+static inline const struct flash_parameters * flash_get_parameters(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (const struct flash_parameters *) arch_syscall_invoke1(parm0.x, K_SYSCALL_FLASH_GET_PARAMETERS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_get_parameters(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_get_parameters(dev) ({ 	const struct flash_parameters * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev); 	syscall__retval = flash_get_parameters(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_GET_PARAMETERS, flash_get_parameters, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out);
+
+__pinned_func
+static inline int flash_ex_op(const struct device * dev, uint16_t code, const uintptr_t in, void * out)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = code };
+		union { uintptr_t x; const uintptr_t val; } parm2 = { .val = in };
+		union { uintptr_t x; void * val; } parm3 = { .val = out };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FLASH_EX_OP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_ex_op(dev, code, in, out);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_ex_op(dev, code, in, out) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out); 	syscall__retval = flash_ex_op(dev, code, in, out); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_EX_OP, flash_ex_op, dev, code, in, out, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/flash_simulator.h b/nrfdemo/build/zephyr/include/generated/syscalls/flash_simulator.h
new file mode 100644
index 0000000..d1f1fa6
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/flash_simulator.h
@@ -0,0 +1,52 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_FLASH_SIMULATOR_H
+#define Z_INCLUDE_SYSCALLS_FLASH_SIMULATOR_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void * z_impl_flash_simulator_get_memory(const struct device * dev, size_t * mock_size);
+
+__pinned_func
+static inline void * flash_simulator_get_memory(const struct device * dev, size_t * mock_size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t * val; } parm1 = { .val = mock_size };
+		return (void *) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_flash_simulator_get_memory(dev, mock_size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define flash_simulator_get_memory(dev, mock_size) ({ 	void * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY, flash_simulator_get_memory, dev, mock_size); 	syscall__retval = flash_simulator_get_memory(dev, mock_size); 	sys_port_trace_syscall_exit(K_SYSCALL_FLASH_SIMULATOR_GET_MEMORY, flash_simulator_get_memory, dev, mock_size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/fuel_gauge.h b/nrfdemo/build/zephyr/include/generated/syscalls/fuel_gauge.h
new file mode 100644
index 0000000..d2567a5
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/fuel_gauge.h
@@ -0,0 +1,179 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
+#define Z_INCLUDE_SYSCALLS_FUEL_GAUGE_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val);
+
+__pinned_func
+static inline int fuel_gauge_get_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
+		union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_GET_PROP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_get_prop(dev, prop, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_get_prop(dev, prop, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val); 	syscall__retval = fuel_gauge_get_prop(dev, prop, val); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROP, fuel_gauge_get_prop, dev, prop, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_fuel_gauge_get_props(const struct device * dev, fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len);
+
+__pinned_func
+static inline int fuel_gauge_get_props(const struct device * dev, fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; fuel_gauge_prop_t * val; } parm1 = { .val = props };
+		union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_PROPS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_get_props(dev, props, vals, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_get_props(dev, props, vals, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len); 	syscall__retval = fuel_gauge_get_props(dev, props, vals, len); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_PROPS, fuel_gauge_get_props, dev, props, vals, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val);
+
+__pinned_func
+static inline int fuel_gauge_set_prop(const struct device * dev, fuel_gauge_prop_t prop, union fuel_gauge_prop_val val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop };
+		union { uintptr_t x; union fuel_gauge_prop_val val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_FUEL_GAUGE_SET_PROP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_set_prop(dev, prop, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_set_prop(dev, prop, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val); 	syscall__retval = fuel_gauge_set_prop(dev, prop, val); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROP, fuel_gauge_set_prop, dev, prop, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_fuel_gauge_set_props(const struct device * dev, fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len);
+
+__pinned_func
+static inline int fuel_gauge_set_props(const struct device * dev, fuel_gauge_prop_t * props, union fuel_gauge_prop_val * vals, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; fuel_gauge_prop_t * val; } parm1 = { .val = props };
+		union { uintptr_t x; union fuel_gauge_prop_val * val; } parm2 = { .val = vals };
+		union { uintptr_t x; size_t val; } parm3 = { .val = len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_SET_PROPS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_set_props(dev, props, vals, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_set_props(dev, props, vals, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len); 	syscall__retval = fuel_gauge_set_props(dev, props, vals, len); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_SET_PROPS, fuel_gauge_set_props, dev, props, vals, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len);
+
+__pinned_func
+static inline int fuel_gauge_get_buffer_prop(const struct device * dev, fuel_gauge_prop_t prop_type, void * dst, size_t dst_len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; fuel_gauge_prop_t val; } parm1 = { .val = prop_type };
+		union { uintptr_t x; void * val; } parm2 = { .val = dst };
+		union { uintptr_t x; size_t val; } parm3 = { .val = dst_len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len); 	syscall__retval = fuel_gauge_get_buffer_prop(dev, prop_type, dst, dst_len); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_GET_BUFFER_PROP, fuel_gauge_get_buffer_prop, dev, prop_type, dst, dst_len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_fuel_gauge_battery_cutoff(const struct device * dev);
+
+__pinned_func
+static inline int fuel_gauge_battery_cutoff(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_fuel_gauge_battery_cutoff(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define fuel_gauge_battery_cutoff(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev); 	syscall__retval = fuel_gauge_battery_cutoff(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_FUEL_GAUGE_BATTERY_CUTOFF, fuel_gauge_battery_cutoff, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/gnss.h b/nrfdemo/build/zephyr/include/generated/syscalls/gnss.h
new file mode 100644
index 0000000..e7cc7e9
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/gnss.h
@@ -0,0 +1,244 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_GNSS_H
+#define Z_INCLUDE_SYSCALLS_GNSS_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms);
+
+__pinned_func
+static inline int gnss_set_fix_rate(const struct device * dev, uint32_t fix_interval_ms)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = fix_interval_ms };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_FIX_RATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_set_fix_rate(dev, fix_interval_ms);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_set_fix_rate(dev, fix_interval_ms) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms); 	syscall__retval = gnss_set_fix_rate(dev, fix_interval_ms); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_FIX_RATE, gnss_set_fix_rate, dev, fix_interval_ms, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms);
+
+__pinned_func
+static inline int gnss_get_fix_rate(const struct device * dev, uint32_t * fix_interval_ms)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = fix_interval_ms };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_FIX_RATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_get_fix_rate(dev, fix_interval_ms);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_get_fix_rate(dev, fix_interval_ms) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms); 	syscall__retval = gnss_get_fix_rate(dev, fix_interval_ms); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_FIX_RATE, gnss_get_fix_rate, dev, fix_interval_ms, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_set_periodic_config(const struct device * dev, const struct gnss_periodic_config * config);
+
+__pinned_func
+static inline int gnss_set_periodic_config(const struct device * dev, const struct gnss_periodic_config * config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct gnss_periodic_config * val; } parm1 = { .val = config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_PERIODIC_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_set_periodic_config(dev, config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_set_periodic_config(dev, config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_PERIODIC_CONFIG, gnss_set_periodic_config, dev, config); 	syscall__retval = gnss_set_periodic_config(dev, config); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_PERIODIC_CONFIG, gnss_set_periodic_config, dev, config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_get_periodic_config(const struct device * dev, struct gnss_periodic_config * config);
+
+__pinned_func
+static inline int gnss_get_periodic_config(const struct device * dev, struct gnss_periodic_config * config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct gnss_periodic_config * val; } parm1 = { .val = config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_PERIODIC_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_get_periodic_config(dev, config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_get_periodic_config(dev, config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_PERIODIC_CONFIG, gnss_get_periodic_config, dev, config); 	syscall__retval = gnss_get_periodic_config(dev, config); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_PERIODIC_CONFIG, gnss_get_periodic_config, dev, config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode);
+
+__pinned_func
+static inline int gnss_set_navigation_mode(const struct device * dev, enum gnss_navigation_mode mode)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum gnss_navigation_mode val; } parm1 = { .val = mode };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_NAVIGATION_MODE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_set_navigation_mode(dev, mode);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_set_navigation_mode(dev, mode) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode); 	syscall__retval = gnss_set_navigation_mode(dev, mode); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_NAVIGATION_MODE, gnss_set_navigation_mode, dev, mode, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode);
+
+__pinned_func
+static inline int gnss_get_navigation_mode(const struct device * dev, enum gnss_navigation_mode * mode)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum gnss_navigation_mode * val; } parm1 = { .val = mode };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_NAVIGATION_MODE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_get_navigation_mode(dev, mode);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_get_navigation_mode(dev, mode) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode); 	syscall__retval = gnss_get_navigation_mode(dev, mode); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_NAVIGATION_MODE, gnss_get_navigation_mode, dev, mode, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems);
+
+__pinned_func
+static inline int gnss_set_enabled_systems(const struct device * dev, gnss_systems_t systems)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; gnss_systems_t val; } parm1 = { .val = systems };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_set_enabled_systems(dev, systems);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_set_enabled_systems(dev, systems) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems); 	syscall__retval = gnss_set_enabled_systems(dev, systems); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_SET_ENABLED_SYSTEMS, gnss_set_enabled_systems, dev, systems, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems);
+
+__pinned_func
+static inline int gnss_get_enabled_systems(const struct device * dev, gnss_systems_t * systems)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_get_enabled_systems(dev, systems);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_get_enabled_systems(dev, systems) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems); 	syscall__retval = gnss_get_enabled_systems(dev, systems); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_ENABLED_SYSTEMS, gnss_get_enabled_systems, dev, systems, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems);
+
+__pinned_func
+static inline int gnss_get_supported_systems(const struct device * dev, gnss_systems_t * systems)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; gnss_systems_t * val; } parm1 = { .val = systems };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gnss_get_supported_systems(dev, systems);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gnss_get_supported_systems(dev, systems) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems); 	syscall__retval = gnss_get_supported_systems(dev, systems); 	sys_port_trace_syscall_exit(K_SYSCALL_GNSS_GET_SUPPORTED_SYSTEMS, gnss_get_supported_systems, dev, systems, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/gpio.h b/nrfdemo/build/zephyr/include/generated/syscalls/gpio.h
new file mode 100644
index 0000000..4f0f4a4
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/gpio.h
@@ -0,0 +1,273 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_GPIO_H
+#define Z_INCLUDE_SYSCALLS_GPIO_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
+
+__pinned_func
+static inline int gpio_pin_interrupt_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
+		union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_pin_interrupt_configure(port, pin, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_pin_interrupt_configure(port, pin, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags); 	syscall__retval = gpio_pin_interrupt_configure(port, pin, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_INTERRUPT_CONFIGURE, gpio_pin_interrupt_configure, port, pin, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags);
+
+__pinned_func
+static inline int gpio_pin_configure(const struct device * port, gpio_pin_t pin, gpio_flags_t flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
+		union { uintptr_t x; gpio_flags_t val; } parm2 = { .val = flags };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_pin_configure(port, pin, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_pin_configure(port, pin, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags); 	syscall__retval = gpio_pin_configure(port, pin, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_CONFIGURE, gpio_pin_configure, port, pin, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs);
+
+__pinned_func
+static inline int gpio_port_get_direction(const struct device * port, gpio_port_pins_t map, gpio_port_pins_t * inputs, gpio_port_pins_t * outputs)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = map };
+		union { uintptr_t x; gpio_port_pins_t * val; } parm2 = { .val = inputs };
+		union { uintptr_t x; gpio_port_pins_t * val; } parm3 = { .val = outputs };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_GPIO_PORT_GET_DIRECTION);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_get_direction(port, map, inputs, outputs);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_get_direction(port, map, inputs, outputs) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs); 	syscall__retval = gpio_port_get_direction(port, map, inputs, outputs); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_DIRECTION, gpio_port_get_direction, port, map, inputs, outputs, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags);
+
+__pinned_func
+static inline int gpio_pin_get_config(const struct device * port, gpio_pin_t pin, gpio_flags_t * flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_pin_t val; } parm1 = { .val = pin };
+		union { uintptr_t x; gpio_flags_t * val; } parm2 = { .val = flags };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PIN_GET_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_pin_get_config(port, pin, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_pin_get_config(port, pin, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags); 	syscall__retval = gpio_pin_get_config(port, pin, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PIN_GET_CONFIG, gpio_pin_get_config, port, pin, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_get_raw(const struct device * port, gpio_port_value_t * value);
+
+__pinned_func
+static inline int gpio_port_get_raw(const struct device * port, gpio_port_value_t * value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_value_t * val; } parm1 = { .val = value };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_GET_RAW);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_get_raw(port, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_get_raw(port, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value); 	syscall__retval = gpio_port_get_raw(port, value); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_GET_RAW, gpio_port_get_raw, port, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value);
+
+__pinned_func
+static inline int gpio_port_set_masked_raw(const struct device * port, gpio_port_pins_t mask, gpio_port_value_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = mask };
+		union { uintptr_t x; gpio_port_value_t val; } parm2 = { .val = value };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_GPIO_PORT_SET_MASKED_RAW);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_set_masked_raw(port, mask, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_set_masked_raw(port, mask, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value); 	syscall__retval = gpio_port_set_masked_raw(port, mask, value); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_MASKED_RAW, gpio_port_set_masked_raw, port, mask, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins);
+
+__pinned_func
+static inline int gpio_port_set_bits_raw(const struct device * port, gpio_port_pins_t pins)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_SET_BITS_RAW);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_set_bits_raw(port, pins);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_set_bits_raw(port, pins) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins); 	syscall__retval = gpio_port_set_bits_raw(port, pins); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_SET_BITS_RAW, gpio_port_set_bits_raw, port, pins, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins);
+
+__pinned_func
+static inline int gpio_port_clear_bits_raw(const struct device * port, gpio_port_pins_t pins)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_clear_bits_raw(port, pins);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_clear_bits_raw(port, pins) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins); 	syscall__retval = gpio_port_clear_bits_raw(port, pins); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_CLEAR_BITS_RAW, gpio_port_clear_bits_raw, port, pins, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins);
+
+__pinned_func
+static inline int gpio_port_toggle_bits(const struct device * port, gpio_port_pins_t pins)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = port };
+		union { uintptr_t x; gpio_port_pins_t val; } parm1 = { .val = pins };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_GPIO_PORT_TOGGLE_BITS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_port_toggle_bits(port, pins);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_port_toggle_bits(port, pins) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins); 	syscall__retval = gpio_port_toggle_bits(port, pins); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_PORT_TOGGLE_BITS, gpio_port_toggle_bits, port, pins, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_gpio_get_pending_int(const struct device * dev);
+
+__pinned_func
+static inline int gpio_get_pending_int(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_GPIO_GET_PENDING_INT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_gpio_get_pending_int(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define gpio_get_pending_int(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev); 	syscall__retval = gpio_get_pending_int(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_GPIO_GET_PENDING_INT, gpio_get_pending_int, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/hwinfo.h b/nrfdemo/build/zephyr/include/generated/syscalls/hwinfo.h
new file mode 100644
index 0000000..e6fd1a0
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/hwinfo.h
@@ -0,0 +1,143 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_HWINFO_H
+#define Z_INCLUDE_SYSCALLS_HWINFO_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern ssize_t z_impl_hwinfo_get_device_id(uint8_t * buffer, size_t length);
+
+__pinned_func
+static inline ssize_t hwinfo_get_device_id(uint8_t * buffer, size_t length)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
+		union { uintptr_t x; size_t val; } parm1 = { .val = length };
+		return (ssize_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWINFO_GET_DEVICE_ID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwinfo_get_device_id(buffer, length);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwinfo_get_device_id(buffer, length) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length); 	syscall__retval = hwinfo_get_device_id(buffer, length); 	sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_ID, hwinfo_get_device_id, buffer, length, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_hwinfo_get_device_eui64(uint8_t * buffer);
+
+__pinned_func
+static inline int hwinfo_get_device_eui64(uint8_t * buffer)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; uint8_t * val; } parm0 = { .val = buffer };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_DEVICE_EUI64);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwinfo_get_device_eui64(buffer);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwinfo_get_device_eui64(buffer) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer); 	syscall__retval = hwinfo_get_device_eui64(buffer); 	sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_DEVICE_EUI64, hwinfo_get_device_eui64, buffer, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_hwinfo_get_reset_cause(uint32_t * cause);
+
+__pinned_func
+static inline int hwinfo_get_reset_cause(uint32_t * cause)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; uint32_t * val; } parm0 = { .val = cause };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_RESET_CAUSE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwinfo_get_reset_cause(cause);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwinfo_get_reset_cause(cause) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause); 	syscall__retval = hwinfo_get_reset_cause(cause); 	sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_RESET_CAUSE, hwinfo_get_reset_cause, cause, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_hwinfo_clear_reset_cause(void);
+
+__pinned_func
+static inline int hwinfo_clear_reset_cause(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int) arch_syscall_invoke0(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwinfo_clear_reset_cause();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwinfo_clear_reset_cause() ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause); 	syscall__retval = hwinfo_clear_reset_cause(); 	sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_CLEAR_RESET_CAUSE, hwinfo_clear_reset_cause, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_hwinfo_get_supported_reset_cause(uint32_t * supported);
+
+__pinned_func
+static inline int hwinfo_get_supported_reset_cause(uint32_t * supported)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; uint32_t * val; } parm0 = { .val = supported };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwinfo_get_supported_reset_cause(supported);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwinfo_get_supported_reset_cause(supported) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported); 	syscall__retval = hwinfo_get_supported_reset_cause(supported); 	sys_port_trace_syscall_exit(K_SYSCALL_HWINFO_GET_SUPPORTED_RESET_CAUSE, hwinfo_get_supported_reset_cause, supported, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/hwspinlock.h b/nrfdemo/build/zephyr/include/generated/syscalls/hwspinlock.h
new file mode 100644
index 0000000..283fc5e
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/hwspinlock.h
@@ -0,0 +1,125 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_HWSPINLOCK_H
+#define Z_INCLUDE_SYSCALLS_HWSPINLOCK_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_hwspinlock_trylock(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline int hwspinlock_trylock(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWSPINLOCK_TRYLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwspinlock_trylock(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwspinlock_trylock(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWSPINLOCK_TRYLOCK, hwspinlock_trylock, dev, id); 	syscall__retval = hwspinlock_trylock(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_HWSPINLOCK_TRYLOCK, hwspinlock_trylock, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_hwspinlock_lock(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline void hwspinlock_lock(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWSPINLOCK_LOCK);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_hwspinlock_lock(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwspinlock_lock(dev, id) do { 	sys_port_trace_syscall_enter(K_SYSCALL_HWSPINLOCK_LOCK, hwspinlock_lock, dev, id); 	hwspinlock_lock(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_HWSPINLOCK_LOCK, hwspinlock_lock, dev, id); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_hwspinlock_unlock(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline void hwspinlock_unlock(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_HWSPINLOCK_UNLOCK);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_hwspinlock_unlock(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwspinlock_unlock(dev, id) do { 	sys_port_trace_syscall_enter(K_SYSCALL_HWSPINLOCK_UNLOCK, hwspinlock_unlock, dev, id); 	hwspinlock_unlock(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_HWSPINLOCK_UNLOCK, hwspinlock_unlock, dev, id); } while(false)
+#endif
+#endif
+
+
+extern uint32_t z_impl_hwspinlock_get_max_id(const struct device * dev);
+
+__pinned_func
+static inline uint32_t hwspinlock_get_max_id(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_HWSPINLOCK_GET_MAX_ID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_hwspinlock_get_max_id(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define hwspinlock_get_max_id(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_HWSPINLOCK_GET_MAX_ID, hwspinlock_get_max_id, dev); 	syscall__retval = hwspinlock_get_max_id(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_HWSPINLOCK_GET_MAX_ID, hwspinlock_get_max_id, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/i2c.h b/nrfdemo/build/zephyr/include/generated/syscalls/i2c.h
new file mode 100644
index 0000000..494e68e
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/i2c.h
@@ -0,0 +1,171 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_I2C_H
+#define Z_INCLUDE_SYSCALLS_I2C_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_i2c_configure(const struct device * dev, uint32_t dev_config);
+
+__pinned_func
+static inline int i2c_configure(const struct device * dev, uint32_t dev_config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = dev_config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_configure(dev, dev_config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_configure(dev, dev_config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config); 	syscall__retval = i2c_configure(dev, dev_config); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_CONFIGURE, i2c_configure, dev, dev_config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2c_get_config(const struct device * dev, uint32_t * dev_config);
+
+__pinned_func
+static inline int i2c_get_config(const struct device * dev, uint32_t * dev_config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = dev_config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I2C_GET_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_get_config(dev, dev_config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_get_config(dev, dev_config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config); 	syscall__retval = i2c_get_config(dev, dev_config); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_GET_CONFIG, i2c_get_config, dev, dev_config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr);
+
+__pinned_func
+static inline int i2c_transfer(const struct device * dev, struct i2c_msg * msgs, uint8_t num_msgs, uint16_t addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct i2c_msg * val; } parm1 = { .val = msgs };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = addr };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_I2C_TRANSFER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_transfer(dev, msgs, num_msgs, addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_transfer(dev, msgs, num_msgs, addr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr); 	syscall__retval = i2c_transfer(dev, msgs, num_msgs, addr); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_TRANSFER, i2c_transfer, dev, msgs, num_msgs, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2c_recover_bus(const struct device * dev);
+
+__pinned_func
+static inline int i2c_recover_bus(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_RECOVER_BUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_recover_bus(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_recover_bus(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev); 	syscall__retval = i2c_recover_bus(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_RECOVER_BUS, i2c_recover_bus, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2c_target_driver_register(const struct device * dev);
+
+__pinned_func
+static inline int i2c_target_driver_register(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_REGISTER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_target_driver_register(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_target_driver_register(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev); 	syscall__retval = i2c_target_driver_register(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_REGISTER, i2c_target_driver_register, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2c_target_driver_unregister(const struct device * dev);
+
+__pinned_func
+static inline int i2c_target_driver_unregister(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2c_target_driver_unregister(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2c_target_driver_unregister(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev); 	syscall__retval = i2c_target_driver_unregister(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_I2C_TARGET_DRIVER_UNREGISTER, i2c_target_driver_unregister, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/i2s.h b/nrfdemo/build/zephyr/include/generated/syscalls/i2s.h
new file mode 100644
index 0000000..28460ba
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/i2s.h
@@ -0,0 +1,128 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_I2S_H
+#define Z_INCLUDE_SYSCALLS_I2S_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg);
+
+__pinned_func
+static inline int i2s_configure(const struct device * dev, enum i2s_dir dir, const struct i2s_config * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
+		union { uintptr_t x; const struct i2s_config * val; } parm2 = { .val = cfg };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2s_configure(dev, dir, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2s_configure(dev, dir, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg); 	syscall__retval = i2s_configure(dev, dir, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_I2S_CONFIGURE, i2s_configure, dev, dir, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2s_buf_read(const struct device * dev, void * buf, size_t * size);
+
+__pinned_func
+static inline int i2s_buf_read(const struct device * dev, void * buf, size_t * size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; void * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t * val; } parm2 = { .val = size };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2s_buf_read(dev, buf, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2s_buf_read(dev, buf, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size); 	syscall__retval = i2s_buf_read(dev, buf, size); 	sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_READ, i2s_buf_read, dev, buf, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2s_buf_write(const struct device * dev, void * buf, size_t size);
+
+__pinned_func
+static inline int i2s_buf_write(const struct device * dev, void * buf, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; void * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = size };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_BUF_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2s_buf_write(dev, buf, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2s_buf_write(dev, buf, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size); 	syscall__retval = i2s_buf_write(dev, buf, size); 	sys_port_trace_syscall_exit(K_SYSCALL_I2S_BUF_WRITE, i2s_buf_write, dev, buf, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd);
+
+__pinned_func
+static inline int i2s_trigger(const struct device * dev, enum i2s_dir dir, enum i2s_trigger_cmd cmd)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum i2s_dir val; } parm1 = { .val = dir };
+		union { uintptr_t x; enum i2s_trigger_cmd val; } parm2 = { .val = cmd };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I2S_TRIGGER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i2s_trigger(dev, dir, cmd);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i2s_trigger(dev, dir, cmd) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd); 	syscall__retval = i2s_trigger(dev, dir, cmd); 	sys_port_trace_syscall_exit(K_SYSCALL_I2S_TRIGGER, i2s_trigger, dev, dir, cmd, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/i3c.h b/nrfdemo/build/zephyr/include/generated/syscalls/i3c.h
new file mode 100644
index 0000000..ef9430b
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/i3c.h
@@ -0,0 +1,77 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_I3C_H
+#define Z_INCLUDE_SYSCALLS_I3C_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload);
+
+__pinned_func
+static inline int i3c_do_ccc(const struct device * dev, struct i3c_ccc_payload * payload)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct i3c_ccc_payload * val; } parm1 = { .val = payload };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_I3C_DO_CCC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i3c_do_ccc(dev, payload);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i3c_do_ccc(dev, payload) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload); 	syscall__retval = i3c_do_ccc(dev, payload); 	sys_port_trace_syscall_exit(K_SYSCALL_I3C_DO_CCC, i3c_do_ccc, dev, payload, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs);
+
+__pinned_func
+static inline int i3c_transfer(struct i3c_device_desc * target, struct i3c_msg * msgs, uint8_t num_msgs)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct i3c_device_desc * val; } parm0 = { .val = target };
+		union { uintptr_t x; struct i3c_msg * val; } parm1 = { .val = msgs };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = num_msgs };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_I3C_TRANSFER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_i3c_transfer(target, msgs, num_msgs);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define i3c_transfer(target, msgs, num_msgs) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs); 	syscall__retval = i3c_transfer(target, msgs, num_msgs); 	sys_port_trace_syscall_exit(K_SYSCALL_I3C_TRANSFER, i3c_transfer, target, msgs, num_msgs, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/ipm.h b/nrfdemo/build/zephyr/include/generated/syscalls/ipm.h
new file mode 100644
index 0000000..ff340ea
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/ipm.h
@@ -0,0 +1,149 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_IPM_H
+#define Z_INCLUDE_SYSCALLS_IPM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size);
+
+__pinned_func
+static inline int ipm_send(const struct device * ipmdev, int wait, uint32_t id, const void * data, int size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
+		union { uintptr_t x; int val; } parm1 = { .val = wait };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = id };
+		union { uintptr_t x; const void * val; } parm3 = { .val = data };
+		union { uintptr_t x; int val; } parm4 = { .val = size };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_IPM_SEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ipm_send(ipmdev, wait, id, data, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ipm_send(ipmdev, wait, id, data, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size); 	syscall__retval = ipm_send(ipmdev, wait, id, data, size); 	sys_port_trace_syscall_exit(K_SYSCALL_IPM_SEND, ipm_send, ipmdev, wait, id, data, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ipm_max_data_size_get(const struct device * ipmdev);
+
+__pinned_func
+static inline int ipm_max_data_size_get(const struct device * ipmdev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_DATA_SIZE_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ipm_max_data_size_get(ipmdev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ipm_max_data_size_get(ipmdev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev); 	syscall__retval = ipm_max_data_size_get(ipmdev); 	sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_DATA_SIZE_GET, ipm_max_data_size_get, ipmdev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_ipm_max_id_val_get(const struct device * ipmdev);
+
+__pinned_func
+static inline uint32_t ipm_max_id_val_get(const struct device * ipmdev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_MAX_ID_VAL_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ipm_max_id_val_get(ipmdev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ipm_max_id_val_get(ipmdev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev); 	syscall__retval = ipm_max_id_val_get(ipmdev); 	sys_port_trace_syscall_exit(K_SYSCALL_IPM_MAX_ID_VAL_GET, ipm_max_id_val_get, ipmdev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ipm_set_enabled(const struct device * ipmdev, int enable);
+
+__pinned_func
+static inline int ipm_set_enabled(const struct device * ipmdev, int enable)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
+		union { uintptr_t x; int val; } parm1 = { .val = enable };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IPM_SET_ENABLED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ipm_set_enabled(ipmdev, enable);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ipm_set_enabled(ipmdev, enable) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable); 	syscall__retval = ipm_set_enabled(ipmdev, enable); 	sys_port_trace_syscall_exit(K_SYSCALL_IPM_SET_ENABLED, ipm_set_enabled, ipmdev, enable, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_ipm_complete(const struct device * ipmdev);
+
+__pinned_func
+static inline void ipm_complete(const struct device * ipmdev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = ipmdev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_IPM_COMPLETE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_ipm_complete(ipmdev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ipm_complete(ipmdev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); 	ipm_complete(ipmdev); 	sys_port_trace_syscall_exit(K_SYSCALL_IPM_COMPLETE, ipm_complete, ipmdev); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/ivshmem.h b/nrfdemo/build/zephyr/include/generated/syscalls/ivshmem.h
new file mode 100644
index 0000000..8f51cb3
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/ivshmem.h
@@ -0,0 +1,315 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_IVSHMEM_H
+#define Z_INCLUDE_SYSCALLS_IVSHMEM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern size_t z_impl_ivshmem_get_mem(const struct device * dev, uintptr_t * memmap);
+
+__pinned_func
+static inline size_t ivshmem_get_mem(const struct device * dev, uintptr_t * memmap)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
+		return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_MEM);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_mem(dev, memmap);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_mem(dev, memmap) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap); 	syscall__retval = ivshmem_get_mem(dev, memmap); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MEM, ivshmem_get_mem, dev, memmap, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_ivshmem_get_id(const struct device * dev);
+
+__pinned_func
+static inline uint32_t ivshmem_get_id(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_ID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_id(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_id(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev); 	syscall__retval = ivshmem_get_id(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_ID, ivshmem_get_id, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint16_t z_impl_ivshmem_get_vectors(const struct device * dev);
+
+__pinned_func
+static inline uint16_t ivshmem_get_vectors(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_VECTORS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_vectors(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_vectors(dev) ({ 	uint16_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev); 	syscall__retval = ivshmem_get_vectors(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_VECTORS, ivshmem_get_vectors, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector);
+
+__pinned_func
+static inline int ivshmem_int_peer(const struct device * dev, uint32_t peer_id, uint16_t vector)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
+		union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_INT_PEER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_int_peer(dev, peer_id, vector);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_int_peer(dev, peer_id, vector) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector); 	syscall__retval = ivshmem_int_peer(dev, peer_id, vector); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_INT_PEER, ivshmem_int_peer, dev, peer_id, vector, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector);
+
+__pinned_func
+static inline int ivshmem_register_handler(const struct device * dev, struct k_poll_signal * signal, uint16_t vector)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
+		union { uintptr_t x; uint16_t val; } parm2 = { .val = vector };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_REGISTER_HANDLER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_register_handler(dev, signal, vector);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_register_handler(dev, signal, vector) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector); 	syscall__retval = ivshmem_register_handler(dev, signal, vector); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_REGISTER_HANDLER, ivshmem_register_handler, dev, signal, vector, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap);
+
+__pinned_func
+static inline size_t ivshmem_get_rw_mem_section(const struct device * dev, uintptr_t * memmap)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uintptr_t * val; } parm1 = { .val = memmap };
+		return (size_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_rw_mem_section(dev, memmap);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_rw_mem_section(dev, memmap) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap); 	syscall__retval = ivshmem_get_rw_mem_section(dev, memmap); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_RW_MEM_SECTION, ivshmem_get_rw_mem_section, dev, memmap, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap);
+
+__pinned_func
+static inline size_t ivshmem_get_output_mem_section(const struct device * dev, uint32_t peer_id, uintptr_t * memmap)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
+		union { uintptr_t x; uintptr_t * val; } parm2 = { .val = memmap };
+		return (size_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_output_mem_section(dev, peer_id, memmap);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_output_mem_section(dev, peer_id, memmap) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap); 	syscall__retval = ivshmem_get_output_mem_section(dev, peer_id, memmap); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_OUTPUT_MEM_SECTION, ivshmem_get_output_mem_section, dev, peer_id, memmap, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_ivshmem_get_state(const struct device * dev, uint32_t peer_id);
+
+__pinned_func
+static inline uint32_t ivshmem_get_state(const struct device * dev, uint32_t peer_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = peer_id };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_GET_STATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_state(dev, peer_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_state(dev, peer_id) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id); 	syscall__retval = ivshmem_get_state(dev, peer_id); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_STATE, ivshmem_get_state, dev, peer_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ivshmem_set_state(const struct device * dev, uint32_t state);
+
+__pinned_func
+static inline int ivshmem_set_state(const struct device * dev, uint32_t state)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = state };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_SET_STATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_set_state(dev, state);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_set_state(dev, state) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state); 	syscall__retval = ivshmem_set_state(dev, state); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_SET_STATE, ivshmem_set_state, dev, state, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_ivshmem_get_max_peers(const struct device * dev);
+
+__pinned_func
+static inline uint32_t ivshmem_get_max_peers(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_MAX_PEERS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_max_peers(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_max_peers(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev); 	syscall__retval = ivshmem_get_max_peers(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_MAX_PEERS, ivshmem_get_max_peers, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint16_t z_impl_ivshmem_get_protocol(const struct device * dev);
+
+__pinned_func
+static inline uint16_t ivshmem_get_protocol(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint16_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_IVSHMEM_GET_PROTOCOL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_get_protocol(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_get_protocol(dev) ({ 	uint16_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev); 	syscall__retval = ivshmem_get_protocol(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_GET_PROTOCOL, ivshmem_get_protocol, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ivshmem_enable_interrupts(const struct device * dev, bool enable);
+
+__pinned_func
+static inline int ivshmem_enable_interrupts(const struct device * dev, bool enable)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = enable };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ivshmem_enable_interrupts(dev, enable);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ivshmem_enable_interrupts(dev, enable) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable); 	syscall__retval = ivshmem_enable_interrupts(dev, enable); 	sys_port_trace_syscall_exit(K_SYSCALL_IVSHMEM_ENABLE_INTERRUPTS, ivshmem_enable_interrupts, dev, enable, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/kernel.h b/nrfdemo/build/zephyr/include/generated/syscalls/kernel.h
new file mode 100644
index 0000000..3c5e56b
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/kernel.h
@@ -0,0 +1,1590 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_KERNEL_H
+#define Z_INCLUDE_SYSCALLS_KERNEL_H
+
+
+
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern k_thread_stack_t * z_impl_k_thread_stack_alloc(size_t size, int flags);
+
+__pinned_func
+static inline k_thread_stack_t * k_thread_stack_alloc(size_t size, int flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; size_t val; } parm0 = { .val = size };
+		union { uintptr_t x; int val; } parm1 = { .val = flags };
+		return (k_thread_stack_t *) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_THREAD_STACK_ALLOC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_stack_alloc(size, flags);
+}
+
+
+extern int z_impl_k_thread_stack_free(k_thread_stack_t * stack);
+
+__pinned_func
+static inline int k_thread_stack_free(k_thread_stack_t * stack)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_thread_stack_t * val; } parm0 = { .val = stack };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_STACK_FREE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_stack_free(stack);
+}
+
+
+extern k_tid_t z_impl_k_thread_create(struct k_thread * new_thread, k_thread_stack_t * stack, size_t stack_size, k_thread_entry_t entry, void * p1, void * p2, void * p3, int prio, uint32_t options, k_timeout_t delay);
+
+__pinned_func
+static inline k_tid_t k_thread_create(struct k_thread * new_thread, k_thread_stack_t * stack, size_t stack_size, k_thread_entry_t entry, void * p1, void * p2, void * p3, int prio, uint32_t options, k_timeout_t delay)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_thread * val; } parm0 = { .val = new_thread };
+		union { uintptr_t x; k_thread_stack_t * val; } parm1 = { .val = stack };
+		union { uintptr_t x; size_t val; } parm2 = { .val = stack_size };
+		union { uintptr_t x; k_thread_entry_t val; } parm3 = { .val = entry };
+		union { uintptr_t x; void * val; } parm4 = { .val = p1 };
+		union { uintptr_t x; void * val; } parm5 = { .val = p2 };
+		union { uintptr_t x; void * val; } parm6 = { .val = p3 };
+		union { uintptr_t x; int val; } parm7 = { .val = prio };
+		union { uintptr_t x; uint32_t val; } parm8 = { .val = options };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm9 = { .val = delay };
+		uintptr_t more[] = {
+			parm5.x,
+			parm6.x,
+			parm7.x,
+			parm8.x,
+			parm9.split.lo,
+			parm9.split.hi
+		};
+		return (k_tid_t) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_K_THREAD_CREATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_create(new_thread, stack, stack_size, entry, p1, p2, p3, prio, options, delay);
+}
+
+
+extern int z_impl_k_thread_stack_space_get(const struct k_thread * thread, size_t * unused_ptr);
+
+__pinned_func
+static inline int k_thread_stack_space_get(const struct k_thread * thread, size_t * unused_ptr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_thread * val; } parm0 = { .val = thread };
+		union { uintptr_t x; size_t * val; } parm1 = { .val = unused_ptr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_THREAD_STACK_SPACE_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_stack_space_get(thread, unused_ptr);
+}
+
+
+extern int z_impl_k_thread_join(struct k_thread * thread, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_thread_join(struct k_thread * thread, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_K_THREAD_JOIN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_join(thread, timeout);
+}
+
+
+extern int32_t z_impl_k_sleep(k_timeout_t timeout);
+
+__pinned_func
+static inline int32_t k_sleep(k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm0 = { .val = timeout };
+		return (int32_t) arch_syscall_invoke2(parm0.split.lo, parm0.split.hi, K_SYSCALL_K_SLEEP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_sleep(timeout);
+}
+
+
+extern int32_t z_impl_k_usleep(int32_t us);
+
+__pinned_func
+static inline int32_t k_usleep(int32_t us)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int32_t val; } parm0 = { .val = us };
+		return (int32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_USLEEP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_usleep(us);
+}
+
+
+extern void z_impl_k_busy_wait(uint32_t usec_to_wait);
+
+__pinned_func
+static inline void k_busy_wait(uint32_t usec_to_wait)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; uint32_t val; } parm0 = { .val = usec_to_wait };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_BUSY_WAIT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_busy_wait(usec_to_wait);
+}
+
+
+extern void z_impl_k_yield(void);
+
+__pinned_func
+static inline void k_yield(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		(void) arch_syscall_invoke0(K_SYSCALL_K_YIELD);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_yield();
+}
+
+
+extern void z_impl_k_wakeup(k_tid_t thread);
+
+__pinned_func
+static inline void k_wakeup(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_WAKEUP);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_wakeup(thread);
+}
+
+
+extern k_tid_t z_impl_k_sched_current_thread_query(void);
+
+__pinned_func
+static inline k_tid_t k_sched_current_thread_query(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (k_tid_t) arch_syscall_invoke0(K_SYSCALL_K_SCHED_CURRENT_THREAD_QUERY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_sched_current_thread_query();
+}
+
+
+extern void z_impl_k_thread_abort(k_tid_t thread);
+
+__pinned_func
+static inline void k_thread_abort(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_ABORT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_abort(thread);
+}
+
+
+extern void z_impl_k_thread_start(k_tid_t thread);
+
+__pinned_func
+static inline void k_thread_start(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_START);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_start(thread);
+}
+
+
+extern k_ticks_t z_impl_k_thread_timeout_expires_ticks(const struct k_thread * thread);
+
+__pinned_func
+static inline k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread * thread)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_thread * val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_K_THREAD_TIMEOUT_EXPIRES_TICKS);
+		return (k_ticks_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_timeout_expires_ticks(thread);
+}
+
+
+extern k_ticks_t z_impl_k_thread_timeout_remaining_ticks(const struct k_thread * thread);
+
+__pinned_func
+static inline k_ticks_t k_thread_timeout_remaining_ticks(const struct k_thread * thread)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_thread * val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_K_THREAD_TIMEOUT_REMAINING_TICKS);
+		return (k_ticks_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_timeout_remaining_ticks(thread);
+}
+
+
+extern int z_impl_k_thread_priority_get(k_tid_t thread);
+
+__pinned_func
+static inline int k_thread_priority_get(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_PRIORITY_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_priority_get(thread);
+}
+
+
+extern void z_impl_k_thread_priority_set(k_tid_t thread, int prio);
+
+__pinned_func
+static inline void k_thread_priority_set(k_tid_t thread, int prio)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		union { uintptr_t x; int val; } parm1 = { .val = prio };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_THREAD_PRIORITY_SET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_priority_set(thread, prio);
+}
+
+
+extern void z_impl_k_thread_deadline_set(k_tid_t thread, int deadline);
+
+__pinned_func
+static inline void k_thread_deadline_set(k_tid_t thread, int deadline)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		union { uintptr_t x; int val; } parm1 = { .val = deadline };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_THREAD_DEADLINE_SET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_deadline_set(thread, deadline);
+}
+
+
+extern void z_impl_k_thread_suspend(k_tid_t thread);
+
+__pinned_func
+static inline void k_thread_suspend(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_SUSPEND);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_suspend(thread);
+}
+
+
+extern void z_impl_k_thread_resume(k_tid_t thread);
+
+__pinned_func
+static inline void k_thread_resume(k_tid_t thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_RESUME);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_resume(thread);
+}
+
+
+extern int z_impl_k_is_preempt_thread(void);
+
+__pinned_func
+static inline int k_is_preempt_thread(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int) arch_syscall_invoke0(K_SYSCALL_K_IS_PREEMPT_THREAD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_is_preempt_thread();
+}
+
+
+extern void z_impl_k_thread_custom_data_set(void * value);
+
+__pinned_func
+static inline void k_thread_custom_data_set(void * value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = value };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_THREAD_CUSTOM_DATA_SET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_thread_custom_data_set(value);
+}
+
+
+extern void * z_impl_k_thread_custom_data_get(void);
+
+__pinned_func
+static inline void * k_thread_custom_data_get(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (void *) arch_syscall_invoke0(K_SYSCALL_K_THREAD_CUSTOM_DATA_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_custom_data_get();
+}
+
+
+extern int z_impl_k_thread_name_set(k_tid_t thread, const char * str);
+
+__pinned_func
+static inline int k_thread_name_set(k_tid_t thread, const char * str)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		union { uintptr_t x; const char * val; } parm1 = { .val = str };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_THREAD_NAME_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_name_set(thread, str);
+}
+
+
+extern int z_impl_k_thread_name_copy(k_tid_t thread, char * buf, size_t size);
+
+__pinned_func
+static inline int k_thread_name_copy(k_tid_t thread, char * buf, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; k_tid_t val; } parm0 = { .val = thread };
+		union { uintptr_t x; char * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = size };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_THREAD_NAME_COPY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_thread_name_copy(thread, buf, size);
+}
+
+
+extern void z_impl_k_timer_start(struct k_timer * timer, k_timeout_t duration, k_timeout_t period);
+
+__pinned_func
+static inline void k_timer_start(struct k_timer * timer, k_timeout_t duration, k_timeout_t period)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_timer * val; } parm0 = { .val = timer };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = duration };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = period };
+		(void) arch_syscall_invoke5(parm0.x, parm1.split.lo, parm1.split.hi, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_TIMER_START);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_timer_start(timer, duration, period);
+}
+
+
+extern void z_impl_k_timer_stop(struct k_timer * timer);
+
+__pinned_func
+static inline void k_timer_stop(struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_timer * val; } parm0 = { .val = timer };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_TIMER_STOP);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_timer_stop(timer);
+}
+
+
+extern uint32_t z_impl_k_timer_status_get(struct k_timer * timer);
+
+__pinned_func
+static inline uint32_t k_timer_status_get(struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_timer * val; } parm0 = { .val = timer };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_TIMER_STATUS_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_timer_status_get(timer);
+}
+
+
+extern uint32_t z_impl_k_timer_status_sync(struct k_timer * timer);
+
+__pinned_func
+static inline uint32_t k_timer_status_sync(struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_timer * val; } parm0 = { .val = timer };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_TIMER_STATUS_SYNC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_timer_status_sync(timer);
+}
+
+
+extern k_ticks_t z_impl_k_timer_expires_ticks(const struct k_timer * timer);
+
+__pinned_func
+static inline k_ticks_t k_timer_expires_ticks(const struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_timer * val; } parm0 = { .val = timer };
+		(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_K_TIMER_EXPIRES_TICKS);
+		return (k_ticks_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_timer_expires_ticks(timer);
+}
+
+
+extern k_ticks_t z_impl_k_timer_remaining_ticks(const struct k_timer * timer);
+
+__pinned_func
+static inline k_ticks_t k_timer_remaining_ticks(const struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_timer * val; } parm0 = { .val = timer };
+		(void) arch_syscall_invoke2(parm0.x, (uintptr_t)&ret64, K_SYSCALL_K_TIMER_REMAINING_TICKS);
+		return (k_ticks_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_timer_remaining_ticks(timer);
+}
+
+
+extern void z_impl_k_timer_user_data_set(struct k_timer * timer, void * user_data);
+
+__pinned_func
+static inline void k_timer_user_data_set(struct k_timer * timer, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_timer * val; } parm0 = { .val = timer };
+		union { uintptr_t x; void * val; } parm1 = { .val = user_data };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_TIMER_USER_DATA_SET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_timer_user_data_set(timer, user_data);
+}
+
+
+extern void * z_impl_k_timer_user_data_get(const struct k_timer * timer);
+
+__pinned_func
+static inline void * k_timer_user_data_get(const struct k_timer * timer)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct k_timer * val; } parm0 = { .val = timer };
+		return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_TIMER_USER_DATA_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_timer_user_data_get(timer);
+}
+
+
+extern int64_t z_impl_k_uptime_ticks(void);
+
+__pinned_func
+static inline int64_t k_uptime_ticks(void)
+{
+#ifdef CONFIG_USERSPACE
+	uint64_t ret64;
+	if (z_syscall_trap()) {
+		(void) arch_syscall_invoke1((uintptr_t)&ret64, K_SYSCALL_K_UPTIME_TICKS);
+		return (int64_t) ret64;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_uptime_ticks();
+}
+
+
+extern void z_impl_k_queue_init(struct k_queue * queue);
+
+__pinned_func
+static inline void k_queue_init(struct k_queue * queue)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_QUEUE_INIT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_queue_init(queue);
+}
+
+
+extern void z_impl_k_queue_cancel_wait(struct k_queue * queue);
+
+__pinned_func
+static inline void k_queue_cancel_wait(struct k_queue * queue)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_QUEUE_CANCEL_WAIT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_queue_cancel_wait(queue);
+}
+
+
+extern int32_t z_impl_k_queue_alloc_append(struct k_queue * queue, void * data);
+
+__pinned_func
+static inline int32_t k_queue_alloc_append(struct k_queue * queue, void * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		return (int32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_QUEUE_ALLOC_APPEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_alloc_append(queue, data);
+}
+
+
+extern int32_t z_impl_k_queue_alloc_prepend(struct k_queue * queue, void * data);
+
+__pinned_func
+static inline int32_t k_queue_alloc_prepend(struct k_queue * queue, void * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		return (int32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_QUEUE_ALLOC_PREPEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_alloc_prepend(queue, data);
+}
+
+
+extern void * z_impl_k_queue_get(struct k_queue * queue, k_timeout_t timeout);
+
+__pinned_func
+static inline void * k_queue_get(struct k_queue * queue, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (void *) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_K_QUEUE_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_get(queue, timeout);
+}
+
+
+extern int z_impl_k_queue_is_empty(struct k_queue * queue);
+
+__pinned_func
+static inline int k_queue_is_empty(struct k_queue * queue)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_QUEUE_IS_EMPTY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_is_empty(queue);
+}
+
+
+extern void * z_impl_k_queue_peek_head(struct k_queue * queue);
+
+__pinned_func
+static inline void * k_queue_peek_head(struct k_queue * queue)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_QUEUE_PEEK_HEAD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_peek_head(queue);
+}
+
+
+extern void * z_impl_k_queue_peek_tail(struct k_queue * queue);
+
+__pinned_func
+static inline void * k_queue_peek_tail(struct k_queue * queue)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_queue * val; } parm0 = { .val = queue };
+		return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_QUEUE_PEEK_TAIL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_queue_peek_tail(queue);
+}
+
+
+extern int z_impl_k_futex_wait(struct k_futex * futex, int expected, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_futex_wait(struct k_futex * futex, int expected, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_futex * val; } parm0 = { .val = futex };
+		union { uintptr_t x; int val; } parm1 = { .val = expected };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_FUTEX_WAIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_futex_wait(futex, expected, timeout);
+}
+
+
+extern int z_impl_k_futex_wake(struct k_futex * futex, bool wake_all);
+
+__pinned_func
+static inline int k_futex_wake(struct k_futex * futex, bool wake_all)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_futex * val; } parm0 = { .val = futex };
+		union { uintptr_t x; bool val; } parm1 = { .val = wake_all };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_FUTEX_WAKE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_futex_wake(futex, wake_all);
+}
+
+
+extern void z_impl_k_event_init(struct k_event * event);
+
+__pinned_func
+static inline void k_event_init(struct k_event * event)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_EVENT_INIT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_event_init(event);
+}
+
+
+extern uint32_t z_impl_k_event_post(struct k_event * event, uint32_t events);
+
+__pinned_func
+static inline uint32_t k_event_post(struct k_event * event, uint32_t events)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_EVENT_POST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_post(event, events);
+}
+
+
+extern uint32_t z_impl_k_event_set(struct k_event * event, uint32_t events);
+
+__pinned_func
+static inline uint32_t k_event_set(struct k_event * event, uint32_t events)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_EVENT_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_set(event, events);
+}
+
+
+extern uint32_t z_impl_k_event_set_masked(struct k_event * event, uint32_t events, uint32_t events_mask);
+
+__pinned_func
+static inline uint32_t k_event_set_masked(struct k_event * event, uint32_t events, uint32_t events_mask)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = events_mask };
+		return (uint32_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_EVENT_SET_MASKED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_set_masked(event, events, events_mask);
+}
+
+
+extern uint32_t z_impl_k_event_clear(struct k_event * event, uint32_t events);
+
+__pinned_func
+static inline uint32_t k_event_clear(struct k_event * event, uint32_t events)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_EVENT_CLEAR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_clear(event, events);
+}
+
+
+extern uint32_t z_impl_k_event_wait(struct k_event * event, uint32_t events, bool reset, k_timeout_t timeout);
+
+__pinned_func
+static inline uint32_t k_event_wait(struct k_event * event, uint32_t events, bool reset, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		union { uintptr_t x; bool val; } parm2 = { .val = reset };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
+		return (uint32_t) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, K_SYSCALL_K_EVENT_WAIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_wait(event, events, reset, timeout);
+}
+
+
+extern uint32_t z_impl_k_event_wait_all(struct k_event * event, uint32_t events, bool reset, k_timeout_t timeout);
+
+__pinned_func
+static inline uint32_t k_event_wait_all(struct k_event * event, uint32_t events, bool reset, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_event * val; } parm0 = { .val = event };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = events };
+		union { uintptr_t x; bool val; } parm2 = { .val = reset };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
+		return (uint32_t) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, K_SYSCALL_K_EVENT_WAIT_ALL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_event_wait_all(event, events, reset, timeout);
+}
+
+
+extern int32_t z_impl_k_stack_alloc_init(struct k_stack * stack, uint32_t num_entries);
+
+__pinned_func
+static inline int32_t k_stack_alloc_init(struct k_stack * stack, uint32_t num_entries)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_stack * val; } parm0 = { .val = stack };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = num_entries };
+		return (int32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_STACK_ALLOC_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_stack_alloc_init(stack, num_entries);
+}
+
+
+extern int z_impl_k_stack_push(struct k_stack * stack, stack_data_t data);
+
+__pinned_func
+static inline int k_stack_push(struct k_stack * stack, stack_data_t data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_stack * val; } parm0 = { .val = stack };
+		union { uintptr_t x; stack_data_t val; } parm1 = { .val = data };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_STACK_PUSH);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_stack_push(stack, data);
+}
+
+
+extern int z_impl_k_stack_pop(struct k_stack * stack, stack_data_t * data, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_stack_pop(struct k_stack * stack, stack_data_t * data, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_stack * val; } parm0 = { .val = stack };
+		union { uintptr_t x; stack_data_t * val; } parm1 = { .val = data };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_STACK_POP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_stack_pop(stack, data, timeout);
+}
+
+
+extern int z_impl_k_mutex_init(struct k_mutex * mutex);
+
+__pinned_func
+static inline int k_mutex_init(struct k_mutex * mutex)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mutex * val; } parm0 = { .val = mutex };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MUTEX_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_mutex_init(mutex);
+}
+
+
+extern int z_impl_k_mutex_lock(struct k_mutex * mutex, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_mutex_lock(struct k_mutex * mutex, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mutex * val; } parm0 = { .val = mutex };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_K_MUTEX_LOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_mutex_lock(mutex, timeout);
+}
+
+
+extern int z_impl_k_mutex_unlock(struct k_mutex * mutex);
+
+__pinned_func
+static inline int k_mutex_unlock(struct k_mutex * mutex)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_mutex * val; } parm0 = { .val = mutex };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MUTEX_UNLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_mutex_unlock(mutex);
+}
+
+
+extern int z_impl_k_condvar_init(struct k_condvar * condvar);
+
+__pinned_func
+static inline int k_condvar_init(struct k_condvar * condvar)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_condvar * val; } parm0 = { .val = condvar };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_CONDVAR_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_condvar_init(condvar);
+}
+
+
+extern int z_impl_k_condvar_signal(struct k_condvar * condvar);
+
+__pinned_func
+static inline int k_condvar_signal(struct k_condvar * condvar)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_condvar * val; } parm0 = { .val = condvar };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_CONDVAR_SIGNAL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_condvar_signal(condvar);
+}
+
+
+extern int z_impl_k_condvar_broadcast(struct k_condvar * condvar);
+
+__pinned_func
+static inline int k_condvar_broadcast(struct k_condvar * condvar)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_condvar * val; } parm0 = { .val = condvar };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_CONDVAR_BROADCAST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_condvar_broadcast(condvar);
+}
+
+
+extern int z_impl_k_condvar_wait(struct k_condvar * condvar, struct k_mutex * mutex, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_condvar_wait(struct k_condvar * condvar, struct k_mutex * mutex, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_condvar * val; } parm0 = { .val = condvar };
+		union { uintptr_t x; struct k_mutex * val; } parm1 = { .val = mutex };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_CONDVAR_WAIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_condvar_wait(condvar, mutex, timeout);
+}
+
+
+extern int z_impl_k_sem_init(struct k_sem * sem, unsigned int initial_count, unsigned int limit);
+
+__pinned_func
+static inline int k_sem_init(struct k_sem * sem, unsigned int initial_count, unsigned int limit)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_sem * val; } parm0 = { .val = sem };
+		union { uintptr_t x; unsigned int val; } parm1 = { .val = initial_count };
+		union { uintptr_t x; unsigned int val; } parm2 = { .val = limit };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_SEM_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_sem_init(sem, initial_count, limit);
+}
+
+
+extern int z_impl_k_sem_take(struct k_sem * sem, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_sem_take(struct k_sem * sem, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_sem * val; } parm0 = { .val = sem };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_K_SEM_TAKE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_sem_take(sem, timeout);
+}
+
+
+extern void z_impl_k_sem_give(struct k_sem * sem);
+
+__pinned_func
+static inline void k_sem_give(struct k_sem * sem)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_sem * val; } parm0 = { .val = sem };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_SEM_GIVE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_sem_give(sem);
+}
+
+
+extern void z_impl_k_sem_reset(struct k_sem * sem);
+
+__pinned_func
+static inline void k_sem_reset(struct k_sem * sem)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_sem * val; } parm0 = { .val = sem };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_SEM_RESET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_sem_reset(sem);
+}
+
+
+extern unsigned int z_impl_k_sem_count_get(struct k_sem * sem);
+
+__pinned_func
+static inline unsigned int k_sem_count_get(struct k_sem * sem)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_sem * val; } parm0 = { .val = sem };
+		return (unsigned int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_SEM_COUNT_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_sem_count_get(sem);
+}
+
+
+extern int z_impl_k_msgq_alloc_init(struct k_msgq * msgq, size_t msg_size, uint32_t max_msgs);
+
+__pinned_func
+static inline int k_msgq_alloc_init(struct k_msgq * msgq, size_t msg_size, uint32_t max_msgs)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; size_t val; } parm1 = { .val = msg_size };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = max_msgs };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_MSGQ_ALLOC_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_alloc_init(msgq, msg_size, max_msgs);
+}
+
+
+extern int z_impl_k_msgq_put(struct k_msgq * msgq, const void * data, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_msgq_put(struct k_msgq * msgq, const void * data, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; const void * val; } parm1 = { .val = data };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_MSGQ_PUT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_put(msgq, data, timeout);
+}
+
+
+extern int z_impl_k_msgq_get(struct k_msgq * msgq, void * data, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_msgq_get(struct k_msgq * msgq, void * data, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_MSGQ_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_get(msgq, data, timeout);
+}
+
+
+extern int z_impl_k_msgq_peek(struct k_msgq * msgq, void * data);
+
+__pinned_func
+static inline int k_msgq_peek(struct k_msgq * msgq, void * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_MSGQ_PEEK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_peek(msgq, data);
+}
+
+
+extern int z_impl_k_msgq_peek_at(struct k_msgq * msgq, void * data, uint32_t idx);
+
+__pinned_func
+static inline int k_msgq_peek_at(struct k_msgq * msgq, void * data, uint32_t idx)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = idx };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_MSGQ_PEEK_AT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_peek_at(msgq, data, idx);
+}
+
+
+extern void z_impl_k_msgq_purge(struct k_msgq * msgq);
+
+__pinned_func
+static inline void k_msgq_purge(struct k_msgq * msgq)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MSGQ_PURGE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_msgq_purge(msgq);
+}
+
+
+extern uint32_t z_impl_k_msgq_num_free_get(struct k_msgq * msgq);
+
+__pinned_func
+static inline uint32_t k_msgq_num_free_get(struct k_msgq * msgq)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MSGQ_NUM_FREE_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_num_free_get(msgq);
+}
+
+
+extern void z_impl_k_msgq_get_attrs(struct k_msgq * msgq, struct k_msgq_attrs * attrs);
+
+__pinned_func
+static inline void k_msgq_get_attrs(struct k_msgq * msgq, struct k_msgq_attrs * attrs)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		union { uintptr_t x; struct k_msgq_attrs * val; } parm1 = { .val = attrs };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_MSGQ_GET_ATTRS);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_msgq_get_attrs(msgq, attrs);
+}
+
+
+extern uint32_t z_impl_k_msgq_num_used_get(struct k_msgq * msgq);
+
+__pinned_func
+static inline uint32_t k_msgq_num_used_get(struct k_msgq * msgq)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_msgq * val; } parm0 = { .val = msgq };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_MSGQ_NUM_USED_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_msgq_num_used_get(msgq);
+}
+
+
+extern int z_impl_k_pipe_alloc_init(struct k_pipe * pipe, size_t size);
+
+__pinned_func
+static inline int k_pipe_alloc_init(struct k_pipe * pipe, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_PIPE_ALLOC_INIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_pipe_alloc_init(pipe, size);
+}
+
+
+extern int z_impl_k_pipe_put(struct k_pipe * pipe, const void * data, size_t bytes_to_write, size_t * bytes_written, size_t min_xfer, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_pipe_put(struct k_pipe * pipe, const void * data, size_t bytes_to_write, size_t * bytes_written, size_t min_xfer, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		union { uintptr_t x; const void * val; } parm1 = { .val = data };
+		union { uintptr_t x; size_t val; } parm2 = { .val = bytes_to_write };
+		union { uintptr_t x; size_t * val; } parm3 = { .val = bytes_written };
+		union { uintptr_t x; size_t val; } parm4 = { .val = min_xfer };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm5 = { .val = timeout };
+		uintptr_t more[] = {
+			parm5.split.lo,
+			parm5.split.hi
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_K_PIPE_PUT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_pipe_put(pipe, data, bytes_to_write, bytes_written, min_xfer, timeout);
+}
+
+
+extern int z_impl_k_pipe_get(struct k_pipe * pipe, void * data, size_t bytes_to_read, size_t * bytes_read, size_t min_xfer, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_pipe_get(struct k_pipe * pipe, void * data, size_t bytes_to_read, size_t * bytes_read, size_t min_xfer, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		union { uintptr_t x; void * val; } parm1 = { .val = data };
+		union { uintptr_t x; size_t val; } parm2 = { .val = bytes_to_read };
+		union { uintptr_t x; size_t * val; } parm3 = { .val = bytes_read };
+		union { uintptr_t x; size_t val; } parm4 = { .val = min_xfer };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm5 = { .val = timeout };
+		uintptr_t more[] = {
+			parm5.split.lo,
+			parm5.split.hi
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_K_PIPE_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_pipe_get(pipe, data, bytes_to_read, bytes_read, min_xfer, timeout);
+}
+
+
+extern size_t z_impl_k_pipe_read_avail(struct k_pipe * pipe);
+
+__pinned_func
+static inline size_t k_pipe_read_avail(struct k_pipe * pipe)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_PIPE_READ_AVAIL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_pipe_read_avail(pipe);
+}
+
+
+extern size_t z_impl_k_pipe_write_avail(struct k_pipe * pipe);
+
+__pinned_func
+static inline size_t k_pipe_write_avail(struct k_pipe * pipe)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_PIPE_WRITE_AVAIL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_pipe_write_avail(pipe);
+}
+
+
+extern void z_impl_k_pipe_flush(struct k_pipe * pipe);
+
+__pinned_func
+static inline void k_pipe_flush(struct k_pipe * pipe)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_PIPE_FLUSH);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_pipe_flush(pipe);
+}
+
+
+extern void z_impl_k_pipe_buffer_flush(struct k_pipe * pipe);
+
+__pinned_func
+static inline void k_pipe_buffer_flush(struct k_pipe * pipe)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_pipe * val; } parm0 = { .val = pipe };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_PIPE_BUFFER_FLUSH);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_pipe_buffer_flush(pipe);
+}
+
+
+extern int z_impl_k_poll(struct k_poll_event * events, int num_events, k_timeout_t timeout);
+
+__pinned_func
+static inline int k_poll(struct k_poll_event * events, int num_events, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_poll_event * val; } parm0 = { .val = events };
+		union { uintptr_t x; int val; } parm1 = { .val = num_events };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, K_SYSCALL_K_POLL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_poll(events, num_events, timeout);
+}
+
+
+extern void z_impl_k_poll_signal_init(struct k_poll_signal * sig);
+
+__pinned_func
+static inline void k_poll_signal_init(struct k_poll_signal * sig)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_poll_signal * val; } parm0 = { .val = sig };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_POLL_SIGNAL_INIT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_poll_signal_init(sig);
+}
+
+
+extern void z_impl_k_poll_signal_reset(struct k_poll_signal * sig);
+
+__pinned_func
+static inline void k_poll_signal_reset(struct k_poll_signal * sig)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_poll_signal * val; } parm0 = { .val = sig };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_POLL_SIGNAL_RESET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_poll_signal_reset(sig);
+}
+
+
+extern void z_impl_k_poll_signal_check(struct k_poll_signal * sig, unsigned int * signaled, int * result);
+
+__pinned_func
+static inline void k_poll_signal_check(struct k_poll_signal * sig, unsigned int * signaled, int * result)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_poll_signal * val; } parm0 = { .val = sig };
+		union { uintptr_t x; unsigned int * val; } parm1 = { .val = signaled };
+		union { uintptr_t x; int * val; } parm2 = { .val = result };
+		(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_K_POLL_SIGNAL_CHECK);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_poll_signal_check(sig, signaled, result);
+}
+
+
+extern int z_impl_k_poll_signal_raise(struct k_poll_signal * sig, int result);
+
+__pinned_func
+static inline int k_poll_signal_raise(struct k_poll_signal * sig, int result)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_poll_signal * val; } parm0 = { .val = sig };
+		union { uintptr_t x; int val; } parm1 = { .val = result };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_POLL_SIGNAL_RAISE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_poll_signal_raise(sig, result);
+}
+
+
+extern void z_impl_k_str_out(char * c, size_t n);
+
+__pinned_func
+static inline void k_str_out(char * c, size_t n)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; char * val; } parm0 = { .val = c };
+		union { uintptr_t x; size_t val; } parm1 = { .val = n };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_STR_OUT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_str_out(c, n);
+}
+
+
+extern int z_impl_k_float_disable(struct k_thread * thread);
+
+__pinned_func
+static inline int k_float_disable(struct k_thread * thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_FLOAT_DISABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_float_disable(thread);
+}
+
+
+extern int z_impl_k_float_enable(struct k_thread * thread, unsigned int options);
+
+__pinned_func
+static inline int k_float_enable(struct k_thread * thread, unsigned int options)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct k_thread * val; } parm0 = { .val = thread };
+		union { uintptr_t x; unsigned int val; } parm1 = { .val = options };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_FLOAT_ENABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_float_enable(thread, options);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/kobject.h b/nrfdemo/build/zephyr/include/generated/syscalls/kobject.h
new file mode 100644
index 0000000..6de4eac
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/kobject.h
@@ -0,0 +1,124 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_KOBJECT_H
+#define Z_INCLUDE_SYSCALLS_KOBJECT_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_k_object_access_grant(const void * object, struct k_thread * thread);
+
+__pinned_func
+static inline void k_object_access_grant(const void * object, struct k_thread * thread)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = object };
+		union { uintptr_t x; struct k_thread * val; } parm1 = { .val = thread };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_OBJECT_ACCESS_GRANT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_object_access_grant(object, thread);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_object_access_grant(object, thread) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ACCESS_GRANT, k_object_access_grant, object, thread); 	k_object_access_grant(object, thread); 	sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ACCESS_GRANT, k_object_access_grant, object, thread); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_k_object_release(const void * object);
+
+__pinned_func
+static inline void k_object_release(const void * object)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = object };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_OBJECT_RELEASE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_k_object_release(object);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_object_release(object) do { 	sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_RELEASE, k_object_release, object); 	k_object_release(object); 	sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_RELEASE, k_object_release, object); } while(false)
+#endif
+#endif
+
+
+extern void * z_impl_k_object_alloc(enum k_objects otype);
+
+__pinned_func
+static inline void * k_object_alloc(enum k_objects otype)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; enum k_objects val; } parm0 = { .val = otype };
+		return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_K_OBJECT_ALLOC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_object_alloc(otype);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_object_alloc(otype) ({ 	void * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ALLOC, k_object_alloc, otype); 	syscall__retval = k_object_alloc(otype); 	sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ALLOC, k_object_alloc, otype, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void * z_impl_k_object_alloc_size(enum k_objects otype, size_t size);
+
+__pinned_func
+static inline void * k_object_alloc_size(enum k_objects otype, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; enum k_objects val; } parm0 = { .val = otype };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		return (void *) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_K_OBJECT_ALLOC_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_k_object_alloc_size(otype, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define k_object_alloc_size(otype, size) ({ 	void * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_K_OBJECT_ALLOC_SIZE, k_object_alloc_size, otype, size); 	syscall__retval = k_object_alloc_size(otype, size); 	sys_port_trace_syscall_exit(K_SYSCALL_K_OBJECT_ALLOC_SIZE, k_object_alloc_size, otype, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/kscan.h b/nrfdemo/build/zephyr/include/generated/syscalls/kscan.h
new file mode 100644
index 0000000..4077382
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/kscan.h
@@ -0,0 +1,98 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_KSCAN_H
+#define Z_INCLUDE_SYSCALLS_KSCAN_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_kscan_config(const struct device * dev, kscan_callback_t callback);
+
+__pinned_func
+static inline int kscan_config(const struct device * dev, kscan_callback_t callback)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; kscan_callback_t val; } parm1 = { .val = callback };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_KSCAN_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_kscan_config(dev, callback);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define kscan_config(dev, callback) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_KSCAN_CONFIG, kscan_config, dev, callback); 	syscall__retval = kscan_config(dev, callback); 	sys_port_trace_syscall_exit(K_SYSCALL_KSCAN_CONFIG, kscan_config, dev, callback, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_kscan_enable_callback(const struct device * dev);
+
+__pinned_func
+static inline int kscan_enable_callback(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_KSCAN_ENABLE_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_kscan_enable_callback(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define kscan_enable_callback(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_KSCAN_ENABLE_CALLBACK, kscan_enable_callback, dev); 	syscall__retval = kscan_enable_callback(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_KSCAN_ENABLE_CALLBACK, kscan_enable_callback, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_kscan_disable_callback(const struct device * dev);
+
+__pinned_func
+static inline int kscan_disable_callback(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_KSCAN_DISABLE_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_kscan_disable_callback(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define kscan_disable_callback(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_KSCAN_DISABLE_CALLBACK, kscan_disable_callback, dev); 	syscall__retval = kscan_disable_callback(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_KSCAN_DISABLE_CALLBACK, kscan_disable_callback, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/led.h b/nrfdemo/build/zephyr/include/generated/syscalls/led.h
new file mode 100644
index 0000000..4eef880
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/led.h
@@ -0,0 +1,229 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_LED_H
+#define Z_INCLUDE_SYSCALLS_LED_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off);
+
+__pinned_func
+static inline int led_blink(const struct device * dev, uint32_t led, uint32_t delay_on, uint32_t delay_off)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = delay_on };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = delay_off };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_BLINK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_blink(dev, led, delay_on, delay_off);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_blink(dev, led, delay_on, delay_off) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off); 	syscall__retval = led_blink(dev, led, delay_on, delay_off); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_BLINK, led_blink, dev, led, delay_on, delay_off, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info);
+
+__pinned_func
+static inline int led_get_info(const struct device * dev, uint32_t led, const struct led_info ** info)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		union { uintptr_t x; const struct led_info ** val; } parm2 = { .val = info };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_GET_INFO);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_get_info(dev, led, info);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_get_info(dev, led, info) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info); 	syscall__retval = led_get_info(dev, led, info); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_GET_INFO, led_get_info, dev, led, info, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_set_brightness(const struct device * dev, uint32_t led, uint8_t value);
+
+__pinned_func
+static inline int led_set_brightness(const struct device * dev, uint32_t led, uint8_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_BRIGHTNESS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_set_brightness(dev, led, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_set_brightness(dev, led, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value); 	syscall__retval = led_set_brightness(dev, led, value); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_BRIGHTNESS, led_set_brightness, dev, led, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf);
+
+__pinned_func
+static inline int led_write_channels(const struct device * dev, uint32_t start_channel, uint32_t num_channels, const uint8_t * buf)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = start_channel };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = num_channels };
+		union { uintptr_t x; const uint8_t * val; } parm3 = { .val = buf };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_WRITE_CHANNELS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_write_channels(dev, start_channel, num_channels, buf);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_write_channels(dev, start_channel, num_channels, buf) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf); 	syscall__retval = led_write_channels(dev, start_channel, num_channels, buf); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_WRITE_CHANNELS, led_write_channels, dev, start_channel, num_channels, buf, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_set_channel(const struct device * dev, uint32_t channel, uint8_t value);
+
+__pinned_func
+static inline int led_set_channel(const struct device * dev, uint32_t channel, uint8_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = value };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_LED_SET_CHANNEL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_set_channel(dev, channel, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_set_channel(dev, channel, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value); 	syscall__retval = led_set_channel(dev, channel, value); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_CHANNEL, led_set_channel, dev, channel, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color);
+
+__pinned_func
+static inline int led_set_color(const struct device * dev, uint32_t led, uint8_t num_colors, const uint8_t * color)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = num_colors };
+		union { uintptr_t x; const uint8_t * val; } parm3 = { .val = color };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LED_SET_COLOR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_set_color(dev, led, num_colors, color);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_set_color(dev, led, num_colors, color) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color); 	syscall__retval = led_set_color(dev, led, num_colors, color); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_SET_COLOR, led_set_color, dev, led, num_colors, color, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_on(const struct device * dev, uint32_t led);
+
+__pinned_func
+static inline int led_on(const struct device * dev, uint32_t led)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_ON);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_on(dev, led);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_on(dev, led) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_ON, led_on, dev, led); 	syscall__retval = led_on(dev, led); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_ON, led_on, dev, led, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_led_off(const struct device * dev, uint32_t led);
+
+__pinned_func
+static inline int led_off(const struct device * dev, uint32_t led)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = led };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LED_OFF);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_led_off(dev, led);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define led_off(dev, led) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LED_OFF, led_off, dev, led); 	syscall__retval = led_off(dev, led); 	sys_port_trace_syscall_exit(K_SYSCALL_LED_OFF, led_off, dev, led, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/libc-hooks.h b/nrfdemo/build/zephyr/include/generated/syscalls/libc-hooks.h
new file mode 100644
index 0000000..c90ad63
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/libc-hooks.h
@@ -0,0 +1,126 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
+#define Z_INCLUDE_SYSCALLS_LIBC_HOOKS_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_zephyr_read_stdin(char * buf, int nbytes);
+
+__pinned_func
+static inline int zephyr_read_stdin(char * buf, int nbytes)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; char * val; } parm0 = { .val = buf };
+		union { uintptr_t x; int val; } parm1 = { .val = nbytes };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_READ_STDIN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zephyr_read_stdin(buf, nbytes);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zephyr_read_stdin(buf, nbytes) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes); 	syscall__retval = zephyr_read_stdin(buf, nbytes); 	sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_READ_STDIN, zephyr_read_stdin, buf, nbytes, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zephyr_write_stdout(const void * buf, int nbytes);
+
+__pinned_func
+static inline int zephyr_write_stdout(const void * buf, int nbytes)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = buf };
+		union { uintptr_t x; int val; } parm1 = { .val = nbytes };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_WRITE_STDOUT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zephyr_write_stdout(buf, nbytes);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zephyr_write_stdout(buf, nbytes) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes); 	syscall__retval = zephyr_write_stdout(buf, nbytes); 	sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_WRITE_STDOUT, zephyr_write_stdout, buf, nbytes, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zephyr_fputc(int c, FILE * stream);
+
+__pinned_func
+static inline int zephyr_fputc(int c, FILE * stream)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = c };
+		union { uintptr_t x; FILE * val; } parm1 = { .val = stream };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZEPHYR_FPUTC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zephyr_fputc(c, stream);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zephyr_fputc(c, stream) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream); 	syscall__retval = zephyr_fputc(c, stream); 	sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FPUTC, zephyr_fputc, c, stream, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream);
+
+__pinned_func
+static inline size_t zephyr_fwrite(const void *ZRESTRICT ptr, size_t size, size_t nitems, FILE *ZRESTRICT stream)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void *ZRESTRICT val; } parm0 = { .val = ptr };
+		union { uintptr_t x; size_t val; } parm1 = { .val = size };
+		union { uintptr_t x; size_t val; } parm2 = { .val = nitems };
+		union { uintptr_t x; FILE *ZRESTRICT val; } parm3 = { .val = stream };
+		return (size_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_ZEPHYR_FWRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zephyr_fwrite(ptr, size, nitems, stream);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zephyr_fwrite(ptr, size, nitems, stream) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream); 	syscall__retval = zephyr_fwrite(ptr, size, nitems, stream); 	sys_port_trace_syscall_exit(K_SYSCALL_ZEPHYR_FWRITE, zephyr_fwrite, ptr, size, nitems, stream, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/log_ctrl.h b/nrfdemo/build/zephyr/include/generated/syscalls/log_ctrl.h
new file mode 100644
index 0000000..f4df429
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/log_ctrl.h
@@ -0,0 +1,145 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_LOG_CTRL_H
+#define Z_INCLUDE_SYSCALLS_LOG_CTRL_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_log_panic(void);
+
+__pinned_func
+static inline void log_panic(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		(void) arch_syscall_invoke0(K_SYSCALL_LOG_PANIC);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_log_panic();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define log_panic() do { 	sys_port_trace_syscall_enter(K_SYSCALL_LOG_PANIC, log_panic); 	log_panic(); 	sys_port_trace_syscall_exit(K_SYSCALL_LOG_PANIC, log_panic); } while(false)
+#endif
+#endif
+
+
+extern bool z_impl_log_process(void);
+
+__pinned_func
+static inline bool log_process(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (bool) arch_syscall_invoke0(K_SYSCALL_LOG_PROCESS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_log_process();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define log_process() ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LOG_PROCESS, log_process); 	syscall__retval = log_process(); 	sys_port_trace_syscall_exit(K_SYSCALL_LOG_PROCESS, log_process, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_log_buffered_cnt(void);
+
+__pinned_func
+static inline uint32_t log_buffered_cnt(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (uint32_t) arch_syscall_invoke0(K_SYSCALL_LOG_BUFFERED_CNT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_log_buffered_cnt();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define log_buffered_cnt() ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt); 	syscall__retval = log_buffered_cnt(); 	sys_port_trace_syscall_exit(K_SYSCALL_LOG_BUFFERED_CNT, log_buffered_cnt, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level);
+
+__pinned_func
+static inline uint32_t log_filter_set(struct log_backend const *const backend, uint32_t domain_id, int16_t source_id, uint32_t level)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct log_backend const *const val; } parm0 = { .val = backend };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = domain_id };
+		union { uintptr_t x; int16_t val; } parm2 = { .val = source_id };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = level };
+		return (uint32_t) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_LOG_FILTER_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_log_filter_set(backend, domain_id, source_id, level);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define log_filter_set(backend, domain_id, source_id, level) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level); 	syscall__retval = log_filter_set(backend, domain_id, source_id, level); 	sys_port_trace_syscall_exit(K_SYSCALL_LOG_FILTER_SET, log_filter_set, backend, domain_id, source_id, level, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_log_frontend_filter_set(int16_t source_id, uint32_t level);
+
+__pinned_func
+static inline uint32_t log_frontend_filter_set(int16_t source_id, uint32_t level)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int16_t val; } parm0 = { .val = source_id };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_LOG_FRONTEND_FILTER_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_log_frontend_filter_set(source_id, level);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define log_frontend_filter_set(source_id, level) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level); 	syscall__retval = log_frontend_filter_set(source_id, level); 	sys_port_trace_syscall_exit(K_SYSCALL_LOG_FRONTEND_FILTER_SET, log_frontend_filter_set, source_id, level, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/log_msg.h b/nrfdemo/build/zephyr/include/generated/syscalls/log_msg.h
new file mode 100644
index 0000000..24e13c8
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/log_msg.h
@@ -0,0 +1,136 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_LOG_MSG_H
+#define Z_INCLUDE_SYSCALLS_LOG_MSG_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt);
+
+__pinned_func
+static inline void z_log_msg_simple_create_0(const void * source, uint32_t level, const char * fmt)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = source };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
+		union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
+		(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_z_log_msg_simple_create_0(source, level, fmt);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_log_msg_simple_create_0(source, level, fmt) do { 	sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); 	z_log_msg_simple_create_0(source, level, fmt); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_0, z_log_msg_simple_create_0, source, level, fmt); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg);
+
+__pinned_func
+static inline void z_log_msg_simple_create_1(const void * source, uint32_t level, const char * fmt, uint32_t arg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = source };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
+		union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = arg };
+		(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_z_log_msg_simple_create_1(source, level, fmt, arg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_log_msg_simple_create_1(source, level, fmt, arg) do { 	sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); 	z_log_msg_simple_create_1(source, level, fmt, arg); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_1, z_log_msg_simple_create_1, source, level, fmt, arg); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1);
+
+__pinned_func
+static inline void z_log_msg_simple_create_2(const void * source, uint32_t level, const char * fmt, uint32_t arg0, uint32_t arg1)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = source };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = level };
+		union { uintptr_t x; const char * val; } parm2 = { .val = fmt };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = arg0 };
+		union { uintptr_t x; uint32_t val; } parm4 = { .val = arg1 };
+		(void) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_z_log_msg_simple_create_2(source, level, fmt, arg0, arg1);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_log_msg_simple_create_2(source, level, fmt, arg0, arg1) do { 	sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); 	z_log_msg_simple_create_2(source, level, fmt, arg0, arg1); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_SIMPLE_CREATE_2, z_log_msg_simple_create_2, source, level, fmt, arg0, arg1); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data);
+
+__pinned_func
+static inline void z_log_msg_static_create(const void * source, const struct log_msg_desc desc, uint8_t * package, const void * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const void * val; } parm0 = { .val = source };
+		union { uintptr_t x; const struct log_msg_desc val; } parm1 = { .val = desc };
+		union { uintptr_t x; uint8_t * val; } parm2 = { .val = package };
+		union { uintptr_t x; const void * val; } parm3 = { .val = data };
+		(void) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_LOG_MSG_STATIC_CREATE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_z_log_msg_static_create(source, desc, package, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_log_msg_static_create(source, desc, package, data) do { 	sys_port_trace_syscall_enter(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); 	z_log_msg_static_create(source, desc, package, data); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_LOG_MSG_STATIC_CREATE, z_log_msg_static_create, source, desc, package, data); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/maxim_ds3231.h b/nrfdemo/build/zephyr/include/generated/syscalls/maxim_ds3231.h
new file mode 100644
index 0000000..7a656a4
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/maxim_ds3231.h
@@ -0,0 +1,76 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
+#define Z_INCLUDE_SYSCALLS_MAXIM_DS3231_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal);
+
+__pinned_func
+static inline int maxim_ds3231_req_syncpoint(const struct device * dev, struct k_poll_signal * signal)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct k_poll_signal * val; } parm1 = { .val = signal };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_maxim_ds3231_req_syncpoint(dev, signal);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define maxim_ds3231_req_syncpoint(dev, signal) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal); 	syscall__retval = maxim_ds3231_req_syncpoint(dev, signal); 	sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_REQ_SYNCPOINT, maxim_ds3231_req_syncpoint, dev, signal, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint);
+
+__pinned_func
+static inline int maxim_ds3231_get_syncpoint(const struct device * dev, struct maxim_ds3231_syncpoint * syncpoint)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct maxim_ds3231_syncpoint * val; } parm1 = { .val = syncpoint };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_maxim_ds3231_get_syncpoint(dev, syncpoint);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define maxim_ds3231_get_syncpoint(dev, syncpoint) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint); 	syscall__retval = maxim_ds3231_get_syncpoint(dev, syncpoint); 	sys_port_trace_syscall_exit(K_SYSCALL_MAXIM_DS3231_GET_SYNCPOINT, maxim_ds3231_get_syncpoint, dev, syncpoint, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/mbox.h b/nrfdemo/build/zephyr/include/generated/syscalls/mbox.h
new file mode 100644
index 0000000..c8b4ae5
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/mbox.h
@@ -0,0 +1,124 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_MBOX_H
+#define Z_INCLUDE_SYSCALLS_MBOX_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg);
+
+__pinned_func
+static inline int mbox_send(const struct device * dev, mbox_channel_id_t channel_id, const struct mbox_msg * msg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
+		union { uintptr_t x; const struct mbox_msg * val; } parm2 = { .val = msg };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SEND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mbox_send(dev, channel_id, msg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mbox_send(dev, channel_id, msg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg); 	syscall__retval = mbox_send(dev, channel_id, msg); 	sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SEND, mbox_send, dev, channel_id, msg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_mbox_mtu_get(const struct device * dev);
+
+__pinned_func
+static inline int mbox_mtu_get(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MTU_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mbox_mtu_get(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mbox_mtu_get(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev); 	syscall__retval = mbox_mtu_get(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MTU_GET, mbox_mtu_get, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled);
+
+__pinned_func
+static inline int mbox_set_enabled(const struct device * dev, mbox_channel_id_t channel_id, bool enabled)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; mbox_channel_id_t val; } parm1 = { .val = channel_id };
+		union { uintptr_t x; bool val; } parm2 = { .val = enabled };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_MBOX_SET_ENABLED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mbox_set_enabled(dev, channel_id, enabled);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mbox_set_enabled(dev, channel_id, enabled) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled); 	syscall__retval = mbox_set_enabled(dev, channel_id, enabled); 	sys_port_trace_syscall_exit(K_SYSCALL_MBOX_SET_ENABLED, mbox_set_enabled, dev, channel_id, enabled, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_mbox_max_channels_get(const struct device * dev);
+
+__pinned_func
+static inline uint32_t mbox_max_channels_get(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (uint32_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_MBOX_MAX_CHANNELS_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mbox_max_channels_get(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mbox_max_channels_get(dev) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev); 	syscall__retval = mbox_max_channels_get(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_MBOX_MAX_CHANNELS_GET, mbox_max_channels_get, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/mdio.h b/nrfdemo/build/zephyr/include/generated/syscalls/mdio.h
new file mode 100644
index 0000000..0e96369
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/mdio.h
@@ -0,0 +1,182 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_MDIO_H
+#define Z_INCLUDE_SYSCALLS_MDIO_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_mdio_bus_enable(const struct device * dev);
+
+__pinned_func
+static inline void mdio_bus_enable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_MDIO_BUS_ENABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_mdio_bus_enable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_bus_enable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_BUS_ENABLE, mdio_bus_enable, dev); 	mdio_bus_enable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_BUS_ENABLE, mdio_bus_enable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_mdio_bus_disable(const struct device * dev);
+
+__pinned_func
+static inline void mdio_bus_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_MDIO_BUS_DISABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_mdio_bus_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_bus_disable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_BUS_DISABLE, mdio_bus_disable, dev); 	mdio_bus_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_BUS_DISABLE, mdio_bus_disable, dev); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_mdio_read(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t * data);
+
+__pinned_func
+static inline int mdio_read(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = regad };
+		union { uintptr_t x; uint16_t * val; } parm3 = { .val = data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MDIO_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mdio_read(dev, prtad, regad, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_read(dev, prtad, regad, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_READ, mdio_read, dev, prtad, regad, data); 	syscall__retval = mdio_read(dev, prtad, regad, data); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_READ, mdio_read, dev, prtad, regad, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_mdio_write(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t data);
+
+__pinned_func
+static inline int mdio_write(const struct device * dev, uint8_t prtad, uint8_t regad, uint16_t data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = regad };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_MDIO_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mdio_write(dev, prtad, regad, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_write(dev, prtad, regad, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_WRITE, mdio_write, dev, prtad, regad, data); 	syscall__retval = mdio_write(dev, prtad, regad, data); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_WRITE, mdio_write, dev, prtad, regad, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_mdio_read_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t * data);
+
+__pinned_func
+static inline int mdio_read_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = devad };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = regad };
+		union { uintptr_t x; uint16_t * val; } parm4 = { .val = data };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_MDIO_READ_C45);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mdio_read_c45(dev, prtad, devad, regad, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_read_c45(dev, prtad, devad, regad, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_READ_C45, mdio_read_c45, dev, prtad, devad, regad, data); 	syscall__retval = mdio_read_c45(dev, prtad, devad, regad, data); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_READ_C45, mdio_read_c45, dev, prtad, devad, regad, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_mdio_write_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t data);
+
+__pinned_func
+static inline int mdio_write_c45(const struct device * dev, uint8_t prtad, uint8_t devad, uint16_t regad, uint16_t data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = prtad };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = devad };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = regad };
+		union { uintptr_t x; uint16_t val; } parm4 = { .val = data };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_MDIO_WRITE_C45);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_mdio_write_c45(dev, prtad, devad, regad, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define mdio_write_c45(dev, prtad, devad, regad, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_MDIO_WRITE_C45, mdio_write_c45, dev, prtad, devad, regad, data); 	syscall__retval = mdio_write_c45(dev, prtad, devad, regad, data); 	sys_port_trace_syscall_exit(K_SYSCALL_MDIO_WRITE_C45, mdio_write_c45, dev, prtad, devad, regad, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/mutex.h b/nrfdemo/build/zephyr/include/generated/syscalls/mutex.h
new file mode 100644
index 0000000..c529133
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/mutex.h
@@ -0,0 +1,75 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_MUTEX_H
+#define Z_INCLUDE_SYSCALLS_MUTEX_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout);
+
+__pinned_func
+static inline int z_sys_mutex_kernel_lock(struct sys_mutex * mutex, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm1 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.split.lo, parm1.split.hi, K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_z_sys_mutex_kernel_lock(mutex, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_sys_mutex_kernel_lock(mutex, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout); 	syscall__retval = z_sys_mutex_kernel_lock(mutex, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_LOCK, z_sys_mutex_kernel_lock, mutex, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_z_sys_mutex_kernel_unlock(struct sys_mutex * mutex);
+
+__pinned_func
+static inline int z_sys_mutex_kernel_unlock(struct sys_mutex * mutex)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct sys_mutex * val; } parm0 = { .val = mutex };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_z_sys_mutex_kernel_unlock(mutex);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_sys_mutex_kernel_unlock(mutex) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex); 	syscall__retval = z_sys_mutex_kernel_unlock(mutex); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_SYS_MUTEX_KERNEL_UNLOCK, z_sys_mutex_kernel_unlock, mutex, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/net_if.h b/nrfdemo/build/zephyr/include/generated/syscalls/net_if.h
new file mode 100644
index 0000000..74fe947
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/net_if.h
@@ -0,0 +1,270 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_NET_IF_H
+#define Z_INCLUDE_SYSCALLS_NET_IF_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_net_if_ipv6_addr_lookup_by_index(const struct in6_addr * addr);
+
+__pinned_func
+static inline int net_if_ipv6_addr_lookup_by_index(const struct in6_addr * addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct in6_addr * val; } parm0 = { .val = addr };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv6_addr_lookup_by_index(addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv6_addr_lookup_by_index(addr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX, net_if_ipv6_addr_lookup_by_index, addr); 	syscall__retval = net_if_ipv6_addr_lookup_by_index(addr); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_LOOKUP_BY_INDEX, net_if_ipv6_addr_lookup_by_index, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv6_addr_add_by_index(int index, struct in6_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime);
+
+__pinned_func
+static inline bool net_if_ipv6_addr_add_by_index(int index, struct in6_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; struct in6_addr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; enum net_addr_type val; } parm2 = { .val = addr_type };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = vlifetime };
+		return (bool) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX, net_if_ipv6_addr_add_by_index, index, addr, addr_type, vlifetime); 	syscall__retval = net_if_ipv6_addr_add_by_index(index, addr, addr_type, vlifetime); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_ADD_BY_INDEX, net_if_ipv6_addr_add_by_index, index, addr, addr_type, vlifetime, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv6_addr_rm_by_index(int index, const struct in6_addr * addr);
+
+__pinned_func
+static inline bool net_if_ipv6_addr_rm_by_index(int index, const struct in6_addr * addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; const struct in6_addr * val; } parm1 = { .val = addr };
+		return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv6_addr_rm_by_index(index, addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv6_addr_rm_by_index(index, addr) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX, net_if_ipv6_addr_rm_by_index, index, addr); 	syscall__retval = net_if_ipv6_addr_rm_by_index(index, addr); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV6_ADDR_RM_BY_INDEX, net_if_ipv6_addr_rm_by_index, index, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_net_if_ipv4_addr_lookup_by_index(const struct in_addr * addr);
+
+__pinned_func
+static inline int net_if_ipv4_addr_lookup_by_index(const struct in_addr * addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct in_addr * val; } parm0 = { .val = addr };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_addr_lookup_by_index(addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_addr_lookup_by_index(addr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX, net_if_ipv4_addr_lookup_by_index, addr); 	syscall__retval = net_if_ipv4_addr_lookup_by_index(addr); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_LOOKUP_BY_INDEX, net_if_ipv4_addr_lookup_by_index, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv4_addr_add_by_index(int index, struct in_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime);
+
+__pinned_func
+static inline bool net_if_ipv4_addr_add_by_index(int index, struct in_addr * addr, enum net_addr_type addr_type, uint32_t vlifetime)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; struct in_addr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; enum net_addr_type val; } parm2 = { .val = addr_type };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = vlifetime };
+		return (bool) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX, net_if_ipv4_addr_add_by_index, index, addr, addr_type, vlifetime); 	syscall__retval = net_if_ipv4_addr_add_by_index(index, addr, addr_type, vlifetime); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_ADD_BY_INDEX, net_if_ipv4_addr_add_by_index, index, addr, addr_type, vlifetime, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv4_addr_rm_by_index(int index, const struct in_addr * addr);
+
+__pinned_func
+static inline bool net_if_ipv4_addr_rm_by_index(int index, const struct in_addr * addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; const struct in_addr * val; } parm1 = { .val = addr };
+		return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_addr_rm_by_index(index, addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_addr_rm_by_index(index, addr) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr); 	syscall__retval = net_if_ipv4_addr_rm_by_index(index, addr); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_ADDR_RM_BY_INDEX, net_if_ipv4_addr_rm_by_index, index, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv4_set_netmask_by_index(int index, const struct in_addr * netmask);
+
+__pinned_func
+static inline bool net_if_ipv4_set_netmask_by_index(int index, const struct in_addr * netmask)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; const struct in_addr * val; } parm1 = { .val = netmask };
+		return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_set_netmask_by_index(index, netmask);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_set_netmask_by_index(index, netmask) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask); 	syscall__retval = net_if_ipv4_set_netmask_by_index(index, netmask); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_INDEX, net_if_ipv4_set_netmask_by_index, index, netmask, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct in_addr * addr, const struct in_addr * netmask);
+
+__pinned_func
+static inline bool net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct in_addr * addr, const struct in_addr * netmask)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; const struct in_addr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; const struct in_addr * val; } parm2 = { .val = netmask };
+		return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX, net_if_ipv4_set_netmask_by_addr_by_index, index, addr, netmask); 	syscall__retval = net_if_ipv4_set_netmask_by_addr_by_index(index, addr, netmask); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_NETMASK_BY_ADDR_BY_INDEX, net_if_ipv4_set_netmask_by_addr_by_index, index, addr, netmask, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern bool z_impl_net_if_ipv4_set_gw_by_index(int index, const struct in_addr * gw);
+
+__pinned_func
+static inline bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr * gw)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		union { uintptr_t x; const struct in_addr * val; } parm1 = { .val = gw };
+		return (bool) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_ipv4_set_gw_by_index(index, gw);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_ipv4_set_gw_by_index(index, gw) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX, net_if_ipv4_set_gw_by_index, index, gw); 	syscall__retval = net_if_ipv4_set_gw_by_index(index, gw); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_IPV4_SET_GW_BY_INDEX, net_if_ipv4_set_gw_by_index, index, gw, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern struct net_if * z_impl_net_if_get_by_index(int index);
+
+__pinned_func
+static inline struct net_if * net_if_get_by_index(int index)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = index };
+		return (struct net_if *) arch_syscall_invoke1(parm0.x, K_SYSCALL_NET_IF_GET_BY_INDEX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_if_get_by_index(index);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_if_get_by_index(index) ({ 	struct net_if * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_IF_GET_BY_INDEX, net_if_get_by_index, index); 	syscall__retval = net_if_get_by_index(index); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_IF_GET_BY_INDEX, net_if_get_by_index, index, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/net_ip.h b/nrfdemo/build/zephyr/include/generated/syscalls/net_ip.h
new file mode 100644
index 0000000..6659cd4
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/net_ip.h
@@ -0,0 +1,79 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_NET_IP_H
+#define Z_INCLUDE_SYSCALLS_NET_IP_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_net_addr_pton(sa_family_t family, const char * src, void * dst);
+
+__pinned_func
+static inline int net_addr_pton(sa_family_t family, const char * src, void * dst)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; sa_family_t val; } parm0 = { .val = family };
+		union { uintptr_t x; const char * val; } parm1 = { .val = src };
+		union { uintptr_t x; void * val; } parm2 = { .val = dst };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_NET_ADDR_PTON);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_addr_pton(family, src, dst);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_addr_pton(family, src, dst) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_ADDR_PTON, net_addr_pton, family, src, dst); 	syscall__retval = net_addr_pton(family, src, dst); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_ADDR_PTON, net_addr_pton, family, src, dst, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern char * z_impl_net_addr_ntop(sa_family_t family, const void * src, char * dst, size_t size);
+
+__pinned_func
+static inline char * net_addr_ntop(sa_family_t family, const void * src, char * dst, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; sa_family_t val; } parm0 = { .val = family };
+		union { uintptr_t x; const void * val; } parm1 = { .val = src };
+		union { uintptr_t x; char * val; } parm2 = { .val = dst };
+		union { uintptr_t x; size_t val; } parm3 = { .val = size };
+		return (char *) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_ADDR_NTOP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_addr_ntop(family, src, dst, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_addr_ntop(family, src, dst, size) ({ 	char * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size); 	syscall__retval = net_addr_ntop(family, src, dst, size); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_ADDR_NTOP, net_addr_ntop, family, src, dst, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/nrf_qspi_nor.h b/nrfdemo/build/zephyr/include/generated/syscalls/nrf_qspi_nor.h
new file mode 100644
index 0000000..0caf244
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/nrf_qspi_nor.h
@@ -0,0 +1,53 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
+#define Z_INCLUDE_SYSCALLS_NRF_QSPI_NOR_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_nrf_qspi_nor_xip_enable(const struct device * dev, bool enable);
+
+__pinned_func
+static inline void nrf_qspi_nor_xip_enable(const struct device * dev, bool enable)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = enable };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_nrf_qspi_nor_xip_enable(dev, enable);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define nrf_qspi_nor_xip_enable(dev, enable) do { 	sys_port_trace_syscall_enter(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); 	nrf_qspi_nor_xip_enable(dev, enable); 	sys_port_trace_syscall_exit(K_SYSCALL_NRF_QSPI_NOR_XIP_ENABLE, nrf_qspi_nor_xip_enable, dev, enable); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/peci.h b/nrfdemo/build/zephyr/include/generated/syscalls/peci.h
new file mode 100644
index 0000000..6d3a15a
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/peci.h
@@ -0,0 +1,122 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_PECI_H
+#define Z_INCLUDE_SYSCALLS_PECI_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_peci_config(const struct device * dev, uint32_t bitrate);
+
+__pinned_func
+static inline int peci_config(const struct device * dev, uint32_t bitrate)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = bitrate };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_peci_config(dev, bitrate);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define peci_config(dev, bitrate) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate); 	syscall__retval = peci_config(dev, bitrate); 	sys_port_trace_syscall_exit(K_SYSCALL_PECI_CONFIG, peci_config, dev, bitrate, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_peci_enable(const struct device * dev);
+
+__pinned_func
+static inline int peci_enable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_ENABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_peci_enable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define peci_enable(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PECI_ENABLE, peci_enable, dev); 	syscall__retval = peci_enable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_PECI_ENABLE, peci_enable, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_peci_disable(const struct device * dev);
+
+__pinned_func
+static inline int peci_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PECI_DISABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_peci_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define peci_disable(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PECI_DISABLE, peci_disable, dev); 	syscall__retval = peci_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_PECI_DISABLE, peci_disable, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_peci_transfer(const struct device * dev, struct peci_msg * msg);
+
+__pinned_func
+static inline int peci_transfer(const struct device * dev, struct peci_msg * msg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct peci_msg * val; } parm1 = { .val = msg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PECI_TRANSFER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_peci_transfer(dev, msg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define peci_transfer(dev, msg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg); 	syscall__retval = peci_transfer(dev, msg); 	sys_port_trace_syscall_exit(K_SYSCALL_PECI_TRANSFER, peci_transfer, dev, msg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/posix_clock.h b/nrfdemo/build/zephyr/include/generated/syscalls/posix_clock.h
new file mode 100644
index 0000000..0227397
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/posix_clock.h
@@ -0,0 +1,52 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_POSIX_CLOCK_H
+#define Z_INCLUDE_SYSCALLS_POSIX_CLOCK_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl___posix_clock_get_base(clockid_t clock_id, struct timespec * ts);
+
+__pinned_func
+static inline int __posix_clock_get_base(clockid_t clock_id, struct timespec * ts)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; clockid_t val; } parm0 = { .val = clock_id };
+		union { uintptr_t x; struct timespec * val; } parm1 = { .val = ts };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL___POSIX_CLOCK_GET_BASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl___posix_clock_get_base(clock_id, ts);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define __posix_clock_get_base(clock_id, ts) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL___POSIX_CLOCK_GET_BASE, __posix_clock_get_base, clock_id, ts); 	syscall__retval = __posix_clock_get_base(clock_id, ts); 	sys_port_trace_syscall_exit(K_SYSCALL___POSIX_CLOCK_GET_BASE, __posix_clock_get_base, clock_id, ts, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/ps2.h b/nrfdemo/build/zephyr/include/generated/syscalls/ps2.h
new file mode 100644
index 0000000..53ee99b
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/ps2.h
@@ -0,0 +1,146 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_PS2_H
+#define Z_INCLUDE_SYSCALLS_PS2_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_ps2_config(const struct device * dev, ps2_callback_t callback_isr);
+
+__pinned_func
+static inline int ps2_config(const struct device * dev, ps2_callback_t callback_isr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; ps2_callback_t val; } parm1 = { .val = callback_isr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ps2_config(dev, callback_isr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ps2_config(dev, callback_isr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr); 	syscall__retval = ps2_config(dev, callback_isr); 	sys_port_trace_syscall_exit(K_SYSCALL_PS2_CONFIG, ps2_config, dev, callback_isr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ps2_write(const struct device * dev, uint8_t value);
+
+__pinned_func
+static inline int ps2_write(const struct device * dev, uint8_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = value };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ps2_write(dev, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ps2_write(dev, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PS2_WRITE, ps2_write, dev, value); 	syscall__retval = ps2_write(dev, value); 	sys_port_trace_syscall_exit(K_SYSCALL_PS2_WRITE, ps2_write, dev, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ps2_read(const struct device * dev, uint8_t * value);
+
+__pinned_func
+static inline int ps2_read(const struct device * dev, uint8_t * value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = value };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PS2_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ps2_read(dev, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ps2_read(dev, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PS2_READ, ps2_read, dev, value); 	syscall__retval = ps2_read(dev, value); 	sys_port_trace_syscall_exit(K_SYSCALL_PS2_READ, ps2_read, dev, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ps2_enable_callback(const struct device * dev);
+
+__pinned_func
+static inline int ps2_enable_callback(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_ENABLE_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ps2_enable_callback(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ps2_enable_callback(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev); 	syscall__retval = ps2_enable_callback(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_PS2_ENABLE_CALLBACK, ps2_enable_callback, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_ps2_disable_callback(const struct device * dev);
+
+__pinned_func
+static inline int ps2_disable_callback(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_PS2_DISABLE_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ps2_disable_callback(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ps2_disable_callback(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev); 	syscall__retval = ps2_disable_callback(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_PS2_DISABLE_CALLBACK, ps2_disable_callback, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/ptp_clock.h b/nrfdemo/build/zephyr/include/generated/syscalls/ptp_clock.h
new file mode 100644
index 0000000..c852ef2
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/ptp_clock.h
@@ -0,0 +1,52 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
+#define Z_INCLUDE_SYSCALLS_PTP_CLOCK_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_ptp_clock_get(const struct device * dev, struct net_ptp_time * tm);
+
+__pinned_func
+static inline int ptp_clock_get(const struct device * dev, struct net_ptp_time * tm)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct net_ptp_time * val; } parm1 = { .val = tm };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PTP_CLOCK_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_ptp_clock_get(dev, tm);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define ptp_clock_get(dev, tm) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm); 	syscall__retval = ptp_clock_get(dev, tm); 	sys_port_trace_syscall_exit(K_SYSCALL_PTP_CLOCK_GET, ptp_clock_get, dev, tm, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/pwm.h b/nrfdemo/build/zephyr/include/generated/syscalls/pwm.h
new file mode 100644
index 0000000..5c27060
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/pwm.h
@@ -0,0 +1,160 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_PWM_H
+#define Z_INCLUDE_SYSCALLS_PWM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_pwm_set_cycles(const struct device * dev, uint32_t channel, uint32_t period, uint32_t pulse, pwm_flags_t flags);
+
+__pinned_func
+static inline int pwm_set_cycles(const struct device * dev, uint32_t channel, uint32_t period, uint32_t pulse, pwm_flags_t flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = period };
+		union { uintptr_t x; uint32_t val; } parm3 = { .val = pulse };
+		union { uintptr_t x; pwm_flags_t val; } parm4 = { .val = flags };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_PWM_SET_CYCLES);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_pwm_set_cycles(dev, channel, period, pulse, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define pwm_set_cycles(dev, channel, period, pulse, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PWM_SET_CYCLES, pwm_set_cycles, dev, channel, period, pulse, flags); 	syscall__retval = pwm_set_cycles(dev, channel, period, pulse, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_PWM_SET_CYCLES, pwm_set_cycles, dev, channel, period, pulse, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_pwm_get_cycles_per_sec(const struct device * dev, uint32_t channel, uint64_t * cycles);
+
+__pinned_func
+static inline int pwm_get_cycles_per_sec(const struct device * dev, uint32_t channel, uint64_t * cycles)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		union { uintptr_t x; uint64_t * val; } parm2 = { .val = cycles };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_PWM_GET_CYCLES_PER_SEC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_pwm_get_cycles_per_sec(dev, channel, cycles);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define pwm_get_cycles_per_sec(dev, channel, cycles) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PWM_GET_CYCLES_PER_SEC, pwm_get_cycles_per_sec, dev, channel, cycles); 	syscall__retval = pwm_get_cycles_per_sec(dev, channel, cycles); 	sys_port_trace_syscall_exit(K_SYSCALL_PWM_GET_CYCLES_PER_SEC, pwm_get_cycles_per_sec, dev, channel, cycles, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_pwm_enable_capture(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int pwm_enable_capture(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_ENABLE_CAPTURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_pwm_enable_capture(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define pwm_enable_capture(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PWM_ENABLE_CAPTURE, pwm_enable_capture, dev, channel); 	syscall__retval = pwm_enable_capture(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_PWM_ENABLE_CAPTURE, pwm_enable_capture, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_pwm_disable_capture(const struct device * dev, uint32_t channel);
+
+__pinned_func
+static inline int pwm_disable_capture(const struct device * dev, uint32_t channel)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_PWM_DISABLE_CAPTURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_pwm_disable_capture(dev, channel);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define pwm_disable_capture(dev, channel) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PWM_DISABLE_CAPTURE, pwm_disable_capture, dev, channel); 	syscall__retval = pwm_disable_capture(dev, channel); 	sys_port_trace_syscall_exit(K_SYSCALL_PWM_DISABLE_CAPTURE, pwm_disable_capture, dev, channel, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_pwm_capture_cycles(const struct device * dev, uint32_t channel, pwm_flags_t flags, uint32_t * period, uint32_t * pulse, k_timeout_t timeout);
+
+__pinned_func
+static inline int pwm_capture_cycles(const struct device * dev, uint32_t channel, pwm_flags_t flags, uint32_t * period, uint32_t * pulse, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = channel };
+		union { uintptr_t x; pwm_flags_t val; } parm2 = { .val = flags };
+		union { uintptr_t x; uint32_t * val; } parm3 = { .val = period };
+		union { uintptr_t x; uint32_t * val; } parm4 = { .val = pulse };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm5 = { .val = timeout };
+		uintptr_t more[] = {
+			parm5.split.lo,
+			parm5.split.hi
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_PWM_CAPTURE_CYCLES);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_pwm_capture_cycles(dev, channel, flags, period, pulse, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define pwm_capture_cycles(dev, channel, flags, period, pulse, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_PWM_CAPTURE_CYCLES, pwm_capture_cycles, dev, channel, flags, period, pulse, timeout); 	syscall__retval = pwm_capture_cycles(dev, channel, flags, period, pulse, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_PWM_CAPTURE_CYCLES, pwm_capture_cycles, dev, channel, flags, period, pulse, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/random.h b/nrfdemo/build/zephyr/include/generated/syscalls/random.h
new file mode 100644
index 0000000..839bd2f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/random.h
@@ -0,0 +1,77 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_RANDOM_H
+#define Z_INCLUDE_SYSCALLS_RANDOM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_sys_rand_get(void * dst, size_t len);
+
+__pinned_func
+static inline void sys_rand_get(void * dst, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = dst };
+		union { uintptr_t x; size_t val; } parm1 = { .val = len };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_RAND_GET);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_sys_rand_get(dst, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_rand_get(dst, len) do { 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_RAND_GET, sys_rand_get, dst, len); 	sys_rand_get(dst, len); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_RAND_GET, sys_rand_get, dst, len); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_sys_csrand_get(void * dst, size_t len);
+
+__pinned_func
+static inline int sys_csrand_get(void * dst, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; void * val; } parm0 = { .val = dst };
+		union { uintptr_t x; size_t val; } parm1 = { .val = len };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYS_CSRAND_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sys_csrand_get(dst, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_csrand_get(dst, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_CSRAND_GET, sys_csrand_get, dst, len); 	syscall__retval = sys_csrand_get(dst, len); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_CSRAND_GET, sys_csrand_get, dst, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/reset.h b/nrfdemo/build/zephyr/include/generated/syscalls/reset.h
new file mode 100644
index 0000000..4da372c
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/reset.h
@@ -0,0 +1,125 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_RESET_H
+#define Z_INCLUDE_SYSCALLS_RESET_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_reset_status(const struct device * dev, uint32_t id, uint8_t * status);
+
+__pinned_func
+static inline int reset_status(const struct device * dev, uint32_t id, uint8_t * status)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		union { uintptr_t x; uint8_t * val; } parm2 = { .val = status };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RESET_STATUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_reset_status(dev, id, status);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define reset_status(dev, id, status) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RESET_STATUS, reset_status, dev, id, status); 	syscall__retval = reset_status(dev, id, status); 	sys_port_trace_syscall_exit(K_SYSCALL_RESET_STATUS, reset_status, dev, id, status, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_reset_line_assert(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline int reset_line_assert(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_ASSERT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_reset_line_assert(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define reset_line_assert(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_ASSERT, reset_line_assert, dev, id); 	syscall__retval = reset_line_assert(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_ASSERT, reset_line_assert, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_reset_line_deassert(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline int reset_line_deassert(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_DEASSERT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_reset_line_deassert(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define reset_line_deassert(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_DEASSERT, reset_line_deassert, dev, id); 	syscall__retval = reset_line_deassert(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_DEASSERT, reset_line_deassert, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_reset_line_toggle(const struct device * dev, uint32_t id);
+
+__pinned_func
+static inline int reset_line_toggle(const struct device * dev, uint32_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RESET_LINE_TOGGLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_reset_line_toggle(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define reset_line_toggle(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RESET_LINE_TOGGLE, reset_line_toggle, dev, id); 	syscall__retval = reset_line_toggle(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_RESET_LINE_TOGGLE, reset_line_toggle, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/retained_mem.h b/nrfdemo/build/zephyr/include/generated/syscalls/retained_mem.h
new file mode 100644
index 0000000..5495846
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/retained_mem.h
@@ -0,0 +1,126 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_RETAINED_MEM_H
+#define Z_INCLUDE_SYSCALLS_RETAINED_MEM_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern ssize_t z_impl_retained_mem_size(const struct device * dev);
+
+__pinned_func
+static inline ssize_t retained_mem_size(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (ssize_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_RETAINED_MEM_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_retained_mem_size(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define retained_mem_size(dev) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_SIZE, retained_mem_size, dev); 	syscall__retval = retained_mem_size(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_SIZE, retained_mem_size, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_retained_mem_read(const struct device * dev, off_t offset, uint8_t * buffer, size_t size);
+
+__pinned_func
+static inline int retained_mem_read(const struct device * dev, off_t offset, uint8_t * buffer, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; uint8_t * val; } parm2 = { .val = buffer };
+		union { uintptr_t x; size_t val; } parm3 = { .val = size };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RETAINED_MEM_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_retained_mem_read(dev, offset, buffer, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define retained_mem_read(dev, offset, buffer, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_READ, retained_mem_read, dev, offset, buffer, size); 	syscall__retval = retained_mem_read(dev, offset, buffer, size); 	sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_READ, retained_mem_read, dev, offset, buffer, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_retained_mem_write(const struct device * dev, off_t offset, const uint8_t * buffer, size_t size);
+
+__pinned_func
+static inline int retained_mem_write(const struct device * dev, off_t offset, const uint8_t * buffer, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; off_t val; } parm1 = { .val = offset };
+		union { uintptr_t x; const uint8_t * val; } parm2 = { .val = buffer };
+		union { uintptr_t x; size_t val; } parm3 = { .val = size };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RETAINED_MEM_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_retained_mem_write(dev, offset, buffer, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define retained_mem_write(dev, offset, buffer, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_WRITE, retained_mem_write, dev, offset, buffer, size); 	syscall__retval = retained_mem_write(dev, offset, buffer, size); 	sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_WRITE, retained_mem_write, dev, offset, buffer, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_retained_mem_clear(const struct device * dev);
+
+__pinned_func
+static inline int retained_mem_clear(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_RETAINED_MEM_CLEAR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_retained_mem_clear(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define retained_mem_clear(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RETAINED_MEM_CLEAR, retained_mem_clear, dev); 	syscall__retval = retained_mem_clear(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_RETAINED_MEM_CLEAR, retained_mem_clear, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/rtc.h b/nrfdemo/build/zephyr/include/generated/syscalls/rtc.h
new file mode 100644
index 0000000..038f1b7
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/rtc.h
@@ -0,0 +1,276 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_RTC_H
+#define Z_INCLUDE_SYSCALLS_RTC_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_rtc_set_time(const struct device * dev, const struct rtc_time * timeptr);
+
+__pinned_func
+static inline int rtc_set_time(const struct device * dev, const struct rtc_time * timeptr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct rtc_time * val; } parm1 = { .val = timeptr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_SET_TIME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_set_time(dev, timeptr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_set_time(dev, timeptr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_SET_TIME, rtc_set_time, dev, timeptr); 	syscall__retval = rtc_set_time(dev, timeptr); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_SET_TIME, rtc_set_time, dev, timeptr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_get_time(const struct device * dev, struct rtc_time * timeptr);
+
+__pinned_func
+static inline int rtc_get_time(const struct device * dev, struct rtc_time * timeptr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct rtc_time * val; } parm1 = { .val = timeptr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_GET_TIME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_get_time(dev, timeptr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_get_time(dev, timeptr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_GET_TIME, rtc_get_time, dev, timeptr); 	syscall__retval = rtc_get_time(dev, timeptr); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_GET_TIME, rtc_get_time, dev, timeptr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_alarm_get_supported_fields(const struct device * dev, uint16_t id, uint16_t * mask);
+
+__pinned_func
+static inline int rtc_alarm_get_supported_fields(const struct device * dev, uint16_t id, uint16_t * mask)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
+		union { uintptr_t x; uint16_t * val; } parm2 = { .val = mask };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_alarm_get_supported_fields(dev, id, mask);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_alarm_get_supported_fields(dev, id, mask) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS, rtc_alarm_get_supported_fields, dev, id, mask); 	syscall__retval = rtc_alarm_get_supported_fields(dev, id, mask); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_GET_SUPPORTED_FIELDS, rtc_alarm_get_supported_fields, dev, id, mask, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_alarm_set_time(const struct device * dev, uint16_t id, uint16_t mask, const struct rtc_time * timeptr);
+
+__pinned_func
+static inline int rtc_alarm_set_time(const struct device * dev, uint16_t id, uint16_t mask, const struct rtc_time * timeptr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
+		union { uintptr_t x; uint16_t val; } parm2 = { .val = mask };
+		union { uintptr_t x; const struct rtc_time * val; } parm3 = { .val = timeptr };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTC_ALARM_SET_TIME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_alarm_set_time(dev, id, mask, timeptr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_alarm_set_time(dev, id, mask, timeptr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_SET_TIME, rtc_alarm_set_time, dev, id, mask, timeptr); 	syscall__retval = rtc_alarm_set_time(dev, id, mask, timeptr); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_SET_TIME, rtc_alarm_set_time, dev, id, mask, timeptr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_alarm_get_time(const struct device * dev, uint16_t id, uint16_t * mask, struct rtc_time * timeptr);
+
+__pinned_func
+static inline int rtc_alarm_get_time(const struct device * dev, uint16_t id, uint16_t * mask, struct rtc_time * timeptr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
+		union { uintptr_t x; uint16_t * val; } parm2 = { .val = mask };
+		union { uintptr_t x; struct rtc_time * val; } parm3 = { .val = timeptr };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTC_ALARM_GET_TIME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_alarm_get_time(dev, id, mask, timeptr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_alarm_get_time(dev, id, mask, timeptr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_GET_TIME, rtc_alarm_get_time, dev, id, mask, timeptr); 	syscall__retval = rtc_alarm_get_time(dev, id, mask, timeptr); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_GET_TIME, rtc_alarm_get_time, dev, id, mask, timeptr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_alarm_is_pending(const struct device * dev, uint16_t id);
+
+__pinned_func
+static inline int rtc_alarm_is_pending(const struct device * dev, uint16_t id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_ALARM_IS_PENDING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_alarm_is_pending(dev, id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_alarm_is_pending(dev, id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_IS_PENDING, rtc_alarm_is_pending, dev, id); 	syscall__retval = rtc_alarm_is_pending(dev, id); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_IS_PENDING, rtc_alarm_is_pending, dev, id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_alarm_set_callback(const struct device * dev, uint16_t id, rtc_alarm_callback callback, void * user_data);
+
+__pinned_func
+static inline int rtc_alarm_set_callback(const struct device * dev, uint16_t id, rtc_alarm_callback callback, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = id };
+		union { uintptr_t x; rtc_alarm_callback val; } parm2 = { .val = callback };
+		union { uintptr_t x; void * val; } parm3 = { .val = user_data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTC_ALARM_SET_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_alarm_set_callback(dev, id, callback, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_alarm_set_callback(dev, id, callback, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_ALARM_SET_CALLBACK, rtc_alarm_set_callback, dev, id, callback, user_data); 	syscall__retval = rtc_alarm_set_callback(dev, id, callback, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_ALARM_SET_CALLBACK, rtc_alarm_set_callback, dev, id, callback, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_update_set_callback(const struct device * dev, rtc_update_callback callback, void * user_data);
+
+__pinned_func
+static inline int rtc_update_set_callback(const struct device * dev, rtc_update_callback callback, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; rtc_update_callback val; } parm1 = { .val = callback };
+		union { uintptr_t x; void * val; } parm2 = { .val = user_data };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RTC_UPDATE_SET_CALLBACK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_update_set_callback(dev, callback, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_update_set_callback(dev, callback, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_UPDATE_SET_CALLBACK, rtc_update_set_callback, dev, callback, user_data); 	syscall__retval = rtc_update_set_callback(dev, callback, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_UPDATE_SET_CALLBACK, rtc_update_set_callback, dev, callback, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_set_calibration(const struct device * dev, int32_t calibration);
+
+__pinned_func
+static inline int rtc_set_calibration(const struct device * dev, int32_t calibration)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int32_t val; } parm1 = { .val = calibration };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_SET_CALIBRATION);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_set_calibration(dev, calibration);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_set_calibration(dev, calibration) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_SET_CALIBRATION, rtc_set_calibration, dev, calibration); 	syscall__retval = rtc_set_calibration(dev, calibration); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_SET_CALIBRATION, rtc_set_calibration, dev, calibration, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtc_get_calibration(const struct device * dev, int32_t * calibration);
+
+__pinned_func
+static inline int rtc_get_calibration(const struct device * dev, int32_t * calibration)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int32_t * val; } parm1 = { .val = calibration };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTC_GET_CALIBRATION);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtc_get_calibration(dev, calibration);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtc_get_calibration(dev, calibration) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTC_GET_CALIBRATION, rtc_get_calibration, dev, calibration); 	syscall__retval = rtc_get_calibration(dev, calibration); 	sys_port_trace_syscall_exit(K_SYSCALL_RTC_GET_CALIBRATION, rtc_get_calibration, dev, calibration, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/rtio.h b/nrfdemo/build/zephyr/include/generated/syscalls/rtio.h
new file mode 100644
index 0000000..2f53a5f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/rtio.h
@@ -0,0 +1,179 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_RTIO_H
+#define Z_INCLUDE_SYSCALLS_RTIO_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_rtio_cqe_get_mempool_buffer(const struct rtio * r, struct rtio_cqe * cqe, uint8_t ** buff, uint32_t * buff_len);
+
+__pinned_func
+static inline int rtio_cqe_get_mempool_buffer(const struct rtio * r, struct rtio_cqe * cqe, uint8_t ** buff, uint32_t * buff_len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct rtio * val; } parm0 = { .val = r };
+		union { uintptr_t x; struct rtio_cqe * val; } parm1 = { .val = cqe };
+		union { uintptr_t x; uint8_t ** val; } parm2 = { .val = buff };
+		union { uintptr_t x; uint32_t * val; } parm3 = { .val = buff_len };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER, rtio_cqe_get_mempool_buffer, r, cqe, buff, buff_len); 	syscall__retval = rtio_cqe_get_mempool_buffer(r, cqe, buff, buff_len); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_CQE_GET_MEMPOOL_BUFFER, rtio_cqe_get_mempool_buffer, r, cqe, buff, buff_len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_rtio_release_buffer(struct rtio * r, void * buff, uint32_t buff_len);
+
+__pinned_func
+static inline void rtio_release_buffer(struct rtio * r, void * buff, uint32_t buff_len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
+		union { uintptr_t x; void * val; } parm1 = { .val = buff };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = buff_len };
+		(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_RTIO_RELEASE_BUFFER);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_rtio_release_buffer(r, buff, buff_len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_release_buffer(r, buff, buff_len) do { 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_RELEASE_BUFFER, rtio_release_buffer, r, buff, buff_len); 	rtio_release_buffer(r, buff, buff_len); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_RELEASE_BUFFER, rtio_release_buffer, r, buff, buff_len); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_rtio_sqe_cancel(struct rtio_sqe * sqe);
+
+__pinned_func
+static inline int rtio_sqe_cancel(struct rtio_sqe * sqe)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio_sqe * val; } parm0 = { .val = sqe };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_RTIO_SQE_CANCEL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtio_sqe_cancel(sqe);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_sqe_cancel(sqe) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SQE_CANCEL, rtio_sqe_cancel, sqe); 	syscall__retval = rtio_sqe_cancel(sqe); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SQE_CANCEL, rtio_sqe_cancel, sqe, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtio_sqe_copy_in_get_handles(struct rtio * r, const struct rtio_sqe * sqes, struct rtio_sqe ** handle, size_t sqe_count);
+
+__pinned_func
+static inline int rtio_sqe_copy_in_get_handles(struct rtio * r, const struct rtio_sqe * sqes, struct rtio_sqe ** handle, size_t sqe_count)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
+		union { uintptr_t x; const struct rtio_sqe * val; } parm1 = { .val = sqes };
+		union { uintptr_t x; struct rtio_sqe ** val; } parm2 = { .val = handle };
+		union { uintptr_t x; size_t val; } parm3 = { .val = sqe_count };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES, rtio_sqe_copy_in_get_handles, r, sqes, handle, sqe_count); 	syscall__retval = rtio_sqe_copy_in_get_handles(r, sqes, handle, sqe_count); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SQE_COPY_IN_GET_HANDLES, rtio_sqe_copy_in_get_handles, r, sqes, handle, sqe_count, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtio_cqe_copy_out(struct rtio * r, struct rtio_cqe * cqes, size_t cqe_count, k_timeout_t timeout);
+
+__pinned_func
+static inline int rtio_cqe_copy_out(struct rtio * r, struct rtio_cqe * cqes, size_t cqe_count, k_timeout_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
+		union { uintptr_t x; struct rtio_cqe * val; } parm1 = { .val = cqes };
+		union { uintptr_t x; size_t val; } parm2 = { .val = cqe_count };
+		union { struct { uintptr_t lo, hi; } split; k_timeout_t val; } parm3 = { .val = timeout };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.split.lo, parm3.split.hi, K_SYSCALL_RTIO_CQE_COPY_OUT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtio_cqe_copy_out(r, cqes, cqe_count, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_cqe_copy_out(r, cqes, cqe_count, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_CQE_COPY_OUT, rtio_cqe_copy_out, r, cqes, cqe_count, timeout); 	syscall__retval = rtio_cqe_copy_out(r, cqes, cqe_count, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_CQE_COPY_OUT, rtio_cqe_copy_out, r, cqes, cqe_count, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_rtio_submit(struct rtio * r, uint32_t wait_count);
+
+__pinned_func
+static inline int rtio_submit(struct rtio * r, uint32_t wait_count)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio * val; } parm0 = { .val = r };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = wait_count };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_RTIO_SUBMIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_rtio_submit(r, wait_count);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define rtio_submit(r, wait_count) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_RTIO_SUBMIT, rtio_submit, r, wait_count); 	syscall__retval = rtio_submit(r, wait_count); 	sys_port_trace_syscall_exit(K_SYSCALL_RTIO_SUBMIT, rtio_submit, r, wait_count, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/sdhc.h b/nrfdemo/build/zephyr/include/generated/syscalls/sdhc.h
new file mode 100644
index 0000000..fe27319
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/sdhc.h
@@ -0,0 +1,243 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SDHC_H
+#define Z_INCLUDE_SYSCALLS_SDHC_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_sdhc_hw_reset(const struct device * dev);
+
+__pinned_func
+static inline int sdhc_hw_reset(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_SDHC_HW_RESET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_hw_reset(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_hw_reset(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_HW_RESET, sdhc_hw_reset, dev); 	syscall__retval = sdhc_hw_reset(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_HW_RESET, sdhc_hw_reset, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_request(const struct device * dev, struct sdhc_command * cmd, struct sdhc_data * data);
+
+__pinned_func
+static inline int sdhc_request(const struct device * dev, struct sdhc_command * cmd, struct sdhc_data * data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct sdhc_command * val; } parm1 = { .val = cmd };
+		union { uintptr_t x; struct sdhc_data * val; } parm2 = { .val = data };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SDHC_REQUEST);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_request(dev, cmd, data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_request(dev, cmd, data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_REQUEST, sdhc_request, dev, cmd, data); 	syscall__retval = sdhc_request(dev, cmd, data); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_REQUEST, sdhc_request, dev, cmd, data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_set_io(const struct device * dev, struct sdhc_io * io);
+
+__pinned_func
+static inline int sdhc_set_io(const struct device * dev, struct sdhc_io * io)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct sdhc_io * val; } parm1 = { .val = io };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_SET_IO);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_set_io(dev, io);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_set_io(dev, io) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_SET_IO, sdhc_set_io, dev, io); 	syscall__retval = sdhc_set_io(dev, io); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_SET_IO, sdhc_set_io, dev, io, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_card_present(const struct device * dev);
+
+__pinned_func
+static inline int sdhc_card_present(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_SDHC_CARD_PRESENT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_card_present(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_card_present(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_CARD_PRESENT, sdhc_card_present, dev); 	syscall__retval = sdhc_card_present(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_CARD_PRESENT, sdhc_card_present, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_execute_tuning(const struct device * dev);
+
+__pinned_func
+static inline int sdhc_execute_tuning(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_SDHC_EXECUTE_TUNING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_execute_tuning(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_execute_tuning(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_EXECUTE_TUNING, sdhc_execute_tuning, dev); 	syscall__retval = sdhc_execute_tuning(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_EXECUTE_TUNING, sdhc_execute_tuning, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_card_busy(const struct device * dev);
+
+__pinned_func
+static inline int sdhc_card_busy(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_SDHC_CARD_BUSY);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_card_busy(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_card_busy(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_CARD_BUSY, sdhc_card_busy, dev); 	syscall__retval = sdhc_card_busy(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_CARD_BUSY, sdhc_card_busy, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_get_host_props(const struct device * dev, struct sdhc_host_props * props);
+
+__pinned_func
+static inline int sdhc_get_host_props(const struct device * dev, struct sdhc_host_props * props)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct sdhc_host_props * val; } parm1 = { .val = props };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_GET_HOST_PROPS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_get_host_props(dev, props);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_get_host_props(dev, props) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_GET_HOST_PROPS, sdhc_get_host_props, dev, props); 	syscall__retval = sdhc_get_host_props(dev, props); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_GET_HOST_PROPS, sdhc_get_host_props, dev, props, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_enable_interrupt(const struct device * dev, sdhc_interrupt_cb_t callback, int sources, void * user_data);
+
+__pinned_func
+static inline int sdhc_enable_interrupt(const struct device * dev, sdhc_interrupt_cb_t callback, int sources, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; sdhc_interrupt_cb_t val; } parm1 = { .val = callback };
+		union { uintptr_t x; int val; } parm2 = { .val = sources };
+		union { uintptr_t x; void * val; } parm3 = { .val = user_data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SDHC_ENABLE_INTERRUPT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_enable_interrupt(dev, callback, sources, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_enable_interrupt(dev, callback, sources, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_ENABLE_INTERRUPT, sdhc_enable_interrupt, dev, callback, sources, user_data); 	syscall__retval = sdhc_enable_interrupt(dev, callback, sources, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_ENABLE_INTERRUPT, sdhc_enable_interrupt, dev, callback, sources, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sdhc_disable_interrupt(const struct device * dev, int sources);
+
+__pinned_func
+static inline int sdhc_disable_interrupt(const struct device * dev, int sources)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int val; } parm1 = { .val = sources };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SDHC_DISABLE_INTERRUPT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sdhc_disable_interrupt(dev, sources);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sdhc_disable_interrupt(dev, sources) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SDHC_DISABLE_INTERRUPT, sdhc_disable_interrupt, dev, sources); 	syscall__retval = sdhc_disable_interrupt(dev, sources); 	sys_port_trace_syscall_exit(K_SYSCALL_SDHC_DISABLE_INTERRUPT, sdhc_disable_interrupt, dev, sources, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/sensor.h b/nrfdemo/build/zephyr/include/generated/syscalls/sensor.h
new file mode 100644
index 0000000..0837868
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/sensor.h
@@ -0,0 +1,202 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SENSOR_H
+#define Z_INCLUDE_SYSCALLS_SENSOR_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_sensor_attr_set(const struct device * dev, enum sensor_channel chan, enum sensor_attribute attr, const struct sensor_value * val);
+
+__pinned_func
+static inline int sensor_attr_set(const struct device * dev, enum sensor_channel chan, enum sensor_attribute attr, const struct sensor_value * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum sensor_channel val; } parm1 = { .val = chan };
+		union { uintptr_t x; enum sensor_attribute val; } parm2 = { .val = attr };
+		union { uintptr_t x; const struct sensor_value * val; } parm3 = { .val = val };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SENSOR_ATTR_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_attr_set(dev, chan, attr, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_attr_set(dev, chan, attr, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_ATTR_SET, sensor_attr_set, dev, chan, attr, val); 	syscall__retval = sensor_attr_set(dev, chan, attr, val); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_ATTR_SET, sensor_attr_set, dev, chan, attr, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_attr_get(const struct device * dev, enum sensor_channel chan, enum sensor_attribute attr, struct sensor_value * val);
+
+__pinned_func
+static inline int sensor_attr_get(const struct device * dev, enum sensor_channel chan, enum sensor_attribute attr, struct sensor_value * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum sensor_channel val; } parm1 = { .val = chan };
+		union { uintptr_t x; enum sensor_attribute val; } parm2 = { .val = attr };
+		union { uintptr_t x; struct sensor_value * val; } parm3 = { .val = val };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SENSOR_ATTR_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_attr_get(dev, chan, attr, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_attr_get(dev, chan, attr, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_ATTR_GET, sensor_attr_get, dev, chan, attr, val); 	syscall__retval = sensor_attr_get(dev, chan, attr, val); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_ATTR_GET, sensor_attr_get, dev, chan, attr, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_sample_fetch(const struct device * dev);
+
+__pinned_func
+static inline int sensor_sample_fetch(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_SENSOR_SAMPLE_FETCH);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_sample_fetch(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_sample_fetch(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_SAMPLE_FETCH, sensor_sample_fetch, dev); 	syscall__retval = sensor_sample_fetch(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_SAMPLE_FETCH, sensor_sample_fetch, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_sample_fetch_chan(const struct device * dev, enum sensor_channel type);
+
+__pinned_func
+static inline int sensor_sample_fetch_chan(const struct device * dev, enum sensor_channel type)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum sensor_channel val; } parm1 = { .val = type };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_sample_fetch_chan(dev, type);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_sample_fetch_chan(dev, type) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN, sensor_sample_fetch_chan, dev, type); 	syscall__retval = sensor_sample_fetch_chan(dev, type); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_SAMPLE_FETCH_CHAN, sensor_sample_fetch_chan, dev, type, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_channel_get(const struct device * dev, enum sensor_channel chan, struct sensor_value * val);
+
+__pinned_func
+static inline int sensor_channel_get(const struct device * dev, enum sensor_channel chan, struct sensor_value * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum sensor_channel val; } parm1 = { .val = chan };
+		union { uintptr_t x; struct sensor_value * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SENSOR_CHANNEL_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_channel_get(dev, chan, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_channel_get(dev, chan, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_CHANNEL_GET, sensor_channel_get, dev, chan, val); 	syscall__retval = sensor_channel_get(dev, chan, val); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_CHANNEL_GET, sensor_channel_get, dev, chan, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_get_decoder(const struct device * dev, const struct sensor_decoder_api ** decoder);
+
+__pinned_func
+static inline int sensor_get_decoder(const struct device * dev, const struct sensor_decoder_api ** decoder)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct sensor_decoder_api ** val; } parm1 = { .val = decoder };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SENSOR_GET_DECODER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_get_decoder(dev, decoder);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_get_decoder(dev, decoder) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_GET_DECODER, sensor_get_decoder, dev, decoder); 	syscall__retval = sensor_get_decoder(dev, decoder); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_GET_DECODER, sensor_get_decoder, dev, decoder, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sensor_reconfigure_read_iodev(struct rtio_iodev * iodev, const struct device * sensor, const struct sensor_chan_spec * channels, size_t num_channels);
+
+__pinned_func
+static inline int sensor_reconfigure_read_iodev(struct rtio_iodev * iodev, const struct device * sensor, const struct sensor_chan_spec * channels, size_t num_channels)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct rtio_iodev * val; } parm0 = { .val = iodev };
+		union { uintptr_t x; const struct device * val; } parm1 = { .val = sensor };
+		union { uintptr_t x; const struct sensor_chan_spec * val; } parm2 = { .val = channels };
+		union { uintptr_t x; size_t val; } parm3 = { .val = num_channels };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sensor_reconfigure_read_iodev(iodev, sensor, channels, num_channels);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sensor_reconfigure_read_iodev(iodev, sensor, channels, num_channels) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV, sensor_reconfigure_read_iodev, iodev, sensor, channels, num_channels); 	syscall__retval = sensor_reconfigure_read_iodev(iodev, sensor, channels, num_channels); 	sys_port_trace_syscall_exit(K_SYSCALL_SENSOR_RECONFIGURE_READ_IODEV, sensor_reconfigure_read_iodev, iodev, sensor, channels, num_channels, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/sip_svc_driver.h b/nrfdemo/build/zephyr/include/generated/syscalls/sip_svc_driver.h
new file mode 100644
index 0000000..e4004ed
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/sip_svc_driver.h
@@ -0,0 +1,285 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SIP_SVC_DRIVER_H
+#define Z_INCLUDE_SYSCALLS_SIP_SVC_DRIVER_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_sip_supervisory_call(const struct device * dev, unsigned long function_id, unsigned long arg0, unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6, struct arm_smccc_res * res);
+
+__pinned_func
+static inline void sip_supervisory_call(const struct device * dev, unsigned long function_id, unsigned long arg0, unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6, struct arm_smccc_res * res)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; unsigned long val; } parm1 = { .val = function_id };
+		union { uintptr_t x; unsigned long val; } parm2 = { .val = arg0 };
+		union { uintptr_t x; unsigned long val; } parm3 = { .val = arg1 };
+		union { uintptr_t x; unsigned long val; } parm4 = { .val = arg2 };
+		union { uintptr_t x; unsigned long val; } parm5 = { .val = arg3 };
+		union { uintptr_t x; unsigned long val; } parm6 = { .val = arg4 };
+		union { uintptr_t x; unsigned long val; } parm7 = { .val = arg5 };
+		union { uintptr_t x; unsigned long val; } parm8 = { .val = arg6 };
+		union { uintptr_t x; struct arm_smccc_res * val; } parm9 = { .val = res };
+		uintptr_t more[] = {
+			parm5.x,
+			parm6.x,
+			parm7.x,
+			parm8.x,
+			parm9.x
+		};
+		(void) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_SIP_SUPERVISORY_CALL);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_sip_supervisory_call(dev, function_id, arg0, arg1, arg2, arg3, arg4, arg5, arg6, res);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_supervisory_call(dev, function_id, arg0, arg1, arg2, arg3, arg4, arg5, arg6, res) do { 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SUPERVISORY_CALL, sip_supervisory_call, dev, function_id, arg0, arg1, arg2, arg3, arg4, arg5, arg6, res); 	sip_supervisory_call(dev, function_id, arg0, arg1, arg2, arg3, arg4, arg5, arg6, res); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SUPERVISORY_CALL, sip_supervisory_call, dev, function_id, arg0, arg1, arg2, arg3, arg4, arg5, arg6, res); } while(false)
+#endif
+#endif
+
+
+extern bool z_impl_sip_svc_plat_func_id_valid(const struct device * dev, uint32_t command, uint32_t func_id);
+
+__pinned_func
+static inline bool sip_svc_plat_func_id_valid(const struct device * dev, uint32_t command, uint32_t func_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = command };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = func_id };
+		return (bool) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_func_id_valid(dev, command, func_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_func_id_valid(dev, command, func_id) ({ 	bool syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID, sip_svc_plat_func_id_valid, dev, command, func_id); 	syscall__retval = sip_svc_plat_func_id_valid(dev, command, func_id); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_FUNC_ID_VALID, sip_svc_plat_func_id_valid, dev, command, func_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_sip_svc_plat_format_trans_id(const struct device * dev, uint32_t client_idx, uint32_t trans_idx);
+
+__pinned_func
+static inline uint32_t sip_svc_plat_format_trans_id(const struct device * dev, uint32_t client_idx, uint32_t trans_idx)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = client_idx };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = trans_idx };
+		return (uint32_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_format_trans_id(dev, client_idx, trans_idx);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_format_trans_id(dev, client_idx, trans_idx) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID, sip_svc_plat_format_trans_id, dev, client_idx, trans_idx); 	syscall__retval = sip_svc_plat_format_trans_id(dev, client_idx, trans_idx); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_FORMAT_TRANS_ID, sip_svc_plat_format_trans_id, dev, client_idx, trans_idx, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern uint32_t z_impl_sip_svc_plat_get_trans_idx(const struct device * dev, uint32_t trans_id);
+
+__pinned_func
+static inline uint32_t sip_svc_plat_get_trans_idx(const struct device * dev, uint32_t trans_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = trans_id };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_get_trans_idx(dev, trans_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_get_trans_idx(dev, trans_id) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX, sip_svc_plat_get_trans_idx, dev, trans_id); 	syscall__retval = sip_svc_plat_get_trans_idx(dev, trans_id); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_GET_TRANS_IDX, sip_svc_plat_get_trans_idx, dev, trans_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_sip_svc_plat_update_trans_id(const struct device * dev, struct sip_svc_request * request, uint32_t trans_id);
+
+__pinned_func
+static inline void sip_svc_plat_update_trans_id(const struct device * dev, struct sip_svc_request * request, uint32_t trans_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct sip_svc_request * val; } parm1 = { .val = request };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = trans_id };
+		(void) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_sip_svc_plat_update_trans_id(dev, request, trans_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_update_trans_id(dev, request, trans_id) do { 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID, sip_svc_plat_update_trans_id, dev, request, trans_id); 	sip_svc_plat_update_trans_id(dev, request, trans_id); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_UPDATE_TRANS_ID, sip_svc_plat_update_trans_id, dev, request, trans_id); } while(false)
+#endif
+#endif
+
+
+extern uint32_t z_impl_sip_svc_plat_get_error_code(const struct device * dev, struct arm_smccc_res * res);
+
+__pinned_func
+static inline uint32_t sip_svc_plat_get_error_code(const struct device * dev, struct arm_smccc_res * res)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct arm_smccc_res * val; } parm1 = { .val = res };
+		return (uint32_t) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_get_error_code(dev, res);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_get_error_code(dev, res) ({ 	uint32_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE, sip_svc_plat_get_error_code, dev, res); 	syscall__retval = sip_svc_plat_get_error_code(dev, res); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_GET_ERROR_CODE, sip_svc_plat_get_error_code, dev, res, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sip_svc_plat_async_res_req(const struct device * dev, unsigned long * a0, unsigned long * a1, unsigned long * a2, unsigned long * a3, unsigned long * a4, unsigned long * a5, unsigned long * a6, unsigned long * a7, char * buf, size_t size);
+
+__pinned_func
+static inline int sip_svc_plat_async_res_req(const struct device * dev, unsigned long * a0, unsigned long * a1, unsigned long * a2, unsigned long * a3, unsigned long * a4, unsigned long * a5, unsigned long * a6, unsigned long * a7, char * buf, size_t size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; unsigned long * val; } parm1 = { .val = a0 };
+		union { uintptr_t x; unsigned long * val; } parm2 = { .val = a1 };
+		union { uintptr_t x; unsigned long * val; } parm3 = { .val = a2 };
+		union { uintptr_t x; unsigned long * val; } parm4 = { .val = a3 };
+		union { uintptr_t x; unsigned long * val; } parm5 = { .val = a4 };
+		union { uintptr_t x; unsigned long * val; } parm6 = { .val = a5 };
+		union { uintptr_t x; unsigned long * val; } parm7 = { .val = a6 };
+		union { uintptr_t x; unsigned long * val; } parm8 = { .val = a7 };
+		union { uintptr_t x; char * val; } parm9 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm10 = { .val = size };
+		uintptr_t more[] = {
+			parm5.x,
+			parm6.x,
+			parm7.x,
+			parm8.x,
+			parm9.x,
+			parm10.x
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_async_res_req(dev, a0, a1, a2, a3, a4, a5, a6, a7, buf, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_async_res_req(dev, a0, a1, a2, a3, a4, a5, a6, a7, buf, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ, sip_svc_plat_async_res_req, dev, a0, a1, a2, a3, a4, a5, a6, a7, buf, size); 	syscall__retval = sip_svc_plat_async_res_req(dev, a0, a1, a2, a3, a4, a5, a6, a7, buf, size); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_REQ, sip_svc_plat_async_res_req, dev, a0, a1, a2, a3, a4, a5, a6, a7, buf, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_sip_svc_plat_async_res_res(const struct device * dev, struct arm_smccc_res * res, char * buf, size_t * size, uint32_t * trans_id);
+
+__pinned_func
+static inline int sip_svc_plat_async_res_res(const struct device * dev, struct arm_smccc_res * res, char * buf, size_t * size, uint32_t * trans_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct arm_smccc_res * val; } parm1 = { .val = res };
+		union { uintptr_t x; char * val; } parm2 = { .val = buf };
+		union { uintptr_t x; size_t * val; } parm3 = { .val = size };
+		union { uintptr_t x; uint32_t * val; } parm4 = { .val = trans_id };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sip_svc_plat_async_res_res(dev, res, buf, size, trans_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_async_res_res(dev, res, buf, size, trans_id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES, sip_svc_plat_async_res_res, dev, res, buf, size, trans_id); 	syscall__retval = sip_svc_plat_async_res_res(dev, res, buf, size, trans_id); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_ASYNC_RES_RES, sip_svc_plat_async_res_res, dev, res, buf, size, trans_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_sip_svc_plat_free_async_memory(const struct device * dev, struct sip_svc_request * request);
+
+__pinned_func
+static inline void sip_svc_plat_free_async_memory(const struct device * dev, struct sip_svc_request * request)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct sip_svc_request * val; } parm1 = { .val = request };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_sip_svc_plat_free_async_memory(dev, request);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sip_svc_plat_free_async_memory(dev, request) do { 	sys_port_trace_syscall_enter(K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY, sip_svc_plat_free_async_memory, dev, request); 	sip_svc_plat_free_async_memory(dev, request); 	sys_port_trace_syscall_exit(K_SYSCALL_SIP_SVC_PLAT_FREE_ASYNC_MEMORY, sip_svc_plat_free_async_memory, dev, request); } while(false)
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/smbus.h b/nrfdemo/build/zephyr/include/generated/syscalls/smbus.h
new file mode 100644
index 0000000..9fbabbd
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/smbus.h
@@ -0,0 +1,417 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SMBUS_H
+#define Z_INCLUDE_SYSCALLS_SMBUS_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_smbus_configure(const struct device * dev, uint32_t dev_config);
+
+__pinned_func
+static inline int smbus_configure(const struct device * dev, uint32_t dev_config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = dev_config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SMBUS_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_configure(dev, dev_config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_configure(dev, dev_config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_CONFIGURE, smbus_configure, dev, dev_config); 	syscall__retval = smbus_configure(dev, dev_config); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_CONFIGURE, smbus_configure, dev, dev_config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_get_config(const struct device * dev, uint32_t * dev_config);
+
+__pinned_func
+static inline int smbus_get_config(const struct device * dev, uint32_t * dev_config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = dev_config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SMBUS_GET_CONFIG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_get_config(dev, dev_config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_get_config(dev, dev_config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_GET_CONFIG, smbus_get_config, dev, dev_config); 	syscall__retval = smbus_get_config(dev, dev_config); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_GET_CONFIG, smbus_get_config, dev, dev_config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_smbalert_remove_cb(const struct device * dev, struct smbus_callback * cb);
+
+__pinned_func
+static inline int smbus_smbalert_remove_cb(const struct device * dev, struct smbus_callback * cb)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct smbus_callback * val; } parm1 = { .val = cb };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_smbalert_remove_cb(dev, cb);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_smbalert_remove_cb(dev, cb) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB, smbus_smbalert_remove_cb, dev, cb); 	syscall__retval = smbus_smbalert_remove_cb(dev, cb); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_SMBALERT_REMOVE_CB, smbus_smbalert_remove_cb, dev, cb, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_host_notify_remove_cb(const struct device * dev, struct smbus_callback * cb);
+
+__pinned_func
+static inline int smbus_host_notify_remove_cb(const struct device * dev, struct smbus_callback * cb)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct smbus_callback * val; } parm1 = { .val = cb };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_host_notify_remove_cb(dev, cb);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_host_notify_remove_cb(dev, cb) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB, smbus_host_notify_remove_cb, dev, cb); 	syscall__retval = smbus_host_notify_remove_cb(dev, cb); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_HOST_NOTIFY_REMOVE_CB, smbus_host_notify_remove_cb, dev, cb, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_quick(const struct device * dev, uint16_t addr, enum smbus_direction direction);
+
+__pinned_func
+static inline int smbus_quick(const struct device * dev, uint16_t addr, enum smbus_direction direction)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; enum smbus_direction val; } parm2 = { .val = direction };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SMBUS_QUICK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_quick(dev, addr, direction);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_quick(dev, addr, direction) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_QUICK, smbus_quick, dev, addr, direction); 	syscall__retval = smbus_quick(dev, addr, direction); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_QUICK, smbus_quick, dev, addr, direction, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_byte_write(const struct device * dev, uint16_t addr, uint8_t byte);
+
+__pinned_func
+static inline int smbus_byte_write(const struct device * dev, uint16_t addr, uint8_t byte)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = byte };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SMBUS_BYTE_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_byte_write(dev, addr, byte);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_byte_write(dev, addr, byte) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BYTE_WRITE, smbus_byte_write, dev, addr, byte); 	syscall__retval = smbus_byte_write(dev, addr, byte); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BYTE_WRITE, smbus_byte_write, dev, addr, byte, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_byte_read(const struct device * dev, uint16_t addr, uint8_t * byte);
+
+__pinned_func
+static inline int smbus_byte_read(const struct device * dev, uint16_t addr, uint8_t * byte)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t * val; } parm2 = { .val = byte };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SMBUS_BYTE_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_byte_read(dev, addr, byte);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_byte_read(dev, addr, byte) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BYTE_READ, smbus_byte_read, dev, addr, byte); 	syscall__retval = smbus_byte_read(dev, addr, byte); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BYTE_READ, smbus_byte_read, dev, addr, byte, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_byte_data_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t byte);
+
+__pinned_func
+static inline int smbus_byte_data_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t byte)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint8_t val; } parm3 = { .val = byte };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SMBUS_BYTE_DATA_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_byte_data_write(dev, addr, cmd, byte);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_byte_data_write(dev, addr, cmd, byte) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BYTE_DATA_WRITE, smbus_byte_data_write, dev, addr, cmd, byte); 	syscall__retval = smbus_byte_data_write(dev, addr, cmd, byte); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BYTE_DATA_WRITE, smbus_byte_data_write, dev, addr, cmd, byte, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_byte_data_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t * byte);
+
+__pinned_func
+static inline int smbus_byte_data_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t * byte)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint8_t * val; } parm3 = { .val = byte };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SMBUS_BYTE_DATA_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_byte_data_read(dev, addr, cmd, byte);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_byte_data_read(dev, addr, cmd, byte) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BYTE_DATA_READ, smbus_byte_data_read, dev, addr, cmd, byte); 	syscall__retval = smbus_byte_data_read(dev, addr, cmd, byte); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BYTE_DATA_READ, smbus_byte_data_read, dev, addr, cmd, byte, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_word_data_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t word);
+
+__pinned_func
+static inline int smbus_word_data_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t word)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = word };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SMBUS_WORD_DATA_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_word_data_write(dev, addr, cmd, word);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_word_data_write(dev, addr, cmd, word) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_WORD_DATA_WRITE, smbus_word_data_write, dev, addr, cmd, word); 	syscall__retval = smbus_word_data_write(dev, addr, cmd, word); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_WORD_DATA_WRITE, smbus_word_data_write, dev, addr, cmd, word, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_word_data_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t * word);
+
+__pinned_func
+static inline int smbus_word_data_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t * word)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint16_t * val; } parm3 = { .val = word };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SMBUS_WORD_DATA_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_word_data_read(dev, addr, cmd, word);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_word_data_read(dev, addr, cmd, word) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_WORD_DATA_READ, smbus_word_data_read, dev, addr, cmd, word); 	syscall__retval = smbus_word_data_read(dev, addr, cmd, word); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_WORD_DATA_READ, smbus_word_data_read, dev, addr, cmd, word, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_pcall(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t send_word, uint16_t * recv_word);
+
+__pinned_func
+static inline int smbus_pcall(const struct device * dev, uint16_t addr, uint8_t cmd, uint16_t send_word, uint16_t * recv_word)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint16_t val; } parm3 = { .val = send_word };
+		union { uintptr_t x; uint16_t * val; } parm4 = { .val = recv_word };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_SMBUS_PCALL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_pcall(dev, addr, cmd, send_word, recv_word);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_pcall(dev, addr, cmd, send_word, recv_word) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_PCALL, smbus_pcall, dev, addr, cmd, send_word, recv_word); 	syscall__retval = smbus_pcall(dev, addr, cmd, send_word, recv_word); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_PCALL, smbus_pcall, dev, addr, cmd, send_word, recv_word, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_block_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t count, uint8_t * buf);
+
+__pinned_func
+static inline int smbus_block_write(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t count, uint8_t * buf)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint8_t val; } parm3 = { .val = count };
+		union { uintptr_t x; uint8_t * val; } parm4 = { .val = buf };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_SMBUS_BLOCK_WRITE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_block_write(dev, addr, cmd, count, buf);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_block_write(dev, addr, cmd, count, buf) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BLOCK_WRITE, smbus_block_write, dev, addr, cmd, count, buf); 	syscall__retval = smbus_block_write(dev, addr, cmd, count, buf); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BLOCK_WRITE, smbus_block_write, dev, addr, cmd, count, buf, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_block_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t * count, uint8_t * buf);
+
+__pinned_func
+static inline int smbus_block_read(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t * count, uint8_t * buf)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint8_t * val; } parm3 = { .val = count };
+		union { uintptr_t x; uint8_t * val; } parm4 = { .val = buf };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_SMBUS_BLOCK_READ);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_block_read(dev, addr, cmd, count, buf);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_block_read(dev, addr, cmd, count, buf) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BLOCK_READ, smbus_block_read, dev, addr, cmd, count, buf); 	syscall__retval = smbus_block_read(dev, addr, cmd, count, buf); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BLOCK_READ, smbus_block_read, dev, addr, cmd, count, buf, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_smbus_block_pcall(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t snd_count, uint8_t * snd_buf, uint8_t * rcv_count, uint8_t * rcv_buf);
+
+__pinned_func
+static inline int smbus_block_pcall(const struct device * dev, uint16_t addr, uint8_t cmd, uint8_t snd_count, uint8_t * snd_buf, uint8_t * rcv_count, uint8_t * rcv_buf)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = addr };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = cmd };
+		union { uintptr_t x; uint8_t val; } parm3 = { .val = snd_count };
+		union { uintptr_t x; uint8_t * val; } parm4 = { .val = snd_buf };
+		union { uintptr_t x; uint8_t * val; } parm5 = { .val = rcv_count };
+		union { uintptr_t x; uint8_t * val; } parm6 = { .val = rcv_buf };
+		uintptr_t more[] = {
+			parm5.x,
+			parm6.x
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, (uintptr_t) &more, K_SYSCALL_SMBUS_BLOCK_PCALL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_smbus_block_pcall(dev, addr, cmd, snd_count, snd_buf, rcv_count, rcv_buf);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define smbus_block_pcall(dev, addr, cmd, snd_count, snd_buf, rcv_count, rcv_buf) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SMBUS_BLOCK_PCALL, smbus_block_pcall, dev, addr, cmd, snd_count, snd_buf, rcv_count, rcv_buf); 	syscall__retval = smbus_block_pcall(dev, addr, cmd, snd_count, snd_buf, rcv_count, rcv_buf); 	sys_port_trace_syscall_exit(K_SYSCALL_SMBUS_BLOCK_PCALL, smbus_block_pcall, dev, addr, cmd, snd_count, snd_buf, rcv_count, rcv_buf, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/socket.h b/nrfdemo/build/zephyr/include/generated/syscalls/socket.h
new file mode 100644
index 0000000..3623d3c
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/socket.h
@@ -0,0 +1,611 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SOCKET_H
+#define Z_INCLUDE_SYSCALLS_SOCKET_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void * z_impl_zsock_get_context_object(int sock);
+
+__pinned_func
+static inline void * zsock_get_context_object(int sock)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		return (void *) arch_syscall_invoke1(parm0.x, K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_get_context_object(sock);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_get_context_object(sock) ({ 	void * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT, zsock_get_context_object, sock); 	syscall__retval = zsock_get_context_object(sock); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_GET_CONTEXT_OBJECT, zsock_get_context_object, sock, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_socket(int family, int type, int proto);
+
+__pinned_func
+static inline int zsock_socket(int family, int type, int proto)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = family };
+		union { uintptr_t x; int val; } parm1 = { .val = type };
+		union { uintptr_t x; int val; } parm2 = { .val = proto };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_SOCKET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_socket(family, type, proto);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_socket(family, type, proto) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SOCKET, zsock_socket, family, type, proto); 	syscall__retval = zsock_socket(family, type, proto); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SOCKET, zsock_socket, family, type, proto, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_socketpair(int family, int type, int proto, int * sv);
+
+__pinned_func
+static inline int zsock_socketpair(int family, int type, int proto, int * sv)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = family };
+		union { uintptr_t x; int val; } parm1 = { .val = type };
+		union { uintptr_t x; int val; } parm2 = { .val = proto };
+		union { uintptr_t x; int * val; } parm3 = { .val = sv };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_ZSOCK_SOCKETPAIR);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_socketpair(family, type, proto, sv);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_socketpair(family, type, proto, sv) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SOCKETPAIR, zsock_socketpair, family, type, proto, sv); 	syscall__retval = zsock_socketpair(family, type, proto, sv); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SOCKETPAIR, zsock_socketpair, family, type, proto, sv, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_close(int sock);
+
+__pinned_func
+static inline int zsock_close(int sock)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_ZSOCK_CLOSE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_close(sock);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_close(sock) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_CLOSE, zsock_close, sock); 	syscall__retval = zsock_close(sock); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_CLOSE, zsock_close, sock, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_shutdown(int sock, int how);
+
+__pinned_func
+static inline int zsock_shutdown(int sock, int how)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; int val; } parm1 = { .val = how };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZSOCK_SHUTDOWN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_shutdown(sock, how);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_shutdown(sock, how) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SHUTDOWN, zsock_shutdown, sock, how); 	syscall__retval = zsock_shutdown(sock, how); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SHUTDOWN, zsock_shutdown, sock, how, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_bind(int sock, const struct sockaddr * addr, socklen_t addrlen);
+
+__pinned_func
+static inline int zsock_bind(int sock, const struct sockaddr * addr, socklen_t addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; const struct sockaddr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; socklen_t val; } parm2 = { .val = addrlen };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_BIND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_bind(sock, addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_bind(sock, addr, addrlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_BIND, zsock_bind, sock, addr, addrlen); 	syscall__retval = zsock_bind(sock, addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_BIND, zsock_bind, sock, addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_connect(int sock, const struct sockaddr * addr, socklen_t addrlen);
+
+__pinned_func
+static inline int zsock_connect(int sock, const struct sockaddr * addr, socklen_t addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; const struct sockaddr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; socklen_t val; } parm2 = { .val = addrlen };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_CONNECT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_connect(sock, addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_connect(sock, addr, addrlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_CONNECT, zsock_connect, sock, addr, addrlen); 	syscall__retval = zsock_connect(sock, addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_CONNECT, zsock_connect, sock, addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_listen(int sock, int backlog);
+
+__pinned_func
+static inline int zsock_listen(int sock, int backlog)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; int val; } parm1 = { .val = backlog };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZSOCK_LISTEN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_listen(sock, backlog);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_listen(sock, backlog) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_LISTEN, zsock_listen, sock, backlog); 	syscall__retval = zsock_listen(sock, backlog); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_LISTEN, zsock_listen, sock, backlog, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_accept(int sock, struct sockaddr * addr, socklen_t * addrlen);
+
+__pinned_func
+static inline int zsock_accept(int sock, struct sockaddr * addr, socklen_t * addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; struct sockaddr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; socklen_t * val; } parm2 = { .val = addrlen };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_ACCEPT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_accept(sock, addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_accept(sock, addr, addrlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_ACCEPT, zsock_accept, sock, addr, addrlen); 	syscall__retval = zsock_accept(sock, addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_ACCEPT, zsock_accept, sock, addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern ssize_t z_impl_zsock_sendto(int sock, const void * buf, size_t len, int flags, const struct sockaddr * dest_addr, socklen_t addrlen);
+
+__pinned_func
+static inline ssize_t zsock_sendto(int sock, const void * buf, size_t len, int flags, const struct sockaddr * dest_addr, socklen_t addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; const void * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		union { uintptr_t x; int val; } parm3 = { .val = flags };
+		union { uintptr_t x; const struct sockaddr * val; } parm4 = { .val = dest_addr };
+		union { uintptr_t x; socklen_t val; } parm5 = { .val = addrlen };
+		return (ssize_t) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, parm5.x, K_SYSCALL_ZSOCK_SENDTO);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_sendto(sock, buf, len, flags, dest_addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_sendto(sock, buf, len, flags, dest_addr, addrlen) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SENDTO, zsock_sendto, sock, buf, len, flags, dest_addr, addrlen); 	syscall__retval = zsock_sendto(sock, buf, len, flags, dest_addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SENDTO, zsock_sendto, sock, buf, len, flags, dest_addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern ssize_t z_impl_zsock_sendmsg(int sock, const struct msghdr * msg, int flags);
+
+__pinned_func
+static inline ssize_t zsock_sendmsg(int sock, const struct msghdr * msg, int flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; const struct msghdr * val; } parm1 = { .val = msg };
+		union { uintptr_t x; int val; } parm2 = { .val = flags };
+		return (ssize_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_SENDMSG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_sendmsg(sock, msg, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_sendmsg(sock, msg, flags) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SENDMSG, zsock_sendmsg, sock, msg, flags); 	syscall__retval = zsock_sendmsg(sock, msg, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SENDMSG, zsock_sendmsg, sock, msg, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern ssize_t z_impl_zsock_recvfrom(int sock, void * buf, size_t max_len, int flags, struct sockaddr * src_addr, socklen_t * addrlen);
+
+__pinned_func
+static inline ssize_t zsock_recvfrom(int sock, void * buf, size_t max_len, int flags, struct sockaddr * src_addr, socklen_t * addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; void * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = max_len };
+		union { uintptr_t x; int val; } parm3 = { .val = flags };
+		union { uintptr_t x; struct sockaddr * val; } parm4 = { .val = src_addr };
+		union { uintptr_t x; socklen_t * val; } parm5 = { .val = addrlen };
+		return (ssize_t) arch_syscall_invoke6(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, parm5.x, K_SYSCALL_ZSOCK_RECVFROM);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_recvfrom(sock, buf, max_len, flags, src_addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_recvfrom(sock, buf, max_len, flags, src_addr, addrlen) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_RECVFROM, zsock_recvfrom, sock, buf, max_len, flags, src_addr, addrlen); 	syscall__retval = zsock_recvfrom(sock, buf, max_len, flags, src_addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_RECVFROM, zsock_recvfrom, sock, buf, max_len, flags, src_addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern ssize_t z_impl_zsock_recvmsg(int sock, struct msghdr * msg, int flags);
+
+__pinned_func
+static inline ssize_t zsock_recvmsg(int sock, struct msghdr * msg, int flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; struct msghdr * val; } parm1 = { .val = msg };
+		union { uintptr_t x; int val; } parm2 = { .val = flags };
+		return (ssize_t) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_RECVMSG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_recvmsg(sock, msg, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_recvmsg(sock, msg, flags) ({ 	ssize_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_RECVMSG, zsock_recvmsg, sock, msg, flags); 	syscall__retval = zsock_recvmsg(sock, msg, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_RECVMSG, zsock_recvmsg, sock, msg, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_fcntl_impl(int sock, int cmd, int flags);
+
+__pinned_func
+static inline int zsock_fcntl_impl(int sock, int cmd, int flags)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; int val; } parm1 = { .val = cmd };
+		union { uintptr_t x; int val; } parm2 = { .val = flags };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_FCNTL_IMPL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_fcntl_impl(sock, cmd, flags);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_fcntl_impl(sock, cmd, flags) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_FCNTL_IMPL, zsock_fcntl_impl, sock, cmd, flags); 	syscall__retval = zsock_fcntl_impl(sock, cmd, flags); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_FCNTL_IMPL, zsock_fcntl_impl, sock, cmd, flags, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_ioctl_impl(int sock, unsigned long request, va_list ap);
+
+__pinned_func
+static inline int zsock_ioctl_impl(int sock, unsigned long request, va_list ap)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; unsigned long val; } parm1 = { .val = request };
+		union { uintptr_t x; va_list val; } parm2;
+		va_copy(parm2.val, ap);
+		int invoke__retval = arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_IOCTL_IMPL);
+		va_end(parm2.val);
+		return invoke__retval;
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_ioctl_impl(sock, request, ap);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_ioctl_impl(sock, request, ap) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_IOCTL_IMPL, zsock_ioctl_impl, sock, request, ap); 	syscall__retval = zsock_ioctl_impl(sock, request, ap); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_IOCTL_IMPL, zsock_ioctl_impl, sock, request, ap, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_poll(struct zsock_pollfd * fds, int nfds, int timeout);
+
+__pinned_func
+static inline int zsock_poll(struct zsock_pollfd * fds, int nfds, int timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; struct zsock_pollfd * val; } parm0 = { .val = fds };
+		union { uintptr_t x; int val; } parm1 = { .val = nfds };
+		union { uintptr_t x; int val; } parm2 = { .val = timeout };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_POLL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_poll(fds, nfds, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_poll(fds, nfds, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_POLL, zsock_poll, fds, nfds, timeout); 	syscall__retval = zsock_poll(fds, nfds, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_POLL, zsock_poll, fds, nfds, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_getsockopt(int sock, int level, int optname, void * optval, socklen_t * optlen);
+
+__pinned_func
+static inline int zsock_getsockopt(int sock, int level, int optname, void * optval, socklen_t * optlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; int val; } parm1 = { .val = level };
+		union { uintptr_t x; int val; } parm2 = { .val = optname };
+		union { uintptr_t x; void * val; } parm3 = { .val = optval };
+		union { uintptr_t x; socklen_t * val; } parm4 = { .val = optlen };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_ZSOCK_GETSOCKOPT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_getsockopt(sock, level, optname, optval, optlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_getsockopt(sock, level, optname, optval, optlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_GETSOCKOPT, zsock_getsockopt, sock, level, optname, optval, optlen); 	syscall__retval = zsock_getsockopt(sock, level, optname, optval, optlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_GETSOCKOPT, zsock_getsockopt, sock, level, optname, optval, optlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_setsockopt(int sock, int level, int optname, const void * optval, socklen_t optlen);
+
+__pinned_func
+static inline int zsock_setsockopt(int sock, int level, int optname, const void * optval, socklen_t optlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; int val; } parm1 = { .val = level };
+		union { uintptr_t x; int val; } parm2 = { .val = optname };
+		union { uintptr_t x; const void * val; } parm3 = { .val = optval };
+		union { uintptr_t x; socklen_t val; } parm4 = { .val = optlen };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_ZSOCK_SETSOCKOPT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_setsockopt(sock, level, optname, optval, optlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_setsockopt(sock, level, optname, optval, optlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SETSOCKOPT, zsock_setsockopt, sock, level, optname, optval, optlen); 	syscall__retval = zsock_setsockopt(sock, level, optname, optval, optlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SETSOCKOPT, zsock_setsockopt, sock, level, optname, optval, optlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_getpeername(int sock, struct sockaddr * addr, socklen_t * addrlen);
+
+__pinned_func
+static inline int zsock_getpeername(int sock, struct sockaddr * addr, socklen_t * addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; struct sockaddr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; socklen_t * val; } parm2 = { .val = addrlen };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_GETPEERNAME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_getpeername(sock, addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_getpeername(sock, addr, addrlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_GETPEERNAME, zsock_getpeername, sock, addr, addrlen); 	syscall__retval = zsock_getpeername(sock, addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_GETPEERNAME, zsock_getpeername, sock, addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_getsockname(int sock, struct sockaddr * addr, socklen_t * addrlen);
+
+__pinned_func
+static inline int zsock_getsockname(int sock, struct sockaddr * addr, socklen_t * addrlen)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = sock };
+		union { uintptr_t x; struct sockaddr * val; } parm1 = { .val = addr };
+		union { uintptr_t x; socklen_t * val; } parm2 = { .val = addrlen };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_GETSOCKNAME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_getsockname(sock, addr, addrlen);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_getsockname(sock, addr, addrlen) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_GETSOCKNAME, zsock_getsockname, sock, addr, addrlen); 	syscall__retval = zsock_getsockname(sock, addr, addrlen); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_GETSOCKNAME, zsock_getsockname, sock, addr, addrlen, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_gethostname(char * buf, size_t len);
+
+__pinned_func
+static inline int zsock_gethostname(char * buf, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; char * val; } parm0 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm1 = { .val = len };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_ZSOCK_GETHOSTNAME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_gethostname(buf, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_gethostname(buf, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_GETHOSTNAME, zsock_gethostname, buf, len); 	syscall__retval = zsock_gethostname(buf, len); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_GETHOSTNAME, zsock_gethostname, buf, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_zsock_inet_pton(sa_family_t family, const char * src, void * dst);
+
+__pinned_func
+static inline int zsock_inet_pton(sa_family_t family, const char * src, void * dst)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; sa_family_t val; } parm0 = { .val = family };
+		union { uintptr_t x; const char * val; } parm1 = { .val = src };
+		union { uintptr_t x; void * val; } parm2 = { .val = dst };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_ZSOCK_INET_PTON);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_inet_pton(family, src, dst);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_inet_pton(family, src, dst) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_INET_PTON, zsock_inet_pton, family, src, dst); 	syscall__retval = zsock_inet_pton(family, src, dst); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_INET_PTON, zsock_inet_pton, family, src, dst, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_z_zsock_getaddrinfo_internal(const char * host, const char * service, const struct zsock_addrinfo * hints, struct zsock_addrinfo * res);
+
+__pinned_func
+static inline int z_zsock_getaddrinfo_internal(const char * host, const char * service, const struct zsock_addrinfo * hints, struct zsock_addrinfo * res)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const char * val; } parm0 = { .val = host };
+		union { uintptr_t x; const char * val; } parm1 = { .val = service };
+		union { uintptr_t x; const struct zsock_addrinfo * val; } parm2 = { .val = hints };
+		union { uintptr_t x; struct zsock_addrinfo * val; } parm3 = { .val = res };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_z_zsock_getaddrinfo_internal(host, service, hints, res);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define z_zsock_getaddrinfo_internal(host, service, hints, res) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL, z_zsock_getaddrinfo_internal, host, service, hints, res); 	syscall__retval = z_zsock_getaddrinfo_internal(host, service, hints, res); 	sys_port_trace_syscall_exit(K_SYSCALL_Z_ZSOCK_GETADDRINFO_INTERNAL, z_zsock_getaddrinfo_internal, host, service, hints, res, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/socket_select.h b/nrfdemo/build/zephyr/include/generated/syscalls/socket_select.h
new file mode 100644
index 0000000..1ebe088
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/socket_select.h
@@ -0,0 +1,55 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SOCKET_SELECT_H
+#define Z_INCLUDE_SYSCALLS_SOCKET_SELECT_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_zsock_select(int nfds, zsock_fd_set * readfds, zsock_fd_set * writefds, zsock_fd_set * exceptfds, struct zsock_timeval * timeout);
+
+__pinned_func
+static inline int zsock_select(int nfds, zsock_fd_set * readfds, zsock_fd_set * writefds, zsock_fd_set * exceptfds, struct zsock_timeval * timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = nfds };
+		union { uintptr_t x; zsock_fd_set * val; } parm1 = { .val = readfds };
+		union { uintptr_t x; zsock_fd_set * val; } parm2 = { .val = writefds };
+		union { uintptr_t x; zsock_fd_set * val; } parm3 = { .val = exceptfds };
+		union { uintptr_t x; struct zsock_timeval * val; } parm4 = { .val = timeout };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_ZSOCK_SELECT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_zsock_select(nfds, readfds, writefds, exceptfds, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define zsock_select(nfds, readfds, writefds, exceptfds, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_ZSOCK_SELECT, zsock_select, nfds, readfds, writefds, exceptfds, timeout); 	syscall__retval = zsock_select(nfds, readfds, writefds, exceptfds, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_ZSOCK_SELECT, zsock_select, nfds, readfds, writefds, exceptfds, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/socket_service.h b/nrfdemo/build/zephyr/include/generated/syscalls/socket_service.h
new file mode 100644
index 0000000..55fb3a6
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/socket_service.h
@@ -0,0 +1,54 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SOCKET_SERVICE_H
+#define Z_INCLUDE_SYSCALLS_SOCKET_SERVICE_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_net_socket_service_register(const struct net_socket_service_desc * service, struct zsock_pollfd * fds, int len, void * user_data);
+
+__pinned_func
+static inline int net_socket_service_register(const struct net_socket_service_desc * service, struct zsock_pollfd * fds, int len, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct net_socket_service_desc * val; } parm0 = { .val = service };
+		union { uintptr_t x; struct zsock_pollfd * val; } parm1 = { .val = fds };
+		union { uintptr_t x; int val; } parm2 = { .val = len };
+		union { uintptr_t x; void * val; } parm3 = { .val = user_data };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_NET_SOCKET_SERVICE_REGISTER);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_net_socket_service_register(service, fds, len, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define net_socket_service_register(service, fds, len, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_NET_SOCKET_SERVICE_REGISTER, net_socket_service_register, service, fds, len, user_data); 	syscall__retval = net_socket_service_register(service, fds, len, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_NET_SOCKET_SERVICE_REGISTER, net_socket_service_register, service, fds, len, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/spi.h b/nrfdemo/build/zephyr/include/generated/syscalls/spi.h
new file mode 100644
index 0000000..3771ebc
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/spi.h
@@ -0,0 +1,78 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SPI_H
+#define Z_INCLUDE_SYSCALLS_SPI_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_spi_transceive(const struct device * dev, const struct spi_config * config, const struct spi_buf_set * tx_bufs, const struct spi_buf_set * rx_bufs);
+
+__pinned_func
+static inline int spi_transceive(const struct device * dev, const struct spi_config * config, const struct spi_buf_set * tx_bufs, const struct spi_buf_set * rx_bufs)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct spi_config * val; } parm1 = { .val = config };
+		union { uintptr_t x; const struct spi_buf_set * val; } parm2 = { .val = tx_bufs };
+		union { uintptr_t x; const struct spi_buf_set * val; } parm3 = { .val = rx_bufs };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_SPI_TRANSCEIVE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_spi_transceive(dev, config, tx_bufs, rx_bufs);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define spi_transceive(dev, config, tx_bufs, rx_bufs) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SPI_TRANSCEIVE, spi_transceive, dev, config, tx_bufs, rx_bufs); 	syscall__retval = spi_transceive(dev, config, tx_bufs, rx_bufs); 	sys_port_trace_syscall_exit(K_SYSCALL_SPI_TRANSCEIVE, spi_transceive, dev, config, tx_bufs, rx_bufs, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_spi_release(const struct device * dev, const struct spi_config * config);
+
+__pinned_func
+static inline int spi_release(const struct device * dev, const struct spi_config * config)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct spi_config * val; } parm1 = { .val = config };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SPI_RELEASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_spi_release(dev, config);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define spi_release(dev, config) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SPI_RELEASE, spi_release, dev, config); 	syscall__retval = spi_release(dev, config); 	sys_port_trace_syscall_exit(K_SYSCALL_SPI_RELEASE, spi_release, dev, config, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/syscon.h b/nrfdemo/build/zephyr/include/generated/syscalls/syscon.h
new file mode 100644
index 0000000..7d13d74
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/syscon.h
@@ -0,0 +1,126 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_SYSCON_H
+#define Z_INCLUDE_SYSCALLS_SYSCON_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_syscon_get_base(const struct device * dev, uintptr_t * addr);
+
+__pinned_func
+static inline int syscon_get_base(const struct device * dev, uintptr_t * addr)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uintptr_t * val; } parm1 = { .val = addr };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYSCON_GET_BASE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_syscon_get_base(dev, addr);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define syscon_get_base(dev, addr) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYSCON_GET_BASE, syscon_get_base, dev, addr); 	syscall__retval = syscon_get_base(dev, addr); 	sys_port_trace_syscall_exit(K_SYSCALL_SYSCON_GET_BASE, syscon_get_base, dev, addr, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_syscon_read_reg(const struct device * dev, uint16_t reg, uint32_t * val);
+
+__pinned_func
+static inline int syscon_read_reg(const struct device * dev, uint16_t reg, uint32_t * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = reg };
+		union { uintptr_t x; uint32_t * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SYSCON_READ_REG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_syscon_read_reg(dev, reg, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define syscon_read_reg(dev, reg, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYSCON_READ_REG, syscon_read_reg, dev, reg, val); 	syscall__retval = syscon_read_reg(dev, reg, val); 	sys_port_trace_syscall_exit(K_SYSCALL_SYSCON_READ_REG, syscon_read_reg, dev, reg, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_syscon_write_reg(const struct device * dev, uint16_t reg, uint32_t val);
+
+__pinned_func
+static inline int syscon_write_reg(const struct device * dev, uint16_t reg, uint32_t val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = reg };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_SYSCON_WRITE_REG);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_syscon_write_reg(dev, reg, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define syscon_write_reg(dev, reg, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYSCON_WRITE_REG, syscon_write_reg, dev, reg, val); 	syscall__retval = syscon_write_reg(dev, reg, val); 	sys_port_trace_syscall_exit(K_SYSCALL_SYSCON_WRITE_REG, syscon_write_reg, dev, reg, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_syscon_get_size(const struct device * dev, size_t * size);
+
+__pinned_func
+static inline int syscon_get_size(const struct device * dev, size_t * size)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; size_t * val; } parm1 = { .val = size };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_SYSCON_GET_SIZE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_syscon_get_size(dev, size);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define syscon_get_size(dev, size) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYSCON_GET_SIZE, syscon_get_size, dev, size); 	syscall__retval = syscon_get_size(dev, size); 	sys_port_trace_syscall_exit(K_SYSCALL_SYSCON_GET_SIZE, syscon_get_size, dev, size, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/time_units.h b/nrfdemo/build/zephyr/include/generated/syscalls/time_units.h
new file mode 100644
index 0000000..1d94e62
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/time_units.h
@@ -0,0 +1,50 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_TIME_UNITS_H
+#define Z_INCLUDE_SYSCALLS_TIME_UNITS_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_sys_clock_hw_cycles_per_sec_runtime_get(void);
+
+__pinned_func
+static inline int sys_clock_hw_cycles_per_sec_runtime_get(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int) arch_syscall_invoke0(K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_sys_clock_hw_cycles_per_sec_runtime_get();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define sys_clock_hw_cycles_per_sec_runtime_get() ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET, sys_clock_hw_cycles_per_sec_runtime_get); 	syscall__retval = sys_clock_hw_cycles_per_sec_runtime_get(); 	sys_port_trace_syscall_exit(K_SYSCALL_SYS_CLOCK_HW_CYCLES_PER_SEC_RUNTIME_GET, sys_clock_hw_cycles_per_sec_runtime_get, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/timeaware_gpio.h b/nrfdemo/build/zephyr/include/generated/syscalls/timeaware_gpio.h
new file mode 100644
index 0000000..db67411
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/timeaware_gpio.h
@@ -0,0 +1,182 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_TIMEAWARE_GPIO_H
+#define Z_INCLUDE_SYSCALLS_TIMEAWARE_GPIO_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_tgpio_port_get_time(const struct device * dev, uint64_t * current_time);
+
+__pinned_func
+static inline int tgpio_port_get_time(const struct device * dev, uint64_t * current_time)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint64_t * val; } parm1 = { .val = current_time };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_TGPIO_PORT_GET_TIME);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_port_get_time(dev, current_time);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_port_get_time(dev, current_time) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PORT_GET_TIME, tgpio_port_get_time, dev, current_time); 	syscall__retval = tgpio_port_get_time(dev, current_time); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PORT_GET_TIME, tgpio_port_get_time, dev, current_time, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_tgpio_port_get_cycles_per_second(const struct device * dev, uint32_t * cycles);
+
+__pinned_func
+static inline int tgpio_port_get_cycles_per_second(const struct device * dev, uint32_t * cycles)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t * val; } parm1 = { .val = cycles };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_port_get_cycles_per_second(dev, cycles);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_port_get_cycles_per_second(dev, cycles) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND, tgpio_port_get_cycles_per_second, dev, cycles); 	syscall__retval = tgpio_port_get_cycles_per_second(dev, cycles); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PORT_GET_CYCLES_PER_SECOND, tgpio_port_get_cycles_per_second, dev, cycles, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_tgpio_pin_disable(const struct device * dev, uint32_t pin);
+
+__pinned_func
+static inline int tgpio_pin_disable(const struct device * dev, uint32_t pin)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = pin };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_TGPIO_PIN_DISABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_pin_disable(dev, pin);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_pin_disable(dev, pin) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PIN_DISABLE, tgpio_pin_disable, dev, pin); 	syscall__retval = tgpio_pin_disable(dev, pin); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PIN_DISABLE, tgpio_pin_disable, dev, pin, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_tgpio_pin_config_ext_timestamp(const struct device * dev, uint32_t pin, uint32_t event_polarity);
+
+__pinned_func
+static inline int tgpio_pin_config_ext_timestamp(const struct device * dev, uint32_t pin, uint32_t event_polarity)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = pin };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = event_polarity };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_pin_config_ext_timestamp(dev, pin, event_polarity);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_pin_config_ext_timestamp(dev, pin, event_polarity) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP, tgpio_pin_config_ext_timestamp, dev, pin, event_polarity); 	syscall__retval = tgpio_pin_config_ext_timestamp(dev, pin, event_polarity); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PIN_CONFIG_EXT_TIMESTAMP, tgpio_pin_config_ext_timestamp, dev, pin, event_polarity, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_tgpio_pin_periodic_output(const struct device * dev, uint32_t pin, uint64_t start_time, uint64_t repeat_interval, bool periodic_enable);
+
+__pinned_func
+static inline int tgpio_pin_periodic_output(const struct device * dev, uint32_t pin, uint64_t start_time, uint64_t repeat_interval, bool periodic_enable)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = pin };
+		union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm2 = { .val = start_time };
+		union { struct { uintptr_t lo, hi; } split; uint64_t val; } parm3 = { .val = repeat_interval };
+		union { uintptr_t x; bool val; } parm4 = { .val = periodic_enable };
+		uintptr_t more[] = {
+			parm3.split.hi,
+			parm4.x
+		};
+		return (int) arch_syscall_invoke6(parm0.x, parm1.x, parm2.split.lo, parm2.split.hi, parm3.split.lo, (uintptr_t) &more, K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_pin_periodic_output(dev, pin, start_time, repeat_interval, periodic_enable);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_pin_periodic_output(dev, pin, start_time, repeat_interval, periodic_enable) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT, tgpio_pin_periodic_output, dev, pin, start_time, repeat_interval, periodic_enable); 	syscall__retval = tgpio_pin_periodic_output(dev, pin, start_time, repeat_interval, periodic_enable); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PIN_PERIODIC_OUTPUT, tgpio_pin_periodic_output, dev, pin, start_time, repeat_interval, periodic_enable, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_tgpio_pin_read_ts_ec(const struct device * dev, uint32_t pin, uint64_t * timestamp, uint64_t * event_count);
+
+__pinned_func
+static inline int tgpio_pin_read_ts_ec(const struct device * dev, uint32_t pin, uint64_t * timestamp, uint64_t * event_count)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = pin };
+		union { uintptr_t x; uint64_t * val; } parm2 = { .val = timestamp };
+		union { uintptr_t x; uint64_t * val; } parm3 = { .val = event_count };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_TGPIO_PIN_READ_TS_EC);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_tgpio_pin_read_ts_ec(dev, pin, timestamp, event_count);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define tgpio_pin_read_ts_ec(dev, pin, timestamp, event_count) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_TGPIO_PIN_READ_TS_EC, tgpio_pin_read_ts_ec, dev, pin, timestamp, event_count); 	syscall__retval = tgpio_pin_read_ts_ec(dev, pin, timestamp, event_count); 	sys_port_trace_syscall_exit(K_SYSCALL_TGPIO_PIN_READ_TS_EC, tgpio_pin_read_ts_ec, dev, pin, timestamp, event_count, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/uart.h b/nrfdemo/build/zephyr/include/generated/syscalls/uart.h
new file mode 100644
index 0000000..b3b9b91
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/uart.h
@@ -0,0 +1,612 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_UART_H
+#define Z_INCLUDE_SYSCALLS_UART_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_uart_err_check(const struct device * dev);
+
+__pinned_func
+static inline int uart_err_check(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_ERR_CHECK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_err_check(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_err_check(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_ERR_CHECK, uart_err_check, dev); 	syscall__retval = uart_err_check(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_ERR_CHECK, uart_err_check, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_poll_in(const struct device * dev, unsigned char * p_char);
+
+__pinned_func
+static inline int uart_poll_in(const struct device * dev, unsigned char * p_char)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; unsigned char * val; } parm1 = { .val = p_char };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_POLL_IN);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_poll_in(dev, p_char);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_poll_in(dev, p_char) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_POLL_IN, uart_poll_in, dev, p_char); 	syscall__retval = uart_poll_in(dev, p_char); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_POLL_IN, uart_poll_in, dev, p_char, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_poll_in_u16(const struct device * dev, uint16_t * p_u16);
+
+__pinned_func
+static inline int uart_poll_in_u16(const struct device * dev, uint16_t * p_u16)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t * val; } parm1 = { .val = p_u16 };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_POLL_IN_U16);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_poll_in_u16(dev, p_u16);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_poll_in_u16(dev, p_u16) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_POLL_IN_U16, uart_poll_in_u16, dev, p_u16); 	syscall__retval = uart_poll_in_u16(dev, p_u16); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_POLL_IN_U16, uart_poll_in_u16, dev, p_u16, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_uart_poll_out(const struct device * dev, unsigned char out_char);
+
+__pinned_func
+static inline void uart_poll_out(const struct device * dev, unsigned char out_char)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; unsigned char val; } parm1 = { .val = out_char };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_POLL_OUT);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_poll_out(dev, out_char);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_poll_out(dev, out_char) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_POLL_OUT, uart_poll_out, dev, out_char); 	uart_poll_out(dev, out_char); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_POLL_OUT, uart_poll_out, dev, out_char); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_poll_out_u16(const struct device * dev, uint16_t out_u16);
+
+__pinned_func
+static inline void uart_poll_out_u16(const struct device * dev, uint16_t out_u16)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t val; } parm1 = { .val = out_u16 };
+		(void) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_POLL_OUT_U16);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_poll_out_u16(dev, out_u16);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_poll_out_u16(dev, out_u16) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_POLL_OUT_U16, uart_poll_out_u16, dev, out_u16); 	uart_poll_out_u16(dev, out_u16); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_POLL_OUT_U16, uart_poll_out_u16, dev, out_u16); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_uart_configure(const struct device * dev, const struct uart_config * cfg);
+
+__pinned_func
+static inline int uart_configure(const struct device * dev, const struct uart_config * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const struct uart_config * val; } parm1 = { .val = cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_configure(dev, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_configure(dev, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_CONFIGURE, uart_configure, dev, cfg); 	syscall__retval = uart_configure(dev, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_CONFIGURE, uart_configure, dev, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_config_get(const struct device * dev, struct uart_config * cfg);
+
+__pinned_func
+static inline int uart_config_get(const struct device * dev, struct uart_config * cfg)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; struct uart_config * val; } parm1 = { .val = cfg };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_UART_CONFIG_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_config_get(dev, cfg);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_config_get(dev, cfg) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_CONFIG_GET, uart_config_get, dev, cfg); 	syscall__retval = uart_config_get(dev, cfg); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_CONFIG_GET, uart_config_get, dev, cfg, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_tx_enable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_tx_enable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_TX_ENABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_tx_enable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_tx_enable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_TX_ENABLE, uart_irq_tx_enable, dev); 	uart_irq_tx_enable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_TX_ENABLE, uart_irq_tx_enable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_tx_disable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_tx_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_TX_DISABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_tx_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_tx_disable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_TX_DISABLE, uart_irq_tx_disable, dev); 	uart_irq_tx_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_TX_DISABLE, uart_irq_tx_disable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_rx_enable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_rx_enable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_RX_ENABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_rx_enable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_rx_enable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_RX_ENABLE, uart_irq_rx_enable, dev); 	uart_irq_rx_enable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_RX_ENABLE, uart_irq_rx_enable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_rx_disable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_rx_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_RX_DISABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_rx_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_rx_disable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_RX_DISABLE, uart_irq_rx_disable, dev); 	uart_irq_rx_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_RX_DISABLE, uart_irq_rx_disable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_err_enable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_err_enable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_ERR_ENABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_err_enable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_err_enable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_ERR_ENABLE, uart_irq_err_enable, dev); 	uart_irq_err_enable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_ERR_ENABLE, uart_irq_err_enable, dev); } while(false)
+#endif
+#endif
+
+
+extern void z_impl_uart_irq_err_disable(const struct device * dev);
+
+__pinned_func
+static inline void uart_irq_err_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		(void) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_ERR_DISABLE);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_uart_irq_err_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_err_disable(dev) do { 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_ERR_DISABLE, uart_irq_err_disable, dev); 	uart_irq_err_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_ERR_DISABLE, uart_irq_err_disable, dev); } while(false)
+#endif
+#endif
+
+
+extern int z_impl_uart_irq_is_pending(const struct device * dev);
+
+__pinned_func
+static inline int uart_irq_is_pending(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_IS_PENDING);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_irq_is_pending(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_is_pending(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_IS_PENDING, uart_irq_is_pending, dev); 	syscall__retval = uart_irq_is_pending(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_IS_PENDING, uart_irq_is_pending, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_irq_update(const struct device * dev);
+
+__pinned_func
+static inline int uart_irq_update(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_IRQ_UPDATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_irq_update(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_irq_update(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_IRQ_UPDATE, uart_irq_update, dev); 	syscall__retval = uart_irq_update(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_IRQ_UPDATE, uart_irq_update, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_tx(const struct device * dev, const uint8_t * buf, size_t len, int32_t timeout);
+
+__pinned_func
+static inline int uart_tx(const struct device * dev, const uint8_t * buf, size_t len, int32_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const uint8_t * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		union { uintptr_t x; int32_t val; } parm3 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_UART_TX);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_tx(dev, buf, len, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_tx(dev, buf, len, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_TX, uart_tx, dev, buf, len, timeout); 	syscall__retval = uart_tx(dev, buf, len, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_TX, uart_tx, dev, buf, len, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_tx_u16(const struct device * dev, const uint16_t * buf, size_t len, int32_t timeout);
+
+__pinned_func
+static inline int uart_tx_u16(const struct device * dev, const uint16_t * buf, size_t len, int32_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const uint16_t * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		union { uintptr_t x; int32_t val; } parm3 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_UART_TX_U16);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_tx_u16(dev, buf, len, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_tx_u16(dev, buf, len, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_TX_U16, uart_tx_u16, dev, buf, len, timeout); 	syscall__retval = uart_tx_u16(dev, buf, len, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_TX_U16, uart_tx_u16, dev, buf, len, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_tx_abort(const struct device * dev);
+
+__pinned_func
+static inline int uart_tx_abort(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_TX_ABORT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_tx_abort(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_tx_abort(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_TX_ABORT, uart_tx_abort, dev); 	syscall__retval = uart_tx_abort(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_TX_ABORT, uart_tx_abort, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_rx_enable(const struct device * dev, uint8_t * buf, size_t len, int32_t timeout);
+
+__pinned_func
+static inline int uart_rx_enable(const struct device * dev, uint8_t * buf, size_t len, int32_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		union { uintptr_t x; int32_t val; } parm3 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_UART_RX_ENABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_rx_enable(dev, buf, len, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_rx_enable(dev, buf, len, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_RX_ENABLE, uart_rx_enable, dev, buf, len, timeout); 	syscall__retval = uart_rx_enable(dev, buf, len, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_RX_ENABLE, uart_rx_enable, dev, buf, len, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_rx_enable_u16(const struct device * dev, uint16_t * buf, size_t len, int32_t timeout);
+
+__pinned_func
+static inline int uart_rx_enable_u16(const struct device * dev, uint16_t * buf, size_t len, int32_t timeout)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint16_t * val; } parm1 = { .val = buf };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		union { uintptr_t x; int32_t val; } parm3 = { .val = timeout };
+		return (int) arch_syscall_invoke4(parm0.x, parm1.x, parm2.x, parm3.x, K_SYSCALL_UART_RX_ENABLE_U16);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_rx_enable_u16(dev, buf, len, timeout);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_rx_enable_u16(dev, buf, len, timeout) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_RX_ENABLE_U16, uart_rx_enable_u16, dev, buf, len, timeout); 	syscall__retval = uart_rx_enable_u16(dev, buf, len, timeout); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_RX_ENABLE_U16, uart_rx_enable_u16, dev, buf, len, timeout, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_rx_disable(const struct device * dev);
+
+__pinned_func
+static inline int uart_rx_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_RX_DISABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_rx_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_rx_disable(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_RX_DISABLE, uart_rx_disable, dev); 	syscall__retval = uart_rx_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_RX_DISABLE, uart_rx_disable, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_line_ctrl_set(const struct device * dev, uint32_t ctrl, uint32_t val);
+
+__pinned_func
+static inline int uart_line_ctrl_set(const struct device * dev, uint32_t ctrl, uint32_t val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = ctrl };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_UART_LINE_CTRL_SET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_line_ctrl_set(dev, ctrl, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_line_ctrl_set(dev, ctrl, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_LINE_CTRL_SET, uart_line_ctrl_set, dev, ctrl, val); 	syscall__retval = uart_line_ctrl_set(dev, ctrl, val); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_LINE_CTRL_SET, uart_line_ctrl_set, dev, ctrl, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_line_ctrl_get(const struct device * dev, uint32_t ctrl, uint32_t * val);
+
+__pinned_func
+static inline int uart_line_ctrl_get(const struct device * dev, uint32_t ctrl, uint32_t * val)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = ctrl };
+		union { uintptr_t x; uint32_t * val; } parm2 = { .val = val };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_UART_LINE_CTRL_GET);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_line_ctrl_get(dev, ctrl, val);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_line_ctrl_get(dev, ctrl, val) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_LINE_CTRL_GET, uart_line_ctrl_get, dev, ctrl, val); 	syscall__retval = uart_line_ctrl_get(dev, ctrl, val); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_LINE_CTRL_GET, uart_line_ctrl_get, dev, ctrl, val, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_uart_drv_cmd(const struct device * dev, uint32_t cmd, uint32_t p);
+
+__pinned_func
+static inline int uart_drv_cmd(const struct device * dev, uint32_t cmd, uint32_t p)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint32_t val; } parm1 = { .val = cmd };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = p };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_UART_DRV_CMD);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_drv_cmd(dev, cmd, p);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_drv_cmd(dev, cmd, p) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_DRV_CMD, uart_drv_cmd, dev, cmd, p); 	syscall__retval = uart_drv_cmd(dev, cmd, p); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_DRV_CMD, uart_drv_cmd, dev, cmd, p, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/uart_mux.h b/nrfdemo/build/zephyr/include/generated/syscalls/uart_mux.h
new file mode 100644
index 0000000..57a5939
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/uart_mux.h
@@ -0,0 +1,51 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_UART_MUX_H
+#define Z_INCLUDE_SYSCALLS_UART_MUX_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const struct device * z_impl_uart_mux_find(int dlci_address);
+
+__pinned_func
+static inline const struct device * uart_mux_find(int dlci_address)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; int val; } parm0 = { .val = dlci_address };
+		return (const struct device *) arch_syscall_invoke1(parm0.x, K_SYSCALL_UART_MUX_FIND);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_uart_mux_find(dlci_address);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define uart_mux_find(dlci_address) ({ 	const struct device * syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UART_MUX_FIND, uart_mux_find, dlci_address); 	syscall__retval = uart_mux_find(dlci_address); 	sys_port_trace_syscall_exit(K_SYSCALL_UART_MUX_FIND, uart_mux_find, dlci_address, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/updatehub.h b/nrfdemo/build/zephyr/include/generated/syscalls/updatehub.h
new file mode 100644
index 0000000..4a99d6f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/updatehub.h
@@ -0,0 +1,139 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_UPDATEHUB_H
+#define Z_INCLUDE_SYSCALLS_UPDATEHUB_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void z_impl_updatehub_autohandler(void);
+
+__pinned_func
+static inline void updatehub_autohandler(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		(void) arch_syscall_invoke0(K_SYSCALL_UPDATEHUB_AUTOHANDLER);
+		return;
+	}
+#endif
+	compiler_barrier();
+	z_impl_updatehub_autohandler();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define updatehub_autohandler() do { 	sys_port_trace_syscall_enter(K_SYSCALL_UPDATEHUB_AUTOHANDLER, updatehub_autohandler); 	updatehub_autohandler(); 	sys_port_trace_syscall_exit(K_SYSCALL_UPDATEHUB_AUTOHANDLER, updatehub_autohandler); } while(false)
+#endif
+#endif
+
+
+extern enum updatehub_response z_impl_updatehub_probe(void);
+
+__pinned_func
+static inline enum updatehub_response updatehub_probe(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (enum updatehub_response) arch_syscall_invoke0(K_SYSCALL_UPDATEHUB_PROBE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_updatehub_probe();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define updatehub_probe() ({ 	enum updatehub_response syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UPDATEHUB_PROBE, updatehub_probe); 	syscall__retval = updatehub_probe(); 	sys_port_trace_syscall_exit(K_SYSCALL_UPDATEHUB_PROBE, updatehub_probe, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern enum updatehub_response z_impl_updatehub_update(void);
+
+__pinned_func
+static inline enum updatehub_response updatehub_update(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (enum updatehub_response) arch_syscall_invoke0(K_SYSCALL_UPDATEHUB_UPDATE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_updatehub_update();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define updatehub_update() ({ 	enum updatehub_response syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UPDATEHUB_UPDATE, updatehub_update); 	syscall__retval = updatehub_update(); 	sys_port_trace_syscall_exit(K_SYSCALL_UPDATEHUB_UPDATE, updatehub_update, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_updatehub_confirm(void);
+
+__pinned_func
+static inline int updatehub_confirm(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int) arch_syscall_invoke0(K_SYSCALL_UPDATEHUB_CONFIRM);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_updatehub_confirm();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define updatehub_confirm() ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UPDATEHUB_CONFIRM, updatehub_confirm); 	syscall__retval = updatehub_confirm(); 	sys_port_trace_syscall_exit(K_SYSCALL_UPDATEHUB_CONFIRM, updatehub_confirm, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_updatehub_reboot(void);
+
+__pinned_func
+static inline int updatehub_reboot(void)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		return (int) arch_syscall_invoke0(K_SYSCALL_UPDATEHUB_REBOOT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_updatehub_reboot();
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define updatehub_reboot() ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_UPDATEHUB_REBOOT, updatehub_reboot); 	syscall__retval = updatehub_reboot(); 	sys_port_trace_syscall_exit(K_SYSCALL_UPDATEHUB_REBOOT, updatehub_reboot, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/usb_bc12.h b/nrfdemo/build/zephyr/include/generated/syscalls/usb_bc12.h
new file mode 100644
index 0000000..3b93c9f
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/usb_bc12.h
@@ -0,0 +1,77 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_USB_BC12_H
+#define Z_INCLUDE_SYSCALLS_USB_BC12_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_bc12_set_role(const struct device * dev, enum bc12_role role);
+
+__pinned_func
+static inline int bc12_set_role(const struct device * dev, enum bc12_role role)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum bc12_role val; } parm1 = { .val = role };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_BC12_SET_ROLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bc12_set_role(dev, role);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bc12_set_role(dev, role) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BC12_SET_ROLE, bc12_set_role, dev, role); 	syscall__retval = bc12_set_role(dev, role); 	sys_port_trace_syscall_exit(K_SYSCALL_BC12_SET_ROLE, bc12_set_role, dev, role, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_bc12_set_result_cb(const struct device * dev, bc12_callback_t cb, void * user_data);
+
+__pinned_func
+static inline int bc12_set_result_cb(const struct device * dev, bc12_callback_t cb, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bc12_callback_t val; } parm1 = { .val = cb };
+		union { uintptr_t x; void * val; } parm2 = { .val = user_data };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_BC12_SET_RESULT_CB);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_bc12_set_result_cb(dev, cb, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define bc12_set_result_cb(dev, cb, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_BC12_SET_RESULT_CB, bc12_set_result_cb, dev, cb, user_data); 	syscall__retval = bc12_set_result_cb(dev, cb, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_BC12_SET_RESULT_CB, bc12_set_result_cb, dev, cb, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/w1.h b/nrfdemo/build/zephyr/include/generated/syscalls/w1.h
new file mode 100644
index 0000000..6e913b4
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/w1.h
@@ -0,0 +1,294 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_W1_H
+#define Z_INCLUDE_SYSCALLS_W1_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_w1_change_bus_lock(const struct device * dev, bool lock);
+
+__pinned_func
+static inline int w1_change_bus_lock(const struct device * dev, bool lock)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; bool val; } parm1 = { .val = lock };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_W1_CHANGE_BUS_LOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_change_bus_lock(dev, lock);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_change_bus_lock(dev, lock) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_CHANGE_BUS_LOCK, w1_change_bus_lock, dev, lock); 	syscall__retval = w1_change_bus_lock(dev, lock); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_CHANGE_BUS_LOCK, w1_change_bus_lock, dev, lock, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_reset_bus(const struct device * dev);
+
+__pinned_func
+static inline int w1_reset_bus(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_W1_RESET_BUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_reset_bus(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_reset_bus(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_RESET_BUS, w1_reset_bus, dev); 	syscall__retval = w1_reset_bus(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_RESET_BUS, w1_reset_bus, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_read_bit(const struct device * dev);
+
+__pinned_func
+static inline int w1_read_bit(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_W1_READ_BIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_read_bit(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_read_bit(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_READ_BIT, w1_read_bit, dev); 	syscall__retval = w1_read_bit(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_READ_BIT, w1_read_bit, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_write_bit(const struct device * dev, const bool bit);
+
+__pinned_func
+static inline int w1_write_bit(const struct device * dev, const bool bit)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const bool val; } parm1 = { .val = bit };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_W1_WRITE_BIT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_write_bit(dev, bit);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_write_bit(dev, bit) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_WRITE_BIT, w1_write_bit, dev, bit); 	syscall__retval = w1_write_bit(dev, bit); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_WRITE_BIT, w1_write_bit, dev, bit, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_read_byte(const struct device * dev);
+
+__pinned_func
+static inline int w1_read_byte(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_W1_READ_BYTE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_read_byte(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_read_byte(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_READ_BYTE, w1_read_byte, dev); 	syscall__retval = w1_read_byte(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_READ_BYTE, w1_read_byte, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_write_byte(const struct device * dev, uint8_t byte);
+
+__pinned_func
+static inline int w1_write_byte(const struct device * dev, uint8_t byte)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = byte };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_W1_WRITE_BYTE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_write_byte(dev, byte);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_write_byte(dev, byte) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_WRITE_BYTE, w1_write_byte, dev, byte); 	syscall__retval = w1_write_byte(dev, byte); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_WRITE_BYTE, w1_write_byte, dev, byte, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_read_block(const struct device * dev, uint8_t * buffer, size_t len);
+
+__pinned_func
+static inline int w1_read_block(const struct device * dev, uint8_t * buffer, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t * val; } parm1 = { .val = buffer };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_W1_READ_BLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_read_block(dev, buffer, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_read_block(dev, buffer, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_READ_BLOCK, w1_read_block, dev, buffer, len); 	syscall__retval = w1_read_block(dev, buffer, len); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_READ_BLOCK, w1_read_block, dev, buffer, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_write_block(const struct device * dev, const uint8_t * buffer, size_t len);
+
+__pinned_func
+static inline int w1_write_block(const struct device * dev, const uint8_t * buffer, size_t len)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; const uint8_t * val; } parm1 = { .val = buffer };
+		union { uintptr_t x; size_t val; } parm2 = { .val = len };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_W1_WRITE_BLOCK);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_write_block(dev, buffer, len);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_write_block(dev, buffer, len) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_WRITE_BLOCK, w1_write_block, dev, buffer, len); 	syscall__retval = w1_write_block(dev, buffer, len); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_WRITE_BLOCK, w1_write_block, dev, buffer, len, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern size_t z_impl_w1_get_slave_count(const struct device * dev);
+
+__pinned_func
+static inline size_t w1_get_slave_count(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (size_t) arch_syscall_invoke1(parm0.x, K_SYSCALL_W1_GET_SLAVE_COUNT);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_get_slave_count(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_get_slave_count(dev) ({ 	size_t syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_GET_SLAVE_COUNT, w1_get_slave_count, dev); 	syscall__retval = w1_get_slave_count(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_GET_SLAVE_COUNT, w1_get_slave_count, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_configure(const struct device * dev, enum w1_settings_type type, uint32_t value);
+
+__pinned_func
+static inline int w1_configure(const struct device * dev, enum w1_settings_type type, uint32_t value)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; enum w1_settings_type val; } parm1 = { .val = type };
+		union { uintptr_t x; uint32_t val; } parm2 = { .val = value };
+		return (int) arch_syscall_invoke3(parm0.x, parm1.x, parm2.x, K_SYSCALL_W1_CONFIGURE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_configure(dev, type, value);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_configure(dev, type, value) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_CONFIGURE, w1_configure, dev, type, value); 	syscall__retval = w1_configure(dev, type, value); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_CONFIGURE, w1_configure, dev, type, value, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_w1_search_bus(const struct device * dev, uint8_t command, uint8_t family, w1_search_callback_t callback, void * user_data);
+
+__pinned_func
+static inline int w1_search_bus(const struct device * dev, uint8_t command, uint8_t family, w1_search_callback_t callback, void * user_data)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = command };
+		union { uintptr_t x; uint8_t val; } parm2 = { .val = family };
+		union { uintptr_t x; w1_search_callback_t val; } parm3 = { .val = callback };
+		union { uintptr_t x; void * val; } parm4 = { .val = user_data };
+		return (int) arch_syscall_invoke5(parm0.x, parm1.x, parm2.x, parm3.x, parm4.x, K_SYSCALL_W1_SEARCH_BUS);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_w1_search_bus(dev, command, family, callback, user_data);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define w1_search_bus(dev, command, family, callback, user_data) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_W1_SEARCH_BUS, w1_search_bus, dev, command, family, callback, user_data); 	syscall__retval = w1_search_bus(dev, command, family, callback, user_data); 	sys_port_trace_syscall_exit(K_SYSCALL_W1_SEARCH_BUS, w1_search_bus, dev, command, family, callback, user_data, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */
diff --git a/nrfdemo/build/zephyr/include/generated/syscalls/watchdog.h b/nrfdemo/build/zephyr/include/generated/syscalls/watchdog.h
new file mode 100644
index 0000000..c066ee5
--- /dev/null
+++ b/nrfdemo/build/zephyr/include/generated/syscalls/watchdog.h
@@ -0,0 +1,99 @@
+/* auto-generated by gen_syscalls.py, don't edit */
+
+#ifndef Z_INCLUDE_SYSCALLS_WATCHDOG_H
+#define Z_INCLUDE_SYSCALLS_WATCHDOG_H
+
+
+#include <zephyr/tracing/tracing_syscall.h>
+
+#ifndef _ASMLANGUAGE
+
+#include <stdarg.h>
+
+#include <syscall_list.h>
+#include <zephyr/syscall.h>
+
+#include <zephyr/linker/sections.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int z_impl_wdt_setup(const struct device * dev, uint8_t options);
+
+__pinned_func
+static inline int wdt_setup(const struct device * dev, uint8_t options)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; uint8_t val; } parm1 = { .val = options };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_WDT_SETUP);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_wdt_setup(dev, options);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define wdt_setup(dev, options) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_WDT_SETUP, wdt_setup, dev, options); 	syscall__retval = wdt_setup(dev, options); 	sys_port_trace_syscall_exit(K_SYSCALL_WDT_SETUP, wdt_setup, dev, options, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_wdt_disable(const struct device * dev);
+
+__pinned_func
+static inline int wdt_disable(const struct device * dev)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		return (int) arch_syscall_invoke1(parm0.x, K_SYSCALL_WDT_DISABLE);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_wdt_disable(dev);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define wdt_disable(dev) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_WDT_DISABLE, wdt_disable, dev); 	syscall__retval = wdt_disable(dev); 	sys_port_trace_syscall_exit(K_SYSCALL_WDT_DISABLE, wdt_disable, dev, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+extern int z_impl_wdt_feed(const struct device * dev, int channel_id);
+
+__pinned_func
+static inline int wdt_feed(const struct device * dev, int channel_id)
+{
+#ifdef CONFIG_USERSPACE
+	if (z_syscall_trap()) {
+		union { uintptr_t x; const struct device * val; } parm0 = { .val = dev };
+		union { uintptr_t x; int val; } parm1 = { .val = channel_id };
+		return (int) arch_syscall_invoke2(parm0.x, parm1.x, K_SYSCALL_WDT_FEED);
+	}
+#endif
+	compiler_barrier();
+	return z_impl_wdt_feed(dev, channel_id);
+}
+
+#if defined(CONFIG_TRACING_SYSCALL)
+#ifndef DISABLE_SYSCALL_TRACING
+
+#define wdt_feed(dev, channel_id) ({ 	int syscall__retval; 	sys_port_trace_syscall_enter(K_SYSCALL_WDT_FEED, wdt_feed, dev, channel_id); 	syscall__retval = wdt_feed(dev, channel_id); 	sys_port_trace_syscall_exit(K_SYSCALL_WDT_FEED, wdt_feed, dev, channel_id, syscall__retval); 	syscall__retval; })
+#endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif /* include guard */