sllin/sllin.c

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