sllin/sllin.c

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