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