sys/pci/if_sis.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
  33 /*
  34  * SiS 900/SiS 7016 fast ethernet PCI NIC driver. Datasheets are
  35  * available from http://www.sis.com.tw.
  36  *
  37  * This driver also supports the NatSemi DP83815. Datasheets are
  38  * available from http://www.national.com.
  39  *
  40  * Written by Bill Paul <wpaul@ee.columbia.edu>
  41  * Electrical Engineering Department
  42  * Columbia University, New York City
  43  */
  44
  45 /*
  46  * The SiS 900 is a fairly simple chip. It uses bus master DMA with
  47  * simple TX and RX descriptors of 3 longwords in size. The receiver
  48  * has a single perfect filter entry for the station address and a
  49  * 128-bit multicast hash table. The SiS 900 has a built-in MII-based
  50  * transceiver while the 7016 requires an external transceiver chip.
  51  * Both chips offer the standard bit-bang MII interface as well as
  52  * an enchanced PHY interface which simplifies accessing MII registers.
  53  *
  54  * The only downside to this chipset is that RX descriptors must be
  55  * longword aligned.
  56  */
  57
  58 #include <sys/cdefs.h>
  59 __FBSDID("$FreeBSD$");
  60
  61 #include <sys/param.h>
  62 #include <sys/systm.h>
  63 #include <sys/sockio.h>
  64 #include <sys/mbuf.h>
  65 #include <sys/malloc.h>
  66 #include <sys/kernel.h>
  67 #include <sys/socket.h>
  68 #include <sys/sysctl.h>
  69
  70 #include <net/if.h>
  71 #include <net/if_arp.h>
  72 #include <net/ethernet.h>
  73 #include <net/if_dl.h>
  74 #include <net/if_media.h>
  75 #include <net/if_types.h>
  76 #include <net/if_vlan_var.h>
  77
  78 #include <net/bpf.h>
  79
  80 #include <machine/bus_pio.h>
  81 #include <machine/bus_memio.h>
  82 #include <machine/bus.h>
  83 #include <machine/resource.h>
  84 #include <sys/bus.h>
  85 #include <sys/rman.h>
  86
  87 #include <dev/mii/mii.h>
  88 #include <dev/mii/miivar.h>
  89
  90 #include <dev/pci/pcireg.h>
  91 #include <dev/pci/pcivar.h>
  92
  93 #define SIS_USEIOSPACE
  94
  95 #include <pci/if_sisreg.h>
  96
  97 MODULE_DEPEND(sis, pci, 1, 1, 1);
  98 MODULE_DEPEND(sis, ether, 1, 1, 1);
  99 MODULE_DEPEND(sis, miibus, 1, 1, 1);
 100
 101 /* "controller miibus0" required.  See GENERIC if you get errors here. */
 102 #include "miibus_if.h"
 103
 104 /*
 105  * Various supported device vendors/types and their names.
 106  */
 107 static struct sis_type sis_devs[] = {
 108         { SIS_VENDORID, SIS_DEVICEID_900, "SiS 900 10/100BaseTX" },
 109         { SIS_VENDORID, SIS_DEVICEID_7016, "SiS 7016 10/100BaseTX" },
 110         { NS_VENDORID, NS_DEVICEID_DP83815, "NatSemi DP8381[56] 10/100BaseTX" },
 111         { 0, 0, NULL }
 112 };
 113
 114 static int sis_probe            (device_t);
 115 static int sis_attach           (device_t);
 116 static int sis_detach           (device_t);
 117
 118 static int sis_newbuf           (struct sis_softc *,
 119                                         struct sis_desc *, struct mbuf *);
 120 static int sis_encap            (struct sis_softc *,
 121                                         struct mbuf **, u_int32_t *);
 122 static void sis_rxeof           (struct sis_softc *);
 123 static void sis_rxeoc           (struct sis_softc *);
 124 static void sis_txeof           (struct sis_softc *);
 125 static void sis_intr            (void *);
 126 static void sis_tick            (void *);
 127 static void sis_start           (struct ifnet *);
 128 static int sis_ioctl            (struct ifnet *, u_long, caddr_t);
 129 static void sis_init            (void *);
 130 static void sis_stop            (struct sis_softc *);
 131 static void sis_watchdog                (struct ifnet *);
 132 static void sis_shutdown                (device_t);
 133 static int sis_ifmedia_upd      (struct ifnet *);
 134 static void sis_ifmedia_sts     (struct ifnet *, struct ifmediareq *);
 135
 136 static u_int16_t sis_reverse    (u_int16_t);
 137 static void sis_delay           (struct sis_softc *);
 138 static void sis_eeprom_idle     (struct sis_softc *);
 139 static void sis_eeprom_putbyte  (struct sis_softc *, int);
 140 static void sis_eeprom_getword  (struct sis_softc *, int, u_int16_t *);
 141 static void sis_read_eeprom     (struct sis_softc *, caddr_t, int, int, int);
 142 #ifdef __i386__
 143 static void sis_read_cmos       (struct sis_softc *, device_t, caddr_t,
 144                                                         int, int);
 145 static void sis_read_mac        (struct sis_softc *, device_t, caddr_t);
 146 static device_t sis_find_bridge (device_t);
 147 #endif
 148
 149 static void sis_mii_sync        (struct sis_softc *);
 150 static void sis_mii_send        (struct sis_softc *, u_int32_t, int);
 151 static int sis_mii_readreg      (struct sis_softc *, struct sis_mii_frame *);
 152 static int sis_mii_writereg     (struct sis_softc *, struct sis_mii_frame *);
 153 static int sis_miibus_readreg   (device_t, int, int);
 154 static int sis_miibus_writereg  (device_t, int, int, int);
 155 static void sis_miibus_statchg  (device_t);
 156
 157 static void sis_setmulti_sis    (struct sis_softc *);
 158 static void sis_setmulti_ns     (struct sis_softc *);
 159 static u_int32_t sis_crc        (struct sis_softc *, caddr_t);
 160 static void sis_reset           (struct sis_softc *);
 161 static int sis_list_rx_init     (struct sis_softc *);
 162 static int sis_list_tx_init     (struct sis_softc *);
 163
 164 static void sis_dma_map_desc_ptr        (void *, bus_dma_segment_t *, int, int);
 165 static void sis_dma_map_desc_next       (void *, bus_dma_segment_t *, int, int);
 166 static void sis_dma_map_ring            (void *, bus_dma_segment_t *, int, int);
 167 #ifdef SIS_USEIOSPACE
 168 #define SIS_RES                 SYS_RES_IOPORT
 169 #define SIS_RID                 SIS_PCI_LOIO
 170 #else
 171 #define SIS_RES                 SYS_RES_MEMORY
 172 #define SIS_RID                 SIS_PCI_LOMEM
 173 #endif
 174
 175 static device_method_t sis_methods[] = {
 176         /* Device interface */
 177         DEVMETHOD(device_probe,         sis_probe),
 178         DEVMETHOD(device_attach,        sis_attach),
 179         DEVMETHOD(device_detach,        sis_detach),
 180         DEVMETHOD(device_shutdown,      sis_shutdown),
 181
 182         /* bus interface */
 183         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 184         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 185
 186         /* MII interface */
 187         DEVMETHOD(miibus_readreg,       sis_miibus_readreg),
 188         DEVMETHOD(miibus_writereg,      sis_miibus_writereg),
 189         DEVMETHOD(miibus_statchg,       sis_miibus_statchg),
 190
 191         { 0, 0 }
 192 };
 193
 194 static driver_t sis_driver = {
 195         "sis",
 196         sis_methods,
 197         sizeof(struct sis_softc)
 198 };
 199
 200 static devclass_t sis_devclass;
 201
 202 DRIVER_MODULE(sis, pci, sis_driver, sis_devclass, 0, 0);
 203 DRIVER_MODULE(miibus, sis, miibus_driver, miibus_devclass, 0, 0);
 204
 205 #define SIS_SETBIT(sc, reg, x)                          \
 206         CSR_WRITE_4(sc, reg,                            \
 207                 CSR_READ_4(sc, reg) | (x))
 208
 209 #define SIS_CLRBIT(sc, reg, x)                          \
 210         CSR_WRITE_4(sc, reg,                            \
 211                 CSR_READ_4(sc, reg) & ~(x))
 212
 213 #define SIO_SET(x)                                      \
 214         CSR_WRITE_4(sc, SIS_EECTL, CSR_READ_4(sc, SIS_EECTL) | x)
 215
 216 #define SIO_CLR(x)                                      \
 217         CSR_WRITE_4(sc, SIS_EECTL, CSR_READ_4(sc, SIS_EECTL) & ~x)
 218
 219 static void
 220 sis_dma_map_desc_next(arg, segs, nseg, error)
 221         void *arg;
 222         bus_dma_segment_t *segs;
 223         int nseg, error;
 224 {
 225         struct sis_desc *r;
 226
 227         r = arg;
 228         r->sis_next = segs->ds_addr;
 229
 230         return;
 231 }
 232
 233 static void
 234 sis_dma_map_desc_ptr(arg, segs, nseg, error)
 235         void *arg;
 236         bus_dma_segment_t *segs;
 237         int nseg, error;
 238 {
 239         struct sis_desc *r;
 240
 241         r = arg;
 242         r->sis_ptr = segs->ds_addr;
 243
 244         return;
 245 }
 246
 247 static void
 248 sis_dma_map_ring(arg, segs, nseg, error)
 249         void *arg;
 250         bus_dma_segment_t *segs;
 251         int nseg, error;
 252 {
 253         u_int32_t *p;
 254
 255         p = arg;
 256         *p = segs->ds_addr;
 257
 258         return;
 259 }
 260
 261 /*
 262  * Routine to reverse the bits in a word. Stolen almost
 263  * verbatim from /usr/games/fortune.
 264  */
 265 static u_int16_t
 266 sis_reverse(n)
 267         u_int16_t               n;
 268 {
 269         n = ((n >>  1) & 0x5555) | ((n <<  1) & 0xaaaa);
 270         n = ((n >>  2) & 0x3333) | ((n <<  2) & 0xcccc);
 271         n = ((n >>  4) & 0x0f0f) | ((n <<  4) & 0xf0f0);
 272         n = ((n >>  8) & 0x00ff) | ((n <<  8) & 0xff00);
 273
 274         return(n);
 275 }
 276
 277 static void
 278 sis_delay(sc)
 279         struct sis_softc        *sc;
 280 {
 281         int                     idx;
 282
 283         for (idx = (300 / 33) + 1; idx > 0; idx--)
 284                 CSR_READ_4(sc, SIS_CSR);
 285
 286         return;
 287 }
 288
 289 static void
 290 sis_eeprom_idle(sc)
 291         struct sis_softc        *sc;
 292 {
 293         register int            i;
 294
 295         SIO_SET(SIS_EECTL_CSEL);
 296         sis_delay(sc);
 297         SIO_SET(SIS_EECTL_CLK);
 298         sis_delay(sc);
 299
 300         for (i = 0; i < 25; i++) {
 301                 SIO_CLR(SIS_EECTL_CLK);
 302                 sis_delay(sc);
 303                 SIO_SET(SIS_EECTL_CLK);
 304                 sis_delay(sc);
 305         }
 306
 307         SIO_CLR(SIS_EECTL_CLK);
 308         sis_delay(sc);
 309         SIO_CLR(SIS_EECTL_CSEL);
 310         sis_delay(sc);
 311         CSR_WRITE_4(sc, SIS_EECTL, 0x00000000);
 312
 313         return;
 314 }
 315
 316 /*
 317  * Send a read command and address to the EEPROM, check for ACK.
 318  */
 319 static void
 320 sis_eeprom_putbyte(sc, addr)
 321         struct sis_softc        *sc;
 322         int                     addr;
 323 {
 324         register int            d, i;
 325
 326         d = addr | SIS_EECMD_READ;
 327
 328         /*
 329          * Feed in each bit and stobe the clock.
 330          */
 331         for (i = 0x400; i; i >>= 1) {
 332                 if (d & i) {
 333                         SIO_SET(SIS_EECTL_DIN);
 334                 } else {
 335                         SIO_CLR(SIS_EECTL_DIN);
 336                 }
 337                 sis_delay(sc);
 338                 SIO_SET(SIS_EECTL_CLK);
 339                 sis_delay(sc);
 340                 SIO_CLR(SIS_EECTL_CLK);
 341                 sis_delay(sc);
 342         }
 343
 344         return;
 345 }
 346
 347 /*
 348  * Read a word of data stored in the EEPROM at address 'addr.'
 349  */
 350 static void
 351 sis_eeprom_getword(sc, addr, dest)
 352         struct sis_softc        *sc;
 353         int                     addr;
 354         u_int16_t               *dest;
 355 {
 356         register int            i;
 357         u_int16_t               word = 0;
 358
 359         /* Force EEPROM to idle state. */
 360         sis_eeprom_idle(sc);
 361
 362         /* Enter EEPROM access mode. */
 363         sis_delay(sc);
 364         SIO_CLR(SIS_EECTL_CLK);
 365         sis_delay(sc);
 366         SIO_SET(SIS_EECTL_CSEL);
 367         sis_delay(sc);
 368
 369         /*
 370          * Send address of word we want to read.
 371          */
 372         sis_eeprom_putbyte(sc, addr);
 373
 374         /*
 375          * Start reading bits from EEPROM.
 376          */
 377         for (i = 0x8000; i; i >>= 1) {
 378                 SIO_SET(SIS_EECTL_CLK);
 379                 sis_delay(sc);
 380                 if (CSR_READ_4(sc, SIS_EECTL) & SIS_EECTL_DOUT)
 381                         word |= i;
 382                 sis_delay(sc);
 383                 SIO_CLR(SIS_EECTL_CLK);
 384                 sis_delay(sc);
 385         }
 386
 387         /* Turn off EEPROM access mode. */
 388         sis_eeprom_idle(sc);
 389
 390         *dest = word;
 391
 392         return;
 393 }
 394
 395 /*
 396  * Read a sequence of words from the EEPROM.
 397  */
 398 static void
 399 sis_read_eeprom(sc, dest, off, cnt, swap)
 400         struct sis_softc        *sc;
 401         caddr_t                 dest;
 402         int                     off;
 403         int                     cnt;
 404         int                     swap;
 405 {
 406         int                     i;
 407         u_int16_t               word = 0, *ptr;
 408
 409         for (i = 0; i < cnt; i++) {
 410                 sis_eeprom_getword(sc, off + i, &word);
 411                 ptr = (u_int16_t *)(dest + (i * 2));
 412                 if (swap)
 413                         *ptr = ntohs(word);
 414                 else
 415                         *ptr = word;
 416         }
 417
 418         return;
 419 }
 420
 421 #ifdef __i386__
 422 static device_t
 423 sis_find_bridge(dev)
 424         device_t                dev;
 425 {
 426         devclass_t              pci_devclass;
 427         device_t                *pci_devices;
 428         int                     pci_count = 0;
 429         device_t                *pci_children;
 430         int                     pci_childcount = 0;
 431         device_t                *busp, *childp;
 432         device_t                child = NULL;
 433         int                     i, j;
 434
 435         if ((pci_devclass = devclass_find("pci")) == NULL)
 436                 return(NULL);
 437
 438         devclass_get_devices(pci_devclass, &pci_devices, &pci_count);
 439
 440         for (i = 0, busp = pci_devices; i < pci_count; i++, busp++) {
 441                 pci_childcount = 0;
 442                 device_get_children(*busp, &pci_children, &pci_childcount);
 443                 for (j = 0, childp = pci_children;
 444                     j < pci_childcount; j++, childp++) {
 445                         if (pci_get_vendor(*childp) == SIS_VENDORID &&
 446                             pci_get_device(*childp) == 0x0008) {
 447                                 child = *childp;
 448                                 goto done;
 449                         }
 450                 }
 451         }
 452
 453 done:
 454         free(pci_devices, M_TEMP);
 455         free(pci_children, M_TEMP);
 456         return(child);
 457 }
 458
 459 static void
 460 sis_read_cmos(sc, dev, dest, off, cnt)
 461         struct sis_softc        *sc;
 462         device_t                dev;
 463         caddr_t                 dest;
 464         int                     off;
 465         int                     cnt;
 466 {
 467         device_t                bridge;
 468         u_int8_t                reg;
 469         int                     i;
 470         bus_space_tag_t         btag;
 471
 472         bridge = sis_find_bridge(dev);
 473         if (bridge == NULL)
 474                 return;
 475         reg = pci_read_config(bridge, 0x48, 1);
 476         pci_write_config(bridge, 0x48, reg|0x40, 1);
 477
 478         /* XXX */
 479         btag = I386_BUS_SPACE_IO;
 480
 481         for (i = 0; i < cnt; i++) {
 482                 bus_space_write_1(btag, 0x0, 0x70, i + off);
 483                 *(dest + i) = bus_space_read_1(btag, 0x0, 0x71);
 484         }
 485
 486         pci_write_config(bridge, 0x48, reg & ~0x40, 1);
 487         return;
 488 }
 489
 490 static void
 491 sis_read_mac(sc, dev, dest)
 492         struct sis_softc        *sc;
 493         device_t                dev;
 494         caddr_t                 dest;
 495 {
 496         u_int32_t               filtsave, csrsave;
 497
 498         filtsave = CSR_READ_4(sc, SIS_RXFILT_CTL);
 499         csrsave = CSR_READ_4(sc, SIS_CSR);
 500
 501         CSR_WRITE_4(sc, SIS_CSR, SIS_CSR_RELOAD | filtsave);
 502         CSR_WRITE_4(sc, SIS_CSR, 0);
 503
 504         CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave & ~SIS_RXFILTCTL_ENABLE);
 505
 506         CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR0);
 507         ((u_int16_t *)dest)[0] = CSR_READ_2(sc, SIS_RXFILT_DATA);
 508         CSR_WRITE_4(sc, SIS_RXFILT_CTL,SIS_FILTADDR_PAR1);
 509         ((u_int16_t *)dest)[1] = CSR_READ_2(sc, SIS_RXFILT_DATA);
 510         CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR2);
 511         ((u_int16_t *)dest)[2] = CSR_READ_2(sc, SIS_RXFILT_DATA);
 512
 513         CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave);
 514         CSR_WRITE_4(sc, SIS_CSR, csrsave);
 515         return;
 516 }
 517 #endif
 518
 519 /*
 520  * Sync the PHYs by setting data bit and strobing the clock 32 times.
 521  */
 522 static void sis_mii_sync(sc)
 523         struct sis_softc        *sc;
 524 {
 525         register int            i;
 526
 527         SIO_SET(SIS_MII_DIR|SIS_MII_DATA);
 528
 529         for (i = 0; i < 32; i++) {
 530                 SIO_SET(SIS_MII_CLK);
 531                 DELAY(1);
 532                 SIO_CLR(SIS_MII_CLK);
 533                 DELAY(1);
 534         }
 535
 536         return;
 537 }
 538
 539 /*
 540  * Clock a series of bits through the MII.
 541  */
 542 static void sis_mii_send(sc, bits, cnt)
 543         struct sis_softc        *sc;
 544         u_int32_t               bits;
 545         int                     cnt;
 546 {
 547         int                     i;
 548
 549         SIO_CLR(SIS_MII_CLK);
 550
 551         for (i = (0x1 << (cnt - 1)); i; i >>= 1) {
 552                 if (bits & i) {
 553                         SIO_SET(SIS_MII_DATA);
 554                 } else {
 555                         SIO_CLR(SIS_MII_DATA);
 556                 }
 557                 DELAY(1);
 558                 SIO_CLR(SIS_MII_CLK);
 559                 DELAY(1);
 560                 SIO_SET(SIS_MII_CLK);
 561         }
 562 }
 563
 564 /*
 565  * Read an PHY register through the MII.
 566  */
 567 static int sis_mii_readreg(sc, frame)
 568         struct sis_softc        *sc;
 569         struct sis_mii_frame    *frame;
 570
 571 {
 572         int                     i, ack, s;
 573
 574         s = splimp();
 575
 576         /*
 577          * Set up frame for RX.
 578          */
 579         frame->mii_stdelim = SIS_MII_STARTDELIM;
 580         frame->mii_opcode = SIS_MII_READOP;
 581         frame->mii_turnaround = 0;
 582         frame->mii_data = 0;
 583
 584         /*
 585          * Turn on data xmit.
 586          */
 587         SIO_SET(SIS_MII_DIR);
 588
 589         sis_mii_sync(sc);
 590
 591         /*
 592          * Send command/address info.
 593          */
 594         sis_mii_send(sc, frame->mii_stdelim, 2);
 595         sis_mii_send(sc, frame->mii_opcode, 2);
 596         sis_mii_send(sc, frame->mii_phyaddr, 5);
 597         sis_mii_send(sc, frame->mii_regaddr, 5);
 598
 599         /* Idle bit */
 600         SIO_CLR((SIS_MII_CLK|SIS_MII_DATA));
 601         DELAY(1);
 602         SIO_SET(SIS_MII_CLK);
 603         DELAY(1);
 604
 605         /* Turn off xmit. */
 606         SIO_CLR(SIS_MII_DIR);
 607
 608         /* Check for ack */
 609         SIO_CLR(SIS_MII_CLK);
 610         DELAY(1);
 611         ack = CSR_READ_4(sc, SIS_EECTL) & SIS_MII_DATA;
 612         SIO_SET(SIS_MII_CLK);
 613         DELAY(1);
 614
 615         /*
 616          * Now try reading data bits. If the ack failed, we still
 617          * need to clock through 16 cycles to keep the PHY(s) in sync.
 618          */
 619         if (ack) {
 620                 for(i = 0; i < 16; i++) {
 621                         SIO_CLR(SIS_MII_CLK);
 622                         DELAY(1);
 623                         SIO_SET(SIS_MII_CLK);
 624                         DELAY(1);
 625                 }
 626                 goto fail;
 627         }
 628
 629         for (i = 0x8000; i; i >>= 1) {
 630                 SIO_CLR(SIS_MII_CLK);
 631                 DELAY(1);
 632                 if (!ack) {
 633                         if (CSR_READ_4(sc, SIS_EECTL) & SIS_MII_DATA)
 634                                 frame->mii_data |= i;
 635                         DELAY(1);
 636                 }
 637                 SIO_SET(SIS_MII_CLK);
 638                 DELAY(1);
 639         }
 640
 641 fail:
 642
 643         SIO_CLR(SIS_MII_CLK);
 644         DELAY(1);
 645         SIO_SET(SIS_MII_CLK);
 646         DELAY(1);
 647
 648         splx(s);
 649
 650         if (ack)
 651                 return(1);
 652         return(0);
 653 }
 654
 655 /*
 656  * Write to a PHY register through the MII.
 657  */
 658 static int sis_mii_writereg(sc, frame)
 659         struct sis_softc        *sc;
 660         struct sis_mii_frame    *frame;
 661
 662 {
 663         int                     s;
 664
 665          s = splimp();
 666         /*
 667          * Set up frame for TX.
 668          */
 669
 670         frame->mii_stdelim = SIS_MII_STARTDELIM;
 671         frame->mii_opcode = SIS_MII_WRITEOP;
 672         frame->mii_turnaround = SIS_MII_TURNAROUND;
 673
 674         /*
 675          * Turn on data output.
 676          */
 677         SIO_SET(SIS_MII_DIR);
 678
 679         sis_mii_sync(sc);
 680
 681         sis_mii_send(sc, frame->mii_stdelim, 2);
 682         sis_mii_send(sc, frame->mii_opcode, 2);
 683         sis_mii_send(sc, frame->mii_phyaddr, 5);
 684         sis_mii_send(sc, frame->mii_regaddr, 5);
 685         sis_mii_send(sc, frame->mii_turnaround, 2);
 686         sis_mii_send(sc, frame->mii_data, 16);
 687
 688         /* Idle bit. */
 689         SIO_SET(SIS_MII_CLK);
 690         DELAY(1);
 691         SIO_CLR(SIS_MII_CLK);
 692         DELAY(1);
 693
 694         /*
 695          * Turn off xmit.
 696          */
 697         SIO_CLR(SIS_MII_DIR);
 698
 699         splx(s);
 700
 701         return(0);
 702 }
 703
 704 static int
 705 sis_miibus_readreg(dev, phy, reg)
 706         device_t                dev;
 707         int                     phy, reg;
 708 {
 709         struct sis_softc        *sc;
 710         struct sis_mii_frame    frame;
 711
 712         sc = device_get_softc(dev);
 713
 714         if (sc->sis_type == SIS_TYPE_83815) {
 715                 if (phy != 0)
 716                         return(0);
 717                 /*
 718                  * The NatSemi chip can take a while after
 719                  * a reset to come ready, during which the BMSR
 720                  * returns a value of 0. This is *never* supposed
 721                  * to happen: some of the BMSR bits are meant to
 722                  * be hardwired in the on position, and this can
 723                  * confuse the miibus code a bit during the probe
 724                  * and attach phase. So we make an effort to check
 725                  * for this condition and wait for it to clear.
 726                  */
 727                 if (!CSR_READ_4(sc, NS_BMSR))
 728                         DELAY(1000);
 729                 return CSR_READ_4(sc, NS_BMCR + (reg * 4));
 730         }
 731
 732         /*
 733          * Chipsets < SIS_635 seem not to be able to read/write
 734          * through mdio. Use the enhanced PHY access register
 735          * again for them.
 736          */
 737         if (sc->sis_type == SIS_TYPE_900 &&
 738             sc->sis_rev < SIS_REV_635) {
 739                 int i, val = 0;
 740
 741                 if (phy != 0)
 742                         return(0);
 743
 744                 CSR_WRITE_4(sc, SIS_PHYCTL,
 745                     (phy << 11) | (reg << 6) | SIS_PHYOP_READ);
 746                 SIS_SETBIT(sc, SIS_PHYCTL, SIS_PHYCTL_ACCESS);
 747
 748                 for (i = 0; i < SIS_TIMEOUT; i++) {
 749                         if (!(CSR_READ_4(sc, SIS_PHYCTL) & SIS_PHYCTL_ACCESS))
 750                                 break;
 751                 }
 752
 753                 if (i == SIS_TIMEOUT) {
 754                         printf("sis%d: PHY failed to come ready\n",
 755                             sc->sis_unit);
 756                         return(0);
 757                 }
 758
 759                 val = (CSR_READ_4(sc, SIS_PHYCTL) >> 16) & 0xFFFF;
 760
 761                 if (val == 0xFFFF)
 762                         return(0);
 763
 764                 return(val);
 765         } else {
 766                 bzero((char *)&frame, sizeof(frame));
 767
 768                 frame.mii_phyaddr = phy;
 769                 frame.mii_regaddr = reg;
 770                 sis_mii_readreg(sc, &frame);
 771
 772                 return(frame.mii_data);
 773         }
 774 }
 775
 776 static int
 777 sis_miibus_writereg(dev, phy, reg, data)
 778         device_t                dev;
 779         int                     phy, reg, data;
 780 {
 781         struct sis_softc        *sc;
 782         struct sis_mii_frame    frame;
 783
 784         sc = device_get_softc(dev);
 785
 786         if (sc->sis_type == SIS_TYPE_83815) {
 787                 if (phy != 0)
 788                         return(0);
 789                 CSR_WRITE_4(sc, NS_BMCR + (reg * 4), data);
 790                 return(0);
 791         }
 792
 793         /*
 794          * Chipsets < SIS_635 seem not to be able to read/write
 795          * through mdio. Use the enhanced PHY access register
 796          * again for them.
 797          */
 798         if (sc->sis_type == SIS_TYPE_900 &&
 799             sc->sis_rev < SIS_REV_635) {
 800                 int i;
 801
 802                 if (phy != 0)
 803                         return(0);
 804
 805                 CSR_WRITE_4(sc, SIS_PHYCTL, (data << 16) | (phy << 11) |
 806                     (reg << 6) | SIS_PHYOP_WRITE);
 807                 SIS_SETBIT(sc, SIS_PHYCTL, SIS_PHYCTL_ACCESS);
 808
 809                 for (i = 0; i < SIS_TIMEOUT; i++) {
 810                         if (!(CSR_READ_4(sc, SIS_PHYCTL) & SIS_PHYCTL_ACCESS))
 811                                 break;
 812                 }
 813
 814                 if (i == SIS_TIMEOUT)
 815                         printf("sis%d: PHY failed to come ready\n",
 816                             sc->sis_unit);
 817         } else {
 818                 bzero((char *)&frame, sizeof(frame));
 819
 820                 frame.mii_phyaddr = phy;
 821                 frame.mii_regaddr = reg;
 822                 frame.mii_data = data;
 823                 sis_mii_writereg(sc, &frame);
 824         }
 825         return(0);
 826 }
 827
 828 static void
 829 sis_miibus_statchg(dev)
 830         device_t                dev;
 831 {
 832         struct sis_softc        *sc;
 833
 834         sc = device_get_softc(dev);
 835         sis_init(sc);
 836
 837         return;
 838 }
 839
 840 static u_int32_t
 841 sis_crc(sc, addr)
 842         struct sis_softc        *sc;
 843         caddr_t                 addr;
 844 {
 845         u_int32_t               crc, carry;
 846         int                     i, j;
 847         u_int8_t                c;
 848
 849         /* Compute CRC for the address value. */
 850         crc = 0xFFFFFFFF; /* initial value */
 851
 852         for (i = 0; i < 6; i++) {
 853                 c = *(addr + i);
 854                 for (j = 0; j < 8; j++) {
 855                         carry = ((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01);
 856                         crc <<= 1;
 857                         c >>= 1;
 858                         if (carry)
 859                                 crc = (crc ^ 0x04c11db6) | carry;
 860                 }
 861         }
 862
 863         /*
 864          * return the filter bit position
 865          *
 866          * The NatSemi chip has a 512-bit filter, which is
 867          * different than the SiS, so we special-case it.
 868          */
 869         if (sc->sis_type == SIS_TYPE_83815)
 870                 return (crc >> 23);
 871         else if (sc->sis_rev >= SIS_REV_635 ||
 872             sc->sis_rev == SIS_REV_900B)
 873                 return (crc >> 24);
 874         else
 875                 return (crc >> 25);
 876 }
 877
 878 static void
 879 sis_setmulti_ns(sc)
 880         struct sis_softc        *sc;
 881 {
 882         struct ifnet            *ifp;
 883         struct ifmultiaddr      *ifma;
 884         u_int32_t               h = 0, i, filtsave;
 885         int                     bit, index;
 886
 887         ifp = &sc->arpcom.ac_if;
 888
 889         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
 890                 SIS_CLRBIT(sc, SIS_RXFILT_CTL, NS_RXFILTCTL_MCHASH);
 891                 SIS_SETBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_ALLMULTI);
 892                 return;
 893         }
 894
 895         /*
 896          * We have to explicitly enable the multicast hash table
 897          * on the NatSemi chip if we want to use it, which we do.
 898          */
 899         SIS_SETBIT(sc, SIS_RXFILT_CTL, NS_RXFILTCTL_MCHASH);
 900         SIS_CLRBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_ALLMULTI);
 901
 902         filtsave = CSR_READ_4(sc, SIS_RXFILT_CTL);
 903
 904         /* first, zot all the existing hash bits */
 905         for (i = 0; i < 32; i++) {
 906                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_FMEM_LO + (i*2));
 907                 CSR_WRITE_4(sc, SIS_RXFILT_DATA, 0);
 908         }
 909
 910         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 911                 if (ifma->ifma_addr->sa_family != AF_LINK)
 912                         continue;
 913                 h = sis_crc(sc, LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 914                 index = h >> 3;
 915                 bit = h & 0x1F;
 916                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_FMEM_LO + index);
 917                 if (bit > 0xF)
 918                         bit -= 0x10;
 919                 SIS_SETBIT(sc, SIS_RXFILT_DATA, (1 << bit));
 920         }
 921
 922         CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave);
 923
 924         return;
 925 }
 926
 927 static void
 928 sis_setmulti_sis(sc)
 929         struct sis_softc        *sc;
 930 {
 931         struct ifnet            *ifp;
 932         struct ifmultiaddr      *ifma;
 933         u_int32_t               h, i, n, ctl;
 934         u_int16_t               hashes[16];
 935
 936         ifp = &sc->arpcom.ac_if;
 937
 938         /* hash table size */
 939         if (sc->sis_rev >= SIS_REV_635 ||
 940             sc->sis_rev == SIS_REV_900B)
 941                 n = 16;
 942         else
 943                 n = 8;
 944
 945         ctl = CSR_READ_4(sc, SIS_RXFILT_CTL) & SIS_RXFILTCTL_ENABLE;
 946
 947         if (ifp->if_flags & IFF_BROADCAST)
 948                 ctl |= SIS_RXFILTCTL_BROAD;
 949
 950         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
 951                 ctl |= SIS_RXFILTCTL_ALLMULTI;
 952                 if (ifp->if_flags & IFF_PROMISC)
 953                         ctl |= SIS_RXFILTCTL_BROAD|SIS_RXFILTCTL_ALLPHYS;
 954                 for (i = 0; i < n; i++)
 955                         hashes[i] = ~0;
 956         } else {
 957                 for (i = 0; i < n; i++)
 958                         hashes[i] = 0;
 959                 i = 0;
 960                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 961                         if (ifma->ifma_addr->sa_family != AF_LINK)
 962                         continue;
 963                         h = sis_crc(sc,
 964                             LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 965                         hashes[h >> 4] |= 1 << (h & 0xf);
 966                         i++;
 967                 }
 968                 if (i > n) {
 969                         ctl |= SIS_RXFILTCTL_ALLMULTI;
 970                         for (i = 0; i < n; i++)
 971                                 hashes[i] = ~0;
 972                 }
 973         }
 974
 975         for (i = 0; i < n; i++) {
 976                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, (4 + i) << 16);
 977                 CSR_WRITE_4(sc, SIS_RXFILT_DATA, hashes[i]);
 978         }
 979
 980         CSR_WRITE_4(sc, SIS_RXFILT_CTL, ctl);
 981 }
 982
 983 static void
 984 sis_reset(sc)
 985         struct sis_softc        *sc;
 986 {
 987         register int            i;
 988
 989         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RESET);
 990
 991         for (i = 0; i < SIS_TIMEOUT; i++) {
 992                 if (!(CSR_READ_4(sc, SIS_CSR) & SIS_CSR_RESET))
 993                         break;
 994         }
 995
 996         if (i == SIS_TIMEOUT)
 997                 printf("sis%d: reset never completed\n", sc->sis_unit);
 998
 999         /* Wait a little while for the chip to get its brains in order. */
