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