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