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, char forcednum)
 627 {
 628         int i;
 629         int sel = -1;
 630         int score = -1;
 631         struct net_device *dev = NULL;
 632         struct slcan       *sl;
 633
 634         if (slcan_devs == NULL)
 635                 return NULL;    /* Master array missing ! */
 636
 637         for (i = 0; i < maxdev; i++) {
 638                 dev = slcan_devs[i];
 639                 if (dev == NULL)
 640                         break;
 641
 642                 sl = netdev_priv(dev);
 643                 if (sl->leased) {
 644                         if (sl->line != line)
 645                                 continue;
 646                         if (sl->tty)
 647                                 return NULL;
 648
 649                         /* Clear ESCAPE & ERROR flags */
 650                         sl->flags &= (1 << SLF_INUSE);
 651                         return sl;
 652                 }
 653
 654                 if (sl->tty)
 655                         continue;
 656
 657                 if (current->pid == sl->pid) {
 658                         if (sl->line == line && score < 3) {
 659                                 sel = i;
 660                                 score = 3;
 661                                 continue;
 662                         }
 663                         if (score < 2) {
 664                                 sel = i;
 665                                 score = 2;
 666                         }
 667                         continue;
 668                 }
 669                 if (sl->line == line && score < 1) {
 670                         sel = i;
 671                         score = 1;
 672                         continue;
 673                 }
 674                 if (score < 0) {
 675                         sel = i;
 676                         score = 0;
 677                 }
 678         }
 679
 680         /* Check if the user specified an exact interface to use */
 681         if (forcednum) {
 682                 sel = forcednum - '0';
 683                 score = 0;
 684                 i = sel;
 685                 dev = slcan_devs[i];
 686         }
 687
 688         if (sel >= 0) {
 689                 i = sel;
 690                 dev = slcan_devs[i];
 691                 if ((score > 1) && (dev)) {
 692                         sl = netdev_priv(dev);
 693                         sl->flags &= (1 << SLF_INUSE);
 694                         return sl;
 695                 }
 696         }
 697
 698         /* Sorry, too many, all slots in use */
 699         if (i >= maxdev)
 700                 return NULL;
 701
 702         if (dev) {
 703                 sl = netdev_priv(dev);
 704                 if (test_bit(SLF_INUSE, &sl->flags)) {
 705                         unregister_netdevice(dev);
 706                         dev = NULL;
 707                         slcan_devs[i] = NULL;
 708                 }
 709         }
 710
 711         if (!dev) {
 712                 char name[IFNAMSIZ];
 713                 sprintf(name, "can%d", i);
 714
 715                 dev = alloc_netdev(sizeof(*sl), name, slc_setup);
 716                 if (!dev)
 717                         return NULL;
 718                 dev->base_addr  = i;
 719         }
 720
 721         sl = netdev_priv(dev);
 722
 723         /* Initialize channel control data */
 724         sl->magic       = SLCAN_MAGIC;
 725         sl->dev         = dev;
 726         spin_lock_init(&sl->lock);
 727         slcan_devs[i] = dev;
 728
 729         return sl;
 730 }
 731
 732 /*
 733  * Open the high-level part of the SLCAN channel.
 734  * This function is called by the TTY module when the
 735  * SLCAN line discipline is called for.  Because we are
 736  * sure the tty line exists, we only have to link it to
 737  * a free SLCAN channel...
 738  *
 739  * Called in process context serialized from other ldisc calls.
 740  */
 741
 742 static int slcan_open(struct tty_struct *tty)
 743 {
 744         struct slcan *sl;
 745         int err;
 746
 747         if (!capable(CAP_NET_ADMIN))
 748                 return -EPERM;
 749
 750 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
 751         if (tty->ops->write == NULL)
 752                 return -EOPNOTSUPP;
 753 #endif
 754
 755         /* RTnetlink lock is misused here to serialize concurrent
 756            opens of slcan channels. There are better ways, but it is
 757            the simplest one.
 758          */
 759         rtnl_lock();
 760
 761         /* Collect hanged up channels. */
 762         slc_sync();
 763
 764         sl = (struct slcan *) tty->disc_data;
 765
 766         err = -EEXIST;
 767         /* First make sure we're not already connected. */
 768         if (sl && sl->magic == SLCAN_MAGIC)
 769                 goto err_exit;
 770
 771         /* OK.  Find a free SLCAN channel to use. */
 772         err = -ENFILE;
 773
 774         /* Look to see if the user has requested a specific channel
 775          * to be used (encoded as '0' plus the interface number requested in
 776          * the otherwise unused swtch termios variable )
 777          * stty swtch 'channel' device
 778          *  where 'channel' is '0' to maxdevs (0)
 779          *  where device is the name of the serial device (/dev/ttyUSB0)
 780          */
 781         if ((SWTC_CHAR(tty)>='0') && (SWTC_CHAR(tty)<'0'+maxdev)){
 782                 sl = slc_alloc(tty_devnum(tty),SWTC_CHAR(tty));
 783         } else {
 784                 /* OK.  Find a free SLCAN channel to use. */
 785                 sl = slc_alloc(tty_devnum(tty),0);
 786         }
 787
 788         if (sl == NULL)
 789                 goto err_exit;
 790
 791         sl->tty = tty;
 792         tty->disc_data = sl;
 793         sl->line = tty_devnum(tty);
 794         sl->pid = current->pid;
 795
 796 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
 797         /* FIXME: already done before we were called - seems this can go */
 798         if (tty->driver->flush_buffer)
 799                 tty->driver->flush_buffer(tty);
 800 #endif
 801
 802         if (!test_bit(SLF_INUSE, &sl->flags)) {
 803                 /* Perform the low-level SLCAN initialization. */
 804                 sl->rcount   = 0;
 805                 sl->xleft    = 0;
 806
 807                 set_bit(SLF_INUSE, &sl->flags);
 808
 809                 err = register_netdevice(sl->dev);
 810                 if (err)
 811                         goto err_free_chan;
 812         }
 813
 814         /* Done.  We have linked the TTY line to a channel. */
 815         rtnl_unlock();
 816
 817 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
 818         tty->receive_room = 65536;      /* We don't flow control */
 819 #endif
 820
 821         return sl->dev->base_addr;
 822
 823 err_free_chan:
 824         sl->tty = NULL;
 825         tty->disc_data = NULL;
 826         clear_bit(SLF_INUSE, &sl->flags);
 827
 828 err_exit:
 829         rtnl_unlock();
 830
 831         /* Count references from TTY module */
 832         return err;
 833 }
 834
 835 /*
 836  * Close down a SLCAN channel.
 837  * This means flushing out any pending queues, and then returning. This
 838  * call is serialized against other ldisc functions.
 839  *
 840  * We also use this method for a hangup event.
 841  */
 842 static void slcan_close(struct tty_struct *tty)
 843 {
 844         struct slcan *sl = (struct slcan *) tty->disc_data;
 845
 846         /* First make sure we're connected. */
 847         if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
 848                 return;
 849
 850         tty->disc_data = NULL;
 851         sl->tty = NULL;
 852         if (!sl->leased)
 853                 sl->line = 0;
 854
 855 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 856         /* Flush network side */
 857         unregister_netdev(sl->dev);
 858         /* This will complete via sl_free_netdev */
 859 #else
 860         /* Count references from TTY module */
 861 #endif
 862 }
 863
 864 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 865 static int slcan_hangup(struct tty_struct *tty)
 866 {
 867         slcan_close(tty);
 868         return 0;
 869 }
 870 #endif
 871
 872 /* Perform I/O control on an active SLCAN channel. */
 873 static int slcan_ioctl(struct tty_struct *tty, struct file *file,
 874                        unsigned int cmd, unsigned long arg)
 875 {
 876         struct slcan *sl = (struct slcan *) tty->disc_data;
 877         unsigned int tmp;
 878
 879         /* First make sure we're connected. */
 880         if (!sl || sl->magic != SLCAN_MAGIC)
 881                 return -EINVAL;
 882
 883         switch (cmd) {
 884         case SIOCGIFNAME:
 885                 tmp = strlen(sl->dev->name) + 1;
 886                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
 887                         return -EFAULT;
 888                 return 0;
 889
 890         case SIOCSIFHWADDR:
 891                 return -EINVAL;
 892
 893 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 894         /* Allow stty to read, but not set, the serial port */
 895         case TCGETS:
 896         case TCGETA:
 897                 return n_tty_ioctl(tty, file, cmd, arg);
 898
 899         default:
 900                 return -ENOIOCTLCMD;
 901 #else
 902         default:
 903                 return tty_mode_ioctl(tty, file, cmd, arg);
 904 #endif
 905         }
 906 }
 907
 908 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 909 static struct tty_ldisc slc_ldisc = {
 910 #else
 911 static struct tty_ldisc_ops slc_ldisc = {
 912 #endif
 913         .owner          = THIS_MODULE,
 914         .magic          = TTY_LDISC_MAGIC,
 915         .name           = "slcan",
 916         .open           = slcan_open,
 917         .close          = slcan_close,
 918 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31)
 919         .hangup         = slcan_hangup,
 920 #endif
 921         .ioctl          = slcan_ioctl,
 922         .receive_buf    = slcan_receive_buf,
 923 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
 924         .receive_room   = slcan_receive_room,
 925 #endif
 926         .write_wakeup   = slcan_write_wakeup,
 927 };
 928
 929 /************************************
 930  * general slcan module init/exit
 931  ************************************/
 932
 933 static int __init slcan_init(void)
 934 {
 935         int status;
 936
 937         if (maxdev < 4)
 938                 maxdev = 4; /* Sanity */
 939
 940         printk(banner);
 941         printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
 942
 943         slcan_devs = kmalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
 944         if (!slcan_devs) {
 945                 printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
 946                 return -ENOMEM;
 947         }
 948
 949         /* Clear the pointer array, we allocate devices when we need them */
 950         memset(slcan_devs, 0, sizeof(struct net_device *)*maxdev);
 951
 952         /* Fill in our line protocol discipline, and register it */
 953         status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
 954         if (status != 0)  {
 955                 printk(KERN_ERR "slcan: can't register line discipline\n");
 956                 kfree(slcan_devs);
 957         }
 958         return status;
 959 }
 960
 961 static void __exit slcan_exit(void)
 962 {
 963         int i;
 964         struct net_device *dev;
 965         struct slcan *sl;
 966         unsigned long timeout = jiffies + HZ;
 967         int busy = 0;
 968
 969         if (slcan_devs == NULL)
 970                 return;
 971
 972         /* First of all: check for active disciplines and hangup them.
 973          */
 974         do {
 975                 if (busy)
 976                         msleep_interruptible(100);
 977
 978                 busy = 0;
 979                 for (i = 0; i < maxdev; i++) {
 980                         dev = slcan_devs[i];
 981                         if (!dev)
 982                                 continue;
 983                         sl = netdev_priv(dev);
 984                         spin_lock_bh(&sl->lock);
 985                         if (sl->tty) {
 986                                 busy++;
 987                                 tty_hangup(sl->tty);
 988                         }
 989                         spin_unlock_bh(&sl->lock);
 990                 }
 991         } while (busy && time_before(jiffies, timeout));
 992
 993         /* FIXME (2.6.32+): hangup is async so we should wait when doing
 994            this second phase */
 995
 996         for (i = 0; i < maxdev; i++) {
 997                 dev = slcan_devs[i];
 998                 if (!dev)
 999                         continue;
1000                 slcan_devs[i] = NULL;
1001
1002                 sl = netdev_priv(dev);
1003                 if (sl->tty) {
1004                         printk(KERN_ERR "%s: tty discipline still running\n",
1005                                dev->name);
1006                         /* Intentionally leak the control block. */
1007                         dev->destructor = NULL;
1008                 }
1009
1010                 unregister_netdev(dev);
1011         }
1012
1013         kfree(slcan_devs);
1014         slcan_devs = NULL;
1015
1016         i = tty_unregister_ldisc(N_SLCAN);
1017         if (i)
1018                 printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
1019 }
1020
1021 module_init(slcan_init);
1022 module_exit(slcan_exit);