drivers/net/de620.c

   1 /*
   2  *      de620.c $Revision: 1.40 $ BETA
   3  *
   4  *
   5  *      Linux driver for the D-Link DE-620 Ethernet pocket adapter.
   6  *
   7  *      Portions (C) Copyright 1993, 1994 by Bjorn Ekwall <bj0rn@blox.se>
   8  *
   9  *      Based on adapter information gathered from DOS packetdriver
  10  *      sources from D-Link Inc:  (Special thanks to Henry Ngai of D-Link.)
  11  *              Portions (C) Copyright D-Link SYSTEM Inc. 1991, 1992
  12  *              Copyright, 1988, Russell Nelson, Crynwr Software
  13  *
  14  *      Adapted to the sample network driver core for linux,
  15  *      written by: Donald Becker <becker@super.org>
  16  *              (Now at <becker@cesdis.gsfc.nasa.gov>
  17  *
  18  *      Valuable assistance from:
  19  *              J. Joshua Kopper <kopper@rtsg.mot.com>
  20  *              Olav Kvittem <Olav.Kvittem@uninett.no>
  21  *              Germano Caronni <caronni@nessie.cs.id.ethz.ch>
  22  *              Jeremy Fitzhardinge <jeremy@suite.sw.oz.au>
  23  *
  24  *****************************************************************************/
  25 /*
  26  *      This program is free software; you can redistribute it and/or modify
  27  *      it under the terms of the GNU General Public License as published by
  28  *      the Free Software Foundation; either version 2, or (at your option)
  29  *      any later version.
  30  *
  31  *      This program is distributed in the hope that it will be useful,
  32  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  33  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34  *      GNU General Public License for more details.
  35  *
  36  *      You should have received a copy of the GNU General Public License
  37  *      along with this program; if not, write to the Free Software
  38  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  39  *
  40  *****************************************************************************/
  41 static const char *version =
  42         "de620.c: $Revision: 1.40 $,  Bjorn Ekwall <bj0rn@blox.se>\n";
  43 \f
  44 /***********************************************************************
  45  *
  46  * "Tuning" section.
  47  *
  48  * Compile-time options: (see below for descriptions)
  49  * -DDE620_IO=0x378     (lpt1)
  50  * -DDE620_IRQ=7        (lpt1)
  51  * -DDE602_DEBUG=...
  52  * -DSHUTDOWN_WHEN_LOST
  53  * -DCOUNT_LOOPS
  54  * -DLOWSPEED
  55  * -DREAD_DELAY
  56  * -DWRITE_DELAY
  57  */
  58
  59 /*
  60  * This driver assumes that the printer port is a "normal",
  61  * dumb, uni-directional port!
  62  * If your port is "fancy" in any way, please try to set it to "normal"
  63  * with your BIOS setup.  I have no access to machines with bi-directional
  64  * ports, so I can't test such a driver :-(
  65  * (Yes, I _know_ it is possible to use DE620 with bidirectional ports...)
  66  *
  67  * There are some clones of DE620 out there, with different names.
  68  * If the current driver does not recognize a clone, try to change
  69  * the following #define to:
  70  *
  71  * #define DE620_CLONE 1
  72  */
  73 #define DE620_CLONE 0
  74
  75 /*
  76  * If the adapter has problems with high speeds, enable this #define
  77  * otherwise full printerport speed will be attempted.
  78  *
  79  * You can tune the READ_DELAY/WRITE_DELAY below if you enable LOWSPEED
  80  *
  81 #define LOWSPEED
  82  */
  83
  84 #ifndef READ_DELAY
  85 #define READ_DELAY 100  /* adapter internal read delay in 100ns units */
  86 #endif
  87
  88 #ifndef WRITE_DELAY
  89 #define WRITE_DELAY 100 /* adapter internal write delay in 100ns units */
  90 #endif
  91
  92 /*
  93  * Enable this #define if you want the adapter to do a "ifconfig down" on
  94  * itself when we have detected that something is possibly wrong with it.
  95  * The default behaviour is to retry with "adapter_init()" until success.
  96  * This should be used for debugging purposes only.
  97  *
  98 #define SHUTDOWN_WHEN_LOST
  99  */
 100
 101 /*
 102  * Enable debugging by "-DDE620_DEBUG=3" when compiling,
 103  * OR by enabling the following #define
 104  *
 105  * use 0 for production, 1 for verification, >2 for debug
 106  *
 107 #define DE620_DEBUG 3
 108  */
 109
 110 #ifdef LOWSPEED
 111 /*
 112  * Enable this #define if you want to see debugging output that show how long
 113  * we have to wait before the DE-620 is ready for the next read/write/command.
 114  *
 115 #define COUNT_LOOPS
 116  */
 117 #endif
 118 \f
 119 #include <linux/module.h>
 120
 121 #include <linux/kernel.h>
 122 #include <linux/sched.h>
 123 #include <linux/types.h>
 124 #include <linux/fcntl.h>
 125 #include <linux/string.h>
 126 #include <linux/interrupt.h>
 127 #include <linux/ioport.h>
 128 #include <asm/io.h>
 129 #include <linux/in.h>
 130 #include <linux/ptrace.h>
 131 #include <asm/system.h>
 132 #include <linux/errno.h>
 133 #include <linux/init.h>
 134
 135 #include <linux/inet.h>
 136 #include <linux/netdevice.h>
 137 #include <linux/etherdevice.h>
 138 #include <linux/skbuff.h>
 139
 140 /* Constant definitions for the DE-620 registers, commands and bits */
 141 #include "de620.h"
 142
 143 typedef unsigned char byte;
 144
 145 /*******************************************************
 146  *                                                     *
 147  * Definition of D-Link DE-620 Ethernet Pocket adapter *
 148  * See also "de620.h"                                  *
 149  *                                                     *
 150  *******************************************************/
 151 #ifndef DE620_IO /* Compile-time configurable */
 152 #define DE620_IO 0x378
 153 #endif
 154
 155 #ifndef DE620_IRQ /* Compile-time configurable */
 156 #define DE620_IRQ       7
 157 #endif
 158
 159 #define DATA_PORT       (dev->base_addr)
 160 #define STATUS_PORT     (dev->base_addr + 1)
 161 #define COMMAND_PORT    (dev->base_addr + 2)
 162
 163 #define RUNT 60         /* Too small Ethernet packet */
 164 #define GIANT 1514      /* largest legal size packet, no fcs */
 165
 166 #ifdef DE620_DEBUG /* Compile-time configurable */
 167 #define PRINTK(x) if (de620_debug >= 2) printk x
 168 #else
 169 #define DE620_DEBUG 0
 170 #define PRINTK(x) /**/
 171 #endif
 172
 173
 174 /*
 175  * Force media with insmod:
 176  *      insmod de620.o bnc=1
 177  * or
 178  *      insmod de620.o utp=1
 179  *
 180  * Force io and/or irq with insmod:
 181  *      insmod de620.o io=0x378 irq=7
 182  *
 183  * Make a clone skip the Ethernet-address range check:
 184  *      insmod de620.o clone=1
 185  */
 186 static int bnc = 0;
 187 static int utp = 0;
 188 static int io  = DE620_IO;
 189 static int irq = DE620_IRQ;
 190 static int clone = DE620_CLONE;
 191
 192 static unsigned int de620_debug = DE620_DEBUG;
 193
 194 MODULE_PARM(bnc, "i");
 195 MODULE_PARM(utp, "i");
 196 MODULE_PARM(io, "i");
 197 MODULE_PARM(irq, "i");
 198 MODULE_PARM(clone, "i");
 199 MODULE_PARM(de620_debug, "i");
 200
 201 /***********************************************
 202  *                                             *
 203  * Index to functions, as function prototypes. *
 204  *                                             *
 205  ***********************************************/
 206
 207 /*
 208  * Routines used internally. (See also "convenience macros.. below")
 209  */
 210
 211 /* Put in the device structure. */
 212 static int      de620_open(struct net_device *);
 213 static int      de620_close(struct net_device *);
 214 static struct   net_device_stats *get_stats(struct net_device *);
 215 static void     de620_set_multicast_list(struct net_device *);
 216 static int      de620_start_xmit(struct sk_buff *, struct net_device *);
 217
 218 /* Dispatch from interrupts. */
 219 static void     de620_interrupt(int, void *, struct pt_regs *);
 220 static int      de620_rx_intr(struct net_device *);
 221
 222 /* Initialization */
 223 static int      adapter_init(struct net_device *);
 224 int             de620_probe(struct net_device *);
 225 static int      read_eeprom(struct net_device *);
 226
 227
 228 /*
 229  * D-Link driver variables:
 230  */
 231 #define SCR_DEF NIBBLEMODE |INTON | SLEEP | AUTOTX
 232 #define TCR_DEF RXPB                    /* not used: | TXSUCINT | T16INT */
 233 #define DE620_RX_START_PAGE 12          /* 12 pages (=3k) reserved for tx */
 234 #define DEF_NIC_CMD IRQEN | ICEN | DS1
 235
 236 static volatile byte    NIC_Cmd;
 237 static volatile byte    next_rx_page;
 238 static byte             first_rx_page;
 239 static byte             last_rx_page;
 240 static byte             EIPRegister;
 241
 242 static struct nic {
 243         byte    NodeID[6];
 244         byte    RAM_Size;
 245         byte    Model;
 246         byte    Media;
 247         byte    SCR;
 248 } nic_data;
 249 \f
 250 /**********************************************************
 251  *                                                        *
 252  * Convenience macros/functions for D-Link DE-620 adapter *
 253  *                                                        *
 254  **********************************************************/
 255 #define de620_tx_buffs(dd) (inb(STATUS_PORT) & (TXBF0 | TXBF1))
 256 #define de620_flip_ds(dd) NIC_Cmd ^= DS0 | DS1; outb(NIC_Cmd, COMMAND_PORT);
 257
 258 /* Check for ready-status, and return a nibble (high 4 bits) for data input */
 259 #ifdef COUNT_LOOPS
 260 static int tot_cnt;
 261 #endif
 262 static inline byte
 263 de620_ready(struct net_device *dev)
 264 {
 265         byte value;
 266         register short int cnt = 0;
 267
 268         while ((((value = inb(STATUS_PORT)) & READY) == 0) && (cnt <= 1000))
 269                 ++cnt;
 270
 271 #ifdef COUNT_LOOPS
 272         tot_cnt += cnt;
 273 #endif
 274         return value & 0xf0; /* nibble */
 275 }
 276
 277 static inline void
 278 de620_send_command(struct net_device *dev, byte cmd)
 279 {
 280         de620_ready(dev);
 281         if (cmd == W_DUMMY)
 282                 outb(NIC_Cmd, COMMAND_PORT);
 283
 284         outb(cmd, DATA_PORT);
 285
 286         outb(NIC_Cmd ^ CS0, COMMAND_PORT);
 287         de620_ready(dev);
 288         outb(NIC_Cmd, COMMAND_PORT);
 289 }
 290
 291 static inline void
 292 de620_put_byte(struct net_device *dev, byte value)
 293 {
 294         /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
 295         de620_ready(dev);
 296         outb(value, DATA_PORT);
 297         de620_flip_ds(dev);
 298 }
 299
 300 static inline byte
 301 de620_read_byte(struct net_device *dev)
 302 {
 303         byte value;
 304
 305         /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
 306         value = de620_ready(dev); /* High nibble */
 307         de620_flip_ds(dev);
 308         value |= de620_ready(dev) >> 4; /* Low nibble */
 309         return value;
 310 }
 311
 312 static inline void
 313 de620_write_block(struct net_device *dev, byte *buffer, int count)
 314 {
 315 #ifndef LOWSPEED
 316         byte uflip = NIC_Cmd ^ (DS0 | DS1);
 317         byte dflip = NIC_Cmd;
 318 #else /* LOWSPEED */
 319 #ifdef COUNT_LOOPS
 320         int bytes = count;
 321 #endif /* COUNT_LOOPS */
 322 #endif /* LOWSPEED */
 323
 324 #ifdef LOWSPEED
 325 #ifdef COUNT_LOOPS
 326         tot_cnt = 0;
 327 #endif /* COUNT_LOOPS */
 328         /* No further optimization useful, the limit is in the adapter. */
 329         for ( ; count > 0; --count, ++buffer) {
 330                 de620_put_byte(dev,*buffer);
 331         }
 332         de620_send_command(dev,W_DUMMY);
 333 #ifdef COUNT_LOOPS
 334         /* trial debug output: loops per byte in de620_ready() */
 335         printk("WRITE(%d)\n", tot_cnt/((bytes?bytes:1)));
 336 #endif /* COUNT_LOOPS */
 337 #else /* not LOWSPEED */
 338         for ( ; count > 0; count -=2) {
 339                 outb(*buffer++, DATA_PORT);
 340                 outb(uflip, COMMAND_PORT);
 341                 outb(*buffer++, DATA_PORT);
 342                 outb(dflip, COMMAND_PORT);
 343         }
 344         de620_send_command(dev,W_DUMMY);
 345 #endif /* LOWSPEED */
 346 }
 347
 348 static inline void
 349 de620_read_block(struct net_device *dev, byte *data, int count)
 350 {
 351 #ifndef LOWSPEED
 352         byte value;
 353         byte uflip = NIC_Cmd ^ (DS0 | DS1);
 354         byte dflip = NIC_Cmd;
 355 #else /* LOWSPEED */
 356 #ifdef COUNT_LOOPS
 357         int bytes = count;
 358
 359         tot_cnt = 0;
 360 #endif /* COUNT_LOOPS */
 361 #endif /* LOWSPEED */
 362
 363 #ifdef LOWSPEED
 364         /* No further optimization useful, the limit is in the adapter. */
 365         while (count-- > 0) {
 366                 *data++ = de620_read_byte(dev);
 367                 de620_flip_ds(dev);
 368         }
 369 #ifdef COUNT_LOOPS
 370         /* trial debug output: loops per byte in de620_ready() */
 371         printk("READ(%d)\n", tot_cnt/(2*(bytes?bytes:1)));
 372 #endif /* COUNT_LOOPS */
 373 #else /* not LOWSPEED */
 374         while (count-- > 0) {
 375                 value = inb(STATUS_PORT) & 0xf0; /* High nibble */
 376                 outb(uflip, COMMAND_PORT);
 377                 *data++ = value | inb(STATUS_PORT) >> 4; /* Low nibble */
 378                 outb(dflip , COMMAND_PORT);
 379         }
 380 #endif /* LOWSPEED */
 381 }
 382
 383 static inline void
 384 de620_set_delay(struct net_device *dev)
 385 {
 386         de620_ready(dev);
 387         outb(W_DFR, DATA_PORT);
 388         outb(NIC_Cmd ^ CS0, COMMAND_PORT);
 389
 390         de620_ready(dev);
 391 #ifdef LOWSPEED
 392         outb(WRITE_DELAY, DATA_PORT);
 393 #else
 394         outb(0, DATA_PORT);
 395 #endif
 396         de620_flip_ds(dev);
 397
 398         de620_ready(dev);
 399 #ifdef LOWSPEED
 400         outb(READ_DELAY, DATA_PORT);
 401 #else
 402         outb(0, DATA_PORT);
 403 #endif
 404         de620_flip_ds(dev);
 405 }
 406
 407 static inline void
 408 de620_set_register(struct net_device *dev, byte reg, byte value)
 409 {
 410         de620_ready(dev);
 411         outb(reg, DATA_PORT);
 412         outb(NIC_Cmd ^ CS0, COMMAND_PORT);
 413
 414         de620_put_byte(dev, value);
 415 }
 416
 417 static inline byte
 418 de620_get_register(struct net_device *dev, byte reg)
 419 {
 420         byte value;
 421
 422         de620_send_command(dev,reg);
 423         value = de620_read_byte(dev);
 424         de620_send_command(dev,W_DUMMY);
 425
 426         return value;
 427 }
 428 \f
 429 /*********************************************************************
 430  *
 431  * Open/initialize the board.
 432  *
 433  * This routine should set everything up anew at each open, even
 434  * registers that "should" only need to be set once at boot, so that
 435  * there is a non-reboot way to recover if something goes wrong.
 436  *
 437  */
 438 static int
 439 de620_open(struct net_device *dev)
 440 {
 441         if (request_irq(dev->irq, de620_interrupt, 0, "de620", dev)) {
 442                 printk ("%s: unable to get IRQ %d\n", dev->name, dev->irq);
 443                 return 1;
 444         }
 445
 446         MOD_INC_USE_COUNT;
 447         if (adapter_init(dev)) {
 448                 return 1;
 449         }
 450         dev->start = 1;
 451         return 0;
 452 }
 453
 454 /************************************************
 455  *
 456  * The inverse routine to de620_open().
 457  *
 458  */
 459 static int
 460 de620_close(struct net_device *dev)
 461 {
 462         /* disable recv */
 463         de620_set_register(dev, W_TCR, RXOFF);
 464
 465         free_irq(dev->irq, dev);
 466
 467         dev->start = 0;
 468         MOD_DEC_USE_COUNT;
 469         return 0;
 470 }
 471
 472 /*********************************************
 473  *
 474  * Return current statistics
 475  *
 476  */
 477 static struct net_device_stats *get_stats(struct net_device *dev)
 478 {
 479         return (struct net_device_stats *)(dev->priv);
 480 }
 481
 482 /*********************************************
 483  *
 484  * Set or clear the multicast filter for this adaptor.
 485  * (no real multicast implemented for the DE-620, but she can be promiscuous...)
 486  *
 487  */
 488
 489 static void de620_set_multicast_list(struct net_device *dev)
 490 {
 491         if (dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
 492         { /* Enable promiscuous mode */
 493                 /*
 494                  *      We must make the kernel realise we had to move
 495                  *      into promisc mode or we start all out war on
 496                  *      the cable. - AC
 497                  */
 498                 dev->flags|=IFF_PROMISC;
 499
 500                 de620_set_register(dev, W_TCR, (TCR_DEF & ~RXPBM) | RXALL);
 501         }
 502         else
 503         { /* Disable promiscuous mode, use normal mode */
 504                 de620_set_register(dev, W_TCR, TCR_DEF);
 505         }
 506 }
 507
 508 /*******************************************************
 509  *
 510  * Copy a buffer to the adapter transmit page memory.
 511  * Start sending.
 512  */
 513 static int
 514 de620_start_xmit(struct sk_buff *skb, struct net_device *dev)
 515 {
 516         unsigned long flags;
 517         int len;
 518         int tickssofar;
 519         byte *buffer = skb->data;
 520         byte using_txbuf;
 521
 522         using_txbuf = de620_tx_buffs(dev); /* Peek at the adapter */
 523         dev->tbusy = (using_txbuf == (TXBF0 | TXBF1)); /* Boolean! */
 524
 525         if (dev->tbusy) {       /* Do timeouts, to avoid hangs. */
 526                 tickssofar = jiffies - dev->trans_start;
 527
 528                 if (tickssofar < 5)
 529                         return 1;
 530
 531                 /* else */
 532                 printk("%s: transmit timed out (%d), %s?\n",
 533                         dev->name,
 534                         tickssofar,
 535                         "network cable problem"
 536                         );
 537                 /* Restart the adapter. */
 538                 if (adapter_init(dev)) /* maybe close it */
 539                         return 1;
 540         }
 541
 542         if ((len = skb->len) < RUNT)
 543                 len = RUNT;
 544         if (len & 1) /* send an even number of bytes */
 545                 ++len;
 546
 547         /* Start real output */
 548         save_flags(flags);
 549         cli();
 550
 551         PRINTK(("de620_start_xmit: len=%d, bufs 0x%02x\n",
 552                 (int)skb->len, using_txbuf));
 553
 554         /* select a free tx buffer. if there is one... */
 555         switch (using_txbuf) {
 556         default: /* both are free: use TXBF0 */
 557         case TXBF1: /* use TXBF0 */
 558                 de620_send_command(dev,W_CR | RW0);
 559                 using_txbuf |= TXBF0;
 560                 break;
 561
 562         case TXBF0: /* use TXBF1 */
 563                 de620_send_command(dev,W_CR | RW1);
 564                 using_txbuf |= TXBF1;
 565                 break;
 566
 567         case (TXBF0 | TXBF1): /* NONE!!! */
 568                 printk("de620: Ouch! No tx-buffer available!\n");
 569                 restore_flags(flags);
 570                 return 1;
 571                 break;
 572         }
 573         de620_write_block(dev, buffer, len);
 574
 575         dev->trans_start = jiffies;
 576         dev->tbusy = (using_txbuf == (TXBF0 | TXBF1)); /* Boolean! */
 577
 578         ((struct net_device_stats *)(dev->priv))->tx_packets++;
 579
 580         restore_flags(flags); /* interrupts maybe back on */
 581
 582         dev_kfree_skb (skb);
 583
 584         return 0;
 585 }
 586 \f
 587 /*****************************************************
 588  *
 589  * Handle the network interface interrupts.
 590  *
 591  */
 592 static void
 593 de620_interrupt(int irq_in, void *dev_id, struct pt_regs *regs)
 594 {
 595         struct net_device *dev = dev_id;
 596         byte irq_status;
 597         int bogus_count = 0;
 598         int again = 0;
 599
 600         /* This might be deleted now, no crummy drivers present :-) Or..? */
 601         if ((dev == NULL) || (irq != irq_in)) {
 602                 printk("%s: bogus interrupt %d\n", dev?dev->name:"de620", irq_in);
 603                 return;
 604         }
 605
 606         cli();
 607         dev->interrupt = 1;
 608
 609         /* Read the status register (_not_ the status port) */
 610         irq_status = de620_get_register(dev, R_STS);
 611
 612         PRINTK(("de620_interrupt (%2.2X)\n", irq_status));
 613
 614         if (irq_status & RXGOOD) {
 615                 do {
 616                         again = de620_rx_intr(dev);
 617                         PRINTK(("again=%d\n", again));
 618                 }
 619                 while (again && (++bogus_count < 100));
 620         }
 621
 622         dev->tbusy = (de620_tx_buffs(dev) == (TXBF0 | TXBF1)); /* Boolean! */
 623
 624         dev->interrupt = 0;
 625         sti();
 626         return;
 627 }
 628
 629 /**************************************
 630  *
 631  * Get a packet from the adapter
 632  *
 633  * Send it "upstairs"
 634  *
 635  */
 636 static int
 637 de620_rx_intr(struct net_device *dev)
 638 {
 639         struct header_buf {
 640                 byte            status;
 641                 byte            Rx_NextPage;
 642                 unsigned short  Rx_ByteCount;
 643         } header_buf;
 644         struct sk_buff *skb;
 645         int size;
 646         byte *buffer;
 647         byte pagelink;
 648         byte curr_page;
 649
 650         PRINTK(("de620_rx_intr: next_rx_page = %d\n", next_rx_page));
 651
 652         /* Tell the adapter that we are going to read data, and from where */
 653         de620_send_command(dev, W_CR | RRN);
 654         de620_set_register(dev, W_RSA1, next_rx_page);
 655         de620_set_register(dev, W_RSA0, 0);
 656
 657         /* Deep breath, and away we goooooo */
 658         de620_read_block(dev, (byte *)&header_buf, sizeof(struct header_buf));
 659         PRINTK(("page status=0x%02x, nextpage=%d, packetsize=%d\n",
 660         header_buf.status, header_buf.Rx_NextPage, header_buf.Rx_ByteCount));
 661
 662         /* Plausible page header? */
 663         pagelink = header_buf.Rx_NextPage;
 664         if ((pagelink < first_rx_page) || (last_rx_page < pagelink)) {
 665                 /* Ouch... Forget it! Skip all and start afresh... */
 666                 printk("%s: Ring overrun? Restoring...\n", dev->name);
 667                 /* You win some, you lose some. And sometimes plenty... */
 668                 adapter_init(dev);
 669                 ((struct net_device_stats *)(dev->priv))->rx_over_errors++;
 670                 return 0;
 671         }
 672
 673         /* OK, this look good, so far. Let's see if it's consistent... */
 674         /* Let's compute the start of the next packet, based on where we are */
 675         pagelink = next_rx_page +
 676                 ((header_buf.Rx_ByteCount + (4 - 1 + 0x100)) >> 8);
 677
 678         /* Are we going to wrap around the page counter? */
 679         if (pagelink > last_rx_page)
 680                 pagelink -= (last_rx_page - first_rx_page + 1);
 681
 682         /* Is the _computed_ next page number equal to what the adapter says? */
 683         if (pagelink != header_buf.Rx_NextPage) {
 684                 /* Naah, we'll skip this packet. Probably bogus data as well */
 685                 printk("%s: Page link out of sync! Restoring...\n", dev->name);
 686                 next_rx_page = header_buf.Rx_NextPage; /* at least a try... */
 687                 de620_send_command(dev, W_DUMMY);
 688                 de620_set_register(dev, W_NPRF, next_rx_page);
 689                 ((struct net_device_stats *)(dev->priv))->rx_over_errors++;
 690                 return 0;
 691         }
 692         next_rx_page = pagelink;
 693
 694         size = header_buf.Rx_ByteCount - 4;
 695         if ((size < RUNT) || (GIANT < size)) {
 696                 printk("%s: Illegal packet size: %d!\n", dev->name, size);
 697         }
 698         else { /* Good packet? */
 699                 skb = dev_alloc_skb(size+2);
 700                 if (skb == NULL) { /* Yeah, but no place to put it... */
 701                         printk("%s: Couldn't allocate a sk_buff of size %d.\n",
 702                                 dev->name, size);
 703                         ((struct net_device_stats *)(dev->priv))->rx_dropped++;
 704                 }
 705                 else { /* Yep! Go get it! */
 706                         skb_reserve(skb,2);     /* Align */
 707                         skb->dev = dev;
 708                         skb->used = 0;
 709                         /* skb->data points to the start of sk_buff data area */
 710                         buffer = skb_put(skb,size);
 711                         /* copy the packet into the buffer */
 712                         de620_read_block(dev, buffer, size);
 713                         PRINTK(("Read %d bytes\n", size));
 714                         skb->protocol=eth_type_trans(skb,dev);
 715                         netif_rx(skb); /* deliver it "upstairs" */
 716                         /* count all receives */
 717                         ((struct net_device_stats *)(dev->priv))->rx_packets++;
 718                 }
 719         }
 720
 721         /* Let's peek ahead to see if we have read the last current packet */
 722         /* NOTE! We're _not_ checking the 'EMPTY'-flag! This seems better... */
 723         curr_page = de620_get_register(dev, R_CPR);
 724         de620_set_register(dev, W_NPRF, next_rx_page);
 725         PRINTK(("next_rx_page=%d CPR=%d\n", next_rx_page, curr_page));
 726
 727         return (next_rx_page != curr_page); /* That was slightly tricky... */
 728 }
 729 \f
 730 /*********************************************
 731  *
 732  * Reset the adapter to a known state
 733  *
 734  */
 735 static int
 736 adapter_init(struct net_device *dev)
 737 {
 738         int i;
 739         static int was_down = 0;
 740
 741         if ((nic_data.Model == 3) || (nic_data.Model == 0)) { /* CT */
 742                 EIPRegister = NCTL0;
 743                 if (nic_data.Media != 1)
 744                         EIPRegister |= NIS0;    /* not BNC */
 745         }
 746         else if (nic_data.Model == 2) { /* UTP */
 747                 EIPRegister = NCTL0 | NIS0;
 748         }
 749
 750         if (utp)
 751                 EIPRegister = NCTL0 | NIS0;
 752         if (bnc)
 753                 EIPRegister = NCTL0;
 754
 755         de620_send_command(dev, W_CR | RNOP | CLEAR);
 756         de620_send_command(dev, W_CR | RNOP);
 757
 758         de620_set_register(dev, W_SCR, SCR_DEF);
 759         /* disable recv to wait init */
 760         de620_set_register(dev, W_TCR, RXOFF);
 761
 762         /* Set the node ID in the adapter */
 763         for (i = 0; i < 6; ++i) { /* W_PARn = 0xaa + n */
 764                 de620_set_register(dev, W_PAR0 + i, dev->dev_addr[i]);
 765         }
 766
 767         de620_set_register(dev, W_EIP, EIPRegister);
 768
 769         next_rx_page = first_rx_page = DE620_RX_START_PAGE;
 770         if (nic_data.RAM_Size)
 771                 last_rx_page = nic_data.RAM_Size - 1;
 772         else /* 64k RAM */
 773                 last_rx_page = 255;
 774
 775         de620_set_register(dev, W_SPR, first_rx_page); /* Start Page Register*/
 776         de620_set_register(dev, W_EPR, last_rx_page);  /* End Page Register */
 777         de620_set_register(dev, W_CPR, first_rx_page);/*Current Page Register*/
 778         de620_send_command(dev, W_NPR | first_rx_page); /* Next Page Register*/
 779         de620_send_command(dev, W_DUMMY);
 780         de620_set_delay(dev);
 781
 782         /* Final sanity check: Anybody out there? */
 783         /* Let's hope some bits from the statusregister make a good check */
 784 #define CHECK_MASK (  0 | TXSUC |  T16  |  0  | RXCRC | RXSHORT |  0  |  0  )
 785 #define CHECK_OK   (  0 |   0   |  0    |  0  |   0   |   0     |  0  |  0  )
 786         /* success:   X     0      0       X      0       0        X     X  */
 787         /* ignore:   EEDI                RXGOOD                   COLS  LNKS*/
 788
 789         if (((i = de620_get_register(dev, R_STS)) & CHECK_MASK) != CHECK_OK) {
 790                 printk("Something has happened to the DE-620!  Please check it"
 791 #ifdef SHUTDOWN_WHEN_LOST
 792                         " and do a new ifconfig"
 793 #endif
 794                         "! (%02x)\n", i);
 795 #ifdef SHUTDOWN_WHEN_LOST
 796                 /* Goodbye, cruel world... */
 797                 dev->flags &= ~IFF_UP;
 798                 de620_close(dev);
 799 #endif
 800                 was_down = 1;
 801                 return 1; /* failed */
 802         }
 803         if (was_down) {
 804                 printk("Thanks, I feel much better now!\n");
 805                 was_down = 0;
 806         }
 807
 808         /* All OK, go ahead... */
 809         de620_set_register(dev, W_TCR, TCR_DEF);
 810
 811         return 0; /* all ok */
 812 }
 813 \f
 814 /******************************************************************************
 815  *
 816  * Only start-up code below
 817  *
 818  */
 819 /****************************************
 820  *
 821  * Check if there is a DE-620 connected
 822  */
 823 int __init
 824 de620_probe(struct net_device *dev)
 825 {
 826         static struct net_device_stats de620_netstats;
 827         int i;
 828         byte checkbyte = 0xa5;
 829
 830         /*
 831          * This is where the base_addr and irq gets set.
 832          * Tunable at compile-time and insmod-time
 833          */
 834         dev->base_addr = io;
 835         dev->irq       = irq;
 836
 837         if (de620_debug)
 838                 printk(version);
 839
 840         printk("D-Link DE-620 pocket adapter");
 841
 842         /* Initially, configure basic nibble mode, so we can read the EEPROM */
 843         NIC_Cmd = DEF_NIC_CMD;
 844         de620_set_register(dev, W_EIP, EIPRegister);
 845
 846         /* Anybody out there? */
 847         de620_set_register(dev, W_CPR, checkbyte);
 848         checkbyte = de620_get_register(dev, R_CPR);
 849
 850         if ((checkbyte != 0xa5) || (read_eeprom(dev) != 0)) {
 851                 printk(" not identified in the printer port\n");
 852                 return ENODEV;
 853         }
 854
 855 #if 0 /* Not yet */
 856         if (check_region(dev->base_addr, 3)) {
 857                 printk(", port 0x%x busy\n", dev->base_addr);
 858                 return EBUSY;
 859         }
 860 #endif
 861         request_region(dev->base_addr, 3, "de620");
 862
 863         /* else, got it! */
 864         printk(", Ethernet Address: %2.2X",
 865                 dev->dev_addr[0] = nic_data.NodeID[0]);
 866         for (i = 1; i < ETH_ALEN; i++) {
 867                 printk(":%2.2X", dev->dev_addr[i] = nic_data.NodeID[i]);
 868                 dev->broadcast[i] = 0xff;
 869         }
 870
 871         printk(" (%dk RAM,",
 872                 (nic_data.RAM_Size) ? (nic_data.RAM_Size >> 2) : 64);
 873
 874         if (nic_data.Media == 1)
 875                 printk(" BNC)\n");
 876         else
 877                 printk(" UTP)\n");
 878
 879         /* Initialize the device structure. */
 880         dev->priv = &de620_netstats;
 881
 882         memset(dev->priv, 0, sizeof(struct net_device_stats));
 883         dev->get_stats = get_stats;
 884         dev->open = de620_open;
 885         dev->stop = de620_close;
 886         dev->hard_start_xmit = &de620_start_xmit;
 887         dev->set_multicast_list = &de620_set_multicast_list;
 888         /* base_addr and irq are already set, see above! */
 889
 890         ether_setup(dev);
 891
 892         /* dump eeprom */
 893         if (de620_debug) {
 894                 printk("\nEEPROM contents:\n");
 895                 printk("RAM_Size = 0x%02X\n", nic_data.RAM_Size);
 896                 printk("NodeID = %02X:%02X:%02X:%02X:%02X:%02X\n",
 897                         nic_data.NodeID[0], nic_data.NodeID[1],
 898                         nic_data.NodeID[2], nic_data.NodeID[3],
 899                         nic_data.NodeID[4], nic_data.NodeID[5]);
 900                 printk("Model = %d\n", nic_data.Model);
 901                 printk("Media = %d\n", nic_data.Media);
 902                 printk("SCR = 0x%02x\n", nic_data.SCR);
 903         }
 904
 905         return 0;
 906 }
 907 \f
 908 /**********************************
 909  *
 910  * Read info from on-board EEPROM
 911  *
 912  * Note: Bitwise serial I/O to/from the EEPROM vi the status _register_!
 913  */
 914 #define sendit(dev,data) de620_set_register(dev, W_EIP, data | EIPRegister);
 915
 916 static unsigned short __init
 917 ReadAWord(struct net_device *dev, int from)
 918 {
 919         unsigned short data;
 920         int nbits;
 921
 922         /* cs   [__~~] SET SEND STATE */
 923         /* di   [____]                */
 924         /* sck  [_~~_]                */
 925         sendit(dev, 0); sendit(dev, 1); sendit(dev, 5); sendit(dev, 4);
 926
 927         /* Send the 9-bit address from where we want to read the 16-bit word */
 928         for (nbits = 9; nbits > 0; --nbits, from <<= 1) {
 929                 if (from & 0x0100) { /* bit set? */
 930                         /* cs    [~~~~] SEND 1 */
 931                         /* di    [~~~~]        */
 932                         /* sck   [_~~_]        */
 933                         sendit(dev, 6); sendit(dev, 7); sendit(dev, 7); sendit(dev, 6);
 934                 }
 935                 else {
 936                         /* cs    [~~~~] SEND 0 */
 937                         /* di    [____]        */
 938                         /* sck   [_~~_]        */
 939                         sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
 940                 }
 941         }
 942
 943         /* Shift in the 16-bit word. The bits appear serially in EEDI (=0x80) */
 944         for (data = 0, nbits = 16; nbits > 0; --nbits) {
 945                 /* cs    [~~~~] SEND 0 */
 946                 /* di    [____]        */
 947                 /* sck   [_~~_]        */
 948                 sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
 949                 data = (data << 1) | ((de620_get_register(dev, R_STS) & EEDI) >> 7);
 950         }
 951         /* cs    [____] RESET SEND STATE */
 952         /* di    [____]                  */
 953         /* sck   [_~~_]                  */
 954         sendit(dev, 0); sendit(dev, 1); sendit(dev, 1); sendit(dev, 0);
 955
 956         return data;
 957 }
 958
 959 static int __init
 960 read_eeprom(struct net_device *dev)
 961 {
 962         unsigned short wrd;
 963
 964         /* D-Link Ethernet addresses are in the series  00:80:c8:7X:XX:XX:XX */
 965         wrd = ReadAWord(dev, 0x1aa);    /* bytes 0 + 1 of NodeID */
 966         if (!clone && (wrd != htons(0x0080))) /* Valid D-Link ether sequence? */
 967                 return -1; /* Nope, not a DE-620 */
 968         nic_data.NodeID[0] = wrd & 0xff;
 969         nic_data.NodeID[1] = wrd >> 8;
 970
 971         wrd = ReadAWord(dev, 0x1ab);    /* bytes 2 + 3 of NodeID */
 972         if (!clone && ((wrd & 0xff) != 0xc8)) /* Valid D-Link ether sequence? */
 973                 return -1; /* Nope, not a DE-620 */
 974         nic_data.NodeID[2] = wrd & 0xff;
 975         nic_data.NodeID[3] = wrd >> 8;
 976
 977         wrd = ReadAWord(dev, 0x1ac);    /* bytes 4 + 5 of NodeID */
 978         nic_data.NodeID[4] = wrd & 0xff;
 979         nic_data.NodeID[5] = wrd >> 8;
 980
 981         wrd = ReadAWord(dev, 0x1ad);    /* RAM size in pages (256 bytes). 0 = 64k */
 982         nic_data.RAM_Size = (wrd >> 8);
 983
 984         wrd = ReadAWord(dev, 0x1ae);    /* hardware model (CT = 3) */
 985         nic_data.Model = (wrd & 0xff);
 986
 987         wrd = ReadAWord(dev, 0x1af); /* media (indicates BNC/UTP) */
 988         nic_data.Media = (wrd & 0xff);
 989
 990         wrd = ReadAWord(dev, 0x1a8); /* System Configuration Register */
 991         nic_data.SCR = (wrd >> 8);
 992
 993         return 0; /* no errors */
 994 }
 995 \f
 996 /******************************************************************************
 997  *
 998  * Loadable module skeleton
 999  *
1000  */
1001 #ifdef MODULE
1002 static char nullname[8] = "";
1003 static struct net_device de620_dev = {
1004         nullname, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, de620_probe };
1005
1006 int
1007 init_module(void)
1008 {
1009         if (register_netdev(&de620_dev) != 0)
1010                 return -EIO;
1011         return 0;
1012 }
1013
1014 void
1015 cleanup_module(void)
1016 {
1017         unregister_netdev(&de620_dev);
1018         release_region(de620_dev.base_addr, 3);
1019 }
1020 #endif /* MODULE */
1021 \f
1022 /*
1023  * (add '-DMODULE' when compiling as loadable module)
1024  *
1025  * compile-command:
1026  *      gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
1027  *       -fomit-frame-pointer -m486 \
1028  *      -I/usr/src/linux/include -I../../net/inet -c de620.c
1029 */
1030 /*
1031  * Local variables:
1032  *  kernel-compile-command: "gcc -D__KERNEL__ -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
1033  *  module-compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
1034  *  compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
1035  * End:
1036  */