git.oblomov.eu Git - linux-2.6/blob - 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/parport.h>
 110 #include <linux/bitops.h>
 111
 112 #include <net/neighbour.h>
 113
 114 #include <asm/system.h>
 115 #include <asm/irq.h>
 116 #include <asm/byteorder.h>
 117 #include <asm/semaphore.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 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 net_device *dev);
 142 static void plip_bh(struct net_device *dev);
 143 static void plip_timer_bh(struct net_device *dev);
 144
 145 /* Interrupt handler */
 146 static void plip_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 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, void *daddr,
 152                             void *saddr, unsigned len);
 153 static int plip_hard_header_cache(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 struct net_device_stats *plip_get_stats(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_stats enet_stats;
 210         struct work_struct immediate;
 211         struct work_struct deferred;
 212         struct work_struct 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         int (*orig_hard_header)(struct sk_buff *skb, struct net_device *dev,
 224                                 unsigned short type, void *daddr,
 225                                 void *saddr, unsigned len);
 226         int (*orig_hard_header_cache)(struct neighbour *neigh,
 227                                       struct hh_cache *hh);
 228         spinlock_t lock;
 229         atomic_t kill_timer;
 230         struct semaphore killed_timer_sem;
 231 };
 232
 233 static inline void enable_parport_interrupts (struct net_device *dev)
 234 {
 235         if (dev->irq != -1)
 236         {
 237                 struct parport *port =
 238                    ((struct net_local *)dev->priv)->pardev->port;
 239                 port->ops->enable_irq (port);
 240         }
 241 }
 242
 243 static inline void disable_parport_interrupts (struct net_device *dev)
 244 {
 245         if (dev->irq != -1)
 246         {
 247                 struct parport *port =
 248                    ((struct net_local *)dev->priv)->pardev->port;
 249                 port->ops->disable_irq (port);
 250         }
 251 }
 252
 253 static inline void write_data (struct net_device *dev, unsigned char data)
 254 {
 255         struct parport *port =
 256            ((struct net_local *)dev->priv)->pardev->port;
 257
 258         port->ops->write_data (port, data);
 259 }
 260
 261 static inline unsigned char read_status (struct net_device *dev)
 262 {
 263         struct parport *port =
 264            ((struct net_local *)dev->priv)->pardev->port;
 265
 266         return port->ops->read_status (port);
 267 }
 268
 269 /* Entry point of PLIP driver.
 270    Probe the hardware, and register/initialize the driver.
 271
 272    PLIP is rather weird, because of the way it interacts with the parport
 273    system.  It is _not_ initialised from Space.c.  Instead, plip_init()
 274    is called, and that function makes up a "struct net_device" for each port, and
 275    then calls us here.
 276
 277    */
 278 static void
 279 plip_init_netdev(struct net_device *dev)
 280 {
 281         struct net_local *nl = netdev_priv(dev);
 282
 283         /* Then, override parts of it */
 284         dev->hard_start_xmit     = plip_tx_packet;
 285         dev->open                = plip_open;
 286         dev->stop                = plip_close;
 287         dev->get_stats           = plip_get_stats;
 288         dev->do_ioctl            = plip_ioctl;
 289         dev->header_cache_update = NULL;
 290         dev->tx_queue_len        = 10;
 291         dev->flags               = IFF_POINTOPOINT|IFF_NOARP;
 292         memset(dev->dev_addr, 0xfc, ETH_ALEN);
 293
 294         /* Set the private structure */
 295         nl->orig_hard_header    = dev->hard_header;
 296         dev->hard_header        = plip_hard_header;
 297
 298         nl->orig_hard_header_cache = dev->hard_header_cache;
 299         dev->hard_header_cache     = plip_hard_header_cache;
 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, (void (*)(void *))plip_bh, dev);
 310         INIT_WORK(&nl->deferred, (void (*)(void *))plip_kick_bh, dev);
 311
 312         if (dev->irq == -1)
 313                 INIT_WORK(&nl->timer, (void (*)(void *))plip_timer_bh, dev);
 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 net_device *dev)
 323 {
 324         struct net_local *nl = netdev_priv(dev);
 325
 326         if (nl->is_deferred)
 327                 schedule_work(&nl->immediate);
 328 }
 329
 330 /* Forward declarations of internal routines */
 331 static int plip_none(struct net_device *, struct net_local *,
 332                      struct plip_local *, struct plip_local *);
 333 static int plip_receive_packet(struct net_device *, struct net_local *,
 334                                struct plip_local *, struct plip_local *);
 335 static int plip_send_packet(struct net_device *, struct net_local *,
 336                             struct plip_local *, struct plip_local *);
 337 static int plip_connection_close(struct net_device *, struct net_local *,
 338                                  struct plip_local *, struct plip_local *);
 339 static int plip_error(struct net_device *, struct net_local *,
 340                       struct plip_local *, struct plip_local *);
 341 static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
 342                                  struct plip_local *snd,
 343                                  struct plip_local *rcv,
 344                                  int error);
 345
 346 #define OK        0
 347 #define TIMEOUT   1
 348 #define ERROR     2
 349 #define HS_TIMEOUT      3
 350
 351 typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
 352                          struct plip_local *snd, struct plip_local *rcv);
 353
 354 static plip_func connection_state_table[] =
 355 {
 356         plip_none,
 357         plip_receive_packet,
 358         plip_send_packet,
 359         plip_connection_close,
 360         plip_error
 361 };
 362
 363 /* Bottom half handler of PLIP. */
 364 static void
 365 plip_bh(struct net_device *dev)
 366 {
 367         struct net_local *nl = netdev_priv(dev);
 368         struct plip_local *snd = &nl->snd_data;
 369         struct plip_local *rcv = &nl->rcv_data;
 370         plip_func f;
 371         int r;
 372
 373         nl->is_deferred = 0;
 374         f = connection_state_table[nl->connection];
 375         if ((r = (*f)(dev, nl, snd, rcv)) != OK
 376             && (r = plip_bh_timeout_error(dev, nl, snd, rcv, r)) != OK) {
 377                 nl->is_deferred = 1;
 378                 schedule_delayed_work(&nl->deferred, 1);
 379         }
 380 }
 381
 382 static void
 383 plip_timer_bh(struct net_device *dev)
 384 {
 385         struct net_local *nl = netdev_priv(dev);
 386
 387         if (!(atomic_read (&nl->kill_timer))) {
 388                 plip_interrupt (-1, dev, NULL);
 389
 390                 schedule_delayed_work(&nl->timer, 1);
 391         }
 392         else {
 393                 up (&nl->killed_timer_sem);
 394         }
 395 }
 396
 397 static int
 398 plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
 399                       struct plip_local *snd, struct plip_local *rcv,
 400                       int error)
 401 {
 402         unsigned char c0;
 403         /*
 404          * This is tricky. If we got here from the beginning of send (either
 405          * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
 406          * already disabled. With the old variant of {enable,disable}_irq()
 407          * extra disable_irq() was a no-op. Now it became mortal - it's
 408          * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
 409          * that is). So we have to treat HS_TIMEOUT and ERROR from send
 410          * in a special way.
 411          */
 412
 413         spin_lock_irq(&nl->lock);
 414         if (nl->connection == PLIP_CN_SEND) {
 415
 416                 if (error != ERROR) { /* Timeout */
 417                         nl->timeout_count++;
 418                         if ((error == HS_TIMEOUT
 419                              && nl->timeout_count <= 10)
 420                             || nl->timeout_count <= 3) {
 421                                 spin_unlock_irq(&nl->lock);
 422                                 /* Try again later */
 423                                 return TIMEOUT;
 424                         }
 425                         c0 = read_status(dev);
 426                         printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
 427                                dev->name, snd->state, c0);
 428                 } else
 429                         error = HS_TIMEOUT;
 430                 nl->enet_stats.tx_errors++;
 431                 nl->enet_stats.tx_aborted_errors++;
 432         } else if (nl->connection == PLIP_CN_RECEIVE) {
 433                 if (rcv->state == PLIP_PK_TRIGGER) {
 434                         /* Transmission was interrupted. */
 435                         spin_unlock_irq(&nl->lock);
 436                         return OK;
 437                 }
 438                 if (error != ERROR) { /* Timeout */
 439                         if (++nl->timeout_count <= 3) {
 440                                 spin_unlock_irq(&nl->lock);
 441                                 /* Try again later */
 442                                 return TIMEOUT;
 443                         }
 444                         c0 = read_status(dev);
 445                         printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
 446                                dev->name, rcv->state, c0);
 447                 }
 448                 nl->enet_stats.rx_dropped++;
 449         }
 450         rcv->state = PLIP_PK_DONE;
 451         if (rcv->skb) {
 452                 kfree_skb(rcv->skb);
 453                 rcv->skb = NULL;
 454         }
 455         snd->state = PLIP_PK_DONE;
 456         if (snd->skb) {
 457                 dev_kfree_skb(snd->skb);
 458                 snd->skb = NULL;
 459         }
 460         spin_unlock_irq(&nl->lock);
 461         if (error == HS_TIMEOUT) {
 462                 DISABLE(dev->irq);
 463                 synchronize_irq(dev->irq);
 464         }
 465         disable_parport_interrupts (dev);
 466         netif_stop_queue (dev);
 467         nl->connection = PLIP_CN_ERROR;
 468         write_data (dev, 0x00);
 469
 470         return TIMEOUT;
 471 }
 472
 473 static int
 474 plip_none(struct net_device *dev, struct net_local *nl,
 475           struct plip_local *snd, struct plip_local *rcv)
 476 {
 477         return OK;
 478 }
 479
 480 /* PLIP_RECEIVE --- receive a byte(two nibbles)
 481    Returns OK on success, TIMEOUT on timeout */
 482 static inline int
 483 plip_receive(unsigned short nibble_timeout, struct net_device *dev,
 484              enum plip_nibble_state *ns_p, unsigned char *data_p)
 485 {
 486         unsigned char c0, c1;
 487         unsigned int cx;
 488
 489         switch (*ns_p) {
 490         case PLIP_NB_BEGIN:
 491                 cx = nibble_timeout;
 492                 while (1) {
 493                         c0 = read_status(dev);
 494                         udelay(PLIP_DELAY_UNIT);
 495                         if ((c0 & 0x80) == 0) {
 496                                 c1 = read_status(dev);
 497                                 if (c0 == c1)
 498                                         break;
 499                         }
 500                         if (--cx == 0)
 501                                 return TIMEOUT;
 502                 }
 503                 *data_p = (c0 >> 3) & 0x0f;
 504                 write_data (dev, 0x10); /* send ACK */
 505                 *ns_p = PLIP_NB_1;
 506
 507         case PLIP_NB_1:
 508                 cx = nibble_timeout;
 509                 while (1) {
 510                         c0 = read_status(dev);
 511                         udelay(PLIP_DELAY_UNIT);
 512                         if (c0 & 0x80) {
 513                                 c1 = read_status(dev);
 514                                 if (c0 == c1)
 515                                         break;
 516                         }
 517                         if (--cx == 0)
 518                                 return TIMEOUT;
 519                 }
 520                 *data_p |= (c0 << 1) & 0xf0;
 521                 write_data (dev, 0x00); /* send ACK */
 522                 *ns_p = PLIP_NB_BEGIN;
 523         case PLIP_NB_2:
 524                 break;
 525         }
 526         return OK;
 527 }
 528
 529 /*
 530  *      Determine the packet's protocol ID. The rule here is that we
 531  *      assume 802.3 if the type field is short enough to be a length.
 532  *      This is normal practice and works for any 'now in use' protocol.
 533  *
 534  *      PLIP is ethernet ish but the daddr might not be valid if unicast.
 535  *      PLIP fortunately has no bus architecture (its Point-to-point).
 536  *
 537  *      We can't fix the daddr thing as that quirk (more bug) is embedded
 538  *      in far too many old systems not all even running Linux.
 539  */
 540
 541 static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
 542 {
 543         struct ethhdr *eth;
 544         unsigned char *rawp;
 545
 546         skb->mac.raw=skb->data;
 547         skb_pull(skb,dev->hard_header_len);
 548         eth = eth_hdr(skb);
 549
 550         if(*eth->h_dest&1)
 551         {
 552                 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
 553                         skb->pkt_type=PACKET_BROADCAST;
 554                 else
 555                         skb->pkt_type=PACKET_MULTICAST;
 556         }
 557
 558         /*
 559          *      This ALLMULTI check should be redundant by 1.4
 560          *      so don't forget to remove it.
 561          */
 562
 563         if (ntohs(eth->h_proto) >= 1536)
 564                 return eth->h_proto;
 565
 566         rawp = skb->data;
 567
 568         /*
 569          *      This is a magic hack to spot IPX packets. Older Novell breaks
 570          *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
 571          *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
 572          *      won't work for fault tolerant netware but does for the rest.
 573          */
 574         if (*(unsigned short *)rawp == 0xFFFF)
 575                 return htons(ETH_P_802_3);
 576
 577         /*
 578          *      Real 802.2 LLC
 579          */
 580         return htons(ETH_P_802_2);
 581 }
 582
 583 /* PLIP_RECEIVE_PACKET --- receive a packet */
 584 static int
 585 plip_receive_packet(struct net_device *dev, struct net_local *nl,
 586                     struct plip_local *snd, struct plip_local *rcv)
 587 {
 588         unsigned short nibble_timeout = nl->nibble;
 589         unsigned char *lbuf;
 590
 591         switch (rcv->state) {
 592         case PLIP_PK_TRIGGER:
 593                 DISABLE(dev->irq);
 594                 /* Don't need to synchronize irq, as we can safely ignore it */
 595                 disable_parport_interrupts (dev);
 596                 write_data (dev, 0x01); /* send ACK */
 597                 if (net_debug > 2)
 598                         printk(KERN_DEBUG "%s: receive start\n", dev->name);
 599                 rcv->state = PLIP_PK_LENGTH_LSB;
 600                 rcv->nibble = PLIP_NB_BEGIN;
 601
 602         case PLIP_PK_LENGTH_LSB:
 603                 if (snd->state != PLIP_PK_DONE) {
 604                         if (plip_receive(nl->trigger, dev,
 605                                          &rcv->nibble, &rcv->length.b.lsb)) {
 606                                 /* collision, here dev->tbusy == 1 */
 607                                 rcv->state = PLIP_PK_DONE;
 608                                 nl->is_deferred = 1;
 609                                 nl->connection = PLIP_CN_SEND;
 610                                 schedule_delayed_work(&nl->deferred, 1);
 611                                 enable_parport_interrupts (dev);
 612                                 ENABLE(dev->irq);
 613                                 return OK;
 614                         }
 615                 } else {
 616                         if (plip_receive(nibble_timeout, dev,
 617                                          &rcv->nibble, &rcv->length.b.lsb))
 618                                 return TIMEOUT;
 619                 }
 620                 rcv->state = PLIP_PK_LENGTH_MSB;
 621
 622         case PLIP_PK_LENGTH_MSB:
 623                 if (plip_receive(nibble_timeout, dev,
 624                                  &rcv->nibble, &rcv->length.b.msb))
 625                         return TIMEOUT;
 626                 if (rcv->length.h > dev->mtu + dev->hard_header_len
 627                     || rcv->length.h < 8) {
 628                         printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
 629                         return ERROR;
 630                 }
 631                 /* Malloc up new buffer. */
 632                 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
 633                 if (rcv->skb == NULL) {
 634                         printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
 635                         return ERROR;
 636                 }
 637                 skb_reserve(rcv->skb, 2);       /* Align IP on 16 byte boundaries */
 638                 skb_put(rcv->skb,rcv->length.h);
 639                 rcv->skb->dev = dev;
 640                 rcv->state = PLIP_PK_DATA;
 641                 rcv->byte = 0;
 642                 rcv->checksum = 0;
 643
 644         case PLIP_PK_DATA:
 645                 lbuf = rcv->skb->data;
 646                 do
 647                         if (plip_receive(nibble_timeout, dev,
 648                                          &rcv->nibble, &lbuf[rcv->byte]))
 649                                 return TIMEOUT;
 650                 while (++rcv->byte < rcv->length.h);
 651                 do
 652                         rcv->checksum += lbuf[--rcv->byte];
 653                 while (rcv->byte);
 654                 rcv->state = PLIP_PK_CHECKSUM;
 655
 656         case PLIP_PK_CHECKSUM:
 657                 if (plip_receive(nibble_timeout, dev,
 658                                  &rcv->nibble, &rcv->data))
 659                         return TIMEOUT;
 660                 if (rcv->data != rcv->checksum) {
 661                         nl->enet_stats.rx_crc_errors++;
 662                         if (net_debug)
 663                                 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
 664                         return ERROR;
 665                 }
 666                 rcv->state = PLIP_PK_DONE;
 667
 668         case PLIP_PK_DONE:
 669                 /* Inform the upper layer for the arrival of a packet. */
 670                 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
 671                 netif_rx(rcv->skb);
 672                 dev->last_rx = jiffies;
 673                 nl->enet_stats.rx_bytes += rcv->length.h;
 674                 nl->enet_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                                 nl->enet_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                                         nl->enet_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                 nl->enet_stats.tx_bytes += snd->skb->len;
 841                 dev_kfree_skb(snd->skb);
 842                 nl->enet_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(int irq, void *dev_id, struct pt_regs * regs)
 906 {
 907         struct net_device *dev = dev_id;
 908         struct net_local *nl;
 909         struct plip_local *rcv;
 910         unsigned char c0;
 911
 912         if (dev == NULL) {
 913                 printk(KERN_DEBUG "plip_interrupt: irq %d for unknown device.\n", irq);
 914                 return;
 915         }
 916
 917         nl = netdev_priv(dev);
 918         rcv = &nl->rcv_data;
 919
 920         spin_lock_irq (&nl->lock);
 921
 922         c0 = read_status(dev);
 923         if ((c0 & 0xf8) != 0xc0) {
 924                 if ((dev->irq != -1) && (net_debug > 1))
 925                         printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
 926                 spin_unlock_irq (&nl->lock);
 927                 return;
 928         }
 929
 930         if (net_debug > 3)
 931                 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
 932
 933         switch (nl->connection) {
 934         case PLIP_CN_CLOSING:
 935                 netif_wake_queue (dev);
 936         case PLIP_CN_NONE:
 937         case PLIP_CN_SEND:
 938                 rcv->state = PLIP_PK_TRIGGER;
 939                 nl->connection = PLIP_CN_RECEIVE;
 940                 nl->timeout_count = 0;
 941                 schedule_work(&nl->immediate);
 942                 break;
 943
 944         case PLIP_CN_RECEIVE:
 945                 /* May occur because there is race condition
 946                    around test and set of dev->interrupt.
 947                    Ignore this interrupt. */
 948                 break;
 949
 950         case PLIP_CN_ERROR:
 951                 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
 952                 break;
 953         }
 954
 955         spin_unlock_irq(&nl->lock);
 956 }
 957
 958 static int
 959 plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
 960 {
 961         struct net_local *nl = netdev_priv(dev);
 962         struct plip_local *snd = &nl->snd_data;
 963
 964         if (netif_queue_stopped(dev))
 965                 return 1;
 966
 967         /* We may need to grab the bus */
 968         if (!nl->port_owner) {
 969                 if (parport_claim(nl->pardev))
 970                         return 1;
 971                 nl->port_owner = 1;
 972         }
 973
 974         netif_stop_queue (dev);
 975
 976         if (skb->len > dev->mtu + dev->hard_header_len) {
 977                 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
 978                 netif_start_queue (dev);
 979                 return 1;
 980         }
 981
 982         if (net_debug > 2)
 983                 printk(KERN_DEBUG "%s: send request\n", dev->name);
 984
 985         spin_lock_irq(&nl->lock);
 986         dev->trans_start = jiffies;
 987         snd->skb = skb;
 988         snd->length.h = skb->len;
 989         snd->state = PLIP_PK_TRIGGER;
 990         if (nl->connection == PLIP_CN_NONE) {
 991                 nl->connection = PLIP_CN_SEND;
 992                 nl->timeout_count = 0;
 993         }
 994         schedule_work(&nl->immediate);
 995         spin_unlock_irq(&nl->lock);
 996
 997         return 0;
 998 }
 999
1000 static void
1001 plip_rewrite_address(struct net_device *dev, struct ethhdr *eth)
1002 {
1003         struct in_device *in_dev;
1004
1005         if ((in_dev=dev->ip_ptr) != NULL) {
1006                 /* Any address will do - we take the first */
1007                 struct in_ifaddr *ifa=in_dev->ifa_list;
1008                 if (ifa != NULL) {
1009                         memcpy(eth->h_source, dev->dev_addr, 6);
1010                         memset(eth->h_dest, 0xfc, 2);
1011                         memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1012                 }
1013         }
1014 }
1015
1016 static int
1017 plip_hard_header(struct sk_buff *skb, struct net_device *dev,
1018                  unsigned short type, void *daddr,
1019                  void *saddr, unsigned len)
1020 {
1021         struct net_local *nl = netdev_priv(dev);
1022         int ret;
1023
1024         if ((ret = nl->orig_hard_header(skb, dev, type, daddr, saddr, len)) >= 0)
1025                 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1026
1027         return ret;
1028 }
1029
1030 int plip_hard_header_cache(struct neighbour *neigh,
1031                            struct hh_cache *hh)
1032 {
1033         struct net_local *nl = neigh->dev->priv;
1034         int ret;
1035
1036         if ((ret = nl->orig_hard_header_cache(neigh, hh)) == 0)
1037         {
1038                 struct ethhdr *eth;
1039
1040                 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1041                                        HH_DATA_OFF(sizeof(*eth)));
1042                 plip_rewrite_address (neigh->dev, eth);
1043         }
1044
1045         return ret;
1046 }
1047
1048 /* Open/initialize the board.  This is called (in the current kernel)
1049    sometime after booting when the 'ifconfig' program is run.
1050
1051    This routine gets exclusive access to the parallel port by allocating
1052    its IRQ line.
1053  */
1054 static int
1055 plip_open(struct net_device *dev)
1056 {
1057         struct net_local *nl = netdev_priv(dev);
1058         struct in_device *in_dev;
1059
1060         /* Grab the port */
1061         if (!nl->port_owner) {
1062                 if (parport_claim(nl->pardev)) return -EAGAIN;
1063                 nl->port_owner = 1;
1064         }
1065
1066         nl->should_relinquish = 0;
1067
1068         /* Clear the data port. */
1069         write_data (dev, 0x00);
1070
1071         /* Enable rx interrupt. */
1072         enable_parport_interrupts (dev);
1073         if (dev->irq == -1)
1074         {
1075                 atomic_set (&nl->kill_timer, 0);
1076                 schedule_delayed_work(&nl->timer, 1);
1077         }
1078
1079         /* Initialize the state machine. */
1080         nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1081         nl->rcv_data.skb = nl->snd_data.skb = NULL;
1082         nl->connection = PLIP_CN_NONE;
1083         nl->is_deferred = 0;
1084
1085         /* Fill in the MAC-level header.
1086            We used to abuse dev->broadcast to store the point-to-point
1087            MAC address, but we no longer do it. Instead, we fetch the
1088            interface address whenever it is needed, which is cheap enough
1089            because we use the hh_cache. Actually, abusing dev->broadcast
1090            didn't work, because when using plip_open the point-to-point
1091            address isn't yet known.
1092            PLIP doesn't have a real MAC address, but we need it to be
1093            DOS compatible, and to properly support taps (otherwise,
1094            when the device address isn't identical to the address of a
1095            received frame, the kernel incorrectly drops it).             */
1096
1097         if ((in_dev=dev->ip_ptr) != NULL) {
1098                 /* Any address will do - we take the first. We already
1099                    have the first two bytes filled with 0xfc, from
1100                    plip_init_dev(). */
1101                 struct in_ifaddr *ifa=in_dev->ifa_list;
1102                 if (ifa != NULL) {
1103                         memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1104                 }
1105         }
1106
1107         netif_start_queue (dev);
1108
1109         return 0;
1110 }
1111
1112 /* The inverse routine to plip_open (). */
1113 static int
1114 plip_close(struct net_device *dev)
1115 {
1116         struct net_local *nl = netdev_priv(dev);
1117         struct plip_local *snd = &nl->snd_data;
1118         struct plip_local *rcv = &nl->rcv_data;
1119
1120         netif_stop_queue (dev);
1121         DISABLE(dev->irq);
1122         synchronize_irq(dev->irq);
1123
1124         if (dev->irq == -1)
1125         {
1126                 init_MUTEX_LOCKED (&nl->killed_timer_sem);
1127                 atomic_set (&nl->kill_timer, 1);
1128                 down (&nl->killed_timer_sem);
1129         }
1130
1131 #ifdef NOTDEF
1132         outb(0x00, PAR_DATA(dev));
1133 #endif
1134         nl->is_deferred = 0;
1135         nl->connection = PLIP_CN_NONE;
1136         if (nl->port_owner) {
1137                 parport_release(nl->pardev);
1138                 nl->port_owner = 0;
1139         }
1140
1141         snd->state = PLIP_PK_DONE;
1142         if (snd->skb) {
1143                 dev_kfree_skb(snd->skb);
1144                 snd->skb = NULL;
1145         }
1146         rcv->state = PLIP_PK_DONE;
1147         if (rcv->skb) {
1148                 kfree_skb(rcv->skb);
1149                 rcv->skb = NULL;
1150         }
1151
1152 #ifdef NOTDEF
1153         /* Reset. */
1154         outb(0x00, PAR_CONTROL(dev));
1155 #endif
1156         return 0;
1157 }
1158
1159 static int
1160 plip_preempt(void *handle)
1161 {
1162         struct net_device *dev = (struct net_device *)handle;
1163         struct net_local *nl = netdev_priv(dev);
1164
1165         /* Stand our ground if a datagram is on the wire */
1166         if (nl->connection != PLIP_CN_NONE) {
1167                 nl->should_relinquish = 1;
1168                 return 1;
1169         }
1170
1171         nl->port_owner = 0;     /* Remember that we released the bus */
1172         return 0;
1173 }
1174
1175 static void
1176 plip_wakeup(void *handle)
1177 {
1178         struct net_device *dev = (struct net_device *)handle;
1179         struct net_local *nl = netdev_priv(dev);
1180
1181         if (nl->port_owner) {
1182                 /* Why are we being woken up? */
1183                 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1184                 if (!parport_claim(nl->pardev))
1185                         /* bus_owner is already set (but why?) */
1186                         printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1187                 else
1188                         return;
1189         }
1190
1191         if (!(dev->flags & IFF_UP))
1192                 /* Don't need the port when the interface is down */
1193                 return;
1194
1195         if (!parport_claim(nl->pardev)) {
1196                 nl->port_owner = 1;
1197                 /* Clear the data port. */
1198                 write_data (dev, 0x00);
1199         }
1200
1201         return;
1202 }
1203
1204 static struct net_device_stats *
1205 plip_get_stats(struct net_device *dev)
1206 {
1207         struct net_local *nl = netdev_priv(dev);
1208         struct net_device_stats *r = &nl->enet_stats;
1209
1210         return r;
1211 }
1212
1213 static int
1214 plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1215 {
1216         struct net_local *nl = netdev_priv(dev);
1217         struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1218
1219         if (cmd != SIOCDEVPLIP)
1220                 return -EOPNOTSUPP;
1221
1222         switch(pc->pcmd) {
1223         case PLIP_GET_TIMEOUT:
1224                 pc->trigger = nl->trigger;
1225                 pc->nibble  = nl->nibble;
1226                 break;
1227         case PLIP_SET_TIMEOUT:
1228                 if(!capable(CAP_NET_ADMIN))
1229                         return -EPERM;
1230                 nl->trigger = pc->trigger;
1231                 nl->nibble  = pc->nibble;
1232                 break;
1233         default:
1234                 return -EOPNOTSUPP;
1235         }
1236         return 0;
1237 }
1238
1239 static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1240 static int timid;
1241
1242 module_param_array(parport, int, NULL, 0);
1243 module_param(timid, int, 0);
1244 MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1245
1246 static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1247
1248 static inline int
1249 plip_searchfor(int list[], int a)
1250 {
1251         int i;
1252         for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1253                 if (list[i] == a) return 1;
1254         }
1255         return 0;
1256 }
1257
1258 /* plip_attach() is called (by the parport code) when a port is
1259  * available to use. */
1260 static void plip_attach (struct parport *port)
1261 {
1262         static int unit;
1263         struct net_device *dev;
1264         struct net_local *nl;
1265         char name[IFNAMSIZ];
1266
1267         if ((parport[0] == -1 && (!timid || !port->devices)) ||
1268             plip_searchfor(parport, port->number)) {
1269                 if (unit == PLIP_MAX) {
1270                         printk(KERN_ERR "plip: too many devices\n");
1271                         return;
1272                 }
1273
1274                 sprintf(name, "plip%d", unit);
1275                 dev = alloc_etherdev(sizeof(struct net_local));
1276                 if (!dev) {
1277                         printk(KERN_ERR "plip: memory squeeze\n");
1278                         return;
1279                 }
1280
1281                 strcpy(dev->name, name);
1282
1283                 SET_MODULE_OWNER(dev);
1284                 dev->irq = port->irq;
1285                 dev->base_addr = port->base;
1286                 if (port->irq == -1) {
1287                         printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1288                                  "which is fairly inefficient!\n", port->name);
1289                 }
1290
1291                 nl = netdev_priv(dev);
1292                 nl->pardev = parport_register_device(port, name, plip_preempt,
1293                                                  plip_wakeup, plip_interrupt,
1294                                                  0, dev);
1295
1296                 if (!nl->pardev) {
1297                         printk(KERN_ERR "%s: parport_register failed\n", name);
1298                         goto err_free_dev;
1299                         return;
1300                 }
1301
1302                 plip_init_netdev(dev);
1303
1304                 if (register_netdev(dev)) {
1305                         printk(KERN_ERR "%s: network register failed\n", name);
1306                         goto err_parport_unregister;
1307                 }
1308
1309                 printk(KERN_INFO "%s", version);
1310                 if (dev->irq != -1)
1311                         printk(KERN_INFO "%s: Parallel port at %#3lx, "
1312                                          "using IRQ %d.\n",
1313                                          dev->name, dev->base_addr, dev->irq);
1314                 else
1315                         printk(KERN_INFO "%s: Parallel port at %#3lx, "
1316                                          "not using IRQ.\n",
1317                                          dev->name, dev->base_addr);
1318                 dev_plip[unit++] = dev;
1319         }
1320         return;
1321
1322 err_parport_unregister:
1323         parport_unregister_device(nl->pardev);
1324 err_free_dev:
1325         free_netdev(dev);
1326         return;
1327 }
1328
1329 /* plip_detach() is called (by the parport code) when a port is
1330  * no longer available to use. */
1331 static void plip_detach (struct parport *port)
1332 {
1333         /* Nothing to do */
1334 }
1335
1336 static struct parport_driver plip_driver = {
1337         .name   = "plip",
1338         .attach = plip_attach,
1339         .detach = plip_detach
1340 };
1341
1342 static void __exit plip_cleanup_module (void)
1343 {
1344         struct net_device *dev;
1345         int i;
1346
1347         parport_unregister_driver (&plip_driver);
1348
1349         for (i=0; i < PLIP_MAX; i++) {
1350                 if ((dev = dev_plip[i])) {
1351                         struct net_local *nl = netdev_priv(dev);
1352                         unregister_netdev(dev);
1353                         if (nl->port_owner)
1354                                 parport_release(nl->pardev);
1355                         parport_unregister_device(nl->pardev);
1356                         free_netdev(dev);
1357                         dev_plip[i] = NULL;
1358                 }
1359         }
1360 }
1361
1362 #ifndef MODULE
1363
1364 static int parport_ptr;
1365
1366 static int __init plip_setup(char *str)
1367 {
1368         int ints[4];
1369
1370         str = get_options(str, ARRAY_SIZE(ints), ints);
1371
1372         /* Ugh. */
1373         if (!strncmp(str, "parport", 7)) {
1374                 int n = simple_strtoul(str+7, NULL, 10);
1375                 if (parport_ptr < PLIP_MAX)
1376                         parport[parport_ptr++] = n;
1377                 else
1378                         printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1379                                str);
1380         } else if (!strcmp(str, "timid")) {
1381                 timid = 1;
1382         } else {
1383                 if (ints[0] == 0 || ints[1] == 0) {
1384                         /* disable driver on "plip=" or "plip=0" */
1385                         parport[0] = -2;
1386                 } else {
1387                         printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1388                                ints[1]);
1389                 }
1390         }
1391         return 1;
1392 }
1393
1394 __setup("plip=", plip_setup);
1395
1396 #endif /* !MODULE */
1397
1398 static int __init plip_init (void)
1399 {
1400         if (parport[0] == -2)
1401                 return 0;
1402
1403         if (parport[0] != -1 && timid) {
1404                 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1405                 timid = 0;
1406         }
1407
1408         if (parport_register_driver (&plip_driver)) {
1409                 printk (KERN_WARNING "plip: couldn't register driver\n");
1410                 return 1;
1411         }
1412
1413         return 0;
1414 }
1415
1416 module_init(plip_init);
1417 module_exit(plip_cleanup_module);
1418 MODULE_LICENSE("GPL");
1419
1420 /*
1421  * Local variables:
1422  * compile-command: "gcc -DMODULE -DMODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -c plip.c"
1423  * End:
1424  */