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