1000         DELAY(1000);
1001
1002         /*
1003          * If this is a NetSemi chip, make sure to clear
1004          * PME mode.
1005          */
1006         if (sc->sis_type == SIS_TYPE_83815) {
1007                 CSR_WRITE_4(sc, NS_CLKRUN, NS_CLKRUN_PMESTS);
1008                 CSR_WRITE_4(sc, NS_CLKRUN, 0);
1009         }
1010
1011         return;
1012 }
1013
1014 /*
1015  * Probe for an SiS chip. Check the PCI vendor and device
1016  * IDs against our list and return a device name if we find a match.
1017  */
1018 static int
1019 sis_probe(dev)
1020         device_t                dev;
1021 {
1022         struct sis_type         *t;
1023
1024         t = sis_devs;
1025
1026         while(t->sis_name != NULL) {
1027                 if ((pci_get_vendor(dev) == t->sis_vid) &&
1028                     (pci_get_device(dev) == t->sis_did)) {
1029                         device_set_desc(dev, t->sis_name);
1030                         return(0);
1031                 }
1032                 t++;
1033         }
1034
1035         return(ENXIO);
1036 }
1037
1038 /*
1039  * Attach the interface. Allocate softc structures, do ifmedia
1040  * setup and ethernet/BPF attach.
1041  */
1042 static int
1043 sis_attach(dev)
1044         device_t                dev;
1045 {
1046         u_char                  eaddr[ETHER_ADDR_LEN];
1047         struct sis_softc        *sc;
1048         struct ifnet            *ifp;
1049         int                     unit, error = 0, rid, waittime = 0;
1050
1051         waittime = 0;
1052         sc = device_get_softc(dev);
1053         unit = device_get_unit(dev);
1054
1055         sc->sis_self = dev;
1056
1057         mtx_init(&sc->sis_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
1058             MTX_DEF | MTX_RECURSE);
1059
1060         if (pci_get_device(dev) == SIS_DEVICEID_900)
1061                 sc->sis_type = SIS_TYPE_900;
1062         if (pci_get_device(dev) == SIS_DEVICEID_7016)
1063                 sc->sis_type = SIS_TYPE_7016;
1064         if (pci_get_vendor(dev) == NS_VENDORID)
1065                 sc->sis_type = SIS_TYPE_83815;
1066
1067         sc->sis_rev = pci_read_config(dev, PCIR_REVID, 1);
1068 #ifndef BURN_BRIDGES
1069         /*
1070          * Handle power management nonsense.
1071          */
1072         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) {
1073                 u_int32_t               iobase, membase, irq;
1074
1075                 /* Save important PCI config data. */
1076                 iobase = pci_read_config(dev, SIS_PCI_LOIO, 4);
1077                 membase = pci_read_config(dev, SIS_PCI_LOMEM, 4);
1078                 irq = pci_read_config(dev, SIS_PCI_INTLINE, 4);
1079
1080                 /* Reset the power state. */
1081                 printf("sis%d: chip is in D%d power mode "
1082                     "-- setting to D0\n", unit,
1083                     pci_get_powerstate(dev));
1084                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
1085
1086                 /* Restore PCI config data. */
1087                 pci_write_config(dev, SIS_PCI_LOIO, iobase, 4);
1088                 pci_write_config(dev, SIS_PCI_LOMEM, membase, 4);
1089                 pci_write_config(dev, SIS_PCI_INTLINE, irq, 4);
1090         }
1091 #endif
1092         /*
1093          * Map control/status registers.
1094          */
1095         pci_enable_busmaster(dev);
1096
1097         rid = SIS_RID;
1098         sc->sis_res = bus_alloc_resource(dev, SIS_RES, &rid,
1099             0, ~0, 1, RF_ACTIVE);
1100
1101         if (sc->sis_res == NULL) {
1102                 printf("sis%d: couldn't map ports/memory\n", unit);
1103                 error = ENXIO;
1104                 goto fail;
1105         }
1106
1107         sc->sis_btag = rman_get_bustag(sc->sis_res);
1108         sc->sis_bhandle = rman_get_bushandle(sc->sis_res);
1109
1110         /* Allocate interrupt */
1111         rid = 0;
1112         sc->sis_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
1113             RF_SHAREABLE | RF_ACTIVE);
1114
1115         if (sc->sis_irq == NULL) {
1116                 printf("sis%d: couldn't map interrupt\n", unit);
1117                 error = ENXIO;
1118                 goto fail;
1119         }
1120
1121         /* Reset the adapter. */
1122         sis_reset(sc);
1123
1124         if (sc->sis_type == SIS_TYPE_900 &&
1125             (sc->sis_rev == SIS_REV_635 ||
1126             sc->sis_rev == SIS_REV_900B)) {
1127                 SIO_SET(SIS_CFG_RND_CNT);
1128                 SIO_SET(SIS_CFG_PERR_DETECT);
1129         }
1130
1131         /*
1132          * Get station address from the EEPROM.
1133          */
1134         switch (pci_get_vendor(dev)) {
1135         case NS_VENDORID:
1136                 sc->sis_srr = CSR_READ_4(sc, NS_SRR);
1137
1138                 /* We can't update the device description, so spew */
1139                 if (sc->sis_srr == NS_SRR_15C)
1140                         device_printf(dev, "Silicon Revision: DP83815C\n");
1141                 else if (sc->sis_srr == NS_SRR_15D)
1142                         device_printf(dev, "Silicon Revision: DP83815D\n");
1143                 else if (sc->sis_srr == NS_SRR_16A)
1144                         device_printf(dev, "Silicon Revision: DP83816A\n");
1145                 else
1146                         device_printf(dev, "Silicon Revision %x\n", sc->sis_srr);
1147
1148                 /*
1149                  * Reading the MAC address out of the EEPROM on
1150                  * the NatSemi chip takes a bit more work than
1151                  * you'd expect. The address spans 4 16-bit words,
1152                  * with the first word containing only a single bit.
1153                  * You have to shift everything over one bit to
1154                  * get it aligned properly. Also, the bits are
1155                  * stored backwards (the LSB is really the MSB,
1156                  * and so on) so you have to reverse them in order
1157                  * to get the MAC address into the form we want.
1158                  * Why? Who the hell knows.
1159                  */
1160                 {
1161                         u_int16_t               tmp[4];
1162
1163                         sis_read_eeprom(sc, (caddr_t)&tmp,
1164                             NS_EE_NODEADDR, 4, 0);
1165
1166                         /* Shift everything over one bit. */
1167                         tmp[3] = tmp[3] >> 1;
1168                         tmp[3] |= tmp[2] << 15;
1169                         tmp[2] = tmp[2] >> 1;
1170                         tmp[2] |= tmp[1] << 15;
1171                         tmp[1] = tmp[1] >> 1;
1172                         tmp[1] |= tmp[0] << 15;
1173
1174                         /* Now reverse all the bits. */
1175                         tmp[3] = sis_reverse(tmp[3]);
1176                         tmp[2] = sis_reverse(tmp[2]);
1177                         tmp[1] = sis_reverse(tmp[1]);
1178
1179                         bcopy((char *)&tmp[1], eaddr, ETHER_ADDR_LEN);
1180                 }
1181                 break;
1182         case SIS_VENDORID:
1183         default:
1184 #ifdef __i386__
1185                 /*
1186                  * If this is a SiS 630E chipset with an embedded
1187                  * SiS 900 controller, we have to read the MAC address
1188                  * from the APC CMOS RAM. Our method for doing this
1189                  * is very ugly since we have to reach out and grab
1190                  * ahold of hardware for which we cannot properly
1191                  * allocate resources. This code is only compiled on
1192                  * the i386 architecture since the SiS 630E chipset
1193                  * is for x86 motherboards only. Note that there are
1194                  * a lot of magic numbers in this hack. These are
1195                  * taken from SiS's Linux driver. I'd like to replace
1196                  * them with proper symbolic definitions, but that
1197                  * requires some datasheets that I don't have access
1198                  * to at the moment.
1199                  */
1200                 if (sc->sis_rev == SIS_REV_630S ||
1201                     sc->sis_rev == SIS_REV_630E ||
1202                     sc->sis_rev == SIS_REV_630EA1)
1203                         sis_read_cmos(sc, dev, (caddr_t)&eaddr, 0x9, 6);
1204
1205                 else if (sc->sis_rev == SIS_REV_635 ||
1206                          sc->sis_rev == SIS_REV_630ET)
1207                         sis_read_mac(sc, dev, (caddr_t)&eaddr);
1208                 else if (sc->sis_rev == SIS_REV_96x) {
1209                         /* Allow to read EEPROM from LAN. It is shared
1210                          * between a 1394 controller and the NIC and each
1211                          * time we access it, we need to set SIS_EECMD_REQ.
1212                          */
1213                         SIO_SET(SIS_EECMD_REQ);
1214                         for (waittime = 0; waittime < SIS_TIMEOUT;
1215                             waittime++) {
1216                                 /* Force EEPROM to idle state. */
1217                                 sis_eeprom_idle(sc);
1218                                 if (CSR_READ_4(sc, SIS_EECTL) & SIS_EECMD_GNT) {
1219                                         sis_read_eeprom(sc, (caddr_t)&eaddr,
1220                                             SIS_EE_NODEADDR, 3, 0);
1221                                         break;
1222                                 }
1223                                 DELAY(1);
1224                         }
1225                         /*
1226                          * Set SIS_EECTL_CLK to high, so a other master
1227                          * can operate on the i2c bus.
1228                          */
1229                         SIO_SET(SIS_EECTL_CLK);
1230                         /* Refuse EEPROM access by LAN */
1231                         SIO_SET(SIS_EECMD_DONE);
1232                 } else
1233 #endif
1234                         sis_read_eeprom(sc, (caddr_t)&eaddr,
1235                             SIS_EE_NODEADDR, 3, 0);
1236                 break;
1237         }
1238
1239         /*
1240          * A SiS chip was detected. Inform the world.
1241          */
1242         printf("sis%d: Ethernet address: %6D\n", unit, eaddr, ":");
1243
1244         sc->sis_unit = unit;
1245         callout_init(&sc->sis_stat_ch, CALLOUT_MPSAFE);
1246         bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
1247
1248         /*
1249          * Allocate the parent bus DMA tag appropriate for PCI.
1250          */
1251 #define SIS_NSEG_NEW 32
1252          error = bus_dma_tag_create(NULL,       /* parent */
1253                         1, 0,                   /* alignment, boundary */
1254                         BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
1255                         BUS_SPACE_MAXADDR,      /* highaddr */
1256                         NULL, NULL,             /* filter, filterarg */
1257                         MAXBSIZE, SIS_NSEG_NEW, /* maxsize, nsegments */
1258                         BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
1259                         BUS_DMA_ALLOCNOW,       /* flags */
1260                         NULL, NULL,             /* lockfunc, lockarg */
1261                         &sc->sis_parent_tag);
1262         if (error)
1263                 goto fail;
1264
1265         /*
1266          * Now allocate a tag for the DMA descriptor lists and a chunk
1267          * of DMA-able memory based on the tag.  Also obtain the physical
1268          * addresses of the RX and TX ring, which we'll need later.
1269          * All of our lists are allocated as a contiguous block
1270          * of memory.
1271          */
1272         error = bus_dma_tag_create(sc->sis_parent_tag,  /* parent */
1273                         1, 0,                   /* alignment, boundary */
1274                         BUS_SPACE_MAXADDR,      /* lowaddr */
1275                         BUS_SPACE_MAXADDR,      /* highaddr */
1276                         NULL, NULL,             /* filter, filterarg */
1277                         SIS_RX_LIST_SZ, 1,      /* maxsize,nsegments */
1278                         BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
1279                         0,                      /* flags */
1280                         busdma_lock_mutex,      /* lockfunc */
1281                         &Giant,                 /* lockarg */
1282                         &sc->sis_ldata.sis_rx_tag);
1283         if (error)
1284                 goto fail;
1285
1286         error = bus_dmamem_alloc(sc->sis_ldata.sis_rx_tag,
1287             (void **)&sc->sis_ldata.sis_rx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
1288             &sc->sis_ldata.sis_rx_dmamap);
1289
1290         if (error) {
1291                 printf("sis%d: no memory for rx list buffers!\n", unit);
1292                 bus_dma_tag_destroy(sc->sis_ldata.sis_rx_tag);
1293                 sc->sis_ldata.sis_rx_tag = NULL;
1294                 goto fail;
1295         }
1296
1297         error = bus_dmamap_load(sc->sis_ldata.sis_rx_tag,
1298             sc->sis_ldata.sis_rx_dmamap, &(sc->sis_ldata.sis_rx_list[0]),
1299             sizeof(struct sis_desc), sis_dma_map_ring,
1300             &sc->sis_cdata.sis_rx_paddr, 0);
1301
1302         if (error) {
1303                 printf("sis%d: cannot get address of the rx ring!\n", unit);
1304                 bus_dmamem_free(sc->sis_ldata.sis_rx_tag,
1305                     sc->sis_ldata.sis_rx_list, sc->sis_ldata.sis_rx_dmamap);
1306                 bus_dma_tag_destroy(sc->sis_ldata.sis_rx_tag);
1307                 sc->sis_ldata.sis_rx_tag = NULL;
1308                 goto fail;
1309         }
1310
1311         error = bus_dma_tag_create(sc->sis_parent_tag,  /* parent */
1312                         1, 0,                   /* alignment, boundary */
1313                         BUS_SPACE_MAXADDR,      /* lowaddr */
1314                         BUS_SPACE_MAXADDR,      /* highaddr */
1315                         NULL, NULL,             /* filter, filterarg */
1316                         SIS_TX_LIST_SZ, 1,      /* maxsize,nsegments */
1317                         BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
1318                         0,                      /* flags */
1319                         busdma_lock_mutex,      /* lockfunc */
1320                         &Giant,                 /* lockarg */
1321                         &sc->sis_ldata.sis_tx_tag);
1322         if (error)
1323                 goto fail;
1324
1325         error = bus_dmamem_alloc(sc->sis_ldata.sis_tx_tag,
1326             (void **)&sc->sis_ldata.sis_tx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
1327             &sc->sis_ldata.sis_tx_dmamap);
1328
1329         if (error) {
1330                 printf("sis%d: no memory for tx list buffers!\n", unit);
1331                 bus_dma_tag_destroy(sc->sis_ldata.sis_tx_tag);
1332                 sc->sis_ldata.sis_tx_tag = NULL;
1333                 goto fail;
1334         }
1335
1336         error = bus_dmamap_load(sc->sis_ldata.sis_tx_tag,
1337             sc->sis_ldata.sis_tx_dmamap, &(sc->sis_ldata.sis_tx_list[0]),
1338             sizeof(struct sis_desc), sis_dma_map_ring,
1339             &sc->sis_cdata.sis_tx_paddr, 0);
1340
1341         if (error) {
1342                 printf("sis%d: cannot get address of the tx ring!\n", unit);
1343                 bus_dmamem_free(sc->sis_ldata.sis_tx_tag,
1344                     sc->sis_ldata.sis_tx_list, sc->sis_ldata.sis_tx_dmamap);
1345                 bus_dma_tag_destroy(sc->sis_ldata.sis_tx_tag);
1346                 sc->sis_ldata.sis_tx_tag = NULL;
1347                 goto fail;
1348         }
1349
1350         error = bus_dma_tag_create(sc->sis_parent_tag,  /* parent */
1351                         1, 0,                   /* alignment, boundary */
1352                         BUS_SPACE_MAXADDR,      /* lowaddr */
1353                         BUS_SPACE_MAXADDR,      /* highaddr */
1354                         NULL, NULL,             /* filter, filterarg */
1355                         MCLBYTES, 1,            /* maxsize,nsegments */
1356                         BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
1357                         0,                      /* flags */
1358                         busdma_lock_mutex,      /* lockfunc */
1359                         &Giant,                 /* lockarg */
1360                         &sc->sis_tag);
1361         if (error)
1362                 goto fail;
1363
1364         /*
1365          * Obtain the physical addresses of the RX and TX
1366          * rings which we'll need later in the init routine.
1367          */
1368
1369         ifp = &sc->arpcom.ac_if;
1370         ifp->if_softc = sc;
1371         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1372         ifp->if_mtu = ETHERMTU;
1373         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1374         ifp->if_ioctl = sis_ioctl;
1375         ifp->if_output = ether_output;
1376         ifp->if_start = sis_start;
1377         ifp->if_watchdog = sis_watchdog;
1378         ifp->if_init = sis_init;
1379         ifp->if_baudrate = 10000000;
1380         ifp->if_snd.ifq_maxlen = SIS_TX_LIST_CNT - 1;
1381
1382         /*
1383          * Do MII setup.
1384          */
1385         if (mii_phy_probe(dev, &sc->sis_miibus,
1386             sis_ifmedia_upd, sis_ifmedia_sts)) {
1387                 printf("sis%d: MII without any PHY!\n", sc->sis_unit);
1388                 error = ENXIO;
1389                 goto fail;
1390         }
1391
1392         /*
1393          * Call MI attach routine.
1394          */
1395         ether_ifattach(ifp, eaddr);
1396
1397         /*
1398          * Tell the upper layer(s) we support long frames.
1399          */
1400         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1401         ifp->if_capabilities |= IFCAP_VLAN_MTU;
1402
1403         /* Hook interrupt last to avoid having to lock softc */
1404         error = bus_setup_intr(dev, sc->sis_irq, INTR_TYPE_NET | INTR_MPSAFE,
1405             sis_intr, sc, &sc->sis_intrhand);
1406
1407         if (error) {
1408                 printf("sis%d: couldn't set up irq\n", unit);
1409                 ether_ifdetach(ifp);
1410                 goto fail;
1411         }
1412
1413 fail:
1414         if (error)
1415                 sis_detach(dev);
1416
1417         return(error);
1418 }
1419
1420 /*
1421  * Shutdown hardware and free up resources. This can be called any
1422  * time after the mutex has been initialized. It is called in both
1423  * the error case in attach and the normal detach case so it needs
1424  * to be careful about only freeing resources that have actually been
1425  * allocated.
1426  */
1427 static int
1428 sis_detach(dev)
1429         device_t                dev;
1430 {
1431         struct sis_softc        *sc;
1432         struct ifnet            *ifp;
1433
1434         sc = device_get_softc(dev);
1435         KASSERT(mtx_initialized(&sc->sis_mtx), ("sis mutex not initialized"));
1436         SIS_LOCK(sc);
1437         ifp = &sc->arpcom.ac_if;
1438
1439         /* These should only be active if attach succeeded. */
1440         if (device_is_attached(dev)) {
1441                 sis_reset(sc);
1442                 sis_stop(sc);
1443                 ether_ifdetach(ifp);
1444         }
1445         if (sc->sis_miibus)
1446                 device_delete_child(dev, sc->sis_miibus);
1447         bus_generic_detach(dev);
1448
1449         if (sc->sis_intrhand)
1450                 bus_teardown_intr(dev, sc->sis_irq, sc->sis_intrhand);
1451         if (sc->sis_irq)
1452                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sis_irq);
1453         if (sc->sis_res)
1454                 bus_release_resource(dev, SIS_RES, SIS_RID, sc->sis_res);
1455
1456         if (sc->sis_ldata.sis_rx_tag) {
1457                 bus_dmamap_unload(sc->sis_ldata.sis_rx_tag,
1458                     sc->sis_ldata.sis_rx_dmamap);
1459                 bus_dmamem_free(sc->sis_ldata.sis_rx_tag,
1460                     sc->sis_ldata.sis_rx_list, sc->sis_ldata.sis_rx_dmamap);
1461                 bus_dma_tag_destroy(sc->sis_ldata.sis_rx_tag);
1462         }
1463         if (sc->sis_ldata.sis_tx_tag) {
1464                 bus_dmamap_unload(sc->sis_ldata.sis_tx_tag,
1465                     sc->sis_ldata.sis_tx_dmamap);
1466                 bus_dmamem_free(sc->sis_ldata.sis_tx_tag,
1467                     sc->sis_ldata.sis_tx_list, sc->sis_ldata.sis_tx_dmamap);
1468                 bus_dma_tag_destroy(sc->sis_ldata.sis_tx_tag);
1469         }
1470         if (sc->sis_parent_tag)
1471                 bus_dma_tag_destroy(sc->sis_parent_tag);
1472         if (sc->sis_tag)
1473                 bus_dma_tag_destroy(sc->sis_tag);
1474
1475         SIS_UNLOCK(sc);
1476         mtx_destroy(&sc->sis_mtx);
1477
1478         return(0);
1479 }
1480
1481 /*
1482  * Initialize the transmit descriptors.
1483  */
1484 static int
1485 sis_list_tx_init(sc)
1486         struct sis_softc        *sc;
1487 {
1488         struct sis_list_data    *ld;
1489         struct sis_ring_data    *cd;
1490         int                     i, nexti;
1491
1492         cd = &sc->sis_cdata;
1493         ld = &sc->sis_ldata;
1494
1495         for (i = 0; i < SIS_TX_LIST_CNT; i++) {
1496                 nexti = (i == (SIS_TX_LIST_CNT - 1)) ? 0 : i+1;
1497                         ld->sis_tx_list[i].sis_nextdesc =
1498                             &ld->sis_tx_list[nexti];
1499                         bus_dmamap_load(sc->sis_ldata.sis_tx_tag,
1500                             sc->sis_ldata.sis_tx_dmamap,
1501                             &ld->sis_tx_list[nexti], sizeof(struct sis_desc),
1502                             sis_dma_map_desc_next, &ld->sis_tx_list[i], 0);
1503                 ld->sis_tx_list[i].sis_mbuf = NULL;
1504                 ld->sis_tx_list[i].sis_ptr = 0;
1505                 ld->sis_tx_list[i].sis_ctl = 0;
1506         }
1507
1508         cd->sis_tx_prod = cd->sis_tx_cons = cd->sis_tx_cnt = 0;
1509
1510         bus_dmamap_sync(sc->sis_ldata.sis_tx_tag,
1511             sc->sis_ldata.sis_rx_dmamap, BUS_DMASYNC_PREWRITE);
1512
1513         return(0);
1514 }
1515
1516 /*
1517  * Initialize the RX descriptors and allocate mbufs for them. Note that
1518  * we arrange the descriptors in a closed ring, so that the last descriptor
1519  * points back to the first.
1520  */
1521 static int
1522 sis_list_rx_init(sc)
1523         struct sis_softc        *sc;
1524 {
1525         struct sis_list_data    *ld;
1526         struct sis_ring_data    *cd;
1527         int                     i,nexti;
1528
1529         ld = &sc->sis_ldata;
1530         cd = &sc->sis_cdata;
1531
1532         for (i = 0; i < SIS_RX_LIST_CNT; i++) {
1533                 if (sis_newbuf(sc, &ld->sis_rx_list[i], NULL) == ENOBUFS)
1534                         return(ENOBUFS);
1535                 nexti = (i == (SIS_RX_LIST_CNT - 1)) ? 0 : i+1;
1536                         ld->sis_rx_list[i].sis_nextdesc =
1537                             &ld->sis_rx_list[nexti];
1538                         bus_dmamap_load(sc->sis_ldata.sis_rx_tag,
1539                             sc->sis_ldata.sis_rx_dmamap,
1540                             &ld->sis_rx_list[nexti],
1541                             sizeof(struct sis_desc), sis_dma_map_desc_next,
1542                             &ld->sis_rx_list[i], 0);
1543                 }
1544
1545         bus_dmamap_sync(sc->sis_ldata.sis_rx_tag,
1546             sc->sis_ldata.sis_rx_dmamap, BUS_DMASYNC_PREWRITE);
1547
1548         cd->sis_rx_prod = 0;
1549
1550         return(0);
1551 }
1552
1553 /*
1554  * Initialize an RX descriptor and attach an MBUF cluster.
1555  */
1556 static int
1557 sis_newbuf(sc, c, m)
1558         struct sis_softc        *sc;
1559         struct sis_desc         *c;
1560         struct mbuf             *m;
1561 {
1562
1563         if (c == NULL)
1564                 return(EINVAL);
1565
1566         if (m == NULL) {
1567                 m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
1568                 if (m == NULL)
1569                         return(ENOBUFS);
1570         } else
1571                 m->m_data = m->m_ext.ext_buf;
1572
1573         c->sis_mbuf = m;
1574         c->sis_ctl = SIS_RXLEN;
1575
1576         bus_dmamap_create(sc->sis_tag, 0, &c->sis_map);
1577         bus_dmamap_load(sc->sis_tag, c->sis_map,
1578             mtod(m, void *), MCLBYTES,
1579             sis_dma_map_desc_ptr, c, 0);
1580         bus_dmamap_sync(sc->sis_tag, c->sis_map, BUS_DMASYNC_PREWRITE);
1581
1582         return(0);
1583 }
1584
1585 /*
1586  * A frame has been uploaded: pass the resulting mbuf chain up to
1587  * the higher level protocols.
1588  */
1589 static void
1590 sis_rxeof(sc)
1591         struct sis_softc        *sc;
1592 {
1593         struct mbuf             *m;
1594         struct ifnet            *ifp;
1595         struct sis_desc         *cur_rx;
1596         int                     i, total_len = 0;
1597         u_int32_t               rxstat;
1598
1599         ifp = &sc->arpcom.ac_if;
1600         i = sc->sis_cdata.sis_rx_prod;
1601
1602         while(SIS_OWNDESC(&sc->sis_ldata.sis_rx_list[i])) {
1603
1604 #ifdef DEVICE_POLLING
1605                 if (ifp->if_flags & IFF_POLLING) {
1606                         if (sc->rxcycles <= 0)
1607                                 break;
1608                         sc->rxcycles--;
1609                 }
1610 #endif /* DEVICE_POLLING */
1611                 cur_rx = &sc->sis_ldata.sis_rx_list[i];
1612                 rxstat = cur_rx->sis_rxstat;
1613                 bus_dmamap_sync(sc->sis_tag,
1614                     cur_rx->sis_map, BUS_DMASYNC_POSTWRITE);
1615                 bus_dmamap_unload(sc->sis_tag, cur_rx->sis_map);
1616                 bus_dmamap_destroy(sc->sis_tag, cur_rx->sis_map);
1617                 m = cur_rx->sis_mbuf;
1618                 cur_rx->sis_mbuf = NULL;
1619                 total_len = SIS_RXBYTES(cur_rx);
1620                 SIS_INC(i, SIS_RX_LIST_CNT);
1621
1622                 /*
1623                  * If an error occurs, update stats, clear the
1624                  * status word and leave the mbuf cluster in place:
1625                  * it should simply get re-used next time this descriptor
1626                  * comes up in the ring.
1627                  */
1628                 if (!(rxstat & SIS_CMDSTS_PKT_OK)) {
1629                         ifp->if_ierrors++;
1630                         if (rxstat & SIS_RXSTAT_COLL)
1631                                 ifp->if_collisions++;
1632                         sis_newbuf(sc, cur_rx, m);
1633                         continue;
1634                 }
1635
1636                 /* No errors; receive the packet. */
1637 #ifdef __i386__
1638                 /*
1639                  * On the x86 we do not have alignment problems, so try to
1640                  * allocate a new buffer for the receive ring, and pass up
1641                  * the one where the packet is already, saving the expensive
1642                  * copy done in m_devget().
1643                  * If we are on an architecture with alignment problems, or
1644                  * if the allocation fails, then use m_devget and leave the
1645                  * existing buffer in the receive ring.
1646                  */
1647                 if (sis_newbuf(sc, cur_rx, NULL) == 0)
1648                         m->m_pkthdr.len = m->m_len = total_len;
1649                 else
1650 #endif
1651                 {
1652                         struct mbuf             *m0;
1653                         m0 = m_devget(mtod(m, char *), total_len,
1654                                 ETHER_ALIGN, ifp, NULL);
1655                         sis_newbuf(sc, cur_rx, m);
1656                         if (m0 == NULL) {
1657                                 ifp->if_ierrors++;
1658                                 continue;
1659                         }
1660                         m = m0;
1661                 }
1662
1663                 ifp->if_ipackets++;
1664                 m->m_pkthdr.rcvif = ifp;
1665
1666                 (*ifp->if_input)(ifp, m);
1667         }
1668
1669         sc->sis_cdata.sis_rx_prod = i;
1670
1671         return;
1672 }
1673
1674 static void
1675 sis_rxeoc(sc)
1676         struct sis_softc        *sc;
1677 {
1678         sis_rxeof(sc);
1679         sis_init(sc);
1680         return;
1681 }
1682
1683 /*
1684  * A frame was downloaded to the chip. It's safe for us to clean up
1685  * the list buffers.
1686  */
1687
1688 static void
1689 sis_txeof(sc)
1690         struct sis_softc        *sc;
1691 {
1692         struct ifnet            *ifp;
1693         u_int32_t               idx;
1694
1695         ifp = &sc->arpcom.ac_if;
1696
1697         /*
1698          * Go through our tx list and free mbufs for those
1699          * frames that have been transmitted.
1700          */
1701         for (idx = sc->sis_cdata.sis_tx_cons; sc->sis_cdata.sis_tx_cnt > 0;
1702             sc->sis_cdata.sis_tx_cnt--, SIS_INC(idx, SIS_TX_LIST_CNT) ) {
1703                 struct sis_desc *cur_tx = &sc->sis_ldata.sis_tx_list[idx];
1704
1705                 if (SIS_OWNDESC(cur_tx))
1706                         break;
1707
1708                 if (cur_tx->sis_ctl & SIS_CMDSTS_MORE)
1709                         continue;
1710
1711                 if (!(cur_tx->sis_ctl & SIS_CMDSTS_PKT_OK)) {
1712                         ifp->if_oerrors++;
1713                         if (cur_tx->sis_txstat & SIS_TXSTAT_EXCESSCOLLS)
1714                                 ifp->if_collisions++;
1715                         if (cur_tx->sis_txstat & SIS_TXSTAT_OUTOFWINCOLL)
1716                                 ifp->if_collisions++;
1717                 }
1718
1719                 ifp->if_collisions +=
1720                     (cur_tx->sis_txstat & SIS_TXSTAT_COLLCNT) >> 16;
1721
1722                 ifp->if_opackets++;
1723                 if (cur_tx->sis_mbuf != NULL) {
1724                         m_freem(cur_tx->sis_mbuf);
1725                         cur_tx->sis_mbuf = NULL;
1726                         bus_dmamap_unload(sc->sis_tag, cur_tx->sis_map);
1727                         bus_dmamap_destroy(sc->sis_tag, cur_tx->sis_map);
1728                 }
1729         }
1730
1731         if (idx != sc->sis_cdata.sis_tx_cons) {
1732                 /* we freed up some buffers */
1733                 sc->sis_cdata.sis_tx_cons = idx;
1734                 ifp->if_flags &= ~IFF_OACTIVE;
1735         }
1736
1737         ifp->if_timer = (sc->sis_cdata.sis_tx_cnt == 0) ? 0 : 5;
1738
1739         return;
1740 }
1741
1742 static void
1743 sis_tick(xsc)
1744         void                    *xsc;
1745 {
1746         struct sis_softc        *sc;
1747         struct mii_data         *mii;
1748         struct ifnet            *ifp;
1749
1750         sc = xsc;
1751         SIS_LOCK(sc);
1752         sc->in_tick = 1;
1753         ifp = &sc->arpcom.ac_if;
1754
1755         mii = device_get_softc(sc->sis_miibus);
1756         mii_tick(mii);
1757
1758         if (!sc->sis_link && mii->mii_media_status & IFM_ACTIVE &&
1759             IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1760                 sc->sis_link++;
1761                 if (ifp->if_snd.ifq_head != NULL)
1762                         sis_start(ifp);
1763         }
1764
1765         callout_reset(&sc->sis_stat_ch, hz,  sis_tick, sc);
1766         sc->in_tick = 0;
1767         SIS_UNLOCK(sc);
1768
1769         return;
1770 }
1771
1772 #ifdef DEVICE_POLLING
1773 static poll_handler_t sis_poll;
1774
1775 static void
1776 sis_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1777 {
1778         struct  sis_softc *sc = ifp->if_softc;
1779
1780         SIS_LOCK(sc);
1781         if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */
1782                 CSR_WRITE_4(sc, SIS_IER, 1);
1783                 goto done;
1784         }
1785
1786         /*
1787          * On the sis, reading the status register also clears it.
1788          * So before returning to intr mode we must make sure that all
1789          * possible pending sources of interrupts have been served.
1790          * In practice this means run to completion the *eof routines,
1791          * and then call the interrupt routine
1792          */
1793         sc->rxcycles = count;
1794         sis_rxeof(sc);
1795         sis_txeof(sc);
1796         if (ifp->if_snd.ifq_head != NULL)
1797                 sis_start(ifp);
1798
1799         if (sc->rxcycles > 0 || cmd == POLL_AND_CHECK_STATUS) {
1800                 u_int32_t       status;
1801
1802                 /* Reading the ISR register clears all interrupts. */
1803                 status = CSR_READ_4(sc, SIS_ISR);
1804
1805                 if (status & (SIS_ISR_RX_ERR|SIS_ISR_RX_OFLOW))
1806                         sis_rxeoc(sc);
1807
1808                 if (status & (SIS_ISR_RX_IDLE))
1809                         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
1810
1811                 if (status & SIS_ISR_SYSERR) {
1812                         sis_reset(sc);
1813                         sis_init(sc);
1814                 }
1815         }
1816 done:
1817         SIS_UNLOCK(sc);
1818         return;
1819 }
1820 #endif /* DEVICE_POLLING */
1821
1822 static void
1823 sis_intr(arg)
1824         void                    *arg;
1825 {
1826         struct sis_softc        *sc;
1827         struct ifnet            *ifp;
1828         u_int32_t               status;
1829
1830         sc = arg;
1831         ifp = &sc->arpcom.ac_if;
1832
1833         SIS_LOCK(sc);
1834 #ifdef DEVICE_POLLING
1835         if (ifp->if_flags & IFF_POLLING)
1836                 goto done;
1837         if (ether_poll_register(sis_poll, ifp)) { /* ok, disable interrupts */
1838                 CSR_WRITE_4(sc, SIS_IER, 0);
1839                 goto done;
1840         }
1841 #endif /* DEVICE_POLLING */
1842
1843         /* Supress unwanted interrupts */
1844         if (!(ifp->if_flags & IFF_UP)) {
1845                 sis_stop(sc);
1846                 goto done;
1847         }
1848
1849         /* Disable interrupts. */
1850         CSR_WRITE_4(sc, SIS_IER, 0);
1851
1852         for (;;) {
1853                 /* Reading the ISR register clears all interrupts. */
1854                 status = CSR_READ_4(sc, SIS_ISR);
1855
1856                 if ((status & SIS_INTRS) == 0)
1857                         break;
1858
1859                 if (status &
1860                     (SIS_ISR_TX_DESC_OK | SIS_ISR_TX_ERR |
1861                      SIS_ISR_TX_OK | SIS_ISR_TX_IDLE) )
1862                         sis_txeof(sc);
1863
1864                 if (status & (SIS_ISR_RX_DESC_OK|SIS_ISR_RX_OK|SIS_ISR_RX_IDLE))
1865                         sis_rxeof(sc);
1866
1867                 if (status & (SIS_ISR_RX_ERR | SIS_ISR_RX_OFLOW))
1868                         sis_rxeoc(sc);
1869
1870                 if (status & (SIS_ISR_RX_IDLE))
1871                         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
1872
1873                 if (status & SIS_ISR_SYSERR) {
1874                         sis_reset(sc);
1875                         sis_init(sc);
1876                 }
1877         }
1878
1879         /* Re-enable interrupts. */
1880         CSR_WRITE_4(sc, SIS_IER, 1);
1881
1882         if (ifp->if_snd.ifq_head != NULL)
1883                 sis_start(ifp);
1884 done:
1885         SIS_UNLOCK(sc);
1886
1887         return;
1888 }
1889
1890 /*
1891  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
1892  * pointers to the fragment pointers.
1893  */
1894 static int
1895 sis_encap(sc, m_head, txidx)
1896         struct sis_softc        *sc;
1897         struct mbuf             **m_head;
1898         u_int32_t               *txidx;
1899 {
1900         struct sis_desc         *f = NULL;
1901         struct mbuf             *m;
1902         int                     frag, cur, cnt = 0, chainlen = 0;
1903
1904         /*
1905          * If there's no way we can send any packets, return now.
1906          */
1907         if (SIS_TX_LIST_CNT - sc->sis_cdata.sis_tx_cnt < 2)
1908                 return (ENOBUFS);
1909
1910         /*
1911          * Count the number of frags in this chain to see if
1912          * we need to m_defrag.  Since the descriptor list is shared
1913          * by all packets, we'll m_defrag long chains so that they
1914          * do not use up the entire list, even if they would fit.
1915          */
1916
1917         for (m = *m_head; m != NULL; m = m->m_next)
1918                 chainlen++;
1919
1920         if ((chainlen > SIS_TX_LIST_CNT / 4) ||
1921             ((SIS_TX_LIST_CNT - (chainlen + sc->sis_cdata.sis_tx_cnt)) < 2)) {
1922                 m = m_defrag(*m_head, M_DONTWAIT);
1923                 if (m == NULL)
1924                         return (ENOBUFS);
1925                 *m_head = m;
1926         }
1927
1928         /*
1929          * Start packing the mbufs in this chain into
1930          * the fragment pointers. Stop when we run out
1931          * of fragments or hit the end of the mbuf chain.
1932          */
1933         cur = frag = *txidx;
1934
1935         for (m = *m_head; m != NULL; m = m->m_next) {
1936                 if (m->m_len != 0) {
1937                         if ((SIS_TX_LIST_CNT -
1938                             (sc->sis_cdata.sis_tx_cnt + cnt)) < 2)
1939                                 return(ENOBUFS);
1940                         f = &sc->sis_ldata.sis_tx_list[frag];
1941                         f->sis_ctl = SIS_CMDSTS_MORE | m->m_len;
1942                         bus_dmamap_create(sc->sis_tag, 0, &f->sis_map);
1943                         bus_dmamap_load(sc->sis_tag, f->sis_map,
1944                             mtod(m, void *), m->m_len,
1945                             sis_dma_map_desc_ptr, f, 0);
1946                         bus_dmamap_sync(sc->sis_tag,
1947                             f->sis_map, BUS_DMASYNC_PREREAD);
1948                         if (cnt != 0)
1949                                 f->sis_ctl |= SIS_CMDSTS_OWN;
1950                         cur = frag;
1951                         SIS_INC(frag, SIS_TX_LIST_CNT);
1952                         cnt++;
1953                 }
1954         }
1955
1956         if (m != NULL)
1957                 return(ENOBUFS);
1958
1959         sc->sis_ldata.sis_tx_list[cur].sis_mbuf = *m_head;
1960         sc->sis_ldata.sis_tx_list[cur].sis_ctl &= ~SIS_CMDSTS_MORE;
1961         sc->sis_ldata.sis_tx_list[*txidx].sis_ctl |= SIS_CMDSTS_OWN;
1962         sc->sis_cdata.sis_tx_cnt += cnt;
1963         *txidx = frag;
1964
1965         return(0);
1966 }
1967
1968 /*
1969  * Main transmit routine. To avoid having to do mbuf copies, we put pointers
1970  * to the mbuf data regions directly in the transmit lists. We also save a
1971  * copy of the pointers since the transmit list fragment pointers are
1972  * physical addresses.
1973  */
1974
1975 static void
1976 sis_start(ifp)
1977         struct ifnet            *ifp;
1978 {
1979         struct sis_softc        *sc;
1980         struct mbuf             *m_head = NULL;
1981         u_int32_t               idx;
1982
1983         sc = ifp->if_softc;
1984         SIS_LOCK(sc);
1985
1986         if (!sc->sis_link) {
1987                 SIS_UNLOCK(sc);
1988                 return;
1989         }
1990
1991         idx = sc->sis_cdata.sis_tx_prod;
1992
1993         if (ifp->if_flags & IFF_OACTIVE) {
1994                 SIS_UNLOCK(sc);
1995                 return;
1996         }
1997
1998         while(sc->sis_ldata.sis_tx_list[idx].sis_mbuf == NULL) {
1999                 IF_DEQUEUE(&ifp->if_snd, m_head);
2000                 if (m_head == NULL)
2001                         break;
2002
2003                 if (sis_encap(sc, &m_head, &idx)) {
2004                         IF_PREPEND(&ifp->if_snd, m_head);
2005                         ifp->if_flags |= IFF_OACTIVE;
2006                         break;
2007                 }
2008
2009                 /*
2010                  * If there's a BPF listener, bounce a copy of this frame
2011                  * to him.
2012                  */
2013                 BPF_MTAP(ifp, m_head);
2014
2015         }
2016
2017         /* Transmit */
2018         sc->sis_cdata.sis_tx_prod = idx;
2019         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_TX_ENABLE);
2020
2021         /*
2022          * Set a timeout in case the chip goes out to lunch.
2023          */
2024         ifp->if_timer = 5;
2025
2026         SIS_UNLOCK(sc);
2027
2028         return;
2029 }
2030
2031 static void
2032 sis_init(xsc)
2033         void                    *xsc;
2034 {
2035         struct sis_softc        *sc = xsc;
2036         struct ifnet            *ifp = &sc->arpcom.ac_if;
2037         struct mii_data         *mii;
2038
2039         SIS_LOCK(sc);
2040
2041         /*
2042          * Cancel pending I/O and free all RX/TX buffers.
2043          */
2044         sis_stop(sc);
2045
2046 #ifdef notyet
2047         if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr >= NS_SRR_16A) {
2048                 /*
2049                  * Configure 400usec of interrupt holdoff.  This is based
2050                  * on emperical tests on a Soekris 4801.
2051                  */
2052                 CSR_WRITE_4(sc, NS_IHR, 0x100 | 4);
2053         }
2054 #endif
2055
2056         mii = device_get_softc(sc->sis_miibus);
2057
2058         /* Set MAC address */
2059         if (sc->sis_type == SIS_TYPE_83815) {
2060                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR0);
2061                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2062                     ((u_int16_t *)sc->arpcom.ac_enaddr)[0]);
2063                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR1);
2064                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2065                     ((u_int16_t *)sc->arpcom.ac_enaddr)[1]);
2066                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, NS_FILTADDR_PAR2);
2067                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2068                     ((u_int16_t *)sc->arpcom.ac_enaddr)[2]);
2069         } else {
2070                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR0);
2071                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2072                     ((u_int16_t *)sc->arpcom.ac_enaddr)[0]);
2073                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR1);
2074                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2075                     ((u_int16_t *)sc->arpcom.ac_enaddr)[1]);
2076                 CSR_WRITE_4(sc, SIS_RXFILT_CTL, SIS_FILTADDR_PAR2);
2077                 CSR_WRITE_4(sc, SIS_RXFILT_DATA,
2078                     ((u_int16_t *)sc->arpcom.ac_enaddr)[2]);
2079         }
2080
2081         /* Init circular RX list. */
2082         if (sis_list_rx_init(sc) == ENOBUFS) {
2083                 printf("sis%d: initialization failed: no "
2084                         "memory for rx buffers\n", sc->sis_unit);
2085                 sis_stop(sc);
2086                 SIS_UNLOCK(sc);
2087                 return;
2088         }
2089
2090         /*
2091          * Init tx descriptors.
2092          */
2093         sis_list_tx_init(sc);
2094
2095         /*
2096          * For the NatSemi chip, we have to explicitly enable the
2097          * reception of ARP frames, as well as turn on the 'perfect
2098          * match' filter where we store the station address, otherwise
2099          * we won't receive unicasts meant for this host.
2100          */
2101         if (sc->sis_type == SIS_TYPE_83815) {
2102                 SIS_SETBIT(sc, SIS_RXFILT_CTL, NS_RXFILTCTL_ARP);
2103                 SIS_SETBIT(sc, SIS_RXFILT_CTL, NS_RXFILTCTL_PERFECT);
2104         }
2105
2106          /* If we want promiscuous mode, set the allframes bit. */
2107         if (ifp->if_flags & IFF_PROMISC) {
2108                 SIS_SETBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_ALLPHYS);
2109         } else {
2110                 SIS_CLRBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_ALLPHYS);
2111         }
2112
2113         /*
2114          * Set the capture broadcast bit to capture broadcast frames.
2115          */
2116         if (ifp->if_flags & IFF_BROADCAST) {
2117                 SIS_SETBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_BROAD);
2118         } else {
2119                 SIS_CLRBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_BROAD);
2120         }
2121
2122         /*
2123          * Load the multicast filter.
2124          */
2125         if (sc->sis_type == SIS_TYPE_83815)
2126                 sis_setmulti_ns(sc);
2127         else
2128                 sis_setmulti_sis(sc);
2129
2130         /* Turn the receive filter on */
2131         SIS_SETBIT(sc, SIS_RXFILT_CTL, SIS_RXFILTCTL_ENABLE);
2132
2133         /*
2134          * Load the address of the RX and TX lists.
2135          */
2136         CSR_WRITE_4(sc, SIS_RX_LISTPTR, sc->sis_cdata.sis_rx_paddr);
2137         CSR_WRITE_4(sc, SIS_TX_LISTPTR, sc->sis_cdata.sis_tx_paddr);
2138
2139         /* SIS_CFG_EDB_MASTER_EN indicates the EDB bus is used instead of
2140          * the PCI bus. When this bit is set, the Max DMA Burst Size
2141          * for TX/RX DMA should be no larger than 16 double words.
2142          */
2143         if (CSR_READ_4(sc, SIS_CFG) & SIS_CFG_EDB_MASTER_EN) {
2144                 CSR_WRITE_4(sc, SIS_RX_CFG, SIS_RXCFG64);
2145         } else {
2146                 CSR_WRITE_4(sc, SIS_RX_CFG, SIS_RXCFG256);
2147         }
2148
2149
2150         /* Accept Long Packets for VLAN support */
2151         SIS_SETBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_JABBER);
2152
2153         /* Set TX configuration */
2154         if (IFM_SUBTYPE(mii->mii_media_active) == IFM_10_T) {
2155                 CSR_WRITE_4(sc, SIS_TX_CFG, SIS_TXCFG_10);
2156         } else {
2157                 CSR_WRITE_4(sc, SIS_TX_CFG, SIS_TXCFG_100);
2158         }
2159
2160         /* Set full/half duplex mode. */
2161         if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) {
2162                 SIS_SETBIT(sc, SIS_TX_CFG,
2163                     (SIS_TXCFG_IGN_HBEAT|SIS_TXCFG_IGN_CARR));
2164                 SIS_SETBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_TXPKTS);
2165         } else {
2166                 SIS_CLRBIT(sc, SIS_TX_CFG,
2167                     (SIS_TXCFG_IGN_HBEAT|SIS_TXCFG_IGN_CARR));
2168                 SIS_CLRBIT(sc, SIS_RX_CFG, SIS_RXCFG_RX_TXPKTS);
2169         }
2170
2171         if (sc->sis_type == SIS_TYPE_83815 && sc->sis_srr < NS_SRR_16A &&
2172              IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) {
2173                 uint32_t reg;
2174
2175                 /*
2176                  * Some DP83815s experience problems when used with short
2177                  * (< 30m/100ft) Ethernet cables in 100BaseTX mode.  This
2178                  * sequence adjusts the DSP's signal attenuation to fix the
2179                  * problem.
2180                  */
2181                 CSR_WRITE_4(sc, NS_PHY_PAGE, 0x0001);
2182
2183                 reg = CSR_READ_4(sc, NS_PHY_DSPCFG);
2184                 CSR_WRITE_4(sc, NS_PHY_DSPCFG, (reg & 0xfff) | 0x1000);
2185                 DELAY(100);
2186                 reg = CSR_READ_4(sc, NS_PHY_TDATA);
2187                 if ((reg & 0x0080) == 0 || (reg & 0xff) >= 0xd8) {
2188                         device_printf(sc->sis_self, "Applying short cable fix (reg=%x)\n", reg);
2189                         CSR_WRITE_4(sc, NS_PHY_TDATA, 0x00e8);
2190                         SIS_SETBIT(sc, NS_PHY_DSPCFG, 0x20);
2191                 }
2192                 CSR_WRITE_4(sc, NS_PHY_PAGE, 0);
2193         }
2194
2195         /*
2196          * Enable interrupts.
2197          */
2198         CSR_WRITE_4(sc, SIS_IMR, SIS_INTRS);
2199 #ifdef DEVICE_POLLING
2200         /*
2201          * ... only enable interrupts if we are not polling, make sure
2202          * they are off otherwise.
2203          */
2204         if (ifp->if_flags & IFF_POLLING)
2205                 CSR_WRITE_4(sc, SIS_IER, 0);
2206         else
2207 #endif /* DEVICE_POLLING */
2208         CSR_WRITE_4(sc, SIS_IER, 1);
2209
2210         /* Enable receiver and transmitter. */
2211         SIS_CLRBIT(sc, SIS_CSR, SIS_CSR_TX_DISABLE|SIS_CSR_RX_DISABLE);
2212         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_RX_ENABLE);
2213
2214 #ifdef notdef
2215         mii_mediachg(mii);
2216 #endif
2217
2218         /*
2219          * Page 75 of the DP83815 manual recommends the
2220          * following register settings "for optimum
2221          * performance." Note however that at least three
2222          * of the registers are listed as "reserved" in
2223          * the register map, so who knows what they do.
2224          */
2225         if (sc->sis_type == SIS_TYPE_83815) {
2226                 CSR_WRITE_4(sc, NS_PHY_PAGE, 0x0001);
2227                 CSR_WRITE_4(sc, NS_PHY_CR, 0x189C);
2228                 CSR_WRITE_4(sc, NS_PHY_TDATA, 0x0000);
2229                 CSR_WRITE_4(sc, NS_PHY_DSPCFG, 0x5040);
2230                 CSR_WRITE_4(sc, NS_PHY_SDCFG, 0x008C);
2231         }
2232
2233         ifp->if_flags |= IFF_RUNNING;
2234         ifp->if_flags &= ~IFF_OACTIVE;
2235
2236         if (!sc->in_tick)
2237                 callout_reset(&sc->sis_stat_ch, hz,  sis_tick, sc);
2238
2239         SIS_UNLOCK(sc);
2240
2241         return;
2242 }
2243
2244 /*
2245  * Set media options.
2246  */
2247 static int
2248 sis_ifmedia_upd(ifp)
2249         struct ifnet            *ifp;
2250 {
2251         struct sis_softc        *sc;
2252         struct mii_data         *mii;
2253
2254         sc = ifp->if_softc;
2255
2256         mii = device_get_softc(sc->sis_miibus);
2257         sc->sis_link = 0;
2258         if (mii->mii_instance) {
2259                 struct mii_softc        *miisc;
2260                 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
2261                         mii_phy_reset(miisc);
2262         }
2263         mii_mediachg(mii);
2264
2265         return(0);
2266 }
2267
2268 /*
2269  * Report current media status.
2270  */
2271 static void
2272 sis_ifmedia_sts(ifp, ifmr)
2273         struct ifnet            *ifp;
2274         struct ifmediareq       *ifmr;
2275 {
2276         struct sis_softc        *sc;
2277         struct mii_data         *mii;
2278
2279         sc = ifp->if_softc;
2280
2281         mii = device_get_softc(sc->sis_miibus);
2282         mii_pollstat(mii);
2283         ifmr->ifm_active = mii->mii_media_active;
2284         ifmr->ifm_status = mii->mii_media_status;
2285
2286         return;
2287 }
2288
2289 static int
2290 sis_ioctl(ifp, command, data)
2291         struct ifnet            *ifp;
2292         u_long                  command;
2293         caddr_t                 data;
2294 {
2295         struct sis_softc        *sc = ifp->if_softc;
2296         struct ifreq            *ifr = (struct ifreq *) data;
2297         struct mii_data         *mii;
2298         int                     error = 0;
2299
2300         switch(command) {
2301         case SIOCSIFFLAGS:
2302                 if (ifp->if_flags & IFF_UP) {
2303                         sis_init(sc);
2304                 } else {
2305                         if (ifp->if_flags & IFF_RUNNING)
2306                                 sis_stop(sc);
2307                 }
2308                 error = 0;
2309                 break;
2310         case SIOCADDMULTI:
2311         case SIOCDELMULTI:
2312                 SIS_LOCK(sc);
2313                 if (sc->sis_type == SIS_TYPE_83815)
2314                         sis_setmulti_ns(sc);
2315                 else
2316                         sis_setmulti_sis(sc);
2317                 SIS_UNLOCK(sc);
2318                 error = 0;
2319                 break;
2320         case SIOCGIFMEDIA:
2321         case SIOCSIFMEDIA:
2322                 mii = device_get_softc(sc->sis_miibus);
2323                 SIS_LOCK(sc);
2324                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
2325                 SIS_UNLOCK(sc);
2326                 break;
2327         default:
2328                 error = ether_ioctl(ifp, command, data);
2329                 break;
2330         }
2331
2332         return(error);
2333 }
2334
2335 static void
2336 sis_watchdog(ifp)
2337         struct ifnet            *ifp;
2338 {
2339         struct sis_softc        *sc;
2340
2341         sc = ifp->if_softc;
2342
2343         SIS_LOCK(sc);
2344
2345         ifp->if_oerrors++;
2346         printf("sis%d: watchdog timeout\n", sc->sis_unit);
2347
2348         sis_stop(sc);
2349         sis_reset(sc);
2350         sis_init(sc);
2351
2352         if (ifp->if_snd.ifq_head != NULL)
2353                 sis_start(ifp);
2354
2355         SIS_UNLOCK(sc);
2356
2357         return;
2358 }
2359
2360 /*
2361  * Stop the adapter and free any mbufs allocated to the
2362  * RX and TX lists.
2363  */
2364 static void
2365 sis_stop(sc)
2366         struct sis_softc        *sc;
2367 {
2368         register int            i;
2369         struct ifnet            *ifp;
2370
2371         SIS_LOCK(sc);
2372         ifp = &sc->arpcom.ac_if;
2373         ifp->if_timer = 0;
2374
2375         callout_stop(&sc->sis_stat_ch);
2376
2377         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2378 #ifdef DEVICE_POLLING
2379         ether_poll_deregister(ifp);
2380 #endif
2381         CSR_WRITE_4(sc, SIS_IER, 0);
2382         CSR_WRITE_4(sc, SIS_IMR, 0);
2383         SIS_SETBIT(sc, SIS_CSR, SIS_CSR_TX_DISABLE|SIS_CSR_RX_DISABLE);
2384         DELAY(1000);
2385         CSR_WRITE_4(sc, SIS_TX_LISTPTR, 0);
2386         CSR_WRITE_4(sc, SIS_RX_LISTPTR, 0);
2387
2388         sc->sis_link = 0;
2389
2390         /*
2391          * Free data in the RX lists.
2392          */
2393         for (i = 0; i < SIS_RX_LIST_CNT; i++) {
2394                 if (sc->sis_ldata.sis_rx_list[i].sis_mbuf != NULL) {
2395                         bus_dmamap_unload(sc->sis_tag,
2396                             sc->sis_ldata.sis_rx_list[i].sis_map);
2397                         bus_dmamap_destroy(sc->sis_tag,
2398                             sc->sis_ldata.sis_rx_list[i].sis_map);
2399                         m_freem(sc->sis_ldata.sis_rx_list[i].sis_mbuf);
2400                         sc->sis_ldata.sis_rx_list[i].sis_mbuf = NULL;
2401                 }
2402         }
2403         bzero(sc->sis_ldata.sis_rx_list,
2404                 sizeof(sc->sis_ldata.sis_rx_list));
2405
2406         /*
2407          * Free the TX list buffers.
2408          */
2409         for (i = 0; i < SIS_TX_LIST_CNT; i++) {
2410                 if (sc->sis_ldata.sis_tx_list[i].sis_mbuf != NULL) {
2411                         bus_dmamap_unload(sc->sis_tag,
2412                             sc->sis_ldata.sis_tx_list[i].sis_map);
2413                         bus_dmamap_destroy(sc->sis_tag,
2414                             sc->sis_ldata.sis_tx_list[i].sis_map);
2415                         m_freem(sc->sis_ldata.sis_tx_list[i].sis_mbuf);
2416                         sc->sis_ldata.sis_tx_list[i].sis_mbuf = NULL;
2417                 }
2418         }
2419
2420         bzero(sc->sis_ldata.sis_tx_list,
2421                 sizeof(sc->sis_ldata.sis_tx_list));
2422
2423         SIS_UNLOCK(sc);
2424
2425         return;
2426 }
2427
2428 /*
2429  * Stop all chip I/O so that the kernel's probe routines don't
2430  * get confused by errant DMAs when rebooting.
2431  */
2432 static void
2433 sis_shutdown(dev)
2434         device_t                dev;
2435 {
2436         struct sis_softc        *sc;
2437
2438         sc = device_get_softc(dev);
2439         SIS_LOCK(sc);
2440         sis_reset(sc);
2441         sis_stop(sc);
2442         SIS_UNLOCK(sc);
2443
2444         return;
2445 }