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