sllin/sllin.c

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