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->frame_fl & LIN_CACHE_RESPONSE) {
 772                                 sl->rx_expect += sce->dlc + 1; /* + checksum */
 773                                 sl->rx_len_unknown = false;
 774                                 set_bit(SLF_MSGEVENT, &sl->flags);
 775                                 wake_up(&sl->kwt_wq);
 776                         } else {
 777                                 sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 778                                 sl->rx_len_unknown = true;
 779                         }
 780                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
 781
 782                         sl->header_received = true;
 783
 784                         hrtimer_start(&sl->rx_timer,
 785                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
 786                                 HRTIMER_MODE_ABS);
 787                         sll_send_rtr(sl);
 788                         continue;
 789                 }
 790
 791                 /* Response received */
 792                 if ((sl->header_received == true) &&
 793                         ((sl->rx_cnt >= sl->rx_expect))) {
 794
 795                         hrtimer_cancel(&sl->rx_timer);
 796                         netdev_dbg(sl->dev, "Received LIN header & LIN response. "
 797                                         "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
 798                                         sl->rx_expect);
 799                         sllin_slave_finish_rx_msg(sl);
 800
 801                         set_bit(SLF_RXEVENT, &sl->flags);
 802                         wake_up(&sl->kwt_wq);
 803                 }
 804         }
 805 }
 806
 807 static void sllin_receive_buf(struct tty_struct *tty,
 808                               const unsigned char *cp, char *fp, int count)
 809 {
 810         struct sllin *sl = (struct sllin *) tty->disc_data;
 811         netdev_dbg(sl->dev, "sllin_receive_buf invoked, count = %u\n", count);
 812
 813         if (!sl || sl->magic != SLLIN_MAGIC || !netif_running(sl->dev))
 814                 return;
 815
 816         if (sl->lin_master)
 817                 sllin_master_receive_buf(tty, cp, fp, count);
 818         else
 819                 sllin_slave_receive_buf(tty, cp, fp, count);
 820
 821 }
 822
 823 static int sllin_send_tx_buff(struct sllin *sl)
 824 {
 825         struct tty_struct *tty = sl->tty;
 826         int remains;
 827         int res;
 828
 829         set_bit(SLF_TXBUFF_RQ, &sl->flags);
 830         do {
 831                 if (unlikely(test_and_set_bit(SLF_TXBUFF_INPR, &sl->flags)))
 832                         return 0;       /* ongoing concurrent processing */
 833
 834                 clear_bit(SLF_TXBUFF_RQ, &sl->flags);
 835                 smp_mb__after_clear_bit();
 836
 837 #ifdef BREAK_BY_BAUD
 838                 if (sl->lin_state != SLSTATE_BREAK_SENT)
 839                         remains = sl->tx_lim - sl->tx_cnt;
 840                 else
 841                         remains = 1;
 842 #else
 843                 remains = sl->tx_lim - sl->tx_cnt;
 844 #endif
 845
 846                 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 847                 if (res < 0)
 848                         goto error_in_write;
 849
 850                 remains -= res;
 851                 sl->tx_cnt += res;
 852
 853                 if (remains > 0) {
 854                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 855                         res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 856                         if (res < 0) {
 857                                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 858                                 goto error_in_write;
 859                         }
 860
 861                         remains -= res;
 862                         sl->tx_cnt += res;
 863                 }
 864
 865                 netdev_dbg(sl->dev, "sllin_send_tx_buff sent %d, remains %d\n",
 866                                 sl->tx_cnt, remains);
 867
 868                 clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 869                 smp_mb__after_clear_bit();
 870
 871         } while (unlikely(test_bit(SLF_TXBUFF_RQ, &sl->flags)));
 872
 873         return 0;
 874
 875 error_in_write:
 876         clear_bit(SLF_TXBUFF_INPR, &sl->flags);
 877         return -1;
 878
 879 }
 880
 881 #ifdef BREAK_BY_BAUD
 882 static int sllin_send_break(struct sllin *sl)
 883 {
 884         struct tty_struct *tty = sl->tty;
 885         unsigned long break_baud;
 886         int res;
 887
 888         break_baud = ((sl->lin_baud * 2) / 3);
 889         sltty_change_speed(tty, break_baud);
 890
 891         tty->ops->flush_buffer(tty);
 892         sl->rx_cnt = SLLIN_BUFF_BREAK;
 893
 894         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 895         sl->lin_state = SLSTATE_BREAK_SENT;
 896
 897         res = sllin_send_tx_buff(sl);
 898         if (res < 0) {
 899                 sl->lin_state = SLSTATE_IDLE;
 900                 return res;
 901         }
 902
 903         return 0;
 904 }
 905 #else /* BREAK_BY_BAUD */
 906
 907 static int sllin_send_break(struct sllin *sl)
 908 {
 909         struct tty_struct *tty = sl->tty;
 910         int retval;
 911         unsigned long break_baud;
 912         unsigned long usleep_range_min;
 913         unsigned long usleep_range_max;
 914
 915         break_baud = ((sl->lin_baud * 2) / 3);
 916         sl->rx_cnt = SLLIN_BUFF_BREAK;
 917         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 918         sl->lin_state = SLSTATE_BREAK_SENT;
 919
 920         /* Do the break ourselves; Inspired by
 921            http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
 922         retval = tty->ops->break_ctl(tty, -1);
 923         if (retval)
 924                 return retval;
 925
 926         /* udelay(712); */
 927         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
 928         usleep_range_max = usleep_range_min + 50;
 929         usleep_range(usleep_range_min, usleep_range_max);
 930
 931         retval = tty->ops->break_ctl(tty, 0);
 932         usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
 933         usleep_range_max = usleep_range_min + 30;
 934         usleep_range(usleep_range_min, usleep_range_max);
 935
 936         tty->ops->flush_buffer(tty);
 937
 938         sl->tx_cnt = SLLIN_BUFF_SYNC;
 939
 940         netdev_dbg(sl->dev, "Break sent.\n");
 941         set_bit(SLF_RXEVENT, &sl->flags);
 942         wake_up(&sl->kwt_wq);
 943
 944         return 0;
 945 }
 946 #endif /* BREAK_BY_BAUD */
 947
 948
 949 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
 950 {
 951         struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
 952
 953         if (sl->lin_master) {
 954                 sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
 955                 set_bit(SLF_TMOUTEVENT, &sl->flags);
 956         } else {
 957                 sllin_slave_finish_rx_msg(sl);
 958                 set_bit(SLF_RXEVENT, &sl->flags);
 959         }
 960         wake_up(&sl->kwt_wq);
 961
 962         return HRTIMER_NORESTART;
 963 }
 964
 965 /*****************************************
 966  *  sllin_kwthread - kernel worker thread
 967  *****************************************/
 968
 969 static int sllin_kwthread(void *ptr)
 970 {
 971         struct sllin *sl = (struct sllin *)ptr;
 972         struct tty_struct *tty = sl->tty;
 973         struct sched_param schparam = { .sched_priority = 40 };
 974         int tx_bytes = 0; /* Used for Network statistics */
 975         unsigned long flags;
 976         int lin_id;
 977         struct sllin_conf_entry *sce;
 978
 979         netdev_dbg(sl->dev, "sllin_kwthread started.\n");
 980         sched_setscheduler(current, SCHED_FIFO, &schparam);
 981
 982         clear_bit(SLF_ERROR, &sl->flags);
 983         sltty_change_speed(tty, sl->lin_baud);
 984
 985         while (!kthread_should_stop()) {
 986                 struct can_frame *cf;
 987                 u8 *lin_data;
 988                 int lin_dlc;
 989                 u8 lin_data_buff[SLLIN_DATA_MAX];
 990
 991
 992                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
 993                         sl->id_to_send) {
 994                         if (sllin_send_break(sl) < 0) {
 995                                 /* error processing */
 996                         }
 997                 }
 998
 999                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
1000                         test_bit(SLF_RXEVENT, &sl->flags) ||
1001                         test_bit(SLF_TXEVENT, &sl->flags) ||
1002                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
1003                         test_bit(SLF_ERROR, &sl->flags) ||
1004                         (((sl->lin_state == SLSTATE_IDLE) ||
1005                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT) ||
1006                                 (sl->lin_state == SLSTATE_ID_RECEIVED))
1007                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
1008
1009                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
1010                         netdev_dbg(sl->dev, "sllin_kthread RXEVENT\n");
1011                 }
1012
1013                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
1014                         unsigned long usleep_range_min;
1015                         unsigned long usleep_range_max;
1016                         hrtimer_cancel(&sl->rx_timer);
1017                         netdev_dbg(sl->dev, "sllin_kthread ERROR\n");
1018
1019                         if (sl->lin_state != SLSTATE_IDLE)
1020                                 sllin_report_error(sl, LIN_ERR_FRAMING);
1021
1022                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
1023                                                 sl->lin_baud;
1024                         usleep_range_max = usleep_range_min + 50;
1025                         usleep_range(usleep_range_min, usleep_range_max);
1026                         sllin_reset_buffs(sl);
1027                         sl->lin_state = SLSTATE_IDLE;
1028                 }
1029
1030                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
1031                         netdev_dbg(sl->dev, "sllin_kthread TXEVENT\n");
1032                 }
1033
1034                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
1035                         netdev_dbg(sl->dev, "sllin_kthread TMOUTEVENT\n");
1036                         sllin_reset_buffs(sl);
1037
1038                         sl->lin_state = SLSTATE_IDLE;
1039                 }
1040
1041                 switch (sl->lin_state) {
1042                 case SLSTATE_IDLE:
1043                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
1044                                 break;
1045
1046                         cf = (struct can_frame *)sl->tx_req_skb->data;
1047
1048                         /* SFF RTR CAN frame -> LIN header */
1049                         if (cf->can_id & CAN_RTR_FLAG) {
1050                                 struct sllin_conf_entry *sce;
1051
1052                                 netdev_dbg(sl->dev, "%s: RTR SFF CAN frame, ID = %x\n",
1053                                         __func__, cf->can_id & LIN_ID_MASK);
1054
1055                                 sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
1056                                 spin_lock_irqsave(&sl->linfr_lock, flags);
1057
1058                                 /* Is there Slave response in linfr_cache to be sent? */
1059                                 if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1060                                         && (sce->dlc > 0)) {
1061
1062                                         netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1063
1064                                         lin_data = sce->data;
1065                                         lin_dlc = sce->dlc;
1066                                         if (lin_dlc > SLLIN_DATA_MAX)
1067                                                 lin_dlc = SLLIN_DATA_MAX;
1068                                         memcpy(lin_data_buff, lin_data, lin_dlc);
1069                                         lin_data = lin_data_buff;
1070                                 } else {
1071                                         lin_data = NULL;
1072                                         lin_dlc = sce->dlc;
1073                                 }
1074                                 spin_unlock_irqrestore(&sl->linfr_lock, flags);
1075
1076                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
1077                                 netdev_dbg(sl->dev, "%s: NON-RTR SFF CAN frame, ID = %x\n",
1078                                         __func__, (int)cf->can_id & LIN_ID_MASK);
1079
1080                                 lin_data = cf->data;
1081                                 lin_dlc = cf->can_dlc;
1082                                 if (lin_dlc > SLLIN_DATA_MAX)
1083                                         lin_dlc = SLLIN_DATA_MAX;
1084                                 tx_bytes = lin_dlc;
1085                         }
1086
1087                         if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
1088                                 lin_data, lin_dlc) != -1) {
1089
1090                                 sl->id_to_send = true;
1091                                 sl->data_to_send = (lin_data != NULL) ? true : false;
1092                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
1093                                 sl->dev->stats.tx_packets++;
1094                                 sl->dev->stats.tx_bytes += tx_bytes;
1095                         }
1096
1097                         clear_bit(SLF_MSGEVENT, &sl->flags);
1098                         kfree_skb(sl->tx_req_skb);
1099                         netif_wake_queue(sl->dev);
1100                         hrtimer_start(&sl->rx_timer,
1101                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
1102                                 HRTIMER_MODE_ABS);
1103                         break;
1104
1105                 case SLSTATE_BREAK_SENT:
1106 #ifdef BREAK_BY_BAUD
1107                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
1108                                 continue;
1109
1110                         res = sltty_change_speed(tty, sl->lin_baud);
1111 #endif
1112
1113                         sl->lin_state = SLSTATE_ID_SENT;
1114                         sllin_send_tx_buff(sl);
1115                         break;
1116
1117                 case SLSTATE_ID_SENT:
1118                         hrtimer_cancel(&sl->rx_timer);
1119                         sl->id_to_send = false;
1120                         if (sl->data_to_send) {
1121                                 sllin_send_tx_buff(sl);
1122                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1123                                 sl->rx_expect = sl->tx_lim;
1124                                 goto slstate_response_sent;
1125                         } else {
1126                                 if (sl->resp_len_known) {
1127                                         sl->rx_expect = sl->rx_lim;
1128                                 } else {
1129                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
1130                                 }
1131                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
1132                                 /* If we don't receive anything, timer will "unblock" us */
1133                                 hrtimer_start(&sl->rx_timer,
1134                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1135                                         HRTIMER_MODE_ABS);
1136                                 goto slstate_response_wait;
1137                         }
1138                         break;
1139
1140                 case SLSTATE_RESPONSE_WAIT:
1141 slstate_response_wait:
1142                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
1143                                 unsigned char *lin_buff;
1144                                 cf = (struct can_frame *)sl->tx_req_skb->data;
1145
1146                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
1147                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
1148                                         hrtimer_cancel(&sl->rx_timer);
1149                                         netdev_dbg(sl->dev, "received LIN response in a CAN frame.\n");
1150                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
1151                                                 cf->can_id & LIN_ID_MASK,
1152                                                 cf->data, cf->can_dlc) != -1) {
1153
1154                                                 sl->rx_expect = sl->tx_lim;
1155                                                 sl->data_to_send = true;
1156                                                 sl->dev->stats.tx_packets++;
1157                                                 sl->dev->stats.tx_bytes += tx_bytes;
1158
1159                                                 if (!sl->lin_master) {
1160                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1161                                                 }
1162
1163                                                 sllin_send_tx_buff(sl);
1164                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1165                                                 kfree_skb(sl->tx_req_skb);
1166                                                 netif_wake_queue(sl->dev);
1167
1168                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1169                                                 goto slstate_response_sent;
1170                                         }
1171                                 } else {
1172                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1173                                 }
1174                         }
1175
1176                         /* Be aware, no BREAK here */
1177                 case SLSTATE_RESPONSE_WAIT_BUS:
1178                         if (sl->rx_cnt < sl->rx_expect)
1179                                 continue;
1180
1181                         hrtimer_cancel(&sl->rx_timer);
1182                         netdev_dbg(sl->dev, "response received ID %d len %d\n",
1183                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1184
1185                         if (sllin_rx_validate(sl) == -1) {
1186                                 netdev_dbg(sl->dev, "RX validation failed.\n");
1187                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1188                         } else {
1189                                 /* Send CAN non-RTR frame with data */
1190                                 netdev_dbg(sl->dev, "sending NON-RTR CAN frame with LIN payload.");
1191                                 sll_bump(sl); /* send packet to the network layer */
1192                         }
1193
1194                         sl->id_to_send = false;
1195                         sl->lin_state = SLSTATE_IDLE;
1196                         break;
1197
1198                 case SLSTATE_ID_RECEIVED:
1199                         lin_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
1200                         sce = &sl->linfr_cache[lin_id];
1201                         spin_lock_irqsave(&sl->linfr_lock, flags);
1202
1203                         if ((sce->frame_fl & LIN_CACHE_RESPONSE)
1204                                         && (sce->dlc > 0)
1205                                         && (test_bit(SLF_MSGEVENT, &sl->flags))) {
1206                                 int mode;
1207
1208                                 netdev_dbg(sl->dev, "Sending LIN response from linfr_cache\n");
1209
1210                                 lin_data = sce->data;
1211                                 lin_dlc = sce->dlc;
1212                                 if (lin_dlc > SLLIN_DATA_MAX)
1213                                         lin_dlc = SLLIN_DATA_MAX;
1214                                 memcpy(lin_data_buff, lin_data, lin_dlc);
1215                                 lin_data = lin_data_buff;
1216                                 tx_bytes = lin_dlc;
1217
1218                                 mode = SLLIN_STPMSG_RESPONLY;
1219                                 if (sce->frame_fl & LIN_CHECKSUM_EXTENDED)
1220                                         mode |= SLLIN_STPMSG_CHCKSUM_ENH;
1221
1222                                 if (sllin_setup_msg(sl, mode, lin_id & LIN_ID_MASK,
1223                                         lin_data, lin_dlc) != -1) {
1224
1225                                         sl->rx_expect = sl->tx_lim;
1226                                         sl->data_to_send = true;
1227                                         sl->dev->stats.tx_packets++;
1228                                         sl->dev->stats.tx_bytes += tx_bytes;
1229                                         sl->resp_len_known = true;
1230
1231                                         if (!sl->lin_master) {
1232                                                 sl->tx_cnt = SLLIN_BUFF_DATA;
1233                                         }
1234                                         sllin_send_tx_buff(sl);
1235                                 }
1236
1237                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1238                                 kfree_skb(sl->tx_req_skb);
1239                                 netif_wake_queue(sl->dev);
1240                                 hrtimer_start(&sl->rx_timer,
1241                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
1242                                         HRTIMER_MODE_ABS);
1243                         }
1244                         spin_unlock_irqrestore(&sl->linfr_lock, flags);
1245                         sl->lin_state = SLSTATE_IDLE;
1246                         break;
1247
1248                 case SLSTATE_RESPONSE_SENT:
1249 slstate_response_sent:
1250                         if (sl->rx_cnt < sl->tx_lim)
1251                                 continue;
1252
1253                         hrtimer_cancel(&sl->rx_timer);
1254                         sll_bump(sl); /* send packet to the network layer */
1255                         netdev_dbg(sl->dev, "response sent ID %d len %d\n",
1256                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1257
1258                         sl->id_to_send = false;
1259                         sl->lin_state = SLSTATE_IDLE;
1260                         break;
1261                 }
1262         }
1263
1264         hrtimer_cancel(&sl->rx_timer);
1265         netdev_dbg(sl->dev, "sllin_kwthread stopped.\n");
1266
1267         return 0;
1268 }
1269
1270
1271 /************************************
1272  *  sllin_open helper routines.
1273  ************************************/
1274
1275 /* Collect hanged up channels */
1276 static void sll_sync(void)
1277 {
1278         int i;
1279         struct net_device *dev;
1280         struct sllin      *sl;
1281
1282         for (i = 0; i < maxdev; i++) {
1283                 dev = sllin_devs[i];
1284                 if (dev == NULL)
1285                         break;
1286
1287                 sl = netdev_priv(dev);
1288                 if (sl->tty)
1289                         continue;
1290                 if (dev->flags & IFF_UP)
1291                         dev_close(dev);
1292         }
1293 }
1294
1295 /* Find a free SLLIN channel, and link in this `tty' line. */
1296 static struct sllin *sll_alloc(dev_t line)
1297 {
1298         int i;
1299         struct net_device *dev = NULL;
1300         struct sllin       *sl;
1301
1302         if (sllin_devs == NULL)
1303                 return NULL;    /* Master array missing ! */
1304
1305         for (i = 0; i < maxdev; i++) {
1306                 dev = sllin_devs[i];
1307                 if (dev == NULL)
1308                         break;
1309
1310         }
1311
1312         /* Sorry, too many, all slots in use */
1313         if (i >= maxdev)
1314                 return NULL;
1315
1316         if (dev) {
1317                 sl = netdev_priv(dev);
1318                 if (test_bit(SLF_INUSE, &sl->flags)) {
1319                         unregister_netdevice(dev);
1320                         dev = NULL;
1321                         sllin_devs[i] = NULL;
1322                 }
1323         }
1324
1325         if (!dev) {
1326                 char name[IFNAMSIZ];
1327                 sprintf(name, "sllin%d", i);
1328
1329                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1330                 if (!dev)
1331                         return NULL;
1332                 dev->base_addr  = i;
1333         }
1334
1335         sl = netdev_priv(dev);
1336         /* Initialize channel control data */
1337         sl->magic = SLLIN_MAGIC;
1338         sl->dev = dev;
1339         spin_lock_init(&sl->lock);
1340         spin_lock_init(&sl->linfr_lock);
1341         sllin_devs[i] = dev;
1342
1343         return sl;
1344 }
1345
1346 /*
1347  * Open the high-level part of the SLLIN channel.
1348  * This function is called by the TTY module when the
1349  * SLLIN line discipline is called for.  Because we are
1350  * sure the tty line exists, we only have to link it to
1351  * a free SLLIN channel...
1352  *
1353  * Called in process context serialized from other ldisc calls.
1354  */
1355
1356 static int sllin_open(struct tty_struct *tty)
1357 {
1358         struct sllin *sl;
1359         int err;
1360
1361         pr_debug("sllin: %s() invoked\n", __func__);
1362
1363         if (!capable(CAP_NET_ADMIN))
1364                 return -EPERM;
1365
1366         if (tty->ops->write == NULL)
1367                 return -EOPNOTSUPP;
1368
1369         /* RTnetlink lock is misused here to serialize concurrent
1370            opens of sllin channels. There are better ways, but it is
1371            the simplest one.
1372          */
1373         rtnl_lock();
1374
1375         /* Collect hanged up channels. */
1376         sll_sync();
1377
1378         sl = tty->disc_data;
1379
1380         err = -EEXIST;
1381         /* First make sure we're not already connected. */
1382         if (sl && sl->magic == SLLIN_MAGIC)
1383                 goto err_exit;
1384
1385         /* OK.  Find a free SLLIN channel to use. */
1386         err = -ENFILE;
1387         sl = sll_alloc(tty_devnum(tty));
1388         if (sl == NULL)
1389                 goto err_exit;
1390
1391         sl->tty = tty;
1392         tty->disc_data = sl;
1393         sl->line = tty_devnum(tty);
1394
1395         if (!test_bit(SLF_INUSE, &sl->flags)) {
1396                 /* Perform the low-level SLLIN initialization. */
1397                 sl->lin_master = master;
1398                 if (master)
1399                         pr_debug("sllin: Configured as MASTER\n");
1400                 else
1401                         pr_debug("sllin: Configured as SLAVE\n");
1402
1403                 sllin_reset_buffs(sl);
1404
1405                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1406                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1407
1408                 sl->lin_state = SLSTATE_IDLE;
1409
1410                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1411                 sl->rx_timer.function = sllin_rx_timeout_handler;
1412                 /* timeval_to_ktime(msg_head->ival1); */
1413                 sl->rx_timer_timeout = ns_to_ktime(
1414                         (1000000000l / sl->lin_baud) *
1415                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1416
1417                 set_bit(SLF_INUSE, &sl->flags);
1418
1419                 init_waitqueue_head(&sl->kwt_wq);
1420                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1421                 if (sl->kwthread == NULL)
1422                         goto err_free_chan;
1423
1424                 err = register_netdevice(sl->dev);
1425                 if (err)
1426                         goto err_free_chan_and_thread;
1427         }
1428
1429         /* Done.  We have linked the TTY line to a channel. */
1430         rtnl_unlock();
1431         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1432
1433         /* TTY layer expects 0 on success */
1434         return 0;
1435
1436 err_free_chan_and_thread:
1437         kthread_stop(sl->kwthread);
1438         sl->kwthread = NULL;
1439
1440 err_free_chan:
1441         sl->tty = NULL;
1442         tty->disc_data = NULL;
1443         clear_bit(SLF_INUSE, &sl->flags);
1444
1445 err_exit:
1446         rtnl_unlock();
1447
1448         /* Count references from TTY module */
1449         return err;
1450 }
1451
1452 /*
1453  * Close down a SLLIN channel.
1454  * This means flushing out any pending queues, and then returning. This
1455  * call is serialized against other ldisc functions.
1456  *
1457  * We also use this method for a hangup event.
1458  */
1459
1460 static void sllin_close(struct tty_struct *tty)
1461 {
1462         struct sllin *sl = (struct sllin *) tty->disc_data;
1463
1464         /* First make sure we're connected. */
1465         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1466                 return;
1467
1468         kthread_stop(sl->kwthread);
1469         sl->kwthread = NULL;
1470
1471         tty->disc_data = NULL;
1472         sl->tty = NULL;
1473
1474         /* Flush network side */
1475         unregister_netdev(sl->dev);
1476         /* This will complete via sl_free_netdev */
1477 }
1478
1479 static int sllin_hangup(struct tty_struct *tty)
1480 {
1481         sllin_close(tty);
1482         return 0;
1483 }
1484
1485 /* Perform I/O control on an active SLLIN channel. */
1486 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1487                        unsigned int cmd, unsigned long arg)
1488 {
1489         struct sllin *sl = (struct sllin *) tty->disc_data;
1490         unsigned int tmp;
1491
1492         /* First make sure we're connected. */
1493         if (!sl || sl->magic != SLLIN_MAGIC)
1494                 return -EINVAL;
1495
1496         switch (cmd) {
1497         case SIOCGIFNAME:
1498                 tmp = strlen(sl->dev->name) + 1;
1499                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1500                         return -EFAULT;
1501                 return 0;
1502
1503         case SIOCSIFHWADDR:
1504                 return -EINVAL;
1505
1506         default:
1507                 return tty_mode_ioctl(tty, file, cmd, arg);
1508         }
1509 }
1510
1511 static struct tty_ldisc_ops sll_ldisc = {
1512         .owner          = THIS_MODULE,
1513         .magic          = TTY_LDISC_MAGIC,
1514         .name           = "sllin",
1515         .open           = sllin_open,
1516         .close          = sllin_close,
1517         .hangup         = sllin_hangup,
1518         .ioctl          = sllin_ioctl,
1519         .receive_buf    = sllin_receive_buf,
1520         .write_wakeup   = sllin_write_wakeup,
1521 };
1522
1523 static int __init sllin_init(void)
1524 {
1525         int status;
1526
1527         if (maxdev < 4)
1528                 maxdev = 4; /* Sanity */
1529
1530         printk(banner);
1531         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1532
1533         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1534         if (!sllin_devs) {
1535                 pr_err("sllin: can't allocate sllin device array!\n");
1536                 return -ENOMEM;
1537         }
1538
1539         /* Fill in our line protocol discipline, and register it */
1540         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1541         if (status)  {
1542                 pr_err("sllin: can't register line discipline\n");
1543                 kfree(sllin_devs);
1544         }
1545
1546 #ifdef BREAK_BY_BAUD
1547         pr_debug("sllin: Break is generated by baud-rate change.");
1548 #else
1549         pr_debug("sllin: Break is generated manually with tiny sleep.");
1550 #endif
1551
1552         return status;
1553 }
1554
1555 static void __exit sllin_exit(void)
1556 {
1557         int i;
1558         struct net_device *dev;
1559         struct sllin *sl;
1560         unsigned long timeout = jiffies + HZ;
1561         int busy = 0;
1562
1563         if (sllin_devs == NULL)
1564                 return;
1565
1566         /* First of all: check for active disciplines and hangup them.
1567          */
1568         do {
1569                 if (busy)
1570                         msleep_interruptible(100);
1571
1572                 busy = 0;
1573                 for (i = 0; i < maxdev; i++) {
1574                         dev = sllin_devs[i];
1575                         if (!dev)
1576                                 continue;
1577                         sl = netdev_priv(dev);
1578                         spin_lock_bh(&sl->lock);
1579                         if (sl->tty) {
1580                                 busy++;
1581                                 tty_hangup(sl->tty);
1582                         }
1583                         spin_unlock_bh(&sl->lock);
1584                 }
1585         } while (busy && time_before(jiffies, timeout));
1586
1587         /* FIXME: hangup is async so we should wait when doing this second
1588            phase */
1589
1590         for (i = 0; i < maxdev; i++) {
1591                 dev = sllin_devs[i];
1592                 if (!dev)
1593                         continue;
1594                 sllin_devs[i] = NULL;
1595
1596                 sl = netdev_priv(dev);
1597                 if (sl->tty) {
1598                         netdev_dbg(sl->dev, "tty discipline still running\n");
1599                         /* Intentionally leak the control block. */
1600                         dev->destructor = NULL;
1601                 }
1602
1603                 unregister_netdev(dev);
1604         }
1605
1606         kfree(sllin_devs);
1607         sllin_devs = NULL;
1608
1609         i = tty_unregister_ldisc(N_SLLIN);
1610         if (i)
1611                 pr_err("sllin: can't unregister ldisc (err %d)\n", i);
1612 }
1613
1614 module_init(sllin_init);
1615 module_exit(sllin_exit);