/*
 * Copyright (c) 2018 Alexander Wachter
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <syscall_handler.h>
#include <drivers/can.h>

static inline int z_vrfy_can_set_timing(const struct device *dev,
					const struct can_timing *timing,
					const struct can_timing *timing_data)
{
	Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, set_timing));

	return z_impl_can_set_timing((const struct device *)dev,
				     (const struct can_timing *)timing,
				     (const struct can_timing *)timing_data);
}
#include <syscalls/can_set_timing_mrsh.c>

static inline int z_vrfy_can_get_core_clock(const struct device *dev,
					    uint32_t *rate)
{
	Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_core_clock));
	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(rate, sizeof(rate)));

	return z_impl_can_get_core_clock(dev, rate);
}
#include <syscalls/can_get_core_clock_mrsh.c>

static inline int z_vrfy_can_get_max_bitrate(const struct device *dev,
					     uint32_t *max_bitrate)
{
	Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, get_max_bitrate));
	Z_OOPS(Z_SYSCALL_MEMORY_WRITE(max_bitrate, sizeof(*max_bitrate)));

	return z_impl_can_get_max_bitrate(dev, max_bitrate);
}
#include <syscalls/can_get_max_bitrate_mrsh.c>

static inline int z_vrfy_can_send(const struct device *dev,
				  const struct zcan_frame *frame,
				  k_timeout_t timeout,
				  can_tx_callback_t callback,
				  void *user_data)
{
	Z_OOPS(Z_SYSCALL_DRIVER_CAN(dev, send));

	Z_OOPS(Z_SYSCALL_MEMORY_READ((const struct zcan_frame *)frame,
				      sizeof(struct zcan_frame)));
	Z_OOPS(Z_SYSCALL_MEMORY_READ(((struct zcan_frame *)frame)->data,
				     sizeof((struct zcan_frame *)frame)->data));
	Z_OOPS(Z_SYSCALL_VERIFY_MSG(callback == 0,
				    "callbacks may not be set from user mode"));

	Z_OOPS(Z_SYSCALL_MEMORY_READ((void *)user_data, sizeof(void *)));

	return z_impl_can_send((const struct device *)dev,
			       (const struct zcan_frame *)frame,
			       (k_timeout_t)timeout,
			       (can_tx_callback_t) callback,
			       (void *)user_data);
}
#include <syscalls/can_send_mrsh.c>

static inline int z_vrfy_can_add_rx_filter_msgq(const struct device *dev,
						struct k_msgq *msgq,
						const struct zcan_filter *filter)
{
	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_CAN));

	Z_OOPS(Z_SYSCALL_MEMORY_READ((struct zcan_filter *)filter,
				     sizeof(struct zcan_filter)));
	Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));

	return z_impl_can_add_rx_filter_msgq((const struct device *)dev,
					     (struct k_msgq *)msgq,
					     (const struct zcan_filter *)filter);
}
#include <syscalls/can_add_rx_filter_msgq_mrsh.c>

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_impl_can_remove_rx_filter((const struct device *)dev, (int)filter_id);
}
#include <syscalls/can_remove_rx_filter_mrsh.c>

static inline
int z_vrfy_can_get_state(const struct device *dev, enum can_state *state,
			 struct can_bus_err_cnt *err_cnt)
{
	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_CAN));

	if (state != NULL) {
		Z_OOPS(Z_SYSCALL_MEMORY_WRITE(state, sizeof(enum can_state)));
	}

	if (err_cnt != NULL) {
		Z_OOPS(Z_SYSCALL_MEMORY_WRITE(err_cnt, sizeof(struct can_bus_err_cnt)));
	}

	return z_impl_can_get_state(dev, state, err_cnt);
}
#include <syscalls/can_get_state_mrsh.c>

#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
static inline int z_vrfy_can_recover(const struct device *dev,
				     k_timeout_t timeout)
{
	Z_OOPS(Z_SYSCALL_OBJ(dev, K_OBJ_DRIVER_CAN));

	return z_impl_can_recover(dev, k_timeout_t timeout);
}
#include <syscalls/can_recover_mrsh.c>
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */