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