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