michaelh/zephyr
1
0
Fork 0
Code Releases Activity

syscall: rename Z_SYSCALL_DRIVER_ -> K_SYSCALL_DRIVER_

Browse source 
Rename internal API to not use z_/Z_.

Signed-off-by: Anas Nashif <anas.nashif@intel.com>
This commit is contained in:
Anas Nashif 2023-09-27 11:18:12 +00:00 • committed by Carles Cufí
commit 1a9de05767
36 changed files with 179 additions and 179 deletions
Download patch file Download diff file Expand all files Collapse all files

4
doc/kernel/usermode/syscalls.rst
View file

@ -320,7 +320,7 @@ Several macros exist to validate arguments:
macro can be used by itself, it's mostly a building block for macros macro can be used by itself, it's mostly a building block for macros
that are automatically generated for every driver subsystem. For that are automatically generated for every driver subsystem. For
instance, to validate the GPIO driver, one could use the instance, to validate the GPIO driver, one could use the
:c:macro:`Z_SYSCALL_DRIVER_GPIO()` macro. :c:macro:`K_SYSCALL_DRIVER_GPIO()` macro.
* :c:macro:`K_SYSCALL_SPECIFIC_DRIVER()` is a runtime check to verify that * :c:macro:`K_SYSCALL_SPECIFIC_DRIVER()` is a runtime check to verify that
a provided pointer is a valid instance of a specific device driver, that a provided pointer is a valid instance of a specific device driver, that
@ -572,7 +572,7 @@ conventions are as follows:
overflowed. overflowed.
#. Most system calls take kernel object pointers as an argument, checked either #. Most system calls take kernel object pointers as an argument, checked either
with one of the ``K_SYSCALL_OBJ`` functions, ``Z_SYSCALL_DRIVER_nnnnn``, or with one of the ``K_SYSCALL_OBJ`` functions, ``K_SYSCALL_DRIVER_nnnnn``, or
manually using :c:func:`k_object_validate()`. These can fail for a variety manually using :c:func:`k_object_validate()`. These can fail for a variety
of reasons: missing driver API, bad kernel object pointer, wrong kernel of reasons: missing driver API, bad kernel object pointer, wrong kernel
object type, or improper initialization state. These issues should always object type, or improper initialization state. These issues should always

6
drivers/adc/adc_handlers.c
View file

@ -13,7 +13,7 @@ static inline int z_vrfy_adc_channel_setup(const struct device *dev,
{ {
struct adc_channel_cfg channel_cfg; struct adc_channel_cfg channel_cfg;
Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, channel_setup)); Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, channel_setup));
Z_OOPS(k_usermode_from_copy(&channel_cfg, Z_OOPS(k_usermode_from_copy(&channel_cfg,
(struct adc_channel_cfg *)user_channel_cfg, (struct adc_channel_cfg *)user_channel_cfg,
sizeof(struct adc_channel_cfg))); sizeof(struct adc_channel_cfg)));
@ -55,7 +55,7 @@ static inline int z_vrfy_adc_read(const struct device *dev,
struct adc_sequence sequence; struct adc_sequence sequence;
struct adc_sequence_options options; struct adc_sequence_options options;
Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, read)); Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, read));
Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options, Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
(struct adc_sequence *)user_sequence), (struct adc_sequence *)user_sequence),
"invalid ADC sequence")); "invalid ADC sequence"));
@ -76,7 +76,7 @@ static inline int z_vrfy_adc_read_async(const struct device *dev,
struct adc_sequence sequence; struct adc_sequence sequence;
struct adc_sequence_options options; struct adc_sequence_options options;
Z_OOPS(Z_SYSCALL_DRIVER_ADC(dev, read_async)); Z_OOPS(K_SYSCALL_DRIVER_ADC(dev, read_async));
Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options, Z_OOPS(K_SYSCALL_VERIFY_MSG(copy_sequence(&sequence, &options,
(struct adc_sequence *)user_sequence), (struct adc_sequence *)user_sequence),
"invalid ADC sequence")); "invalid ADC sequence"));

32
drivers/can/can_handlers.c
View file

@ -13,7 +13,7 @@ static int z_vrfy_can_calc_timing(const struct device *dev, struct can_timing *r
struct can_timing res_copy; struct can_timing res_copy;
int err; int err;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_core_clock)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, get_core_clock));
Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy))); Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy)));
err = z_impl_can_calc_timing(dev, &res_copy, bitrate, sample_pnt); err = z_impl_can_calc_timing(dev, &res_copy, bitrate, sample_pnt);
@ -28,7 +28,7 @@ static inline int z_vrfy_can_set_timing(const struct device *dev,
{ {
struct can_timing timing_copy; struct can_timing timing_copy;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, set_timing));
Z_OOPS(k_usermode_from_copy(&timing_copy, timing, sizeof(timing_copy))); Z_OOPS(k_usermode_from_copy(&timing_copy, timing, sizeof(timing_copy)));
return z_impl_can_set_timing(dev, &timing_copy); return z_impl_can_set_timing(dev, &timing_copy);
@ -38,7 +38,7 @@ static inline int z_vrfy_can_set_timing(const struct device *dev,
static inline int z_vrfy_can_get_core_clock(const struct device *dev, static inline int z_vrfy_can_get_core_clock(const struct device *dev,
uint32_t *rate) uint32_t *rate)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_core_clock)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, get_core_clock));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(rate, sizeof(*rate))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(rate, sizeof(*rate)));
return z_impl_can_get_core_clock(dev, rate); return z_impl_can_get_core_clock(dev, rate);
@ -80,7 +80,7 @@ static int z_vrfy_can_calc_timing_data(const struct device *dev, struct can_timi
struct can_timing res_copy; struct can_timing res_copy;
int err; int err;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_core_clock)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, get_core_clock));
Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy))); Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy)));
err = z_impl_can_calc_timing_data(dev, &res_copy, bitrate, sample_pnt); err = z_impl_can_calc_timing_data(dev, &res_copy, bitrate, sample_pnt);
@ -111,7 +111,7 @@ static inline int z_vrfy_can_set_timing_data(const struct device *dev,
{ {
struct can_timing timing_data_copy; struct can_timing timing_data_copy;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing_data)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, set_timing_data));
Z_OOPS(k_usermode_from_copy(&timing_data_copy, timing_data, sizeof(timing_data_copy))); Z_OOPS(k_usermode_from_copy(&timing_data_copy, timing_data, sizeof(timing_data_copy)));
return z_impl_can_set_timing_data(dev, &timing_data_copy); return z_impl_can_set_timing_data(dev, &timing_data_copy);
@ -121,7 +121,7 @@ static inline int z_vrfy_can_set_timing_data(const struct device *dev,
static inline int z_vrfy_can_set_bitrate_data(const struct device *dev, static inline int z_vrfy_can_set_bitrate_data(const struct device *dev,
uint32_t bitrate_data) uint32_t bitrate_data)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing_data)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, set_timing_data));
return z_impl_can_set_bitrate_data(dev, bitrate_data); return z_impl_can_set_bitrate_data(dev, bitrate_data);
} }
@ -140,7 +140,7 @@ static inline int z_vrfy_can_get_max_filters(const struct device *dev, bool ide)
static inline int z_vrfy_can_get_capabilities(const struct device *dev, can_mode_t *cap) static inline int z_vrfy_can_get_capabilities(const struct device *dev, can_mode_t *cap)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_capabilities)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, get_capabilities));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(cap, sizeof(*cap))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(cap, sizeof(*cap)));
return z_impl_can_get_capabilities(dev, cap); return z_impl_can_get_capabilities(dev, cap);
@ -149,7 +149,7 @@ static inline int z_vrfy_can_get_capabilities(const struct device *dev, can_mode
static inline int z_vrfy_can_start(const struct device *dev) static inline int z_vrfy_can_start(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, start)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, start));
return z_impl_can_start(dev); return z_impl_can_start(dev);
} }
@ -157,7 +157,7 @@ static inline int z_vrfy_can_start(const struct device *dev)
static inline int z_vrfy_can_stop(const struct device *dev) static inline int z_vrfy_can_stop(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, stop)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, stop));
return z_impl_can_stop(dev); return z_impl_can_stop(dev);
} }
@ -165,7 +165,7 @@ static inline int z_vrfy_can_stop(const struct device *dev)
static inline int z_vrfy_can_set_mode(const struct device *dev, can_mode_t mode) static inline int z_vrfy_can_set_mode(const struct device *dev, can_mode_t mode)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_mode)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, set_mode));
return z_impl_can_set_mode(dev, mode); return z_impl_can_set_mode(dev, mode);
} }
@ -173,7 +173,7 @@ static inline int z_vrfy_can_set_mode(const struct device *dev, can_mode_t mode)
static inline int z_vrfy_can_set_bitrate(const struct device *dev, uint32_t bitrate) static inline int z_vrfy_can_set_bitrate(const struct device *dev, uint32_t bitrate)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, set_timing));
return z_impl_can_set_bitrate(dev, bitrate); return z_impl_can_set_bitrate(dev, bitrate);
} }
@ -187,7 +187,7 @@ static inline int z_vrfy_can_send(const struct device *dev,
{ {
struct can_frame frame_copy; struct can_frame frame_copy;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, send)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, send));
Z_OOPS(k_usermode_from_copy(&frame_copy, frame, sizeof(frame_copy))); Z_OOPS(k_usermode_from_copy(&frame_copy, frame, sizeof(frame_copy)));
Z_OOPS(K_SYSCALL_VERIFY_MSG(callback == NULL, "callbacks may not be set from user mode")); Z_OOPS(K_SYSCALL_VERIFY_MSG(callback == NULL, "callbacks may not be set from user mode"));
@ -201,7 +201,7 @@ static inline int z_vrfy_can_add_rx_filter_msgq(const struct device *dev,
{ {
struct can_filter filter_copy; struct can_filter filter_copy;
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, add_rx_filter)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, add_rx_filter));
Z_OOPS(K_SYSCALL_OBJ(msgq, K_OBJ_MSGQ)); Z_OOPS(K_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
Z_OOPS(k_usermode_from_copy(&filter_copy, filter, sizeof(filter_copy))); Z_OOPS(k_usermode_from_copy(&filter_copy, filter, sizeof(filter_copy)));
@ -211,7 +211,7 @@ static inline int z_vrfy_can_add_rx_filter_msgq(const struct device *dev,
static inline void z_vrfy_can_remove_rx_filter(const struct device *dev, int filter_id) static inline void z_vrfy_can_remove_rx_filter(const struct device *dev, int filter_id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, remove_rx_filter)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, remove_rx_filter));
z_impl_can_remove_rx_filter(dev, filter_id); z_impl_can_remove_rx_filter(dev, filter_id);
} }
@ -220,7 +220,7 @@ static inline void z_vrfy_can_remove_rx_filter(const struct device *dev, int fil
static inline int z_vrfy_can_get_state(const struct device *dev, enum can_state *state, static inline int z_vrfy_can_get_state(const struct device *dev, enum can_state *state,
struct can_bus_err_cnt *err_cnt) struct can_bus_err_cnt *err_cnt)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_state)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, get_state));
if (state != NULL) { if (state != NULL) {
Z_OOPS(K_SYSCALL_MEMORY_WRITE(state, sizeof(*state))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(state, sizeof(*state)));
@ -237,7 +237,7 @@ static inline int z_vrfy_can_get_state(const struct device *dev, enum can_state
#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
static inline int z_vrfy_can_recover(const struct device *dev, k_timeout_t timeout) static inline int z_vrfy_can_recover(const struct device *dev, k_timeout_t timeout)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, recover)); Z_OOPS(K_SYSCALL_DRIVER_CAN(dev, recover));
return z_impl_can_recover(dev, timeout); return z_impl_can_recover(dev, timeout);
} }

4
drivers/charger/charger_handlers.c
View file

