sllin/sllin.c

   1 /*
   2  * sllin.c - serial line LIN interface driver (using tty line discipline)
   3  *
   4  * This file is derived from drivers/net/can/slcan.c
   5  * slcan.c Author: Oliver Hartkopp <socketcan@hartkopp.net>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 59 Temple Place, Suite 330, Boston, MA 02111-1307. You can also get it
  20  * at http://www.gnu.org/licenses/gpl.html
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  33  * DAMAGE.
  34  *
  35  * Idea:       Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
  36  * Copyright:  (c) 2011 Czech Technical University in Prague
  37  *             (c) 2011 Volkswagen Group Research
  38  * Authors:    Pavel Pisa <pisa@cmp.felk.cvut.cz>
  39  *             Rostislav Lisovy <lisovy@kormus.cz>
  40  *             Michal Sojka <sojkam1@fel.cvut.cz>
  41  * Funded by:  Volkswagen Group Research
  42  */
  43
  44 #define DEBUG                   1 /* Enables pr_debug() printouts */
  45
  46 #include <linux/module.h>
  47 #include <linux/moduleparam.h>
  48
  49 #include <asm/system.h>
  50 #include <linux/uaccess.h>
  51 #include <linux/bitops.h>
  52 #include <linux/string.h>
  53 #include <linux/tty.h>
  54 #include <linux/errno.h>
  55 #include <linux/netdevice.h>
  56 #include <linux/skbuff.h>
  57 #include <linux/rtnetlink.h>
  58 #include <linux/if_arp.h>
  59 #include <linux/if_ether.h>
  60 #include <linux/sched.h>
  61 #include <linux/delay.h>
  62 #include <linux/init.h>
  63 #include <linux/can.h>
  64 #include <linux/kthread.h>
  65 #include <linux/hrtimer.h>
  66 #include "linux/lin_bus.h"
  67
  68 /* Should be in include/linux/tty.h */
  69 #define N_SLLIN                 25
  70 /* -------------------------------- */
  71
  72 static __initdata const char banner[] =
  73         KERN_INFO "sllin: serial line LIN interface driver\n";
  74
  75 MODULE_ALIAS_LDISC(N_SLLIN);
  76 MODULE_DESCRIPTION("serial line LIN interface");
  77 MODULE_LICENSE("GPL");
  78 MODULE_AUTHOR("Pavel Pisa <pisa@cmp.felk.cvut.cz>");
  79
  80 #define SLLIN_MAGIC             0x53CA
  81 /* #define BREAK_BY_BAUD */
  82
  83 static int master = true;
  84 static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
  85
  86 module_param(master, bool, 0);
  87 MODULE_PARM_DESC(master, "LIN interface is Master device");
  88 module_param(baudrate, int, 0);
  89 MODULE_PARM_DESC(baudrate, "Baudrate of LIN interface");
  90
  91 static int maxdev = 10;         /* MAX number of SLLIN channels;
  92                                    This can be overridden with
  93                                    insmod sllin.ko maxdev=nnn   */
  94 module_param(maxdev, int, 0);
  95 MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
  96
  97 /* maximum buffer len to store whole LIN message*/
  98 #define SLLIN_DATA_MAX          8
  99 #define SLLIN_BUFF_LEN          (1 /*break*/ + 1 /*sync*/ + 1 /*ID*/ + \
 100                                 SLLIN_DATA_MAX + 1 /*checksum*/)
 101 #define SLLIN_BUFF_BREAK        0
 102 #define SLLIN_BUFF_SYNC         1
 103 #define SLLIN_BUFF_ID           2
 104 #define SLLIN_BUFF_DATA         3
 105
 106 #define SLLIN_SAMPLES_PER_CHAR  10
 107 #define SLLIN_CHARS_TO_TIMEOUT  24
 108
 109 enum slstate {
 110         SLSTATE_IDLE = 0,
 111         SLSTATE_BREAK_SENT,
 112         SLSTATE_ID_SENT,
 113         SLSTATE_RESPONSE_WAIT, /* Wait for response */
 114         SLSTATE_RESPONSE_WAIT_BUS, /* Wait for response from LIN bus
 115                                 only (CAN frames from network stack
 116                                 are not processed in this moment) */
 117         SLSTATE_RESPONSE_SENT,
 118 };
 119
 120 struct sllin_conf_entry {
 121         int dlc;                /* Length of data in LIN frame */
 122         canid_t frame_fl;       /* LIN frame flags. Passed from userspace as
 123                                    canid_t data type */
 124         u8 data[8];             /* LIN frame data payload */
 125 };
 126
 127 struct sllin {
 128         int                     magic;
 129
 130         /* Various fields. */
 131         struct tty_struct       *tty;           /* ptr to TTY structure      */
 132         struct net_device       *dev;           /* easy for intr handling    */
 133         spinlock_t              lock;
 134
 135         /* LIN message buffer and actual processed data counts */
 136         unsigned char           rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
 137         unsigned char           tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
 138         int                     rx_expect;      /* expected number of Rx chars */
 139         int                     rx_lim;         /* maximum Rx chars for current frame */
 140         int                     rx_cnt;         /* message buffer Rx fill level  */
 141         int                     tx_lim;         /* actual limit of bytes to Tx */
 142         int                     tx_cnt;         /* number of already Tx bytes */
 143         char                    lin_master;     /* node is a master node */
 144         int                     lin_baud;       /* LIN baudrate */
 145         int                     lin_state;      /* state */
 146         char                    id_to_send;     /* there is ID to be sent */
 147         char                    data_to_send;   /* there are data to be sent */
 148         char                    resp_len_known; /* Length of the response is known */
 149         char                    header_received;/* In Slave mode, set when header was already
 150                                                    received */
 151         char                    rx_len_unknown; /* We are not sure how much data will be sent to us --
 152                                                    we just guess the length */
 153
 154         unsigned long           flags;          /* Flag values/ mode etc     */
 155 #define SLF_INUSE               0               /* Channel in use            */
 156 #define SLF_ERROR               1               /* Parity, etc. error        */
 157 #define SLF_RXEVENT             2               /* Rx wake event             */
 158 #define SLF_TXEVENT             3               /* Tx wake event             */
 159 #define SLF_MSGEVENT            4               /* CAN message to sent       */
 160 #define SLF_TMOUTEVENT          5               /* Timeout on received data  */
 161 #define SLF_TXBUFF_RQ           6               /* Req. to send buffer to UART*/
 162 #define SLF_TXBUFF_INPR         7               /* Above request in progress */
 163
 164         dev_t                   line;
 165         struct task_struct      *kwthread;
 166         wait_queue_head_t       kwt_wq;         /* Wait queue used by kwthread */
 167         struct hrtimer          rx_timer;       /* RX timeout timer */
 168         ktime_t                 rx_timer_timeout; /* RX timeout timer value */
 169         struct sk_buff          *tx_req_skb;    /* Socket buffer with CAN frame
 170                                                 received from network stack*/
 171
 172         /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
 173         struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
 174         spinlock_t              linfr_lock;     /* frame cache and buffers lock */
 175 };
 176
 177 static struct net_device **sllin_devs;
 178 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf);
 179 static void sllin_slave_receive_buf(struct tty_struct *tty,
 180                               const unsigned char *cp, char *fp, int count);
 181 static void sllin_master_receive_buf(struct tty_struct *tty,
 182                               const unsigned char *cp, char *fp, int count);
 183
 184
 185 /* Values of two parity bits in LIN Protected
 186    Identifier for each particular LIN ID */
 187 const unsigned char sllin_id_parity_table[] = {
 188         0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
 189         0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
 190         0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80,
 191         0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
 192         0x00, 0x40, 0xc0, 0x80, 0x40, 0x00, 0x80, 0xc0,
 193         0x80, 0xc0, 0x40, 0x00, 0xc0, 0x80, 0x00, 0x40,
 194         0xc0, 0x80, 0x00, 0x40, 0x80, 0xc0, 0x40, 0x00,
 195         0x40, 0x00, 0x80, 0xc0, 0x00, 0x40, 0xc0, 0x80
 196 };
 197
 198 /**
 199  * sltty_change_speed() -- Change baudrate of Serial device belonging
 200  *                         to particular @tty
 201  *
 202  * @tty:        Pointer to TTY to change speed for.
 203  * @speed:      Integer value of new speed. It is possible to
 204  *              assign non-standard values, i.e. those which
 205  *              are not defined in termbits.h.
 206  */
 207 static int sltty_change_speed(struct tty_struct *tty, unsigned speed)
 208 {
 209         struct ktermios old_termios;
 210         int cflag;
 211
 212         mutex_lock(&tty->termios_mutex);
 213
 214         old_termios = *(tty->termios);
 215
 216         cflag = CS8 | CREAD | CLOCAL | HUPCL;
 217         cflag &= ~(CBAUD | CIBAUD);
 218         cflag |= BOTHER;
 219         tty->termios->c_cflag = cflag;
 220         tty->termios->c_oflag = 0;
 221         tty->termios->c_lflag = 0;
 222
 223         /* Enable interrupt when UART-Break or Framing error received */
 224         tty->termios->c_iflag = BRKINT | INPCK;
 225
 226         tty_encode_baud_rate(tty, speed, speed);
 227
 228         if (tty->ops->set_termios)
 229                 tty->ops->set_termios(tty, &old_termios);
 230
 231         mutex_unlock(&tty->termios_mutex);
 232
 233         return 0;
 234 }
 235
 236 /* Send one can_frame to the network layer */
 237 static void sllin_send_canfr(struct sllin *sl, canid_t id, char *data, int len)
 238 {
 239         struct sk_buff *skb;
 240         struct can_frame cf;
 241
 242         cf.can_id = id;
 243         cf.can_dlc = len;
 244         if (cf.can_dlc > 0)
 245                 memcpy(&cf.data, data, cf.can_dlc);
 246
 247         skb = dev_alloc_skb(sizeof(struct can_frame));
 248         if (!skb)
 249                 return;
 250
 251         skb->dev = sl->dev;
 252         skb->protocol = htons(ETH_P_CAN);
 253         skb->pkt_type = PACKET_BROADCAST;
 254         skb->ip_summed = CHECKSUM_UNNECESSARY;
 255         memcpy(skb_put(skb, sizeof(struct can_frame)),
 256                &cf, sizeof(struct can_frame));
 257         netif_rx(skb);
 258
 259         sl->dev->stats.rx_packets++;
 260         sl->dev->stats.rx_bytes += cf.can_dlc;
 261 }
 262
 263 /**
 264  * sll_bump() -- Send data of received LIN frame (existing in sl->rx_buff)
 265  *               as CAN frame
 266  *
 267  * @sl:
 268  */
 269 static void sll_bump(struct sllin *sl)
 270 {
 271         int len = sl->rx_cnt - SLLIN_BUFF_DATA - 1; /* without checksum */
 272         len = (len < 0) ? 0 : len;
 273
 274         sllin_send_canfr(sl, sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK,
 275                 sl->rx_buff + SLLIN_BUFF_DATA, len);
 276 }
 277
 278 static void sll_send_rtr(struct sllin *sl)
 279 {
 280         sllin_send_canfr(sl, (sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK) |
 281                 CAN_RTR_FLAG, NULL, 0);
 282 }
 283
 284 /*
 285  * Called by the driver when there's room for more data.  If we have
 286  * more packets to send, we send them here.
 287  */
 288 static void sllin_write_wakeup(struct tty_struct *tty)
 289 {
 290         int actual = 0;
 291         int remains;
 292         struct sllin *sl = (struct sllin *) tty->disc_data;
 293
 294         /* First make sure we're connected. */
 295         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 296                 return;
 297
 298         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 299         do {
 300                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 301                         return; /* ongoing concurrent processing */
 302
 303                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 304                 smp_mb__after_clear_bit();
 305
 306                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 307                         remains = sl->tx_lim - sl->tx_cnt;
 308                 else
 309                         remains = SLLIN_BUFF_BREAK + 1 - sl->tx_cnt;
 310
 311                 if (remains > 0) {
 312                         actual = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt,
 313                                 sl->tx_cnt - sl->tx_lim);
 314                         sl->tx_cnt += actual;
 315                         remains -= actual;
 316                 }
 317                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 318                 smp_mb__after_clear_bit();
 319
 320         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 321
 322         if ((remains > 0) && (actual >= 0)) {
 323                 pr_debug("sllin: sllin_write_wakeup sent %d, "
 324                         "remains %d, waiting\n",
 325                         sl->tx_cnt, sl->tx_lim - sl->tx_cnt);
 326                 return;
 327         }
 328
 329         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 330         set_bit(SLF_TXEVENT, &sl->flags);
 331         wake_up(&sl->kwt_wq);
 332
 333         pr_debug("sllin: sllin_write_wakeup sent %d, wakeup\n", sl->tx_cnt);
 334 }
 335
 336 /**
 337  * sll_xmit() -- Send a can_frame to a TTY queue.
 338  *
 339  * @skb: Pointer to Socket buffer to be sent.
 340  * @dev: Network device where @skb will be sent.
 341  */
 342 static netdev_tx_t sll_xmit(struct sk_buff *skb, struct net_device *dev)
 343 {
 344         struct sllin *sl = netdev_priv(dev);
 345         struct can_frame *cf;
 346
 347         if (skb->len != sizeof(struct can_frame))
 348                 goto err_out;
 349
 350         spin_lock(&sl->lock);
 351         if (!netif_running(dev))  {
 352                 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
 353                 goto err_out_unlock;
 354         }
 355         if (sl->tty == NULL) {
 356                 printk(KERN_WARNING "%s: xmit: no tty device connected\n", dev->name);
 357                 goto err_out_unlock;
 358         }
 359
 360         cf = (struct can_frame *) skb->data;
 361         if (cf->can_id & LIN_CTRL_FRAME) {
 362                 sllin_configure_frame_cache(sl, cf);
 363                 goto free_out_unlock;
 364         }
 365
 366         netif_stop_queue(sl->dev);
 367
 368         sl->tx_req_skb = skb;
 369         set_bit(SLF_MSGEVENT, &sl->flags);
 370         wake_up(&sl->kwt_wq);
 371         spin_unlock(&sl->lock);
 372         return NETDEV_TX_OK;
 373
 374 free_out_unlock:
 375 err_out_unlock:
 376         spin_unlock(&sl->lock);
 377 err_out:
 378         kfree_skb(skb);
 379         return NETDEV_TX_OK;
 380 }
 381
 382
 383 /******************************************
 384  *   Routines looking at netdevice side.
 385  ******************************************/
 386
 387 /* Netdevice UP -> DOWN routine */
 388 static int sll_close(struct net_device *dev)
 389 {
 390         struct sllin *sl = netdev_priv(dev);
 391
 392         spin_lock_bh(&sl->lock);
 393         if (sl->tty) {
 394                 /* TTY discipline is running. */
 395                 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
 396         }
 397         netif_stop_queue(dev);
 398         sl->rx_expect = 0;
 399         sl->tx_lim    = 0;
 400         spin_unlock_bh(&sl->lock);
 401
 402         return 0;
 403 }
 404
 405 /* Netdevice DOWN -> UP routine */
 406 static int sll_open(struct net_device *dev)
 407 {
 408         struct sllin *sl = netdev_priv(dev);
 409
 410         pr_debug("sllin: %s() invoked\n", __func__);
 411
 412         if (sl->tty == NULL)
 413                 return -ENODEV;
 414
 415         sl->flags &= (1 << SLF_INUSE);
 416         netif_start_queue(dev);
 417         return 0;
 418 }
 419
 420 /* Hook the destructor so we can free sllin devs at the right point in time */
 421 static void sll_free_netdev(struct net_device *dev)
 422 {
 423         int i = dev->base_addr;
 424         free_netdev(dev);
 425         sllin_devs[i] = NULL;
 426 }
 427
 428 static const struct net_device_ops sll_netdev_ops = {
 429         .ndo_open               = sll_open,
 430         .ndo_stop               = sll_close,
 431         .ndo_start_xmit         = sll_xmit,
 432 };
 433
 434 static void sll_setup(struct net_device *dev)
 435 {
 436         dev->netdev_ops         = &sll_netdev_ops;
 437         dev->destructor         = sll_free_netdev;
 438
 439         dev->hard_header_len    = 0;
 440         dev->addr_len           = 0;
 441         dev->tx_queue_len       = 10;
 442
 443         dev->mtu                = sizeof(struct can_frame);
 444         dev->type               = ARPHRD_CAN;
 445
 446         /* New-style flags. */
 447         dev->flags              = IFF_NOARP;
 448         dev->features           = NETIF_F_NO_CSUM;
 449 }
 450
 451 /******************************************
 452   Routines looking at TTY side.
 453  ******************************************/
 454 static void sllin_master_receive_buf(struct tty_struct *tty,
 455                               const unsigned char *cp, char *fp, int count)
 456 {
 457         struct sllin *sl = (struct sllin *) tty->disc_data;
 458
 459         /* Read the characters out of the buffer */
 460         while (count--) {
 461                 if (fp && *fp++) {
 462                         pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
 463                                 "due marker 0x%02x, flags 0x%lx\n",
 464                                 *cp, *(fp-1), sl->flags);
 465
 466                         /* i.e. Real error -- not Break */
 467                         if (sl->rx_cnt > SLLIN_BUFF_BREAK) {
 468                                 set_bit(SLF_ERROR, &sl->flags);
 469                                 wake_up(&sl->kwt_wq);
 470                                 return;
 471                         }
 472                 }
 473
 474 #ifndef BREAK_BY_BAUD
 475                 /* We didn't receive Break character -- fake it! */
 476                 if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
 477                         pr_debug("sllin: LIN_RX[%d]: 0x00\n", sl->rx_cnt);
 478                         sl->rx_buff[sl->rx_cnt++] = 0x00;
 479                 }
 480 #endif /* BREAK_BY_BAUD */
 481
 482                 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
 483                         pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
 484                         sl->rx_buff[sl->rx_cnt++] = *cp++;
 485                 }
 486         }
 487
 488
 489         if (sl->rx_cnt >= sl->rx_expect) {
 490                 set_bit(SLF_RXEVENT, &sl->flags);
 491                 wake_up(&sl->kwt_wq);
 492                 pr_debug("sllin: sllin_receive_buf count %d, wakeup\n", sl->rx_cnt);
 493         } else {
 494                 pr_debug("sllin: sllin_receive_buf count %d, waiting\n", sl->rx_cnt);
 495         }
 496 }
 497
 498
 499 static void sllin_slave_receive_buf(struct tty_struct *tty,
 500                               const unsigned char *cp, char *fp, int count)
 501 {
 502         struct sllin *sl = (struct sllin *) tty->disc_data;
 503         int lin_id;
 504         struct sllin_conf_entry *sce;
 505
 506
 507         /* Read the characters out of the buffer */
 508         while (count--) {
 509                 if (fp && *fp++) {
 510                         pr_debug("sllin: sllin_receive_buf char 0x%02x ignored "
 511                                 "due marker 0x%02x, flags 0x%lx\n",
 512                                 *cp, *(fp-1), sl->flags);
 513
 514                         /* Received Break */
 515                         sl->rx_cnt = 0;
 516                         sl->rx_expect = SLLIN_BUFF_ID + 1;
 517                         sl->rx_len_unknown = false; /* We do know exact length of the header */
 518                         sl->header_received = false;
 519                 }
 520
 521                 if (sl->rx_cnt < SLLIN_BUFF_LEN) {
 522                         pr_debug("sllin: LIN_RX[%d]: 0x%02x\n", sl->rx_cnt, *cp);
 523
 524                         /* We did not receive break (0x00) character */
 525                         if ((sl->rx_cnt == SLLIN_BUFF_BREAK) && (*cp == 0x55)) {
 526                                 sl->rx_buff[sl->rx_cnt++] = 0x00;
 527                         }
 528
 529                         if (sl->rx_cnt == SLLIN_BUFF_SYNC) {
 530                                 /* 'Duplicated' break character -- ignore */
 531                                 if (*cp == 0x00) {
 532                                         cp++;
 533                                         continue;
 534                                 }
 535
 536                                 /* Wrong sync character */
 537                                 if (*cp != 0x55)
 538                                         break;
 539                         }
 540
 541                         sl->rx_buff[sl->rx_cnt++] = *cp++;
 542                 }
 543
 544                 /* Header received */
 545                 if ((sl->header_received == false) && (sl->rx_cnt >= (SLLIN_BUFF_ID + 1))) {
 546                         unsigned long flags;
 547
 548                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 549                         sce = &sl->linfr_cache[lin_id];
 550
 551                         spin_lock_irqsave(&sl->linfr_lock, flags);
 552                         /* Is the length of data set in frame cache? */
 553                         if (sce->frame_fl & LIN_CACHE_RESPONSE) {
 554                                 sl->rx_expect += sce->dlc;
 555                                 sl->rx_len_unknown = false;
 556                         } else {
 557                                 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 558                                 sl->rx_len_unknown = true;
 559                         }
 560                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 561
 562                         sl->header_received = true;
 563                         sll_send_rtr(sl);
 564                         continue;
 565                 }
 566
 567                 /* Response received */
 568                 if ((sl->header_received == true) &&
 569                         ((sl->rx_cnt >= sl->rx_expect) ||
 570                         ((sl->rx_len_unknown == true) && (count == 0)))) {
 571
 572                         sll_bump(sl);
 573                         pr_debug("sllin: Received LIN header & LIN response. "
 574                                         "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
 575                                         sl->rx_expect);
 576
 577                         /* Prepare for reception of new header */
 578                         sl->rx_cnt = 0;
 579                         sl->rx_expect = SLLIN_BUFF_ID + 1;
 580                         sl->rx_len_unknown = false; /* We do know exact length of the header */
 581                         sl->header_received = false;
 582                 }
 583         }
 584 }
 585
 586 static void sllin_receive_buf(struct tty_struct *tty,
 587                               const unsigned char *cp, char *fp, int count)
 588 {
 589         struct sllin *sl = (struct sllin *) tty->disc_data;
 590         pr_debug("sllin: sllin_receive_buf invoked, count = %u\n", count);
 591
 592         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 593                 return;
 594
 595         if (sl->lin_master)
 596                 sllin_master_receive_buf(tty, cp, fp, count);
 597         else
 598                 sllin_slave_receive_buf(tty, cp, fp, count);
 599
 600 }
 601
 602 /*****************************************
 603  *  sllin message helper routines
 604  *****************************************/
 605 /**
 606  * sllin_report_error() -- Report an error by sending CAN frame
 607  *      with particular error flag set in can_id
 608  *
 609  * @sl:
 610  * @err: Error flag to be sent.
 611  */
 612 void sllin_report_error(struct sllin *sl, int err)
 613 {
 614         switch (err) {
 615         case LIN_ERR_CHECKSUM:
 616                 sl->dev->stats.rx_crc_errors++;
 617                 break;
 618
 619         case LIN_ERR_RX_TIMEOUT:
 620                 sl->dev->stats.rx_errors++;
 621                 break;
 622
 623         case LIN_ERR_FRAMING:
 624                 sl->dev->stats.rx_frame_errors++;
 625                 break;
 626         }
 627
 628         sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
 629                 (err & ~LIN_ID_MASK), NULL, 0);
 630 }
 631
 632 /**
 633  * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
 634  *
 635  * @sl:
 636  * @cf: Pointer to CAN frame sent to this driver
 637  *      holding configuration information
 638  */
 639 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
 640 {
 641         unsigned long flags;
 642         struct sllin_conf_entry *sce;
 643
 644         if (!(cf->can_id & LIN_CTRL_FRAME))
 645                 return -1;
 646
 647         sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
 648         pr_debug("sllin: Setting frame cache with EFF CAN frame. "
 649                 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
 650
 651         spin_lock_irqsave(&sl->linfr_lock, flags);
 652
 653         sce->dlc = cf->can_dlc;
 654         if (sce->dlc > SLLIN_DATA_MAX)
 655                 sce->dlc = SLLIN_DATA_MAX;
 656
 657         sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
 658         memcpy(sce->data, cf->data, cf->can_dlc);
 659
 660         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 661
 662         return 0;
 663 }
 664
 665 /**
 666  * sllin_checksum() -- Count checksum for particular data
 667  *
 668  * @data:        Pointer to the buffer containing whole LIN
 669  *               frame (i.e. including break and sync bytes).
 670  * @length:      Length of the buffer.
 671  * @enhanced_fl: Flag determining whether Enhanced or Classic
 672  *               checksum should be counted.
 673  */
 674 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
 675 {
 676         unsigned csum = 0;
 677         int i;
 678
 679         if (enhanced_fl)
 680                 i = SLLIN_BUFF_ID;
 681         else
 682                 i = SLLIN_BUFF_DATA;
 683
 684         for (; i < length; i++) {
 685                 csum += data[i];
 686                 if (csum > 255)
 687                         csum -= 255;
 688         }
 689
 690         return ~csum & 0xff;
 691 }
 692
 693 #define SLLIN_STPMSG_RESPONLY           (1) /* Message will be LIN Response only */
 694 #define SLLIN_STPMSG_CHCKSUM_CLS        (1 << 1)
 695 #define SLLIN_STPMSG_CHCKSUM_ENH        (1 << 2)
 696
 697 int sllin_setup_msg(struct sllin *sl, int mode, int id,
 698                 unsigned char *data, int len)
 699 {
 700         if (id > LIN_ID_MASK)
 701                 return -1;
 702
 703         if (!(mode & SLLIN_STPMSG_RESPONLY)) {
 704                 sl->rx_cnt = 0;
 705                 sl->tx_cnt = 0;
 706                 sl->rx_expect = 0;
 707                 sl->rx_lim = SLLIN_BUFF_LEN;
 708         }
 709
 710         sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
 711         sl->tx_buff[SLLIN_BUFF_SYNC]  = 0x55;
 712         sl->tx_buff[SLLIN_BUFF_ID]    = id | sllin_id_parity_table[id];
 713         sl->tx_lim = SLLIN_BUFF_DATA;
 714
 715         if ((data != NULL) && len) {
 716                 sl->tx_lim += len;
 717                 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
 718                 sl->tx_buff[sl->tx_lim] = sllin_checksum(sl->tx_buff,
 719                                 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
 720                 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 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                 pr_debug("sllin: 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 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 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         pr_debug("sllin: 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 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         pr_debug("sllin: 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                         pr_debug("sllin: 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                         pr_debug("sllin: 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                         pr_debug("sllin: sllin_kthread TXEVENT\n");
 979                 }
 980
 981                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
 982                         pr_debug("sllin: 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                                 pr_debug("sllin: %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                                         pr_debug("sllin: 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                                 pr_debug("sllin: %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                                         pr_debug("sllin: 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                         pr_debug("sllin: 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                                 pr_debug("sllin: RX validation failed.\n");
1135                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1136                         } else {
1137                                 /* Send CAN non-RTR frame with data */
1138                                 pr_debug("sllin: sending NON-RTR CAN"
1139                                         "frame with LIN payload.");
1140                                 sll_bump(sl); /* send packet to the network layer */
1141                         }
1142
1143                         sl->id_to_send = false;
1144                         sl->lin_state = SLSTATE_IDLE;
1145                         break;
1146
1147                 case SLSTATE_RESPONSE_SENT:
1148 slstate_response_sent:
1149                         if (sl->rx_cnt < sl->tx_lim)
1150                                 continue;
1151
1152                         hrtimer_cancel(&sl->rx_timer);
1153                         sll_bump(sl); /* send packet to the network layer */
1154                         pr_debug("sllin: response sent ID %d len %d\n",
1155                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1156
1157                         sl->id_to_send = false;
1158                         sl->lin_state = SLSTATE_IDLE;
1159                         break;
1160                 }
1161         }
1162
1163         hrtimer_cancel(&sl->rx_timer);
1164         pr_debug("sllin: sllin_kwthread stopped.\n");
1165
1166         return 0;
1167 }
1168
1169
1170 /************************************
1171  *  sllin_open helper routines.
1172  ************************************/
1173
1174 /* Collect hanged up channels */
1175 static void sll_sync(void)
1176 {
1177         int i;
1178         struct net_device *dev;
1179         struct sllin      *sl;
1180
1181         for (i = 0; i < maxdev; i++) {
1182                 dev = sllin_devs[i];
1183                 if (dev == NULL)
1184                         break;
1185
1186                 sl = netdev_priv(dev);
1187                 if (sl->tty)
1188                         continue;
1189                 if (dev->flags & IFF_UP)
1190                         dev_close(dev);
1191         }
1192 }
1193
1194 /* Find a free SLLIN channel, and link in this `tty' line. */
1195 static struct sllin *sll_alloc(dev_t line)
1196 {
1197         int i;
1198         struct net_device *dev = NULL;
1199         struct sllin       *sl;
1200
1201         if (sllin_devs == NULL)
1202                 return NULL;    /* Master array missing ! */
1203
1204         for (i = 0; i < maxdev; i++) {
1205                 dev = sllin_devs[i];
1206                 if (dev == NULL)
1207                         break;
1208
1209         }
1210
1211         /* Sorry, too many, all slots in use */
1212         if (i >= maxdev)
1213                 return NULL;
1214
1215         if (dev) {
1216                 sl = netdev_priv(dev);
1217                 if (test_bit(SLF_INUSE, &sl->flags)) {
1218                         unregister_netdevice(dev);
1219                         dev = NULL;
1220                         sllin_devs[i] = NULL;
1221                 }
1222         }
1223
1224         if (!dev) {
1225                 char name[IFNAMSIZ];
1226                 sprintf(name, "sllin%d", i);
1227
1228                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1229                 if (!dev)
1230                         return NULL;
1231                 dev->base_addr  = i;
1232         }
1233
1234         sl = netdev_priv(dev);
1235         /* Initialize channel control data */
1236         sl->magic = SLLIN_MAGIC;
1237         sl->dev = dev;
1238         spin_lock_init(&sl->lock);
1239         spin_lock_init(&sl->linfr_lock);
1240         sllin_devs[i] = dev;
1241
1242         return sl;
1243 }
1244
1245 /*
1246  * Open the high-level part of the SLLIN channel.
1247  * This function is called by the TTY module when the
1248  * SLLIN line discipline is called for.  Because we are
1249  * sure the tty line exists, we only have to link it to
1250  * a free SLLIN channel...
1251  *
1252  * Called in process context serialized from other ldisc calls.
1253  */
1254
1255 static int sllin_open(struct tty_struct *tty)
1256 {
1257         struct sllin *sl;
1258         int err;
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 #ifdef DEBUG
1297                 if (master)
1298                         pr_debug("sllin: Configured as MASTER\n");
1299                 else
1300                         pr_debug("sllin: Configured as SLAVE\n");
1301 #endif
1302
1303                 sllin_reset_buffs(sl);
1304
1305                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1306                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1307
1308                 sl->lin_state = SLSTATE_IDLE;
1309
1310                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1311                 sl->rx_timer.function = sllin_rx_timeout_handler;
1312                 /* timeval_to_ktime(msg_head->ival1); */
1313                 sl->rx_timer_timeout = ns_to_ktime(
1314                         (1000000000l / sl->lin_baud) *
1315                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1316
1317                 set_bit(SLF_INUSE, &sl->flags);
1318
1319                 init_waitqueue_head(&sl->kwt_wq);
1320                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1321                 if (sl->kwthread == NULL)
1322                         goto err_free_chan;
1323
1324                 err = register_netdevice(sl->dev);
1325                 if (err)
1326                         goto err_free_chan_and_thread;
1327         }
1328
1329         /* Done.  We have linked the TTY line to a channel. */
1330         rtnl_unlock();
1331         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1332
1333         /* TTY layer expects 0 on success */
1334         return 0;
1335
1336 err_free_chan_and_thread:
1337         kthread_stop(sl->kwthread);
1338         sl->kwthread = NULL;
1339
1340 err_free_chan:
1341         sl->tty = NULL;
1342         tty->disc_data = NULL;
1343         clear_bit(SLF_INUSE, &sl->flags);
1344
1345 err_exit:
1346         rtnl_unlock();
1347
1348         /* Count references from TTY module */
1349         return err;
1350 }
1351
1352 /*
1353  * Close down a SLLIN channel.
1354  * This means flushing out any pending queues, and then returning. This
1355  * call is serialized against other ldisc functions.
1356  *
1357  * We also use this method for a hangup event.
1358  */
1359
1360 static void sllin_close(struct tty_struct *tty)
1361 {
1362         struct sllin *sl = (struct sllin *) tty->disc_data;
1363
1364         /* First make sure we're connected. */
1365         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1366                 return;
1367
1368         kthread_stop(sl->kwthread);
1369         sl->kwthread = NULL;
1370
1371         tty->disc_data = NULL;
1372         sl->tty = NULL;
1373
1374         /* Flush network side */
1375         unregister_netdev(sl->dev);
1376         /* This will complete via sl_free_netdev */
1377 }
1378
1379 static int sllin_hangup(struct tty_struct *tty)
1380 {
1381         sllin_close(tty);
1382         return 0;
1383 }
1384
1385 /* Perform I/O control on an active SLLIN channel. */
1386 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1387                        unsigned int cmd, unsigned long arg)
1388 {
1389         struct sllin *sl = (struct sllin *) tty->disc_data;
1390         unsigned int tmp;
1391
1392         /* First make sure we're connected. */
1393         if (!sl || sl->magic != SLLIN_MAGIC)
1394                 return -EINVAL;
1395
1396         switch (cmd) {
1397         case SIOCGIFNAME:
1398                 tmp = strlen(sl->dev->name) + 1;
1399                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1400                         return -EFAULT;
1401                 return 0;
1402
1403         case SIOCSIFHWADDR:
1404                 return -EINVAL;
1405
1406         default:
1407                 return tty_mode_ioctl(tty, file, cmd, arg);
1408         }
1409 }
1410
1411 static struct tty_ldisc_ops sll_ldisc = {
1412         .owner          = THIS_MODULE,
1413         .magic          = TTY_LDISC_MAGIC,
1414         .name           = "sllin",
1415         .open           = sllin_open,
1416         .close          = sllin_close,
1417         .hangup         = sllin_hangup,
1418         .ioctl          = sllin_ioctl,
1419         .receive_buf    = sllin_receive_buf,
1420         .write_wakeup   = sllin_write_wakeup,
1421 };
1422
1423 static int __init sllin_init(void)
1424 {
1425         int status;
1426
1427         if (maxdev < 4)
1428                 maxdev = 4; /* Sanity */
1429
1430         printk(banner);
1431         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1432
1433         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1434         if (!sllin_devs) {
1435                 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1436                 return -ENOMEM;
1437         }
1438
1439         /* Fill in our line protocol discipline, and register it */
1440         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1441         if (status)  {
1442                 printk(KERN_ERR "sllin: can't register line discipline\n");
1443                 kfree(sllin_devs);
1444         }
1445
1446 #ifdef BREAK_BY_BAUD
1447         pr_debug("sllin: Break is generated by baud-rate change.");
1448 #else
1449         pr_debug("sllin: Break is generated manually with tiny sleep.");
1450 #endif
1451
1452         return status;
1453 }
1454
1455 static void __exit sllin_exit(void)
1456 {
1457         int i;
1458         struct net_device *dev;
1459         struct sllin *sl;
1460         unsigned long timeout = jiffies + HZ;
1461         int busy = 0;
1462
1463         if (sllin_devs == NULL)
1464                 return;
1465
1466         /* First of all: check for active disciplines and hangup them.
1467          */
1468         do {
1469                 if (busy)
1470                         msleep_interruptible(100);
1471
1472                 busy = 0;
1473                 for (i = 0; i < maxdev; i++) {
1474                         dev = sllin_devs[i];
1475                         if (!dev)
1476                                 continue;
1477                         sl = netdev_priv(dev);
1478                         spin_lock_bh(&sl->lock);
1479                         if (sl->tty) {
1480                                 busy++;
1481                                 tty_hangup(sl->tty);
1482                         }
1483                         spin_unlock_bh(&sl->lock);
1484                 }
1485         } while (busy && time_before(jiffies, timeout));
1486
1487         /* FIXME: hangup is async so we should wait when doing this second
1488            phase */
1489
1490         for (i = 0; i < maxdev; i++) {
1491                 dev = sllin_devs[i];
1492                 if (!dev)
1493                         continue;
1494                 sllin_devs[i] = NULL;
1495
1496                 sl = netdev_priv(dev);
1497                 if (sl->tty) {
1498                         printk(KERN_ERR "%s: tty discipline still running\n",
1499                                dev->name);
1500                         /* Intentionally leak the control block. */
1501                         dev->destructor = NULL;
1502                 }
1503
1504                 unregister_netdev(dev);
1505         }
1506
1507         kfree(sllin_devs);
1508         sllin_devs = NULL;
1509
1510         i = tty_unregister_ldisc(N_SLLIN);
1511         if (i)
1512                 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1513 }
1514
1515 module_init(sllin_init);
1516 module_exit(sllin_exit);