drivers/net/plip.c

   1 /* $Id: plip.c,v 1.3.6.2 1997/04/16 15:07:56 phil Exp $ */
   2 /* PLIP: A parallel port "network" driver for Linux. */
   3 /* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */
   4 /*
   5  * Authors:     Donald Becker <becker@scyld.com>
   6  *              Tommy Thorn <thorn@daimi.aau.dk>
   7  *              Tanabe Hiroyasu <hiro@sanpo.t.u-tokyo.ac.jp>
   8  *              Alan Cox <gw4pts@gw4pts.ampr.org>
   9  *              Peter Bauer <100136.3530@compuserve.com>
  10  *              Niibe Yutaka <gniibe@mri.co.jp>
  11  *              Nimrod Zimerman <zimerman@mailandnews.com>
  12  *
  13  * Enhancements:
  14  *              Modularization and ifreq/ifmap support by Alan Cox.
  15  *              Rewritten by Niibe Yutaka.
  16  *              parport-sharing awareness code by Philip Blundell.
  17  *              SMP locking by Niibe Yutaka.
  18  *              Support for parallel ports with no IRQ (poll mode),
  19  *              Modifications to use the parallel port API
  20  *              by Nimrod Zimerman.
  21  *
  22  * Fixes:
  23  *              Niibe Yutaka
  24  *                - Module initialization.
  25  *                - MTU fix.
  26  *                - Make sure other end is OK, before sending a packet.
  27  *                - Fix immediate timer problem.
  28  *
  29  *              Al Viro
  30  *                - Changed {enable,disable}_irq handling to make it work
  31  *                  with new ("stack") semantics.
  32  *
  33  *              This program is free software; you can redistribute it and/or
  34  *              modify it under the terms of the GNU General Public License
  35  *              as published by the Free Software Foundation; either version
  36  *              2 of the License, or (at your option) any later version.
  37  */
  38
  39 /*
  40  * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com>
  41  * inspired by Russ Nelson's parallel port packet driver.
  42  *
  43  * NOTE:
  44  *     Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0.
  45  *     Because of the necessity to communicate to DOS machines with the
  46  *     Crynwr packet driver, Peter Bauer changed the protocol again
  47  *     back to original protocol.
  48  *
  49  *     This version follows original PLIP protocol.
  50  *     So, this PLIP can't communicate the PLIP of Linux v1.0.
  51  */
  52
  53 /*
  54  *     To use with DOS box, please do (Turn on ARP switch):
  55  *      # ifconfig plip[0-2] arp
  56  */
  57 static const char version[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n";
  58
  59 /*
  60   Sources:
  61         Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
  62         "parallel.asm" parallel port packet driver.
  63
  64   The "Crynwr" parallel port standard specifies the following protocol:
  65     Trigger by sending nibble '0x8' (this causes interrupt on other end)
  66     count-low octet
  67     count-high octet
  68     ... data octets
  69     checksum octet
  70   Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
  71                         <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
  72
  73   The packet is encapsulated as if it were ethernet.
  74
  75   The cable used is a de facto standard parallel null cable -- sold as
  76   a "LapLink" cable by various places.  You'll need a 12-conductor cable to
  77   make one yourself.  The wiring is:
  78     SLCTIN      17 - 17
  79     GROUND      25 - 25
  80     D0->ERROR   2 - 15          15 - 2
  81     D1->SLCT    3 - 13          13 - 3
  82     D2->PAPOUT  4 - 12          12 - 4
  83     D3->ACK     5 - 10          10 - 5
  84     D4->BUSY    6 - 11          11 - 6
  85   Do not connect the other pins.  They are
  86     D5,D6,D7 are 7,8,9
  87     STROBE is 1, FEED is 14, INIT is 16
  88     extra grounds are 18,19,20,21,22,23,24
  89 */
  90
  91 #include <linux/module.h>
  92 #include <linux/kernel.h>
  93 #include <linux/types.h>
  94 #include <linux/fcntl.h>
  95 #include <linux/interrupt.h>
  96 #include <linux/string.h>
  97 #include <linux/if_ether.h>
  98 #include <linux/in.h>
  99 #include <linux/errno.h>
 100 #include <linux/delay.h>
 101 #include <linux/init.h>
 102 #include <linux/netdevice.h>
 103 #include <linux/etherdevice.h>
 104 #include <linux/inetdevice.h>
 105 #include <linux/skbuff.h>
 106 #include <linux/if_plip.h>
 107 #include <linux/workqueue.h>
 108 #include <linux/spinlock.h>
 109 #include <linux/completion.h>
 110 #include <linux/parport.h>
 111 #include <linux/bitops.h>
 112
 113 #include <net/neighbour.h>
 114
 115 #include <asm/system.h>
 116 #include <asm/irq.h>
 117 #include <asm/byteorder.h>
 118
 119 /* Maximum number of devices to support. */
 120 #define PLIP_MAX  8
 121
 122 /* Use 0 for production, 1 for verification, >2 for debug */
 123 #ifndef NET_DEBUG
 124 #define NET_DEBUG 1
 125 #endif
 126 static const unsigned int net_debug = NET_DEBUG;
 127
 128 #define ENABLE(irq)  if (irq != -1) enable_irq(irq)
 129 #define DISABLE(irq) if (irq != -1) disable_irq(irq)
 130
 131 /* In micro second */
 132 #define PLIP_DELAY_UNIT            1
 133
 134 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
 135 #define PLIP_TRIGGER_WAIT        500
 136
 137 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
 138 #define PLIP_NIBBLE_WAIT        3000
 139
 140 /* Bottom halves */
 141 static void plip_kick_bh(struct work_struct *work);
 142 static void plip_bh(struct work_struct *work);
 143 static void plip_timer_bh(struct work_struct *work);
 144
 145 /* Interrupt handler */
 146 static void plip_interrupt(void *dev_id);
 147
 148 /* Functions for DEV methods */
 149 static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);
 150 static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,
 151                             unsigned short type, const void *daddr,
 152                             const void *saddr, unsigned len);
 153 static int plip_hard_header_cache(const struct neighbour *neigh,
 154                                   struct hh_cache *hh);
 155 static int plip_open(struct net_device *dev);
 156 static int plip_close(struct net_device *dev);
 157 static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 158 static int plip_preempt(void *handle);
 159 static void plip_wakeup(void *handle);
 160
 161 enum plip_connection_state {
 162         PLIP_CN_NONE=0,
 163         PLIP_CN_RECEIVE,
 164         PLIP_CN_SEND,
 165         PLIP_CN_CLOSING,
 166         PLIP_CN_ERROR
 167 };
 168
 169 enum plip_packet_state {
 170         PLIP_PK_DONE=0,
 171         PLIP_PK_TRIGGER,
 172         PLIP_PK_LENGTH_LSB,
 173         PLIP_PK_LENGTH_MSB,
 174         PLIP_PK_DATA,
 175         PLIP_PK_CHECKSUM
 176 };
 177
 178 enum plip_nibble_state {
 179         PLIP_NB_BEGIN,
 180         PLIP_NB_1,
 181         PLIP_NB_2,
 182 };
 183
 184 struct plip_local {
 185         enum plip_packet_state state;
 186         enum plip_nibble_state nibble;
 187         union {
 188                 struct {
 189 #if defined(__LITTLE_ENDIAN)
 190                         unsigned char lsb;
 191                         unsigned char msb;
 192 #elif defined(__BIG_ENDIAN)
 193                         unsigned char msb;
 194                         unsigned char lsb;
 195 #else
 196 #error  "Please fix the endianness defines in <asm/byteorder.h>"
 197 #endif
 198                 } b;
 199                 unsigned short h;
 200         } length;
 201         unsigned short byte;
 202         unsigned char  checksum;
 203         unsigned char  data;
 204         struct sk_buff *skb;
 205 };
 206
 207 struct net_local {
 208         struct net_device *dev;
 209         struct work_struct immediate;
 210         struct delayed_work deferred;
 211         struct delayed_work timer;
 212         struct plip_local snd_data;
 213         struct plip_local rcv_data;
 214         struct pardevice *pardev;
 215         unsigned long  trigger;
 216         unsigned long  nibble;
 217         enum plip_connection_state connection;
 218         unsigned short timeout_count;
 219         int is_deferred;
 220         int port_owner;
 221         int should_relinquish;
 222         spinlock_t lock;
 223         atomic_t kill_timer;
 224         struct completion killed_timer_cmp;
 225 };
 226
 227 static inline void enable_parport_interrupts (struct net_device *dev)
 228 {
 229         if (dev->irq != -1)
 230         {
 231                 struct parport *port =
 232                    ((struct net_local *)netdev_priv(dev))->pardev->port;
 233                 port->ops->enable_irq (port);
 234         }
 235 }
 236
 237 static inline void disable_parport_interrupts (struct net_device *dev)
 238 {
 239         if (dev->irq != -1)
 240         {
 241                 struct parport *port =
 242                    ((struct net_local *)netdev_priv(dev))->pardev->port;
 243                 port->ops->disable_irq (port);
 244         }
 245 }
 246
 247 static inline void write_data (struct net_device *dev, unsigned char data)
 248 {
 249         struct parport *port =
 250            ((struct net_local *)netdev_priv(dev))->pardev->port;
 251
 252         port->ops->write_data (port, data);
 253 }
 254
 255 static inline unsigned char read_status (struct net_device *dev)
 256 {
 257         struct parport *port =
 258            ((struct net_local *)netdev_priv(dev))->pardev->port;
 259
 260         return port->ops->read_status (port);
 261 }
 262
 263 static const struct header_ops plip_header_ops = {
 264         .create = plip_hard_header,
 265         .cache  = plip_hard_header_cache,
 266 };
 267
 268 /* Entry point of PLIP driver.
 269    Probe the hardware, and register/initialize the driver.
 270
 271    PLIP is rather weird, because of the way it interacts with the parport
 272    system.  It is _not_ initialised from Space.c.  Instead, plip_init()
 273    is called, and that function makes up a "struct net_device" for each port, and
 274    then calls us here.
 275
 276    */
 277 static void
 278 plip_init_netdev(struct net_device *dev)
 279 {
 280         struct net_local *nl = netdev_priv(dev);
 281
 282         /* Then, override parts of it */
 283         dev->hard_start_xmit     = plip_tx_packet;
 284         dev->open                = plip_open;
 285         dev->stop                = plip_close;
 286         dev->do_ioctl            = plip_ioctl;
 287
 288         dev->tx_queue_len        = 10;
 289         dev->flags               = IFF_POINTOPOINT|IFF_NOARP;
 290         memset(dev->dev_addr, 0xfc, ETH_ALEN);
 291
 292         dev->header_ops          = &plip_header_ops;
 293
 294
 295         nl->port_owner = 0;
 296
 297         /* Initialize constants */
 298         nl->trigger     = PLIP_TRIGGER_WAIT;
 299         nl->nibble      = PLIP_NIBBLE_WAIT;
 300
 301         /* Initialize task queue structures */
 302         INIT_WORK(&nl->immediate, plip_bh);
 303         INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);
 304
 305         if (dev->irq == -1)
 306                 INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);
 307
 308         spin_lock_init(&nl->lock);
 309 }
 310
 311 /* Bottom half handler for the delayed request.
 312    This routine is kicked by do_timer().
 313    Request `plip_bh' to be invoked. */
 314 static void
 315 plip_kick_bh(struct work_struct *work)
 316 {
 317         struct net_local *nl =
 318                 container_of(work, struct net_local, deferred.work);
 319
 320         if (nl->is_deferred)
 321                 schedule_work(&nl->immediate);
 322 }
 323
 324 /* Forward declarations of internal routines */
 325 static int plip_none(struct net_device *, struct net_local *,
 326                      struct plip_local *, struct plip_local *);
 327 static int plip_receive_packet(struct net_device *, struct net_local *,
 328                                struct plip_local *, struct plip_local *);
 329 static int plip_send_packet(struct net_device *, struct net_local *,
 330                             struct plip_local *, struct plip_local *);
 331 static int plip_connection_close(struct net_device *, struct net_local *,
 332                                  struct plip_local *, struct plip_local *);
 333 static int plip_error(struct net_device *, struct net_local *,
 334                       struct plip_local *, struct plip_local *);
 335 static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
 336                                  struct plip_local *snd,
 337                                  struct plip_local *rcv,
 338                                  int error);
 339
 340 #define OK        0
 341 #define TIMEOUT   1
 342 #define ERROR     2
 343 #define HS_TIMEOUT      3
 344
 345 typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
 346                          struct plip_local *snd, struct plip_local *rcv);
 347
 348 static const plip_func connection_state_table[] =
 349 {
 350         plip_none,
 351         plip_receive_packet,
 352         plip_send_packet,
 353         plip_connection_close,
 354         plip_error
 355 };
 356
 357 /* Bottom half handler of PLIP. */
 358 static void
 359 plip_bh(struct work_struct *work)
 360 {
 361         struct net_local *nl = container_of(work, struct net_local, immediate);
 362         struct plip_local *snd = &nl->snd_data;
 363         struct plip_local *rcv = &nl->rcv_data;
 364         plip_func f;
 365         int r;
 366
 367         nl->is_deferred = 0;
 368         f = connection_state_table[nl->connection];
 369         if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK
 370             && (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) {
 371                 nl->is_deferred = 1;
 372                 schedule_delayed_work(&nl->deferred, 1);
 373         }
 374 }
 375
 376 static void
 377 plip_timer_bh(struct work_struct *work)
 378 {
 379         struct net_local *nl =
 380                 container_of(work, struct net_local, timer.work);
 381
 382         if (!(atomic_read (&nl->kill_timer))) {
 383                 plip_interrupt (nl->dev);
 384
 385                 schedule_delayed_work(&nl->timer, 1);
 386         }
 387         else {
 388                 complete(&nl->killed_timer_cmp);
 389         }
 390 }
 391
 392 static int
 393 plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
 394                       struct plip_local *snd, struct plip_local *rcv,
 395                       int error)
 396 {
 397         unsigned char c0;
 398         /*
 399          * This is tricky. If we got here from the beginning of send (either
 400          * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
 401          * already disabled. With the old variant of {enable,disable}_irq()
 402          * extra disable_irq() was a no-op. Now it became mortal - it's
 403          * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
 404          * that is). So we have to treat HS_TIMEOUT and ERROR from send
 405          * in a special way.
 406          */
 407
 408         spin_lock_irq(&nl->lock);
 409         if (nl->connection == PLIP_CN_SEND) {
 410
 411                 if (error != ERROR) { /* Timeout */
 412                         nl->timeout_count++;
 413                         if ((error == HS_TIMEOUT
 414                              && nl->timeout_count <= 10)
 415                             || nl->timeout_count <= 3) {
 416                                 spin_unlock_irq(&nl->lock);
 417                                 /* Try again later */
 418                                 return TIMEOUT;
 419                         }
 420                         c0 = read_status(dev);
 421                         printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
 422                                dev->name, snd->state, c0);
 423                 } else
 424                         error = HS_TIMEOUT;
 425                 dev->stats.tx_errors++;
 426                 dev->stats.tx_aborted_errors++;
 427         } else if (nl->connection == PLIP_CN_RECEIVE) {
 428                 if (rcv->state == PLIP_PK_TRIGGER) {
 429                         /* Transmission was interrupted. */
 430                         spin_unlock_irq(&nl->lock);
 431                         return OK;
 432                 }
 433                 if (error != ERROR) { /* Timeout */
 434                         if (++nl->timeout_count <= 3) {
 435                                 spin_unlock_irq(&nl->lock);
 436                                 /* Try again later */
 437                                 return TIMEOUT;
 438                         }
 439                         c0 = read_status(dev);
 440                         printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
 441                                dev->name, rcv->state, c0);
 442                 }
 443                 dev->stats.rx_dropped++;
 444         }
 445         rcv->state = PLIP_PK_DONE;
 446         if (rcv->skb) {
 447                 kfree_skb(rcv->skb);
 448                 rcv->skb = NULL;
 449         }
 450         snd->state = PLIP_PK_DONE;
 451         if (snd->skb) {
 452                 dev_kfree_skb(snd->skb);
 453                 snd->skb = NULL;
 454         }
 455         spin_unlock_irq(&nl->lock);
 456         if (error == HS_TIMEOUT) {
 457                 DISABLE(dev->irq);
 458                 synchronize_irq(dev->irq);
 459         }
 460         disable_parport_interrupts (dev);
 461         netif_stop_queue (dev);
 462         nl->connection = PLIP_CN_ERROR;
 463         write_data (dev, 0x00);
 464
 465         return TIMEOUT;
 466 }
 467
 468 static int
 469 plip_none(struct net_device *dev, struct net_local *nl,
 470           struct plip_local *snd, struct plip_local *rcv)
 471 {
 472         return OK;
 473 }
 474
 475 /* PLIP_RECEIVE --- receive a byte(two nibbles)
 476    Returns OK on success, TIMEOUT on timeout */
 477 static inline int
 478 plip_receive(unsigned short nibble_timeout, struct net_device *dev,
 479              enum plip_nibble_state *ns_p, unsigned char *data_p)
 480 {
 481         unsigned char c0, c1;
 482         unsigned int cx;
 483
 484         switch (*ns_p) {
 485         case PLIP_NB_BEGIN:
 486                 cx = nibble_timeout;
 487                 while (1) {
 488                         c0 = read_status(dev);
 489                         udelay(PLIP_DELAY_UNIT);
 490                         if ((c0 & 0x80) == 0) {
 491                                 c1 = read_status(dev);
 492                                 if (c0 == c1)
 493                                         break;
 494                         }
 495                         if (--cx == 0)
 496                                 return TIMEOUT;
 497                 }
 498                 *data_p = (c0 >> 3) & 0x0f;
 499                 write_data (dev, 0x10); /* send ACK */
 500                 *ns_p = PLIP_NB_1;
 501
 502         case PLIP_NB_1:
 503                 cx = nibble_timeout;
 504                 while (1) {
 505                         c0 = read_status(dev);
 506                         udelay(PLIP_DELAY_UNIT);
 507                         if (c0 & 0x80) {
 508                                 c1 = read_status(dev);
 509                                 if (c0 == c1)
 510                                         break;
 511                         }
 512                         if (--cx == 0)
 513                                 return TIMEOUT;
 514                 }
 515                 *data_p |= (c0 << 1) & 0xf0;
 516                 write_data (dev, 0x00); /* send ACK */
 517                 *ns_p = PLIP_NB_BEGIN;
 518         case PLIP_NB_2:
 519                 break;
 520         }
 521         return OK;
 522 }
 523
 524 /*
 525  *      Determine the packet's protocol ID. The rule here is that we
 526  *      assume 802.3 if the type field is short enough to be a length.
 527  *      This is normal practice and works for any 'now in use' protocol.
 528  *
 529  *      PLIP is ethernet ish but the daddr might not be valid if unicast.
 530  *      PLIP fortunately has no bus architecture (its Point-to-point).
 531  *
 532  *      We can't fix the daddr thing as that quirk (more bug) is embedded
 533  *      in far too many old systems not all even running Linux.
 534  */
 535
 536 static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
 537 {
 538         struct ethhdr *eth;
 539         unsigned char *rawp;
 540
 541         skb_reset_mac_header(skb);
 542         skb_pull(skb,dev->hard_header_len);
 543         eth = eth_hdr(skb);
 544
 545         if(*eth->h_dest&1)
 546         {
 547                 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
 548                         skb->pkt_type=PACKET_BROADCAST;
 549                 else
 550                         skb->pkt_type=PACKET_MULTICAST;
 551         }
 552
 553         /*
 554          *      This ALLMULTI check should be redundant by 1.4
 555          *      so don't forget to remove it.
 556          */
 557
 558         if (ntohs(eth->h_proto) >= 1536)
 559                 return eth->h_proto;
 560
 561         rawp = skb->data;
 562
 563         /*
 564          *      This is a magic hack to spot IPX packets. Older Novell breaks
 565          *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
 566          *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
 567          *      won't work for fault tolerant netware but does for the rest.
 568          */
 569         if (*(unsigned short *)rawp == 0xFFFF)
 570                 return htons(ETH_P_802_3);
 571
 572         /*
 573          *      Real 802.2 LLC
 574          */
 575         return htons(ETH_P_802_2);
 576 }
 577
 578 /* PLIP_RECEIVE_PACKET --- receive a packet */
 579 static int
 580 plip_receive_packet(struct net_device *dev, struct net_local *nl,
 581                     struct plip_local *snd, struct plip_local *rcv)
 582 {
 583         unsigned short nibble_timeout = nl->nibble;
 584         unsigned char *lbuf;
 585
 586         switch (rcv->state) {
 587         case PLIP_PK_TRIGGER:
 588                 DISABLE(dev->irq);
 589                 /* Don't need to synchronize irq, as we can safely ignore it */
 590                 disable_parport_interrupts (dev);
 591                 write_data (dev, 0x01); /* send ACK */
 592                 if (net_debug > 2)
 593                         printk(KERN_DEBUG "%s: receive start\n", dev->name);
 594                 rcv->state = PLIP_PK_LENGTH_LSB;
 595                 rcv->nibble = PLIP_NB_BEGIN;
 596
 597         case PLIP_PK_LENGTH_LSB:
 598                 if (snd->state != PLIP_PK_DONE) {
 599                         if (plip_receive(nl->trigger, dev,
 600                                          &rcv->nibble, &rcv->length.b.lsb)) {
 601                                 /* collision, here dev->tbusy == 1 */
 602                                 rcv->state = PLIP_PK_DONE;
 603                                 nl->is_deferred = 1;
 604                                 nl->connection = PLIP_CN_SEND;
 605                                 schedule_delayed_work(&nl->deferred, 1);
 606                                 enable_parport_interrupts (dev);
 607                                 ENABLE(dev->irq);
 608                                 return OK;
 609                         }
 610                 } else {
 611                         if (plip_receive(nibble_timeout, dev,
 612                                          &rcv->nibble, &rcv->length.b.lsb))
 613                                 return TIMEOUT;
 614                 }
 615                 rcv->state = PLIP_PK_LENGTH_MSB;
 616
 617         case PLIP_PK_LENGTH_MSB:
 618                 if (plip_receive(nibble_timeout, dev,
 619                                  &rcv->nibble, &rcv->length.b.msb))
 620                         return TIMEOUT;
 621                 if (rcv->length.h > dev->mtu + dev->hard_header_len
 622                     || rcv->length.h < 8) {
 623                         printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
 624                         return ERROR;
 625                 }
 626                 /* Malloc up new buffer. */
 627                 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
 628                 if (rcv->skb == NULL) {
 629                         printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
 630                         return ERROR;
 631                 }
 632                 skb_reserve(rcv->skb, 2);       /* Align IP on 16 byte boundaries */
 633                 skb_put(rcv->skb,rcv->length.h);
 634                 rcv->skb->dev = dev;
 635                 rcv->state = PLIP_PK_DATA;
 636                 rcv->byte = 0;
 637                 rcv->checksum = 0;
 638
 639         case PLIP_PK_DATA:
 640                 lbuf = rcv->skb->data;
 641                 do
 642                         if (plip_receive(nibble_timeout, dev,
 643                                          &rcv->nibble, &lbuf[rcv->byte]))
 644                                 return TIMEOUT;
 645                 while (++rcv->byte < rcv->length.h);
 646                 do
 647                         rcv->checksum += lbuf[--rcv->byte];
 648                 while (rcv->byte);
 649                 rcv->state = PLIP_PK_CHECKSUM;
 650
 651         case PLIP_PK_CHECKSUM:
 652                 if (plip_receive(nibble_timeout, dev,
 653                                  &rcv->nibble, &rcv->data))
 654                         return TIMEOUT;
 655                 if (rcv->data != rcv->checksum) {
 656                         dev->stats.rx_crc_errors++;
 657                         if (net_debug)
 658                                 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
 659                         return ERROR;
 660                 }
 661                 rcv->state = PLIP_PK_DONE;
 662
 663         case PLIP_PK_DONE:
 664                 /* Inform the upper layer for the arrival of a packet. */
 665                 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
 666                 netif_rx_ni(rcv->skb);
 667                 dev->stats.rx_bytes += rcv->length.h;
 668                 dev->stats.rx_packets++;
 669                 rcv->skb = NULL;
 670                 if (net_debug > 2)
 671                         printk(KERN_DEBUG "%s: receive end\n", dev->name);
 672
 673                 /* Close the connection. */
 674                 write_data (dev, 0x00);
 675                 spin_lock_irq(&nl->lock);
 676                 if (snd->state != PLIP_PK_DONE) {
 677                         nl->connection = PLIP_CN_SEND;
 678                         spin_unlock_irq(&nl->lock);
 679                         schedule_work(&nl->immediate);
 680                         enable_parport_interrupts (dev);
 681                         ENABLE(dev->irq);
 682                         return OK;
 683                 } else {
 684                         nl->connection = PLIP_CN_NONE;
 685                         spin_unlock_irq(&nl->lock);
 686                         enable_parport_interrupts (dev);
 687                         ENABLE(dev->irq);
 688                         return OK;
 689                 }
 690         }
 691         return OK;
 692 }
 693
 694 /* PLIP_SEND --- send a byte (two nibbles)
 695    Returns OK on success, TIMEOUT when timeout    */
 696 static inline int
 697 plip_send(unsigned short nibble_timeout, struct net_device *dev,
 698           enum plip_nibble_state *ns_p, unsigned char data)
 699 {
 700         unsigned char c0;
 701         unsigned int cx;
 702
 703         switch (*ns_p) {
 704         case PLIP_NB_BEGIN:
 705                 write_data (dev, data & 0x0f);
 706                 *ns_p = PLIP_NB_1;
 707
 708         case PLIP_NB_1:
 709                 write_data (dev, 0x10 | (data & 0x0f));
 710                 cx = nibble_timeout;
 711                 while (1) {
 712                         c0 = read_status(dev);
 713                         if ((c0 & 0x80) == 0)
 714                                 break;
 715                         if (--cx == 0)
 716                                 return TIMEOUT;
 717                         udelay(PLIP_DELAY_UNIT);
 718                 }
 719                 write_data (dev, 0x10 | (data >> 4));
 720                 *ns_p = PLIP_NB_2;
 721
 722         case PLIP_NB_2:
 723                 write_data (dev, (data >> 4));
 724                 cx = nibble_timeout;
 725                 while (1) {
 726                         c0 = read_status(dev);
 727                         if (c0 & 0x80)
 728                                 break;
 729                         if (--cx == 0)
 730                                 return TIMEOUT;
 731                         udelay(PLIP_DELAY_UNIT);
 732                 }
 733                 *ns_p = PLIP_NB_BEGIN;
 734                 return OK;
 735         }
 736         return OK;
 737 }
 738
 739 /* PLIP_SEND_PACKET --- send a packet */
 740 static int
 741 plip_send_packet(struct net_device *dev, struct net_local *nl,
 742                  struct plip_local *snd, struct plip_local *rcv)
 743 {
 744         unsigned short nibble_timeout = nl->nibble;
 745         unsigned char *lbuf;
 746         unsigned char c0;
 747         unsigned int cx;
 748
 749         if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
 750                 printk(KERN_DEBUG "%s: send skb lost\n", dev->name);
 751                 snd->state = PLIP_PK_DONE;
 752                 snd->skb = NULL;
 753                 return ERROR;
 754         }
 755
 756         switch (snd->state) {
 757         case PLIP_PK_TRIGGER:
 758                 if ((read_status(dev) & 0xf8) != 0x80)
 759                         return HS_TIMEOUT;
 760
 761                 /* Trigger remote rx interrupt. */
 762                 write_data (dev, 0x08);
 763                 cx = nl->trigger;
 764                 while (1) {
 765                         udelay(PLIP_DELAY_UNIT);
 766                         spin_lock_irq(&nl->lock);
 767                         if (nl->connection == PLIP_CN_RECEIVE) {
 768                                 spin_unlock_irq(&nl->lock);
 769                                 /* Interrupted. */
 770                                 dev->stats.collisions++;
 771                                 return OK;
 772                         }
 773                         c0 = read_status(dev);
 774                         if (c0 & 0x08) {
 775                                 spin_unlock_irq(&nl->lock);
 776                                 DISABLE(dev->irq);
 777                                 synchronize_irq(dev->irq);
 778                                 if (nl->connection == PLIP_CN_RECEIVE) {
 779                                         /* Interrupted.
 780                                            We don't need to enable irq,
 781                                            as it is soon disabled.    */
 782                                         /* Yes, we do. New variant of
 783                                            {enable,disable}_irq *counts*
 784                                            them.  -- AV  */
 785                                         ENABLE(dev->irq);
 786                                         dev->stats.collisions++;
 787                                         return OK;
 788                                 }
 789                                 disable_parport_interrupts (dev);
 790                                 if (net_debug > 2)
 791                                         printk(KERN_DEBUG "%s: send start\n", dev->name);
 792                                 snd->state = PLIP_PK_LENGTH_LSB;
 793                                 snd->nibble = PLIP_NB_BEGIN;
 794                                 nl->timeout_count = 0;
 795                                 break;
 796                         }
 797                         spin_unlock_irq(&nl->lock);
 798                         if (--cx == 0) {
 799                                 write_data (dev, 0x00);
 800                                 return HS_TIMEOUT;
 801                         }
 802                 }
 803
 804         case PLIP_PK_LENGTH_LSB:
 805                 if (plip_send(nibble_timeout, dev,
 806                               &snd->nibble, snd->length.b.lsb))
 807                         return TIMEOUT;
 808                 snd->state = PLIP_PK_LENGTH_MSB;
 809
 810         case PLIP_PK_LENGTH_MSB:
 811                 if (plip_send(nibble_timeout, dev,
 812                               &snd->nibble, snd->length.b.msb))
 813                         return TIMEOUT;
 814                 snd->state = PLIP_PK_DATA;
 815                 snd->byte = 0;
 816                 snd->checksum = 0;
 817
 818         case PLIP_PK_DATA:
 819                 do
 820                         if (plip_send(nibble_timeout, dev,
 821                                       &snd->nibble, lbuf[snd->byte]))
 822                                 return TIMEOUT;
 823                 while (++snd->byte < snd->length.h);
 824                 do
 825                         snd->checksum += lbuf[--snd->byte];
 826                 while (snd->byte);
 827                 snd->state = PLIP_PK_CHECKSUM;
 828
 829         case PLIP_PK_CHECKSUM:
 830                 if (plip_send(nibble_timeout, dev,
 831                               &snd->nibble, snd->checksum))
 832                         return TIMEOUT;
 833
 834                 dev->stats.tx_bytes += snd->skb->len;
 835                 dev_kfree_skb(snd->skb);
 836                 dev->stats.tx_packets++;
 837                 snd->state = PLIP_PK_DONE;
 838
 839         case PLIP_PK_DONE:
 840                 /* Close the connection */
 841                 write_data (dev, 0x00);
 842                 snd->skb = NULL;
 843                 if (net_debug > 2)
 844                         printk(KERN_DEBUG "%s: send end\n", dev->name);
 845                 nl->connection = PLIP_CN_CLOSING;
 846                 nl->is_deferred = 1;
 847                 schedule_delayed_work(&nl->deferred, 1);
 848                 enable_parport_interrupts (dev);
 849                 ENABLE(dev->irq);
 850                 return OK;
 851         }
 852         return OK;
 853 }
 854
 855 static int
 856 plip_connection_close(struct net_device *dev, struct net_local *nl,
 857                       struct plip_local *snd, struct plip_local *rcv)
 858 {
 859         spin_lock_irq(&nl->lock);
 860         if (nl->connection == PLIP_CN_CLOSING) {
 861                 nl->connection = PLIP_CN_NONE;
 862                 netif_wake_queue (dev);
 863         }
 864         spin_unlock_irq(&nl->lock);
 865         if (nl->should_relinquish) {
 866                 nl->should_relinquish = nl->port_owner = 0;
 867                 parport_release(nl->pardev);
 868         }
 869         return OK;
 870 }
 871
 872 /* PLIP_ERROR --- wait till other end settled */
 873 static int
 874 plip_error(struct net_device *dev, struct net_local *nl,
 875            struct plip_local *snd, struct plip_local *rcv)
 876 {
 877         unsigned char status;
 878
 879         status = read_status(dev);
 880         if ((status & 0xf8) == 0x80) {
 881                 if (net_debug > 2)
 882                         printk(KERN_DEBUG "%s: reset interface.\n", dev->name);
 883                 nl->connection = PLIP_CN_NONE;
 884                 nl->should_relinquish = 0;
 885                 netif_start_queue (dev);
 886                 enable_parport_interrupts (dev);
 887                 ENABLE(dev->irq);
 888                 netif_wake_queue (dev);
 889         } else {
 890                 nl->is_deferred = 1;
 891                 schedule_delayed_work(&nl->deferred, 1);
 892         }
 893
 894         return OK;
 895 }
 896
 897 /* Handle the parallel port interrupts. */
 898 static void
 899 plip_interrupt(void *dev_id)
 900 {
 901         struct net_device *dev = dev_id;
 902         struct net_local *nl;
 903         struct plip_local *rcv;
 904         unsigned char c0;
 905         unsigned long flags;
 906
 907         nl = netdev_priv(dev);
 908         rcv = &nl->rcv_data;
 909
 910         spin_lock_irqsave (&nl->lock, flags);
 911
 912         c0 = read_status(dev);
 913         if ((c0 & 0xf8) != 0xc0) {
 914                 if ((dev->irq != -1) && (net_debug > 1))
 915                         printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
 916                 spin_unlock_irqrestore (&nl->lock, flags);
 917                 return;
 918         }
 919
 920         if (net_debug > 3)
 921                 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
 922
 923         switch (nl->connection) {
 924         case PLIP_CN_CLOSING:
 925                 netif_wake_queue (dev);
 926         case PLIP_CN_NONE:
 927         case PLIP_CN_SEND:
 928                 rcv->state = PLIP_PK_TRIGGER;
 929                 nl->connection = PLIP_CN_RECEIVE;
 930                 nl->timeout_count = 0;
 931                 schedule_work(&nl->immediate);
 932                 break;
 933
 934         case PLIP_CN_RECEIVE:
 935                 /* May occur because there is race condition
 936                    around test and set of dev->interrupt.
 937                    Ignore this interrupt. */
 938                 break;
 939
 940         case PLIP_CN_ERROR:
 941                 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
 942                 break;
 943         }
 944
 945         spin_unlock_irqrestore(&nl->lock, flags);
 946 }
 947
 948 static int
 949 plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
 950 {
 951         struct net_local *nl = netdev_priv(dev);
 952         struct plip_local *snd = &nl->snd_data;
 953
 954         if (netif_queue_stopped(dev))
 955                 return 1;
 956
 957         /* We may need to grab the bus */
 958         if (!nl->port_owner) {
 959                 if (parport_claim(nl->pardev))
 960                         return 1;
 961                 nl->port_owner = 1;
 962         }
 963
 964         netif_stop_queue (dev);
 965
 966         if (skb->len > dev->mtu + dev->hard_header_len) {
 967                 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
 968                 netif_start_queue (dev);
 969                 return 1;
 970         }
 971
 972         if (net_debug > 2)
 973                 printk(KERN_DEBUG "%s: send request\n", dev->name);
 974
 975         spin_lock_irq(&nl->lock);
 976         dev->trans_start = jiffies;
 977         snd->skb = skb;
 978         snd->length.h = skb->len;
 979         snd->state = PLIP_PK_TRIGGER;
 980         if (nl->connection == PLIP_CN_NONE) {
 981                 nl->connection = PLIP_CN_SEND;
 982                 nl->timeout_count = 0;
 983         }
 984         schedule_work(&nl->immediate);
 985         spin_unlock_irq(&nl->lock);
 986
 987         return 0;
 988 }
 989
 990 static void
 991 plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth)
 992 {
 993         const struct in_device *in_dev = dev->ip_ptr;
 994
 995         if (in_dev) {
 996                 /* Any address will do - we take the first */
 997                 const struct in_ifaddr *ifa = in_dev->ifa_list;
 998                 if (ifa) {
 999                         memcpy(eth->h_source, dev->dev_addr, 6);
1000                         memset(eth->h_dest, 0xfc, 2);
1001                         memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1002                 }
1003         }
1004 }
1005
1006 static int
1007 plip_hard_header(struct sk_buff *skb, struct net_device *dev,
1008                  unsigned short type, const void *daddr,
1009                  const void *saddr, unsigned len)
1010 {
1011         int ret;
1012
1013         ret = eth_header(skb, dev, type, daddr, saddr, len);
1014         if (ret >= 0)
1015                 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1016
1017         return ret;
1018 }
1019
1020 int plip_hard_header_cache(const struct neighbour *neigh,
1021                            struct hh_cache *hh)
1022 {
1023         int ret;
1024
1025         ret = eth_header_cache(neigh, hh);
1026         if (ret == 0) {
1027                 struct ethhdr *eth;
1028
1029                 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1030                                        HH_DATA_OFF(sizeof(*eth)));
1031                 plip_rewrite_address (neigh->dev, eth);
1032         }
1033
1034         return ret;
1035 }
1036
1037 /* Open/initialize the board.  This is called (in the current kernel)
1038    sometime after booting when the 'ifconfig' program is run.
1039
1040    This routine gets exclusive access to the parallel port by allocating
1041    its IRQ line.
1042  */
1043 static int
1044 plip_open(struct net_device *dev)
1045 {
1046         struct net_local *nl = netdev_priv(dev);
1047         struct in_device *in_dev;
1048
1049         /* Grab the port */
1050         if (!nl->port_owner) {
1051                 if (parport_claim(nl->pardev)) return -EAGAIN;
1052                 nl->port_owner = 1;
1053         }
1054
1055         nl->should_relinquish = 0;
1056
1057         /* Clear the data port. */
1058         write_data (dev, 0x00);
1059
1060         /* Enable rx interrupt. */
1061         enable_parport_interrupts (dev);
1062         if (dev->irq == -1)
1063         {
1064                 atomic_set (&nl->kill_timer, 0);
1065                 schedule_delayed_work(&nl->timer, 1);
1066         }
1067
1068         /* Initialize the state machine. */
1069         nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1070         nl->rcv_data.skb = nl->snd_data.skb = NULL;
1071         nl->connection = PLIP_CN_NONE;
1072         nl->is_deferred = 0;
1073
1074         /* Fill in the MAC-level header.
1075            We used to abuse dev->broadcast to store the point-to-point
1076            MAC address, but we no longer do it. Instead, we fetch the
1077            interface address whenever it is needed, which is cheap enough
1078            because we use the hh_cache. Actually, abusing dev->broadcast
1079            didn't work, because when using plip_open the point-to-point
1080            address isn't yet known.
1081            PLIP doesn't have a real MAC address, but we need it to be
1082            DOS compatible, and to properly support taps (otherwise,
1083            when the device address isn't identical to the address of a
1084            received frame, the kernel incorrectly drops it).             */
1085
1086         if ((in_dev=dev->ip_ptr) != NULL) {
1087                 /* Any address will do - we take the first. We already
1088                    have the first two bytes filled with 0xfc, from
1089                    plip_init_dev(). */
1090                 struct in_ifaddr *ifa=in_dev->ifa_list;
1091                 if (ifa != NULL) {
1092                         memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1093                 }
1094         }
1095
1096         netif_start_queue (dev);
1097
1098         return 0;
1099 }
1100
1101 /* The inverse routine to plip_open (). */
1102 static int
1103 plip_close(struct net_device *dev)
1104 {
1105         struct net_local *nl = netdev_priv(dev);
1106         struct plip_local *snd = &nl->snd_data;
1107         struct plip_local *rcv = &nl->rcv_data;
1108
1109         netif_stop_queue (dev);
1110         DISABLE(dev->irq);
1111         synchronize_irq(dev->irq);
1112
1113         if (dev->irq == -1)
1114         {
1115                 init_completion(&nl->killed_timer_cmp);
1116                 atomic_set (&nl->kill_timer, 1);
1117                 wait_for_completion(&nl->killed_timer_cmp);
1118         }
1119
1120 #ifdef NOTDEF
1121         outb(0x00, PAR_DATA(dev));
1122 #endif
1123         nl->is_deferred = 0;
1124         nl->connection = PLIP_CN_NONE;
1125         if (nl->port_owner) {
1126                 parport_release(nl->pardev);
1127                 nl->port_owner = 0;
1128         }
1129
1130         snd->state = PLIP_PK_DONE;
1131         if (snd->skb) {
1132                 dev_kfree_skb(snd->skb);
1133                 snd->skb = NULL;
1134         }
1135         rcv->state = PLIP_PK_DONE;
1136         if (rcv->skb) {
1137                 kfree_skb(rcv->skb);
1138                 rcv->skb = NULL;
1139         }
1140
1141 #ifdef NOTDEF
1142         /* Reset. */
1143         outb(0x00, PAR_CONTROL(dev));
1144 #endif
1145         return 0;
1146 }
1147
1148 static int
1149 plip_preempt(void *handle)
1150 {
1151         struct net_device *dev = (struct net_device *)handle;
1152         struct net_local *nl = netdev_priv(dev);
1153
1154         /* Stand our ground if a datagram is on the wire */
1155         if (nl->connection != PLIP_CN_NONE) {
1156                 nl->should_relinquish = 1;
1157                 return 1;
1158         }
1159
1160         nl->port_owner = 0;     /* Remember that we released the bus */
1161         return 0;
1162 }
1163
1164 static void
1165 plip_wakeup(void *handle)
1166 {
1167         struct net_device *dev = (struct net_device *)handle;
1168         struct net_local *nl = netdev_priv(dev);
1169
1170         if (nl->port_owner) {
1171                 /* Why are we being woken up? */
1172                 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1173                 if (!parport_claim(nl->pardev))
1174                         /* bus_owner is already set (but why?) */
1175                         printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1176                 else
1177                         return;
1178         }
1179
1180         if (!(dev->flags & IFF_UP))
1181                 /* Don't need the port when the interface is down */
1182                 return;
1183
1184         if (!parport_claim(nl->pardev)) {
1185                 nl->port_owner = 1;
1186                 /* Clear the data port. */
1187                 write_data (dev, 0x00);
1188         }
1189
1190         return;
1191 }
1192
1193 static int
1194 plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1195 {
1196         struct net_local *nl = netdev_priv(dev);
1197         struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1198
1199         if (cmd != SIOCDEVPLIP)
1200                 return -EOPNOTSUPP;
1201
1202         switch(pc->pcmd) {
1203         case PLIP_GET_TIMEOUT:
1204                 pc->trigger = nl->trigger;
1205                 pc->nibble  = nl->nibble;
1206                 break;
1207         case PLIP_SET_TIMEOUT:
1208                 if(!capable(CAP_NET_ADMIN))
1209                         return -EPERM;
1210                 nl->trigger = pc->trigger;
1211                 nl->nibble  = pc->nibble;
1212                 break;
1213         default:
1214                 return -EOPNOTSUPP;
1215         }
1216         return 0;
1217 }
1218
1219 static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1220 static int timid;
1221
1222 module_param_array(parport, int, NULL, 0);
1223 module_param(timid, int, 0);
1224 MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1225
1226 static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1227
1228 static inline int
1229 plip_searchfor(int list[], int a)
1230 {
1231         int i;
1232         for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1233                 if (list[i] == a) return 1;
1234         }
1235         return 0;
1236 }
1237
1238 /* plip_attach() is called (by the parport code) when a port is
1239  * available to use. */
1240 static void plip_attach (struct parport *port)
1241 {
1242         static int unit;
1243         struct net_device *dev;
1244         struct net_local *nl;
1245         char name[IFNAMSIZ];
1246
1247         if ((parport[0] == -1 && (!timid || !port->devices)) ||
1248             plip_searchfor(parport, port->number)) {
1249                 if (unit == PLIP_MAX) {
1250                         printk(KERN_ERR "plip: too many devices\n");
1251                         return;
1252                 }
1253
1254                 sprintf(name, "plip%d", unit);
1255                 dev = alloc_etherdev(sizeof(struct net_local));
1256                 if (!dev) {
1257                         printk(KERN_ERR "plip: memory squeeze\n");
1258                         return;
1259                 }
1260
1261                 strcpy(dev->name, name);
1262
1263                 dev->irq = port->irq;
1264                 dev->base_addr = port->base;
1265                 if (port->irq == -1) {
1266                         printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1267                                  "which is fairly inefficient!\n", port->name);
1268                 }
1269
1270                 nl = netdev_priv(dev);
1271                 nl->dev = dev;
1272                 nl->pardev = parport_register_device(port, dev->name, plip_preempt,
1273                                                  plip_wakeup, plip_interrupt,
1274                                                  0, dev);
1275
1276                 if (!nl->pardev) {
1277                         printk(KERN_ERR "%s: parport_register failed\n", name);
1278                         goto err_free_dev;
1279                         return;
1280                 }
1281
1282                 plip_init_netdev(dev);
1283
1284                 if (register_netdev(dev)) {
1285                         printk(KERN_ERR "%s: network register failed\n", name);
1286                         goto err_parport_unregister;
1287                 }
1288
1289                 printk(KERN_INFO "%s", version);
1290                 if (dev->irq != -1)
1291                         printk(KERN_INFO "%s: Parallel port at %#3lx, "
1292                                          "using IRQ %d.\n",
1293                                          dev->name, dev->base_addr, dev->irq);
1294                 else
1295                         printk(KERN_INFO "%s: Parallel port at %#3lx, "
1296                                          "not using IRQ.\n",
1297                                          dev->name, dev->base_addr);
1298                 dev_plip[unit++] = dev;
1299         }
1300         return;
1301
1302 err_parport_unregister:
1303         parport_unregister_device(nl->pardev);
1304 err_free_dev:
1305         free_netdev(dev);
1306         return;
1307 }
1308
1309 /* plip_detach() is called (by the parport code) when a port is
1310  * no longer available to use. */
1311 static void plip_detach (struct parport *port)
1312 {
1313         /* Nothing to do */
1314 }
1315
1316 static struct parport_driver plip_driver = {
1317         .name   = "plip",
1318         .attach = plip_attach,
1319         .detach = plip_detach
1320 };
1321
1322 static void __exit plip_cleanup_module (void)
1323 {
1324         struct net_device *dev;
1325         int i;
1326
1327         parport_unregister_driver (&plip_driver);
1328
1329         for (i=0; i < PLIP_MAX; i++) {
1330                 if ((dev = dev_plip[i])) {
1331                         struct net_local *nl = netdev_priv(dev);
1332                         unregister_netdev(dev);
1333                         if (nl->port_owner)
1334                                 parport_release(nl->pardev);
1335                         parport_unregister_device(nl->pardev);
1336                         free_netdev(dev);
1337                         dev_plip[i] = NULL;
1338                 }
1339         }
1340 }
1341
1342 #ifndef MODULE
1343
1344 static int parport_ptr;
1345
1346 static int __init plip_setup(char *str)
1347 {
1348         int ints[4];
1349
1350         str = get_options(str, ARRAY_SIZE(ints), ints);
1351
1352         /* Ugh. */
1353         if (!strncmp(str, "parport", 7)) {
1354                 int n = simple_strtoul(str+7, NULL, 10);
1355                 if (parport_ptr < PLIP_MAX)
1356                         parport[parport_ptr++] = n;
1357                 else
1358                         printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1359                                str);
1360         } else if (!strcmp(str, "timid")) {
1361                 timid = 1;
1362         } else {
1363                 if (ints[0] == 0 || ints[1] == 0) {
1364                         /* disable driver on "plip=" or "plip=0" */
1365                         parport[0] = -2;
1366                 } else {
1367                         printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1368                                ints[1]);
1369                 }
1370         }
1371         return 1;
1372 }
1373
1374 __setup("plip=", plip_setup);
1375
1376 #endif /* !MODULE */
1377
1378 static int __init plip_init (void)
1379 {
1380         if (parport[0] == -2)
1381                 return 0;
1382
1383         if (parport[0] != -1 && timid) {
1384                 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1385                 timid = 0;
1386         }
1387
1388         if (parport_register_driver (&plip_driver)) {
1389                 printk (KERN_WARNING "plip: couldn't register driver\n");
1390                 return 1;
1391         }
1392
1393         return 0;
1394 }
1395
1396 module_init(plip_init);
1397 module_exit(plip_cleanup_module);
1398 MODULE_LICENSE("GPL");