3.1.2

Signed-off-by: Christian Gabriel <ch_gabriel@web.de>

CHANGELOG

@@ -1,3 +1,31 @@
+v3.1.2
+	Update kernel logging for dropped messages to pr_debug
+	Added instructions for debug message in README
+v3.1.1
+	Update copyright
+	Fix Ethernet interfaces
+
+v3.0.4
+	Update copyright
+	Add Fedora package requirements to README
+	Fix for newer 6.4.x Kernel, class_create() sig changed (Doug Potts <dpotts@genrad.com>)
+
+v3.0.3
+	Update daemon version requirement to 3.1.*
+
+v3.0.2
+	Bump maximum device count to 64
+
+v3.0.1
+	Update copyright
+
+v3.0.0
+	Added Functionality for Ethernet
+
+v2.1.1
+	Fix support for kernels <5.12
+		Tested on 5.4.0
+
 v2.1.0
 	Implement proper functionality for echoing transmits
 	Transmit errors are now reported properly

README.md

@@ -1,10 +1,10 @@
-Version 2.1.0
+Version 3.1.2
 
 This is the kernel object portion of the Intrepid Control Systems SocketCAN support. For SocketCAN to work with Intrepid devices you will need to have this kernel object loaded on your system. Once the module is built and loaded run [icsscand](https://github.com/intrepidcs/icsscand) to turn on SocketCAN support.
 
-First, install the necessary dependencies for building kernel modules.
-
-On Ubuntu, this is accomplished by running `sudo apt install linux-headers-generic build-essential gcc git`
+First, install the necessary dependencies for building kernel modules:
+- Ubuntu: `sudo apt install linux-headers-generic build-essential gcc git`
+- Fedora: `sudo dnf install git kernel-devel-matched`
 
 Clone this repository by running `git clone https://github.com/intrepidcs/intrepid-socketcan-kernel-module.git`
 
@@ -45,3 +45,50 @@ can_raw
 can_dev
 intrepid
 ```
+
+## Dynamic Debug Support
+
+The module includes debug messages that can be enabled at runtime using the kernel's dynamic debug framework. This requires your kernel to be built with `CONFIG_DYNAMIC_DEBUG=y` (most modern distributions include this).
+
+### Enabling Debug Messages
+
+After building and loading the module with the standard `make` and `make install`, you can enable debug output:
+
+**Enable all debug messages for the intrepid module:**
+```bash
+$ echo "module intrepid +p" | sudo tee /sys/kernel/debug/dynamic_debug/control
+```
+
+**Disable debug messages:**
+```bash
+$ echo "module intrepid -p" | sudo tee /sys/kernel/debug/dynamic_debug/control
+```
+
+**Enable debug messages for specific functions:**
+```bash
+$ echo "file intrepid.c func function_name +p" | sudo tee /sys/kernel/debug/dynamic_debug/control
+```
+
+**View current debug settings:**
+```bash
+$ sudo cat /sys/kernel/debug/dynamic_debug/control | grep intrepid
+```
+
+**View debug output:**
+```bash
+$ sudo dmesg | grep intrepid
+$ sudo dmesg -w  # Follow live output
+```
+
+### Available Debug Messages
+
+The debug messages provide information about:
+- CAN bittiming configuration
+- Frame validation and processing
+- Message dropping conditions
+- Error handling
+
+Debug messages are primarily triggered during:
+- CAN interface configuration
+- Frame transmission/reception
+- Error conditions and message drops

intrepid.c

@@ -1,7 +1,7 @@
 /*
  * intrepid.c - Netdevice driver for Intrepid CAN/Ethernet devices
  *
- * Copyright (c) 2016-2022 Intrepid Control Systems, Inc.
+ * Copyright (c) 2016-2025 Intrepid Control Systems, Inc.
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -48,6 +48,7 @@
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <linux/version.h>
+#include <linux/etherdevice.h>
 
 #include "neomessage.h"
 
@@ -55,9 +56,9 @@
 #define str(x) str_first(x)
 
 #define KO_DESC "Netdevice driver for Intrepid CAN/Ethernet devices"
-#define KO_MAJOR 2
+#define KO_MAJOR 3
 #define KO_MINOR 1
-#define KO_PATCH 0
+#define KO_PATCH 2
 #define KO_VERSION str(KO_MAJOR) "." str(KO_MINOR) "." str(KO_PATCH)
 #define KO_VERSION_INT (KO_MAJOR << 16) | (KO_MINOR << 8) | KO_PATCH
 
@@ -69,30 +70,35 @@ MODULE_DESCRIPTION(KO_DESC);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Paul Hollinsky <phollinsky@intrepidcs.com>");
 MODULE_AUTHOR("Jeffrey Quesnelle <jeffq@intrepidcs.com>");
+MODULE_AUTHOR("Kyle Schwarz <kschwarz@intrepidcs.com>");
+MODULE_AUTHOR("Thomas Stoddard <tstoddard@intrepidcs.com>");
 MODULE_VERSION(KO_VERSION);
 
 #define INTREPID_DEVICE_NAME            "intrepid_netdevice"
 #define INTREPID_CLASS_NAME             "intrepid"
-#define MAX_NET_DEVICES                 16
+#define MAX_NET_DEVICES                 64
 #define SHARED_MEM_SIZE                 0x400000
 
-#define SIOCSADDIF                      0x3001
-#define SIOCSREMOVEIF                   0x3002
-#define SIOCGSHAREDMEMSIZE              0x3003
-#define SIOCSMSGSWRITTEN                0x3004
-#define SIOCGMAXIFACES                  0x3005
-#define SIOCGVERSION                    0x3006
-#define SIOCGCLIENTVEROK                0x3007
+#define SIOCSADDCANIF			0x3001
+#define SIOCSADDETHIF			0x3002
+#define SIOCSREMOVECANIF		0x3003
+#define SIOCSREMOVEETHIF		0x3004
+#define SIOCGSHAREDMEMSIZE		0x3005
+#define SIOCSMSGSWRITTEN		0x3006
+#define SIOCGMAXIFACES			0x3007
+#define SIOCGVERSION			0x3008
+#define SIOCGCLIENTVEROK		0x3009
+#define SIOCSBAUDRATE			0x300A
 
 /* This is true until we have Ethernet support
  * It is used to stop the netif queues before we have to return NETDEV_TX_BUSY
  */
-#define MAX_MTU                         CANFD_MTU
 
 #define KERNEL_CHECKS_MTU_RANGE         (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
 #define KERNEL_FAULT_TAKES_VMA          (LINUX_VERSION_CODE <  KERNEL_VERSION(4,11,0))
 #define KERNEL_SUPPORTS_ALIASES         (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
 #define KERNEL_DEFINES_VM_FAULT_T       (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
+#define KERNEL_CAN_ECHO_TRACKS_LEN      (LINUX_VERSION_CODE >= KERNEL_VERSION(5,12,0))
 
 #if KERNEL_DEFINES_VM_FAULT_T == 0
 typedef int vm_fault_t;
@@ -106,16 +112,17 @@ struct intrepid_pending_tx_info {
 
 struct intrepid_netdevice {
 	struct can_priv         can;
-	struct can_berr_counter bec;
 	struct net_device       *dev;
 	spinlock_t              lock;
 	int                     is_stopped;
 	unsigned char           *from_user;
 	uint8_t                 tx_idx;
+	int			bitrate_changed;
 };
 
 static int                      is_open;
 static int                      major_number;
+static int                      client_version;
 static unsigned char            *shared_mem;
 static struct class             *intrepid_dev_class;
 static struct device            *intrepid_dev;
@@ -166,7 +173,7 @@ static inline int intrepid_tx_box_no_space_for(size_t size)
 static void intrepid_unpause_all_queues(void)
 {
 	int i;
-	for(i = 0; i < MAX_NET_DEVICES; ++i) {
+	for (i = 0; i < MAX_NET_DEVICES; ++i) {
 		struct net_device *dev = net_devices[i];
 		struct intrepid_netdevice *ics;
 		if (dev == NULL)
@@ -185,7 +192,7 @@ static void intrepid_unpause_all_queues(void)
 static void intrepid_pause_all_queues(void)
 {
 	int i;
-	for(i = 0; i < MAX_NET_DEVICES; ++i) {
+	for (i = 0; i < MAX_NET_DEVICES; ++i) {
 		struct net_device *dev = net_devices[i];
 		struct intrepid_netdevice *ics;
 		if (dev == NULL)
@@ -201,7 +208,7 @@ static void intrepid_pause_all_queues(void)
 	}
 }
 
-static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t intrepid_CAN_netdevice_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	int ret = NETDEV_TX_OK;
 	struct intrepid_netdevice *ics = netdev_priv(dev);
@@ -213,7 +220,7 @@ static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_devic
 	neomessage_can_t msg = {0};
 
 	if (can_dropped_invalid_skb(dev, skb)) {
-		pr_info("intrepid: dropping invalid frame on %s\n", dev->name);
+		pr_debug("intrepid: dropping invalid frame on %s\n", dev->name);
 		goto exit;
 	}
 
@@ -222,7 +229,7 @@ static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_devic
 
 	if (unlikely(ics->is_stopped)) {
 		pr_err("intrepid: in xmit but device is stopped\n");
-		if (intrepid_tx_box_no_space_for(sizeof(neomessage_can_t) + MAX_MTU)) {
+		if (intrepid_tx_box_no_space_for(sizeof(neomessage_can_t) + CANFD_MTU)) {
 			ret = NETDEV_TX_BUSY;
 			goto exit;
 		}
@@ -251,7 +258,6 @@ static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_devic
 			pr_info("intrepid: tried to send RTR frame on CANFD %s\n", dev->name);
 			goto exit;
 		}
-
 		msg.status.remoteFrame = true;
 	}
 
@@ -267,9 +273,12 @@ static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_devic
 		ret = NETDEV_TX_BUSY;
 		goto exit;
 	}
-
 	msg.description = intrepid_next_tx_description(ics, &tx_idx);
-	can_put_echo_skb(skb, dev, tx_idx, msg.length);
+	can_put_echo_skb(skb, dev, tx_idx
+#if KERNEL_CAN_ECHO_TRACKS_LEN
+		, msg.length
+#endif
+	);
 	consumed = true;
 
 	/* Copy the message into the usermode box */
@@ -280,14 +289,68 @@ static netdev_tx_t intrepid_netdevice_xmit(struct sk_buff *skb, struct net_devic
 	tx_box_count[current_tx_box]++;
 
 	/* If we might not be able to fit the next message, let's lock until we can to prevent NETDEV_TX_BUSY */
-	if (intrepid_tx_box_no_space_for(sizeof(neomessage_can_t) + MAX_MTU))
+	if (intrepid_tx_box_no_space_for(sizeof(neomessage_can_t) + CANFD_MTU))
 		intrepid_pause_all_queues();
-
 exit:
-	if(ret == NETDEV_TX_OK && !consumed)
+	if (ret == NETDEV_TX_OK && !consumed)
 		consume_skb(skb);
 	wake_up_interruptible(&tx_wait);
-	if(needs_unlock)
+	if (needs_unlock)
+		spin_unlock_bh(&tx_box_lock);
+	return ret;
+}
+
+static netdev_tx_t intrepid_ETH_netdevice_xmit(struct sk_buff *skb, struct net_device *dev) {
+	int ret = NETDEV_TX_OK;
+	struct intrepid_netdevice *ics = netdev_priv(dev);
+	bool needs_unlock = false;
+	bool consumed = false;
+	int tx_idx;
+	neomessage_eth_t msg = {0};
+
+	spin_lock_bh(&tx_box_lock);
+	needs_unlock = true;
+
+	if (unlikely(ics->is_stopped)) {
+		pr_err("intrepid: in xmit but device is stopped\n");
+		if (intrepid_tx_box_no_space_for(sizeof(neomessage_eth_t) + ETH_DATA_LEN)) {
+			ret = NETDEV_TX_BUSY;
+			goto exit;
+		}
+		pr_warn("intrepid: device should not have been stopped, waking all\n");
+		intrepid_unpause_all_queues();
+	}
+
+	msg.length = skb->len;
+	msg.netid = dev->base_addr;
+	msg.type = ICSNEO_NETWORK_TYPE_ETHERNET;
+
+	if (intrepid_tx_box_no_space_for(sizeof(neomessage_eth_t) + msg.length)) {
+		/* This should never happen, the queue should be paused before this */
+		ssize_t offset = TX_BOX_SIZE;
+		offset -= (tx_box_bytes[current_tx_box] + sizeof(neomessage_eth_t) + msg.length);
+		pr_err("intrepid: %zu length message caused NETDEV_TX_BUSY (%zd)\n", msg.length, offset);
+		ret = NETDEV_TX_BUSY;
+		goto exit;
+	}
+	msg.description = intrepid_next_tx_description(ics, &tx_idx);
+	consumed = true;
+
+	/* Copy the message into the usermode box */
+	memcpy(tx_boxes[current_tx_box] + tx_box_bytes[current_tx_box], &msg, sizeof(neomessage_eth_t));
+	tx_box_bytes[current_tx_box] += sizeof(neomessage_eth_t);
+	memcpy(tx_boxes[current_tx_box] + tx_box_bytes[current_tx_box], skb->data, skb->len);
+	tx_box_bytes[current_tx_box] += msg.length;
+	tx_box_count[current_tx_box]++;
+
+	/* If we might not be able to fit the next message, let's lock until we can to prevent NETDEV_TX_BUSY */
+	if (intrepid_tx_box_no_space_for(sizeof(neomessage_eth_t) + ETH_DATA_LEN))
+		intrepid_pause_all_queues();
+exit:
+	if (ret == NETDEV_TX_OK && !consumed)
+		consume_skb(skb);
+	wake_up_interruptible(&tx_wait);
+	if (needs_unlock)
 		spin_unlock_bh(&tx_box_lock);
 	return ret;
 }
@@ -296,8 +359,6 @@ static int intrepid_netdevice_stop(struct net_device *dev)
 {
 	struct intrepid_netdevice *ics = netdev_priv(dev);
 
-	close_candev(dev);
-
 	spin_lock_bh(&ics->lock);
 	netif_stop_queue(dev);
 	netif_carrier_off(dev);
@@ -318,10 +379,19 @@ static int intrepid_netdevice_open(struct net_device *dev)
 // 	return -EINVAL;
 // }
 
-static const struct net_device_ops intrepid_netdevice_ops = {
+//CAN
+static const struct net_device_ops intrepid_CAN_netdevice_ops = {
 	.ndo_open               = intrepid_netdevice_open,
 	.ndo_stop               = intrepid_netdevice_stop,
-	.ndo_start_xmit         = intrepid_netdevice_xmit,
+	.ndo_start_xmit         = intrepid_CAN_netdevice_xmit,
+	//.ndo_change_mtu         = intrepid_netdevice_change_mtu,
+};
+
+//ETH
+static const struct net_device_ops intrepid_ETH_netdevice_ops = {
+	.ndo_open               = intrepid_netdevice_open,
+	.ndo_stop               = intrepid_netdevice_stop,
+	.ndo_start_xmit         = intrepid_ETH_netdevice_xmit,
 	//.ndo_change_mtu         = intrepid_netdevice_change_mtu,
 };
 
@@ -353,6 +423,68 @@ static int intrepid_remove_can_if(int index)
 	return 0;
 }
 
+static int intrepid_set_bittiming(struct net_device *netdev)
+{
+	struct intrepid_netdevice *dev = netdev_priv(netdev);
+	struct can_bittiming *bt = &dev->can.bittiming;
+
+	dev_dbg(&netdev->dev, "bitrate %d sample_point %d tq %d sjw %d phase1 %d phase2 %d prop %d brp %d",
+		bt->bitrate, bt->sample_point, bt->tq, bt->sjw, bt->phase_seg1, bt->phase_seg2, bt->prop_seg, bt->brp);
+
+	dev->bitrate_changed = 1;
+	wake_up_interruptible(&tx_wait);
+	return 0;
+}
+
+static int intrepid_set_data_bittiming(struct net_device *netdev)
+{
+	struct intrepid_netdevice *dev = netdev_priv(netdev);
+	struct can_bittiming *bt = &dev->can.data_bittiming;
+
+	dev_dbg(&netdev->dev, "bitrate %d sample_point %d tq %d sjw %d phase1 %d phase2 %d prop %d brp %d",
+		bt->bitrate, bt->sample_point, bt->tq, bt->sjw, bt->phase_seg1, bt->phase_seg2, bt->prop_seg, bt->brp);
+
+	dev->bitrate_changed = 1;
+	wake_up_interruptible(&tx_wait);
+	return 0;
+}
+
+static int intrepid_bitrates[] = {
+	20000,
+	33000,
+	50000,
+	62000,
+	83000,
+	100000,
+	125000,
+	250000,
+	500000,
+	666000,
+	800000,
+	1000000
+};
+
+static int intrepid_data_bitrates[] = {
+	20000,
+	33000,
+	50000,
+	62000,
+	83000,
+	100000,
+	125000,
+	250000,
+	500000,
+	666000,
+	800000,
+	1000000,
+	2000000,
+	4000000,
+	5000000,
+	6667000,
+	8000000,
+	10000000
+};
+
 static int intrepid_add_can_if(struct intrepid_netdevice **result, const char *requestedName)
 {
 	// The `requestedName` parameter is always NULL if KERNEL_SUPPORTS_ALIASES is false
@@ -383,15 +515,14 @@ static int intrepid_add_can_if(struct intrepid_netdevice **result, const char *r
 		goto exit;
 	}
 
-
 	dev->base_addr          = i;
 	dev->flags             |= IFF_ECHO;
 #if KERNEL_CHECKS_MTU_RANGE
 	dev->min_mtu            = CAN_MTU;
-	dev->max_mtu            = MAX_MTU;
+	dev->max_mtu            = CANFD_MTU;
 #endif
 	dev->mtu                = CANFD_MTU; /* TODO: Check CAN-FD support from usermode daemon */
-	dev->netdev_ops         = &intrepid_netdevice_ops;
+	dev->netdev_ops         = &intrepid_CAN_netdevice_ops;
 #if KERNEL_SUPPORTS_ALIASES
 	if (requestedName && ((aliasLen = strlen(requestedName)) > 0) && aliasLen < IFALIASZ) {
 		dev->ifalias = kzalloc(sizeof(struct dev_ifalias) + aliasLen + 1, GFP_KERNEL);
@@ -409,6 +540,17 @@ static int intrepid_add_can_if(struct intrepid_netdevice **result, const char *r
 	ics->from_user       = GET_RX_BOX(i); /* incoming rx messages */
 	ics->tx_idx          = 0;
 
+	if (VER_MIN_FROM_INT(client_version) > 1) {
+		ics->can.bitrate_const = intrepid_bitrates;
+		ics->can.bitrate_const_cnt = ARRAY_SIZE(intrepid_bitrates);
+		ics->can.data_bitrate_const = intrepid_data_bitrates;
+		ics->can.data_bitrate_const_cnt = ARRAY_SIZE(intrepid_data_bitrates);
+		ics->can.do_set_bittiming = intrepid_set_bittiming;
+		ics->can.do_set_data_bittiming = intrepid_set_data_bittiming;
+	}
+	ics->can.state = CAN_STATE_ERROR_ACTIVE;
+	ics->can.ctrlmode_supported = CAN_CTRLMODE_FD;
+
 	spin_lock_init(&ics->lock);
 
 	ret = register_candev(dev);
@@ -515,7 +657,7 @@ static int intrepid_fill_can_frame_from_neomessage(
  * If false is returned, this message should be handled as a receive
  * message, regardless of the transmit flag.
  */
-static bool handle_transmit_receipt(
+static bool handle_CAN_transmit_receipt(
 	struct net_device *device,
 	const neomessage_can_t *msg,
 	const uint8_t *data,
@@ -537,16 +679,182 @@ static bool handle_transmit_receipt(
 	/* unsuccessful transmits */
 	/* stats are handled in intrepid_fill_canerr_frame_from_neomessage */
 	if (msg->status.globalError) {
-		can_free_echo_skb(device, tx_idx, NULL);
+		can_free_echo_skb(device, tx_idx
+#if KERNEL_CAN_ECHO_TRACKS_LEN
+			, NULL
+#endif
+		);
 		return false;
 	}
 
-	length = can_get_echo_skb(device, tx_idx, NULL);
+	length = can_get_echo_skb(device, tx_idx
+#if KERNEL_CAN_ECHO_TRACKS_LEN
+		, NULL
+#endif
+	);
 	stats->tx_packets++;
 	stats->tx_bytes += length;
 	return true;
 }
 
+static bool handle_ETH_transmit_receipt(
+	const neomessage_eth_t *msg,
+	const uint8_t *data,
+	struct net_device_stats *stats)
+{
+	int tx_idx;
+
+	if (!msg->status.transmitMessage) {
+		return false;
+	}
+
+	tx_idx = intrepid_description_to_idx(msg->description);
+
+	/* not transmitted by us, maybe by CoreMini */
+	/* just handle it as a receive */
+	if (tx_idx < 0)
+		return false;
+
+	/* unsuccessful transmits */
+	if (msg->status.globalError) {
+		struct sk_buff *skb;
+		kfree_skb(&skb[tx_idx]);
+		return false;
+	}
+
+	stats->tx_packets++;
+	stats->tx_bytes += msg->length;
+
+	return true;
+}
+
+static int intrepid_remove_eth_if(int index)
+{
+	struct net_device *device = intrepid_get_dev_by_index(index);
+	if (!device)
+		return -EINVAL;
+
+	if (index != device->base_addr)
+		pr_warn("intrepid: Index of device %ld does not match given index %d\n", device->base_addr, index);
+
+	pr_info("intrepid: Removing device %d %s 0x%p\n", index, device->name, device);
+
+	unregister_netdev(device);
+
+	net_devices[index] = NULL;
+
+	pr_info("intrepid: Removed device %d\n", index);
+
+	return 0;
+}
+
+static int intrepid_add_eth_if(struct intrepid_netdevice **result, const char *requestedName)
+{
+	// The `requestedName` parameter is always NULL if KERNEL_SUPPORTS_ALIASES is false
+#if KERNEL_SUPPORTS_ALIASES
+	size_t aliasLen = 0;
+#endif
+	int i = 0;
+	int ret = -EPERM;
+	struct net_device *dev = NULL;
+	struct intrepid_netdevice *ics = NULL;
+
+	*result = NULL;
+	// Find the first NULL position in net_devices
+	for (i = 0; i < MAX_NET_DEVICES; ++i) {
+		if (net_devices[i] == NULL) {
+			break;
+		}
+	}
+
+	// If for loop never broke, there is no room in net_devices
+	if (i == MAX_NET_DEVICES) {
+		pr_alert("intrepid: No more netdevices available\n");
+		ret = -ENFILE;
+		goto exit;
+	}
+
+	// Allocates and sets an ethernet device
+	dev = alloc_etherdev(sizeof(*ics));
+
+	if (!dev) {
+		pr_alert("intrepid: Could not allocate ethernet device\n");
+		goto exit;
+	}
+
+	dev->base_addr = i;
+	dev->flags |= IFF_BROADCAST | IFF_MULTICAST | IFF_RUNNING;
+	dev->operstate = IF_OPER_UP;
+#if KERNEL_CHECKS_MTU_RANGE
+	dev->min_mtu = ETH_MIN_MTU;
+	dev->max_mtu = ETH_MAX_MTU;
+#endif
+	dev->mtu = ETH_DATA_LEN;
+	dev->netdev_ops = &intrepid_ETH_netdevice_ops;
+#if KERNEL_SUPPORTS_ALIASES
+	if (requestedName && ((aliasLen = strlen(requestedName)) > 0) && aliasLen < IFALIASZ) {
+		dev->ifalias = kzalloc(sizeof(struct dev_ifalias) + aliasLen + 1, GFP_KERNEL);
+		if (dev->ifalias == NULL) {
+			pr_alert("inrepid: Could not allocate space for ifalias %zu\n", sizeof(struct dev_ifalias));
+		}
+		else {
+			strncpy(dev->ifalias->ifalias, requestedName, aliasLen + 1);
+			pr_info("intrepid: %s alias set to %s\n", dev->name, requestedName);
+		}
+	}
+#endif
+	eth_hw_addr_random(dev);
+
+	ics = netdev_priv(dev);
+	ics->dev = dev;
+	ics->is_stopped = 0;
+	ics->from_user = GET_RX_BOX(i);
+	ics->tx_idx = 0;
+
+	spin_lock_init(&ics->lock);
+
+	ret = register_netdev(dev);
+
+	if (ret) {
+		pr_alert("intrepid: Could not register ethernet device\n");
+		free_netdev(dev);
+		goto exit;
+	}
+
+	net_devices[i] = dev;
+	*result = ics;
+
+	ret = i;
+
+	pr_info("intrepid: Allocated new netdevice %s @ %d\n", dev->name, ret);
+exit:
+	return ret;
+}
+
+static int intrepid_fill_eth_frame_from_neomessage(
+	struct net_device_stats *stats,
+	const neomessage_eth_t *msg,
+	const uint8_t *data,
+	struct sk_buff *skb)
+{
+	if (unlikely(msg->length > (ETH_FRAME_LEN + ETH_FCS_LEN))) {
+		stats->rx_dropped++;
+		return -1;
+	}
+
+	if (unlikely(skb == NULL)) {
+		stats->rx_dropped++;
+		return -1;
+	}
+
+	skb_put_data(skb, data, msg->length);
+	skb->protocol = eth_type_trans(skb, skb->dev);
+	stats->rx_bytes += msg->length;
+	stats->rx_packets++;
+
+	return 0;
+}
+
 static struct sk_buff *intrepid_skb_from_neomessage(
 	struct net_device *device,
 	const neomessage_frame_t *msg_generic,
@@ -554,75 +862,81 @@ static struct sk_buff *intrepid_skb_from_neomessage(
 	struct net_device_stats *stats)
 {
 	struct sk_buff *skb = NULL;
-	struct canfd_frame* cf = NULL;
-	const neomessage_can_t* msg = NULL;
 	int ret = 0;
 
 	/* input validation */
 	if (unlikely(device == NULL || msg_generic == NULL || data == NULL || stats == NULL)) {
 		stats->rx_dropped++;
-		pr_warn("intrepid: Dropping message on %s, skb from neomessage input validation failed", device->name);
+		pr_debug("intrepid: Dropping message on %s, skb from neomessage input validation failed", device->name);
 		goto out;
 	}
-
-	if (unlikely(msg_generic->type != ICSNEO_NETWORK_TYPE_CAN)) {
-		stats->rx_dropped++;
-		pr_warn("intrepid: Dropping message on %s, wrong type %d", device->name, (int)msg_generic->type);
+	switch (msg_generic->type) {
+		case ICSNEO_NETWORK_TYPE_CAN:
+			{
+				struct canfd_frame* cf = NULL;
+				const neomessage_can_t* can_msg = NULL;
+				can_msg = (const neomessage_can_t*)msg_generic;
+				if (handle_CAN_transmit_receipt(device, can_msg, data, stats))
 					goto out;
-	}
-
-	msg = (const neomessage_can_t*)msg_generic;
-
-	/* if this message is handled as a transmit receipt,
-	 * don't turn it into a receive skb here.
-	 */
-	if (handle_transmit_receipt(device, msg, data, stats))
-		goto out;
-
-	if (msg->status.globalError)
+				if (can_msg->status.globalError)
 					skb = alloc_can_err_skb(device, (struct can_frame**)&cf);
-	else if (msg->status.canfdFDF)
+				else if (can_msg->status.canfdFDF)
 					skb = alloc_canfd_skb(device, &cf);
 				else
 					skb = alloc_can_skb(device, (struct can_frame**)&cf);
 
+				/* if this message is handled as a transmit receipt,
+				* don't turn it into a receive skb here.
+				*/
 				if (unlikely(skb == NULL)) {
 					stats->rx_dropped++;
 					pr_warn("intrepid: Dropping message on %s, skb allocation failed", device->name);
 					goto out;
 				}
 
-	switch(msg->type) {
-		case ICSNEO_NETWORK_TYPE_CAN:
-			if (msg->status.globalError)
+				if (can_msg->status.globalError)
 					ret = intrepid_fill_canerr_frame_from_neomessage(
 					stats,
 					(struct can_frame*)cf,
-					(const neomessage_can_t*)msg);
-			else if (msg->status.canfdFDF)
+					(const neomessage_can_t*)can_msg);
+				else if (can_msg->status.canfdFDF)
 					ret = intrepid_fill_canfd_frame_from_neomessage(
 						stats,
 						cf,
-					(const neomessage_can_t*)msg,
+						(const neomessage_can_t*)can_msg,
 						data);
 				else
 					ret = intrepid_fill_can_frame_from_neomessage(
 						stats,
 						(struct can_frame*)cf,
-					(const neomessage_can_t*)msg,
+						(const neomessage_can_t*)can_msg,
 						data);
+			}
+			break;
+		case ICSNEO_NETWORK_TYPE_ETHERNET:
+			{
+				const neomessage_eth_t *msg = (const neomessage_eth_t*)msg_generic;
+				if (handle_ETH_transmit_receipt(msg, data, stats))
+					goto out;
+				skb = netdev_alloc_skb_ip_align(device, msg->length);
+				if (unlikely(skb == NULL)) {
+					stats->rx_dropped++;
+					pr_warn("intrepid: Dropping message on %s, skb allocation failed", device->name);
+					goto out;
+				}
+
+				ret = intrepid_fill_eth_frame_from_neomessage(stats, msg, data, skb);
+			}
 			break;
 		default:
-			pr_warn("intrepid: Dropping message on %s, invalid type %d", device->name, msg->type);
+			pr_debug("intrepid: Dropping message on %s, invalid type %d", device->name, msg_generic->type);
 			goto out;
 		}
 
-
 	if (unlikely(ret != 0)) {
-		pr_warn("intrepid: Dropping message on %s, frame fill failed", device->name);
+		pr_debug("intrepid: Dropping message on %s, frame fill failed", device->name);
 		goto out;
 	}
-
 out:
 	return skb;
 }
@@ -658,13 +972,13 @@ static int intrepid_read_messages(int device_index, unsigned int count)
 		data = currentPosition;
 		currentPosition += msg->length;
 
-		/* pass along the converted message to the kernel for dispatch */
 		skb = intrepid_skb_from_neomessage(device, msg, data, stats);
+		/* pass along the converted message to the kernel for dispatch */
 		if (skb != NULL)
 			ret = netif_rx(skb);
 
 		if (ret == NET_RX_DROP)
-			pr_warn("intrepid: Dropping message on %s, dropped by kernel", device->name);
+			pr_debug("intrepid: Dropping message on %s, dropped by kernel", device->name);
 	}
 
 	spin_unlock_bh(&ics->lock);
@@ -679,8 +993,8 @@ static long intrepid_dev_ioctl(struct file *fp, unsigned int cmd, unsigned long
 		return -ERESTARTSYS;
 	}
 
-	switch (cmd) {
-		case SIOCSADDIF: {
+	switch(cmd) {
+		case SIOCSADDCANIF: {
 			struct intrepid_netdevice *result = NULL;
 #if KERNEL_SUPPORTS_ALIASES
 			char requestedNameBuffer[IFALIASZ] = {0};
@@ -688,7 +1002,7 @@ static long intrepid_dev_ioctl(struct file *fp, unsigned int cmd, unsigned long
 			int bytesNotCopied = 0;
 			if ((void __user*)arg != NULL) {
 				bytesNotCopied = copy_from_user(requestedNameBuffer, (void __user*)arg, IFALIASZ);
-				if(bytesNotCopied != 0)
+				if (bytesNotCopied != 0)
 					pr_warn("intrepid: %d bytes not copied for alias", bytesNotCopied);
 				requestedName = requestedNameBuffer;
 			}
@@ -698,9 +1012,46 @@ static long intrepid_dev_ioctl(struct file *fp, unsigned int cmd, unsigned long
 #endif
 			break;
 		}
-		case SIOCSREMOVEIF:
+		case SIOCSREMOVECANIF:
 			ret = intrepid_remove_can_if (arg);
 			break;
+		case SIOCSBAUDRATE: {
+			struct baudrate_info {
+				int handle;
+				int64_t baudrates[2];
+			} info;
+			ret = copy_from_user(&info, (void __user*)arg, sizeof(info));
+			if (ret)
+				break;
+			struct net_device *device = intrepid_get_dev_by_index(info.handle);
+			if (device == NULL)
+				break;
+			struct intrepid_netdevice *ics = netdev_priv(device);
+			ics->can.bittiming.bitrate = info.baudrates[0];
+			ics->can.data_bittiming.bitrate = info.baudrates[1];
+			break;
+		}
+		case SIOCSADDETHIF: {
+			struct intrepid_netdevice *result = NULL;
+#if KERNEL_SUPPORTS_ALIASES
+			char requestedNameBuffer[IFALIASZ] = {0};
+			char* requestedName = NULL;
+			int bytesNotCopied = 0;
+			if ((void __user*)arg != NULL) {
+				bytesNotCopied = copy_from_user(requestedNameBuffer, (void __user*)arg, IFALIASZ);
+				if (bytesNotCopied != 0)
+					pr_warn("intrepid: %d bytes not copied for alias", bytesNotCopied);
+				requestedName = requestedNameBuffer;
+			}
+			ret = intrepid_add_eth_if(&result, requestedName);
+#else
+			ret = intrepid_add_eth_if(&result, NULL);
+#endif
+			break;
+		}
+		case SIOCSREMOVEETHIF:
+			ret = intrepid_remove_eth_if (arg);
+			break;
 		case SIOCGSHAREDMEMSIZE:
 			ret = SHARED_MEM_SIZE;
 			break;
@@ -711,13 +1062,8 @@ static long intrepid_dev_ioctl(struct file *fp, unsigned int cmd, unsigned long
 			ret = KO_VERSION_INT;
 			break;
 		case SIOCGCLIENTVEROK:
-			/* Here we can do checks to see if the usermode daemon is
-			 * a compatible version with us. We don't enforce anything
-			 * on the kernel side. icsscand v2.0.0 will not work with
-			 * older kernels, and would display an obscure error, thus
-			 * we want to ask the user to update to v2.0.1 or later
-			 */
-			if (VER_MAJ_FROM_INT(arg) == 2 && (VER_MIN_FROM_INT(arg) > 0 || VER_PATCH_FROM_INT(arg) >= 1))
+			client_version = arg;
+			if (VER_MAJ_FROM_INT(arg) == 3 && VER_MIN_FROM_INT(arg) >= 1 && VER_PATCH_FROM_INT(arg) >= 0)
 				ret = 0; /* ok to start */
 			else
 				ret = 1;
@@ -782,14 +1128,45 @@ static int intrepid_dev_release(struct inode *ip, struct file *fp)
 	wake_up_interruptible(&tx_wait);
 
 	for (i = 0; i < MAX_NET_DEVICES; i++) {
-		if (net_devices[i] != NULL)
+		if (net_devices[i] != NULL) {
+			if (net_devices[i]->type == ARPHRD_CAN)
 				intrepid_remove_can_if(i);
+			else if (net_devices[i]->type == ARPHRD_ETHER)
+				intrepid_remove_eth_if(i);
+		}
 	}
 
 	is_open = 0;
 	return 0;
 }
 
+/* Re-use the pending_tx_info struct to send changed bitrates to userland
+ * Set the box index to -(dev_id) and encode the rest of the data in the count
+ * and bytes fields.
+ * count is the bitrate value
+ * bytes is the data bitrate value. */
+static int check_bitrate_change(struct intrepid_pending_tx_info *info)
+{
+	int i;
+	struct intrepid_netdevice *ics;
+
+	for (i = 0; i < MAX_NET_DEVICES; i++) {
+		if (net_devices[i] == NULL || net_devices[i]->type != ARPHRD_CAN)
+			continue;
+		ics = netdev_priv(net_devices[i]);
+
+		if (ics->bitrate_changed) {
+			info->tx_box_index = -(i + 1);
+			info->count = ics->can.bittiming.bitrate;
+			info->bytes = ics->can.data_bittiming.bitrate;
+			ics->bitrate_changed = 0;
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
 /* usermode uses read() to get the current size of the tx buffer. we use a ping pong buffer
  * so the user doesn't have to worry about the data changing out from under them while
  * still avoiding a full copy to user. the ping pong flips on every call to this func */
@@ -801,6 +1178,15 @@ static ssize_t intrepid_dev_read(struct file *fp, char *buffer, size_t len, loff
 	if (len < sizeof(info))
 		return -EFAULT;
 
+	/* check if we have to send a bitrate change */
+	if (VER_MIN_FROM_INT(client_version) > 1) {
+		if (check_bitrate_change(&info)) {
+			if (copy_to_user(buffer, &info, sizeof(info)))
+				return -EFAULT;
+			return sizeof(info);
+		}
+	}
+
 	spin_lock_bh(&tx_box_lock);
 
 	/* fill out the info for the user */
@@ -835,6 +1221,18 @@ static unsigned int intrepid_dev_poll(struct file *fp, poll_table *wait)
 	if (tx_box_count[current_tx_box] > 0)
 		return POLLIN | POLLRDNORM;
 
+	if (VER_MIN_FROM_INT(client_version) > 1) {
+		int i;
+		for (i = 0; i < MAX_NET_DEVICES; i++) {
+			if (net_devices[i] == NULL || net_devices[i]->type != ARPHRD_CAN)
+				continue;
+			struct intrepid_netdevice *ics = netdev_priv(net_devices[i]);
+
+			if (ics->bitrate_changed)
+				return POLLIN | POLLRDNORM;
+		}
+	}
+
 	return 0;
 }
 
@@ -852,6 +1250,17 @@ static __init int intrepid_init(void)
 	int ret;
 	pr_info("intrepid: %s %s\n", KO_DESC, KO_VERSION);
 
+	BUILD_BUG_ON_MSG(sizeof(neomessage_t) != (56 + sizeof(void*) + sizeof(size_t)),
+		"neomessage_t size is incorrect!");
+	BUILD_BUG_ON_MSG(sizeof(neomessage_frame_t) != sizeof(neomessage_t),
+		"All types of neomessage_t must be the same size! (Base frame is not)");
+	BUILD_BUG_ON_MSG(sizeof(neomessage_can_t) != sizeof(neomessage_t),
+		"All types of neomessage_t must be the same size! (CAN is not)");
+	BUILD_BUG_ON_MSG(sizeof(neomessage_can_error_t) != sizeof(neomessage_t),
+		"All types of neomessage_t must be the same size! (CAN error is not)");
+	BUILD_BUG_ON_MSG(sizeof(neomessage_eth_t) != sizeof(neomessage_t),
+		"All types of neomessage_t must be the same size! (Ethernet is not)");
+
 	is_open = 0;
 
 	/* this is the shared memory used to transfer between us and the user daemon */
@@ -893,7 +1302,11 @@ static __init int intrepid_init(void)
 		return -1;
 	}
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 4, 0)
 	intrepid_dev_class = class_create(THIS_MODULE, INTREPID_CLASS_NAME);
+#else
+	intrepid_dev_class = class_create(INTREPID_CLASS_NAME);
+#endif
 	if (IS_ERR(intrepid_dev_class)) {
 		ret = PTR_ERR(intrepid_dev_class);
 		pr_alert("intrepid: failed to create device class, got %d\n", ret);
@@ -934,8 +1347,12 @@ static __exit void intrepid_exit(void)
 	unregister_chrdev(major_number, INTREPID_DEVICE_NAME);
 
 	for (i = 0; i < MAX_NET_DEVICES; i++) {
-		if (net_devices[i] != NULL)
+		if (net_devices[i] != NULL) {
+			if (net_devices[i]->type == ARPHRD_CAN)
 				intrepid_remove_can_if(i);
+			else if (net_devices[i]->type == ARPHRD_ETHER)
+				intrepid_remove_eth_if(i);
+		}
 	}
 
 	kfree(net_devices);