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                 netdev_dbg(sl->dev, "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         netdev_dbg(sl->dev, "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                 netdev_warn(sl->dev, "xmit: iface is down\n");
 351                 goto err_out_unlock;
 352         }
 353         if (sl->tty == NULL) {
 354                 netdev_warn(sl->dev, "xmit: no tty device connected\n");
 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         netdev_dbg(sl->dev, "%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                         netdev_dbg(sl->dev, "sllin_master_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                         netdev_dbg(sl->dev, "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                         netdev_dbg(sl->dev, "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                 netdev_dbg(sl->dev, "sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
 491         } else {
 492                 netdev_dbg(sl->dev, "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                         netdev_dbg(sl->dev, "sllin_slave_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                         netdev_dbg(sl->dev, "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
 551                         /* Is the length of data set in frame cache? */
 552                         if (sce->frame_fl & LIN_CACHE_RESPONSE) {
 553                                 sl->rx_expect += sce->dlc + 1; /* + checksum */
 554                                 sl->rx_len_unknown = false;
 555                         } else {
 556                                 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 557                                 sl->rx_len_unknown = true;
 558                         }
 559                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 560
 561                         sl->header_received = true;
 562
 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                         netdev_dbg(sl->dev, "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         netdev_dbg(sl->dev, "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 static 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_CTRL_FRAME))
 645                 return -1;
 646
 647         sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
 648         netdev_dbg(sl->dev, "Setting frame cache with EFF CAN frame. LIN ID = %d\n",
 649                 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 static 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                 sl->tx_lim++;
 721         }
 722         if (len != 0)
 723                 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
 724
 725         return 0;
 726 }
 727
 728 static void sllin_reset_buffs(struct sllin *sl)
 729 {
 730         sl->rx_cnt = 0;
 731         sl->rx_expect = 0;
 732         sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
 733         sl->tx_cnt = 0;
 734         sl->tx_lim = 0;
 735         sl->id_to_send = false;
 736         sl->data_to_send = false;
 737 }
 738
 739 static int sllin_send_tx_buff(struct sllin *sl)
 740 {
 741         struct tty_struct *tty = sl->tty;
 742         int remains;
 743         int res;
 744
 745         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 746         do {
 747                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 748                         return 0;       /* ongoing concurrent processing */
 749
 750                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 751                 smp_mb__after_clear_bit();
 752
 753 #ifdef BREAK_BY_BAUD
 754                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 755                         remains = sl->tx_lim - sl->tx_cnt;
 756                 else
 757                         remains = 1;
 758 #else
 759                 remains = sl->tx_lim - sl->tx_cnt;
 760 #endif
 761
 762                 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 763                 if (res < 0)
 764                         goto error_in_write;
 765
 766                 remains -= res;
 767                 sl->tx_cnt += res;
 768
 769                 if (remains > 0) {
 770                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 771                         res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 772                         if (res < 0) {
 773                                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 774                                 goto error_in_write;
 775                         }
 776
 777                         remains -= res;
 778                         sl->tx_cnt += res;
 779                 }
 780
 781                 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
 782                                 sl->tx_cnt, remains);
 783
 784                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 785                 smp_mb__after_clear_bit();
 786
 787         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 788
 789         return 0;
 790
 791 error_in_write:
 792         clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 793         return -1;
 794
 795 }
 796
 797 #ifdef BREAK_BY_BAUD
 798 static int sllin_send_break(struct sllin *sl)
 799 {
 800         struct tty_struct *tty = sl->tty;
 801         unsigned long break_baud;
 802         int res;
 803
 804         break_baud = ((sl->lin_baud * 2) / 3);
 805         sltty_change_speed(tty, break_baud);
 806
 807         tty->ops->flush_buffer(tty);
 808         sl->rx_cnt = SLLIN_BUFF_BREAK;
 809
 810         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 811         sl->lin_state = SLSTATE_BREAK_SENT;
 812
 813         res = sllin_send_tx_buff(sl);
 814         if (res < 0) {
 815                 sl->lin_state = SLSTATE_IDLE;
 816                 return res;
 817         }
 818
 819         return 0;
 820 }
 821 #else /* BREAK_BY_BAUD */
 822
 823 static int sllin_send_break(struct sllin *sl)
 824 {
 825         struct tty_struct *tty = sl->tty;
 826         int retval;
 827         unsigned long break_baud;
 828         unsigned long usleep_range_min;
 829         unsigned long usleep_range_max;
 830
 831         break_baud = ((sl->lin_baud * 2) / 3);
 832         sl->rx_cnt = SLLIN_BUFF_BREAK;
 833         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 834         sl->lin_state = SLSTATE_BREAK_SENT;
 835
 836         /* Do the break ourselves; Inspired by
 837            http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
 838         retval = tty->ops->break_ctl(tty, -1);
 839         if (retval)
 840                 return retval;
 841
 842         /* udelay(712); */
 843         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
 844         usleep_range_max = usleep_range_min + 50;
 845         usleep_range(usleep_range_min, usleep_range_max);
 846
 847         retval = tty->ops->break_ctl(tty, 0);
 848         usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
 849         usleep_range_max = usleep_range_min + 30;
 850         usleep_range(usleep_range_min, usleep_range_max);
 851
 852         tty->ops->flush_buffer(tty);
 853
 854         sl->tx_cnt = SLLIN_BUFF_SYNC;
 855
 856         netdev_dbg(sl->dev, "Break sent.\n");
 857         set_bit(SLF_RXEVENT, &sl->flags);
 858         wake_up(&sl->kwt_wq);
 859
 860         return 0;
 861 }
 862 #endif /* BREAK_BY_BAUD */
 863
 864
 865 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
 866 {
 867         struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
 868
 869         sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
 870         set_bit(SLF_TMOUTEVENT, &sl->flags);
 871         wake_up(&sl->kwt_wq);
 872
 873         return HRTIMER_NORESTART;
 874 }
 875
 876 /**
 877  * sllin_rx_validate() -- Validate received frame, i,e. check checksum
 878  *
 879  * @sl:
 880  */
 881 static int sllin_rx_validate(struct sllin *sl)
 882 {
 883         unsigned long flags;
 884         int actual_id;
 885         int ext_chcks_fl;
 886         int lin_dlc;
 887         unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
 888         struct sllin_conf_entry *sce;
 889
 890         actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 891         sce = &sl->linfr_cache[actual_id];
 892
 893         spin_lock_irqsave(&sl->linfr_lock, flags);
 894         lin_dlc = sce->dlc;
 895         ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
 896         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 897
 898         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
 899                 rec_chcksm) {
 900
 901                 /* Type of checksum is configured for particular frame */
 902                 if (lin_dlc > 0) {
 903                         return -1;
 904                 } else {
 905                         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
 906                                 !ext_chcks_fl) != rec_chcksm) {
 907                                 return -1;
 908                         }
 909                 }
 910         }
 911
 912         return 0;
 913 }
 914
 915 /*****************************************
 916  *  sllin_kwthread - kernel worker thread
 917  *****************************************/
 918
 919 static int sllin_kwthread(void *ptr)
 920 {
 921         struct sllin *sl = (struct sllin *)ptr;
 922         struct tty_struct *tty = sl->tty;
 923         struct sched_param schparam = { .sched_priority = 40 };
 924         int tx_bytes = 0; /* Used for Network statistics */
 925
 926
 927         netdev_dbg(sl->dev, "sllin_kwthread started.\n");
 928         sched_setscheduler(current, SCHED_FIFO, &schparam);
 929
 930         clear_bit(SLF_ERROR, &sl->flags);
 931         sltty_change_speed(tty, sl->lin_baud);
 932
 933         while (!kthread_should_stop()) {
 934                 struct can_frame *cf;
 935                 u8 *lin_data;
 936                 int lin_dlc;
 937                 u8 lin_data_buff[SLLIN_DATA_MAX];
 938
 939
 940                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
 941                         sl->id_to_send) {
 942                         if (sllin_send_break(sl) < 0) {
 943                                 /* error processing */
 944                         }
 945                 }
 946
 947                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
 948                         test_bit(SLF_RXEVENT, &sl->flags) ||
 949                         test_bit(SLF_TXEVENT, &sl->flags) ||
 950                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
 951                         test_bit(SLF_ERROR, &sl->flags) ||
 952                         (((sl->lin_state == SLSTATE_IDLE) ||
 953                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
 954                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
 955
 956                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
 957                         netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
 958                 }
 959
 960                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
 961                         unsigned long usleep_range_min;
 962                         unsigned long usleep_range_max;
 963                         hrtimer_cancel(&sl->rx_timer);
 964                         netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
 965
 966                         if (sl->lin_state != SLSTATE_IDLE)
 967                                 sllin_report_error(sl, LIN_ERR_FRAMING);
 968
 969                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
 970                                                 sl->lin_baud;
 971                         usleep_range_max = usleep_range_min + 50;
 972                         usleep_range(usleep_range_min, usleep_range_max);
 973                         sllin_reset_buffs(sl);
 974                         sl->lin_state = SLSTATE_IDLE;
 975                 }
 976
 977                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
 978                         netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
 979                 }
 980
 981                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
 982                         netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
 983                         sllin_reset_buffs(sl);
 984
 985                         sl->lin_state = SLSTATE_IDLE;
 986                 }
 987
 988                 switch (sl->lin_state) {
 989                 case SLSTATE_IDLE:
 990                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
 991                                 break;
 992
 993                         cf = (struct can_frame *)sl->tx_req_skb->data;
 994
 995                         /* SFF RTR CAN frame -> LIN header */
 996                         if (cf->can_id & CAN_RTR_FLAG) {
 997                                 unsigned long flags;
 998                                 struct sllin_conf_entry *sce;
 999
1000                                 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1001                                         __func__, cf->can_id & LIN_ID_MASK);
1002
1003                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1004                                 spin_lock_irqsave(&sl->linfr_lock, flags);
1005
1006                                 /* Is there Slave response in linfr_cache to be sent? */
1007                                 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1008                                         && (sce->dlc > 0)) {
1009
1010                                         netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1011
1012                                         lin_data = sce->data;
1013                                         lin_dlc = sce->dlc;
1014                                         if (lin_dlc > SLLIN_DATA_MAX)
1015                                                 lin_dlc = SLLIN_DATA_MAX;
1016                                         memcpy(lin_data_buff, lin_data, lin_dlc);
1017                                         lin_data = lin_data_buff;
1018                                 } else {
1019                                         lin_data = NULL;
1020                                         lin_dlc = sce->dlc;
1021                                 }
1022                                 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1023
1024                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1025                                 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1026                                         __func__, (int)cf->can_id & LIN_ID_MASK);
1027
1028                                 lin_data = cf->data;
1029                                 lin_dlc = cf->can_dlc;
1030                                 if (lin_dlc > SLLIN_DATA_MAX)
1031                                         lin_dlc = SLLIN_DATA_MAX;
1032                                 tx_bytes = lin_dlc;
1033                         }
1034
1035                         if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1036                                 lin_data, lin_dlc) != -1) {
1037
1038                                 sl->id_to_send = true;
1039                                 sl->data_to_send = (lin_data != NULL) ? true : false;
1040                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1041                                 sl->dev->stats.tx_packets++;
1042                                 sl->dev->stats.tx_bytes += tx_bytes;
1043                         }
1044
1045                         clear_bit(SLF_MSGEVENT, &sl->flags);
1046                         kfree_skb(sl->tx_req_skb);
1047                         netif_wake_queue(sl->dev);
1048                         hrtimer_start(&sl->rx_timer,
1049                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
1050                                 HRTIMER_MODE_ABS);
1051                         break;
1052
1053                 case SLSTATE_BREAK_SENT:
1054 #ifdef BREAK_BY_BAUD
1055                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1056                                 continue;
1057
1058                         res = sltty_change_speed(tty, sl->lin_baud);
1059 #endif
1060
1061                         sl->lin_state = SLSTATE_ID_SENT;
1062                         sllin_send_tx_buff(sl);
1063                         break;
1064
1065                 case SLSTATE_ID_SENT:
1066                         hrtimer_cancel(&sl->rx_timer);
1067                         sl->id_to_send = false;
1068                         if (sl->data_to_send) {
1069                                 sllin_send_tx_buff(sl);
1070                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1071                                 sl->rx_expect = sl->tx_lim;
1072                                 goto slstate_response_sent;
1073                         } else {
1074                                 if (sl->resp_len_known) {
1075                                         sl->rx_expect = sl->rx_lim;
1076                                 } else {
1077                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
1078                                 }
1079                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1080                                 /* If we don't receive anything, timer will "unblock" us */
1081                                 hrtimer_start(&sl->rx_timer,
1082                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1083                                         HRTIMER_MODE_ABS);
1084                                 goto slstate_response_wait;
1085                         }
1086                         break;
1087
1088                 case SLSTATE_RESPONSE_WAIT:
1089 slstate_response_wait:
1090                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1091                                 unsigned char *lin_buff;
1092                                 cf = (struct can_frame *)sl->tx_req_skb->data;
1093
1094                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1095                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1096                                         hrtimer_cancel(&sl->rx_timer);
1097                                         netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1098                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1099                                                 cf->can_id & LIN_ID_MASK,
1100                                                 cf->data, cf->can_dlc) != -1) {
1101
1102                                                 sl->rx_expect = sl->tx_lim;
1103                                                 sl->data_to_send = true;
1104                                                 sl->dev->stats.tx_packets++;
1105                                                 sl->dev->stats.tx_bytes += tx_bytes;
1106
1107                                                 if (!sl->lin_master) {
1108                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1109                                                 }
1110
1111                                                 sllin_send_tx_buff(sl);
1112                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1113                                                 kfree_skb(sl->tx_req_skb);
1114                                                 netif_wake_queue(sl->dev);
1115
1116                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1117                                                 goto slstate_response_sent;
1118                                         }
1119                                 } else {
1120                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1121                                 }
1122                         }
1123
1124                         /* Be aware, no BREAK here */
1125                 case SLSTATE_RESPONSE_WAIT_BUS:
1126                         if (sl->rx_cnt < sl->rx_expect)
1127                                 continue;
1128
1129                         hrtimer_cancel(&sl->rx_timer);
1130                         netdev_dbg(sl->dev, "response received ID %d len %d\n",
1131                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1132
1133                         if (sllin_rx_validate(sl) == -1) {
1134                                 netdev_dbg(sl->dev, "RX validation failed.\n");
1135                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1136                         } else {
1137                                 /* Send CAN non-RTR frame with data */
1138                                 netdev_dbg(sl->dev, "sending NON-RTR CAN 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                         netdev_dbg(sl->dev, "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         netdev_dbg(sl->dev, "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
1259         pr_debug("sllin: %s() invoked\n", __func__);
1260
1261         if (!capable(CAP_NET_ADMIN))
1262                 return -EPERM;
1263
1264         if (tty->ops->write == NULL)
1265                 return -EOPNOTSUPP;
1266
1267         /* RTnetlink lock is misused here to serialize concurrent
1268            opens of sllin channels. There are better ways, but it is
1269            the simplest one.
1270          */
1271         rtnl_lock();
1272
1273         /* Collect hanged up channels. */
1274         sll_sync();
1275
1276         sl = tty->disc_data;
1277
1278         err = -EEXIST;
1279         /* First make sure we're not already connected. */
1280         if (sl && sl->magic == SLLIN_MAGIC)
1281                 goto err_exit;
1282
1283         /* OK.  Find a free SLLIN channel to use. */
1284         err = -ENFILE;
1285         sl = sll_alloc(tty_devnum(tty));
1286         if (sl == NULL)
1287                 goto err_exit;
1288
1289         sl->tty = tty;
1290         tty->disc_data = sl;
1291         sl->line = tty_devnum(tty);
1292
1293         if (!test_bit(SLF_INUSE, &sl->flags)) {
1294                 /* Perform the low-level SLLIN initialization. */
1295                 sl->lin_master = master;
1296                 if (master)
1297                         pr_debug("sllin: Configured as MASTER\n");
1298                 else
1299                         pr_debug("sllin: Configured as SLAVE\n");
1300
1301                 sllin_reset_buffs(sl);
1302
1303                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1304                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1305
1306                 sl->lin_state = SLSTATE_IDLE;
1307
1308                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1309                 sl->rx_timer.function = sllin_rx_timeout_handler;
1310                 /* timeval_to_ktime(msg_head->ival1); */
1311                 sl->rx_timer_timeout = ns_to_ktime(
1312                         (1000000000l / sl->lin_baud) *
1313                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1314
1315                 set_bit(SLF_INUSE, &sl->flags);
1316
1317                 init_waitqueue_head(&sl->kwt_wq);
1318                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1319                 if (sl->kwthread == NULL)
1320                         goto err_free_chan;
1321
1322                 err = register_netdevice(sl->dev);
1323                 if (err)
1324                         goto err_free_chan_and_thread;
1325         }
1326
1327         /* Done.  We have linked the TTY line to a channel. */
1328         rtnl_unlock();
1329         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1330
1331         /* TTY layer expects 0 on success */
1332         return 0;
1333
1334 err_free_chan_and_thread:
1335         kthread_stop(sl->kwthread);
1336         sl->kwthread = NULL;
1337
1338 err_free_chan:
1339         sl->tty = NULL;
1340         tty->disc_data = NULL;
1341         clear_bit(SLF_INUSE, &sl->flags);
1342
1343 err_exit:
1344         rtnl_unlock();
1345
1346         /* Count references from TTY module */
1347         return err;
1348 }
1349
1350 /*
1351  * Close down a SLLIN channel.
1352  * This means flushing out any pending queues, and then returning. This
1353  * call is serialized against other ldisc functions.
1354  *
1355  * We also use this method for a hangup event.
1356  */
1357
1358 static void sllin_close(struct tty_struct *tty)
1359 {
1360         struct sllin *sl = (struct sllin *) tty->disc_data;
1361
1362         /* First make sure we're connected. */
1363         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1364                 return;
1365
1366         kthread_stop(sl->kwthread);
1367         sl->kwthread = NULL;
1368
1369         tty->disc_data = NULL;
1370         sl->tty = NULL;
1371
1372         /* Flush network side */
1373         unregister_netdev(sl->dev);
1374         /* This will complete via sl_free_netdev */
1375 }
1376
1377 static int sllin_hangup(struct tty_struct *tty)
1378 {
1379         sllin_close(tty);
1380         return 0;
1381 }
1382
1383 /* Perform I/O control on an active SLLIN channel. */
1384 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1385                        unsigned int cmd, unsigned long arg)
1386 {
1387         struct sllin *sl = (struct sllin *) tty->disc_data;
1388         unsigned int tmp;
1389
1390         /* First make sure we're connected. */
1391         if (!sl || sl->magic != SLLIN_MAGIC)
1392                 return -EINVAL;
1393
1394         switch (cmd) {
1395         case SIOCGIFNAME:
1396                 tmp = strlen(sl->dev->name) + 1;
1397                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1398                         return -EFAULT;
1399                 return 0;
1400
1401         case SIOCSIFHWADDR:
1402                 return -EINVAL;
1403
1404         default:
1405                 return tty_mode_ioctl(tty, file, cmd, arg);
1406         }
1407 }
1408
1409 static struct tty_ldisc_ops sll_ldisc = {
1410         .owner          = THIS_MODULE,
1411         .magic          = TTY_LDISC_MAGIC,
1412         .name           = "sllin",
1413         .open           = sllin_open,
1414         .close          = sllin_close,
1415         .hangup         = sllin_hangup,
1416         .ioctl          = sllin_ioctl,
1417         .receive_buf    = sllin_receive_buf,
1418         .write_wakeup   = sllin_write_wakeup,
1419 };
1420
1421 static int __init sllin_init(void)
1422 {
1423         int status;
1424
1425         if (maxdev < 4)
1426                 maxdev = 4; /* Sanity */
1427
1428         printk(banner);
1429         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1430
1431         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1432         if (!sllin_devs) {
1433                 pr_err("sllin: can't allocate sllin device array!\n");
1434                 return -ENOMEM;
1435         }
1436
1437         /* Fill in our line protocol discipline, and register it */
1438         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1439         if (status)  {
1440                 pr_err("sllin: can't register line discipline\n");
1441                 kfree(sllin_devs);
1442         }
1443
1444 #ifdef BREAK_BY_BAUD
1445         pr_debug("sllin: Break is generated by baud-rate change.");
1446 #else
1447         pr_debug("sllin: Break is generated manually with tiny sleep.");
1448 #endif
1449
1450         return status;
1451 }
1452
1453 static void __exit sllin_exit(void)
1454 {
1455         int i;
1456         struct net_device *dev;
1457         struct sllin *sl;
1458         unsigned long timeout = jiffies + HZ;
1459         int busy = 0;
1460
1461         if (sllin_devs == NULL)
1462                 return;
1463
1464         /* First of all: check for active disciplines and hangup them.
1465          */
1466         do {
1467                 if (busy)
1468                         msleep_interruptible(100);
1469
1470                 busy = 0;
1471                 for (i = 0; i < maxdev; i++) {
1472                         dev = sllin_devs[i];
1473                         if (!dev)
1474                                 continue;
1475                         sl = netdev_priv(dev);
1476                         spin_lock_bh(&sl->lock);
1477                         if (sl->tty) {
1478                                 busy++;
1479                                 tty_hangup(sl->tty);
1480                         }
1481                         spin_unlock_bh(&sl->lock);
1482                 }
1483         } while (busy && time_before(jiffies, timeout));
1484
1485         /* FIXME: hangup is async so we should wait when doing this second
1486            phase */
1487
1488         for (i = 0; i < maxdev; i++) {
1489                 dev = sllin_devs[i];
1490                 if (!dev)
1491                         continue;
1492                 sllin_devs[i] = NULL;
1493
1494                 sl = netdev_priv(dev);
1495                 if (sl->tty) {
1496                         netdev_dbg(sl->dev, "tty discipline still running\n");
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);