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