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 <asm/system.h>
50 #include <linux/uaccess.h>
51 #include <linux/bitops.h>
52 #include <linux/string.h>
53 #include <linux/tty.h>
54 #include <linux/errno.h>
55 #include <linux/netdevice.h>
56 #include <linux/skbuff.h>
57 #include <linux/rtnetlink.h>
58 #include <linux/if_arp.h>
59 #include <linux/if_ether.h>
60 #include <linux/sched.h>
61 #include <linux/delay.h>
62 #include <linux/init.h>
63 #include <linux/can.h>
64 #include <linux/kthread.h>
65 #include <linux/hrtimer.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 int 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) */
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 */
163 struct task_struct *kwthread;
164 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
165 struct hrtimer rx_timer; /* RX timeout timer */
166 ktime_t rx_timer_timeout; /* RX timeout timer value */
167 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame
168 received from network stack*/
170 /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
171 struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
174 static struct net_device **sllin_devs;
175 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
178 /* Values of two parity bits in LIN Protected
179 Identifier for each particular LIN ID */
180 const unsigned char sllin_id_parity_table[] = {
181 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
182 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
183 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
184 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
185 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
186 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
187 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
188 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
192 * sltty_change_speed() -- Change baudrate of Serial device belonging
195 * @tty: Pointer to TTY to change speed for.
196 * @speed: Integer value of new speed. It is possible to
197 * assign non-standard values, i.e. those which
198 * are not defined in termbits.h.
200 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
202 struct ktermios old_termios;
205 mutex_lock(&tty->termios_mutex);
207 old_termios = *(tty->termios);
209 cflag = CS8 | CREAD | CLOCAL | HUPCL;
210 cflag &= ~(CBAUD | CIBAUD);
212 tty->termios->c_cflag = cflag;
213 tty->termios->c_oflag = 0;
214 tty->termios->c_lflag = 0;
216 /* Enable interrupt when UART-Break or Framing error received */
217 tty->termios->c_iflag = BRKINT | INPCK;
219 tty_encode_baud_rate(tty, speed, speed);
221 if (tty->ops->set_termios)
222 tty->ops->set_termios(tty, &old_termios);
224 mutex_unlock(&tty->termios_mutex);
229 /* Send one can_frame to the network layer */
230 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
237 if (cf.can_dlc > 0) {
238 memcpy(&cf.data, data, cf.can_dlc);
241 skb = dev_alloc_skb(sizeof(struct can_frame));
246 skb->protocol = htons(ETH_P_CAN);
247 skb->pkt_type = PACKET_BROADCAST;
248 skb->ip_summed = CHECKSUM_UNNECESSARY;
249 memcpy(skb_put(skb, sizeof(struct can_frame)),
250 &cf, sizeof(struct can_frame));
253 sl->dev->stats.rx_packets++;
254 sl->dev->stats.rx_bytes += cf.can_dlc;
258 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
263 static void sll_bump(struct sllin *sl)
265 int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
266 len = (len < 0) ? 0 : len;
268 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
269 sl->rx_buff + SLLIN_BUFF_DATA, len);
272 static void sll_send_rtr(struct sllin *sl)
274 sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
275 CAN_RTR_FLAG, NULL, 0);
279 * Called by the driver when there's room for more data. If we have
280 * more packets to send, we send them here.
282 static void sllin_write_wakeup(struct tty_struct *tty)
286 struct sllin *sl = (struct sllin *) tty->disc_data;
288 /* First make sure we're connected. */
289 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
292 if (sl->lin_state != SLSTATE_BREAK_SENT)
293 remains = sl->tx_lim - sl->tx_cnt;
295 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
298 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
299 sl->tx_cnt - sl->tx_lim);
300 sl->tx_cnt += actual;
302 if (sl->tx_cnt < sl->tx_lim) {
303 pr_debug("sllin: sllin_write_wakeup sent %d, "
304 "remains %d, waiting\n",
305 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
310 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
311 set_bit(SLF_TXEVENT, &sl->flags);
312 wake_up(&sl->kwt_wq);
314 pr_debug("sllin: sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
318 * sll_xmit() -- Send a can_frame to a TTY queue.
320 * @skb: Pointer to Socket buffer to be sent.
321 * @dev: Network device where @skb will be sent.
323 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
325 struct sllin *sl = netdev_priv(dev);
326 struct can_frame *cf;
328 if (skb->len != sizeof(struct can_frame))
331 spin_lock(&sl->lock);
332 if (!netif_running(dev)) {
333 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
336 if (sl->tty == NULL) {
340 cf = (struct can_frame *) skb->data;
341 if (cf->can_id & LIN_CTRL_FRAME) {
342 sllin_configure_frame_cache(sl, cf);
343 goto free_out_unlock;
346 netif_stop_queue(sl->dev);
348 sl->tx_req_skb = skb;
349 set_bit(SLF_MSGEVENT, &sl->flags);
350 wake_up(&sl->kwt_wq);
351 spin_unlock(&sl->lock);
356 spin_unlock(&sl->lock);
363 /******************************************
364 * Routines looking at netdevice side.
365 ******************************************/
367 /* Netdevice UP -> DOWN routine */
368 static int sll_close(struct net_device *dev)
370 struct sllin *sl = netdev_priv(dev);
372 spin_lock_bh(&sl->lock);
374 /* TTY discipline is running. */
375 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
377 netif_stop_queue(dev);
380 spin_unlock_bh(&sl->lock);
385 /* Netdevice DOWN -> UP routine */
386 static int sll_open(struct net_device *dev)
388 struct sllin *sl = netdev_priv(dev);
390 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
395 sl->flags &= (1 << SLF_INUSE);
396 netif_start_queue(dev);
400 /* Hook the destructor so we can free sllin devs at the right point in time */
401 static void sll_free_netdev(struct net_device *dev)
403 int i = dev->base_addr;
405 sllin_devs[i] = NULL;
408 static const struct net_device_ops sll_netdev_ops = {
409 .ndo_open = sll_open,
410 .ndo_stop = sll_close,
411 .ndo_start_xmit = sll_xmit,
414 static void sll_setup(struct net_device *dev)
416 dev->netdev_ops = &sll_netdev_ops;
417 dev->destructor = sll_free_netdev;
419 dev->hard_header_len = 0;
421 dev->tx_queue_len = 10;
423 dev->mtu = sizeof(struct can_frame);
424 dev->type = ARPHRD_CAN;
426 /* New-style flags. */
427 dev->flags = IFF_NOARP;
428 dev->features = NETIF_F_NO_CSUM;
431 /******************************************
432 Routines looking at TTY side.
433 ******************************************/
434 #define SLL_RESPONSE_RECEIVED ((sl->header_received == true) && \
435 ((sl->rx_cnt >= sl->rx_expect) || \
436 ((sl->rx_len_unknown == true) && (count == 0))))
438 #define SLL_HEADER_RECEIVED ((sl->header_received == false) && \
439 (sl->rx_cnt >= (SLLIN_BUFF_ID + 1)))
441 static void sllin_receive_buf(struct tty_struct *tty,
442 const unsigned char *cp, char *fp, int count)
444 struct sllin *sl = (struct sllin *) tty->disc_data;
445 pr_debug("sllin: sllin_receive_buf invoked, count = %u\n", count);
447 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
450 /* Read the characters out of the buffer */
453 pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
454 "due marker 0x%02x, flags 0x%lx\n",
455 *cp, *(fp-1), sl->flags);
457 if (sl->lin_master == true) { /* Report error */
458 set_bit(SLF_ERROR, &sl->flags);
459 wake_up(&sl->kwt_wq);
461 } else { /* Received Break */
463 sl->rx_expect = SLLIN_BUFF_ID + 1;
464 sl->rx_len_unknown = false; /* We do know exact length of the header */
465 sl->header_received = false;
469 #ifndef BREAK_BY_BAUD
470 /* We didn't receive Break character -- fake it! */
471 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
472 pr_debug("sllin: LIN_RX[%d]: 0x00\n", sl->rx_cnt);
473 sl->rx_buff[sl->rx_cnt++] = 0x00;
476 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
477 pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
478 sl->rx_buff[sl->rx_cnt++] = *cp++;
481 if (sl->lin_master == true) {
482 if (SLL_RESPONSE_RECEIVED) {
483 set_bit(SLF_RXEVENT, &sl->flags);
484 wake_up(&sl->kwt_wq);
485 pr_debug("sllin: sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
487 pr_debug("sllin: sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
489 } else { /* LIN slave */
491 struct sllin_conf_entry *sce;
493 pr_debug("sllin: rx_cnt = %u; header_received = %u\n",
494 sl->rx_cnt, sl->header_received);
496 if (SLL_HEADER_RECEIVED) {
497 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
498 sce = &sl->linfr_cache[lin_id];
500 /* Is the length of data set in frame cache? */
501 if (sce->frame_fl & LIN_LOC_SLAVE_CACHE) {
502 sl->rx_expect += sce->dlc;
503 sl->rx_len_unknown = false;
505 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
506 sl->rx_len_unknown = true;
509 sl->header_received = true;
514 if (SLL_RESPONSE_RECEIVED) {
516 pr_debug("sllin: Received LIN header & LIN response. "
517 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
520 /* Prepare for reception of new header */
522 sl->rx_expect = SLLIN_BUFF_ID + 1;
523 sl->rx_len_unknown = false; /* We do know exact length of the header */
524 sl->header_received = false;
530 /*****************************************
531 * sllin message helper routines
532 *****************************************/
534 * sllin_report_error() -- Report an error by sending CAN frame
535 * with particular error flag set in can_id
538 * @err: Error flag to be sent.
540 void sllin_report_error(struct sllin *sl, int err)
543 case LIN_ERR_CHECKSUM:
544 sl->dev->stats.rx_crc_errors++;
547 case LIN_ERR_RX_TIMEOUT:
548 sl->dev->stats.rx_errors++;
551 case LIN_ERR_FRAMING:
552 sl->dev->stats.rx_frame_errors++;
556 sllin_send_canfr(sl, 0 | 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)
569 struct sllin_conf_entry *sce;
570 if (!(cf->can_id & LIN_ID_CONF))
573 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
574 pr_debug("sllin: Setting frame cache with EFF CAN frame. "
575 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
577 sce->dlc = cf->can_dlc;
578 if (sce->dlc > SLLIN_DATA_MAX)
579 sce->dlc = SLLIN_DATA_MAX;
581 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
582 memcpy(sce->data, cf->data, cf->can_dlc);
588 * sllin_checksum() -- Count checksum for particular data
590 * @data: Pointer to the buffer containing whole LIN
591 * frame (i.e. including break and sync bytes).
592 * @length: Length of the buffer.
593 * @enhanced_fl: Flag determining whether Enhanced or Classic
594 * checksum should be counted.
596 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
607 for (; i < length; i++) {
616 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
617 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
618 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
620 int sllin_setup_msg(struct sllin *sl, int mode, int id,
621 unsigned char *data, int len)
623 if (id > LIN_ID_MASK)
626 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
630 sl->rx_lim = SLLIN_BUFF_LEN;
633 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
634 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
635 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
636 sl->tx_lim = SLLIN_BUFF_DATA;
638 if ((data != NULL) && len) {
640 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
641 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
642 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
645 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
650 static void sllin_reset_buffs(struct sllin *sl)
654 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
657 sl->id_to_send = false;
658 sl->data_to_send = false;
661 int sllin_send_tx_buff(struct sllin *sl)
663 struct tty_struct *tty = sl->tty;
668 if (sl->lin_state != SLSTATE_BREAK_SENT)
669 remains = sl->tx_lim - sl->tx_cnt;
673 remains = sl->tx_lim - sl->tx_cnt;
676 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
684 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
685 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
687 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
695 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
696 sl->tx_cnt, remains);
702 int sllin_send_break(struct sllin *sl)
704 struct tty_struct *tty = sl->tty;
705 unsigned long break_baud;
708 break_baud = ((sl->lin_baud * 2) / 3);
709 sltty_change_speed(tty, break_baud);
711 tty->ops->flush_buffer(tty);
712 sl->rx_cnt = SLLIN_BUFF_BREAK;
714 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
715 sl->lin_state = SLSTATE_BREAK_SENT;
717 res = sllin_send_tx_buff(sl);
719 sl->lin_state = SLSTATE_IDLE;
725 #else /* BREAK_BY_BAUD */
727 int sllin_send_break(struct sllin *sl)
729 struct tty_struct *tty = sl->tty;
731 unsigned long break_baud;
732 unsigned long usleep_range_min;
733 unsigned long usleep_range_max;
735 break_baud = ((sl->lin_baud * 2) / 3);
736 sl->rx_cnt = SLLIN_BUFF_BREAK;
737 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
738 sl->lin_state = SLSTATE_BREAK_SENT;
740 /* Do the break ourselves; Inspired by
741 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
742 retval = tty->ops->break_ctl(tty, -1);
747 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
748 usleep_range_max = usleep_range_min + 50;
749 usleep_range(usleep_range_min, usleep_range_max);
751 retval = tty->ops->break_ctl(tty, 0);
752 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
753 usleep_range_max = usleep_range_min + 30;
754 usleep_range(usleep_range_min, usleep_range_max);
756 tty->ops->flush_buffer(tty);
758 sl->tx_cnt = SLLIN_BUFF_SYNC;
760 pr_debug("sllin: Break sent.\n");
761 set_bit(SLF_RXEVENT, &sl->flags);
762 wake_up(&sl->kwt_wq);
766 #endif /* BREAK_BY_BAUD */
769 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
771 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
773 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
774 set_bit(SLF_TMOUTEVENT, &sl->flags);
775 wake_up(&sl->kwt_wq);
777 return HRTIMER_NORESTART;
781 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
785 static int sllin_rx_validate(struct sllin *sl)
790 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
791 struct sllin_conf_entry *scf;
793 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
794 scf = &sl->linfr_cache[actual_id];
796 ext_chcks_fl = scf->frame_fl & LIN_CHECKSUM_EXTENDED;
798 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
801 /* Type of checksum is configured for particular frame */
805 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
806 !ext_chcks_fl) != rec_chcksm) {
815 /*****************************************
816 * sllin_kwthread - kernel worker thread
817 *****************************************/
819 int sllin_kwthread(void *ptr)
821 struct sllin *sl = (struct sllin *)ptr;
822 struct tty_struct *tty = sl->tty;
823 struct sched_param schparam = { .sched_priority = 40 };
824 int tx_bytes = 0; /* Used for Network statistics */
827 pr_debug("sllin: sllin_kwthread started.\n");
828 sched_setscheduler(current, SCHED_FIFO, &schparam);
830 clear_bit(SLF_ERROR, &sl->flags);
831 sltty_change_speed(tty, sl->lin_baud);
833 while (!kthread_should_stop()) {
834 struct can_frame *cf;
837 u8 lin_data_buff[SLLIN_DATA_MAX];
840 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
842 if (sllin_send_break(sl) < 0) {
843 /* error processing */
847 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
848 test_bit(SLF_RXEVENT, &sl->flags) ||
849 test_bit(SLF_TXEVENT, &sl->flags) ||
850 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
851 test_bit(SLF_ERROR, &sl->flags) ||
852 (((sl->lin_state == SLSTATE_IDLE) ||
853 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
854 && test_bit(SLF_MSGEVENT, &sl->flags)));
856 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
857 pr_debug("sllin: sllin_kthread RXEVENT\n");
860 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
861 unsigned long usleep_range_min;
862 unsigned long usleep_range_max;
863 hrtimer_cancel(&sl->rx_timer);
864 pr_debug("sllin: sllin_kthread ERROR\n");
866 if (sl->lin_state != SLSTATE_IDLE)
867 sllin_report_error(sl, LIN_ERR_FRAMING);
869 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
871 usleep_range_max = usleep_range_min + 50;
872 usleep_range(usleep_range_min, usleep_range_max);
873 sllin_reset_buffs(sl);
874 sl->lin_state = SLSTATE_IDLE;
877 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
878 pr_debug("sllin: sllin_kthread TXEVENT\n");
881 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
882 pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
883 sllin_reset_buffs(sl);
885 sl->lin_state = SLSTATE_IDLE;
888 switch (sl->lin_state) {
890 if (!test_bit(SLF_MSGEVENT, &sl->flags))
893 cf = (struct can_frame *)sl->tx_req_skb->data;
895 /* SFF RTR CAN frame -> LIN header */
896 if (cf->can_id & CAN_RTR_FLAG) {
897 spin_lock(&sl->lock);
898 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
899 __FUNCTION__, cf->can_id & LIN_ID_MASK);
901 /* Is there Slave response in linfr_cache to be sent? */
902 if ((sl->linfr_cache[cf->can_id & LIN_ID_MASK].frame_fl &
904 && (sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc > 0)) {
906 pr_debug("sllin: Sending LIN response from linfr_cache\n");
907 lin_data = sl->linfr_cache[cf->can_id & LIN_ID_MASK].data;
908 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
909 if (lin_dlc > SLLIN_DATA_MAX)
910 lin_dlc = SLLIN_DATA_MAX;
911 memcpy(lin_data_buff, lin_data, lin_dlc);
912 lin_data = lin_data_buff;
915 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
917 spin_unlock(&sl->lock);
918 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
919 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
920 __FUNCTION__, (int)cf->can_id & LIN_ID_MASK);
923 lin_dlc = cf->can_dlc;
924 if (lin_dlc > SLLIN_DATA_MAX)
925 lin_dlc = SLLIN_DATA_MAX;
929 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
930 lin_data, lin_dlc) != -1) {
932 sl->id_to_send = true;
933 sl->data_to_send = (lin_data != NULL) ? true : false;
934 sl->resp_len_known = (lin_dlc > 0) ? true : false;
935 sl->dev->stats.tx_packets++;
936 sl->dev->stats.tx_bytes += tx_bytes;
939 clear_bit(SLF_MSGEVENT, &sl->flags);
940 kfree_skb(sl->tx_req_skb);
941 netif_wake_queue(sl->dev);
942 hrtimer_start(&sl->rx_timer,
943 ktime_add(ktime_get(), sl->rx_timer_timeout),
947 case SLSTATE_BREAK_SENT:
949 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
952 res = sltty_change_speed(tty, sl->lin_baud);
955 sl->lin_state = SLSTATE_ID_SENT;
956 sllin_send_tx_buff(sl);
959 case SLSTATE_ID_SENT:
960 hrtimer_cancel(&sl->rx_timer);
961 sl->id_to_send = false;
962 if (sl->data_to_send) {
963 sllin_send_tx_buff(sl);
964 sl->lin_state = SLSTATE_RESPONSE_SENT;
965 sl->rx_expect = sl->tx_lim;
966 goto slstate_response_sent;
968 if (sl->resp_len_known) {
969 sl->rx_expect = sl->rx_lim;
971 sl->rx_expect = SLLIN_BUFF_DATA + 2;
973 sl->lin_state = SLSTATE_RESPONSE_WAIT;
974 /* If we don't receive anything, timer will "unblock" us */
975 hrtimer_start(&sl->rx_timer,
976 ktime_add(ktime_get(), sl->rx_timer_timeout),
978 goto slstate_response_wait;
982 case SLSTATE_RESPONSE_WAIT:
983 slstate_response_wait:
984 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
985 unsigned char *lin_buff;
986 cf = (struct can_frame *)sl->tx_req_skb->data;
988 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
989 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
990 hrtimer_cancel(&sl->rx_timer);
991 pr_debug("sllin: received LIN response in a CAN frame.\n");
992 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
993 cf->can_id & LIN_ID_MASK,
994 cf->data, cf->can_dlc) != -1) {
996 sl->rx_expect = sl->tx_lim;
997 sl->data_to_send = true;
998 sl->dev->stats.tx_packets++;
999 sl->dev->stats.tx_bytes += tx_bytes;
1001 if (!sl->lin_master) {
1002 sl->tx_cnt = SLLIN_BUFF_DATA;
1005 sllin_send_tx_buff(sl);
1006 clear_bit(SLF_MSGEVENT, &sl->flags);
1007 kfree_skb(sl->tx_req_skb);
1008 netif_wake_queue(sl->dev);
1010 sl->lin_state = SLSTATE_RESPONSE_SENT;
1011 goto slstate_response_sent;
1014 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1018 /* Be aware, no BREAK here */
1019 case SLSTATE_RESPONSE_WAIT_BUS:
1020 if (sl->rx_cnt < sl->rx_expect)
1023 hrtimer_cancel(&sl->rx_timer);
1024 pr_debug("sllin: response received ID %d len %d\n",
1025 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1027 if (sllin_rx_validate(sl) == -1) {
1028 pr_debug("sllin: RX validation failed.\n");
1029 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1031 /* Send CAN non-RTR frame with data */
1032 pr_debug("sllin: sending NON-RTR CAN"
1033 "frame with LIN payload.");
1034 sll_bump(sl); /* send packet to the network layer */
1037 sl->id_to_send = false;
1038 sl->lin_state = SLSTATE_IDLE;
1041 case SLSTATE_RESPONSE_SENT:
1042 slstate_response_sent:
1043 if (sl->rx_cnt < sl->tx_lim)
1046 hrtimer_cancel(&sl->rx_timer);
1047 sll_bump(sl); /* send packet to the network layer */
1048 pr_debug("sllin: response sent ID %d len %d\n",
1049 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1051 sl->id_to_send = false;
1052 sl->lin_state = SLSTATE_IDLE;
1057 hrtimer_cancel(&sl->rx_timer);
1058 pr_debug("sllin: sllin_kwthread stopped.\n");
1064 /************************************
1065 * sllin_open helper routines.
1066 ************************************/
1068 /* Collect hanged up channels */
1069 static void sll_sync(void)
1072 struct net_device *dev;
1075 for (i = 0; i < maxdev; i++) {
1076 dev = sllin_devs[i];
1080 sl = netdev_priv(dev);
1083 if (dev->flags & IFF_UP)
1088 /* Find a free SLLIN channel, and link in this `tty' line. */
1089 static struct sllin *sll_alloc(dev_t line)
1092 struct net_device *dev = NULL;
1095 if (sllin_devs == NULL)
1096 return NULL; /* Master array missing ! */
1098 for (i = 0; i < maxdev; i++) {
1099 dev = sllin_devs[i];
1105 /* Sorry, too many, all slots in use */
1110 sl = netdev_priv(dev);
1111 if (test_bit(SLF_INUSE, &sl->flags)) {
1112 unregister_netdevice(dev);
1114 sllin_devs[i] = NULL;
1119 char name[IFNAMSIZ];
1120 sprintf(name, "sllin%d", i);
1122 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1128 sl = netdev_priv(dev);
1129 /* Initialize channel control data */
1130 sl->magic = SLLIN_MAGIC;
1132 spin_lock_init(&sl->lock);
1133 sllin_devs[i] = dev;
1139 * Open the high-level part of the SLLIN channel.
1140 * This function is called by the TTY module when the
1141 * SLLIN line discipline is called for. Because we are
1142 * sure the tty line exists, we only have to link it to
1143 * a free SLLIN channel...
1145 * Called in process context serialized from other ldisc calls.
1148 static int sllin_open(struct tty_struct *tty)
1152 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1154 if (!capable(CAP_NET_ADMIN))
1157 if (tty->ops->write == NULL)
1160 /* RTnetlink lock is misused here to serialize concurrent
1161 opens of sllin channels. There are better ways, but it is
1166 /* Collect hanged up channels. */
1169 sl = tty->disc_data;
1172 /* First make sure we're not already connected. */
1173 if (sl && sl->magic == SLLIN_MAGIC)
1176 /* OK. Find a free SLLIN channel to use. */
1178 sl = sll_alloc(tty_devnum(tty));
1183 tty->disc_data = sl;
1184 sl->line = tty_devnum(tty);
1186 if (!test_bit(SLF_INUSE, &sl->flags)) {
1187 /* Perform the low-level SLLIN initialization. */
1188 sl->lin_master = master;
1191 pr_debug("sllin: Configured as MASTER\n");
1193 pr_debug("sllin: Configured as SLAVE\n");
1196 sllin_reset_buffs(sl);
1198 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1199 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1201 sl->lin_state = SLSTATE_IDLE;
1203 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1204 sl->rx_timer.function = sllin_rx_timeout_handler;
1205 /* timeval_to_ktime(msg_head->ival1); */
1206 sl->rx_timer_timeout = ns_to_ktime(
1207 (1000000000l / sl->lin_baud) *
1208 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1210 set_bit(SLF_INUSE, &sl->flags);
1212 init_waitqueue_head(&sl->kwt_wq);
1213 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1214 if (sl->kwthread == NULL)
1217 err = register_netdevice(sl->dev);
1219 goto err_free_chan_and_thread;
1222 /* Done. We have linked the TTY line to a channel. */
1224 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1226 /* TTY layer expects 0 on success */
1229 err_free_chan_and_thread:
1230 kthread_stop(sl->kwthread);
1231 sl->kwthread = NULL;
1235 tty->disc_data = NULL;
1236 clear_bit(SLF_INUSE, &sl->flags);
1241 /* Count references from TTY module */
1246 * Close down a SLLIN channel.
1247 * This means flushing out any pending queues, and then returning. This
1248 * call is serialized against other ldisc functions.
1250 * We also use this method for a hangup event.
1253 static void sllin_close(struct tty_struct *tty)
1255 struct sllin *sl = (struct sllin *) tty->disc_data;
1257 /* First make sure we're connected. */
1258 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1261 kthread_stop(sl->kwthread);
1262 sl->kwthread = NULL;
1264 tty->disc_data = NULL;
1267 /* Flush network side */
1268 unregister_netdev(sl->dev);
1269 /* This will complete via sl_free_netdev */
1272 static int sllin_hangup(struct tty_struct *tty)
1278 /* Perform I/O control on an active SLLIN channel. */
1279 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1280 unsigned int cmd, unsigned long arg)
1282 struct sllin *sl = (struct sllin *) tty->disc_data;
1285 /* First make sure we're connected. */
1286 if (!sl || sl->magic != SLLIN_MAGIC)
1291 tmp = strlen(sl->dev->name) + 1;
1292 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1300 return tty_mode_ioctl(tty, file, cmd, arg);
1304 static struct tty_ldisc_ops sll_ldisc = {
1305 .owner = THIS_MODULE,
1306 .magic = TTY_LDISC_MAGIC,
1309 .close = sllin_close,
1310 .hangup = sllin_hangup,
1311 .ioctl = sllin_ioctl,
1312 .receive_buf = sllin_receive_buf,
1313 .write_wakeup = sllin_write_wakeup,
1316 static int __init sllin_init(void)
1321 maxdev = 4; /* Sanity */
1324 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1326 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1328 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1332 /* Fill in our line protocol discipline, and register it */
1333 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1335 printk(KERN_ERR "sllin: can't register line discipline\n");
1339 #ifdef BREAK_BY_BAUD
1340 pr_debug("sllin: Break is generated by baud-rate change.");
1342 pr_debug("sllin: Break is generated manually with tiny sleep.");
1348 static void __exit sllin_exit(void)
1351 struct net_device *dev;
1353 unsigned long timeout = jiffies + HZ;
1356 if (sllin_devs == NULL)
1359 /* First of all: check for active disciplines and hangup them.
1363 msleep_interruptible(100);
1366 for (i = 0; i < maxdev; i++) {
1367 dev = sllin_devs[i];
1370 sl = netdev_priv(dev);
1371 spin_lock_bh(&sl->lock);
1374 tty_hangup(sl->tty);
1376 spin_unlock_bh(&sl->lock);
1378 } while (busy && time_before(jiffies, timeout));
1380 /* FIXME: hangup is async so we should wait when doing this second
1383 for (i = 0; i < maxdev; i++) {
1384 dev = sllin_devs[i];
1387 sllin_devs[i] = NULL;
1389 sl = netdev_priv(dev);
1391 printk(KERN_ERR "%s: tty discipline still running\n",
1393 /* Intentionally leak the control block. */
1394 dev->destructor = NULL;
1397 unregister_netdev(dev);
1403 i = tty_unregister_ldisc(N_SLLIN);
1405 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1408 module_init(sllin_init);
1409 module_exit(sllin_exit);