2 * sllin.c - serial line LIN interface driver (using tty line discipline)
4 * This file is derived from drivers/net/can/slcan.c
5 * slcan.c Author: Oliver Hartkopp <socketcan@hartkopp.net>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 59 Temple Place, Suite 330, Boston, MA 02111-1307. You can also get it
20 * at http://www.gnu.org/licenses/gpl.html
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
35 * Idea: Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
36 * Copyright: (c) 2011 Czech Technical University in Prague
37 * (c) 2011 Volkswagen Group Research
38 * Authors: Pavel Pisa <pisa@cmp.felk.cvut.cz>
39 * Rostislav Lisovy <lisovy@kormus.cz>
40 * Michal Sojka <sojkam1@fel.cvut.cz>
41 * Funded by: Volkswagen Group Research
44 //#define DEBUG 1 /* Enables pr_debug() printouts */
46 #include <linux/module.h>
47 #include <linux/moduleparam.h>
49 #include <linux/uaccess.h>
50 #include <linux/bitops.h>
51 #include <linux/string.h>
52 #include <linux/tty.h>
53 #include <linux/errno.h>
54 #include <linux/netdevice.h>
55 #include <linux/skbuff.h>
56 #include <linux/rtnetlink.h>
57 #include <linux/if_arp.h>
58 #include <linux/if_ether.h>
59 #include <linux/sched.h>
60 #include <linux/delay.h>
61 #include <linux/init.h>
62 #include <linux/can.h>
63 #include <linux/kthread.h>
64 #include <linux/hrtimer.h>
65 #include <linux/version.h>
66 #include "linux/lin_bus.h"
68 /* Should be in include/linux/tty.h */
70 /* -------------------------------- */
72 static __initdata const char banner[] =
73 KERN_INFO "sllin: serial line LIN interface driver\n";
75 MODULE_ALIAS_LDISC(N_SLLIN);
76 MODULE_DESCRIPTION("serial line LIN interface");
77 MODULE_LICENSE("GPL");
78 MODULE_AUTHOR("Pavel Pisa <pisa@cmp.felk.cvut.cz>");
80 #define SLLIN_MAGIC 0x53CA
81 /* #define BREAK_BY_BAUD */
83 static bool master = true;
84 static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
86 module_param(master, bool, 0);
87 MODULE_PARM_DESC(master, "LIN interface is Master device");
88 module_param(baudrate, int, 0);
89 MODULE_PARM_DESC(baudrate, "Baudrate of LIN interface");
91 static int maxdev = 10; /* MAX number of SLLIN channels;
92 This can be overridden with
93 insmod sllin.ko maxdev=nnn */
94 module_param(maxdev, int, 0);
95 MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
97 /* maximum buffer len to store whole LIN message*/
98 #define SLLIN_DATA_MAX 8
99 #define SLLIN_BUFF_LEN (1 /*break*/ + 1 /*sync*/ + 1 /*ID*/ + \
100 SLLIN_DATA_MAX + 1 /*checksum*/)
101 #define SLLIN_BUFF_BREAK 0
102 #define SLLIN_BUFF_SYNC 1
103 #define SLLIN_BUFF_ID 2
104 #define SLLIN_BUFF_DATA 3
106 #define SLLIN_SAMPLES_PER_CHAR 10
107 #define SLLIN_CHARS_TO_TIMEOUT 24
113 SLSTATE_RESPONSE_WAIT, /* Wait for response */
114 SLSTATE_RESPONSE_WAIT_BUS, /* Wait for response from LIN bus
115 only (CAN frames from network stack
116 are not processed in this moment) */
118 SLSTATE_RESPONSE_SENT,
121 struct sllin_conf_entry {
122 int dlc; /* Length of data in LIN frame */
123 canid_t frame_fl; /* LIN frame flags. Passed from userspace as
125 u8 data[8]; /* LIN frame data payload */
131 /* Various fields. */
132 struct tty_struct *tty; /* ptr to TTY structure */
133 struct net_device *dev; /* easy for intr handling */
136 /* LIN message buffer and actual processed data counts */
137 unsigned char rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
138 unsigned char tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
139 int rx_expect; /* expected number of Rx chars */
140 int rx_lim; /* maximum Rx chars for current frame */
141 int rx_cnt; /* message buffer Rx fill level */
142 int tx_lim; /* actual limit of bytes to Tx */
143 int tx_cnt; /* number of already Tx bytes */
144 char lin_master; /* node is a master node */
145 int lin_baud; /* LIN baudrate */
146 int lin_state; /* state */
147 char id_to_send; /* there is ID to be sent */
148 char data_to_send; /* there are data to be sent */
149 char resp_len_known; /* Length of the response is known */
150 char header_received;/* In Slave mode, set when header was already
152 char rx_len_unknown; /* We are not sure how much data will be sent to us --
153 we just guess the length */
155 unsigned long flags; /* Flag values/ mode etc */
156 #define SLF_INUSE 0 /* Channel in use */
157 #define SLF_ERROR 1 /* Parity, etc. error */
158 #define SLF_RXEVENT 2 /* Rx wake event */
159 #define SLF_TXEVENT 3 /* Tx wake event */
160 #define SLF_MSGEVENT 4 /* CAN message to sent */
161 #define SLF_TMOUTEVENT 5 /* Timeout on received data */
162 #define SLF_TXBUFF_RQ 6 /* Req. to send buffer to UART*/
163 #define SLF_TXBUFF_INPR 7 /* Above request in progress */
166 struct task_struct *kwthread;
167 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
168 struct hrtimer rx_timer; /* RX timeout timer */
169 ktime_t rx_timer_timeout; /* RX timeout timer value */
170 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame
171 received from network stack*/
173 /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
174 struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
175 spinlock_t linfr_lock; /* frame cache and buffers lock */
178 static struct net_device **sllin_devs;
179 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
180 static void sllin_slave_receive_buf(struct tty_struct *tty,
181 const unsigned char *cp, char *fp, int count);
182 static void sllin_master_receive_buf(struct tty_struct *tty,
183 const unsigned char *cp, char *fp, int count);
186 /* Values of two parity bits in LIN Protected
187 Identifier for each particular LIN ID */
188 const unsigned char sllin_id_parity_table[] = {
189 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
190 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
191 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
192 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
193 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
194 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
195 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
196 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
200 * sltty_change_speed() -- Change baudrate of Serial device belonging
203 * @tty: Pointer to TTY to change speed for.
204 * @speed: Integer value of new speed. It is possible to
205 * assign non-standard values, i.e. those which
206 * are not defined in termbits.h.
208 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
210 struct ktermios old_termios, termios;
213 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
214 mutex_lock(&tty->termios_mutex);
216 down_write(&tty->termios_rwsem);
219 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
220 old_termios = termios = *(tty->termios);
222 old_termios = termios = tty->termios;
225 cflag = CS8 | CREAD | CLOCAL | HUPCL;
226 cflag &= ~(CBAUD | CIBAUD);
228 termios.c_cflag = cflag;
232 /* Enable interrupt when UART-Break or Framing error received */
233 termios.c_iflag = BRKINT | INPCK;
234 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
235 *(tty->termios) = termios;
237 tty->termios = termios;
240 tty_encode_baud_rate(tty, speed, speed);
242 if (tty->ops->set_termios)
243 tty->ops->set_termios(tty, &old_termios);
245 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
246 mutex_unlock(&tty->termios_mutex);
248 up_write(&tty->termios_rwsem);
254 /* Send one can_frame to the network layer */
255 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
263 memcpy(&cf.data, data, cf.can_dlc);
265 skb = dev_alloc_skb(sizeof(struct can_frame));
270 skb->protocol = htons(ETH_P_CAN);
271 skb->pkt_type = PACKET_BROADCAST;
272 skb->ip_summed = CHECKSUM_UNNECESSARY;
273 memcpy(skb_put(skb, sizeof(struct can_frame)),
274 &cf, sizeof(struct can_frame));
277 sl->dev->stats.rx_packets++;
278 sl->dev->stats.rx_bytes += cf.can_dlc;
282 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
287 static void sll_bump(struct sllin *sl)
289 int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
290 len = (len < 0) ? 0 : len;
292 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
293 sl->rx_buff + SLLIN_BUFF_DATA, len);
296 static void sll_send_rtr(struct sllin *sl)
298 sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
299 CAN_RTR_FLAG, NULL, 0);
303 * Called by the driver when there's room for more data. If we have
304 * more packets to send, we send them here.
306 static void sllin_write_wakeup(struct tty_struct *tty)
310 struct sllin *sl = (struct sllin *) tty->disc_data;
312 /* First make sure we're connected. */
313 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
316 set_bit(SLF_TXBUFF_RQ, &sl->flags);
318 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
319 return; /* ongoing concurrent processing */
321 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
323 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
324 smp_mb__after_clear_bit();
326 smp_mb__after_atomic();
329 if (sl->lin_state != SLSTATE_BREAK_SENT)
330 remains = sl->tx_lim - sl->tx_cnt;
332 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
335 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
336 sl->tx_cnt - sl->tx_lim);
337 sl->tx_cnt += actual;
340 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
341 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
342 smp_mb__after_clear_bit();
344 smp_mb__after_atomic();
347 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
349 if ((remains > 0) && (actual >= 0)) {
350 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, remains %d, waiting\n",
351 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
355 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
356 set_bit(SLF_TXEVENT, &sl->flags);
357 wake_up(&sl->kwt_wq);
359 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
363 * sll_xmit() -- Send a can_frame to a TTY queue.
365 * @skb: Pointer to Socket buffer to be sent.
366 * @dev: Network device where @skb will be sent.
368 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
370 struct sllin *sl = netdev_priv(dev);
371 struct can_frame *cf;
373 if (skb->len != sizeof(struct can_frame))
376 spin_lock(&sl->lock);
377 if (!netif_running(dev)) {
378 netdev_warn(sl->dev, "xmit: iface is down\n");
381 if (sl->tty == NULL) {
382 netdev_warn(sl->dev, "xmit: no tty device connected\n");
386 cf = (struct can_frame *) skb->data;
387 if (cf->can_id & LIN_CTRL_FRAME) {
388 sllin_configure_frame_cache(sl, cf);
389 goto free_out_unlock;
392 netif_stop_queue(sl->dev);
394 sl->tx_req_skb = skb;
395 set_bit(SLF_MSGEVENT, &sl->flags);
396 wake_up(&sl->kwt_wq);
397 spin_unlock(&sl->lock);
402 spin_unlock(&sl->lock);
409 /******************************************
410 * Routines looking at netdevice side.
411 ******************************************/
413 /* Netdevice UP -> DOWN routine */
414 static int sll_close(struct net_device *dev)
416 struct sllin *sl = netdev_priv(dev);
418 spin_lock_bh(&sl->lock);
420 /* TTY discipline is running. */
421 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
423 netif_stop_queue(dev);
426 spin_unlock_bh(&sl->lock);
431 /* Netdevice DOWN -> UP routine */
432 static int sll_open(struct net_device *dev)
434 struct sllin *sl = netdev_priv(dev);
436 netdev_dbg(sl->dev, "%s() invoked\n", __func__);
441 sl->flags &= (1 << SLF_INUSE);
442 netif_start_queue(dev);
446 /* Hook the destructor so we can free sllin devs at the right point in time */
447 static void sll_free_netdev(struct net_device *dev)
449 int i = dev->base_addr;
451 sllin_devs[i] = NULL;
454 static const struct net_device_ops sll_netdev_ops = {
455 .ndo_open = sll_open,
456 .ndo_stop = sll_close,
457 .ndo_start_xmit = sll_xmit,
460 static void sll_setup(struct net_device *dev)
462 dev->netdev_ops = &sll_netdev_ops;
463 dev->destructor = sll_free_netdev;
465 dev->hard_header_len = 0;
467 dev->tx_queue_len = 10;
469 dev->mtu = sizeof(struct can_frame);
470 dev->type = ARPHRD_CAN;
472 /* New-style flags. */
473 dev->flags = IFF_NOARP;
474 dev->features = NETIF_F_HW_CSUM; /* NETIF_F_NO_CSUM;*/
477 /******************************************
478 Routines looking at TTY side.
479 ******************************************/
480 static void sllin_master_receive_buf(struct tty_struct *tty,
481 const unsigned char *cp, char *fp, int count)
483 struct sllin *sl = (struct sllin *) tty->disc_data;
485 /* Read the characters out of the buffer */
488 netdev_dbg(sl->dev, "sllin_master_receive_buf char 0x%02x ignored "
489 "due marker 0x%02x, flags 0x%lx\n",
490 *cp, *(fp-1), sl->flags);
492 /* i.e. Real error -- not Break */
493 if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
494 set_bit(SLF_ERROR, &sl->flags);
495 wake_up(&sl->kwt_wq);
500 #ifndef BREAK_BY_BAUD
501 /* We didn't receive Break character -- fake it! */
502 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
503 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n", sl->rx_cnt);
504 sl->rx_buff[sl->rx_cnt++] = 0x00;
506 #endif /* BREAK_BY_BAUD */
508 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
509 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
510 sl->rx_buff[sl->rx_cnt++] = *cp++;
515 if (sl->rx_cnt >= sl->rx_expect) {
516 set_bit(SLF_RXEVENT, &sl->flags);
517 wake_up(&sl->kwt_wq);
518 netdev_dbg(sl->dev, "sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
520 netdev_dbg(sl->dev, "sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
525 /*****************************************
526 * sllin message helper routines
527 *****************************************/
529 * sllin_report_error() -- Report an error by sending CAN frame
530 * with particular error flag set in can_id
533 * @err: Error flag to be sent.
535 static void sllin_report_error(struct sllin *sl, int err)
537 unsigned char *lin_buff;
541 case LIN_ERR_CHECKSUM:
542 sl->dev->stats.rx_crc_errors++;
545 case LIN_ERR_RX_TIMEOUT:
546 sl->dev->stats.rx_errors++;
549 case LIN_ERR_FRAMING:
550 sl->dev->stats.rx_frame_errors++;
554 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
555 lin_id = lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
556 sllin_send_canfr(sl, lin_id | CAN_EFF_FLAG |
557 (err & ~LIN_ID_MASK), NULL, 0);
561 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
564 * @cf: Pointer to CAN frame sent to this driver
565 * holding configuration information
567 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
570 struct sllin_conf_entry *sce;
572 if (!(cf->can_id & LIN_CTRL_FRAME))
575 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
576 netdev_dbg(sl->dev, "Setting frame cache with EFF CAN frame. LIN ID = %d\n",
577 cf->can_id & LIN_ID_MASK);
579 spin_lock_irqsave(&sl->linfr_lock, flags);
581 sce->dlc = cf->can_dlc;
582 if (sce->dlc > SLLIN_DATA_MAX)
583 sce->dlc = SLLIN_DATA_MAX;
585 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
586 memcpy(sce->data, cf->data, cf->can_dlc);
588 spin_unlock_irqrestore(&sl->linfr_lock, flags);
594 * sllin_checksum() -- Count checksum for particular data
596 * @data: Pointer to the buffer containing whole LIN
597 * frame (i.e. including break and sync bytes).
598 * @length: Length of the buffer.
599 * @enhanced_fl: Flag determining whether Enhanced or Classic
600 * checksum should be counted.
602 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
612 for (; i < length; i++) {
621 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
622 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
623 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
625 static int sllin_setup_msg(struct sllin *sl, int mode, int id,
626 unsigned char *data, int len)
628 if (id > LIN_ID_MASK)
631 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
635 sl->rx_lim = SLLIN_BUFF_LEN;
638 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
639 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
640 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
641 sl->tx_lim = SLLIN_BUFF_DATA;
643 if ((data != NULL) && len) {
645 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
646 sl->tx_buff[sl->tx_lim] = sllin_checksum(sl->tx_buff,
647 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
651 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
656 static void sllin_reset_buffs(struct sllin *sl)
660 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
663 sl->id_to_send = false;
664 sl->data_to_send = false;
668 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
672 static int sllin_rx_validate(struct sllin *sl)
678 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
679 struct sllin_conf_entry *sce;
681 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
682 sce = &sl->linfr_cache[actual_id];
684 spin_lock_irqsave(&sl->linfr_lock, flags);
686 ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
687 spin_unlock_irqrestore(&sl->linfr_lock, flags);
689 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
692 /* Type of checksum is configured for particular frame */
696 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
697 !ext_chcks_fl) != rec_chcksm) {
706 static void sllin_slave_finish_rx_msg(struct sllin *sl)
708 if (sllin_rx_validate(sl) == -1) {
709 netdev_dbg(sl->dev, "sllin: RX validation failed.\n");
710 sllin_report_error(sl, LIN_ERR_CHECKSUM);
712 /* Send CAN non-RTR frame with data */
713 netdev_dbg(sl->dev, "sllin: sending NON-RTR CAN frame with LIN payload.");
714 sll_bump(sl); /* send packet to the network layer */
716 /* Prepare for reception of new header */
718 sl->rx_expect = SLLIN_BUFF_ID + 1;
719 sl->rx_len_unknown = false; /* We do know exact length of the header */
720 sl->header_received = false;
723 static void sllin_slave_receive_buf(struct tty_struct *tty,
724 const unsigned char *cp, char *fp, int count)
726 struct sllin *sl = (struct sllin *) tty->disc_data;
728 struct sllin_conf_entry *sce;
731 /* Read the characters out of the buffer */
735 * If we don't know the length of the current message
736 * and received at least the LIN ID, we received here
737 * the break of the next message.
738 * Evaluate the previous one before continuing.
740 if ((sl->rx_len_unknown == true) &&
741 (sl->rx_cnt >= SLLIN_BUFF_ID))
743 hrtimer_cancel(&sl->rx_timer);
744 sllin_slave_finish_rx_msg(sl);
746 set_bit(SLF_RXEVENT, &sl->flags);
747 wake_up(&sl->kwt_wq);
750 netdev_dbg(sl->dev, "sllin_slave_receive_buf char 0x%02x ignored "
751 "due marker 0x%02x, flags 0x%lx\n",
752 *cp, *(fp-1), sl->flags);
756 sl->rx_expect = SLLIN_BUFF_ID + 1;
757 sl->rx_len_unknown = false; /* We do know exact length of the header */
758 sl->header_received = false;
761 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
762 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
764 /* We did not receive break (0x00) character */
765 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
766 sl->rx_buff[sl->rx_cnt++] = 0x00;
769 if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
770 /* 'Duplicated' break character -- ignore */
776 /* Wrong sync character */
781 sl->rx_buff[sl->rx_cnt++] = *cp++;
784 /* Header received */
785 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
788 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
789 sce = &sl->linfr_cache[lin_id];
791 spin_lock_irqsave(&sl->linfr_lock, flags);
793 sl->lin_state = SLSTATE_ID_RECEIVED;
794 /* Is the length of data set in frame cache? */
796 sl->rx_expect += sce->dlc + 1; /* + checksum */
797 sl->rx_len_unknown = false;
798 wake_up(&sl->kwt_wq);
800 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
801 sl->rx_len_unknown = true;
803 spin_unlock_irqrestore(&sl->linfr_lock, flags);
805 sl->header_received = true;
807 hrtimer_start(&sl->rx_timer,
808 ktime_add(ktime_get(), sl->rx_timer_timeout),
814 /* Response received */
815 if ((sl->header_received == true) &&
816 ((sl->rx_cnt >= sl->rx_expect))) {
818 hrtimer_cancel(&sl->rx_timer);
819 netdev_dbg(sl->dev, "Received LIN header & LIN response. "
820 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
822 sllin_slave_finish_rx_msg(sl);
824 set_bit(SLF_RXEVENT, &sl->flags);
825 wake_up(&sl->kwt_wq);
830 static void sllin_receive_buf(struct tty_struct *tty,
831 const unsigned char *cp, char *fp, int count)
833 struct sllin *sl = (struct sllin *) tty->disc_data;
834 netdev_dbg(sl->dev, "sllin_receive_buf invoked, count = %u\n", count);
836 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
840 sllin_master_receive_buf(tty, cp, fp, count);
842 sllin_slave_receive_buf(tty, cp, fp, count);
846 static int sllin_send_tx_buff(struct sllin *sl)
848 struct tty_struct *tty = sl->tty;
852 set_bit(SLF_TXBUFF_RQ, &sl->flags);
854 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
855 return 0; /* ongoing concurrent processing */
857 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
858 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
859 smp_mb__after_clear_bit();
861 smp_mb__after_atomic();
865 if (sl->lin_state != SLSTATE_BREAK_SENT)
866 remains = sl->tx_lim - sl->tx_cnt;
870 remains = sl->tx_lim - sl->tx_cnt;
873 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
881 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
882 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
884 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
892 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
893 sl->tx_cnt, remains);
895 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
896 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
897 smp_mb__after_clear_bit();
899 smp_mb__after_atomic();
902 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
907 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
913 static int sllin_send_break(struct sllin *sl)
915 struct tty_struct *tty = sl->tty;
916 unsigned long break_baud;
919 break_baud = ((sl->lin_baud * 2) / 3);
920 sltty_change_speed(tty, break_baud);
922 tty->ops->flush_buffer(tty);
923 sl->rx_cnt = SLLIN_BUFF_BREAK;
925 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
926 sl->lin_state = SLSTATE_BREAK_SENT;
928 res = sllin_send_tx_buff(sl);
930 sl->lin_state = SLSTATE_IDLE;
936 #else /* BREAK_BY_BAUD */
938 static int sllin_send_break(struct sllin *sl)
940 struct tty_struct *tty = sl->tty;
942 unsigned long break_baud;
943 unsigned long usleep_range_min;
944 unsigned long usleep_range_max;
946 break_baud = ((sl->lin_baud * 2) / 3);
947 sl->rx_cnt = SLLIN_BUFF_BREAK;
948 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
949 sl->lin_state = SLSTATE_BREAK_SENT;
951 /* Do the break ourselves; Inspired by
952 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
953 retval = tty->ops->break_ctl(tty, -1);
958 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
959 usleep_range_max = usleep_range_min + 50;
960 usleep_range(usleep_range_min, usleep_range_max);
962 retval = tty->ops->break_ctl(tty, 0);
963 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
964 usleep_range_max = usleep_range_min + 30;
965 usleep_range(usleep_range_min, usleep_range_max);
967 tty->ops->flush_buffer(tty);
969 sl->tx_cnt = SLLIN_BUFF_SYNC;
971 netdev_dbg(sl->dev, "Break sent.\n");
972 set_bit(SLF_RXEVENT, &sl->flags);
973 wake_up(&sl->kwt_wq);
977 #endif /* BREAK_BY_BAUD */
980 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
982 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
985 * Signal timeout when:
986 * master: We did not receive as much characters as expected
987 * slave: * we did not receive any data bytes at all
988 * * we know the length and didn't receive enough
990 if ((sl->lin_master) ||
991 (sl->rx_cnt <= SLLIN_BUFF_DATA) ||
992 ((!sl->rx_len_unknown) &&
993 (sl->rx_cnt < sl->rx_expect))) {
994 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
995 set_bit(SLF_TMOUTEVENT, &sl->flags);
997 sllin_slave_finish_rx_msg(sl);
998 set_bit(SLF_RXEVENT, &sl->flags);
1000 wake_up(&sl->kwt_wq);
1002 return HRTIMER_NORESTART;
1005 /*****************************************
1006 * sllin_kwthread - kernel worker thread
1007 *****************************************/
1009 static int sllin_kwthread(void *ptr)
1011 struct sllin *sl = (struct sllin *)ptr;
1012 struct tty_struct *tty = sl->tty;
1013 struct sched_param schparam = { .sched_priority = 40 };
1014 int tx_bytes = 0; /* Used for Network statistics */
1015 unsigned long flags;
1018 struct sllin_conf_entry *sce;
1020 netdev_dbg(sl->dev, "sllin_kwthread started.\n");
1021 sched_setscheduler(current, SCHED_FIFO, &schparam);
1023 clear_bit(SLF_ERROR, &sl->flags);
1024 sltty_change_speed(tty, sl->lin_baud);
1026 while (!kthread_should_stop()) {
1027 struct can_frame *cf;
1030 u8 lin_data_buff[SLLIN_DATA_MAX];
1033 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
1035 if (sllin_send_break(sl) < 0) {
1036 /* error processing */
1040 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
1041 test_bit(SLF_RXEVENT, &sl->flags) ||
1042 test_bit(SLF_TXEVENT, &sl->flags) ||
1043 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
1044 test_bit(SLF_ERROR, &sl->flags) ||
1045 (sl->lin_state == SLSTATE_ID_RECEIVED) ||
1046 (((sl->lin_state == SLSTATE_IDLE) ||
1047 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
1048 && test_bit(SLF_MSGEVENT, &sl->flags)));
1050 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1051 netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1054 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1055 unsigned long usleep_range_min;
1056 unsigned long usleep_range_max;
1057 hrtimer_cancel(&sl->rx_timer);
1058 netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1060 if (sl->lin_state != SLSTATE_IDLE)
1061 sllin_report_error(sl, LIN_ERR_FRAMING);
1063 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1065 usleep_range_max = usleep_range_min + 50;
1066 usleep_range(usleep_range_min, usleep_range_max);
1067 sllin_reset_buffs(sl);
1068 sl->lin_state = SLSTATE_IDLE;
1071 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1072 netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1075 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1076 netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1077 sllin_reset_buffs(sl);
1079 sl->lin_state = SLSTATE_IDLE;
1082 switch (sl->lin_state) {
1084 if (!test_bit(SLF_MSGEVENT, &sl->flags))
1088 cf = (struct can_frame *)sl->tx_req_skb->data;
1090 if (cf->can_id & LIN_CHECKSUM_EXTENDED)
1091 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1093 /* SFF RTR CAN frame -> LIN header */
1094 if (cf->can_id & CAN_RTR_FLAG) {
1095 struct sllin_conf_entry *sce;
1097 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1098 __func__, cf->can_id & LIN_ID_MASK);
1100 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1101 spin_lock_irqsave(&sl->linfr_lock, flags);
1102 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1103 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1105 /* Is there Slave response in linfr_cache to be sent? */
1106 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1107 && (sce->dlc > 0)) {
1109 if (sce->frame_fl & LIN_SINGLE_RESPONSE)
1110 sce->frame_fl &= ~LIN_CACHE_RESPONSE;
1112 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1114 lin_data = sce->data;
1116 if (lin_dlc > SLLIN_DATA_MAX)
1117 lin_dlc = SLLIN_DATA_MAX;
1118 memcpy(lin_data_buff, lin_data, lin_dlc);
1119 lin_data = lin_data_buff;
1124 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1126 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1127 struct sllin_conf_entry *sce;
1129 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1130 __func__, (int)cf->can_id & LIN_ID_MASK);
1132 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1133 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1134 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1136 lin_data = cf->data;
1137 lin_dlc = cf->can_dlc;
1138 if (lin_dlc > SLLIN_DATA_MAX)
1139 lin_dlc = SLLIN_DATA_MAX;
1143 if (sllin_setup_msg(sl, mode, cf->can_id & LIN_ID_MASK,
1144 lin_data, lin_dlc) != -1) {
1146 sl->id_to_send = true;
1147 sl->data_to_send = (lin_data != NULL) ? true : false;
1148 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1149 sl->dev->stats.tx_packets++;
1150 sl->dev->stats.tx_bytes += tx_bytes;
1153 clear_bit(SLF_MSGEVENT, &sl->flags);
1154 kfree_skb(sl->tx_req_skb);
1155 netif_wake_queue(sl->dev);
1156 hrtimer_start(&sl->rx_timer,
1157 ktime_add(ktime_get(), sl->rx_timer_timeout),
1161 case SLSTATE_BREAK_SENT:
1162 #ifdef BREAK_BY_BAUD
1163 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1166 res = sltty_change_speed(tty, sl->lin_baud);
1169 sl->lin_state = SLSTATE_ID_SENT;
1170 sllin_send_tx_buff(sl);
1173 case SLSTATE_ID_SENT:
1174 hrtimer_cancel(&sl->rx_timer);
1175 sl->id_to_send = false;
1176 if (sl->data_to_send) {
1177 sllin_send_tx_buff(sl);
1178 sl->lin_state = SLSTATE_RESPONSE_SENT;
1179 sl->rx_expect = sl->tx_lim;
1180 goto slstate_response_sent;
1182 if (sl->resp_len_known) {
1183 sl->rx_expect = sl->rx_lim;
1185 sl->rx_expect = SLLIN_BUFF_DATA + 2;
1187 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1188 /* If we don't receive anything, timer will "unblock" us */
1189 hrtimer_start(&sl->rx_timer,
1190 ktime_add(ktime_get(), sl->rx_timer_timeout),
1192 goto slstate_response_wait;
1196 case SLSTATE_RESPONSE_WAIT:
1197 slstate_response_wait:
1198 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1199 unsigned char *lin_buff;
1200 cf = (struct can_frame *)sl->tx_req_skb->data;
1202 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1203 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1204 hrtimer_cancel(&sl->rx_timer);
1205 netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1206 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1207 cf->can_id & LIN_ID_MASK,
1208 cf->data, cf->can_dlc) != -1) {
1210 sl->rx_expect = sl->tx_lim;
1211 sl->data_to_send = true;
1212 sl->dev->stats.tx_packets++;
1213 sl->dev->stats.tx_bytes += tx_bytes;
1215 if (!sl->lin_master) {
1216 sl->tx_cnt = SLLIN_BUFF_DATA;
1219 sllin_send_tx_buff(sl);
1220 clear_bit(SLF_MSGEVENT, &sl->flags);
1221 kfree_skb(sl->tx_req_skb);
1222 netif_wake_queue(sl->dev);
1224 sl->lin_state = SLSTATE_RESPONSE_SENT;
1225 goto slstate_response_sent;
1228 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1232 /* Be aware, no BREAK here */
1233 case SLSTATE_RESPONSE_WAIT_BUS:
1234 if (sl->rx_cnt < sl->rx_expect)
1237 hrtimer_cancel(&sl->rx_timer);
1238 netdev_dbg(sl->dev, "response received ID %d len %d\n",
1239 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1241 if (sllin_rx_validate(sl) == -1) {
1242 netdev_dbg(sl->dev, "RX validation failed.\n");
1243 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1245 /* Send CAN non-RTR frame with data */
1246 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1247 sll_bump(sl); /* send packet to the network layer */
1250 sl->id_to_send = false;
1251 sl->lin_state = SLSTATE_IDLE;
1254 case SLSTATE_ID_RECEIVED:
1255 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1256 sce = &sl->linfr_cache[lin_id];
1257 spin_lock_irqsave(&sl->linfr_lock, flags);
1259 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1260 && (sce->dlc > 0)) {
1262 if (sce->frame_fl & LIN_SINGLE_RESPONSE)
1263 sce->frame_fl &= ~LIN_CACHE_RESPONSE;
1265 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1267 lin_data = sce->data;
1269 if (lin_dlc > SLLIN_DATA_MAX)
1270 lin_dlc = SLLIN_DATA_MAX;
1271 memcpy(lin_data_buff, lin_data, lin_dlc);
1272 lin_data = lin_data_buff;
1275 mode = SLLIN_STPMSG_RESPONLY;
1276 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1277 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1279 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1280 lin_data, lin_dlc) != -1) {
1282 sl->rx_expect = sl->tx_lim;
1283 sl->data_to_send = true;
1284 sl->dev->stats.tx_packets++;
1285 sl->dev->stats.tx_bytes += tx_bytes;
1286 sl->resp_len_known = true;
1288 if (!sl->lin_master) {
1289 sl->tx_cnt = SLLIN_BUFF_DATA;
1291 sllin_send_tx_buff(sl);
1294 hrtimer_start(&sl->rx_timer,
1295 ktime_add(ktime_get(), sl->rx_timer_timeout),
1298 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1299 sl->lin_state = SLSTATE_IDLE;
1302 case SLSTATE_RESPONSE_SENT:
1303 slstate_response_sent:
1304 if (sl->rx_cnt < sl->tx_lim)
1307 hrtimer_cancel(&sl->rx_timer);
1308 sll_bump(sl); /* send packet to the network layer */
1309 netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1310 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1312 sl->id_to_send = false;
1313 sl->lin_state = SLSTATE_IDLE;
1318 hrtimer_cancel(&sl->rx_timer);
1319 netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1325 /************************************
1326 * sllin_open helper routines.
1327 ************************************/
1329 /* Collect hanged up channels */
1330 static void sll_sync(void)
1333 struct net_device *dev;
1336 for (i = 0; i < maxdev; i++) {
1337 dev = sllin_devs[i];
1341 sl = netdev_priv(dev);
1344 if (dev->flags & IFF_UP)
1349 /* Find a free SLLIN channel, and link in this `tty' line. */
1350 static struct sllin *sll_alloc(dev_t line)
1353 struct net_device *dev = NULL;
1356 if (sllin_devs == NULL)
1357 return NULL; /* Master array missing ! */
1359 for (i = 0; i < maxdev; i++) {
1360 dev = sllin_devs[i];
1366 /* Sorry, too many, all slots in use */
1371 sl = netdev_priv(dev);
1372 if (test_bit(SLF_INUSE, &sl->flags)) {
1373 unregister_netdevice(dev);
1375 sllin_devs[i] = NULL;
1380 char name[IFNAMSIZ];
1381 sprintf(name, "sllin%d", i);
1383 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0))
1384 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1386 dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sll_setup);
1394 sl = netdev_priv(dev);
1395 /* Initialize channel control data */
1396 sl->magic = SLLIN_MAGIC;
1398 spin_lock_init(&sl->lock);
1399 spin_lock_init(&sl->linfr_lock);
1400 sllin_devs[i] = dev;
1406 * Open the high-level part of the SLLIN channel.
1407 * This function is called by the TTY module when the
1408 * SLLIN line discipline is called for. Because we are
1409 * sure the tty line exists, we only have to link it to
1410 * a free SLLIN channel...
1412 * Called in process context serialized from other ldisc calls.
1415 static int sllin_open(struct tty_struct *tty)
1420 pr_debug("sllin: %s() invoked\n", __func__);
1422 if (!capable(CAP_NET_ADMIN))
1425 if (tty->ops->write == NULL)
1428 /* RTnetlink lock is misused here to serialize concurrent
1429 opens of sllin channels. There are better ways, but it is
1434 /* Collect hanged up channels. */
1437 sl = tty->disc_data;
1440 /* First make sure we're not already connected. */
1441 if (sl && sl->magic == SLLIN_MAGIC)
1444 /* OK. Find a free SLLIN channel to use. */
1446 sl = sll_alloc(tty_devnum(tty));
1451 tty->disc_data = sl;
1452 sl->line = tty_devnum(tty);
1454 if (!test_bit(SLF_INUSE, &sl->flags)) {
1455 /* Perform the low-level SLLIN initialization. */
1456 sl->lin_master = master;
1458 pr_debug("sllin: Configured as MASTER\n");
1460 pr_debug("sllin: Configured as SLAVE\n");
1462 sllin_reset_buffs(sl);
1464 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1465 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1467 sl->lin_state = SLSTATE_IDLE;
1469 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1470 sl->rx_timer.function = sllin_rx_timeout_handler;
1471 /* timeval_to_ktime(msg_head->ival1); */
1472 sl->rx_timer_timeout = ns_to_ktime(
1473 (1000000000l / sl->lin_baud) *
1474 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1476 set_bit(SLF_INUSE, &sl->flags);
1478 init_waitqueue_head(&sl->kwt_wq);
1479 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1480 if (sl->kwthread == NULL)
1483 err = register_netdevice(sl->dev);
1485 goto err_free_chan_and_thread;
1488 /* Done. We have linked the TTY line to a channel. */
1490 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1492 /* TTY layer expects 0 on success */
1495 err_free_chan_and_thread:
1496 kthread_stop(sl->kwthread);
1497 sl->kwthread = NULL;
1501 tty->disc_data = NULL;
1502 clear_bit(SLF_INUSE, &sl->flags);
1507 /* Count references from TTY module */
1512 * Close down a SLLIN channel.
1513 * This means flushing out any pending queues, and then returning. This
1514 * call is serialized against other ldisc functions.
1516 * We also use this method for a hangup event.
1519 static void sllin_close(struct tty_struct *tty)
1521 struct sllin *sl = (struct sllin *) tty->disc_data;
1523 /* First make sure we're connected. */
1524 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1527 kthread_stop(sl->kwthread);
1528 sl->kwthread = NULL;
1530 tty->disc_data = NULL;
1533 /* Flush network side */
1534 unregister_netdev(sl->dev);
1535 /* This will complete via sl_free_netdev */
1538 static int sllin_hangup(struct tty_struct *tty)
1544 /* Perform I/O control on an active SLLIN channel. */
1545 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1546 unsigned int cmd, unsigned long arg)
1548 struct sllin *sl = (struct sllin *) tty->disc_data;
1551 /* First make sure we're connected. */
1552 if (!sl || sl->magic != SLLIN_MAGIC)
1557 tmp = strlen(sl->dev->name) + 1;
1558 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1566 return tty_mode_ioctl(tty, file, cmd, arg);
1570 static struct tty_ldisc_ops sll_ldisc = {
1571 .owner = THIS_MODULE,
1572 .magic = TTY_LDISC_MAGIC,
1575 .close = sllin_close,
1576 .hangup = sllin_hangup,
1577 .ioctl = sllin_ioctl,
1578 .receive_buf = sllin_receive_buf,
1579 .write_wakeup = sllin_write_wakeup,
1582 static int __init sllin_init(void)
1587 maxdev = 4; /* Sanity */
1590 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1592 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1594 pr_err("sllin: can't allocate sllin device array!\n");
1598 /* Fill in our line protocol discipline, and register it */
1599 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1601 pr_err("sllin: can't register line discipline\n");
1605 #ifdef BREAK_BY_BAUD
1606 pr_debug("sllin: Break is generated by baud-rate change.");
1608 pr_debug("sllin: Break is generated manually with tiny sleep.");
1614 static void __exit sllin_exit(void)
1617 struct net_device *dev;
1619 unsigned long timeout = jiffies + HZ;
1622 if (sllin_devs == NULL)
1625 /* First of all: check for active disciplines and hangup them.
1629 msleep_interruptible(100);
1632 for (i = 0; i < maxdev; i++) {
1633 dev = sllin_devs[i];
1636 sl = netdev_priv(dev);
1637 spin_lock_bh(&sl->lock);
1640 tty_hangup(sl->tty);
1642 spin_unlock_bh(&sl->lock);
1644 } while (busy && time_before(jiffies, timeout));
1646 /* FIXME: hangup is async so we should wait when doing this second
1649 for (i = 0; i < maxdev; i++) {
1650 dev = sllin_devs[i];
1653 sllin_devs[i] = NULL;
1655 sl = netdev_priv(dev);
1657 netdev_dbg(sl->dev, "tty discipline still running\n");
1658 /* Intentionally leak the control block. */
1659 dev->destructor = NULL;
1662 unregister_netdev(dev);
1668 i = tty_unregister_ldisc(N_SLLIN);
1670 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1673 module_init(sllin_init);
1674 module_exit(sllin_exit);