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