kernel/2.6/drivers/net/can/slcan.c

   1 /*
   2  * slcan.c - serial line CAN interface driver (using tty line discipline)
   3  *
   4  * This file is derived from linux/drivers/net/slip.c
   5  *
   6  * Therefore it has the same (strange?) behaviour not to unregister the
   7  * netdevice when detaching the tty. Is there any better solution?
   8  *
   9  * Do not try to attach, detach and re-attach a tty for this reason ...
  10  *
  11  * slip.c Authors  : Laurence Culhane <loz@holmes.demon.co.uk>
  12  *                   Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
  13  * slcan.c Author  : Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
  14  *
  15  * Copyright (c) 2007-2009 Volkswagen Group Electronic Research
  16  *
  17  * This program is free software; you can redistribute it and/or modify it
  18  * under the terms of the GNU General Public License as published by the
  19  * Free Software Foundation; either version 2 of the License, or (at your
  20  * option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful, but
  23  * WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25  * General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License along
  28  * with this program; if not, write to the Free Software Foundation, Inc.,
  29  * 59 Temple Place, Suite 330, Boston, MA 02111-1307. You can also get it
  30  * at http://www.gnu.org/licenses/gpl.html
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  37  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  38  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  39  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  40  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  41  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  42  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  43  * DAMAGE.
  44  *
  45  * Send feedback to <socketcan-users@lists.berlios.de>
  46  *
  47  */
  48
  49 #include <linux/version.h>
  50 #include <linux/module.h>
  51 #include <linux/moduleparam.h>
  52
  53 #include <asm/system.h>
  54 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)
  55 #include <linux/uaccess.h>
  56 #else
  57 #include <asm/uaccess.h>
  58 #endif
  59 #include <linux/bitops.h>
  60 #include <linux/sched.h>
  61 #include <linux/string.h>
  62 #include <linux/mm.h>
  63 #include <linux/interrupt.h>
  64 #include <linux/in.h>
  65 #include <linux/tty.h>
  66 #include <linux/errno.h>
  67 #include <linux/netdevice.h>
  68 #include <linux/etherdevice.h>
  69 #include <linux/skbuff.h>
  70 #include <linux/rtnetlink.h>
  71 #include <linux/if_arp.h>
  72 #include <linux/if_ether.h>
  73 #include <linux/if_slip.h>
  74 #include <linux/delay.h>
  75 #include <linux/init.h>
  76
  77 #include <socketcan/can.h>
  78
  79 #include <socketcan/can/version.h> /* for RCSID. Removed by mkpatch script */
  80 RCSID("$Id$");
  81
  82 static __initdata const char banner[] =
  83         KERN_INFO "slcan: serial line CAN interface driver\n";
  84
  85 MODULE_ALIAS_LDISC(N_SLCAN);
  86 MODULE_DESCRIPTION("serial line CAN interface");
  87 MODULE_LICENSE("GPL");
  88 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
  89
  90 #ifdef CONFIG_CAN_DEBUG_DEVICES
  91 static int debug;
  92 module_param(debug, int, S_IRUGO);
  93 #define DBG(args...)       (debug & 1 ? \
  94                                (printk(KERN_DEBUG "slcan %s: ", __func__), \
  95                                 printk(args)) : 0)
  96 #else
  97 #define DBG(args...)
  98 #endif
  99
 100 #ifndef N_SLCAN
 101 #error Your kernel does not support tty line discipline N_SLCAN
 102 #endif
 103 /*
 104  * As there is currently no line discipline N_SLCAN in the mainstream kernel
 105  * you will have to modify two kernel includes & recompile the kernel.
 106  *
 107  * Add this in include/asm/termios.h after the definition of N_HCI:
 108  *        #define N_SLCAN         16
 109  *
 110  * Increment NR_LDICS in include/linux/tty.h from 16 to 17
 111  *
 112  * NEW: Since Kernel 2.6.21 you only have to change include/linux/tty.h
 113  *
 114  * HACK for precompiled Kernels:
 115  *
 116  * In order to use the slcan driver without rebuilding the kernel, the slcan
 117  * driver must be compiled to use an existing line discipline.
 118  * The N_MOUSE line discipline is documented to be free for custom use and
 119  * using it *should* not cause any side effect.
 120  *
 121  * Then, before compiling the slcan driver, add a -DN_SLCAN=N_MOUSE
 122  * compilation option in its Makefile. The slcan_attach tool must(!!) also be
 123  * rebuild to use the right value for N_SLCAN. This workaround will allow
 124  * to use the slcan driver with an existing kernel.
 125  */
 126
 127 #define SLCAN_MAGIC 0x53CA
 128
 129 static int maxdev = 10;         /* MAX number of SLCAN channels;
 130                                    This can be overridden with
 131                                    insmod slcan.ko maxdev=nnn   */
 132 module_param(maxdev, int, 0);
 133 MODULE_PARM_DESC(maxdev, "Maximum number of slcan interfaces");
 134
 135 /* maximum rx buffer len: extended CAN frame with timestamp */
 136 #define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r")+1)
 137
 138 struct slcan {
 139         int                     magic;
 140
 141         /* Various fields. */
 142         struct tty_struct       *tty;           /* ptr to TTY structure      */
 143         struct net_device       *dev;           /* easy for intr handling    */
 144         spinlock_t              lock;
 145
 146         /* These are pointers to the malloc()ed frame buffers. */
 147         unsigned char           rbuff[SLC_MTU]; /* receiver buffer           */
 148         int                     rcount;         /* received chars counter    */
 149         unsigned char           xbuff[SLC_MTU]; /* transmitter buffer        */
 150         unsigned char           *xhead;         /* pointer to next XMIT byte */
 151         int                     xleft;          /* bytes left in XMIT queue  */
 152
 153 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 154         /* SLCAN interface statistics. */
 155         struct net_device_stats stats;
 156 #endif
 157
 158         unsigned long           flags;          /* Flag values/ mode etc     */
 159 #define SLF_INUSE               0               /* Channel in use            */
 160 #define SLF_ERROR               1               /* Parity, etc. error        */
 161
 162         unsigned char           leased;
 163         dev_t                   line;
 164         pid_t                   pid;
 165 };
 166
 167 static struct net_device **slcan_devs;
 168
 169
 170 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 171 /* Netdevice get statistics request */
 172 static struct net_device_stats *slc_get_stats(struct net_device *dev)
 173 {
 174         struct slcan *sl = netdev_priv(dev);
 175
 176         return &sl->stats;
 177 }
 178 #endif
 179
 180  /************************************************************************
 181   *                     SLCAN ENCAPSULATION FORMAT                       *
 182   ************************************************************************/
 183
 184 /*
 185  * A CAN frame has a can_id (11 bit standard frame format OR 29 bit extended
 186  * frame format) a data length code (can_dlc) which can be from 0 to 8
 187  * and up to <can_dlc> data bytes as payload.
 188  * Additionally a CAN frame may become a remote transmission frame if the
 189  * RTR-bit is set. This causes another ECU to send a CAN frame with the
 190  * given can_id.
 191  *
 192  * The SLCAN ASCII representation of these different frame types is:
 193  * <type> <id> <dlc> <data>*
 194  *
 195  * Extended frames (29 bit) are defined by capital characters in the type.
 196  * RTR frames are defined as 'r' types - normal frames have 't' type:
 197  * t => 11 bit data frame
 198  * r => 11 bit RTR frame
 199  * T => 29 bit data frame
 200  * R => 29 bit RTR frame
 201  *
 202  * The <id> is 3 (standard) or 8 (extended) bytes in ASCII Hex (base64).
 203  * The <dlc> is a one byte ASCII number ('0' - '8')
 204  * The <data> section has at much ASCII Hex bytes as defined by the <dlc>
 205  *
 206  * Examples:
 207  *
 208  * t1230 : can_id 0x123, can_dlc 0, no data
 209  * t4563112233 : can_id 0x456, can_dlc 3, data 0x11 0x22 0x33
 210  * T12ABCDEF2AA55 : extended can_id 0x12ABCDEF, can_dlc 2, data 0xAA 0x55
 211  * r1230 : can_id 0x123, can_dlc 0, no data, remote transmission request
 212  *
 213  */
 214
 215  /************************************************************************
 216   *                     STANDARD SLCAN DECAPSULATION                     *
 217   ************************************************************************/
 218
 219 static int asc2nibble(char c)
 220 {
 221
 222         if ((c >= '0') && (c <= '9'))
 223                 return c - '0';
 224
 225         if ((c >= 'A') && (c <= 'F'))
 226                 return c - 'A' + 10;
 227
 228         if ((c >= 'a') && (c <= 'f'))
 229                 return c - 'a' + 10;
 230
 231         return 16; /* error */
 232 }
 233
 234 /* Send one completely decapsulated can_frame to the network layer */
 235 static void slc_bump(struct slcan *sl)
 236 {
 237 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 238         struct net_device_stats *stats = slc_get_stats(sl->dev);
 239 #else
 240         struct net_device_stats *stats = &sl->dev->stats;
 241 #endif
 242         struct sk_buff *skb;
 243         struct can_frame cf;
 244         int i, dlc_pos, tmp;
 245         unsigned long ultmp;
 246         char cmd = sl->rbuff[0];
 247
 248         if ((cmd != 't') && (cmd != 'T') && (cmd != 'r') && (cmd != 'R'))
 249                 return;
 250
 251         if (cmd & 0x20) /* tiny chars 'r' 't' => standard frame format */
 252                 dlc_pos = 4; /* dlc position tiiid */
 253         else
 254                 dlc_pos = 9; /* dlc position Tiiiiiiiid */
 255
 256         if (!((sl->rbuff[dlc_pos] >= '0') && (sl->rbuff[dlc_pos] < '9')))
 257                 return;
 258
 259         cf.can_dlc = sl->rbuff[dlc_pos] - '0'; /* get can_dlc from ASCII val */
 260
 261         sl->rbuff[dlc_pos] = 0; /* terminate can_id string */
 262
 263 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 264         ultmp = simple_strtoul(sl->rbuff+1, NULL, 16);
 265 #else
 266         if (strict_strtoul(sl->rbuff+1, 16, &ultmp))
 267                 return;
 268 #endif
 269         cf.can_id = ultmp;
 270
 271         if (!(cmd & 0x20)) /* NO tiny chars => extended frame format */
 272                 cf.can_id |= CAN_EFF_FLAG;
 273
 274         if ((cmd | 0x20) == 'r') /* RTR frame */
 275                 cf.can_id |= CAN_RTR_FLAG;
 276
 277         *(u64 *) (&cf.data) = 0; /* clear payload */
 278
 279         for (i = 0, dlc_pos++; i < cf.can_dlc; i++) {
 280
 281                 tmp = asc2nibble(sl->rbuff[dlc_pos++]);
 282                 if (tmp > 0x0F)
 283                         return;
 284                 cf.data[i] = (tmp << 4);
 285                 tmp = asc2nibble(sl->rbuff[dlc_pos++]);
 286                 if (tmp > 0x0F)
 287                         return;
 288                 cf.data[i] |= tmp;
 289         }
 290
 291
 292         skb = dev_alloc_skb(sizeof(struct can_frame));
 293         if (!skb)
 294                 return;
 295
 296         skb->dev = sl->dev;
 297         skb->protocol = htons(ETH_P_CAN);
 298         skb->pkt_type = PACKET_BROADCAST;
 299         skb->ip_summed = CHECKSUM_UNNECESSARY;
 300         memcpy(skb_put(skb, sizeof(struct can_frame)),
 301                &cf, sizeof(struct can_frame));
 302         netif_rx(skb);
 303
 304 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 305         sl->dev->last_rx = jiffies;
 306 #endif
 307         stats->rx_packets++;
 308         stats->rx_bytes += cf.can_dlc;
 309 }
 310
 311 /* parse tty input stream */
 312 static void slcan_unesc(struct slcan *sl, unsigned char s)
 313 {
 314 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 315         struct net_device_stats *stats = slc_get_stats(sl->dev);
 316 #else
 317         struct net_device_stats *stats = &sl->dev->stats;
 318 #endif
 319
 320         if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */
 321                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
 322                     (sl->rcount > 4))  {
 323                         slc_bump(sl);
 324                 }
 325                 sl->rcount = 0;
 326         } else {
 327                 if (!test_bit(SLF_ERROR, &sl->flags))  {
 328                         if (sl->rcount < SLC_MTU)  {
 329                                 sl->rbuff[sl->rcount++] = s;
 330                                 return;
 331                         } else {
 332                                 stats->rx_over_errors++;
 333                                 set_bit(SLF_ERROR, &sl->flags);
 334                         }
 335                 }
 336         }
 337 }
 338
 339  /************************************************************************
 340   *                     STANDARD SLCAN ENCAPSULATION                     *
 341   ************************************************************************/
 342
 343 /* Encapsulate one can_frame and stuff into a TTY queue. */
 344 static void slc_encaps(struct slcan *sl, struct can_frame *cf)
 345 {
 346 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 347         struct net_device_stats *stats = slc_get_stats(sl->dev);
 348 #else
 349         struct net_device_stats *stats = &sl->dev->stats;
 350 #endif
 351         int actual, idx, i;
 352         char cmd;
 353
 354         if (cf->can_id & CAN_RTR_FLAG)
 355                 cmd = 'R'; /* becomes 'r' in standard frame format */
 356         else
 357                 cmd = 'T'; /* becomes 't' in standard frame format */
 358
 359         if (cf->can_id & CAN_EFF_FLAG)
 360                 sprintf(sl->xbuff, "%c%08X%d", cmd,
 361                         cf->can_id & CAN_EFF_MASK, cf->can_dlc);
 362         else
 363                 sprintf(sl->xbuff, "%c%03X%d", cmd | 0x20,
 364                         cf->can_id & CAN_SFF_MASK, cf->can_dlc);
 365
 366         idx = strlen(sl->xbuff);
 367
 368         for (i = 0; i < cf->can_dlc; i++)
 369                 sprintf(&sl->xbuff[idx + 2*i], "%02X", cf->data[i]);
 370
 371         DBG("ASCII frame = '%s'\n", sl->xbuff);
 372
 373         strcat(sl->xbuff, "\r"); /* add terminating character */
 374
 375         /* Order of next two lines is *very* important.
 376          * When we are sending a little amount of data,
 377          * the transfer may be completed inside driver.write()
 378          * routine, because it's running with interrupts enabled.
 379          * In this case we *never* got WRITE_WAKEUP event,
 380          * if we did not request it before write operation.
 381          *       14 Oct 1994  Dmitry Gorodchanin.
 382          */
 383         sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 384 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
 385         actual = sl->tty->driver->write(sl->tty, sl->xbuff, strlen(sl->xbuff));
 386 #else
 387         actual = sl->tty->ops->write(sl->tty, sl->xbuff, strlen(sl->xbuff));
 388 #endif
 389         sl->xleft = strlen(sl->xbuff) - actual;
 390         sl->xhead = sl->xbuff + actual;
 391         stats->tx_bytes += cf->can_dlc;
 392 }
 393
 394 /*
 395  * Called by the driver when there's room for more data.  If we have
 396  * more packets to send, we send them here.
 397  */
 398 static void slcan_write_wakeup(struct tty_struct *tty)
 399 {
 400         int actual;
 401         struct slcan *sl = (struct slcan *) tty->disc_data;
 402 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 403         struct net_device_stats *stats = slc_get_stats(sl->dev);
 404 #else
 405         struct net_device_stats *stats = &sl->dev->stats;
 406 #endif
 407
 408         /* First make sure we're connected. */
 409         if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
 410                 return;
 411
 412         if (sl->xleft <= 0)  {
 413                 /* Now serial buffer is almost free & we can start
 414                  * transmission of another packet */
 415                 stats->tx_packets++;
 416                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 417                 netif_wake_queue(sl->dev);
 418                 return;
 419         }
 420
 421 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
 422         actual = tty->driver->write(tty, sl->xhead, sl->xleft);
 423 #else
 424         actual = tty->ops->write(tty, sl->xhead, sl->xleft);
 425 #endif
 426         sl->xleft -= actual;
 427         sl->xhead += actual;
 428 }
 429
 430
 431 /******************************************
 432  *   Routines looking at netdevice side.
 433  ******************************************/
 434
 435 /* Send a can_frame to a TTY queue. */
 436 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 437 static int slc_xmit(struct sk_buff *skb, struct net_device *dev)
 438 #else
 439 static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
 440 #endif
 441 {
 442         struct slcan *sl = netdev_priv(dev);
 443
 444         if (skb->len != sizeof(struct can_frame))
 445                 goto out;
 446
 447         spin_lock(&sl->lock);
 448         if (!netif_running(dev))  {
 449                 spin_unlock(&sl->lock);
 450                 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
 451                 goto out;
 452         }
 453
 454         if (sl->tty == NULL) {
 455                 spin_unlock(&sl->lock);
 456                 goto out;
 457         }
 458
 459         netif_stop_queue(sl->dev);
 460         slc_encaps(sl, (struct can_frame *) skb->data); /* encaps & send */
 461         spin_unlock(&sl->lock);
 462
 463 out:
 464         kfree_skb(skb);
 465 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 466         return 0;
 467 #else
 468         return NETDEV_TX_OK;
 469 #endif
 470 }
 471
 472
 473 /* Netdevice UP -> DOWN routine */
 474 static int slc_close(struct net_device *dev)
 475 {
 476         struct slcan *sl = netdev_priv(dev);
 477
 478         spin_lock_bh(&sl->lock);
 479         if (sl->tty) {
 480                 /* TTY discipline is running. */
 481                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 482         }
 483         netif_stop_queue(dev);
 484         sl->rcount   = 0;
 485         sl->xleft    = 0;
 486         spin_unlock_bh(&sl->lock);
 487
 488         return 0;
 489 }
 490
 491 /* Netdevice DOWN -> UP routine */
 492 static int slc_open(struct net_device *dev)
 493 {
 494         struct slcan *sl = netdev_priv(dev);
 495
 496         if (sl->tty == NULL)
 497                 return -ENODEV;
 498
 499         sl->flags &= (1 << SLF_INUSE);
 500         netif_start_queue(dev);
 501         return 0;
 502 }
 503
 504 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 505 /* Hook the destructor so we can free slcan devs at the right point in time */
 506 static void slc_free_netdev(struct net_device *dev)
 507 {
 508         int i = dev->base_addr;
 509         free_netdev(dev);
 510         slcan_devs[i] = NULL;
 511 }
 512 #endif
 513
 514 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 515 static const struct net_device_ops slc_netdev_ops = {
 516         .ndo_open               = slc_open,
 517         .ndo_stop               = slc_close,
 518         .ndo_start_xmit         = slc_xmit,
 519 };
 520 #endif
 521
 522 /* Netdevice register callback */
 523 static void slc_setup(struct net_device *dev)
 524 {
 525 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
 526         dev->netdev_ops = &slc_netdev_ops;
 527 #else
 528         dev->open               = slc_open;
 529         dev->stop               = slc_close;
 530         dev->hard_start_xmit    = slc_xmit;
 531 #endif
 532 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 533         dev->destructor         = slc_free_netdev;
 534 #else
 535         dev->destructor         = free_netdev;
 536 #endif
 537 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 538         dev->get_stats          = slc_get_stats;
 539 #endif
 540
 541         dev->hard_header_len    = 0;
 542         dev->addr_len           = 0;
 543         dev->tx_queue_len       = 10;
 544
 545         dev->mtu                = sizeof(struct can_frame);
 546         dev->type               = ARPHRD_CAN;
 547
 548         /* New-style flags. */
 549         dev->flags              = IFF_NOARP;
 550         dev->features           = NETIF_F_NO_CSUM;
 551 }
 552
 553 /******************************************
 554  * Routines looking at TTY side.
 555  ******************************************/
 556
 557 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
 558 static int slcan_receive_room(struct tty_struct *tty)
 559 {
 560         return 65536;  /* We can handle an infinite amount of data. :-) */
 561 }
 562 #endif
 563
 564 /*
 565  * Handle the 'receiver data ready' interrupt.
 566  * This function is called by the 'tty_io' module in the kernel when
 567  * a block of SLCAN data has been received, which can now be decapsulated
 568  * and sent on to some IP layer for further processing. This will not
 569  * be re-entered while running but other ldisc functions may be called
 570  * in parallel
 571  */
 572
 573 static void slcan_receive_buf(struct tty_struct *tty,
 574                               const unsigned char *cp, char *fp, int count)
 575 {
 576         struct slcan *sl = (struct slcan *) tty->disc_data;
 577 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
 578         struct net_device_stats *stats = slc_get_stats(sl->dev);
 579 #else
 580         struct net_device_stats *stats = &sl->dev->stats;
 581 #endif
 582
 583         if (!sl || sl->magic != SLCAN_MAGIC ||
 584             !netif_running(sl->dev))
 585                 return;
 586
 587         /* Read the characters out of the buffer */
 588         while (count--) {
 589                 if (fp && *fp++) {
 590                         if (!test_and_set_bit(SLF_ERROR, &sl->flags))
 591                                 stats->rx_errors++;
 592                         cp++;
 593                         continue;
 594                 }
 595                 slcan_unesc(sl, *cp++);
 596         }
 597 }
 598
 599 /************************************
 600  *  slcan_open helper routines.
 601  ************************************/
 602
 603 /* Collect hanged up channels */
 604
 605 static void slc_sync(void)
 606 {
 607         int i;
 608         struct net_device *dev;
 609         struct slcan      *sl;
 610
 611         for (i = 0; i < maxdev; i++) {
 612                 dev = slcan_devs[i];
 613                 if (dev == NULL)
 614                         break;
 615
 616                 sl = netdev_priv(dev);
 617                 if (sl->tty || sl->leased)
 618                         continue;
 619                 if (dev->flags&IFF_UP)
 620                         dev_close(dev);
 621         }
 622 }
 623
 624
 625 /* Find a free SLCAN channel, and link in this `tty' line. */
 626 static struct slcan *slc_alloc(dev_t line)
 627 {
 628         int i;
 629 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 630         int sel = -1;
 631         int score = -1;
 632 #endif
 633         struct net_device *dev = NULL;
 634         struct slcan       *sl;
 635
 636         if (slcan_devs == NULL)
 637                 return NULL;    /* Master array missing ! */
 638
 639         for (i = 0; i < maxdev; i++) {
 640                 dev = slcan_devs[i];
 641                 if (dev == NULL)
 642                         break;
 643
 644 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 645                 sl = netdev_priv(dev);
 646                 if (sl->leased) {
 647                         if (sl->line != line)
 648                                 continue;
 649                         if (sl->tty)
 650                                 return NULL;
 651
 652                         /* Clear ESCAPE & ERROR flags */
 653                         sl->flags &= (1 << SLF_INUSE);
 654                         return sl;
 655                 }
 656
 657                 if (sl->tty)
 658                         continue;
 659
 660                 if (current->pid == sl->pid) {
 661                         if (sl->line == line && score < 3) {
 662                                 sel = i;
 663                                 score = 3;
 664                                 continue;
 665                         }
 666                         if (score < 2) {
 667                                 sel = i;
 668                                 score = 2;
 669                         }
 670                         continue;
 671                 }
 672                 if (sl->line == line && score < 1) {
 673                         sel = i;
 674                         score = 1;
 675                         continue;
 676                 }
 677                 if (score < 0) {
 678                         sel = i;
 679                         score = 0;
 680                 }
 681         }
 682
 683         if (sel >= 0) {
 684                 i = sel;
 685                 dev = slcan_devs[i];
 686                 if (score > 1) {
 687                         sl = netdev_priv(dev);
 688                         sl->flags &= (1 << SLF_INUSE);
 689                         return sl;
 690                 }
 691 #endif
 692         }
 693
 694         /* Sorry, too many, all slots in use */
 695         if (i >= maxdev)
 696                 return NULL;
 697
 698         if (dev) {
 699                 sl = netdev_priv(dev);
 700                 if (test_bit(SLF_INUSE, &sl->flags)) {
 701                         unregister_netdevice(dev);
 702                         dev = NULL;
 703                         slcan_devs[i] = NULL;
 704                 }
 705         }
 706
 707         if (!dev) {
 708                 char name[IFNAMSIZ];
 709                 sprintf(name, "can%d", i);
 710
 711                 dev = alloc_netdev(sizeof(*sl), name, slc_setup);
 712                 if (!dev)
 713                         return NULL;
 714                 dev->base_addr  = i;
 715         }
 716
 717         sl = netdev_priv(dev);
 718
 719         /* Initialize channel control data */
 720         sl->magic       = SLCAN_MAGIC;
 721         sl->dev         = dev;
 722         spin_lock_init(&sl->lock);
 723         slcan_devs[i] = dev;
 724
 725         return sl;
 726 }
 727
 728 /*
 729  * Open the high-level part of the SLCAN channel.
 730  * This function is called by the TTY module when the
 731  * SLCAN line discipline is called for.  Because we are
 732  * sure the tty line exists, we only have to link it to
 733  * a free SLCAN channel...
 734  *
 735  * Called in process context serialized from other ldisc calls.
 736  */
 737
 738 static int slcan_open(struct tty_struct *tty)
 739 {
 740         struct slcan *sl;
 741         int err;
 742
 743         if (!capable(CAP_NET_ADMIN))
 744                 return -EPERM;
 745
 746 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
 747         if (tty->ops->write == NULL)
 748                 return -EOPNOTSUPP;
 749 #endif
 750
 751         /* RTnetlink lock is misused here to serialize concurrent
 752            opens of slcan channels. There are better ways, but it is
 753            the simplest one.
 754          */
 755         rtnl_lock();
 756
 757         /* Collect hanged up channels. */
 758         slc_sync();
 759
 760         sl = (struct slcan *) tty->disc_data;
 761
 762         err = -EEXIST;
 763         /* First make sure we're not already connected. */
 764         if (sl && sl->magic == SLCAN_MAGIC)
 765                 goto err_exit;
 766
 767         /* OK.  Find a free SLCAN channel to use. */
 768         err = -ENFILE;
 769         sl = slc_alloc(tty_devnum(tty));
 770         if (sl == NULL)
 771                 goto err_exit;
 772
 773         sl->tty = tty;
 774         tty->disc_data = sl;
 775         sl->line = tty_devnum(tty);
 776         sl->pid = current->pid;
 777
 778 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
 779         /* FIXME: already done before we were called - seems this can go */
 780         if (tty->driver->flush_buffer)
 781                 tty->driver->flush_buffer(tty);
 782 #endif
 783
 784         if (!test_bit(SLF_INUSE, &sl->flags)) {
 785                 /* Perform the low-level SLCAN initialization. */
 786                 sl->rcount   = 0;
 787                 sl->xleft    = 0;
 788
 789                 set_bit(SLF_INUSE, &sl->flags);
 790
 791                 err = register_netdevice(sl->dev);
 792                 if (err)
 793                         goto err_free_chan;
 794         }
 795
 796         /* Done.  We have linked the TTY line to a channel. */
 797         rtnl_unlock();
 798
 799 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
 800         tty->receive_room = 65536;      /* We don't flow control */
 801 #endif
 802
 803         return sl->dev->base_addr;
 804
 805 err_free_chan:
 806         sl->tty = NULL;
 807         tty->disc_data = NULL;
 808         clear_bit(SLF_INUSE, &sl->flags);
 809
 810 err_exit:
 811         rtnl_unlock();
 812
 813         /* Count references from TTY module */
 814         return err;
 815 }
 816
 817 /*
 818  * Close down a SLCAN channel.
 819  * This means flushing out any pending queues, and then returning. This
 820  * call is serialized against other ldisc functions.
 821  *
 822  * We also use this method for a hangup event.
 823  */
 824 static void slcan_close(struct tty_struct *tty)
 825 {
 826         struct slcan *sl = (struct slcan *) tty->disc_data;
 827
 828         /* First make sure we're connected. */
 829         if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
 830                 return;
 831
 832         tty->disc_data = NULL;
 833         sl->tty = NULL;
 834         if (!sl->leased)
 835                 sl->line = 0;
 836
 837 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 838         /* Flush network side */
 839         unregister_netdev(sl->dev);
 840         /* This will complete via sl_free_netdev */
 841 #else
 842         /* Count references from TTY module */
 843 #endif
 844 }
 845
 846 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 847 static int slcan_hangup(struct tty_struct *tty)
 848 {
 849         slcan_close(tty);
 850         return 0;
 851 }
 852 #endif
 853
 854 /* Perform I/O control on an active SLCAN channel. */
 855 static int slcan_ioctl(struct tty_struct *tty, struct file *file,
 856                        unsigned int cmd, unsigned long arg)
 857 {
 858         struct slcan *sl = (struct slcan *) tty->disc_data;
 859         unsigned int tmp;
 860
 861         /* First make sure we're connected. */
 862         if (!sl || sl->magic != SLCAN_MAGIC)
 863                 return -EINVAL;
 864
 865         switch (cmd) {
 866         case SIOCGIFNAME:
 867                 tmp = strlen(sl->dev->name) + 1;
 868                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
 869                         return -EFAULT;
 870                 return 0;
 871
 872         case SIOCSIFHWADDR:
 873                 return -EINVAL;
 874
 875 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 876         /* Allow stty to read, but not set, the serial port */
 877         case TCGETS:
 878         case TCGETA:
 879                 return n_tty_ioctl(tty, file, cmd, arg);
 880
 881         default:
 882                 return -ENOIOCTLCMD;
 883 #else
 884         default:
 885                 return tty_mode_ioctl(tty, file, cmd, arg);
 886 #endif
 887         }
 888 }
 889
 890 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 891 static struct tty_ldisc slc_ldisc = {
 892 #else
 893 static struct tty_ldisc_ops slc_ldisc = {
 894 #endif
 895         .owner          = THIS_MODULE,
 896         .magic          = TTY_LDISC_MAGIC,
 897         .name           = "slcan",
 898         .open           = slcan_open,
 899         .close          = slcan_close,
 900 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 901         .hangup         = slcan_hangup,
 902 #endif
 903         .ioctl          = slcan_ioctl,
 904         .receive_buf    = slcan_receive_buf,
 905 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
 906         .receive_room   = slcan_receive_room,
 907 #endif
 908         .write_wakeup   = slcan_write_wakeup,
 909 };
 910
 911 /************************************
 912  * general slcan module init/exit
 913  ************************************/
 914
 915 static int __init slcan_init(void)
 916 {
 917         int status;
 918
 919         if (maxdev < 4)
 920                 maxdev = 4; /* Sanity */
 921
 922         printk(banner);
 923         printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
 924
 925         slcan_devs = kmalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
 926         if (!slcan_devs) {
 927                 printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
 928                 return -ENOMEM;
 929         }
 930
 931         /* Clear the pointer array, we allocate devices when we need them */
 932         memset(slcan_devs, 0, sizeof(struct net_device *)*maxdev);
 933
 934         /* Fill in our line protocol discipline, and register it */
 935         status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
 936         if (status != 0)  {
 937                 printk(KERN_ERR "slcan: can't register line discipline\n");
 938                 kfree(slcan_devs);
 939         }
 940         return status;
 941 }
 942
 943 static void __exit slcan_exit(void)
 944 {
 945         int i;
 946         struct net_device *dev;
 947         struct slcan *sl;
 948         unsigned long timeout = jiffies + HZ;
 949         int busy = 0;
 950
 951         if (slcan_devs == NULL)
 952                 return;
 953
 954         /* First of all: check for active disciplines and hangup them.
 955          */
 956         do {
 957                 if (busy)
 958                         msleep_interruptible(100);
 959
 960                 busy = 0;
 961                 for (i = 0; i < maxdev; i++) {
 962                         dev = slcan_devs[i];
 963                         if (!dev)
 964                                 continue;
 965                         sl = netdev_priv(dev);
 966                         spin_lock_bh(&sl->lock);
 967                         if (sl->tty) {
 968                                 busy++;
 969                                 tty_hangup(sl->tty);
 970                         }
 971                         spin_unlock_bh(&sl->lock);
 972                 }
 973         } while (busy && time_before(jiffies, timeout));
 974
 975         /* FIXME (2.6.32+): hangup is async so we should wait when doing
 976            this second phase */
 977
 978         for (i = 0; i < maxdev; i++) {
 979                 dev = slcan_devs[i];
 980                 if (!dev)
 981                         continue;
 982                 slcan_devs[i] = NULL;
 983
 984                 sl = netdev_priv(dev);
 985                 if (sl->tty) {
 986                         printk(KERN_ERR "%s: tty discipline still running\n",
 987                                dev->name);
 988                         /* Intentionally leak the control block. */
 989                         dev->destructor = NULL;
 990                 }
 991
 992                 unregister_netdev(dev);
 993         }
 994
 995         kfree(slcan_devs);
 996         slcan_devs = NULL;
 997
 998         i = tty_unregister_ldisc(N_SLCAN);
 999         if (i)
1000                 printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
1001 }
1002
1003 module_init(slcan_init);
1004 module_exit(slcan_exit);