michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: can: drop POSIX from the native Linux SocketCAN driver name

Browse source 
Rename the native Linux SocketCAN driver to reflect that it can can now be
used in both native_posix and native_sim (with or without an embedded
C-library).

Signed-off-by: Henrik Brix Andersen <hebad@vestas.com>
This commit is contained in:
Henrik Brix Andersen 2023-12-10 22:03:41 +01:00 • committed by Fabio Baltieri
commit fe74ffe2d5
12 changed files with 92 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

2
boards/posix/native_sim/doc/index.rst
View file

@ -615,7 +615,7 @@ host libC (:kconfig:option:`CONFIG_EXTERNAL_LIBC`):
adc, ADC emul, :kconfig:option:`CONFIG_ADC_EMUL`, all adc, ADC emul, :kconfig:option:`CONFIG_ADC_EMUL`, all
bluetooth, userchan, :kconfig:option:`CONFIG_BT_USERCHAN`, host libC bluetooth, userchan, :kconfig:option:`CONFIG_BT_USERCHAN`, host libC
can, can native posix, :kconfig:option:`CONFIG_CAN_NATIVE_POSIX_LINUX`, all can, can native Linux, :kconfig:option:`CONFIG_CAN_NATIVE_LINUX`, all
console backend, POSIX arch console, :kconfig:option:`CONFIG_POSIX_ARCH_CONSOLE`, all console backend, POSIX arch console, :kconfig:option:`CONFIG_POSIX_ARCH_CONSOLE`, all
display, display SDL, :kconfig:option:`CONFIG_SDL_DISPLAY`, all display, display SDL, :kconfig:option:`CONFIG_SDL_DISPLAY`, all
entropy, native posix entropy, :kconfig:option:`CONFIG_FAKE_ENTROPY_NATIVE_POSIX`, all entropy, native posix entropy, :kconfig:option:`CONFIG_FAKE_ENTROPY_NATIVE_POSIX`, all

2
boards/posix/native_sim/native_sim.dts
View file

@ -195,7 +195,7 @@
can0: can { can0: can {
status = "disabled"; status = "disabled";
compatible = "zephyr,native-posix-linux-can"; compatible = "zephyr,native-linux-can";
/* adjust zcan0 to desired host interface or create an alternative /* adjust zcan0 to desired host interface or create an alternative
* name, e.g.: sudo ip link property add dev vcan0 altname zcan0 * name, e.g.: sudo ip link property add dev vcan0 altname zcan0
*/ */

9
doc/releases/migration-guide-3.6.rst
View file

@ -128,6 +128,15 @@ Device Drivers and Device Tree
status = "okay"; status = "okay";
}; };
* The native Linux SocketCAN driver, which can now be used in both :ref:`native_posix<native_posix>`
and :ref:`native_sim<native_sim>` with or without an embedded C-library, has been renamed to
reflect this:
* The devicetree compatible was renamed from ``zephyr,native-posix-linux-can`` to
:dtcompatible:`zephyr,native-linux-can`.
* The main Kconfig option was renamed from ``CONFIG_CAN_NATIVE_POSIX_LINUX`` to
:kconfig:option:`CONFIG_CAN_NATIVE_LINUX`.
Power Management Power Management
================ ================

2
doc/releases/release-notes-3.2.rst
View file

@ -1166,7 +1166,7 @@ Devicetree
* :dtcompatible:`zephyr,coredump` * :dtcompatible:`zephyr,coredump`
* :dtcompatible:`zephyr,ieee802154-uart-pipe` * :dtcompatible:`zephyr,ieee802154-uart-pipe`
* :dtcompatible:`zephyr,native-posix-counter` * :dtcompatible:`zephyr,native-posix-counter`
* :dtcompatible:`zephyr,native-posix-linux-can` * ``zephyr,native-posix-linux-can``
* :dtcompatible:`zephyr,sdl-kscan` * :dtcompatible:`zephyr,sdl-kscan`
* :dtcompatible:`zephyr,sdmmc-disk` * :dtcompatible:`zephyr,sdmmc-disk`
* :dtcompatible:`zephyr,w1-serial` * :dtcompatible:`zephyr,w1-serial`

