sys/pci/if_ti.c

   1 /*
   2  * Copyright (c) 1997, 1998, 1999
   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  * $FreeBSD$
  33  */
  34
  35 /*
  36  * Alteon Networks Tigon PCI gigabit ethernet driver for FreeBSD.
  37  * Manuals, sample driver and firmware source kits are available
  38  * from http://www.alteon.com/support/openkits.
  39  *
  40  * Written by Bill Paul <wpaul@ctr.columbia.edu>
  41  * Electrical Engineering Department
  42  * Columbia University, New York City
  43  */
  44
  45 /*
  46  * The Alteon Networks Tigon chip contains an embedded R4000 CPU,
  47  * gigabit MAC, dual DMA channels and a PCI interface unit. NICs
  48  * using the Tigon may have anywhere from 512K to 2MB of SRAM. The
  49  * Tigon supports hardware IP, TCP and UCP checksumming, multicast
  50  * filtering and jumbo (9014 byte) frames. The hardware is largely
  51  * controlled by firmware, which must be loaded into the NIC during
  52  * initialization.
  53  *
  54  * The Tigon 2 contains 2 R4000 CPUs and requires a newer firmware
  55  * revision, which supports new features such as extended commands,
  56  * extended jumbo receive ring desciptors and a mini receive ring.
  57  *
  58  * Alteon Networks is to be commended for releasing such a vast amount
  59  * of development material for the Tigon NIC without requiring an NDA
  60  * (although they really should have done it a long time ago). With
  61  * any luck, the other vendors will finally wise up and follow Alteon's
  62  * stellar example.
  63  *
  64  * The firmware for the Tigon 1 and 2 NICs is compiled directly into
  65  * this driver by #including it as a C header file. This bloats the
  66  * driver somewhat, but it's the easiest method considering that the
  67  * driver code and firmware code need to be kept in sync. The source
  68  * for the firmware is not provided with the FreeBSD distribution since
  69  * compiling it requires a GNU toolchain targeted for mips-sgi-irix5.3.
  70  *
  71  * The following people deserve special thanks:
  72  * - Terry Murphy of 3Com, for providing a 3c985 Tigon 1 board
  73  *   for testing
  74  * - Raymond Lee of Netgear, for providing a pair of Netgear
  75  *   GA620 Tigon 2 boards for testing
  76  * - Ulf Zimmermann, for bringing the GA260 to my attention and
  77  *   convincing me to write this driver.
  78  * - Andrew Gallatin for providing FreeBSD/Alpha support.
  79  */
  80
  81 #include "vlan.h"
  82
  83 #include <sys/param.h>
  84 #include <sys/systm.h>
  85 #include <sys/sockio.h>
  86 #include <sys/mbuf.h>
  87 #include <sys/malloc.h>
  88 #include <sys/kernel.h>
  89 #include <sys/socket.h>
  90 #include <sys/queue.h>
  91
  92 #include <net/if.h>
  93 #include <net/if_arp.h>
  94 #include <net/ethernet.h>
  95 #include <net/if_dl.h>
  96 #include <net/if_media.h>
  97
  98 #include <net/bpf.h>
  99
 100 #if NVLAN > 0
 101 #include <net/if_types.h>
 102 #include <net/if_vlan_var.h>
 103 #endif
 104
 105 #include <netinet/in_systm.h>
 106 #include <netinet/in.h>
 107 #include <netinet/ip.h>
 108
 109 #include <vm/vm.h>              /* for vtophys */
 110 #include <vm/pmap.h>            /* for vtophys */
 111 #include <machine/bus_memio.h>
 112 #include <machine/bus.h>
 113 #include <machine/resource.h>
 114 #include <sys/bus.h>
 115 #include <sys/rman.h>
 116
 117 #include <pci/pcireg.h>
 118 #include <pci/pcivar.h>
 119
 120 #include <pci/if_tireg.h>
 121 #include <pci/ti_fw.h>
 122 #include <pci/ti_fw2.h>
 123
 124 #define TI_CSUM_FEATURES        (CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_IP_FRAGS)
 125
 126 #if !defined(lint)
 127 static const char rcsid[] =
 128   "$FreeBSD$";
 129 #endif
 130
 131 /*
 132  * Various supported device vendors/types and their names.
 133  */
 134
 135 static struct ti_type ti_devs[] = {
 136         { ALT_VENDORID, ALT_DEVICEID_ACENIC,
 137                 "Alteon AceNIC 1000baseSX Gigabit Ethernet" },
 138         { ALT_VENDORID, ALT_DEVICEID_ACENIC_COPPER,
 139                 "Alteon AceNIC 1000baseT Gigabit Ethernet" },
 140         { TC_VENDORID,  TC_DEVICEID_3C985,
 141                 "3Com 3c985-SX Gigabit Ethernet" },
 142         { NG_VENDORID, NG_DEVICEID_GA620,
 143                 "Netgear GA620 1000baseSX Gigabit Ethernet" },
 144         { NG_VENDORID, NG_DEVICEID_GA620T,
 145                 "Netgear GA620 1000baseT Gigabit Ethernet" },
 146         { SGI_VENDORID, SGI_DEVICEID_TIGON,
 147                 "Silicon Graphics Gigabit Ethernet" },
 148         { DEC_VENDORID, DEC_DEVICEID_FARALLON_PN9000SX,
 149                 "Farallon PN9000SX Gigabit Ethernet" },
 150         { 0, 0, NULL }
 151 };
 152
 153 static int ti_probe             __P((device_t));
 154 static int ti_attach            __P((device_t));
 155 static int ti_detach            __P((device_t));
 156 static void ti_txeof            __P((struct ti_softc *));
 157 static void ti_rxeof            __P((struct ti_softc *));
 158
 159 static void ti_stats_update     __P((struct ti_softc *));
 160 static int ti_encap             __P((struct ti_softc *, struct mbuf *,
 161                                         u_int32_t *));
 162
 163 static void ti_intr             __P((void *));
 164 static void ti_start            __P((struct ifnet *));
 165 static int ti_ioctl             __P((struct ifnet *, u_long, caddr_t));
 166 static void ti_init             __P((void *));
 167 static void ti_init2            __P((struct ti_softc *));
 168 static void ti_stop             __P((struct ti_softc *));
 169 static void ti_watchdog         __P((struct ifnet *));
 170 static void ti_shutdown         __P((device_t));
 171 static int ti_ifmedia_upd       __P((struct ifnet *));
 172 static void ti_ifmedia_sts      __P((struct ifnet *, struct ifmediareq *));
 173
 174 static u_int32_t ti_eeprom_putbyte      __P((struct ti_softc *, int));
 175 static u_int8_t ti_eeprom_getbyte       __P((struct ti_softc *,
 176                                                 int, u_int8_t *));
 177 static int ti_read_eeprom       __P((struct ti_softc *, caddr_t, int, int));
 178
 179 static void ti_add_mcast        __P((struct ti_softc *, struct ether_addr *));
 180 static void ti_del_mcast        __P((struct ti_softc *, struct ether_addr *));
 181 static void ti_setmulti         __P((struct ti_softc *));
 182
 183 static void ti_mem              __P((struct ti_softc *, u_int32_t,
 184                                         u_int32_t, caddr_t));
 185 static void ti_loadfw           __P((struct ti_softc *));
 186 static void ti_cmd              __P((struct ti_softc *, struct ti_cmd_desc *));
 187 static void ti_cmd_ext          __P((struct ti_softc *, struct ti_cmd_desc *,
 188                                         caddr_t, int));
 189 static void ti_handle_events    __P((struct ti_softc *));
 190 static int ti_alloc_jumbo_mem   __P((struct ti_softc *));
 191 static void *ti_jalloc          __P((struct ti_softc *));
 192 static void ti_jfree            __P((caddr_t, void *));
 193 static int ti_newbuf_std        __P((struct ti_softc *, int, struct mbuf *));
 194 static int ti_newbuf_mini       __P((struct ti_softc *, int, struct mbuf *));
 195 static int ti_newbuf_jumbo      __P((struct ti_softc *, int, struct mbuf *));
 196 static int ti_init_rx_ring_std  __P((struct ti_softc *));
 197 static void ti_free_rx_ring_std __P((struct ti_softc *));
 198 static int ti_init_rx_ring_jumbo        __P((struct ti_softc *));
 199 static void ti_free_rx_ring_jumbo       __P((struct ti_softc *));
 200 static int ti_init_rx_ring_mini __P((struct ti_softc *));
 201 static void ti_free_rx_ring_mini        __P((struct ti_softc *));
 202 static void ti_free_tx_ring     __P((struct ti_softc *));
 203 static int ti_init_tx_ring      __P((struct ti_softc *));
 204
 205 static int ti_64bitslot_war     __P((struct ti_softc *));
 206 static int ti_chipinit          __P((struct ti_softc *));
 207 static int ti_gibinit           __P((struct ti_softc *));
 208
 209 static device_method_t ti_methods[] = {
 210         /* Device interface */
 211         DEVMETHOD(device_probe,         ti_probe),
 212         DEVMETHOD(device_attach,        ti_attach),
 213         DEVMETHOD(device_detach,        ti_detach),
 214         DEVMETHOD(device_shutdown,      ti_shutdown),
 215         { 0, 0 }
 216 };
 217
 218 static driver_t ti_driver = {
 219         "ti",
 220         ti_methods,
 221         sizeof(struct ti_softc)
 222 };
 223
 224 static devclass_t ti_devclass;
 225
 226 DRIVER_MODULE(if_ti, pci, ti_driver, ti_devclass, 0, 0);
 227
 228 /*
 229  * Send an instruction or address to the EEPROM, check for ACK.
 230  */
 231 static u_int32_t ti_eeprom_putbyte(sc, byte)
 232         struct ti_softc         *sc;
 233         int                     byte;
 234 {
 235         register int            i, ack = 0;
 236
 237         /*
 238          * Make sure we're in TX mode.
 239          */
 240         TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_TXEN);
 241
 242         /*
 243          * Feed in each bit and stobe the clock.
 244          */
 245         for (i = 0x80; i; i >>= 1) {
 246                 if (byte & i) {
 247                         TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_DOUT);
 248                 } else {
 249                         TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_DOUT);
 250                 }
 251                 DELAY(1);
 252                 TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 253                 DELAY(1);
 254                 TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 255         }
 256
 257         /*
 258          * Turn off TX mode.
 259          */
 260         TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_TXEN);
 261
 262         /*
 263          * Check for ack.
 264          */
 265         TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 266         ack = CSR_READ_4(sc, TI_MISC_LOCAL_CTL) & TI_MLC_EE_DIN;
 267         TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 268
 269         return(ack);
 270 }
 271
 272 /*
 273  * Read a byte of data stored in the EEPROM at address 'addr.'
 274  * We have to send two address bytes since the EEPROM can hold
 275  * more than 256 bytes of data.
 276  */
 277 static u_int8_t ti_eeprom_getbyte(sc, addr, dest)
 278         struct ti_softc         *sc;
 279         int                     addr;
 280         u_int8_t                *dest;
 281 {
 282         register int            i;
 283         u_int8_t                byte = 0;
 284
 285         EEPROM_START;
 286
 287         /*
 288          * Send write control code to EEPROM.
 289          */
 290         if (ti_eeprom_putbyte(sc, EEPROM_CTL_WRITE)) {
 291                 printf("ti%d: failed to send write command, status: %x\n",
 292                     sc->ti_unit, CSR_READ_4(sc, TI_MISC_LOCAL_CTL));
 293                 return(1);
 294         }
 295
 296         /*
 297          * Send first byte of address of byte we want to read.
 298          */
 299         if (ti_eeprom_putbyte(sc, (addr >> 8) & 0xFF)) {
 300                 printf("ti%d: failed to send address, status: %x\n",
 301                     sc->ti_unit, CSR_READ_4(sc, TI_MISC_LOCAL_CTL));
 302                 return(1);
 303         }
 304         /*
 305          * Send second byte address of byte we want to read.
 306          */
 307         if (ti_eeprom_putbyte(sc, addr & 0xFF)) {
 308                 printf("ti%d: failed to send address, status: %x\n",
 309                     sc->ti_unit, CSR_READ_4(sc, TI_MISC_LOCAL_CTL));
 310                 return(1);
 311         }
 312
 313         EEPROM_STOP;
 314         EEPROM_START;
 315         /*
 316          * Send read control code to EEPROM.
 317          */
 318         if (ti_eeprom_putbyte(sc, EEPROM_CTL_READ)) {
 319                 printf("ti%d: failed to send read command, status: %x\n",
 320                     sc->ti_unit, CSR_READ_4(sc, TI_MISC_LOCAL_CTL));
 321                 return(1);
 322         }
 323
 324         /*
 325          * Start reading bits from EEPROM.
 326          */
 327         TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_TXEN);
 328         for (i = 0x80; i; i >>= 1) {
 329                 TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 330                 DELAY(1);
 331                 if (CSR_READ_4(sc, TI_MISC_LOCAL_CTL) & TI_MLC_EE_DIN)
 332                         byte |= i;
 333                 TI_CLRBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_EE_CLK);
 334                 DELAY(1);
 335         }
 336
 337         EEPROM_STOP;
 338
 339         /*
 340          * No ACK generated for read, so just return byte.
 341          */
 342
 343         *dest = byte;
 344
 345         return(0);
 346 }
 347
 348 /*
 349  * Read a sequence of bytes from the EEPROM.
 350  */
 351 static int ti_read_eeprom(sc, dest, off, cnt)
 352         struct ti_softc         *sc;
 353         caddr_t                 dest;
 354         int                     off;
 355         int                     cnt;
 356 {
 357         int                     err = 0, i;
 358         u_int8_t                byte = 0;
 359
 360         for (i = 0; i < cnt; i++) {
 361                 err = ti_eeprom_getbyte(sc, off + i, &byte);
 362                 if (err)
 363                         break;
 364                 *(dest + i) = byte;
 365         }
 366
 367         return(err ? 1 : 0);
 368 }
 369
 370 /*
 371  * NIC memory access function. Can be used to either clear a section
 372  * of NIC local memory or (if buf is non-NULL) copy data into it.
 373  */
 374 static void ti_mem(sc, addr, len, buf)
 375         struct ti_softc         *sc;
 376         u_int32_t               addr, len;
 377         caddr_t                 buf;
 378 {
 379         int                     segptr, segsize, cnt;
 380         caddr_t                 ti_winbase, ptr;
 381
 382         segptr = addr;
 383         cnt = len;
 384         ti_winbase = (caddr_t)(sc->ti_vhandle + TI_WINDOW);
 385         ptr = buf;
 386
 387         while(cnt) {
 388                 if (cnt < TI_WINLEN)
 389                         segsize = cnt;
 390                 else
 391                         segsize = TI_WINLEN - (segptr % TI_WINLEN);
 392                 CSR_WRITE_4(sc, TI_WINBASE, (segptr & ~(TI_WINLEN - 1)));
 393                 if (buf == NULL)
 394                         bzero((char *)ti_winbase + (segptr &
 395                             (TI_WINLEN - 1)), segsize);
 396                 else {
 397                         bcopy((char *)ptr, (char *)ti_winbase +
 398                             (segptr & (TI_WINLEN - 1)), segsize);
 399                         ptr += segsize;
 400                 }
 401                 segptr += segsize;
 402                 cnt -= segsize;
 403         }
 404
 405         return;
 406 }
 407
 408 /*
 409  * Load firmware image into the NIC. Check that the firmware revision
 410  * is acceptable and see if we want the firmware for the Tigon 1 or
 411  * Tigon 2.
 412  */
 413 static void ti_loadfw(sc)
 414         struct ti_softc         *sc;
 415 {
 416         switch(sc->ti_hwrev) {
 417         case TI_HWREV_TIGON:
 418                 if (tigonFwReleaseMajor != TI_FIRMWARE_MAJOR ||
 419                     tigonFwReleaseMinor != TI_FIRMWARE_MINOR ||
 420                     tigonFwReleaseFix != TI_FIRMWARE_FIX) {
 421                         printf("ti%d: firmware revision mismatch; want "
 422                             "%d.%d.%d, got %d.%d.%d\n", sc->ti_unit,
 423                             TI_FIRMWARE_MAJOR, TI_FIRMWARE_MINOR,
 424                             TI_FIRMWARE_FIX, tigonFwReleaseMajor,
 425                             tigonFwReleaseMinor, tigonFwReleaseFix);
 426                         return;
 427                 }
 428                 ti_mem(sc, tigonFwTextAddr, tigonFwTextLen,
 429                     (caddr_t)tigonFwText);
 430                 ti_mem(sc, tigonFwDataAddr, tigonFwDataLen,
 431                     (caddr_t)tigonFwData);
 432                 ti_mem(sc, tigonFwRodataAddr, tigonFwRodataLen,
 433                     (caddr_t)tigonFwRodata);
 434                 ti_mem(sc, tigonFwBssAddr, tigonFwBssLen, NULL);
 435                 ti_mem(sc, tigonFwSbssAddr, tigonFwSbssLen, NULL);
 436                 CSR_WRITE_4(sc, TI_CPU_PROGRAM_COUNTER, tigonFwStartAddr);
 437                 break;
 438         case TI_HWREV_TIGON_II:
 439                 if (tigon2FwReleaseMajor != TI_FIRMWARE_MAJOR ||
 440                     tigon2FwReleaseMinor != TI_FIRMWARE_MINOR ||
 441                     tigon2FwReleaseFix != TI_FIRMWARE_FIX) {
 442                         printf("ti%d: firmware revision mismatch; want "
 443                             "%d.%d.%d, got %d.%d.%d\n", sc->ti_unit,
 444                             TI_FIRMWARE_MAJOR, TI_FIRMWARE_MINOR,
 445                             TI_FIRMWARE_FIX, tigon2FwReleaseMajor,
 446                             tigon2FwReleaseMinor, tigon2FwReleaseFix);
 447                         return;
 448                 }
 449                 ti_mem(sc, tigon2FwTextAddr, tigon2FwTextLen,
 450                     (caddr_t)tigon2FwText);
 451                 ti_mem(sc, tigon2FwDataAddr, tigon2FwDataLen,
 452                     (caddr_t)tigon2FwData);
 453                 ti_mem(sc, tigon2FwRodataAddr, tigon2FwRodataLen,
 454                     (caddr_t)tigon2FwRodata);
 455                 ti_mem(sc, tigon2FwBssAddr, tigon2FwBssLen, NULL);
 456                 ti_mem(sc, tigon2FwSbssAddr, tigon2FwSbssLen, NULL);
 457                 CSR_WRITE_4(sc, TI_CPU_PROGRAM_COUNTER, tigon2FwStartAddr);
 458                 break;
 459         default:
 460                 printf("ti%d: can't load firmware: unknown hardware rev\n",
 461                     sc->ti_unit);
 462                 break;
 463         }
 464
 465         return;
 466 }
 467
 468 /*
 469  * Send the NIC a command via the command ring.
 470  */
 471 static void ti_cmd(sc, cmd)
 472         struct ti_softc         *sc;
 473         struct ti_cmd_desc      *cmd;
 474 {
 475         u_int32_t               index;
 476
 477         if (sc->ti_rdata->ti_cmd_ring == NULL)
 478                 return;
 479
 480         index = sc->ti_cmd_saved_prodidx;
 481         CSR_WRITE_4(sc, TI_GCR_CMDRING + (index * 4), *(u_int32_t *)(cmd));
 482         TI_INC(index, TI_CMD_RING_CNT);
 483         CSR_WRITE_4(sc, TI_MB_CMDPROD_IDX, index);
 484         sc->ti_cmd_saved_prodidx = index;
 485
 486         return;
 487 }
 488
 489 /*
 490  * Send the NIC an extended command. The 'len' parameter specifies the
 491  * number of command slots to include after the initial command.
 492  */
 493 static void ti_cmd_ext(sc, cmd, arg, len)
 494         struct ti_softc         *sc;
 495         struct ti_cmd_desc      *cmd;
 496         caddr_t                 arg;
 497         int                     len;
 498 {
 499         u_int32_t               index;
 500         register int            i;
 501
 502         if (sc->ti_rdata->ti_cmd_ring == NULL)
 503                 return;
 504
 505         index = sc->ti_cmd_saved_prodidx;
 506         CSR_WRITE_4(sc, TI_GCR_CMDRING + (index * 4), *(u_int32_t *)(cmd));
 507         TI_INC(index, TI_CMD_RING_CNT);
 508         for (i = 0; i < len; i++) {
 509                 CSR_WRITE_4(sc, TI_GCR_CMDRING + (index * 4),
 510                     *(u_int32_t *)(&arg[i * 4]));
 511                 TI_INC(index, TI_CMD_RING_CNT);
 512         }
 513         CSR_WRITE_4(sc, TI_MB_CMDPROD_IDX, index);
 514         sc->ti_cmd_saved_prodidx = index;
 515
 516         return;
 517 }
 518
 519 /*
 520  * Handle events that have triggered interrupts.
 521  */
 522 static void ti_handle_events(sc)
 523         struct ti_softc         *sc;
 524 {
 525         struct ti_event_desc    *e;
 526
 527         if (sc->ti_rdata->ti_event_ring == NULL)
 528                 return;
 529
 530         while (sc->ti_ev_saved_considx != sc->ti_ev_prodidx.ti_idx) {
 531                 e = &sc->ti_rdata->ti_event_ring[sc->ti_ev_saved_considx];
 532                 switch(e->ti_event) {
 533                 case TI_EV_LINKSTAT_CHANGED:
 534                         sc->ti_linkstat = e->ti_code;
 535                         if (e->ti_code == TI_EV_CODE_LINK_UP)
 536                                 printf("ti%d: 10/100 link up\n", sc->ti_unit);
 537                         else if (e->ti_code == TI_EV_CODE_GIG_LINK_UP)
 538                                 printf("ti%d: gigabit link up\n", sc->ti_unit);
 539                         else if (e->ti_code == TI_EV_CODE_LINK_DOWN)
 540                                 printf("ti%d: link down\n", sc->ti_unit);
 541                         break;
 542                 case TI_EV_ERROR:
 543                         if (e->ti_code == TI_EV_CODE_ERR_INVAL_CMD)
 544                                 printf("ti%d: invalid command\n", sc->ti_unit);
 545                         else if (e->ti_code == TI_EV_CODE_ERR_UNIMP_CMD)
 546                                 printf("ti%d: unknown command\n", sc->ti_unit);
 547                         else if (e->ti_code == TI_EV_CODE_ERR_BADCFG)
 548                                 printf("ti%d: bad config data\n", sc->ti_unit);
 549                         break;
 550                 case TI_EV_FIRMWARE_UP:
 551                         ti_init2(sc);
 552                         break;
 553                 case TI_EV_STATS_UPDATED:
 554                         ti_stats_update(sc);
 555                         break;
 556                 case TI_EV_RESET_JUMBO_RING:
 557                 case TI_EV_MCAST_UPDATED:
 558                         /* Who cares. */
 559                         break;
 560                 default:
 561                         printf("ti%d: unknown event: %d\n",
 562                             sc->ti_unit, e->ti_event);
 563                         break;
 564                 }
 565                 /* Advance the consumer index. */
 566                 TI_INC(sc->ti_ev_saved_considx, TI_EVENT_RING_CNT);
 567                 CSR_WRITE_4(sc, TI_GCR_EVENTCONS_IDX, sc->ti_ev_saved_considx);
 568         }
 569
 570         return;
 571 }
 572
 573 /*
 574  * Memory management for the jumbo receive ring is a pain in the
 575  * butt. We need to allocate at least 9018 bytes of space per frame,
 576  * _and_ it has to be contiguous (unless you use the extended
 577  * jumbo descriptor format). Using malloc() all the time won't
 578  * work: malloc() allocates memory in powers of two, which means we
 579  * would end up wasting a considerable amount of space by allocating
 580  * 9K chunks. We don't have a jumbo mbuf cluster pool. Thus, we have
 581  * to do our own memory management.
 582  *
 583  * The driver needs to allocate a contiguous chunk of memory at boot
 584  * time. We then chop this up ourselves into 9K pieces and use them
 585  * as external mbuf storage.
 586  *
 587  * One issue here is how much memory to allocate. The jumbo ring has
 588  * 256 slots in it, but at 9K per slot than can consume over 2MB of
 589  * RAM. This is a bit much, especially considering we also need
 590  * RAM for the standard ring and mini ring (on the Tigon 2). To
 591  * save space, we only actually allocate enough memory for 64 slots
 592  * by default, which works out to between 500 and 600K. This can
 593  * be tuned by changing a #define in if_tireg.h.
 594  */
 595
 596 static int ti_alloc_jumbo_mem(sc)
 597         struct ti_softc         *sc;
 598 {
 599         caddr_t                 ptr;
 600         register int            i;
 601         struct ti_jpool_entry   *entry;
 602
 603         /* Grab a big chunk o' storage. */
 604         sc->ti_cdata.ti_jumbo_buf = contigmalloc(TI_JMEM, M_DEVBUF,
 605                 M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
 606
 607         if (sc->ti_cdata.ti_jumbo_buf == NULL) {
 608                 printf("ti%d: no memory for jumbo buffers!\n", sc->ti_unit);
 609                 return(ENOBUFS);
 610         }
 611
 612         SLIST_INIT(&sc->ti_jfree_listhead);
 613         SLIST_INIT(&sc->ti_jinuse_listhead);
 614
 615         /*
 616          * Now divide it up into 9K pieces and save the addresses
 617          * in an array.
 618          */
 619         ptr = sc->ti_cdata.ti_jumbo_buf;
 620         for (i = 0; i < TI_JSLOTS; i++) {
 621                 sc->ti_cdata.ti_jslots[i] = ptr;
 622                 ptr += TI_JLEN;
 623                 entry = malloc(sizeof(struct ti_jpool_entry),
 624                                M_DEVBUF, M_NOWAIT);
 625                 if (entry == NULL) {
 626                         contigfree(sc->ti_cdata.ti_jumbo_buf, TI_JMEM,
 627                                    M_DEVBUF);
 628                         sc->ti_cdata.ti_jumbo_buf = NULL;
 629                         printf("ti%d: no memory for jumbo "
 630                             "buffer queue!\n", sc->ti_unit);
 631                         return(ENOBUFS);
 632                 }
 633                 entry->slot = i;
 634                 SLIST_INSERT_HEAD(&sc->ti_jfree_listhead, entry, jpool_entries);
 635         }
 636
 637         return(0);
 638 }
 639
 640 /*
 641  * Allocate a jumbo buffer.
 642  */
 643 static void *ti_jalloc(sc)
 644         struct ti_softc         *sc;
 645 {
 646         struct ti_jpool_entry   *entry;
 647
 648         entry = SLIST_FIRST(&sc->ti_jfree_listhead);
 649
 650         if (entry == NULL) {
 651                 printf("ti%d: no free jumbo buffers\n", sc->ti_unit);
 652                 return(NULL);
 653         }
 654
 655         SLIST_REMOVE_HEAD(&sc->ti_jfree_listhead, jpool_entries);
 656         SLIST_INSERT_HEAD(&sc->ti_jinuse_listhead, entry, jpool_entries);
 657         return(sc->ti_cdata.ti_jslots[entry->slot]);
 658 }
 659
 660 /*
 661  * Release a jumbo buffer.
 662  */
 663 static void ti_jfree(buf, args)
 664         caddr_t                 buf;
 665         void                    *args;
 666 {
 667         struct ti_softc         *sc;
 668         int                     i;
 669         struct ti_jpool_entry   *entry;
 670
 671         /* Extract the softc struct pointer. */
 672         sc = (struct ti_softc *)args;
 673
 674         if (sc == NULL)
 675                 panic("ti_jfree: didn't get softc pointer!");
 676
 677         /* calculate the slot this buffer belongs to */
 678         i = ((vm_offset_t)buf
 679              - (vm_offset_t)sc->ti_cdata.ti_jumbo_buf) / TI_JLEN;
 680
 681         if ((i < 0) || (i >= TI_JSLOTS))
 682                 panic("ti_jfree: asked to free buffer that we don't manage!");
 683
 684         entry = SLIST_FIRST(&sc->ti_jinuse_listhead);
 685         if (entry == NULL)
 686                 panic("ti_jfree: buffer not in use!");
 687         entry->slot = i;
 688         SLIST_REMOVE_HEAD(&sc->ti_jinuse_listhead, jpool_entries);
 689         SLIST_INSERT_HEAD(&sc->ti_jfree_listhead, entry, jpool_entries);
 690
 691         return;
 692 }
 693
 694
 695 /*
 696  * Intialize a standard receive ring descriptor.
 697  */
 698 static int ti_newbuf_std(sc, i, m)
 699         struct ti_softc         *sc;
 700         int                     i;
 701         struct mbuf             *m;
 702 {
 703         struct mbuf             *m_new = NULL;
 704         struct ti_rx_desc       *r;
 705
 706         if (m == NULL) {
 707                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 708                 if (m_new == NULL) {
 709                         printf("ti%d: mbuf allocation failed "
 710                             "-- packet dropped!\n", sc->ti_unit);
 711                         return(ENOBUFS);
 712                 }
 713
 714                 MCLGET(m_new, M_DONTWAIT);
 715                 if (!(m_new->m_flags & M_EXT)) {
 716                         printf("ti%d: cluster allocation failed "
 717                             "-- packet dropped!\n", sc->ti_unit);
 718                         m_freem(m_new);
 719                         return(ENOBUFS);
 720                 }
 721                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 722         } else {
 723                 m_new = m;
 724                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 725                 m_new->m_data = m_new->m_ext.ext_buf;
 726         }
 727
 728         m_adj(m_new, ETHER_ALIGN);
 729         sc->ti_cdata.ti_rx_std_chain[i] = m_new;
 730         r = &sc->ti_rdata->ti_rx_std_ring[i];
 731         TI_HOSTADDR(r->ti_addr) = vtophys(mtod(m_new, caddr_t));
 732         r->ti_type = TI_BDTYPE_RECV_BD;
 733         r->ti_flags = 0;
 734         if (sc->arpcom.ac_if.if_hwassist)
 735                 r->ti_flags |= TI_BDFLAG_TCP_UDP_CKSUM | TI_BDFLAG_IP_CKSUM;
 736         r->ti_len = m_new->m_len;
 737         r->ti_idx = i;
 738
 739         return(0);
 740 }
 741
 742 /*
 743  * Intialize a mini receive ring descriptor. This only applies to
 744  * the Tigon 2.
 745  */
 746 static int ti_newbuf_mini(sc, i, m)
 747         struct ti_softc         *sc;
 748         int                     i;
 749         struct mbuf             *m;
 750 {
 751         struct mbuf             *m_new = NULL;
 752         struct ti_rx_desc       *r;
 753
 754         if (m == NULL) {
 755                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 756                 if (m_new == NULL) {
 757                         printf("ti%d: mbuf allocation failed "
 758                             "-- packet dropped!\n", sc->ti_unit);
 759                         return(ENOBUFS);
 760                 }
 761                 m_new->m_len = m_new->m_pkthdr.len = MHLEN;
 762         } else {
 763                 m_new = m;
 764                 m_new->m_data = m_new->m_pktdat;
 765                 m_new->m_len = m_new->m_pkthdr.len = MHLEN;
 766         }
 767
 768         m_adj(m_new, ETHER_ALIGN);
 769         r = &sc->ti_rdata->ti_rx_mini_ring[i];
 770         sc->ti_cdata.ti_rx_mini_chain[i] = m_new;
 771         TI_HOSTADDR(r->ti_addr) = vtophys(mtod(m_new, caddr_t));
 772         r->ti_type = TI_BDTYPE_RECV_BD;
 773         r->ti_flags = TI_BDFLAG_MINI_RING;
 774         if (sc->arpcom.ac_if.if_hwassist)
 775                 r->ti_flags |= TI_BDFLAG_TCP_UDP_CKSUM | TI_BDFLAG_IP_CKSUM;
 776         r->ti_len = m_new->m_len;
 777         r->ti_idx = i;
 778
 779         return(0);
 780 }
 781
 782 /*
 783  * Initialize a jumbo receive ring descriptor. This allocates
 784  * a jumbo buffer from the pool managed internally by the driver.
 785  */
 786 static int ti_newbuf_jumbo(sc, i, m)
 787         struct ti_softc         *sc;
 788         int                     i;
 789         struct mbuf             *m;
 790 {
 791         struct mbuf             *m_new = NULL;
 792         struct ti_rx_desc       *r;
 793
 794         if (m == NULL) {
 795                 caddr_t                 *buf = NULL;
 796
 797                 /* Allocate the mbuf. */
 798                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 799                 if (m_new == NULL) {
 800                         printf("ti%d: mbuf allocation failed "
 801                             "-- packet dropped!\n", sc->ti_unit);
 802                         return(ENOBUFS);
 803                 }
 804
 805                 /* Allocate the jumbo buffer */
 806                 buf = ti_jalloc(sc);
 807                 if (buf == NULL) {
 808                         m_freem(m_new);
 809                         printf("ti%d: jumbo allocation failed "
 810                             "-- packet dropped!\n", sc->ti_unit);
 811                         return(ENOBUFS);
 812                 }
 813
 814                 /* Attach the buffer to the mbuf. */
 815                 m_new->m_data = (void *) buf;
 816                 m_new->m_len = m_new->m_pkthdr.len = TI_JUMBO_FRAMELEN;
 817                 MEXTADD(m_new, buf, TI_JUMBO_FRAMELEN, ti_jfree,
 818                     (struct ti_softc *)sc, 0, EXT_NET_DRV);
 819         } else {
 820                 m_new = m;
 821                 m_new->m_data = m_new->m_ext.ext_buf;
 822                 m_new->m_ext.ext_size = TI_JUMBO_FRAMELEN;
 823         }
 824
 825         m_adj(m_new, ETHER_ALIGN);
 826         /* Set up the descriptor. */
 827         r = &sc->ti_rdata->ti_rx_jumbo_ring[i];
 828         sc->ti_cdata.ti_rx_jumbo_chain[i] = m_new;
 829         TI_HOSTADDR(r->ti_addr) = vtophys(mtod(m_new, caddr_t));
 830         r->ti_type = TI_BDTYPE_RECV_JUMBO_BD;
 831         r->ti_flags = TI_BDFLAG_JUMBO_RING;
 832         if (sc->arpcom.ac_if.if_hwassist)
 833                 r->ti_flags |= TI_BDFLAG_TCP_UDP_CKSUM | TI_BDFLAG_IP_CKSUM;
 834         r->ti_len = m_new->m_len;
 835         r->ti_idx = i;
 836
 837         return(0);
 838 }
 839
 840 /*
 841  * The standard receive ring has 512 entries in it. At 2K per mbuf cluster,
 842  * that's 1MB or memory, which is a lot. For now, we fill only the first
 843  * 256 ring entries and hope that our CPU is fast enough to keep up with
 844  * the NIC.
 845  */
 846 static int ti_init_rx_ring_std(sc)
 847         struct ti_softc         *sc;
 848 {
 849         register int            i;
 850         struct ti_cmd_desc      cmd;
 851
 852         for (i = 0; i < TI_SSLOTS; i++) {
 853                 if (ti_newbuf_std(sc, i, NULL) == ENOBUFS)
 854                         return(ENOBUFS);
 855         };
 856
 857         TI_UPDATE_STDPROD(sc, i - 1);
 858         sc->ti_std = i - 1;
 859
 860         return(0);
 861 }
 862
 863 static void ti_free_rx_ring_std(sc)
 864         struct ti_softc         *sc;
 865 {
 866         register int            i;
 867
 868         for (i = 0; i < TI_STD_RX_RING_CNT; i++) {
 869                 if (sc->ti_cdata.ti_rx_std_chain[i] != NULL) {
 870                         m_freem(sc->ti_cdata.ti_rx_std_chain[i]);
 871                         sc->ti_cdata.ti_rx_std_chain[i] = NULL;
 872                 }
 873                 bzero((char *)&sc->ti_rdata->ti_rx_std_ring[i],
 874                     sizeof(struct ti_rx_desc));
 875         }
 876
 877         return;
 878 }
 879
 880 static int ti_init_rx_ring_jumbo(sc)
 881         struct ti_softc         *sc;
 882 {
 883         register int            i;
 884         struct ti_cmd_desc      cmd;
 885
 886         for (i = 0; i < TI_JUMBO_RX_RING_CNT; i++) {
 887                 if (ti_newbuf_jumbo(sc, i, NULL) == ENOBUFS)
 888                         return(ENOBUFS);
 889         };
 890
 891         TI_UPDATE_JUMBOPROD(sc, i - 1);
 892         sc->ti_jumbo = i - 1;
 893
 894         return(0);
 895 }
 896
 897 static void ti_free_rx_ring_jumbo(sc)
 898         struct ti_softc         *sc;
 899 {
 900         register int            i;
 901
 902         for (i = 0; i < TI_JUMBO_RX_RING_CNT; i++) {
 903                 if (sc->ti_cdata.ti_rx_jumbo_chain[i] != NULL) {
 904                         m_freem(sc->ti_cdata.ti_rx_jumbo_chain[i]);
 905                         sc->ti_cdata.ti_rx_jumbo_chain[i] = NULL;
 906                 }
 907                 bzero((char *)&sc->ti_rdata->ti_rx_jumbo_ring[i],
 908                     sizeof(struct ti_rx_desc));
 909         }
 910
 911         return;
 912 }
 913
 914 static int ti_init_rx_ring_mini(sc)
 915         struct ti_softc         *sc;
 916 {
 917         register int            i;
 918
 919         for (i = 0; i < TI_MSLOTS; i++) {
 920                 if (ti_newbuf_mini(sc, i, NULL) == ENOBUFS)
 921                         return(ENOBUFS);
 922         };
 923
 924         TI_UPDATE_MINIPROD(sc, i - 1);
 925         sc->ti_mini = i - 1;
 926
 927         return(0);
 928 }
 929
 930 static void ti_free_rx_ring_mini(sc)
 931         struct ti_softc         *sc;
 932 {
 933         register int            i;
 934
 935         for (i = 0; i < TI_MINI_RX_RING_CNT; i++) {
 936                 if (sc->ti_cdata.ti_rx_mini_chain[i] != NULL) {
 937                         m_freem(sc->ti_cdata.ti_rx_mini_chain[i]);
 938                         sc->ti_cdata.ti_rx_mini_chain[i] = NULL;
 939                 }
 940                 bzero((char *)&sc->ti_rdata->ti_rx_mini_ring[i],
 941                     sizeof(struct ti_rx_desc));
 942         }
 943
 944         return;
 945 }
 946
 947 static void ti_free_tx_ring(sc)
 948         struct ti_softc         *sc;
 949 {
 950         register int            i;
 951
 952         if (sc->ti_rdata->ti_tx_ring == NULL)
 953                 return;
 954
 955         for (i = 0; i < TI_TX_RING_CNT; i++) {
 956                 if (sc->ti_cdata.ti_tx_chain[i] != NULL) {
 957                         m_freem(sc->ti_cdata.ti_tx_chain[i]);
 958                         sc->ti_cdata.ti_tx_chain[i] = NULL;
 959                 }
 960                 bzero((char *)&sc->ti_rdata->ti_tx_ring[i],
 961                     sizeof(struct ti_tx_desc));
 962         }
 963
 964         return;
 965 }
 966
 967 static int ti_init_tx_ring(sc)
 968         struct ti_softc         *sc;
 969 {
 970         sc->ti_txcnt = 0;
 971         sc->ti_tx_saved_considx = 0;
 972         CSR_WRITE_4(sc, TI_MB_SENDPROD_IDX, 0);
 973         return(0);
 974 }
 975
 976 /*
 977  * The Tigon 2 firmware has a new way to add/delete multicast addresses,
 978  * but we have to support the old way too so that Tigon 1 cards will
 979  * work.
 980  */
 981 void ti_add_mcast(sc, addr)
 982         struct ti_softc         *sc;
 983         struct ether_addr       *addr;
 984 {
 985         struct ti_cmd_desc      cmd;
 986         u_int16_t               *m;
 987         u_int32_t               ext[2] = {0, 0};
 988
 989         m = (u_int16_t *)&addr->octet[0];
 990
 991         switch(sc->ti_hwrev) {
 992         case TI_HWREV_TIGON:
 993                 CSR_WRITE_4(sc, TI_GCR_MAR0, htons(m[0]));
 994                 CSR_WRITE_4(sc, TI_GCR_MAR1, (htons(m[1]) << 16) | htons(m[2]));
 995                 TI_DO_CMD(TI_CMD_ADD_MCAST_ADDR, 0, 0);
 996                 break;
 997         case TI_HWREV_TIGON_II:
 998                 ext[0] = htons(m[0]);
 999                 ext[1] = (htons(m[1]) << 16) | htons(m[2]);
1000                 TI_DO_CMD_EXT(TI_CMD_EXT_ADD_MCAST, 0, 0, (caddr_t)&ext, 2);
1001                 break;
1002         default:
1003                 printf("ti%d: unknown hwrev\n", sc->ti_unit);
1004                 break;
1005         }
1006
1007         return;
1008 }
1009
1010 void ti_del_mcast(sc, addr)
1011         struct ti_softc         *sc;
1012         struct ether_addr       *addr;
1013 {
1014         struct ti_cmd_desc      cmd;
1015         u_int16_t               *m;
1016         u_int32_t               ext[2] = {0, 0};
1017
1018         m = (u_int16_t *)&addr->octet[0];
1019
1020         switch(sc->ti_hwrev) {
1021         case TI_HWREV_TIGON:
1022                 CSR_WRITE_4(sc, TI_GCR_MAR0, htons(m[0]));
1023                 CSR_WRITE_4(sc, TI_GCR_MAR1, (htons(m[1]) << 16) | htons(m[2]));
1024                 TI_DO_CMD(TI_CMD_DEL_MCAST_ADDR, 0, 0);
1025                 break;
1026         case TI_HWREV_TIGON_II:
1027                 ext[0] = htons(m[0]);
1028                 ext[1] = (htons(m[1]) << 16) | htons(m[2]);
1029                 TI_DO_CMD_EXT(TI_CMD_EXT_DEL_MCAST, 0, 0, (caddr_t)&ext, 2);
1030                 break;
1031         default:
1032                 printf("ti%d: unknown hwrev\n", sc->ti_unit);
1033                 break;
1034         }
1035
1036         return;
1037 }
1038
1039 /*
1040  * Configure the Tigon's multicast address filter.
1041  *
1042  * The actual multicast table management is a bit of a pain, thanks to
1043  * slight brain damage on the part of both Alteon and us. With our
1044  * multicast code, we are only alerted when the multicast address table
1045  * changes and at that point we only have the current list of addresses:
1046  * we only know the current state, not the previous state, so we don't
1047  * actually know what addresses were removed or added. The firmware has
1048  * state, but we can't get our grubby mits on it, and there is no 'delete
1049  * all multicast addresses' command. Hence, we have to maintain our own
1050  * state so we know what addresses have been programmed into the NIC at
1051  * any given time.
1052  */
1053 static void ti_setmulti(sc)
1054         struct ti_softc         *sc;
1055 {
1056         struct ifnet            *ifp;
1057         struct ifmultiaddr      *ifma;
1058         struct ti_cmd_desc      cmd;
1059         struct ti_mc_entry      *mc;
1060         u_int32_t               intrs;
1061
1062         ifp = &sc->arpcom.ac_if;
1063
1064         if (ifp->if_flags & IFF_ALLMULTI) {
1065                 TI_DO_CMD(TI_CMD_SET_ALLMULTI, TI_CMD_CODE_ALLMULTI_ENB, 0);
1066                 return;
1067         } else {
1068                 TI_DO_CMD(TI_CMD_SET_ALLMULTI, TI_CMD_CODE_ALLMULTI_DIS, 0);
1069         }
1070
1071         /* Disable interrupts. */
1072         intrs = CSR_READ_4(sc, TI_MB_HOSTINTR);
1073         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1);
1074
1075         /* First, zot all the existing filters. */
1076         while (SLIST_FIRST(&sc->ti_mc_listhead) != NULL) {
1077                 mc = SLIST_FIRST(&sc->ti_mc_listhead);
1078                 ti_del_mcast(sc, &mc->mc_addr);
1079                 SLIST_REMOVE_HEAD(&sc->ti_mc_listhead, mc_entries);
1080                 free(mc, M_DEVBUF);
1081         }
1082
1083         /* Now program new ones. */
1084         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1085                 if (ifma->ifma_addr->sa_family != AF_LINK)
1086                         continue;
1087                 mc = malloc(sizeof(struct ti_mc_entry), M_DEVBUF, M_NOWAIT);
1088                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
1089                     (char *)&mc->mc_addr, ETHER_ADDR_LEN);
1090                 SLIST_INSERT_HEAD(&sc->ti_mc_listhead, mc, mc_entries);
1091                 ti_add_mcast(sc, &mc->mc_addr);
1092         }
1093
1094         /* Re-enable interrupts. */
1095         CSR_WRITE_4(sc, TI_MB_HOSTINTR, intrs);
1096
1097         return;
1098 }
1099
1100 /*
1101  * Check to see if the BIOS has configured us for a 64 bit slot when
1102  * we aren't actually in one. If we detect this condition, we can work
1103  * around it on the Tigon 2 by setting a bit in the PCI state register,
1104  * but for the Tigon 1 we must give up and abort the interface attach.
1105  */
1106 static int ti_64bitslot_war(sc)
1107         struct ti_softc         *sc;
1108 {
1109         if (!(CSR_READ_4(sc, TI_PCI_STATE) & TI_PCISTATE_32BIT_BUS)) {
1110                 CSR_WRITE_4(sc, 0x600, 0);
1111                 CSR_WRITE_4(sc, 0x604, 0);
1112                 CSR_WRITE_4(sc, 0x600, 0x5555AAAA);
1113                 if (CSR_READ_4(sc, 0x604) == 0x5555AAAA) {
1114                         if (sc->ti_hwrev == TI_HWREV_TIGON)
1115                                 return(EINVAL);
1116                         else {
1117                                 TI_SETBIT(sc, TI_PCI_STATE,
1118                                     TI_PCISTATE_32BIT_BUS);
1119                                 return(0);
1120                         }
1121                 }
1122         }
1123
1124         return(0);
1125 }
1126
1127 /*
1128  * Do endian, PCI and DMA initialization. Also check the on-board ROM
1129  * self-test results.
1130  */
1131 static int ti_chipinit(sc)
1132         struct ti_softc         *sc;
1133 {
1134         u_int32_t               cacheline;
1135         u_int32_t               pci_writemax = 0;
1136
1137         /* Initialize link to down state. */
1138         sc->ti_linkstat = TI_EV_CODE_LINK_DOWN;
1139
1140         sc->arpcom.ac_if.if_hwassist = TI_CSUM_FEATURES;
1141
1142         /* Set endianness before we access any non-PCI registers. */
1143 #if BYTE_ORDER == BIG_ENDIAN
1144         CSR_WRITE_4(sc, TI_MISC_HOST_CTL,
1145             TI_MHC_BIGENDIAN_INIT | (TI_MHC_BIGENDIAN_INIT << 24));
1146 #else
1147         CSR_WRITE_4(sc, TI_MISC_HOST_CTL,
1148             TI_MHC_LITTLEENDIAN_INIT | (TI_MHC_LITTLEENDIAN_INIT << 24));
1149 #endif
1150
1151         /* Check the ROM failed bit to see if self-tests passed. */
1152         if (CSR_READ_4(sc, TI_CPU_STATE) & TI_CPUSTATE_ROMFAIL) {
1153                 printf("ti%d: board self-diagnostics failed!\n", sc->ti_unit);
1154                 return(ENODEV);
1155         }
1156
1157         /* Halt the CPU. */
1158         TI_SETBIT(sc, TI_CPU_STATE, TI_CPUSTATE_HALT);
1159
1160         /* Figure out the hardware revision. */
1161         switch(CSR_READ_4(sc, TI_MISC_HOST_CTL) & TI_MHC_CHIP_REV_MASK) {
1162         case TI_REV_TIGON_I:
1163                 sc->ti_hwrev = TI_HWREV_TIGON;
1164                 break;
1165         case TI_REV_TIGON_II:
1166                 sc->ti_hwrev = TI_HWREV_TIGON_II;
1167                 break;
1168         default:
1169                 printf("ti%d: unsupported chip revision\n", sc->ti_unit);
1170                 return(ENODEV);
1171         }
1172
1173         /* Do special setup for Tigon 2. */
1174         if (sc->ti_hwrev == TI_HWREV_TIGON_II) {
1175                 TI_SETBIT(sc, TI_CPU_CTL_B, TI_CPUSTATE_HALT);
1176                 TI_SETBIT(sc, TI_MISC_LOCAL_CTL, TI_MLC_SRAM_BANK_512K);
1177                 TI_SETBIT(sc, TI_MISC_CONF, TI_MCR_SRAM_SYNCHRONOUS);
1178         }
1179
1180         /* Set up the PCI state register. */
1181         CSR_WRITE_4(sc, TI_PCI_STATE, TI_PCI_READ_CMD|TI_PCI_WRITE_CMD);
1182         if (sc->ti_hwrev == TI_HWREV_TIGON_II) {
1183                 TI_SETBIT(sc, TI_PCI_STATE, TI_PCISTATE_USE_MEM_RD_MULT);
1184         }
1185
1186         /* Clear the read/write max DMA parameters. */
1187         TI_CLRBIT(sc, TI_PCI_STATE, (TI_PCISTATE_WRITE_MAXDMA|
1188             TI_PCISTATE_READ_MAXDMA));
1189
1190         /* Get cache line size. */
1191         cacheline = CSR_READ_4(sc, TI_PCI_BIST) & 0xFF;
1192
1193         /*
1194          * If the system has set enabled the PCI memory write
1195          * and invalidate command in the command register, set
1196          * the write max parameter accordingly. This is necessary
1197          * to use MWI with the Tigon 2.
1198          */
1199         if (CSR_READ_4(sc, TI_PCI_CMDSTAT) & PCIM_CMD_MWIEN) {
1200                 switch(cacheline) {
1201                 case 1:
1202                 case 4:
1203                 case 8:
1204                 case 16:
1205                 case 32:
1206                 case 64:
1207                         break;
1208                 default:
1209                 /* Disable PCI memory write and invalidate. */
1210                         if (bootverbose)
1211                                 printf("ti%d: cache line size %d not "
1212                                     "supported; disabling PCI MWI\n",
1213                                     sc->ti_unit, cacheline);
1214                         CSR_WRITE_4(sc, TI_PCI_CMDSTAT, CSR_READ_4(sc,
1215                             TI_PCI_CMDSTAT) & ~PCIM_CMD_MWIEN);
1216                         break;
1217                 }
1218         }
1219
1220 #ifdef __brokenalpha__
1221         /*
1222          * From the Alteon sample driver:
1223          * Must insure that we do not cross an 8K (bytes) boundary
1224          * for DMA reads.  Our highest limit is 1K bytes.  This is a
1225          * restriction on some ALPHA platforms with early revision
1226          * 21174 PCI chipsets, such as the AlphaPC 164lx
1227          */
1228         TI_SETBIT(sc, TI_PCI_STATE, pci_writemax|TI_PCI_READMAX_1024);
1229 #else
1230         TI_SETBIT(sc, TI_PCI_STATE, pci_writemax);
1231 #endif
1232
1233         /* This sets the min dma param all the way up (0xff). */
1234         TI_SETBIT(sc, TI_PCI_STATE, TI_PCISTATE_MINDMA);
1235
1236         /* Configure DMA variables. */
1237 #if BYTE_ORDER == BIG_ENDIAN
1238         CSR_WRITE_4(sc, TI_GCR_OPMODE, TI_OPMODE_BYTESWAP_BD |
1239             TI_OPMODE_BYTESWAP_DATA | TI_OPMODE_WORDSWAP_BD |
1240             TI_OPMODE_WARN_ENB | TI_OPMODE_FATAL_ENB |
1241             TI_OPMODE_DONT_FRAG_JUMBO);
1242 #else
1243         CSR_WRITE_4(sc, TI_GCR_OPMODE, TI_OPMODE_BYTESWAP_DATA|
1244             TI_OPMODE_WORDSWAP_BD|TI_OPMODE_DONT_FRAG_JUMBO|
1245             TI_OPMODE_WARN_ENB|TI_OPMODE_FATAL_ENB);
1246 #endif
1247
1248         /*
1249          * Only allow 1 DMA channel to be active at a time.
1250          * I don't think this is a good idea, but without it
1251          * the firmware racks up lots of nicDmaReadRingFull
1252          * errors.  This is not compatible with hardware checksums.
1253          */
1254         if (sc->arpcom.ac_if.if_hwassist == 0)
1255                 TI_SETBIT(sc, TI_GCR_OPMODE, TI_OPMODE_1_DMA_ACTIVE);
1256
1257         /* Recommended settings from Tigon manual. */
1258         CSR_WRITE_4(sc, TI_GCR_DMA_WRITECFG, TI_DMA_STATE_THRESH_8W);
1259         CSR_WRITE_4(sc, TI_GCR_DMA_READCFG, TI_DMA_STATE_THRESH_8W);
1260
1261         if (ti_64bitslot_war(sc)) {
1262                 printf("ti%d: bios thinks we're in a 64 bit slot, "
1263                     "but we aren't", sc->ti_unit);
1264                 return(EINVAL);
1265         }
1266
1267         return(0);
1268 }
1269
1270 /*
1271  * Initialize the general information block and firmware, and
1272  * start the CPU(s) running.
1273  */
1274 static int ti_gibinit(sc)
1275         struct ti_softc         *sc;
1276 {
1277         struct ti_rcb           *rcb;
1278         int                     i;
1279         struct ifnet            *ifp;
1280
1281         ifp = &sc->arpcom.ac_if;
1282
1283         /* Disable interrupts for now. */
1284         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1);
1285
1286         /* Tell the chip where to find the general information block. */
1287         CSR_WRITE_4(sc, TI_GCR_GENINFO_HI, 0);
1288         CSR_WRITE_4(sc, TI_GCR_GENINFO_LO, vtophys(&sc->ti_rdata->ti_info));
1289
1290         /* Load the firmware into SRAM. */
1291         ti_loadfw(sc);
1292
1293         /* Set up the contents of the general info and ring control blocks. */
1294
1295         /* Set up the event ring and producer pointer. */
1296         rcb = &sc->ti_rdata->ti_info.ti_ev_rcb;
1297
1298         TI_HOSTADDR(rcb->ti_hostaddr) = vtophys(&sc->ti_rdata->ti_event_ring);
1299         rcb->ti_flags = 0;
1300         TI_HOSTADDR(sc->ti_rdata->ti_info.ti_ev_prodidx_ptr) =
1301             vtophys(&sc->ti_ev_prodidx);
1302         sc->ti_ev_prodidx.ti_idx = 0;
1303         CSR_WRITE_4(sc, TI_GCR_EVENTCONS_IDX, 0);
1304         sc->ti_ev_saved_considx = 0;
1305
1306         /* Set up the command ring and producer mailbox. */
1307         rcb = &sc->ti_rdata->ti_info.ti_cmd_rcb;
1308
1309         sc->ti_rdata->ti_cmd_ring =
1310             (struct ti_cmd_desc *)(sc->ti_vhandle + TI_GCR_CMDRING);
1311         TI_HOSTADDR(rcb->ti_hostaddr) = TI_GCR_NIC_ADDR(TI_GCR_CMDRING);
1312         rcb->ti_flags = 0;
1313         rcb->ti_max_len = 0;
1314         for (i = 0; i < TI_CMD_RING_CNT; i++) {
1315                 CSR_WRITE_4(sc, TI_GCR_CMDRING + (i * 4), 0);
1316         }
1317         CSR_WRITE_4(sc, TI_GCR_CMDCONS_IDX, 0);
1318         CSR_WRITE_4(sc, TI_MB_CMDPROD_IDX, 0);
1319         sc->ti_cmd_saved_prodidx = 0;
1320
1321         /*
1322          * Assign the address of the stats refresh buffer.
1323          * We re-use the current stats buffer for this to
1324          * conserve memory.
1325          */
1326         TI_HOSTADDR(sc->ti_rdata->ti_info.ti_refresh_stats_ptr) =
1327             vtophys(&sc->ti_rdata->ti_info.ti_stats);
1328
1329         /* Set up the standard receive ring. */
1330         rcb = &sc->ti_rdata->ti_info.ti_std_rx_rcb;
1331         TI_HOSTADDR(rcb->ti_hostaddr) = vtophys(&sc->ti_rdata->ti_rx_std_ring);
1332         rcb->ti_max_len = TI_FRAMELEN;
1333         rcb->ti_flags = 0;
1334         if (sc->arpcom.ac_if.if_hwassist)
1335                 rcb->ti_flags |= TI_RCB_FLAG_TCP_UDP_CKSUM |
1336                      TI_RCB_FLAG_IP_CKSUM | TI_RCB_FLAG_NO_PHDR_CKSUM;
1337 #if NVLAN > 0
1338         rcb->ti_flags |= TI_RCB_FLAG_VLAN_ASSIST;
1339 #endif
1340
1341         /* Set up the jumbo receive ring. */
1342         rcb = &sc->ti_rdata->ti_info.ti_jumbo_rx_rcb;
1343         TI_HOSTADDR(rcb->ti_hostaddr) =
1344             vtophys(&sc->ti_rdata->ti_rx_jumbo_ring);
1345         rcb->ti_max_len = TI_JUMBO_FRAMELEN;
1346         rcb->ti_flags = 0;
1347         if (sc->arpcom.ac_if.if_hwassist)
1348                 rcb->ti_flags |= TI_RCB_FLAG_TCP_UDP_CKSUM |
1349                      TI_RCB_FLAG_IP_CKSUM | TI_RCB_FLAG_NO_PHDR_CKSUM;
1350 #if NVLAN > 0
1351         rcb->ti_flags |= TI_RCB_FLAG_VLAN_ASSIST;
1352 #endif
1353
1354         /*
1355          * Set up the mini ring. Only activated on the
1356          * Tigon 2 but the slot in the config block is
1357          * still there on the Tigon 1.
1358          */
1359         rcb = &sc->ti_rdata->ti_info.ti_mini_rx_rcb;
1360         TI_HOSTADDR(rcb->ti_hostaddr) =
1361             vtophys(&sc->ti_rdata->ti_rx_mini_ring);
1362         rcb->ti_max_len = MHLEN - ETHER_ALIGN;
1363         if (sc->ti_hwrev == TI_HWREV_TIGON)
1364                 rcb->ti_flags = TI_RCB_FLAG_RING_DISABLED;
1365         else
1366                 rcb->ti_flags = 0;
1367         if (sc->arpcom.ac_if.if_hwassist)
1368                 rcb->ti_flags |= TI_RCB_FLAG_TCP_UDP_CKSUM |
1369                      TI_RCB_FLAG_IP_CKSUM | TI_RCB_FLAG_NO_PHDR_CKSUM;
1370 #if NVLAN > 0
1371         rcb->ti_flags |= TI_RCB_FLAG_VLAN_ASSIST;
1372 #endif
1373
1374         /*
1375          * Set up the receive return ring.
1376          */
1377         rcb = &sc->ti_rdata->ti_info.ti_return_rcb;
1378         TI_HOSTADDR(rcb->ti_hostaddr) =
1379             vtophys(&sc->ti_rdata->ti_rx_return_ring);
1380         rcb->ti_flags = 0;
1381         rcb->ti_max_len = TI_RETURN_RING_CNT;
1382         TI_HOSTADDR(sc->ti_rdata->ti_info.ti_return_prodidx_ptr) =
1383             vtophys(&sc->ti_return_prodidx);
1384
1385         /*
1386          * Set up the tx ring. Note: for the Tigon 2, we have the option
1387          * of putting the transmit ring in the host's address space and
1388          * letting the chip DMA it instead of leaving the ring in the NIC's
1389          * memory and accessing it through the shared memory region. We
1390          * do this for the Tigon 2, but it doesn't work on the Tigon 1,
1391          * so we have to revert to the shared memory scheme if we detect
1392          * a Tigon 1 chip.
1393          */
1394         CSR_WRITE_4(sc, TI_WINBASE, TI_TX_RING_BASE);
1395         if (sc->ti_hwrev == TI_HWREV_TIGON) {
1396                 sc->ti_rdata->ti_tx_ring_nic =
1397                     (struct ti_tx_desc *)(sc->ti_vhandle + TI_WINDOW);
1398         }
1399         bzero((char *)sc->ti_rdata->ti_tx_ring,
1400             TI_TX_RING_CNT * sizeof(struct ti_tx_desc));
1401         rcb = &sc->ti_rdata->ti_info.ti_tx_rcb;
1402         if (sc->ti_hwrev == TI_HWREV_TIGON)
1403                 rcb->ti_flags = 0;
1404         else
1405                 rcb->ti_flags = TI_RCB_FLAG_HOST_RING;
1406 #if NVLAN > 0
1407         rcb->ti_flags |= TI_RCB_FLAG_VLAN_ASSIST;
1408 #endif
1409         if (sc->arpcom.ac_if.if_hwassist)
1410                 rcb->ti_flags |= TI_RCB_FLAG_TCP_UDP_CKSUM |
1411                      TI_RCB_FLAG_IP_CKSUM | TI_RCB_FLAG_NO_PHDR_CKSUM;
1412         rcb->ti_max_len = TI_TX_RING_CNT;
1413         if (sc->ti_hwrev == TI_HWREV_TIGON)
1414                 TI_HOSTADDR(rcb->ti_hostaddr) = TI_TX_RING_BASE;
1415         else
1416                 TI_HOSTADDR(rcb->ti_hostaddr) =
1417                     vtophys(&sc->ti_rdata->ti_tx_ring);
1418         TI_HOSTADDR(sc->ti_rdata->ti_info.ti_tx_considx_ptr) =
1419             vtophys(&sc->ti_tx_considx);
1420
1421         /* Set up tuneables */
1422         if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
1423                 CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS,
1424                     (sc->ti_rx_coal_ticks / 10));
1425         else
1426                 CSR_WRITE_4(sc, TI_GCR_RX_COAL_TICKS, sc->ti_rx_coal_ticks);
1427         CSR_WRITE_4(sc, TI_GCR_TX_COAL_TICKS, sc->ti_tx_coal_ticks);
1428         CSR_WRITE_4(sc, TI_GCR_STAT_TICKS, sc->ti_stat_ticks);
1429         CSR_WRITE_4(sc, TI_GCR_RX_MAX_COAL_BD, sc->ti_rx_max_coal_bds);
1430         CSR_WRITE_4(sc, TI_GCR_TX_MAX_COAL_BD, sc->ti_tx_max_coal_bds);
1431         CSR_WRITE_4(sc, TI_GCR_TX_BUFFER_RATIO, sc->ti_tx_buf_ratio);
1432
1433         /* Turn interrupts on. */
1434         CSR_WRITE_4(sc, TI_GCR_MASK_INTRS, 0);
1435         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 0);
1436
1437         /* Start CPU. */
1438         TI_CLRBIT(sc, TI_CPU_STATE, (TI_CPUSTATE_HALT|TI_CPUSTATE_STEP));
1439
1440         return(0);
1441 }
1442
1443 /*
1444  * Probe for a Tigon chip. Check the PCI vendor and device IDs
1445  * against our list and return its name if we find a match.
1446  */
1447 static int ti_probe(dev)
1448         device_t                dev;
1449 {
1450         struct ti_type          *t;
1451
1452         t = ti_devs;
1453
1454         while(t->ti_name != NULL) {
1455                 if ((pci_get_vendor(dev) == t->ti_vid) &&
1456                     (pci_get_device(dev) == t->ti_did)) {
1457                         device_set_desc(dev, t->ti_name);
1458                         return(0);
1459                 }
1460                 t++;
1461         }
1462
1463         return(ENXIO);
1464 }
1465
1466 static int ti_attach(dev)
1467         device_t                dev;
1468 {
1469         u_int32_t               command;
1470         struct ifnet            *ifp;
1471         struct ti_softc         *sc;
1472         int                     unit, error = 0, rid;
1473
1474         sc = device_get_softc(dev);
1475         unit = device_get_unit(dev);
1476         bzero(sc, sizeof(struct ti_softc));
1477
1478         mtx_init(&sc->ti_mtx, device_get_nameunit(dev), MTX_DEF | MTX_RECURSE);
1479         TI_LOCK(sc);
1480
1481         /*
1482          * Map control/status registers.
1483          */
1484         pci_enable_busmaster(dev);
1485         pci_enable_io(dev, SYS_RES_MEMORY);
1486         command = pci_read_config(dev, PCIR_COMMAND, 4);
1487
1488         if (!(command & PCIM_CMD_MEMEN)) {
1489                 printf("ti%d: failed to enable memory mapping!\n", unit);
1490                 error = ENXIO;
1491                 goto fail;
1492         }
1493
1494         rid = TI_PCI_LOMEM;
1495         sc->ti_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
1496             0, ~0, 1, RF_ACTIVE|PCI_RF_DENSE);
1497
1498         if (sc->ti_res == NULL) {
1499                 printf ("ti%d: couldn't map memory\n", unit);
1500                 error = ENXIO;
1501                 goto fail;
1502         }
1503
1504         sc->ti_btag = rman_get_bustag(sc->ti_res);
1505         sc->ti_bhandle = rman_get_bushandle(sc->ti_res);
1506         sc->ti_vhandle = (vm_offset_t)rman_get_virtual(sc->ti_res);
1507
1508         /* Allocate interrupt */
1509         rid = 0;
1510
1511         sc->ti_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
1512             RF_SHAREABLE | RF_ACTIVE);
1513
1514         if (sc->ti_irq == NULL) {
1515                 printf("ti%d: couldn't map interrupt\n", unit);
1516                 error = ENXIO;
1517                 goto fail;
1518         }
1519
1520         error = bus_setup_intr(dev, sc->ti_irq, INTR_TYPE_NET,
1521            ti_intr, sc, &sc->ti_intrhand);
1522
1523         if (error) {
1524                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1525                 bus_release_resource(dev, SYS_RES_MEMORY,
1526                     TI_PCI_LOMEM, sc->ti_res);
1527                 printf("ti%d: couldn't set up irq\n", unit);
1528                 goto fail;
1529         }
1530
1531         sc->ti_unit = unit;
1532
1533         if (ti_chipinit(sc)) {
1534                 printf("ti%d: chip initialization failed\n", sc->ti_unit);
1535                 bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1536                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1537                 bus_release_resource(dev, SYS_RES_MEMORY,
1538                     TI_PCI_LOMEM, sc->ti_res);
1539                 error = ENXIO;
1540                 goto fail;
1541         }
1542
1543         /* Zero out the NIC's on-board SRAM. */
1544         ti_mem(sc, 0x2000, 0x100000 - 0x2000,  NULL);
1545
1546         /* Init again -- zeroing memory may have clobbered some registers. */
1547         if (ti_chipinit(sc)) {
1548                 printf("ti%d: chip initialization failed\n", sc->ti_unit);
1549                 bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1550                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1551                 bus_release_resource(dev, SYS_RES_MEMORY,
1552                     TI_PCI_LOMEM, sc->ti_res);
1553                 error = ENXIO;
1554                 goto fail;
1555         }
1556
1557         /*
1558          * Get station address from the EEPROM. Note: the manual states
1559          * that the MAC address is at offset 0x8c, however the data is
1560          * stored as two longwords (since that's how it's loaded into
1561          * the NIC). This means the MAC address is actually preceded
1562          * by two zero bytes. We need to skip over those.
1563          */
1564         if (ti_read_eeprom(sc, (caddr_t)&sc->arpcom.ac_enaddr,
1565                                 TI_EE_MAC_OFFSET + 2, ETHER_ADDR_LEN)) {
1566                 printf("ti%d: failed to read station address\n", unit);
1567                 bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1568                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1569                 bus_release_resource(dev, SYS_RES_MEMORY,
1570                     TI_PCI_LOMEM, sc->ti_res);
1571                 error = ENXIO;
1572                 goto fail;
1573         }
1574
1575         /*
1576          * A Tigon chip was detected. Inform the world.
1577          */
1578         printf("ti%d: Ethernet address: %6D\n", unit,
1579                                 sc->arpcom.ac_enaddr, ":");
1580
1581         /* Allocate the general information block and ring buffers. */
1582         sc->ti_rdata = contigmalloc(sizeof(struct ti_ring_data), M_DEVBUF,
1583             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
1584
1585         if (sc->ti_rdata == NULL) {
1586                 bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1587                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1588                 bus_release_resource(dev, SYS_RES_MEMORY,
1589                     TI_PCI_LOMEM, sc->ti_res);
1590                 error = ENXIO;
1591                 printf("ti%d: no memory for list buffers!\n", sc->ti_unit);
1592                 goto fail;
1593         }
1594
1595         bzero(sc->ti_rdata, sizeof(struct ti_ring_data));
1596
1597         /* Try to allocate memory for jumbo buffers. */
1598         if (ti_alloc_jumbo_mem(sc)) {
1599                 printf("ti%d: jumbo buffer allocation failed\n", sc->ti_unit);
1600                 bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1601                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1602                 bus_release_resource(dev, SYS_RES_MEMORY,
1603                     TI_PCI_LOMEM, sc->ti_res);
1604                 contigfree(sc->ti_rdata, sizeof(struct ti_ring_data),
1605                     M_DEVBUF);
1606                 error = ENXIO;
1607                 goto fail;
1608         }
1609
1610         /*
1611          * We really need a better way to tell a 1000baseTX card
1612          * from a 1000baseSX one, since in theory there could be
1613          * OEMed 1000baseTX cards from lame vendors who aren't
1614          * clever enough to change the PCI ID. For the moment
1615          * though, the AceNIC is the only copper card available.
1616          */
1617         if (pci_get_vendor(dev) == ALT_VENDORID &&
1618             pci_get_device(dev) == ALT_DEVICEID_ACENIC_COPPER)
1619                 sc->ti_copper = 1;
1620         /* Ok, it's not the only copper card available. */
1621         if (pci_get_vendor(dev) == NG_VENDORID &&
1622             pci_get_device(dev) == NG_DEVICEID_GA620T)
1623                 sc->ti_copper = 1;
1624
1625         /* Set default tuneable values. */
1626         sc->ti_stat_ticks = 2 * TI_TICKS_PER_SEC;
1627         sc->ti_rx_coal_ticks = TI_TICKS_PER_SEC / 5000;
1628         sc->ti_tx_coal_ticks = TI_TICKS_PER_SEC / 500;
1629         sc->ti_rx_max_coal_bds = 64;
1630         sc->ti_tx_max_coal_bds = 128;
1631         sc->ti_tx_buf_ratio = 21;
1632
1633         /* Set up ifnet structure */
1634         ifp = &sc->arpcom.ac_if;
1635         ifp->if_softc = sc;
1636         ifp->if_unit = sc->ti_unit;
1637         ifp->if_name = "ti";
1638         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1639         ifp->if_ioctl = ti_ioctl;
1640         ifp->if_output = ether_output;
1641         ifp->if_start = ti_start;
1642         ifp->if_watchdog = ti_watchdog;
1643         ifp->if_init = ti_init;
1644         ifp->if_mtu = ETHERMTU;
1645         ifp->if_snd.ifq_maxlen = TI_TX_RING_CNT - 1;
1646
1647         /* Set up ifmedia support. */
1648         ifmedia_init(&sc->ifmedia, IFM_IMASK, ti_ifmedia_upd, ti_ifmedia_sts);
1649         if (sc->ti_copper) {
1650                 /*
1651                  * Copper cards allow manual 10/100 mode selection,
1652                  * but not manual 1000baseTX mode selection. Why?
1653                  * Becuase currently there's no way to specify the
1654                  * master/slave setting through the firmware interface,
1655                  * so Alteon decided to just bag it and handle it
1656                  * via autonegotiation.
1657                  */
1658                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
1659                 ifmedia_add(&sc->ifmedia,
1660                     IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
1661                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL);
1662                 ifmedia_add(&sc->ifmedia,
1663                     IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL);
1664                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_1000_TX, 0, NULL);
1665                 ifmedia_add(&sc->ifmedia,
1666                     IFM_ETHER|IFM_1000_TX|IFM_FDX, 0, NULL);
1667         } else {
1668                 /* Fiber cards don't support 10/100 modes. */
1669                 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_1000_SX, 0, NULL);
1670                 ifmedia_add(&sc->ifmedia,
1671                     IFM_ETHER|IFM_1000_SX|IFM_FDX, 0, NULL);
1672         }
1673         ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL);
1674         ifmedia_set(&sc->ifmedia, IFM_ETHER|IFM_AUTO);
1675
1676         /*
1677          * Call MI attach routine.
1678          */
1679         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1680         TI_UNLOCK(sc);
1681         return(0);
1682
1683 fail:
1684         TI_UNLOCK(sc);
1685         mtx_destroy(&sc->ti_mtx);
1686         return(error);
1687 }
1688
1689 static int ti_detach(dev)
1690         device_t                dev;
1691 {
1692         struct ti_softc         *sc;
1693         struct ifnet            *ifp;
1694
1695
1696         sc = device_get_softc(dev);
1697         TI_LOCK(sc);
1698         ifp = &sc->arpcom.ac_if;
1699
1700         ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
1701         ti_stop(sc);
1702
1703         bus_teardown_intr(dev, sc->ti_irq, sc->ti_intrhand);
1704         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ti_irq);
1705         bus_release_resource(dev, SYS_RES_MEMORY, TI_PCI_LOMEM, sc->ti_res);
1706
1707         contigfree(sc->ti_cdata.ti_jumbo_buf, TI_JMEM, M_DEVBUF);
1708         contigfree(sc->ti_rdata, sizeof(struct ti_ring_data), M_DEVBUF);
1709         ifmedia_removeall(&sc->ifmedia);
1710
1711         TI_UNLOCK(sc);
1712         mtx_destroy(&sc->ti_mtx);
1713
1714         return(0);
1715 }
1716
1717 /*
1718  * Frame reception handling. This is called if there's a frame
1719  * on the receive return list.
1720  *
1721  * Note: we have to be able to handle three possibilities here:
1722  * 1) the frame is from the mini receive ring (can only happen)
1723  *    on Tigon 2 boards)
1724  * 2) the frame is from the jumbo recieve ring
1725  * 3) the frame is from the standard receive ring
1726  */
1727
1728 static void ti_rxeof(sc)
1729         struct ti_softc         *sc;
1730 {
1731         struct ifnet            *ifp;
1732         struct ti_cmd_desc      cmd;
1733
1734         ifp = &sc->arpcom.ac_if;
1735
1736         while(sc->ti_rx_saved_considx != sc->ti_return_prodidx.ti_idx) {
1737                 struct ti_rx_desc       *cur_rx;
1738                 u_int32_t               rxidx;
1739                 struct ether_header     *eh;
1740                 struct mbuf             *m = NULL;
1741 #if NVLAN > 0
1742                 u_int16_t               vlan_tag = 0;
1743                 int                     have_tag = 0;
1744 #endif
1745
1746                 cur_rx =
1747                     &sc->ti_rdata->ti_rx_return_ring[sc->ti_rx_saved_considx];
1748                 rxidx = cur_rx->ti_idx;
1749                 TI_INC(sc->ti_rx_saved_considx, TI_RETURN_RING_CNT);
1750
1751 #if NVLAN > 0
1752                 if (cur_rx->ti_flags & TI_BDFLAG_VLAN_TAG) {
1753                         have_tag = 1;
1754                         vlan_tag = cur_rx->ti_vlan_tag & 0xfff;
1755                 }
1756 #endif
1757
1758                 if (cur_rx->ti_flags & TI_BDFLAG_JUMBO_RING) {
1759                         TI_INC(sc->ti_jumbo, TI_JUMBO_RX_RING_CNT);
1760                         m = sc->ti_cdata.ti_rx_jumbo_chain[rxidx];
1761                         sc->ti_cdata.ti_rx_jumbo_chain[rxidx] = NULL;
1762                         if (cur_rx->ti_flags & TI_BDFLAG_ERROR) {
1763                                 ifp->if_ierrors++;
1764                                 ti_newbuf_jumbo(sc, sc->ti_jumbo, m);
1765                                 continue;
1766                         }
1767                         if (ti_newbuf_jumbo(sc, sc->ti_jumbo, NULL) == ENOBUFS) {
1768                                 ifp->if_ierrors++;
1769                                 ti_newbuf_jumbo(sc, sc->ti_jumbo, m);
1770                                 continue;
1771                         }
1772                 } else if (cur_rx->ti_flags & TI_BDFLAG_MINI_RING) {
1773                         TI_INC(sc->ti_mini, TI_MINI_RX_RING_CNT);
1774                         m = sc->ti_cdata.ti_rx_mini_chain[rxidx];
1775                         sc->ti_cdata.ti_rx_mini_chain[rxidx] = NULL;
1776                         if (cur_rx->ti_flags & TI_BDFLAG_ERROR) {
1777                                 ifp->if_ierrors++;
1778                                 ti_newbuf_mini(sc, sc->ti_mini, m);
1779                                 continue;
1780                         }
1781                         if (ti_newbuf_mini(sc, sc->ti_mini, NULL) == ENOBUFS) {
1782                                 ifp->if_ierrors++;
1783                                 ti_newbuf_mini(sc, sc->ti_mini, m);
1784                                 continue;
1785                         }
1786                 } else {
1787                         TI_INC(sc->ti_std, TI_STD_RX_RING_CNT);
1788                         m = sc->ti_cdata.ti_rx_std_chain[rxidx];
1789                         sc->ti_cdata.ti_rx_std_chain[rxidx] = NULL;
1790                         if (cur_rx->ti_flags & TI_BDFLAG_ERROR) {
1791                                 ifp->if_ierrors++;
1792                                 ti_newbuf_std(sc, sc->ti_std, m);
1793                                 continue;
1794                         }
1795                         if (ti_newbuf_std(sc, sc->ti_std, NULL) == ENOBUFS) {
1796                                 ifp->if_ierrors++;
1797                                 ti_newbuf_std(sc, sc->ti_std, m);
1798                                 continue;
1799                         }
1800                 }
1801
1802                 m->m_pkthdr.len = m->m_len = cur_rx->ti_len;
1803                 ifp->if_ipackets++;
1804                 eh = mtod(m, struct ether_header *);
1805                 m->m_pkthdr.rcvif = ifp;
1806
1807                 /* Remove header from mbuf and pass it on. */
1808                 m_adj(m, sizeof(struct ether_header));
1809
1810                 if (ifp->if_hwassist) {
1811                         m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED |
1812                             CSUM_DATA_VALID;
1813                         if ((cur_rx->ti_ip_cksum ^ 0xffff) == 0)
1814                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
1815                         m->m_pkthdr.csum_data = cur_rx->ti_tcp_udp_cksum;
1816                 }
1817
1818 #if NVLAN > 0
1819                 /*
1820                  * If we received a packet with a vlan tag, pass it
1821                  * to vlan_input() instead of ether_input().
1822                  */
1823                 if (have_tag) {
1824                         vlan_input_tag(eh, m, vlan_tag);
1825                         have_tag = vlan_tag = 0;
1826                         continue;
1827                 }
1828 #endif
1829                 ether_input(ifp, eh, m);
1830         }
1831
1832         /* Only necessary on the Tigon 1. */
1833         if (sc->ti_hwrev == TI_HWREV_TIGON)
1834                 CSR_WRITE_4(sc, TI_GCR_RXRETURNCONS_IDX,
1835                     sc->ti_rx_saved_considx);
1836
1837         TI_UPDATE_STDPROD(sc, sc->ti_std);
1838         TI_UPDATE_MINIPROD(sc, sc->ti_mini);
1839         TI_UPDATE_JUMBOPROD(sc, sc->ti_jumbo);
1840
1841         return;
1842 }
1843
1844 static void ti_txeof(sc)
1845         struct ti_softc         *sc;
1846 {
1847         struct ti_tx_desc       *cur_tx = NULL;
1848         struct ifnet            *ifp;
1849
1850         ifp = &sc->arpcom.ac_if;
1851
1852         /*
1853          * Go through our tx ring and free mbufs for those
1854          * frames that have been sent.
1855          */
1856         while (sc->ti_tx_saved_considx != sc->ti_tx_considx.ti_idx) {
1857                 u_int32_t               idx = 0;
1858
1859                 idx = sc->ti_tx_saved_considx;
1860                 if (sc->ti_hwrev == TI_HWREV_TIGON) {
1861                         if (idx > 383)
1862                                 CSR_WRITE_4(sc, TI_WINBASE,
1863                                     TI_TX_RING_BASE + 6144);
1864                         else if (idx > 255)
1865                                 CSR_WRITE_4(sc, TI_WINBASE,
1866                                     TI_TX_RING_BASE + 4096);
1867                         else if (idx > 127)
1868                                 CSR_WRITE_4(sc, TI_WINBASE,
1869                                     TI_TX_RING_BASE + 2048);
1870                         else
1871                                 CSR_WRITE_4(sc, TI_WINBASE,
1872                                     TI_TX_RING_BASE);
1873                         cur_tx = &sc->ti_rdata->ti_tx_ring_nic[idx % 128];
1874                 } else
1875                         cur_tx = &sc->ti_rdata->ti_tx_ring[idx];
1876                 if (cur_tx->ti_flags & TI_BDFLAG_END)
1877                         ifp->if_opackets++;
1878                 if (sc->ti_cdata.ti_tx_chain[idx] != NULL) {
1879                         m_freem(sc->ti_cdata.ti_tx_chain[idx]);
1880                         sc->ti_cdata.ti_tx_chain[idx] = NULL;
1881                 }
1882                 sc->ti_txcnt--;
1883                 TI_INC(sc->ti_tx_saved_considx, TI_TX_RING_CNT);
1884                 ifp->if_timer = 0;
1885         }
1886
1887         if (cur_tx != NULL)
1888                 ifp->if_flags &= ~IFF_OACTIVE;
1889
1890         return;
1891 }
1892
1893 static void ti_intr(xsc)
1894         void                    *xsc;
1895 {
1896         struct ti_softc         *sc;
1897         struct ifnet            *ifp;
1898
1899         sc = xsc;
1900         TI_LOCK(sc);
1901         ifp = &sc->arpcom.ac_if;
1902
1903 #ifdef notdef
1904         /* Avoid this for now -- checking this register is expensive. */
1905         /* Make sure this is really our interrupt. */
1906         if (!(CSR_READ_4(sc, TI_MISC_HOST_CTL) & TI_MHC_INTSTATE)) {
1907                 TI_UNLOCK(sc);
1908                 return;
1909         }
1910 #endif
1911
1912         /* Ack interrupt and stop others from occuring. */
1913         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1);
1914
1915         if (ifp->if_flags & IFF_RUNNING) {
1916                 /* Check RX return ring producer/consumer */
1917                 ti_rxeof(sc);
1918
1919                 /* Check TX ring producer/consumer */
1920                 ti_txeof(sc);
1921         }
1922
1923         ti_handle_events(sc);
1924
1925         /* Re-enable interrupts. */
1926         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 0);
1927
1928         if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL)
1929                 ti_start(ifp);
1930
1931         TI_UNLOCK(sc);
1932
1933         return;
1934 }
1935
1936 static void ti_stats_update(sc)
1937         struct ti_softc         *sc;
1938 {
1939         struct ifnet            *ifp;
1940
1941         ifp = &sc->arpcom.ac_if;
1942
1943         ifp->if_collisions +=
1944            (sc->ti_rdata->ti_info.ti_stats.dot3StatsSingleCollisionFrames +
1945            sc->ti_rdata->ti_info.ti_stats.dot3StatsMultipleCollisionFrames +
1946            sc->ti_rdata->ti_info.ti_stats.dot3StatsExcessiveCollisions +
1947            sc->ti_rdata->ti_info.ti_stats.dot3StatsLateCollisions) -
1948            ifp->if_collisions;
1949
1950         return;
1951 }
1952
1953 /*
1954  * Encapsulate an mbuf chain in the tx ring  by coupling the mbuf data
1955  * pointers to descriptors.
1956  */
1957 static int ti_encap(sc, m_head, txidx)
1958         struct ti_softc         *sc;
1959         struct mbuf             *m_head;
1960         u_int32_t               *txidx;
1961 {
1962         struct ti_tx_desc       *f = NULL;
1963         struct mbuf             *m;
1964         u_int32_t               frag, cur, cnt = 0;
1965         u_int16_t               csum_flags = 0;
1966 #if NVLAN > 0
1967         struct ifvlan           *ifv = NULL;
1968
1969         if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) &&
1970             m_head->m_pkthdr.rcvif != NULL &&
1971             m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
1972                 ifv = m_head->m_pkthdr.rcvif->if_softc;
1973 #endif
1974
1975         m = m_head;
1976         cur = frag = *txidx;
1977
1978         if (m_head->m_pkthdr.csum_flags) {
1979                 if (m_head->m_pkthdr.csum_flags & CSUM_IP)
1980                         csum_flags |= TI_BDFLAG_IP_CKSUM;
1981                 if (m_head->m_pkthdr.csum_flags & (CSUM_TCP | CSUM_UDP))
1982                         csum_flags |= TI_BDFLAG_TCP_UDP_CKSUM;
1983                 if (m_head->m_flags & M_LASTFRAG)
1984                         csum_flags |= TI_BDFLAG_IP_FRAG_END;
1985                 else if (m_head->m_flags & M_FRAG)
1986                         csum_flags |= TI_BDFLAG_IP_FRAG;
1987         }
1988         /*
1989          * Start packing the mbufs in this chain into
1990          * the fragment pointers. Stop when we run out
1991          * of fragments or hit the end of the mbuf chain.
1992          */
1993         for (m = m_head; m != NULL; m = m->m_next) {
1994                 if (m->m_len != 0) {
1995                         if (sc->ti_hwrev == TI_HWREV_TIGON) {
1996                                 if (frag > 383)
1997                                         CSR_WRITE_4(sc, TI_WINBASE,
1998                                             TI_TX_RING_BASE + 6144);
1999                                 else if (frag > 255)
2000                                         CSR_WRITE_4(sc, TI_WINBASE,
2001                                             TI_TX_RING_BASE + 4096);
2002                                 else if (frag > 127)
2003                                         CSR_WRITE_4(sc, TI_WINBASE,
2004                                             TI_TX_RING_BASE + 2048);
2005                                 else
2006                                         CSR_WRITE_4(sc, TI_WINBASE,
2007                                             TI_TX_RING_BASE);
2008                                 f = &sc->ti_rdata->ti_tx_ring_nic[frag % 128];
2009                         } else
2010                                 f = &sc->ti_rdata->ti_tx_ring[frag];
2011                         if (sc->ti_cdata.ti_tx_chain[frag] != NULL)
2012                                 break;
2013                         TI_HOSTADDR(f->ti_addr) = vtophys(mtod(m, vm_offset_t));
2014                         f->ti_len = m->m_len;
2015                         f->ti_flags = csum_flags;
2016 #if NVLAN > 0
2017                         if (ifv != NULL) {
2018                                 f->ti_flags |= TI_BDFLAG_VLAN_TAG;
2019                                 f->ti_vlan_tag = ifv->ifv_tag & 0xfff;
2020                         } else {
2021                                 f->ti_vlan_tag = 0;
2022                         }
2023 #endif
2024                         /*
2025                          * Sanity check: avoid coming within 16 descriptors
2026                          * of the end of the ring.
2027                          */
2028                         if ((TI_TX_RING_CNT - (sc->ti_txcnt + cnt)) < 16)
2029                                 return(ENOBUFS);
2030                         cur = frag;
2031                         TI_INC(frag, TI_TX_RING_CNT);
2032                         cnt++;
2033                 }
2034         }
2035
2036         if (m != NULL)
2037                 return(ENOBUFS);
2038
2039         if (frag == sc->ti_tx_saved_considx)
2040                 return(ENOBUFS);
2041
2042         if (sc->ti_hwrev == TI_HWREV_TIGON)
2043                 sc->ti_rdata->ti_tx_ring_nic[cur % 128].ti_flags |=
2044                     TI_BDFLAG_END;
2045         else
2046                 sc->ti_rdata->ti_tx_ring[cur].ti_flags |= TI_BDFLAG_END;
2047         sc->ti_cdata.ti_tx_chain[cur] = m_head;
2048         sc->ti_txcnt += cnt;
2049
2050         *txidx = frag;
2051
2052         return(0);
2053 }
2054
2055 /*
2056  * Main transmit routine. To avoid having to do mbuf copies, we put pointers
2057  * to the mbuf data regions directly in the transmit descriptors.
2058  */
2059 static void ti_start(ifp)
2060         struct ifnet            *ifp;
2061 {
2062         struct ti_softc         *sc;
2063         struct mbuf             *m_head = NULL;
2064         u_int32_t               prodidx = 0;
2065
2066         sc = ifp->if_softc;
2067         TI_LOCK(sc);
2068
2069         prodidx = CSR_READ_4(sc, TI_MB_SENDPROD_IDX);
2070
2071         while(sc->ti_cdata.ti_tx_chain[prodidx] == NULL) {
2072                 IF_DEQUEUE(&ifp->if_snd, m_head);
2073                 if (m_head == NULL)
2074                         break;
2075
2076                 /*
2077                  * XXX
2078                  * safety overkill.  If this is a fragmented packet chain
2079                  * with delayed TCP/UDP checksums, then only encapsulate
2080                  * it if we have enough descriptors to handle the entire
2081                  * chain at once.
2082                  * (paranoia -- may not actually be needed)
2083                  */
2084                 if (m_head->m_flags & M_FIRSTFRAG &&
2085                     m_head->m_pkthdr.csum_flags & (CSUM_DELAY_DATA)) {
2086                         if ((TI_TX_RING_CNT - sc->ti_txcnt) <
2087                             m_head->m_pkthdr.csum_data + 16) {
2088                                 IF_PREPEND(&ifp->if_snd, m_head);
2089                                 ifp->if_flags |= IFF_OACTIVE;
2090                                 break;
2091                         }
2092                 }
2093
2094                 /*
2095                  * Pack the data into the transmit ring. If we
2096                  * don't have room, set the OACTIVE flag and wait
2097                  * for the NIC to drain the ring.
2098                  */
2099                 if (ti_encap(sc, m_head, &prodidx)) {
2100                         IF_PREPEND(&ifp->if_snd, m_head);
2101                         ifp->if_flags |= IFF_OACTIVE;
2102                         break;
2103                 }
2104
2105                 /*
2106                  * If there's a BPF listener, bounce a copy of this frame
2107                  * to him.
2108                  */
2109                 if (ifp->if_bpf)
2110                         bpf_mtap(ifp, m_head);
2111         }
2112
2113         /* Transmit */
2114         CSR_WRITE_4(sc, TI_MB_SENDPROD_IDX, prodidx);
2115
2116         /*
2117          * Set a timeout in case the chip goes out to lunch.
2118          */
2119         ifp->if_timer = 5;
2120         TI_UNLOCK(sc);
2121
2122         return;
2123 }
2124
2125 static void ti_init(xsc)
2126         void                    *xsc;
2127 {
2128         struct ti_softc         *sc = xsc;
2129
2130         /* Cancel pending I/O and flush buffers. */
2131         ti_stop(sc);
2132
2133         TI_LOCK(sc);
2134         /* Init the gen info block, ring control blocks and firmware. */
2135         if (ti_gibinit(sc)) {
2136                 printf("ti%d: initialization failure\n", sc->ti_unit);
2137                 TI_UNLOCK(sc);
2138                 return;
2139         }
2140
2141         TI_UNLOCK(sc);
2142
2143         return;
2144 }
2145
2146 static void ti_init2(sc)
2147         struct ti_softc         *sc;
2148 {
2149         struct ti_cmd_desc      cmd;
2150         struct ifnet            *ifp;
2151         u_int16_t               *m;
2152         struct ifmedia          *ifm;
2153         int                     tmp;
2154
2155         ifp = &sc->arpcom.ac_if;
2156
2157         /* Specify MTU and interface index. */
2158         CSR_WRITE_4(sc, TI_GCR_IFINDEX, ifp->if_unit);
2159         CSR_WRITE_4(sc, TI_GCR_IFMTU, ifp->if_mtu +
2160             ETHER_HDR_LEN + ETHER_CRC_LEN);
2161         TI_DO_CMD(TI_CMD_UPDATE_GENCOM, 0, 0);
2162
2163         /* Load our MAC address. */
2164         m = (u_int16_t *)&sc->arpcom.ac_enaddr[0];
2165         CSR_WRITE_4(sc, TI_GCR_PAR0, htons(m[0]));
2166         CSR_WRITE_4(sc, TI_GCR_PAR1, (htons(m[1]) << 16) | htons(m[2]));
2167         TI_DO_CMD(TI_CMD_SET_MAC_ADDR, 0, 0);
2168
2169         /* Enable or disable promiscuous mode as needed. */
2170         if (ifp->if_flags & IFF_PROMISC) {
2171                 TI_DO_CMD(TI_CMD_SET_PROMISC_MODE, TI_CMD_CODE_PROMISC_ENB, 0);
2172         } else {
2173                 TI_DO_CMD(TI_CMD_SET_PROMISC_MODE, TI_CMD_CODE_PROMISC_DIS, 0);
2174         }
2175
2176         /* Program multicast filter. */
2177         ti_setmulti(sc);
2178
2179         /*
2180          * If this is a Tigon 1, we should tell the
2181          * firmware to use software packet filtering.
2182          */
2183         if (sc->ti_hwrev == TI_HWREV_TIGON) {
2184                 TI_DO_CMD(TI_CMD_FDR_FILTERING, TI_CMD_CODE_FILT_ENB, 0);
2185         }
2186
2187         /* Init RX ring. */
2188         ti_init_rx_ring_std(sc);
2189
2190         /* Init jumbo RX ring. */
2191         if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
2192                 ti_init_rx_ring_jumbo(sc);
2193
2194         /*
2195          * If this is a Tigon 2, we can also configure the
2196          * mini ring.
2197          */
2198         if (sc->ti_hwrev == TI_HWREV_TIGON_II)
2199                 ti_init_rx_ring_mini(sc);
2200
2201         CSR_WRITE_4(sc, TI_GCR_RXRETURNCONS_IDX, 0);
2202         sc->ti_rx_saved_considx = 0;
2203
2204         /* Init TX ring. */
2205         ti_init_tx_ring(sc);
2206
2207         /* Tell firmware we're alive. */
2208         TI_DO_CMD(TI_CMD_HOST_STATE, TI_CMD_CODE_STACK_UP, 0);
2209
2210         /* Enable host interrupts. */
2211         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 0);
2212
2213         ifp->if_flags |= IFF_RUNNING;
2214         ifp->if_flags &= ~IFF_OACTIVE;
2215
2216         /*
2217          * Make sure to set media properly. We have to do this
2218          * here since we have to issue commands in order to set
2219          * the link negotiation and we can't issue commands until
2220          * the firmware is running.
2221          */
2222         ifm = &sc->ifmedia;
2223         tmp = ifm->ifm_media;
2224         ifm->ifm_media = ifm->ifm_cur->ifm_media;
2225         ti_ifmedia_upd(ifp);
2226         ifm->ifm_media = tmp;
2227
2228         return;
2229 }
2230
2231 /*
2232  * Set media options.
2233  */
2234 static int ti_ifmedia_upd(ifp)
2235         struct ifnet            *ifp;
2236 {
2237         struct ti_softc         *sc;
2238         struct ifmedia          *ifm;
2239         struct ti_cmd_desc      cmd;
2240
2241         sc = ifp->if_softc;
2242         ifm = &sc->ifmedia;
2243
2244         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
2245                 return(EINVAL);
2246
2247         switch(IFM_SUBTYPE(ifm->ifm_media)) {
2248         case IFM_AUTO:
2249                 CSR_WRITE_4(sc, TI_GCR_GLINK, TI_GLNK_PREF|TI_GLNK_1000MB|
2250                     TI_GLNK_FULL_DUPLEX|TI_GLNK_RX_FLOWCTL_Y|
2251                     TI_GLNK_AUTONEGENB|TI_GLNK_ENB);
2252                 CSR_WRITE_4(sc, TI_GCR_LINK, TI_LNK_100MB|TI_LNK_10MB|
2253                     TI_LNK_FULL_DUPLEX|TI_LNK_HALF_DUPLEX|
2254                     TI_LNK_AUTONEGENB|TI_LNK_ENB);
2255                 TI_DO_CMD(TI_CMD_LINK_NEGOTIATION,
2256                     TI_CMD_CODE_NEGOTIATE_BOTH, 0);
2257                 break;
2258         case IFM_1000_SX:
2259         case IFM_1000_TX:
2260                 CSR_WRITE_4(sc, TI_GCR_GLINK, TI_GLNK_PREF|TI_GLNK_1000MB|
2261                     TI_GLNK_RX_FLOWCTL_Y|TI_GLNK_ENB);
2262                 CSR_WRITE_4(sc, TI_GCR_LINK, 0);
2263                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
2264                         TI_SETBIT(sc, TI_GCR_GLINK, TI_GLNK_FULL_DUPLEX);
2265                 }
2266                 TI_DO_CMD(TI_CMD_LINK_NEGOTIATION,
2267                     TI_CMD_CODE_NEGOTIATE_GIGABIT, 0);
2268                 break;
2269         case IFM_100_FX:
2270         case IFM_10_FL:
2271         case IFM_100_TX:
2272         case IFM_10_T:
2273                 CSR_WRITE_4(sc, TI_GCR_GLINK, 0);
2274                 CSR_WRITE_4(sc, TI_GCR_LINK, TI_LNK_ENB|TI_LNK_PREF);
2275                 if (IFM_SUBTYPE(ifm->ifm_media) == IFM_100_FX ||
2276                     IFM_SUBTYPE(ifm->ifm_media) == IFM_100_TX) {
2277                         TI_SETBIT(sc, TI_GCR_LINK, TI_LNK_100MB);
2278                 } else {
2279                         TI_SETBIT(sc, TI_GCR_LINK, TI_LNK_10MB);
2280                 }
2281                 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
2282                         TI_SETBIT(sc, TI_GCR_LINK, TI_LNK_FULL_DUPLEX);
2283                 } else {
2284                         TI_SETBIT(sc, TI_GCR_LINK, TI_LNK_HALF_DUPLEX);
2285                 }
2286                 TI_DO_CMD(TI_CMD_LINK_NEGOTIATION,
2287                     TI_CMD_CODE_NEGOTIATE_10_100, 0);
2288                 break;
2289         }
2290
2291         return(0);
2292 }
2293
2294 /*
2295  * Report current media status.
2296  */
2297 static void ti_ifmedia_sts(ifp, ifmr)
2298         struct ifnet            *ifp;
2299         struct ifmediareq       *ifmr;
2300 {
2301         struct ti_softc         *sc;
2302         u_int32_t               media = 0;
2303
2304         sc = ifp->if_softc;
2305
2306         ifmr->ifm_status = IFM_AVALID;
2307         ifmr->ifm_active = IFM_ETHER;
2308
2309         if (sc->ti_linkstat == TI_EV_CODE_LINK_DOWN)
2310                 return;
2311
2312         ifmr->ifm_status |= IFM_ACTIVE;
2313
2314         if (sc->ti_linkstat == TI_EV_CODE_GIG_LINK_UP) {
2315                 media = CSR_READ_4(sc, TI_GCR_GLINK_STAT);
2316                 if (sc->ti_copper)
2317                         ifmr->ifm_active |= IFM_1000_TX;
2318                 else
2319                         ifmr->ifm_active |= IFM_1000_SX;
2320                 if (media & TI_GLNK_FULL_DUPLEX)
2321                         ifmr->ifm_active |= IFM_FDX;
2322                 else
2323                         ifmr->ifm_active |= IFM_HDX;
2324         } else if (sc->ti_linkstat == TI_EV_CODE_LINK_UP) {
2325                 media = CSR_READ_4(sc, TI_GCR_LINK_STAT);
2326                 if (sc->ti_copper) {
2327                         if (media & TI_LNK_100MB)
2328                                 ifmr->ifm_active |= IFM_100_TX;
2329                         if (media & TI_LNK_10MB)
2330                                 ifmr->ifm_active |= IFM_10_T;
2331                 } else {
2332                         if (media & TI_LNK_100MB)
2333                                 ifmr->ifm_active |= IFM_100_FX;
2334                         if (media & TI_LNK_10MB)
2335                                 ifmr->ifm_active |= IFM_10_FL;
2336                 }
2337                 if (media & TI_LNK_FULL_DUPLEX)
2338                         ifmr->ifm_active |= IFM_FDX;
2339                 if (media & TI_LNK_HALF_DUPLEX)
2340                         ifmr->ifm_active |= IFM_HDX;
2341         }
2342
2343         return;
2344 }
2345
2346 static int ti_ioctl(ifp, command, data)
2347         struct ifnet            *ifp;
2348         u_long                  command;
2349         caddr_t                 data;
2350 {
2351         struct ti_softc         *sc = ifp->if_softc;
2352         struct ifreq            *ifr = (struct ifreq *) data;
2353         int                     error = 0;
2354         struct ti_cmd_desc      cmd;
2355
2356         TI_LOCK(sc);
2357
2358         switch(command) {
2359         case SIOCSIFADDR:
2360         case SIOCGIFADDR:
2361                 error = ether_ioctl(ifp, command, data);
2362                 break;
2363         case SIOCSIFMTU:
2364                 if (ifr->ifr_mtu > TI_JUMBO_MTU)
2365                         error = EINVAL;
2366                 else {
2367                         ifp->if_mtu = ifr->ifr_mtu;
2368                         ti_init(sc);
2369                 }
2370                 break;
2371         case SIOCSIFFLAGS:
2372                 if (ifp->if_flags & IFF_UP) {
2373                         /*
2374                          * If only the state of the PROMISC flag changed,
2375                          * then just use the 'set promisc mode' command
2376                          * instead of reinitializing the entire NIC. Doing
2377                          * a full re-init means reloading the firmware and
2378                          * waiting for it to start up, which may take a
2379                          * second or two.
2380                          */
2381                         if (ifp->if_flags & IFF_RUNNING &&
2382                             ifp->if_flags & IFF_PROMISC &&
2383                             !(sc->ti_if_flags & IFF_PROMISC)) {
2384                                 TI_DO_CMD(TI_CMD_SET_PROMISC_MODE,
2385                                     TI_CMD_CODE_PROMISC_ENB, 0);
2386                         } else if (ifp->if_flags & IFF_RUNNING &&
2387                             !(ifp->if_flags & IFF_PROMISC) &&
2388                             sc->ti_if_flags & IFF_PROMISC) {
2389                                 TI_DO_CMD(TI_CMD_SET_PROMISC_MODE,
2390                                     TI_CMD_CODE_PROMISC_DIS, 0);
2391                         } else
2392                                 ti_init(sc);
2393                 } else {
2394                         if (ifp->if_flags & IFF_RUNNING) {
2395                                 ti_stop(sc);
2396                         }
2397                 }
2398                 sc->ti_if_flags = ifp->if_flags;
2399                 error = 0;
2400                 break;
2401         case SIOCADDMULTI:
2402         case SIOCDELMULTI:
2403                 if (ifp->if_flags & IFF_RUNNING) {
2404                         ti_setmulti(sc);
2405                         error = 0;
2406                 }
2407                 break;
2408         case SIOCSIFMEDIA:
2409         case SIOCGIFMEDIA:
2410                 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
2411                 break;
2412         default:
2413                 error = EINVAL;
2414                 break;
2415         }
2416
2417         TI_UNLOCK(sc);
2418
2419         return(error);
2420 }
2421
2422 static void ti_watchdog(ifp)
2423         struct ifnet            *ifp;
2424 {
2425         struct ti_softc         *sc;
2426
2427         sc = ifp->if_softc;
2428         TI_LOCK(sc);
2429
2430         printf("ti%d: watchdog timeout -- resetting\n", sc->ti_unit);
2431         ti_stop(sc);
2432         ti_init(sc);
2433
2434         ifp->if_oerrors++;
2435         TI_UNLOCK(sc);
2436
2437         return;
2438 }
2439
2440 /*
2441  * Stop the adapter and free any mbufs allocated to the
2442  * RX and TX lists.
2443  */
2444 static void ti_stop(sc)
2445         struct ti_softc         *sc;
2446 {
2447         struct ifnet            *ifp;
2448         struct ti_cmd_desc      cmd;
2449
2450         TI_LOCK(sc);
2451
2452         ifp = &sc->arpcom.ac_if;
2453
2454         /* Disable host interrupts. */
2455         CSR_WRITE_4(sc, TI_MB_HOSTINTR, 1);
2456         /*
2457          * Tell firmware we're shutting down.
2458          */
2459         TI_DO_CMD(TI_CMD_HOST_STATE, TI_CMD_CODE_STACK_DOWN, 0);
2460
2461         /* Halt and reinitialize. */
2462         ti_chipinit(sc);
2463         ti_mem(sc, 0x2000, 0x100000 - 0x2000, NULL);
2464         ti_chipinit(sc);
2465
2466         /* Free the RX lists. */
2467         ti_free_rx_ring_std(sc);
2468
2469         /* Free jumbo RX list. */
2470         ti_free_rx_ring_jumbo(sc);
2471
2472         /* Free mini RX list. */
2473         ti_free_rx_ring_mini(sc);
2474
2475         /* Free TX buffers. */
2476         ti_free_tx_ring(sc);
2477
2478         sc->ti_ev_prodidx.ti_idx = 0;
2479         sc->ti_return_prodidx.ti_idx = 0;
2480         sc->ti_tx_considx.ti_idx = 0;
2481         sc->ti_tx_saved_considx = TI_TXCONS_UNSET;
2482
2483         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2484         TI_UNLOCK(sc);
2485
2486         return;
2487 }
2488
2489 /*
2490  * Stop all chip I/O so that the kernel's probe routines don't
2491  * get confused by errant DMAs when rebooting.
2492  */
2493 static void ti_shutdown(dev)
2494         device_t                dev;
2495 {
2496         struct ti_softc         *sc;
2497
2498         sc = device_get_softc(dev);
2499         TI_LOCK(sc);
2500         ti_chipinit(sc);
2501         TI_UNLOCK(sc);
2502
2503         return;
2504 }