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 * Send feedback to <socketcan-users@lists.berlios.de>
39 #define DEBUG 1 /* Enables pr_debug() printouts */
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
44 #include <asm/system.h>
45 #include <linux/uaccess.h>
46 #include <linux/bitops.h>
47 #include <linux/string.h>
48 #include <linux/tty.h>
49 #include <linux/errno.h>
50 #include <linux/netdevice.h>
51 #include <linux/skbuff.h>
52 #include <linux/rtnetlink.h>
53 #include <linux/if_arp.h>
54 #include <linux/if_ether.h>
55 #include <linux/sched.h>
56 #include <linux/delay.h>
57 #include <linux/init.h>
58 #include <linux/can.h>
59 #include <linux/kthread.h>
60 #include <linux/hrtimer.h>
61 #include "linux/lin_bus.h"
63 /* Should be in include/linux/tty.h */
65 /* -------------------------------- */
67 static __initdata const char banner[] =
68 KERN_INFO "sllin: serial line LIN interface driver\n";
70 MODULE_ALIAS_LDISC(N_SLLIN);
71 MODULE_DESCRIPTION("serial line LIN interface");
72 MODULE_LICENSE("GPL");
75 #define SLLIN_MAGIC 0x53CA
76 /* #define BREAK_BY_BAUD */
78 static int maxdev = 10; /* MAX number of SLLIN channels;
79 This can be overridden with
80 insmod sllin.ko maxdev=nnn */
81 module_param(maxdev, int, 0);
82 MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
84 /* maximum buffer len to store whole LIN message*/
85 #define SLLIN_DATA_MAX 8
86 #define SLLIN_BUFF_LEN (1 /*break*/ + 1 /*sync*/ + 1 /*ID*/ + \
87 SLLIN_DATA_MAX + 1 /*checksum*/)
88 #define SLLIN_BUFF_BREAK 0
89 #define SLLIN_BUFF_SYNC 1
90 #define SLLIN_BUFF_ID 2
91 #define SLLIN_BUFF_DATA 3
93 #define SLLIN_SAMPLES_PER_CHAR 10
94 #define SLLIN_CHARS_TO_TIMEOUT 12
100 SLSTATE_RESPONSE_WAIT, /* Wait for response */
101 SLSTATE_RESPONSE_WAIT_BUS, /* Wait for response from LIN bus
102 only (CAN frames from network stack
103 are not processed in this moment) */
104 SLSTATE_RESPONSE_SENT,
107 struct sllin_conf_entry {
108 int dlc; /* Length of data in LIN frame */
109 canid_t frame_fl; /* LIN frame flags. Passed from userspace as canid_t data type */
110 u8 data[8]; /* LIN frame data payload */
116 /* Various fields. */
117 struct tty_struct *tty; /* ptr to TTY structure */
118 struct net_device *dev; /* easy for intr handling */
121 /* LIN message buffer and actual processed data counts */
122 unsigned char rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
123 unsigned char tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
124 int rx_expect; /* expected number of Rx chars */
125 int rx_lim; /* maximum Rx chars for current frame */
126 int rx_cnt; /* message buffer Rx fill level */
127 int tx_lim; /* actual limit of bytes to Tx */
128 int tx_cnt; /* number of already Tx bytes */
129 char lin_master; /* node is a master node */
130 int lin_baud; /* LIN baudrate */
131 int lin_state; /* state */
132 char id_to_send; /* there is ID to be sent */
133 char data_to_send; /* there are data to be sent */
134 char resp_len_known; /* Length of the response is known */
136 unsigned long flags; /* Flag values/ mode etc */
137 #define SLF_INUSE 0 /* Channel in use */
138 #define SLF_ERROR 1 /* Parity, etc. error */
139 #define SLF_RXEVENT 2 /* Rx wake event */
140 #define SLF_TXEVENT 3 /* Tx wake event */
141 #define SLF_MSGEVENT 4 /* CAN message to sent */
142 #define SLF_TMOUTEVENT 5 /* Timeout on received data */
145 struct task_struct *kwthread;
146 wait_queue_head_t kwt_wq; /* Wait queue used by kwthread */
147 struct hrtimer rx_timer; /* RX timeout timer */
148 ktime_t rx_timer_timeout; /* RX timeout timer value */
149 struct sk_buff *tx_req_skb; /* Socket buffer with CAN frame received
152 struct sllin_conf_entry linfr_cache[SLLIN_ID_MAX + 1]; /* List with configurations for
153 each of 0 to SLLIN_ID_MAX LIN IDs */
156 static struct net_device **sllin_devs;
157 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
160 /* Values of two parity bits in LIN Protected
161 Identifier for each particular LIN ID */
162 const unsigned char sllin_id_parity_table[] = {
163 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
164 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
165 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
166 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
167 0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
168 0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
169 0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
170 0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
174 * sltty_change_speed() -- Change baudrate of Serial device belonging to particular @tty
176 * @tty: Pointer to TTY to change speed for.
177 * @speed: Integer value of new speed. It is possible to
178 * assign non-standard values, i.e. those which
179 * are not defined in termbits.h.
181 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
183 struct ktermios old_termios;
186 mutex_lock(&tty->termios_mutex);
188 old_termios = *(tty->termios);
189 cflag = tty->termios->c_cflag;
190 cflag &= ~(CBAUD | CIBAUD);
192 tty->termios->c_cflag = cflag;
194 tty_encode_baud_rate(tty, speed, speed);
196 if (tty->ops->set_termios)
197 tty->ops->set_termios(tty, &old_termios);
199 mutex_unlock(&tty->termios_mutex);
205 /* Send one can_frame to the network layer */
206 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
213 if (cf.can_dlc > 0) {
214 memcpy(&cf.data, data, cf.can_dlc);
217 skb = dev_alloc_skb(sizeof(struct can_frame));
222 skb->protocol = htons(ETH_P_CAN);
223 skb->pkt_type = PACKET_BROADCAST;
224 skb->ip_summed = CHECKSUM_UNNECESSARY;
225 memcpy(skb_put(skb, sizeof(struct can_frame)),
226 &cf, sizeof(struct can_frame));
229 sl->dev->stats.rx_packets++;
230 sl->dev->stats.rx_bytes += cf.can_dlc;
236 * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff) as CAN frame
240 static void sll_bump(struct sllin *sl)
242 sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & SLLIN_ID_MASK,
243 sl->rx_buff + SLLIN_BUFF_DATA,
244 sl->rx_cnt - SLLIN_BUFF_DATA - 1); /* without checksum */
248 * Called by the driver when there's room for more data. If we have
249 * more packets to send, we send them here.
251 static void sllin_write_wakeup(struct tty_struct *tty)
255 struct sllin *sl = (struct sllin *) tty->disc_data;
257 /* First make sure we're connected. */
258 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
261 if (sl->lin_state != SLSTATE_BREAK_SENT)
262 remains = sl->tx_lim - sl->tx_cnt;
264 remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
267 actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, sl->tx_cnt - sl->tx_lim);
268 sl->tx_cnt += actual;
270 if (sl->tx_cnt < sl->tx_lim) {
271 pr_debug("sllin: sllin_write_wakeup sent %d, remains %d, waiting\n",
272 sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
277 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
278 set_bit(SLF_TXEVENT, &sl->flags);
279 wake_up(&sl->kwt_wq);
281 pr_debug("sllin: sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
285 * sll_xmit() -- Send a can_frame to a TTY queue.
287 * @skb: Pointer to Socket buffer to be sent.
288 * @dev: Network device where @skb will be sent.
290 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
292 struct sllin *sl = netdev_priv(dev);
293 struct can_frame *cf;
295 if (skb->len != sizeof(struct can_frame))
298 spin_lock(&sl->lock);
299 if (!netif_running(dev)) {
300 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
303 if (sl->tty == NULL) {
307 cf = (struct can_frame *) skb->data;
308 if (cf->can_id & SLLIN_CTRL_FRAME) {
309 sllin_configure_frame_cache(sl, cf);
310 goto free_out_unlock;
313 netif_stop_queue(sl->dev);
315 sl->tx_req_skb = skb;
316 set_bit(SLF_MSGEVENT, &sl->flags);
317 wake_up(&sl->kwt_wq);
318 spin_unlock(&sl->lock);
323 spin_unlock(&sl->lock);
330 /******************************************
331 * Routines looking at netdevice side.
332 ******************************************/
334 /* Netdevice UP -> DOWN routine */
335 static int sll_close(struct net_device *dev)
337 struct sllin *sl = netdev_priv(dev);
339 spin_lock_bh(&sl->lock);
341 /* TTY discipline is running. */
342 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
344 netif_stop_queue(dev);
347 spin_unlock_bh(&sl->lock);
352 /* Netdevice DOWN -> UP routine */
353 static int sll_open(struct net_device *dev)
355 struct sllin *sl = netdev_priv(dev);
357 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
362 sl->flags &= (1 << SLF_INUSE);
363 netif_start_queue(dev);
367 /* Hook the destructor so we can free sllin devs at the right point in time */
368 static void sll_free_netdev(struct net_device *dev)
370 int i = dev->base_addr;
372 sllin_devs[i] = NULL;
375 static const struct net_device_ops sll_netdev_ops = {
376 .ndo_open = sll_open,
377 .ndo_stop = sll_close,
378 .ndo_start_xmit = sll_xmit,
381 static void sll_setup(struct net_device *dev)
383 dev->netdev_ops = &sll_netdev_ops;
384 dev->destructor = sll_free_netdev;
386 dev->hard_header_len = 0;
388 dev->tx_queue_len = 10;
390 dev->mtu = sizeof(struct can_frame);
391 dev->type = ARPHRD_CAN;
393 /* New-style flags. */
394 dev->flags = IFF_NOARP;
395 dev->features = NETIF_F_NO_CSUM;
398 /******************************************
399 Routines looking at TTY side.
400 ******************************************/
402 static void sllin_receive_buf(struct tty_struct *tty,
403 const unsigned char *cp, char *fp, int count)
405 struct sllin *sl = (struct sllin *) tty->disc_data;
407 pr_debug("sllin: sllin_receive_buf invoked\n");
409 if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
412 /* Read the characters out of the buffer */
415 if (!test_and_set_bit(SLF_ERROR, &sl->flags))
416 sl->dev->stats.rx_errors++;
417 pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
418 "due marker 0x%02x, flags 0x%lx\n",
419 *cp, *(fp-1), sl->flags);
424 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
425 #ifndef BREAK_BY_BAUD
426 /* We didn't receive Break character */
427 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
428 sl->rx_buff[sl->rx_cnt++] = 0x00;
431 pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
432 sl->rx_buff[sl->rx_cnt++] = *cp++;
436 if (sl->rx_cnt >= sl->rx_expect) {
437 set_bit(SLF_RXEVENT, &sl->flags);
438 wake_up(&sl->kwt_wq);
439 pr_debug("sllin: sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
441 pr_debug("sllin: sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
445 /*****************************************
446 * sllin message helper routines
447 *****************************************/
449 * sllin_report_error() -- Report an error by sending CAN frame \
450 * with particular error flag set in can_id
453 * @err: Error flag to be sent.
455 void sllin_report_error(struct sllin *sl, int err)
457 sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
458 (err & ~SLLIN_ID_MASK), NULL, 0);
462 * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
465 * @cf: Pointer to CAN frame sent to this driver
466 * holding configuration information
468 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
470 struct sllin_conf_entry *sce;
471 if (!(cf->can_id & SLLIN_LIN_ID_CONF))
474 sce = &sl->linfr_cache[cf->can_id & SLLIN_ID_MASK];
475 pr_debug("sllin: Setting frame cache with EFF CAN frame. "
476 "LIN ID = %d\n", cf->can_id & SLLIN_ID_MASK);
478 sce->dlc = cf->can_dlc;
479 if (sce->dlc > SLLIN_DATA_MAX)
480 sce->dlc = SLLIN_DATA_MAX;
482 sce->frame_fl = (cf->can_id & ~SLLIN_ID_MASK) & CAN_EFF_MASK;
483 memcpy(sce->data, cf->data, cf->can_dlc);
489 * sllin_checksum() -- Count checksum for particular data
491 * @data: Pointer to the buffer containing whole LIN
492 * frame (i.e. including break and sync bytes).
493 * @length: Length of the buffer.
494 * @enhanced_fl: Flag determining whether Enhanced or Classic
495 * checksum should be counted.
497 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
508 for (; i < length; i++) {
517 #define SLLIN_STPMSG_RESPONLY (1) /* Message will be LIN Response only */
518 #define SLLIN_STPMSG_CHCKSUM_CLS (1 << 1)
519 #define SLLIN_STPMSG_CHCKSUM_ENH (1 << 2)
521 int sllin_setup_msg(struct sllin *sl, int mode, int id,
522 unsigned char *data, int len)
524 if (id > SLLIN_ID_MASK)
527 if (!(mode & SLLIN_STPMSG_RESPONLY)) {
531 sl->rx_lim = SLLIN_BUFF_LEN;
534 sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
535 sl->tx_buff[SLLIN_BUFF_SYNC] = 0x55;
536 sl->tx_buff[SLLIN_BUFF_ID] = id | sllin_id_parity_table[id];
537 sl->tx_lim = SLLIN_BUFF_DATA;
539 if ((data != NULL) && len) {
541 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
542 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
543 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
546 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
552 int sllin_send_tx_buff(struct sllin *sl)
554 struct tty_struct *tty = sl->tty;
559 if (sl->lin_state != SLSTATE_BREAK_SENT)
560 remains = sl->tx_lim - sl->tx_cnt;
564 remains = sl->tx_lim - sl->tx_cnt;
567 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
575 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
576 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
578 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
586 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
587 sl->tx_cnt, remains);
593 int sllin_send_break(struct sllin *sl)
595 struct tty_struct *tty = sl->tty;
596 unsigned long break_baud;
599 break_baud = ((sl->lin_baud * 2) / 3);
600 sltty_change_speed(tty, break_baud);
602 tty->ops->flush_buffer(tty);
603 sl->rx_cnt = SLLIN_BUFF_BREAK;
605 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
606 sl->lin_state = SLSTATE_BREAK_SENT;
608 res = sllin_send_tx_buff(sl);
610 sl->lin_state = SLSTATE_IDLE;
616 #else /* BREAK_BY_BAUD */
618 int sllin_send_break(struct sllin *sl)
620 struct tty_struct *tty = sl->tty;
622 unsigned long break_baud;
623 unsigned long usleep_range_min;
624 unsigned long usleep_range_max;
626 break_baud = ((sl->lin_baud * 2) / 3);
627 sl->rx_cnt = SLLIN_BUFF_BREAK;
628 sl->rx_expect = SLLIN_BUFF_BREAK + 1;
629 sl->lin_state = SLSTATE_BREAK_SENT;
631 /* Do the break ourselves; Inspired by
632 http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
633 retval = tty->ops->break_ctl(tty, -1);
638 usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
639 usleep_range_max = usleep_range_min + 50;
640 usleep_range(usleep_range_min, usleep_range_max);
642 retval = tty->ops->break_ctl(tty, 0);
643 usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
644 usleep_range_max = usleep_range_min + 30;
645 usleep_range(usleep_range_min, usleep_range_max);
647 tty->ops->flush_buffer(tty);
649 sl->tx_cnt = SLLIN_BUFF_SYNC;
651 pr_debug("sllin: Break sent.\n");
652 set_bit(SLF_RXEVENT, &sl->flags);
653 wake_up(&sl->kwt_wq);
657 #endif /* BREAK_BY_BAUD */
660 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
662 struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
664 sllin_report_error(sl, SLLIN_ERR_RX_TIMEOUT);
665 set_bit(SLF_TMOUTEVENT, &sl->flags);
666 wake_up(&sl->kwt_wq);
668 return HRTIMER_NORESTART;
672 * sllin_rx_validate() -- Validate received frame, i,e. check checksum
676 static int sllin_rx_validate(struct sllin *sl)
681 unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
682 struct sllin_conf_entry *scf;
684 actual_id = sl->rx_buff[SLLIN_BUFF_ID] & SLLIN_ID_MASK;
685 scf = &sl->linfr_cache[actual_id];
687 ext_chcks_fl = scf->frame_fl & SLLIN_CHECKSUM_EXTENDED;
689 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
692 /* Type of checksum is configured for particular frame */
696 if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
697 !ext_chcks_fl) != rec_chcksm) {
706 /*****************************************
707 * sllin_kwthread - kernel worker thread
708 *****************************************/
710 int sllin_kwthread(void *ptr)
712 struct sllin *sl = (struct sllin *)ptr;
713 struct tty_struct *tty = sl->tty;
714 struct sched_param schparam = { .sched_priority = 40 };
715 int tx_bytes = 0; /* Used for Network statistics */
718 pr_debug("sllin: sllin_kwthread started.\n");
719 sched_setscheduler(current, SCHED_FIFO, &schparam);
721 clear_bit(SLF_ERROR, &sl->flags);
722 sltty_change_speed(tty, sl->lin_baud);
724 while (!kthread_should_stop()) {
725 struct can_frame *cf;
728 u8 lin_data_buff[SLLIN_DATA_MAX];
731 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
733 if(sllin_send_break(sl) < 0) {
734 /* error processing */
738 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
739 test_bit(SLF_RXEVENT, &sl->flags) ||
740 test_bit(SLF_TXEVENT, &sl->flags) ||
741 test_bit(SLF_TMOUTEVENT, &sl->flags) ||
742 (((sl->lin_state == SLSTATE_IDLE) ||
743 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
744 && test_bit(SLF_MSGEVENT, &sl->flags)));
746 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
747 pr_debug("sllin: sllin_kthread RXEVENT \n");
750 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
751 pr_debug("sllin: sllin_kthread TXEVENT \n");
754 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
755 pr_debug("sllin: sllin_kthread TMOUTEVENT \n");
758 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
761 sl->id_to_send = false;
762 sl->data_to_send = false;
764 sl->lin_state = SLSTATE_IDLE;
767 switch (sl->lin_state) {
769 if (!test_bit(SLF_MSGEVENT, &sl->flags))
772 cf = (struct can_frame *)sl->tx_req_skb->data;
774 /* SFF RTR CAN frame -> LIN header */
775 if (cf->can_id & CAN_RTR_FLAG) {
776 spin_lock(&sl->lock);
777 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
778 __FUNCTION__, cf->can_id & SLLIN_ID_MASK);
780 /* Is there Slave response in linfr_cache to be sent? */
781 if ((sl->linfr_cache[cf->can_id & SLLIN_ID_MASK].frame_fl &
782 SLLIN_LOC_SLAVE_CACHE)
783 && (sl->linfr_cache[cf->can_id & SLLIN_ID_MASK].dlc > 0)) {
785 pr_debug("sllin: Sending LIN response from linfr_cache\n");
786 lin_data = sl->linfr_cache[cf->can_id & SLLIN_ID_MASK].data;
787 lin_dlc = sl->linfr_cache[cf->can_id & SLLIN_ID_MASK].dlc;
788 if (lin_dlc > SLLIN_DATA_MAX)
789 lin_dlc = SLLIN_DATA_MAX;
790 memcpy(lin_data_buff, lin_data, lin_dlc);
791 lin_data = lin_data_buff;
794 lin_dlc = sl->linfr_cache[cf->can_id & SLLIN_ID_MASK].dlc;
796 spin_unlock(&sl->lock);
797 } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
798 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
799 __FUNCTION__, (int)cf->can_id & SLLIN_ID_MASK);
802 lin_dlc = cf->can_dlc;
803 if (lin_dlc > SLLIN_DATA_MAX)
804 lin_dlc = SLLIN_DATA_MAX;
808 if (sllin_setup_msg(sl, 0, cf->can_id & SLLIN_ID_MASK,
809 lin_data, lin_dlc) != -1) {
811 sl->id_to_send = true;
812 sl->data_to_send = (lin_data != NULL) ? true : false;
813 sl->resp_len_known = (lin_dlc > 0) ? true : false;
814 sl->dev->stats.tx_packets++;
815 sl->dev->stats.tx_bytes += tx_bytes;
818 clear_bit(SLF_MSGEVENT, &sl->flags);
819 kfree_skb(sl->tx_req_skb);
820 netif_wake_queue(sl->dev);
823 case SLSTATE_BREAK_SENT:
825 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
828 res = sltty_change_speed(tty, sl->lin_baud);
831 sl->lin_state = SLSTATE_ID_SENT;
832 sllin_send_tx_buff(sl);
835 case SLSTATE_ID_SENT:
836 sl->id_to_send = false;
837 if (sl->data_to_send) {
838 sllin_send_tx_buff(sl);
839 sl->lin_state = SLSTATE_RESPONSE_SENT;
840 sl->rx_expect = sl->tx_lim;
841 goto slstate_response_sent;
843 if (sl->resp_len_known) {
844 sl->rx_expect = sl->rx_lim;
846 sl->rx_expect = SLLIN_BUFF_DATA + 2;
848 sl->lin_state = SLSTATE_RESPONSE_WAIT;
849 /* If we don't receive anything, timer will "unblock" us */
850 hrtimer_start(&sl->rx_timer,
851 ktime_add(ktime_get(), sl->rx_timer_timeout),
853 goto slstate_response_wait;
857 case SLSTATE_RESPONSE_WAIT:
858 slstate_response_wait:
859 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
860 unsigned char *lin_buff;
861 cf = (struct can_frame *)sl->tx_req_skb->data;
863 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
864 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & SLLIN_ID_MASK)) {
865 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
866 cf->can_id & SLLIN_ID_MASK,
867 cf->data, cf->can_dlc) != -1) {
869 sl->rx_expect = sl->tx_lim;
870 sl->data_to_send = true;
871 sl->dev->stats.tx_packets++;
872 sl->dev->stats.tx_bytes += tx_bytes;
874 if (!sl->lin_master) {
875 sl->tx_cnt = SLLIN_BUFF_DATA;
878 sllin_send_tx_buff(sl);
879 clear_bit(SLF_MSGEVENT, &sl->flags);
880 kfree_skb(sl->tx_req_skb);
881 netif_wake_queue(sl->dev);
883 sl->lin_state = SLSTATE_RESPONSE_SENT;
884 goto slstate_response_sent;
887 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
891 case SLSTATE_RESPONSE_WAIT_BUS:
892 if (sl->rx_cnt < sl->rx_expect)
895 hrtimer_cancel(&sl->rx_timer);
896 pr_debug("sllin: response received ID %d len %d\n",
897 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
899 if (sllin_rx_validate(sl) == -1) {
900 pr_debug("sllin: RX validation failed.\n");
901 sllin_report_error(sl, SLLIN_ERR_CHECKSUM);
902 //FIXME tx_stat.err++
904 // send CAN non-RTR frame with data
905 pr_debug("sllin: sending NON-RTR CAN"
906 "frame with LIN payload.");
907 sll_bump(sl); //send packet to the network layer
910 sl->id_to_send = false;
911 sl->lin_state = SLSTATE_IDLE;
914 case SLSTATE_RESPONSE_SENT:
915 slstate_response_sent:
916 if (sl->rx_cnt < sl->tx_lim)
919 sll_bump(sl); //send packet to the network layer
920 pr_debug("sllin: response sent ID %d len %d\n",
921 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
923 sl->id_to_send = false;
924 sl->lin_state = SLSTATE_IDLE;
931 /* sl->dev->stats.tx_packets++; send frames statistic */
932 /* netif_wake_queue(sl->dev); allow next Tx packet arrival */
935 hrtimer_cancel(&sl->rx_timer);
936 pr_debug("sllin: sllin_kwthread stopped.\n");
942 /************************************
943 * sllin_open helper routines.
944 ************************************/
946 /* Collect hanged up channels */
947 static void sll_sync(void)
950 struct net_device *dev;
953 for (i = 0; i < maxdev; i++) {
958 sl = netdev_priv(dev);
961 if (dev->flags & IFF_UP)
966 /* Find a free SLLIN channel, and link in this `tty' line. */
967 static struct sllin *sll_alloc(dev_t line)
970 struct net_device *dev = NULL;
973 if (sllin_devs == NULL)
974 return NULL; /* Master array missing ! */
976 for (i = 0; i < maxdev; i++) {
983 /* Sorry, too many, all slots in use */
988 sl = netdev_priv(dev);
989 if (test_bit(SLF_INUSE, &sl->flags)) {
990 unregister_netdevice(dev);
992 sllin_devs[i] = NULL;
998 sprintf(name, "sllin%d", i);
1000 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1006 sl = netdev_priv(dev);
1007 /* Initialize channel control data */
1008 sl->magic = SLLIN_MAGIC;
1010 spin_lock_init(&sl->lock);
1011 sllin_devs[i] = dev;
1017 * Open the high-level part of the SLLIN channel.
1018 * This function is called by the TTY module when the
1019 * SLLIN line discipline is called for. Because we are
1020 * sure the tty line exists, we only have to link it to
1021 * a free SLLIN channel...
1023 * Called in process context serialized from other ldisc calls.
1026 static int sllin_open(struct tty_struct *tty)
1030 pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1032 if (!capable(CAP_NET_ADMIN))
1035 if (tty->ops->write == NULL)
1038 /* RTnetlink lock is misused here to serialize concurrent
1039 opens of sllin channels. There are better ways, but it is
1044 /* Collect hanged up channels. */
1047 sl = tty->disc_data;
1050 /* First make sure we're not already connected. */
1051 if (sl && sl->magic == SLLIN_MAGIC)
1054 /* OK. Find a free SLLIN channel to use. */
1056 sl = sll_alloc(tty_devnum(tty));
1061 tty->disc_data = sl;
1062 sl->line = tty_devnum(tty);
1064 if (!test_bit(SLF_INUSE, &sl->flags)) {
1065 /* Perform the low-level SLLIN initialization. */
1066 sl->lin_master = true;
1070 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
1073 sl->id_to_send = false;
1074 sl->data_to_send = false;
1076 sl->lin_baud = 19200;
1078 sl->lin_state = SLSTATE_IDLE;
1080 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1081 sl->rx_timer.function = sllin_rx_timeout_handler;
1082 /* timeval_to_ktime(msg_head->ival1); */
1083 sl->rx_timer_timeout = ns_to_ktime(
1084 (1000000000l / sl->lin_baud) *
1085 SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1087 set_bit(SLF_INUSE, &sl->flags);
1089 init_waitqueue_head(&sl->kwt_wq);
1090 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1091 if (sl->kwthread == NULL)
1094 err = register_netdevice(sl->dev);
1096 goto err_free_chan_and_thread;
1099 /* Done. We have linked the TTY line to a channel. */
1101 tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1103 /* TTY layer expects 0 on success */
1106 err_free_chan_and_thread:
1107 kthread_stop(sl->kwthread);
1108 sl->kwthread = NULL;
1112 tty->disc_data = NULL;
1113 clear_bit(SLF_INUSE, &sl->flags);
1118 /* Count references from TTY module */
1123 * Close down a SLLIN channel.
1124 * This means flushing out any pending queues, and then returning. This
1125 * call is serialized against other ldisc functions.
1127 * We also use this method for a hangup event.
1130 static void sllin_close(struct tty_struct *tty)
1132 struct sllin *sl = (struct sllin *) tty->disc_data;
1134 /* First make sure we're connected. */
1135 if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1138 kthread_stop(sl->kwthread);
1139 sl->kwthread = NULL;
1141 tty->disc_data = NULL;
1144 /* Flush network side */
1145 unregister_netdev(sl->dev);
1146 /* This will complete via sl_free_netdev */
1149 static int sllin_hangup(struct tty_struct *tty)
1155 /* Perform I/O control on an active SLLIN channel. */
1156 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1157 unsigned int cmd, unsigned long arg)
1159 struct sllin *sl = (struct sllin *) tty->disc_data;
1162 /* First make sure we're connected. */
1163 if (!sl || sl->magic != SLLIN_MAGIC)
1168 tmp = strlen(sl->dev->name) + 1;
1169 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1177 return tty_mode_ioctl(tty, file, cmd, arg);
1181 static struct tty_ldisc_ops sll_ldisc = {
1182 .owner = THIS_MODULE,
1183 .magic = TTY_LDISC_MAGIC,
1186 .close = sllin_close,
1187 .hangup = sllin_hangup,
1188 .ioctl = sllin_ioctl,
1189 .receive_buf = sllin_receive_buf,
1190 .write_wakeup = sllin_write_wakeup,
1193 static int __init sllin_init(void)
1198 maxdev = 4; /* Sanity */
1201 pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1203 sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1205 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1209 /* Fill in our line protocol discipline, and register it */
1210 status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1212 printk(KERN_ERR "sllin: can't register line discipline\n");
1216 #ifdef BREAK_BY_BAUD
1217 pr_debug("sllin: Break is generated by baud-rate change.");
1219 pr_debug("sllin: Break is generated manually with tiny sleep.");
1225 static void __exit sllin_exit(void)
1228 struct net_device *dev;
1230 unsigned long timeout = jiffies + HZ;
1233 if (sllin_devs == NULL)
1236 /* First of all: check for active disciplines and hangup them.
1240 msleep_interruptible(100);
1243 for (i = 0; i < maxdev; i++) {
1244 dev = sllin_devs[i];
1247 sl = netdev_priv(dev);
1248 spin_lock_bh(&sl->lock);
1251 tty_hangup(sl->tty);
1253 spin_unlock_bh(&sl->lock);
1255 } while (busy && time_before(jiffies, timeout));
1257 /* FIXME: hangup is async so we should wait when doing this second
1260 for (i = 0; i < maxdev; i++) {
1261 dev = sllin_devs[i];
1264 sllin_devs[i] = NULL;
1266 sl = netdev_priv(dev);
1268 printk(KERN_ERR "%s: tty discipline still running\n",
1270 /* Intentionally leak the control block. */
1271 dev->destructor = NULL;
1274 unregister_netdev(dev);
1280 i = tty_unregister_ldisc(N_SLLIN);
1282 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1285 module_init(sllin_init);
1286 module_exit(sllin_exit);