@ -12,7 +12,7 @@ static inline int z_vrfy_charger_get_prop(const struct device *dev, const charge
{ {
union charger_propval k_val; union charger_propval k_val;
Z_OOPS(Z_SYSCALL_DRIVER_CHARGER(dev, get_property)); Z_OOPS(K_SYSCALL_DRIVER_CHARGER(dev, get_property));
int ret = z_impl_charger_get_prop(dev, prop, &k_val); int ret = z_impl_charger_get_prop(dev, prop, &k_val);
@ -28,7 +28,7 @@ static inline int z_vrfy_charger_set_prop(const struct device *dev, const charge
{ {
union charger_propval k_val; union charger_propval k_val;
Z_OOPS(Z_SYSCALL_DRIVER_CHARGER(dev, set_property)); Z_OOPS(K_SYSCALL_DRIVER_CHARGER(dev, set_property));
Z_OOPS(k_usermode_from_copy(&k_val, val, sizeof(union charger_propval))); Z_OOPS(k_usermode_from_copy(&k_val, val, sizeof(union charger_propval)));

14
drivers/counter/counter_handlers.c
View file

@ -13,7 +13,7 @@
#define COUNTER_HANDLER(name) \ #define COUNTER_HANDLER(name) \
static inline int z_vrfy_counter_##name(const struct device *dev) \ static inline int z_vrfy_counter_##name(const struct device *dev) \
{ \ { \
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, name)); \ Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, name)); \
return z_impl_counter_ ## name((const struct device *)dev); \ return z_impl_counter_ ## name((const struct device *)dev); \
} }
@ -67,7 +67,7 @@ static inline uint64_t z_vrfy_counter_ticks_to_us(const struct device *dev,
static inline int z_vrfy_counter_get_value(const struct device *dev, static inline int z_vrfy_counter_get_value(const struct device *dev,
uint32_t *ticks) uint32_t *ticks)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, get_value)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, get_value));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(ticks, sizeof(*ticks))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(ticks, sizeof(*ticks)));
return z_impl_counter_get_value((const struct device *)dev, ticks); return z_impl_counter_get_value((const struct device *)dev, ticks);
} }
@ -75,7 +75,7 @@ static inline int z_vrfy_counter_get_value(const struct device *dev,
static inline int z_vrfy_counter_get_value_64(const struct device *dev, static inline int z_vrfy_counter_get_value_64(const struct device *dev,
uint64_t *ticks) uint64_t *ticks)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, get_value_64)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, get_value_64));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(ticks, sizeof(*ticks))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(ticks, sizeof(*ticks)));
return z_impl_counter_get_value_64((const struct device *)dev, ticks); return z_impl_counter_get_value_64((const struct device *)dev, ticks);
} }
@ -88,7 +88,7 @@ static inline int z_vrfy_counter_set_channel_alarm(const struct device *dev,
{ {
struct counter_alarm_cfg cfg_copy; struct counter_alarm_cfg cfg_copy;
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, set_alarm)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, set_alarm));
Z_OOPS(k_usermode_from_copy(&cfg_copy, alarm_cfg, sizeof(cfg_copy))); Z_OOPS(k_usermode_from_copy(&cfg_copy, alarm_cfg, sizeof(cfg_copy)));
Z_OOPS(K_SYSCALL_VERIFY_MSG(cfg_copy.callback == NULL, Z_OOPS(K_SYSCALL_VERIFY_MSG(cfg_copy.callback == NULL,
"callbacks may not be set from user mode")); "callbacks may not be set from user mode"));
@ -102,7 +102,7 @@ static inline int z_vrfy_counter_set_channel_alarm(const struct device *dev,
static inline int z_vrfy_counter_cancel_channel_alarm(const struct device *dev, static inline int z_vrfy_counter_cancel_channel_alarm(const struct device *dev,
uint8_t chan_id) uint8_t chan_id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, cancel_alarm)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, cancel_alarm));
return z_impl_counter_cancel_channel_alarm((const struct device *)dev, return z_impl_counter_cancel_channel_alarm((const struct device *)dev,
(uint8_t)chan_id); (uint8_t)chan_id);
} }
@ -114,7 +114,7 @@ static inline int z_vrfy_counter_set_top_value(const struct device *dev,
{ {
struct counter_top_cfg cfg_copy; struct counter_top_cfg cfg_copy;
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, set_top_value)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, set_top_value));
Z_OOPS(k_usermode_from_copy(&cfg_copy, cfg, sizeof(cfg_copy))); Z_OOPS(k_usermode_from_copy(&cfg_copy, cfg, sizeof(cfg_copy)));
Z_OOPS(K_SYSCALL_VERIFY_MSG(cfg_copy.callback == NULL, Z_OOPS(K_SYSCALL_VERIFY_MSG(cfg_copy.callback == NULL,
"callbacks may not be set from user mode")); "callbacks may not be set from user mode"));
@ -126,7 +126,7 @@ static inline int z_vrfy_counter_set_top_value(const struct device *dev,
static inline uint32_t z_vrfy_counter_get_top_value(const struct device *dev) static inline uint32_t z_vrfy_counter_get_top_value(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_COUNTER(dev, get_top_value)); Z_OOPS(K_SYSCALL_DRIVER_COUNTER(dev, get_top_value));
return z_impl_counter_get_top_value((const struct device *)dev); return z_impl_counter_get_top_value((const struct device *)dev);
} }
#include <syscalls/counter_get_top_value_mrsh.c> #include <syscalls/counter_get_top_value_mrsh.c>

4
drivers/dac/dac_handlers.c
View file

@ -13,7 +13,7 @@ static inline int z_vrfy_dac_channel_setup(const struct device *dev,
{ {
struct dac_channel_cfg channel_cfg; struct dac_channel_cfg channel_cfg;
Z_OOPS(Z_SYSCALL_DRIVER_DAC(dev, channel_setup)); Z_OOPS(K_SYSCALL_DRIVER_DAC(dev, channel_setup));
Z_OOPS(k_usermode_from_copy(&channel_cfg, Z_OOPS(k_usermode_from_copy(&channel_cfg,
(struct dac_channel_cfg *)user_channel_cfg, (struct dac_channel_cfg *)user_channel_cfg,
sizeof(struct dac_channel_cfg))); sizeof(struct dac_channel_cfg)));
@ -26,7 +26,7 @@ static inline int z_vrfy_dac_channel_setup(const struct device *dev,
static inline int z_vrfy_dac_write_value(const struct device *dev, static inline int z_vrfy_dac_write_value(const struct device *dev,
uint8_t channel, uint32_t value) uint8_t channel, uint32_t value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_DAC(dev, write_value)); Z_OOPS(K_SYSCALL_DRIVER_DAC(dev, write_value));
return z_impl_dac_write_value((const struct device *)dev, channel, return z_impl_dac_write_value((const struct device *)dev, channel,
value); value);

4
drivers/dma/dma_handlers.c
View file

@ -13,14 +13,14 @@
static inline int z_vrfy_dma_start(const struct device *dev, uint32_t channel) static inline int z_vrfy_dma_start(const struct device *dev, uint32_t channel)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_DMA(dev, start)); Z_OOPS(K_SYSCALL_DRIVER_DMA(dev, start));
return z_impl_dma_start((const struct device *)dev, channel); return z_impl_dma_start((const struct device *)dev, channel);
} }
#include <syscalls/dma_start_mrsh.c> #include <syscalls/dma_start_mrsh.c>
static inline int z_vrfy_dma_stop(const struct device *dev, uint32_t channel) static inline int z_vrfy_dma_stop(const struct device *dev, uint32_t channel)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_DMA(dev, stop)); Z_OOPS(K_SYSCALL_DRIVER_DMA(dev, stop));
return z_impl_dma_stop((const struct device *)dev, channel); return z_impl_dma_stop((const struct device *)dev, channel);
} }
#include <syscalls/dma_stop_mrsh.c> #include <syscalls/dma_stop_mrsh.c>

6
drivers/eeprom/eeprom_handlers.c
View file

@ -10,7 +10,7 @@
static inline int z_vrfy_eeprom_read(const struct device *dev, off_t offset, static inline int z_vrfy_eeprom_read(const struct device *dev, off_t offset,
void *data, size_t len) void *data, size_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_EEPROM(dev, read)); Z_OOPS(K_SYSCALL_DRIVER_EEPROM(dev, read));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len));
return z_impl_eeprom_read((const struct device *)dev, offset, return z_impl_eeprom_read((const struct device *)dev, offset,
(void *)data, (void *)data,
@ -21,7 +21,7 @@ static inline int z_vrfy_eeprom_read(const struct device *dev, off_t offset,
static inline int z_vrfy_eeprom_write(const struct device *dev, off_t offset, static inline int z_vrfy_eeprom_write(const struct device *dev, off_t offset,
const void *data, size_t len) const void *data, size_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_EEPROM(dev, write)); Z_OOPS(K_SYSCALL_DRIVER_EEPROM(dev, write));
Z_OOPS(K_SYSCALL_MEMORY_READ(data, len)); Z_OOPS(K_SYSCALL_MEMORY_READ(data, len));
return z_impl_eeprom_write((const struct device *)dev, offset, return z_impl_eeprom_write((const struct device *)dev, offset,
(const void *)data, len); (const void *)data, len);
@ -30,7 +30,7 @@ static inline int z_vrfy_eeprom_write(const struct device *dev, off_t offset,
static inline size_t z_vrfy_eeprom_get_size(const struct device *dev) static inline size_t z_vrfy_eeprom_get_size(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_EEPROM(dev, size)); Z_OOPS(K_SYSCALL_DRIVER_EEPROM(dev, size));
return z_impl_eeprom_get_size((const struct device *)dev); return z_impl_eeprom_get_size((const struct device *)dev);
} }
#include <syscalls/eeprom_get_size_mrsh.c> #include <syscalls/eeprom_get_size_mrsh.c>

2
drivers/entropy/entropy_handlers.c
View file

@ -11,7 +11,7 @@ static inline int z_vrfy_entropy_get_entropy(const struct device *dev,
uint8_t *buffer, uint8_t *buffer,
uint16_t len) uint16_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_ENTROPY(dev, get_entropy)); Z_OOPS(K_SYSCALL_DRIVER_ENTROPY(dev, get_entropy));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(buffer, len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(buffer, len));
return z_impl_entropy_get_entropy((const struct device *)dev, return z_impl_entropy_get_entropy((const struct device *)dev,
(uint8_t *)buffer, (uint8_t *)buffer,

26
drivers/espi/espi_handlers.c
View file

@ -13,7 +13,7 @@ static inline int z_vrfy_espi_config(const struct device *dev,
{ {
struct espi_cfg cfg_copy; struct espi_cfg cfg_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, config)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, config));
Z_OOPS(k_usermode_from_copy(&cfg_copy, cfg, Z_OOPS(k_usermode_from_copy(&cfg_copy, cfg,
sizeof(struct espi_cfg))); sizeof(struct espi_cfg)));
@ -24,7 +24,7 @@ static inline int z_vrfy_espi_config(const struct device *dev,
static inline bool z_vrfy_espi_get_channel_status(const struct device *dev, static inline bool z_vrfy_espi_get_channel_status(const struct device *dev,
enum espi_channel ch) enum espi_channel ch)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, get_channel_status)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, get_channel_status));
return z_impl_espi_get_channel_status(dev, ch); return z_impl_espi_get_channel_status(dev, ch);
} }
@ -37,7 +37,7 @@ static inline int z_vrfy_espi_read_lpc_request(const struct device *dev,
int ret; int ret;
uint32_t data_copy; uint32_t data_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, read_lpc_request)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, read_lpc_request));
ret = z_impl_espi_read_lpc_request(dev, op, &data_copy); ret = z_impl_espi_read_lpc_request(dev, op, &data_copy);
Z_OOPS(k_usermode_to_copy(data, &data_copy, sizeof(uint8_t))); Z_OOPS(k_usermode_to_copy(data, &data_copy, sizeof(uint8_t)));
@ -52,7 +52,7 @@ static inline int z_vrfy_espi_write_lpc_request(const struct device *dev,
{ {
uint32_t data_copy; uint32_t data_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, write_lpc_request)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, write_lpc_request));
Z_OOPS(k_usermode_from_copy(&data_copy, data, sizeof(*data))); Z_OOPS(k_usermode_from_copy(&data_copy, data, sizeof(*data)));
return z_impl_espi_write_lpc_request(dev, op, &data_copy); return z_impl_espi_write_lpc_request(dev, op, &data_copy);
@ -63,7 +63,7 @@ static inline int z_vrfy_espi_send_vwire(const struct device *dev,
enum espi_vwire_signal signal, enum espi_vwire_signal signal,
uint8_t level) uint8_t level)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, send_vwire)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, send_vwire));
return z_impl_espi_send_vwire(dev, signal, level); return z_impl_espi_send_vwire(dev, signal, level);
} }
@ -76,7 +76,7 @@ static inline int z_vrfy_espi_receive_vwire(const struct device *dev,
int ret; int ret;
uint8_t level_copy; uint8_t level_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, receive_vwire)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, receive_vwire));
ret = z_impl_espi_receive_vwire(dev, signal, &level_copy); ret = z_impl_espi_receive_vwire(dev, signal, &level_copy);
Z_OOPS(k_usermode_to_copy(level, &level_copy, sizeof(uint8_t))); Z_OOPS(k_usermode_to_copy(level, &level_copy, sizeof(uint8_t)));
@ -91,7 +91,7 @@ static inline int z_vrfy_espi_read_request(const struct device *dev,
int ret; int ret;
struct espi_request_packet req_copy; struct espi_request_packet req_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, read_request)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, read_request));
Z_OOPS(k_usermode_from_copy(&req_copy, req, Z_OOPS(k_usermode_from_copy(&req_copy, req,
sizeof(struct espi_request_packet))); sizeof(struct espi_request_packet)));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(req_copy.data, req_copy.len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(req_copy.data, req_copy.len));
@ -111,7 +111,7 @@ static inline int z_vrfy_espi_write_request(const struct device *dev,
int ret; int ret;
struct espi_request_packet req_copy; struct espi_request_packet req_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, write_request)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, write_request));
Z_OOPS(K_SYSCALL_MEMORY_READ(req->data, req->len)); Z_OOPS(K_SYSCALL_MEMORY_READ(req->data, req->len));
Z_OOPS(k_usermode_from_copy(&req_copy, req, Z_OOPS(k_usermode_from_copy(&req_copy, req,
sizeof(struct espi_request_packet))); sizeof(struct espi_request_packet)));
@ -128,7 +128,7 @@ static inline int z_vrfy_espi_send_oob(const struct device *dev,
int ret; int ret;
struct espi_oob_packet pckt_copy; struct espi_oob_packet pckt_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, send_oob)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, send_oob));
Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len)); Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len));
Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt, Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt,
sizeof(struct espi_oob_packet))); sizeof(struct espi_oob_packet)));
@ -145,7 +145,7 @@ static inline int z_vrfy_espi_receive_oob(const struct device *dev,
int ret; int ret;
struct espi_oob_packet pckt_copy; struct espi_oob_packet pckt_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, receive_oob)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, receive_oob));
Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt, Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt,
sizeof(struct espi_oob_packet))); sizeof(struct espi_oob_packet)));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len));
@ -164,7 +164,7 @@ static inline int z_vrfy_espi_read_flash(const struct device *dev,
int ret; int ret;
struct espi_flash_packet pckt_copy; struct espi_flash_packet pckt_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, flash_read)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, flash_read));
Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt, Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt,
sizeof(struct espi_flash_packet))); sizeof(struct espi_flash_packet)));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len));
@ -183,7 +183,7 @@ static inline int z_vrfy_espi_write_flash(const struct device *dev,
int ret; int ret;
struct espi_flash_packet pckt_copy; struct espi_flash_packet pckt_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, flash_write)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, flash_write));
Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt, Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt,
sizeof(struct espi_flash_packet))); sizeof(struct espi_flash_packet)));
Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len)); Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len));
@ -200,7 +200,7 @@ static inline int z_vrfy_espi_flash_erase(const struct device *dev,
int ret; int ret;
struct espi_flash_packet pckt_copy; struct espi_flash_packet pckt_copy;
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, flash_write)); Z_OOPS(K_SYSCALL_DRIVER_ESPI(dev, flash_write));
Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt, Z_OOPS(k_usermode_from_copy(&pckt_copy, pckt,
sizeof(struct espi_flash_packet))); sizeof(struct espi_flash_packet)));
Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len)); Z_OOPS(K_SYSCALL_MEMORY_READ(pckt->buf, pckt->len));

