sys/dev/netif/rdp/if_rdp.c

   1 /*
   2  * Copyright 1998, Joerg Wunsch
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/i386/isa/if_rdp.c,v 1.6.2.2 2000/07/17 21:24:32 archie Exp $
  28  * $DragonFly: src/sys/dev/netif/rdp/if_rdp.c,v 1.12 2004/07/23 07:16:27 joerg Exp $
  29  */
  30
  31 /*
  32  * Device driver for RealTek RTL 8002 (`REDP') based pocket-ethernet
  33  * adapters, hooked up to a printer port.  `rdp' is a shorthand for
  34  * REDP since some tools like netstat work best if the interface name
  35  * has no more than three letters.
  36  *
  37  * Driver configuration flags so far:
  38  *   flags 0x1 -- assume 74S288 EEPROM (default 94C46)
  39  *   flags 0x2 -- use `slow' mode (mode 3 of the packet driver, default 0)
  40  *
  41  * Maybe this driver will some day also work with the successor, RTL
  42  * 8012 (`AREDP'), which is unfortunately not fully register-
  43  * compatible with the 8002.  The 8012 offers support for faster
  44  * transfer modi like bidirectional SPP and EPP, 64 K x 4 buffer
  45  * memory as opposed to 16 K x 4 for the 8002, a multicast filter, and
  46  * a builtin multiplexer that allows chaining a printer behind the
  47  * ethernet adapter.
  48  *
  49  * About the only documentation i've been able to find about the RTL
  50  * 8002 was the packet driver source code at ftp.realtek.com.tw, so
  51  * this driver is somewhat based on the way the packet driver handles
  52  * the chip.  The exact author of the packet driver is unknown, the
  53  * only name that i could find in the source was someone called Chiu,
  54  * supposedly an employee of RealTek.  So credits to them for that
  55  * piece of code which has proven valuable to me.
  56  *
  57  * Later on, Leo kuo <leo@realtek.com.tw> has been very helpful to me
  58  * by sending me a readable (PDF) file documenting the RTL 8012, which
  59  * helped me to also understand the 8002, as well as by providing me
  60  * with the source code of the 8012 packet driver that i haven't been
  61  * able to find on the FTP site.  A big Thanks! goes here to RealTek
  62  * for this kind of service.
  63  */
  64
  65 #include "use_rdp.h"
  66
  67 #include <sys/param.h>
  68 #include <sys/systm.h>
  69 #include <sys/conf.h>
  70 #include <sys/sockio.h>
  71 #include <sys/malloc.h>
  72 #include <sys/mbuf.h>
  73 #include <sys/socket.h>
  74 #include <sys/syslog.h>
  75 #include <sys/linker_set.h>
  76 #include <sys/module.h>
  77 #include <sys/bus.h>
  78
  79 #include <net/ethernet.h>
  80 #include <net/if.h>
  81 #include <net/if_arp.h>
  82 #include <net/if_dl.h>
  83 #include <net/if_mib.h>
  84
  85 #ifdef INET
  86 #include <netinet/in.h>
  87 #include <netinet/if_ether.h>
  88 #endif
  89
  90 #ifdef NS
  91 #include <netns/ns.h>
  92 #include <netns/ns_if.h>
  93 #endif
  94
  95 #include <net/bpf.h>
  96
  97 #include <machine/clock.h>
  98 #include <machine/md_var.h>
  99
 100 #include <bus/isa/isavar.h>
 101 #include <bus/isa/i386/isa_device.h>
 102 #include <i386/isa/icu.h>
 103 #include "if_rdpreg.h"
 104 #include <i386/isa/intr_machdep.h>
 105
 106 #define IOCTL_CMD_T u_long
 107
 108 /*
 109  * Debug levels (ORed together):
 110  *  != 0 - general (bad packets etc.)
 111  *  2 - debug EEPROM IO
 112  *  4 - debug interrupt status
 113  */
 114 #undef DEBUG
 115 #define DEBUG 0
 116
 117 /*
 118  * rdp_softc: per interface info and status
 119  */
 120 struct rdp_softc {
 121         struct arpcom arpcom;   /*
 122                                  * Ethernet common, always goes first so
 123                                  * a rdp_softc * can be cast into an
 124                                  * arpcom * or into an ifnet *.
 125                                  */
 126
 127         /*
 128          * local stuff, somewhat sorted by memory alignment class
 129          */
 130         u_short baseaddr;       /* IO port address */
 131         u_short txsize;         /* tx size for next (buffered) packet,
 132                                  * there's only one additional packet
 133                                  * we can buffer, thus a single variable
 134                                  * ought to be enough */
 135         int txbusy;             /* tx is transmitting */
 136         int txbuffered;         /* # of packets in tx buffer */
 137         int slow;               /* use lpt_control to send data */
 138         u_char irqenbit;        /* mirror of current Ctrl_IRQEN */
 139         /*
 140          * type of parameter EEPROM; device flags 0x1 selects 74S288
 141          */
 142         enum {
 143                 EEPROM_93C46, EEPROM_74S288 /* or 82S123 */
 144         } eeprom;
 145 };
 146
 147 DECLARE_DUMMY_MODULE(if_rdp);
 148
 149 static struct rdp_softc rdp_softc[NRDP];
 150
 151 /*
 152  * Since there's no fixed location in the EEPROM about where to find
 153  * the ethernet hardware address, we drop a table of valid OUIs here,
 154  * and search through the EEPROM until we find a possible valid
 155  * Ethernet address.  Only the first 16 bits of all possible OUIs are
 156  * recorded in the table (as obtained from
 157  * http://standards.ieee.org/regauth/oui/oui.txt).
 158  */
 159
 160 static u_short allowed_ouis[] = {
 161         0x0000, 0x0001, 0x0002, 0x0004, 0x0005, 0x0006, 0x0007,
 162         0x0008, 0x0010, 0x001C, 0x0020, 0x0040, 0x0050, 0x0060,
 163         0x0070, 0x0080, 0x0090, 0x009D, 0x00A0, 0x00AA, 0x00BB,
 164         0x00C0, 0x00CF, 0x00DD, 0x00E0, 0x00E6, 0x0207, 0x021C,
 165         0x0260, 0x0270, 0x029D, 0x02AA, 0x02BB, 0x02C0, 0x02CF,
 166         0x02E6, 0x040A, 0x04E0, 0x0800, 0x08BB, 0x1000, 0x1100,
 167         0x8000, 0xAA00
 168 };
 169
 170 /*
 171  * ISA bus support.
 172  */
 173 static int rdp_probe            (struct isa_device *);
 174 static int rdp_attach           (struct isa_device *);
 175
 176 /*
 177  * Required entry points.
 178  */
 179 static void rdp_init(void *);
 180 static int rdp_ioctl(struct ifnet *, IOCTL_CMD_T, caddr_t, struct ucred *);
 181 static void rdp_start(struct ifnet *);
 182 static void rdp_reset(struct ifnet *);
 183 static void rdp_watchdog(struct ifnet *);
 184 static void rdpintr(int);
 185
 186 /*
 187  * REDP private functions.
 188  */
 189
 190 static void rdp_stop(struct rdp_softc *);
 191 static void rdp_rint(struct rdp_softc *);
 192 static void rdp_get_packet(struct rdp_softc *, unsigned);
 193 static u_short rdp_write_mbufs(struct rdp_softc *, struct mbuf *);
 194 static int rdp_gethwaddr_93c46(struct rdp_softc *, u_char *);
 195 static void rdp_gethwaddr_74s288(struct rdp_softc *, u_char *);
 196 static void rdp_93c46_cmd(struct rdp_softc *, u_short, unsigned);
 197 static u_short rdp_93c46_read(struct rdp_softc *);
 198
 199 struct isa_driver rdpdriver = {
 200         rdp_probe,
 201         rdp_attach,
 202         "rdp",
 203         1                       /* we wanna get a chance before lptN */
 204 };
 205
 206 /*
 207  * REDP-specific functions.
 208  *
 209  * They are inlined, thus go first in this file.  Together with gcc's
 210  * usual optimization, these functions probably come close to the
 211  * packet driver's hand-optimized code. ;-)
 212  *
 213  * Comments are partially obtained from the packet driver as well.
 214  * Some of the function names contain register names which don't make
 215  * much sense for us, but i've kept them for easier reference in
 216  * comparision to the packet driver.
 217  *
 218  * Some of the functions are currently not used by the driver; it's
 219  * not quite clear whether we ever need them at all.  They are
 220  * supposedly even slower than what is currently implemented as `slow'
 221  * mode.  Right now, `fast' (default) mode is what the packet driver
 222  * calls mode 0, slow mode is mode 3 (writing through lpt_control,
 223  * reading twice).
 224  *
 225  * We should autoprobe the modi, as opposed to making them dependent
 226  * on a kernel configuration flag.
 227  */
 228
 229 /*
 230  * read a nibble from rreg; end-of-data cmd is not issued;
 231  * used for general register read.
 232  *
 233  * Unlike the packet driver's version, i'm shifting the result
 234  * by 3 here (as opposed to within the caller's code) for clarity.
 235  *  -- Joerg
 236  */
 237 static __inline u_char
 238 RdNib(struct rdp_softc *sc, u_char rreg)
 239 {
 240
 241         outb(sc->baseaddr + lpt_data, EOC + rreg);
 242         outb(sc->baseaddr + lpt_data, RdAddr + rreg); /* write addr */
 243         (void)inb(sc->baseaddr + lpt_status);
 244         return (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
 245 }
 246
 247 #if 0
 248 /*
 249  * read a byte from MAR register through lpt_data; the low nibble is
 250  * read prior to the high one; end-of-read command is not issued; used
 251  * for remote DMA in mode 4 + 5
 252  */
 253 static __inline u_char
 254 RdByte(struct rdp_softc *sc)
 255 {
 256         u_char hinib, lonib;
 257
 258         outb(sc->baseaddr + lpt_data, RdAddr + MAR); /* cmd for low nibble */
 259         lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
 260         outb(sc->baseaddr + lpt_data, RdAddr + MAR + HNib);
 261         hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
 262         return hinib + lonib;
 263 }
 264
 265
 266 /*
 267  * read a byte from MAR register through lpt_data; the low nibble is
 268  * read prior to the high one; end-of-read command is not issued; used
 269  * for remote DMA in mode 6 + 7
 270  */
 271 static __inline u_char
 272 RdByte1(struct rdp_softc *sc)
 273 {
 274         u_char hinib, lonib;
 275
 276         outb(sc->baseaddr + lpt_data, RdAddr + MAR); /* cmd for low nibble */
 277         (void)inb(sc->baseaddr + lpt_status);
 278         lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
 279         outb(sc->baseaddr + lpt_data, RdAddr + MAR + HNib);
 280         (void)inb(sc->baseaddr + lpt_status);
 281         hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
 282         return hinib + lonib;
 283 }
 284 #endif
 285
 286
 287 /*
 288  * read a byte from MAR register through lpt_control; the low nibble is
 289  * read prior to the high one; end-of-read command is not issued; used
 290  * for remote DMA in mode 0 + 1
 291  */
 292 static __inline u_char
 293 RdByteA1(struct rdp_softc *sc)
 294 {
 295         u_char hinib, lonib;
 296
 297         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
 298         lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
 299         outb(sc->baseaddr + lpt_control, Ctrl_HNibRead);
 300         hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
 301         return hinib + lonib;
 302 }
 303
 304
 305 /*
 306  * read a byte from MAR register through lpt_control; the low nibble is
 307  * read prior to the high one; end-of-read command is not issued; used
 308  * for remote DMA in mode 2 + 3
 309  */
 310 static __inline u_char
 311 RdByteA2(struct rdp_softc *sc)
 312 {
 313         u_char hinib, lonib;
 314
 315         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
 316         (void)inb(sc->baseaddr + lpt_status);
 317         lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
 318         outb(sc->baseaddr + lpt_control, Ctrl_HNibRead);
 319         (void)inb(sc->baseaddr + lpt_status);
 320         hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
 321         return hinib + lonib;
 322 }
 323
 324 /*
 325  * End-of-read cmd
 326  */
 327 static __inline void
 328 RdEnd(struct rdp_softc *sc, u_char rreg)
 329 {
 330
 331         outb(sc->baseaddr + lpt_data, EOC + rreg);
 332 }
 333
 334 /*
 335  * Write a nibble to a register; end-of-write is issued.
 336  * Used for general register write.
 337  */
 338 static __inline void
 339 WrNib(struct rdp_softc *sc, u_char wreg, u_char wdata)
 340 {
 341
 342         /* prepare and write address */
 343         outb(sc->baseaddr + lpt_data, EOC + wreg);
 344         outb(sc->baseaddr + lpt_data, WrAddr + wreg);
 345         outb(sc->baseaddr + lpt_data, WrAddr + wreg);
 346         /* prepare and write data */
 347         outb(sc->baseaddr + lpt_data, WrAddr + wdata);
 348         outb(sc->baseaddr + lpt_data, wdata);
 349         outb(sc->baseaddr + lpt_data, wdata);
 350         /* end-of-write */
 351         outb(sc->baseaddr + lpt_data, EOC + wdata);
 352 }
 353
 354 /*
 355  * Write a byte to a register; end-of-write is issued.
 356  * Used for general register write.
 357  */
 358 static __inline void
 359 WrByte(struct rdp_softc *sc, u_char wreg, u_char wdata)
 360 {
 361
 362         /* prepare and write address */
 363         outb(sc->baseaddr + lpt_data, EOC + wreg);
 364         outb(sc->baseaddr + lpt_data, WrAddr + wreg);
 365         outb(sc->baseaddr + lpt_data, WrAddr + wreg);
 366         /* prepare and write low nibble */
 367         outb(sc->baseaddr + lpt_data, WrAddr + (wdata & 0x0F));
 368         outb(sc->baseaddr + lpt_data, (wdata & 0x0F));
 369         outb(sc->baseaddr + lpt_data, (wdata & 0x0F));
 370         /* prepare and write high nibble */
 371         wdata >>= 4;
 372         outb(sc->baseaddr + lpt_data, wdata);
 373         outb(sc->baseaddr + lpt_data, wdata + HNib);
 374         outb(sc->baseaddr + lpt_data, wdata + HNib);
 375         /* end-of-write */
 376         outb(sc->baseaddr + lpt_data, EOC + wdata + HNib);
 377 }
 378
 379 /*
 380  * Write the byte to DRAM via lpt_data;
 381  * used for remote DMA write in mode 0 / 2 / 4
 382  */
 383 static __inline void
 384 WrByteALToDRAM(struct rdp_softc *sc, u_char val)
 385 {
 386
 387         outb(sc->baseaddr + lpt_data, val & 0x0F);
 388         outb(sc->baseaddr + lpt_data, MkHi(val));
 389 }
 390
 391 /*
 392  * Write the byte to DRAM via lpt_control;
 393  * used for remote DMA write in mode 1 / 3 / 5
 394  */
 395 static __inline void
 396 WrByteALToDRAMA(struct rdp_softc *sc, u_char val)
 397 {
 398
 399         outb(sc->baseaddr + lpt_data, val & 0x0F);
 400         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
 401         outb(sc->baseaddr + lpt_data, val >> 4);
 402         outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
 403 }
 404
 405 #if 0 /* they could be used for the RAM test */
 406 /*
 407  * Write the u_short to DRAM via lpt_data;
 408  * used for remote DMA write in mode 0 / 2 / 4
 409  */
 410 static __inline void
 411 WrWordbxToDRAM(struct rdp_softc *sc, u_short val)
 412 {
 413
 414         outb(sc->baseaddr + lpt_data, val & 0x0F);
 415         val >>= 4;
 416         outb(sc->baseaddr + lpt_data, (val & 0x0F) + HNib);
 417         val >>= 4;
 418         outb(sc->baseaddr + lpt_data, val & 0x0F);
 419         val >>= 4;
 420         outb(sc->baseaddr + lpt_data, val + HNib);
 421 }
 422
 423
 424 /*
 425  * Write the u_short to DRAM via lpt_control;
 426  * used for remote DMA write in mode 1 / 3 / 5
 427  */
 428 static __inline void
 429 WrWordbxToDRAMA(struct rdp_softc *sc, u_short val)
 430 {
 431
 432         outb(sc->baseaddr + lpt_data, val & 0x0F);
 433         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
 434         val >>= 4;
 435         outb(sc->baseaddr + lpt_data, (val & 0x0F) + HNib);
 436         outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
 437         val >>= 4;
 438         outb(sc->baseaddr + lpt_data, val & 0x0F);
 439         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
 440         val >>= 4;
 441         outb(sc->baseaddr + lpt_data, val + HNib);
 442         outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
 443 }
 444 #endif
 445
 446
 447 /*
 448  * Determine if the device is present
 449  *
 450  *   on entry:
 451  *      a pointer to an isa_device struct
 452  *   on exit:
 453  *      0 if device not found
 454  *      or # of i/o addresses used (if found)
 455  */
 456 static int
 457 rdp_probe(struct isa_device *isa_dev)
 458 {
 459         int unit = isa_dev->id_unit;
 460         struct rdp_softc *sc = &rdp_softc[unit];
 461         u_char b1, b2;
 462         intrmask_t irqmap[3];
 463         u_char sval[3];
 464
 465         if (unit < 0 || unit >= NRDP)
 466                 return 0;
 467
 468         sc->baseaddr = isa_dev->id_iobase;
 469         if (isa_dev->id_flags & 1)
 470                 sc->eeprom = EEPROM_74S288;
 471         /* else defaults to 93C46 */
 472         if (isa_dev->id_flags & 2)
 473                 sc->slow = 1;
 474
 475         /* let R/WB = A/DB = CSB = high to be ready for next r/w cycle */
 476         outb(sc->baseaddr + lpt_data, 0xFF);
 477         /* DIR = 0 for write mode, IRQEN=0, SLCT=INIT=AUTOFEED=STB=high */
 478         outb(sc->baseaddr + lpt_control, Ctrl_SelData);
 479         /* software reset */
 480         WrNib(sc, CMR1 + HNib, MkHi(CMR1_RST));
 481         DELAY(2000);
 482         /* is EPLC alive? */
 483         b1 = RdNib(sc, CMR1);
 484         RdEnd(sc, CMR1);
 485         b2 = RdNib(sc, CMR2) & 0x0f;
 486         b2 |= RdNib(sc, CMR2 + HNib) << 4;
 487         RdEnd(sc, CMR2 + HNib);
 488         /*
 489          * After the reset, we expect CMR1 & 7 to be 1 (rx buffer empty),
 490          * and CMR2 & 0xf7 to be 0x20 (receive mode set to physical and
 491          * broadcasts).
 492          */
 493         if (bootverbose)
 494                 printf("rdp%d: CMR1 = %#x, CMR2 = %#x\n", unit, b1, b2);
 495
 496         if ((b1 & (CMR1_BUFE | CMR1_IRQ | CMR1_TRA)) != CMR1_BUFE
 497             || (b2 & ~CMR2_IRQINV) != CMR2_AM_PB)
 498                 return 0;
 499
 500         /*
 501          * We have found something that could be a RTL 80[01]2, now
 502          * see whether we can generate an interrupt.
 503          */
 504         cpu_disable_intr();
 505
 506         /*
 507          * Test whether our configured IRQ is working.
 508          *
 509          * Set to no acception mode + IRQout, then enable RxE + TxE,
 510          * then cause RBER (by advancing the read pointer although
 511          * the read buffer is empty) to generate an interrupt.
 512          */
 513         WrByte(sc, CMR2, CMR2_IRQOUT);
 514         WrNib(sc, CMR1 + HNib, MkHi(CMR1_TE | CMR1_RE));
 515         WrNib(sc, CMR1, CMR1_RDPAC);
 516         DELAY(1000);
 517
 518         irqmap[0] = isa_irq_pending();
 519         sval[0] = inb(sc->baseaddr + lpt_status);
 520
 521         /* allow IRQs to pass the parallel interface */
 522         outb(sc->baseaddr + lpt_control, Ctrl_IRQEN + Ctrl_SelData);
 523         DELAY(1000);
 524         /* generate interrupt */
 525         WrNib(sc, IMR + HNib, MkHi(ISR_RBER));
 526         DELAY(1000);
 527
 528         irqmap[1] = isa_irq_pending();
 529         sval[1] = inb(sc->baseaddr + lpt_status);
 530
 531         /* de-assert and disable IRQ */
 532         WrNib(sc, IMR + HNib, MkHi(0));
 533         (void)inb(sc->baseaddr + lpt_status); /* might be necessary to
 534                                                  clear IRQ */
 535         DELAY(1000);
 536         irqmap[2] = isa_irq_pending();
 537         sval[2] = inb(sc->baseaddr + lpt_status);
 538
 539         WrNib(sc, CMR1 + HNib, MkHi(0));
 540         outb(sc->baseaddr + lpt_control, Ctrl_SelData);
 541         WrNib(sc, CMR2, CMR2_IRQINV);
 542
 543         cpu_enable_intr();
 544
 545         if (bootverbose)
 546                 printf("rdp%d: irq maps / lpt status "
 547                        "%#x/%#x - %#x/%#x - %#x/%#x (id_irq %#x)\n",
 548                        unit, irqmap[0], sval[0], irqmap[1], sval[1],
 549                        irqmap[2], sval[2], isa_dev->id_irq);
 550
 551         if ((irqmap[1] & isa_dev->id_irq) == 0) {
 552                 printf("rdp%d: configured IRQ (%d) cannot be asserted "
 553                        "by device",
 554                        unit, ffs(isa_dev->id_irq) - 1);
 555                 if (irqmap[1])
 556                         printf(" (probable IRQ: %d)", ffs(irqmap[1]) - 1);
 557                 printf("\n");
 558                 return 0;
 559         }
 560
 561         /*
 562          * XXX should do RAMtest here
 563          */
 564
 565         switch (sc->eeprom) {
 566         case EEPROM_93C46:
 567                 if (rdp_gethwaddr_93c46(sc, sc->arpcom.ac_enaddr) == 0) {
 568                         printf("rdp%d: failed to find a valid hardware "
 569                                "address in EEPROM\n",
 570                                unit);
 571                         return 0;
 572                 }
 573                 break;
 574
 575         case EEPROM_74S288:
 576                 rdp_gethwaddr_74s288(sc, sc->arpcom.ac_enaddr);
 577                 break;
 578         }
 579
 580         return lpt_control + 1;
 581 }
 582
 583 /*
 584  * Install interface into kernel networking data structures
 585  */
 586 static int
 587 rdp_attach(struct isa_device *isa_dev)
 588 {
 589         int unit = isa_dev->id_unit;
 590         struct rdp_softc *sc = &rdp_softc[unit];
 591         struct ifnet *ifp = &sc->arpcom.ac_if;
 592
 593         isa_dev->id_ointr = rdpintr;
 594
 595         /*
 596          * Reset interface
 597          */
 598         rdp_stop(sc);
 599
 600         /*
 601          * Initialize ifnet structure
 602          */
 603         ifp->if_softc = sc;
 604         if_initname(ifp, "rdp", unit);
 605         ifp->if_start = rdp_start;
 606         ifp->if_ioctl = rdp_ioctl;
 607         ifp->if_watchdog = rdp_watchdog;
 608         ifp->if_init = rdp_init;
 609         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 610         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
 611
 612         /*
 613          * Attach the interface
 614          */
 615         ether_ifattach(ifp, sc->arpcom.ac_enaddr);
 616
 617         /*
 618          * Print additional info when attached
 619          */
 620         printf("%s: RealTek RTL%s pocket ethernet, EEPROM %s, %s mode\n",
 621                ifp->if_xname,
 622                "8002",          /* hook for 8012 */
 623                sc->eeprom == EEPROM_93C46? "93C46": "74S288",
 624                sc->slow? "slow": "fast");
 625
 626         return 1;
 627 }
 628
 629 /*
 630  * Reset interface.
 631  */
 632 static void
 633 rdp_reset(struct ifnet *ifp)
 634 {
 635         struct rdp_softc *sc = ifp->if_softc;
 636         int s;
 637
 638         s = splimp();
 639
 640         /*
 641          * Stop interface and re-initialize.
 642          */
 643         rdp_stop(sc);
 644         rdp_init(sc);
 645
 646         (void) splx(s);
 647 }
 648
 649 /*
 650  * Take interface offline.
 651  */
 652 static void
 653 rdp_stop(struct rdp_softc *sc)
 654 {
 655
 656         sc->txbusy = sc->txbusy = 0;
 657
 658         /* disable printer interface interrupts */
 659         sc->irqenbit = 0;
 660         outb(sc->baseaddr + lpt_control, Ctrl_SelData);
 661         outb(sc->baseaddr + lpt_data, 0xff);
 662
 663         /* reset the RTL 8002 */
 664         WrNib(sc, CMR1 + HNib, MkHi(CMR1_RST));
 665         DELAY(100);
 666 }
 667
 668 /*
 669  * Device timeout/watchdog routine. Entered if the device neglects to
 670  * generate an interrupt after a transmit has been started on it.
 671  */
 672 static void
 673 rdp_watchdog(struct ifnet *ifp)
 674 {
 675
 676         log(LOG_ERR, "%s: device timeout\n", ifp->if_xname);
 677         ifp->if_oerrors++;
 678
 679         rdp_reset(ifp);
 680 }
 681
 682 /*
 683  * Initialize device.
 684  */
 685 static void
 686 rdp_init(void *xsc)
 687 {
 688         struct rdp_softc *sc = xsc;
 689         struct ifnet *ifp = &sc->arpcom.ac_if;
 690         int i, s;
 691         u_char reg;
 692
 693         /* address not known */
 694         if (TAILQ_EMPTY(&ifp->if_addrhead))
 695                 return;
 696
 697         s = splimp();
 698
 699         ifp->if_timer = 0;
 700
 701         /* program ethernet ID into the chip */
 702         for (i = 0, reg = IDR0; i < 6; i++, reg++)
 703                 WrByte(sc, reg, sc->arpcom.ac_enaddr[i]);
 704
 705         /* set accept mode */
 706         WrNib(sc, CMR2 + HNib,
 707               MkHi((ifp->if_flags & IFF_PROMISC)? CMR2_AM_ALL: CMR2_AM_PB));
 708
 709         /* enable tx and rx */
 710         WrNib(sc, CMR1 + HNib, MkHi(CMR1_TE | CMR1_RE));
 711
 712         /* allow interrupts to happen */
 713         WrNib(sc, CMR2, CMR2_IRQOUT | CMR2_IRQINV);
 714         WrNib(sc, IMR, ISR_TOK | ISR_TER | ISR_ROK | ISR_RER);
 715         WrNib(sc, IMR + HNib, MkHi(ISR_RBER));
 716
 717         /* allow IRQs to pass the parallel interface */
 718         sc->irqenbit = Ctrl_IRQEN;
 719         outb(sc->baseaddr + lpt_control, sc->irqenbit + Ctrl_SelData);
 720
 721         /* clear all flags */
 722         sc->txbusy = sc->txbuffered = 0;
 723
 724         /*
 725          * Set 'running' flag, and clear output active flag.
 726          */
 727         ifp->if_flags |= IFF_RUNNING;
 728         ifp->if_flags &= ~IFF_OACTIVE;
 729
 730         /*
 731          * ...and attempt to start output
 732          */
 733         rdp_start(ifp);
 734
 735         (void) splx(s);
 736 }
 737
 738 /*
 739  * Start output on interface.
 740  * We make two assumptions here:
 741  *  1) that the current priority is set to splimp _before_ this code
 742  *     is called *and* is returned to the appropriate priority after
 743  *     return
 744  *  2) that the IFF_OACTIVE flag is checked before this code is called
 745  *     (i.e. that the output part of the interface is idle)
 746  */
 747 static void
 748 rdp_start(struct ifnet *ifp)
 749 {
 750         struct rdp_softc *sc = ifp->if_softc;
 751         struct mbuf *m;
 752         int len;
 753
 754 outloop:
 755
 756         /*
 757          * See if there is room to put another packet in the buffer.
 758          */
 759         if (sc->txbuffered) {
 760                 /*
 761                  * No room. Indicate this to the outside world and exit.
 762                  */
 763                 ifp->if_flags |= IFF_OACTIVE;
 764                 return;
 765         }
 766         IF_DEQUEUE(&ifp->if_snd, m);
 767         if (m == 0) {
 768                 /*
 769                  * We are using the !OACTIVE flag to indicate to the outside
 770                  * world that we can accept an additional packet rather than
 771                  * that the transmitter is _actually_ active. Indeed, the
 772                  * transmitter may be active, but if we haven't filled all the
 773                  * buffers with data then we still want to accept more.
 774                  */
 775                 ifp->if_flags &= ~IFF_OACTIVE;
 776                 return;
 777         }
 778
 779         /*
 780          * Copy the mbuf chain into the transmit buffer
 781          */
 782
 783         len = rdp_write_mbufs(sc, m);
 784         if (len == 0)
 785                 goto outloop;
 786
 787         /* ensure minimal valid ethernet length */
 788         len = max(len, (ETHER_MIN_LEN-ETHER_CRC_LEN));
 789
 790         /*
 791          * Actually start the transceiver.  Set a timeout in case the
 792          * Tx interrupt never arrives.
 793          */
 794         if (!sc->txbusy) {
 795                 WrNib(sc, TBCR1, len >> 8);
 796                 WrByte(sc, TBCR0, len & 0xff);
 797                 WrNib(sc, CMR1, CMR1_TRA);
 798                 sc->txbusy = 1;
 799                 ifp->if_timer = 2;
 800         } else {
 801                 sc->txbuffered = 1;
 802                 sc->txsize = len;
 803         }
 804
 805         /*
 806          * Tap off here if there is a bpf listener.
 807          */
 808         if (ifp->if_bpf) {
 809                 bpf_mtap(ifp, m);
 810         }
 811
 812         m_freem(m);
 813
 814         /*
 815          * Loop back to the top to possibly buffer more packets
 816          */
 817         goto outloop;
 818 }
 819
 820 /*
 821  * Process an ioctl request.
 822  */
 823 static int
 824 rdp_ioctl(struct ifnet *ifp, IOCTL_CMD_T command, caddr_t data,
 825           struct ucred *ur)
 826 {
 827         struct rdp_softc *sc = ifp->if_softc;
 828         int s, error = 0;
 829
 830         s = splimp();
 831
 832         switch (command) {
 833
 834         case SIOCSIFADDR:
 835         case SIOCGIFADDR:
 836         case SIOCSIFMTU:
 837                 error = ether_ioctl(ifp, command, data);
 838                 break;
 839
 840         case SIOCSIFFLAGS:
 841                 /*
 842                  * If the interface is marked up and stopped, then start it.
 843                  * If it is marked down and running, then stop it.
 844                  */
 845                 if (ifp->if_flags & IFF_UP) {
 846                         if ((ifp->if_flags & IFF_RUNNING) == 0)
 847                                 rdp_init(sc);
 848                 } else {
 849                         if (ifp->if_flags & IFF_RUNNING) {
 850                                 rdp_stop(sc);
 851                                 ifp->if_flags &= ~IFF_RUNNING;
 852                         }
 853                 }
 854
 855                 /*
 856                  * Promiscuous flag may have changed, propagage this
 857                  * to the NIC.
 858                  */
 859                 if (ifp->if_flags & IFF_UP)
 860                         WrNib(sc, CMR2 + HNib,
 861                               MkHi((ifp->if_flags & IFF_PROMISC)?
 862                                    CMR2_AM_ALL: CMR2_AM_PB));
 863
 864                 break;
 865
 866         case SIOCADDMULTI:
 867         case SIOCDELMULTI:
 868                 /*
 869                  * Multicast list has changed; we don't support it.
 870                  */
 871                 error = ENOTTY;
 872                 break;
 873
 874         default:
 875                 error = EINVAL;
 876         }
 877         (void) splx(s);
 878         return (error);
 879 }
 880
 881 /*
 882  * External interrupt service routine.
 883  */
 884 void
 885 rdpintr(int unit)
 886 {
 887         struct rdp_softc *sc = rdp_softc + unit;
 888         struct ifnet *ifp = (struct ifnet *)sc;
 889         u_char isr, tsr, rsr, colls;
 890
 891         /* disable interrupts, so SD3 can be routed to the pin */
 892         sc->irqenbit = 0;
 893         outb(sc->baseaddr + lpt_control, Ctrl_SelData);
 894         WrNib(sc, CMR2, CMR2_IRQINV);
 895         /*
 896          * loop until there are no more new interrupts
 897          */
 898         for (;;) {
 899                 isr = RdNib(sc, ISR);
 900                 isr |= RdNib(sc, ISR + HNib) << 4;
 901                 RdEnd(sc, ISR + HNib);
 902
 903                 if (isr == 0)
 904                         break;
 905 #if DEBUG & 4
 906                 printf("rdp%d: ISR = %#x\n", unit, isr);
 907 #endif
 908
 909                 /*
 910                  * Clear the pending interrupt bits.
 911                  */
 912                 WrNib(sc, ISR, isr & 0x0f);
 913                 if (isr & 0xf0)
 914                         WrNib(sc, ISR + HNib, MkHi(isr));
 915
 916                 /*
 917                  * Handle transmitter interrupts.
 918                  */
 919                 if (isr & (ISR_TOK | ISR_TER)) {
 920                         tsr = RdNib(sc, TSR);
 921                         RdEnd(sc, TSR);
 922 #if DEBUG & 4
 923                         if (isr & ISR_TER)
 924                                 printf("rdp%d: tsr %#x\n", unit, tsr);
 925 #endif
 926                         if (tsr & TSR_TABT)
 927                                 ifp->if_oerrors++;
 928                         else
 929                                 /*
 930                                  * Update total number of successfully
 931                                  * transmitted packets.
 932                                  */
 933                                 ifp->if_opackets++;
 934
 935                         if (tsr & TSR_COL) {
 936                                 colls = RdNib(sc, COLR);
 937                                 RdEnd(sc, COLR);
 938                                 ifp->if_collisions += colls;
 939                         }
 940
 941                         /*
 942                          * reset tx busy and output active flags
 943                          */
 944                         sc->txbusy = 0;
 945                         ifp->if_flags &= ~IFF_OACTIVE;
 946
 947                         /*
 948                          * If we had already queued up another packet,
 949                          * start sending it now.
 950                          */
 951                         if (sc->txbuffered) {
 952                                 WrNib(sc, TBCR1, sc->txsize >> 8);
 953                                 WrByte(sc, TBCR0, sc->txsize & 0xff);
 954                                 WrNib(sc, CMR1, CMR1_TRA);
 955                                 sc->txbusy = 1;
 956                                 sc->txbuffered = 0;
 957                                 ifp->if_timer = 2;
 958                         } else {
 959                                 /*
 960                                  * clear watchdog timer
 961                                  */
 962                                 ifp->if_timer = 0;
 963                         }
 964
 965                 }
 966
 967                 /*
 968                  * Handle receiver interrupts
 969                  */
 970                 if (isr & (ISR_ROK | ISR_RER | ISR_RBER)) {
 971                         rsr = RdNib(sc, RSR);
 972                         rsr |= RdNib(sc, RSR + HNib) << 4;
 973                         RdEnd(sc, RSR + HNib);
 974 #if DEBUG & 4
 975                         if (isr & (ISR_RER | ISR_RBER))
 976                                 printf("rdp%d: rsr %#x\n", unit, rsr);
 977 #endif
 978
 979                         if (rsr & (RSR_PUN | RSR_POV)) {
 980                                 printf("rdp%d: rsr %#x, resetting\n",
 981                                        unit, rsr);
 982                                 rdp_reset(ifp);
 983                                 break;
 984                         }
 985
 986                         if (rsr & RSR_BUFO)
 987                                 /*
 988                                  * CRC and FA errors are recorded in
 989                                  * rdp_rint() on a per-packet basis
 990                                  */
 991                                 ifp->if_ierrors++;
 992                         if (isr & (ISR_ROK | ISR_RER))
 993                                 rdp_rint(sc);
 994                 }
 995
 996                 /*
 997                  * If it looks like the transmitter can take more data,
 998                  * attempt to start output on the interface. This is done
 999                  * after handling the receiver to give the receiver priority.
1000                  */
1001                 if ((ifp->if_flags & IFF_OACTIVE) == 0)
1002                         rdp_start(ifp);
1003
1004         }
1005         /* re-enable interrupts */
1006         WrNib(sc, CMR2, CMR2_IRQOUT | CMR2_IRQINV);
1007         sc->irqenbit = Ctrl_IRQEN;
1008         outb(sc->baseaddr + lpt_control, Ctrl_SelData + sc->irqenbit);
1009 }
1010
1011 /*
1012  * Ethernet interface receiver interrupt.
1013  */
1014 static void
1015 rdp_rint(struct rdp_softc *sc)
1016 {
1017         struct ifnet *ifp = &sc->arpcom.ac_if;
1018         struct rdphdr rh;
1019         u_short len;
1020         size_t i;
1021         u_char *packet_ptr, b, status;
1022         int excessive_bad_pkts = 0;
1023
1024         /*
1025          * Fetch the packets from the NIC's buffer.
1026          */
1027         for (;;) {
1028                 b = RdNib(sc, CMR1);
1029                 RdEnd(sc, CMR1);
1030
1031                 if (b & CMR1_BUFE)
1032                         /* no more packets */
1033                         break;
1034
1035                 /* first, obtain the buffer header */
1036
1037                 outb(sc->baseaddr + lpt_data, MAR + EOC); /* prepare addr */
1038                 outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
1039                 outb(sc->baseaddr + lpt_data, MAR + RdAddr + HNib);
1040
1041                 packet_ptr = (u_char *)&rh;
1042                 if (sc->slow)
1043                         for (i = 0; i < sizeof rh; i++, packet_ptr++)
1044                                 *packet_ptr = RdByteA2(sc);
1045                 else
1046                         for (i = 0; i < sizeof rh; i++, packet_ptr++)
1047                                 *packet_ptr = RdByteA1(sc);
1048
1049                 RdEnd(sc, MAR + HNib);
1050                 outb(sc->baseaddr + lpt_control, Ctrl_SelData);
1051
1052                 len = rh.pktlen - ETHER_CRC_LEN;
1053                 status = rh.status;
1054
1055                 if ((status & (RSR_ROK | RSR_CRC | RSR_FA)) != RSR_ROK ||
1056                     len > (ETHER_MAX_LEN - ETHER_CRC_LEN) ||
1057                     len < (ETHER_MIN_LEN - ETHER_CRC_LEN) ||
1058                     len > MCLBYTES) {
1059 #if DEBUG
1060                         printf("%s: bad packet in buffer, "
1061                                "len %d, status %#x\n",
1062                                ifp->if_xname, (int)len, (int)status);
1063 #endif
1064                         ifp->if_ierrors++;
1065                         /* rx jump packet */
1066                         WrNib(sc, CMR1, CMR1_RDPAC);
1067                         if (++excessive_bad_pkts > 5) {
1068                                 /*
1069                                  * the chip seems to be stuck, we are
1070                                  * probably seeing the same bad packet
1071                                  * over and over again
1072                                  */
1073 #if DEBUG
1074                                 printf("%s: resetting due to an "
1075                                        "excessive number of bad packets\n",
1076                                        ifp->if_xname);
1077 #endif
1078                                 rdp_reset(ifp);
1079                                 return;
1080                         }
1081                         continue;
1082                 }
1083
1084                 /*
1085                  * Go get packet.
1086                  */
1087                 excessive_bad_pkts = 0;
1088                 rdp_get_packet(sc, len);
1089                 ifp->if_ipackets++;
1090         }
1091 }
1092
1093 /*
1094  * Retreive packet from NIC memory and send to the next level up via
1095  * ether_input().
1096  */
1097 static void
1098 rdp_get_packet(struct rdp_softc *sc, unsigned len)
1099 {
1100         struct ifnet *ifp = &sc->arpcom.ac_if;
1101         struct mbuf *m;
1102         u_char *packet_ptr;
1103         size_t s;
1104
1105         /* Allocate a header mbuf */
1106         MGETHDR(m, MB_DONTWAIT, MT_DATA);
1107         if (m == NULL)
1108                 return;
1109         m->m_pkthdr.rcvif = ifp;
1110         m->m_pkthdr.len = m->m_len = len;
1111
1112         /*
1113          * We always put the received packet in a single buffer -
1114          * either with just an mbuf header or in a cluster attached
1115          * to the header. The +2 is to compensate for the alignment
1116          * fixup below.
1117          */
1118         if ((len + 2) > MHLEN) {
1119                 /* Attach an mbuf cluster */
1120                 MCLGET(m, MB_DONTWAIT);
1121
1122                 /* Insist on getting a cluster */
1123                 if ((m->m_flags & M_EXT) == 0) {
1124                         m_freem(m);
1125                         return;
1126                 }
1127         }
1128
1129         /*
1130          * The +2 is to longword align the start of the real packet.
1131          * This is important for NFS.
1132          */
1133         m->m_data += 2;
1134
1135         /*
1136          * Get packet, including link layer address, from interface.
1137          */
1138         outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
1139         outb(sc->baseaddr + lpt_data, RdAddr + MAR);
1140
1141         packet_ptr = mtod(m, u_char *);
1142         if (sc->slow)
1143                 for (s = 0; s < len; s++, packet_ptr++)
1144                         *packet_ptr = RdByteA2(sc);
1145         else
1146                 for (s = 0; s < len; s++, packet_ptr++)
1147                         *packet_ptr = RdByteA1(sc);
1148
1149         RdEnd(sc, MAR + HNib);
1150         outb(sc->baseaddr + lpt_control, Ctrl_SelData);
1151         WrNib(sc, CMR1, CMR1_RDPAC);
1152
1153         (*ifp->if_input)(ifp, m);
1154 }
1155
1156 /*
1157  * Write an mbuf chain to the NIC's tx buffer.
1158  */
1159 static u_short
1160 rdp_write_mbufs(struct rdp_softc *sc, struct mbuf *m)
1161 {
1162         u_short total_len;
1163         struct mbuf *mp;
1164         u_char *dp, b;
1165         int i;
1166
1167         /* First, count up the total number of bytes to copy */
1168         for (total_len = 0, mp = m; mp; mp = mp->m_next)
1169                 total_len += mp->m_len;
1170
1171         if (total_len == 0)
1172                 return 0;
1173
1174         outb(sc->baseaddr + lpt_data, MAR | EOC);
1175
1176         /*
1177          * Transfer the mbuf chain to the NIC memory.
1178          */
1179         if (sc->slow) {
1180                 /* writing the first byte is complicated */
1181                 outb(sc->baseaddr + lpt_control,
1182                      Ctrl_LNibRead | sc->irqenbit);
1183                 outb(sc->baseaddr + lpt_data, MAR | WrAddr);
1184                 b = *(u_char *)m->m_data;
1185                 outb(sc->baseaddr + lpt_data, (b & 0x0f) | 0x40);
1186                 outb(sc->baseaddr + lpt_data, b & 0x0f);
1187                 outb(sc->baseaddr + lpt_data, b >> 4);
1188                 outb(sc->baseaddr + lpt_control,
1189                      Ctrl_HNibRead | sc->irqenbit);
1190                 /* advance the mbuf pointer */
1191                 mp = m;
1192                 m->m_len--;
1193                 m->m_data++;
1194                 /* write the remaining bytes */
1195                 while (m) {
1196                         for (i = 0, dp = (u_char *)m->m_data;
1197                              i < m->m_len;
1198                              i++, dp++)
1199                                 WrByteALToDRAMA(sc, *dp);
1200                         m = m->m_next;
1201                 }
1202                 /*
1203                  * restore old mbuf in case we have to hand it off to
1204                  * BPF again
1205                  */
1206                 m = mp;
1207                 m->m_len++;
1208                 m->m_data--;
1209
1210                 /* the RTL 8002 requires an even byte-count remote DMA */
1211                 if (total_len & 1)
1212                         WrByteALToDRAMA(sc, 0);
1213         } else {
1214                 outb(sc->baseaddr + lpt_data, MAR | WrAddr);
1215                 while (m) {
1216                         for (i = 0, dp = (u_char *)m->m_data;
1217                              i < m->m_len;
1218                              i++, dp++)
1219                                 WrByteALToDRAM(sc, *dp);
1220                         m = m->m_next;
1221                 }
1222
1223                 /* the RTL 8002 requires an even byte-count remote DMA */
1224                 if (total_len & 1)
1225                         WrByteALToDRAM(sc, 0);
1226         }
1227
1228         outb(sc->baseaddr + lpt_data, 0xff);
1229         outb(sc->baseaddr + lpt_control,
1230              Ctrl_HNibRead | Ctrl_SelData | sc->irqenbit);
1231
1232         return total_len;
1233 }
1234
1235 /*
1236  * Read the designated ethernet hardware address out of a 93C46
1237  * (serial) EEPROM.
1238  * Note that the 93C46 uses 16-bit words in big-endian notation.
1239  */
1240 static int
1241 rdp_gethwaddr_93c46(struct rdp_softc *sc, u_char *etheraddr)
1242 {
1243         int i, magic;
1244         size_t j = 0;
1245         u_short w;
1246
1247         WrNib(sc, CMR2, CMR2_PAGE | CMR2_IRQINV); /* select page 1 */
1248
1249         /*
1250          * The original RealTek packet driver had the ethernet address
1251          * starting at EEPROM address 0.  Other vendors seem to have
1252          * gone `creative' here -- while they didn't do anything else
1253          * than changing a few strings in the entire driver, compared
1254          * to the RealTek version, they also moved out the ethernet
1255          * address to a different location in the EEPROM, so the
1256          * original RealTek driver won't work correctly with them, and
1257          * vice versa.  Sounds pretty cool, eh?  $@%&!
1258          *
1259          * Anyway, we walk through the EEPROM, until we find some
1260          * allowable value based upon our table of IEEE OUI assignments.
1261          */
1262         for (i = magic = 0; magic < 3 && i < 32; i++) {
1263                 /* read cmd (+ 6 bit address) */
1264                 rdp_93c46_cmd(sc, 0x180 + i, 10);
1265                 w = rdp_93c46_read(sc);
1266                 switch (magic) {
1267                 case 0:
1268                         for (j = 0;
1269                              j < sizeof allowed_ouis / sizeof(u_short);
1270                              j++)
1271                                 if (w == allowed_ouis[j]) {
1272                                         etheraddr[0] = (w >> 8) & 0xff;
1273                                         etheraddr[1] = w & 0xff;
1274                                         magic++;
1275                                         break;
1276                                 }
1277                         break;
1278
1279                 case 1:
1280                         /*
1281                          * If the first two bytes have been 00:00, we
1282                          * discard the match iff the next two bytes
1283                          * are also 00:00, so we won't get fooled by
1284                          * an EEPROM that has been filled with zeros.
1285                          * This in theory would disallow 64 K of legal
1286                          * addresses assigned to Xerox, but it's
1287                          * almost certain that those addresses haven't
1288                          * been used for RTL80[01]2 chips anyway.
1289                          */
1290                         if ((etheraddr[0] | etheraddr[1]) == 0 && w == 0) {
1291                                 magic--;
1292                                 break;
1293                         }
1294
1295                         etheraddr[2] = (w >> 8) & 0xff;
1296                         etheraddr[3] = w & 0xff;
1297                         magic++;
1298                         break;
1299
1300                 case 2:
1301                         etheraddr[4] = (w >> 8) & 0xff;
1302                         etheraddr[5] = w & 0xff;
1303                         magic++;
1304                         break;
1305                 }
1306         }
1307
1308         WrNib(sc, CMR2, CMR2_IRQINV);   /* back to page 0 */
1309
1310         return magic == 3;
1311 }
1312
1313 /*
1314  * Read the designated ethernet hardware address out of a 74S288
1315  * EEPROM.
1316  *
1317  * This is untested, since i haven't seen any adapter actually using
1318  * a 74S288.  In the RTL 8012, only the serial EEPROM (94C46) is
1319  * supported anymore.
1320  */
1321 static void
1322 rdp_gethwaddr_74s288(struct rdp_softc *sc, u_char *etheraddr)
1323 {
1324         int i;
1325         u_char b;
1326
1327         WrNib(sc, CMR2, CMR2_PAGE | CMR2_IRQINV); /* select page 1 */
1328
1329         for (i = 0; i < 6; i++) {
1330                 WrNib(sc, PCMR, i & 0x0f); /* lower 4 bit of addr */
1331                 WrNib(sc, PCMR + HNib, HNib + 4); /* upper 2 bit addr + /CS */
1332                 WrNib(sc, PCMR + HNib, HNib); /* latch data now */
1333                 b = RdNib(sc, PDR) & 0x0f;
1334                 b |= (RdNib(sc, PDR + HNib) & 0x0f) << 4;
1335                 etheraddr[i] = b;
1336         }
1337
1338         RdEnd(sc, PDR + HNib);
1339         WrNib(sc, CMR2, CMR2_IRQINV);   /* reselect page 0 */
1340 }
1341
1342 /*
1343  * Send nbits of data (starting with MSB) out to the 93c46 as a
1344  * command.  Assumes register page 1 has already been selected.
1345  */
1346 static void
1347 rdp_93c46_cmd(struct rdp_softc *sc, u_short data, unsigned nbits)
1348 {
1349         u_short mask = 1 << (nbits - 1);
1350         unsigned i;
1351         u_char b;
1352
1353 #if DEBUG & 2
1354         printf("rdp_93c46_cmd(): ");
1355 #endif
1356         for (i = 0; i < nbits; i++, mask >>= 1) {
1357                 b = HNib + PCMR_SK + PCMR_CS;
1358                 if (data & mask)
1359                         b += PCMR_DO;
1360 #if DEBUG & 2
1361                 printf("%d", b & 1);
1362 #endif
1363                 WrNib(sc, PCMR + HNib, b);
1364                 DELAY(1);
1365                 WrNib(sc, PCMR + HNib, b & ~PCMR_SK);
1366                 DELAY(1);
1367         }
1368 #if DEBUG & 2
1369         printf("\n");
1370 #endif
1371 }
1372
1373 /*
1374  * Read one word of data from the 93c46.  Actually, we have to read
1375  * 17 bits, and discard the very first bit.  Assumes register page 1
1376  * to be selected as well.
1377  */
1378 static u_short
1379 rdp_93c46_read(struct rdp_softc *sc)
1380 {
1381         u_short data = 0;
1382         u_char b;
1383         int i;
1384
1385 #if DEBUG & 2
1386         printf("rdp_93c46_read(): ");
1387 #endif
1388         for (i = 0; i < 17; i++) {
1389                 WrNib(sc, PCMR + HNib, PCMR_SK + PCMR_CS + HNib);
1390                 DELAY(1);
1391                 WrNib(sc, PCMR + HNib, PCMR_CS + HNib);
1392                 DELAY(1);
1393                 b = RdNib(sc, PDR);
1394                 data <<= 1;
1395                 if (b & 1)
1396                         data |= 1;
1397 #if DEBUG & 2
1398                 printf("%d", b & 1);
1399 #endif
1400                 RdEnd(sc, PDR);
1401                 DELAY(1);
1402         }
1403
1404 #if DEBUG & 2
1405         printf("\n");
1406 #endif
1407         /* end of cycle */
1408         WrNib(sc, PCMR + HNib, PCMR_SK + HNib);
1409         DELAY(1);
1410
1411         return data;
1412 }