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 */
161 #define SLF_TXBUFF_RQ 6 /* Req. to send buffer to UART*/
162 #define SLF_TXBUFF_INPR 7 /* Above request in progress */
165 struct task_struct *kwthread;
166 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
167 struct hrtimer rx_timer; /* RX timeout timer */
168 ktime_t rx_timer_timeout; /* RX timeout timer value */
169 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame
170 received from network stack*/
172 /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
173 struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
174 spinlock_t linfr_lock; /* frame cache and buffers lock */
177 static struct net_device **sllin_devs;
178 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
181 /* Values of two parity bits in LIN Protected
182 Identifier for each particular LIN ID */
183 const unsigned char sllin_id_parity_table[] = {
184 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
185 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
186 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
187 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
188 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
189 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
190 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
191 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
195 * sltty_change_speed() -- Change baudrate of Serial device belonging
198 * @tty: Pointer to TTY to change speed for.
199 * @speed: Integer value of new speed. It is possible to
200 * assign non-standard values, i.e. those which
201 * are not defined in termbits.h.
203 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
205 struct ktermios old_termios;
208 mutex_lock(&tty->termios_mutex);
210 old_termios = *(tty->termios);
212 cflag = CS8 | CREAD | CLOCAL | HUPCL;
213 cflag &= ~(CBAUD | CIBAUD);
215 tty->termios->c_cflag = cflag;
216 tty->termios->c_oflag = 0;
217 tty->termios->c_lflag = 0;
219 /* Enable interrupt when UART-Break or Framing error received */
220 tty->termios->c_iflag = BRKINT | INPCK;
222 tty_encode_baud_rate(tty, speed, speed);
224 if (tty->ops->set_termios)
225 tty->ops->set_termios(tty, &old_termios);
227 mutex_unlock(&tty->termios_mutex);
232 /* Send one can_frame to the network layer */
233 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
241 memcpy(&cf.data, data, cf.can_dlc);
243 skb = dev_alloc_skb(sizeof(struct can_frame));
248 skb->protocol = htons(ETH_P_CAN);
249 skb->pkt_type = PACKET_BROADCAST;
250 skb->ip_summed = CHECKSUM_UNNECESSARY;
251 memcpy(skb_put(skb, sizeof(struct can_frame)),
252 &cf, sizeof(struct can_frame));
255 sl->dev->stats.rx_packets++;
256 sl->dev->stats.rx_bytes += cf.can_dlc;
260 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
265 static void sll_bump(struct sllin *sl)
267 int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
268 len = (len < 0) ? 0 : len;
270 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
271 sl->rx_buff + SLLIN_BUFF_DATA, len);
274 static void sll_send_rtr(struct sllin *sl)
276 sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
277 CAN_RTR_FLAG, NULL, 0);
281 * Called by the driver when there's room for more data. If we have
282 * more packets to send, we send them here.
284 static void sllin_write_wakeup(struct tty_struct *tty)
288 struct sllin *sl = (struct sllin *) tty->disc_data;
290 /* First make sure we're connected. */
291 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
294 set_bit(SLF_TXBUFF_RQ, &sl->flags);
296 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
297 return; /* ongoing concurrent processing */
299 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
300 smp_mb__after_clear_bit();
302 if (sl->lin_state != SLSTATE_BREAK_SENT)
303 remains = sl->tx_lim - sl->tx_cnt;
305 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
308 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
309 sl->tx_cnt - sl->tx_lim);
310 sl->tx_cnt += actual;
313 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
314 smp_mb__after_clear_bit();
316 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
318 if ((remains > 0) && (actual >= 0)) {
319 pr_debug("sllin: sllin_write_wakeup sent %d, "
320 "remains %d, waiting\n",
321 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
325 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
326 set_bit(SLF_TXEVENT, &sl->flags);
327 wake_up(&sl->kwt_wq);
329 pr_debug("sllin: sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
333 * sll_xmit() -- Send a can_frame to a TTY queue.
335 * @skb: Pointer to Socket buffer to be sent.
336 * @dev: Network device where @skb will be sent.
338 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
340 struct sllin *sl = netdev_priv(dev);
341 struct can_frame *cf;
343 if (skb->len != sizeof(struct can_frame))
346 spin_lock(&sl->lock);
347 if (!netif_running(dev)) {
348 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
351 if (sl->tty == NULL) {
352 printk(KERN_WARNING "%s: xmit: no tty device connected\n", dev->name);
356 cf = (struct can_frame *) skb->data;
357 if (cf->can_id & LIN_CTRL_FRAME) {
358 sllin_configure_frame_cache(sl, cf);
359 goto free_out_unlock;
362 netif_stop_queue(sl->dev);
364 sl->tx_req_skb = skb;
365 set_bit(SLF_MSGEVENT, &sl->flags);
366 wake_up(&sl->kwt_wq);
367 spin_unlock(&sl->lock);
372 spin_unlock(&sl->lock);
379 /******************************************
380 * Routines looking at netdevice side.
381 ******************************************/
383 /* Netdevice UP -> DOWN routine */
384 static int sll_close(struct net_device *dev)
386 struct sllin *sl = netdev_priv(dev);
388 spin_lock_bh(&sl->lock);
390 /* TTY discipline is running. */
391 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
393 netif_stop_queue(dev);
396 spin_unlock_bh(&sl->lock);
401 /* Netdevice DOWN -> UP routine */
402 static int sll_open(struct net_device *dev)
404 struct sllin *sl = netdev_priv(dev);
406 pr_debug("sllin: %s() invoked\n", __func__);
411 sl->flags &= (1 << SLF_INUSE);
412 netif_start_queue(dev);
416 /* Hook the destructor so we can free sllin devs at the right point in time */
417 static void sll_free_netdev(struct net_device *dev)
419 int i = dev->base_addr;
421 sllin_devs[i] = NULL;
424 static const struct net_device_ops sll_netdev_ops = {
425 .ndo_open = sll_open,
426 .ndo_stop = sll_close,
427 .ndo_start_xmit = sll_xmit,
430 static void sll_setup(struct net_device *dev)
432 dev->netdev_ops = &sll_netdev_ops;
433 dev->destructor = sll_free_netdev;
435 dev->hard_header_len = 0;
437 dev->tx_queue_len = 10;
439 dev->mtu = sizeof(struct can_frame);
440 dev->type = ARPHRD_CAN;
442 /* New-style flags. */
443 dev->flags = IFF_NOARP;
444 dev->features = NETIF_F_NO_CSUM;
447 /******************************************
448 Routines looking at TTY side.
449 ******************************************/
450 static void sllin_receive_buf(struct tty_struct *tty,
451 const unsigned char *cp, char *fp, int count)
453 struct sllin *sl = (struct sllin *) tty->disc_data;
454 pr_debug("sllin: sllin_receive_buf invoked, count = %u\n", count);
456 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
459 /* Read the characters out of the buffer */
462 pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
463 "due marker 0x%02x, flags 0x%lx\n",
464 *cp, *(fp-1), sl->flags);
466 if (sl->lin_master == true) {
467 if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
469 set_bit(SLF_ERROR, &sl->flags);
470 wake_up(&sl->kwt_wq);
473 } else { /* Received Break */
475 sl->rx_expect = SLLIN_BUFF_ID + 1;
476 sl->rx_len_unknown = false; /* We do know exact length of the header */
477 sl->header_received = false;
481 #ifndef BREAK_BY_BAUD
482 /* We didn't receive Break character -- fake it! */
483 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
484 pr_debug("sllin: LIN_RX[%d]: 0x00\n", sl->rx_cnt);
485 sl->rx_buff[sl->rx_cnt++] = 0x00;
488 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
489 pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
490 sl->rx_buff[sl->rx_cnt++] = *cp++;
493 if (sl->lin_master == true) {
494 if ((sl->rx_cnt >= sl->rx_expect) && (count == 0)) {
495 set_bit(SLF_RXEVENT, &sl->flags);
496 wake_up(&sl->kwt_wq);
497 pr_debug("sllin: sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
499 pr_debug("sllin: sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
501 } else { /* LIN slave */
503 struct sllin_conf_entry *sce;
505 pr_debug("sllin: rx_cnt = %u; header_received = %u\n",
506 sl->rx_cnt, sl->header_received);
508 /* Header received */
509 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
512 lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
513 sce = &sl->linfr_cache[lin_id];
515 spin_lock_irqsave(&sl->linfr_lock, flags);
516 /* Is the length of data set in frame cache? */
517 if (sce->frame_fl & LIN_LOC_SLAVE_CACHE) {
518 sl->rx_expect += sce->dlc;
519 sl->rx_len_unknown = false;
521 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
522 sl->rx_len_unknown = true;
524 spin_unlock_irqrestore(&sl->linfr_lock, flags);
526 sl->header_received = true;
531 /* Response received */
532 if ((sl->header_received == true) &&
533 ((sl->rx_cnt >= sl->rx_expect) ||
534 ((sl->rx_len_unknown == true) && (count == 0)))) {
537 pr_debug("sllin: Received LIN header & LIN response. "
538 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
541 /* Prepare for reception of new header */
543 sl->rx_expect = SLLIN_BUFF_ID + 1;
544 sl->rx_len_unknown = false; /* We do know exact length of the header */
545 sl->header_received = false;
551 /*****************************************
552 * sllin message helper routines
553 *****************************************/
555 * sllin_report_error() -- Report an error by sending CAN frame
556 * with particular error flag set in can_id
559 * @err: Error flag to be sent.
561 void sllin_report_error(struct sllin *sl, int err)
564 case LIN_ERR_CHECKSUM:
565 sl->dev->stats.rx_crc_errors++;
568 case LIN_ERR_RX_TIMEOUT:
569 sl->dev->stats.rx_errors++;
572 case LIN_ERR_FRAMING:
573 sl->dev->stats.rx_frame_errors++;
577 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
578 (err & ~LIN_ID_MASK), NULL, 0);
582 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
585 * @cf: Pointer to CAN frame sent to this driver
586 * holding configuration information
588 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
591 struct sllin_conf_entry *sce;
593 if (!(cf->can_id & LIN_ID_CONF))
596 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
597 pr_debug("sllin: Setting frame cache with EFF CAN frame. "
598 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
600 spin_lock_irqsave(&sl->linfr_lock, flags);
602 sce->dlc = cf->can_dlc;
603 if (sce->dlc > SLLIN_DATA_MAX)
604 sce->dlc = SLLIN_DATA_MAX;
606 sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
607 memcpy(sce->data, cf->data, cf->can_dlc);
609 spin_unlock_irqrestore(&sl->linfr_lock, flags);
615 * sllin_checksum() -- Count checksum for particular data
617 * @data: Pointer to the buffer containing whole LIN
618 * frame (i.e. including break and sync bytes).
619 * @length: Length of the buffer.
620 * @enhanced_fl: Flag determining whether Enhanced or Classic
621 * checksum should be counted.
623 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
633 for (; i < length; i++) {
642 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
643 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
644 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
646 int sllin_setup_msg(struct sllin *sl, int mode, int id,
647 unsigned char *data, int len)
649 if (id > LIN_ID_MASK)
652 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
656 sl->rx_lim = SLLIN_BUFF_LEN;
659 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
660 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
661 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
662 sl->tx_lim = SLLIN_BUFF_DATA;
664 if ((data != NULL) && len) {
666 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
667 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
668 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
671 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
676 static void sllin_reset_buffs(struct sllin *sl)
680 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
683 sl->id_to_send = false;
684 sl->data_to_send = false;
687 int sllin_send_tx_buff(struct sllin *sl)
689 struct tty_struct *tty = sl->tty;
693 set_bit(SLF_TXBUFF_RQ, &sl->flags);
695 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
696 return 0; /* ongoing concurrent processing */
698 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
699 smp_mb__after_clear_bit();
702 if (sl->lin_state != SLSTATE_BREAK_SENT)
703 remains = sl->tx_lim - sl->tx_cnt;
707 remains = sl->tx_lim - sl->tx_cnt;
710 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
718 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
719 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
721 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
729 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
730 sl->tx_cnt, remains);
732 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
733 smp_mb__after_clear_bit();
735 } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
740 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
746 int sllin_send_break(struct sllin *sl)
748 struct tty_struct *tty = sl->tty;
749 unsigned long break_baud;
752 break_baud = ((sl->lin_baud * 2) / 3);
753 sltty_change_speed(tty, break_baud);
755 tty->ops->flush_buffer(tty);
756 sl->rx_cnt = SLLIN_BUFF_BREAK;
758 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
759 sl->lin_state = SLSTATE_BREAK_SENT;
761 res = sllin_send_tx_buff(sl);
763 sl->lin_state = SLSTATE_IDLE;
769 #else /* BREAK_BY_BAUD */
771 int sllin_send_break(struct sllin *sl)
773 struct tty_struct *tty = sl->tty;
775 unsigned long break_baud;
776 unsigned long usleep_range_min;
777 unsigned long usleep_range_max;
779 break_baud = ((sl->lin_baud * 2) / 3);
780 sl->rx_cnt = SLLIN_BUFF_BREAK;
781 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
782 sl->lin_state = SLSTATE_BREAK_SENT;
784 /* Do the break ourselves; Inspired by
785 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
786 retval = tty->ops->break_ctl(tty, -1);
791 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
792 usleep_range_max = usleep_range_min + 50;
793 usleep_range(usleep_range_min, usleep_range_max);
795 retval = tty->ops->break_ctl(tty, 0);
796 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
797 usleep_range_max = usleep_range_min + 30;
798 usleep_range(usleep_range_min, usleep_range_max);
800 tty->ops->flush_buffer(tty);
802 sl->tx_cnt = SLLIN_BUFF_SYNC;
804 pr_debug("sllin: Break sent.\n");
805 set_bit(SLF_RXEVENT, &sl->flags);
806 wake_up(&sl->kwt_wq);
810 #endif /* BREAK_BY_BAUD */
813 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
815 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
817 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
818 set_bit(SLF_TMOUTEVENT, &sl->flags);
819 wake_up(&sl->kwt_wq);
821 return HRTIMER_NORESTART;
825 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
829 static int sllin_rx_validate(struct sllin *sl)
835 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
836 struct sllin_conf_entry *sce;
838 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
839 sce = &sl->linfr_cache[actual_id];
841 spin_lock_irqsave(&sl->linfr_lock, flags);
843 ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
844 spin_unlock_irqrestore(&sl->linfr_lock, flags);
846 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
849 /* Type of checksum is configured for particular frame */
853 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
854 !ext_chcks_fl) != rec_chcksm) {
863 /*****************************************
864 * sllin_kwthread - kernel worker thread
865 *****************************************/
867 int sllin_kwthread(void *ptr)
869 struct sllin *sl = (struct sllin *)ptr;
870 struct tty_struct *tty = sl->tty;
871 struct sched_param schparam = { .sched_priority = 40 };
872 int tx_bytes = 0; /* Used for Network statistics */
875 pr_debug("sllin: sllin_kwthread started.\n");
876 sched_setscheduler(current, SCHED_FIFO, &schparam);
878 clear_bit(SLF_ERROR, &sl->flags);
879 sltty_change_speed(tty, sl->lin_baud);
881 while (!kthread_should_stop()) {
882 struct can_frame *cf;
885 u8 lin_data_buff[SLLIN_DATA_MAX];
888 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
890 if (sllin_send_break(sl) < 0) {
891 /* error processing */
895 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
896 test_bit(SLF_RXEVENT, &sl->flags) ||
897 test_bit(SLF_TXEVENT, &sl->flags) ||
898 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
899 test_bit(SLF_ERROR, &sl->flags) ||
900 (((sl->lin_state == SLSTATE_IDLE) ||
901 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
902 && test_bit(SLF_MSGEVENT, &sl->flags)));
904 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
905 pr_debug("sllin: sllin_kthread RXEVENT\n");
908 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
909 unsigned long usleep_range_min;
910 unsigned long usleep_range_max;
911 hrtimer_cancel(&sl->rx_timer);
912 pr_debug("sllin: sllin_kthread ERROR\n");
914 if (sl->lin_state != SLSTATE_IDLE)
915 sllin_report_error(sl, LIN_ERR_FRAMING);
917 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
919 usleep_range_max = usleep_range_min + 50;
920 usleep_range(usleep_range_min, usleep_range_max);
921 sllin_reset_buffs(sl);
922 sl->lin_state = SLSTATE_IDLE;
925 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
926 pr_debug("sllin: sllin_kthread TXEVENT\n");
929 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
930 pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
931 sllin_reset_buffs(sl);
933 sl->lin_state = SLSTATE_IDLE;
936 switch (sl->lin_state) {
938 if (!test_bit(SLF_MSGEVENT, &sl->flags))
941 cf = (struct can_frame *)sl->tx_req_skb->data;
943 /* SFF RTR CAN frame -> LIN header */
944 if (cf->can_id & CAN_RTR_FLAG) {
946 struct sllin_conf_entry *sce;
948 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
949 __func__, cf->can_id & LIN_ID_MASK);
951 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
952 spin_lock_irqsave(&sl->linfr_lock, flags);
954 /* Is there Slave response in linfr_cache to be sent? */
955 if ((sce->frame_fl & LIN_LOC_SLAVE_CACHE)
958 pr_debug("sllin: Sending LIN response from linfr_cache\n");
960 lin_data = sce->data;
962 if (lin_dlc > SLLIN_DATA_MAX)
963 lin_dlc = SLLIN_DATA_MAX;
964 memcpy(lin_data_buff, lin_data, lin_dlc);
965 lin_data = lin_data_buff;
970 spin_unlock_irqrestore(&sl->linfr_lock, flags);
972 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
973 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
974 __func__, (int)cf->can_id & LIN_ID_MASK);
977 lin_dlc = cf->can_dlc;
978 if (lin_dlc > SLLIN_DATA_MAX)
979 lin_dlc = SLLIN_DATA_MAX;
983 if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
984 lin_data, lin_dlc) != -1) {
986 sl->id_to_send = true;
987 sl->data_to_send = (lin_data != NULL) ? true : false;
988 sl->resp_len_known = (lin_dlc > 0) ? true : false;
989 sl->dev->stats.tx_packets++;
990 sl->dev->stats.tx_bytes += tx_bytes;
993 clear_bit(SLF_MSGEVENT, &sl->flags);
994 kfree_skb(sl->tx_req_skb);
995 netif_wake_queue(sl->dev);
996 hrtimer_start(&sl->rx_timer,
997 ktime_add(ktime_get(), sl->rx_timer_timeout),
1001 case SLSTATE_BREAK_SENT:
1002 #ifdef BREAK_BY_BAUD
1003 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1006 res = sltty_change_speed(tty, sl->lin_baud);
1009 sl->lin_state = SLSTATE_ID_SENT;
1010 sllin_send_tx_buff(sl);
1013 case SLSTATE_ID_SENT:
1014 hrtimer_cancel(&sl->rx_timer);
1015 sl->id_to_send = false;
1016 if (sl->data_to_send) {
1017 sllin_send_tx_buff(sl);
1018 sl->lin_state = SLSTATE_RESPONSE_SENT;
1019 sl->rx_expect = sl->tx_lim;
1020 goto slstate_response_sent;
1022 if (sl->resp_len_known) {
1023 sl->rx_expect = sl->rx_lim;
1025 sl->rx_expect = SLLIN_BUFF_DATA + 2;
1027 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1028 /* If we don't receive anything, timer will "unblock" us */
1029 hrtimer_start(&sl->rx_timer,
1030 ktime_add(ktime_get(), sl->rx_timer_timeout),
1032 goto slstate_response_wait;
1036 case SLSTATE_RESPONSE_WAIT:
1037 slstate_response_wait:
1038 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1039 unsigned char *lin_buff;
1040 cf = (struct can_frame *)sl->tx_req_skb->data;
1042 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1043 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1044 hrtimer_cancel(&sl->rx_timer);
1045 pr_debug("sllin: received LIN response in a CAN frame.\n");
1046 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1047 cf->can_id & LIN_ID_MASK,
1048 cf->data, cf->can_dlc) != -1) {
1050 sl->rx_expect = sl->tx_lim;
1051 sl->data_to_send = true;
1052 sl->dev->stats.tx_packets++;
1053 sl->dev->stats.tx_bytes += tx_bytes;
1055 if (!sl->lin_master) {
1056 sl->tx_cnt = SLLIN_BUFF_DATA;
1059 sllin_send_tx_buff(sl);
1060 clear_bit(SLF_MSGEVENT, &sl->flags);
1061 kfree_skb(sl->tx_req_skb);
1062 netif_wake_queue(sl->dev);
1064 sl->lin_state = SLSTATE_RESPONSE_SENT;
1065 goto slstate_response_sent;
1068 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1072 /* Be aware, no BREAK here */
1073 case SLSTATE_RESPONSE_WAIT_BUS:
1074 if (sl->rx_cnt < sl->rx_expect)
1077 hrtimer_cancel(&sl->rx_timer);
1078 pr_debug("sllin: response received ID %d len %d\n",
1079 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1081 if (sllin_rx_validate(sl) == -1) {
1082 pr_debug("sllin: RX validation failed.\n");
1083 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1085 /* Send CAN non-RTR frame with data */
1086 pr_debug("sllin: sending NON-RTR CAN"
1087 "frame with LIN payload.");
1088 sll_bump(sl); /* send packet to the network layer */
1091 sl->id_to_send = false;
1092 sl->lin_state = SLSTATE_IDLE;
1095 case SLSTATE_RESPONSE_SENT:
1096 slstate_response_sent:
1097 if (sl->rx_cnt < sl->tx_lim)
1100 hrtimer_cancel(&sl->rx_timer);
1101 sll_bump(sl); /* send packet to the network layer */
1102 pr_debug("sllin: response sent ID %d len %d\n",
1103 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1105 sl->id_to_send = false;
1106 sl->lin_state = SLSTATE_IDLE;
1111 hrtimer_cancel(&sl->rx_timer);
1112 pr_debug("sllin: sllin_kwthread stopped.\n");
1118 /************************************
1119 * sllin_open helper routines.
1120 ************************************/
1122 /* Collect hanged up channels */
1123 static void sll_sync(void)
1126 struct net_device *dev;
1129 for (i = 0; i < maxdev; i++) {
1130 dev = sllin_devs[i];
1134 sl = netdev_priv(dev);
1137 if (dev->flags & IFF_UP)
1142 /* Find a free SLLIN channel, and link in this `tty' line. */
1143 static struct sllin *sll_alloc(dev_t line)
1146 struct net_device *dev = NULL;
1149 if (sllin_devs == NULL)
1150 return NULL; /* Master array missing ! */
1152 for (i = 0; i < maxdev; i++) {
1153 dev = sllin_devs[i];
1159 /* Sorry, too many, all slots in use */
1164 sl = netdev_priv(dev);
1165 if (test_bit(SLF_INUSE, &sl->flags)) {
1166 unregister_netdevice(dev);
1168 sllin_devs[i] = NULL;
1173 char name[IFNAMSIZ];
1174 sprintf(name, "sllin%d", i);
1176 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1182 sl = netdev_priv(dev);
1183 /* Initialize channel control data */
1184 sl->magic = SLLIN_MAGIC;
1186 spin_lock_init(&sl->lock);
1187 spin_lock_init(&sl->linfr_lock);
1188 sllin_devs[i] = dev;
1194 * Open the high-level part of the SLLIN channel.
1195 * This function is called by the TTY module when the
1196 * SLLIN line discipline is called for. Because we are
1197 * sure the tty line exists, we only have to link it to
1198 * a free SLLIN channel...
1200 * Called in process context serialized from other ldisc calls.
1203 static int sllin_open(struct tty_struct *tty)
1207 pr_debug("sllin: %s() invoked\n", __func__);
1209 if (!capable(CAP_NET_ADMIN))
1212 if (tty->ops->write == NULL)
1215 /* RTnetlink lock is misused here to serialize concurrent
1216 opens of sllin channels. There are better ways, but it is
1221 /* Collect hanged up channels. */
1224 sl = tty->disc_data;
1227 /* First make sure we're not already connected. */
1228 if (sl && sl->magic == SLLIN_MAGIC)
1231 /* OK. Find a free SLLIN channel to use. */
1233 sl = sll_alloc(tty_devnum(tty));
1238 tty->disc_data = sl;
1239 sl->line = tty_devnum(tty);
1241 if (!test_bit(SLF_INUSE, &sl->flags)) {
1242 /* Perform the low-level SLLIN initialization. */
1243 sl->lin_master = master;
1246 pr_debug("sllin: Configured as MASTER\n");
1248 pr_debug("sllin: Configured as SLAVE\n");
1251 sllin_reset_buffs(sl);
1253 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1254 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1256 sl->lin_state = SLSTATE_IDLE;
1258 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1259 sl->rx_timer.function = sllin_rx_timeout_handler;
1260 /* timeval_to_ktime(msg_head->ival1); */
1261 sl->rx_timer_timeout = ns_to_ktime(
1262 (1000000000l / sl->lin_baud) *
1263 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1265 set_bit(SLF_INUSE, &sl->flags);
1267 init_waitqueue_head(&sl->kwt_wq);
1268 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1269 if (sl->kwthread == NULL)
1272 err = register_netdevice(sl->dev);
1274 goto err_free_chan_and_thread;
1277 /* Done. We have linked the TTY line to a channel. */
1279 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1281 /* TTY layer expects 0 on success */
1284 err_free_chan_and_thread:
1285 kthread_stop(sl->kwthread);
1286 sl->kwthread = NULL;
1290 tty->disc_data = NULL;
1291 clear_bit(SLF_INUSE, &sl->flags);
1296 /* Count references from TTY module */
1301 * Close down a SLLIN channel.
1302 * This means flushing out any pending queues, and then returning. This
1303 * call is serialized against other ldisc functions.
1305 * We also use this method for a hangup event.
1308 static void sllin_close(struct tty_struct *tty)
1310 struct sllin *sl = (struct sllin *) tty->disc_data;
1312 /* First make sure we're connected. */
1313 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1316 kthread_stop(sl->kwthread);
1317 sl->kwthread = NULL;
1319 tty->disc_data = NULL;
1322 /* Flush network side */
1323 unregister_netdev(sl->dev);
1324 /* This will complete via sl_free_netdev */
1327 static int sllin_hangup(struct tty_struct *tty)
1333 /* Perform I/O control on an active SLLIN channel. */
1334 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1335 unsigned int cmd, unsigned long arg)
1337 struct sllin *sl = (struct sllin *) tty->disc_data;
1340 /* First make sure we're connected. */
1341 if (!sl || sl->magic != SLLIN_MAGIC)
1346 tmp = strlen(sl->dev->name) + 1;
1347 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1355 return tty_mode_ioctl(tty, file, cmd, arg);
1359 static struct tty_ldisc_ops sll_ldisc = {
1360 .owner = THIS_MODULE,
1361 .magic = TTY_LDISC_MAGIC,
1364 .close = sllin_close,
1365 .hangup = sllin_hangup,
1366 .ioctl = sllin_ioctl,
1367 .receive_buf = sllin_receive_buf,
1368 .write_wakeup = sllin_write_wakeup,
1371 static int __init sllin_init(void)
1376 maxdev = 4; /* Sanity */
1379 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1381 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1383 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1387 /* Fill in our line protocol discipline, and register it */
1388 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1390 printk(KERN_ERR "sllin: can't register line discipline\n");
1394 #ifdef BREAK_BY_BAUD
1395 pr_debug("sllin: Break is generated by baud-rate change.");
1397 pr_debug("sllin: Break is generated manually with tiny sleep.");
1403 static void __exit sllin_exit(void)
1406 struct net_device *dev;
1408 unsigned long timeout = jiffies + HZ;
1411 if (sllin_devs == NULL)
1414 /* First of all: check for active disciplines and hangup them.
1418 msleep_interruptible(100);
1421 for (i = 0; i < maxdev; i++) {
1422 dev = sllin_devs[i];
1425 sl = netdev_priv(dev);
1426 spin_lock_bh(&sl->lock);
1429 tty_hangup(sl->tty);
1431 spin_unlock_bh(&sl->lock);
1433 } while (busy && time_before(jiffies, timeout));
1435 /* FIXME: hangup is async so we should wait when doing this second
1438 for (i = 0; i < maxdev; i++) {
1439 dev = sllin_devs[i];
1442 sllin_devs[i] = NULL;
1444 sl = netdev_priv(dev);
1446 printk(KERN_ERR "%s: tty discipline still running\n",
1448 /* Intentionally leak the control block. */
1449 dev->destructor = NULL;
1452 unregister_netdev(dev);
1458 i = tty_unregister_ldisc(N_SLLIN);
1460 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1463 module_init(sllin_init);
1464 module_exit(sllin_exit);