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