sllin/sllin.c

   1 /*
   2  * sllin.c - serial line LIN interface driver (using tty line discipline)
   3  *
   4  * This file is derived from drivers/net/can/slcan.c
   5  * slcan.c Author: Oliver Hartkopp <socketcan@hartkopp.net>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 59 Temple Place, Suite 330, Boston, MA 02111-1307. You can also get it
  20  * at http://www.gnu.org/licenses/gpl.html
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  33  * DAMAGE.
  34  *
  35  * Idea:       Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
  36  * Copyright:  (c) 2011 Czech Technical University in Prague
  37  *             (c) 2011 Volkswagen Group Research
  38  * Authors:    Pavel Pisa <pisa@cmp.felk.cvut.cz>
  39  *             Rostislav Lisovy <lisovy@kormus.cz>
  40  *             Michal Sojka <sojkam1@fel.cvut.cz>
  41  * Funded by:  Volkswagen Group Research
  42  */
  43
  44 #define DEBUG                   1 /* Enables pr_debug() printouts */
  45
  46 #include <linux/module.h>
  47 #include <linux/moduleparam.h>
  48
  49 #include <asm/system.h>
  50 #include <linux/uaccess.h>
  51 #include <linux/bitops.h>
  52 #include <linux/string.h>
  53 #include <linux/tty.h>
  54 #include <linux/errno.h>
  55 #include <linux/netdevice.h>
  56 #include <linux/skbuff.h>
  57 #include <linux/rtnetlink.h>
  58 #include <linux/if_arp.h>
  59 #include <linux/if_ether.h>
  60 #include <linux/sched.h>
  61 #include <linux/delay.h>
  62 #include <linux/init.h>
  63 #include <linux/can.h>
  64 #include <linux/kthread.h>
  65 #include <linux/hrtimer.h>
  66 #include "linux/lin_bus.h"
  67
  68 /* Should be in include/linux/tty.h */
  69 #define N_SLLIN                 25
  70 /* -------------------------------- */
  71
  72 static __initdata const char banner[] =
  73         KERN_INFO "sllin: serial line LIN interface driver\n";
  74
  75 MODULE_ALIAS_LDISC(N_SLLIN);
  76 MODULE_DESCRIPTION("serial line LIN interface");
  77 MODULE_LICENSE("GPL");
  78 MODULE_AUTHOR("Pavel Pisa <pisa@cmp.felk.cvut.cz>");
  79
  80 #define SLLIN_MAGIC             0x53CA
  81 /* #define BREAK_BY_BAUD */
  82
  83 static int master = true;
  84 static int baudrate; /* Use LIN_DEFAULT_BAUDRATE when not set */
  85
  86 module_param(master, bool, 0);
  87 MODULE_PARM_DESC(master, "LIN interface is Master device");
  88 module_param(baudrate, int, 0);
  89 MODULE_PARM_DESC(baudrate, "Baudrate of LIN interface");
  90
  91 static int maxdev = 10;         /* MAX number of SLLIN channels;
  92                                    This can be overridden with
  93                                    insmod sllin.ko maxdev=nnn   */
  94 module_param(maxdev, int, 0);
  95 MODULE_PARM_DESC(maxdev, "Maximum number of sllin interfaces");
  96
  97 /* maximum buffer len to store whole LIN message*/
  98 #define SLLIN_DATA_MAX          8
  99 #define SLLIN_BUFF_LEN          (1 /*break*/ + 1 /*sync*/ + 1 /*ID*/ + \
 100                                 SLLIN_DATA_MAX + 1 /*checksum*/)
 101 #define SLLIN_BUFF_BREAK        0
 102 #define SLLIN_BUFF_SYNC         1
 103 #define SLLIN_BUFF_ID           2
 104 #define SLLIN_BUFF_DATA         3
 105
 106 #define SLLIN_SAMPLES_PER_CHAR  10
 107 #define SLLIN_CHARS_TO_TIMEOUT  24
 108
 109 enum slstate {
 110         SLSTATE_IDLE = 0,
 111         SLSTATE_BREAK_SENT,
 112         SLSTATE_ID_SENT,
 113         SLSTATE_RESPONSE_WAIT, /* Wait for response */
 114         SLSTATE_RESPONSE_WAIT_BUS, /* Wait for response from LIN bus
 115                                 only (CAN frames from network stack
 116                                 are not processed in this moment) */
 117         SLSTATE_RESPONSE_SENT,
 118 };
 119
 120 struct sllin_conf_entry {
 121         int dlc;                /* Length of data in LIN frame */
 122         canid_t frame_fl;       /* LIN frame flags. Passed from userspace as
 123                                    canid_t data type */
 124         u8 data[8];             /* LIN frame data payload */
 125 };
 126
 127 struct sllin {
 128         int                     magic;
 129
 130         /* Various fields. */
 131         struct tty_struct       *tty;           /* ptr to TTY structure      */
 132         struct net_device       *dev;           /* easy for intr handling    */
 133         spinlock_t              lock;
 134
 135         /* LIN message buffer and actual processed data counts */
 136         unsigned char           rx_buff[SLLIN_BUFF_LEN]; /* LIN Rx buffer */
 137         unsigned char           tx_buff[SLLIN_BUFF_LEN]; /* LIN Tx buffer */
 138         int                     rx_expect;      /* expected number of Rx chars */
 139         int                     rx_lim;         /* maximum Rx chars for current frame */
 140         int                     rx_cnt;         /* message buffer Rx fill level  */
 141         int                     tx_lim;         /* actual limit of bytes to Tx */
 142         int                     tx_cnt;         /* number of already Tx bytes */
 143         char                    lin_master;     /* node is a master node */
 144         int                     lin_baud;       /* LIN baudrate */
 145         int                     lin_state;      /* state */
 146         char                    id_to_send;     /* there is ID to be sent */
 147         char                    data_to_send;   /* there are data to be sent */
 148         char                    resp_len_known; /* Length of the response is known */
 149         char                    header_received;/* In Slave mode, set when header was already
 150                                                    received */
 151         char                    rx_len_unknown; /* We are not sure how much data will be sent to us --
 152                                                    we just guess the length */
 153
 154         unsigned long           flags;          /* Flag values/ mode etc     */
 155 #define SLF_INUSE               0               /* Channel in use            */
 156 #define SLF_ERROR               1               /* Parity, etc. error        */
 157 #define SLF_RXEVENT             2               /* Rx wake event             */
 158 #define SLF_TXEVENT             3               /* Tx wake event             */
 159 #define SLF_MSGEVENT            4               /* CAN message to sent       */
 160 #define SLF_TMOUTEVENT          5               /* Timeout on received data  */
 161
 162         dev_t                   line;
 163         struct task_struct      *kwthread;
 164         wait_queue_head_t       kwt_wq;         /* Wait queue used by kwthread */
 165         struct hrtimer          rx_timer;       /* RX timeout timer */
 166         ktime_t                 rx_timer_timeout; /* RX timeout timer value */
 167         struct sk_buff          *tx_req_skb;    /* Socket buffer with CAN frame
 168                                                 received from network stack*/
 169
 170         /* List with configurations for each of 0 to LIN_ID_MAX LIN IDs */
 171         struct sllin_conf_entry linfr_cache[LIN_ID_MAX + 1];
 172 };
 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                                 spin_lock(&sl->lock);
 501                                 /* Is the length of data set in frame cache? */
 502                                 if (sce->frame_fl & LIN_LOC_SLAVE_CACHE) {
 503                                         sl->rx_expect += sce->dlc;
 504                                         sl->rx_len_unknown = false;
 505                                 } else {
 506                                         sl->rx_expect += SLLIN_DATA_MAX + 1; /* + checksum */
 507                                         sl->rx_len_unknown = true;
 508                                 }
 509                                 spin_unlock(&sl->lock);
 510
 511                                 sl->header_received = true;
 512                                 sll_send_rtr(sl);
 513                                 continue;
 514                         }
 515
 516                         if (SLL_RESPONSE_RECEIVED) {
 517                                 sll_bump(sl);
 518                                 pr_debug("sllin: Received LIN header & LIN response. "
 519                                                 "rx_cnt = %u, rx_expect = %u\n", sl->rx_cnt,
 520                                                 sl->rx_expect);
 521
 522                                 /* Prepare for reception of new header */
 523                                 sl->rx_cnt = 0;
 524                                 sl->rx_expect = SLLIN_BUFF_ID + 1;
 525                                 sl->rx_len_unknown = false; /* We do know exact length of the header */
 526                                 sl->header_received = false;
 527                         }
 528                 }
 529         }
 530 }
 531
 532 /*****************************************
 533  *  sllin message helper routines
 534  *****************************************/
 535 /**
 536  * sllin_report_error() -- Report an error by sending CAN frame
 537  *      with particular error flag set in can_id
 538  *
 539  * @sl:
 540  * @err: Error flag to be sent.
 541  */
 542 void sllin_report_error(struct sllin *sl, int err)
 543 {
 544         switch (err) {
 545         case LIN_ERR_CHECKSUM:
 546                 sl->dev->stats.rx_crc_errors++;
 547                 break;
 548
 549         case LIN_ERR_RX_TIMEOUT:
 550                 sl->dev->stats.rx_errors++;
 551                 break;
 552
 553         case LIN_ERR_FRAMING:
 554                 sl->dev->stats.rx_frame_errors++;
 555                 break;
 556         }
 557
 558         sllin_send_canfr(sl, 0 | CAN_EFF_FLAG |
 559                 (err & ~LIN_ID_MASK), NULL, 0);
 560 }
 561
 562 /**
 563  * sllin_configure_frame_cache() -- Configure particular entry in linfr_cache
 564  *
 565  * @sl:
 566  * @cf: Pointer to CAN frame sent to this driver
 567  *      holding configuration information
 568  *
 569  * Called with sl->lock held.
 570  */
 571 static int sllin_configure_frame_cache(struct sllin *sl, struct can_frame *cf)
 572 {
 573         struct sllin_conf_entry *sce;
 574         if (!(cf->can_id & LIN_ID_CONF))
 575                 return -1;
 576
 577         sce = &sl->linfr_cache[cf->can_id & LIN_ID_MASK];
 578         pr_debug("sllin: Setting frame cache with EFF CAN frame. "
 579                 "LIN ID = %d\n", cf->can_id & LIN_ID_MASK);
 580
 581         sce->dlc = cf->can_dlc;
 582         if (sce->dlc > SLLIN_DATA_MAX)
 583                 sce->dlc = SLLIN_DATA_MAX;
 584
 585         sce->frame_fl = (cf->can_id & ~LIN_ID_MASK) & CAN_EFF_MASK;
 586         memcpy(sce->data, cf->data, cf->can_dlc);
 587
 588         return 0;
 589 }
 590
 591 /**
 592  * sllin_checksum() -- Count checksum for particular data
 593  *
 594  * @data:        Pointer to the buffer containing whole LIN
 595  *               frame (i.e. including break and sync bytes).
 596  * @length:      Length of the buffer.
 597  * @enhanced_fl: Flag determining whether Enhanced or Classic
 598  *               checksum should be counted.
 599  */
 600 static inline unsigned sllin_checksum(unsigned char *data, int length, int enhanced_fl)
 601 {
 602         unsigned csum = 0;
 603         int i;
 604
 605         if (enhanced_fl) {
 606                 i = SLLIN_BUFF_ID;
 607         } else {
 608                 i = SLLIN_BUFF_DATA;
 609         }
 610
 611         for (; i < length; i++) {
 612                 csum += data[i];
 613                 if (csum > 255)
 614                         csum -= 255;
 615         }
 616
 617         return ~csum & 0xff;
 618 }
 619
 620 #define SLLIN_STPMSG_RESPONLY           (1) /* Message will be LIN Response only */
 621 #define SLLIN_STPMSG_CHCKSUM_CLS        (1 << 1)
 622 #define SLLIN_STPMSG_CHCKSUM_ENH        (1 << 2)
 623
 624 int sllin_setup_msg(struct sllin *sl, int mode, int id,
 625                 unsigned char *data, int len)
 626 {
 627         if (id > LIN_ID_MASK)
 628                 return -1;
 629
 630         if (!(mode & SLLIN_STPMSG_RESPONLY)) {
 631                 sl->rx_cnt = 0;
 632                 sl->tx_cnt = 0;
 633                 sl->rx_expect = 0;
 634                 sl->rx_lim = SLLIN_BUFF_LEN;
 635         }
 636
 637         sl->tx_buff[SLLIN_BUFF_BREAK] = 0;
 638         sl->tx_buff[SLLIN_BUFF_SYNC]  = 0x55;
 639         sl->tx_buff[SLLIN_BUFF_ID]    = id | sllin_id_parity_table[id];
 640         sl->tx_lim = SLLIN_BUFF_DATA;
 641
 642         if ((data != NULL) && len) {
 643                 sl->tx_lim += len;
 644                 memcpy(sl->tx_buff + SLLIN_BUFF_DATA, data, len);
 645                 sl->tx_buff[sl->tx_lim++] = sllin_checksum(sl->tx_buff,
 646                                 sl->tx_lim, mode & SLLIN_STPMSG_CHCKSUM_ENH);
 647         }
 648         if (len != 0)
 649                 sl->rx_lim = SLLIN_BUFF_DATA + len + 1;
 650
 651         return 0;
 652 }
 653
 654 static void sllin_reset_buffs(struct sllin *sl)
 655 {
 656         sl->rx_cnt = 0;
 657         sl->rx_expect = 0;
 658         sl->rx_lim = sl->lin_master ? 0 : SLLIN_BUFF_LEN;
 659         sl->tx_cnt = 0;
 660         sl->tx_lim = 0;
 661         sl->id_to_send = false;
 662         sl->data_to_send = false;
 663 }
 664
 665 int sllin_send_tx_buff(struct sllin *sl)
 666 {
 667         struct tty_struct *tty = sl->tty;
 668         int remains;
 669         int res;
 670
 671 #ifdef BREAK_BY_BAUD
 672         if (sl->lin_state != SLSTATE_BREAK_SENT)
 673                 remains = sl->tx_lim - sl->tx_cnt;
 674         else
 675                 remains = 1;
 676 #else
 677         remains = sl->tx_lim - sl->tx_cnt;
 678 #endif
 679
 680         res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 681         if (res < 0)
 682                 return -1;
 683
 684         remains -= res;
 685         sl->tx_cnt += res;
 686
 687         if (remains > 0) {
 688                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 689                 res = tty->ops->write(tty, sl->tx_buff + sl->tx_cnt, remains);
 690                 if (res < 0) {
 691                         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 692                         return -1;
 693                 }
 694
 695                 remains -= res;
 696                 sl->tx_cnt += res;
 697         }
 698
 699         pr_debug("sllin: sllin_send_tx_buff sent %d, remains %d\n",
 700                         sl->tx_cnt, remains);
 701
 702         return 0;
 703 }
 704
 705 #ifdef BREAK_BY_BAUD
 706 int sllin_send_break(struct sllin *sl)
 707 {
 708         struct tty_struct *tty = sl->tty;
 709         unsigned long break_baud;
 710         int res;
 711
 712         break_baud = ((sl->lin_baud * 2) / 3);
 713         sltty_change_speed(tty, break_baud);
 714
 715         tty->ops->flush_buffer(tty);
 716         sl->rx_cnt = SLLIN_BUFF_BREAK;
 717
 718         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 719         sl->lin_state = SLSTATE_BREAK_SENT;
 720
 721         res = sllin_send_tx_buff(sl);
 722         if (res < 0) {
 723                 sl->lin_state = SLSTATE_IDLE;
 724                 return res;
 725         }
 726
 727         return 0;
 728 }
 729 #else /* BREAK_BY_BAUD */
 730
 731 int sllin_send_break(struct sllin *sl)
 732 {
 733         struct tty_struct *tty = sl->tty;
 734         int retval;
 735         unsigned long break_baud;
 736         unsigned long usleep_range_min;
 737         unsigned long usleep_range_max;
 738
 739         break_baud = ((sl->lin_baud * 2) / 3);
 740         sl->rx_cnt = SLLIN_BUFF_BREAK;
 741         sl->rx_expect = SLLIN_BUFF_BREAK + 1;
 742         sl->lin_state = SLSTATE_BREAK_SENT;
 743
 744         /* Do the break ourselves; Inspired by
 745            http://lxr.linux.no/#linux+v3.1.2/drivers/tty/tty_io.c#L2452 */
 746         retval = tty->ops->break_ctl(tty, -1);
 747         if (retval)
 748                 return retval;
 749
 750         /* udelay(712); */
 751         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR) / break_baud;
 752         usleep_range_max = usleep_range_min + 50;
 753         usleep_range(usleep_range_min, usleep_range_max);
 754
 755         retval = tty->ops->break_ctl(tty, 0);
 756         usleep_range_min = (1000000l * 1 /* 1 bit */) / break_baud;
 757         usleep_range_max = usleep_range_min + 30;
 758         usleep_range(usleep_range_min, usleep_range_max);
 759
 760         tty->ops->flush_buffer(tty);
 761
 762         sl->tx_cnt = SLLIN_BUFF_SYNC;
 763
 764         pr_debug("sllin: Break sent.\n");
 765         set_bit(SLF_RXEVENT, &sl->flags);
 766         wake_up(&sl->kwt_wq);
 767
 768         return 0;
 769 }
 770 #endif /* BREAK_BY_BAUD */
 771
 772
 773 static enum hrtimer_restart sllin_rx_timeout_handler(struct hrtimer *hrtimer)
 774 {
 775         struct sllin *sl = container_of(hrtimer, struct sllin, rx_timer);
 776
 777         sllin_report_error(sl, LIN_ERR_RX_TIMEOUT);
 778         set_bit(SLF_TMOUTEVENT, &sl->flags);
 779         wake_up(&sl->kwt_wq);
 780
 781         return HRTIMER_NORESTART;
 782 }
 783
 784 /**
 785  * sllin_rx_validate() -- Validate received frame, i,e. check checksum
 786  *
 787  * @sl:
 788  */
 789 static int sllin_rx_validate(struct sllin *sl)
 790 {
 791         int actual_id;
 792         int ext_chcks_fl;
 793         int lin_dlc;
 794         unsigned char rec_chcksm = sl->rx_buff[sl->rx_cnt - 1];
 795         struct sllin_conf_entry *scf;
 796
 797         actual_id = sl->rx_buff[SLLIN_BUFF_ID] & LIN_ID_MASK;
 798         scf = &sl->linfr_cache[actual_id];
 799         spin_lock(&sl->lock);
 800         lin_dlc = scf->dlc;
 801         ext_chcks_fl = scf->frame_fl & LIN_CHECKSUM_EXTENDED;
 802         spin_unlock(&sl->lock);
 803
 804         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1, ext_chcks_fl) !=
 805                 rec_chcksm) {
 806
 807                 /* Type of checksum is configured for particular frame */
 808                 if (lin_dlc > 0) {
 809                         return -1;
 810                 } else {
 811                         if (sllin_checksum(sl->rx_buff, sl->rx_cnt - 1,
 812                                 !ext_chcks_fl) != rec_chcksm) {
 813                                 return -1;
 814                         }
 815                 }
 816         }
 817
 818         return 0;
 819 }
 820
 821 /*****************************************
 822  *  sllin_kwthread - kernel worker thread
 823  *****************************************/
 824
 825 int sllin_kwthread(void *ptr)
 826 {
 827         struct sllin *sl = (struct sllin *)ptr;
 828         struct tty_struct *tty = sl->tty;
 829         struct sched_param schparam = { .sched_priority = 40 };
 830         int tx_bytes = 0; /* Used for Network statistics */
 831
 832
 833         pr_debug("sllin: sllin_kwthread started.\n");
 834         sched_setscheduler(current, SCHED_FIFO, &schparam);
 835
 836         clear_bit(SLF_ERROR, &sl->flags);
 837         sltty_change_speed(tty, sl->lin_baud);
 838
 839         while (!kthread_should_stop()) {
 840                 struct can_frame *cf;
 841                 u8 *lin_data;
 842                 int lin_dlc;
 843                 u8 lin_data_buff[SLLIN_DATA_MAX];
 844
 845
 846                 if ((sl->lin_state == SLSTATE_IDLE) && sl->lin_master &&
 847                         sl->id_to_send) {
 848                         if (sllin_send_break(sl) < 0) {
 849                                 /* error processing */
 850                         }
 851                 }
 852
 853                 wait_event_killable(sl->kwt_wq, kthread_should_stop() ||
 854                         test_bit(SLF_RXEVENT, &sl->flags) ||
 855                         test_bit(SLF_TXEVENT, &sl->flags) ||
 856                         test_bit(SLF_TMOUTEVENT, &sl->flags) ||
 857                         test_bit(SLF_ERROR, &sl->flags) ||
 858                         (((sl->lin_state == SLSTATE_IDLE) ||
 859                                 (sl->lin_state == SLSTATE_RESPONSE_WAIT))
 860                                 && test_bit(SLF_MSGEVENT, &sl->flags)));
 861
 862                 if (test_and_clear_bit(SLF_RXEVENT, &sl->flags)) {
 863                         pr_debug("sllin: sllin_kthread RXEVENT\n");
 864                 }
 865
 866                 if (test_and_clear_bit(SLF_ERROR, &sl->flags)) {
 867                         unsigned long usleep_range_min;
 868                         unsigned long usleep_range_max;
 869                         hrtimer_cancel(&sl->rx_timer);
 870                         pr_debug("sllin: sllin_kthread ERROR\n");
 871
 872                         if (sl->lin_state != SLSTATE_IDLE)
 873                                 sllin_report_error(sl, LIN_ERR_FRAMING);
 874
 875                         usleep_range_min = (1000000l * SLLIN_SAMPLES_PER_CHAR * 10) /
 876                                                 sl->lin_baud;
 877                         usleep_range_max = usleep_range_min + 50;
 878                         usleep_range(usleep_range_min, usleep_range_max);
 879                         sllin_reset_buffs(sl);
 880                         sl->lin_state = SLSTATE_IDLE;
 881                 }
 882
 883                 if (test_and_clear_bit(SLF_TXEVENT, &sl->flags)) {
 884                         pr_debug("sllin: sllin_kthread TXEVENT\n");
 885                 }
 886
 887                 if (test_and_clear_bit(SLF_TMOUTEVENT, &sl->flags)) {
 888                         pr_debug("sllin: sllin_kthread TMOUTEVENT\n");
 889                         sllin_reset_buffs(sl);
 890
 891                         sl->lin_state = SLSTATE_IDLE;
 892                 }
 893
 894                 switch (sl->lin_state) {
 895                 case SLSTATE_IDLE:
 896                         if (!test_bit(SLF_MSGEVENT, &sl->flags))
 897                                 break;
 898
 899                         cf = (struct can_frame *)sl->tx_req_skb->data;
 900
 901                         /* SFF RTR CAN frame -> LIN header */
 902                         if (cf->can_id & CAN_RTR_FLAG) {
 903                                 spin_lock(&sl->lock);
 904                                 pr_debug("sllin: %s: RTR SFF CAN frame, ID = %x\n",
 905                                         __FUNCTION__, cf->can_id & LIN_ID_MASK);
 906
 907                                 /* Is there Slave response in linfr_cache to be sent? */
 908                                 if ((sl->linfr_cache[cf->can_id & LIN_ID_MASK].frame_fl &
 909                                         LIN_LOC_SLAVE_CACHE)
 910                                         && (sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc > 0)) {
 911
 912                                         pr_debug("sllin: Sending LIN response from linfr_cache\n");
 913                                         lin_data = sl->linfr_cache[cf->can_id & LIN_ID_MASK].data;
 914                                         lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
 915                                         if (lin_dlc > SLLIN_DATA_MAX)
 916                                                 lin_dlc = SLLIN_DATA_MAX;
 917                                         memcpy(lin_data_buff, lin_data, lin_dlc);
 918                                         lin_data = lin_data_buff;
 919                                 } else {
 920                                         lin_data = NULL;
 921                                         lin_dlc = sl->linfr_cache[cf->can_id & LIN_ID_MASK].dlc;
 922                                 }
 923                                 spin_unlock(&sl->lock);
 924                         } else { /* SFF NON-RTR CAN frame -> LIN header + LIN response */
 925                                 pr_debug("sllin: %s: NON-RTR SFF CAN frame, ID = %x\n",
 926                                         __FUNCTION__, (int)cf->can_id & LIN_ID_MASK);
 927
 928                                 lin_data = cf->data;
 929                                 lin_dlc = cf->can_dlc;
 930                                 if (lin_dlc > SLLIN_DATA_MAX)
 931                                         lin_dlc = SLLIN_DATA_MAX;
 932                                 tx_bytes = lin_dlc;
 933                         }
 934
 935                         if (sllin_setup_msg(sl, 0, cf->can_id & LIN_ID_MASK,
 936                                 lin_data, lin_dlc) != -1) {
 937
 938                                 sl->id_to_send = true;
 939                                 sl->data_to_send = (lin_data != NULL) ? true : false;
 940                                 sl->resp_len_known = (lin_dlc > 0) ? true : false;
 941                                 sl->dev->stats.tx_packets++;
 942                                 sl->dev->stats.tx_bytes += tx_bytes;
 943                         }
 944
 945                         clear_bit(SLF_MSGEVENT, &sl->flags);
 946                         kfree_skb(sl->tx_req_skb);
 947                         netif_wake_queue(sl->dev);
 948                         hrtimer_start(&sl->rx_timer,
 949                                 ktime_add(ktime_get(), sl->rx_timer_timeout),
 950                                 HRTIMER_MODE_ABS);
 951                         break;
 952
 953                 case SLSTATE_BREAK_SENT:
 954 #ifdef BREAK_BY_BAUD
 955                         if (sl->rx_cnt <= SLLIN_BUFF_BREAK)
 956                                 continue;
 957
 958                         res = sltty_change_speed(tty, sl->lin_baud);
 959 #endif
 960
 961                         sl->lin_state = SLSTATE_ID_SENT;
 962                         sllin_send_tx_buff(sl);
 963                         break;
 964
 965                 case SLSTATE_ID_SENT:
 966                         hrtimer_cancel(&sl->rx_timer);
 967                         sl->id_to_send = false;
 968                         if (sl->data_to_send) {
 969                                 sllin_send_tx_buff(sl);
 970                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
 971                                 sl->rx_expect = sl->tx_lim;
 972                                 goto slstate_response_sent;
 973                         } else {
 974                                 if (sl->resp_len_known) {
 975                                         sl->rx_expect = sl->rx_lim;
 976                                 } else {
 977                                         sl->rx_expect = SLLIN_BUFF_DATA + 2;
 978                                 }
 979                                 sl->lin_state = SLSTATE_RESPONSE_WAIT;
 980                                 /* If we don't receive anything, timer will "unblock" us */
 981                                 hrtimer_start(&sl->rx_timer,
 982                                         ktime_add(ktime_get(), sl->rx_timer_timeout),
 983                                         HRTIMER_MODE_ABS);
 984                                 goto slstate_response_wait;
 985                         }
 986                         break;
 987
 988                 case SLSTATE_RESPONSE_WAIT:
 989 slstate_response_wait:
 990                         if (test_bit(SLF_MSGEVENT, &sl->flags)) {
 991                                 unsigned char *lin_buff;
 992                                 cf = (struct can_frame *)sl->tx_req_skb->data;
 993
 994                                 lin_buff = (sl->lin_master) ? sl->tx_buff : sl->rx_buff;
 995                                 if (cf->can_id == (lin_buff[SLLIN_BUFF_ID] & LIN_ID_MASK)) {
 996                                         hrtimer_cancel(&sl->rx_timer);
 997                                         pr_debug("sllin: received LIN response in a CAN frame.\n");
 998                                         if (sllin_setup_msg(sl, SLLIN_STPMSG_RESPONLY,
 999                                                 cf->can_id & LIN_ID_MASK,
1000                                                 cf->data, cf->can_dlc) != -1) {
1001
1002                                                 sl->rx_expect = sl->tx_lim;
1003                                                 sl->data_to_send = true;
1004                                                 sl->dev->stats.tx_packets++;
1005                                                 sl->dev->stats.tx_bytes += tx_bytes;
1006
1007                                                 if (!sl->lin_master) {
1008                                                         sl->tx_cnt = SLLIN_BUFF_DATA;
1009                                                 }
1010
1011                                                 sllin_send_tx_buff(sl);
1012                                                 clear_bit(SLF_MSGEVENT, &sl->flags);
1013                                                 kfree_skb(sl->tx_req_skb);
1014                                                 netif_wake_queue(sl->dev);
1015
1016                                                 sl->lin_state = SLSTATE_RESPONSE_SENT;
1017                                                 goto slstate_response_sent;
1018                                         }
1019                                 } else {
1020                                         sl->lin_state = SLSTATE_RESPONSE_WAIT_BUS;
1021                                 }
1022                         }
1023
1024                         /* Be aware, no BREAK here */
1025                 case SLSTATE_RESPONSE_WAIT_BUS:
1026                         if (sl->rx_cnt < sl->rx_expect)
1027                                 continue;
1028
1029                         hrtimer_cancel(&sl->rx_timer);
1030                         pr_debug("sllin: response received ID %d len %d\n",
1031                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1032
1033                         if (sllin_rx_validate(sl) == -1) {
1034                                 pr_debug("sllin: RX validation failed.\n");
1035                                 sllin_report_error(sl, LIN_ERR_CHECKSUM);
1036                         } else {
1037                                 /* Send CAN non-RTR frame with data */
1038                                 pr_debug("sllin: sending NON-RTR CAN"
1039                                         "frame with LIN payload.");
1040                                 sll_bump(sl); /* send packet to the network layer */
1041                         }
1042
1043                         sl->id_to_send = false;
1044                         sl->lin_state = SLSTATE_IDLE;
1045                         break;
1046
1047                 case SLSTATE_RESPONSE_SENT:
1048 slstate_response_sent:
1049                         if (sl->rx_cnt < sl->tx_lim)
1050                                 continue;
1051
1052                         hrtimer_cancel(&sl->rx_timer);
1053                         sll_bump(sl); /* send packet to the network layer */
1054                         pr_debug("sllin: response sent ID %d len %d\n",
1055                                 sl->rx_buff[SLLIN_BUFF_ID], sl->rx_cnt - SLLIN_BUFF_DATA - 1);
1056
1057                         sl->id_to_send = false;
1058                         sl->lin_state = SLSTATE_IDLE;
1059                         break;
1060                 }
1061         }
1062
1063         hrtimer_cancel(&sl->rx_timer);
1064         pr_debug("sllin: sllin_kwthread stopped.\n");
1065
1066         return 0;
1067 }
1068
1069
1070 /************************************
1071  *  sllin_open helper routines.
1072  ************************************/
1073
1074 /* Collect hanged up channels */
1075 static void sll_sync(void)
1076 {
1077         int i;
1078         struct net_device *dev;
1079         struct sllin      *sl;
1080
1081         for (i = 0; i < maxdev; i++) {
1082                 dev = sllin_devs[i];
1083                 if (dev == NULL)
1084                         break;
1085
1086                 sl = netdev_priv(dev);
1087                 if (sl->tty)
1088                         continue;
1089                 if (dev->flags & IFF_UP)
1090                         dev_close(dev);
1091         }
1092 }
1093
1094 /* Find a free SLLIN channel, and link in this `tty' line. */
1095 static struct sllin *sll_alloc(dev_t line)
1096 {
1097         int i;
1098         struct net_device *dev = NULL;
1099         struct sllin       *sl;
1100
1101         if (sllin_devs == NULL)
1102                 return NULL;    /* Master array missing ! */
1103
1104         for (i = 0; i < maxdev; i++) {
1105                 dev = sllin_devs[i];
1106                 if (dev == NULL)
1107                         break;
1108
1109         }
1110
1111         /* Sorry, too many, all slots in use */
1112         if (i >= maxdev)
1113                 return NULL;
1114
1115         if (dev) {
1116                 sl = netdev_priv(dev);
1117                 if (test_bit(SLF_INUSE, &sl->flags)) {
1118                         unregister_netdevice(dev);
1119                         dev = NULL;
1120                         sllin_devs[i] = NULL;
1121                 }
1122         }
1123
1124         if (!dev) {
1125                 char name[IFNAMSIZ];
1126                 sprintf(name, "sllin%d", i);
1127
1128                 dev = alloc_netdev(sizeof(*sl), name, sll_setup);
1129                 if (!dev)
1130                         return NULL;
1131                 dev->base_addr  = i;
1132         }
1133
1134         sl = netdev_priv(dev);
1135         /* Initialize channel control data */
1136         sl->magic = SLLIN_MAGIC;
1137         sl->dev = dev;
1138         spin_lock_init(&sl->lock);
1139         sllin_devs[i] = dev;
1140
1141         return sl;
1142 }
1143
1144 /*
1145  * Open the high-level part of the SLLIN channel.
1146  * This function is called by the TTY module when the
1147  * SLLIN line discipline is called for.  Because we are
1148  * sure the tty line exists, we only have to link it to
1149  * a free SLLIN channel...
1150  *
1151  * Called in process context serialized from other ldisc calls.
1152  */
1153
1154 static int sllin_open(struct tty_struct *tty)
1155 {
1156         struct sllin *sl;
1157         int err;
1158         pr_debug("sllin: %s() invoked\n", __FUNCTION__);
1159
1160         if (!capable(CAP_NET_ADMIN))
1161                 return -EPERM;
1162
1163         if (tty->ops->write == NULL)
1164                 return -EOPNOTSUPP;
1165
1166         /* RTnetlink lock is misused here to serialize concurrent
1167            opens of sllin channels. There are better ways, but it is
1168            the simplest one.
1169          */
1170         rtnl_lock();
1171
1172         /* Collect hanged up channels. */
1173         sll_sync();
1174
1175         sl = tty->disc_data;
1176
1177         err = -EEXIST;
1178         /* First make sure we're not already connected. */
1179         if (sl && sl->magic == SLLIN_MAGIC)
1180                 goto err_exit;
1181
1182         /* OK.  Find a free SLLIN channel to use. */
1183         err = -ENFILE;
1184         sl = sll_alloc(tty_devnum(tty));
1185         if (sl == NULL)
1186                 goto err_exit;
1187
1188         sl->tty = tty;
1189         tty->disc_data = sl;
1190         sl->line = tty_devnum(tty);
1191
1192         if (!test_bit(SLF_INUSE, &sl->flags)) {
1193                 /* Perform the low-level SLLIN initialization. */
1194                 sl->lin_master = master;
1195 #ifdef DEBUG
1196                 if (master)
1197                         pr_debug("sllin: Configured as MASTER\n");
1198                 else
1199                         pr_debug("sllin: Configured as SLAVE\n");
1200 #endif
1201
1202                 sllin_reset_buffs(sl);
1203
1204                 sl->lin_baud = (baudrate == 0) ? LIN_DEFAULT_BAUDRATE : baudrate;
1205                 pr_debug("sllin: Baudrate set to %u\n", sl->lin_baud);
1206
1207                 sl->lin_state = SLSTATE_IDLE;
1208
1209                 hrtimer_init(&sl->rx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1210                 sl->rx_timer.function = sllin_rx_timeout_handler;
1211                 /* timeval_to_ktime(msg_head->ival1); */
1212                 sl->rx_timer_timeout = ns_to_ktime(
1213                         (1000000000l / sl->lin_baud) *
1214                         SLLIN_SAMPLES_PER_CHAR * SLLIN_CHARS_TO_TIMEOUT);
1215
1216                 set_bit(SLF_INUSE, &sl->flags);
1217
1218                 init_waitqueue_head(&sl->kwt_wq);
1219                 sl->kwthread = kthread_run(sllin_kwthread, sl, "sllin");
1220                 if (sl->kwthread == NULL)
1221                         goto err_free_chan;
1222
1223                 err = register_netdevice(sl->dev);
1224                 if (err)
1225                         goto err_free_chan_and_thread;
1226         }
1227
1228         /* Done.  We have linked the TTY line to a channel. */
1229         rtnl_unlock();
1230         tty->receive_room = SLLIN_BUFF_LEN * 40; /* We don't flow control */
1231
1232         /* TTY layer expects 0 on success */
1233         return 0;
1234
1235 err_free_chan_and_thread:
1236         kthread_stop(sl->kwthread);
1237         sl->kwthread = NULL;
1238
1239 err_free_chan:
1240         sl->tty = NULL;
1241         tty->disc_data = NULL;
1242         clear_bit(SLF_INUSE, &sl->flags);
1243
1244 err_exit:
1245         rtnl_unlock();
1246
1247         /* Count references from TTY module */
1248         return err;
1249 }
1250
1251 /*
1252  * Close down a SLLIN channel.
1253  * This means flushing out any pending queues, and then returning. This
1254  * call is serialized against other ldisc functions.
1255  *
1256  * We also use this method for a hangup event.
1257  */
1258
1259 static void sllin_close(struct tty_struct *tty)
1260 {
1261         struct sllin *sl = (struct sllin *) tty->disc_data;
1262
1263         /* First make sure we're connected. */
1264         if (!sl || sl->magic != SLLIN_MAGIC || sl->tty != tty)
1265                 return;
1266
1267         kthread_stop(sl->kwthread);
1268         sl->kwthread = NULL;
1269
1270         tty->disc_data = NULL;
1271         sl->tty = NULL;
1272
1273         /* Flush network side */
1274         unregister_netdev(sl->dev);
1275         /* This will complete via sl_free_netdev */
1276 }
1277
1278 static int sllin_hangup(struct tty_struct *tty)
1279 {
1280         sllin_close(tty);
1281         return 0;
1282 }
1283
1284 /* Perform I/O control on an active SLLIN channel. */
1285 static int sllin_ioctl(struct tty_struct *tty, struct file *file,
1286                        unsigned int cmd, unsigned long arg)
1287 {
1288         struct sllin *sl = (struct sllin *) tty->disc_data;
1289         unsigned int tmp;
1290
1291         /* First make sure we're connected. */
1292         if (!sl || sl->magic != SLLIN_MAGIC)
1293                 return -EINVAL;
1294
1295         switch (cmd) {
1296         case SIOCGIFNAME:
1297                 tmp = strlen(sl->dev->name) + 1;
1298                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
1299                         return -EFAULT;
1300                 return 0;
1301
1302         case SIOCSIFHWADDR:
1303                 return -EINVAL;
1304
1305         default:
1306                 return tty_mode_ioctl(tty, file, cmd, arg);
1307         }
1308 }
1309
1310 static struct tty_ldisc_ops sll_ldisc = {
1311         .owner          = THIS_MODULE,
1312         .magic          = TTY_LDISC_MAGIC,
1313         .name           = "sllin",
1314         .open           = sllin_open,
1315         .close          = sllin_close,
1316         .hangup         = sllin_hangup,
1317         .ioctl          = sllin_ioctl,
1318         .receive_buf    = sllin_receive_buf,
1319         .write_wakeup   = sllin_write_wakeup,
1320 };
1321
1322 static int __init sllin_init(void)
1323 {
1324         int status;
1325
1326         if (maxdev < 4)
1327                 maxdev = 4; /* Sanity */
1328
1329         printk(banner);
1330         pr_debug("sllin: %d dynamic interface channels.\n", maxdev);
1331
1332         sllin_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
1333         if (!sllin_devs) {
1334                 printk(KERN_ERR "sllin: can't allocate sllin device array!\n");
1335                 return -ENOMEM;
1336         }
1337
1338         /* Fill in our line protocol discipline, and register it */
1339         status = tty_register_ldisc(N_SLLIN, &sll_ldisc);
1340         if (status)  {
1341                 printk(KERN_ERR "sllin: can't register line discipline\n");
1342                 kfree(sllin_devs);
1343         }
1344
1345 #ifdef BREAK_BY_BAUD
1346         pr_debug("sllin: Break is generated by baud-rate change.");
1347 #else
1348         pr_debug("sllin: Break is generated manually with tiny sleep.");
1349 #endif
1350
1351         return status;
1352 }
1353
1354 static void __exit sllin_exit(void)
1355 {
1356         int i;
1357         struct net_device *dev;
1358         struct sllin *sl;
1359         unsigned long timeout = jiffies + HZ;
1360         int busy = 0;
1361
1362         if (sllin_devs == NULL)
1363                 return;
1364
1365         /* First of all: check for active disciplines and hangup them.
1366          */
1367         do {
1368                 if (busy)
1369                         msleep_interruptible(100);
1370
1371                 busy = 0;
1372                 for (i = 0; i < maxdev; i++) {
1373                         dev = sllin_devs[i];
1374                         if (!dev)
1375                                 continue;
1376                         sl = netdev_priv(dev);
1377                         spin_lock_bh(&sl->lock);
1378                         if (sl->tty) {
1379                                 busy++;
1380                                 tty_hangup(sl->tty);
1381                         }
1382                         spin_unlock_bh(&sl->lock);
1383                 }
1384         } while (busy && time_before(jiffies, timeout));
1385
1386         /* FIXME: hangup is async so we should wait when doing this second
1387            phase */
1388
1389         for (i = 0; i < maxdev; i++) {
1390                 dev = sllin_devs[i];
1391                 if (!dev)
1392                         continue;
1393                 sllin_devs[i] = NULL;
1394
1395                 sl = netdev_priv(dev);
1396                 if (sl->tty) {
1397                         printk(KERN_ERR "%s: tty discipline still running\n",
1398                                dev->name);
1399                         /* Intentionally leak the control block. */
1400                         dev->destructor = NULL;
1401                 }
1402
1403                 unregister_netdev(dev);
1404         }
1405
1406         kfree(sllin_devs);
1407         sllin_devs = NULL;
1408
1409         i = tty_unregister_ldisc(N_SLLIN);
1410         if (i)
1411                 printk(KERN_ERR "sllin: can't unregister ldisc (err %d)\n", i);
1412 }
1413
1414 module_init(sllin_init);
1415 module_exit(sllin_exit);