* Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
*/
-#define pr_fmt(fmt) "[elmcan] " fmt
+#define pr_fmt(fmt) "elmcan: " fmt
#include <linux/init.h>
#include <linux/module.h>
#include <linux/if_ether.h>
#include <linux/kernel.h>
#include <linux/list.h>
+#include <linux/lockdep.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/can/led.h>
#include <linux/can/rx-offload.h>
-MODULE_ALIAS_LDISC(N_DEVELOPMENT);
-MODULE_DESCRIPTION("ELM327 based CAN interface");
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");
-
/* Line discipline ID number.
* N_DEVELOPMENT will likely be defined from Linux 5.18 onwards:
* https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git/commit/?h=tty-next&id=c2faf737abfb10f88f2d2612d573e9edc3c42c37
struct can_rx_offload offload;
/* TTY and netdev devices that we're bridging */
- struct tty_struct *tty;
- struct net_device *dev;
+ struct tty_struct *tty;
+ struct net_device *dev;
/* Per-channel lock */
- spinlock_t lock;
-
- /* Keep track of how many things are using this struct.
- * Once it reaches 0, we are in the process of cleaning up,
- * and new operations will be cancelled immediately.
- * Use atomic_t rather than refcount_t because we deliberately
- * decrement to 0, and refcount_dec() spills a WARN_ONCE in
- * that case.
- */
- atomic_t refcount;
+ spinlock_t lock;
/* Stop the channel on hardware failure.
* Once this is true, nothing will be sent to the TTY.
*/
- bool hw_failure;
+ bool hw_failure;
/* TTY TX helpers */
- struct work_struct tx_work; /* Flushes TTY TX buffer */
- unsigned char *txbuf;
- unsigned char *txhead; /* Pointer to next TX byte */
- int txleft; /* Bytes left to TX */
+ struct work_struct tx_work; /* Flushes TTY TX buffer */
+ u8 *txbuf; /* Pointer to our TX buffer */
+ u8 *txhead; /* Pointer to next TX byte */
+ unsigned txleft; /* Bytes left to TX */
/* TTY RX helpers */
- unsigned char rxbuf[ELM327_SIZE_RXBUF];
+ u8 rxbuf[ELM327_SIZE_RXBUF];
int rxfill;
/* State machine */
enum {
- ELM_NOTINIT = 0,
- ELM_GETDUMMYCHAR,
- ELM_GETPROMPT,
- ELM_RECEIVING,
+ ELM327_STATE_NOTINIT = 0,
+ ELM327_STATE_GETDUMMYCHAR,
+ ELM327_STATE_GETPROMPT,
+ ELM327_STATE_RECEIVING,
} state;
- int drop_next_line;
+ bool drop_next_line;
/* The CAN frame and config the ELM327 is sending/using,
* or will send/use after finishing all cmds_todo
*/
struct can_frame can_frame_to_send;
- unsigned short can_config;
- unsigned long can_bitrate;
- unsigned char can_bitrate_divisor;
- int silent_monitoring;
+ u16 can_config;
+ u8 can_bitrate_divisor;
/* Things we have yet to send */
char **next_init_cmd;
unsigned long cmds_todo;
};
-/* A lock for all tty->disc_data handled by this ldisc.
- * This is to prevent a case where tty->disc_data is set to NULL,
- * yet someone is still trying to dereference it.
- * Without this, we cannot do a clean shutdown.
- */
-static DEFINE_SPINLOCK(elmcan_discdata_lock);
-
static inline void elm327_hw_failure(struct elmcan *elm);
-/* Assumes elm->lock taken. */
static void elm327_send(struct elmcan *elm, const void *buf, size_t len)
{
- int actual;
+ int written;
+
+ lockdep_assert_held(elm->lock);
if (elm->hw_failure)
return;
memcpy(elm->txbuf, buf, len);
- /* Order of next two lines is *very* important.
- * When we are sending a little amount of data,
- * the transfer may be completed inside the ops->write()
- * routine, because it's running with interrupts enabled.
- * In this case we *never* got WRITE_WAKEUP event,
- * if we did not request it before write operation.
- * 14 Oct 1994 Dmitry Gorodchanin.
- */
- set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
- actual = elm->tty->ops->write(elm->tty, elm->txbuf, len);
- if (actual < 0) {
+ written = elm->tty->ops->write(elm->tty, elm->txbuf, len);
+ if (written < 0) {
netdev_err(elm->dev,
"Failed to write to tty %s.\n",
elm->tty->name);
return;
}
- elm->txleft = len - actual;
- elm->txhead = elm->txbuf + actual;
+ elm->txleft = len - written;
+ elm->txhead = elm->txbuf + written;
+
+ if (!elm->txleft)
+ netif_wake_queue(elm->dev);
+ else
+ set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
}
/* Take the ELM327 out of almost any state and back into command mode.
* We send ELM327_DUMMY_CHAR which will either abort any running
* operation, or be echoed back to us in case we're already in command
* mode.
- *
- * Assumes elm->lock taken.
*/
static void elm327_kick_into_cmd_mode(struct elmcan *elm)
{
- if (elm->state != ELM_GETDUMMYCHAR && elm->state != ELM_GETPROMPT) {
+ lockdep_assert_held(elm->lock);
+
+ if (elm->state != ELM327_STATE_GETDUMMYCHAR &&
+ elm->state != ELM327_STATE_GETPROMPT) {
elm327_send(elm, ELM327_DUMMY_STRING, 1);
- elm->state = ELM_GETDUMMYCHAR;
+ elm->state = ELM327_STATE_GETDUMMYCHAR;
}
}
-/* Schedule a CAN frame and necessary config changes to be sent to the TTY.
- *
- * Assumes elm->lock taken.
- */
+/* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
static void elm327_send_frame(struct elmcan *elm, struct can_frame *frame)
{
+ lockdep_assert_held(elm->lock);
+
/* Schedule any necessary changes in ELM327's CAN configuration */
if (elm->can_frame_to_send.can_id != frame->can_id) {
/* Set the new CAN ID for transmission. */
- if ((frame->can_id & CAN_EFF_FLAG)
- ^ (elm->can_frame_to_send.can_id & CAN_EFF_FLAG)) {
+ if ((frame->can_id & CAN_EFF_FLAG) ^
+ (elm->can_frame_to_send.can_id & CAN_EFF_FLAG)) {
elm->can_config = (frame->can_id & CAN_EFF_FLAG
? 0
: ELM327_CAN_CONFIG_SEND_SFF)
elm327_kick_into_cmd_mode(elm);
}
-/* ELM327 initialization sequence.
- *
- * Assumes elm->lock taken.
- */
+/* ELM327 initialisation sequence. */
static char *elm327_init_script[] = {
"AT WS\r", /* v1.0: Warm Start */
"AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */
"AT M0\r", /* v1.0: Memory Off */
"AT AL\r", /* v1.0: Allow Long messages */
- "AT BI\r", /* v1.0: Bypass Initialization */
+ "AT BI\r", /* v1.0: Bypass Initialisation */
"AT CAF0\r", /* v1.0: CAN Auto Formatting Off */
"AT CFC0\r", /* v1.0: CAN Flow Control Off */
"AT CF 000\r", /* v1.0: Reset CAN ID Filter */
static void elm327_init(struct elmcan *elm)
{
- elm->state = ELM_NOTINIT;
+ lockdep_assert_held(elm->lock);
+
+ elm->state = ELM327_STATE_NOTINIT;
elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */
elm->rxfill = 0;
elm->drop_next_line = 0;
elm327_kick_into_cmd_mode(elm);
}
-/* Assumes elm->lock taken. */
static void elm327_feed_frame_to_netdev(struct elmcan *elm,
struct sk_buff *skb)
{
+ lockdep_assert_held(elm->lock);
+
if (!netif_running(elm->dev))
return;
#endif
}
-/* Called when we're out of ideas and just want it all to end.
- * Assumes elm->lock taken.
- */
+/* Called when we're out of ideas and just want it all to end. */
static inline void elm327_hw_failure(struct elmcan *elm)
{
struct can_frame *frame;
struct sk_buff *skb;
+ lockdep_assert_held(elm->lock);
+
elm->hw_failure = true;
elm->can.can_stats.bus_off++;
elm327_feed_frame_to_netdev(elm, skb);
}
-/* Compare a buffer to a fixed string */
-static inline int _memstrcmp(const u8 *mem, const char *str)
-{
- return memcmp(mem, str, strlen(str));
-}
-
/* Compare buffer to string length, then compare buffer to fixed string.
* This ensures two things:
* - It flags cases where the fixed string is only the start of the
* buffer, rather than exactly all of it.
* - It avoids byte comparisons in case the length doesn't match.
+ *
+ * strncmp() cannot be used here because it accepts the following wrong case:
+ * strncmp("CAN ER", "CAN ERROR", 6);
+ * This must fail, hence this helper function.
*/
-static inline int _len_memstrcmp(const u8 *mem, size_t mem_len, const char *str)
+static inline int check_len_then_cmp(const u8 *mem, size_t mem_len, const char *str)
{
size_t str_len = strlen(str);
- return (mem_len != str_len) || memcmp(mem, str, str_len);
+ return (mem_len == str_len) && !memcmp(mem, str, str_len);
}
-/* Assumes elm->lock taken. */
static void elm327_parse_error(struct elmcan *elm, size_t len)
{
struct can_frame *frame;
struct sk_buff *skb;
+ lockdep_assert_held(elm->lock);
+
skb = alloc_can_err_skb(elm->dev, &frame);
if (!skb)
/* It's okay to return here:
return;
/* Filter possible error messages based on length of RX'd line */
- if (!_len_memstrcmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
+ if (check_len_then_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
netdev_err(elm->dev,
"ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
- } else if (!_len_memstrcmp(elm->rxbuf, len, "BUFFER FULL")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "BUFFER FULL")) {
/* This will only happen if the last data line was complete.
* Otherwise, elm327_parse_frame() will heuristically
* emit this kind of error frame instead.
*/
frame->can_id |= CAN_ERR_CRTL;
frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
- } else if (!_len_memstrcmp(elm->rxbuf, len, "BUS ERROR")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "BUS ERROR")) {
frame->can_id |= CAN_ERR_BUSERROR;
- } else if (!_len_memstrcmp(elm->rxbuf, len, "CAN ERROR")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "CAN ERROR")) {
frame->can_id |= CAN_ERR_PROT;
- } else if (!_len_memstrcmp(elm->rxbuf, len, "<RX ERROR")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "<RX ERROR")) {
frame->can_id |= CAN_ERR_PROT;
- } else if (!_len_memstrcmp(elm->rxbuf, len, "BUS BUSY")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "BUS BUSY")) {
frame->can_id |= CAN_ERR_PROT;
frame->data[2] = CAN_ERR_PROT_OVERLOAD;
- } else if (!_len_memstrcmp(elm->rxbuf, len, "FB ERROR")) {
+ } else if (check_len_then_cmp(elm->rxbuf, len, "FB ERROR")) {
frame->can_id |= CAN_ERR_PROT;
frame->data[2] = CAN_ERR_PROT_TX;
- } else if (len == 5 && !_memstrcmp(elm->rxbuf, "ERR")) {
+ } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) {
/* ERR is followed by two digits, hence line length 5 */
netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n",
elm->rxbuf[3], elm->rxbuf[4]);
* Instead of a payload, RTR indicates a remote request.
*
* We will use the spaces and line length to guess the format.
- *
- * Assumes elm->lock taken.
*/
static int elm327_parse_frame(struct elmcan *elm, size_t len)
{
int datastart;
int i;
+ lockdep_assert_held(elm->lock);
+
skb = alloc_can_skb(elm->dev, &frame);
if (!skb)
return -ENOMEM;
frame->can_id = CAN_EFF_FLAG;
datastart = 14;
} else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
- frame->can_id = 0;
datastart = 6;
} else {
/* This is not a well-formatted data line.
/* Check for RTR frame */
if (elm->rxfill >= hexlen + 3 &&
- !_memstrcmp(&elm->rxbuf[hexlen], "RTR")) {
+ !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
frame->can_id |= CAN_RTR_FLAG;
}
return 0;
}
-/* Assumes elm->lock taken. */
static void elm327_parse_line(struct elmcan *elm, size_t len)
{
+ lockdep_assert_held(elm->lock);
+
/* Skip empty lines */
if (!len)
return;
if (elm->drop_next_line) {
elm->drop_next_line = 0;
return;
- } else if (!_memstrcmp(elm->rxbuf, "AT")) {
+ } else if (!memcmp(elm->rxbuf, "AT", 2)) {
return;
}
/* Regular parsing */
- if (elm->state == ELM_RECEIVING
+ if (elm->state == ELM327_STATE_RECEIVING
&& elm327_parse_frame(elm, len)) {
/* Parse an error line. */
elm327_parse_error(elm, len);
}
}
-/* Assumes elm->lock taken. */
static void elm327_handle_prompt(struct elmcan *elm)
{
struct can_frame *frame = &elm->can_frame_to_send;
char local_txbuf[20];
+ lockdep_assert_held(elm->lock);
+
if (!elm->cmds_todo) {
/* Enter CAN monitor mode */
elm327_send(elm, "ATMA\r", 5);
- elm->state = ELM_RECEIVING;
+ elm->state = ELM327_STATE_RECEIVING;
return;
}
}
elm->drop_next_line = 1;
- elm->state = ELM_RECEIVING;
+ elm->state = ELM327_STATE_RECEIVING;
}
elm327_send(elm, local_txbuf, strlen(local_txbuf));
return (c & 0x3f) == ELM327_READY_CHAR;
}
-/* Assumes elm->lock taken. */
static void elm327_drop_bytes(struct elmcan *elm, size_t i)
{
+ lockdep_assert_held(elm->lock);
+
memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
elm->rxfill -= i;
}
-/* Assumes elm->lock taken. */
static void elm327_parse_rxbuf(struct elmcan *elm)
{
size_t len;
int i;
+ lockdep_assert_held(elm->lock);
+
switch (elm->state) {
- case ELM_NOTINIT:
+ case ELM327_STATE_NOTINIT:
elm->rxfill = 0;
break;
- case ELM_GETDUMMYCHAR:
+ case ELM327_STATE_GETDUMMYCHAR:
{
/* Wait for 'y' or '>' */
for (i = 0; i < elm->rxfill; i++) {
if (elm->rxbuf[i] == ELM327_DUMMY_CHAR) {
elm327_send(elm, "\r", 1);
- elm->state = ELM_GETPROMPT;
+ elm->state = ELM327_STATE_GETPROMPT;
i++;
break;
} else if (elm327_is_ready_char(elm->rxbuf[i])) {
break;
}
- case ELM_GETPROMPT:
+ case ELM327_STATE_GETPROMPT:
/* Wait for '>' */
if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
elm327_handle_prompt(elm);
elm->rxfill = 0;
break;
- case ELM_RECEIVING:
+ case ELM327_STATE_RECEIVING:
/* Find <CR> delimiting feedback lines. */
for (len = 0;
(len < elm->rxfill) && (elm->rxbuf[len] != '\r');
}
}
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
/* Dummy needed to use can_rx_offload */
static struct sk_buff *elmcan_mailbox_read(struct can_rx_offload *offload,
unsigned int n, u32 *timestamp,
return ERR_PTR(-ENOBUFS);
}
+#endif
static int elmcan_netdev_open(struct net_device *dev)
{
elm327_init(elm);
spin_unlock_bh(&elm->lock);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
elm->offload.mailbox_read = elmcan_mailbox_read;
err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT);
+#else
+ err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT);
+#endif
if (err) {
close_candev(dev);
return err;
struct elmcan *elm = netdev_priv(dev);
struct can_frame *frame = (struct can_frame *)skb->data;
+ if (can_dropped_invalid_skb(dev, skb))
+ return NETDEV_TX_OK;
+
/* BHs are already disabled, so no spin_lock_bh().
* See Documentation/networking/netdevices.txt
*/
.ndo_change_mtu = can_change_mtu,
};
-/* Get a reference to our struct, taking into account locks/refcounts.
- * This is to ensure ordering in case we are shutting down, and to ensure
- * there is a refcount at all (otherwise tty->disc_data may be freed and
- * before we increment the refcount).
- * Use this for anything that can race against elmcan_ldisc_close().
- */
-static struct elmcan *get_elm(struct tty_struct *tty)
-{
- struct elmcan *elm;
- bool got_ref;
-
- spin_lock_bh(&elmcan_discdata_lock);
- elm = (struct elmcan *)tty->disc_data;
-
- if (!elm) {
- spin_unlock_bh(&elmcan_discdata_lock);
- return NULL;
- }
-
- got_ref = atomic_inc_not_zero(&elm->refcount);
- spin_unlock_bh(&elmcan_discdata_lock);
-
- if (!got_ref)
- return NULL;
-
- return elm;
-}
-
-static void put_elm(struct elmcan *elm)
-{
- atomic_dec(&elm->refcount);
-}
-
static bool elmcan_is_valid_rx_char(char c)
{
return (isdigit(c) ||
const unsigned char *cp, const char *fp, int count)
#endif
{
- struct elmcan *elm = get_elm(tty);
-
- if (!elm)
- return;
+ struct elmcan *elm = (struct elmcan *)tty->disc_data;
spin_lock_bh(&elm->lock);
out:
spin_unlock_bh(&elm->lock);
- put_elm(elm);
}
/* Write out remaining transmit buffer.
*/
static void elmcan_ldisc_tx_worker(struct work_struct *work)
{
- /* No need to use get_elm() here, as we'll always flush workers
- * before destroying the elmcan object.
- */
struct elmcan *elm = container_of(work, struct elmcan, tx_work);
- ssize_t actual;
+ ssize_t written;
- spin_lock_bh(&elm->lock);
- if (elm->hw_failure) {
- spin_unlock_bh(&elm->lock);
+ if (elm->hw_failure)
return;
- }
- if (!elm->tty || !netif_running(elm->dev)) {
- spin_unlock_bh(&elm->lock);
- return;
+ spin_lock_bh(&elm->lock);
+
+ if (elm->txleft) {
+ written = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
+ if (written < 0) {
+ netdev_err(elm->dev,
+ "Failed to write to tty %s.\n",
+ elm->tty->name);
+ elm327_hw_failure(elm);
+ spin_unlock_bh(&elm->lock);
+ return;
+ } else {
+ elm->txleft -= written;
+ elm->txhead += written;
+ }
}
- if (elm->txleft <= 0) {
- /* Our TTY write buffer is empty:
- * Allow netdev to hand us another packet
- */
+ if (!elm->txleft) {
clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
spin_unlock_bh(&elm->lock);
netif_wake_queue(elm->dev);
- return;
- }
-
- actual = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
- if (actual < 0) {
- netdev_err(elm->dev,
- "Failed to write to tty %s.\n",
- elm->tty->name);
- elm327_hw_failure(elm);
+ } else {
spin_unlock_bh(&elm->lock);
- return;
}
-
- elm->txleft -= actual;
- elm->txhead += actual;
- spin_unlock_bh(&elm->lock);
}
/* Called by the driver when there's room for more data. */
static void elmcan_ldisc_tx_wakeup(struct tty_struct *tty)
{
- struct elmcan *elm = get_elm(tty);
-
- if (!elm)
- return;
+ struct elmcan *elm = (struct elmcan *)tty->disc_data;
schedule_work(&elm->tx_work);
-
- put_elm(elm);
}
/* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
tty->receive_room = 65536; /* We don't flow control */
elm->txleft = 0; /* Clear TTY TX buffer */
spin_lock_init(&elm->lock);
- atomic_set(&elm->refcount, 1);
INIT_WORK(&elm->tx_work, elmcan_ldisc_tx_worker);
/* Configure CAN metadata */
- elm->can.state = CAN_STATE_STOPPED;
elm->can.bitrate_const = elmcan_bitrate_const;
elm->can.bitrate_const_cnt = ARRAY_SIZE(elmcan_bitrate_const);
elm->can.do_set_bittiming = elmcan_do_set_bittiming;
*/
static void elmcan_ldisc_close(struct tty_struct *tty)
{
- struct elmcan *elm = get_elm(tty);
-
- if (!elm)
- return;
+ struct elmcan *elm = (struct elmcan *)tty->disc_data;
/* unregister_netdev() calls .ndo_stop() so we don't have to. */
unregister_candev(elm->dev);
- /* Decrease the refcount twice, once for our own get_elm(),
- * and once to remove the count of 1 that we set in _open().
- * Once it reaches 0, we can safely destroy it.
- */
- put_elm(elm);
- put_elm(elm);
-
- while (atomic_read(&elm->refcount) > 0)
- msleep_interruptible(10);
-
- /* At this point, all ldisc calls to us have become no-ops. */
-
+ /* Ensure that our worker won't be rescheduled */
+ clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
flush_work(&elm->tx_work);
/* Mark channel as dead */
free_candev(elm->dev);
}
-#if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
-static int elmcan_ldisc_hangup(struct tty_struct *tty)
-#else
-static void elmcan_ldisc_hangup(struct tty_struct *tty)
-#endif
-{
- elmcan_ldisc_close(tty);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
- return 0;
-#endif
-}
-
static int elmcan_ldisc_ioctl(struct tty_struct *tty,
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
struct file *file,
#endif
unsigned int cmd, unsigned long arg)
{
- struct elmcan *elm = get_elm(tty);
+ struct elmcan *elm = (struct elmcan *)tty->disc_data;
unsigned int tmp;
- if (!elm)
- return -EINVAL;
-
switch (cmd) {
case SIOCGIFNAME:
tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
- if (copy_to_user((void __user *)arg, elm->dev->name, tmp)) {
- put_elm(elm);
+ if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
return -EFAULT;
- }
-
- put_elm(elm);
return 0;
case SIOCSIFHWADDR:
- put_elm(elm);
return -EINVAL;
default:
- put_elm(elm);
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
return tty_mode_ioctl(tty, file, cmd, arg);
#else
.write_wakeup = elmcan_ldisc_tx_wakeup,
.open = elmcan_ldisc_open,
.close = elmcan_ldisc_close,
- .hangup = elmcan_ldisc_hangup,
.ioctl = elmcan_ldisc_ioctl,
};
module_init(elmcan_init);
module_exit(elmcan_exit);
+
+MODULE_ALIAS_LDISC(N_DEVELOPMENT);
+MODULE_DESCRIPTION("ELM327 based CAN interface");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");