drivers/net/plip/plip.c

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