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