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 spin_lock(&sl->lock);
501 /* Is the length of data set in frame cache? */
502 if (sce->frame_fl & LIN_LOC_SLAVE_CACHE) {
503 sl->rx_expect += sce->dlc;
504 sl->rx_len_unknown = false;
506 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
507 sl->rx_len_unknown = true;
509 spin_unlock(&sl->lock);
511 sl->header_received = true;
516 if (SLL_RESPONSE_RECEIVED) {
518 pr_debug("sllin: Received LIN header & LIN response. "
519 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
522 /* Prepare for reception of new header */
524 sl->rx_expect = SLLIN_BUFF_ID + 1;
525 sl->rx_len_unknown = false; /* We do know exact length of the header */
526 sl->header_received = false;
532 /*****************************************
533 * sllin message helper routines
534 *****************************************/
536 * sllin_report_error() -- Report an error by sending CAN frame
537 * with particular error flag set in can_id
540 * @err: Error flag to be sent.
542 void sllin_report_error(struct sllin *sl, int err)
545 case LIN_ERR_CHECKSUM:
546 sl->dev->stats.rx_crc_errors++;
549 case LIN_ERR_RX_TIMEOUT:
550 sl->dev->stats.rx_errors++;
553 case LIN_ERR_FRAMING:
554 sl->dev->stats.rx_frame_errors++;
558 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
559 (err & ~LIN_ID_MASK), NULL, 0);
563 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
566 * @cf: Pointer to CAN frame sent to this driver
567 * holding configuration information
569 * Called with sl->lock held.
571 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
573 struct sllin_conf_entry *sce;
574 if (!(cf->can_id & LIN_ID_CONF))
577 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
578 pr_debug("sllin: Setting frame cache with EFF CAN frame. "
579 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
581 sce->dlc = cf->can_dlc;
582 if (sce->dlc > SLLIN_DATA_MAX)
583 sce->dlc = SLLIN_DATA_MAX;
585 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
586 memcpy(sce->data, cf->data, cf->can_dlc);
592 * sllin_checksum() -- Count checksum for particular data
594 * @data: Pointer to the buffer containing whole LIN
595 * frame (i.e. including break and sync bytes).
596 * @length: Length of the buffer.
597 * @enhanced_fl: Flag determining whether Enhanced or Classic
598 * checksum should be counted.
600 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
611 for (; i < length; i++) {
620 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
621 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
622 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
624 int sllin_setup_msg(struct sllin *sl, int mode, int id,
625 unsigned char *data, int len)
627 if (id > LIN_ID_MASK)
630 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
634 sl->rx_lim = SLLIN_BUFF_LEN;
637 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
638 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
639 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
640 sl->tx_lim = SLLIN_BUFF_DATA;
642 if ((data != NULL) && len) {
644 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
645 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
646 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
649 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
654 static void sllin_reset_buffs(struct sllin *sl)
658 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
661 sl->id_to_send = false;
662 sl->data_to_send = false;
665 int sllin_send_tx_buff(struct sllin *sl)
667 struct tty_struct *tty = sl->tty;
672 if (sl->lin_state != SLSTATE_BREAK_SENT)
673 remains = sl->tx_lim - sl->tx_cnt;
677 remains = sl->tx_lim - sl->tx_cnt;
680 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
688 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
689 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
691 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
699 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
700 sl->tx_cnt, remains);
706 int sllin_send_break(struct sllin *sl)
708 struct tty_struct *tty = sl->tty;
709 unsigned long break_baud;
712 break_baud = ((sl->lin_baud * 2) / 3);
713 sltty_change_speed(tty, break_baud);
715 tty->ops->flush_buffer(tty);
716 sl->rx_cnt = SLLIN_BUFF_BREAK;
718 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
719 sl->lin_state = SLSTATE_BREAK_SENT;
721 res = sllin_send_tx_buff(sl);
723 sl->lin_state = SLSTATE_IDLE;
729 #else /* BREAK_BY_BAUD */
731 int sllin_send_break(struct sllin *sl)
733 struct tty_struct *tty = sl->tty;
735 unsigned long break_baud;
736 unsigned long usleep_range_min;
737 unsigned long usleep_range_max;
739 break_baud = ((sl->lin_baud * 2) / 3);
740 sl->rx_cnt = SLLIN_BUFF_BREAK;
741 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
742 sl->lin_state = SLSTATE_BREAK_SENT;
744 /* Do the break ourselves; Inspired by
745 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
746 retval = tty->ops->break_ctl(tty, -1);
751 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
752 usleep_range_max = usleep_range_min + 50;
753 usleep_range(usleep_range_min, usleep_range_max);
755 retval = tty->ops->break_ctl(tty, 0);
756 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
757 usleep_range_max = usleep_range_min + 30;
758 usleep_range(usleep_range_min, usleep_range_max);
760 tty->ops->flush_buffer(tty);
762 sl->tx_cnt = SLLIN_BUFF_SYNC;
764 pr_debug("sllin: Break sent.\n");
765 set_bit(SLF_RXEVENT, &sl->flags);
766 wake_up(&sl->kwt_wq);
770 #endif /* BREAK_BY_BAUD */
773 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
775 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
777 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
778 set_bit(SLF_TMOUTEVENT, &sl->flags);
779 wake_up(&sl->kwt_wq);
781 return HRTIMER_NORESTART;
785 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
789 static int sllin_rx_validate(struct sllin *sl)
794 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
795 struct sllin_conf_entry *scf;
797 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
798 scf = &sl->linfr_cache[actual_id];
799 spin_lock(&sl->lock);
801 ext_chcks_fl = scf->frame_fl & LIN_CHECKSUM_EXTENDED;
802 spin_unlock(&sl->lock);
804 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
807 /* Type of checksum is configured for particular frame */
811 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
812 !ext_chcks_fl) != rec_chcksm) {
821 /*****************************************
822 * sllin_kwthread - kernel worker thread
823 *****************************************/
825 int sllin_kwthread(void *ptr)
827 struct sllin *sl = (struct sllin *)ptr;
828 struct tty_struct *tty = sl->tty;
829 struct sched_param schparam = { .sched_priority = 40 };
830 int tx_bytes = 0; /* Used for Network statistics */
833 pr_debug("sllin: sllin_kwthread started.\n");
834 sched_setscheduler(current, SCHED_FIFO, &schparam);
836 clear_bit(SLF_ERROR, &sl->flags);
837 sltty_change_speed(tty, sl->lin_baud);
839 while (!kthread_should_stop()) {
840 struct can_frame *cf;
843 u8 lin_data_buff[SLLIN_DATA_MAX];
846 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
848 if (sllin_send_break(sl) < 0) {
849 /* error processing */
853 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
854 test_bit(SLF_RXEVENT, &sl->flags) ||
855 test_bit(SLF_TXEVENT, &sl->flags) ||
856 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
857 test_bit(SLF_ERROR, &sl->flags) ||
858 (((sl->lin_state == SLSTATE_IDLE) ||
859 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
860 && test_bit(SLF_MSGEVENT, &sl->flags)));
862 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
863 pr_debug("sllin: sllin_kthread RXEVENT\n");
866 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
867 unsigned long usleep_range_min;
868 unsigned long usleep_range_max;
869 hrtimer_cancel(&sl->rx_timer);
870 pr_debug("sllin: sllin_kthread ERROR\n");
872 if (sl->lin_state != SLSTATE_IDLE)
873 sllin_report_error(sl, LIN_ERR_FRAMING);
875 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
877 usleep_range_max = usleep_range_min + 50;
878 usleep_range(usleep_range_min, usleep_range_max);
879 sllin_reset_buffs(sl);
880 sl->lin_state = SLSTATE_IDLE;
883 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
884 pr_debug("sllin: sllin_kthread TXEVENT\n");
887 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
888 pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
889 sllin_reset_buffs(sl);
891 sl->lin_state = SLSTATE_IDLE;
894 switch (sl->lin_state) {
896 if (!test_bit(SLF_MSGEVENT, &sl->flags))
899 cf = (struct can_frame *)sl->tx_req_skb->data;
901 /* SFF RTR CAN frame -> LIN header */
902 if (cf->can_id & CAN_RTR_FLAG) {
903 spin_lock(&sl->lock);
904 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
905 __FUNCTION__, cf->can_id & LIN_ID_MASK);
907 /* Is there Slave response in linfr_cache to be sent? */
908 if ((sl->linfr_cache[cf->can_id & LIN_ID_MASK].frame_fl &
910 && (sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc > 0)) {
912 pr_debug("sllin: Sending LIN response from linfr_cache\n");
913 lin_data = sl->linfr_cache[cf->can_id & LIN_ID_MASK].data;
914 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
915 if (lin_dlc > SLLIN_DATA_MAX)
916 lin_dlc = SLLIN_DATA_MAX;
917 memcpy(lin_data_buff, lin_data, lin_dlc);
918 lin_data = lin_data_buff;
921 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
923 spin_unlock(&sl->lock);
924 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
925 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
926 __FUNCTION__, (int)cf->can_id & LIN_ID_MASK);
929 lin_dlc = cf->can_dlc;
930 if (lin_dlc > SLLIN_DATA_MAX)
931 lin_dlc = SLLIN_DATA_MAX;
935 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
936 lin_data, lin_dlc) != -1) {
938 sl->id_to_send = true;
939 sl->data_to_send = (lin_data != NULL) ? true : false;
940 sl->resp_len_known = (lin_dlc > 0) ? true : false;
941 sl->dev->stats.tx_packets++;
942 sl->dev->stats.tx_bytes += tx_bytes;
945 clear_bit(SLF_MSGEVENT, &sl->flags);
946 kfree_skb(sl->tx_req_skb);
947 netif_wake_queue(sl->dev);
948 hrtimer_start(&sl->rx_timer,
949 ktime_add(ktime_get(), sl->rx_timer_timeout),
953 case SLSTATE_BREAK_SENT:
955 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
958 res = sltty_change_speed(tty, sl->lin_baud);
961 sl->lin_state = SLSTATE_ID_SENT;
962 sllin_send_tx_buff(sl);
965 case SLSTATE_ID_SENT:
966 hrtimer_cancel(&sl->rx_timer);
967 sl->id_to_send = false;
968 if (sl->data_to_send) {
969 sllin_send_tx_buff(sl);
970 sl->lin_state = SLSTATE_RESPONSE_SENT;
971 sl->rx_expect = sl->tx_lim;
972 goto slstate_response_sent;
974 if (sl->resp_len_known) {
975 sl->rx_expect = sl->rx_lim;
977 sl->rx_expect = SLLIN_BUFF_DATA + 2;
979 sl->lin_state = SLSTATE_RESPONSE_WAIT;
980 /* If we don't receive anything, timer will "unblock" us */
981 hrtimer_start(&sl->rx_timer,
982 ktime_add(ktime_get(), sl->rx_timer_timeout),
984 goto slstate_response_wait;
988 case SLSTATE_RESPONSE_WAIT:
989 slstate_response_wait:
990 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
991 unsigned char *lin_buff;
992 cf = (struct can_frame *)sl->tx_req_skb->data;
994 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
995 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
996 hrtimer_cancel(&sl->rx_timer);
997 pr_debug("sllin: received LIN response in a CAN frame.\n");
998 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
999 cf->can_id & LIN_ID_MASK,
1000 cf->data, cf->can_dlc) != -1) {
1002 sl->rx_expect = sl->tx_lim;
1003 sl->data_to_send = true;
1004 sl->dev->stats.tx_packets++;
1005 sl->dev->stats.tx_bytes += tx_bytes;
1007 if (!sl->lin_master) {
1008 sl->tx_cnt = SLLIN_BUFF_DATA;
1011 sllin_send_tx_buff(sl);
1012 clear_bit(SLF_MSGEVENT, &sl->flags);
1013 kfree_skb(sl->tx_req_skb);
1014 netif_wake_queue(sl->dev);
1016 sl->lin_state = SLSTATE_RESPONSE_SENT;
1017 goto slstate_response_sent;
1020 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1024 /* Be aware, no BREAK here */
1025 case SLSTATE_RESPONSE_WAIT_BUS:
1026 if (sl->rx_cnt < sl->rx_expect)
1029 hrtimer_cancel(&sl->rx_timer);
1030 pr_debug("sllin: response received ID %d len %d\n",
1031 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1033 if (sllin_rx_validate(sl) == -1) {
1034 pr_debug("sllin: RX validation failed.\n");
1035 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1037 /* Send CAN non-RTR frame with data */
1038 pr_debug("sllin: sending NON-RTR CAN"
1039 "frame with LIN payload.");
1040 sll_bump(sl); /* send packet to the network layer */
1043 sl->id_to_send = false;
1044 sl->lin_state = SLSTATE_IDLE;
1047 case SLSTATE_RESPONSE_SENT:
1048 slstate_response_sent:
1049 if (sl->rx_cnt < sl->tx_lim)
1052 hrtimer_cancel(&sl->rx_timer);
1053 sll_bump(sl); /* send packet to the network layer */
1054 pr_debug("sllin: response sent ID %d len %d\n",
1055 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1057 sl->id_to_send = false;
1058 sl->lin_state = SLSTATE_IDLE;
1063 hrtimer_cancel(&sl->rx_timer);
1064 pr_debug("sllin: sllin_kwthread stopped.\n");
1070 /************************************
1071 * sllin_open helper routines.
1072 ************************************/
1074 /* Collect hanged up channels */
1075 static void sll_sync(void)
1078 struct net_device *dev;
1081 for (i = 0; i < maxdev; i++) {
1082 dev = sllin_devs[i];
1086 sl = netdev_priv(dev);
1089 if (dev->flags & IFF_UP)
1094 /* Find a free SLLIN channel, and link in this `tty' line. */
1095 static struct sllin *sll_alloc(dev_t line)
1098 struct net_device *dev = NULL;
1101 if (sllin_devs == NULL)
1102 return NULL; /* Master array missing ! */
1104 for (i = 0; i < maxdev; i++) {
1105 dev = sllin_devs[i];
1111 /* Sorry, too many, all slots in use */
1116 sl = netdev_priv(dev);
1117 if (test_bit(SLF_INUSE, &sl->flags)) {
1118 unregister_netdevice(dev);
1120 sllin_devs[i] = NULL;
1125 char name[IFNAMSIZ];
1126 sprintf(name, "sllin%d", i);
1128 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1134 sl = netdev_priv(dev);
1135 /* Initialize channel control data */
1136 sl->magic = SLLIN_MAGIC;
1138 spin_lock_init(&sl->lock);
1139 sllin_devs[i] = dev;
1145 * Open the high-level part of the SLLIN channel.
1146 * This function is called by the TTY module when the
1147 * SLLIN line discipline is called for. Because we are
1148 * sure the tty line exists, we only have to link it to
1149 * a free SLLIN channel...
1151 * Called in process context serialized from other ldisc calls.
1154 static int sllin_open(struct tty_struct *tty)
1158 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1160 if (!capable(CAP_NET_ADMIN))
1163 if (tty->ops->write == NULL)
1166 /* RTnetlink lock is misused here to serialize concurrent
1167 opens of sllin channels. There are better ways, but it is
1172 /* Collect hanged up channels. */
1175 sl = tty->disc_data;
1178 /* First make sure we're not already connected. */
1179 if (sl && sl->magic == SLLIN_MAGIC)
1182 /* OK. Find a free SLLIN channel to use. */
1184 sl = sll_alloc(tty_devnum(tty));
1189 tty->disc_data = sl;
1190 sl->line = tty_devnum(tty);
1192 if (!test_bit(SLF_INUSE, &sl->flags)) {
1193 /* Perform the low-level SLLIN initialization. */
1194 sl->lin_master = master;
1197 pr_debug("sllin: Configured as MASTER\n");
1199 pr_debug("sllin: Configured as SLAVE\n");
1202 sllin_reset_buffs(sl);
1204 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1205 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1207 sl->lin_state = SLSTATE_IDLE;
1209 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1210 sl->rx_timer.function = sllin_rx_timeout_handler;
1211 /* timeval_to_ktime(msg_head->ival1); */
1212 sl->rx_timer_timeout = ns_to_ktime(
1213 (1000000000l / sl->lin_baud) *
1214 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1216 set_bit(SLF_INUSE, &sl->flags);
1218 init_waitqueue_head(&sl->kwt_wq);
1219 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1220 if (sl->kwthread == NULL)
1223 err = register_netdevice(sl->dev);
1225 goto err_free_chan_and_thread;
1228 /* Done. We have linked the TTY line to a channel. */
1230 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1232 /* TTY layer expects 0 on success */
1235 err_free_chan_and_thread:
1236 kthread_stop(sl->kwthread);
1237 sl->kwthread = NULL;
1241 tty->disc_data = NULL;
1242 clear_bit(SLF_INUSE, &sl->flags);
1247 /* Count references from TTY module */
1252 * Close down a SLLIN channel.
1253 * This means flushing out any pending queues, and then returning. This
1254 * call is serialized against other ldisc functions.
1256 * We also use this method for a hangup event.
1259 static void sllin_close(struct tty_struct *tty)
1261 struct sllin *sl = (struct sllin *) tty->disc_data;
1263 /* First make sure we're connected. */
1264 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1267 kthread_stop(sl->kwthread);
1268 sl->kwthread = NULL;
1270 tty->disc_data = NULL;
1273 /* Flush network side */
1274 unregister_netdev(sl->dev);
1275 /* This will complete via sl_free_netdev */
1278 static int sllin_hangup(struct tty_struct *tty)
1284 /* Perform I/O control on an active SLLIN channel. */
1285 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1286 unsigned int cmd, unsigned long arg)
1288 struct sllin *sl = (struct sllin *) tty->disc_data;
1291 /* First make sure we're connected. */
1292 if (!sl || sl->magic != SLLIN_MAGIC)
1297 tmp = strlen(sl->dev->name) + 1;
1298 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1306 return tty_mode_ioctl(tty, file, cmd, arg);
1310 static struct tty_ldisc_ops sll_ldisc = {
1311 .owner = THIS_MODULE,
1312 .magic = TTY_LDISC_MAGIC,
1315 .close = sllin_close,
1316 .hangup = sllin_hangup,
1317 .ioctl = sllin_ioctl,
1318 .receive_buf = sllin_receive_buf,
1319 .write_wakeup = sllin_write_wakeup,
1322 static int __init sllin_init(void)
1327 maxdev = 4; /* Sanity */
1330 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1332 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1334 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1338 /* Fill in our line protocol discipline, and register it */
1339 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1341 printk(KERN_ERR "sllin: can't register line discipline\n");
1345 #ifdef BREAK_BY_BAUD
1346 pr_debug("sllin: Break is generated by baud-rate change.");
1348 pr_debug("sllin: Break is generated manually with tiny sleep.");
1354 static void __exit sllin_exit(void)
1357 struct net_device *dev;
1359 unsigned long timeout = jiffies + HZ;
1362 if (sllin_devs == NULL)
1365 /* First of all: check for active disciplines and hangup them.
1369 msleep_interruptible(100);
1372 for (i = 0; i < maxdev; i++) {
1373 dev = sllin_devs[i];
1376 sl = netdev_priv(dev);
1377 spin_lock_bh(&sl->lock);
1380 tty_hangup(sl->tty);
1382 spin_unlock_bh(&sl->lock);
1384 } while (busy && time_before(jiffies, timeout));
1386 /* FIXME: hangup is async so we should wait when doing this second
1389 for (i = 0; i < maxdev; i++) {
1390 dev = sllin_devs[i];
1393 sllin_devs[i] = NULL;
1395 sl = netdev_priv(dev);
1397 printk(KERN_ERR "%s: tty discipline still running\n",
1399 /* Intentionally leak the control block. */
1400 dev->destructor = NULL;
1403 unregister_netdev(dev);
1409 i = tty_unregister_ldisc(N_SLLIN);
1411 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1414 module_init(sllin_init);
1415 module_exit(sllin_exit);