sllin/sllin.c

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