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                                 sl->rx_buff[sl->rx_cnt++] = 0x55;
 528                                 cp++;
 529                         }
 530
 531                         if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
 532                                 /* 'Duplicated' break character -- ignore */
 533                                 if ((*cp == 0x00) && (*(cp + 1) == 0x55)) {
 534                                         cp++;
 535                                         continue;
 536                                 }
 537
 538                                 /* Wrong sync character */
 539                                 if (*cp != 0x55)
 540                                         break;
 541                         }
 542
 543                         sl->rx_buff[sl->rx_cnt++] = *cp++;
 544                 }
 545
 546                 /* Header received */
 547                 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
 548                         unsigned long flags;
 549
 550                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 551                         sce = &sl->linfr_cache[lin_id];
 552
 553                         spin_lock_irqsave(&sl->linfr_lock, flags);
 554                         /* Is the length of data set in frame cache? */
 555                         if (sce->frame_fl & LIN_LOC_SLAVE_CACHE) {
 556                                 sl->rx_expect += sce->dlc;
 557                                 sl->rx_len_unknown = false;
 558                         } else {
 559                                 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 560                                 sl->rx_len_unknown = true;
 561                         }
 562                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 563
 564                         sl->header_received = true;
 565                         sll_send_rtr(sl);
 566                         continue;
 567                 }
 568
 569                 /* Response received */
 570                 if ((sl->header_received == true) &&
 571                         ((sl->rx_cnt >= sl->rx_expect) ||
 572                         ((sl->rx_len_unknown == true) && (count == 0)))) {
 573
 574                         sll_bump(sl);
 575                         pr_debug("sllin: Received LIN header & LIN response. "
 576                                         "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
 577                                         sl->rx_expect);
 578
 579                         /* Prepare for reception of new header */
 580                         sl->rx_cnt = 0;
 581                         sl->rx_expect = SLLIN_BUFF_ID + 1;
 582                         sl->rx_len_unknown = false; /* We do know exact length of the header */
 583                         sl->header_received = false;
 584                 }
 585         }
 586 }
 587
 588 static void sllin_receive_buf(struct tty_struct *tty,
 589                               const unsigned char *cp, char *fp, int count)
 590 {
 591         struct sllin *sl = (struct sllin *) tty->disc_data;
 592         pr_debug("sllin: sllin_receive_buf invoked, count = %u\n", count);
 593
 594         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 595                 return;
 596
 597         if (sl->lin_master)
 598                 sllin_master_receive_buf(tty, cp, fp, count);
 599         else
 600                 sllin_slave_receive_buf(tty, cp, fp, count);
 601
 602 }
 603
 604 /*****************************************
 605  *  sllin message helper routines
 606  *****************************************/
 607 /**
 608  * sllin_report_error() -- Report an error by sending CAN frame
 609  *      with particular error flag set in can_id
 610  *
 611  * @sl:
 612  * @err: Error flag to be sent.
 613  */
 614 void sllin_report_error(struct sllin *sl, int err)
 615 {
 616         switch (err) {
 617         case LIN_ERR_CHECKSUM:
 618                 sl->dev->stats.rx_crc_errors++;
 619                 break;
 620
 621         case LIN_ERR_RX_TIMEOUT:
 622                 sl->dev->stats.rx_errors++;
 623                 break;
 624
 625         case LIN_ERR_FRAMING:
 626                 sl->dev->stats.rx_frame_errors++;
 627                 break;
 628         }
 629
 630         sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
 631                 (err & ~LIN_ID_MASK), NULL, 0);
 632 }
 633
 634 /**
 635  * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
 636  *
 637  * @sl:
 638  * @cf: Pointer to CAN frame sent to this driver
 639  *      holding configuration information
 640  */
 641 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
 642 {
 643         unsigned long flags;
 644         struct sllin_conf_entry *sce;
 645
 646         if (!(cf->can_id & LIN_ID_CONF))
 647                 return -1;
 648
 649         sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
 650         pr_debug("sllin: Setting frame cache with EFF CAN frame. "
 651                 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
 652
 653         spin_lock_irqsave(&sl->linfr_lock, flags);
 654
 655         sce->dlc = cf->can_dlc;
 656         if (sce->dlc > SLLIN_DATA_MAX)
 657                 sce->dlc = SLLIN_DATA_MAX;
 658
 659         sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
 660         memcpy(sce->data, cf->data, cf->can_dlc);
 661
 662         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 663
 664         return 0;
 665 }
 666
 667 /**
 668  * sllin_checksum() -- Count checksum for particular data
 669  *
 670  * @data:        Pointer to the buffer containing whole LIN
 671  *               frame (i.e. including break and sync bytes).
 672  * @length:      Length of the buffer.
 673  * @enhanced_fl: Flag determining whether Enhanced or Classic
 674  *               checksum should be counted.
 675  */
 676 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
 677 {
 678         unsigned csum = 0;
 679         int i;
 680
 681         if (enhanced_fl)
 682                 i = SLLIN_BUFF_ID;
 683         else
 684                 i = SLLIN_BUFF_DATA;
 685
 686         for (; i < length; i++) {
 687                 csum += data[i];
 688                 if (csum > 255)
 689                         csum -= 255;
 690         }
 691
 692         return ~csum & 0xff;
 693 }
 694
 695 #define SLLIN_STPMSG_RESPONLY           (1) /* Message will be LIN Response only */
 696 #define SLLIN_STPMSG_CHCKSUM_CLS        (1 << 1)
 697 #define SLLIN_STPMSG_CHCKSUM_ENH        (1 << 2)
 698
 699 int sllin_setup_msg(struct sllin *sl, int mode, int id,
 700                 unsigned char *data, int len)
 701 {
 702         if (id > LIN_ID_MASK)
 703                 return -1;
 704
 705         if (!(mode & SLLIN_STPMSG_RESPONLY)) {
 706                 sl->rx_cnt = 0;
 707                 sl->tx_cnt = 0;
 708                 sl->rx_expect = 0;
 709                 sl->rx_lim = SLLIN_BUFF_LEN;
 710         }
 711
 712         sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
 713         sl->tx_buff[SLLIN_BUFF_SYNC]  = 0x55;
 714         sl->tx_buff[SLLIN_BUFF_ID]    = id | sllin_id_parity_table[id];
 715         sl->tx_lim = SLLIN_BUFF_DATA;
 716
 717         if ((data != NULL) && len) {
 718                 sl->tx_lim += len;
 719                 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
 720                 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
 721                                 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
 722         }
 723         if (len != 0)
 724                 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
 725
 726         return 0;
 727 }
 728
 729 static void sllin_reset_buffs(struct sllin *sl)
 730 {
 731         sl->rx_cnt = 0;
 732         sl->rx_expect = 0;
 733         sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
 734         sl->tx_cnt = 0;
 735         sl->tx_lim = 0;
 736         sl->id_to_send = false;
 737         sl->data_to_send = false;
 738 }
 739
 740 int sllin_send_tx_buff(struct sllin *sl)
 741 {
 742         struct tty_struct *tty = sl->tty;
 743         int remains;
 744         int res;
 745
 746         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 747         do {
 748                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 749                         return 0;       /* ongoing concurrent processing */
 750
 751                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 752                 smp_mb__after_clear_bit();
 753
 754 #ifdef BREAK_BY_BAUD
 755                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 756                         remains = sl->tx_lim - sl->tx_cnt;
 757                 else
 758                         remains = 1;
 759 #else
 760                 remains = sl->tx_lim - sl->tx_cnt;
 761 #endif
 762
 763                 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 764                 if (res < 0)
 765                         goto error_in_write;
 766
 767                 remains -= res;
 768                 sl->tx_cnt += res;
 769
 770                 if (remains > 0) {
 771                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 772                         res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 773                         if (res < 0) {
 774                                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 775                                 goto error_in_write;
 776                         }
 777
 778                         remains -= res;
 779                         sl->tx_cnt += res;
 780                 }
 781
 782                 pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
 783                                 sl->tx_cnt, remains);
 784
 785                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 786                 smp_mb__after_clear_bit();
 787
 788         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 789
 790         return 0;
 791
 792 error_in_write:
 793         clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 794         return -1;
 795
 796 }
 797
 798 #ifdef BREAK_BY_BAUD
 799 int sllin_send_break(struct sllin *sl)
 800 {
 801         struct tty_struct *tty = sl->tty;
 802         unsigned long break_baud;
 803         int res;
 804
 805         break_baud = ((sl->lin_baud * 2) / 3);
 806         sltty_change_speed(tty, break_baud);
 807
 808         tty->ops->flush_buffer(tty);
 809         sl->rx_cnt = SLLIN_BUFF_BREAK;
 810
 811         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 812         sl->lin_state = SLSTATE_BREAK_SENT;
 813
 814         res = sllin_send_tx_buff(sl);
 815         if (res < 0) {
 816                 sl->lin_state = SLSTATE_IDLE;
 817                 return res;
 818         }
 819
 820         return 0;
 821 }
 822 #else /* BREAK_BY_BAUD */
 823
 824 int sllin_send_break(struct sllin *sl)
 825 {
 826         struct tty_struct *tty = sl->tty;
 827         int retval;
 828         unsigned long break_baud;
 829         unsigned long usleep_range_min;
 830         unsigned long usleep_range_max;
 831
 832         break_baud = ((sl->lin_baud * 2) / 3);
 833         sl->rx_cnt = SLLIN_BUFF_BREAK;
 834         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 835         sl->lin_state = SLSTATE_BREAK_SENT;
 836
 837         /* Do the break ourselves; Inspired by
 838            http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
 839         retval = tty->ops->break_ctl(tty, -1);
 840         if (retval)
 841                 return retval;
 842
 843         /* udelay(712); */
 844         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
 845         usleep_range_max = usleep_range_min + 50;
 846         usleep_range(usleep_range_min, usleep_range_max);
 847
 848         retval = tty->ops->break_ctl(tty, 0);
 849         usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
 850         usleep_range_max = usleep_range_min + 30;
 851         usleep_range(usleep_range_min, usleep_range_max);
 852
 853         tty->ops->flush_buffer(tty);
 854
 855         sl->tx_cnt = SLLIN_BUFF_SYNC;
 856
 857         pr_debug("sllin: Break sent.\n");
 858         set_bit(SLF_RXEVENT, &sl->flags);
 859         wake_up(&sl->kwt_wq);
 860
 861         return 0;
 862 }
 863 #endif /* BREAK_BY_BAUD */
 864
 865
 866 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
 867 {
 868         struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
 869
 870         sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
 871         set_bit(SLF_TMOUTEVENT, &sl->flags);
 872         wake_up(&sl->kwt_wq);
 873
 874         return HRTIMER_NORESTART;
 875 }
 876
 877 /**
 878  * sllin_rx_validate() -- Validate received frame, i,e. check checksum
 879  *
 880  * @sl:
 881  */
 882 static int sllin_rx_validate(struct sllin *sl)
 883 {
 884         unsigned long flags;
 885         int actual_id;
 886         int ext_chcks_fl;
 887         int lin_dlc;
 888         unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
 889         struct sllin_conf_entry *sce;
 890
 891         actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 892         sce = &sl->linfr_cache[actual_id];
 893
 894         spin_lock_irqsave(&sl->linfr_lock, flags);
 895         lin_dlc = sce->dlc;
 896         ext_chcks_fl = sce->frame_fl & LIN_CHECKSUM_EXTENDED;
 897         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 898
 899         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
 900                 rec_chcksm) {
 901
 902                 /* Type of checksum is configured for particular frame */
 903                 if (lin_dlc > 0) {
 904                         return -1;
 905                 } else {
 906                         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
 907                                 !ext_chcks_fl) != rec_chcksm) {
 908                                 return -1;
 909                         }
 910                 }
 911         }
 912
 913         return 0;
 914 }
 915
 916 /*****************************************
 917  *  sllin_kwthread - kernel worker thread
 918  *****************************************/
 919
 920 int sllin_kwthread(void *ptr)
 921 {
 922         struct sllin *sl = (struct sllin *)ptr;
 923         struct tty_struct *tty = sl->tty;
 924         struct sched_param schparam = { .sched_priority = 40 };
 925         int tx_bytes = 0; /* Used for Network statistics */
 926
 927
 928         pr_debug("sllin: sllin_kwthread started.\n");
 929         sched_setscheduler(current, SCHED_FIFO, &schparam);
 930
 931         clear_bit(SLF_ERROR, &sl->flags);
 932         sltty_change_speed(tty, sl->lin_baud);
 933
 934         while (!kthread_should_stop()) {
 935                 struct can_frame *cf;
 936                 u8 *lin_data;
 937                 int lin_dlc;
 938                 u8 lin_data_buff[SLLIN_DATA_MAX];
 939
 940
 941                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
 942                         sl->id_to_send) {
 943                         if (sllin_send_break(sl) < 0) {
 944                                 /* error processing */
 945                         }
 946                 }
 947
 948                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
 949                         test_bit(SLF_RXEVENT, &sl->flags) ||
 950                         test_bit(SLF_TXEVENT, &sl->flags) ||
 951                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
 952                         test_bit(SLF_ERROR, &sl->flags) ||
 953                         (((sl->lin_state == SLSTATE_IDLE) ||
 954                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
 955                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
 956
 957                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
 958                         pr_debug("sllin: sllin_kthread RXEVENT\n");
 959                 }
 960
 961                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
 962                         unsigned long usleep_range_min;
 963                         unsigned long usleep_range_max;
 964                         hrtimer_cancel(&sl->rx_timer);
 965                         pr_debug("sllin: sllin_kthread ERROR\n");
 966
 967                         if (sl->lin_state != SLSTATE_IDLE)
 968                                 sllin_report_error(sl, LIN_ERR_FRAMING);
 969
 970                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
 971                                                 sl->lin_baud;
 972                         usleep_range_max = usleep_range_min + 50;
 973                         usleep_range(usleep_range_min, usleep_range_max);
 974                         sllin_reset_buffs(sl);
 975                         sl->lin_state = SLSTATE_IDLE;
 976                 }
 977
 978                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
 979                         pr_debug("sllin: sllin_kthread TXEVENT\n");
 980                 }
 981
 982                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
 983                         pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
 984                         sllin_reset_buffs(sl);
 985
 986                         sl->lin_state = SLSTATE_IDLE;
 987                 }
 988
 989                 switch (sl->lin_state) {
 990                 case SLSTATE_IDLE:
 991                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
 992                                 break;
 993
 994                         cf = (struct can_frame *)sl->tx_req_skb->data;
 995
 996                         /* SFF RTR CAN frame -> LIN header */
 997                         if (cf->can_id & CAN_RTR_FLAG) {
 998                                 unsigned long flags;
 999                                 struct sllin_conf_entry *sce;
1000
1001                                 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
1002                                         __func__, cf->can_id & LIN_ID_MASK);
1003
1004                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1005                                 spin_lock_irqsave(&sl->linfr_lock, flags);
1006
1007                                 /* Is there Slave response in linfr_cache to be sent? */
1008                                 if ((sce->frame_fl & LIN_LOC_SLAVE_CACHE)
1009                                         && (sce->dlc > 0)) {
1010
1011                                         pr_debug("sllin: Sending LIN response from linfr_cache\n");
1012
1013                                         lin_data = sce->data;
1014                                         lin_dlc = sce->dlc;
1015                                         if (lin_dlc > SLLIN_DATA_MAX)
1016                                                 lin_dlc = SLLIN_DATA_MAX;
1017                                         memcpy(lin_data_buff, lin_data, lin_dlc);
1018                                         lin_data = lin_data_buff;
1019                                 } else {
1020                                         lin_data = NULL;
1021                                         lin_dlc = sce->dlc;
1022                                 }
1023                                 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1024
1025                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1026                                 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
1027                                         __func__, (int)cf->can_id & LIN_ID_MASK);
1028
1029                                 lin_data = cf->data;
1030                                 lin_dlc = cf->can_dlc;
1031                                 if (lin_dlc > SLLIN_DATA_MAX)
1032                                         lin_dlc = SLLIN_DATA_MAX;
1033                                 tx_bytes = lin_dlc;
1034                         }
1035
1036                         if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1037                                 lin_data, lin_dlc) != -1) {
1038
1039                                 sl->id_to_send = true;
1040                                 sl->data_to_send = (lin_data != NULL) ? true : false;
1041                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1042                                 sl->dev->stats.tx_packets++;
1043                                 sl->dev->stats.tx_bytes += tx_bytes;
1044                         }
1045
1046                         clear_bit(SLF_MSGEVENT, &sl->flags);
1047                         kfree_skb(sl->tx_req_skb);
1048                         netif_wake_queue(sl->dev);
1049                         hrtimer_start(&sl->rx_timer,
1050                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
1051                                 HRTIMER_MODE_ABS);
1052                         break;
1053
1054                 case SLSTATE_BREAK_SENT:
1055 #ifdef BREAK_BY_BAUD
1056                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1057                                 continue;
1058
1059                         res = sltty_change_speed(tty, sl->lin_baud);
1060 #endif
1061
1062                         sl->lin_state = SLSTATE_ID_SENT;
1063                         sllin_send_tx_buff(sl);
1064                         break;
1065
1066                 case SLSTATE_ID_SENT:
1067                         hrtimer_cancel(&sl->rx_timer);
1068                         sl->id_to_send = false;
1069                         if (sl->data_to_send) {
1070                                 sllin_send_tx_buff(sl);
1071                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1072                                 sl->rx_expect = sl->tx_lim;
1073                                 goto slstate_response_sent;
1074                         } else {
1075                                 if (sl->resp_len_known) {
1076                                         sl->rx_expect = sl->rx_lim;
1077                                 } else {
1078                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
1079                                 }
1080                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1081                                 /* If we don't receive anything, timer will "unblock" us */
1082                                 hrtimer_start(&sl->rx_timer,
1083                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1084                                         HRTIMER_MODE_ABS);
1085                                 goto slstate_response_wait;
1086                         }
1087                         break;
1088
1089                 case SLSTATE_RESPONSE_WAIT:
1090 slstate_response_wait:
1091                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1092                                 unsigned char *lin_buff;
1093                                 cf = (struct can_frame *)sl->tx_req_skb->data;
1094
1095                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1096                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1097                                         hrtimer_cancel(&sl->rx_timer);
1098                                         pr_debug("sllin: received LIN response in a CAN frame.\n");
1099                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1100                                                 cf->can_id & LIN_ID_MASK,
1101                                                 cf->data, cf->can_dlc) != -1) {
1102
1103                                                 sl->rx_expect = sl->tx_lim;
1104                                                 sl->data_to_send = true;
1105                                                 sl->dev->stats.tx_packets++;
1106                                                 sl->dev->stats.tx_bytes += tx_bytes;
1107
1108                                                 if (!sl->lin_master) {
1109                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1110                                                 }
1111
1112                                                 sllin_send_tx_buff(sl);
1113                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1114                                                 kfree_skb(sl->tx_req_skb);
1115                                                 netif_wake_queue(sl->dev);
1116
1117                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1118                                                 goto slstate_response_sent;
1119                                         }
1120                                 } else {
1121                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1122                                 }
1123                         }
1124
1125                         /* Be aware, no BREAK here */
1126                 case SLSTATE_RESPONSE_WAIT_BUS:
1127                         if (sl->rx_cnt < sl->rx_expect)
1128                                 continue;
1129
1130                         hrtimer_cancel(&sl->rx_timer);
1131                         pr_debug("sllin: response received ID %d len %d\n",
1132                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1133
1134                         if (sllin_rx_validate(sl) == -1) {
1135                                 pr_debug("sllin: RX validation failed.\n");
1136                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1137                         } else {
1138                                 /* Send CAN non-RTR frame with data */
1139                                 pr_debug("sllin: sending NON-RTR CAN"
1140                                         "frame with LIN payload.");
1141                                 sll_bump(sl); /* send packet to the network layer */
1142                         }
1143
1144                         sl->id_to_send = false;
1145                         sl->lin_state = SLSTATE_IDLE;
1146                         break;
1147
1148                 case SLSTATE_RESPONSE_SENT:
1149 slstate_response_sent:
1150                         if (sl->rx_cnt < sl->tx_lim)
1151                                 continue;
1152
1153                         hrtimer_cancel(&sl->rx_timer);
1154                         sll_bump(sl); /* send packet to the network layer */
1155                         pr_debug("sllin: response sent ID %d len %d\n",
1156                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1157
1158                         sl->id_to_send = false;
1159                         sl->lin_state = SLSTATE_IDLE;
1160                         break;
1161                 }
1162         }
1163
1164         hrtimer_cancel(&sl->rx_timer);
1165         pr_debug("sllin: sllin_kwthread stopped.\n");
1166
1167         return 0;
1168 }
1169
1170
1171 /************************************
1172  *  sllin_open helper routines.
1173  ************************************/
1174
1175 /* Collect hanged up channels */
1176 static void sll_sync(void)
1177 {
1178         int i;
1179         struct net_device *dev;
1180         struct sllin      *sl;
1181
1182         for (i = 0; i < maxdev; i++) {
1183                 dev = sllin_devs[i];
1184                 if (dev == NULL)
1185                         break;
1186
1187                 sl = netdev_priv(dev);
1188                 if (sl->tty)
1189                         continue;
1190                 if (dev->flags & IFF_UP)
1191                         dev_close(dev);
1192         }
1193 }
1194
1195 /* Find a free SLLIN channel, and link in this `tty' line. */
1196 static struct sllin *sll_alloc(dev_t line)
1197 {
1198         int i;
1199         struct net_device *dev = NULL;
1200         struct sllin       *sl;
1201
1202         if (sllin_devs == NULL)
1203                 return NULL;    /* Master array missing ! */
1204
1205         for (i = 0; i < maxdev; i++) {
1206                 dev = sllin_devs[i];
1207                 if (dev == NULL)
1208                         break;
1209
1210         }
1211
1212         /* Sorry, too many, all slots in use */
1213         if (i >= maxdev)
1214                 return NULL;
1215
1216         if (dev) {
1217                 sl = netdev_priv(dev);
1218                 if (test_bit(SLF_INUSE, &sl->flags)) {
1219                         unregister_netdevice(dev);
1220                         dev = NULL;
1221                         sllin_devs[i] = NULL;
1222                 }
1223         }
1224
1225         if (!dev) {
1226                 char name[IFNAMSIZ];
1227                 sprintf(name, "sllin%d", i);
1228
1229                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1230                 if (!dev)
1231                         return NULL;
1232                 dev->base_addr  = i;
1233         }
1234
1235         sl = netdev_priv(dev);
1236         /* Initialize channel control data */
1237         sl->magic = SLLIN_MAGIC;
1238         sl->dev = dev;
1239         spin_lock_init(&sl->lock);
1240         spin_lock_init(&sl->linfr_lock);
1241         sllin_devs[i] = dev;
1242
1243         return sl;
1244 }
1245
1246 /*
1247  * Open the high-level part of the SLLIN channel.
1248  * This function is called by the TTY module when the
1249  * SLLIN line discipline is called for.  Because we are
1250  * sure the tty line exists, we only have to link it to
1251  * a free SLLIN channel...
1252  *
1253  * Called in process context serialized from other ldisc calls.
1254  */
1255
1256 static int sllin_open(struct tty_struct *tty)
1257 {
1258         struct sllin *sl;
1259         int err;
1260         pr_debug("sllin: %s() invoked\n", __func__);
1261
1262         if (!capable(CAP_NET_ADMIN))
1263                 return -EPERM;
1264
1265         if (tty->ops->write == NULL)
1266                 return -EOPNOTSUPP;
1267
1268         /* RTnetlink lock is misused here to serialize concurrent
1269            opens of sllin channels. There are better ways, but it is
1270            the simplest one.
1271          */
1272         rtnl_lock();
1273
1274         /* Collect hanged up channels. */
1275         sll_sync();
1276
1277         sl = tty->disc_data;
1278
1279         err = -EEXIST;
1280         /* First make sure we're not already connected. */
1281         if (sl && sl->magic == SLLIN_MAGIC)
1282                 goto err_exit;
1283
1284         /* OK.  Find a free SLLIN channel to use. */
1285         err = -ENFILE;
1286         sl = sll_alloc(tty_devnum(tty));
1287         if (sl == NULL)
1288                 goto err_exit;
1289
1290         sl->tty = tty;
1291         tty->disc_data = sl;
1292         sl->line = tty_devnum(tty);
1293
1294         if (!test_bit(SLF_INUSE, &sl->flags)) {
1295                 /* Perform the low-level SLLIN initialization. */
1296                 sl->lin_master = master;
1297 #ifdef DEBUG
1298                 if (master)
1299                         pr_debug("sllin: Configured as MASTER\n");
1300                 else
1301                         pr_debug("sllin: Configured as SLAVE\n");
1302 #endif
1303
1304                 sllin_reset_buffs(sl);
1305
1306                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1307                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1308
1309                 sl->lin_state = SLSTATE_IDLE;
1310
1311                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1312                 sl->rx_timer.function = sllin_rx_timeout_handler;
1313                 /* timeval_to_ktime(msg_head->ival1); */
1314                 sl->rx_timer_timeout = ns_to_ktime(
1315                         (1000000000l / sl->lin_baud) *
1316                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1317
1318                 set_bit(SLF_INUSE, &sl->flags);
1319
1320                 init_waitqueue_head(&sl->kwt_wq);
1321                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1322                 if (sl->kwthread == NULL)
1323                         goto err_free_chan;
1324
1325                 err = register_netdevice(sl->dev);
1326                 if (err)
1327                         goto err_free_chan_and_thread;
1328         }
1329
1330         /* Done.  We have linked the TTY line to a channel. */
1331         rtnl_unlock();
1332         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1333
1334         /* TTY layer expects 0 on success */
1335         return 0;
1336
1337 err_free_chan_and_thread:
1338         kthread_stop(sl->kwthread);
1339         sl->kwthread = NULL;
1340
1341 err_free_chan:
1342         sl->tty = NULL;
1343         tty->disc_data = NULL;
1344         clear_bit(SLF_INUSE, &sl->flags);
1345
1346 err_exit:
1347         rtnl_unlock();
1348
1349         /* Count references from TTY module */
1350         return err;
1351 }
1352
1353 /*
1354  * Close down a SLLIN channel.
1355  * This means flushing out any pending queues, and then returning. This
1356  * call is serialized against other ldisc functions.
1357  *
1358  * We also use this method for a hangup event.
1359  */
1360
1361 static void sllin_close(struct tty_struct *tty)
1362 {
1363         struct sllin *sl = (struct sllin *) tty->disc_data;
1364
1365         /* First make sure we're connected. */
1366         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1367                 return;
1368
1369         kthread_stop(sl->kwthread);
1370         sl->kwthread = NULL;
1371
1372         tty->disc_data = NULL;
1373         sl->tty = NULL;
1374
1375         /* Flush network side */
1376         unregister_netdev(sl->dev);
1377         /* This will complete via sl_free_netdev */
1378 }
1379
1380 static int sllin_hangup(struct tty_struct *tty)
1381 {
1382         sllin_close(tty);
1383         return 0;
1384 }
1385
1386 /* Perform I/O control on an active SLLIN channel. */
1387 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1388                        unsigned int cmd, unsigned long arg)
1389 {
1390         struct sllin *sl = (struct sllin *) tty->disc_data;
1391         unsigned int tmp;
1392
1393         /* First make sure we're connected. */
1394         if (!sl || sl->magic != SLLIN_MAGIC)
1395                 return -EINVAL;
1396
1397         switch (cmd) {
1398         case SIOCGIFNAME:
1399                 tmp = strlen(sl->dev->name) + 1;
1400                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1401                         return -EFAULT;
1402                 return 0;
1403
1404         case SIOCSIFHWADDR:
1405                 return -EINVAL;
1406
1407         default:
1408                 return tty_mode_ioctl(tty, file, cmd, arg);
1409         }
1410 }
1411
1412 static struct tty_ldisc_ops sll_ldisc = {
1413         .owner          = THIS_MODULE,
1414         .magic          = TTY_LDISC_MAGIC,
1415         .name           = "sllin",
1416         .open           = sllin_open,
1417         .close          = sllin_close,
1418         .hangup         = sllin_hangup,
1419         .ioctl          = sllin_ioctl,
1420         .receive_buf    = sllin_receive_buf,
1421         .write_wakeup   = sllin_write_wakeup,
1422 };
1423
1424 static int __init sllin_init(void)
1425 {
1426         int status;
1427
1428         if (maxdev < 4)
1429                 maxdev = 4; /* Sanity */
1430
1431         printk(banner);
1432         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1433
1434         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1435         if (!sllin_devs) {
1436                 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1437                 return -ENOMEM;
1438         }
1439
1440         /* Fill in our line protocol discipline, and register it */
1441         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1442         if (status)  {
1443                 printk(KERN_ERR "sllin: can't register line discipline\n");
1444                 kfree(sllin_devs);
1445         }
1446
1447 #ifdef BREAK_BY_BAUD
1448         pr_debug("sllin: Break is generated by baud-rate change.");
1449 #else
1450         pr_debug("sllin: Break is generated manually with tiny sleep.");
1451 #endif
1452
1453         return status;
1454 }
1455
1456 static void __exit sllin_exit(void)
1457 {
1458         int i;
1459         struct net_device *dev;
1460         struct sllin *sl;
1461         unsigned long timeout = jiffies + HZ;
1462         int busy = 0;
1463
1464         if (sllin_devs == NULL)
1465                 return;
1466
1467         /* First of all: check for active disciplines and hangup them.
1468          */
1469         do {
1470                 if (busy)
1471                         msleep_interruptible(100);
1472
1473                 busy = 0;
1474                 for (i = 0; i < maxdev; i++) {
1475                         dev = sllin_devs[i];
1476                         if (!dev)
1477                                 continue;
1478                         sl = netdev_priv(dev);
1479                         spin_lock_bh(&sl->lock);
1480                         if (sl->tty) {
1481                                 busy++;
1482                                 tty_hangup(sl->tty);
1483                         }
1484                         spin_unlock_bh(&sl->lock);
1485                 }
1486         } while (busy && time_before(jiffies, timeout));
1487
1488         /* FIXME: hangup is async so we should wait when doing this second
1489            phase */
1490
1491         for (i = 0; i < maxdev; i++) {
1492                 dev = sllin_devs[i];
1493                 if (!dev)
1494                         continue;
1495                 sllin_devs[i] = NULL;
1496
1497                 sl = netdev_priv(dev);
1498                 if (sl->tty) {
1499                         printk(KERN_ERR "%s: tty discipline still running\n",
1500                                dev->name);
1501                         /* Intentionally leak the control block. */
1502                         dev->destructor = NULL;
1503                 }
1504
1505                 unregister_netdev(dev);
1506         }
1507
1508         kfree(sllin_devs);
1509         sllin_devs = NULL;
1510
1511         i = tty_unregister_ldisc(N_SLLIN);
1512         if (i)
1513                 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1514 }
1515
1516 module_init(sllin_init);
1517 module_exit(sllin_exit);