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