* Funded by: Volkswagen Group Research
*/
-#define DEBUG 1 /* Enables pr_debug() printouts */
+//#define DEBUG 1 /* Enables pr_debug() printouts */
+//#define SLLIN_LED_TRIGGER /* Enables led triggers */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/version.h>
#include "linux/lin_bus.h"
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0)
+#include <uapi/linux/sched/types.h>
+#endif
+
/* Should be in include/linux/tty.h */
#define N_SLLIN 25
+#define N_SLLIN_SLAVE 26
/* -------------------------------- */
+#ifdef SLLIN_LED_TRIGGER
+#define SLLIN_LED_NAME_SZ (IFNAMSIZ + 6)
+#include <linux/leds.h>
+
+enum sllin_led_event {
+ SLLIN_LED_EVENT_OPEN,
+ SLLIN_LED_EVENT_STOP,
+ SLLIN_LED_EVENT_TX,
+ SLLIN_LED_EVENT_RX
+};
+
+static unsigned long led_delay = 50;
+module_param(led_delay, ulong, 0644);
+MODULE_PARM_DESC(led_delay,
+ "blink delay time for activity leds (msecs, default: 50).");
+#endif /* SLLIN_LED_TRIGGER */
+
static __initdata const char banner[] =
KERN_INFO "sllin: serial line LIN interface driver\n";
static bool master = true;
static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
+#ifndef BREAK_BY_BAUD
+static bool break_by_baud = false;
+#else /*BREAK_BY_BAUD*/
+static bool break_by_baud = true;
+#endif /*BREAK_BY_BAUD*/
-module_param(master, bool, 0);
+module_param(master, bool, 0444);
MODULE_PARM_DESC(master, "LIN interface is Master device");
-module_param(baudrate, int, 0);
+module_param(baudrate, int, 0444);
MODULE_PARM_DESC(baudrate, "Baudrate of LIN interface");
+module_param(break_by_baud, bool, 0444);
+MODULE_PARM_DESC(break_by_baud, "Break is sent by temporal baudrate switching");
static int maxdev = 10; /* MAX number of SLLIN channels;
This can be overridden with
insmod sllin.ko maxdev=nnn */
-module_param(maxdev, int, 0);
+module_param(maxdev, int, 0444);
MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
/* maximum buffer len to store whole LIN message*/
int tx_lim; /* actual limit of bytes to Tx */
int tx_cnt; /* number of already Tx bytes */
char lin_master; /* node is a master node */
+ bool lin_break_by_baud; /* send break character by baudrate switching */
int lin_baud; /* LIN baudrate */
int lin_state; /* state */
char id_to_send; /* there is ID to be sent */
/* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
spinlock_t linfr_lock; /* frame cache and buffers lock */
+
+#ifdef SLLIN_LED_TRIGGER
+ struct led_trigger *tx_led_trig;
+ char tx_led_trig_name[SLLIN_LED_NAME_SZ];
+ struct led_trigger *rx_led_trig;
+ char rx_led_trig_name[SLLIN_LED_NAME_SZ];
+ struct led_trigger *rxtx_led_trig;
+ char rxtx_led_trig_name[SLLIN_LED_NAME_SZ];
+#endif
};
static struct net_device **sllin_devs;
0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
};
+#ifdef SLLIN_LED_TRIGGER
+static void sllin_led_event(struct net_device *netdev, enum sllin_led_event event)
+{
+ struct sllin *sl = netdev_priv(netdev);
+
+ switch (event) {
+ case SLLIN_LED_EVENT_OPEN:
+ led_trigger_event(sl->tx_led_trig, LED_FULL);
+ led_trigger_event(sl->rx_led_trig, LED_FULL);
+ led_trigger_event(sl->rxtx_led_trig, LED_FULL);
+ break;
+ case SLLIN_LED_EVENT_STOP:
+ led_trigger_event(sl->tx_led_trig, LED_OFF);
+ led_trigger_event(sl->rx_led_trig, LED_OFF);
+ led_trigger_event(sl->rxtx_led_trig, LED_OFF);
+ break;
+ case SLLIN_LED_EVENT_TX:
+ if (led_delay) {
+ led_trigger_blink_oneshot(sl->tx_led_trig,
+ &led_delay, &led_delay, 1);
+ led_trigger_blink_oneshot(sl->rxtx_led_trig,
+ &led_delay, &led_delay, 1);
+ }
+ break;
+ case SLLIN_LED_EVENT_RX:
+ if (led_delay) {
+ led_trigger_blink_oneshot(sl->rx_led_trig,
+ &led_delay, &led_delay, 1);
+ led_trigger_blink_oneshot(sl->rxtx_led_trig,
+ &led_delay, &led_delay, 1);
+ }
+ break;
+ }
+}
+
+static void sllin_led_release(struct device *gendev, void *res)
+{
+ struct sllin *sl = netdev_priv(to_net_dev(gendev));
+
+ led_trigger_unregister_simple(sl->tx_led_trig);
+ led_trigger_unregister_simple(sl->rx_led_trig);
+ led_trigger_unregister_simple(sl->rxtx_led_trig);
+}
+
+static void devm_sllin_led_init(struct net_device *netdev)
+{
+ struct sllin *sl = netdev_priv(netdev);
+ void *res;
+
+ res = devres_alloc(sllin_led_release, 0, GFP_KERNEL);
+ if (!res) {
+ netdev_err(netdev, "cannot register LED triggers\n");
+ return;
+ }
+
+ snprintf(sl->tx_led_trig_name, sizeof(sl->tx_led_trig_name),
+ "%s-tx", netdev->name);
+ snprintf(sl->rx_led_trig_name, sizeof(sl->rx_led_trig_name),
+ "%s-rx", netdev->name);
+ snprintf(sl->rxtx_led_trig_name, sizeof(sl->rxtx_led_trig_name),
+ "%s-rxtx", netdev->name);
+
+ led_trigger_register_simple(sl->tx_led_trig_name,
+ &sl->tx_led_trig);
+ led_trigger_register_simple(sl->rx_led_trig_name,
+ &sl->rx_led_trig);
+ led_trigger_register_simple(sl->rxtx_led_trig_name,
+ &sl->rxtx_led_trig);
+
+ devres_add(&netdev->dev, res);
+}
+
+static struct sllin *netdev_priv_safe(struct net_device *dev)
+{
+ int i;
+
+ if (sllin_devs == NULL)
+ return NULL;
+
+ for (i = 0; i < maxdev; ++i)
+ if (sllin_devs[i] == dev)
+ return netdev_priv(dev);
+
+ return NULL;
+}
+
+static int sllin_netdev_notifier_call(struct notifier_block *nb, unsigned long msg,
+ void *ptr)
+{
+ struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
+ struct sllin *sl = netdev_priv_safe(netdev);
+ char name[SLLIN_LED_NAME_SZ];
+
+ if (!sl)
+ return NOTIFY_DONE;
+
+ if (!sl->tx_led_trig || !sl->rx_led_trig || !sl->rxtx_led_trig)
+ return NOTIFY_DONE;
+
+ if (msg == NETDEV_CHANGENAME) {
+ snprintf(name, sizeof(name), "%s-tx", netdev->name);
+ led_trigger_rename_static(name, sl->tx_led_trig);
+
+ snprintf(name, sizeof(name), "%s-rx", netdev->name);
+ led_trigger_rename_static(name, sl->rx_led_trig);
+
+ snprintf(name, sizeof(name), "%s-rxtx", netdev->name);
+ led_trigger_rename_static(name, sl->rxtx_led_trig);
+ }
+
+ return NOTIFY_DONE;
+}
+
+static struct notifier_block sllin_netdev_notifier __read_mostly = {
+ .notifier_call = sllin_netdev_notifier_call,
+};
+#endif /* SLLIN_LED_TRIGGER */
+
/**
* sltty_change_speed() -- Change baudrate of Serial device belonging
* to particular @tty
struct ktermios old_termios, termios;
int cflag;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
mutex_lock(&tty->termios_mutex);
+#else
+ down_write(&tty->termios_rwsem);
+#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
old_termios = termios = *(tty->termios);
if (tty->ops->set_termios)
tty->ops->set_termios(tty, &old_termios);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
mutex_unlock(&tty->termios_mutex);
+#else
+ up_write(&tty->termios_rwsem);
+#endif
return 0;
}
sl->dev->stats.rx_packets++;
sl->dev->stats.rx_bytes += cf.can_dlc;
+
+#ifdef SLLIN_LED_TRIGGER
+ sllin_led_event(sl->dev, SLLIN_LED_EVENT_RX);
+#endif
}
/**
return; /* ongoing concurrent processing */
clear_bit(SLF_TXBUFF_RQ, &sl->flags);
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
smp_mb__after_clear_bit();
+#else
+ smp_mb__after_atomic();
+#endif
if (sl->lin_state != SLSTATE_BREAK_SENT)
remains = sl->tx_lim - sl->tx_cnt;
remains -= actual;
}
clear_bit(SLF_TXBUFF_INPR, &sl->flags);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
smp_mb__after_clear_bit();
+#else
+ smp_mb__after_atomic();
+#endif
} while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
sl->tx_lim = 0;
spin_unlock_bh(&sl->lock);
+#ifdef SLLIN_LED_TRIGGER
+ sllin_led_event(dev, SLLIN_LED_EVENT_STOP);
+#endif
return 0;
}
sl->flags &= (1 << SLF_INUSE);
netif_start_queue(dev);
+
+#ifdef SLLIN_LED_TRIGGER
+ sllin_led_event(dev, SLLIN_LED_EVENT_OPEN);
+#endif
return 0;
}
static void sll_setup(struct net_device *dev)
{
dev->netdev_ops = &sll_netdev_ops;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,12,0)
dev->destructor = sll_free_netdev;
+#else /* Linux 4.12.0+ */
+ dev->priv_destructor = sll_free_netdev;
+#endif /* Linux 4.12.0+ */
dev->hard_header_len = 0;
dev->addr_len = 0;
}
}
-#ifndef BREAK_BY_BAUD
- /* We didn't receive Break character -- fake it! */
- if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
- netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n", sl->rx_cnt);
- sl->rx_buff[sl->rx_cnt++] = 0x00;
+ if (!sl->lin_break_by_baud ) {
+ /* We didn't receive Break character -- fake it! */
+ if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
+ netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n",
+ sl->rx_cnt);
+ sl->rx_buff[sl->rx_cnt++] = 0x00;
+ }
}
-#endif /* BREAK_BY_BAUD */
if (sl->rx_cnt < SLLIN_BUFF_LEN) {
netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
*/
static void sllin_report_error(struct sllin *sl, int err)
{
+ unsigned char *lin_buff;
+ int lin_id;
+
switch (err) {
case LIN_ERR_CHECKSUM:
sl->dev->stats.rx_crc_errors++;
break;
}
- sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
+ lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
+ lin_id = lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
+ sllin_send_canfr(sl, lin_id | CAN_EFF_FLAG |
(err & ~LIN_ID_MASK), NULL, 0);
}
if (fp && *fp++) {
/*
* If we don't know the length of the current message
- * we received the break of the next message.
- * Evaluate the previous one before continuing
+ * and received at least the LIN ID, we received here
+ * the break of the next message.
+ * Evaluate the previous one before continuing.
*/
- if (sl->rx_len_unknown == true)
+ if ((sl->rx_len_unknown == true) &&
+ (sl->rx_cnt >= SLLIN_BUFF_ID))
{
hrtimer_cancel(&sl->rx_timer);
sllin_slave_finish_rx_msg(sl);
if (sce->dlc > 0) {
sl->rx_expect += sce->dlc + 1; /* + checksum */
sl->rx_len_unknown = false;
- set_bit(SLF_MSGEVENT, &sl->flags);
wake_up(&sl->kwt_wq);
} else {
sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
return 0; /* ongoing concurrent processing */
clear_bit(SLF_TXBUFF_RQ, &sl->flags);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
smp_mb__after_clear_bit();
-
-#ifdef BREAK_BY_BAUD
- if (sl->lin_state != SLSTATE_BREAK_SENT)
- remains = sl->tx_lim - sl->tx_cnt;
- else
- remains = 1;
#else
- remains = sl->tx_lim - sl->tx_cnt;
+ smp_mb__after_atomic();
#endif
+ if (sl->lin_break_by_baud) {
+ if (sl->lin_state != SLSTATE_BREAK_SENT)
+ remains = sl->tx_lim - sl->tx_cnt;
+ else
+ remains = 1;
+ } else {
+ remains = sl->tx_lim - sl->tx_cnt;
+ }
+
res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
if (res < 0)
goto error_in_write;
sl->tx_cnt, remains);
clear_bit(SLF_TXBUFF_INPR, &sl->flags);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
smp_mb__after_clear_bit();
+#else
+ smp_mb__after_atomic();
+#endif
} while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
+#ifdef SLLIN_LED_TRIGGER
+ sllin_led_event(sl->dev, SLLIN_LED_EVENT_TX);
+#endif
+
return 0;
error_in_write:
}
-#ifdef BREAK_BY_BAUD
-static int sllin_send_break(struct sllin *sl)
+static int sllin_send_break_by_baud(struct sllin *sl)
{
struct tty_struct *tty = sl->tty;
unsigned long break_baud;
break_baud = ((sl->lin_baud * 2) / 3);
sltty_change_speed(tty, break_baud);
- tty->ops->flush_buffer(tty);
+ if (tty->ops->flush_buffer != NULL) {
+ tty->ops->flush_buffer(tty);
+ } else {
+ netdev_dbg(sl->dev, "flush_buffer is not implemented.\n");
+ }
sl->rx_cnt = SLLIN_BUFF_BREAK;
sl->rx_expect = SLLIN_BUFF_BREAK + 1;
return 0;
}
-#else /* BREAK_BY_BAUD */
-static int sllin_send_break(struct sllin *sl)
+static int sllin_send_break_by_usleep(struct sllin *sl)
{
struct tty_struct *tty = sl->tty;
int retval;
usleep_range_max = usleep_range_min + 30;
usleep_range(usleep_range_min, usleep_range_max);
- tty->ops->flush_buffer(tty);
+ if (tty != NULL && tty->ops != NULL && tty->ops->flush_buffer != NULL) {
+ tty->ops->flush_buffer(tty);
+ } else {
+ netdev_dbg(sl->dev, "flush_buffer is not implemented.\n");
+ }
sl->tx_cnt = SLLIN_BUFF_SYNC;
return 0;
}
-#endif /* BREAK_BY_BAUD */
+static int sllin_send_break(struct sllin *sl)
+{
+ if (sl->lin_break_by_baud)
+ return sllin_send_break_by_baud(sl);
+ else
+ return sllin_send_break_by_usleep(sl);
+}
static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
{
struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
- if (sl->lin_master) {
+ /*
+ * Signal timeout when:
+ * master: We did not receive as much characters as expected
+ * slave: * we did not receive any data bytes at all
+ * * we know the length and didn't receive enough
+ */
+ if ((sl->lin_master) ||
+ (sl->rx_cnt <= SLLIN_BUFF_DATA) ||
+ ((!sl->rx_len_unknown) &&
+ (sl->rx_cnt < sl->rx_expect))) {
sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
set_bit(SLF_TMOUTEVENT, &sl->flags);
} else {
struct sched_param schparam = { .sched_priority = 40 };
int tx_bytes = 0; /* Used for Network statistics */
unsigned long flags;
+ int mode;
int lin_id;
struct sllin_conf_entry *sce;
test_bit(SLF_TXEVENT, &sl->flags) ||
test_bit(SLF_TMOUTEVENT, &sl->flags) ||
test_bit(SLF_ERROR, &sl->flags) ||
+ (sl->lin_state == SLSTATE_ID_RECEIVED) ||
(((sl->lin_state == SLSTATE_IDLE) ||
- (sl->lin_state == SLSTATE_RESPONSE_WAIT) ||
- (sl->lin_state == SLSTATE_ID_RECEIVED))
+ (sl->lin_state == SLSTATE_RESPONSE_WAIT))
&& test_bit(SLF_MSGEVENT, &sl->flags)));
if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
if (!test_bit(SLF_MSGEVENT, &sl->flags))
break;
+ mode = 0;
cf = (struct can_frame *)sl->tx_req_skb->data;
+ if (cf->can_id & LIN_CHECKSUM_EXTENDED)
+ mode |= SLLIN_STPMSG_CHCKSUM_ENH;
+
/* SFF RTR CAN frame -> LIN header */
if (cf->can_id & CAN_RTR_FLAG) {
- struct sllin_conf_entry *sce;
-
netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
__func__, cf->can_id & LIN_ID_MASK);
sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
spin_lock_irqsave(&sl->linfr_lock, flags);
+ if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
+ mode |= SLLIN_STPMSG_CHCKSUM_ENH;
/* Is there Slave response in linfr_cache to be sent? */
if ((sce->frame_fl & LIN_CACHE_RESPONSE)
&& (sce->dlc > 0)) {
+ if (sce->frame_fl & LIN_SINGLE_RESPONSE)
+ sce->frame_fl &= ~LIN_CACHE_RESPONSE;
+
netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
lin_data = sce->data;
netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
__func__, (int)cf->can_id & LIN_ID_MASK);
+ sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
+ if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
+ mode |= SLLIN_STPMSG_CHCKSUM_ENH;
+
lin_data = cf->data;
lin_dlc = cf->can_dlc;
if (lin_dlc > SLLIN_DATA_MAX)
tx_bytes = lin_dlc;
}
- if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
+ if (sllin_setup_msg(sl, mode, cf->can_id & LIN_ID_MASK,
lin_data, lin_dlc) != -1) {
sl->id_to_send = true;
break;
case SLSTATE_BREAK_SENT:
-#ifdef BREAK_BY_BAUD
- if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
- continue;
+ if (sl->lin_break_by_baud) {
+ if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
+ continue;
- res = sltty_change_speed(tty, sl->lin_baud);
-#endif
+ sltty_change_speed(tty, sl->lin_baud);
+ }
sl->lin_state = SLSTATE_ID_SENT;
sllin_send_tx_buff(sl);
spin_lock_irqsave(&sl->linfr_lock, flags);
if ((sce->frame_fl & LIN_CACHE_RESPONSE)
- && (sce->dlc > 0)
- && (test_bit(SLF_MSGEVENT, &sl->flags))) {
- int mode;
+ && (sce->dlc > 0)) {
+
+ if (sce->frame_fl & LIN_SINGLE_RESPONSE)
+ sce->frame_fl &= ~LIN_CACHE_RESPONSE;
netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
sllin_send_tx_buff(sl);
}
- clear_bit(SLF_MSGEVENT, &sl->flags);
- kfree_skb(sl->tx_req_skb);
- netif_wake_queue(sl->dev);
hrtimer_start(&sl->rx_timer,
ktime_add(ktime_get(), sl->rx_timer_timeout),
HRTIMER_MODE_ABS);
char name[IFNAMSIZ];
sprintf(name, "sllin%d", i);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0))
dev = alloc_netdev(sizeof(*sl), name, sll_setup);
+#else
+ dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sll_setup);
+#endif
+
if (!dev)
return NULL;
dev->base_addr = i;
* Called in process context serialized from other ldisc calls.
*/
-static int sllin_open(struct tty_struct *tty)
+static int sllin_open_common(struct tty_struct *tty, bool setup_master)
{
struct sllin *sl;
int err;
if (!test_bit(SLF_INUSE, &sl->flags)) {
/* Perform the low-level SLLIN initialization. */
- sl->lin_master = master;
- if (master)
+ sl->lin_master = setup_master;
+ if (sl->lin_master)
pr_debug("sllin: Configured as MASTER\n");
else
pr_debug("sllin: Configured as SLAVE\n");
sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
+ sl->lin_break_by_baud = break_by_baud;
+
+ if (tty->ops->break_ctl == NULL && !sl->lin_break_by_baud) {
+ sl->lin_break_by_baud = true;
+ pr_notice ("sllin: break_ctl, switching to break_by_baud\n");
+ }
+
sl->lin_state = SLSTATE_IDLE;
hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
err = register_netdevice(sl->dev);
if (err)
goto err_free_chan_and_thread;
+
+#ifdef SLLIN_LED_TRIGGER
+ devm_sllin_led_init(sl->dev);
+#endif
}
/* Done. We have linked the TTY line to a channel. */
return err;
}
+/*
+ * Open the high-level part of the SLLIN channel.
+ * This function is called by the TTY module when the
+ * SLLIN line discipline is called for. Because we are
+ * sure the tty line exists, we only have to link it to
+ * a free SLLIN channel...
+ *
+ * Called in process context serialized from other ldisc calls.
+ *
+ * This call variant preserves original functionality where
+ * slave/master can be selected by module parameter.
+ * Default is the master.
+ */
+
+static int sllin_open(struct tty_struct *tty)
+{
+ return sllin_open_common(tty, master);
+}
+
+/*
+ * Open the high-level part of the SLLIN channel.
+ * This function is called by the TTY module when the
+ * SLLIN line discipline is called for. Because we are
+ * sure the tty line exists, we only have to link it to
+ * a free SLLIN channel...
+ *
+ * Called in process context serialized from other ldisc calls.
+ *
+ * This call variant enforces slave/LIN device functionality.
+ */
+
+static int sllin_open_slave(struct tty_struct *tty)
+{
+ return sllin_open_common(tty, false);
+}
+
+
/*
* Close down a SLLIN channel.
* This means flushing out any pending queues, and then returning. This
.write_wakeup = sllin_write_wakeup,
};
+static struct tty_ldisc_ops sll_slave_ldisc = {
+ .owner = THIS_MODULE,
+ .magic = TTY_LDISC_MAGIC,
+ .name = "sllin-slave",
+ .open = sllin_open_slave,
+ .close = sllin_close,
+ .hangup = sllin_hangup,
+ .ioctl = sllin_ioctl,
+ .receive_buf = sllin_receive_buf,
+ .write_wakeup = sllin_write_wakeup,
+};
+
static int __init sllin_init(void)
{
int status;
+#ifdef SLLIN_LED_TRIGGER
+ status = register_netdevice_notifier(&sllin_netdev_notifier);
+ if (status)
+ pr_err("sllin: can't register netdevice notifier\n");
+#endif
+
if (maxdev < 4)
maxdev = 4; /* Sanity */
if (status) {
pr_err("sllin: can't register line discipline\n");
kfree(sllin_devs);
+ } else {
+ status = tty_register_ldisc(N_SLLIN_SLAVE, &sll_slave_ldisc);
+ if (status) {
+ tty_unregister_ldisc(N_SLLIN);
+ pr_err("sllin: can't register slave line discipline\n");
+ kfree(sllin_devs);
+ }
}
-#ifdef BREAK_BY_BAUD
- pr_debug("sllin: Break is generated by baud-rate change.");
-#else
- pr_debug("sllin: Break is generated manually with tiny sleep.");
-#endif
+
+ if (break_by_baud)
+ pr_debug("sllin: Break is generated by baud-rate change.");
+ else
+ pr_debug("sllin: Break is generated manually with tiny sleep.");
return status;
}
if (sl->tty) {
netdev_dbg(sl->dev, "tty discipline still running\n");
/* Intentionally leak the control block. */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,12,0)
dev->destructor = NULL;
+#else /* Linux 4.12.0+ */
+ dev->priv_destructor = NULL;
+#endif /* Linux 4.12.0+ */
}
unregister_netdev(dev);
i = tty_unregister_ldisc(N_SLLIN);
if (i)
pr_err("sllin: can't unregister ldisc (err %d)\n", i);
+
+ i = tty_unregister_ldisc(N_SLLIN_SLAVE);
+ if (i)
+ pr_err("sllin: can't unregister slave ldisc (err %d)\n", i);
+
+
+#ifdef SLLIN_LED_TRIGGER
+ unregister_netdevice_notifier(&sllin_netdev_notifier);
+#endif
+
}
module_init(sllin_init);