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