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