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