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