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

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