12
drivers/can/CMakeLists.txt
View file

@ -28,21 +28,21 @@ zephyr_library_sources_ifdef(CONFIG_USERSPACE can_handlers.c)
zephyr_library_sources_ifdef(CONFIG_CAN_SHELL can_shell.c) zephyr_library_sources_ifdef(CONFIG_CAN_SHELL can_shell.c)
zephyr_library_sources_ifdef(CONFIG_CAN_NXP_S32_CANXL can_nxp_s32_canxl.c) zephyr_library_sources_ifdef(CONFIG_CAN_NXP_S32_CANXL can_nxp_s32_canxl.c)
if(CONFIG_CAN_NATIVE_POSIX_LINUX) if(CONFIG_CAN_NATIVE_LINUX)
if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL Linux) if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL Linux)
zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/net/l2) zephyr_library_include_directories(${ZEPHYR_BASE}/subsys/net/l2)
zephyr_library_sources(can_native_posix_linux.c) zephyr_library_sources(can_native_linux.c)
if (CONFIG_NATIVE_APPLICATION) if (CONFIG_NATIVE_APPLICATION)
set_source_files_properties(can_native_posix_linux_socketcan.c set_source_files_properties(can_native_linux_adapt.c
PROPERTIES COMPILE_DEFINITIONS PROPERTIES COMPILE_DEFINITIONS
"NO_POSIX_CHEATS;_BSD_SOURCE;_DEFAULT_SOURCE") "NO_POSIX_CHEATS;_BSD_SOURCE;_DEFAULT_SOURCE")
zephyr_library_sources(can_native_posix_linux_socketcan.c) zephyr_library_sources(can_native_linux_adapt.c)
else() else()
target_sources(native_simulator INTERFACE can_native_posix_linux_socketcan.c) target_sources(native_simulator INTERFACE can_native_linux_adapt.c)
endif() endif()
else() else()
message(FATAL_ERROR "CONFIG_CAN_NATIVE_POSIX_LINUX only available on Linux") message(FATAL_ERROR "CONFIG_CAN_NATIVE_LINUX is only available on Linux")
endif() endif()
endif() endif()

2
drivers/can/Kconfig
View file

@ -93,7 +93,7 @@ source "drivers/can/Kconfig.mcan"
source "drivers/can/Kconfig.rcar" source "drivers/can/Kconfig.rcar"
source "drivers/can/Kconfig.numaker" source "drivers/can/Kconfig.numaker"
source "drivers/can/Kconfig.loopback" source "drivers/can/Kconfig.loopback"
source "drivers/can/Kconfig.native_posix_linux" source "drivers/can/Kconfig.native_linux"
source "drivers/can/Kconfig.sja1000" source "drivers/can/Kconfig.sja1000"
source "drivers/can/Kconfig.esp32" source "drivers/can/Kconfig.esp32"
source "drivers/can/Kconfig.kvaser" source "drivers/can/Kconfig.kvaser"

10
drivers/can/Kconfig.native_posix_linux → drivers/can/Kconfig.native_linux
View file

@ -3,17 +3,17 @@
# Copyright (c) 2022 Martin Jäger <martin@libre.solar> # Copyright (c) 2022 Martin Jäger <martin@libre.solar>
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
config CAN_NATIVE_POSIX_LINUX config CAN_NATIVE_LINUX
bool "Native Linux SocketCAN Driver" bool "Native Linux SocketCAN Driver"
default y default y
depends on DT_HAS_ZEPHYR_NATIVE_POSIX_LINUX_CAN_ENABLED depends on DT_HAS_ZEPHYR_NATIVE_LINUX_CAN_ENABLED
depends on ARCH_POSIX depends on ARCH_POSIX
help help
Enable native Linux SocketCAN Driver Enable native Linux SocketCAN Driver
if CAN_NATIVE_POSIX_LINUX if CAN_NATIVE_LINUX
config CAN_NATIVE_POSIX_LINUX_RX_THREAD_PRIORITY config CAN_NATIVE_LINUX_RX_THREAD_PRIORITY
int "Priority for internal RX thread" int "Priority for internal RX thread"
default 2 default 2
help help
@ -28,4 +28,4 @@ config CAN_MAX_FILTER
Defines the array size of the callback/msgq pointers. Defines the array size of the callback/msgq pointers.
Must be at least the size of concurrent reads. Must be at least the size of concurrent reads.
endif # CAN_NATIVE_POSIX_LINUX endif # CAN_NATIVE_LINUX

