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