X-Git-Url: https://rtime.felk.cvut.cz/gitweb/linux-lin.git/blobdiff_plain/258d510bf0d298d32de4565e223c58bdc3b1a5f5..b56f1ea7a09bf50fc5f115a0c2e148e17d9e4799:/sllin/sllin.c diff --git a/sllin/sllin.c b/sllin/sllin.c index 61c8134..cdc4327 100644 --- a/sllin/sllin.c +++ b/sllin/sllin.c @@ -41,7 +41,8 @@ * 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 #include @@ -65,10 +66,32 @@ #include #include "linux/lin_bus.h" +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0) +#include +#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 + +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"; @@ -82,16 +105,23 @@ MODULE_AUTHOR("Pavel Pisa "); 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*/ @@ -142,6 +172,7 @@ struct sllin { 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 */ @@ -173,6 +204,15 @@ struct sllin { /* 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; @@ -196,6 +236,124 @@ const unsigned char sllin_id_parity_table[] = { 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 @@ -210,7 +368,11 @@ static int sltty_change_speed(struct tty_struct *tty, unsigned speed) 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); @@ -238,7 +400,11 @@ static int sltty_change_speed(struct tty_struct *tty, unsigned speed) 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; } @@ -268,6 +434,10 @@ static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len) 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 } /** @@ -311,7 +481,12 @@ static void sllin_write_wakeup(struct tty_struct *tty) 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; @@ -325,7 +500,11 @@ static void sllin_write_wakeup(struct tty_struct *tty) 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))); @@ -408,6 +587,9 @@ static int sll_close(struct net_device *dev) sl->tx_lim = 0; spin_unlock_bh(&sl->lock); +#ifdef SLLIN_LED_TRIGGER + sllin_led_event(dev, SLLIN_LED_EVENT_STOP); +#endif return 0; } @@ -423,6 +605,10 @@ static int sll_open(struct net_device *dev) sl->flags &= (1 << SLF_INUSE); netif_start_queue(dev); + +#ifdef SLLIN_LED_TRIGGER + sllin_led_event(dev, SLLIN_LED_EVENT_OPEN); +#endif return 0; } @@ -443,7 +629,11 @@ static const struct net_device_ops sll_netdev_ops = { 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; @@ -480,13 +670,14 @@ static void sllin_master_receive_buf(struct tty_struct *tty, } } -#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); @@ -716,10 +907,12 @@ static void sllin_slave_receive_buf(struct tty_struct *tty, 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); @@ -836,17 +1029,21 @@ static int sllin_send_tx_buff(struct sllin *sl) 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; @@ -870,10 +1067,18 @@ static int sllin_send_tx_buff(struct sllin *sl) 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: @@ -882,8 +1087,7 @@ 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; @@ -892,7 +1096,11 @@ static int sllin_send_break(struct sllin *sl) 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; @@ -906,9 +1114,8 @@ static int sllin_send_break(struct sllin *sl) 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; @@ -937,7 +1144,11 @@ static int sllin_send_break(struct sllin *sl) 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; @@ -947,8 +1158,14 @@ static int sllin_send_break(struct sllin *sl) 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) { @@ -986,6 +1203,7 @@ static int sllin_kwthread(void *ptr) 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; @@ -1056,22 +1274,29 @@ static int sllin_kwthread(void *ptr) 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; @@ -1090,6 +1315,10 @@ static int sllin_kwthread(void *ptr) 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) @@ -1097,7 +1326,7 @@ static int sllin_kwthread(void *ptr) 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; @@ -1116,12 +1345,12 @@ static int sllin_kwthread(void *ptr) 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); @@ -1215,7 +1444,9 @@ slstate_response_wait: if ((sce->frame_fl & LIN_CACHE_RESPONSE) && (sce->dlc > 0)) { - int mode; + + if (sce->frame_fl & LIN_SINGLE_RESPONSE) + sce->frame_fl &= ~LIN_CACHE_RESPONSE; netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n"); @@ -1335,7 +1566,12 @@ static struct sllin *sll_alloc(dev_t line) 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; @@ -1362,7 +1598,7 @@ static struct sllin *sll_alloc(dev_t line) * 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; @@ -1403,8 +1639,8 @@ static int sllin_open(struct tty_struct *tty) 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"); @@ -1414,6 +1650,13 @@ static int sllin_open(struct tty_struct *tty) 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); @@ -1433,6 +1676,10 @@ static int sllin_open(struct tty_struct *tty) 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. */ @@ -1458,6 +1705,43 @@ err_exit: 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 @@ -1529,10 +1813,28 @@ static struct tty_ldisc_ops sll_ldisc = { .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 */ @@ -1550,13 +1852,20 @@ static int __init sllin_init(void) 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; } @@ -1606,7 +1915,11 @@ static void __exit sllin_exit(void) 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); @@ -1618,6 +1931,16 @@ static void __exit sllin_exit(void) 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);