drivers/net/plip/plip.c

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