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/lin_bus.h"
67 /* Should be in include/linux/tty.h */
69 /* -------------------------------- */
71 static __initdata const char banner[] =
72 KERN_INFO "sllin: serial line LIN interface driver\n";
74 MODULE_ALIAS_LDISC(N_SLLIN);
75 MODULE_DESCRIPTION("serial line LIN interface");
76 MODULE_LICENSE("GPL");
77 MODULE_AUTHOR("Pavel Pisa <pisa@cmp.felk.cvut.cz>");
79 #define SLLIN_MAGIC 0x53CA
80 /* #define BREAK_BY_BAUD */
82 static bool master = true;
83 static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
85 module_param(master, bool, 0);
86 MODULE_PARM_DESC(master, "LIN interface is Master device");
87 module_param(baudrate, int, 0);
88 MODULE_PARM_DESC(baudrate, "Baudrate of LIN interface");
90 static int maxdev = 10; /* MAX number of SLLIN channels;
91 This can be overridden with
92 insmod sllin.ko maxdev=nnn */
93 module_param(maxdev, int, 0);
94 MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
96 /* maximum buffer len to store whole LIN message*/
97 #define SLLIN_DATA_MAX 8
98 #define SLLIN_BUFF_LEN (1 /*break*/ + 1 /*sync*/ + 1 /*ID*/ + \
99 SLLIN_DATA_MAX + 1 /*checksum*/)
100 #define SLLIN_BUFF_BREAK 0
101 #define SLLIN_BUFF_SYNC 1
102 #define SLLIN_BUFF_ID 2
103 #define SLLIN_BUFF_DATA 3
105 #define SLLIN_SAMPLES_PER_CHAR 10
106 #define SLLIN_CHARS_TO_TIMEOUT 24
112 SLSTATE_RESPONSE_WAIT, /* Wait for response */
113 SLSTATE_RESPONSE_WAIT_BUS, /* Wait for response from LIN bus
114 only (CAN frames from network stack
115 are not processed in this moment) */
117 SLSTATE_RESPONSE_SENT,
120 struct sllin_conf_entry {
121 int dlc; /* Length of data in LIN frame */
122 canid_t frame_fl; /* LIN frame flags. Passed from userspace as
124 u8 data[8]; /* LIN frame data payload */
130 /* Various fields. */
131 struct tty_struct *tty; /* ptr to TTY structure */
132 struct net_device *dev; /* easy for intr handling */
135 /* LIN message buffer and actual processed data counts */
136 unsigned char rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
137 unsigned char tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
138 int rx_expect; /* expected number of Rx chars */
139 int rx_lim; /* maximum Rx chars for current frame */
140 int rx_cnt; /* message buffer Rx fill level */
141 int tx_lim; /* actual limit of bytes to Tx */
142 int tx_cnt; /* number of already Tx bytes */
143 char lin_master; /* node is a master node */
144 int lin_baud; /* LIN baudrate */
145 int lin_state; /* state */
146 char id_to_send; /* there is ID to be sent */
147 char data_to_send; /* there are data to be sent */
148 char resp_len_known; /* Length of the response is known */
149 char header_received;/* In Slave mode, set when header was already
151 char rx_len_unknown; /* We are not sure how much data will be sent to us --
152 we just guess the length */
154 unsigned long flags; /* Flag values/ mode etc */
155 #define SLF_INUSE 0 /* Channel in use */
156 #define SLF_ERROR 1 /* Parity, etc. error */
157 #define SLF_RXEVENT 2 /* Rx wake event */
158 #define SLF_TXEVENT 3 /* Tx wake event */
159 #define SLF_MSGEVENT 4 /* CAN message to sent */
160 #define SLF_TMOUTEVENT 5 /* Timeout on received data */
161 #define SLF_TXBUFF_RQ 6 /* Req. to send buffer to UART*/
162 #define SLF_TXBUFF_INPR 7 /* Above request in progress */
165 struct task_struct *kwthread;
166 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
167 struct hrtimer rx_timer; /* RX timeout timer */
168 ktime_t rx_timer_timeout; /* RX timeout timer value */
169 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame
170 received from network stack*/
172 /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
173 struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
174 spinlock_t linfr_lock; /* frame cache and buffers lock */
177 static struct net_device **sllin_devs;
178 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
179 static void sllin_slave_receive_buf(struct tty_struct *tty,
180 const unsigned char *cp, char *fp, int count);
181 static void sllin_master_receive_buf(struct tty_struct *tty,
182 const unsigned char *cp, char *fp, int count);
185 /* Values of two parity bits in LIN Protected
186 Identifier for each particular LIN ID */
187 const unsigned char sllin_id_parity_table[] = {
188 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
189 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
190 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
191 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
192 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
193 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
194 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
195 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
199 * sltty_change_speed() -- Change baudrate of Serial device belonging
202 * @tty: Pointer to TTY to change speed for.
203 * @speed: Integer value of new speed. It is possible to
204 * assign non-standard values, i.e. those which
205 * are not defined in termbits.h.
207 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
209 struct ktermios old_termios;
212 mutex_lock(&tty->termios_mutex);
214 old_termios = *(tty->termios);
216 cflag = CS8 | CREAD | CLOCAL | HUPCL;
217 cflag &= ~(CBAUD | CIBAUD);
219 tty->termios->c_cflag = cflag;
220 tty->termios->c_oflag = 0;
221 tty->termios->c_lflag = 0;
223 /* Enable interrupt when UART-Break or Framing error received */
224 tty->termios->c_iflag = BRKINT | INPCK;
226 tty_encode_baud_rate(tty, speed, speed);
228 if (tty->ops->set_termios)
229 tty->ops->set_termios(tty, &old_termios);
231 mutex_unlock(&tty->termios_mutex);
236 /* Send one can_frame to the network layer */
237 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
245 memcpy(&cf.data, data, cf.can_dlc);
247 skb = dev_alloc_skb(sizeof(struct can_frame));
252 skb->protocol = htons(ETH_P_CAN);
253 skb->pkt_type = PACKET_BROADCAST;
254 skb->ip_summed = CHECKSUM_UNNECESSARY;
255 memcpy(skb_put(skb, sizeof(struct can_frame)),
256 &cf, sizeof(struct can_frame));
259 sl->dev->stats.rx_packets++;
260 sl->dev->stats.rx_bytes += cf.can_dlc;
264 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
269 static void sll_bump(struct sllin *sl)
271 int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
272 len = (len < 0) ? 0 : len;
274 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
275 sl->rx_buff + SLLIN_BUFF_DATA, len);
278 static void sll_send_rtr(struct sllin *sl)
280 sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
281 CAN_RTR_FLAG, NULL, 0);
285 * Called by the driver when there's room for more data. If we have
286 * more packets to send, we send them here.
288 static void sllin_write_wakeup(struct tty_struct *tty)
292 struct sllin *sl = (struct sllin *) tty->disc_data;
294 /* First make sure we're connected. */
295 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
298 set_bit(SLF_TXBUFF_RQ, &sl->flags);
300 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
301 return; /* ongoing concurrent processing */
303 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
304 smp_mb__after_clear_bit();
306 if (sl->lin_state != SLSTATE_BREAK_SENT)
307 remains = sl->tx_lim - sl->tx_cnt;
309 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
312 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
313 sl->tx_cnt - sl->tx_lim);
314 sl->tx_cnt += actual;
317 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
318 smp_mb__after_clear_bit();
320 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
322 if ((remains > 0) && (actual >= 0)) {
323 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, remains %d, waiting\n",
324 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
328 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
329 set_bit(SLF_TXEVENT, &sl->flags);
330 wake_up(&sl->kwt_wq);
332 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
336 * sll_xmit() -- Send a can_frame to a TTY queue.
338 * @skb: Pointer to Socket buffer to be sent.
339 * @dev: Network device where @skb will be sent.
341 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
343 struct sllin *sl = netdev_priv(dev);
344 struct can_frame *cf;
346 if (skb->len != sizeof(struct can_frame))
349 spin_lock(&sl->lock);
350 if (!netif_running(dev)) {
351 netdev_warn(sl->dev, "xmit: iface is down\n");
354 if (sl->tty == NULL) {
355 netdev_warn(sl->dev, "xmit: no tty device connected\n");
359 cf = (struct can_frame *) skb->data;
360 if (cf->can_id & LIN_CTRL_FRAME) {
361 sllin_configure_frame_cache(sl, cf);
362 goto free_out_unlock;
365 netif_stop_queue(sl->dev);
367 sl->tx_req_skb = skb;
368 set_bit(SLF_MSGEVENT, &sl->flags);
369 wake_up(&sl->kwt_wq);
370 spin_unlock(&sl->lock);
375 spin_unlock(&sl->lock);
382 /******************************************
383 * Routines looking at netdevice side.
384 ******************************************/
386 /* Netdevice UP -> DOWN routine */
387 static int sll_close(struct net_device *dev)
389 struct sllin *sl = netdev_priv(dev);
391 spin_lock_bh(&sl->lock);
393 /* TTY discipline is running. */
394 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
396 netif_stop_queue(dev);
399 spin_unlock_bh(&sl->lock);
404 /* Netdevice DOWN -> UP routine */
405 static int sll_open(struct net_device *dev)
407 struct sllin *sl = netdev_priv(dev);
409 netdev_dbg(sl->dev, "%s() invoked\n", __func__);
414 sl->flags &= (1 << SLF_INUSE);
415 netif_start_queue(dev);
419 /* Hook the destructor so we can free sllin devs at the right point in time */
420 static void sll_free_netdev(struct net_device *dev)
422 int i = dev->base_addr;
424 sllin_devs[i] = NULL;
427 static const struct net_device_ops sll_netdev_ops = {
428 .ndo_open = sll_open,
429 .ndo_stop = sll_close,
430 .ndo_start_xmit = sll_xmit,
433 static void sll_setup(struct net_device *dev)
435 dev->netdev_ops = &sll_netdev_ops;
436 dev->destructor = sll_free_netdev;
438 dev->hard_header_len = 0;
440 dev->tx_queue_len = 10;
442 dev->mtu = sizeof(struct can_frame);
443 dev->type = ARPHRD_CAN;
445 /* New-style flags. */
446 dev->flags = IFF_NOARP;
447 dev->features = NETIF_F_HW_CSUM; /* NETIF_F_NO_CSUM;*/
450 /******************************************
451 Routines looking at TTY side.
452 ******************************************/
453 static void sllin_master_receive_buf(struct tty_struct *tty,
454 const unsigned char *cp, char *fp, int count)
456 struct sllin *sl = (struct sllin *) tty->disc_data;
458 /* Read the characters out of the buffer */
461 netdev_dbg(sl->dev, "sllin_master_receive_buf char 0x%02x ignored "
462 "due marker 0x%02x, flags 0x%lx\n",
463 *cp, *(fp-1), sl->flags);
465 /* i.e. Real error -- not Break */
466 if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
467 set_bit(SLF_ERROR, &sl->flags);
468 wake_up(&sl->kwt_wq);
473 #ifndef BREAK_BY_BAUD
474 /* We didn't receive Break character -- fake it! */
475 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
476 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n", sl->rx_cnt);
477 sl->rx_buff[sl->rx_cnt++] = 0x00;
479 #endif /* BREAK_BY_BAUD */
481 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
482 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
483 sl->rx_buff[sl->rx_cnt++] = *cp++;
488 if (sl->rx_cnt >= sl->rx_expect) {
489 set_bit(SLF_RXEVENT, &sl->flags);
490 wake_up(&sl->kwt_wq);
491 netdev_dbg(sl->dev, "sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
493 netdev_dbg(sl->dev, "sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
498 /*****************************************
499 * sllin message helper routines
500 *****************************************/
502 * sllin_report_error() -- Report an error by sending CAN frame
503 * with particular error flag set in can_id
506 * @err: Error flag to be sent.
508 static void sllin_report_error(struct sllin *sl, int err)
511 case LIN_ERR_CHECKSUM:
512 sl->dev->stats.rx_crc_errors++;
515 case LIN_ERR_RX_TIMEOUT:
516 sl->dev->stats.rx_errors++;
519 case LIN_ERR_FRAMING:
520 sl->dev->stats.rx_frame_errors++;
524 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
525 (err & ~LIN_ID_MASK), NULL, 0);
529 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
532 * @cf: Pointer to CAN frame sent to this driver
533 * holding configuration information
535 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
538 struct sllin_conf_entry *sce;
540 if (!(cf->can_id & LIN_CTRL_FRAME))
543 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
544 netdev_dbg(sl->dev, "Setting frame cache with EFF CAN frame. LIN ID = %d\n",
545 cf->can_id & LIN_ID_MASK);
547 spin_lock_irqsave(&sl->linfr_lock, flags);
549 sce->dlc = cf->can_dlc;
550 if (sce->dlc > SLLIN_DATA_MAX)
551 sce->dlc = SLLIN_DATA_MAX;
553 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
554 memcpy(sce->data, cf->data, cf->can_dlc);
556 spin_unlock_irqrestore(&sl->linfr_lock, flags);
562 * sllin_checksum() -- Count checksum for particular data
564 * @data: Pointer to the buffer containing whole LIN
565 * frame (i.e. including break and sync bytes).
566 * @length: Length of the buffer.
567 * @enhanced_fl: Flag determining whether Enhanced or Classic
568 * checksum should be counted.
570 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
580 for (; i < length; i++) {
589 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
590 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
591 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
593 static int sllin_setup_msg(struct sllin *sl, int mode, int id,
594 unsigned char *data, int len)
596 if (id > LIN_ID_MASK)
599 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
603 sl->rx_lim = SLLIN_BUFF_LEN;
606 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
607 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
608 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
609 sl->tx_lim = SLLIN_BUFF_DATA;
611 if ((data != NULL) && len) {
613 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
614 sl->tx_buff[sl->tx_lim] = sllin_checksum(sl->tx_buff,
615 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
619 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
624 static void sllin_reset_buffs(struct sllin *sl)
628 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
631 sl->id_to_send = false;
632 sl->data_to_send = false;
636 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
640 static int sllin_rx_validate(struct sllin *sl)
646 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
647 struct sllin_conf_entry *sce;
649 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
650 sce = &sl->linfr_cache[actual_id];
652 spin_lock_irqsave(&sl->linfr_lock, flags);
654 ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
655 spin_unlock_irqrestore(&sl->linfr_lock, flags);
657 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
660 /* Type of checksum is configured for particular frame */
664 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
665 !ext_chcks_fl) != rec_chcksm) {
674 static void sllin_slave_finish_rx_msg(struct sllin *sl)
676 if (sllin_rx_validate(sl) == -1) {
677 netdev_dbg(sl->dev, "sllin: RX validation failed.\n");
678 sllin_report_error(sl, LIN_ERR_CHECKSUM);
680 /* Send CAN non-RTR frame with data */
681 netdev_dbg(sl->dev, "sllin: sending NON-RTR CAN frame with LIN payload.");
682 sll_bump(sl); /* send packet to the network layer */
684 /* Prepare for reception of new header */
686 sl->rx_expect = SLLIN_BUFF_ID + 1;
687 sl->rx_len_unknown = false; /* We do know exact length of the header */
688 sl->header_received = false;
691 static void sllin_slave_receive_buf(struct tty_struct *tty,
692 const unsigned char *cp, char *fp, int count)
694 struct sllin *sl = (struct sllin *) tty->disc_data;
696 struct sllin_conf_entry *sce;
699 /* Read the characters out of the buffer */
703 * If we don't know the length of the current message
704 * we received the break of the next message.
705 * Evaluate the previous one before continuing
707 if (sl->rx_len_unknown == true)
709 hrtimer_cancel(&sl->rx_timer);
710 sllin_slave_finish_rx_msg(sl);
712 set_bit(SLF_RXEVENT, &sl->flags);
713 wake_up(&sl->kwt_wq);
716 netdev_dbg(sl->dev, "sllin_slave_receive_buf char 0x%02x ignored "
717 "due marker 0x%02x, flags 0x%lx\n",
718 *cp, *(fp-1), sl->flags);
722 sl->rx_expect = SLLIN_BUFF_ID + 1;
723 sl->rx_len_unknown = false; /* We do know exact length of the header */
724 sl->header_received = false;
727 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
728 netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
730 /* We did not receive break (0x00) character */
731 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
732 sl->rx_buff[sl->rx_cnt++] = 0x00;
735 if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
736 /* 'Duplicated' break character -- ignore */
742 /* Wrong sync character */
747 sl->rx_buff[sl->rx_cnt++] = *cp++;
750 /* Header received */
751 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
754 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
755 sce = &sl->linfr_cache[lin_id];
757 spin_lock_irqsave(&sl->linfr_lock, flags);
759 sl->lin_state = SLSTATE_ID_RECEIVED;
760 /* Is the length of data set in frame cache? */
761 if (sce->frame_fl & LIN_CACHE_RESPONSE) {
762 sl->rx_expect += sce->dlc + 1; /* + checksum */
763 sl->rx_len_unknown = false;
764 set_bit(SLF_MSGEVENT, &sl->flags);
765 wake_up(&sl->kwt_wq);
767 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
768 sl->rx_len_unknown = true;
770 spin_unlock_irqrestore(&sl->linfr_lock, flags);
772 sl->header_received = true;
774 hrtimer_start(&sl->rx_timer,
775 ktime_add(ktime_get(), sl->rx_timer_timeout),
781 /* Response received */
782 if ((sl->header_received == true) &&
783 ((sl->rx_cnt >= sl->rx_expect))) {
785 hrtimer_cancel(&sl->rx_timer);
786 netdev_dbg(sl->dev, "Received LIN header & LIN response. "
787 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
789 sllin_slave_finish_rx_msg(sl);
791 set_bit(SLF_RXEVENT, &sl->flags);
792 wake_up(&sl->kwt_wq);
797 static void sllin_receive_buf(struct tty_struct *tty,
798 const unsigned char *cp, char *fp, int count)
800 struct sllin *sl = (struct sllin *) tty->disc_data;
801 netdev_dbg(sl->dev, "sllin_receive_buf invoked, count = %u\n", count);
803 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
807 sllin_master_receive_buf(tty, cp, fp, count);
809 sllin_slave_receive_buf(tty, cp, fp, count);
813 static int sllin_send_tx_buff(struct sllin *sl)
815 struct tty_struct *tty = sl->tty;
819 set_bit(SLF_TXBUFF_RQ, &sl->flags);
821 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
822 return 0; /* ongoing concurrent processing */
824 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
825 smp_mb__after_clear_bit();
828 if (sl->lin_state != SLSTATE_BREAK_SENT)
829 remains = sl->tx_lim - sl->tx_cnt;
833 remains = sl->tx_lim - sl->tx_cnt;
836 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
844 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
845 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
847 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
855 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
856 sl->tx_cnt, remains);
858 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
859 smp_mb__after_clear_bit();
861 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
866 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
872 static int sllin_send_break(struct sllin *sl)
874 struct tty_struct *tty = sl->tty;
875 unsigned long break_baud;
878 break_baud = ((sl->lin_baud * 2) / 3);
879 sltty_change_speed(tty, break_baud);
881 tty->ops->flush_buffer(tty);
882 sl->rx_cnt = SLLIN_BUFF_BREAK;
884 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
885 sl->lin_state = SLSTATE_BREAK_SENT;
887 res = sllin_send_tx_buff(sl);
889 sl->lin_state = SLSTATE_IDLE;
895 #else /* BREAK_BY_BAUD */
897 static int sllin_send_break(struct sllin *sl)
899 struct tty_struct *tty = sl->tty;
901 unsigned long break_baud;
902 unsigned long usleep_range_min;
903 unsigned long usleep_range_max;
905 break_baud = ((sl->lin_baud * 2) / 3);
906 sl->rx_cnt = SLLIN_BUFF_BREAK;
907 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
908 sl->lin_state = SLSTATE_BREAK_SENT;
910 /* Do the break ourselves; Inspired by
911 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
912 retval = tty->ops->break_ctl(tty, -1);
917 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
918 usleep_range_max = usleep_range_min + 50;
919 usleep_range(usleep_range_min, usleep_range_max);
921 retval = tty->ops->break_ctl(tty, 0);
922 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
923 usleep_range_max = usleep_range_min + 30;
924 usleep_range(usleep_range_min, usleep_range_max);
926 tty->ops->flush_buffer(tty);
928 sl->tx_cnt = SLLIN_BUFF_SYNC;
930 netdev_dbg(sl->dev, "Break sent.\n");
931 set_bit(SLF_RXEVENT, &sl->flags);
932 wake_up(&sl->kwt_wq);
936 #endif /* BREAK_BY_BAUD */
939 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
941 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
943 if (sl->lin_master) {
944 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
945 set_bit(SLF_TMOUTEVENT, &sl->flags);
947 sllin_slave_finish_rx_msg(sl);
948 set_bit(SLF_RXEVENT, &sl->flags);
950 wake_up(&sl->kwt_wq);
952 return HRTIMER_NORESTART;
955 /*****************************************
956 * sllin_kwthread - kernel worker thread
957 *****************************************/
959 static int sllin_kwthread(void *ptr)
961 struct sllin *sl = (struct sllin *)ptr;
962 struct tty_struct *tty = sl->tty;
963 struct sched_param schparam = { .sched_priority = 40 };
964 int tx_bytes = 0; /* Used for Network statistics */
967 struct sllin_conf_entry *sce;
969 netdev_dbg(sl->dev, "sllin_kwthread started.\n");
970 sched_setscheduler(current, SCHED_FIFO, &schparam);
972 clear_bit(SLF_ERROR, &sl->flags);
973 sltty_change_speed(tty, sl->lin_baud);
975 while (!kthread_should_stop()) {
976 struct can_frame *cf;
979 u8 lin_data_buff[SLLIN_DATA_MAX];
982 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
984 if (sllin_send_break(sl) < 0) {
985 /* error processing */
989 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
990 test_bit(SLF_RXEVENT, &sl->flags) ||
991 test_bit(SLF_TXEVENT, &sl->flags) ||
992 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
993 test_bit(SLF_ERROR, &sl->flags) ||
994 (((sl->lin_state == SLSTATE_IDLE) ||
995 (sl->lin_state == SLSTATE_RESPONSE_WAIT) ||
996 (sl->lin_state == SLSTATE_ID_RECEIVED))
997 && test_bit(SLF_MSGEVENT, &sl->flags)));
999 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1000 netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1003 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1004 unsigned long usleep_range_min;
1005 unsigned long usleep_range_max;
1006 hrtimer_cancel(&sl->rx_timer);
1007 netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1009 if (sl->lin_state != SLSTATE_IDLE)
1010 sllin_report_error(sl, LIN_ERR_FRAMING);
1012 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1014 usleep_range_max = usleep_range_min + 50;
1015 usleep_range(usleep_range_min, usleep_range_max);
1016 sllin_reset_buffs(sl);
1017 sl->lin_state = SLSTATE_IDLE;
1020 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1021 netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1024 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1025 netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1026 sllin_reset_buffs(sl);
1028 sl->lin_state = SLSTATE_IDLE;
1031 switch (sl->lin_state) {
1033 if (!test_bit(SLF_MSGEVENT, &sl->flags))
1036 cf = (struct can_frame *)sl->tx_req_skb->data;
1038 /* SFF RTR CAN frame -> LIN header */
1039 if (cf->can_id & CAN_RTR_FLAG) {
1040 struct sllin_conf_entry *sce;
1042 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1043 __func__, cf->can_id & LIN_ID_MASK);
1045 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1046 spin_lock_irqsave(&sl->linfr_lock, flags);
1048 /* Is there Slave response in linfr_cache to be sent? */
1049 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1050 && (sce->dlc > 0)) {
1052 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1054 lin_data = sce->data;
1056 if (lin_dlc > SLLIN_DATA_MAX)
1057 lin_dlc = SLLIN_DATA_MAX;
1058 memcpy(lin_data_buff, lin_data, lin_dlc);
1059 lin_data = lin_data_buff;
1064 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1066 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1067 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1068 __func__, (int)cf->can_id & LIN_ID_MASK);
1070 lin_data = cf->data;
1071 lin_dlc = cf->can_dlc;
1072 if (lin_dlc > SLLIN_DATA_MAX)
1073 lin_dlc = SLLIN_DATA_MAX;
1077 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1078 lin_data, lin_dlc) != -1) {
1080 sl->id_to_send = true;
1081 sl->data_to_send = (lin_data != NULL) ? true : false;
1082 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1083 sl->dev->stats.tx_packets++;
1084 sl->dev->stats.tx_bytes += tx_bytes;
1087 clear_bit(SLF_MSGEVENT, &sl->flags);
1088 kfree_skb(sl->tx_req_skb);
1089 netif_wake_queue(sl->dev);
1090 hrtimer_start(&sl->rx_timer,
1091 ktime_add(ktime_get(), sl->rx_timer_timeout),
1095 case SLSTATE_BREAK_SENT:
1096 #ifdef BREAK_BY_BAUD
1097 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1100 res = sltty_change_speed(tty, sl->lin_baud);
1103 sl->lin_state = SLSTATE_ID_SENT;
1104 sllin_send_tx_buff(sl);
1107 case SLSTATE_ID_SENT:
1108 hrtimer_cancel(&sl->rx_timer);
1109 sl->id_to_send = false;
1110 if (sl->data_to_send) {
1111 sllin_send_tx_buff(sl);
1112 sl->lin_state = SLSTATE_RESPONSE_SENT;
1113 sl->rx_expect = sl->tx_lim;
1114 goto slstate_response_sent;
1116 if (sl->resp_len_known) {
1117 sl->rx_expect = sl->rx_lim;
1119 sl->rx_expect = SLLIN_BUFF_DATA + 2;
1121 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1122 /* If we don't receive anything, timer will "unblock" us */
1123 hrtimer_start(&sl->rx_timer,
1124 ktime_add(ktime_get(), sl->rx_timer_timeout),
1126 goto slstate_response_wait;
1130 case SLSTATE_RESPONSE_WAIT:
1131 slstate_response_wait:
1132 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1133 unsigned char *lin_buff;
1134 cf = (struct can_frame *)sl->tx_req_skb->data;
1136 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1137 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1138 hrtimer_cancel(&sl->rx_timer);
1139 netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1140 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1141 cf->can_id & LIN_ID_MASK,
1142 cf->data, cf->can_dlc) != -1) {
1144 sl->rx_expect = sl->tx_lim;
1145 sl->data_to_send = true;
1146 sl->dev->stats.tx_packets++;
1147 sl->dev->stats.tx_bytes += tx_bytes;
1149 if (!sl->lin_master) {
1150 sl->tx_cnt = SLLIN_BUFF_DATA;
1153 sllin_send_tx_buff(sl);
1154 clear_bit(SLF_MSGEVENT, &sl->flags);
1155 kfree_skb(sl->tx_req_skb);
1156 netif_wake_queue(sl->dev);
1158 sl->lin_state = SLSTATE_RESPONSE_SENT;
1159 goto slstate_response_sent;
1162 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1166 /* Be aware, no BREAK here */
1167 case SLSTATE_RESPONSE_WAIT_BUS:
1168 if (sl->rx_cnt < sl->rx_expect)
1171 hrtimer_cancel(&sl->rx_timer);
1172 netdev_dbg(sl->dev, "response received ID %d len %d\n",
1173 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1175 if (sllin_rx_validate(sl) == -1) {
1176 netdev_dbg(sl->dev, "RX validation failed.\n");
1177 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1179 /* Send CAN non-RTR frame with data */
1180 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1181 sll_bump(sl); /* send packet to the network layer */
1184 sl->id_to_send = false;
1185 sl->lin_state = SLSTATE_IDLE;
1188 case SLSTATE_ID_RECEIVED:
1189 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1190 sce = &sl->linfr_cache[lin_id];
1191 spin_lock_irqsave(&sl->linfr_lock, flags);
1193 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1195 && (test_bit(SLF_MSGEVENT, &sl->flags))) {
1198 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1200 lin_data = sce->data;
1202 if (lin_dlc > SLLIN_DATA_MAX)
1203 lin_dlc = SLLIN_DATA_MAX;
1204 memcpy(lin_data_buff, lin_data, lin_dlc);
1205 lin_data = lin_data_buff;
1208 mode = SLLIN_STPMSG_RESPONLY;
1209 if (sl->rx_buff[SLLIN_BUFF_ID] & LIN_CHECKSUM_EXTENDED)
1210 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1212 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1213 lin_data, lin_dlc) != -1) {
1215 sl->rx_expect = sl->tx_lim;
1216 sl->data_to_send = true;
1217 sl->dev->stats.tx_packets++;
1218 sl->dev->stats.tx_bytes += tx_bytes;
1219 sl->resp_len_known = true;
1221 if (!sl->lin_master) {
1222 sl->tx_cnt = SLLIN_BUFF_DATA;
1224 sllin_send_tx_buff(sl);
1227 clear_bit(SLF_MSGEVENT, &sl->flags);
1228 kfree_skb(sl->tx_req_skb);
1229 netif_wake_queue(sl->dev);
1230 hrtimer_start(&sl->rx_timer,
1231 ktime_add(ktime_get(), sl->rx_timer_timeout),
1234 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1235 sl->lin_state = SLSTATE_IDLE;
1238 case SLSTATE_RESPONSE_SENT:
1239 slstate_response_sent:
1240 if (sl->rx_cnt < sl->tx_lim)
1243 hrtimer_cancel(&sl->rx_timer);
1244 sll_bump(sl); /* send packet to the network layer */
1245 netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1246 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1248 sl->id_to_send = false;
1249 sl->lin_state = SLSTATE_IDLE;
1254 hrtimer_cancel(&sl->rx_timer);
1255 netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1261 /************************************
1262 * sllin_open helper routines.
1263 ************************************/
1265 /* Collect hanged up channels */
1266 static void sll_sync(void)
1269 struct net_device *dev;
1272 for (i = 0; i < maxdev; i++) {
1273 dev = sllin_devs[i];
1277 sl = netdev_priv(dev);
1280 if (dev->flags & IFF_UP)
1285 /* Find a free SLLIN channel, and link in this `tty' line. */
1286 static struct sllin *sll_alloc(dev_t line)
1289 struct net_device *dev = NULL;
1292 if (sllin_devs == NULL)
1293 return NULL; /* Master array missing ! */
1295 for (i = 0; i < maxdev; i++) {
1296 dev = sllin_devs[i];
1302 /* Sorry, too many, all slots in use */
1307 sl = netdev_priv(dev);
1308 if (test_bit(SLF_INUSE, &sl->flags)) {
1309 unregister_netdevice(dev);
1311 sllin_devs[i] = NULL;
1316 char name[IFNAMSIZ];
1317 sprintf(name, "sllin%d", i);
1319 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1325 sl = netdev_priv(dev);
1326 /* Initialize channel control data */
1327 sl->magic = SLLIN_MAGIC;
1329 spin_lock_init(&sl->lock);
1330 spin_lock_init(&sl->linfr_lock);
1331 sllin_devs[i] = dev;
1337 * Open the high-level part of the SLLIN channel.
1338 * This function is called by the TTY module when the
1339 * SLLIN line discipline is called for. Because we are
1340 * sure the tty line exists, we only have to link it to
1341 * a free SLLIN channel...
1343 * Called in process context serialized from other ldisc calls.
1346 static int sllin_open(struct tty_struct *tty)
1351 pr_debug("sllin: %s() invoked\n", __func__);
1353 if (!capable(CAP_NET_ADMIN))
1356 if (tty->ops->write == NULL)
1359 /* RTnetlink lock is misused here to serialize concurrent
1360 opens of sllin channels. There are better ways, but it is
1365 /* Collect hanged up channels. */
1368 sl = tty->disc_data;
1371 /* First make sure we're not already connected. */
1372 if (sl && sl->magic == SLLIN_MAGIC)
1375 /* OK. Find a free SLLIN channel to use. */
1377 sl = sll_alloc(tty_devnum(tty));
1382 tty->disc_data = sl;
1383 sl->line = tty_devnum(tty);
1385 if (!test_bit(SLF_INUSE, &sl->flags)) {
1386 /* Perform the low-level SLLIN initialization. */
1387 sl->lin_master = master;
1389 pr_debug("sllin: Configured as MASTER\n");
1391 pr_debug("sllin: Configured as SLAVE\n");
1393 sllin_reset_buffs(sl);
1395 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1396 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1398 sl->lin_state = SLSTATE_IDLE;
1400 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1401 sl->rx_timer.function = sllin_rx_timeout_handler;
1402 /* timeval_to_ktime(msg_head->ival1); */
1403 sl->rx_timer_timeout = ns_to_ktime(
1404 (1000000000l / sl->lin_baud) *
1405 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1407 set_bit(SLF_INUSE, &sl->flags);
1409 init_waitqueue_head(&sl->kwt_wq);
1410 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1411 if (sl->kwthread == NULL)
1414 err = register_netdevice(sl->dev);
1416 goto err_free_chan_and_thread;
1419 /* Done. We have linked the TTY line to a channel. */
1421 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1423 /* TTY layer expects 0 on success */
1426 err_free_chan_and_thread:
1427 kthread_stop(sl->kwthread);
1428 sl->kwthread = NULL;
1432 tty->disc_data = NULL;
1433 clear_bit(SLF_INUSE, &sl->flags);
1438 /* Count references from TTY module */
1443 * Close down a SLLIN channel.
1444 * This means flushing out any pending queues, and then returning. This
1445 * call is serialized against other ldisc functions.
1447 * We also use this method for a hangup event.
1450 static void sllin_close(struct tty_struct *tty)
1452 struct sllin *sl = (struct sllin *) tty->disc_data;
1454 /* First make sure we're connected. */
1455 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1458 kthread_stop(sl->kwthread);
1459 sl->kwthread = NULL;
1461 tty->disc_data = NULL;
1464 /* Flush network side */
1465 unregister_netdev(sl->dev);
1466 /* This will complete via sl_free_netdev */
1469 static int sllin_hangup(struct tty_struct *tty)
1475 /* Perform I/O control on an active SLLIN channel. */
1476 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1477 unsigned int cmd, unsigned long arg)
1479 struct sllin *sl = (struct sllin *) tty->disc_data;
1482 /* First make sure we're connected. */
1483 if (!sl || sl->magic != SLLIN_MAGIC)
1488 tmp = strlen(sl->dev->name) + 1;
1489 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1497 return tty_mode_ioctl(tty, file, cmd, arg);
1501 static struct tty_ldisc_ops sll_ldisc = {
1502 .owner = THIS_MODULE,
1503 .magic = TTY_LDISC_MAGIC,
1506 .close = sllin_close,
1507 .hangup = sllin_hangup,
1508 .ioctl = sllin_ioctl,
1509 .receive_buf = sllin_receive_buf,
1510 .write_wakeup = sllin_write_wakeup,
1513 static int __init sllin_init(void)
1518 maxdev = 4; /* Sanity */
1521 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1523 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1525 pr_err("sllin: can't allocate sllin device array!\n");
1529 /* Fill in our line protocol discipline, and register it */
1530 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1532 pr_err("sllin: can't register line discipline\n");
1536 #ifdef BREAK_BY_BAUD
1537 pr_debug("sllin: Break is generated by baud-rate change.");
1539 pr_debug("sllin: Break is generated manually with tiny sleep.");
1545 static void __exit sllin_exit(void)
1548 struct net_device *dev;
1550 unsigned long timeout = jiffies + HZ;
1553 if (sllin_devs == NULL)
1556 /* First of all: check for active disciplines and hangup them.
1560 msleep_interruptible(100);
1563 for (i = 0; i < maxdev; i++) {
1564 dev = sllin_devs[i];
1567 sl = netdev_priv(dev);
1568 spin_lock_bh(&sl->lock);
1571 tty_hangup(sl->tty);
1573 spin_unlock_bh(&sl->lock);
1575 } while (busy && time_before(jiffies, timeout));
1577 /* FIXME: hangup is async so we should wait when doing this second
1580 for (i = 0; i < maxdev; i++) {
1581 dev = sllin_devs[i];
1584 sllin_devs[i] = NULL;
1586 sl = netdev_priv(dev);
1588 netdev_dbg(sl->dev, "tty discipline still running\n");
1589 /* Intentionally leak the control block. */
1590 dev->destructor = NULL;
1593 unregister_netdev(dev);
1599 i = tty_unregister_ldisc(N_SLLIN);
1601 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1604 module_init(sllin_init);
1605 module_exit(sllin_exit);