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