sys/pci/if_rl.c

   1 /*
   2  * Copyright (c) 1997, 1998
   3  *      Bill Paul <wpaul@ctr.columbia.edu>.  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, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  *      $Id: if_rl.c,v 1.18 1999/07/02 04:17:14 peter Exp $
  33  */
  34
  35 /*
  36  * RealTek 8129/8139 PCI NIC driver
  37  *
  38  * Supports several extremely cheap PCI 10/100 adapters based on
  39  * the RealTek chipset. Datasheets can be obtained from
  40  * www.realtek.com.tw.
  41  *
  42  * Written by Bill Paul <wpaul@ctr.columbia.edu>
  43  * Electrical Engineering Department
  44  * Columbia University, New York City
  45  */
  46
  47 /*
  48  * The RealTek 8139 PCI NIC redefines the meaning of 'low end.' This is
  49  * probably the worst PCI ethernet controller ever made, with the possible
  50  * exception of the FEAST chip made by SMC. The 8139 supports bus-master
  51  * DMA, but it has a terrible interface that nullifies any performance
  52  * gains that bus-master DMA usually offers.
  53  *
  54  * For transmission, the chip offers a series of four TX descriptor
  55  * registers. Each transmit frame must be in a contiguous buffer, aligned
  56  * on a longword (32-bit) boundary. This means we almost always have to
  57  * do mbuf copies in order to transmit a frame, except in the unlikely
  58  * case where a) the packet fits into a single mbuf, and b) the packet
  59  * is 32-bit aligned within the mbuf's data area. The presence of only
  60  * four descriptor registers means that we can never have more than four
  61  * packets queued for transmission at any one time.
  62  *
  63  * Reception is not much better. The driver has to allocate a single large
  64  * buffer area (up to 64K in size) into which the chip will DMA received
  65  * frames. Because we don't know where within this region received packets
  66  * will begin or end, we have no choice but to copy data from the buffer
  67  * area into mbufs in order to pass the packets up to the higher protocol
  68  * levels.
  69  *
  70  * It's impossible given this rotten design to really achieve decent
  71  * performance at 100Mbps, unless you happen to have a 400Mhz PII or
  72  * some equally overmuscled CPU to drive it.
  73  *
  74  * On the bright side, the 8139 does have a built-in PHY, although
  75  * rather than using an MDIO serial interface like most other NICs, the
  76  * PHY registers are directly accessible through the 8139's register
  77  * space. The 8139 supports autonegotiation, as well as a 64-bit multicast
  78  * filter.
  79  *
  80  * The 8129 chip is an older version of the 8139 that uses an external PHY
  81  * chip. The 8129 has a serial MDIO interface for accessing the MII where
  82  * the 8139 lets you directly access the on-board PHY registers. We need
  83  * to select which interface to use depending on the chip type.
  84  */
  85
  86 #include "bpf.h"
  87
  88 #include <sys/param.h>
  89 #include <sys/systm.h>
  90 #include <sys/sockio.h>
  91 #include <sys/mbuf.h>
  92 #include <sys/malloc.h>
  93 #include <sys/kernel.h>
  94 #include <sys/socket.h>
  95
  96 #include <net/if.h>
  97 #include <net/if_arp.h>
  98 #include <net/ethernet.h>
  99 #include <net/if_dl.h>
 100 #include <net/if_media.h>
 101
 102 #if NBPF > 0
 103 #include <net/bpf.h>
 104 #endif
 105
 106 #include <vm/vm.h>              /* for vtophys */
 107 #include <vm/pmap.h>            /* for vtophys */
 108 #include <machine/clock.h>      /* for DELAY */
 109 #include <machine/bus_pio.h>
 110 #include <machine/bus_memio.h>
 111 #include <machine/bus.h>
 112
 113 #include <pci/pcireg.h>
 114 #include <pci/pcivar.h>
 115
 116 /*
 117  * Default to using PIO access for this driver. On SMP systems,
 118  * there appear to be problems with memory mapped mode: it looks like
 119  * doing too many memory mapped access back to back in rapid succession
 120  * can hang the bus. I'm inclined to blame this on crummy design/construction
 121  * on the part of RealTek. Memory mapped mode does appear to work on
 122  * uniprocessor systems though.
 123  */
 124 #define RL_USEIOSPACE
 125
 126 #include <pci/if_rlreg.h>
 127
 128 #ifndef lint
 129 static const char rcsid[] =
 130         "$Id: if_rl.c,v 1.18 1999/07/02 04:17:14 peter Exp $";
 131 #endif
 132
 133 /*
 134  * Various supported device vendors/types and their names.
 135  */
 136 static struct rl_type rl_devs[] = {
 137         { RT_VENDORID, RT_DEVICEID_8129,
 138                 "RealTek 8129 10/100BaseTX" },
 139         { RT_VENDORID, RT_DEVICEID_8139,
 140                 "RealTek 8139 10/100BaseTX" },
 141         { ACCTON_VENDORID, ACCTON_DEVICEID_5030,
 142                 "Accton MPX 5030/5038 10/100BaseTX" },
 143         { DELTA_VENDORID, DELTA_DEVICEID_8139,
 144                 "Delta Electronics 8139 10/100BaseTX" },
 145         { ADDTRON_VENDORID, ADDTRON_DEVICEID_8139,
 146                 "Addtron Technolgy 8139 10/100BaseTX" },
 147         { SIS_VENDORID, SIS_DEVICEID_8139,
 148                 "SiS 900 10/100BaseTX" },
 149         { 0, 0, NULL }
 150 };
 151
 152 /*
 153  * Various supported PHY vendors/types and their names. Note that
 154  * this driver will work with pretty much any MII-compliant PHY,
 155  * so failure to positively identify the chip is not a fatal error.
 156  */
 157
 158 static struct rl_type rl_phys[] = {
 159         { TI_PHY_VENDORID, TI_PHY_10BT, "<TI ThunderLAN 10BT (internal)>" },
 160         { TI_PHY_VENDORID, TI_PHY_100VGPMI, "<TI TNETE211 100VG Any-LAN>" },
 161         { NS_PHY_VENDORID, NS_PHY_83840A, "<National Semiconductor DP83840A>"},
 162         { LEVEL1_PHY_VENDORID, LEVEL1_PHY_LXT970, "<Level 1 LXT970>" },
 163         { INTEL_PHY_VENDORID, INTEL_PHY_82555, "<Intel 82555>" },
 164         { SEEQ_PHY_VENDORID, SEEQ_PHY_80220, "<SEEQ 80220>" },
 165         { 0, 0, "<MII-compliant physical interface>" }
 166 };
 167
 168 static unsigned long rl_count = 0;
 169 static const char *rl_probe     __P((pcici_t, pcidi_t));
 170 static void rl_attach           __P((pcici_t, int));
 171
 172 static int rl_encap             __P((struct rl_softc *, struct mbuf * ));
 173
 174 static void rl_rxeof            __P((struct rl_softc *));
 175 static void rl_txeof            __P((struct rl_softc *));
 176 static void rl_intr             __P((void *));
 177 static void rl_start            __P((struct ifnet *));
 178 static int rl_ioctl             __P((struct ifnet *, u_long, caddr_t));
 179 static void rl_init             __P((void *));
 180 static void rl_stop             __P((struct rl_softc *));
 181 static void rl_watchdog         __P((struct ifnet *));
 182 static void rl_shutdown         __P((int, void *));
 183 static int rl_ifmedia_upd       __P((struct ifnet *));
 184 static void rl_ifmedia_sts      __P((struct ifnet *, struct ifmediareq *));
 185
 186 static void rl_eeprom_putbyte   __P((struct rl_softc *, int));
 187 static void rl_eeprom_getword   __P((struct rl_softc *, int, u_int16_t *));
 188 static void rl_read_eeprom      __P((struct rl_softc *, caddr_t,
 189                                         int, int, int));
 190 static void rl_mii_sync         __P((struct rl_softc *));
 191 static void rl_mii_send         __P((struct rl_softc *, u_int32_t, int));
 192 static int rl_mii_readreg       __P((struct rl_softc *, struct rl_mii_frame *));
 193 static int rl_mii_writereg      __P((struct rl_softc *, struct rl_mii_frame *));
 194
 195 static u_int16_t rl_phy_readreg __P((struct rl_softc *, int));
 196 static void rl_phy_writereg     __P((struct rl_softc *, int, int));
 197
 198 static void rl_autoneg_xmit     __P((struct rl_softc *));
 199 static void rl_autoneg_mii      __P((struct rl_softc *, int, int));
 200 static void rl_setmode_mii      __P((struct rl_softc *, int));
 201 static void rl_getmode_mii      __P((struct rl_softc *));
 202 static u_int8_t rl_calchash     __P((caddr_t));
 203 static void rl_setmulti         __P((struct rl_softc *));
 204 static void rl_reset            __P((struct rl_softc *));
 205 static int rl_list_tx_init      __P((struct rl_softc *));
 206
 207 #define EE_SET(x)                                       \
 208         CSR_WRITE_1(sc, RL_EECMD,                       \
 209                 CSR_READ_1(sc, RL_EECMD) | x)
 210
 211 #define EE_CLR(x)                                       \
 212         CSR_WRITE_1(sc, RL_EECMD,                       \
 213                 CSR_READ_1(sc, RL_EECMD) & ~x)
 214
 215 /*
 216  * Send a read command and address to the EEPROM, check for ACK.
 217  */
 218 static void rl_eeprom_putbyte(sc, addr)
 219         struct rl_softc         *sc;
 220         int                     addr;
 221 {
 222         register int            d, i;
 223
 224         d = addr | RL_EECMD_READ;
 225
 226         /*
 227          * Feed in each bit and stobe the clock.
 228          */
 229         for (i = 0x400; i; i >>= 1) {
 230                 if (d & i) {
 231                         EE_SET(RL_EE_DATAIN);
 232                 } else {
 233                         EE_CLR(RL_EE_DATAIN);
 234                 }
 235                 DELAY(100);
 236                 EE_SET(RL_EE_CLK);
 237                 DELAY(150);
 238                 EE_CLR(RL_EE_CLK);
 239                 DELAY(100);
 240         }
 241
 242         return;
 243 }
 244
 245 /*
 246  * Read a word of data stored in the EEPROM at address 'addr.'
 247  */
 248 static void rl_eeprom_getword(sc, addr, dest)
 249         struct rl_softc         *sc;
 250         int                     addr;
 251         u_int16_t               *dest;
 252 {
 253         register int            i;
 254         u_int16_t               word = 0;
 255
 256         /* Enter EEPROM access mode. */
 257         CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_PROGRAM|RL_EE_SEL);
 258
 259         /*
 260          * Send address of word we want to read.
 261          */
 262         rl_eeprom_putbyte(sc, addr);
 263
 264         CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_PROGRAM|RL_EE_SEL);
 265
 266         /*
 267          * Start reading bits from EEPROM.
 268          */
 269         for (i = 0x8000; i; i >>= 1) {
 270                 EE_SET(RL_EE_CLK);
 271                 DELAY(100);
 272                 if (CSR_READ_1(sc, RL_EECMD) & RL_EE_DATAOUT)
 273                         word |= i;
 274                 EE_CLR(RL_EE_CLK);
 275                 DELAY(100);
 276         }
 277
 278         /* Turn off EEPROM access mode. */
 279         CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
 280
 281         *dest = word;
 282
 283         return;
 284 }
 285
 286 /*
 287  * Read a sequence of words from the EEPROM.
 288  */
 289 static void rl_read_eeprom(sc, dest, off, cnt, swap)
 290         struct rl_softc         *sc;
 291         caddr_t                 dest;
 292         int                     off;
 293         int                     cnt;
 294         int                     swap;
 295 {
 296         int                     i;
 297         u_int16_t               word = 0, *ptr;
 298
 299         for (i = 0; i < cnt; i++) {
 300                 rl_eeprom_getword(sc, off + i, &word);
 301                 ptr = (u_int16_t *)(dest + (i * 2));
 302                 if (swap)
 303                         *ptr = ntohs(word);
 304                 else
 305                         *ptr = word;
 306         }
 307
 308         return;
 309 }
 310
 311
 312 /*
 313  * MII access routines are provided for the 8129, which
 314  * doesn't have a built-in PHY. For the 8139, we fake things
 315  * up by diverting rl_phy_readreg()/rl_phy_writereg() to the
 316  * direct access PHY registers.
 317  */
 318 #define MII_SET(x)                                      \
 319         CSR_WRITE_1(sc, RL_MII,                         \
 320                 CSR_READ_1(sc, RL_MII) | x)
 321
 322 #define MII_CLR(x)                                      \
 323         CSR_WRITE_1(sc, RL_MII,                         \
 324                 CSR_READ_1(sc, RL_MII) & ~x)
 325
 326 /*
 327  * Sync the PHYs by setting data bit and strobing the clock 32 times.
 328  */
 329 static void rl_mii_sync(sc)
 330         struct rl_softc         *sc;
 331 {
 332         register int            i;
 333
 334         MII_SET(RL_MII_DIR|RL_MII_DATAOUT);
 335
 336         for (i = 0; i < 32; i++) {
 337                 MII_SET(RL_MII_CLK);
 338                 DELAY(1);
 339                 MII_CLR(RL_MII_CLK);
 340                 DELAY(1);
 341         }
 342
 343         return;
 344 }
 345
 346 /*
 347  * Clock a series of bits through the MII.
 348  */
 349 static void rl_mii_send(sc, bits, cnt)
 350         struct rl_softc         *sc;
 351         u_int32_t               bits;
 352         int                     cnt;
 353 {
 354         int                     i;
 355
 356         MII_CLR(RL_MII_CLK);
 357
 358         for (i = (0x1 << (cnt - 1)); i; i >>= 1) {
 359                 if (bits & i) {
 360                         MII_SET(RL_MII_DATAOUT);
 361                 } else {
 362                         MII_CLR(RL_MII_DATAOUT);
 363                 }
 364                 DELAY(1);
 365                 MII_CLR(RL_MII_CLK);
 366                 DELAY(1);
 367                 MII_SET(RL_MII_CLK);
 368         }
 369 }
 370
 371 /*
 372  * Read an PHY register through the MII.
 373  */
 374 static int rl_mii_readreg(sc, frame)
 375         struct rl_softc         *sc;
 376         struct rl_mii_frame     *frame;
 377
 378 {
 379         int                     i, ack, s;
 380
 381         s = splimp();
 382
 383         /*
 384          * Set up frame for RX.
 385          */
 386         frame->mii_stdelim = RL_MII_STARTDELIM;
 387         frame->mii_opcode = RL_MII_READOP;
 388         frame->mii_turnaround = 0;
 389         frame->mii_data = 0;
 390
 391         CSR_WRITE_2(sc, RL_MII, 0);
 392
 393         /*
 394          * Turn on data xmit.
 395          */
 396         MII_SET(RL_MII_DIR);
 397
 398         rl_mii_sync(sc);
 399
 400         /*
 401          * Send command/address info.
 402          */
 403         rl_mii_send(sc, frame->mii_stdelim, 2);
 404         rl_mii_send(sc, frame->mii_opcode, 2);
 405         rl_mii_send(sc, frame->mii_phyaddr, 5);
 406         rl_mii_send(sc, frame->mii_regaddr, 5);
 407
 408         /* Idle bit */
 409         MII_CLR((RL_MII_CLK|RL_MII_DATAOUT));
 410         DELAY(1);
 411         MII_SET(RL_MII_CLK);
 412         DELAY(1);
 413
 414         /* Turn off xmit. */
 415         MII_CLR(RL_MII_DIR);
 416
 417         /* Check for ack */
 418         MII_CLR(RL_MII_CLK);
 419         DELAY(1);
 420         MII_SET(RL_MII_CLK);
 421         DELAY(1);
 422         ack = CSR_READ_2(sc, RL_MII) & RL_MII_DATAIN;
 423
 424         /*
 425          * Now try reading data bits. If the ack failed, we still
 426          * need to clock through 16 cycles to keep the PHY(s) in sync.
 427          */
 428         if (ack) {
 429                 for(i = 0; i < 16; i++) {
 430                         MII_CLR(RL_MII_CLK);
 431                         DELAY(1);
 432                         MII_SET(RL_MII_CLK);
 433                         DELAY(1);
 434                 }
 435                 goto fail;
 436         }
 437
 438         for (i = 0x8000; i; i >>= 1) {
 439                 MII_CLR(RL_MII_CLK);
 440                 DELAY(1);
 441                 if (!ack) {
 442                         if (CSR_READ_2(sc, RL_MII) & RL_MII_DATAIN)
 443                                 frame->mii_data |= i;
 444                         DELAY(1);
 445                 }
 446                 MII_SET(RL_MII_CLK);
 447                 DELAY(1);
 448         }
 449
 450 fail:
 451
 452         MII_CLR(RL_MII_CLK);
 453         DELAY(1);
 454         MII_SET(RL_MII_CLK);
 455         DELAY(1);
 456
 457         splx(s);
 458
 459         if (ack)
 460                 return(1);
 461         return(0);
 462 }
 463
 464 /*
 465  * Write to a PHY register through the MII.
 466  */
 467 static int rl_mii_writereg(sc, frame)
 468         struct rl_softc         *sc;
 469         struct rl_mii_frame     *frame;
 470
 471 {
 472         int                     s;
 473
 474         s = splimp();
 475         /*
 476          * Set up frame for TX.
 477          */
 478
 479         frame->mii_stdelim = RL_MII_STARTDELIM;
 480         frame->mii_opcode = RL_MII_WRITEOP;
 481         frame->mii_turnaround = RL_MII_TURNAROUND;
 482
 483         /*
 484          * Turn on data output.
 485          */
 486         MII_SET(RL_MII_DIR);
 487
 488         rl_mii_sync(sc);
 489
 490         rl_mii_send(sc, frame->mii_stdelim, 2);
 491         rl_mii_send(sc, frame->mii_opcode, 2);
 492         rl_mii_send(sc, frame->mii_phyaddr, 5);
 493         rl_mii_send(sc, frame->mii_regaddr, 5);
 494         rl_mii_send(sc, frame->mii_turnaround, 2);
 495         rl_mii_send(sc, frame->mii_data, 16);
 496
 497         /* Idle bit. */
 498         MII_SET(RL_MII_CLK);
 499         DELAY(1);
 500         MII_CLR(RL_MII_CLK);
 501         DELAY(1);
 502
 503         /*
 504          * Turn off xmit.
 505          */
 506         MII_CLR(RL_MII_DIR);
 507
 508         splx(s);
 509
 510         return(0);
 511 }
 512
 513 static u_int16_t rl_phy_readreg(sc, reg)
 514         struct rl_softc         *sc;
 515         int                     reg;
 516 {
 517         struct rl_mii_frame     frame;
 518         u_int16_t               rval = 0;
 519         u_int16_t               rl8139_reg = 0;
 520
 521         if (sc->rl_type == RL_8139) {
 522                 switch(reg) {
 523                 case PHY_BMCR:
 524                         rl8139_reg = RL_BMCR;
 525                         break;
 526                 case PHY_BMSR:
 527                         rl8139_reg = RL_BMSR;
 528                         break;
 529                 case PHY_ANAR:
 530                         rl8139_reg = RL_ANAR;
 531                         break;
 532                 case PHY_LPAR:
 533                         rl8139_reg = RL_LPAR;
 534                         break;
 535                 default:
 536                         printf("rl%d: bad phy register\n", sc->rl_unit);
 537                         return(0);
 538                 }
 539                 rval = CSR_READ_2(sc, rl8139_reg);
 540                 return(rval);
 541         }
 542
 543         bzero((char *)&frame, sizeof(frame));
 544
 545         frame.mii_phyaddr = sc->rl_phy_addr;
 546         frame.mii_regaddr = reg;
 547         rl_mii_readreg(sc, &frame);
 548
 549         return(frame.mii_data);
 550 }
 551
 552 static void rl_phy_writereg(sc, reg, data)
 553         struct rl_softc         *sc;
 554         int                     reg;
 555         int                     data;
 556 {
 557         struct rl_mii_frame     frame;
 558         u_int16_t               rl8139_reg = 0;
 559
 560         if (sc->rl_type == RL_8139) {
 561                 switch(reg) {
 562                 case PHY_BMCR:
 563                         rl8139_reg = RL_BMCR;
 564                         break;
 565                 case PHY_BMSR:
 566                         rl8139_reg = RL_BMSR;
 567                         break;
 568                 case PHY_ANAR:
 569                         rl8139_reg = RL_ANAR;
 570                         break;
 571                 case PHY_LPAR:
 572                         rl8139_reg = RL_LPAR;
 573                         break;
 574                 default:
 575                         printf("rl%d: bad phy register\n", sc->rl_unit);
 576                         return;
 577                 }
 578                 CSR_WRITE_2(sc, rl8139_reg, data);
 579                 return;
 580         }
 581
 582         bzero((char *)&frame, sizeof(frame));
 583
 584         frame.mii_phyaddr = sc->rl_phy_addr;
 585         frame.mii_regaddr = reg;
 586         frame.mii_data = data;
 587
 588         rl_mii_writereg(sc, &frame);
 589
 590         return;
 591 }
 592
 593 /*
 594  * Calculate CRC of a multicast group address, return the upper 6 bits.
 595  */
 596 static u_int8_t rl_calchash(addr)
 597         caddr_t                 addr;
 598 {
 599         u_int32_t               crc, carry;
 600         int                     i, j;
 601         u_int8_t                c;
 602
 603         /* Compute CRC for the address value. */
 604         crc = 0xFFFFFFFF; /* initial value */
 605
 606         for (i = 0; i < 6; i++) {
 607                 c = *(addr + i);
 608                 for (j = 0; j < 8; j++) {
 609                         carry = ((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01);
 610                         crc <<= 1;
 611                         c >>= 1;
 612                         if (carry)
 613                                 crc = (crc ^ 0x04c11db6) | carry;
 614                 }
 615         }
 616
 617         /* return the filter bit position */
 618         return(crc >> 26);
 619 }
 620
 621 /*
 622  * Program the 64-bit multicast hash filter.
 623  */
 624 static void rl_setmulti(sc)
 625         struct rl_softc         *sc;
 626 {
 627         struct ifnet            *ifp;
 628         int                     h = 0;
 629         u_int32_t               hashes[2] = { 0, 0 };
 630         struct ifmultiaddr      *ifma;
 631         u_int32_t               rxfilt;
 632         int                     mcnt = 0;
 633
 634         ifp = &sc->arpcom.ac_if;
 635
 636         rxfilt = CSR_READ_4(sc, RL_RXCFG);
 637
 638         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
 639                 rxfilt |= RL_RXCFG_RX_MULTI;
 640                 CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
 641                 CSR_WRITE_4(sc, RL_MAR0, 0xFFFFFFFF);
 642                 CSR_WRITE_4(sc, RL_MAR4, 0xFFFFFFFF);
 643                 return;
 644         }
 645
 646         /* first, zot all the existing hash bits */
 647         CSR_WRITE_4(sc, RL_MAR0, 0);
 648         CSR_WRITE_4(sc, RL_MAR4, 0);
 649
 650         /* now program new ones */
 651         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
 652                                 ifma = ifma->ifma_link.le_next) {
 653                 if (ifma->ifma_addr->sa_family != AF_LINK)
 654                         continue;
 655                 h = rl_calchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 656                 if (h < 32)
 657                         hashes[0] |= (1 << h);
 658                 else
 659                         hashes[1] |= (1 << (h - 32));
 660                 mcnt++;
 661         }
 662
 663         if (mcnt)
 664                 rxfilt |= RL_RXCFG_RX_MULTI;
 665         else
 666                 rxfilt &= ~RL_RXCFG_RX_MULTI;
 667
 668         CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
 669         CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
 670         CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
 671
 672         return;
 673 }
 674
 675 /*
 676  * Initiate an autonegotiation session.
 677  */
 678 static void rl_autoneg_xmit(sc)
 679         struct rl_softc         *sc;
 680 {
 681         u_int16_t               phy_sts;
 682
 683         rl_phy_writereg(sc, PHY_BMCR, PHY_BMCR_RESET);
 684         DELAY(500);
 685         while(rl_phy_readreg(sc, PHY_BMCR)
 686                         & PHY_BMCR_RESET);
 687
 688         phy_sts = rl_phy_readreg(sc, PHY_BMCR);
 689         phy_sts |= PHY_BMCR_AUTONEGENBL|PHY_BMCR_AUTONEGRSTR;
 690         rl_phy_writereg(sc, PHY_BMCR, phy_sts);
 691
 692         return;
 693 }
 694
 695 /*
 696  * Invoke autonegotiation on a PHY. Also used with the 8139 internal
 697  * transceiver.
 698  */
 699 static void rl_autoneg_mii(sc, flag, verbose)
 700         struct rl_softc         *sc;
 701         int                     flag;
 702         int                     verbose;
 703 {
 704         u_int16_t               phy_sts = 0, media, advert, ability;
 705         struct ifnet            *ifp;
 706         struct ifmedia          *ifm;
 707
 708         ifm = &sc->ifmedia;
 709         ifp = &sc->arpcom.ac_if;
 710
 711         /*
 712          * The 100baseT4 PHY sometimes has the 'autoneg supported'
 713          * bit cleared in the status register, but has the 'autoneg enabled'
 714          * bit set in the control register. This is a contradiction, and
 715          * I'm not sure how to handle it. If you want to force an attempt
 716          * to autoneg for 100baseT4 PHYs, #define FORCE_AUTONEG_TFOUR
 717          * and see what happens.
 718          */
 719 #ifndef FORCE_AUTONEG_TFOUR
 720         /*
 721          * First, see if autoneg is supported. If not, there's
 722          * no point in continuing.
 723          */
 724         phy_sts = rl_phy_readreg(sc, PHY_BMSR);
 725         if (!(phy_sts & PHY_BMSR_CANAUTONEG)) {
 726                 if (verbose)
 727                         printf("rl%d: autonegotiation not supported\n",
 728                                                         sc->rl_unit);
 729                 return;
 730         }
 731 #endif
 732
 733         switch (flag) {
 734         case RL_FLAG_FORCEDELAY:
 735                 /*
 736                  * XXX Never use this option anywhere but in the probe
 737                  * routine: making the kernel stop dead in its tracks
 738                  * for three whole seconds after we've gone multi-user
 739                  * is really bad manners.
 740                  */
 741                 rl_autoneg_xmit(sc);
 742                 DELAY(5000000);
 743                 break;
 744         case RL_FLAG_SCHEDDELAY:
 745                 /*
 746                  * Wait for the transmitter to go idle before starting
 747                  * an autoneg session, otherwise rl_start() may clobber
 748                  * our timeout, and we don't want to allow transmission
 749                  * during an autoneg session since that can screw it up.
 750                  */
 751                 if (sc->rl_cdata.last_tx != sc->rl_cdata.cur_tx) {
 752                         sc->rl_want_auto = 1;
 753                         return;
 754                 }
 755                 rl_autoneg_xmit(sc);
 756                 ifp->if_timer = 5;
 757                 sc->rl_autoneg = 1;
 758                 sc->rl_want_auto = 0;
 759                 return;
 760                 break;
 761         case RL_FLAG_DELAYTIMEO:
 762                 ifp->if_timer = 0;
 763                 sc->rl_autoneg = 0;
 764                 break;
 765         default:
 766                 printf("rl%d: invalid autoneg flag: %d\n", sc->rl_unit, flag);
 767                 return;
 768         }
 769
 770         if (rl_phy_readreg(sc, PHY_BMSR) & PHY_BMSR_AUTONEGCOMP) {
 771                 if (verbose)
 772                         printf("rl%d: autoneg complete, ", sc->rl_unit);
 773                 phy_sts = rl_phy_readreg(sc, PHY_BMSR);
 774         } else {
 775                 if (verbose)
 776                         printf("rl%d: autoneg not complete, ", sc->rl_unit);
 777         }
 778
 779         media = rl_phy_readreg(sc, PHY_BMCR);
 780
 781         /* Link is good. Report modes and set duplex mode. */
 782         if (rl_phy_readreg(sc, PHY_BMSR) & PHY_BMSR_LINKSTAT) {
 783                 if (verbose)
 784                         printf("link status good ");
 785                 advert = rl_phy_readreg(sc, PHY_ANAR);
 786                 ability = rl_phy_readreg(sc, PHY_LPAR);
 787
 788                 if (advert & PHY_ANAR_100BT4 && ability & PHY_ANAR_100BT4) {
 789                         ifm->ifm_media = IFM_ETHER|IFM_100_T4;
 790                         media |= PHY_BMCR_SPEEDSEL;
 791                         media &= ~PHY_BMCR_DUPLEX;
 792                         printf("(100baseT4)\n");
 793                 } else if (advert & PHY_ANAR_100BTXFULL &&
 794                         ability & PHY_ANAR_100BTXFULL) {
 795                         ifm->ifm_media = IFM_ETHER|IFM_100_TX|IFM_FDX;
 796                         media |= PHY_BMCR_SPEEDSEL;
 797                         media |= PHY_BMCR_DUPLEX;
 798                         printf("(full-duplex, 100Mbps)\n");
 799                 } else if (advert & PHY_ANAR_100BTXHALF &&
 800                         ability & PHY_ANAR_100BTXHALF) {
 801                         ifm->ifm_media = IFM_ETHER|IFM_100_TX|IFM_HDX;
 802                         media |= PHY_BMCR_SPEEDSEL;
 803                         media &= ~PHY_BMCR_DUPLEX;
 804                         printf("(half-duplex, 100Mbps)\n");
 805                 } else if (advert & PHY_ANAR_10BTFULL &&
 806                         ability & PHY_ANAR_10BTFULL) {
 807                         ifm->ifm_media = IFM_ETHER|IFM_10_T|IFM_FDX;
 808                         media &= ~PHY_BMCR_SPEEDSEL;
 809                         media |= PHY_BMCR_DUPLEX;
 810                         printf("(full-duplex, 10Mbps)\n");
 811                 } else {
 812                         ifm->ifm_media = IFM_ETHER|IFM_10_T|IFM_HDX;
 813                         media &= ~PHY_BMCR_SPEEDSEL;
 814                         media &= ~PHY_BMCR_DUPLEX;
 815                         printf("(half-duplex, 10Mbps)\n");
 816                 }
 817
 818                 /* Set ASIC's duplex mode to match the PHY. */
 819                 rl_phy_writereg(sc, PHY_BMCR, media);
 820         } else {
 821                 if (verbose)
 822                         printf("no carrier\n");
 823         }
 824
 825         rl_init(sc);
 826
 827         if (sc->rl_tx_pend) {
 828                 sc->rl_autoneg = 0;
 829                 sc->rl_tx_pend = 0;
 830                 rl_start(ifp);
 831         }
 832
 833         return;
 834 }
 835
 836 static void rl_getmode_mii(sc)
 837         struct rl_softc         *sc;
 838 {
 839         u_int16_t               bmsr;
 840         struct ifnet            *ifp;
 841
 842         ifp = &sc->arpcom.ac_if;
 843
 844         bmsr = rl_phy_readreg(sc, PHY_BMSR);
 845         if (bootverbose)
 846                 printf("rl%d: PHY status word: %x\n", sc->rl_unit, bmsr);
 847
 848         /* fallback */
 849         sc->ifmedia.ifm_media = IFM_ETHER|IFM_10_T|IFM_HDX;
 850
 851         if (bmsr & PHY_BMSR_10BTHALF) {
 852                 if (bootverbose)
 853                         printf("rl%d: 10Mbps half-duplex mode supported\n",
 854                                                                 sc->rl_unit);
 855                 ifmedia_add(&sc->ifmedia,
 856                         IFM_ETHER|IFM_10_T|IFM_HDX, 0, NULL);
 857                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
 858         }
 859
 860         if (bmsr & PHY_BMSR_10BTFULL) {
 861                 if (bootverbose)
 862                         printf("rl%d: 10Mbps full-duplex mode supported\n",
 863                                                                 sc->rl_unit);
 864                 ifmedia_add(&sc->ifmedia,
 865                         IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
 866                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_10_T|IFM_FDX;
 867         }
 868
 869         if (bmsr & PHY_BMSR_100BTXHALF) {
 870                 if (bootverbose)
 871                         printf("rl%d: 100Mbps half-duplex mode supported\n",
 872                                                                 sc->rl_unit);
 873                 ifp->if_baudrate = 100000000;
 874                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL);
 875                 ifmedia_add(&sc->ifmedia,
 876                         IFM_ETHER|IFM_100_TX|IFM_HDX, 0, NULL);
 877                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_100_TX|IFM_HDX;
 878         }
 879
 880         if (bmsr & PHY_BMSR_100BTXFULL) {
 881                 if (bootverbose)
 882                         printf("rl%d: 100Mbps full-duplex mode supported\n",
 883                                                                 sc->rl_unit);
 884                 ifp->if_baudrate = 100000000;
 885                 ifmedia_add(&sc->ifmedia,
 886                         IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL);
 887                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_100_TX|IFM_FDX;
 888         }
 889
 890         /* Some also support 100BaseT4. */
 891         if (bmsr & PHY_BMSR_100BT4) {
 892                 if (bootverbose)
 893                         printf("rl%d: 100baseT4 mode supported\n", sc->rl_unit);
 894                 ifp->if_baudrate = 100000000;
 895                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_T4, 0, NULL);
 896                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_100_T4;
 897 #ifdef FORCE_AUTONEG_TFOUR
 898                 if (bootverbose)
 899                         printf("rl%d: forcing on autoneg support for BT4\n",
 900                                                          sc->rl_unit);
 901                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0 NULL):
 902                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_AUTO;
 903 #endif
 904         }
 905
 906         if (bmsr & PHY_BMSR_CANAUTONEG) {
 907                 if (bootverbose)
 908                         printf("rl%d: autoneg supported\n", sc->rl_unit);
 909                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL);
 910                 sc->ifmedia.ifm_media = IFM_ETHER|IFM_AUTO;
 911         }
 912
 913         return;
 914 }
 915
 916 /*
 917  * Set speed and duplex mode.
 918  */
 919 static void rl_setmode_mii(sc, media)
 920         struct rl_softc         *sc;
 921         int                     media;
 922 {
 923         u_int16_t               bmcr;
 924
 925         printf("rl%d: selecting MII, ", sc->rl_unit);
 926
 927         bmcr = rl_phy_readreg(sc, PHY_BMCR);
 928
 929         bmcr &= ~(PHY_BMCR_AUTONEGENBL|PHY_BMCR_SPEEDSEL|
 930                         PHY_BMCR_DUPLEX|PHY_BMCR_LOOPBK);
 931
 932         if (IFM_SUBTYPE(media) == IFM_100_T4) {
 933                 printf("100Mbps/T4, half-duplex\n");
 934                 bmcr |= PHY_BMCR_SPEEDSEL;
 935                 bmcr &= ~PHY_BMCR_DUPLEX;
 936         }
 937
 938         if (IFM_SUBTYPE(media) == IFM_100_TX) {
 939                 printf("100Mbps, ");
 940                 bmcr |= PHY_BMCR_SPEEDSEL;
 941         }
 942
 943         if (IFM_SUBTYPE(media) == IFM_10_T) {
 944                 printf("10Mbps, ");
 945                 bmcr &= ~PHY_BMCR_SPEEDSEL;
 946         }
 947
 948         if ((media & IFM_GMASK) == IFM_FDX) {
 949                 printf("full duplex\n");
 950                 bmcr |= PHY_BMCR_DUPLEX;
 951         } else {
 952                 printf("half duplex\n");
 953                 bmcr &= ~PHY_BMCR_DUPLEX;
 954         }
 955
 956         rl_phy_writereg(sc, PHY_BMCR, bmcr);
 957
 958         return;
 959 }
 960
 961 static void rl_reset(sc)
 962         struct rl_softc         *sc;
 963 {
 964         register int            i;
 965
 966         CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_RESET);
 967
 968         for (i = 0; i < RL_TIMEOUT; i++) {
 969                 DELAY(10);
 970                 if (!(CSR_READ_1(sc, RL_COMMAND) & RL_CMD_RESET))
 971                         break;
 972         }
 973         if (i == RL_TIMEOUT)
 974                 printf("rl%d: reset never completed!\n", sc->rl_unit);
 975
 976         return;
 977 }
 978
 979 /*
 980  * Probe for a RealTek 8129/8139 chip. Check the PCI vendor and device
 981  * IDs against our list and return a device name if we find a match.
 982  */
 983 static const char *
 984 rl_probe(config_id, device_id)
 985         pcici_t                 config_id;
 986         pcidi_t                 device_id;
 987 {
 988         struct rl_type          *t;
 989
 990         t = rl_devs;
 991
 992         while(t->rl_name != NULL) {
 993                 if ((device_id & 0xFFFF) == t->rl_vid &&
 994                     ((device_id >> 16) & 0xFFFF) == t->rl_did) {
 995                         return(t->rl_name);
 996                 }
 997                 t++;
 998         }
 999
1000         return(NULL);
1001 }
1002
1003 /*
1004  * Attach the interface. Allocate softc structures, do ifmedia
1005  * setup and ethernet/BPF attach.
1006  */
1007 static void
1008 rl_attach(config_id, unit)
1009         pcici_t                 config_id;
1010         int                     unit;
1011 {
1012         int                     s, i;
1013 #ifndef RL_USEIOSPACE
1014         vm_offset_t             pbase, vbase;
1015 #endif
1016         u_char                  eaddr[ETHER_ADDR_LEN];
1017         u_int32_t               command;
1018         struct rl_softc         *sc;
1019         struct ifnet            *ifp;
1020         int                     media = IFM_ETHER|IFM_100_TX|IFM_FDX;
1021         struct rl_type          *p;
1022         u_int16_t               phy_vid, phy_did, phy_sts;
1023         u_int16_t               rl_did = 0;
1024
1025         s = splimp();
1026
1027         sc = malloc(sizeof(struct rl_softc), M_DEVBUF, M_NOWAIT);
1028         if (sc == NULL) {
1029                 printf("rl%d: no memory for softc struct!\n", unit);
1030                 goto fail;
1031         }
1032         bzero(sc, sizeof(struct rl_softc));
1033
1034         /*
1035          * Handle power management nonsense.
1036          */
1037
1038         command = pci_conf_read(config_id, RL_PCI_CAPID) & 0x000000FF;
1039         if (command == 0x01) {
1040
1041                 command = pci_conf_read(config_id, RL_PCI_PWRMGMTCTRL);
1042                 if (command & RL_PSTATE_MASK) {
1043                         u_int32_t               iobase, membase, irq;
1044
1045                         /* Save important PCI config data. */
1046                         iobase = pci_conf_read(config_id, RL_PCI_LOIO);
1047                         membase = pci_conf_read(config_id, RL_PCI_LOMEM);
1048                         irq = pci_conf_read(config_id, RL_PCI_INTLINE);
1049
1050                         /* Reset the power state. */
1051                         printf("rl%d: chip is is in D%d power mode "
1052                         "-- setting to D0\n", unit, command & RL_PSTATE_MASK);
1053                         command &= 0xFFFFFFFC;
1054                         pci_conf_write(config_id, RL_PCI_PWRMGMTCTRL, command);
1055
1056                         /* Restore PCI config data. */
1057                         pci_conf_write(config_id, RL_PCI_LOIO, iobase);
1058                         pci_conf_write(config_id, RL_PCI_LOMEM, membase);
1059                         pci_conf_write(config_id, RL_PCI_INTLINE, irq);
1060                 }
1061         }
1062
1063         /*
1064          * Map control/status registers.
1065          */
1066         command = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
1067         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
1068         pci_conf_write(config_id, PCI_COMMAND_STATUS_REG, command);
1069         command = pci_conf_read(config_id, PCI_COMMAND_STATUS_REG);
1070
1071 #ifdef RL_USEIOSPACE
1072         if (!(command & PCIM_CMD_PORTEN)) {
1073                 printf("rl%d: failed to enable I/O ports!\n", unit);
1074                 free(sc, M_DEVBUF);
1075                 goto fail;
1076         }
1077
1078         if (!pci_map_port(config_id, RL_PCI_LOIO,
1079                                 (pci_port_t *)&(sc->rl_bhandle))) {
1080                 printf ("rl%d: couldn't map ports\n", unit);
1081                 goto fail;
1082         }
1083 #ifdef __i386__
1084         sc->rl_btag = I386_BUS_SPACE_IO;
1085 #endif
1086 #ifdef __alpha__
1087         sc->rl_btag = ALPHA_BUS_SPACE_IO;
1088 #endif
1089 #else
1090         if (!(command & PCIM_CMD_MEMEN)) {
1091                 printf("rl%d: failed to enable memory mapping!\n", unit);
1092                 goto fail;
1093         }
1094
1095         if (!pci_map_mem(config_id, RL_PCI_LOMEM, &vbase, &pbase)) {
1096                 printf ("rl%d: couldn't map memory\n", unit);
1097                 goto fail;
1098         }
1099 #ifdef __i386__
1100         sc->rl_btag = I386_BUS_SPACE_MEM;
1101 #endif
1102 #ifdef __alpha__
1103         sc->rl_btag = ALPHA_BUS_SPACE_MEM;
1104 #endif
1105         sc->rl_bhandle = vbase;
1106 #endif
1107
1108         /* Allocate interrupt */
1109         if (!pci_map_int(config_id, rl_intr, sc, &net_imask)) {
1110                 printf("rl%d: couldn't map interrupt\n", unit);
1111                 goto fail;
1112         }
1113
1114         /* Reset the adapter. */
1115         rl_reset(sc);
1116
1117         /*
1118          * Get station address from the EEPROM.
1119          */
1120         rl_read_eeprom(sc, (caddr_t)&eaddr, RL_EE_EADDR, 3, 0);
1121
1122         /*
1123          * A RealTek chip was detected. Inform the world.
1124          */
1125         printf("rl%d: Ethernet address: %6D\n", unit, eaddr, ":");
1126
1127         sc->rl_unit = unit;
1128         bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
1129
1130         /*
1131          * Now read the exact device type from the EEPROM to find
1132          * out if it's an 8129 or 8139.
1133          */
1134         rl_read_eeprom(sc, (caddr_t)&rl_did, RL_EE_PCI_DID, 1, 0);
1135
1136         if (rl_did == RT_DEVICEID_8139 || rl_did == ACCTON_DEVICEID_5030 ||
1137             rl_did == DELTA_DEVICEID_8139 || rl_did == ADDTRON_DEVICEID_8139 ||
1138             rl_did == SIS_DEVICEID_8139)
1139                 sc->rl_type = RL_8139;
1140         else if (rl_did == RT_DEVICEID_8129)
1141                 sc->rl_type = RL_8129;
1142         else {
1143                 printf("rl%d: unknown device ID: %x\n", unit, rl_did);
1144                 free(sc, M_DEVBUF);
1145                 goto fail;
1146         }
1147
1148         sc->rl_cdata.rl_rx_buf = contigmalloc(RL_RXBUFLEN + 32, M_DEVBUF,
1149                 M_NOWAIT, 0x100000, 0xffffffff, PAGE_SIZE, 0);
1150
1151         if (sc->rl_cdata.rl_rx_buf == NULL) {
1152                 free(sc, M_DEVBUF);
1153                 printf("rl%d: no memory for list buffers!\n", unit);
1154                 goto fail;
1155         }
1156
1157         /* Leave a few bytes before the start of the RX ring buffer. */
1158         sc->rl_cdata.rl_rx_buf_ptr = sc->rl_cdata.rl_rx_buf;
1159         sc->rl_cdata.rl_rx_buf += sizeof(u_int64_t);
1160
1161         ifp = &sc->arpcom.ac_if;
1162         ifp->if_softc = sc;
1163         ifp->if_unit = unit;
1164         ifp->if_name = "rl";
1165         ifp->if_mtu = ETHERMTU;
1166         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1167         ifp->if_ioctl = rl_ioctl;
1168         ifp->if_output = ether_output;
1169         ifp->if_start = rl_start;
1170         ifp->if_watchdog = rl_watchdog;
1171         ifp->if_init = rl_init;
1172         ifp->if_baudrate = 10000000;
1173         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
1174
1175         if (sc->rl_type == RL_8129) {
1176                 if (bootverbose)
1177                         printf("rl%d: probing for a PHY\n", sc->rl_unit);
1178                 for (i = RL_PHYADDR_MIN; i < RL_PHYADDR_MAX + 1; i++) {
1179                         if (bootverbose)
1180                                 printf("rl%d: checking address: %d\n",
1181                                                         sc->rl_unit, i);
1182                         sc->rl_phy_addr = i;
1183                         rl_phy_writereg(sc, PHY_BMCR, PHY_BMCR_RESET);
1184                         DELAY(500);
1185                         while(rl_phy_readreg(sc, PHY_BMCR)
1186                                         & PHY_BMCR_RESET);
1187                         if ((phy_sts = rl_phy_readreg(sc, PHY_BMSR)))
1188                                 break;
1189                 }
1190                 if (phy_sts) {
1191                         phy_vid = rl_phy_readreg(sc, PHY_VENID);
1192                         phy_did = rl_phy_readreg(sc, PHY_DEVID);
1193                         if (bootverbose)
1194                                 printf("rl%d: found PHY at address %d, ",
1195                                                 sc->rl_unit, sc->rl_phy_addr);
1196                         if (bootverbose)
1197                                 printf("vendor id: %x device id: %x\n",
1198                                         phy_vid, phy_did);
1199                         p = rl_phys;
1200                         while(p->rl_vid) {
1201                                 if (phy_vid == p->rl_vid &&
1202                                         (phy_did | 0x000F) == p->rl_did) {
1203                                         sc->rl_pinfo = p;
1204                                         break;
1205                                 }
1206                                 p++;
1207                         }
1208                         if (sc->rl_pinfo == NULL)
1209                                 sc->rl_pinfo = &rl_phys[PHY_UNKNOWN];
1210                         if (bootverbose)
1211                                 printf("rl%d: PHY type: %s\n",
1212                                         sc->rl_unit, sc->rl_pinfo->rl_name);
1213                 } else {
1214                         printf("rl%d: MII without any phy!\n", sc->rl_unit);
1215                 }
1216         }
1217
1218         /*
1219          * Do ifmedia setup.
1220          */
1221         ifmedia_init(&sc->ifmedia, 0, rl_ifmedia_upd, rl_ifmedia_sts);
1222
1223         rl_getmode_mii(sc);
1224
1225         /* Choose a default media. */
1226         media = IFM_ETHER|IFM_AUTO;
1227         ifmedia_set(&sc->ifmedia, media);
1228
1229         rl_autoneg_mii(sc, RL_FLAG_FORCEDELAY, 1);
1230
1231         /*
1232          * Call MI attach routines.
1233          */
1234         if_attach(ifp);
1235         ether_ifattach(ifp);
1236
1237 #if NBPF > 0
1238         bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
1239 #endif
1240         at_shutdown(rl_shutdown, sc, SHUTDOWN_POST_SYNC);
1241
1242 fail:
1243         splx(s);
1244         return;
1245 }
1246
1247 /*
1248  * Initialize the transmit descriptors.
1249  */
1250 static int rl_list_tx_init(sc)
1251         struct rl_softc         *sc;
1252 {
1253         struct rl_chain_data    *cd;
1254         int                     i;
1255
1256         cd = &sc->rl_cdata;
1257         for (i = 0; i < RL_TX_LIST_CNT; i++) {
1258                 cd->rl_tx_chain[i] = NULL;
1259                 CSR_WRITE_4(sc,
1260                     RL_TXADDR0 + (i * sizeof(u_int32_t)), 0x0000000);
1261         }
1262
1263         sc->rl_cdata.cur_tx = 0;
1264         sc->rl_cdata.last_tx = 0;
1265
1266         return(0);
1267 }
1268
1269 /*
1270  * A frame has been uploaded: pass the resulting mbuf chain up to
1271  * the higher level protocols.
1272  *
1273  * You know there's something wrong with a PCI bus-master chip design
1274  * when you have to use m_devget().
1275  *
1276  * The receive operation is badly documented in the datasheet, so I'll
1277  * attempt to document it here. The driver provides a buffer area and
1278  * places its base address in the RX buffer start address register.
1279  * The chip then begins copying frames into the RX buffer. Each frame
1280  * is preceeded by a 32-bit RX status word which specifies the length
1281  * of the frame and certain other status bits. Each frame (starting with
1282  * the status word) is also 32-bit aligned. The frame length is in the
1283  * first 16 bits of the status word; the lower 15 bits correspond with
1284  * the 'rx status register' mentioned in the datasheet.
1285  *
1286  * Note: to make the Alpha happy, the frame payload needs to be aligned
1287  * on a 32-bit boundary. To achieve this, we cheat a bit by copying from
1288  * the ring buffer starting at an address two bytes before the actual
1289  * data location. We can then shave off the first two bytes using m_adj().
1290  * The reason we do this is because m_devget() doesn't let us specify an
1291  * offset into the mbuf storage space, so we have to artificially create
1292  * one. The ring is allocated in such a way that there are a few unused
1293  * bytes of space preceecing it so that it will be safe for us to do the
1294  * 2-byte backstep even if reading from the ring at offset 0.
1295  */
1296 static void rl_rxeof(sc)
1297         struct rl_softc         *sc;
1298 {
1299         struct ether_header     *eh;
1300         struct mbuf             *m;
1301         struct ifnet            *ifp;
1302         int                     total_len = 0;
1303         u_int32_t               rxstat;
1304         caddr_t                 rxbufpos;
1305         int                     wrap = 0;
1306         u_int16_t               cur_rx;
1307         u_int16_t               limit;
1308         u_int16_t               rx_bytes = 0, max_bytes;
1309
1310         ifp = &sc->arpcom.ac_if;
1311
1312         cur_rx = (CSR_READ_2(sc, RL_CURRXADDR) + 16) % RL_RXBUFLEN;
1313
1314         /* Do not try to read past this point. */
1315         limit = CSR_READ_2(sc, RL_CURRXBUF) % RL_RXBUFLEN;
1316
1317         if (limit < cur_rx)
1318                 max_bytes = (RL_RXBUFLEN - cur_rx) + limit;
1319         else
1320                 max_bytes = limit - cur_rx;
1321
1322         while((CSR_READ_1(sc, RL_COMMAND) & RL_CMD_EMPTY_RXBUF) == 0) {
1323                 rxbufpos = sc->rl_cdata.rl_rx_buf + cur_rx;
1324                 rxstat = *(u_int32_t *)rxbufpos;
1325
1326                 /*
1327                  * Here's a totally undocumented fact for you. When the
1328                  * RealTek chip is in the process of copying a packet into
1329                  * RAM for you, the length will be 0xfff0. If you spot a
1330                  * packet header with this value, you need to stop. The
1331                  * datasheet makes absolutely no mention of this and
1332                  * RealTek should be shot for this.
1333                  */
1334                 if ((u_int16_t)(rxstat >> 16) == RL_RXSTAT_UNFINISHED)
1335                         break;
1336
1337                 if (!(rxstat & RL_RXSTAT_RXOK)) {
1338                         ifp->if_ierrors++;
1339                         if (rxstat & (RL_RXSTAT_BADSYM|RL_RXSTAT_RUNT|
1340                                         RL_RXSTAT_GIANT|RL_RXSTAT_CRCERR|
1341                                         RL_RXSTAT_ALIGNERR)) {
1342                                 CSR_WRITE_2(sc, RL_COMMAND, RL_CMD_TX_ENB);
1343                                 CSR_WRITE_2(sc, RL_COMMAND, RL_CMD_TX_ENB|
1344                                                         RL_CMD_RX_ENB);
1345                                 CSR_WRITE_4(sc, RL_RXCFG, RL_RXCFG_CONFIG);
1346                                 CSR_WRITE_4(sc, RL_RXADDR,
1347                                         vtophys(sc->rl_cdata.rl_rx_buf));
1348                                 CSR_WRITE_2(sc, RL_CURRXADDR, cur_rx - 16);
1349                                 cur_rx = 0;
1350                         }
1351                         break;
1352                 }
1353
1354                 /* No errors; receive the packet. */
1355                 total_len = rxstat >> 16;
1356                 rx_bytes += total_len + 4;
1357
1358                 /*
1359                  * XXX The RealTek chip includes the CRC with every
1360                  * received frame, and there's no way to turn this
1361                  * behavior off (at least, I can't find anything in
1362                  * the manual that explains how to do it) so we have
1363                  * to trim off the CRC manually.
1364                  */
1365                 total_len -= ETHER_CRC_LEN;
1366
1367                 /*
1368                  * Avoid trying to read more bytes than we know
1369                  * the chip has prepared for us.
1370                  */
1371                 if (rx_bytes > max_bytes)
1372                         break;
1373
1374                 rxbufpos = sc->rl_cdata.rl_rx_buf +
1375                         ((cur_rx + sizeof(u_int32_t)) % RL_RXBUFLEN);
1376
1377                 if (rxbufpos == (sc->rl_cdata.rl_rx_buf + RL_RXBUFLEN))
1378                         rxbufpos = sc->rl_cdata.rl_rx_buf;
1379
1380                 wrap = (sc->rl_cdata.rl_rx_buf + RL_RXBUFLEN) - rxbufpos;
1381
1382                 if (total_len > wrap) {
1383                         m = m_devget(rxbufpos - RL_ETHER_ALIGN,
1384                            wrap + RL_ETHER_ALIGN, 0, ifp, NULL);
1385                         if (m == NULL) {
1386                                 ifp->if_ierrors++;
1387                                 printf("rl%d: out of mbufs, tried to "
1388                                         "copy %d bytes\n", sc->rl_unit, wrap);
1389                         }
1390                         else {
1391                                 m_adj(m, RL_ETHER_ALIGN);
1392                                 m_copyback(m, wrap, total_len - wrap,
1393                                         sc->rl_cdata.rl_rx_buf);
1394                         }
1395                         cur_rx = (total_len - wrap + ETHER_CRC_LEN);
1396                 } else {
1397                         m = m_devget(rxbufpos - RL_ETHER_ALIGN,
1398                             total_len + RL_ETHER_ALIGN, 0, ifp, NULL);
1399                         if (m == NULL) {
1400                                 ifp->if_ierrors++;
1401                                 printf("rl%d: out of mbufs, tried to "
1402                                 "copy %d bytes\n", sc->rl_unit, total_len);
1403                         } else
1404                                 m_adj(m, RL_ETHER_ALIGN);
1405                         cur_rx += total_len + 4 + ETHER_CRC_LEN;
1406                 }
1407
1408                 /*
1409                  * Round up to 32-bit boundary.
1410                  */
1411                 cur_rx = (cur_rx + 3) & ~3;
1412                 CSR_WRITE_2(sc, RL_CURRXADDR, cur_rx - 16);
1413
1414                 if (m == NULL)
1415                         continue;
1416
1417                 eh = mtod(m, struct ether_header *);
1418                 ifp->if_ipackets++;
1419
1420 #if NBPF > 0
1421                 /*
1422                  * Handle BPF listeners. Let the BPF user see the packet, but
1423                  * don't pass it up to the ether_input() layer unless it's
1424                  * a broadcast packet, multicast packet, matches our ethernet
1425                  * address or the interface is in promiscuous mode.
1426                  */
1427                 if (ifp->if_bpf) {
1428                         bpf_mtap(ifp, m);
1429                         if (ifp->if_flags & IFF_PROMISC &&
1430                                 (bcmp(eh->ether_dhost, sc->arpcom.ac_enaddr,
1431                                                 ETHER_ADDR_LEN) &&
1432                                         (eh->ether_dhost[0] & 1) == 0)) {
1433                                 m_freem(m);
1434                                 continue;
1435                         }
1436                 }
1437 #endif
1438                 /* Remove header from mbuf and pass it on. */
1439                 m_adj(m, sizeof(struct ether_header));
1440                 ether_input(ifp, eh, m);
1441         }
1442
1443         return;
1444 }
1445
1446 /*
1447  * A frame was downloaded to the chip. It's safe for us to clean up
1448  * the list buffers.
1449  */
1450 static void rl_txeof(sc)
1451         struct rl_softc         *sc;
1452 {
1453         struct ifnet            *ifp;
1454         u_int32_t               txstat;
1455
1456         ifp = &sc->arpcom.ac_if;
1457
1458         /* Clear the timeout timer. */
1459         ifp->if_timer = 0;
1460
1461         /*
1462          * Go through our tx list and free mbufs for those
1463          * frames that have been uploaded.
1464          */
1465         do {
1466                 txstat = CSR_READ_4(sc, RL_LAST_TXSTAT(sc));
1467                 if (!(txstat & (RL_TXSTAT_TX_OK|
1468                     RL_TXSTAT_TX_UNDERRUN|RL_TXSTAT_TXABRT)))
1469                         break;
1470
1471                 ifp->if_collisions += (txstat & RL_TXSTAT_COLLCNT) >> 24;
1472
1473                 if (RL_LAST_TXMBUF(sc) != NULL) {
1474                         m_freem(RL_LAST_TXMBUF(sc));
1475                         RL_LAST_TXMBUF(sc) = NULL;
1476                 }
1477                 if (txstat & RL_TXSTAT_TX_OK)
1478                         ifp->if_opackets++;
1479                 else {
1480                         ifp->if_oerrors++;
1481                         if ((txstat & RL_TXSTAT_TXABRT) ||
1482                             (txstat & RL_TXSTAT_OUTOFWIN))
1483                                 CSR_WRITE_4(sc, RL_TXCFG, RL_TXCFG_CONFIG);
1484                 }
1485                 RL_INC(sc->rl_cdata.last_tx);
1486                 ifp->if_flags &= ~IFF_OACTIVE;
1487         } while (sc->rl_cdata.last_tx != sc->rl_cdata.cur_tx);
1488
1489         if (sc->rl_cdata.last_tx == sc->rl_cdata.cur_tx) {
1490                 if (sc->rl_want_auto)
1491                         rl_autoneg_mii(sc, RL_FLAG_SCHEDDELAY, 1);
1492         }
1493
1494         return;
1495 }
1496
1497 static void rl_intr(arg)
1498         void                    *arg;
1499 {
1500         struct rl_softc         *sc;
1501         struct ifnet            *ifp;
1502         u_int16_t               status;
1503
1504         sc = arg;
1505         ifp = &sc->arpcom.ac_if;
1506
1507         /* Disable interrupts. */
1508         CSR_WRITE_2(sc, RL_IMR, 0x0000);
1509
1510         for (;;) {
1511
1512                 status = CSR_READ_2(sc, RL_ISR);
1513                 if (status)
1514                         CSR_WRITE_2(sc, RL_ISR, status);
1515
1516                 if ((status & RL_INTRS) == 0)
1517                         break;
1518
1519                 if (status & RL_ISR_RX_OK)
1520                         rl_rxeof(sc);
1521
1522                 if (status & RL_ISR_RX_ERR)
1523                         rl_rxeof(sc);
1524
1525                 if ((status & RL_ISR_TX_OK) || (status & RL_ISR_TX_ERR))
1526                         rl_txeof(sc);
1527
1528                 if (status & RL_ISR_SYSTEM_ERR) {
1529                         rl_reset(sc);
1530                         rl_init(sc);
1531                 }
1532
1533         }
1534
1535         /* Re-enable interrupts. */
1536         CSR_WRITE_2(sc, RL_IMR, RL_INTRS);
1537
1538         if (ifp->if_snd.ifq_head != NULL) {
1539                 rl_start(ifp);
1540         }
1541
1542         return;
1543 }
1544
1545 /*
1546  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
1547  * pointers to the fragment pointers.
1548  */
1549 static int rl_encap(sc, m_head)
1550         struct rl_softc         *sc;
1551         struct mbuf             *m_head;
1552 {
1553         struct mbuf             *m_new = NULL;
1554
1555         /*
1556          * The RealTek is brain damaged and wants longword-aligned
1557          * TX buffers, plus we can only have one fragment buffer
1558          * per packet. We have to copy pretty much all the time.
1559          */
1560
1561         MGETHDR(m_new, M_DONTWAIT, MT_DATA);
1562         if (m_new == NULL) {
1563                 printf("rl%d: no memory for tx list", sc->rl_unit);
1564                 return(1);
1565         }
1566         if (m_head->m_pkthdr.len > MHLEN) {
1567                 MCLGET(m_new, M_DONTWAIT);
1568                 if (!(m_new->m_flags & M_EXT)) {
1569                         m_freem(m_new);
1570                         printf("rl%d: no memory for tx list",
1571                                         sc->rl_unit);
1572                         return(1);
1573                 }
1574         }
1575         m_copydata(m_head, 0, m_head->m_pkthdr.len,
1576                                 mtod(m_new, caddr_t));
1577         m_new->m_pkthdr.len = m_new->m_len = m_head->m_pkthdr.len;
1578         m_freem(m_head);
1579         m_head = m_new;
1580
1581         /* Pad frames to at least 60 bytes. */
1582         if (m_head->m_pkthdr.len < RL_MIN_FRAMELEN) {
1583                 m_head->m_pkthdr.len +=
1584                         (RL_MIN_FRAMELEN - m_head->m_pkthdr.len);
1585                 m_head->m_len = m_head->m_pkthdr.len;
1586         }
1587
1588         RL_CUR_TXMBUF(sc) = m_head;
1589
1590         return(0);
1591 }
1592
1593 /*
1594  * Main transmit routine.
1595  */
1596
1597 static void rl_start(ifp)
1598         struct ifnet            *ifp;
1599 {
1600         struct rl_softc         *sc;
1601         struct mbuf             *m_head = NULL;
1602
1603         sc = ifp->if_softc;
1604
1605         if (sc->rl_autoneg) {
1606                 sc->rl_tx_pend = 1;
1607                 return;
1608         }
1609
1610         while(RL_CUR_TXMBUF(sc) == NULL) {
1611                 IF_DEQUEUE(&ifp->if_snd, m_head);
1612                 if (m_head == NULL)
1613                         break;
1614
1615                 rl_encap(sc, m_head);
1616
1617 #if NBPF > 0
1618                 /*
1619                  * If there's a BPF listener, bounce a copy of this frame
1620                  * to him.
1621                  */
1622                 if (ifp->if_bpf)
1623                         bpf_mtap(ifp, RL_CUR_TXMBUF(sc));
1624 #endif
1625                 /*
1626                  * Transmit the frame.
1627                  */
1628                 CSR_WRITE_4(sc, RL_CUR_TXADDR(sc),
1629                     vtophys(mtod(RL_CUR_TXMBUF(sc), caddr_t)));
1630                 CSR_WRITE_4(sc, RL_CUR_TXSTAT(sc),
1631                     RL_TX_EARLYTHRESH | RL_CUR_TXMBUF(sc)->m_pkthdr.len);
1632
1633                 RL_INC(sc->rl_cdata.cur_tx);
1634         }
1635
1636         /*
1637          * We broke out of the loop because all our TX slots are
1638          * full. Mark the NIC as busy until it drains some of the
1639          * packets from the queue.
1640          */
1641         if (RL_CUR_TXMBUF(sc) != NULL)
1642                 ifp->if_flags |= IFF_OACTIVE;
1643
1644         /*
1645          * Set a timeout in case the chip goes out to lunch.
1646          */
1647         ifp->if_timer = 5;
1648
1649         return;
1650 }
1651
1652 static void rl_init(xsc)
1653         void                    *xsc;
1654 {
1655         struct rl_softc         *sc = xsc;
1656         struct ifnet            *ifp = &sc->arpcom.ac_if;
1657         int                     s, i;
1658         u_int32_t               rxcfg = 0;
1659         u_int16_t               phy_bmcr = 0;
1660
1661         if (sc->rl_autoneg)
1662                 return;
1663
1664         s = splimp();
1665
1666         /*
1667          * XXX Hack for the 8139: the built-in autoneg logic's state
1668          * gets reset by rl_init() when we don't want it to. Try
1669          * to preserve it. (For 8129 cards with real external PHYs,
1670          * the BMCR register doesn't change, but this doesn't hurt.)
1671          */
1672         if (sc->rl_type == RL_8139)
1673                 phy_bmcr = rl_phy_readreg(sc, PHY_BMCR);
1674
1675         /*
1676          * Cancel pending I/O and free all RX/TX buffers.
1677          */
1678         rl_stop(sc);
1679
1680         /* Init our MAC address */
1681         for (i = 0; i < ETHER_ADDR_LEN; i++) {
1682                 CSR_WRITE_1(sc, RL_IDR0 + i, sc->arpcom.ac_enaddr[i]);
1683         }
1684
1685         /* Init the RX buffer pointer register. */
1686         CSR_WRITE_4(sc, RL_RXADDR, vtophys(sc->rl_cdata.rl_rx_buf));
1687
1688         /* Init TX descriptors. */
1689         rl_list_tx_init(sc);
1690
1691         /*
1692          * Enable transmit and receive.
1693          */
1694         CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_TX_ENB|RL_CMD_RX_ENB);
1695
1696         /*
1697          * Set the initial TX and RX configuration.
1698          */
1699         CSR_WRITE_4(sc, RL_TXCFG, RL_TXCFG_CONFIG);
1700         CSR_WRITE_4(sc, RL_RXCFG, RL_RXCFG_CONFIG);
1701
1702         /* Set the individual bit to receive frames for this host only. */
1703         rxcfg = CSR_READ_4(sc, RL_RXCFG);
1704         rxcfg |= RL_RXCFG_RX_INDIV;
1705
1706         /* If we want promiscuous mode, set the allframes bit. */
1707         if (ifp->if_flags & IFF_PROMISC) {
1708                 rxcfg |= RL_RXCFG_RX_ALLPHYS;
1709                 CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
1710         } else {
1711                 rxcfg &= ~RL_RXCFG_RX_ALLPHYS;
1712                 CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
1713         }
1714
1715         /*
1716          * Set capture broadcast bit to capture broadcast frames.
1717          */
1718         if (ifp->if_flags & IFF_BROADCAST) {
1719                 rxcfg |= RL_RXCFG_RX_BROAD;
1720                 CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
1721         } else {
1722                 rxcfg &= ~RL_RXCFG_RX_BROAD;
1723                 CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
1724         }
1725
1726         /*
1727          * Program the multicast filter, if necessary.
1728          */
1729         rl_setmulti(sc);
1730
1731         /*
1732          * Enable interrupts.
1733          */
1734         CSR_WRITE_2(sc, RL_IMR, RL_INTRS);
1735
1736         /* Start RX/TX process. */
1737         CSR_WRITE_4(sc, RL_MISSEDPKT, 0);
1738
1739         /* Enable receiver and transmitter. */
1740         CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_TX_ENB|RL_CMD_RX_ENB);
1741
1742         /* Restore state of BMCR */
1743         if (sc->rl_pinfo != NULL)
1744                 rl_phy_writereg(sc, PHY_BMCR, phy_bmcr);
1745
1746         CSR_WRITE_1(sc, RL_CFG1, RL_CFG1_DRVLOAD|RL_CFG1_FULLDUPLEX);
1747
1748         ifp->if_flags |= IFF_RUNNING;
1749         ifp->if_flags &= ~IFF_OACTIVE;
1750
1751         (void)splx(s);
1752
1753         return;
1754 }
1755
1756 /*
1757  * Set media options.
1758  */
1759 static int rl_ifmedia_upd(ifp)
1760         struct ifnet            *ifp;
1761 {
1762         struct rl_softc         *sc;
1763         struct ifmedia          *ifm;
1764
1765         sc = ifp->if_softc;
1766         ifm = &sc->ifmedia;
1767
1768         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1769                 return(EINVAL);
1770
1771         if (IFM_SUBTYPE(ifm->ifm_media) == IFM_AUTO)
1772                 rl_autoneg_mii(sc, RL_FLAG_SCHEDDELAY, 1);
1773         else
1774                 rl_setmode_mii(sc, ifm->ifm_media);
1775
1776         return(0);
1777 }
1778
1779 /*
1780  * Report current media status.
1781  */
1782 static void rl_ifmedia_sts(ifp, ifmr)
1783         struct ifnet            *ifp;
1784         struct ifmediareq       *ifmr;
1785 {
1786         struct rl_softc         *sc;
1787         u_int16_t               advert = 0, ability = 0;
1788
1789         sc = ifp->if_softc;
1790
1791         if (!(rl_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_AUTONEGENBL)) {
1792                 if (rl_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_SPEEDSEL)
1793                         ifmr->ifm_active = IFM_ETHER|IFM_100_TX;
1794                 else
1795                         ifmr->ifm_active = IFM_ETHER|IFM_10_T;
1796
1797                 if (rl_phy_readreg(sc, PHY_BMCR) & PHY_BMCR_DUPLEX)
1798                         ifmr->ifm_active |= IFM_FDX;
1799                 else
1800                         ifmr->ifm_active |= IFM_HDX;
1801                 return;
1802         }
1803
1804         ability = rl_phy_readreg(sc, PHY_LPAR);
1805         advert = rl_phy_readreg(sc, PHY_ANAR);
1806         if (advert & PHY_ANAR_100BT4 &&
1807                 ability & PHY_ANAR_100BT4) {
1808                 ifmr->ifm_active = IFM_ETHER|IFM_100_T4;
1809         } else if (advert & PHY_ANAR_100BTXFULL &&
1810                 ability & PHY_ANAR_100BTXFULL) {
1811                 ifmr->ifm_active = IFM_ETHER|IFM_100_TX|IFM_FDX;
1812         } else if (advert & PHY_ANAR_100BTXHALF &&
1813                 ability & PHY_ANAR_100BTXHALF) {
1814                 ifmr->ifm_active = IFM_ETHER|IFM_100_TX|IFM_HDX;
1815         } else if (advert & PHY_ANAR_10BTFULL &&
1816                 ability & PHY_ANAR_10BTFULL) {
1817                 ifmr->ifm_active = IFM_ETHER|IFM_10_T|IFM_FDX;
1818         } else if (advert & PHY_ANAR_10BTHALF &&
1819                 ability & PHY_ANAR_10BTHALF) {
1820                 ifmr->ifm_active = IFM_ETHER|IFM_10_T|IFM_HDX;
1821         }
1822
1823         return;
1824 }
1825
1826 static int rl_ioctl(ifp, command, data)
1827         struct ifnet            *ifp;
1828         u_long                  command;
1829         caddr_t                 data;
1830 {
1831         struct rl_softc         *sc = ifp->if_softc;
1832         struct ifreq            *ifr = (struct ifreq *) data;
1833         int                     s, error = 0;
1834
1835         s = splimp();
1836
1837         switch(command) {
1838         case SIOCSIFADDR:
1839         case SIOCGIFADDR:
1840         case SIOCSIFMTU:
1841                 error = ether_ioctl(ifp, command, data);
1842                 break;
1843         case SIOCSIFFLAGS:
1844                 if (ifp->if_flags & IFF_UP) {
1845                         rl_init(sc);
1846                 } else {
1847                         if (ifp->if_flags & IFF_RUNNING)
1848                                 rl_stop(sc);
1849                 }
1850                 error = 0;
1851                 break;
1852         case SIOCADDMULTI:
1853         case SIOCDELMULTI:
1854                 rl_setmulti(sc);
1855                 error = 0;
1856                 break;
1857         case SIOCGIFMEDIA:
1858         case SIOCSIFMEDIA:
1859                 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
1860                 break;
1861         default:
1862                 error = EINVAL;
1863                 break;
1864         }
1865
1866         (void)splx(s);
1867
1868         return(error);
1869 }
1870
1871 static void rl_watchdog(ifp)
1872         struct ifnet            *ifp;
1873 {
1874         struct rl_softc         *sc;
1875
1876         sc = ifp->if_softc;
1877
1878         if (sc->rl_autoneg) {
1879                 rl_autoneg_mii(sc, RL_FLAG_DELAYTIMEO, 1);
1880                 return;
1881         }
1882
1883         printf("rl%d: watchdog timeout\n", sc->rl_unit);
1884         ifp->if_oerrors++;
1885         if (!(rl_phy_readreg(sc, PHY_BMSR) & PHY_BMSR_LINKSTAT))
1886                 printf("rl%d: no carrier - transceiver cable problem?\n",
1887                                                                 sc->rl_unit);
1888         rl_txeof(sc);
1889         rl_rxeof(sc);
1890         rl_init(sc);
1891
1892         return;
1893 }
1894
1895 /*
1896  * Stop the adapter and free any mbufs allocated to the
1897  * RX and TX lists.
1898  */
1899 static void rl_stop(sc)
1900         struct rl_softc         *sc;
1901 {
1902         register int            i;
1903         struct ifnet            *ifp;
1904
1905         ifp = &sc->arpcom.ac_if;
1906         ifp->if_timer = 0;
1907
1908         CSR_WRITE_1(sc, RL_COMMAND, 0x00);
1909         CSR_WRITE_2(sc, RL_IMR, 0x0000);
1910
1911         /*
1912          * Free the TX list buffers.
1913          */
1914         for (i = 0; i < RL_TX_LIST_CNT; i++) {
1915                 if (sc->rl_cdata.rl_tx_chain[i] != NULL) {
1916                         m_freem(sc->rl_cdata.rl_tx_chain[i]);
1917                         sc->rl_cdata.rl_tx_chain[i] = NULL;
1918                         CSR_WRITE_4(sc, RL_TXADDR0 + i, 0x0000000);
1919                 }
1920         }
1921
1922         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1923
1924         return;
1925 }
1926
1927 /*
1928  * Stop all chip I/O so that the kernel's probe routines don't
1929  * get confused by errant DMAs when rebooting.
1930  */
1931 static void rl_shutdown(howto, arg)
1932         int                     howto;
1933         void                    *arg;
1934 {
1935         struct rl_softc         *sc = (struct rl_softc *)arg;
1936
1937         rl_stop(sc);
1938
1939         return;
1940 }
1941
1942
1943 static struct pci_device rl_device = {
1944         "rl",
1945         rl_probe,
1946         rl_attach,
1947         &rl_count,
1948         NULL
1949 };
1950 COMPAT_PCI_DRIVER(rl, rl_device);