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