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