20
drivers/flash/flash_handlers.c
View file

@ -10,7 +10,7 @@
static inline int z_vrfy_flash_read(const struct device *dev, off_t offset, static inline int z_vrfy_flash_read(const struct device *dev, off_t offset,
void *data, size_t len) void *data, size_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, read)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, read));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len));
return z_impl_flash_read((const struct device *)dev, offset, return z_impl_flash_read((const struct device *)dev, offset,
(void *)data, (void *)data,
@ -21,7 +21,7 @@ static inline int z_vrfy_flash_read(const struct device *dev, off_t offset,
static inline int z_vrfy_flash_write(const struct device *dev, off_t offset, static inline int z_vrfy_flash_write(const struct device *dev, off_t offset,
const void *data, size_t len) const void *data, size_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, write)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, write));
Z_OOPS(K_SYSCALL_MEMORY_READ(data, len)); Z_OOPS(K_SYSCALL_MEMORY_READ(data, len));
return z_impl_flash_write((const struct device *)dev, offset, return z_impl_flash_write((const struct device *)dev, offset,
(const void *)data, len); (const void *)data, len);
@ -31,7 +31,7 @@ static inline int z_vrfy_flash_write(const struct device *dev, off_t offset,
static inline int z_vrfy_flash_erase(const struct device *dev, off_t offset, static inline int z_vrfy_flash_erase(const struct device *dev, off_t offset,
size_t size) size_t size)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, erase)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, erase));
return z_impl_flash_erase((const struct device *)dev, offset, size); return z_impl_flash_erase((const struct device *)dev, offset, size);
} }
#include <syscalls/flash_erase_mrsh.c> #include <syscalls/flash_erase_mrsh.c>
@ -45,7 +45,7 @@ static inline size_t z_vrfy_flash_get_write_block_size(const struct device *dev)
static inline const struct flash_parameters *z_vrfy_flash_get_parameters(const struct device *dev) static inline const struct flash_parameters *z_vrfy_flash_get_parameters(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, get_parameters)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, get_parameters));
return z_impl_flash_get_parameters(dev); return z_impl_flash_get_parameters(dev);
} }
#include <syscalls/flash_get_parameters_mrsh.c> #include <syscalls/flash_get_parameters_mrsh.c>
@ -55,7 +55,7 @@ static inline int z_vrfy_flash_get_page_info_by_offs(const struct device *dev,
off_t offs, off_t offs,
struct flash_pages_info *info) struct flash_pages_info *info)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, page_layout));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info)));
return z_impl_flash_get_page_info_by_offs((const struct device *)dev, return z_impl_flash_get_page_info_by_offs((const struct device *)dev,
offs, offs,
@ -67,7 +67,7 @@ static inline int z_vrfy_flash_get_page_info_by_idx(const struct device *dev,
uint32_t idx, uint32_t idx,
struct flash_pages_info *info) struct flash_pages_info *info)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, page_layout));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(info, sizeof(struct flash_pages_info)));
return z_impl_flash_get_page_info_by_idx((const struct device *)dev, return z_impl_flash_get_page_info_by_idx((const struct device *)dev,
idx, idx,
@ -77,7 +77,7 @@ static inline int z_vrfy_flash_get_page_info_by_idx(const struct device *dev,
static inline size_t z_vrfy_flash_get_page_count(const struct device *dev) static inline size_t z_vrfy_flash_get_page_count(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, page_layout)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, page_layout));
return z_impl_flash_get_page_count((const struct device *)dev); return z_impl_flash_get_page_count((const struct device *)dev);
} }
#include <syscalls/flash_get_page_count_mrsh.c> #include <syscalls/flash_get_page_count_mrsh.c>
@ -90,7 +90,7 @@ static inline int z_vrfy_flash_sfdp_read(const struct device *dev,
off_t offset, off_t offset,
void *data, size_t len) void *data, size_t len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, sfdp_read)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, sfdp_read));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(data, len));
return z_impl_flash_sfdp_read(dev, offset, data, len); return z_impl_flash_sfdp_read(dev, offset, data, len);
} }
@ -99,7 +99,7 @@ static inline int z_vrfy_flash_sfdp_read(const struct device *dev,
static inline int z_vrfy_flash_read_jedec_id(const struct device *dev, static inline int z_vrfy_flash_read_jedec_id(const struct device *dev,
uint8_t *id) uint8_t *id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, read_jedec_id)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, read_jedec_id));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(id, 3)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(id, 3));
return z_impl_flash_read_jedec_id(dev, id); return z_impl_flash_read_jedec_id(dev, id);
} }
@ -112,7 +112,7 @@ static inline int z_vrfy_flash_read_jedec_id(const struct device *dev,
static inline int z_vrfy_flash_ex_op(const struct device *dev, uint16_t code, static inline int z_vrfy_flash_ex_op(const struct device *dev, uint16_t code,
const uintptr_t in, void *out) const uintptr_t in, void *out)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FLASH(dev, ex_op)); Z_OOPS(K_SYSCALL_DRIVER_FLASH(dev, ex_op));
/* /*
* If the code is a vendor code, then ex_op function have to perform * If the code is a vendor code, then ex_op function have to perform

12
drivers/fuel_gauge/fuel_gauge_syscall_handlers.c
View file

@ -13,7 +13,7 @@ static inline int z_vrfy_fuel_gauge_get_prop(const struct device *dev, fuel_gaug
{ {
union fuel_gauge_prop_val k_val; union fuel_gauge_prop_val k_val;
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_property)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_property));
Z_OOPS(k_usermode_from_copy(&k_val, val, sizeof(union fuel_gauge_prop_val))); Z_OOPS(k_usermode_from_copy(&k_val, val, sizeof(union fuel_gauge_prop_val)));
@ -32,7 +32,7 @@ static inline int z_vrfy_fuel_gauge_get_props(const struct device *dev, fuel_gau
union fuel_gauge_prop_val k_vals[len]; union fuel_gauge_prop_val k_vals[len];
fuel_gauge_prop_t k_props[len]; fuel_gauge_prop_t k_props[len];
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_property)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_property));
Z_OOPS(k_usermode_from_copy(k_vals, vals, len * sizeof(union fuel_gauge_prop_val))); Z_OOPS(k_usermode_from_copy(k_vals, vals, len * sizeof(union fuel_gauge_prop_val)));
Z_OOPS(k_usermode_from_copy(k_props, props, len * sizeof(fuel_gauge_prop_t))); Z_OOPS(k_usermode_from_copy(k_props, props, len * sizeof(fuel_gauge_prop_t)));
@ -49,7 +49,7 @@ static inline int z_vrfy_fuel_gauge_get_props(const struct device *dev, fuel_gau
static inline int z_vrfy_fuel_gauge_set_prop(const struct device *dev, fuel_gauge_prop_t prop, static inline int z_vrfy_fuel_gauge_set_prop(const struct device *dev, fuel_gauge_prop_t prop,
union fuel_gauge_prop_val val) union fuel_gauge_prop_val val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, set_property)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, set_property));
int ret = z_impl_fuel_gauge_set_prop(dev, prop, val); int ret = z_impl_fuel_gauge_set_prop(dev, prop, val);
@ -64,7 +64,7 @@ static inline int z_vrfy_fuel_gauge_set_props(const struct device *dev, fuel_gau
union fuel_gauge_prop_val k_vals[len]; union fuel_gauge_prop_val k_vals[len];
fuel_gauge_prop_t k_props[len]; fuel_gauge_prop_t k_props[len];
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, set_property)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, set_property));
Z_OOPS(k_usermode_from_copy(k_vals, vals, len * sizeof(union fuel_gauge_prop_val))); Z_OOPS(k_usermode_from_copy(k_vals, vals, len * sizeof(union fuel_gauge_prop_val)));
Z_OOPS(k_usermode_from_copy(k_props, props, len * sizeof(fuel_gauge_prop_t))); Z_OOPS(k_usermode_from_copy(k_props, props, len * sizeof(fuel_gauge_prop_t)));
@ -83,7 +83,7 @@ static inline int z_vrfy_fuel_gauge_get_buffer_prop(const struct device *dev,
fuel_gauge_prop_t prop, void *dst, fuel_gauge_prop_t prop, void *dst,
size_t dst_len) size_t dst_len)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_buffer_property)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, get_buffer_property));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(dst, dst_len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(dst, dst_len));
@ -96,7 +96,7 @@ static inline int z_vrfy_fuel_gauge_get_buffer_prop(const struct device *dev,
static inline int z_vrfy_fuel_gauge_battery_cutoff(const struct device *dev) static inline int z_vrfy_fuel_gauge_battery_cutoff(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_FUEL_GAUGE(dev, battery_cutoff)); Z_OOPS(K_SYSCALL_DRIVER_FUEL_GAUGE(dev, battery_cutoff));
return z_impl_fuel_gauge_battery_cutoff(dev); return z_impl_fuel_gauge_battery_cutoff(dev);
} }

20
drivers/gpio/gpio_handlers.c
View file

@ -11,7 +11,7 @@ static inline int z_vrfy_gpio_pin_configure(const struct device *port,
gpio_pin_t pin, gpio_pin_t pin,
gpio_flags_t flags) gpio_flags_t flags)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, pin_configure)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, pin_configure));
return z_impl_gpio_pin_configure((const struct device *)port, return z_impl_gpio_pin_configure((const struct device *)port,
pin, pin,
flags); flags);
@ -23,7 +23,7 @@ static inline int z_vrfy_gpio_pin_get_config(const struct device *port,
gpio_pin_t pin, gpio_pin_t pin,
gpio_flags_t *flags) gpio_flags_t *flags)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, pin_get_config)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, pin_get_config));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(flags, sizeof(gpio_flags_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(flags, sizeof(gpio_flags_t)));
return z_impl_gpio_pin_get_config(port, pin, flags); return z_impl_gpio_pin_get_config(port, pin, flags);
@ -34,7 +34,7 @@ static inline int z_vrfy_gpio_pin_get_config(const struct device *port,
static inline int z_vrfy_gpio_port_get_raw(const struct device *port, static inline int z_vrfy_gpio_port_get_raw(const struct device *port,
gpio_port_value_t *value) gpio_port_value_t *value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, port_get_raw)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, port_get_raw));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(value, sizeof(gpio_port_value_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(value, sizeof(gpio_port_value_t)));
return z_impl_gpio_port_get_raw((const struct device *)port, return z_impl_gpio_port_get_raw((const struct device *)port,
(gpio_port_value_t *)value); (gpio_port_value_t *)value);
@ -45,7 +45,7 @@ static inline int z_vrfy_gpio_port_set_masked_raw(const struct device *port,
gpio_port_pins_t mask, gpio_port_pins_t mask,
gpio_port_value_t value) gpio_port_value_t value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, port_set_masked_raw)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, port_set_masked_raw));
return z_impl_gpio_port_set_masked_raw((const struct device *)port, return z_impl_gpio_port_set_masked_raw((const struct device *)port,
mask, mask,
value); value);
@ -55,7 +55,7 @@ static inline int z_vrfy_gpio_port_set_masked_raw(const struct device *port,
static inline int z_vrfy_gpio_port_set_bits_raw(const struct device *port, static inline int z_vrfy_gpio_port_set_bits_raw(const struct device *port,
gpio_port_pins_t pins) gpio_port_pins_t pins)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, port_set_bits_raw)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, port_set_bits_raw));
return z_impl_gpio_port_set_bits_raw((const struct device *)port, return z_impl_gpio_port_set_bits_raw((const struct device *)port,
pins); pins);
} }
@ -64,7 +64,7 @@ static inline int z_vrfy_gpio_port_set_bits_raw(const struct device *port,
static inline int z_vrfy_gpio_port_clear_bits_raw(const struct device *port, static inline int z_vrfy_gpio_port_clear_bits_raw(const struct device *port,
gpio_port_pins_t pins) gpio_port_pins_t pins)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, port_clear_bits_raw)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, port_clear_bits_raw));
return z_impl_gpio_port_clear_bits_raw((const struct device *)port, return z_impl_gpio_port_clear_bits_raw((const struct device *)port,
pins); pins);
} }
@ -73,7 +73,7 @@ static inline int z_vrfy_gpio_port_clear_bits_raw(const struct device *port,
static inline int z_vrfy_gpio_port_toggle_bits(const struct device *port, static inline int z_vrfy_gpio_port_toggle_bits(const struct device *port,
gpio_port_pins_t pins) gpio_port_pins_t pins)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, port_toggle_bits)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, port_toggle_bits));
return z_impl_gpio_port_toggle_bits((const struct device *)port, pins); return z_impl_gpio_port_toggle_bits((const struct device *)port, pins);
} }
#include <syscalls/gpio_port_toggle_bits_mrsh.c> #include <syscalls/gpio_port_toggle_bits_mrsh.c>
@ -82,7 +82,7 @@ static inline int z_vrfy_gpio_pin_interrupt_configure(const struct device *port,
gpio_pin_t pin, gpio_pin_t pin,
gpio_flags_t flags) gpio_flags_t flags)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(port, pin_interrupt_configure)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(port, pin_interrupt_configure));
return z_impl_gpio_pin_interrupt_configure((const struct device *)port, return z_impl_gpio_pin_interrupt_configure((const struct device *)port,
pin, pin,
flags); flags);
@ -91,7 +91,7 @@ static inline int z_vrfy_gpio_pin_interrupt_configure(const struct device *port,
static inline int z_vrfy_gpio_get_pending_int(const struct device *dev) static inline int z_vrfy_gpio_get_pending_int(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(dev, get_pending_int)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(dev, get_pending_int));
return z_impl_gpio_get_pending_int((const struct device *)dev); return z_impl_gpio_get_pending_int((const struct device *)dev);
} }
@ -102,7 +102,7 @@ static inline int z_vrfy_gpio_port_get_direction(const struct device *dev, gpio_
gpio_port_pins_t *inputs, gpio_port_pins_t *inputs,
gpio_port_pins_t *outputs) gpio_port_pins_t *outputs)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_GPIO(dev, port_get_direction)); Z_OOPS(K_SYSCALL_DRIVER_GPIO(dev, port_get_direction));
if (inputs != NULL) { if (inputs != NULL) {
Z_OOPS(K_SYSCALL_MEMORY_WRITE(inputs, sizeof(gpio_port_pins_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(inputs, sizeof(gpio_port_pins_t)));

8
drivers/hwspinlock/hwspinlock_handlers.c
View file

@ -9,7 +9,7 @@
static inline int z_vrfy_hwspinlock_trylock(const struct device *dev, uint32_t id) static inline int z_vrfy_hwspinlock_trylock(const struct device *dev, uint32_t id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_HWSPINLOCK(dev, trylock)); Z_OOPS(K_SYSCALL_DRIVER_HWSPINLOCK(dev, trylock));
return z_impl_hwspinlock_trylock(dev, id); return z_impl_hwspinlock_trylock(dev, id);
} }
@ -17,7 +17,7 @@ static inline int z_vrfy_hwspinlock_trylock(const struct device *dev, uint32_t i
static inline void z_vrfy_hwspinlock_lock(const struct device *dev, uint32_t id) static inline void z_vrfy_hwspinlock_lock(const struct device *dev, uint32_t id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_HWSPINLOCK(dev, lock)); Z_OOPS(K_SYSCALL_DRIVER_HWSPINLOCK(dev, lock));
z_impl_hwspinlock_lock(dev, id); z_impl_hwspinlock_lock(dev, id);
} }
@ -25,7 +25,7 @@ static inline void z_vrfy_hwspinlock_lock(const struct device *dev, uint32_t id)
static inline void z_vrfy_hwspinlock_unlock(const struct device *dev, uint32_t id) static inline void z_vrfy_hwspinlock_unlock(const struct device *dev, uint32_t id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_HWSPINLOCK(dev, unlock)); Z_OOPS(K_SYSCALL_DRIVER_HWSPINLOCK(dev, unlock));
z_impl_hwspinlock_unlock(dev, id); z_impl_hwspinlock_unlock(dev, id);
} }
@ -33,7 +33,7 @@ static inline void z_vrfy_hwspinlock_unlock(const struct device *dev, uint32_t i
static inline uint32_t z_vrfy_hwspinlock_get_max_id(const struct device *dev) static inline uint32_t z_vrfy_hwspinlock_get_max_id(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_HWSPINLOCK(dev, get_max_id)); Z_OOPS(K_SYSCALL_DRIVER_HWSPINLOCK(dev, get_max_id));
return z_impl_hwspinlock_get_max_id(dev); return z_impl_hwspinlock_get_max_id(dev);
} }

4
drivers/i2c/i2c_handlers.c
View file

@ -11,7 +11,7 @@
static inline int z_vrfy_i2c_configure(const struct device *dev, static inline int z_vrfy_i2c_configure(const struct device *dev,
uint32_t dev_config) uint32_t dev_config)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_I2C(dev, configure)); Z_OOPS(K_SYSCALL_DRIVER_I2C(dev, configure));
return z_impl_i2c_configure((const struct device *)dev, dev_config); return z_impl_i2c_configure((const struct device *)dev, dev_config);
} }
#include <syscalls/i2c_configure_mrsh.c> #include <syscalls/i2c_configure_mrsh.c>
@ -19,7 +19,7 @@ static inline int z_vrfy_i2c_configure(const struct device *dev,
static inline int z_vrfy_i2c_get_config(const struct device *dev, static inline int z_vrfy_i2c_get_config(const struct device *dev,
uint32_t *dev_config) uint32_t *dev_config)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_I2C(dev, get_config)); Z_OOPS(K_SYSCALL_DRIVER_I2C(dev, get_config));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(dev_config, sizeof(uint32_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(dev_config, sizeof(uint32_t)));
return z_impl_i2c_get_config(dev, dev_config); return z_impl_i2c_get_config(dev, dev_config);

8
drivers/i2s/i2s_handlers.c
View file

@ -16,7 +16,7 @@ static inline int z_vrfy_i2s_configure(const struct device *dev,
struct i2s_config config; struct i2s_config config;
int ret = -EINVAL; int ret = -EINVAL;
if (Z_SYSCALL_DRIVER_I2S(dev, configure)) { if (K_SYSCALL_DRIVER_I2S(dev, configure)) {
goto out; goto out;
} }
@ -50,7 +50,7 @@ static inline int z_vrfy_i2s_buf_read(const struct device *dev,
size_t data_size; size_t data_size;
int ret; int ret;
Z_OOPS(Z_SYSCALL_DRIVER_I2S(dev, read)); Z_OOPS(K_SYSCALL_DRIVER_I2S(dev, read));
ret = i2s_read((const struct device *)dev, &mem_block, &data_size); ret = i2s_read((const struct device *)dev, &mem_block, &data_size);
@ -83,7 +83,7 @@ static inline int z_vrfy_i2s_buf_write(const struct device *dev,
const struct i2s_config *tx_cfg; const struct i2s_config *tx_cfg;
void *mem_block; void *mem_block;
Z_OOPS(Z_SYSCALL_DRIVER_I2S(dev, write)); Z_OOPS(K_SYSCALL_DRIVER_I2S(dev, write));
tx_cfg = i2s_config_get((const struct device *)dev, I2S_DIR_TX); tx_cfg = i2s_config_get((const struct device *)dev, I2S_DIR_TX);
if (!tx_cfg) { if (!tx_cfg) {
return -EIO; return -EIO;
@ -117,7 +117,7 @@ static inline int z_vrfy_i2s_trigger(const struct device *dev,
enum i2s_dir dir, enum i2s_dir dir,
enum i2s_trigger_cmd cmd) enum i2s_trigger_cmd cmd)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_I2S(dev, trigger)); Z_OOPS(K_SYSCALL_DRIVER_I2S(dev, trigger));
return z_impl_i2s_trigger((const struct device *)dev, dir, cmd); return z_impl_i2s_trigger((const struct device *)dev, dir, cmd);
} }

2
drivers/i3c/i3c_handlers.c
View file

@ -11,7 +11,7 @@
static inline int z_vrfy_i3c_do_ccc(const struct device *dev, static inline int z_vrfy_i3c_do_ccc(const struct device *dev,
struct i3c_ccc_payload *payload) struct i3c_ccc_payload *payload)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_I3C(dev, do_ccc)); Z_OOPS(K_SYSCALL_DRIVER_I3C(dev, do_ccc));
Z_OOPS(K_SYSCALL_MEMORY_READ(payload, sizeof(*payload))); Z_OOPS(K_SYSCALL_MEMORY_READ(payload, sizeof(*payload)));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(payload, sizeof(*payload))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(payload, sizeof(*payload)));

8
drivers/ipm/ipm_handlers.c
View file

@ -11,7 +11,7 @@ static inline int z_vrfy_ipm_send(const struct device *dev, int wait,
uint32_t id, uint32_t id,
const void *data, int size) const void *data, int size)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, send)); Z_OOPS(K_SYSCALL_DRIVER_IPM(dev, send));
Z_OOPS(K_SYSCALL_MEMORY_READ(data, size)); Z_OOPS(K_SYSCALL_MEMORY_READ(data, size));
return z_impl_ipm_send((const struct device *)dev, wait, id, return z_impl_ipm_send((const struct device *)dev, wait, id,
(const void *)data, size); (const void *)data, size);
@ -20,21 +20,21 @@ static inline int z_vrfy_ipm_send(const struct device *dev, int wait,
static inline int z_vrfy_ipm_max_data_size_get(const struct device *dev) static inline int z_vrfy_ipm_max_data_size_get(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, max_data_size_get)); Z_OOPS(K_SYSCALL_DRIVER_IPM(dev, max_data_size_get));
return z_impl_ipm_max_data_size_get((const struct device *)dev); return z_impl_ipm_max_data_size_get((const struct device *)dev);
} }
#include <syscalls/ipm_max_data_size_get_mrsh.c> #include <syscalls/ipm_max_data_size_get_mrsh.c>
static inline uint32_t z_vrfy_ipm_max_id_val_get(const struct device *dev) static inline uint32_t z_vrfy_ipm_max_id_val_get(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, max_id_val_get)); Z_OOPS(K_SYSCALL_DRIVER_IPM(dev, max_id_val_get));
return z_impl_ipm_max_id_val_get((const struct device *)dev); return z_impl_ipm_max_id_val_get((const struct device *)dev);
} }
#include <syscalls/ipm_max_id_val_get_mrsh.c> #include <syscalls/ipm_max_id_val_get_mrsh.c>
static inline int z_vrfy_ipm_set_enabled(const struct device *dev, int enable) static inline int z_vrfy_ipm_set_enabled(const struct device *dev, int enable)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IPM(dev, set_enabled)); Z_OOPS(K_SYSCALL_DRIVER_IPM(dev, set_enabled));
return z_impl_ipm_set_enabled((const struct device *)dev, enable); return z_impl_ipm_set_enabled((const struct device *)dev, enable);
} }
#include <syscalls/ipm_set_enabled_mrsh.c> #include <syscalls/ipm_set_enabled_mrsh.c>

6
drivers/kscan/kscan_handlers.c
View file

@ -10,7 +10,7 @@
static inline int z_vrfy_kscan_config(const struct device *dev, static inline int z_vrfy_kscan_config(const struct device *dev,
kscan_callback_t callback_isr) kscan_callback_t callback_isr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_KSCAN(dev, config)); Z_OOPS(K_SYSCALL_DRIVER_KSCAN(dev, config));
Z_OOPS(K_SYSCALL_VERIFY_MSG(callback_isr == 0, Z_OOPS(K_SYSCALL_VERIFY_MSG(callback_isr == 0,
"callback cannot be set from user mode")); "callback cannot be set from user mode"));
return z_impl_kscan_config((const struct device *)dev, callback_isr); return z_impl_kscan_config((const struct device *)dev, callback_isr);
@ -19,7 +19,7 @@ static inline int z_vrfy_kscan_config(const struct device *dev,
static inline int z_vrfy_kscan_disable_callback(const struct device *dev) static inline int z_vrfy_kscan_disable_callback(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_KSCAN(dev, disable_callback)); Z_OOPS(K_SYSCALL_DRIVER_KSCAN(dev, disable_callback));
return z_impl_kscan_disable_callback((const struct device *)dev); return z_impl_kscan_disable_callback((const struct device *)dev);
} }
@ -27,7 +27,7 @@ static inline int z_vrfy_kscan_disable_callback(const struct device *dev)
static int z_vrfy_kscan_enable_callback(const struct device *dev) static int z_vrfy_kscan_enable_callback(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_KSCAN(dev, enable_callback)); Z_OOPS(K_SYSCALL_DRIVER_KSCAN(dev, enable_callback));
return z_impl_kscan_enable_callback((const struct device *)dev); return z_impl_kscan_enable_callback((const struct device *)dev);
} }

8
drivers/led/led_handlers.c
View file

@ -10,7 +10,7 @@
static inline int z_vrfy_led_blink(const struct device *dev, uint32_t led, static inline int z_vrfy_led_blink(const struct device *dev, uint32_t led,
uint32_t delay_on, uint32_t delay_off) uint32_t delay_on, uint32_t delay_off)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, blink)); Z_OOPS(K_SYSCALL_DRIVER_LED(dev, blink));
return z_impl_led_blink((const struct device *)dev, led, delay_on, return z_impl_led_blink((const struct device *)dev, led, delay_on,
delay_off); delay_off);
} }
@ -29,7 +29,7 @@ static inline int z_vrfy_led_set_brightness(const struct device *dev,
uint32_t led, uint32_t led,
uint8_t value) uint8_t value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, set_brightness)); Z_OOPS(K_SYSCALL_DRIVER_LED(dev, set_brightness));
return z_impl_led_set_brightness((const struct device *)dev, led, return z_impl_led_set_brightness((const struct device *)dev, led,
value); value);
} }
@ -64,14 +64,14 @@ static inline int z_vrfy_led_set_color(const struct device *dev, uint32_t led,
static inline int z_vrfy_led_on(const struct device *dev, uint32_t led) static inline int z_vrfy_led_on(const struct device *dev, uint32_t led)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, on)); Z_OOPS(K_SYSCALL_DRIVER_LED(dev, on));
return z_impl_led_on((const struct device *)dev, led); return z_impl_led_on((const struct device *)dev, led);
} }
#include <syscalls/led_on_mrsh.c> #include <syscalls/led_on_mrsh.c>
static inline int z_vrfy_led_off(const struct device *dev, uint32_t led) static inline int z_vrfy_led_off(const struct device *dev, uint32_t led)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_LED(dev, off)); Z_OOPS(K_SYSCALL_DRIVER_LED(dev, off));
return z_impl_led_off((const struct device *)dev, led); return z_impl_led_off((const struct device *)dev, led);
} }
#include <syscalls/led_off_mrsh.c> #include <syscalls/led_off_mrsh.c>

8
drivers/mbox/mbox_handlers.c
View file

@ -11,7 +11,7 @@ static inline int z_vrfy_mbox_send(const struct mbox_channel *channel,
const struct mbox_msg *msg) const struct mbox_msg *msg)
{ {
Z_OOPS(K_SYSCALL_MEMORY_READ(channel, sizeof(struct mbox_channel))); Z_OOPS(K_SYSCALL_MEMORY_READ(channel, sizeof(struct mbox_channel)));
Z_OOPS(Z_SYSCALL_DRIVER_MBOX(channel->dev, send)); Z_OOPS(K_SYSCALL_DRIVER_MBOX(channel->dev, send));
Z_OOPS(K_SYSCALL_MEMORY_READ(msg, sizeof(struct mbox_msg))); Z_OOPS(K_SYSCALL_MEMORY_READ(msg, sizeof(struct mbox_msg)));
Z_OOPS(K_SYSCALL_MEMORY_READ(msg->data, msg->size)); Z_OOPS(K_SYSCALL_MEMORY_READ(msg->data, msg->size));
@ -21,7 +21,7 @@ static inline int z_vrfy_mbox_send(const struct mbox_channel *channel,
static inline int z_vrfy_mbox_mtu_get(const struct device *dev) static inline int z_vrfy_mbox_mtu_get(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_MBOX(dev, mtu_get)); Z_OOPS(K_SYSCALL_DRIVER_MBOX(dev, mtu_get));
return z_impl_mbox_mtu_get(dev); return z_impl_mbox_mtu_get(dev);
} }
@ -29,7 +29,7 @@ static inline int z_vrfy_mbox_mtu_get(const struct device *dev)
static inline uint32_t z_vrfy_mbox_max_channels_get(const struct device *dev) static inline uint32_t z_vrfy_mbox_max_channels_get(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_MBOX(dev, max_channels_get)); Z_OOPS(K_SYSCALL_DRIVER_MBOX(dev, max_channels_get));
return z_impl_mbox_max_channels_get(dev); return z_impl_mbox_max_channels_get(dev);
} }
@ -38,7 +38,7 @@ static inline uint32_t z_vrfy_mbox_max_channels_get(const struct device *dev)
static inline int z_vrfy_mbox_set_enabled(const struct mbox_channel *channel, bool enable) static inline int z_vrfy_mbox_set_enabled(const struct mbox_channel *channel, bool enable)
{ {
Z_OOPS(K_SYSCALL_MEMORY_READ(channel, sizeof(struct mbox_channel))); Z_OOPS(K_SYSCALL_MEMORY_READ(channel, sizeof(struct mbox_channel)));
Z_OOPS(Z_SYSCALL_DRIVER_MBOX(channel->dev, set_enabled)); Z_OOPS(K_SYSCALL_DRIVER_MBOX(channel->dev, set_enabled));
return z_impl_mbox_set_enabled(channel, enable); return z_impl_mbox_set_enabled(channel, enable);
} }

8
drivers/peci/peci_handlers.c
View file

@ -11,7 +11,7 @@
static inline int z_vrfy_peci_config(const struct device *dev, static inline int z_vrfy_peci_config(const struct device *dev,
uint32_t bitrate) uint32_t bitrate)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PECI(dev, config)); Z_OOPS(K_SYSCALL_DRIVER_PECI(dev, config));
return z_impl_peci_config(dev, bitrate); return z_impl_peci_config(dev, bitrate);
} }
@ -19,7 +19,7 @@ static inline int z_vrfy_peci_config(const struct device *dev,
static inline int z_vrfy_peci_enable(const struct device *dev) static inline int z_vrfy_peci_enable(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PECI(dev, enable)); Z_OOPS(K_SYSCALL_DRIVER_PECI(dev, enable));
return z_impl_peci_enable(dev); return z_impl_peci_enable(dev);
} }
@ -27,7 +27,7 @@ static inline int z_vrfy_peci_enable(const struct device *dev)
static inline int z_vrfy_peci_disable(const struct device *dev) static inline int z_vrfy_peci_disable(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PECI(dev, disable)); Z_OOPS(K_SYSCALL_DRIVER_PECI(dev, disable));
return z_impl_peci_disable(dev); return z_impl_peci_disable(dev);
} }
@ -38,7 +38,7 @@ static inline int z_vrfy_peci_transfer(const struct device *dev,
{ {
struct peci_msg msg_copy; struct peci_msg msg_copy;
Z_OOPS(Z_SYSCALL_DRIVER_PECI(dev, transfer)); Z_OOPS(K_SYSCALL_DRIVER_PECI(dev, transfer));
Z_OOPS(k_usermode_from_copy(&msg_copy, msg, sizeof(*msg))); Z_OOPS(k_usermode_from_copy(&msg_copy, msg, sizeof(*msg)));
return z_impl_peci_transfer(dev, &msg_copy); return z_impl_peci_transfer(dev, &msg_copy);

10
drivers/ps2/ps2_handlers.c
View file

@ -10,7 +10,7 @@
static inline int z_vrfy_ps2_config(const struct device *dev, static inline int z_vrfy_ps2_config(const struct device *dev,
ps2_callback_t callback_isr) ps2_callback_t callback_isr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PS2(dev, config)); Z_OOPS(K_SYSCALL_DRIVER_PS2(dev, config));
Z_OOPS(K_SYSCALL_VERIFY_MSG(callback_isr == NULL, Z_OOPS(K_SYSCALL_VERIFY_MSG(callback_isr == NULL,
"callback not be set from user mode")); "callback not be set from user mode"));
return z_impl_ps2_config(dev, callback_isr); return z_impl_ps2_config(dev, callback_isr);
@ -19,14 +19,14 @@ static inline int z_vrfy_ps2_config(const struct device *dev,
static inline int z_vrfy_ps2_write(const struct device *dev, uint8_t value) static inline int z_vrfy_ps2_write(const struct device *dev, uint8_t value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PS2(dev, write)); Z_OOPS(K_SYSCALL_DRIVER_PS2(dev, write));
return z_impl_ps2_write(dev, value); return z_impl_ps2_write(dev, value);
} }
#include <syscalls/ps2_write_mrsh.c> #include <syscalls/ps2_write_mrsh.c>
static inline int z_vrfy_ps2_read(const struct device *dev, uint8_t *value) static inline int z_vrfy_ps2_read(const struct device *dev, uint8_t *value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PS2(dev, read)); Z_OOPS(K_SYSCALL_DRIVER_PS2(dev, read));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(value, sizeof(uint8_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(value, sizeof(uint8_t)));
return z_impl_ps2_read(dev, value); return z_impl_ps2_read(dev, value);
} }
@ -34,14 +34,14 @@ static inline int z_vrfy_ps2_read(const struct device *dev, uint8_t *value)
static inline int z_vrfy_ps2_enable_callback(const struct device *dev) static inline int z_vrfy_ps2_enable_callback(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PS2(dev, enable_callback)); Z_OOPS(K_SYSCALL_DRIVER_PS2(dev, enable_callback));
return z_impl_ps2_enable_callback(dev); return z_impl_ps2_enable_callback(dev);
} }
#include <syscalls/ps2_enable_callback_mrsh.c> #include <syscalls/ps2_enable_callback_mrsh.c>
static inline int z_vrfy_ps2_disable_callback(const struct device *dev) static inline int z_vrfy_ps2_disable_callback(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PS2(dev, disable_callback)); Z_OOPS(K_SYSCALL_DRIVER_PS2(dev, disable_callback));
return z_impl_ps2_disable_callback(dev); return z_impl_ps2_disable_callback(dev);
} }
#include <syscalls/ps2_disable_callback_mrsh.c> #include <syscalls/ps2_disable_callback_mrsh.c>

2
drivers/ptp_clock/ptp_clock.c
View file

@ -14,7 +14,7 @@ int z_vrfy_ptp_clock_get(const struct device *dev,
struct net_ptp_time ptp_time; struct net_ptp_time ptp_time;
int ret; int ret;
Z_OOPS(Z_SYSCALL_DRIVER_PTP_CLOCK(dev, get)); Z_OOPS(K_SYSCALL_DRIVER_PTP_CLOCK(dev, get));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(tm, sizeof(struct net_ptp_time))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(tm, sizeof(struct net_ptp_time)));
ret = z_impl_ptp_clock_get((const struct device *)dev, &ptp_time); ret = z_impl_ptp_clock_get((const struct device *)dev, &ptp_time);

14
drivers/pwm/pwm_handlers.c
View file

@ -12,7 +12,7 @@ static inline int z_vrfy_pwm_set_cycles(const struct device *dev,
uint32_t channel, uint32_t period, uint32_t channel, uint32_t period,
uint32_t pulse, pwm_flags_t flags) uint32_t pulse, pwm_flags_t flags)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, set_cycles)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, set_cycles));
return z_impl_pwm_set_cycles((const struct device *)dev, channel, return z_impl_pwm_set_cycles((const struct device *)dev, channel,
period, pulse, flags); period, pulse, flags);
} }
@ -22,7 +22,7 @@ static inline int z_vrfy_pwm_get_cycles_per_sec(const struct device *dev,
uint32_t channel, uint32_t channel,
uint64_t *cycles) uint64_t *cycles)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, get_cycles_per_sec)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, get_cycles_per_sec));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(cycles, sizeof(uint64_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(cycles, sizeof(uint64_t)));
return z_impl_pwm_get_cycles_per_sec((const struct device *)dev, return z_impl_pwm_get_cycles_per_sec((const struct device *)dev,
channel, (uint64_t *)cycles); channel, (uint64_t *)cycles);
@ -34,7 +34,7 @@ static inline int z_vrfy_pwm_get_cycles_per_sec(const struct device *dev,
static inline int z_vrfy_pwm_enable_capture(const struct device *dev, static inline int z_vrfy_pwm_enable_capture(const struct device *dev,
uint32_t channel) uint32_t channel)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, enable_capture)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, enable_capture));
return z_impl_pwm_enable_capture((const struct device *)dev, channel); return z_impl_pwm_enable_capture((const struct device *)dev, channel);
} }
#include <syscalls/pwm_enable_capture_mrsh.c> #include <syscalls/pwm_enable_capture_mrsh.c>
@ -42,7 +42,7 @@ static inline int z_vrfy_pwm_enable_capture(const struct device *dev,
static inline int z_vrfy_pwm_disable_capture(const struct device *dev, static inline int z_vrfy_pwm_disable_capture(const struct device *dev,
uint32_t channel) uint32_t channel)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, disable_capture)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, disable_capture));
return z_impl_pwm_disable_capture((const struct device *)dev, channel); return z_impl_pwm_disable_capture((const struct device *)dev, channel);
} }
#include <syscalls/pwm_disable_capture_mrsh.c> #include <syscalls/pwm_disable_capture_mrsh.c>
@ -57,9 +57,9 @@ static inline int z_vrfy_pwm_capture_cycles(const struct device *dev,
uint32_t pulse; uint32_t pulse;
int err; int err;
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, configure_capture)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, configure_capture));
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, enable_capture)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, enable_capture));
Z_OOPS(Z_SYSCALL_DRIVER_PWM(dev, disable_capture)); Z_OOPS(K_SYSCALL_DRIVER_PWM(dev, disable_capture));
err = z_impl_pwm_capture_cycles((const struct device *)dev, channel, err = z_impl_pwm_capture_cycles((const struct device *)dev, channel,
flags, &period, &pulse, timeout); flags, &period, &pulse, timeout);

16
drivers/rtc/rtc_handlers.c
View file

@ -9,7 +9,7 @@
static inline int z_vrfy_rtc_set_time(const struct device *dev, const struct rtc_time *timeptr) static inline int z_vrfy_rtc_set_time(const struct device *dev, const struct rtc_time *timeptr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, set_time)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, set_time));
Z_OOPS(K_SYSCALL_MEMORY_READ(timeptr, sizeof(struct rtc_time))); Z_OOPS(K_SYSCALL_MEMORY_READ(timeptr, sizeof(struct rtc_time)));
return z_impl_rtc_set_time(dev, timeptr); return z_impl_rtc_set_time(dev, timeptr);
} }
@ -17,7 +17,7 @@ static inline int z_vrfy_rtc_set_time(const struct device *dev, const struct rtc
static inline int z_vrfy_rtc_get_time(const struct device *dev, struct rtc_time *timeptr) static inline int z_vrfy_rtc_get_time(const struct device *dev, struct rtc_time *timeptr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, get_time)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, get_time));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(timeptr, sizeof(struct rtc_time))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(timeptr, sizeof(struct rtc_time)));
return z_impl_rtc_get_time(dev, timeptr); return z_impl_rtc_get_time(dev, timeptr);
} }
@ -27,7 +27,7 @@ static inline int z_vrfy_rtc_get_time(const struct device *dev, struct rtc_time
static inline int z_vrfy_rtc_alarm_get_supported_fields(const struct device *dev, uint16_t id, static inline int z_vrfy_rtc_alarm_get_supported_fields(const struct device *dev, uint16_t id,
uint16_t *mask) uint16_t *mask)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, alarm_get_supported_fields)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, alarm_get_supported_fields));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(mask, sizeof(uint16_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(mask, sizeof(uint16_t)));
return z_impl_rtc_alarm_get_supported_fields(dev, id, mask); return z_impl_rtc_alarm_get_supported_fields(dev, id, mask);
} }
@ -36,7 +36,7 @@ static inline int z_vrfy_rtc_alarm_get_supported_fields(const struct device *dev
static inline int z_vrfy_rtc_alarm_set_time(const struct device *dev, uint16_t id, uint16_t mask, static inline int z_vrfy_rtc_alarm_set_time(const struct device *dev, uint16_t id, uint16_t mask,
const struct rtc_time *timeptr) const struct rtc_time *timeptr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, alarm_set_time)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, alarm_set_time));
Z_OOPS(K_SYSCALL_MEMORY_READ(timeptr, sizeof(struct rtc_time))); Z_OOPS(K_SYSCALL_MEMORY_READ(timeptr, sizeof(struct rtc_time)));
return z_impl_rtc_alarm_set_time(dev, id, mask, timeptr); return z_impl_rtc_alarm_set_time(dev, id, mask, timeptr);
} }
@ -45,7 +45,7 @@ static inline int z_vrfy_rtc_alarm_set_time(const struct device *dev, uint16_t i
static inline int z_vrfy_rtc_alarm_get_time(const struct device *dev, uint16_t id, uint16_t *mask, static inline int z_vrfy_rtc_alarm_get_time(const struct device *dev, uint16_t id, uint16_t *mask,
struct rtc_time *timeptr) struct rtc_time *timeptr)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, alarm_get_time)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, alarm_get_time));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(mask, sizeof(uint16_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(mask, sizeof(uint16_t)));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(timeptr, sizeof(struct rtc_time))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(timeptr, sizeof(struct rtc_time)));
return z_impl_rtc_alarm_get_time(dev, id, mask, timeptr); return z_impl_rtc_alarm_get_time(dev, id, mask, timeptr);
@ -54,7 +54,7 @@ static inline int z_vrfy_rtc_alarm_get_time(const struct device *dev, uint16_t i
static inline int z_vrfy_rtc_alarm_is_pending(const struct device *dev, uint16_t id) static inline int z_vrfy_rtc_alarm_is_pending(const struct device *dev, uint16_t id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, alarm_is_pending)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, alarm_is_pending));
return z_impl_rtc_alarm_is_pending(dev, id); return z_impl_rtc_alarm_is_pending(dev, id);
} }
#include <syscalls/rtc_alarm_is_pending_mrsh.c> #include <syscalls/rtc_alarm_is_pending_mrsh.c>
@ -63,7 +63,7 @@ static inline int z_vrfy_rtc_alarm_is_pending(const struct device *dev, uint16_t
#ifdef CONFIG_RTC_CALIBRATION #ifdef CONFIG_RTC_CALIBRATION
static inline int z_vrfy_rtc_set_calibration(const struct device *dev, int32_t calibration) static inline int z_vrfy_rtc_set_calibration(const struct device *dev, int32_t calibration)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, set_calibration)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, set_calibration));
return z_impl_rtc_set_calibration(dev, calibration); return z_impl_rtc_set_calibration(dev, calibration);
} }
@ -71,7 +71,7 @@ static inline int z_vrfy_rtc_set_calibration(const struct device *dev, int32_t c
static inline int z_vrfy_rtc_get_calibration(const struct device *dev, int32_t *calibration) static inline int z_vrfy_rtc_get_calibration(const struct device *dev, int32_t *calibration)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_RTC(dev, get_calibration)); Z_OOPS(K_SYSCALL_DRIVER_RTC(dev, get_calibration));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(calibration, sizeof(int32_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(calibration, sizeof(int32_t)));
return z_impl_rtc_get_calibration(dev, calibration); return z_impl_rtc_get_calibration(dev, calibration);
} }

10
drivers/sensor/sensor_handlers.c
View file

@ -12,7 +12,7 @@ static inline int z_vrfy_sensor_attr_set(const struct device *dev,
enum sensor_attribute attr, enum sensor_attribute attr,
const struct sensor_value *val) const struct sensor_value *val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, attr_set)); Z_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, attr_set));
Z_OOPS(K_SYSCALL_MEMORY_READ(val, sizeof(struct sensor_value))); Z_OOPS(K_SYSCALL_MEMORY_READ(val, sizeof(struct sensor_value)));
return z_impl_sensor_attr_set((const struct device *)dev, chan, attr, return z_impl_sensor_attr_set((const struct device *)dev, chan, attr,
(const struct sensor_value *)val); (const struct sensor_value *)val);
@ -24,7 +24,7 @@ static inline int z_vrfy_sensor_attr_get(const struct device *dev,
enum sensor_attribute attr, enum sensor_attribute attr,
struct sensor_value *val) struct sensor_value *val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, attr_get)); Z_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, attr_get));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value)));
return z_impl_sensor_attr_get((const struct device *)dev, chan, attr, return z_impl_sensor_attr_get((const struct device *)dev, chan, attr,
(struct sensor_value *)val); (struct sensor_value *)val);
@ -33,7 +33,7 @@ static inline int z_vrfy_sensor_attr_get(const struct device *dev,
static inline int z_vrfy_sensor_sample_fetch(const struct device *dev) static inline int z_vrfy_sensor_sample_fetch(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, sample_fetch)); Z_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return z_impl_sensor_sample_fetch((const struct device *)dev); return z_impl_sensor_sample_fetch((const struct device *)dev);
} }
#include <syscalls/sensor_sample_fetch_mrsh.c> #include <syscalls/sensor_sample_fetch_mrsh.c>
@ -41,7 +41,7 @@ static inline int z_vrfy_sensor_sample_fetch(const struct device *dev)
static inline int z_vrfy_sensor_sample_fetch_chan(const struct device *dev, static inline int z_vrfy_sensor_sample_fetch_chan(const struct device *dev,
enum sensor_channel type) enum sensor_channel type)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, sample_fetch)); Z_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, sample_fetch));
return z_impl_sensor_sample_fetch_chan((const struct device *)dev, return z_impl_sensor_sample_fetch_chan((const struct device *)dev,
type); type);
} }
@ -51,7 +51,7 @@ static inline int z_vrfy_sensor_channel_get(const struct device *dev,
enum sensor_channel chan, enum sensor_channel chan,
struct sensor_value *val) struct sensor_value *val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SENSOR(dev, channel_get)); Z_OOPS(K_SYSCALL_DRIVER_SENSOR(dev, channel_get));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(struct sensor_value)));
return z_impl_sensor_channel_get((const struct device *)dev, chan, return z_impl_sensor_channel_get((const struct device *)dev, chan,
(struct sensor_value *)val); (struct sensor_value *)val);

30
drivers/serial/uart_handlers.c
View file

@ -10,14 +10,14 @@
#define UART_SIMPLE(op_) \ #define UART_SIMPLE(op_) \
static inline int z_vrfy_uart_##op_(const struct device *dev) \ static inline int z_vrfy_uart_##op_(const struct device *dev) \
{ \ { \
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, op_)); \ Z_OOPS(K_SYSCALL_DRIVER_UART(dev, op_)); \
return z_impl_uart_ ## op_(dev); \ return z_impl_uart_ ## op_(dev); \
} }
#define UART_SIMPLE_VOID(op_) \ #define UART_SIMPLE_VOID(op_) \
static inline void z_vrfy_uart_##op_(const struct device *dev) \ static inline void z_vrfy_uart_##op_(const struct device *dev) \
{ \ { \
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, op_)); \ Z_OOPS(K_SYSCALL_DRIVER_UART(dev, op_)); \
z_impl_uart_ ## op_(dev); \ z_impl_uart_ ## op_(dev); \
} }
@ -27,7 +27,7 @@ UART_SIMPLE(err_check)
static inline int z_vrfy_uart_poll_in(const struct device *dev, static inline int z_vrfy_uart_poll_in(const struct device *dev,
unsigned char *p_char) unsigned char *p_char)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_in)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, poll_in));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(p_char, sizeof(unsigned char))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(p_char, sizeof(unsigned char)));
return z_impl_uart_poll_in(dev, p_char); return z_impl_uart_poll_in(dev, p_char);
} }
@ -36,7 +36,7 @@ static inline int z_vrfy_uart_poll_in(const struct device *dev,
static inline int z_vrfy_uart_poll_in_u16(const struct device *dev, static inline int z_vrfy_uart_poll_in_u16(const struct device *dev,
uint16_t *p_u16) uint16_t *p_u16)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_in)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, poll_in));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(p_u16, sizeof(uint16_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(p_u16, sizeof(uint16_t)));
return z_impl_uart_poll_in_u16(dev, p_u16); return z_impl_uart_poll_in_u16(dev, p_u16);
} }
@ -45,7 +45,7 @@ static inline int z_vrfy_uart_poll_in_u16(const struct device *dev,
static inline void z_vrfy_uart_poll_out(const struct device *dev, static inline void z_vrfy_uart_poll_out(const struct device *dev,
unsigned char out_char) unsigned char out_char)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_out)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, poll_out));
z_impl_uart_poll_out((const struct device *)dev, out_char); z_impl_uart_poll_out((const struct device *)dev, out_char);
} }
#include <syscalls/uart_poll_out_mrsh.c> #include <syscalls/uart_poll_out_mrsh.c>
@ -53,7 +53,7 @@ static inline void z_vrfy_uart_poll_out(const struct device *dev,
static inline void z_vrfy_uart_poll_out_u16(const struct device *dev, static inline void z_vrfy_uart_poll_out_u16(const struct device *dev,
uint16_t out_u16) uint16_t out_u16)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, poll_out)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, poll_out));
z_impl_uart_poll_out_u16((const struct device *)dev, out_u16); z_impl_uart_poll_out_u16((const struct device *)dev, out_u16);
} }
#include <syscalls/uart_poll_out_u16_mrsh.c> #include <syscalls/uart_poll_out_u16_mrsh.c>
@ -62,7 +62,7 @@ static inline void z_vrfy_uart_poll_out_u16(const struct device *dev,
static inline int z_vrfy_uart_config_get(const struct device *dev, static inline int z_vrfy_uart_config_get(const struct device *dev,
struct uart_config *cfg) struct uart_config *cfg)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, config_get)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, config_get));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(cfg, sizeof(struct uart_config))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(cfg, sizeof(struct uart_config)));
return z_impl_uart_config_get(dev, cfg); return z_impl_uart_config_get(dev, cfg);
@ -72,7 +72,7 @@ static inline int z_vrfy_uart_config_get(const struct device *dev,
static inline int z_vrfy_uart_configure(const struct device *dev, static inline int z_vrfy_uart_configure(const struct device *dev,
const struct uart_config *cfg) const struct uart_config *cfg)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, config_get)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, config_get));
Z_OOPS(K_SYSCALL_MEMORY_READ(cfg, sizeof(struct uart_config))); Z_OOPS(K_SYSCALL_MEMORY_READ(cfg, sizeof(struct uart_config)));
return z_impl_uart_configure(dev, cfg); return z_impl_uart_configure(dev, cfg);
@ -90,7 +90,7 @@ static inline int z_vrfy_uart_configure(const struct device *dev,
static inline int z_vrfy_uart_tx(const struct device *dev, const uint8_t *buf, static inline int z_vrfy_uart_tx(const struct device *dev, const uint8_t *buf,
size_t len, int32_t timeout) size_t len, int32_t timeout)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, tx)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, tx));
Z_OOPS(K_SYSCALL_MEMORY_READ(buf, len)); Z_OOPS(K_SYSCALL_MEMORY_READ(buf, len));
return z_impl_uart_tx(dev, buf, len, timeout); return z_impl_uart_tx(dev, buf, len, timeout);
} }
@ -101,7 +101,7 @@ static inline int z_vrfy_uart_tx_u16(const struct device *dev,
const uint16_t *buf, const uint16_t *buf,
size_t len, int32_t timeout) size_t len, int32_t timeout)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, tx)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, tx));
Z_OOPS(K_SYSCALL_MEMORY_ARRAY_READ(buf, len, sizeof(uint16_t))); Z_OOPS(K_SYSCALL_MEMORY_ARRAY_READ(buf, len, sizeof(uint16_t)));
return z_impl_uart_tx_u16(dev, buf, len, timeout); return z_impl_uart_tx_u16(dev, buf, len, timeout);
} }
@ -115,7 +115,7 @@ static inline int z_vrfy_uart_rx_enable(const struct device *dev,
uint8_t *buf, uint8_t *buf,
size_t len, int32_t timeout) size_t len, int32_t timeout)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, rx_enable)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, rx_enable));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(buf, len)); Z_OOPS(K_SYSCALL_MEMORY_WRITE(buf, len));
return z_impl_uart_rx_enable(dev, buf, len, timeout); return z_impl_uart_rx_enable(dev, buf, len, timeout);
} }
@ -126,7 +126,7 @@ static inline int z_vrfy_uart_rx_enable_u16(const struct device *dev,
uint16_t *buf, uint16_t *buf,
size_t len, int32_t timeout) size_t len, int32_t timeout)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, rx_enable)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, rx_enable));
Z_OOPS(K_SYSCALL_MEMORY_ARRAY_WRITE(buf, len, sizeof(uint16_t))); Z_OOPS(K_SYSCALL_MEMORY_ARRAY_WRITE(buf, len, sizeof(uint16_t)));
return z_impl_uart_rx_enable_u16(dev, buf, len, timeout); return z_impl_uart_rx_enable_u16(dev, buf, len, timeout);
} }
@ -160,7 +160,7 @@ UART_SIMPLE(irq_update)
static inline int z_vrfy_uart_line_ctrl_set(const struct device *dev, static inline int z_vrfy_uart_line_ctrl_set(const struct device *dev,
uint32_t ctrl, uint32_t val) uint32_t ctrl, uint32_t val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, line_ctrl_set)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, line_ctrl_set));
return z_impl_uart_line_ctrl_set((const struct device *)dev, ctrl, return z_impl_uart_line_ctrl_set((const struct device *)dev, ctrl,
val); val);
} }
@ -169,7 +169,7 @@ static inline int z_vrfy_uart_line_ctrl_set(const struct device *dev,
static inline int z_vrfy_uart_line_ctrl_get(const struct device *dev, static inline int z_vrfy_uart_line_ctrl_get(const struct device *dev,
uint32_t ctrl, uint32_t *val) uint32_t ctrl, uint32_t *val)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, line_ctrl_get)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, line_ctrl_get));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(uint32_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(val, sizeof(uint32_t)));
return z_impl_uart_line_ctrl_get((const struct device *)dev, ctrl, return z_impl_uart_line_ctrl_get((const struct device *)dev, ctrl,
(uint32_t *)val); (uint32_t *)val);
@ -181,7 +181,7 @@ static inline int z_vrfy_uart_line_ctrl_get(const struct device *dev,
static inline int z_vrfy_uart_drv_cmd(const struct device *dev, uint32_t cmd, static inline int z_vrfy_uart_drv_cmd(const struct device *dev, uint32_t cmd,
uint32_t p) uint32_t p)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_UART(dev, drv_cmd)); Z_OOPS(K_SYSCALL_DRIVER_UART(dev, drv_cmd));
return z_impl_uart_drv_cmd((const struct device *)dev, cmd, p); return z_impl_uart_drv_cmd((const struct device *)dev, cmd, p);
} }
#include <syscalls/uart_drv_cmd_mrsh.c> #include <syscalls/uart_drv_cmd_mrsh.c>

4
drivers/smbus/smbus_handlers.c
View file

@ -11,7 +11,7 @@
static inline int z_vrfy_smbus_configure(const struct device *dev, static inline int z_vrfy_smbus_configure(const struct device *dev,
uint32_t dev_config) uint32_t dev_config)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SMBUS(dev, configure)); Z_OOPS(K_SYSCALL_DRIVER_SMBUS(dev, configure));
return z_impl_smbus_configure(dev, dev_config); return z_impl_smbus_configure(dev, dev_config);
} }
@ -20,7 +20,7 @@ static inline int z_vrfy_smbus_configure(const struct device *dev,
static inline int z_vrfy_smbus_get_config(const struct device *dev, static inline int z_vrfy_smbus_get_config(const struct device *dev,
uint32_t *dev_config) uint32_t *dev_config)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_SMBUS(dev, get_config)); Z_OOPS(K_SYSCALL_DRIVER_SMBUS(dev, get_config));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(dev_config, sizeof(uint32_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(dev_config, sizeof(uint32_t)));
return z_impl_smbus_get_config(dev, dev_config); return z_impl_smbus_get_config(dev, dev_config);

4
drivers/spi/spi_handlers.c
View file

@ -77,7 +77,7 @@ static inline int z_vrfy_spi_transceive(const struct device *dev,
struct spi_config config_copy; struct spi_config config_copy;
Z_OOPS(K_SYSCALL_MEMORY_READ(config, sizeof(*config))); Z_OOPS(K_SYSCALL_MEMORY_READ(config, sizeof(*config)));
Z_OOPS(Z_SYSCALL_DRIVER_SPI(dev, transceive)); Z_OOPS(K_SYSCALL_DRIVER_SPI(dev, transceive));
if (tx_bufs) { if (tx_bufs) {
const struct spi_buf_set *tx = const struct spi_buf_set *tx =
@ -120,7 +120,7 @@ static inline int z_vrfy_spi_release(const struct device *dev,
const struct spi_config *config) const struct spi_config *config)
{ {
Z_OOPS(K_SYSCALL_MEMORY_READ(config, sizeof(*config))); Z_OOPS(K_SYSCALL_MEMORY_READ(config, sizeof(*config)));
Z_OOPS(Z_SYSCALL_DRIVER_SPI(dev, release)); Z_OOPS(K_SYSCALL_DRIVER_SPI(dev, release));
return z_impl_spi_release((const struct device *)dev, config); return z_impl_spi_release((const struct device *)dev, config);
} }
#include <syscalls/spi_release_mrsh.c> #include <syscalls/spi_release_mrsh.c>

4
drivers/usb/bc12/bc12_handlers.c
View file

@ -9,7 +9,7 @@
static inline int z_vrfy_bc12_set_role(const struct device *dev, enum bc12_role role) static inline int z_vrfy_bc12_set_role(const struct device *dev, enum bc12_role role)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_BC12(dev, set_role)); Z_OOPS(K_SYSCALL_DRIVER_BC12(dev, set_role));
return z_impl_bc12_set_role(dev, role); return z_impl_bc12_set_role(dev, role);
} }
@ -17,7 +17,7 @@ static inline int z_vrfy_bc12_set_role(const struct device *dev, enum bc12_role
static inline int z_vrfy_bc12_set_result_cb(const struct device *dev, bc12_callback_t cb, static inline int z_vrfy_bc12_set_result_cb(const struct device *dev, bc12_callback_t cb,
void *user_data) void *user_data)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_BC12(dev, set_result_cb)); Z_OOPS(K_SYSCALL_DRIVER_BC12(dev, set_result_cb));
Z_OOPS(K_SYSCALL_VERIFY_MSG(cb == NULL, "callbacks may not be set from user mode")); Z_OOPS(K_SYSCALL_VERIFY_MSG(cb == NULL, "callbacks may not be set from user mode"));
return z_impl_bc12_set_result_cb(dev, cb, user_data); return z_impl_bc12_set_result_cb(dev, cb, user_data);

24
drivers/virtualization/virt_ivshmem_handlers.c
View file

@ -11,7 +11,7 @@
static inline size_t z_vrfy_ivshmem_get_mem(const struct device *dev, static inline size_t z_vrfy_ivshmem_get_mem(const struct device *dev,
uintptr_t *memmap) uintptr_t *memmap)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_mem)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_mem));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t)));
return z_impl_ivshmem_get_mem(dev, memmap); return z_impl_ivshmem_get_mem(dev, memmap);
@ -20,7 +20,7 @@ static inline size_t z_vrfy_ivshmem_get_mem(const struct device *dev,
static inline uint32_t z_vrfy_ivshmem_get_id(const struct device *dev) static inline uint32_t z_vrfy_ivshmem_get_id(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_id)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_id));
return z_impl_ivshmem_get_id(dev); return z_impl_ivshmem_get_id(dev);
} }
@ -28,7 +28,7 @@ static inline uint32_t z_vrfy_ivshmem_get_id(const struct device *dev)
static inline uint16_t z_vrfy_ivshmem_get_vectors(const struct device *dev) static inline uint16_t z_vrfy_ivshmem_get_vectors(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_vectors)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_vectors));
return z_impl_ivshmem_get_vectors(dev); return z_impl_ivshmem_get_vectors(dev);
} }
@ -37,7 +37,7 @@ static inline uint16_t z_vrfy_ivshmem_get_vectors(const struct device *dev)
static inline int z_vrfy_ivshmem_int_peer(const struct device *dev, static inline int z_vrfy_ivshmem_int_peer(const struct device *dev,
uint32_t peer_id, uint16_t vector) uint32_t peer_id, uint16_t vector)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, int_peer)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, int_peer));
return z_impl_ivshmem_int_peer(dev, peer_id, vector); return z_impl_ivshmem_int_peer(dev, peer_id, vector);
} }
@ -47,7 +47,7 @@ static inline int z_vrfy_ivshmem_register_handler(const struct device *dev,
struct k_poll_signal *signal, struct k_poll_signal *signal,
uint16_t vector) uint16_t vector)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, register_handler)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, register_handler));
Z_OOPS(K_SYSCALL_OBJ(signal, K_OBJ_POLL_SIGNAL)); Z_OOPS(K_SYSCALL_OBJ(signal, K_OBJ_POLL_SIGNAL));
return z_impl_ivshmem_register_handler(dev, signal, vector); return z_impl_ivshmem_register_handler(dev, signal, vector);
@ -59,7 +59,7 @@ static inline int z_vrfy_ivshmem_register_handler(const struct device *dev,
static inline size_t z_vrfy_ivshmem_get_rw_mem_section(const struct device *dev, static inline size_t z_vrfy_ivshmem_get_rw_mem_section(const struct device *dev,
uintptr_t *memmap) uintptr_t *memmap)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_rw_mem_section)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_rw_mem_section));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t)));
return z_impl_ivshmem_get_rw_mem_section(dev, memmap); return z_impl_ivshmem_get_rw_mem_section(dev, memmap);
@ -70,7 +70,7 @@ static inline size_t z_vrfy_ivshmem_get_output_mem_section(const struct device *
uint32_t peer_id, uint32_t peer_id,
uintptr_t *memmap) uintptr_t *memmap)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_output_mem_section)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_output_mem_section));
Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t))); Z_OOPS(K_SYSCALL_MEMORY_WRITE(memmap, sizeof(uintptr_t)));
return z_impl_ivshmem_get_output_mem_section(dev, peer_id, memmap); return z_impl_ivshmem_get_output_mem_section(dev, peer_id, memmap);
@ -80,7 +80,7 @@ static inline size_t z_vrfy_ivshmem_get_output_mem_section(const struct device *
static inline uint32_t z_vrfy_ivshmem_get_state(const struct device *dev, static inline uint32_t z_vrfy_ivshmem_get_state(const struct device *dev,
uint32_t peer_id) uint32_t peer_id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_state)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_state));
return z_impl_ivshmem_get_state(dev, peer_id); return z_impl_ivshmem_get_state(dev, peer_id);
} }
@ -89,7 +89,7 @@ static inline uint32_t z_vrfy_ivshmem_get_state(const struct device *dev,
static inline int z_vrfy_ivshmem_set_state(const struct device *dev, static inline int z_vrfy_ivshmem_set_state(const struct device *dev,
uint32_t state) uint32_t state)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, set_state)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, set_state));
return z_impl_ivshmem_set_state(dev, state); return z_impl_ivshmem_set_state(dev, state);
} }
@ -97,7 +97,7 @@ static inline int z_vrfy_ivshmem_set_state(const struct device *dev,
static inline uint32_t z_vrfy_ivshmem_get_max_peers(const struct device *dev) static inline uint32_t z_vrfy_ivshmem_get_max_peers(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_max_peers)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_max_peers));
return z_impl_ivshmem_get_max_peers(dev); return z_impl_ivshmem_get_max_peers(dev);
} }
@ -105,7 +105,7 @@ static inline uint32_t z_vrfy_ivshmem_get_max_peers(const struct device *dev)
static inline uint16_t z_vrfy_ivshmem_get_protocol(const struct device *dev) static inline uint16_t z_vrfy_ivshmem_get_protocol(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, get_protocol)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, get_protocol));
return z_impl_ivshmem_get_protocol(dev); return z_impl_ivshmem_get_protocol(dev);
} }
@ -114,7 +114,7 @@ static inline uint16_t z_vrfy_ivshmem_get_protocol(const struct device *dev)
static inline int z_vrfy_ivshmem_enable_interrupts(const struct device *dev, static inline int z_vrfy_ivshmem_enable_interrupts(const struct device *dev,
bool enable) bool enable)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_IVSHMEM(dev, enable_interrupts)); Z_OOPS(K_SYSCALL_DRIVER_IVSHMEM(dev, enable_interrupts));
return z_impl_ivshmem_enable_interrupts(dev, enable); return z_impl_ivshmem_enable_interrupts(dev, enable);
} }

12
drivers/w1/w1_handlers.c
View file

@ -9,7 +9,7 @@
static inline int z_vrfy_w1_reset_bus(const struct device *dev) static inline int z_vrfy_w1_reset_bus(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, reset_bus)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, reset_bus));
return z_impl_w1_reset_bus((const struct device *)dev); return z_impl_w1_reset_bus((const struct device *)dev);
} }
@ -17,7 +17,7 @@ static inline int z_vrfy_w1_reset_bus(const struct device *dev)
static inline int z_vrfy_w1_read_bit(const struct device *dev) static inline int z_vrfy_w1_read_bit(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, read_bit)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, read_bit));
return z_impl_w1_read_bit((const struct device *)dev); return z_impl_w1_read_bit((const struct device *)dev);
} }
@ -25,7 +25,7 @@ static inline int z_vrfy_w1_read_bit(const struct device *dev)
static inline int z_vrfy_w1_write_bit(const struct device *dev, bool bit) static inline int z_vrfy_w1_write_bit(const struct device *dev, bool bit)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, write_bit)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, write_bit));
return z_impl_w1_write_bit((const struct device *)dev, bit); return z_impl_w1_write_bit((const struct device *)dev, bit);
} }
@ -33,7 +33,7 @@ static inline int z_vrfy_w1_write_bit(const struct device *dev, bool bit)
static inline int z_vrfy_w1_read_byte(const struct device *dev) static inline int z_vrfy_w1_read_byte(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, read_byte)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, read_byte));
return z_impl_w1_read_byte((const struct device *)dev); return z_impl_w1_read_byte((const struct device *)dev);
} }
@ -41,7 +41,7 @@ static inline int z_vrfy_w1_read_byte(const struct device *dev)
static inline int z_vrfy_w1_write_byte(const struct device *dev, uint8_t byte) static inline int z_vrfy_w1_write_byte(const struct device *dev, uint8_t byte)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, write_byte)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, write_byte));
return z_impl_w1_write_byte((const struct device *)dev, (uint8_t)byte); return z_impl_w1_write_byte((const struct device *)dev, (uint8_t)byte);
} }
@ -80,7 +80,7 @@ static inline int z_vrfy_w1_change_bus_lock(const struct device *dev, bool lock)
static inline int z_vrfy_w1_configure(const struct device *dev, static inline int z_vrfy_w1_configure(const struct device *dev,
enum w1_settings_type type, uint32_t value) enum w1_settings_type type, uint32_t value)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_W1(dev, configure)); Z_OOPS(K_SYSCALL_DRIVER_W1(dev, configure));
return z_impl_w1_configure(dev, type, value); return z_impl_w1_configure(dev, type, value);
} }

6
drivers/watchdog/wdt_handlers.c
View file

@ -9,7 +9,7 @@
static inline int z_vrfy_wdt_setup(const struct device *dev, uint8_t options) static inline int z_vrfy_wdt_setup(const struct device *dev, uint8_t options)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_WDT(dev, setup)); Z_OOPS(K_SYSCALL_DRIVER_WDT(dev, setup));
return z_impl_wdt_setup(dev, options); return z_impl_wdt_setup(dev, options);
} }
@ -17,7 +17,7 @@ static inline int z_vrfy_wdt_setup(const struct device *dev, uint8_t options)
static inline int z_vrfy_wdt_disable(const struct device *dev) static inline int z_vrfy_wdt_disable(const struct device *dev)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_WDT(dev, disable)); Z_OOPS(K_SYSCALL_DRIVER_WDT(dev, disable));
return z_impl_wdt_disable(dev); return z_impl_wdt_disable(dev);
} }
@ -25,7 +25,7 @@ static inline int z_vrfy_wdt_disable(const struct device *dev)
static inline int z_vrfy_wdt_feed(const struct device *dev, int channel_id) static inline int z_vrfy_wdt_feed(const struct device *dev, int channel_id)
{ {
Z_OOPS(Z_SYSCALL_DRIVER_WDT(dev, feed)); Z_OOPS(K_SYSCALL_DRIVER_WDT(dev, feed));
return z_impl_wdt_feed(dev, channel_id); return z_impl_wdt_feed(dev, channel_id);
} }

4
samples/userspace/prod_consumer/src/sample_driver_handlers.c
View file

@ -10,7 +10,7 @@
int z_vrfy_sample_driver_state_set(const struct device *dev, bool active) int z_vrfy_sample_driver_state_set(const struct device *dev, bool active)
{ {
if (Z_SYSCALL_DRIVER_SAMPLE(dev, state_set)) { if (K_SYSCALL_DRIVER_SAMPLE(dev, state_set)) {
return -EINVAL; return -EINVAL;
} }
@ -21,7 +21,7 @@ int z_vrfy_sample_driver_state_set(const struct device *dev, bool active)
int z_vrfy_sample_driver_write(const struct device *dev, void *buf) int z_vrfy_sample_driver_write(const struct device *dev, void *buf)
{ {
if (Z_SYSCALL_DRIVER_SAMPLE(dev, write)) { if (K_SYSCALL_DRIVER_SAMPLE(dev, write)) {
return -EINVAL; return -EINVAL;
} }

4
scripts/build/gen_kobject_list.py
View file

@ -885,7 +885,7 @@ def write_gperf_table(fp, syms, objs, little_endian, static_begin, static_end):
driver_macro_tpl = """ driver_macro_tpl = """
#define Z_SYSCALL_DRIVER_%(driver_upper)s(ptr, op) Z_SYSCALL_DRIVER_GEN(ptr, op, %(driver_lower)s, %(driver_upper)s) #define K_SYSCALL_DRIVER_%(driver_upper)s(ptr, op) K_SYSCALL_DRIVER_GEN(ptr, op, %(driver_lower)s, %(driver_upper)s)
""" """
@ -893,7 +893,7 @@ def write_validation_output(fp):
fp.write("#ifndef DRIVER_VALIDATION_GEN_H\n") fp.write("#ifndef DRIVER_VALIDATION_GEN_H\n")
fp.write("#define DRIVER_VALIDATION_GEN_H\n") fp.write("#define DRIVER_VALIDATION_GEN_H\n")
fp.write("""#define Z_SYSCALL_DRIVER_GEN(ptr, op, driver_lower_case, driver_upper_case) \\ fp.write("""#define K_SYSCALL_DRIVER_GEN(ptr, op, driver_lower_case, driver_upper_case) \\
(K_SYSCALL_OBJ(ptr, K_OBJ_DRIVER_##driver_upper_case) || \\ (K_SYSCALL_OBJ(ptr, K_OBJ_DRIVER_##driver_upper_case) || \\
K_SYSCALL_DRIVER_OP(ptr, driver_lower_case##_driver_api, op)) K_SYSCALL_DRIVER_OP(ptr, driver_lower_case##_driver_api, op))
""") """)