128
drivers/can/can_native_posix_linux.c → drivers/can/can_native_linux.c
View file

@ -4,7 +4,7 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
#define DT_DRV_COMPAT zephyr_native_posix_linux_can #define DT_DRV_COMPAT zephyr_native_linux_can
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
@ -17,9 +17,9 @@
#include <zephyr/net/socketcan.h> #include <zephyr/net/socketcan.h>
#include <zephyr/net/socketcan_utils.h> #include <zephyr/net/socketcan_utils.h>
#include "can_native_posix_linux_socketcan.h" #include "can_native_linux_adapt.h"
LOG_MODULE_REGISTER(can_npl, CONFIG_CAN_LOG_LEVEL); LOG_MODULE_REGISTER(can_native_linux, CONFIG_CAN_LOG_LEVEL);
struct can_filter_context { struct can_filter_context {
can_rx_callback_t rx_cb; can_rx_callback_t rx_cb;
@ -27,7 +27,7 @@ struct can_filter_context {
struct can_filter filter; struct can_filter filter;
}; };
struct can_npl_data { struct can_native_linux_data {
struct can_filter_context filters[CONFIG_CAN_MAX_FILTER]; struct can_filter_context filters[CONFIG_CAN_MAX_FILTER];
struct k_mutex filter_mutex; struct k_mutex filter_mutex;
struct k_sem tx_idle; struct k_sem tx_idle;
@ -42,13 +42,13 @@ struct can_npl_data {
K_KERNEL_STACK_MEMBER(rx_thread_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE); K_KERNEL_STACK_MEMBER(rx_thread_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
}; };
struct can_npl_config { struct can_native_linux_config {
const char *if_name; const char *if_name;
}; };
static void dispatch_frame(const struct device *dev, struct can_frame *frame) static void dispatch_frame(const struct device *dev, struct can_frame *frame)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
can_rx_callback_t callback; can_rx_callback_t callback;
struct can_frame tmp_frame; struct can_frame tmp_frame;
@ -76,7 +76,7 @@ static void dispatch_frame(const struct device *dev, struct can_frame *frame)
static void rx_thread(void *arg1, void *arg2, void *arg3) static void rx_thread(void *arg1, void *arg2, void *arg3)
{ {
const struct device *dev = arg1; const struct device *dev = arg1;
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
struct socketcan_frame sframe; struct socketcan_frame sframe;
struct can_frame frame; struct can_frame frame;
bool msg_confirm; bool msg_confirm;
@ -113,15 +113,15 @@ static void rx_thread(void *arg1, void *arg2, void *arg3)
dispatch_frame(dev, &frame); dispatch_frame(dev, &frame);
} }
/* short sleep required to avoid blocking the whole native_posix process */ /* short sleep required to avoid blocking the whole native process */
k_sleep(K_MSEC(1)); k_sleep(K_MSEC(1));
} }
} }
static int can_npl_send(const struct device *dev, const struct can_frame *frame, static int can_native_linux_send(const struct device *dev, const struct can_frame *frame,
k_timeout_t timeout, can_tx_callback_t callback, void *user_data) k_timeout_t timeout, can_tx_callback_t callback, void *user_data)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
struct socketcan_frame sframe; struct socketcan_frame sframe;
uint8_t max_dlc = CAN_MAX_DLC; uint8_t max_dlc = CAN_MAX_DLC;
size_t mtu = CAN_MTU; size_t mtu = CAN_MTU;
@ -187,10 +187,10 @@ static int can_npl_send(const struct device *dev, const struct can_frame *frame,
return 0; return 0;
} }
static int can_npl_add_rx_filter(const struct device *dev, can_rx_callback_t cb, static int can_native_linux_add_rx_filter(const struct device *dev, can_rx_callback_t cb,
void *cb_arg, const struct can_filter *filter) void *cb_arg, const struct can_filter *filter)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
struct can_filter_context *filter_ctx; struct can_filter_context *filter_ctx;
int filter_id = -ENOSPC; int filter_id = -ENOSPC;
@ -234,9 +234,9 @@ static int can_npl_add_rx_filter(const struct device *dev, can_rx_callback_t cb,
return filter_id; return filter_id;
} }
static void can_npl_remove_rx_filter(const struct device *dev, int filter_id) static void can_native_linux_remove_rx_filter(const struct device *dev, int filter_id)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
if (filter_id < 0 || filter_id >= ARRAY_SIZE(data->filters)) { if (filter_id < 0 || filter_id >= ARRAY_SIZE(data->filters)) {
LOG_ERR("filter ID %d out of bounds"); LOG_ERR("filter ID %d out of bounds");
@ -250,7 +250,7 @@ static void can_npl_remove_rx_filter(const struct device *dev, int filter_id)
LOG_DBG("Filter removed. ID: %d", filter_id); LOG_DBG("Filter removed. ID: %d", filter_id);
} }
static int can_npl_get_capabilities(const struct device *dev, can_mode_t *cap) static int can_native_linux_get_capabilities(const struct device *dev, can_mode_t *cap)
{ {
ARG_UNUSED(dev); ARG_UNUSED(dev);
@ -263,9 +263,9 @@ static int can_npl_get_capabilities(const struct device *dev, can_mode_t *cap)
return 0; return 0;
} }
static int can_npl_start(const struct device *dev) static int can_native_linux_start(const struct device *dev)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
if (data->started) { if (data->started) {
return -EALREADY; return -EALREADY;
@ -276,9 +276,9 @@ static int can_npl_start(const struct device *dev)
return 0; return 0;
} }
static int can_npl_stop(const struct device *dev) static int can_native_linux_stop(const struct device *dev)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
if (!data->started) { if (!data->started) {
return -EALREADY; return -EALREADY;
@ -289,9 +289,9 @@ static int can_npl_stop(const struct device *dev)
return 0; return 0;
} }
static int can_npl_set_mode(const struct device *dev, can_mode_t mode) static int can_native_linux_set_mode(const struct device *dev, can_mode_t mode)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
#ifdef CONFIG_CAN_FD_MODE #ifdef CONFIG_CAN_FD_MODE
if ((mode & ~(CAN_MODE_LOOPBACK | CAN_MODE_FD)) != 0) { if ((mode & ~(CAN_MODE_LOOPBACK | CAN_MODE_FD)) != 0) {
@ -318,9 +318,9 @@ static int can_npl_set_mode(const struct device *dev, can_mode_t mode)
return 0; return 0;
} }
static int can_npl_set_timing(const struct device *dev, const struct can_timing *timing) static int can_native_linux_set_timing(const struct device *dev, const struct can_timing *timing)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
ARG_UNUSED(timing); ARG_UNUSED(timing);
@ -332,9 +332,10 @@ static int can_npl_set_timing(const struct device *dev, const struct can_timing
} }
#ifdef CONFIG_CAN_FD_MODE #ifdef CONFIG_CAN_FD_MODE
static int can_npl_set_timing_data(const struct device *dev, const struct can_timing *timing) static int can_native_linux_set_timing_data(const struct device *dev,
const struct can_timing *timing)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
ARG_UNUSED(timing); ARG_UNUSED(timing);
@ -346,10 +347,10 @@ static int can_npl_set_timing_data(const struct device *dev, const struct can_ti
} }
#endif /* CONFIG_CAN_FD_MODE */ #endif /* CONFIG_CAN_FD_MODE */
static int can_npl_get_state(const struct device *dev, enum can_state *state, static int can_native_linux_get_state(const struct device *dev, enum can_state *state,
struct can_bus_err_cnt *err_cnt) struct can_bus_err_cnt *err_cnt)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
if (state != NULL) { if (state != NULL) {
if (!data->started) { if (!data->started) {
@ -369,9 +370,9 @@ static int can_npl_get_state(const struct device *dev, enum can_state *state,
} }
#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
static int can_npl_recover(const struct device *dev, k_timeout_t timeout) static int can_native_linux_recover(const struct device *dev, k_timeout_t timeout)
{ {
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
ARG_UNUSED(timeout); ARG_UNUSED(timeout);
@ -383,16 +384,16 @@ static int can_npl_recover(const struct device *dev, k_timeout_t timeout)
} }
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
static void can_npl_set_state_change_callback(const struct device *dev, static void can_native_linux_set_state_change_callback(const struct device *dev,
can_state_change_callback_t cb, can_state_change_callback_t cb,
void *user_data) void *user_data)
{ {
ARG_UNUSED(dev); ARG_UNUSED(dev);
ARG_UNUSED(cb); ARG_UNUSED(cb);
ARG_UNUSED(user_data); ARG_UNUSED(user_data);
} }
static int can_npl_get_core_clock(const struct device *dev, uint32_t *rate) static int can_native_linux_get_core_clock(const struct device *dev, uint32_t *rate)
{ {
/* Return 16MHz as an realistic value for the testcases */ /* Return 16MHz as an realistic value for the testcases */
*rate = 16000000; *rate = 16000000;
@ -400,29 +401,29 @@ static int can_npl_get_core_clock(const struct device *dev, uint32_t *rate)
return 0; return 0;
} }
static int can_npl_get_max_filters(const struct device *dev, bool ide) static int can_native_linux_get_max_filters(const struct device *dev, bool ide)
{ {
ARG_UNUSED(ide); ARG_UNUSED(ide);
return CONFIG_CAN_MAX_FILTER; return CONFIG_CAN_MAX_FILTER;
} }
static const struct can_driver_api can_npl_driver_api = { static const struct can_driver_api can_native_linux_driver_api = {
.start = can_npl_start, .start = can_native_linux_start,
.stop = can_npl_stop, .stop = can_native_linux_stop,
.get_capabilities = can_npl_get_capabilities, .get_capabilities = can_native_linux_get_capabilities,
.set_mode = can_npl_set_mode, .set_mode = can_native_linux_set_mode,
.set_timing = can_npl_set_timing, .set_timing = can_native_linux_set_timing,
.send = can_npl_send, .send = can_native_linux_send,
.add_rx_filter = can_npl_add_rx_filter, .add_rx_filter = can_native_linux_add_rx_filter,
.remove_rx_filter = can_npl_remove_rx_filter, .remove_rx_filter = can_native_linux_remove_rx_filter,
.get_state = can_npl_get_state, .get_state = can_native_linux_get_state,
#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
.recover = can_npl_recover, .recover = can_native_linux_recover,
#endif #endif
.set_state_change_callback = can_npl_set_state_change_callback, .set_state_change_callback = can_native_linux_set_state_change_callback,
.get_core_clock = can_npl_get_core_clock, .get_core_clock = can_native_linux_get_core_clock,
.get_max_filters = can_npl_get_max_filters, .get_max_filters = can_native_linux_get_max_filters,
.timing_min = { .timing_min = {
.sjw = 0x1, .sjw = 0x1,
.prop_seg = 0x01, .prop_seg = 0x01,
@ -438,7 +439,7 @@ static const struct can_driver_api can_npl_driver_api = {
.prescaler = 0xFFFF .prescaler = 0xFFFF
}, },
#ifdef CONFIG_CAN_FD_MODE #ifdef CONFIG_CAN_FD_MODE
.set_timing_data = can_npl_set_timing_data, .set_timing_data = can_native_linux_set_timing_data,
.timing_data_min = { .timing_data_min = {
.sjw = 0x1, .sjw = 0x1,
.prop_seg = 0x01, .prop_seg = 0x01,
@ -456,10 +457,10 @@ static const struct can_driver_api can_npl_driver_api = {
#endif /* CONFIG_CAN_FD_MODE */ #endif /* CONFIG_CAN_FD_MODE */
}; };
static int can_npl_init(const struct device *dev) static int can_native_linux_init(const struct device *dev)
{ {
const struct can_npl_config *cfg = dev->config; const struct can_native_linux_config *cfg = dev->config;
struct can_npl_data *data = dev->data; struct can_native_linux_data *data = dev->data;
k_mutex_init(&data->filter_mutex); k_mutex_init(&data->filter_mutex);
k_sem_init(&data->tx_idle, 1, 1); k_sem_init(&data->tx_idle, 1, 1);
@ -473,7 +474,7 @@ static int can_npl_init(const struct device *dev)
k_thread_create(&data->rx_thread, data->rx_thread_stack, k_thread_create(&data->rx_thread, data->rx_thread_stack,
K_KERNEL_STACK_SIZEOF(data->rx_thread_stack), K_KERNEL_STACK_SIZEOF(data->rx_thread_stack),
rx_thread, (void *)dev, NULL, NULL, rx_thread, (void *)dev, NULL, NULL,
CONFIG_CAN_NATIVE_POSIX_LINUX_RX_THREAD_PRIORITY, CONFIG_CAN_NATIVE_LINUX_RX_THREAD_PRIORITY,
0, K_NO_WAIT); 0, K_NO_WAIT);
LOG_DBG("Init of %s done", dev->name); LOG_DBG("Init of %s done", dev->name);
@ -481,17 +482,18 @@ static int can_npl_init(const struct device *dev)
return 0; return 0;
} }
#define CAN_NATIVE_POSIX_LINUX_INIT(inst) \ #define CAN_NATIVE_LINUX_INIT(inst) \
\ \
static const struct can_npl_config can_npl_cfg_##inst = { \ static const struct can_native_linux_config can_native_linux_cfg_##inst = { \
.if_name = DT_INST_PROP(inst, host_interface), \ .if_name = DT_INST_PROP(inst, host_interface), \
}; \ }; \
\ \
static struct can_npl_data can_npl_data_##inst; \ static struct can_native_linux_data can_native_linux_data_##inst; \
\ \
CAN_DEVICE_DT_INST_DEFINE(inst, can_npl_init, NULL, \ CAN_DEVICE_DT_INST_DEFINE(inst, can_native_linux_init, NULL, \
&can_npl_data_##inst, &can_npl_cfg_##inst, \ &can_native_linux_data_##inst, \
&can_native_linux_cfg_##inst, \
POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \ POST_KERNEL, CONFIG_CAN_INIT_PRIORITY, \
&can_npl_driver_api); &can_native_linux_driver_api);
DT_INST_FOREACH_STATUS_OKAY(CAN_NATIVE_POSIX_LINUX_INIT) DT_INST_FOREACH_STATUS_OKAY(CAN_NATIVE_LINUX_INIT)

2
drivers/can/can_native_posix_linux_socketcan.c → drivers/can/can_native_linux_adapt.c
View file

@ -34,7 +34,7 @@
#error "This driver can only be built on Linux systems" #error "This driver can only be built on Linux systems"
#endif #endif
#include "can_native_posix_linux_socketcan.h" #include "can_native_linux_adapt.h"
#ifndef CANFD_FDF #ifndef CANFD_FDF
/* Linux kernels before v5.14 do not define CANFD_FDF */ /* Linux kernels before v5.14 do not define CANFD_FDF */

0
drivers/can/can_native_posix_linux_socketcan.h → drivers/can/can_native_linux_adapt.h
View file

2
dts/bindings/can/zephyr,native-posix-linux-can.yaml → dts/bindings/can/zephyr,native-linux-can.yaml
View file

@ -3,7 +3,7 @@
description: Zephyr CAN driver using Linux SocketCAN description: Zephyr CAN driver using Linux SocketCAN
compatible: "zephyr,native-posix-linux-can" compatible: "zephyr,native-linux-can"
include: can-controller.yaml include: can-controller.yaml

2
tests/drivers/build_all/can/testcase.yaml
View file

@ -19,7 +19,7 @@ tests:
drivers.can.build_all.mcp251xfd: drivers.can.build_all.mcp251xfd:
extra_args: SHIELD=mikroe_mcp2518fd_click extra_args: SHIELD=mikroe_mcp2518fd_click
platform_allow: lpcxpresso55s28 platform_allow: lpcxpresso55s28
drivers.can.build_all.native_posix_linux: drivers.can.build_all.native_linux:
platform_allow: platform_allow:
- native_posix - native_posix
- native_posix_64 - native_posix_64