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