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 lin_id;
1017         struct sllin_conf_entry *sce;
1018
1019         netdev_dbg(sl->dev, "sllin_kwthread started.\n");
1020         sched_setscheduler(current, SCHED_FIFO, &schparam);
1021
1022         clear_bit(SLF_ERROR, &sl->flags);
1023         sltty_change_speed(tty, sl->lin_baud);
1024
1025         while (!kthread_should_stop()) {
1026                 struct can_frame *cf;
1027                 u8 *lin_data;
1028                 int lin_dlc;
1029                 u8 lin_data_buff[SLLIN_DATA_MAX];
1030
1031
1032                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
1033                         sl->id_to_send) {
1034                         if (sllin_send_break(sl) < 0) {
1035                                 /* error processing */
1036                         }
1037                 }
1038
1039                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
1040                         test_bit(SLF_RXEVENT, &sl->flags) ||
1041                         test_bit(SLF_TXEVENT, &sl->flags) ||
1042                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
1043                         test_bit(SLF_ERROR, &sl->flags) ||
1044                         (sl->lin_state == SLSTATE_ID_RECEIVED) ||
1045                         (((sl->lin_state == SLSTATE_IDLE) ||
1046                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
1047                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
1048
1049                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1050                         netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1051                 }
1052
1053                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1054                         unsigned long usleep_range_min;
1055                         unsigned long usleep_range_max;
1056                         hrtimer_cancel(&sl->rx_timer);
1057                         netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1058
1059                         if (sl->lin_state != SLSTATE_IDLE)
1060                                 sllin_report_error(sl, LIN_ERR_FRAMING);
1061
1062                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1063                                                 sl->lin_baud;
1064                         usleep_range_max = usleep_range_min + 50;
1065                         usleep_range(usleep_range_min, usleep_range_max);
1066                         sllin_reset_buffs(sl);
1067                         sl->lin_state = SLSTATE_IDLE;
1068                 }
1069
1070                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1071                         netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1072                 }
1073
1074                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1075                         netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1076                         sllin_reset_buffs(sl);
1077
1078                         sl->lin_state = SLSTATE_IDLE;
1079                 }
1080
1081                 switch (sl->lin_state) {
1082                 case SLSTATE_IDLE:
1083                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
1084                                 break;
1085
1086                         cf = (struct can_frame *)sl->tx_req_skb->data;
1087
1088                         /* SFF RTR CAN frame -> LIN header */
1089                         if (cf->can_id & CAN_RTR_FLAG) {
1090                                 struct sllin_conf_entry *sce;
1091
1092                                 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1093                                         __func__, cf->can_id & LIN_ID_MASK);
1094
1095                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1096                                 spin_lock_irqsave(&sl->linfr_lock, flags);
1097
1098                                 /* Is there Slave response in linfr_cache to be sent? */
1099                                 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1100                                         && (sce->dlc > 0)) {
1101
1102                                         netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1103
1104                                         lin_data = sce->data;
1105                                         lin_dlc = sce->dlc;
1106                                         if (lin_dlc > SLLIN_DATA_MAX)
1107                                                 lin_dlc = SLLIN_DATA_MAX;
1108                                         memcpy(lin_data_buff, lin_data, lin_dlc);
1109                                         lin_data = lin_data_buff;
1110                                 } else {
1111                                         lin_data = NULL;
1112                                         lin_dlc = sce->dlc;
1113                                 }
1114                                 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1115
1116                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1117                                 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1118                                         __func__, (int)cf->can_id & LIN_ID_MASK);
1119
1120                                 lin_data = cf->data;
1121                                 lin_dlc = cf->can_dlc;
1122                                 if (lin_dlc > SLLIN_DATA_MAX)
1123                                         lin_dlc = SLLIN_DATA_MAX;
1124                                 tx_bytes = lin_dlc;
1125                         }
1126
1127                         if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1128                                 lin_data, lin_dlc) != -1) {
1129
1130                                 sl->id_to_send = true;
1131                                 sl->data_to_send = (lin_data != NULL) ? true : false;
1132                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1133                                 sl->dev->stats.tx_packets++;
1134                                 sl->dev->stats.tx_bytes += tx_bytes;
1135                         }
1136
1137                         clear_bit(SLF_MSGEVENT, &sl->flags);
1138                         kfree_skb(sl->tx_req_skb);
1139                         netif_wake_queue(sl->dev);
1140                         hrtimer_start(&sl->rx_timer,
1141                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
1142                                 HRTIMER_MODE_ABS);
1143                         break;
1144
1145                 case SLSTATE_BREAK_SENT:
1146 #ifdef BREAK_BY_BAUD
1147                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1148                                 continue;
1149
1150                         res = sltty_change_speed(tty, sl->lin_baud);
1151 #endif
1152
1153                         sl->lin_state = SLSTATE_ID_SENT;
1154                         sllin_send_tx_buff(sl);
1155                         break;
1156
1157                 case SLSTATE_ID_SENT:
1158                         hrtimer_cancel(&sl->rx_timer);
1159                         sl->id_to_send = false;
1160                         if (sl->data_to_send) {
1161                                 sllin_send_tx_buff(sl);
1162                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1163                                 sl->rx_expect = sl->tx_lim;
1164                                 goto slstate_response_sent;
1165                         } else {
1166                                 if (sl->resp_len_known) {
1167                                         sl->rx_expect = sl->rx_lim;
1168                                 } else {
1169                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
1170                                 }
1171                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1172                                 /* If we don't receive anything, timer will "unblock" us */
1173                                 hrtimer_start(&sl->rx_timer,
1174                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1175                                         HRTIMER_MODE_ABS);
1176                                 goto slstate_response_wait;
1177                         }
1178                         break;
1179
1180                 case SLSTATE_RESPONSE_WAIT:
1181 slstate_response_wait:
1182                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1183                                 unsigned char *lin_buff;
1184                                 cf = (struct can_frame *)sl->tx_req_skb->data;
1185
1186                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1187                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1188                                         hrtimer_cancel(&sl->rx_timer);
1189                                         netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1190                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1191                                                 cf->can_id & LIN_ID_MASK,
1192                                                 cf->data, cf->can_dlc) != -1) {
1193
1194                                                 sl->rx_expect = sl->tx_lim;
1195                                                 sl->data_to_send = true;
1196                                                 sl->dev->stats.tx_packets++;
1197                                                 sl->dev->stats.tx_bytes += tx_bytes;
1198
1199                                                 if (!sl->lin_master) {
1200                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1201                                                 }
1202
1203                                                 sllin_send_tx_buff(sl);
1204                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1205                                                 kfree_skb(sl->tx_req_skb);
1206                                                 netif_wake_queue(sl->dev);
1207
1208                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1209                                                 goto slstate_response_sent;
1210                                         }
1211                                 } else {
1212                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1213                                 }
1214                         }
1215
1216                         /* Be aware, no BREAK here */
1217                 case SLSTATE_RESPONSE_WAIT_BUS:
1218                         if (sl->rx_cnt < sl->rx_expect)
1219                                 continue;
1220
1221                         hrtimer_cancel(&sl->rx_timer);
1222                         netdev_dbg(sl->dev, "response received ID %d len %d\n",
1223                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1224
1225                         if (sllin_rx_validate(sl) == -1) {
1226                                 netdev_dbg(sl->dev, "RX validation failed.\n");
1227                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1228                         } else {
1229                                 /* Send CAN non-RTR frame with data */
1230                                 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1231                                 sll_bump(sl); /* send packet to the network layer */
1232                         }
1233
1234                         sl->id_to_send = false;
1235                         sl->lin_state = SLSTATE_IDLE;
1236                         break;
1237
1238                 case SLSTATE_ID_RECEIVED:
1239                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1240                         sce = &sl->linfr_cache[lin_id];
1241                         spin_lock_irqsave(&sl->linfr_lock, flags);
1242
1243                         if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1244                                         && (sce->dlc > 0)) {
1245                                 int mode;
1246
1247                                 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1248
1249                                 lin_data = sce->data;
1250                                 lin_dlc = sce->dlc;
1251                                 if (lin_dlc > SLLIN_DATA_MAX)
1252                                         lin_dlc = SLLIN_DATA_MAX;
1253                                 memcpy(lin_data_buff, lin_data, lin_dlc);
1254                                 lin_data = lin_data_buff;
1255                                 tx_bytes = lin_dlc;
1256
1257                                 mode = SLLIN_STPMSG_RESPONLY;
1258                                 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1259                                         mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1260
1261                                 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1262                                         lin_data, lin_dlc) != -1) {
1263
1264                                         sl->rx_expect = sl->tx_lim;
1265                                         sl->data_to_send = true;
1266                                         sl->dev->stats.tx_packets++;
1267                                         sl->dev->stats.tx_bytes += tx_bytes;
1268                                         sl->resp_len_known = true;
1269
1270                                         if (!sl->lin_master) {
1271                                                 sl->tx_cnt = SLLIN_BUFF_DATA;
1272                                         }
1273                                         sllin_send_tx_buff(sl);
1274                                 }
1275
1276                                 hrtimer_start(&sl->rx_timer,
1277                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1278                                         HRTIMER_MODE_ABS);
1279                         }
1280                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
1281                         sl->lin_state = SLSTATE_IDLE;
1282                         break;
1283
1284                 case SLSTATE_RESPONSE_SENT:
1285 slstate_response_sent:
1286                         if (sl->rx_cnt < sl->tx_lim)
1287                                 continue;
1288
1289                         hrtimer_cancel(&sl->rx_timer);
1290                         sll_bump(sl); /* send packet to the network layer */
1291                         netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1292                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1293
1294                         sl->id_to_send = false;
1295                         sl->lin_state = SLSTATE_IDLE;
1296                         break;
1297                 }
1298         }
1299
1300         hrtimer_cancel(&sl->rx_timer);
1301         netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1302
1303         return 0;
1304 }
1305
1306
1307 /************************************
1308  *  sllin_open helper routines.
1309  ************************************/
1310
1311 /* Collect hanged up channels */
1312 static void sll_sync(void)
1313 {
1314         int i;
1315         struct net_device *dev;
1316         struct sllin      *sl;
1317
1318         for (i = 0; i < maxdev; i++) {
1319                 dev = sllin_devs[i];
1320                 if (dev == NULL)
1321                         break;
1322
1323                 sl = netdev_priv(dev);
1324                 if (sl->tty)
1325                         continue;
1326                 if (dev->flags & IFF_UP)
1327                         dev_close(dev);
1328         }
1329 }
1330
1331 /* Find a free SLLIN channel, and link in this `tty' line. */
1332 static struct sllin *sll_alloc(dev_t line)
1333 {
1334         int i;
1335         struct net_device *dev = NULL;
1336         struct sllin       *sl;
1337
1338         if (sllin_devs == NULL)
1339                 return NULL;    /* Master array missing ! */
1340
1341         for (i = 0; i < maxdev; i++) {
1342                 dev = sllin_devs[i];
1343                 if (dev == NULL)
1344                         break;
1345
1346         }
1347
1348         /* Sorry, too many, all slots in use */
1349         if (i >= maxdev)
1350                 return NULL;
1351
1352         if (dev) {
1353                 sl = netdev_priv(dev);
1354                 if (test_bit(SLF_INUSE, &sl->flags)) {
1355                         unregister_netdevice(dev);
1356                         dev = NULL;
1357                         sllin_devs[i] = NULL;
1358                 }
1359         }
1360
1361         if (!dev) {
1362                 char name[IFNAMSIZ];
1363                 sprintf(name, "sllin%d", i);
1364
1365 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0))
1366                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1367 #else
1368                 dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sll_setup);
1369 #endif
1370
1371                 if (!dev)
1372                         return NULL;
1373                 dev->base_addr  = i;
1374         }
1375
1376         sl = netdev_priv(dev);
1377         /* Initialize channel control data */
1378         sl->magic = SLLIN_MAGIC;
1379         sl->dev = dev;
1380         spin_lock_init(&sl->lock);
1381         spin_lock_init(&sl->linfr_lock);
1382         sllin_devs[i] = dev;
1383
1384         return sl;
1385 }
1386
1387 /*
1388  * Open the high-level part of the SLLIN channel.
1389  * This function is called by the TTY module when the
1390  * SLLIN line discipline is called for.  Because we are
1391  * sure the tty line exists, we only have to link it to
1392  * a free SLLIN channel...
1393  *
1394  * Called in process context serialized from other ldisc calls.
1395  */
1396
1397 static int sllin_open(struct tty_struct *tty)
1398 {
1399         struct sllin *sl;
1400         int err;
1401
1402         pr_debug("sllin: %s() invoked\n", __func__);
1403
1404         if (!capable(CAP_NET_ADMIN))
1405                 return -EPERM;
1406
1407         if (tty->ops->write == NULL)
1408                 return -EOPNOTSUPP;
1409
1410         /* RTnetlink lock is misused here to serialize concurrent
1411            opens of sllin channels. There are better ways, but it is
1412            the simplest one.
1413          */
1414         rtnl_lock();
1415
1416         /* Collect hanged up channels. */
1417         sll_sync();
1418
1419         sl = tty->disc_data;
1420
1421         err = -EEXIST;
1422         /* First make sure we're not already connected. */
1423         if (sl && sl->magic == SLLIN_MAGIC)
1424                 goto err_exit;
1425
1426         /* OK.  Find a free SLLIN channel to use. */
1427         err = -ENFILE;
1428         sl = sll_alloc(tty_devnum(tty));
1429         if (sl == NULL)
1430                 goto err_exit;
1431
1432         sl->tty = tty;
1433         tty->disc_data = sl;
1434         sl->line = tty_devnum(tty);
1435
1436         if (!test_bit(SLF_INUSE, &sl->flags)) {
1437                 /* Perform the low-level SLLIN initialization. */
1438                 sl->lin_master = master;
1439                 if (master)
1440                         pr_debug("sllin: Configured as MASTER\n");
1441                 else
1442                         pr_debug("sllin: Configured as SLAVE\n");
1443
1444                 sllin_reset_buffs(sl);
1445
1446                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1447                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1448
1449                 sl->lin_state = SLSTATE_IDLE;
1450
1451                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1452                 sl->rx_timer.function = sllin_rx_timeout_handler;
1453                 /* timeval_to_ktime(msg_head->ival1); */
1454                 sl->rx_timer_timeout = ns_to_ktime(
1455                         (1000000000l / sl->lin_baud) *
1456                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1457
1458                 set_bit(SLF_INUSE, &sl->flags);
1459
1460                 init_waitqueue_head(&sl->kwt_wq);
1461                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1462                 if (sl->kwthread == NULL)
1463                         goto err_free_chan;
1464
1465                 err = register_netdevice(sl->dev);
1466                 if (err)
1467                         goto err_free_chan_and_thread;
1468         }
1469
1470         /* Done.  We have linked the TTY line to a channel. */
1471         rtnl_unlock();
1472         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1473
1474         /* TTY layer expects 0 on success */
1475         return 0;
1476
1477 err_free_chan_and_thread:
1478         kthread_stop(sl->kwthread);
1479         sl->kwthread = NULL;
1480
1481 err_free_chan:
1482         sl->tty = NULL;
1483         tty->disc_data = NULL;
1484         clear_bit(SLF_INUSE, &sl->flags);
1485
1486 err_exit:
1487         rtnl_unlock();
1488
1489         /* Count references from TTY module */
1490         return err;
1491 }
1492
1493 /*
1494  * Close down a SLLIN channel.
1495  * This means flushing out any pending queues, and then returning. This
1496  * call is serialized against other ldisc functions.
1497  *
1498  * We also use this method for a hangup event.
1499  */
1500
1501 static void sllin_close(struct tty_struct *tty)
1502 {
1503         struct sllin *sl = (struct sllin *) tty->disc_data;
1504
1505         /* First make sure we're connected. */
1506         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1507                 return;
1508
1509         kthread_stop(sl->kwthread);
1510         sl->kwthread = NULL;
1511
1512         tty->disc_data = NULL;
1513         sl->tty = NULL;
1514
1515         /* Flush network side */
1516         unregister_netdev(sl->dev);
1517         /* This will complete via sl_free_netdev */
1518 }
1519
1520 static int sllin_hangup(struct tty_struct *tty)
1521 {
1522         sllin_close(tty);
1523         return 0;
1524 }
1525
1526 /* Perform I/O control on an active SLLIN channel. */
1527 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1528                        unsigned int cmd, unsigned long arg)
1529 {
1530         struct sllin *sl = (struct sllin *) tty->disc_data;
1531         unsigned int tmp;
1532
1533         /* First make sure we're connected. */
1534         if (!sl || sl->magic != SLLIN_MAGIC)
1535                 return -EINVAL;
1536
1537         switch (cmd) {
1538         case SIOCGIFNAME:
1539                 tmp = strlen(sl->dev->name) + 1;
1540                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1541                         return -EFAULT;
1542                 return 0;
1543
1544         case SIOCSIFHWADDR:
1545                 return -EINVAL;
1546
1547         default:
1548                 return tty_mode_ioctl(tty, file, cmd, arg);
1549         }
1550 }
1551
1552 static struct tty_ldisc_ops sll_ldisc = {
1553         .owner          = THIS_MODULE,
1554         .magic          = TTY_LDISC_MAGIC,
1555         .name           = "sllin",
1556         .open           = sllin_open,
1557         .close          = sllin_close,
1558         .hangup         = sllin_hangup,
1559         .ioctl          = sllin_ioctl,
1560         .receive_buf    = sllin_receive_buf,
1561         .write_wakeup   = sllin_write_wakeup,
1562 };
1563
1564 static int __init sllin_init(void)
1565 {
1566         int status;
1567
1568         if (maxdev < 4)
1569                 maxdev = 4; /* Sanity */
1570
1571         printk(banner);
1572         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1573
1574         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1575         if (!sllin_devs) {
1576                 pr_err("sllin: can't allocate sllin device array!\n");
1577                 return -ENOMEM;
1578         }
1579
1580         /* Fill in our line protocol discipline, and register it */
1581         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1582         if (status)  {
1583                 pr_err("sllin: can't register line discipline\n");
1584                 kfree(sllin_devs);
1585         }
1586
1587 #ifdef BREAK_BY_BAUD
1588         pr_debug("sllin: Break is generated by baud-rate change.");
1589 #else
1590         pr_debug("sllin: Break is generated manually with tiny sleep.");
1591 #endif
1592
1593         return status;
1594 }
1595
1596 static void __exit sllin_exit(void)
1597 {
1598         int i;
1599         struct net_device *dev;
1600         struct sllin *sl;
1601         unsigned long timeout = jiffies + HZ;
1602         int busy = 0;
1603
1604         if (sllin_devs == NULL)
1605                 return;
1606
1607         /* First of all: check for active disciplines and hangup them.
1608          */
1609         do {
1610                 if (busy)
1611                         msleep_interruptible(100);
1612
1613                 busy = 0;
1614                 for (i = 0; i < maxdev; i++) {
1615                         dev = sllin_devs[i];
1616                         if (!dev)
1617                                 continue;
1618                         sl = netdev_priv(dev);
1619                         spin_lock_bh(&sl->lock);
1620                         if (sl->tty) {
1621                                 busy++;
1622                                 tty_hangup(sl->tty);
1623                         }
1624                         spin_unlock_bh(&sl->lock);
1625                 }
1626         } while (busy && time_before(jiffies, timeout));
1627
1628         /* FIXME: hangup is async so we should wait when doing this second
1629            phase */
1630
1631         for (i = 0; i < maxdev; i++) {
1632                 dev = sllin_devs[i];
1633                 if (!dev)
1634                         continue;
1635                 sllin_devs[i] = NULL;
1636
1637                 sl = netdev_priv(dev);
1638                 if (sl->tty) {
1639                         netdev_dbg(sl->dev, "tty discipline still running\n");
1640                         /* Intentionally leak the control block. */
1641                         dev->destructor = NULL;
1642                 }
1643
1644                 unregister_netdev(dev);
1645         }
1646
1647         kfree(sllin_devs);
1648         sllin_devs = NULL;
1649
1650         i = tty_unregister_ldisc(N_SLLIN);
1651         if (i)
1652                 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1653 }
1654
1655 module_init(sllin_init);
1656 module_exit(sllin_exit);