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  * slip.c Authors  : Laurence Culhane <loz@holmes.demon.co.uk>
   7  *                   Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
   8  * slcan.c Author  : Oliver Hartkopp <socketcan@hartkopp.net>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the
  12  * Free Software Foundation; either version 2 of the License, or (at your
  13  * option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 59 Temple Place, Suite 330, Boston, MA 02111-1307. You can also get it
  23  * at http://www.gnu.org/licenses/gpl.html
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  36  * DAMAGE.
  37  *
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/moduleparam.h>
  42
  43 #include <asm/system.h>
  44 #include <linux/uaccess.h>
  45 #include <linux/bitops.h>
  46 #include <linux/string.h>
  47 #include <linux/tty.h>
  48 #include <linux/errno.h>
  49 #include <linux/netdevice.h>
  50 #include <linux/skbuff.h>
  51 #include <linux/rtnetlink.h>
  52 #include <linux/if_arp.h>
  53 #include <linux/if_ether.h>
  54 #include <linux/sched.h>
  55 #include <linux/delay.h>
  56 #include <linux/init.h>
  57 #include <linux/kernel.h>
  58 #include <linux/can.h>
  59
  60 static __initdata const char banner[] =
  61         KERN_INFO "slcan: serial line CAN interface driver\n";
  62
  63 MODULE_ALIAS_LDISC(N_SLCAN);
  64 MODULE_DESCRIPTION("serial line CAN interface");
  65 MODULE_LICENSE("GPL");
  66 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
  67
  68 #define SLCAN_MAGIC 0x53CA
  69
  70 static int maxdev = 10;         /* MAX number of SLCAN channels;
  71                                    This can be overridden with
  72                                    insmod slcan.ko maxdev=nnn   */
  73 module_param(maxdev, int, 0);
  74 MODULE_PARM_DESC(maxdev, "Maximum number of slcan interfaces");
  75
  76 /* maximum rx buffer len: extended CAN frame with timestamp */
  77 #define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r")+1)
  78
  79 struct slcan {
  80         int                     magic;
  81
  82         /* Various fields. */
  83         struct tty_struct       *tty;           /* ptr to TTY structure      */
  84         struct net_device       *dev;           /* easy for intr handling    */
  85         spinlock_t              lock;
  86
  87         /* These are pointers to the malloc()ed frame buffers. */
  88         unsigned char           rbuff[SLC_MTU]; /* receiver buffer           */
  89         int                     rcount;         /* received chars counter    */
  90         unsigned char           xbuff[SLC_MTU]; /* transmitter buffer        */
  91         unsigned char           *xhead;         /* pointer to next XMIT byte */
  92         int                     xleft;          /* bytes left in XMIT queue  */
  93
  94         unsigned long           flags;          /* Flag values/ mode etc     */
  95 #define SLF_INUSE               0               /* Channel in use            */
  96 #define SLF_ERROR               1               /* Parity, etc. error        */
  97 };
  98
  99 static struct net_device **slcan_devs;
 100
 101  /************************************************************************
 102   *                     SLCAN ENCAPSULATION FORMAT                       *
 103   ************************************************************************/
 104
 105 /*
 106  * A CAN frame has a can_id (11 bit standard frame format OR 29 bit extended
 107  * frame format) a data length code (can_dlc) which can be from 0 to 8
 108  * and up to <can_dlc> data bytes as payload.
 109  * Additionally a CAN frame may become a remote transmission frame if the
 110  * RTR-bit is set. This causes another ECU to send a CAN frame with the
 111  * given can_id.
 112  *
 113  * The SLCAN ASCII representation of these different frame types is:
 114  * <type> <id> <dlc> <data>*
 115  *
 116  * Extended frames (29 bit) are defined by capital characters in the type.
 117  * RTR frames are defined as 'r' types - normal frames have 't' type:
 118  * t => 11 bit data frame
 119  * r => 11 bit RTR frame
 120  * T => 29 bit data frame
 121  * R => 29 bit RTR frame
 122  *
 123  * The <id> is 3 (standard) or 8 (extended) bytes in ASCII Hex (base64).
 124  * The <dlc> is a one byte ASCII number ('0' - '8')
 125  * The <data> section has at much ASCII Hex bytes as defined by the <dlc>
 126  *
 127  * Examples:
 128  *
 129  * t1230 : can_id 0x123, can_dlc 0, no data
 130  * t4563112233 : can_id 0x456, can_dlc 3, data 0x11 0x22 0x33
 131  * T12ABCDEF2AA55 : extended can_id 0x12ABCDEF, can_dlc 2, data 0xAA 0x55
 132  * r1230 : can_id 0x123, can_dlc 0, no data, remote transmission request
 133  *
 134  */
 135
 136  /************************************************************************
 137   *                     STANDARD SLCAN DECAPSULATION                     *
 138   ************************************************************************/
 139
 140 /* Send one completely decapsulated can_frame to the network layer */
 141 static void slc_bump(struct slcan *sl)
 142 {
 143         struct sk_buff *skb;
 144         struct can_frame cf;
 145         int i, dlc_pos, tmp;
 146         unsigned long ultmp;
 147         char cmd = sl->rbuff[0];
 148
 149         if ((cmd != 't') && (cmd != 'T') && (cmd != 'r') && (cmd != 'R'))
 150                 return;
 151
 152         if (cmd & 0x20) /* tiny chars 'r' 't' => standard frame format */
 153                 dlc_pos = 4; /* dlc position tiiid */
 154         else
 155                 dlc_pos = 9; /* dlc position Tiiiiiiiid */
 156
 157         if (!((sl->rbuff[dlc_pos] >= '0') && (sl->rbuff[dlc_pos] < '9')))
 158                 return;
 159
 160         cf.can_dlc = sl->rbuff[dlc_pos] - '0'; /* get can_dlc from ASCII val */
 161
 162         sl->rbuff[dlc_pos] = 0; /* terminate can_id string */
 163
 164         if (strict_strtoul(sl->rbuff+1, 16, &ultmp))
 165                 return;
 166
 167         cf.can_id = ultmp;
 168
 169         if (!(cmd & 0x20)) /* NO tiny chars => extended frame format */
 170                 cf.can_id |= CAN_EFF_FLAG;
 171
 172         if ((cmd | 0x20) == 'r') /* RTR frame */
 173                 cf.can_id |= CAN_RTR_FLAG;
 174
 175         *(u64 *) (&cf.data) = 0; /* clear payload */
 176
 177         for (i = 0, dlc_pos++; i < cf.can_dlc; i++) {
 178                 tmp = hex_to_bin(sl->rbuff[dlc_pos++]);
 179                 if (tmp < 0)
 180                         return;
 181                 cf.data[i] = (tmp << 4);
 182                 tmp = hex_to_bin(sl->rbuff[dlc_pos++]);
 183                 if (tmp < 0)
 184                         return;
 185                 cf.data[i] |= tmp;
 186         }
 187
 188         skb = dev_alloc_skb(sizeof(struct can_frame));
 189         if (!skb)
 190                 return;
 191
 192         skb->dev = sl->dev;
 193         skb->protocol = htons(ETH_P_CAN);
 194         skb->pkt_type = PACKET_BROADCAST;
 195         skb->ip_summed = CHECKSUM_UNNECESSARY;
 196         memcpy(skb_put(skb, sizeof(struct can_frame)),
 197                &cf, sizeof(struct can_frame));
 198         netif_rx_ni(skb);
 199
 200         sl->dev->stats.rx_packets++;
 201         sl->dev->stats.rx_bytes += cf.can_dlc;
 202 }
 203
 204 /* parse tty input stream */
 205 static void slcan_unesc(struct slcan *sl, unsigned char s)
 206 {
 207
 208         if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */
 209                 if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
 210                     (sl->rcount > 4))  {
 211                         slc_bump(sl);
 212                 }
 213                 sl->rcount = 0;
 214         } else {
 215                 if (!test_bit(SLF_ERROR, &sl->flags))  {
 216                         if (sl->rcount < SLC_MTU)  {
 217                                 sl->rbuff[sl->rcount++] = s;
 218                                 return;
 219                         } else {
 220                                 sl->dev->stats.rx_over_errors++;
 221                                 set_bit(SLF_ERROR, &sl->flags);
 222                         }
 223                 }
 224         }
 225 }
 226
 227  /************************************************************************
 228   *                     STANDARD SLCAN ENCAPSULATION                     *
 229   ************************************************************************/
 230
 231 /* Encapsulate one can_frame and stuff into a TTY queue. */
 232 static void slc_encaps(struct slcan *sl, struct can_frame *cf)
 233 {
 234         int actual, idx, i;
 235         char cmd;
 236
 237         if (cf->can_id & CAN_RTR_FLAG)
 238                 cmd = 'R'; /* becomes 'r' in standard frame format */
 239         else
 240                 cmd = 'T'; /* becomes 't' in standard frame format */
 241
 242         if (cf->can_id & CAN_EFF_FLAG)
 243                 sprintf(sl->xbuff, "%c%08X%d", cmd,
 244                         cf->can_id & CAN_EFF_MASK, cf->can_dlc);
 245         else
 246                 sprintf(sl->xbuff, "%c%03X%d", cmd | 0x20,
 247                         cf->can_id & CAN_SFF_MASK, cf->can_dlc);
 248
 249         idx = strlen(sl->xbuff);
 250
 251         for (i = 0; i < cf->can_dlc; i++)
 252                 sprintf(&sl->xbuff[idx + 2*i], "%02X", cf->data[i]);
 253
 254         strcat(sl->xbuff, "\r"); /* add terminating character */
 255
 256         /* Order of next two lines is *very* important.
 257          * When we are sending a little amount of data,
 258          * the transfer may be completed inside the ops->write()
 259          * routine, because it's running with interrupts enabled.
 260          * In this case we *never* got WRITE_WAKEUP event,
 261          * if we did not request it before write operation.
 262          *       14 Oct 1994  Dmitry Gorodchanin.
 263          */
 264         set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
 265         actual = sl->tty->ops->write(sl->tty, sl->xbuff, strlen(sl->xbuff));
 266         sl->xleft = strlen(sl->xbuff) - actual;
 267         sl->xhead = sl->xbuff + actual;
 268         sl->dev->stats.tx_bytes += cf->can_dlc;
 269 }
 270
 271 /*
 272  * Called by the driver when there's room for more data.  If we have
 273  * more packets to send, we send them here.
 274  */
 275 static void slcan_write_wakeup(struct tty_struct *tty)
 276 {
 277         int actual;
 278         struct slcan *sl = (struct slcan *) tty->disc_data;
 279
 280         /* First make sure we're connected. */
 281         if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
 282                 return;
 283
 284         if (sl->xleft <= 0)  {
 285                 /* Now serial buffer is almost free & we can start
 286                  * transmission of another packet */
 287                 sl->dev->stats.tx_packets++;
 288                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 289                 netif_wake_queue(sl->dev);
 290                 return;
 291         }
 292
 293         actual = tty->ops->write(tty, sl->xhead, sl->xleft);
 294         sl->xleft -= actual;
 295         sl->xhead += actual;
 296 }
 297
 298 /* Send a can_frame to a TTY queue. */
 299 static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
 300 {
 301         struct slcan *sl = netdev_priv(dev);
 302
 303         if (skb->len != sizeof(struct can_frame))
 304                 goto out;
 305
 306         spin_lock(&sl->lock);
 307         if (!netif_running(dev))  {
 308                 spin_unlock(&sl->lock);
 309                 printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
 310                 goto out;
 311         }
 312         if (sl->tty == NULL) {
 313                 spin_unlock(&sl->lock);
 314                 goto out;
 315         }
 316
 317         netif_stop_queue(sl->dev);
 318         slc_encaps(sl, (struct can_frame *) skb->data); /* encaps & send */
 319         spin_unlock(&sl->lock);
 320
 321 out:
 322         kfree_skb(skb);
 323         return NETDEV_TX_OK;
 324 }
 325
 326
 327 /******************************************
 328  *   Routines looking at netdevice side.
 329  ******************************************/
 330
 331 /* Netdevice UP -> DOWN routine */
 332 static int slc_close(struct net_device *dev)
 333 {
 334         struct slcan *sl = netdev_priv(dev);
 335
 336         spin_lock_bh(&sl->lock);
 337         if (sl->tty) {
 338                 /* TTY discipline is running. */
 339                 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
 340         }
 341         netif_stop_queue(dev);
 342         sl->rcount   = 0;
 343         sl->xleft    = 0;
 344         spin_unlock_bh(&sl->lock);
 345
 346         return 0;
 347 }
 348
 349 /* Netdevice DOWN -> UP routine */
 350 static int slc_open(struct net_device *dev)
 351 {
 352         struct slcan *sl = netdev_priv(dev);
 353
 354         if (sl->tty == NULL)
 355                 return -ENODEV;
 356
 357         sl->flags &= (1 << SLF_INUSE);
 358         netif_start_queue(dev);
 359         return 0;
 360 }
 361
 362 /* Hook the destructor so we can free slcan devs at the right point in time */
 363 static void slc_free_netdev(struct net_device *dev)
 364 {
 365         int i = dev->base_addr;
 366         free_netdev(dev);
 367         slcan_devs[i] = NULL;
 368 }
 369
 370 static const struct net_device_ops slc_netdev_ops = {
 371         .ndo_open               = slc_open,
 372         .ndo_stop               = slc_close,
 373         .ndo_start_xmit         = slc_xmit,
 374 };
 375
 376 static void slc_setup(struct net_device *dev)
 377 {
 378         dev->netdev_ops         = &slc_netdev_ops;
 379         dev->destructor         = slc_free_netdev;
 380
 381         dev->hard_header_len    = 0;
 382         dev->addr_len           = 0;
 383         dev->tx_queue_len       = 10;
 384
 385         dev->mtu                = sizeof(struct can_frame);
 386         dev->type               = ARPHRD_CAN;
 387
 388         /* New-style flags. */
 389         dev->flags              = IFF_NOARP;
 390         dev->features           = NETIF_F_NO_CSUM;
 391 }
 392
 393 /******************************************
 394   Routines looking at TTY side.
 395  ******************************************/
 396
 397 /*
 398  * Handle the 'receiver data ready' interrupt.
 399  * This function is called by the 'tty_io' module in the kernel when
 400  * a block of SLCAN data has been received, which can now be decapsulated
 401  * and sent on to some IP layer for further processing. This will not
 402  * be re-entered while running but other ldisc functions may be called
 403  * in parallel
 404  */
 405
 406 static void slcan_receive_buf(struct tty_struct *tty,
 407                               const unsigned char *cp, char *fp, int count)
 408 {
 409         struct slcan *sl = (struct slcan *) tty->disc_data;
 410
 411         if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
 412                 return;
 413
 414         /* Read the characters out of the buffer */
 415         while (count--) {
 416                 if (fp && *fp++) {
 417                         if (!test_and_set_bit(SLF_ERROR, &sl->flags))
 418                                 sl->dev->stats.rx_errors++;
 419                         cp++;
 420                         continue;
 421                 }
 422                 slcan_unesc(sl, *cp++);
 423         }
 424 }
 425
 426 /************************************
 427  *  slcan_open helper routines.
 428  ************************************/
 429
 430 /* Collect hanged up channels */
 431 static void slc_sync(void)
 432 {
 433         int i;
 434         struct net_device *dev;
 435         struct slcan      *sl;
 436
 437         for (i = 0; i < maxdev; i++) {
 438                 dev = slcan_devs[i];
 439                 if (dev == NULL)
 440                         break;
 441
 442                 sl = netdev_priv(dev);
 443                 if (sl->tty)
 444                         continue;
 445                 if (dev->flags & IFF_UP)
 446                         dev_close(dev);
 447         }
 448 }
 449
 450 /* Find a free SLCAN channel, and link in this `tty' line. */
 451 static struct slcan *slc_alloc(dev_t line)
 452 {
 453         int i;
 454         char name[IFNAMSIZ];
 455         struct net_device *dev = NULL;
 456         struct slcan       *sl;
 457
 458         for (i = 0; i < maxdev; i++) {
 459                 dev = slcan_devs[i];
 460                 if (dev == NULL)
 461                         break;
 462
 463         }
 464
 465         /* Sorry, too many, all slots in use */
 466         if (i >= maxdev)
 467                 return NULL;
 468
 469         sprintf(name, "slcan%d", i);
 470         dev = alloc_netdev(sizeof(*sl), name, slc_setup);
 471         if (!dev)
 472                 return NULL;
 473
 474         dev->base_addr  = i;
 475         sl = netdev_priv(dev);
 476
 477         /* Initialize channel control data */
 478         sl->magic = SLCAN_MAGIC;
 479         sl->dev = dev;
 480         spin_lock_init(&sl->lock);
 481         slcan_devs[i] = dev;
 482
 483         return sl;
 484 }
 485
 486 /*
 487  * Open the high-level part of the SLCAN channel.
 488  * This function is called by the TTY module when the
 489  * SLCAN line discipline is called for.  Because we are
 490  * sure the tty line exists, we only have to link it to
 491  * a free SLCAN channel...
 492  *
 493  * Called in process context serialized from other ldisc calls.
 494  */
 495
 496 static int slcan_open(struct tty_struct *tty)
 497 {
 498         struct slcan *sl;
 499         int err;
 500
 501         if (!capable(CAP_NET_ADMIN))
 502                 return -EPERM;
 503
 504         if (tty->ops->write == NULL)
 505                 return -EOPNOTSUPP;
 506
 507         /* RTnetlink lock is misused here to serialize concurrent
 508            opens of slcan channels. There are better ways, but it is
 509            the simplest one.
 510          */
 511         rtnl_lock();
 512
 513         /* Collect hanged up channels. */
 514         slc_sync();
 515
 516         sl = tty->disc_data;
 517
 518         err = -EEXIST;
 519         /* First make sure we're not already connected. */
 520         if (sl && sl->magic == SLCAN_MAGIC)
 521                 goto err_exit;
 522
 523         /* OK.  Find a free SLCAN channel to use. */
 524         err = -ENFILE;
 525         sl = slc_alloc(tty_devnum(tty));
 526         if (sl == NULL)
 527                 goto err_exit;
 528
 529         sl->tty = tty;
 530         tty->disc_data = sl;
 531
 532         if (!test_bit(SLF_INUSE, &sl->flags)) {
 533                 /* Perform the low-level SLCAN initialization. */
 534                 sl->rcount   = 0;
 535                 sl->xleft    = 0;
 536
 537                 set_bit(SLF_INUSE, &sl->flags);
 538
 539                 err = register_netdevice(sl->dev);
 540                 if (err)
 541                         goto err_free_chan;
 542         }
 543
 544         /* Done.  We have linked the TTY line to a channel. */
 545         rtnl_unlock();
 546         tty->receive_room = 65536;      /* We don't flow control */
 547
 548         /* TTY layer expects 0 on success */
 549         return 0;
 550
 551 err_free_chan:
 552         sl->tty = NULL;
 553         tty->disc_data = NULL;
 554         clear_bit(SLF_INUSE, &sl->flags);
 555
 556 err_exit:
 557         rtnl_unlock();
 558
 559         /* Count references from TTY module */
 560         return err;
 561 }
 562
 563 /*
 564  * Close down a SLCAN channel.
 565  * This means flushing out any pending queues, and then returning. This
 566  * call is serialized against other ldisc functions.
 567  *
 568  * We also use this method for a hangup event.
 569  */
 570
 571 static void slcan_close(struct tty_struct *tty)
 572 {
 573         struct slcan *sl = (struct slcan *) tty->disc_data;
 574
 575         /* First make sure we're connected. */
 576         if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
 577                 return;
 578
 579         tty->disc_data = NULL;
 580         sl->tty = NULL;
 581
 582         /* Flush network side */
 583         unregister_netdev(sl->dev);
 584         /* This will complete via sl_free_netdev */
 585 }
 586
 587 static int slcan_hangup(struct tty_struct *tty)
 588 {
 589         slcan_close(tty);
 590         return 0;
 591 }
 592
 593 /* Perform I/O control on an active SLCAN channel. */
 594 static int slcan_ioctl(struct tty_struct *tty, struct file *file,
 595                        unsigned int cmd, unsigned long arg)
 596 {
 597         struct slcan *sl = (struct slcan *) tty->disc_data;
 598         unsigned int tmp;
 599
 600         /* First make sure we're connected. */
 601         if (!sl || sl->magic != SLCAN_MAGIC)
 602                 return -EINVAL;
 603
 604         switch (cmd) {
 605         case SIOCGIFNAME:
 606                 tmp = strlen(sl->dev->name) + 1;
 607                 if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
 608                         return -EFAULT;
 609                 return 0;
 610
 611         case SIOCSIFHWADDR:
 612                 return -EINVAL;
 613
 614         default:
 615                 return tty_mode_ioctl(tty, file, cmd, arg);
 616         }
 617 }
 618
 619 static struct tty_ldisc_ops slc_ldisc = {
 620         .owner          = THIS_MODULE,
 621         .magic          = TTY_LDISC_MAGIC,
 622         .name           = "slcan",
 623         .open           = slcan_open,
 624         .close          = slcan_close,
 625         .hangup         = slcan_hangup,
 626         .ioctl          = slcan_ioctl,
 627         .receive_buf    = slcan_receive_buf,
 628         .write_wakeup   = slcan_write_wakeup,
 629 };
 630
 631 static int __init slcan_init(void)
 632 {
 633         int status;
 634
 635         if (maxdev < 4)
 636                 maxdev = 4; /* Sanity */
 637
 638         printk(banner);
 639         printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
 640
 641         slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
 642         if (!slcan_devs) {
 643                 printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
 644                 return -ENOMEM;
 645         }
 646
 647         /* Fill in our line protocol discipline, and register it */
 648         status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
 649         if (status)  {
 650                 printk(KERN_ERR "slcan: can't register line discipline\n");
 651                 kfree(slcan_devs);
 652         }
 653         return status;
 654 }
 655
 656 static void __exit slcan_exit(void)
 657 {
 658         int i;
 659         struct net_device *dev;
 660         struct slcan *sl;
 661         unsigned long timeout = jiffies + HZ;
 662         int busy = 0;
 663
 664         if (slcan_devs == NULL)
 665                 return;
 666
 667         /* First of all: check for active disciplines and hangup them.
 668          */
 669         do {
 670                 if (busy)
 671                         msleep_interruptible(100);
 672
 673                 busy = 0;
 674                 for (i = 0; i < maxdev; i++) {
 675                         dev = slcan_devs[i];
 676                         if (!dev)
 677                                 continue;
 678                         sl = netdev_priv(dev);
 679                         spin_lock_bh(&sl->lock);
 680                         if (sl->tty) {
 681                                 busy++;
 682                                 tty_hangup(sl->tty);
 683                         }
 684                         spin_unlock_bh(&sl->lock);
 685                 }
 686         } while (busy && time_before(jiffies, timeout));
 687
 688         /* FIXME: hangup is async so we should wait when doing this second
 689            phase */
 690
 691         for (i = 0; i < maxdev; i++) {
 692                 dev = slcan_devs[i];
 693                 if (!dev)
 694                         continue;
 695                 slcan_devs[i] = NULL;
 696
 697                 sl = netdev_priv(dev);
 698                 if (sl->tty) {
 699                         printk(KERN_ERR "%s: tty discipline still running\n",
 700                                dev->name);
 701                         /* Intentionally leak the control block. */
 702                         dev->destructor = NULL;
 703                 }
 704
 705                 unregister_netdev(dev);
 706         }
 707
 708         kfree(slcan_devs);
 709         slcan_devs = NULL;
 710
 711         i = tty_unregister_ldisc(N_SLCAN);
 712         if (i)
 713                 printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
 714 }
 715
 716 module_init(slcan_init);
 717 module_exit(slcan_exit);