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 = 0; /* 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 */
150 unsigned long flags; /* Flag values/ mode etc */
151 #define SLF_INUSE 0 /* Channel in use */
152 #define SLF_ERROR 1 /* Parity, etc. error */
153 #define SLF_RXEVENT 2 /* Rx wake event */
154 #define SLF_TXEVENT 3 /* Tx wake event */
155 #define SLF_MSGEVENT 4 /* CAN message to sent */
156 #define SLF_TMOUTEVENT 5 /* Timeout on received data */
159 struct task_struct *kwthread;
160 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
161 struct hrtimer rx_timer; /* RX timeout timer */
162 ktime_t rx_timer_timeout; /* RX timeout timer value */
163 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame
164 received from network stack*/
166 /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
167 struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
170 static struct net_device **sllin_devs;
171 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
174 /* Values of two parity bits in LIN Protected
175 Identifier for each particular LIN ID */
176 const unsigned char sllin_id_parity_table[] = {
177 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
178 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
179 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
180 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
181 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
182 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
183 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
184 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
188 * sltty_change_speed() -- Change baudrate of Serial device belonging
191 * @tty: Pointer to TTY to change speed for.
192 * @speed: Integer value of new speed. It is possible to
193 * assign non-standard values, i.e. those which
194 * are not defined in termbits.h.
196 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
198 struct ktermios old_termios;
201 mutex_lock(&tty->termios_mutex);
203 old_termios = *(tty->termios);
205 cflag = CS8 | CREAD | CLOCAL | HUPCL;
206 cflag &= ~(CBAUD | CIBAUD);
208 tty->termios->c_cflag = cflag;
209 tty->termios->c_oflag = 0;
210 tty->termios->c_lflag = 0;
212 /* Enable interrupt when UART-Break or Framing error received */
213 tty->termios->c_iflag = BRKINT | INPCK;
215 tty_encode_baud_rate(tty, speed, speed);
217 if (tty->ops->set_termios)
218 tty->ops->set_termios(tty, &old_termios);
220 mutex_unlock(&tty->termios_mutex);
225 /* Send one can_frame to the network layer */
226 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
233 if (cf.can_dlc > 0) {
234 memcpy(&cf.data, data, cf.can_dlc);
237 skb = dev_alloc_skb(sizeof(struct can_frame));
242 skb->protocol = htons(ETH_P_CAN);
243 skb->pkt_type = PACKET_BROADCAST;
244 skb->ip_summed = CHECKSUM_UNNECESSARY;
245 memcpy(skb_put(skb, sizeof(struct can_frame)),
246 &cf, sizeof(struct can_frame));
249 sl->dev->stats.rx_packets++;
250 sl->dev->stats.rx_bytes += cf.can_dlc;
254 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
259 static void sll_bump(struct sllin *sl)
261 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
262 sl->rx_buff + SLLIN_BUFF_DATA,
263 sl->rx_cnt - SLLIN_BUFF_DATA - 1); /* without checksum */
267 * Called by the driver when there's room for more data. If we have
268 * more packets to send, we send them here.
270 static void sllin_write_wakeup(struct tty_struct *tty)
274 struct sllin *sl = (struct sllin *) tty->disc_data;
276 /* First make sure we're connected. */
277 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
280 if (sl->lin_state != SLSTATE_BREAK_SENT)
281 remains = sl->tx_lim - sl->tx_cnt;
283 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
286 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
287 sl->tx_cnt - sl->tx_lim);
288 sl->tx_cnt += actual;
290 if (sl->tx_cnt < sl->tx_lim) {
291 pr_debug("sllin: sllin_write_wakeup sent %d, "
292 "remains %d, waiting\n",
293 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
298 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
299 set_bit(SLF_TXEVENT, &sl->flags);
300 wake_up(&sl->kwt_wq);
302 pr_debug("sllin: sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
306 * sll_xmit() -- Send a can_frame to a TTY queue.
308 * @skb: Pointer to Socket buffer to be sent.
309 * @dev: Network device where @skb will be sent.
311 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
313 struct sllin *sl = netdev_priv(dev);
314 struct can_frame *cf;
316 if (skb->len != sizeof(struct can_frame))
319 spin_lock(&sl->lock);
320 if (!netif_running(dev)) {
321 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
324 if (sl->tty == NULL) {
328 cf = (struct can_frame *) skb->data;
329 if (cf->can_id & LIN_CTRL_FRAME) {
330 sllin_configure_frame_cache(sl, cf);
331 goto free_out_unlock;
334 netif_stop_queue(sl->dev);
336 sl->tx_req_skb = skb;
337 set_bit(SLF_MSGEVENT, &sl->flags);
338 wake_up(&sl->kwt_wq);
339 spin_unlock(&sl->lock);
344 spin_unlock(&sl->lock);
351 /******************************************
352 * Routines looking at netdevice side.
353 ******************************************/
355 /* Netdevice UP -> DOWN routine */
356 static int sll_close(struct net_device *dev)
358 struct sllin *sl = netdev_priv(dev);
360 spin_lock_bh(&sl->lock);
362 /* TTY discipline is running. */
363 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
365 netif_stop_queue(dev);
368 spin_unlock_bh(&sl->lock);
373 /* Netdevice DOWN -> UP routine */
374 static int sll_open(struct net_device *dev)
376 struct sllin *sl = netdev_priv(dev);
378 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
383 sl->flags &= (1 << SLF_INUSE);
384 netif_start_queue(dev);
388 /* Hook the destructor so we can free sllin devs at the right point in time */
389 static void sll_free_netdev(struct net_device *dev)
391 int i = dev->base_addr;
393 sllin_devs[i] = NULL;
396 static const struct net_device_ops sll_netdev_ops = {
397 .ndo_open = sll_open,
398 .ndo_stop = sll_close,
399 .ndo_start_xmit = sll_xmit,
402 static void sll_setup(struct net_device *dev)
404 dev->netdev_ops = &sll_netdev_ops;
405 dev->destructor = sll_free_netdev;
407 dev->hard_header_len = 0;
409 dev->tx_queue_len = 10;
411 dev->mtu = sizeof(struct can_frame);
412 dev->type = ARPHRD_CAN;
414 /* New-style flags. */
415 dev->flags = IFF_NOARP;
416 dev->features = NETIF_F_NO_CSUM;
419 /******************************************
420 Routines looking at TTY side.
421 ******************************************/
423 static void sllin_receive_buf(struct tty_struct *tty,
424 const unsigned char *cp, char *fp, int count)
426 struct sllin *sl = (struct sllin *) tty->disc_data;
428 pr_debug("sllin: sllin_receive_buf invoked, count = %u\n", count);
430 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
433 /* Read the characters out of the buffer */
436 if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
437 set_bit(SLF_ERROR, &sl->flags);
439 pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
440 "due marker 0x%02x, flags 0x%lx\n",
441 *cp, *(fp-1), sl->flags);
443 if (sl->lin_master == true) {
444 wake_up(&sl->kwt_wq);
448 sl->rx_expect = SLLIN_BUFF_ID + 1;
457 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
458 #ifndef BREAK_BY_BAUD
459 /* We didn't receive Break character -- fake it! */
460 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
461 sl->rx_buff[sl->rx_cnt++] = 0x00;
464 pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
465 sl->rx_buff[sl->rx_cnt++] = *cp++;
469 if (sl->lin_master == true) {
470 if (sl->rx_cnt >= sl->rx_expect) {
471 set_bit(SLF_RXEVENT, &sl->flags);
472 wake_up(&sl->kwt_wq);
473 pr_debug("sllin: sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
475 pr_debug("sllin: sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
477 } else { /* LIN slave */
479 struct sllin_conf_entry *sce;
481 // sl->rx_buff[sl->rx_cnt] = *cp++;
482 // if (sl->rx_cnt == (SLLIN_BUFF_ID + 1)) { /* Received whole header */
483 // lin_id = sl->rx_buff[sl->rx_cnt] & LIN_ID_MASK;
484 // sce = &sl->linfr_cache[lin_id];
486 // if (sce->frame_fl & LIN_LOC_SLAVE_CACHE)
487 // sl->rx_expect += sce->dlc;
489 // sl->rx_expect += 2;//SLLIN_DATA_MAX;
491 // /* Send RTR frame here */
494 if (sl->rx_cnt >= sl->rx_expect && sl->rx_cnt > SLLIN_BUFF_DATA) {
496 pr_debug("sllin: Received LIN header & LIN response. "
497 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
506 /*****************************************
507 * sllin message helper routines
508 *****************************************/
510 * sllin_report_error() -- Report an error by sending CAN frame
511 * with particular error flag set in can_id
514 * @err: Error flag to be sent.
516 void sllin_report_error(struct sllin *sl, int err)
519 case LIN_ERR_CHECKSUM:
520 sl->dev->stats.rx_crc_errors++;
523 case LIN_ERR_RX_TIMEOUT:
524 sl->dev->stats.rx_errors++;
527 case LIN_ERR_FRAMING:
528 sl->dev->stats.rx_frame_errors++;
532 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
533 (err & ~LIN_ID_MASK), NULL, 0);
537 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
540 * @cf: Pointer to CAN frame sent to this driver
541 * holding configuration information
543 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
545 struct sllin_conf_entry *sce;
546 if (!(cf->can_id & LIN_ID_CONF))
549 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
550 pr_debug("sllin: Setting frame cache with EFF CAN frame. "
551 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
553 sce->dlc = cf->can_dlc;
554 if (sce->dlc > SLLIN_DATA_MAX)
555 sce->dlc = SLLIN_DATA_MAX;
557 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
558 memcpy(sce->data, cf->data, cf->can_dlc);
564 * sllin_checksum() -- Count checksum for particular data
566 * @data: Pointer to the buffer containing whole LIN
567 * frame (i.e. including break and sync bytes).
568 * @length: Length of the buffer.
569 * @enhanced_fl: Flag determining whether Enhanced or Classic
570 * checksum should be counted.
572 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
583 for (; i < length; i++) {
592 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
593 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
594 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
596 int sllin_setup_msg(struct sllin *sl, int mode, int id,
597 unsigned char *data, int len)
599 if (id > LIN_ID_MASK)
602 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
606 sl->rx_lim = SLLIN_BUFF_LEN;
609 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
610 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
611 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
612 sl->tx_lim = SLLIN_BUFF_DATA;
614 if ((data != NULL) && len) {
616 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
617 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
618 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
621 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
626 static void sllin_reset_buffs(struct sllin *sl)
630 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
633 sl->id_to_send = false;
634 sl->data_to_send = false;
637 int sllin_send_tx_buff(struct sllin *sl)
639 struct tty_struct *tty = sl->tty;
644 if (sl->lin_state != SLSTATE_BREAK_SENT)
645 remains = sl->tx_lim - sl->tx_cnt;
649 remains = sl->tx_lim - sl->tx_cnt;
652 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
660 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
661 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
663 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
671 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
672 sl->tx_cnt, remains);
678 int sllin_send_break(struct sllin *sl)
680 struct tty_struct *tty = sl->tty;
681 unsigned long break_baud;
684 break_baud = ((sl->lin_baud * 2) / 3);
685 sltty_change_speed(tty, break_baud);
687 tty->ops->flush_buffer(tty);
688 sl->rx_cnt = SLLIN_BUFF_BREAK;
690 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
691 sl->lin_state = SLSTATE_BREAK_SENT;
693 res = sllin_send_tx_buff(sl);
695 sl->lin_state = SLSTATE_IDLE;
701 #else /* BREAK_BY_BAUD */
703 int sllin_send_break(struct sllin *sl)
705 struct tty_struct *tty = sl->tty;
707 unsigned long break_baud;
708 unsigned long usleep_range_min;
709 unsigned long usleep_range_max;
711 break_baud = ((sl->lin_baud * 2) / 3);
712 sl->rx_cnt = SLLIN_BUFF_BREAK;
713 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
714 sl->lin_state = SLSTATE_BREAK_SENT;
716 /* Do the break ourselves; Inspired by
717 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
718 retval = tty->ops->break_ctl(tty, -1);
723 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
724 usleep_range_max = usleep_range_min + 50;
725 usleep_range(usleep_range_min, usleep_range_max);
727 retval = tty->ops->break_ctl(tty, 0);
728 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
729 usleep_range_max = usleep_range_min + 30;
730 usleep_range(usleep_range_min, usleep_range_max);
732 tty->ops->flush_buffer(tty);
734 sl->tx_cnt = SLLIN_BUFF_SYNC;
736 pr_debug("sllin: Break sent.\n");
737 set_bit(SLF_RXEVENT, &sl->flags);
738 wake_up(&sl->kwt_wq);
742 #endif /* BREAK_BY_BAUD */
745 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
747 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
749 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
750 set_bit(SLF_TMOUTEVENT, &sl->flags);
751 wake_up(&sl->kwt_wq);
753 return HRTIMER_NORESTART;
757 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
761 static int sllin_rx_validate(struct sllin *sl)
766 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
767 struct sllin_conf_entry *scf;
769 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
770 scf = &sl->linfr_cache[actual_id];
772 ext_chcks_fl = scf->frame_fl & LIN_CHECKSUM_EXTENDED;
774 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
777 /* Type of checksum is configured for particular frame */
781 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
782 !ext_chcks_fl) != rec_chcksm) {
791 /*****************************************
792 * sllin_kwthread - kernel worker thread
793 *****************************************/
795 int sllin_kwthread(void *ptr)
797 struct sllin *sl = (struct sllin *)ptr;
798 struct tty_struct *tty = sl->tty;
799 struct sched_param schparam = { .sched_priority = 40 };
800 int tx_bytes = 0; /* Used for Network statistics */
803 pr_debug("sllin: sllin_kwthread started.\n");
804 sched_setscheduler(current, SCHED_FIFO, &schparam);
806 clear_bit(SLF_ERROR, &sl->flags);
807 sltty_change_speed(tty, sl->lin_baud);
809 while (!kthread_should_stop()) {
810 struct can_frame *cf;
813 u8 lin_data_buff[SLLIN_DATA_MAX];
816 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
818 if(sllin_send_break(sl) < 0) {
819 /* error processing */
823 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
824 test_bit(SLF_RXEVENT, &sl->flags) ||
825 test_bit(SLF_TXEVENT, &sl->flags) ||
826 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
827 test_bit(SLF_ERROR, &sl->flags) ||
828 (((sl->lin_state == SLSTATE_IDLE) ||
829 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
830 && test_bit(SLF_MSGEVENT, &sl->flags)));
832 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
833 pr_debug("sllin: sllin_kthread RXEVENT\n");
836 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
837 unsigned long usleep_range_min;
838 unsigned long usleep_range_max;
839 hrtimer_cancel(&sl->rx_timer);
840 pr_debug("sllin: sllin_kthread ERROR\n");
842 if (sl->lin_state != SLSTATE_IDLE)
843 sllin_report_error(sl, LIN_ERR_FRAMING);
845 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
847 usleep_range_max = usleep_range_min + 50;
848 usleep_range(usleep_range_min, usleep_range_max);
849 sllin_reset_buffs(sl);
850 sl->lin_state = SLSTATE_IDLE;
853 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
854 pr_debug("sllin: sllin_kthread TXEVENT\n");
857 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
858 pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
859 sllin_reset_buffs(sl);
861 sl->lin_state = SLSTATE_IDLE;
864 switch (sl->lin_state) {
866 if (!test_bit(SLF_MSGEVENT, &sl->flags))
869 cf = (struct can_frame *)sl->tx_req_skb->data;
871 /* SFF RTR CAN frame -> LIN header */
872 if (cf->can_id & CAN_RTR_FLAG) {
873 spin_lock(&sl->lock);
874 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
875 __FUNCTION__, cf->can_id & LIN_ID_MASK);
877 /* Is there Slave response in linfr_cache to be sent? */
878 if ((sl->linfr_cache[cf->can_id & LIN_ID_MASK].frame_fl &
880 && (sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc > 0)) {
882 pr_debug("sllin: Sending LIN response from linfr_cache\n");
883 lin_data = sl->linfr_cache[cf->can_id & LIN_ID_MASK].data;
884 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
885 if (lin_dlc > SLLIN_DATA_MAX)
886 lin_dlc = SLLIN_DATA_MAX;
887 memcpy(lin_data_buff, lin_data, lin_dlc);
888 lin_data = lin_data_buff;
891 lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
893 spin_unlock(&sl->lock);
894 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
895 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
896 __FUNCTION__, (int)cf->can_id & LIN_ID_MASK);
899 lin_dlc = cf->can_dlc;
900 if (lin_dlc > SLLIN_DATA_MAX)
901 lin_dlc = SLLIN_DATA_MAX;
905 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
906 lin_data, lin_dlc) != -1) {
908 sl->id_to_send = true;
909 sl->data_to_send = (lin_data != NULL) ? true : false;
910 sl->resp_len_known = (lin_dlc > 0) ? true : false;
911 sl->dev->stats.tx_packets++;
912 sl->dev->stats.tx_bytes += tx_bytes;
915 clear_bit(SLF_MSGEVENT, &sl->flags);
916 kfree_skb(sl->tx_req_skb);
917 netif_wake_queue(sl->dev);
918 hrtimer_start(&sl->rx_timer,
919 ktime_add(ktime_get(), sl->rx_timer_timeout),
923 case SLSTATE_BREAK_SENT:
925 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
928 res = sltty_change_speed(tty, sl->lin_baud);
931 sl->lin_state = SLSTATE_ID_SENT;
932 sllin_send_tx_buff(sl);
935 case SLSTATE_ID_SENT:
936 hrtimer_cancel(&sl->rx_timer);
937 sl->id_to_send = false;
938 if (sl->data_to_send) {
939 sllin_send_tx_buff(sl);
940 sl->lin_state = SLSTATE_RESPONSE_SENT;
941 sl->rx_expect = sl->tx_lim;
942 goto slstate_response_sent;
944 if (sl->resp_len_known) {
945 sl->rx_expect = sl->rx_lim;
947 sl->rx_expect = SLLIN_BUFF_DATA + 2;
949 sl->lin_state = SLSTATE_RESPONSE_WAIT;
950 /* If we don't receive anything, timer will "unblock" us */
951 hrtimer_start(&sl->rx_timer,
952 ktime_add(ktime_get(), sl->rx_timer_timeout),
954 goto slstate_response_wait;
958 case SLSTATE_RESPONSE_WAIT:
959 slstate_response_wait:
960 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
961 unsigned char *lin_buff;
962 cf = (struct can_frame *)sl->tx_req_skb->data;
964 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
965 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
966 hrtimer_cancel(&sl->rx_timer);
967 pr_debug("sllin: received LIN response in a CAN frame.\n");
968 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
969 cf->can_id & LIN_ID_MASK,
970 cf->data, cf->can_dlc) != -1) {
972 sl->rx_expect = sl->tx_lim;
973 sl->data_to_send = true;
974 sl->dev->stats.tx_packets++;
975 sl->dev->stats.tx_bytes += tx_bytes;
977 if (!sl->lin_master) {
978 sl->tx_cnt = SLLIN_BUFF_DATA;
981 sllin_send_tx_buff(sl);
982 clear_bit(SLF_MSGEVENT, &sl->flags);
983 kfree_skb(sl->tx_req_skb);
984 netif_wake_queue(sl->dev);
986 sl->lin_state = SLSTATE_RESPONSE_SENT;
987 goto slstate_response_sent;
990 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
994 /* Be aware, no BREAK here */
995 case SLSTATE_RESPONSE_WAIT_BUS:
996 if (sl->rx_cnt < sl->rx_expect)
999 hrtimer_cancel(&sl->rx_timer);
1000 pr_debug("sllin: response received ID %d len %d\n",
1001 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1003 if (sllin_rx_validate(sl) == -1) {
1004 pr_debug("sllin: RX validation failed.\n");
1005 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1007 /* Send CAN non-RTR frame with data */
1008 pr_debug("sllin: sending NON-RTR CAN"
1009 "frame with LIN payload.");
1010 sll_bump(sl); /* send packet to the network layer */
1013 sl->id_to_send = false;
1014 sl->lin_state = SLSTATE_IDLE;
1017 case SLSTATE_RESPONSE_SENT:
1018 slstate_response_sent:
1019 if (sl->rx_cnt < sl->tx_lim)
1022 hrtimer_cancel(&sl->rx_timer);
1023 sll_bump(sl); /* send packet to the network layer */
1024 pr_debug("sllin: response sent ID %d len %d\n",
1025 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1027 sl->id_to_send = false;
1028 sl->lin_state = SLSTATE_IDLE;
1033 hrtimer_cancel(&sl->rx_timer);
1034 pr_debug("sllin: sllin_kwthread stopped.\n");
1040 /************************************
1041 * sllin_open helper routines.
1042 ************************************/
1044 /* Collect hanged up channels */
1045 static void sll_sync(void)
1048 struct net_device *dev;
1051 for (i = 0; i < maxdev; i++) {
1052 dev = sllin_devs[i];
1056 sl = netdev_priv(dev);
1059 if (dev->flags & IFF_UP)
1064 /* Find a free SLLIN channel, and link in this `tty' line. */
1065 static struct sllin *sll_alloc(dev_t line)
1068 struct net_device *dev = NULL;
1071 if (sllin_devs == NULL)
1072 return NULL; /* Master array missing ! */
1074 for (i = 0; i < maxdev; i++) {
1075 dev = sllin_devs[i];
1081 /* Sorry, too many, all slots in use */
1086 sl = netdev_priv(dev);
1087 if (test_bit(SLF_INUSE, &sl->flags)) {
1088 unregister_netdevice(dev);
1090 sllin_devs[i] = NULL;
1095 char name[IFNAMSIZ];
1096 sprintf(name, "sllin%d", i);
1098 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1104 sl = netdev_priv(dev);
1105 /* Initialize channel control data */
1106 sl->magic = SLLIN_MAGIC;
1108 spin_lock_init(&sl->lock);
1109 sllin_devs[i] = dev;
1115 * Open the high-level part of the SLLIN channel.
1116 * This function is called by the TTY module when the
1117 * SLLIN line discipline is called for. Because we are
1118 * sure the tty line exists, we only have to link it to
1119 * a free SLLIN channel...
1121 * Called in process context serialized from other ldisc calls.
1124 static int sllin_open(struct tty_struct *tty)
1128 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1130 if (!capable(CAP_NET_ADMIN))
1133 if (tty->ops->write == NULL)
1136 /* RTnetlink lock is misused here to serialize concurrent
1137 opens of sllin channels. There are better ways, but it is
1142 /* Collect hanged up channels. */
1145 sl = tty->disc_data;
1148 /* First make sure we're not already connected. */
1149 if (sl && sl->magic == SLLIN_MAGIC)
1152 /* OK. Find a free SLLIN channel to use. */
1154 sl = sll_alloc(tty_devnum(tty));
1159 tty->disc_data = sl;
1160 sl->line = tty_devnum(tty);
1162 if (!test_bit(SLF_INUSE, &sl->flags)) {
1163 /* Perform the low-level SLLIN initialization. */
1164 sl->lin_master = master;
1166 sllin_reset_buffs(sl);
1168 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1169 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1171 sl->lin_state = SLSTATE_IDLE;
1173 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1174 sl->rx_timer.function = sllin_rx_timeout_handler;
1175 /* timeval_to_ktime(msg_head->ival1); */
1176 sl->rx_timer_timeout = ns_to_ktime(
1177 (1000000000l / sl->lin_baud) *
1178 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1180 set_bit(SLF_INUSE, &sl->flags);
1182 init_waitqueue_head(&sl->kwt_wq);
1183 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1184 if (sl->kwthread == NULL)
1187 err = register_netdevice(sl->dev);
1189 goto err_free_chan_and_thread;
1192 /* Done. We have linked the TTY line to a channel. */
1194 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1196 /* TTY layer expects 0 on success */
1199 err_free_chan_and_thread:
1200 kthread_stop(sl->kwthread);
1201 sl->kwthread = NULL;
1205 tty->disc_data = NULL;
1206 clear_bit(SLF_INUSE, &sl->flags);
1211 /* Count references from TTY module */
1216 * Close down a SLLIN channel.
1217 * This means flushing out any pending queues, and then returning. This
1218 * call is serialized against other ldisc functions.
1220 * We also use this method for a hangup event.
1223 static void sllin_close(struct tty_struct *tty)
1225 struct sllin *sl = (struct sllin *) tty->disc_data;
1227 /* First make sure we're connected. */
1228 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1231 kthread_stop(sl->kwthread);
1232 sl->kwthread = NULL;
1234 tty->disc_data = NULL;
1237 /* Flush network side */
1238 unregister_netdev(sl->dev);
1239 /* This will complete via sl_free_netdev */
1242 static int sllin_hangup(struct tty_struct *tty)
1248 /* Perform I/O control on an active SLLIN channel. */
1249 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1250 unsigned int cmd, unsigned long arg)
1252 struct sllin *sl = (struct sllin *) tty->disc_data;
1255 /* First make sure we're connected. */
1256 if (!sl || sl->magic != SLLIN_MAGIC)
1261 tmp = strlen(sl->dev->name) + 1;
1262 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1270 return tty_mode_ioctl(tty, file, cmd, arg);
1274 static struct tty_ldisc_ops sll_ldisc = {
1275 .owner = THIS_MODULE,
1276 .magic = TTY_LDISC_MAGIC,
1279 .close = sllin_close,
1280 .hangup = sllin_hangup,
1281 .ioctl = sllin_ioctl,
1282 .receive_buf = sllin_receive_buf,
1283 .write_wakeup = sllin_write_wakeup,
1286 static int __init sllin_init(void)
1291 maxdev = 4; /* Sanity */
1294 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1296 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1298 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1302 /* Fill in our line protocol discipline, and register it */
1303 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1305 printk(KERN_ERR "sllin: can't register line discipline\n");
1309 #ifdef BREAK_BY_BAUD
1310 pr_debug("sllin: Break is generated by baud-rate change.");
1312 pr_debug("sllin: Break is generated manually with tiny sleep.");
1318 static void __exit sllin_exit(void)
1321 struct net_device *dev;
1323 unsigned long timeout = jiffies + HZ;
1326 if (sllin_devs == NULL)
1329 /* First of all: check for active disciplines and hangup them.
1333 msleep_interruptible(100);
1336 for (i = 0; i < maxdev; i++) {
1337 dev = sllin_devs[i];
1340 sl = netdev_priv(dev);
1341 spin_lock_bh(&sl->lock);
1344 tty_hangup(sl->tty);
1346 spin_unlock_bh(&sl->lock);
1348 } while (busy && time_before(jiffies, timeout));
1350 /* FIXME: hangup is async so we should wait when doing this second
1353 for (i = 0; i < maxdev; i++) {
1354 dev = sllin_devs[i];
1357 sllin_devs[i] = NULL;
1359 sl = netdev_priv(dev);
1361 printk(KERN_ERR "%s: tty discipline still running\n",
1363 /* Intentionally leak the control block. */
1364 dev->destructor = NULL;
1367 unregister_netdev(dev);
1373 i = tty_unregister_ldisc(N_SLLIN);
1375 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1378 module_init(sllin_init);
1379 module_exit(sllin_exit);