sllin/sllin.c

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