sllin/sllin.c

   1 /*
   2  * sllin.c - serial line LIN interface driver (using tty line discipline)
   3  *
   4  * This file is derived from drivers/net/can/slcan.c
   5  * slcan.c Author: Oliver Hartkopp <socketcan@hartkopp.net>
   6  *
   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.
  11  *
  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.
  16  *
  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
  21  *
  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
  33  * DAMAGE.
  34  *
  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
  42  */
  43
  44 //#define DEBUG                 1 /* Enables pr_debug() printouts */
  45
  46 #include <linux/module.h>
  47 #include <linux/moduleparam.h>
  48
  49 #include <linux/uaccess.h>
  50 #include <linux/bitops.h>
  51 #include <linux/string.h>
  52 #include <linux/tty.h>
  53 #include <linux/errno.h>
  54 #include <linux/netdevice.h>
  55 #include <linux/skbuff.h>
  56 #include <linux/rtnetlink.h>
  57 #include <linux/if_arp.h>
  58 #include <linux/if_ether.h>
  59 #include <linux/sched.h>
  60 #include <linux/delay.h>
  61 #include <linux/init.h>
  62 #include <linux/can.h>
  63 #include <linux/kthread.h>
  64 #include <linux/hrtimer.h>
  65 #include <linux/version.h>
  66 #include "linux/lin_bus.h"
  67
  68 /* Should be in include/linux/tty.h */
  69 #define N_SLLIN                 25
  70 /* -------------------------------- */
  71
  72 static __initdata const char banner[] =
  73         KERN_INFO "sllin: serial line LIN interface driver\n";
  74
  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>");
  79
  80 #define SLLIN_MAGIC             0x53CA
  81 /* #define BREAK_BY_BAUD */
  82
  83 static bool master = true;
  84 static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
  85
  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");
  90
  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");
  96
  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
 105
 106 #define SLLIN_SAMPLES_PER_CHAR  10
 107 #define SLLIN_CHARS_TO_TIMEOUT  24
 108
 109 enum slstate {
 110         SLSTATE_IDLE = 0,
 111         SLSTATE_BREAK_SENT,
 112         SLSTATE_ID_SENT,
 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_ID_RECEIVED,
 118         SLSTATE_RESPONSE_SENT,
 119 };
 120
 121 struct sllin_conf_entry {
 122         int dlc;                /* Length of data in LIN frame */
 123         canid_t frame_fl;       /* LIN frame flags. Passed from userspace as
 124                                    canid_t data type */
 125         u8 data[8];             /* LIN frame data payload */
 126 };
 127
 128 struct sllin {
 129         int                     magic;
 130
 131         /* Various fields. */
 132         struct tty_struct       *tty;           /* ptr to TTY structure      */
 133         struct net_device       *dev;           /* easy for intr handling    */
 134         spinlock_t              lock;
 135
 136         /* LIN message buffer and actual processed data counts */
 137         unsigned char           rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
 138         unsigned char           tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
 139         int                     rx_expect;      /* expected number of Rx chars */
 140         int                     rx_lim;         /* maximum Rx chars for current frame */
 141         int                     rx_cnt;         /* message buffer Rx fill level  */
 142         int                     tx_lim;         /* actual limit of bytes to Tx */
 143         int                     tx_cnt;         /* number of already Tx bytes */
 144         char                    lin_master;     /* node is a master node */
 145         int                     lin_baud;       /* LIN baudrate */
 146         int                     lin_state;      /* state */
 147         char                    id_to_send;     /* there is ID to be sent */
 148         char                    data_to_send;   /* there are data to be sent */
 149         char                    resp_len_known; /* Length of the response is known */
 150         char                    header_received;/* In Slave mode, set when header was already
 151                                                    received */
 152         char                    rx_len_unknown; /* We are not sure how much data will be sent to us --
 153                                                    we just guess the length */
 154
 155         unsigned long           flags;          /* Flag values/ mode etc     */
 156 #define SLF_INUSE               0               /* Channel in use            */
 157 #define SLF_ERROR               1               /* Parity, etc. error        */
 158 #define SLF_RXEVENT             2               /* Rx wake event             */
 159 #define SLF_TXEVENT             3               /* Tx wake event             */
 160 #define SLF_MSGEVENT            4               /* CAN message to sent       */
 161 #define SLF_TMOUTEVENT          5               /* Timeout on received data  */
 162 #define SLF_TXBUFF_RQ           6               /* Req. to send buffer to UART*/
 163 #define SLF_TXBUFF_INPR         7               /* Above request in progress */
 164
 165         dev_t                   line;
 166         struct task_struct      *kwthread;
 167         wait_queue_head_t       kwt_wq;         /* Wait queue used by kwthread */
 168         struct hrtimer          rx_timer;       /* RX timeout timer */
 169         ktime_t                 rx_timer_timeout; /* RX timeout timer value */
 170         struct sk_buff          *tx_req_skb;    /* Socket buffer with CAN frame
 171                                                 received from network stack*/
 172
 173         /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
 174         struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
 175         spinlock_t              linfr_lock;     /* frame cache and buffers lock */
 176 };
 177
 178 static struct net_device **sllin_devs;
 179 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
 180 static void sllin_slave_receive_buf(struct tty_struct *tty,
 181                               const unsigned char *cp, char *fp, int count);
 182 static void sllin_master_receive_buf(struct tty_struct *tty,
 183                               const unsigned char *cp, char *fp, int count);
 184
 185
 186 /* Values of two parity bits in LIN Protected
 187    Identifier for each particular LIN ID */
 188 const unsigned char sllin_id_parity_table[] = {
 189         0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
 190         0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
 191         0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
 192         0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
 193         0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
 194         0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
 195         0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
 196         0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
 197 };
 198
 199 /**
 200  * sltty_change_speed() -- Change baudrate of Serial device belonging
 201  *                         to particular @tty
 202  *
 203  * @tty:        Pointer to TTY to change speed for.
 204  * @speed:      Integer value of new speed. It is possible to
 205  *              assign non-standard values, i.e. those which
 206  *              are not defined in termbits.h.
 207  */
 208 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
 209 {
 210         struct ktermios old_termios, termios;
 211         int cflag;
 212
 213 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
 214         mutex_lock(&tty->termios_mutex);
 215 #else
 216         down_write(&tty->termios_rwsem);
 217 #endif
 218
 219 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
 220         old_termios = termios = *(tty->termios);
 221 #else
 222         old_termios = termios = tty->termios;
 223 #endif
 224
 225         cflag = CS8 | CREAD | CLOCAL | HUPCL;
 226         cflag &= ~(CBAUD | CIBAUD);
 227         cflag |= BOTHER;
 228         termios.c_cflag = cflag;
 229         termios.c_oflag = 0;
 230         termios.c_lflag = 0;
 231
 232         /* Enable interrupt when UART-Break or Framing error received */
 233         termios.c_iflag = BRKINT | INPCK;
 234 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
 235         *(tty->termios) = termios;
 236 #else
 237         tty->termios = termios;
 238 #endif
 239
 240         tty_encode_baud_rate(tty, speed, speed);
 241
 242         if (tty->ops->set_termios)
 243                 tty->ops->set_termios(tty, &old_termios);
 244
 245 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
 246         mutex_unlock(&tty->termios_mutex);
 247 #else
 248         up_write(&tty->termios_rwsem);
 249 #endif
 250
 251         return 0;
 252 }
 253
 254 /* Send one can_frame to the network layer */
 255 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
 256 {
 257         struct sk_buff *skb;
 258         struct can_frame cf;
 259
 260         cf.can_id = id;
 261         cf.can_dlc = len;
 262         if (cf.can_dlc > 0)
 263                 memcpy(&cf.data, data, cf.can_dlc);
 264
 265         skb = dev_alloc_skb(sizeof(struct can_frame));
 266         if (!skb)
 267                 return;
 268
 269         skb->dev = sl->dev;
 270         skb->protocol = htons(ETH_P_CAN);
 271         skb->pkt_type = PACKET_BROADCAST;
 272         skb->ip_summed = CHECKSUM_UNNECESSARY;
 273         memcpy(skb_put(skb, sizeof(struct can_frame)),
 274                &cf, sizeof(struct can_frame));
 275         netif_rx(skb);
 276
 277         sl->dev->stats.rx_packets++;
 278         sl->dev->stats.rx_bytes += cf.can_dlc;
 279 }
 280
 281 /**
 282  * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
 283  *               as CAN frame
 284  *
 285  * @sl:
 286  */
 287 static void sll_bump(struct sllin *sl)
 288 {
 289         int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
 290         len = (len < 0) ? 0 : len;
 291
 292         sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
 293                 sl->rx_buff + SLLIN_BUFF_DATA, len);
 294 }
 295
 296 static void sll_send_rtr(struct sllin *sl)
 297 {
 298         sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
 299                 CAN_RTR_FLAG, NULL, 0);
 300 }
 301
 302 /*
 303  * Called by the driver when there's room for more data.  If we have
 304  * more packets to send, we send them here.
 305  */
 306 static void sllin_write_wakeup(struct tty_struct *tty)
 307 {
 308         int actual = 0;
 309         int remains;
 310         struct sllin *sl = (struct sllin *) tty->disc_data;
 311
 312         /* First make sure we're connected. */
 313         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 314                 return;
 315
 316         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 317         do {
 318                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 319                         return; /* ongoing concurrent processing */
 320
 321                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 322
 323 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
 324                 smp_mb__after_clear_bit();
 325 #else
 326                 smp_mb__after_atomic();
 327 #endif
 328
 329                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 330                         remains = sl->tx_lim - sl->tx_cnt;
 331                 else
 332                         remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
 333
 334                 if (remains > 0) {
 335                         actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
 336                                 sl->tx_cnt - sl->tx_lim);
 337                         sl->tx_cnt += actual;
 338                         remains -= actual;
 339                 }
 340                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 341 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
 342                 smp_mb__after_clear_bit();
 343 #else
 344                 smp_mb__after_atomic();
 345 #endif
 346
 347         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 348
 349         if ((remains > 0) && (actual >= 0)) {
 350                 netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, remains %d, waiting\n",
 351                         sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
 352                 return;
 353         }
 354
 355         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 356         set_bit(SLF_TXEVENT, &sl->flags);
 357         wake_up(&sl->kwt_wq);
 358
 359         netdev_dbg(sl->dev, "sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
 360 }
 361
 362 /**
 363  * sll_xmit() -- Send a can_frame to a TTY queue.
 364  *
 365  * @skb: Pointer to Socket buffer to be sent.
 366  * @dev: Network device where @skb will be sent.
 367  */
 368 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
 369 {
 370         struct sllin *sl = netdev_priv(dev);
 371         struct can_frame *cf;
 372
 373         if (skb->len != sizeof(struct can_frame))
 374                 goto err_out;
 375
 376         spin_lock(&sl->lock);
 377         if (!netif_running(dev))  {
 378                 netdev_warn(sl->dev, "xmit: iface is down\n");
 379                 goto err_out_unlock;
 380         }
 381         if (sl->tty == NULL) {
 382                 netdev_warn(sl->dev, "xmit: no tty device connected\n");
 383                 goto err_out_unlock;
 384         }
 385
 386         cf = (struct can_frame *) skb->data;
 387         if (cf->can_id & LIN_CTRL_FRAME) {
 388                 sllin_configure_frame_cache(sl, cf);
 389                 goto free_out_unlock;
 390         }
 391
 392         netif_stop_queue(sl->dev);
 393
 394         sl->tx_req_skb = skb;
 395         set_bit(SLF_MSGEVENT, &sl->flags);
 396         wake_up(&sl->kwt_wq);
 397         spin_unlock(&sl->lock);
 398         return NETDEV_TX_OK;
 399
 400 free_out_unlock:
 401 err_out_unlock:
 402         spin_unlock(&sl->lock);
 403 err_out:
 404         kfree_skb(skb);
 405         return NETDEV_TX_OK;
 406 }
 407
 408
 409 /******************************************
 410  *   Routines looking at netdevice side.
 411  ******************************************/
 412
 413 /* Netdevice UP -> DOWN routine */
 414 static int sll_close(struct net_device *dev)
 415 {
 416         struct sllin *sl = netdev_priv(dev);
 417
 418         spin_lock_bh(&sl->lock);
 419         if (sl->tty) {
 420                 /* TTY discipline is running. */
 421                 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
 422         }
 423         netif_stop_queue(dev);
 424         sl->rx_expect = 0;
 425         sl->tx_lim    = 0;
 426         spin_unlock_bh(&sl->lock);
 427
 428         return 0;
 429 }
 430
 431 /* Netdevice DOWN -> UP routine */
 432 static int sll_open(struct net_device *dev)
 433 {
 434         struct sllin *sl = netdev_priv(dev);
 435
 436         netdev_dbg(sl->dev, "%s() invoked\n", __func__);
 437
 438         if (sl->tty == NULL)
 439                 return -ENODEV;
 440
 441         sl->flags &= (1 << SLF_INUSE);
 442         netif_start_queue(dev);
 443         return 0;
 444 }
 445
 446 /* Hook the destructor so we can free sllin devs at the right point in time */
 447 static void sll_free_netdev(struct net_device *dev)
 448 {
 449         int i = dev->base_addr;
 450         free_netdev(dev);
 451         sllin_devs[i] = NULL;
 452 }
 453
 454 static const struct net_device_ops sll_netdev_ops = {
 455         .ndo_open               = sll_open,
 456         .ndo_stop               = sll_close,
 457         .ndo_start_xmit         = sll_xmit,
 458 };
 459
 460 static void sll_setup(struct net_device *dev)
 461 {
 462         dev->netdev_ops         = &sll_netdev_ops;
 463         dev->destructor         = sll_free_netdev;
 464
 465         dev->hard_header_len    = 0;
 466         dev->addr_len           = 0;
 467         dev->tx_queue_len       = 10;
 468
 469         dev->mtu                = sizeof(struct can_frame);
 470         dev->type               = ARPHRD_CAN;
 471
 472         /* New-style flags. */
 473         dev->flags              = IFF_NOARP;
 474         dev->features           = NETIF_F_HW_CSUM; /* NETIF_F_NO_CSUM;*/
 475 }
 476
 477 /******************************************
 478   Routines looking at TTY side.
 479  ******************************************/
 480 static void sllin_master_receive_buf(struct tty_struct *tty,
 481                               const unsigned char *cp, char *fp, int count)
 482 {
 483         struct sllin *sl = (struct sllin *) tty->disc_data;
 484
 485         /* Read the characters out of the buffer */
 486         while (count--) {
 487                 if (fp && *fp++) {
 488                         netdev_dbg(sl->dev, "sllin_master_receive_buf char 0x%02x ignored "
 489                                 "due marker 0x%02x, flags 0x%lx\n",
 490                                 *cp, *(fp-1), sl->flags);
 491
 492                         /* i.e. Real error -- not Break */
 493                         if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
 494                                 set_bit(SLF_ERROR, &sl->flags);
 495                                 wake_up(&sl->kwt_wq);
 496                                 return;
 497                         }
 498                 }
 499
 500 #ifndef BREAK_BY_BAUD
 501                 /* We didn't receive Break character -- fake it! */
 502                 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
 503                         netdev_dbg(sl->dev, "LIN_RX[%d]: 0x00\n", sl->rx_cnt);
 504                         sl->rx_buff[sl->rx_cnt++] = 0x00;
 505                 }
 506 #endif /* BREAK_BY_BAUD */
 507
 508                 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
 509                         netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
 510                         sl->rx_buff[sl->rx_cnt++] = *cp++;
 511                 }
 512         }
 513
 514
 515         if (sl->rx_cnt >= sl->rx_expect) {
 516                 set_bit(SLF_RXEVENT, &sl->flags);
 517                 wake_up(&sl->kwt_wq);
 518                 netdev_dbg(sl->dev, "sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
 519         } else {
 520                 netdev_dbg(sl->dev, "sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
 521         }
 522 }
 523
 524
 525 /*****************************************
 526  *  sllin message helper routines
 527  *****************************************/
 528 /**
 529  * sllin_report_error() -- Report an error by sending CAN frame
 530  *      with particular error flag set in can_id
 531  *
 532  * @sl:
 533  * @err: Error flag to be sent.
 534  */
 535 static void sllin_report_error(struct sllin *sl, int err)
 536 {
 537         unsigned char *lin_buff;
 538         int lin_id;
 539
 540         switch (err) {
 541         case LIN_ERR_CHECKSUM:
 542                 sl->dev->stats.rx_crc_errors++;
 543                 break;
 544
 545         case LIN_ERR_RX_TIMEOUT:
 546                 sl->dev->stats.rx_errors++;
 547                 break;
 548
 549         case LIN_ERR_FRAMING:
 550                 sl->dev->stats.rx_frame_errors++;
 551                 break;
 552         }
 553
 554         lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
 555         lin_id = lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 556         sllin_send_canfr(sl, lin_id | CAN_EFF_FLAG |
 557                 (err & ~LIN_ID_MASK), NULL, 0);
 558 }
 559
 560 /**
 561  * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
 562  *
 563  * @sl:
 564  * @cf: Pointer to CAN frame sent to this driver
 565  *      holding configuration information
 566  */
 567 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
 568 {
 569         unsigned long flags;
 570         struct sllin_conf_entry *sce;
 571
 572         if (!(cf->can_id & LIN_CTRL_FRAME))
 573                 return -1;
 574
 575         sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
 576         netdev_dbg(sl->dev, "Setting frame cache with EFF CAN frame. LIN ID = %d\n",
 577                 cf->can_id & LIN_ID_MASK);
 578
 579         spin_lock_irqsave(&sl->linfr_lock, flags);
 580
 581         sce->dlc = cf->can_dlc;
 582         if (sce->dlc > SLLIN_DATA_MAX)
 583                 sce->dlc = SLLIN_DATA_MAX;
 584
 585         sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
 586         memcpy(sce->data, cf->data, cf->can_dlc);
 587
 588         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 589
 590         return 0;
 591 }
 592
 593 /**
 594  * sllin_checksum() -- Count checksum for particular data
 595  *
 596  * @data:        Pointer to the buffer containing whole LIN
 597  *               frame (i.e. including break and sync bytes).
 598  * @length:      Length of the buffer.
 599  * @enhanced_fl: Flag determining whether Enhanced or Classic
 600  *               checksum should be counted.
 601  */
 602 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
 603 {
 604         unsigned csum = 0;
 605         int i;
 606
 607         if (enhanced_fl)
 608                 i = SLLIN_BUFF_ID;
 609         else
 610                 i = SLLIN_BUFF_DATA;
 611
 612         for (; i < length; i++) {
 613                 csum += data[i];
 614                 if (csum > 255)
 615                         csum -= 255;
 616         }
 617
 618         return ~csum & 0xff;
 619 }
 620
 621 #define SLLIN_STPMSG_RESPONLY           (1) /* Message will be LIN Response only */
 622 #define SLLIN_STPMSG_CHCKSUM_CLS        (1 << 1)
 623 #define SLLIN_STPMSG_CHCKSUM_ENH        (1 << 2)
 624
 625 static int sllin_setup_msg(struct sllin *sl, int mode, int id,
 626                 unsigned char *data, int len)
 627 {
 628         if (id > LIN_ID_MASK)
 629                 return -1;
 630
 631         if (!(mode & SLLIN_STPMSG_RESPONLY)) {
 632                 sl->rx_cnt = 0;
 633                 sl->tx_cnt = 0;
 634                 sl->rx_expect = 0;
 635                 sl->rx_lim = SLLIN_BUFF_LEN;
 636         }
 637
 638         sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
 639         sl->tx_buff[SLLIN_BUFF_SYNC]  = 0x55;
 640         sl->tx_buff[SLLIN_BUFF_ID]    = id | sllin_id_parity_table[id];
 641         sl->tx_lim = SLLIN_BUFF_DATA;
 642
 643         if ((data != NULL) && len) {
 644                 sl->tx_lim += len;
 645                 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
 646                 sl->tx_buff[sl->tx_lim] = sllin_checksum(sl->tx_buff,
 647                                 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
 648                 sl->tx_lim++;
 649         }
 650         if (len != 0)
 651                 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
 652
 653         return 0;
 654 }
 655
 656 static void sllin_reset_buffs(struct sllin *sl)
 657 {
 658         sl->rx_cnt = 0;
 659         sl->rx_expect = 0;
 660         sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
 661         sl->tx_cnt = 0;
 662         sl->tx_lim = 0;
 663         sl->id_to_send = false;
 664         sl->data_to_send = false;
 665 }
 666
 667 /**
 668  * sllin_rx_validate() -- Validate received frame, i,e. check checksum
 669  *
 670  * @sl:
 671  */
 672 static int sllin_rx_validate(struct sllin *sl)
 673 {
 674         unsigned long flags;
 675         int actual_id;
 676         int ext_chcks_fl;
 677         int lin_dlc;
 678         unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
 679         struct sllin_conf_entry *sce;
 680
 681         actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 682         sce = &sl->linfr_cache[actual_id];
 683
 684         spin_lock_irqsave(&sl->linfr_lock, flags);
 685         lin_dlc = sce->dlc;
 686         ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
 687         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 688
 689         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
 690                 rec_chcksm) {
 691
 692                 /* Type of checksum is configured for particular frame */
 693                 if (lin_dlc > 0) {
 694                         return -1;
 695                 } else {
 696                         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
 697                                 !ext_chcks_fl) != rec_chcksm) {
 698                                 return -1;
 699                         }
 700                 }
 701         }
 702
 703         return 0;
 704 }
 705
 706 static void sllin_slave_finish_rx_msg(struct sllin *sl)
 707 {
 708         if (sllin_rx_validate(sl) == -1) {
 709                 netdev_dbg(sl->dev, "sllin: RX validation failed.\n");
 710                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
 711         } else {
 712                 /* Send CAN non-RTR frame with data */
 713                 netdev_dbg(sl->dev, "sllin: sending NON-RTR CAN frame with LIN payload.");
 714                 sll_bump(sl); /* send packet to the network layer */
 715         }
 716         /* Prepare for reception of new header */
 717         sl->rx_cnt = 0;
 718         sl->rx_expect = SLLIN_BUFF_ID + 1;
 719         sl->rx_len_unknown = false; /* We do know exact length of the header */
 720         sl->header_received = false;
 721 }
 722
 723 static void sllin_slave_receive_buf(struct tty_struct *tty,
 724                               const unsigned char *cp, char *fp, int count)
 725 {
 726         struct sllin *sl = (struct sllin *) tty->disc_data;
 727         int lin_id;
 728         struct sllin_conf_entry *sce;
 729
 730
 731         /* Read the characters out of the buffer */
 732         while (count--) {
 733                 if (fp && *fp++) {
 734                         /*
 735                          * If we don't know the length of the current message
 736                          * and received at least the LIN ID, we received here
 737                          * the break of the next message.
 738                          * Evaluate the previous one before continuing.
 739                          */
 740                         if ((sl->rx_len_unknown == true) &&
 741                                 (sl->rx_cnt >= SLLIN_BUFF_ID))
 742                         {
 743                                 hrtimer_cancel(&sl->rx_timer);
 744                                 sllin_slave_finish_rx_msg(sl);
 745
 746                                 set_bit(SLF_RXEVENT, &sl->flags);
 747                                 wake_up(&sl->kwt_wq);
 748                         }
 749
 750                         netdev_dbg(sl->dev, "sllin_slave_receive_buf char 0x%02x ignored "
 751                                 "due marker 0x%02x, flags 0x%lx\n",
 752                                 *cp, *(fp-1), sl->flags);
 753
 754                         /* Received Break */
 755                         sl->rx_cnt = 0;
 756                         sl->rx_expect = SLLIN_BUFF_ID + 1;
 757                         sl->rx_len_unknown = false; /* We do know exact length of the header */
 758                         sl->header_received = false;
 759                 }
 760
 761                 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
 762                         netdev_dbg(sl->dev, "LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
 763
 764                         /* We did not receive break (0x00) character */
 765                         if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
 766                                 sl->rx_buff[sl->rx_cnt++] = 0x00;
 767                         }
 768
 769                         if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
 770                                 /* 'Duplicated' break character -- ignore */
 771                                 if (*cp == 0x00) {
 772                                         cp++;
 773                                         continue;
 774                                 }
 775
 776                                 /* Wrong sync character */
 777                                 if (*cp != 0x55)
 778                                         break;
 779                         }
 780
 781                         sl->rx_buff[sl->rx_cnt++] = *cp++;
 782                 }
 783
 784                 /* Header received */
 785                 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
 786                         unsigned long flags;
 787
 788                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 789                         sce = &sl->linfr_cache[lin_id];
 790
 791                         spin_lock_irqsave(&sl->linfr_lock, flags);
 792
 793                         sl->lin_state = SLSTATE_ID_RECEIVED;
 794                         /* Is the length of data set in frame cache? */
 795                         if (sce->dlc > 0) {
 796                                 sl->rx_expect += sce->dlc + 1; /* + checksum */
 797                                 sl->rx_len_unknown = false;
 798                                 wake_up(&sl->kwt_wq);
 799                         } else {
 800                                 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 801                                 sl->rx_len_unknown = true;
 802                         }
 803                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 804
 805                         sl->header_received = true;
 806
 807                         hrtimer_start(&sl->rx_timer,
 808                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
 809                                 HRTIMER_MODE_ABS);
 810                         sll_send_rtr(sl);
 811                         continue;
 812                 }
 813
 814                 /* Response received */
 815                 if ((sl->header_received == true) &&
 816                         ((sl->rx_cnt >= sl->rx_expect))) {
 817
 818                         hrtimer_cancel(&sl->rx_timer);
 819                         netdev_dbg(sl->dev, "Received LIN header & LIN response. "
 820                                         "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
 821                                         sl->rx_expect);
 822                         sllin_slave_finish_rx_msg(sl);
 823
 824                         set_bit(SLF_RXEVENT, &sl->flags);
 825                         wake_up(&sl->kwt_wq);
 826                 }
 827         }
 828 }
 829
 830 static void sllin_receive_buf(struct tty_struct *tty,
 831                               const unsigned char *cp, char *fp, int count)
 832 {
 833         struct sllin *sl = (struct sllin *) tty->disc_data;
 834         netdev_dbg(sl->dev, "sllin_receive_buf invoked, count = %u\n", count);
 835
 836         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 837                 return;
 838
 839         if (sl->lin_master)
 840                 sllin_master_receive_buf(tty, cp, fp, count);
 841         else
 842                 sllin_slave_receive_buf(tty, cp, fp, count);
 843
 844 }
 845
 846 static int sllin_send_tx_buff(struct sllin *sl)
 847 {
 848         struct tty_struct *tty = sl->tty;
 849         int remains;
 850         int res;
 851
 852         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 853         do {
 854                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 855                         return 0;       /* ongoing concurrent processing */
 856
 857                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 858 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
 859                 smp_mb__after_clear_bit();
 860 #else
 861                 smp_mb__after_atomic();
 862 #endif
 863
 864 #ifdef BREAK_BY_BAUD
 865                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 866                         remains = sl->tx_lim - sl->tx_cnt;
 867                 else
 868                         remains = 1;
 869 #else
 870                 remains = sl->tx_lim - sl->tx_cnt;
 871 #endif
 872
 873                 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 874                 if (res < 0)
 875                         goto error_in_write;
 876
 877                 remains -= res;
 878                 sl->tx_cnt += res;
 879
 880                 if (remains > 0) {
 881                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 882                         res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 883                         if (res < 0) {
 884                                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 885                                 goto error_in_write;
 886                         }
 887
 888                         remains -= res;
 889                         sl->tx_cnt += res;
 890                 }
 891
 892                 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
 893                                 sl->tx_cnt, remains);
 894
 895                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 896 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
 897                 smp_mb__after_clear_bit();
 898 #else
 899                 smp_mb__after_atomic();
 900 #endif
 901
 902         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 903
 904         return 0;
 905
 906 error_in_write:
 907         clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 908         return -1;
 909
 910 }
 911
 912 #ifdef BREAK_BY_BAUD
 913 static int sllin_send_break(struct sllin *sl)
 914 {
 915         struct tty_struct *tty = sl->tty;
 916         unsigned long break_baud;
 917         int res;
 918
 919         break_baud = ((sl->lin_baud * 2) / 3);
 920         sltty_change_speed(tty, break_baud);
 921
 922         tty->ops->flush_buffer(tty);
 923         sl->rx_cnt = SLLIN_BUFF_BREAK;
 924
 925         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 926         sl->lin_state = SLSTATE_BREAK_SENT;
 927
 928         res = sllin_send_tx_buff(sl);
 929         if (res < 0) {
 930                 sl->lin_state = SLSTATE_IDLE;
 931                 return res;
 932         }
 933
 934         return 0;
 935 }
 936 #else /* BREAK_BY_BAUD */
 937
 938 static int sllin_send_break(struct sllin *sl)
 939 {
 940         struct tty_struct *tty = sl->tty;
 941         int retval;
 942         unsigned long break_baud;
 943         unsigned long usleep_range_min;
 944         unsigned long usleep_range_max;
 945
 946         break_baud = ((sl->lin_baud * 2) / 3);
 947         sl->rx_cnt = SLLIN_BUFF_BREAK;
 948         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 949         sl->lin_state = SLSTATE_BREAK_SENT;
 950
 951         /* Do the break ourselves; Inspired by
 952            http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
 953         retval = tty->ops->break_ctl(tty, -1);
 954         if (retval)
 955                 return retval;
 956
 957         /* udelay(712); */
 958         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
 959         usleep_range_max = usleep_range_min + 50;
 960         usleep_range(usleep_range_min, usleep_range_max);
 961
 962         retval = tty->ops->break_ctl(tty, 0);
 963         usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
 964         usleep_range_max = usleep_range_min + 30;
 965         usleep_range(usleep_range_min, usleep_range_max);
 966
 967         tty->ops->flush_buffer(tty);
 968
 969         sl->tx_cnt = SLLIN_BUFF_SYNC;
 970
 971         netdev_dbg(sl->dev, "Break sent.\n");
 972         set_bit(SLF_RXEVENT, &sl->flags);
 973         wake_up(&sl->kwt_wq);
 974
 975         return 0;
 976 }
 977 #endif /* BREAK_BY_BAUD */
 978
 979
 980 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
 981 {
 982         struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
 983
 984         /*
 985          * Signal timeout when:
 986          * master: We did not receive as much characters as expected
 987          * slave: * we did not receive any data bytes at all
 988          *        * we know the length and didn't receive enough
 989          */
 990         if ((sl->lin_master) ||
 991                         (sl->rx_cnt <= SLLIN_BUFF_DATA) ||
 992                         ((!sl->rx_len_unknown) &&
 993                         (sl->rx_cnt < sl->rx_expect))) {
 994                 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
 995                 set_bit(SLF_TMOUTEVENT, &sl->flags);
 996         } else {
 997                 sllin_slave_finish_rx_msg(sl);
 998                 set_bit(SLF_RXEVENT, &sl->flags);
 999         }
1000         wake_up(&sl->kwt_wq);
1001
1002         return HRTIMER_NORESTART;
1003 }
1004
1005 /*****************************************
1006  *  sllin_kwthread - kernel worker thread
1007  *****************************************/
1008
1009 static int sllin_kwthread(void *ptr)
1010 {
1011         struct sllin *sl = (struct sllin *)ptr;
1012         struct tty_struct *tty = sl->tty;
1013         struct sched_param schparam = { .sched_priority = 40 };
1014         int tx_bytes = 0; /* Used for Network statistics */
1015         unsigned long flags;
1016         int mode;
1017         int lin_id;
1018         struct sllin_conf_entry *sce;
1019
1020         netdev_dbg(sl->dev, "sllin_kwthread started.\n");
1021         sched_setscheduler(current, SCHED_FIFO, &schparam);
1022
1023         clear_bit(SLF_ERROR, &sl->flags);
1024         sltty_change_speed(tty, sl->lin_baud);
1025
1026         while (!kthread_should_stop()) {
1027                 struct can_frame *cf;
1028                 u8 *lin_data;
1029                 int lin_dlc;
1030                 u8 lin_data_buff[SLLIN_DATA_MAX];
1031
1032
1033                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
1034                         sl->id_to_send) {
1035                         if (sllin_send_break(sl) < 0) {
1036                                 /* error processing */
1037                         }
1038                 }
1039
1040                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
1041                         test_bit(SLF_RXEVENT, &sl->flags) ||
1042                         test_bit(SLF_TXEVENT, &sl->flags) ||
1043                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
1044                         test_bit(SLF_ERROR, &sl->flags) ||
1045                         (sl->lin_state == SLSTATE_ID_RECEIVED) ||
1046                         (((sl->lin_state == SLSTATE_IDLE) ||
1047                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
1048                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
1049
1050                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1051                         netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1052                 }
1053
1054                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1055                         unsigned long usleep_range_min;
1056                         unsigned long usleep_range_max;
1057                         hrtimer_cancel(&sl->rx_timer);
1058                         netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1059
1060                         if (sl->lin_state != SLSTATE_IDLE)
1061                                 sllin_report_error(sl, LIN_ERR_FRAMING);
1062
1063                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1064                                                 sl->lin_baud;
1065                         usleep_range_max = usleep_range_min + 50;
1066                         usleep_range(usleep_range_min, usleep_range_max);
1067                         sllin_reset_buffs(sl);
1068                         sl->lin_state = SLSTATE_IDLE;
1069                 }
1070
1071                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1072                         netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1073                 }
1074
1075                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1076                         netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1077                         sllin_reset_buffs(sl);
1078
1079                         sl->lin_state = SLSTATE_IDLE;
1080                 }
1081
1082                 switch (sl->lin_state) {
1083                 case SLSTATE_IDLE:
1084                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
1085                                 break;
1086
1087                         mode = 0;
1088                         cf = (struct can_frame *)sl->tx_req_skb->data;
1089
1090                         if (cf->can_id & LIN_CHECKSUM_EXTENDED)
1091                                 mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1092
1093                         /* SFF RTR CAN frame -> LIN header */
1094                         if (cf->can_id & CAN_RTR_FLAG) {
1095                                 struct sllin_conf_entry *sce;
1096
1097                                 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1098                                         __func__, cf->can_id & LIN_ID_MASK);
1099
1100                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1101                                 spin_lock_irqsave(&sl->linfr_lock, flags);
1102                                 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1103                                         mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1104
1105                                 /* Is there Slave response in linfr_cache to be sent? */
1106                                 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1107                                         && (sce->dlc > 0)) {
1108
1109                                         if (sce->frame_fl & LIN_SINGLE_RESPONSE)
1110                                                 sce->frame_fl &= ~LIN_CACHE_RESPONSE;
1111
1112                                         netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1113
1114                                         lin_data = sce->data;
1115                                         lin_dlc = sce->dlc;
1116                                         if (lin_dlc > SLLIN_DATA_MAX)
1117                                                 lin_dlc = SLLIN_DATA_MAX;
1118                                         memcpy(lin_data_buff, lin_data, lin_dlc);
1119                                         lin_data = lin_data_buff;
1120                                 } else {
1121                                         lin_data = NULL;
1122                                         lin_dlc = sce->dlc;
1123                                 }
1124                                 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1125
1126                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1127                                 struct sllin_conf_entry *sce;
1128
1129                                 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1130                                         __func__, (int)cf->can_id & LIN_ID_MASK);
1131
1132                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1133                                 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1134                                         mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1135
1136                                 lin_data = cf->data;
1137                                 lin_dlc = cf->can_dlc;
1138                                 if (lin_dlc > SLLIN_DATA_MAX)
1139                                         lin_dlc = SLLIN_DATA_MAX;
1140                                 tx_bytes = lin_dlc;
1141                         }
1142
1143                         if (sllin_setup_msg(sl, mode, cf->can_id & LIN_ID_MASK,
1144                                 lin_data, lin_dlc) != -1) {
1145
1146                                 sl->id_to_send = true;
1147                                 sl->data_to_send = (lin_data != NULL) ? true : false;
1148                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1149                                 sl->dev->stats.tx_packets++;
1150                                 sl->dev->stats.tx_bytes += tx_bytes;
1151                         }
1152
1153                         clear_bit(SLF_MSGEVENT, &sl->flags);
1154                         kfree_skb(sl->tx_req_skb);
1155                         netif_wake_queue(sl->dev);
1156                         hrtimer_start(&sl->rx_timer,
1157                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
1158                                 HRTIMER_MODE_ABS);
1159                         break;
1160
1161                 case SLSTATE_BREAK_SENT:
1162 #ifdef BREAK_BY_BAUD
1163                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1164                                 continue;
1165
1166                         res = sltty_change_speed(tty, sl->lin_baud);
1167 #endif
1168
1169                         sl->lin_state = SLSTATE_ID_SENT;
1170                         sllin_send_tx_buff(sl);
1171                         break;
1172
1173                 case SLSTATE_ID_SENT:
1174                         hrtimer_cancel(&sl->rx_timer);
1175                         sl->id_to_send = false;
1176                         if (sl->data_to_send) {
1177                                 sllin_send_tx_buff(sl);
1178                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1179                                 sl->rx_expect = sl->tx_lim;
1180                                 goto slstate_response_sent;
1181                         } else {
1182                                 if (sl->resp_len_known) {
1183                                         sl->rx_expect = sl->rx_lim;
1184                                 } else {
1185                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
1186                                 }
1187                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1188                                 /* If we don't receive anything, timer will "unblock" us */
1189                                 hrtimer_start(&sl->rx_timer,
1190                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1191                                         HRTIMER_MODE_ABS);
1192                                 goto slstate_response_wait;
1193                         }
1194                         break;
1195
1196                 case SLSTATE_RESPONSE_WAIT:
1197 slstate_response_wait:
1198                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1199                                 unsigned char *lin_buff;
1200                                 cf = (struct can_frame *)sl->tx_req_skb->data;
1201
1202                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1203                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1204                                         hrtimer_cancel(&sl->rx_timer);
1205                                         netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1206                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1207                                                 cf->can_id & LIN_ID_MASK,
1208                                                 cf->data, cf->can_dlc) != -1) {
1209
1210                                                 sl->rx_expect = sl->tx_lim;
1211                                                 sl->data_to_send = true;
1212                                                 sl->dev->stats.tx_packets++;
1213                                                 sl->dev->stats.tx_bytes += tx_bytes;
1214
1215                                                 if (!sl->lin_master) {
1216                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1217                                                 }
1218
1219                                                 sllin_send_tx_buff(sl);
1220                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1221                                                 kfree_skb(sl->tx_req_skb);
1222                                                 netif_wake_queue(sl->dev);
1223
1224                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1225                                                 goto slstate_response_sent;
1226                                         }
1227                                 } else {
1228                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1229                                 }
1230                         }
1231
1232                         /* Be aware, no BREAK here */
1233                 case SLSTATE_RESPONSE_WAIT_BUS:
1234                         if (sl->rx_cnt < sl->rx_expect)
1235                                 continue;
1236
1237                         hrtimer_cancel(&sl->rx_timer);
1238                         netdev_dbg(sl->dev, "response received ID %d len %d\n",
1239                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1240
1241                         if (sllin_rx_validate(sl) == -1) {
1242                                 netdev_dbg(sl->dev, "RX validation failed.\n");
1243                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1244                         } else {
1245                                 /* Send CAN non-RTR frame with data */
1246                                 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1247                                 sll_bump(sl); /* send packet to the network layer */
1248                         }
1249
1250                         sl->id_to_send = false;
1251                         sl->lin_state = SLSTATE_IDLE;
1252                         break;
1253
1254                 case SLSTATE_ID_RECEIVED:
1255                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1256                         sce = &sl->linfr_cache[lin_id];
1257                         spin_lock_irqsave(&sl->linfr_lock, flags);
1258
1259                         if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1260                                         && (sce->dlc > 0)) {
1261
1262                                 if (sce->frame_fl & LIN_SINGLE_RESPONSE)
1263                                         sce->frame_fl &= ~LIN_CACHE_RESPONSE;
1264
1265                                 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1266
1267                                 lin_data = sce->data;
1268                                 lin_dlc = sce->dlc;
1269                                 if (lin_dlc > SLLIN_DATA_MAX)
1270                                         lin_dlc = SLLIN_DATA_MAX;
1271                                 memcpy(lin_data_buff, lin_data, lin_dlc);
1272                                 lin_data = lin_data_buff;
1273                                 tx_bytes = lin_dlc;
1274
1275                                 mode = SLLIN_STPMSG_RESPONLY;
1276                                 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1277                                         mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1278
1279                                 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1280                                         lin_data, lin_dlc) != -1) {
1281
1282                                         sl->rx_expect = sl->tx_lim;
1283                                         sl->data_to_send = true;
1284                                         sl->dev->stats.tx_packets++;
1285                                         sl->dev->stats.tx_bytes += tx_bytes;
1286                                         sl->resp_len_known = true;
1287
1288                                         if (!sl->lin_master) {
1289                                                 sl->tx_cnt = SLLIN_BUFF_DATA;
1290                                         }
1291                                         sllin_send_tx_buff(sl);
1292                                 }
1293
1294                                 hrtimer_start(&sl->rx_timer,
1295                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1296                                         HRTIMER_MODE_ABS);
1297                         }
1298                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
1299                         sl->lin_state = SLSTATE_IDLE;
1300                         break;
1301
1302                 case SLSTATE_RESPONSE_SENT:
1303 slstate_response_sent:
1304                         if (sl->rx_cnt < sl->tx_lim)
1305                                 continue;
1306
1307                         hrtimer_cancel(&sl->rx_timer);
1308                         sll_bump(sl); /* send packet to the network layer */
1309                         netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1310                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1311
1312                         sl->id_to_send = false;
1313                         sl->lin_state = SLSTATE_IDLE;
1314                         break;
1315                 }
1316         }
1317
1318         hrtimer_cancel(&sl->rx_timer);
1319         netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1320
1321         return 0;
1322 }
1323
1324
1325 /************************************
1326  *  sllin_open helper routines.
1327  ************************************/
1328
1329 /* Collect hanged up channels */
1330 static void sll_sync(void)
1331 {
1332         int i;
1333         struct net_device *dev;
1334         struct sllin      *sl;
1335
1336         for (i = 0; i < maxdev; i++) {
1337                 dev = sllin_devs[i];
1338                 if (dev == NULL)
1339                         break;
1340
1341                 sl = netdev_priv(dev);
1342                 if (sl->tty)
1343                         continue;
1344                 if (dev->flags & IFF_UP)
1345                         dev_close(dev);
1346         }
1347 }
1348
1349 /* Find a free SLLIN channel, and link in this `tty' line. */
1350 static struct sllin *sll_alloc(dev_t line)
1351 {
1352         int i;
1353         struct net_device *dev = NULL;
1354         struct sllin       *sl;
1355
1356         if (sllin_devs == NULL)
1357                 return NULL;    /* Master array missing ! */
1358
1359         for (i = 0; i < maxdev; i++) {
1360                 dev = sllin_devs[i];
1361                 if (dev == NULL)
1362                         break;
1363
1364         }
1365
1366         /* Sorry, too many, all slots in use */
1367         if (i >= maxdev)
1368                 return NULL;
1369
1370         if (dev) {
1371                 sl = netdev_priv(dev);
1372                 if (test_bit(SLF_INUSE, &sl->flags)) {
1373                         unregister_netdevice(dev);
1374                         dev = NULL;
1375                         sllin_devs[i] = NULL;
1376                 }
1377         }
1378
1379         if (!dev) {
1380                 char name[IFNAMSIZ];
1381                 sprintf(name, "sllin%d", i);
1382
1383 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0))
1384                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1385 #else
1386                 dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sll_setup);
1387 #endif
1388
1389                 if (!dev)
1390                         return NULL;
1391                 dev->base_addr  = i;
1392         }
1393
1394         sl = netdev_priv(dev);
1395         /* Initialize channel control data */
1396         sl->magic = SLLIN_MAGIC;
1397         sl->dev = dev;
1398         spin_lock_init(&sl->lock);
1399         spin_lock_init(&sl->linfr_lock);
1400         sllin_devs[i] = dev;
1401
1402         return sl;
1403 }
1404
1405 /*
1406  * Open the high-level part of the SLLIN channel.
1407  * This function is called by the TTY module when the
1408  * SLLIN line discipline is called for.  Because we are
1409  * sure the tty line exists, we only have to link it to
1410  * a free SLLIN channel...
1411  *
1412  * Called in process context serialized from other ldisc calls.
1413  */
1414
1415 static int sllin_open(struct tty_struct *tty)
1416 {
1417         struct sllin *sl;
1418         int err;
1419
1420         pr_debug("sllin: %s() invoked\n", __func__);
1421
1422         if (!capable(CAP_NET_ADMIN))
1423                 return -EPERM;
1424
1425         if (tty->ops->write == NULL)
1426                 return -EOPNOTSUPP;
1427
1428         /* RTnetlink lock is misused here to serialize concurrent
1429            opens of sllin channels. There are better ways, but it is
1430            the simplest one.
1431          */
1432         rtnl_lock();
1433
1434         /* Collect hanged up channels. */
1435         sll_sync();
1436
1437         sl = tty->disc_data;
1438
1439         err = -EEXIST;
1440         /* First make sure we're not already connected. */
1441         if (sl && sl->magic == SLLIN_MAGIC)
1442                 goto err_exit;
1443
1444         /* OK.  Find a free SLLIN channel to use. */
1445         err = -ENFILE;
1446         sl = sll_alloc(tty_devnum(tty));
1447         if (sl == NULL)
1448                 goto err_exit;
1449
1450         sl->tty = tty;
1451         tty->disc_data = sl;
1452         sl->line = tty_devnum(tty);
1453
1454         if (!test_bit(SLF_INUSE, &sl->flags)) {
1455                 /* Perform the low-level SLLIN initialization. */
1456                 sl->lin_master = master;
1457                 if (master)
1458                         pr_debug("sllin: Configured as MASTER\n");
1459                 else
1460                         pr_debug("sllin: Configured as SLAVE\n");
1461
1462                 sllin_reset_buffs(sl);
1463
1464                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1465                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1466
1467                 sl->lin_state = SLSTATE_IDLE;
1468
1469                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1470                 sl->rx_timer.function = sllin_rx_timeout_handler;
1471                 /* timeval_to_ktime(msg_head->ival1); */
1472                 sl->rx_timer_timeout = ns_to_ktime(
1473                         (1000000000l / sl->lin_baud) *
1474                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1475
1476                 set_bit(SLF_INUSE, &sl->flags);
1477
1478                 init_waitqueue_head(&sl->kwt_wq);
1479                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1480                 if (sl->kwthread == NULL)
1481                         goto err_free_chan;
1482
1483                 err = register_netdevice(sl->dev);
1484                 if (err)
1485                         goto err_free_chan_and_thread;
1486         }
1487
1488         /* Done.  We have linked the TTY line to a channel. */
1489         rtnl_unlock();
1490         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1491
1492         /* TTY layer expects 0 on success */
1493         return 0;
1494
1495 err_free_chan_and_thread:
1496         kthread_stop(sl->kwthread);
1497         sl->kwthread = NULL;
1498
1499 err_free_chan:
1500         sl->tty = NULL;
1501         tty->disc_data = NULL;
1502         clear_bit(SLF_INUSE, &sl->flags);
1503
1504 err_exit:
1505         rtnl_unlock();
1506
1507         /* Count references from TTY module */
1508         return err;
1509 }
1510
1511 /*
1512  * Close down a SLLIN channel.
1513  * This means flushing out any pending queues, and then returning. This
1514  * call is serialized against other ldisc functions.
1515  *
1516  * We also use this method for a hangup event.
1517  */
1518
1519 static void sllin_close(struct tty_struct *tty)
1520 {
1521         struct sllin *sl = (struct sllin *) tty->disc_data;
1522
1523         /* First make sure we're connected. */
1524         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1525                 return;
1526
1527         kthread_stop(sl->kwthread);
1528         sl->kwthread = NULL;
1529
1530         tty->disc_data = NULL;
1531         sl->tty = NULL;
1532
1533         /* Flush network side */
1534         unregister_netdev(sl->dev);
1535         /* This will complete via sl_free_netdev */
1536 }
1537
1538 static int sllin_hangup(struct tty_struct *tty)
1539 {
1540         sllin_close(tty);
1541         return 0;
1542 }
1543
1544 /* Perform I/O control on an active SLLIN channel. */
1545 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1546                        unsigned int cmd, unsigned long arg)
1547 {
1548         struct sllin *sl = (struct sllin *) tty->disc_data;
1549         unsigned int tmp;
1550
1551         /* First make sure we're connected. */
1552         if (!sl || sl->magic != SLLIN_MAGIC)
1553                 return -EINVAL;
1554
1555         switch (cmd) {
1556         case SIOCGIFNAME:
1557                 tmp = strlen(sl->dev->name) + 1;
1558                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1559                         return -EFAULT;
1560                 return 0;
1561
1562         case SIOCSIFHWADDR:
1563                 return -EINVAL;
1564
1565         default:
1566                 return tty_mode_ioctl(tty, file, cmd, arg);
1567         }
1568 }
1569
1570 static struct tty_ldisc_ops sll_ldisc = {
1571         .owner          = THIS_MODULE,
1572         .magic          = TTY_LDISC_MAGIC,
1573         .name           = "sllin",
1574         .open           = sllin_open,
1575         .close          = sllin_close,
1576         .hangup         = sllin_hangup,
1577         .ioctl          = sllin_ioctl,
1578         .receive_buf    = sllin_receive_buf,
1579         .write_wakeup   = sllin_write_wakeup,
1580 };
1581
1582 static int __init sllin_init(void)
1583 {
1584         int status;
1585
1586         if (maxdev < 4)
1587                 maxdev = 4; /* Sanity */
1588
1589         printk(banner);
1590         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1591
1592         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1593         if (!sllin_devs) {
1594                 pr_err("sllin: can't allocate sllin device array!\n");
1595                 return -ENOMEM;
1596         }
1597
1598         /* Fill in our line protocol discipline, and register it */
1599         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1600         if (status)  {
1601                 pr_err("sllin: can't register line discipline\n");
1602                 kfree(sllin_devs);
1603         }
1604
1605 #ifdef BREAK_BY_BAUD
1606         pr_debug("sllin: Break is generated by baud-rate change.");
1607 #else
1608         pr_debug("sllin: Break is generated manually with tiny sleep.");
1609 #endif
1610
1611         return status;
1612 }
1613
1614 static void __exit sllin_exit(void)
1615 {
1616         int i;
1617         struct net_device *dev;
1618         struct sllin *sl;
1619         unsigned long timeout = jiffies + HZ;
1620         int busy = 0;
1621
1622         if (sllin_devs == NULL)
1623                 return;
1624
1625         /* First of all: check for active disciplines and hangup them.
1626          */
1627         do {
1628                 if (busy)
1629                         msleep_interruptible(100);
1630
1631                 busy = 0;
1632                 for (i = 0; i < maxdev; i++) {
1633                         dev = sllin_devs[i];
1634                         if (!dev)
1635                                 continue;
1636                         sl = netdev_priv(dev);
1637                         spin_lock_bh(&sl->lock);
1638                         if (sl->tty) {
1639                                 busy++;
1640                                 tty_hangup(sl->tty);
1641                         }
1642                         spin_unlock_bh(&sl->lock);
1643                 }
1644         } while (busy && time_before(jiffies, timeout));
1645
1646         /* FIXME: hangup is async so we should wait when doing this second
1647            phase */
1648
1649         for (i = 0; i < maxdev; i++) {
1650                 dev = sllin_devs[i];
1651                 if (!dev)
1652                         continue;
1653                 sllin_devs[i] = NULL;
1654
1655                 sl = netdev_priv(dev);
1656                 if (sl->tty) {
1657                         netdev_dbg(sl->dev, "tty discipline still running\n");
1658                         /* Intentionally leak the control block. */
1659                         dev->destructor = NULL;
1660                 }
1661
1662                 unregister_netdev(dev);
1663         }
1664
1665         kfree(sllin_devs);
1666         sllin_devs = NULL;
1667
1668         i = tty_unregister_ldisc(N_SLLIN);
1669         if (i)
1670                 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1671 }
1672
1673 module_init(sllin_init);
1674 module_exit(sllin_exit);