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