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                                 break;
 835
 836                         case SLSTATE_BREAK_SENT:
 837 #ifdef BREAK_BY_BAUD
 838                                 if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
 839                                         continue;
 840
 841                                 res = sltty_change_speed(tty, sl->lin_baud);
 842 #endif
 843
 844                                 sl->lin_state = SLSTATE_ID_SENT;
 845                                 sllin_send_tx_buff(sl);
 846                                 break;
 847
 848                         case SLSTATE_ID_SENT:
 849                                 sl->id_to_send = false;
 850                                 if (sl->data_to_send) {
 851                                         sllin_send_tx_buff(sl);
 852                                         sl->lin_state = SLSTATE_RESPONSE_SENT;
 853                                         sl->rx_expect = sl->tx_lim;
 854                                         goto slstate_response_sent;
 855                                 } else {
 856                                         if (sl->resp_len_known) {
 857                                                 sl->rx_expect = sl->rx_lim;
 858                                         } else {
 859                                                 sl->rx_expect = SLLIN_BUFF_DATA + 2;
 860                                         }
 861                                         sl->lin_state = SLSTATE_RESPONSE_WAIT;
 862                                         /* If we don't receive anything, timer will "unblock" us */
 863                                         hrtimer_start(&sl->rx_timer,
 864                                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
 865                                                 HRTIMER_MODE_ABS);
 866                                         goto slstate_response_wait;
 867                                 }
 868                                 break;
 869
 870                         case SLSTATE_RESPONSE_WAIT:
 871                         slstate_response_wait:
 872                                 if (test_bit(SLF_MSGEVENT, &sl->flags)) {
 873                                         unsigned char *lin_buff;
 874                                         cf = (struct can_frame *)sl->tx_req_skb->data;
 875
 876                                         lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
 877                                         if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
 878                                                 if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
 879                                                         cf->can_id & LIN_ID_MASK,
 880                                                         cf->data, cf->can_dlc) != -1) {
 881
 882                                                         sl->rx_expect = sl->tx_lim;
 883                                                         sl->data_to_send = true;
 884                                                         sl->dev->stats.tx_packets++;
 885                                                         sl->dev->stats.tx_bytes += tx_bytes;
 886
 887                                                         if (!sl->lin_master) {
 888                                                                 sl->tx_cnt = SLLIN_BUFF_DATA;
 889                                                         }
 890
 891                                                         sllin_send_tx_buff(sl);
 892                                                         clear_bit(SLF_MSGEVENT, &sl->flags);
 893                                                         kfree_skb(sl->tx_req_skb);
 894                                                         netif_wake_queue(sl->dev);
 895
 896                                                         sl->lin_state = SLSTATE_RESPONSE_SENT;
 897                                                         goto slstate_response_sent;
 898                                                 }
 899                                         } else {
 900                                                 sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
 901                                         }
 902                                 }
 903
 904                                 /* Be aware, no BREAK here */
 905                         case SLSTATE_RESPONSE_WAIT_BUS:
 906                                 if (sl->rx_cnt < sl->rx_expect)
 907                                         continue;
 908
 909                                 hrtimer_cancel(&sl->rx_timer);
 910                                 pr_debug("sllin: response received ID %d len %d\n",
 911                                         sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
 912
 913                                 if (sllin_rx_validate(sl) == -1) {
 914                                         pr_debug("sllin: RX validation failed.\n");
 915                                         sllin_report_error(sl, LIN_ERR_CHECKSUM);
 916                                 } else {
 917                                         /* Send CAN non-RTR frame with data */
 918                                         pr_debug("sllin: sending NON-RTR CAN"
 919                                                 "frame with LIN payload.");
 920                                         sll_bump(sl); /* send packet to the network layer */
 921                                 }
 922
 923                                 sl->id_to_send = false;
 924                                 sl->lin_state = SLSTATE_IDLE;
 925                                 break;
 926
 927                         case SLSTATE_RESPONSE_SENT:
 928                         slstate_response_sent:
 929                                 if (sl->rx_cnt < sl->tx_lim)
 930                                         continue;
 931
 932                                 sll_bump(sl); /* send packet to the network layer */
 933                                 pr_debug("sllin: response sent ID %d len %d\n",
 934                                         sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
 935
 936                                 sl->id_to_send = false;
 937                                 sl->lin_state = SLSTATE_IDLE;
 938                                 break;
 939                 }
 940         }
 941
 942         hrtimer_cancel(&sl->rx_timer);
 943         pr_debug("sllin: sllin_kwthread stopped.\n");
 944
 945         return 0;
 946 }
 947
 948
 949 /************************************
 950  *  sllin_open helper routines.
 951  ************************************/
 952
 953 /* Collect hanged up channels */
 954 static void sll_sync(void)
 955 {
 956         int i;
 957         struct net_device *dev;
 958         struct sllin      *sl;
 959
 960         for (i = 0; i < maxdev; i++) {
 961                 dev = sllin_devs[i];
 962                 if (dev == NULL)
 963                         break;
 964
 965                 sl = netdev_priv(dev);
 966                 if (sl->tty)
 967                         continue;
 968                 if (dev->flags & IFF_UP)
 969                         dev_close(dev);
 970         }
 971 }
 972
 973 /* Find a free SLLIN channel, and link in this `tty' line. */
 974 static struct sllin *sll_alloc(dev_t line)
 975 {
 976         int i;
 977         struct net_device *dev = NULL;
 978         struct sllin       *sl;
 979
 980         if (sllin_devs == NULL)
 981                 return NULL;    /* Master array missing ! */
 982
 983         for (i = 0; i < maxdev; i++) {
 984                 dev = sllin_devs[i];
 985                 if (dev == NULL)
 986                         break;
 987
 988         }
 989
 990         /* Sorry, too many, all slots in use */
 991         if (i >= maxdev)
 992                 return NULL;
 993
 994         if (dev) {
 995                 sl = netdev_priv(dev);
 996                 if (test_bit(SLF_INUSE, &sl->flags)) {
 997                         unregister_netdevice(dev);
 998                         dev = NULL;
 999                         sllin_devs[i] = NULL;
1000                 }
1001         }
1002
1003         if (!dev) {
1004                 char name[IFNAMSIZ];
1005                 sprintf(name, "sllin%d", i);
1006
1007                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1008                 if (!dev)
1009                         return NULL;
1010                 dev->base_addr  = i;
1011         }
1012
1013         sl = netdev_priv(dev);
1014         /* Initialize channel control data */
1015         sl->magic = SLLIN_MAGIC;
1016         sl->dev = dev;
1017         spin_lock_init(&sl->lock);
1018         sllin_devs[i] = dev;
1019
1020         return sl;
1021 }
1022
1023 /*
1024  * Open the high-level part of the SLLIN channel.
1025  * This function is called by the TTY module when the
1026  * SLLIN line discipline is called for.  Because we are
1027  * sure the tty line exists, we only have to link it to
1028  * a free SLLIN channel...
1029  *
1030  * Called in process context serialized from other ldisc calls.
1031  */
1032
1033 static int sllin_open(struct tty_struct *tty)
1034 {
1035         struct sllin *sl;
1036         int err;
1037         pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1038
1039         if (!capable(CAP_NET_ADMIN))
1040                 return -EPERM;
1041
1042         if (tty->ops->write == NULL)
1043                 return -EOPNOTSUPP;
1044
1045         /* RTnetlink lock is misused here to serialize concurrent
1046            opens of sllin channels. There are better ways, but it is
1047            the simplest one.
1048          */
1049         rtnl_lock();
1050
1051         /* Collect hanged up channels. */
1052         sll_sync();
1053
1054         sl = tty->disc_data;
1055
1056         err = -EEXIST;
1057         /* First make sure we're not already connected. */
1058         if (sl && sl->magic == SLLIN_MAGIC)
1059                 goto err_exit;
1060
1061         /* OK.  Find a free SLLIN channel to use. */
1062         err = -ENFILE;
1063         sl = sll_alloc(tty_devnum(tty));
1064         if (sl == NULL)
1065                 goto err_exit;
1066
1067         sl->tty = tty;
1068         tty->disc_data = sl;
1069         sl->line = tty_devnum(tty);
1070
1071         if (!test_bit(SLF_INUSE, &sl->flags)) {
1072                 /* Perform the low-level SLLIN initialization. */
1073                 sl->lin_master = true;
1074
1075                 sl->rx_cnt = 0;
1076                 sl->rx_expect = 0;
1077                 sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
1078                 sl->tx_cnt = 0;
1079                 sl->tx_lim = 0;
1080                 sl->id_to_send = false;
1081                 sl->data_to_send = false;
1082
1083                 sl->lin_baud  = 19200;
1084
1085                 sl->lin_state = SLSTATE_IDLE;
1086
1087                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1088                 sl->rx_timer.function = sllin_rx_timeout_handler;
1089                 /* timeval_to_ktime(msg_head->ival1); */
1090                 sl->rx_timer_timeout = ns_to_ktime(
1091                         (1000000000l / sl->lin_baud) *
1092                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1093
1094                 set_bit(SLF_INUSE, &sl->flags);
1095
1096                 init_waitqueue_head(&sl->kwt_wq);
1097                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1098                 if (sl->kwthread == NULL)
1099                         goto err_free_chan;
1100
1101                 err = register_netdevice(sl->dev);
1102                 if (err)
1103                         goto err_free_chan_and_thread;
1104         }
1105
1106         /* Done.  We have linked the TTY line to a channel. */
1107         rtnl_unlock();
1108         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1109
1110         /* TTY layer expects 0 on success */
1111         return 0;
1112
1113 err_free_chan_and_thread:
1114         kthread_stop(sl->kwthread);
1115         sl->kwthread = NULL;
1116
1117 err_free_chan:
1118         sl->tty = NULL;
1119         tty->disc_data = NULL;
1120         clear_bit(SLF_INUSE, &sl->flags);
1121
1122 err_exit:
1123         rtnl_unlock();
1124
1125         /* Count references from TTY module */
1126         return err;
1127 }
1128
1129 /*
1130  * Close down a SLLIN channel.
1131  * This means flushing out any pending queues, and then returning. This
1132  * call is serialized against other ldisc functions.
1133  *
1134  * We also use this method for a hangup event.
1135  */
1136
1137 static void sllin_close(struct tty_struct *tty)
1138 {
1139         struct sllin *sl = (struct sllin *) tty->disc_data;
1140
1141         /* First make sure we're connected. */
1142         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1143                 return;
1144
1145         kthread_stop(sl->kwthread);
1146         sl->kwthread = NULL;
1147
1148         tty->disc_data = NULL;
1149         sl->tty = NULL;
1150
1151         /* Flush network side */
1152         unregister_netdev(sl->dev);
1153         /* This will complete via sl_free_netdev */
1154 }
1155
1156 static int sllin_hangup(struct tty_struct *tty)
1157 {
1158         sllin_close(tty);
1159         return 0;
1160 }
1161
1162 /* Perform I/O control on an active SLLIN channel. */
1163 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1164                        unsigned int cmd, unsigned long arg)
1165 {
1166         struct sllin *sl = (struct sllin *) tty->disc_data;
1167         unsigned int tmp;
1168
1169         /* First make sure we're connected. */
1170         if (!sl || sl->magic != SLLIN_MAGIC)
1171                 return -EINVAL;
1172
1173         switch (cmd) {
1174         case SIOCGIFNAME:
1175                 tmp = strlen(sl->dev->name) + 1;
1176                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1177                         return -EFAULT;
1178                 return 0;
1179
1180         case SIOCSIFHWADDR:
1181                 return -EINVAL;
1182
1183         default:
1184                 return tty_mode_ioctl(tty, file, cmd, arg);
1185         }
1186 }
1187
1188 static struct tty_ldisc_ops sll_ldisc = {
1189         .owner          = THIS_MODULE,
1190         .magic          = TTY_LDISC_MAGIC,
1191         .name           = "sllin",
1192         .open           = sllin_open,
1193         .close          = sllin_close,
1194         .hangup         = sllin_hangup,
1195         .ioctl          = sllin_ioctl,
1196         .receive_buf    = sllin_receive_buf,
1197         .write_wakeup   = sllin_write_wakeup,
1198 };
1199
1200 static int __init sllin_init(void)
1201 {
1202         int status;
1203
1204         if (maxdev < 4)
1205                 maxdev = 4; /* Sanity */
1206
1207         printk(banner);
1208         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1209
1210         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1211         if (!sllin_devs) {
1212                 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1213                 return -ENOMEM;
1214         }
1215
1216         /* Fill in our line protocol discipline, and register it */
1217         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1218         if (status)  {
1219                 printk(KERN_ERR "sllin: can't register line discipline\n");
1220                 kfree(sllin_devs);
1221         }
1222
1223 #ifdef BREAK_BY_BAUD
1224         pr_debug("sllin: Break is generated by baud-rate change.");
1225 #else
1226         pr_debug("sllin: Break is generated manually with tiny sleep.");
1227 #endif
1228
1229         return status;
1230 }
1231
1232 static void __exit sllin_exit(void)
1233 {
1234         int i;
1235         struct net_device *dev;
1236         struct sllin *sl;
1237         unsigned long timeout = jiffies + HZ;
1238         int busy = 0;
1239
1240         if (sllin_devs == NULL)
1241                 return;
1242
1243         /* First of all: check for active disciplines and hangup them.
1244          */
1245         do {
1246                 if (busy)
1247                         msleep_interruptible(100);
1248
1249                 busy = 0;
1250                 for (i = 0; i < maxdev; i++) {
1251                         dev = sllin_devs[i];
1252                         if (!dev)
1253                                 continue;
1254                         sl = netdev_priv(dev);
1255                         spin_lock_bh(&sl->lock);
1256                         if (sl->tty) {
1257                                 busy++;
1258                                 tty_hangup(sl->tty);
1259                         }
1260                         spin_unlock_bh(&sl->lock);
1261                 }
1262         } while (busy && time_before(jiffies, timeout));
1263
1264         /* FIXME: hangup is async so we should wait when doing this second
1265            phase */
1266
1267         for (i = 0; i < maxdev; i++) {
1268                 dev = sllin_devs[i];
1269                 if (!dev)
1270                         continue;
1271                 sllin_devs[i] = NULL;
1272
1273                 sl = netdev_priv(dev);
1274                 if (sl->tty) {
1275                         printk(KERN_ERR "%s: tty discipline still running\n",
1276                                dev->name);
1277                         /* Intentionally leak the control block. */
1278                         dev->destructor = NULL;
1279                 }
1280
1281                 unregister_netdev(dev);
1282         }
1283
1284         kfree(sllin_devs);
1285         sllin_devs = NULL;
1286
1287         i = tty_unregister_ldisc(N_SLLIN);
1288         if (i)
1289                 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1290 }
1291
1292 module_init(sllin_init);
1293 module_exit(sllin_exit);