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