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 mutex_lock(&tty->termios_mutex);
215 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
216 old_termios = termios = *(tty->termios);
218 old_termios = termios = tty->termios;
221 cflag = CS8 | CREAD | CLOCAL | HUPCL;
222 cflag &= ~(CBAUD | CIBAUD);
224 termios.c_cflag = cflag;
228 /* Enable interrupt when UART-Break or Framing error received */
229 termios.c_iflag = BRKINT | INPCK;
230 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
231 *(tty->termios) = termios;
233 tty->termios = termios;
236 tty_encode_baud_rate(tty, speed, speed);
238 if (tty->ops->set_termios)
239 tty->ops->set_termios(tty, &old_termios);
241 mutex_unlock(&tty->termios_mutex);
246 /* Send one can_frame to the network layer */
247 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
255 memcpy(&cf.data, data, cf.can_dlc);
257 skb = dev_alloc_skb(sizeof(struct can_frame));
262 skb->protocol = htons(ETH_P_CAN);
263 skb->pkt_type = PACKET_BROADCAST;
264 skb->ip_summed = CHECKSUM_UNNECESSARY;
265 memcpy(skb_put(skb, sizeof(struct can_frame)),
266 &cf, sizeof(struct can_frame));
269 sl->dev->stats.rx_packets++;
270 sl->dev->stats.rx_bytes += cf.can_dlc;
274 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
279 static void sll_bump(struct sllin *sl)
281 int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
282 len = (len < 0) ? 0 : len;
284 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
285 sl->rx_buff + SLLIN_BUFF_DATA, len);
288 static void sll_send_rtr(struct sllin *sl)
290 sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
291 CAN_RTR_FLAG, NULL, 0);
295 * Called by the driver when there's room for more data. If we have
296 * more packets to send, we send them here.
298 static void sllin_write_wakeup(struct tty_struct *tty)
302 struct sllin *sl = (struct sllin *) tty->disc_data;
304 /* First make sure we're connected. */
305 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
308 set_bit(SLF_TXBUFF_RQ, &sl->flags);
310 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
311 return; /* ongoing concurrent processing */
313 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
314 smp_mb__after_clear_bit();
316 if (sl->lin_state != SLSTATE_BREAK_SENT)
317 remains = sl->tx_lim - sl->tx_cnt;
319 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
322 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
323 sl->tx_cnt - sl->tx_lim);
324 sl->tx_cnt += actual;
327 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
328 smp_mb__after_clear_bit();
330 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
332 if ((remains > 0) && (actual >= 0)) {
333 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, remains %d, waiting\n",
334 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
338 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
339 set_bit(SLF_TXEVENT, &sl->flags);
340 wake_up(&sl->kwt_wq);
342 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
346 * sll_xmit() -- Send a can_frame to a TTY queue.
348 * @skb: Pointer to Socket buffer to be sent.
349 * @dev: Network device where @skb will be sent.
351 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
353 struct sllin *sl = netdev_priv(dev);
354 struct can_frame *cf;
356 if (skb->len != sizeof(struct can_frame))
359 spin_lock(&sl->lock);
360 if (!netif_running(dev)) {
361 netdev_warn(sl->dev, "xmit: iface is down\n");
364 if (sl->tty == NULL) {
365 netdev_warn(sl->dev, "xmit: no tty device connected\n");
369 cf = (struct can_frame *) skb->data;
370 if (cf->can_id & LIN_CTRL_FRAME) {
371 sllin_configure_frame_cache(sl, cf);
372 goto free_out_unlock;
375 netif_stop_queue(sl->dev);
377 sl->tx_req_skb = skb;
378 set_bit(SLF_MSGEVENT, &sl->flags);
379 wake_up(&sl->kwt_wq);
380 spin_unlock(&sl->lock);
385 spin_unlock(&sl->lock);
392 /******************************************
393 * Routines looking at netdevice side.
394 ******************************************/
396 /* Netdevice UP -> DOWN routine */
397 static int sll_close(struct net_device *dev)
399 struct sllin *sl = netdev_priv(dev);
401 spin_lock_bh(&sl->lock);
403 /* TTY discipline is running. */
404 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
406 netif_stop_queue(dev);
409 spin_unlock_bh(&sl->lock);
414 /* Netdevice DOWN -> UP routine */
415 static int sll_open(struct net_device *dev)
417 struct sllin *sl = netdev_priv(dev);
419 netdev_dbg(sl->dev, "%s() invoked\n", __func__);
424 sl->flags &= (1 << SLF_INUSE);
425 netif_start_queue(dev);
429 /* Hook the destructor so we can free sllin devs at the right point in time */
430 static void sll_free_netdev(struct net_device *dev)
432 int i = dev->base_addr;
434 sllin_devs[i] = NULL;
437 static const struct net_device_ops sll_netdev_ops = {
438 .ndo_open = sll_open,
439 .ndo_stop = sll_close,
440 .ndo_start_xmit = sll_xmit,
443 static void sll_setup(struct net_device *dev)
445 dev->netdev_ops = &sll_netdev_ops;
446 dev->destructor = sll_free_netdev;
448 dev->hard_header_len = 0;
450 dev->tx_queue_len = 10;
452 dev->mtu = sizeof(struct can_frame);
453 dev->type = ARPHRD_CAN;
455 /* New-style flags. */
456 dev->flags = IFF_NOARP;
457 dev->features = NETIF_F_HW_CSUM; /* NETIF_F_NO_CSUM;*/
460 /******************************************
461 Routines looking at TTY side.
462 ******************************************/
463 static void sllin_master_receive_buf(struct tty_struct *tty,
464 const unsigned char *cp, char *fp, int count)
466 struct sllin *sl = (struct sllin *) tty->disc_data;
468 /* Read the characters out of the buffer */
471 netdev_dbg(sl->dev, "sllin_master_receive_buf char 0x%02x ignored "
472 "due marker 0x%02x, flags 0x%lx\n",
473 *cp, *(fp-1), sl->flags);
475 /* i.e. Real error -- not Break */
476 if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
477 set_bit(SLF_ERROR, &sl->flags);
478 wake_up(&sl->kwt_wq);
483 #ifndef BREAK_BY_BAUD
484 /* We didn't receive Break character -- fake it! */
485 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
486 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n", sl->rx_cnt);
487 sl->rx_buff[sl->rx_cnt++] = 0x00;
489 #endif /* BREAK_BY_BAUD */
491 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
492 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
493 sl->rx_buff[sl->rx_cnt++] = *cp++;
498 if (sl->rx_cnt >= sl->rx_expect) {
499 set_bit(SLF_RXEVENT, &sl->flags);
500 wake_up(&sl->kwt_wq);
501 netdev_dbg(sl->dev, "sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
503 netdev_dbg(sl->dev, "sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
508 /*****************************************
509 * sllin message helper routines
510 *****************************************/
512 * sllin_report_error() -- Report an error by sending CAN frame
513 * with particular error flag set in can_id
516 * @err: Error flag to be sent.
518 static void sllin_report_error(struct sllin *sl, int err)
521 case LIN_ERR_CHECKSUM:
522 sl->dev->stats.rx_crc_errors++;
525 case LIN_ERR_RX_TIMEOUT:
526 sl->dev->stats.rx_errors++;
529 case LIN_ERR_FRAMING:
530 sl->dev->stats.rx_frame_errors++;
534 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
535 (err & ~LIN_ID_MASK), NULL, 0);
539 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
542 * @cf: Pointer to CAN frame sent to this driver
543 * holding configuration information
545 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
548 struct sllin_conf_entry *sce;
550 if (!(cf->can_id & LIN_CTRL_FRAME))
553 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
554 netdev_dbg(sl->dev, "Setting frame cache with EFF CAN frame. LIN ID = %d\n",
555 cf->can_id & LIN_ID_MASK);
557 spin_lock_irqsave(&sl->linfr_lock, flags);
559 sce->dlc = cf->can_dlc;
560 if (sce->dlc > SLLIN_DATA_MAX)
561 sce->dlc = SLLIN_DATA_MAX;
563 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
564 memcpy(sce->data, cf->data, cf->can_dlc);
566 spin_unlock_irqrestore(&sl->linfr_lock, flags);
572 * sllin_checksum() -- Count checksum for particular data
574 * @data: Pointer to the buffer containing whole LIN
575 * frame (i.e. including break and sync bytes).
576 * @length: Length of the buffer.
577 * @enhanced_fl: Flag determining whether Enhanced or Classic
578 * checksum should be counted.
580 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
590 for (; i < length; i++) {
599 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
600 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
601 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
603 static int sllin_setup_msg(struct sllin *sl, int mode, int id,
604 unsigned char *data, int len)
606 if (id > LIN_ID_MASK)
609 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
613 sl->rx_lim = SLLIN_BUFF_LEN;
616 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
617 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
618 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
619 sl->tx_lim = SLLIN_BUFF_DATA;
621 if ((data != NULL) && len) {
623 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
624 sl->tx_buff[sl->tx_lim] = sllin_checksum(sl->tx_buff,
625 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
629 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
634 static void sllin_reset_buffs(struct sllin *sl)
638 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
641 sl->id_to_send = false;
642 sl->data_to_send = false;
646 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
650 static int sllin_rx_validate(struct sllin *sl)
656 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
657 struct sllin_conf_entry *sce;
659 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
660 sce = &sl->linfr_cache[actual_id];
662 spin_lock_irqsave(&sl->linfr_lock, flags);
664 ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
665 spin_unlock_irqrestore(&sl->linfr_lock, flags);
667 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
670 /* Type of checksum is configured for particular frame */
674 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
675 !ext_chcks_fl) != rec_chcksm) {
684 static void sllin_slave_finish_rx_msg(struct sllin *sl)
686 if (sllin_rx_validate(sl) == -1) {
687 netdev_dbg(sl->dev, "sllin: RX validation failed.\n");
688 sllin_report_error(sl, LIN_ERR_CHECKSUM);
690 /* Send CAN non-RTR frame with data */
691 netdev_dbg(sl->dev, "sllin: sending NON-RTR CAN frame with LIN payload.");
692 sll_bump(sl); /* send packet to the network layer */
694 /* Prepare for reception of new header */
696 sl->rx_expect = SLLIN_BUFF_ID + 1;
697 sl->rx_len_unknown = false; /* We do know exact length of the header */
698 sl->header_received = false;
701 static void sllin_slave_receive_buf(struct tty_struct *tty,
702 const unsigned char *cp, char *fp, int count)
704 struct sllin *sl = (struct sllin *) tty->disc_data;
706 struct sllin_conf_entry *sce;
709 /* Read the characters out of the buffer */
713 * If we don't know the length of the current message
714 * we received the break of the next message.
715 * Evaluate the previous one before continuing
717 if (sl->rx_len_unknown == true)
719 hrtimer_cancel(&sl->rx_timer);
720 sllin_slave_finish_rx_msg(sl);
722 set_bit(SLF_RXEVENT, &sl->flags);
723 wake_up(&sl->kwt_wq);
726 netdev_dbg(sl->dev, "sllin_slave_receive_buf char 0x%02x ignored "
727 "due marker 0x%02x, flags 0x%lx\n",
728 *cp, *(fp-1), sl->flags);
732 sl->rx_expect = SLLIN_BUFF_ID + 1;
733 sl->rx_len_unknown = false; /* We do know exact length of the header */
734 sl->header_received = false;
737 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
738 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
740 /* We did not receive break (0x00) character */
741 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
742 sl->rx_buff[sl->rx_cnt++] = 0x00;
745 if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
746 /* 'Duplicated' break character -- ignore */
752 /* Wrong sync character */
757 sl->rx_buff[sl->rx_cnt++] = *cp++;
760 /* Header received */
761 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
764 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
765 sce = &sl->linfr_cache[lin_id];
767 spin_lock_irqsave(&sl->linfr_lock, flags);
769 sl->lin_state = SLSTATE_ID_RECEIVED;
770 /* Is the length of data set in frame cache? */
772 sl->rx_expect += sce->dlc + 1; /* + checksum */
773 sl->rx_len_unknown = false;
774 set_bit(SLF_MSGEVENT, &sl->flags);
775 wake_up(&sl->kwt_wq);
777 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
778 sl->rx_len_unknown = true;
780 spin_unlock_irqrestore(&sl->linfr_lock, flags);
782 sl->header_received = true;
784 hrtimer_start(&sl->rx_timer,
785 ktime_add(ktime_get(), sl->rx_timer_timeout),
791 /* Response received */
792 if ((sl->header_received == true) &&
793 ((sl->rx_cnt >= sl->rx_expect))) {
795 hrtimer_cancel(&sl->rx_timer);
796 netdev_dbg(sl->dev, "Received LIN header & LIN response. "
797 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
799 sllin_slave_finish_rx_msg(sl);
801 set_bit(SLF_RXEVENT, &sl->flags);
802 wake_up(&sl->kwt_wq);
807 static void sllin_receive_buf(struct tty_struct *tty,
808 const unsigned char *cp, char *fp, int count)
810 struct sllin *sl = (struct sllin *) tty->disc_data;
811 netdev_dbg(sl->dev, "sllin_receive_buf invoked, count = %u\n", count);
813 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
817 sllin_master_receive_buf(tty, cp, fp, count);
819 sllin_slave_receive_buf(tty, cp, fp, count);
823 static int sllin_send_tx_buff(struct sllin *sl)
825 struct tty_struct *tty = sl->tty;
829 set_bit(SLF_TXBUFF_RQ, &sl->flags);
831 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
832 return 0; /* ongoing concurrent processing */
834 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
835 smp_mb__after_clear_bit();
838 if (sl->lin_state != SLSTATE_BREAK_SENT)
839 remains = sl->tx_lim - sl->tx_cnt;
843 remains = sl->tx_lim - sl->tx_cnt;
846 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
854 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
855 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
857 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
865 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
866 sl->tx_cnt, remains);
868 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
869 smp_mb__after_clear_bit();
871 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
876 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
882 static int sllin_send_break(struct sllin *sl)
884 struct tty_struct *tty = sl->tty;
885 unsigned long break_baud;
888 break_baud = ((sl->lin_baud * 2) / 3);
889 sltty_change_speed(tty, break_baud);
891 tty->ops->flush_buffer(tty);
892 sl->rx_cnt = SLLIN_BUFF_BREAK;
894 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
895 sl->lin_state = SLSTATE_BREAK_SENT;
897 res = sllin_send_tx_buff(sl);
899 sl->lin_state = SLSTATE_IDLE;
905 #else /* BREAK_BY_BAUD */
907 static int sllin_send_break(struct sllin *sl)
909 struct tty_struct *tty = sl->tty;
911 unsigned long break_baud;
912 unsigned long usleep_range_min;
913 unsigned long usleep_range_max;
915 break_baud = ((sl->lin_baud * 2) / 3);
916 sl->rx_cnt = SLLIN_BUFF_BREAK;
917 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
918 sl->lin_state = SLSTATE_BREAK_SENT;
920 /* Do the break ourselves; Inspired by
921 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
922 retval = tty->ops->break_ctl(tty, -1);
927 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
928 usleep_range_max = usleep_range_min + 50;
929 usleep_range(usleep_range_min, usleep_range_max);
931 retval = tty->ops->break_ctl(tty, 0);
932 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
933 usleep_range_max = usleep_range_min + 30;
934 usleep_range(usleep_range_min, usleep_range_max);
936 tty->ops->flush_buffer(tty);
938 sl->tx_cnt = SLLIN_BUFF_SYNC;
940 netdev_dbg(sl->dev, "Break sent.\n");
941 set_bit(SLF_RXEVENT, &sl->flags);
942 wake_up(&sl->kwt_wq);
946 #endif /* BREAK_BY_BAUD */
949 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
951 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
953 if (sl->lin_master) {
954 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
955 set_bit(SLF_TMOUTEVENT, &sl->flags);
957 sllin_slave_finish_rx_msg(sl);
958 set_bit(SLF_RXEVENT, &sl->flags);
960 wake_up(&sl->kwt_wq);
962 return HRTIMER_NORESTART;
965 /*****************************************
966 * sllin_kwthread - kernel worker thread
967 *****************************************/
969 static int sllin_kwthread(void *ptr)
971 struct sllin *sl = (struct sllin *)ptr;
972 struct tty_struct *tty = sl->tty;
973 struct sched_param schparam = { .sched_priority = 40 };
974 int tx_bytes = 0; /* Used for Network statistics */
977 struct sllin_conf_entry *sce;
979 netdev_dbg(sl->dev, "sllin_kwthread started.\n");
980 sched_setscheduler(current, SCHED_FIFO, &schparam);
982 clear_bit(SLF_ERROR, &sl->flags);
983 sltty_change_speed(tty, sl->lin_baud);
985 while (!kthread_should_stop()) {
986 struct can_frame *cf;
989 u8 lin_data_buff[SLLIN_DATA_MAX];
992 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
994 if (sllin_send_break(sl) < 0) {
995 /* error processing */
999 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
1000 test_bit(SLF_RXEVENT, &sl->flags) ||
1001 test_bit(SLF_TXEVENT, &sl->flags) ||
1002 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
1003 test_bit(SLF_ERROR, &sl->flags) ||
1004 (((sl->lin_state == SLSTATE_IDLE) ||
1005 (sl->lin_state == SLSTATE_RESPONSE_WAIT) ||
1006 (sl->lin_state == SLSTATE_ID_RECEIVED))
1007 && test_bit(SLF_MSGEVENT, &sl->flags)));
1009 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1010 netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1013 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1014 unsigned long usleep_range_min;
1015 unsigned long usleep_range_max;
1016 hrtimer_cancel(&sl->rx_timer);
1017 netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1019 if (sl->lin_state != SLSTATE_IDLE)
1020 sllin_report_error(sl, LIN_ERR_FRAMING);
1022 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1024 usleep_range_max = usleep_range_min + 50;
1025 usleep_range(usleep_range_min, usleep_range_max);
1026 sllin_reset_buffs(sl);
1027 sl->lin_state = SLSTATE_IDLE;
1030 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1031 netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1034 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1035 netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1036 sllin_reset_buffs(sl);
1038 sl->lin_state = SLSTATE_IDLE;
1041 switch (sl->lin_state) {
1043 if (!test_bit(SLF_MSGEVENT, &sl->flags))
1046 cf = (struct can_frame *)sl->tx_req_skb->data;
1048 /* SFF RTR CAN frame -> LIN header */
1049 if (cf->can_id & CAN_RTR_FLAG) {
1050 struct sllin_conf_entry *sce;
1052 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1053 __func__, cf->can_id & LIN_ID_MASK);
1055 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1056 spin_lock_irqsave(&sl->linfr_lock, flags);
1058 /* Is there Slave response in linfr_cache to be sent? */
1059 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1060 && (sce->dlc > 0)) {
1062 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1064 lin_data = sce->data;
1066 if (lin_dlc > SLLIN_DATA_MAX)
1067 lin_dlc = SLLIN_DATA_MAX;
1068 memcpy(lin_data_buff, lin_data, lin_dlc);
1069 lin_data = lin_data_buff;
1074 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1076 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1077 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1078 __func__, (int)cf->can_id & LIN_ID_MASK);
1080 lin_data = cf->data;
1081 lin_dlc = cf->can_dlc;
1082 if (lin_dlc > SLLIN_DATA_MAX)
1083 lin_dlc = SLLIN_DATA_MAX;
1087 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1088 lin_data, lin_dlc) != -1) {
1090 sl->id_to_send = true;
1091 sl->data_to_send = (lin_data != NULL) ? true : false;
1092 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1093 sl->dev->stats.tx_packets++;
1094 sl->dev->stats.tx_bytes += tx_bytes;
1097 clear_bit(SLF_MSGEVENT, &sl->flags);
1098 kfree_skb(sl->tx_req_skb);
1099 netif_wake_queue(sl->dev);
1100 hrtimer_start(&sl->rx_timer,
1101 ktime_add(ktime_get(), sl->rx_timer_timeout),
1105 case SLSTATE_BREAK_SENT:
1106 #ifdef BREAK_BY_BAUD
1107 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1110 res = sltty_change_speed(tty, sl->lin_baud);
1113 sl->lin_state = SLSTATE_ID_SENT;
1114 sllin_send_tx_buff(sl);
1117 case SLSTATE_ID_SENT:
1118 hrtimer_cancel(&sl->rx_timer);
1119 sl->id_to_send = false;
1120 if (sl->data_to_send) {
1121 sllin_send_tx_buff(sl);
1122 sl->lin_state = SLSTATE_RESPONSE_SENT;
1123 sl->rx_expect = sl->tx_lim;
1124 goto slstate_response_sent;
1126 if (sl->resp_len_known) {
1127 sl->rx_expect = sl->rx_lim;
1129 sl->rx_expect = SLLIN_BUFF_DATA + 2;
1131 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1132 /* If we don't receive anything, timer will "unblock" us */
1133 hrtimer_start(&sl->rx_timer,
1134 ktime_add(ktime_get(), sl->rx_timer_timeout),
1136 goto slstate_response_wait;
1140 case SLSTATE_RESPONSE_WAIT:
1141 slstate_response_wait:
1142 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1143 unsigned char *lin_buff;
1144 cf = (struct can_frame *)sl->tx_req_skb->data;
1146 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1147 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1148 hrtimer_cancel(&sl->rx_timer);
1149 netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1150 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1151 cf->can_id & LIN_ID_MASK,
1152 cf->data, cf->can_dlc) != -1) {
1154 sl->rx_expect = sl->tx_lim;
1155 sl->data_to_send = true;
1156 sl->dev->stats.tx_packets++;
1157 sl->dev->stats.tx_bytes += tx_bytes;
1159 if (!sl->lin_master) {
1160 sl->tx_cnt = SLLIN_BUFF_DATA;
1163 sllin_send_tx_buff(sl);
1164 clear_bit(SLF_MSGEVENT, &sl->flags);
1165 kfree_skb(sl->tx_req_skb);
1166 netif_wake_queue(sl->dev);
1168 sl->lin_state = SLSTATE_RESPONSE_SENT;
1169 goto slstate_response_sent;
1172 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1176 /* Be aware, no BREAK here */
1177 case SLSTATE_RESPONSE_WAIT_BUS:
1178 if (sl->rx_cnt < sl->rx_expect)
1181 hrtimer_cancel(&sl->rx_timer);
1182 netdev_dbg(sl->dev, "response received ID %d len %d\n",
1183 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1185 if (sllin_rx_validate(sl) == -1) {
1186 netdev_dbg(sl->dev, "RX validation failed.\n");
1187 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1189 /* Send CAN non-RTR frame with data */
1190 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1191 sll_bump(sl); /* send packet to the network layer */
1194 sl->id_to_send = false;
1195 sl->lin_state = SLSTATE_IDLE;
1198 case SLSTATE_ID_RECEIVED:
1199 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1200 sce = &sl->linfr_cache[lin_id];
1201 spin_lock_irqsave(&sl->linfr_lock, flags);
1203 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1205 && (test_bit(SLF_MSGEVENT, &sl->flags))) {
1208 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1210 lin_data = sce->data;
1212 if (lin_dlc > SLLIN_DATA_MAX)
1213 lin_dlc = SLLIN_DATA_MAX;
1214 memcpy(lin_data_buff, lin_data, lin_dlc);
1215 lin_data = lin_data_buff;
1218 mode = SLLIN_STPMSG_RESPONLY;
1219 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1220 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1222 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1223 lin_data, lin_dlc) != -1) {
1225 sl->rx_expect = sl->tx_lim;
1226 sl->data_to_send = true;
1227 sl->dev->stats.tx_packets++;
1228 sl->dev->stats.tx_bytes += tx_bytes;
1229 sl->resp_len_known = true;
1231 if (!sl->lin_master) {
1232 sl->tx_cnt = SLLIN_BUFF_DATA;
1234 sllin_send_tx_buff(sl);
1237 clear_bit(SLF_MSGEVENT, &sl->flags);
1238 kfree_skb(sl->tx_req_skb);
1239 netif_wake_queue(sl->dev);
1240 hrtimer_start(&sl->rx_timer,
1241 ktime_add(ktime_get(), sl->rx_timer_timeout),
1244 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1245 sl->lin_state = SLSTATE_IDLE;
1248 case SLSTATE_RESPONSE_SENT:
1249 slstate_response_sent:
1250 if (sl->rx_cnt < sl->tx_lim)
1253 hrtimer_cancel(&sl->rx_timer);
1254 sll_bump(sl); /* send packet to the network layer */
1255 netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1256 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1258 sl->id_to_send = false;
1259 sl->lin_state = SLSTATE_IDLE;
1264 hrtimer_cancel(&sl->rx_timer);
1265 netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1271 /************************************
1272 * sllin_open helper routines.
1273 ************************************/
1275 /* Collect hanged up channels */
1276 static void sll_sync(void)
1279 struct net_device *dev;
1282 for (i = 0; i < maxdev; i++) {
1283 dev = sllin_devs[i];
1287 sl = netdev_priv(dev);
1290 if (dev->flags & IFF_UP)
1295 /* Find a free SLLIN channel, and link in this `tty' line. */
1296 static struct sllin *sll_alloc(dev_t line)
1299 struct net_device *dev = NULL;
1302 if (sllin_devs == NULL)
1303 return NULL; /* Master array missing ! */
1305 for (i = 0; i < maxdev; i++) {
1306 dev = sllin_devs[i];
1312 /* Sorry, too many, all slots in use */
1317 sl = netdev_priv(dev);
1318 if (test_bit(SLF_INUSE, &sl->flags)) {
1319 unregister_netdevice(dev);
1321 sllin_devs[i] = NULL;
1326 char name[IFNAMSIZ];
1327 sprintf(name, "sllin%d", i);
1329 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1335 sl = netdev_priv(dev);
1336 /* Initialize channel control data */
1337 sl->magic = SLLIN_MAGIC;
1339 spin_lock_init(&sl->lock);
1340 spin_lock_init(&sl->linfr_lock);
1341 sllin_devs[i] = dev;
1347 * Open the high-level part of the SLLIN channel.
1348 * This function is called by the TTY module when the
1349 * SLLIN line discipline is called for. Because we are
1350 * sure the tty line exists, we only have to link it to
1351 * a free SLLIN channel...
1353 * Called in process context serialized from other ldisc calls.
1356 static int sllin_open(struct tty_struct *tty)
1361 pr_debug("sllin: %s() invoked\n", __func__);
1363 if (!capable(CAP_NET_ADMIN))
1366 if (tty->ops->write == NULL)
1369 /* RTnetlink lock is misused here to serialize concurrent
1370 opens of sllin channels. There are better ways, but it is
1375 /* Collect hanged up channels. */
1378 sl = tty->disc_data;
1381 /* First make sure we're not already connected. */
1382 if (sl && sl->magic == SLLIN_MAGIC)
1385 /* OK. Find a free SLLIN channel to use. */
1387 sl = sll_alloc(tty_devnum(tty));
1392 tty->disc_data = sl;
1393 sl->line = tty_devnum(tty);
1395 if (!test_bit(SLF_INUSE, &sl->flags)) {
1396 /* Perform the low-level SLLIN initialization. */
1397 sl->lin_master = master;
1399 pr_debug("sllin: Configured as MASTER\n");
1401 pr_debug("sllin: Configured as SLAVE\n");
1403 sllin_reset_buffs(sl);
1405 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1406 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1408 sl->lin_state = SLSTATE_IDLE;
1410 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1411 sl->rx_timer.function = sllin_rx_timeout_handler;
1412 /* timeval_to_ktime(msg_head->ival1); */
1413 sl->rx_timer_timeout = ns_to_ktime(
1414 (1000000000l / sl->lin_baud) *
1415 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1417 set_bit(SLF_INUSE, &sl->flags);
1419 init_waitqueue_head(&sl->kwt_wq);
1420 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1421 if (sl->kwthread == NULL)
1424 err = register_netdevice(sl->dev);
1426 goto err_free_chan_and_thread;
1429 /* Done. We have linked the TTY line to a channel. */
1431 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1433 /* TTY layer expects 0 on success */
1436 err_free_chan_and_thread:
1437 kthread_stop(sl->kwthread);
1438 sl->kwthread = NULL;
1442 tty->disc_data = NULL;
1443 clear_bit(SLF_INUSE, &sl->flags);
1448 /* Count references from TTY module */
1453 * Close down a SLLIN channel.
1454 * This means flushing out any pending queues, and then returning. This
1455 * call is serialized against other ldisc functions.
1457 * We also use this method for a hangup event.
1460 static void sllin_close(struct tty_struct *tty)
1462 struct sllin *sl = (struct sllin *) tty->disc_data;
1464 /* First make sure we're connected. */
1465 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1468 kthread_stop(sl->kwthread);
1469 sl->kwthread = NULL;
1471 tty->disc_data = NULL;
1474 /* Flush network side */
1475 unregister_netdev(sl->dev);
1476 /* This will complete via sl_free_netdev */
1479 static int sllin_hangup(struct tty_struct *tty)
1485 /* Perform I/O control on an active SLLIN channel. */
1486 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1487 unsigned int cmd, unsigned long arg)
1489 struct sllin *sl = (struct sllin *) tty->disc_data;
1492 /* First make sure we're connected. */
1493 if (!sl || sl->magic != SLLIN_MAGIC)
1498 tmp = strlen(sl->dev->name) + 1;
1499 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1507 return tty_mode_ioctl(tty, file, cmd, arg);
1511 static struct tty_ldisc_ops sll_ldisc = {
1512 .owner = THIS_MODULE,
1513 .magic = TTY_LDISC_MAGIC,
1516 .close = sllin_close,
1517 .hangup = sllin_hangup,
1518 .ioctl = sllin_ioctl,
1519 .receive_buf = sllin_receive_buf,
1520 .write_wakeup = sllin_write_wakeup,
1523 static int __init sllin_init(void)
1528 maxdev = 4; /* Sanity */
1531 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1533 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1535 pr_err("sllin: can't allocate sllin device array!\n");
1539 /* Fill in our line protocol discipline, and register it */
1540 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1542 pr_err("sllin: can't register line discipline\n");
1546 #ifdef BREAK_BY_BAUD
1547 pr_debug("sllin: Break is generated by baud-rate change.");
1549 pr_debug("sllin: Break is generated manually with tiny sleep.");
1555 static void __exit sllin_exit(void)
1558 struct net_device *dev;
1560 unsigned long timeout = jiffies + HZ;
1563 if (sllin_devs == NULL)
1566 /* First of all: check for active disciplines and hangup them.
1570 msleep_interruptible(100);
1573 for (i = 0; i < maxdev; i++) {
1574 dev = sllin_devs[i];
1577 sl = netdev_priv(dev);
1578 spin_lock_bh(&sl->lock);
1581 tty_hangup(sl->tty);
1583 spin_unlock_bh(&sl->lock);
1585 } while (busy && time_before(jiffies, timeout));
1587 /* FIXME: hangup is async so we should wait when doing this second
1590 for (i = 0; i < maxdev; i++) {
1591 dev = sllin_devs[i];
1594 sllin_devs[i] = NULL;
1596 sl = netdev_priv(dev);
1598 netdev_dbg(sl->dev, "tty discipline still running\n");
1599 /* Intentionally leak the control block. */
1600 dev->destructor = NULL;
1603 unregister_netdev(dev);
1609 i = tty_unregister_ldisc(N_SLLIN);
1611 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1614 module_init(sllin_init);
1615 module_exit(sllin_exit);