sys/dev/cas/if_cas.c

   1 /*-
   2  * Copyright (C) 2001 Eduardo Horvath.
   3  * Copyright (c) 2001-2003 Thomas Moestl
   4  * Copyright (c) 2007-2009 Marius Strobl <marius@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR  BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *      from: NetBSD: gem.c,v 1.21 2002/06/01 23:50:58 lukem Exp
  29  *      from: FreeBSD: if_gem.c 182060 2008-08-23 15:03:26Z marius
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 /*
  36  * driver for Sun Cassini/Cassini+ and National Semiconductor DP83065
  37  * Saturn Gigabit Ethernet controllers
  38  */
  39
  40 #if 0
  41 #define CAS_DEBUG
  42 #endif
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/bus.h>
  47 #include <sys/callout.h>
  48 #include <sys/endian.h>
  49 #include <sys/mbuf.h>
  50 #include <sys/malloc.h>
  51 #include <sys/kernel.h>
  52 #include <sys/lock.h>
  53 #include <sys/module.h>
  54 #include <sys/mutex.h>
  55 #include <sys/refcount.h>
  56 #include <sys/resource.h>
  57 #include <sys/rman.h>
  58 #include <sys/socket.h>
  59 #include <sys/sockio.h>
  60 #include <sys/taskqueue.h>
  61
  62 #include <net/bpf.h>
  63 #include <net/ethernet.h>
  64 #include <net/if.h>
  65 #include <net/if_var.h>
  66 #include <net/if_arp.h>
  67 #include <net/if_dl.h>
  68 #include <net/if_media.h>
  69 #include <net/if_types.h>
  70 #include <net/if_vlan_var.h>
  71
  72 #include <netinet/in.h>
  73 #include <netinet/in_systm.h>
  74 #include <netinet/ip.h>
  75 #include <netinet/tcp.h>
  76 #include <netinet/udp.h>
  77
  78 #include <machine/bus.h>
  79 #if defined(__powerpc__) || defined(__sparc64__)
  80 #include <dev/ofw/ofw_bus.h>
  81 #include <dev/ofw/openfirm.h>
  82 #include <machine/ofw_machdep.h>
  83 #endif
  84 #include <machine/resource.h>
  85
  86 #include <dev/mii/mii.h>
  87 #include <dev/mii/miivar.h>
  88
  89 #include <dev/cas/if_casreg.h>
  90 #include <dev/cas/if_casvar.h>
  91
  92 #include <dev/pci/pcireg.h>
  93 #include <dev/pci/pcivar.h>
  94
  95 #include "miibus_if.h"
  96
  97 #define RINGASSERT(n , min, max)                                        \
  98         CTASSERT(powerof2(n) && (n) >= (min) && (n) <= (max))
  99
 100 RINGASSERT(CAS_NRXCOMP, 128, 32768);
 101 RINGASSERT(CAS_NRXDESC, 32, 8192);
 102 RINGASSERT(CAS_NRXDESC2, 32, 8192);
 103 RINGASSERT(CAS_NTXDESC, 32, 8192);
 104
 105 #undef RINGASSERT
 106
 107 #define CCDASSERT(m, a)                                                 \
 108         CTASSERT((offsetof(struct cas_control_data, m) & ((a) - 1)) == 0)
 109
 110 CCDASSERT(ccd_rxcomps, CAS_RX_COMP_ALIGN);
 111 CCDASSERT(ccd_rxdescs, CAS_RX_DESC_ALIGN);
 112 CCDASSERT(ccd_rxdescs2, CAS_RX_DESC_ALIGN);
 113
 114 #undef CCDASSERT
 115
 116 #define CAS_TRIES       10000
 117
 118 /*
 119  * According to documentation, the hardware has support for basic TCP
 120  * checksum offloading only, in practice this can be also used for UDP
 121  * however (i.e. the problem of previous Sun NICs that a checksum of 0x0
 122  * is not converted to 0xffff no longer exists).
 123  */
 124 #define CAS_CSUM_FEATURES       (CSUM_TCP | CSUM_UDP)
 125
 126 static inline void cas_add_rxdesc(struct cas_softc *sc, u_int idx);
 127 static int      cas_attach(struct cas_softc *sc);
 128 static int      cas_bitwait(struct cas_softc *sc, bus_addr_t r, uint32_t clr,
 129                     uint32_t set);
 130 static void     cas_cddma_callback(void *xsc, bus_dma_segment_t *segs,
 131                     int nsegs, int error);
 132 static void     cas_detach(struct cas_softc *sc);
 133 static int      cas_disable_rx(struct cas_softc *sc);
 134 static int      cas_disable_tx(struct cas_softc *sc);
 135 static void     cas_eint(struct cas_softc *sc, u_int status);
 136 static int      cas_free(struct mbuf *m, void *arg1, void* arg2);
 137 static void     cas_init(void *xsc);
 138 static void     cas_init_locked(struct cas_softc *sc);
 139 static void     cas_init_regs(struct cas_softc *sc);
 140 static int      cas_intr(void *v);
 141 static void     cas_intr_task(void *arg, int pending __unused);
 142 static int      cas_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
 143 static int      cas_load_txmbuf(struct cas_softc *sc, struct mbuf **m_head);
 144 static int      cas_mediachange(struct ifnet *ifp);
 145 static void     cas_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr);
 146 static void     cas_meminit(struct cas_softc *sc);
 147 static void     cas_mifinit(struct cas_softc *sc);
 148 static int      cas_mii_readreg(device_t dev, int phy, int reg);
 149 static void     cas_mii_statchg(device_t dev);
 150 static int      cas_mii_writereg(device_t dev, int phy, int reg, int val);
 151 static void     cas_reset(struct cas_softc *sc);
 152 static int      cas_reset_rx(struct cas_softc *sc);
 153 static int      cas_reset_tx(struct cas_softc *sc);
 154 static void     cas_resume(struct cas_softc *sc);
 155 static u_int    cas_descsize(u_int sz);
 156 static void     cas_rint(struct cas_softc *sc);
 157 static void     cas_rint_timeout(void *arg);
 158 static inline void cas_rxcksum(struct mbuf *m, uint16_t cksum);
 159 static inline void cas_rxcompinit(struct cas_rx_comp *rxcomp);
 160 static u_int    cas_rxcompsize(u_int sz);
 161 static void     cas_rxdma_callback(void *xsc, bus_dma_segment_t *segs,
 162                     int nsegs, int error);
 163 static void     cas_setladrf(struct cas_softc *sc);
 164 static void     cas_start(struct ifnet *ifp);
 165 static void     cas_stop(struct ifnet *ifp);
 166 static void     cas_suspend(struct cas_softc *sc);
 167 static void     cas_tick(void *arg);
 168 static void     cas_tint(struct cas_softc *sc);
 169 static void     cas_tx_task(void *arg, int pending __unused);
 170 static inline void cas_txkick(struct cas_softc *sc);
 171 static void     cas_watchdog(struct cas_softc *sc);
 172
 173 static devclass_t cas_devclass;
 174
 175 MODULE_DEPEND(cas, ether, 1, 1, 1);
 176 MODULE_DEPEND(cas, miibus, 1, 1, 1);
 177
 178 #ifdef CAS_DEBUG
 179 #include <sys/ktr.h>
 180 #define KTR_CAS         KTR_SPARE2
 181 #endif
 182
 183 static int
 184 cas_attach(struct cas_softc *sc)
 185 {
 186         struct cas_txsoft *txs;
 187         struct ifnet *ifp;
 188         int error, i;
 189         uint32_t v;
 190
 191         /* Set up ifnet structure. */
 192         ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
 193         if (ifp == NULL)
 194                 return (ENOSPC);
 195         ifp->if_softc = sc;
 196         if_initname(ifp, device_get_name(sc->sc_dev),
 197             device_get_unit(sc->sc_dev));
 198         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 199         ifp->if_start = cas_start;
 200         ifp->if_ioctl = cas_ioctl;
 201         ifp->if_init = cas_init;
 202         IFQ_SET_MAXLEN(&ifp->if_snd, CAS_TXQUEUELEN);
 203         ifp->if_snd.ifq_drv_maxlen = CAS_TXQUEUELEN;
 204         IFQ_SET_READY(&ifp->if_snd);
 205
 206         callout_init_mtx(&sc->sc_tick_ch, &sc->sc_mtx, 0);
 207         callout_init_mtx(&sc->sc_rx_ch, &sc->sc_mtx, 0);
 208         /* Create local taskq. */
 209         TASK_INIT(&sc->sc_intr_task, 0, cas_intr_task, sc);
 210         TASK_INIT(&sc->sc_tx_task, 1, cas_tx_task, ifp);
 211         sc->sc_tq = taskqueue_create_fast("cas_taskq", M_WAITOK,
 212             taskqueue_thread_enqueue, &sc->sc_tq);
 213         if (sc->sc_tq == NULL) {
 214                 device_printf(sc->sc_dev, "could not create taskqueue\n");
 215                 error = ENXIO;
 216                 goto fail_ifnet;
 217         }
 218         error = taskqueue_start_threads(&sc->sc_tq, 1, PI_NET, "%s taskq",
 219             device_get_nameunit(sc->sc_dev));
 220         if (error != 0) {
 221                 device_printf(sc->sc_dev, "could not start threads\n");
 222                 goto fail_taskq;
 223         }
 224
 225         /* Make sure the chip is stopped. */
 226         cas_reset(sc);
 227
 228         error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0,
 229             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 230             BUS_SPACE_MAXSIZE, 0, BUS_SPACE_MAXSIZE, 0, NULL, NULL,
 231             &sc->sc_pdmatag);
 232         if (error != 0)
 233                 goto fail_taskq;
 234
 235         error = bus_dma_tag_create(sc->sc_pdmatag, 1, 0,
 236             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 237             CAS_PAGE_SIZE, 1, CAS_PAGE_SIZE, 0, NULL, NULL, &sc->sc_rdmatag);
 238         if (error != 0)
 239                 goto fail_ptag;
 240
 241         error = bus_dma_tag_create(sc->sc_pdmatag, 1, 0,
 242             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 243             MCLBYTES * CAS_NTXSEGS, CAS_NTXSEGS, MCLBYTES,
 244             BUS_DMA_ALLOCNOW, NULL, NULL, &sc->sc_tdmatag);
 245         if (error != 0)
 246                 goto fail_rtag;
 247
 248         error = bus_dma_tag_create(sc->sc_pdmatag, CAS_TX_DESC_ALIGN, 0,
 249             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 250             sizeof(struct cas_control_data), 1,
 251             sizeof(struct cas_control_data), 0,
 252             NULL, NULL, &sc->sc_cdmatag);
 253         if (error != 0)
 254                 goto fail_ttag;
 255
 256         /*
 257          * Allocate the control data structures, create and load the
 258          * DMA map for it.
 259          */
 260         if ((error = bus_dmamem_alloc(sc->sc_cdmatag,
 261             (void **)&sc->sc_control_data,
 262             BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
 263             &sc->sc_cddmamap)) != 0) {
 264                 device_printf(sc->sc_dev,
 265                     "unable to allocate control data, error = %d\n", error);
 266                 goto fail_ctag;
 267         }
 268
 269         sc->sc_cddma = 0;
 270         if ((error = bus_dmamap_load(sc->sc_cdmatag, sc->sc_cddmamap,
 271             sc->sc_control_data, sizeof(struct cas_control_data),
 272             cas_cddma_callback, sc, 0)) != 0 || sc->sc_cddma == 0) {
 273                 device_printf(sc->sc_dev,
 274                     "unable to load control data DMA map, error = %d\n",
 275                     error);
 276                 goto fail_cmem;
 277         }
 278
 279         /*
 280          * Initialize the transmit job descriptors.
 281          */
 282         STAILQ_INIT(&sc->sc_txfreeq);
 283         STAILQ_INIT(&sc->sc_txdirtyq);
 284
 285         /*
 286          * Create the transmit buffer DMA maps.
 287          */
 288         error = ENOMEM;
 289         for (i = 0; i < CAS_TXQUEUELEN; i++) {
 290                 txs = &sc->sc_txsoft[i];
 291                 txs->txs_mbuf = NULL;
 292                 txs->txs_ndescs = 0;
 293                 if ((error = bus_dmamap_create(sc->sc_tdmatag, 0,
 294                     &txs->txs_dmamap)) != 0) {
 295                         device_printf(sc->sc_dev,
 296                             "unable to create TX DMA map %d, error = %d\n",
 297                             i, error);
 298                         goto fail_txd;
 299                 }
 300                 STAILQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
 301         }
 302
 303         /*
 304          * Allocate the receive buffers, create and load the DMA maps
 305          * for them.
 306          */
 307         for (i = 0; i < CAS_NRXDESC; i++) {
 308                 if ((error = bus_dmamem_alloc(sc->sc_rdmatag,
 309                     &sc->sc_rxdsoft[i].rxds_buf, BUS_DMA_WAITOK,
 310                     &sc->sc_rxdsoft[i].rxds_dmamap)) != 0) {
 311                         device_printf(sc->sc_dev,
 312                             "unable to allocate RX buffer %d, error = %d\n",
 313                             i, error);
 314                         goto fail_rxmem;
 315                 }
 316
 317                 sc->sc_rxdptr = i;
 318                 sc->sc_rxdsoft[i].rxds_paddr = 0;
 319                 if ((error = bus_dmamap_load(sc->sc_rdmatag,
 320                     sc->sc_rxdsoft[i].rxds_dmamap, sc->sc_rxdsoft[i].rxds_buf,
 321                     CAS_PAGE_SIZE, cas_rxdma_callback, sc, 0)) != 0 ||
 322                     sc->sc_rxdsoft[i].rxds_paddr == 0) {
 323                         device_printf(sc->sc_dev,
 324                             "unable to load RX DMA map %d, error = %d\n",
 325                             i, error);
 326                         goto fail_rxmap;
 327                 }
 328         }
 329
 330         if ((sc->sc_flags & CAS_SERDES) == 0) {
 331                 CAS_WRITE_4(sc, CAS_PCS_DATAPATH, CAS_PCS_DATAPATH_MII);
 332                 CAS_BARRIER(sc, CAS_PCS_DATAPATH, 4,
 333                     BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 334                 cas_mifinit(sc);
 335                 /*
 336                  * Look for an external PHY.
 337                  */
 338                 error = ENXIO;
 339                 v = CAS_READ_4(sc, CAS_MIF_CONF);
 340                 if ((v & CAS_MIF_CONF_MDI1) != 0) {
 341                         v |= CAS_MIF_CONF_PHY_SELECT;
 342                         CAS_WRITE_4(sc, CAS_MIF_CONF, v);
 343                         CAS_BARRIER(sc, CAS_MIF_CONF, 4,
 344                             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 345                         /* Enable/unfreeze the GMII pins of Saturn. */
 346                         if (sc->sc_variant == CAS_SATURN) {
 347                                 CAS_WRITE_4(sc, CAS_SATURN_PCFG,
 348                                     CAS_READ_4(sc, CAS_SATURN_PCFG) &
 349                                     ~CAS_SATURN_PCFG_FSI);
 350                                 CAS_BARRIER(sc, CAS_SATURN_PCFG, 4,
 351                                     BUS_SPACE_BARRIER_READ |
 352                                     BUS_SPACE_BARRIER_WRITE);
 353                                 DELAY(10000);
 354                         }
 355                         error = mii_attach(sc->sc_dev, &sc->sc_miibus, ifp,
 356                             cas_mediachange, cas_mediastatus, BMSR_DEFCAPMASK,
 357                             MII_PHY_ANY, MII_OFFSET_ANY, MIIF_DOPAUSE);
 358                 }
 359                 /*
 360                  * Fall back on an internal PHY if no external PHY was found.
 361                  */
 362                 if (error != 0 && (v & CAS_MIF_CONF_MDI0) != 0) {
 363                         v &= ~CAS_MIF_CONF_PHY_SELECT;
 364                         CAS_WRITE_4(sc, CAS_MIF_CONF, v);
 365                         CAS_BARRIER(sc, CAS_MIF_CONF, 4,
 366                             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 367                         /* Freeze the GMII pins of Saturn for saving power. */
 368                         if (sc->sc_variant == CAS_SATURN) {
 369                                 CAS_WRITE_4(sc, CAS_SATURN_PCFG,
 370                                     CAS_READ_4(sc, CAS_SATURN_PCFG) |
 371                                     CAS_SATURN_PCFG_FSI);
 372                                 CAS_BARRIER(sc, CAS_SATURN_PCFG, 4,
 373                                     BUS_SPACE_BARRIER_READ |
 374                                     BUS_SPACE_BARRIER_WRITE);
 375                                 DELAY(10000);
 376                         }
 377                         error = mii_attach(sc->sc_dev, &sc->sc_miibus, ifp,
 378                             cas_mediachange, cas_mediastatus, BMSR_DEFCAPMASK,
 379                             MII_PHY_ANY, MII_OFFSET_ANY, MIIF_DOPAUSE);
 380                 }
 381         } else {
 382                 /*
 383                  * Use the external PCS SERDES.
 384                  */
 385                 CAS_WRITE_4(sc, CAS_PCS_DATAPATH, CAS_PCS_DATAPATH_SERDES);
 386                 CAS_BARRIER(sc, CAS_PCS_DATAPATH, 4, BUS_SPACE_BARRIER_WRITE);
 387                 /* Enable/unfreeze the SERDES pins of Saturn. */
 388                 if (sc->sc_variant == CAS_SATURN) {
 389                         CAS_WRITE_4(sc, CAS_SATURN_PCFG, 0);
 390                         CAS_BARRIER(sc, CAS_SATURN_PCFG, 4,
 391                             BUS_SPACE_BARRIER_WRITE);
 392                 }
 393                 CAS_WRITE_4(sc, CAS_PCS_SERDES_CTRL, CAS_PCS_SERDES_CTRL_ESD);
 394                 CAS_BARRIER(sc, CAS_PCS_SERDES_CTRL, 4,
 395                     BUS_SPACE_BARRIER_WRITE);
 396                 CAS_WRITE_4(sc, CAS_PCS_CONF, CAS_PCS_CONF_EN);
 397                 CAS_BARRIER(sc, CAS_PCS_CONF, 4,
 398                     BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 399                 error = mii_attach(sc->sc_dev, &sc->sc_miibus, ifp,
 400                     cas_mediachange, cas_mediastatus, BMSR_DEFCAPMASK,
 401                     CAS_PHYAD_EXTERNAL, MII_OFFSET_ANY, MIIF_DOPAUSE);
 402         }
 403         if (error != 0) {
 404                 device_printf(sc->sc_dev, "attaching PHYs failed\n");
 405                 goto fail_rxmap;
 406         }
 407         sc->sc_mii = device_get_softc(sc->sc_miibus);
 408
 409         /*
 410          * From this point forward, the attachment cannot fail.  A failure
 411          * before this point releases all resources that may have been
 412          * allocated.
 413          */
 414
 415         /* Announce FIFO sizes. */
 416         v = CAS_READ_4(sc, CAS_TX_FIFO_SIZE);
 417         device_printf(sc->sc_dev, "%ukB RX FIFO, %ukB TX FIFO\n",
 418             CAS_RX_FIFO_SIZE / 1024, v / 16);
 419
 420         /* Attach the interface. */
 421         ether_ifattach(ifp, sc->sc_enaddr);
 422
 423         /*
 424          * Tell the upper layer(s) we support long frames/checksum offloads.
 425          */
 426         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
 427         ifp->if_capabilities = IFCAP_VLAN_MTU;
 428         if ((sc->sc_flags & CAS_NO_CSUM) == 0) {
 429                 ifp->if_capabilities |= IFCAP_HWCSUM;
 430                 ifp->if_hwassist = CAS_CSUM_FEATURES;
 431         }
 432         ifp->if_capenable = ifp->if_capabilities;
 433
 434         return (0);
 435
 436         /*
 437          * Free any resources we've allocated during the failed attach
 438          * attempt.  Do this in reverse order and fall through.
 439          */
 440  fail_rxmap:
 441         for (i = 0; i < CAS_NRXDESC; i++)
 442                 if (sc->sc_rxdsoft[i].rxds_paddr != 0)
 443                         bus_dmamap_unload(sc->sc_rdmatag,
 444                             sc->sc_rxdsoft[i].rxds_dmamap);
 445  fail_rxmem:
 446         for (i = 0; i < CAS_NRXDESC; i++)
 447                 if (sc->sc_rxdsoft[i].rxds_buf != NULL)
 448                         bus_dmamem_free(sc->sc_rdmatag,
 449                             sc->sc_rxdsoft[i].rxds_buf,
 450                             sc->sc_rxdsoft[i].rxds_dmamap);
 451  fail_txd:
 452         for (i = 0; i < CAS_TXQUEUELEN; i++)
 453                 if (sc->sc_txsoft[i].txs_dmamap != NULL)
 454                         bus_dmamap_destroy(sc->sc_tdmatag,
 455                             sc->sc_txsoft[i].txs_dmamap);
 456         bus_dmamap_unload(sc->sc_cdmatag, sc->sc_cddmamap);
 457  fail_cmem:
 458         bus_dmamem_free(sc->sc_cdmatag, sc->sc_control_data,
 459             sc->sc_cddmamap);
 460  fail_ctag:
 461         bus_dma_tag_destroy(sc->sc_cdmatag);
 462  fail_ttag:
 463         bus_dma_tag_destroy(sc->sc_tdmatag);
 464  fail_rtag:
 465         bus_dma_tag_destroy(sc->sc_rdmatag);
 466  fail_ptag:
 467         bus_dma_tag_destroy(sc->sc_pdmatag);
 468  fail_taskq:
 469         taskqueue_free(sc->sc_tq);
 470  fail_ifnet:
 471         if_free(ifp);
 472         return (error);
 473 }
 474
 475 static void
 476 cas_detach(struct cas_softc *sc)
 477 {
 478         struct ifnet *ifp = sc->sc_ifp;
 479         int i;
 480
 481         ether_ifdetach(ifp);
 482         CAS_LOCK(sc);
 483         cas_stop(ifp);
 484         CAS_UNLOCK(sc);
 485         callout_drain(&sc->sc_tick_ch);
 486         callout_drain(&sc->sc_rx_ch);
 487         taskqueue_drain(sc->sc_tq, &sc->sc_intr_task);
 488         taskqueue_drain(sc->sc_tq, &sc->sc_tx_task);
 489         if_free(ifp);
 490         taskqueue_free(sc->sc_tq);
 491         device_delete_child(sc->sc_dev, sc->sc_miibus);
 492
 493         for (i = 0; i < CAS_NRXDESC; i++)
 494                 if (sc->sc_rxdsoft[i].rxds_dmamap != NULL)
 495                         bus_dmamap_sync(sc->sc_rdmatag,
 496                             sc->sc_rxdsoft[i].rxds_dmamap,
 497                             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 498         for (i = 0; i < CAS_NRXDESC; i++)
 499                 if (sc->sc_rxdsoft[i].rxds_paddr != 0)
 500                         bus_dmamap_unload(sc->sc_rdmatag,
 501                             sc->sc_rxdsoft[i].rxds_dmamap);
 502         for (i = 0; i < CAS_NRXDESC; i++)
 503                 if (sc->sc_rxdsoft[i].rxds_buf != NULL)
 504                         bus_dmamem_free(sc->sc_rdmatag,
 505                             sc->sc_rxdsoft[i].rxds_buf,
 506                             sc->sc_rxdsoft[i].rxds_dmamap);
 507         for (i = 0; i < CAS_TXQUEUELEN; i++)
 508                 if (sc->sc_txsoft[i].txs_dmamap != NULL)
 509                         bus_dmamap_destroy(sc->sc_tdmatag,
 510                             sc->sc_txsoft[i].txs_dmamap);
 511         CAS_CDSYNC(sc, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 512         bus_dmamap_unload(sc->sc_cdmatag, sc->sc_cddmamap);
 513         bus_dmamem_free(sc->sc_cdmatag, sc->sc_control_data,
 514             sc->sc_cddmamap);
 515         bus_dma_tag_destroy(sc->sc_cdmatag);
 516         bus_dma_tag_destroy(sc->sc_tdmatag);
 517         bus_dma_tag_destroy(sc->sc_rdmatag);
 518         bus_dma_tag_destroy(sc->sc_pdmatag);
 519 }
 520
 521 static void
 522 cas_suspend(struct cas_softc *sc)
 523 {
 524         struct ifnet *ifp = sc->sc_ifp;
 525
 526         CAS_LOCK(sc);
 527         cas_stop(ifp);
 528         CAS_UNLOCK(sc);
 529 }
 530
 531 static void
 532 cas_resume(struct cas_softc *sc)
 533 {
 534         struct ifnet *ifp = sc->sc_ifp;
 535
 536         CAS_LOCK(sc);
 537         /*
 538          * On resume all registers have to be initialized again like
 539          * after power-on.
 540          */
 541         sc->sc_flags &= ~CAS_INITED;
 542         if (ifp->if_flags & IFF_UP)
 543                 cas_init_locked(sc);
 544         CAS_UNLOCK(sc);
 545 }
 546
 547 static inline void
 548 cas_rxcksum(struct mbuf *m, uint16_t cksum)
 549 {
 550         struct ether_header *eh;
 551         struct ip *ip;
 552         struct udphdr *uh;
 553         uint16_t *opts;
 554         int32_t hlen, len, pktlen;
 555         uint32_t temp32;
 556
 557         pktlen = m->m_pkthdr.len;
 558         if (pktlen < sizeof(struct ether_header) + sizeof(struct ip))
 559                 return;
 560         eh = mtod(m, struct ether_header *);
 561         if (eh->ether_type != htons(ETHERTYPE_IP))
 562                 return;
 563         ip = (struct ip *)(eh + 1);
 564         if (ip->ip_v != IPVERSION)
 565                 return;
 566
 567         hlen = ip->ip_hl << 2;
 568         pktlen -= sizeof(struct ether_header);
 569         if (hlen < sizeof(struct ip))
 570                 return;
 571         if (ntohs(ip->ip_len) < hlen)
 572                 return;
 573         if (ntohs(ip->ip_len) != pktlen)
 574                 return;
 575         if (ip->ip_off & htons(IP_MF | IP_OFFMASK))
 576                 return; /* Cannot handle fragmented packet. */
 577
 578         switch (ip->ip_p) {
 579         case IPPROTO_TCP:
 580                 if (pktlen < (hlen + sizeof(struct tcphdr)))
 581                         return;
 582                 break;
 583         case IPPROTO_UDP:
 584                 if (pktlen < (hlen + sizeof(struct udphdr)))
 585                         return;
 586                 uh = (struct udphdr *)((uint8_t *)ip + hlen);
 587                 if (uh->uh_sum == 0)
 588                         return; /* no checksum */
 589                 break;
 590         default:
 591                 return;
 592         }
 593
 594         cksum = ~cksum;
 595         /* checksum fixup for IP options */
 596         len = hlen - sizeof(struct ip);
 597         if (len > 0) {
 598                 opts = (uint16_t *)(ip + 1);
 599                 for (; len > 0; len -= sizeof(uint16_t), opts++) {
 600                         temp32 = cksum - *opts;
 601                         temp32 = (temp32 >> 16) + (temp32 & 65535);
 602                         cksum = temp32 & 65535;
 603                 }
 604         }
 605         m->m_pkthdr.csum_flags |= CSUM_DATA_VALID;
 606         m->m_pkthdr.csum_data = cksum;
 607 }
 608
 609 static void
 610 cas_cddma_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
 611 {
 612         struct cas_softc *sc = xsc;
 613
 614         if (error != 0)
 615                 return;
 616         if (nsegs != 1)
 617                 panic("%s: bad control buffer segment count", __func__);
 618         sc->sc_cddma = segs[0].ds_addr;
 619 }
 620
 621 static void
 622 cas_rxdma_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
 623 {
 624         struct cas_softc *sc = xsc;
 625
 626         if (error != 0)
 627                 return;
 628         if (nsegs != 1)
 629                 panic("%s: bad RX buffer segment count", __func__);
 630         sc->sc_rxdsoft[sc->sc_rxdptr].rxds_paddr = segs[0].ds_addr;
 631 }
 632
 633 static void
 634 cas_tick(void *arg)
 635 {
 636         struct cas_softc *sc = arg;
 637         struct ifnet *ifp = sc->sc_ifp;
 638         uint32_t v;
 639
 640         CAS_LOCK_ASSERT(sc, MA_OWNED);
 641
 642         /*
 643          * Unload collision and error counters.
 644          */
 645         ifp->if_collisions +=
 646             CAS_READ_4(sc, CAS_MAC_NORM_COLL_CNT) +
 647             CAS_READ_4(sc, CAS_MAC_FIRST_COLL_CNT);
 648         v = CAS_READ_4(sc, CAS_MAC_EXCESS_COLL_CNT) +
 649             CAS_READ_4(sc, CAS_MAC_LATE_COLL_CNT);
 650         ifp->if_collisions += v;
 651         ifp->if_oerrors += v;
 652         ifp->if_ierrors +=
 653             CAS_READ_4(sc, CAS_MAC_RX_LEN_ERR_CNT) +
 654             CAS_READ_4(sc, CAS_MAC_RX_ALIGN_ERR) +
 655             CAS_READ_4(sc, CAS_MAC_RX_CRC_ERR_CNT) +
 656             CAS_READ_4(sc, CAS_MAC_RX_CODE_VIOL);
 657
 658         /*
 659          * Then clear the hardware counters.
 660          */
 661         CAS_WRITE_4(sc, CAS_MAC_NORM_COLL_CNT, 0);
 662         CAS_WRITE_4(sc, CAS_MAC_FIRST_COLL_CNT, 0);
 663         CAS_WRITE_4(sc, CAS_MAC_EXCESS_COLL_CNT, 0);
 664         CAS_WRITE_4(sc, CAS_MAC_LATE_COLL_CNT, 0);
 665         CAS_WRITE_4(sc, CAS_MAC_RX_LEN_ERR_CNT, 0);
 666         CAS_WRITE_4(sc, CAS_MAC_RX_ALIGN_ERR, 0);
 667         CAS_WRITE_4(sc, CAS_MAC_RX_CRC_ERR_CNT, 0);
 668         CAS_WRITE_4(sc, CAS_MAC_RX_CODE_VIOL, 0);
 669
 670         mii_tick(sc->sc_mii);
 671
 672         if (sc->sc_txfree != CAS_MAXTXFREE)
 673                 cas_tint(sc);
 674
 675         cas_watchdog(sc);
 676
 677         callout_reset(&sc->sc_tick_ch, hz, cas_tick, sc);
 678 }
 679
 680 static int
 681 cas_bitwait(struct cas_softc *sc, bus_addr_t r, uint32_t clr, uint32_t set)
 682 {
 683         int i;
 684         uint32_t reg;
 685
 686         for (i = CAS_TRIES; i--; DELAY(100)) {
 687                 reg = CAS_READ_4(sc, r);
 688                 if ((reg & clr) == 0 && (reg & set) == set)
 689                         return (1);
 690         }
 691         return (0);
 692 }
 693
 694 static void
 695 cas_reset(struct cas_softc *sc)
 696 {
 697
 698 #ifdef CAS_DEBUG
 699         CTR2(KTR_CAS, "%s: %s", device_get_name(sc->sc_dev), __func__);
 700 #endif
 701         /* Disable all interrupts in order to avoid spurious ones. */
 702         CAS_WRITE_4(sc, CAS_INTMASK, 0xffffffff);
 703
 704         cas_reset_rx(sc);
 705         cas_reset_tx(sc);
 706
 707         /*
 708          * Do a full reset modulo the result of the last auto-negotiation
 709          * when using the SERDES.
 710          */
 711         CAS_WRITE_4(sc, CAS_RESET, CAS_RESET_RX | CAS_RESET_TX |
 712             ((sc->sc_flags & CAS_SERDES) != 0 ? CAS_RESET_PCS_DIS : 0));
 713         CAS_BARRIER(sc, CAS_RESET, 4,
 714             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 715         DELAY(3000);
 716         if (!cas_bitwait(sc, CAS_RESET, CAS_RESET_RX | CAS_RESET_TX, 0))
 717                 device_printf(sc->sc_dev, "cannot reset device\n");
 718 }
 719
 720 static void
 721 cas_stop(struct ifnet *ifp)
 722 {
 723         struct cas_softc *sc = ifp->if_softc;
 724         struct cas_txsoft *txs;
 725
 726 #ifdef CAS_DEBUG
 727         CTR2(KTR_CAS, "%s: %s", device_get_name(sc->sc_dev), __func__);
 728 #endif
 729
 730         callout_stop(&sc->sc_tick_ch);
 731         callout_stop(&sc->sc_rx_ch);
 732
 733         /* Disable all interrupts in order to avoid spurious ones. */
 734         CAS_WRITE_4(sc, CAS_INTMASK, 0xffffffff);
 735
 736         cas_reset_tx(sc);
 737         cas_reset_rx(sc);
 738
 739         /*
 740          * Release any queued transmit buffers.
 741          */
 742         while ((txs = STAILQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
 743                 STAILQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
 744                 if (txs->txs_ndescs != 0) {
 745                         bus_dmamap_sync(sc->sc_tdmatag, txs->txs_dmamap,
 746                             BUS_DMASYNC_POSTWRITE);
 747                         bus_dmamap_unload(sc->sc_tdmatag, txs->txs_dmamap);
 748                         if (txs->txs_mbuf != NULL) {
 749                                 m_freem(txs->txs_mbuf);
 750                                 txs->txs_mbuf = NULL;
 751                         }
 752                 }
 753                 STAILQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
 754         }
 755
 756         /*
 757          * Mark the interface down and cancel the watchdog timer.
 758          */
 759         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 760         sc->sc_flags &= ~CAS_LINK;
 761         sc->sc_wdog_timer = 0;
 762 }
 763
 764 static int
 765 cas_reset_rx(struct cas_softc *sc)
 766 {
 767
 768         /*
 769          * Resetting while DMA is in progress can cause a bus hang, so we
 770          * disable DMA first.
 771          */
 772         (void)cas_disable_rx(sc);
 773         CAS_WRITE_4(sc, CAS_RX_CONF, 0);
 774         CAS_BARRIER(sc, CAS_RX_CONF, 4,
 775             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 776         if (!cas_bitwait(sc, CAS_RX_CONF, CAS_RX_CONF_RXDMA_EN, 0))
 777                 device_printf(sc->sc_dev, "cannot disable RX DMA\n");
 778
 779         /* Finally, reset the ERX. */
 780         CAS_WRITE_4(sc, CAS_RESET, CAS_RESET_RX |
 781             ((sc->sc_flags & CAS_SERDES) != 0 ? CAS_RESET_PCS_DIS : 0));
 782         CAS_BARRIER(sc, CAS_RESET, 4,
 783             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 784         if (!cas_bitwait(sc, CAS_RESET, CAS_RESET_RX, 0)) {
 785                 device_printf(sc->sc_dev, "cannot reset receiver\n");
 786                 return (1);
 787         }
 788         return (0);
 789 }
 790
 791 static int
 792 cas_reset_tx(struct cas_softc *sc)
 793 {
 794
 795         /*
 796          * Resetting while DMA is in progress can cause a bus hang, so we
 797          * disable DMA first.
 798          */
 799         (void)cas_disable_tx(sc);
 800         CAS_WRITE_4(sc, CAS_TX_CONF, 0);
 801         CAS_BARRIER(sc, CAS_TX_CONF, 4,
 802             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 803         if (!cas_bitwait(sc, CAS_TX_CONF, CAS_TX_CONF_TXDMA_EN, 0))
 804                 device_printf(sc->sc_dev, "cannot disable TX DMA\n");
 805
 806         /* Finally, reset the ETX. */
 807         CAS_WRITE_4(sc, CAS_RESET, CAS_RESET_TX |
 808             ((sc->sc_flags & CAS_SERDES) != 0 ? CAS_RESET_PCS_DIS : 0));
 809         CAS_BARRIER(sc, CAS_RESET, 4,
 810             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 811         if (!cas_bitwait(sc, CAS_RESET, CAS_RESET_TX, 0)) {
 812                 device_printf(sc->sc_dev, "cannot reset transmitter\n");
 813                 return (1);
 814         }
 815         return (0);
 816 }
 817
 818 static int
 819 cas_disable_rx(struct cas_softc *sc)
 820 {
 821
 822         CAS_WRITE_4(sc, CAS_MAC_RX_CONF,
 823             CAS_READ_4(sc, CAS_MAC_RX_CONF) & ~CAS_MAC_RX_CONF_EN);
 824         CAS_BARRIER(sc, CAS_MAC_RX_CONF, 4,
 825             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 826         if (cas_bitwait(sc, CAS_MAC_RX_CONF, CAS_MAC_RX_CONF_EN, 0))
 827                 return (1);
 828         if (bootverbose)
 829                 device_printf(sc->sc_dev, "cannot disable RX MAC\n");
 830         return (0);
 831 }
 832
 833 static int
 834 cas_disable_tx(struct cas_softc *sc)
 835 {
 836
 837         CAS_WRITE_4(sc, CAS_MAC_TX_CONF,
 838             CAS_READ_4(sc, CAS_MAC_TX_CONF) & ~CAS_MAC_TX_CONF_EN);
 839         CAS_BARRIER(sc, CAS_MAC_TX_CONF, 4,
 840             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
 841         if (cas_bitwait(sc, CAS_MAC_TX_CONF, CAS_MAC_TX_CONF_EN, 0))
 842                 return (1);
 843         if (bootverbose)
 844                 device_printf(sc->sc_dev, "cannot disable TX MAC\n");
 845         return (0);
 846 }
 847
 848 static inline void
 849 cas_rxcompinit(struct cas_rx_comp *rxcomp)
 850 {
 851
 852         rxcomp->crc_word1 = 0;
 853         rxcomp->crc_word2 = 0;
 854         rxcomp->crc_word3 =
 855             htole64(CAS_SET(ETHER_HDR_LEN + sizeof(struct ip), CAS_RC3_CSO));
 856         rxcomp->crc_word4 = htole64(CAS_RC4_ZERO);
 857 }
 858
 859 static void
 860 cas_meminit(struct cas_softc *sc)
 861 {
 862         int i;
 863
 864         CAS_LOCK_ASSERT(sc, MA_OWNED);
 865
 866         /*
 867          * Initialize the transmit descriptor ring.
 868          */
 869         for (i = 0; i < CAS_NTXDESC; i++) {
 870                 sc->sc_txdescs[i].cd_flags = 0;
 871                 sc->sc_txdescs[i].cd_buf_ptr = 0;
 872         }
 873         sc->sc_txfree = CAS_MAXTXFREE;
 874         sc->sc_txnext = 0;
 875         sc->sc_txwin = 0;
 876
 877         /*
 878          * Initialize the receive completion ring.
 879          */
 880         for (i = 0; i < CAS_NRXCOMP; i++)
 881                 cas_rxcompinit(&sc->sc_rxcomps[i]);
 882         sc->sc_rxcptr = 0;
 883
 884         /*
 885          * Initialize the first receive descriptor ring.  We leave
 886          * the second one zeroed as we don't actually use it.
 887          */
 888         for (i = 0; i < CAS_NRXDESC; i++)
 889                 CAS_INIT_RXDESC(sc, i, i);
 890         sc->sc_rxdptr = 0;
 891
 892         CAS_CDSYNC(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 893 }
 894
 895 static u_int
 896 cas_descsize(u_int sz)
 897 {
 898
 899         switch (sz) {
 900         case 32:
 901                 return (CAS_DESC_32);
 902         case 64:
 903                 return (CAS_DESC_64);
 904         case 128:
 905                 return (CAS_DESC_128);
 906         case 256:
 907                 return (CAS_DESC_256);
 908         case 512:
 909                 return (CAS_DESC_512);
 910         case 1024:
 911                 return (CAS_DESC_1K);
 912         case 2048:
 913                 return (CAS_DESC_2K);
 914         case 4096:
 915                 return (CAS_DESC_4K);
 916         case 8192:
 917                 return (CAS_DESC_8K);
 918         default:
 919                 printf("%s: invalid descriptor ring size %d\n", __func__, sz);
 920                 return (CAS_DESC_32);
 921         }
 922 }
 923
 924 static u_int
 925 cas_rxcompsize(u_int sz)
 926 {
 927
 928         switch (sz) {
 929         case 128:
 930                 return (CAS_RX_CONF_COMP_128);
 931         case 256:
 932                 return (CAS_RX_CONF_COMP_256);
 933         case 512:
 934                 return (CAS_RX_CONF_COMP_512);
 935         case 1024:
 936                 return (CAS_RX_CONF_COMP_1K);
 937         case 2048:
 938                 return (CAS_RX_CONF_COMP_2K);
 939         case 4096:
 940                 return (CAS_RX_CONF_COMP_4K);
 941         case 8192:
 942                 return (CAS_RX_CONF_COMP_8K);
 943         case 16384:
 944                 return (CAS_RX_CONF_COMP_16K);
 945         case 32768:
 946                 return (CAS_RX_CONF_COMP_32K);
 947         default:
 948                 printf("%s: invalid dcompletion ring size %d\n", __func__, sz);
 949                 return (CAS_RX_CONF_COMP_128);
 950         }
 951 }
 952
 953 static void
 954 cas_init(void *xsc)
 955 {
 956         struct cas_softc *sc = xsc;
 957
 958         CAS_LOCK(sc);
 959         cas_init_locked(sc);
 960         CAS_UNLOCK(sc);
 961 }
 962
 963 /*
 964  * Initialization of interface; set up initialization block
 965  * and transmit/receive descriptor rings.
 966  */
 967 static void
 968 cas_init_locked(struct cas_softc *sc)
 969 {
 970         struct ifnet *ifp = sc->sc_ifp;
 971         uint32_t v;
 972
 973         CAS_LOCK_ASSERT(sc, MA_OWNED);
 974
 975         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
 976                 return;
 977
 978 #ifdef CAS_DEBUG
 979         CTR2(KTR_CAS, "%s: %s: calling stop", device_get_name(sc->sc_dev),
 980             __func__);
 981 #endif
 982         /*
 983          * Initialization sequence.  The numbered steps below correspond
 984          * to the sequence outlined in section 6.3.5.1 in the Ethernet
 985          * Channel Engine manual (part of the PCIO manual).
 986          * See also the STP2002-STQ document from Sun Microsystems.
 987          */
 988
 989         /* step 1 & 2.  Reset the Ethernet Channel. */
 990         cas_stop(ifp);
 991         cas_reset(sc);
 992 #ifdef CAS_DEBUG
 993         CTR2(KTR_CAS, "%s: %s: restarting", device_get_name(sc->sc_dev),
 994             __func__);
 995 #endif
 996
 997         if ((sc->sc_flags & CAS_SERDES) == 0)
 998                 /* Re-initialize the MIF. */
 999                 cas_mifinit(sc);
1000
1001         /* step 3.  Setup data structures in host memory. */
1002         cas_meminit(sc);
1003
1004         /* step 4.  TX MAC registers & counters */
1005         cas_init_regs(sc);
1006
1007         /* step 5.  RX MAC registers & counters */
1008
1009         /* step 6 & 7.  Program Ring Base Addresses. */
1010         CAS_WRITE_4(sc, CAS_TX_DESC3_BASE_HI,
1011             (((uint64_t)CAS_CDTXDADDR(sc, 0)) >> 32));
1012         CAS_WRITE_4(sc, CAS_TX_DESC3_BASE_LO,
1013             CAS_CDTXDADDR(sc, 0) & 0xffffffff);
1014
1015         CAS_WRITE_4(sc, CAS_RX_COMP_BASE_HI,
1016             (((uint64_t)CAS_CDRXCADDR(sc, 0)) >> 32));
1017         CAS_WRITE_4(sc, CAS_RX_COMP_BASE_LO,
1018             CAS_CDRXCADDR(sc, 0) & 0xffffffff);
1019
1020         CAS_WRITE_4(sc, CAS_RX_DESC_BASE_HI,
1021             (((uint64_t)CAS_CDRXDADDR(sc, 0)) >> 32));
1022         CAS_WRITE_4(sc, CAS_RX_DESC_BASE_LO,
1023             CAS_CDRXDADDR(sc, 0) & 0xffffffff);
1024
1025         if ((sc->sc_flags & CAS_REG_PLUS) != 0) {
1026                 CAS_WRITE_4(sc, CAS_RX_DESC2_BASE_HI,
1027                     (((uint64_t)CAS_CDRXD2ADDR(sc, 0)) >> 32));
1028                 CAS_WRITE_4(sc, CAS_RX_DESC2_BASE_LO,
1029                     CAS_CDRXD2ADDR(sc, 0) & 0xffffffff);
1030         }
1031
1032 #ifdef CAS_DEBUG
1033         CTR5(KTR_CAS,
1034             "loading TXDR %lx, RXCR %lx, RXDR %lx, RXD2R %lx, cddma %lx",
1035             CAS_CDTXDADDR(sc, 0), CAS_CDRXCADDR(sc, 0), CAS_CDRXDADDR(sc, 0),
1036             CAS_CDRXD2ADDR(sc, 0), sc->sc_cddma);
1037 #endif
1038
1039         /* step 8.  Global Configuration & Interrupt Masks */
1040
1041         /* Disable weighted round robin. */
1042         CAS_WRITE_4(sc, CAS_CAW, CAS_CAW_RR_DIS);
1043
1044         /*
1045          * Enable infinite bursts for revisions without PCI issues if
1046          * applicable.  Doing so greatly improves the TX performance on
1047          * !__sparc64__ (on sparc64, setting CAS_INF_BURST improves TX
1048          * performance only marginally but hurts RX throughput quite a bit).
1049          */
1050         CAS_WRITE_4(sc, CAS_INF_BURST,
1051 #if !defined(__sparc64__)
1052             (sc->sc_flags & CAS_TABORT) == 0 ? CAS_INF_BURST_EN :
1053 #endif
1054             0);
1055
1056         /* Set up interrupts. */
1057         CAS_WRITE_4(sc, CAS_INTMASK,
1058             ~(CAS_INTR_TX_INT_ME | CAS_INTR_TX_TAG_ERR |
1059             CAS_INTR_RX_DONE | CAS_INTR_RX_BUF_NA | CAS_INTR_RX_TAG_ERR |
1060             CAS_INTR_RX_COMP_FULL | CAS_INTR_RX_BUF_AEMPTY |
1061             CAS_INTR_RX_COMP_AFULL | CAS_INTR_RX_LEN_MMATCH |
1062             CAS_INTR_PCI_ERROR_INT
1063 #ifdef CAS_DEBUG
1064             | CAS_INTR_PCS_INT | CAS_INTR_MIF
1065 #endif
1066             ));
1067         /* Don't clear top level interrupts when CAS_STATUS_ALIAS is read. */
1068         CAS_WRITE_4(sc, CAS_CLEAR_ALIAS, 0);
1069         CAS_WRITE_4(sc, CAS_MAC_RX_MASK, ~CAS_MAC_RX_OVERFLOW);
1070         CAS_WRITE_4(sc, CAS_MAC_TX_MASK,
1071             ~(CAS_MAC_TX_UNDERRUN | CAS_MAC_TX_MAX_PKT_ERR));
1072 #ifdef CAS_DEBUG
1073         CAS_WRITE_4(sc, CAS_MAC_CTRL_MASK,
1074             ~(CAS_MAC_CTRL_PAUSE_RCVD | CAS_MAC_CTRL_PAUSE |
1075             CAS_MAC_CTRL_NON_PAUSE));
1076 #else
1077         CAS_WRITE_4(sc, CAS_MAC_CTRL_MASK,
1078             CAS_MAC_CTRL_PAUSE_RCVD | CAS_MAC_CTRL_PAUSE |
1079             CAS_MAC_CTRL_NON_PAUSE);
1080 #endif
1081
1082         /* Enable PCI error interrupts. */
1083         CAS_WRITE_4(sc, CAS_ERROR_MASK,
1084             ~(CAS_ERROR_DTRTO | CAS_ERROR_OTHER | CAS_ERROR_DMAW_ZERO |
1085             CAS_ERROR_DMAR_ZERO | CAS_ERROR_RTRTO));
1086
1087         /* Enable PCI error interrupts in BIM configuration. */
1088         CAS_WRITE_4(sc, CAS_BIM_CONF,
1089             CAS_BIM_CONF_DPAR_EN | CAS_BIM_CONF_RMA_EN | CAS_BIM_CONF_RTA_EN);
1090
1091         /*
1092          * step 9.  ETX Configuration: encode receive descriptor ring size,
1093          * enable DMA and disable pre-interrupt writeback completion.
1094          */
1095         v = cas_descsize(CAS_NTXDESC) << CAS_TX_CONF_DESC3_SHFT;
1096         CAS_WRITE_4(sc, CAS_TX_CONF, v | CAS_TX_CONF_TXDMA_EN |
1097             CAS_TX_CONF_RDPP_DIS | CAS_TX_CONF_PICWB_DIS);
1098
1099         /* step 10.  ERX Configuration */
1100
1101         /*
1102          * Encode receive completion and descriptor ring sizes, set the
1103          * swivel offset.
1104          */
1105         v = cas_rxcompsize(CAS_NRXCOMP) << CAS_RX_CONF_COMP_SHFT;
1106         v |= cas_descsize(CAS_NRXDESC) << CAS_RX_CONF_DESC_SHFT;
1107         if ((sc->sc_flags & CAS_REG_PLUS) != 0)
1108                 v |= cas_descsize(CAS_NRXDESC2) << CAS_RX_CONF_DESC2_SHFT;
1109         CAS_WRITE_4(sc, CAS_RX_CONF,
1110             v | (ETHER_ALIGN << CAS_RX_CONF_SOFF_SHFT));
1111
1112         /* Set the PAUSE thresholds.  We use the maximum OFF threshold. */
1113         CAS_WRITE_4(sc, CAS_RX_PTHRS,
1114             (111 << CAS_RX_PTHRS_XOFF_SHFT) | (15 << CAS_RX_PTHRS_XON_SHFT));
1115
1116         /* RX blanking */
1117         CAS_WRITE_4(sc, CAS_RX_BLANK,
1118             (15 << CAS_RX_BLANK_TIME_SHFT) | (5 << CAS_RX_BLANK_PKTS_SHFT));
1119
1120         /* Set RX_COMP_AFULL threshold to half of the RX completions. */
1121         CAS_WRITE_4(sc, CAS_RX_AEMPTY_THRS,
1122             (CAS_NRXCOMP / 2) << CAS_RX_AEMPTY_COMP_SHFT);
1123
1124         /* Initialize the RX page size register as appropriate for 8k. */
1125         CAS_WRITE_4(sc, CAS_RX_PSZ,
1126             (CAS_RX_PSZ_8K << CAS_RX_PSZ_SHFT) |
1127             (4 << CAS_RX_PSZ_MB_CNT_SHFT) |
1128             (CAS_RX_PSZ_MB_STRD_2K << CAS_RX_PSZ_MB_STRD_SHFT) |
1129             (CAS_RX_PSZ_MB_OFF_64 << CAS_RX_PSZ_MB_OFF_SHFT));
1130
1131         /* Disable RX random early detection. */
1132         CAS_WRITE_4(sc, CAS_RX_RED, 0);
1133
1134         /* Zero the RX reassembly DMA table. */
1135         for (v = 0; v <= CAS_RX_REAS_DMA_ADDR_LC; v++) {
1136                 CAS_WRITE_4(sc, CAS_RX_REAS_DMA_ADDR, v);
1137                 CAS_WRITE_4(sc, CAS_RX_REAS_DMA_DATA_LO, 0);
1138                 CAS_WRITE_4(sc, CAS_RX_REAS_DMA_DATA_MD, 0);
1139                 CAS_WRITE_4(sc, CAS_RX_REAS_DMA_DATA_HI, 0);
1140         }
1141
1142         /* Ensure the RX control FIFO and RX IPP FIFO addresses are zero. */
1143         CAS_WRITE_4(sc, CAS_RX_CTRL_FIFO, 0);
1144         CAS_WRITE_4(sc, CAS_RX_IPP_ADDR, 0);
1145
1146         /* Finally, enable RX DMA. */
1147         CAS_WRITE_4(sc, CAS_RX_CONF,
1148             CAS_READ_4(sc, CAS_RX_CONF) | CAS_RX_CONF_RXDMA_EN);
1149
1150         /* step 11.  Configure Media. */
1151
1152         /* step 12.  RX_MAC Configuration Register */
1153         v = CAS_READ_4(sc, CAS_MAC_RX_CONF);
1154         v &= ~(CAS_MAC_RX_CONF_STRPPAD | CAS_MAC_RX_CONF_EN);
1155         v |= CAS_MAC_RX_CONF_STRPFCS;
1156         sc->sc_mac_rxcfg = v;
1157         /*
1158          * Clear the RX filter and reprogram it.  This will also set the
1159          * current RX MAC configuration and enable it.
1160          */
1161         cas_setladrf(sc);
1162
1163         /* step 13.  TX_MAC Configuration Register */
1164         v = CAS_READ_4(sc, CAS_MAC_TX_CONF);
1165         v |= CAS_MAC_TX_CONF_EN;
1166         (void)cas_disable_tx(sc);
1167         CAS_WRITE_4(sc, CAS_MAC_TX_CONF, v);
1168
1169         /* step 14.  Issue Transmit Pending command. */
1170
1171         /* step 15.  Give the receiver a swift kick. */
1172         CAS_WRITE_4(sc, CAS_RX_KICK, CAS_NRXDESC - 4);
1173         CAS_WRITE_4(sc, CAS_RX_COMP_TAIL, 0);
1174         if ((sc->sc_flags & CAS_REG_PLUS) != 0)
1175                 CAS_WRITE_4(sc, CAS_RX_KICK2, CAS_NRXDESC2 - 4);
1176
1177         ifp->if_drv_flags |= IFF_DRV_RUNNING;
1178         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1179
1180         mii_mediachg(sc->sc_mii);
1181
1182         /* Start the one second timer. */
1183         sc->sc_wdog_timer = 0;
1184         callout_reset(&sc->sc_tick_ch, hz, cas_tick, sc);
1185 }
1186
1187 static int
1188 cas_load_txmbuf(struct cas_softc *sc, struct mbuf **m_head)
1189 {
1190         bus_dma_segment_t txsegs[CAS_NTXSEGS];
1191         struct cas_txsoft *txs;
1192         struct ip *ip;
1193         struct mbuf *m;
1194         uint64_t cflags;
1195         int error, nexttx, nsegs, offset, seg;
1196
1197         CAS_LOCK_ASSERT(sc, MA_OWNED);
1198
1199         /* Get a work queue entry. */
1200         if ((txs = STAILQ_FIRST(&sc->sc_txfreeq)) == NULL) {
1201                 /* Ran out of descriptors. */
1202                 return (ENOBUFS);
1203         }
1204
1205         cflags = 0;
1206         if (((*m_head)->m_pkthdr.csum_flags & CAS_CSUM_FEATURES) != 0) {
1207                 if (M_WRITABLE(*m_head) == 0) {
1208                         m = m_dup(*m_head, M_NOWAIT);
1209                         m_freem(*m_head);
1210                         *m_head = m;
1211                         if (m == NULL)
1212                                 return (ENOBUFS);
1213                 }
1214                 offset = sizeof(struct ether_header);
1215                 m = m_pullup(*m_head, offset + sizeof(struct ip));
1216                 if (m == NULL) {
1217                         *m_head = NULL;
1218                         return (ENOBUFS);
1219                 }
1220                 ip = (struct ip *)(mtod(m, caddr_t) + offset);
1221                 offset += (ip->ip_hl << 2);
1222                 cflags = (offset << CAS_TD_CKSUM_START_SHFT) |
1223                     ((offset + m->m_pkthdr.csum_data) <<
1224                     CAS_TD_CKSUM_STUFF_SHFT) | CAS_TD_CKSUM_EN;
1225                 *m_head = m;
1226         }
1227
1228         error = bus_dmamap_load_mbuf_sg(sc->sc_tdmatag, txs->txs_dmamap,
1229             *m_head, txsegs, &nsegs, BUS_DMA_NOWAIT);
1230         if (error == EFBIG) {
1231                 m = m_collapse(*m_head, M_NOWAIT, CAS_NTXSEGS);
1232                 if (m == NULL) {
1233                         m_freem(*m_head);
1234                         *m_head = NULL;
1235                         return (ENOBUFS);
1236                 }
1237                 *m_head = m;
1238                 error = bus_dmamap_load_mbuf_sg(sc->sc_tdmatag,
1239                     txs->txs_dmamap, *m_head, txsegs, &nsegs,
1240                     BUS_DMA_NOWAIT);
1241                 if (error != 0) {
1242                         m_freem(*m_head);
1243                         *m_head = NULL;
1244                         return (error);
1245                 }
1246         } else if (error != 0)
1247                 return (error);
1248         /* If nsegs is wrong then the stack is corrupt. */
1249         KASSERT(nsegs <= CAS_NTXSEGS,
1250             ("%s: too many DMA segments (%d)", __func__, nsegs));
1251         if (nsegs == 0) {
1252                 m_freem(*m_head);
1253                 *m_head = NULL;
1254                 return (EIO);
1255         }
1256
1257         /*
1258          * Ensure we have enough descriptors free to describe
1259          * the packet.  Note, we always reserve one descriptor
1260          * at the end of the ring as a termination point, in
1261          * order to prevent wrap-around.
1262          */
1263         if (nsegs > sc->sc_txfree - 1) {
1264                 txs->txs_ndescs = 0;
1265                 bus_dmamap_unload(sc->sc_tdmatag, txs->txs_dmamap);
1266                 return (ENOBUFS);
1267         }
1268
1269         txs->txs_ndescs = nsegs;
1270         txs->txs_firstdesc = sc->sc_txnext;
1271         nexttx = txs->txs_firstdesc;
1272         for (seg = 0; seg < nsegs; seg++, nexttx = CAS_NEXTTX(nexttx)) {
1273 #ifdef CAS_DEBUG
1274                 CTR6(KTR_CAS,
1275                     "%s: mapping seg %d (txd %d), len %lx, addr %#lx (%#lx)",
1276                     __func__, seg, nexttx, txsegs[seg].ds_len,
1277                     txsegs[seg].ds_addr, htole64(txsegs[seg].ds_addr));
1278 #endif
1279                 sc->sc_txdescs[nexttx].cd_buf_ptr =
1280                     htole64(txsegs[seg].ds_addr);
1281                 KASSERT(txsegs[seg].ds_len <
1282                     CAS_TD_BUF_LEN_MASK >> CAS_TD_BUF_LEN_SHFT,
1283                     ("%s: segment size too large!", __func__));
1284                 sc->sc_txdescs[nexttx].cd_flags =
1285                     htole64(txsegs[seg].ds_len << CAS_TD_BUF_LEN_SHFT);
1286                 txs->txs_lastdesc = nexttx;
1287         }
1288
1289         /* Set EOF on the last descriptor. */
1290 #ifdef CAS_DEBUG
1291         CTR3(KTR_CAS, "%s: end of frame at segment %d, TX %d",
1292             __func__, seg, nexttx);
1293 #endif
1294         sc->sc_txdescs[txs->txs_lastdesc].cd_flags |=
1295             htole64(CAS_TD_END_OF_FRAME);
1296
1297         /* Lastly set SOF on the first descriptor. */
1298 #ifdef CAS_DEBUG
1299         CTR3(KTR_CAS, "%s: start of frame at segment %d, TX %d",
1300             __func__, seg, nexttx);
1301 #endif
1302         if (sc->sc_txwin += nsegs > CAS_MAXTXFREE * 2 / 3) {
1303                 sc->sc_txwin = 0;
1304                 sc->sc_txdescs[txs->txs_firstdesc].cd_flags |=
1305                     htole64(cflags | CAS_TD_START_OF_FRAME | CAS_TD_INT_ME);
1306         } else
1307                 sc->sc_txdescs[txs->txs_firstdesc].cd_flags |=
1308                     htole64(cflags | CAS_TD_START_OF_FRAME);
1309
1310         /* Sync the DMA map. */
1311         bus_dmamap_sync(sc->sc_tdmatag, txs->txs_dmamap,
1312             BUS_DMASYNC_PREWRITE);
1313
1314 #ifdef CAS_DEBUG
1315         CTR4(KTR_CAS, "%s: setting firstdesc=%d, lastdesc=%d, ndescs=%d",
1316             __func__, txs->txs_firstdesc, txs->txs_lastdesc,
1317             txs->txs_ndescs);
1318 #endif
1319         STAILQ_REMOVE_HEAD(&sc->sc_txfreeq, txs_q);
1320         STAILQ_INSERT_TAIL(&sc->sc_txdirtyq, txs, txs_q);
1321         txs->txs_mbuf = *m_head;
1322
1323         sc->sc_txnext = CAS_NEXTTX(txs->txs_lastdesc);
1324         sc->sc_txfree -= txs->txs_ndescs;
1325
1326         return (0);
1327 }
1328
1329 static void
1330 cas_init_regs(struct cas_softc *sc)
1331 {
1332         int i;
1333         const u_char *laddr = IF_LLADDR(sc->sc_ifp);
1334
1335         CAS_LOCK_ASSERT(sc, MA_OWNED);
1336
1337         /* These registers are not cleared on reset. */
1338         if ((sc->sc_flags & CAS_INITED) == 0) {
1339                 /* magic values */
1340                 CAS_WRITE_4(sc, CAS_MAC_IPG0, 0);
1341                 CAS_WRITE_4(sc, CAS_MAC_IPG1, 8);
1342                 CAS_WRITE_4(sc, CAS_MAC_IPG2, 4);
1343
1344                 /* min frame length */
1345                 CAS_WRITE_4(sc, CAS_MAC_MIN_FRAME, ETHER_MIN_LEN);
1346                 /* max frame length and max burst size */
1347                 CAS_WRITE_4(sc, CAS_MAC_MAX_BF,
1348                     ((ETHER_MAX_LEN_JUMBO + ETHER_VLAN_ENCAP_LEN) <<
1349                     CAS_MAC_MAX_BF_FRM_SHFT) |
1350                     (0x2000 << CAS_MAC_MAX_BF_BST_SHFT));
1351
1352                 /* more magic values */
1353                 CAS_WRITE_4(sc, CAS_MAC_PREAMBLE_LEN, 0x7);
1354                 CAS_WRITE_4(sc, CAS_MAC_JAM_SIZE, 0x4);
1355                 CAS_WRITE_4(sc, CAS_MAC_ATTEMPT_LIMIT, 0x10);
1356                 CAS_WRITE_4(sc, CAS_MAC_CTRL_TYPE, 0x8808);
1357
1358                 /* random number seed */
1359                 CAS_WRITE_4(sc, CAS_MAC_RANDOM_SEED,
1360                     ((laddr[5] << 8) | laddr[4]) & 0x3ff);
1361
1362                 /* secondary MAC addresses: 0:0:0:0:0:0 */
1363                 for (i = CAS_MAC_ADDR3; i <= CAS_MAC_ADDR41;
1364                     i += CAS_MAC_ADDR4 - CAS_MAC_ADDR3)
1365                         CAS_WRITE_4(sc, i, 0);
1366
1367                 /* MAC control address: 01:80:c2:00:00:01 */
1368                 CAS_WRITE_4(sc, CAS_MAC_ADDR42, 0x0001);
1369                 CAS_WRITE_4(sc, CAS_MAC_ADDR43, 0xc200);
1370                 CAS_WRITE_4(sc, CAS_MAC_ADDR44, 0x0180);
1371
1372                 /* MAC filter address: 0:0:0:0:0:0 */
1373                 CAS_WRITE_4(sc, CAS_MAC_AFILTER0, 0);
1374                 CAS_WRITE_4(sc, CAS_MAC_AFILTER1, 0);
1375                 CAS_WRITE_4(sc, CAS_MAC_AFILTER2, 0);
1376                 CAS_WRITE_4(sc, CAS_MAC_AFILTER_MASK1_2, 0);
1377                 CAS_WRITE_4(sc, CAS_MAC_AFILTER_MASK0, 0);
1378
1379                 /* Zero the hash table. */
1380                 for (i = CAS_MAC_HASH0; i <= CAS_MAC_HASH15;
1381                     i += CAS_MAC_HASH1 - CAS_MAC_HASH0)
1382                         CAS_WRITE_4(sc, i, 0);
1383
1384                 sc->sc_flags |= CAS_INITED;
1385         }
1386
1387         /* Counters need to be zeroed. */
1388         CAS_WRITE_4(sc, CAS_MAC_NORM_COLL_CNT, 0);
1389         CAS_WRITE_4(sc, CAS_MAC_FIRST_COLL_CNT, 0);
1390         CAS_WRITE_4(sc, CAS_MAC_EXCESS_COLL_CNT, 0);
1391         CAS_WRITE_4(sc, CAS_MAC_LATE_COLL_CNT, 0);
1392         CAS_WRITE_4(sc, CAS_MAC_DEFER_TMR_CNT, 0);
1393         CAS_WRITE_4(sc, CAS_MAC_PEAK_ATTEMPTS, 0);
1394         CAS_WRITE_4(sc, CAS_MAC_RX_FRAME_COUNT, 0);
1395         CAS_WRITE_4(sc, CAS_MAC_RX_LEN_ERR_CNT, 0);
1396         CAS_WRITE_4(sc, CAS_MAC_RX_ALIGN_ERR, 0);
1397         CAS_WRITE_4(sc, CAS_MAC_RX_CRC_ERR_CNT, 0);
1398         CAS_WRITE_4(sc, CAS_MAC_RX_CODE_VIOL, 0);
1399
1400         /* Set XOFF PAUSE time. */
1401         CAS_WRITE_4(sc, CAS_MAC_SPC, 0x1BF0 << CAS_MAC_SPC_TIME_SHFT);
1402
1403         /* Set the station address. */
1404         CAS_WRITE_4(sc, CAS_MAC_ADDR0, (laddr[4] << 8) | laddr[5]);
1405         CAS_WRITE_4(sc, CAS_MAC_ADDR1, (laddr[2] << 8) | laddr[3]);
1406         CAS_WRITE_4(sc, CAS_MAC_ADDR2, (laddr[0] << 8) | laddr[1]);
1407
1408         /* Enable MII outputs. */
1409         CAS_WRITE_4(sc, CAS_MAC_XIF_CONF, CAS_MAC_XIF_CONF_TX_OE);
1410 }
1411
1412 static void
1413 cas_tx_task(void *arg, int pending __unused)
1414 {
1415         struct ifnet *ifp;
1416
1417         ifp = (struct ifnet *)arg;
1418         cas_start(ifp);
1419 }
1420
1421 static inline void
1422 cas_txkick(struct cas_softc *sc)
1423 {
1424
1425         /*
1426          * Update the TX kick register.  This register has to point to the
1427          * descriptor after the last valid one and for optimum performance
1428          * should be incremented in multiples of 4 (the DMA engine fetches/
1429          * updates descriptors in batches of 4).
1430          */
1431 #ifdef CAS_DEBUG
1432         CTR3(KTR_CAS, "%s: %s: kicking TX %d",
1433             device_get_name(sc->sc_dev), __func__, sc->sc_txnext);
1434 #endif
1435         CAS_CDSYNC(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1436         CAS_WRITE_4(sc, CAS_TX_KICK3, sc->sc_txnext);
1437 }
1438
1439 static void
1440 cas_start(struct ifnet *ifp)
1441 {
1442         struct cas_softc *sc = ifp->if_softc;
1443         struct mbuf *m;
1444         int kicked, ntx;
1445
1446         CAS_LOCK(sc);
1447
1448         if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
1449             IFF_DRV_RUNNING || (sc->sc_flags & CAS_LINK) == 0) {
1450                 CAS_UNLOCK(sc);
1451                 return;
1452         }
1453
1454         if (sc->sc_txfree < CAS_MAXTXFREE / 4)
1455                 cas_tint(sc);
1456
1457 #ifdef CAS_DEBUG
1458         CTR4(KTR_CAS, "%s: %s: txfree %d, txnext %d",
1459             device_get_name(sc->sc_dev), __func__, sc->sc_txfree,
1460             sc->sc_txnext);
1461 #endif
1462         ntx = 0;
1463         kicked = 0;
1464         for (; !IFQ_DRV_IS_EMPTY(&ifp->if_snd) && sc->sc_txfree > 1;) {
1465                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1466                 if (m == NULL)
1467                         break;
1468                 if (cas_load_txmbuf(sc, &m) != 0) {
1469                         if (m == NULL)
1470                                 break;
1471                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1472                         IFQ_DRV_PREPEND(&ifp->if_snd, m);
1473                         break;
1474                 }
1475                 if ((sc->sc_txnext % 4) == 0) {
1476                         cas_txkick(sc);
1477                         kicked = 1;
1478                 } else
1479                         kicked = 0;
1480                 ntx++;
1481                 BPF_MTAP(ifp, m);
1482         }
1483
1484         if (ntx > 0) {
1485                 if (kicked == 0)
1486                         cas_txkick(sc);
1487 #ifdef CAS_DEBUG
1488                 CTR2(KTR_CAS, "%s: packets enqueued, OWN on %d",
1489                     device_get_name(sc->sc_dev), sc->sc_txnext);
1490 #endif
1491
1492                 /* Set a watchdog timer in case the chip flakes out. */
1493                 sc->sc_wdog_timer = 5;
1494 #ifdef CAS_DEBUG
1495                 CTR3(KTR_CAS, "%s: %s: watchdog %d",
1496                     device_get_name(sc->sc_dev), __func__,
1497                     sc->sc_wdog_timer);
1498 #endif
1499         }
1500
1501         CAS_UNLOCK(sc);
1502 }
1503
1504 static void
1505 cas_tint(struct cas_softc *sc)
1506 {
1507         struct ifnet *ifp = sc->sc_ifp;
1508         struct cas_txsoft *txs;
1509         int progress;
1510         uint32_t txlast;
1511 #ifdef CAS_DEBUG
1512         int i;
1513
1514         CAS_LOCK_ASSERT(sc, MA_OWNED);
1515
1516         CTR2(KTR_CAS, "%s: %s", device_get_name(sc->sc_dev), __func__);
1517 #endif
1518
1519         /*
1520          * Go through our TX list and free mbufs for those
1521          * frames that have been transmitted.
1522          */
1523         progress = 0;
1524         CAS_CDSYNC(sc, BUS_DMASYNC_POSTREAD);
1525         while ((txs = STAILQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
1526 #ifdef CAS_DEBUG
1527                 if ((ifp->if_flags & IFF_DEBUG) != 0) {
1528                         printf("    txsoft %p transmit chain:\n", txs);
1529                         for (i = txs->txs_firstdesc;; i = CAS_NEXTTX(i)) {
1530                                 printf("descriptor %d: ", i);
1531                                 printf("cd_flags: 0x%016llx\t",
1532                                     (long long)le64toh(
1533                                     sc->sc_txdescs[i].cd_flags));
1534                                 printf("cd_buf_ptr: 0x%016llx\n",
1535                                     (long long)le64toh(
1536                                     sc->sc_txdescs[i].cd_buf_ptr));
1537                                 if (i == txs->txs_lastdesc)
1538                                         break;
1539                         }
1540                 }
1541 #endif
1542
1543                 /*
1544                  * In theory, we could harvest some descriptors before
1545                  * the ring is empty, but that's a bit complicated.
1546                  *
1547                  * CAS_TX_COMPn points to the last descriptor
1548                  * processed + 1.
1549                  */
1550                 txlast = CAS_READ_4(sc, CAS_TX_COMP3);
1551 #ifdef CAS_DEBUG
1552                 CTR4(KTR_CAS, "%s: txs->txs_firstdesc = %d, "
1553                     "txs->txs_lastdesc = %d, txlast = %d",
1554                     __func__, txs->txs_firstdesc, txs->txs_lastdesc, txlast);
1555 #endif
1556                 if (txs->txs_firstdesc <= txs->txs_lastdesc) {
1557                         if ((txlast >= txs->txs_firstdesc) &&
1558                             (txlast <= txs->txs_lastdesc))
1559                                 break;
1560                 } else {
1561                         /* Ick -- this command wraps. */
1562                         if ((txlast >= txs->txs_firstdesc) ||
1563                             (txlast <= txs->txs_lastdesc))
1564                                 break;
1565                 }
1566
1567 #ifdef CAS_DEBUG
1568                 CTR1(KTR_CAS, "%s: releasing a descriptor", __func__);
1569 #endif
1570                 STAILQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
1571
1572                 sc->sc_txfree += txs->txs_ndescs;
1573
1574                 bus_dmamap_sync(sc->sc_tdmatag, txs->txs_dmamap,
1575                     BUS_DMASYNC_POSTWRITE);
1576                 bus_dmamap_unload(sc->sc_tdmatag, txs->txs_dmamap);
1577                 if (txs->txs_mbuf != NULL) {
1578                         m_freem(txs->txs_mbuf);
1579                         txs->txs_mbuf = NULL;
1580                 }
1581
1582                 STAILQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
1583
1584                 ifp->if_opackets++;
1585                 progress = 1;
1586         }
1587
1588 #ifdef CAS_DEBUG
1589         CTR5(KTR_CAS, "%s: CAS_TX_SM1 %x CAS_TX_SM2 %x CAS_TX_DESC_BASE %llx "
1590             "CAS_TX_COMP3 %x",
1591             __func__, CAS_READ_4(sc, CAS_TX_SM1), CAS_READ_4(sc, CAS_TX_SM2),
1592             ((long long)CAS_READ_4(sc, CAS_TX_DESC3_BASE_HI) << 32) |
1593             CAS_READ_4(sc, CAS_TX_DESC3_BASE_LO),
1594             CAS_READ_4(sc, CAS_TX_COMP3));
1595 #endif
1596
1597         if (progress) {
1598                 /* We freed some descriptors, so reset IFF_DRV_OACTIVE. */
1599                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1600                 if (STAILQ_EMPTY(&sc->sc_txdirtyq))
1601                         sc->sc_wdog_timer = 0;
1602         }
1603
1604 #ifdef CAS_DEBUG
1605         CTR3(KTR_CAS, "%s: %s: watchdog %d",
1606             device_get_name(sc->sc_dev), __func__, sc->sc_wdog_timer);
1607 #endif
1608 }
1609
1610 static void
1611 cas_rint_timeout(void *arg)
1612 {
1613         struct cas_softc *sc = arg;
1614
1615         CAS_LOCK_ASSERT(sc, MA_OWNED);
1616
1617         cas_rint(sc);
1618 }
1619
1620 static void
1621 cas_rint(struct cas_softc *sc)
1622 {
1623         struct cas_rxdsoft *rxds, *rxds2;
1624         struct ifnet *ifp = sc->sc_ifp;
1625         struct mbuf *m, *m2;
1626         uint64_t word1, word2, word3, word4;
1627         uint32_t rxhead;
1628         u_int idx, idx2, len, off, skip;
1629
1630         CAS_LOCK_ASSERT(sc, MA_OWNED);
1631
1632         callout_stop(&sc->sc_rx_ch);
1633
1634 #ifdef CAS_DEBUG
1635         CTR2(KTR_CAS, "%s: %s", device_get_name(sc->sc_dev), __func__);
1636 #endif
1637
1638 #define PRINTWORD(n, delimiter)                                         \
1639         printf("word ## n: 0x%016llx%c", (long long)word ## n, delimiter)
1640
1641 #define SKIPASSERT(n)                                                   \
1642         KASSERT(sc->sc_rxcomps[sc->sc_rxcptr].crc_word ## n == 0,       \
1643             ("%s: word ## n not 0", __func__))
1644
1645 #define WORDTOH(n)                                                      \
1646         word ## n = le64toh(sc->sc_rxcomps[sc->sc_rxcptr].crc_word ## n)
1647
1648         /*
1649          * Read the completion head register once.  This limits
1650          * how long the following loop can execute.
1651          */
1652         rxhead = CAS_READ_4(sc, CAS_RX_COMP_HEAD);
1653 #ifdef CAS_DEBUG
1654         CTR4(KTR_CAS, "%s: sc->sc_rxcptr %d, sc->sc_rxdptr %d, head %d",
1655             __func__, sc->sc_rxcptr, sc->sc_rxdptr, rxhead);
1656 #endif
1657         skip = 0;
1658         CAS_CDSYNC(sc, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1659         for (; sc->sc_rxcptr != rxhead;
1660             sc->sc_rxcptr = CAS_NEXTRXCOMP(sc->sc_rxcptr)) {
1661                 if (skip != 0) {
1662                         SKIPASSERT(1);
1663                         SKIPASSERT(2);
1664                         SKIPASSERT(3);
1665
1666                         --skip;
1667                         goto skip;
1668                 }
1669
1670                 WORDTOH(1);
1671                 WORDTOH(2);
1672                 WORDTOH(3);
1673                 WORDTOH(4);
1674
1675 #ifdef CAS_DEBUG
1676                 if ((ifp->if_flags & IFF_DEBUG) != 0) {
1677                         printf("    completion %d: ", sc->sc_rxcptr);
1678                         PRINTWORD(1, '\t');
1679                         PRINTWORD(2, '\t');
1680                         PRINTWORD(3, '\t');
1681                         PRINTWORD(4, '\n');
1682                 }
1683 #endif
1684
1685                 if (__predict_false(
1686                     (word1 & CAS_RC1_TYPE_MASK) == CAS_RC1_TYPE_HW ||
1687                     (word4 & CAS_RC4_ZERO) != 0)) {
1688                         /*
1689                          * The descriptor is still marked as owned, although
1690                          * it is supposed to have completed.  This has been
1691                          * observed on some machines.  Just exiting here
1692                          * might leave the packet sitting around until another
1693                          * one arrives to trigger a new interrupt, which is
1694                          * generally undesirable, so set up a timeout.
1695                          */
1696                         callout_reset(&sc->sc_rx_ch, CAS_RXOWN_TICKS,
1697                             cas_rint_timeout, sc);
1698                         break;
1699                 }
1700
1701                 if (__predict_false(
1702                     (word4 & (CAS_RC4_BAD | CAS_RC4_LEN_MMATCH)) != 0)) {
1703                         ifp->if_ierrors++;
1704                         device_printf(sc->sc_dev,
1705                             "receive error: CRC error\n");
1706                         continue;
1707                 }
1708
1709                 KASSERT(CAS_GET(word1, CAS_RC1_DATA_SIZE) == 0 ||
1710                     CAS_GET(word2, CAS_RC2_HDR_SIZE) == 0,
1711                     ("%s: data and header present", __func__));
1712                 KASSERT((word1 & CAS_RC1_SPLIT_PKT) == 0 ||
1713                     CAS_GET(word2, CAS_RC2_HDR_SIZE) == 0,
1714                     ("%s: split and header present", __func__));
1715                 KASSERT(CAS_GET(word1, CAS_RC1_DATA_SIZE) == 0 ||
1716                     (word1 & CAS_RC1_RELEASE_HDR) == 0,
1717                     ("%s: data present but header release", __func__));
1718                 KASSERT(CAS_GET(word2, CAS_RC2_HDR_SIZE) == 0 ||
1719                     (word1 & CAS_RC1_RELEASE_DATA) == 0,
1720                     ("%s: header present but data release", __func__));
1721
1722                 if ((len = CAS_GET(word2, CAS_RC2_HDR_SIZE)) != 0) {
1723                         idx = CAS_GET(word2, CAS_RC2_HDR_INDEX);
1724                         off = CAS_GET(word2, CAS_RC2_HDR_OFF);
1725 #ifdef CAS_DEBUG
1726                         CTR4(KTR_CAS, "%s: hdr at idx %d, off %d, len %d",
1727                             __func__, idx, off, len);
1728 #endif
1729                         rxds = &sc->sc_rxdsoft[idx];
1730                         MGETHDR(m, M_NOWAIT, MT_DATA);
1731                         if (m != NULL) {
1732                                 refcount_acquire(&rxds->rxds_refcount);
1733                                 bus_dmamap_sync(sc->sc_rdmatag,
1734                                     rxds->rxds_dmamap, BUS_DMASYNC_POSTREAD);
1735 #if __FreeBSD_version < 800016
1736                                 MEXTADD(m, (caddr_t)rxds->rxds_buf +
1737                                     off * 256 + ETHER_ALIGN, len, cas_free,
1738                                     rxds, M_RDONLY, EXT_NET_DRV);
1739 #else
1740                                 MEXTADD(m, (caddr_t)rxds->rxds_buf +
1741                                     off * 256 + ETHER_ALIGN, len, cas_free,
1742                                     sc, (void *)(uintptr_t)idx,
1743                                     M_RDONLY, EXT_NET_DRV);
1744 #endif
1745                                 if ((m->m_flags & M_EXT) == 0) {
1746                                         m_freem(m);
1747                                         m = NULL;
1748                                 }
1749                         }
1750                         if (m != NULL) {
1751                                 m->m_pkthdr.rcvif = ifp;
1752                                 m->m_pkthdr.len = m->m_len = len;
1753                                 ifp->if_ipackets++;
1754                                 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
1755                                         cas_rxcksum(m, CAS_GET(word4,
1756                                             CAS_RC4_TCP_CSUM));
1757                                 /* Pass it on. */
1758                                 CAS_UNLOCK(sc);
1759                                 (*ifp->if_input)(ifp, m);
1760                                 CAS_LOCK(sc);
1761                         } else
1762                                 ifp->if_iqdrops++;
1763
1764                         if ((word1 & CAS_RC1_RELEASE_HDR) != 0 &&
1765                             refcount_release(&rxds->rxds_refcount) != 0)
1766                                 cas_add_rxdesc(sc, idx);
1767                 } else if ((len = CAS_GET(word1, CAS_RC1_DATA_SIZE)) != 0) {
1768                         idx = CAS_GET(word1, CAS_RC1_DATA_INDEX);
1769                         off = CAS_GET(word1, CAS_RC1_DATA_OFF);
1770 #ifdef CAS_DEBUG
1771                         CTR4(KTR_CAS, "%s: data at idx %d, off %d, len %d",
1772                             __func__, idx, off, len);
1773 #endif
1774                         rxds = &sc->sc_rxdsoft[idx];
1775                         MGETHDR(m, M_NOWAIT, MT_DATA);
1776                         if (m != NULL) {
1777                                 refcount_acquire(&rxds->rxds_refcount);
1778                                 off += ETHER_ALIGN;
1779                                 m->m_len = min(CAS_PAGE_SIZE - off, len);
1780                                 bus_dmamap_sync(sc->sc_rdmatag,
1781                                     rxds->rxds_dmamap, BUS_DMASYNC_POSTREAD);
1782 #if __FreeBSD_version < 800016
1783                                 MEXTADD(m, (caddr_t)rxds->rxds_buf + off,
1784                                     m->m_len, cas_free, rxds, M_RDONLY,
1785                                     EXT_NET_DRV);
1786 #else
1787                                 MEXTADD(m, (caddr_t)rxds->rxds_buf + off,
1788                                     m->m_len, cas_free, sc,
1789                                     (void *)(uintptr_t)idx, M_RDONLY,
1790                                     EXT_NET_DRV);
1791 #endif
1792                                 if ((m->m_flags & M_EXT) == 0) {
1793                                         m_freem(m);
1794                                         m = NULL;
1795                                 }
1796                         }
1797                         idx2 = 0;
1798                         m2 = NULL;
1799                         rxds2 = NULL;
1800                         if ((word1 & CAS_RC1_SPLIT_PKT) != 0) {
1801                                 KASSERT((word1 & CAS_RC1_RELEASE_NEXT) != 0,
1802                                     ("%s: split but no release next",
1803                                     __func__));
1804
1805                                 idx2 = CAS_GET(word2, CAS_RC2_NEXT_INDEX);
1806 #ifdef CAS_DEBUG
1807                                 CTR2(KTR_CAS, "%s: split at idx %d",
1808                                     __func__, idx2);
1809 #endif
1810                                 rxds2 = &sc->sc_rxdsoft[idx2];
1811                                 if (m != NULL) {
1812                                         MGET(m2, M_NOWAIT, MT_DATA);
1813                                         if (m2 != NULL) {
1814                                                 refcount_acquire(
1815                                                     &rxds2->rxds_refcount);
1816                                                 m2->m_len = len - m->m_len;
1817                                                 bus_dmamap_sync(
1818                                                     sc->sc_rdmatag,
1819                                                     rxds2->rxds_dmamap,
1820                                                     BUS_DMASYNC_POSTREAD);
1821 #if __FreeBSD_version < 800016
1822                                                 MEXTADD(m2,
1823                                                     (caddr_t)rxds2->rxds_buf,
1824                                                     m2->m_len, cas_free,
1825                                                     rxds2, M_RDONLY,
1826                                                     EXT_NET_DRV);
1827 #else
1828                                                 MEXTADD(m2,
1829                                                     (caddr_t)rxds2->rxds_buf,
1830                                                     m2->m_len, cas_free, sc,
1831                                                     (void *)(uintptr_t)idx2,
1832                                                     M_RDONLY, EXT_NET_DRV);
1833 #endif
1834                                                 if ((m2->m_flags & M_EXT) ==
1835                                                     0) {
1836                                                         m_freem(m2);
1837                                                         m2 = NULL;
1838                                                 }
1839                                         }
1840                                 }
1841                                 if (m2 != NULL)
1842                                         m->m_next = m2;
1843                                 else if (m != NULL) {
1844                                         m_freem(m);
1845                                         m = NULL;
1846                                 }
1847                         }
1848                         if (m != NULL) {
1849                                 m->m_pkthdr.rcvif = ifp;
1850                                 m->m_pkthdr.len = len;
1851                                 ifp->if_ipackets++;
1852                                 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
1853                                         cas_rxcksum(m, CAS_GET(word4,
1854                                             CAS_RC4_TCP_CSUM));
1855                                 /* Pass it on. */
1856                                 CAS_UNLOCK(sc);
1857                                 (*ifp->if_input)(ifp, m);
1858                                 CAS_LOCK(sc);
1859                         } else
1860                                 ifp->if_iqdrops++;
1861
1862                         if ((word1 & CAS_RC1_RELEASE_DATA) != 0 &&
1863                             refcount_release(&rxds->rxds_refcount) != 0)
1864                                 cas_add_rxdesc(sc, idx);
1865                         if ((word1 & CAS_RC1_SPLIT_PKT) != 0 &&
1866                             refcount_release(&rxds2->rxds_refcount) != 0)
1867                                 cas_add_rxdesc(sc, idx2);
1868                 }
1869
1870                 skip = CAS_GET(word1, CAS_RC1_SKIP);
1871
1872  skip:
1873                 cas_rxcompinit(&sc->sc_rxcomps[sc->sc_rxcptr]);
1874                 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1875                         break;
1876         }
1877         CAS_CDSYNC(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1878         CAS_WRITE_4(sc, CAS_RX_COMP_TAIL, sc->sc_rxcptr);
1879
1880 #undef PRINTWORD
1881 #undef SKIPASSERT
1882 #undef WORDTOH
1883
1884 #ifdef CAS_DEBUG
1885         CTR4(KTR_CAS, "%s: done sc->sc_rxcptr %d, sc->sc_rxdptr %d, head %d",
1886             __func__, sc->sc_rxcptr, sc->sc_rxdptr,
1887             CAS_READ_4(sc, CAS_RX_COMP_HEAD));
1888 #endif
1889 }
1890
1891 static int
1892 cas_free(struct mbuf *m, void *arg1, void *arg2)
1893 {
1894         struct cas_rxdsoft *rxds;
1895         struct cas_softc *sc;
1896         u_int idx, locked;
1897
1898 #if __FreeBSD_version < 800016
1899         rxds = arg2;
1900         sc = rxds->rxds_sc;
1901         idx = rxds->rxds_idx;
1902 #else
1903         sc = arg1;
1904         idx = (uintptr_t)arg2;
1905         rxds = &sc->sc_rxdsoft[idx];
1906 #endif
1907         if (refcount_release(&rxds->rxds_refcount) == 0)
1908                 return (EXT_FREE_OK);
1909
1910         /*
1911          * NB: this function can be called via m_freem(9) within
1912          * this driver!
1913          */
1914         if ((locked = CAS_LOCK_OWNED(sc)) == 0)
1915                 CAS_LOCK(sc);
1916         cas_add_rxdesc(sc, idx);
1917         if (locked == 0)
1918                 CAS_UNLOCK(sc);
1919         return (EXT_FREE_OK);
1920 }
1921
1922 static inline void
1923 cas_add_rxdesc(struct cas_softc *sc, u_int idx)
1924 {
1925
1926         CAS_LOCK_ASSERT(sc, MA_OWNED);
1927
1928         bus_dmamap_sync(sc->sc_rdmatag, sc->sc_rxdsoft[idx].rxds_dmamap,
1929             BUS_DMASYNC_PREREAD);
1930         CAS_UPDATE_RXDESC(sc, sc->sc_rxdptr, idx);
1931         sc->sc_rxdptr = CAS_NEXTRXDESC(sc->sc_rxdptr);
1932
1933         /*
1934          * Update the RX kick register.  This register has to point to the
1935          * descriptor after the last valid one (before the current batch)
1936          * and for optimum performance should be incremented in multiples
1937          * of 4 (the DMA engine fetches/updates descriptors in batches of 4).
1938          */
1939         if ((sc->sc_rxdptr % 4) == 0) {
1940                 CAS_CDSYNC(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1941                 CAS_WRITE_4(sc, CAS_RX_KICK,
1942                     (sc->sc_rxdptr + CAS_NRXDESC - 4) & CAS_NRXDESC_MASK);
1943         }
1944 }
1945
1946 static void
1947 cas_eint(struct cas_softc *sc, u_int status)
1948 {
1949         struct ifnet *ifp = sc->sc_ifp;
1950
1951         CAS_LOCK_ASSERT(sc, MA_OWNED);
1952
1953         ifp->if_ierrors++;
1954
1955         device_printf(sc->sc_dev, "%s: status 0x%x", __func__, status);
1956         if ((status & CAS_INTR_PCI_ERROR_INT) != 0) {
1957                 status = CAS_READ_4(sc, CAS_ERROR_STATUS);
1958                 printf(", PCI bus error 0x%x", status);
1959                 if ((status & CAS_ERROR_OTHER) != 0) {
1960                         status = pci_read_config(sc->sc_dev, PCIR_STATUS, 2);
1961                         printf(", PCI status 0x%x", status);
1962                         pci_write_config(sc->sc_dev, PCIR_STATUS, status, 2);
1963                 }
1964         }
1965         printf("\n");
1966
1967         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1968         cas_init_locked(sc);
1969         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1970                 taskqueue_enqueue(sc->sc_tq, &sc->sc_tx_task);
1971 }
1972
1973 static int
1974 cas_intr(void *v)
1975 {
1976         struct cas_softc *sc = v;
1977
1978         if (__predict_false((CAS_READ_4(sc, CAS_STATUS_ALIAS) &
1979             CAS_INTR_SUMMARY) == 0))
1980                 return (FILTER_STRAY);
1981
1982         /* Disable interrupts. */
1983         CAS_WRITE_4(sc, CAS_INTMASK, 0xffffffff);
1984         taskqueue_enqueue(sc->sc_tq, &sc->sc_intr_task);
1985
1986         return (FILTER_HANDLED);
1987 }
1988
1989 static void
1990 cas_intr_task(void *arg, int pending __unused)
1991 {
1992         struct cas_softc *sc = arg;
1993         struct ifnet *ifp = sc->sc_ifp;
1994         uint32_t status, status2;
1995
1996         CAS_LOCK_ASSERT(sc, MA_NOTOWNED);
1997
1998         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1999                 return;
2000
2001         status = CAS_READ_4(sc, CAS_STATUS);
2002         if (__predict_false((status & CAS_INTR_SUMMARY) == 0))
2003                 goto done;
2004
2005         CAS_LOCK(sc);
2006 #ifdef CAS_DEBUG
2007         CTR4(KTR_CAS, "%s: %s: cplt %x, status %x",
2008             device_get_name(sc->sc_dev), __func__,
2009             (status >> CAS_STATUS_TX_COMP3_SHFT), (u_int)status);
2010
2011         /*
2012          * PCS interrupts must be cleared, otherwise no traffic is passed!
2013          */
2014         if ((status & CAS_INTR_PCS_INT) != 0) {
2015                 status2 =
2016                     CAS_READ_4(sc, CAS_PCS_INTR_STATUS) |
2017                     CAS_READ_4(sc, CAS_PCS_INTR_STATUS);
2018                 if ((status2 & CAS_PCS_INTR_LINK) != 0)
2019                         device_printf(sc->sc_dev,
2020                             "%s: PCS link status changed\n", __func__);
2021         }
2022         if ((status & CAS_MAC_CTRL_STATUS) != 0) {
2023                 status2 = CAS_READ_4(sc, CAS_MAC_CTRL_STATUS);
2024                 if ((status2 & CAS_MAC_CTRL_PAUSE) != 0)
2025                         device_printf(sc->sc_dev,
2026                             "%s: PAUSE received (PAUSE time %d slots)\n",
2027                             __func__,
2028                             (status2 & CAS_MAC_CTRL_STATUS_PT_MASK) >>
2029                             CAS_MAC_CTRL_STATUS_PT_SHFT);
2030                 if ((status2 & CAS_MAC_CTRL_PAUSE) != 0)
2031                         device_printf(sc->sc_dev,
2032                             "%s: transited to PAUSE state\n", __func__);
2033                 if ((status2 & CAS_MAC_CTRL_NON_PAUSE) != 0)
2034                         device_printf(sc->sc_dev,
2035                             "%s: transited to non-PAUSE state\n", __func__);
2036         }
2037         if ((status & CAS_INTR_MIF) != 0)
2038                 device_printf(sc->sc_dev, "%s: MIF interrupt\n", __func__);
2039 #endif
2040
2041         if (__predict_false((status &
2042             (CAS_INTR_TX_TAG_ERR | CAS_INTR_RX_TAG_ERR |
2043             CAS_INTR_RX_LEN_MMATCH | CAS_INTR_PCI_ERROR_INT)) != 0)) {
2044                 cas_eint(sc, status);
2045                 CAS_UNLOCK(sc);
2046                 return;
2047         }
2048
2049         if (__predict_false(status & CAS_INTR_TX_MAC_INT)) {
2050                 status2 = CAS_READ_4(sc, CAS_MAC_TX_STATUS);
2051                 if ((status2 &
2052                     (CAS_MAC_TX_UNDERRUN | CAS_MAC_TX_MAX_PKT_ERR)) != 0)
2053                         ifp->if_oerrors++;
2054                 else if ((status2 & ~CAS_MAC_TX_FRAME_XMTD) != 0)
2055                         device_printf(sc->sc_dev,
2056                             "MAC TX fault, status %x\n", status2);
2057         }
2058
2059         if (__predict_false(status & CAS_INTR_RX_MAC_INT)) {
2060                 status2 = CAS_READ_4(sc, CAS_MAC_RX_STATUS);
2061                 if ((status2 & CAS_MAC_RX_OVERFLOW) != 0)
2062                         ifp->if_ierrors++;
2063                 else if ((status2 & ~CAS_MAC_RX_FRAME_RCVD) != 0)
2064                         device_printf(sc->sc_dev,
2065                             "MAC RX fault, status %x\n", status2);
2066         }
2067
2068         if ((status &
2069             (CAS_INTR_RX_DONE | CAS_INTR_RX_BUF_NA | CAS_INTR_RX_COMP_FULL |
2070             CAS_INTR_RX_BUF_AEMPTY | CAS_INTR_RX_COMP_AFULL)) != 0) {
2071                 cas_rint(sc);
2072 #ifdef CAS_DEBUG
2073                 if (__predict_false((status &
2074                     (CAS_INTR_RX_BUF_NA | CAS_INTR_RX_COMP_FULL |
2075                     CAS_INTR_RX_BUF_AEMPTY | CAS_INTR_RX_COMP_AFULL)) != 0))
2076                         device_printf(sc->sc_dev,
2077                             "RX fault, status %x\n", status);
2078 #endif
2079         }
2080
2081         if ((status &
2082             (CAS_INTR_TX_INT_ME | CAS_INTR_TX_ALL | CAS_INTR_TX_DONE)) != 0)
2083                 cas_tint(sc);
2084
2085         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2086                 CAS_UNLOCK(sc);
2087                 return;
2088         } else if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
2089                 taskqueue_enqueue(sc->sc_tq, &sc->sc_tx_task);
2090         CAS_UNLOCK(sc);
2091
2092         status = CAS_READ_4(sc, CAS_STATUS_ALIAS);
2093         if (__predict_false((status & CAS_INTR_SUMMARY) != 0)) {
2094                 taskqueue_enqueue(sc->sc_tq, &sc->sc_intr_task);
2095                 return;
2096         }
2097
2098  done:
2099         /* Re-enable interrupts. */
2100         CAS_WRITE_4(sc, CAS_INTMASK,
2101             ~(CAS_INTR_TX_INT_ME | CAS_INTR_TX_TAG_ERR |
2102             CAS_INTR_RX_DONE | CAS_INTR_RX_BUF_NA | CAS_INTR_RX_TAG_ERR |
2103             CAS_INTR_RX_COMP_FULL | CAS_INTR_RX_BUF_AEMPTY |
2104             CAS_INTR_RX_COMP_AFULL | CAS_INTR_RX_LEN_MMATCH |
2105             CAS_INTR_PCI_ERROR_INT
2106 #ifdef CAS_DEBUG
2107             | CAS_INTR_PCS_INT | CAS_INTR_MIF
2108 #endif
2109         ));
2110 }
2111
2112 static void
2113 cas_watchdog(struct cas_softc *sc)
2114 {
2115         struct ifnet *ifp = sc->sc_ifp;
2116
2117         CAS_LOCK_ASSERT(sc, MA_OWNED);
2118
2119 #ifdef CAS_DEBUG
2120         CTR4(KTR_CAS,
2121             "%s: CAS_RX_CONF %x CAS_MAC_RX_STATUS %x CAS_MAC_RX_CONF %x",
2122             __func__, CAS_READ_4(sc, CAS_RX_CONF),
2123             CAS_READ_4(sc, CAS_MAC_RX_STATUS),
2124             CAS_READ_4(sc, CAS_MAC_RX_CONF));
2125         CTR4(KTR_CAS,
2126             "%s: CAS_TX_CONF %x CAS_MAC_TX_STATUS %x CAS_MAC_TX_CONF %x",
2127             __func__, CAS_READ_4(sc, CAS_TX_CONF),
2128             CAS_READ_4(sc, CAS_MAC_TX_STATUS),
2129             CAS_READ_4(sc, CAS_MAC_TX_CONF));
2130 #endif
2131
2132         if (sc->sc_wdog_timer == 0 || --sc->sc_wdog_timer != 0)
2133                 return;
2134
2135         if ((sc->sc_flags & CAS_LINK) != 0)
2136                 device_printf(sc->sc_dev, "device timeout\n");
2137         else if (bootverbose)
2138                 device_printf(sc->sc_dev, "device timeout (no link)\n");
2139         ++ifp->if_oerrors;
2140
2141         /* Try to get more packets going. */
2142         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
2143         cas_init_locked(sc);
2144         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
2145                 taskqueue_enqueue(sc->sc_tq, &sc->sc_tx_task);
2146 }
2147
2148 static void
2149 cas_mifinit(struct cas_softc *sc)
2150 {
2151
2152         /* Configure the MIF in frame mode. */
2153         CAS_WRITE_4(sc, CAS_MIF_CONF,
2154             CAS_READ_4(sc, CAS_MIF_CONF) & ~CAS_MIF_CONF_BB_MODE);
2155         CAS_BARRIER(sc, CAS_MIF_CONF, 4,
2156             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2157 }
2158
2159 /*
2160  * MII interface
2161  *
2162  * The MII interface supports at least three different operating modes:
2163  *
2164  * Bitbang mode is implemented using data, clock and output enable registers.
2165  *
2166  * Frame mode is implemented by loading a complete frame into the frame
2167  * register and polling the valid bit for completion.
2168  *
2169  * Polling mode uses the frame register but completion is indicated by
2170  * an interrupt.
2171  *
2172  */
2173 static int
2174 cas_mii_readreg(device_t dev, int phy, int reg)
2175 {
2176         struct cas_softc *sc;
2177         int n;
2178         uint32_t v;
2179
2180 #ifdef CAS_DEBUG_PHY
2181         printf("%s: phy %d reg %d\n", __func__, phy, reg);
2182 #endif
2183
2184         sc = device_get_softc(dev);
2185         if ((sc->sc_flags & CAS_SERDES) != 0) {
2186                 switch (reg) {
2187                 case MII_BMCR:
2188                         reg = CAS_PCS_CTRL;
2189                         break;
2190                 case MII_BMSR:
2191                         reg = CAS_PCS_STATUS;
2192                         break;
2193                 case MII_PHYIDR1:
2194                 case MII_PHYIDR2:
2195                         return (0);
2196                 case MII_ANAR:
2197                         reg = CAS_PCS_ANAR;
2198                         break;
2199                 case MII_ANLPAR:
2200                         reg = CAS_PCS_ANLPAR;
2201                         break;
2202                 case MII_EXTSR:
2203                         return (EXTSR_1000XFDX | EXTSR_1000XHDX);
2204                 default:
2205                         device_printf(sc->sc_dev,
2206                             "%s: unhandled register %d\n", __func__, reg);
2207                         return (0);
2208                 }
2209                 return (CAS_READ_4(sc, reg));
2210         }
2211
2212         /* Construct the frame command. */
2213         v = CAS_MIF_FRAME_READ |
2214             (phy << CAS_MIF_FRAME_PHY_SHFT) |
2215             (reg << CAS_MIF_FRAME_REG_SHFT);
2216
2217         CAS_WRITE_4(sc, CAS_MIF_FRAME, v);
2218         CAS_BARRIER(sc, CAS_MIF_FRAME, 4,
2219             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2220         for (n = 0; n < 100; n++) {
2221                 DELAY(1);
2222                 v = CAS_READ_4(sc, CAS_MIF_FRAME);
2223                 if (v & CAS_MIF_FRAME_TA_LSB)
2224                         return (v & CAS_MIF_FRAME_DATA);
2225         }
2226
2227         device_printf(sc->sc_dev, "%s: timed out\n", __func__);
2228         return (0);
2229 }
2230
2231 static int
2232 cas_mii_writereg(device_t dev, int phy, int reg, int val)
2233 {
2234         struct cas_softc *sc;
2235         int n;
2236         uint32_t v;
2237
2238 #ifdef CAS_DEBUG_PHY
2239         printf("%s: phy %d reg %d val %x\n", phy, reg, val, __func__);
2240 #endif
2241
2242         sc = device_get_softc(dev);
2243         if ((sc->sc_flags & CAS_SERDES) != 0) {
2244                 switch (reg) {
2245                 case MII_BMSR:
2246                         reg = CAS_PCS_STATUS;
2247                         break;
2248                 case MII_BMCR:
2249                         reg = CAS_PCS_CTRL;
2250                         if ((val & CAS_PCS_CTRL_RESET) == 0)
2251                                 break;
2252                         CAS_WRITE_4(sc, CAS_PCS_CTRL, val);
2253                         CAS_BARRIER(sc, CAS_PCS_CTRL, 4,
2254                             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2255                         if (!cas_bitwait(sc, CAS_PCS_CTRL,
2256                             CAS_PCS_CTRL_RESET, 0))
2257                                 device_printf(sc->sc_dev,
2258                                     "cannot reset PCS\n");
2259                         /* FALLTHROUGH */
2260                 case MII_ANAR:
2261                         CAS_WRITE_4(sc, CAS_PCS_CONF, 0);
2262                         CAS_BARRIER(sc, CAS_PCS_CONF, 4,
2263                             BUS_SPACE_BARRIER_WRITE);
2264                         CAS_WRITE_4(sc, CAS_PCS_ANAR, val);
2265                         CAS_BARRIER(sc, CAS_PCS_ANAR, 4,
2266                             BUS_SPACE_BARRIER_WRITE);
2267                         CAS_WRITE_4(sc, CAS_PCS_SERDES_CTRL,
2268                             CAS_PCS_SERDES_CTRL_ESD);
2269                         CAS_BARRIER(sc, CAS_PCS_CONF, 4,
2270                             BUS_SPACE_BARRIER_WRITE);
2271                         CAS_WRITE_4(sc, CAS_PCS_CONF,
2272                             CAS_PCS_CONF_EN);
2273                         CAS_BARRIER(sc, CAS_PCS_CONF, 4,
2274                             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2275                         return (0);
2276                 case MII_ANLPAR:
2277                         reg = CAS_PCS_ANLPAR;
2278                         break;
2279                 default:
2280                         device_printf(sc->sc_dev,
2281                             "%s: unhandled register %d\n", __func__, reg);
2282                         return (0);
2283                 }
2284                 CAS_WRITE_4(sc, reg, val);
2285                 CAS_BARRIER(sc, reg, 4,
2286                     BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2287                 return (0);
2288         }
2289
2290         /* Construct the frame command. */
2291         v = CAS_MIF_FRAME_WRITE |
2292             (phy << CAS_MIF_FRAME_PHY_SHFT) |
2293             (reg << CAS_MIF_FRAME_REG_SHFT) |
2294             (val & CAS_MIF_FRAME_DATA);
2295
2296         CAS_WRITE_4(sc, CAS_MIF_FRAME, v);
2297         CAS_BARRIER(sc, CAS_MIF_FRAME, 4,
2298             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2299         for (n = 0; n < 100; n++) {
2300                 DELAY(1);
2301                 v = CAS_READ_4(sc, CAS_MIF_FRAME);
2302                 if (v & CAS_MIF_FRAME_TA_LSB)
2303                         return (1);
2304         }
2305
2306         device_printf(sc->sc_dev, "%s: timed out\n", __func__);
2307         return (0);
2308 }
2309
2310 static void
2311 cas_mii_statchg(device_t dev)
2312 {
2313         struct cas_softc *sc;
2314         struct ifnet *ifp;
2315         int gigabit;
2316         uint32_t rxcfg, txcfg, v;
2317
2318         sc = device_get_softc(dev);
2319         ifp = sc->sc_ifp;
2320
2321         CAS_LOCK_ASSERT(sc, MA_OWNED);
2322
2323 #ifdef CAS_DEBUG
2324         if ((ifp->if_flags & IFF_DEBUG) != 0)
2325                 device_printf(sc->sc_dev, "%s: status changen", __func__);
2326 #endif
2327
2328         if ((sc->sc_mii->mii_media_status & IFM_ACTIVE) != 0 &&
2329             IFM_SUBTYPE(sc->sc_mii->mii_media_active) != IFM_NONE)
2330                 sc->sc_flags |= CAS_LINK;
2331         else
2332                 sc->sc_flags &= ~CAS_LINK;
2333
2334         switch (IFM_SUBTYPE(sc->sc_mii->mii_media_active)) {
2335         case IFM_1000_SX:
2336         case IFM_1000_LX:
2337         case IFM_1000_CX:
2338         case IFM_1000_T:
2339                 gigabit = 1;
2340                 break;
2341         default:
2342                 gigabit = 0;
2343         }
2344
2345         /*
2346          * The configuration done here corresponds to the steps F) and
2347          * G) and as far as enabling of RX and TX MAC goes also step H)
2348          * of the initialization sequence outlined in section 11.2.1 of
2349          * the Cassini+ ASIC Specification.
2350          */
2351
2352         rxcfg = sc->sc_mac_rxcfg;
2353         rxcfg &= ~CAS_MAC_RX_CONF_CARR;
2354         txcfg = CAS_MAC_TX_CONF_EN_IPG0 | CAS_MAC_TX_CONF_NGU |
2355             CAS_MAC_TX_CONF_NGUL;
2356         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) != 0)
2357                 txcfg |= CAS_MAC_TX_CONF_ICARR | CAS_MAC_TX_CONF_ICOLLIS;
2358         else if (gigabit != 0) {
2359                 rxcfg |= CAS_MAC_RX_CONF_CARR;
2360                 txcfg |= CAS_MAC_TX_CONF_CARR;
2361         }
2362         (void)cas_disable_tx(sc);
2363         CAS_WRITE_4(sc, CAS_MAC_TX_CONF, txcfg);
2364         (void)cas_disable_rx(sc);
2365         CAS_WRITE_4(sc, CAS_MAC_RX_CONF, rxcfg);
2366
2367         v = CAS_READ_4(sc, CAS_MAC_CTRL_CONF) &
2368             ~(CAS_MAC_CTRL_CONF_TXP | CAS_MAC_CTRL_CONF_RXP);
2369         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) &
2370             IFM_ETH_RXPAUSE) != 0)
2371                 v |= CAS_MAC_CTRL_CONF_RXP;
2372         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) &
2373             IFM_ETH_TXPAUSE) != 0)
2374                 v |= CAS_MAC_CTRL_CONF_TXP;
2375         CAS_WRITE_4(sc, CAS_MAC_CTRL_CONF, v);
2376
2377         /*
2378          * All supported chips have a bug causing incorrect checksum
2379          * to be calculated when letting them strip the FCS in half-
2380          * duplex mode.  In theory we could disable FCS stripping and
2381          * manually adjust the checksum accordingly.  It seems to make
2382          * more sense to optimze for the common case and just disable
2383          * hardware checksumming in half-duplex mode though.
2384          */
2385         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) == 0) {
2386                 ifp->if_capenable &= ~IFCAP_HWCSUM;
2387                 ifp->if_hwassist = 0;
2388         } else if ((sc->sc_flags & CAS_NO_CSUM) == 0) {
2389                 ifp->if_capenable = ifp->if_capabilities;
2390                 ifp->if_hwassist = CAS_CSUM_FEATURES;
2391         }
2392
2393         if (sc->sc_variant == CAS_SATURN) {
2394                 if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) == 0)
2395                         /* silicon bug workaround */
2396                         CAS_WRITE_4(sc, CAS_MAC_PREAMBLE_LEN, 0x41);
2397                 else
2398                         CAS_WRITE_4(sc, CAS_MAC_PREAMBLE_LEN, 0x7);
2399         }
2400
2401         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) == 0 &&
2402             gigabit != 0)
2403                 CAS_WRITE_4(sc, CAS_MAC_SLOT_TIME,
2404                     CAS_MAC_SLOT_TIME_CARR);
2405         else
2406                 CAS_WRITE_4(sc, CAS_MAC_SLOT_TIME,
2407                     CAS_MAC_SLOT_TIME_NORM);
2408
2409         /* XIF Configuration */
2410         v = CAS_MAC_XIF_CONF_TX_OE | CAS_MAC_XIF_CONF_LNKLED;
2411         if ((sc->sc_flags & CAS_SERDES) == 0) {
2412                 if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) == 0)
2413                         v |= CAS_MAC_XIF_CONF_NOECHO;
2414                 v |= CAS_MAC_XIF_CONF_BUF_OE;
2415         }
2416         if (gigabit != 0)
2417                 v |= CAS_MAC_XIF_CONF_GMII;
2418         if ((IFM_OPTIONS(sc->sc_mii->mii_media_active) & IFM_FDX) != 0)
2419                 v |= CAS_MAC_XIF_CONF_FDXLED;
2420         CAS_WRITE_4(sc, CAS_MAC_XIF_CONF, v);
2421
2422         sc->sc_mac_rxcfg = rxcfg;
2423         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0 &&
2424             (sc->sc_flags & CAS_LINK) != 0) {
2425                 CAS_WRITE_4(sc, CAS_MAC_TX_CONF,
2426                     txcfg | CAS_MAC_TX_CONF_EN);
2427                 CAS_WRITE_4(sc, CAS_MAC_RX_CONF,
2428                     rxcfg | CAS_MAC_RX_CONF_EN);
2429         }
2430 }
2431
2432 static int
2433 cas_mediachange(struct ifnet *ifp)
2434 {
2435         struct cas_softc *sc = ifp->if_softc;
2436         int error;
2437
2438         /* XXX add support for serial media. */
2439
2440         CAS_LOCK(sc);
2441         error = mii_mediachg(sc->sc_mii);
2442         CAS_UNLOCK(sc);
2443         return (error);
2444 }
2445
2446 static void
2447 cas_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
2448 {
2449         struct cas_softc *sc = ifp->if_softc;
2450
2451         CAS_LOCK(sc);
2452         if ((ifp->if_flags & IFF_UP) == 0) {
2453                 CAS_UNLOCK(sc);
2454                 return;
2455         }
2456
2457         mii_pollstat(sc->sc_mii);
2458         ifmr->ifm_active = sc->sc_mii->mii_media_active;
2459         ifmr->ifm_status = sc->sc_mii->mii_media_status;
2460         CAS_UNLOCK(sc);
2461 }
2462
2463 static int
2464 cas_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2465 {
2466         struct cas_softc *sc = ifp->if_softc;
2467         struct ifreq *ifr = (struct ifreq *)data;
2468         int error;
2469
2470         error = 0;
2471         switch (cmd) {
2472         case SIOCSIFFLAGS:
2473                 CAS_LOCK(sc);
2474                 if ((ifp->if_flags & IFF_UP) != 0) {
2475                         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0 &&
2476                             ((ifp->if_flags ^ sc->sc_ifflags) &
2477                             (IFF_ALLMULTI | IFF_PROMISC)) != 0)
2478                                 cas_setladrf(sc);
2479                         else
2480                                 cas_init_locked(sc);
2481                 } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
2482                         cas_stop(ifp);
2483                 sc->sc_ifflags = ifp->if_flags;
2484                 CAS_UNLOCK(sc);
2485                 break;
2486         case SIOCSIFCAP:
2487                 CAS_LOCK(sc);
2488                 if ((sc->sc_flags & CAS_NO_CSUM) != 0) {
2489                         error = EINVAL;
2490                         CAS_UNLOCK(sc);
2491                         break;
2492                 }
2493                 ifp->if_capenable = ifr->ifr_reqcap;
2494                 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
2495                         ifp->if_hwassist = CAS_CSUM_FEATURES;
2496                 else
2497                         ifp->if_hwassist = 0;
2498                 CAS_UNLOCK(sc);
2499                 break;
2500         case SIOCADDMULTI:
2501         case SIOCDELMULTI:
2502                 CAS_LOCK(sc);
2503                 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
2504                         cas_setladrf(sc);
2505                 CAS_UNLOCK(sc);
2506                 break;
2507         case SIOCSIFMTU:
2508                 if ((ifr->ifr_mtu < ETHERMIN) ||
2509                     (ifr->ifr_mtu > ETHERMTU_JUMBO))
2510                         error = EINVAL;
2511                 else
2512                         ifp->if_mtu = ifr->ifr_mtu;
2513                 break;
2514         case SIOCGIFMEDIA:
2515         case SIOCSIFMEDIA:
2516                 error = ifmedia_ioctl(ifp, ifr, &sc->sc_mii->mii_media, cmd);
2517                 break;
2518         default:
2519                 error = ether_ioctl(ifp, cmd, data);
2520                 break;
2521         }
2522
2523         return (error);
2524 }
2525
2526 static void
2527 cas_setladrf(struct cas_softc *sc)
2528 {
2529         struct ifnet *ifp = sc->sc_ifp;
2530         struct ifmultiaddr *inm;
2531         int i;
2532         uint32_t hash[16];
2533         uint32_t crc, v;
2534
2535         CAS_LOCK_ASSERT(sc, MA_OWNED);
2536
2537         /*
2538          * Turn off the RX MAC and the hash filter as required by the Sun
2539          * Cassini programming restrictions.
2540          */
2541         v = sc->sc_mac_rxcfg & ~(CAS_MAC_RX_CONF_HFILTER |
2542             CAS_MAC_RX_CONF_EN);
2543         CAS_WRITE_4(sc, CAS_MAC_RX_CONF, v);
2544         CAS_BARRIER(sc, CAS_MAC_RX_CONF, 4,
2545             BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);
2546         if (!cas_bitwait(sc, CAS_MAC_RX_CONF, CAS_MAC_RX_CONF_HFILTER |
2547             CAS_MAC_RX_CONF_EN, 0))
2548                 device_printf(sc->sc_dev,
2549                     "cannot disable RX MAC or hash filter\n");
2550
2551         v &= ~(CAS_MAC_RX_CONF_PROMISC | CAS_MAC_RX_CONF_PGRP);
2552         if ((ifp->if_flags & IFF_PROMISC) != 0) {
2553                 v |= CAS_MAC_RX_CONF_PROMISC;
2554                 goto chipit;
2555         }
2556         if ((ifp->if_flags & IFF_ALLMULTI) != 0) {
2557                 v |= CAS_MAC_RX_CONF_PGRP;
2558                 goto chipit;
2559         }
2560
2561         /*
2562          * Set up multicast address filter by passing all multicast
2563          * addresses through a crc generator, and then using the high
2564          * order 8 bits as an index into the 256 bit logical address
2565          * filter.  The high order 4 bits selects the word, while the
2566          * other 4 bits select the bit within the word (where bit 0
2567          * is the MSB).
2568          */
2569
2570         /* Clear the hash table. */
2571         memset(hash, 0, sizeof(hash));
2572
2573         if_maddr_rlock(ifp);
2574         TAILQ_FOREACH(inm, &ifp->if_multiaddrs, ifma_link) {
2575                 if (inm->ifma_addr->sa_family != AF_LINK)
2576                         continue;
2577                 crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
2578                     inm->ifma_addr), ETHER_ADDR_LEN);
2579
2580                 /* We just want the 8 most significant bits. */
2581                 crc >>= 24;
2582
2583                 /* Set the corresponding bit in the filter. */
2584                 hash[crc >> 4] |= 1 << (15 - (crc & 15));
2585         }
2586         if_maddr_runlock(ifp);
2587
2588         v |= CAS_MAC_RX_CONF_HFILTER;
2589
2590         /* Now load the hash table into the chip (if we are using it). */
2591         for (i = 0; i < 16; i++)
2592                 CAS_WRITE_4(sc,
2593                     CAS_MAC_HASH0 + i * (CAS_MAC_HASH1 - CAS_MAC_HASH0),
2594                     hash[i]);
2595
2596  chipit:
2597         sc->sc_mac_rxcfg = v;
2598         CAS_WRITE_4(sc, CAS_MAC_RX_CONF, v | CAS_MAC_RX_CONF_EN);
2599 }
2600
2601 static int      cas_pci_attach(device_t dev);
2602 static int      cas_pci_detach(device_t dev);
2603 static int      cas_pci_probe(device_t dev);
2604 static int      cas_pci_resume(device_t dev);
2605 static int      cas_pci_suspend(device_t dev);
2606
2607 static device_method_t cas_pci_methods[] = {
2608         /* Device interface */
2609         DEVMETHOD(device_probe,         cas_pci_probe),
2610         DEVMETHOD(device_attach,        cas_pci_attach),
2611         DEVMETHOD(device_detach,        cas_pci_detach),
2612         DEVMETHOD(device_suspend,       cas_pci_suspend),
2613         DEVMETHOD(device_resume,        cas_pci_resume),
2614         /* Use the suspend handler here, it is all that is required. */
2615         DEVMETHOD(device_shutdown,      cas_pci_suspend),
2616
2617         /* MII interface */
2618         DEVMETHOD(miibus_readreg,       cas_mii_readreg),
2619         DEVMETHOD(miibus_writereg,      cas_mii_writereg),
2620         DEVMETHOD(miibus_statchg,       cas_mii_statchg),
2621
2622         DEVMETHOD_END
2623 };
2624
2625 static driver_t cas_pci_driver = {
2626         "cas",
2627         cas_pci_methods,
2628         sizeof(struct cas_softc)
2629 };
2630
2631 DRIVER_MODULE(cas, pci, cas_pci_driver, cas_devclass, 0, 0);
2632 DRIVER_MODULE(miibus, cas, miibus_driver, miibus_devclass, 0, 0);
2633 MODULE_DEPEND(cas, pci, 1, 1, 1);
2634
2635 static const struct cas_pci_dev {
2636         uint32_t        cpd_devid;
2637         uint8_t         cpd_revid;
2638         int             cpd_variant;
2639         const char      *cpd_desc;
2640 } cas_pci_devlist[] = {
2641         { 0x0035100b, 0x0, CAS_SATURN, "NS DP83065 Saturn Gigabit Ethernet" },
2642         { 0xabba108e, 0x10, CAS_CASPLUS, "Sun Cassini+ Gigabit Ethernet" },
2643         { 0xabba108e, 0x0, CAS_CAS, "Sun Cassini Gigabit Ethernet" },
2644         { 0, 0, 0, NULL }
2645 };
2646
2647 static int
2648 cas_pci_probe(device_t dev)
2649 {
2650         int i;
2651
2652         for (i = 0; cas_pci_devlist[i].cpd_desc != NULL; i++) {
2653                 if (pci_get_devid(dev) == cas_pci_devlist[i].cpd_devid &&
2654                     pci_get_revid(dev) >= cas_pci_devlist[i].cpd_revid) {
2655                         device_set_desc(dev, cas_pci_devlist[i].cpd_desc);
2656                         return (BUS_PROBE_DEFAULT);
2657                 }
2658         }
2659
2660         return (ENXIO);
2661 }
2662
2663 static struct resource_spec cas_pci_res_spec[] = {
2664         { SYS_RES_IRQ, 0, RF_SHAREABLE | RF_ACTIVE },   /* CAS_RES_INTR */
2665         { SYS_RES_MEMORY, PCIR_BAR(0), RF_ACTIVE },     /* CAS_RES_MEM */
2666         { -1, 0 }
2667 };
2668
2669 #define CAS_LOCAL_MAC_ADDRESS   "local-mac-address"
2670 #define CAS_PHY_INTERFACE       "phy-interface"
2671 #define CAS_PHY_TYPE            "phy-type"
2672 #define CAS_PHY_TYPE_PCS        "pcs"
2673
2674 static int
2675 cas_pci_attach(device_t dev)
2676 {
2677         char buf[sizeof(CAS_LOCAL_MAC_ADDRESS)];
2678         struct cas_softc *sc;
2679         int i;
2680 #if !(defined(__powerpc__) || defined(__sparc64__))
2681         u_char enaddr[4][ETHER_ADDR_LEN];
2682         u_int j, k, lma, pcs[4], phy;
2683 #endif
2684
2685         sc = device_get_softc(dev);
2686         sc->sc_variant = CAS_UNKNOWN;
2687         for (i = 0; cas_pci_devlist[i].cpd_desc != NULL; i++) {
2688                 if (pci_get_devid(dev) == cas_pci_devlist[i].cpd_devid &&
2689                     pci_get_revid(dev) >= cas_pci_devlist[i].cpd_revid) {
2690                         sc->sc_variant = cas_pci_devlist[i].cpd_variant;
2691                         break;
2692                 }
2693         }
2694         if (sc->sc_variant == CAS_UNKNOWN) {
2695                 device_printf(dev, "unknown adaptor\n");
2696                 return (ENXIO);
2697         }
2698
2699         /* PCI configuration */
2700         pci_write_config(dev, PCIR_COMMAND,
2701             pci_read_config(dev, PCIR_COMMAND, 2) | PCIM_CMD_BUSMASTEREN |
2702             PCIM_CMD_MWRICEN | PCIM_CMD_PERRESPEN | PCIM_CMD_SERRESPEN, 2);
2703
2704         sc->sc_dev = dev;
2705         if (sc->sc_variant == CAS_CAS && pci_get_devid(dev) < 0x02)
2706                 /* Hardware checksumming may hang TX. */
2707                 sc->sc_flags |= CAS_NO_CSUM;
2708         if (sc->sc_variant == CAS_CASPLUS || sc->sc_variant == CAS_SATURN)
2709                 sc->sc_flags |= CAS_REG_PLUS;
2710         if (sc->sc_variant == CAS_CAS ||
2711             (sc->sc_variant == CAS_CASPLUS && pci_get_revid(dev) < 0x11))
2712                 sc->sc_flags |= CAS_TABORT;
2713         if (bootverbose)
2714                 device_printf(dev, "flags=0x%x\n", sc->sc_flags);
2715
2716         if (bus_alloc_resources(dev, cas_pci_res_spec, sc->sc_res)) {
2717                 device_printf(dev, "failed to allocate resources\n");
2718                 bus_release_resources(dev, cas_pci_res_spec, sc->sc_res);
2719                 return (ENXIO);
2720         }
2721
2722         CAS_LOCK_INIT(sc, device_get_nameunit(dev));
2723
2724 #if defined(__powerpc__) || defined(__sparc64__)
2725         OF_getetheraddr(dev, sc->sc_enaddr);
2726         if (OF_getprop(ofw_bus_get_node(dev), CAS_PHY_INTERFACE, buf,
2727             sizeof(buf)) > 0 || OF_getprop(ofw_bus_get_node(dev),
2728             CAS_PHY_TYPE, buf, sizeof(buf)) > 0) {
2729                 buf[sizeof(buf) - 1] = '\0';
2730                 if (strcmp(buf, CAS_PHY_TYPE_PCS) == 0)
2731                         sc->sc_flags |= CAS_SERDES;
2732         }
2733 #else
2734         /*
2735          * Dig out VPD (vital product data) and read the MAC address as well
2736          * as the PHY type.  The VPD resides in the PCI Expansion ROM (PCI
2737          * FCode) and can't be accessed via the PCI capability pointer.
2738          * SUNW,pci-ce and SUNW,pci-qge use the Enhanced VPD format described
2739          * in the free US Patent 7149820.
2740          */
2741
2742 #define PCI_ROMHDR_SIZE                 0x1c
2743 #define PCI_ROMHDR_SIG                  0x00
2744 #define PCI_ROMHDR_SIG_MAGIC            0xaa55          /* little endian */
2745 #define PCI_ROMHDR_PTR_DATA             0x18
2746 #define PCI_ROM_SIZE                    0x18
2747 #define PCI_ROM_SIG                     0x00
2748 #define PCI_ROM_SIG_MAGIC               0x52494350      /* "PCIR", endian */
2749                                                         /* reversed */
2750 #define PCI_ROM_VENDOR                  0x04
2751 #define PCI_ROM_DEVICE                  0x06
2752 #define PCI_ROM_PTR_VPD                 0x08
2753 #define PCI_VPDRES_BYTE0                0x00
2754 #define PCI_VPDRES_ISLARGE(x)           ((x) & 0x80)
2755 #define PCI_VPDRES_LARGE_NAME(x)        ((x) & 0x7f)
2756 #define PCI_VPDRES_LARGE_LEN_LSB        0x01
2757 #define PCI_VPDRES_LARGE_LEN_MSB        0x02
2758 #define PCI_VPDRES_LARGE_SIZE           0x03
2759 #define PCI_VPDRES_TYPE_ID_STRING       0x02            /* large */
2760 #define PCI_VPDRES_TYPE_VPD             0x10            /* large */
2761 #define PCI_VPD_KEY0                    0x00
2762 #define PCI_VPD_KEY1                    0x01
2763 #define PCI_VPD_LEN                     0x02
2764 #define PCI_VPD_SIZE                    0x03
2765
2766 #define CAS_ROM_READ_1(sc, offs)                                        \
2767         CAS_READ_1((sc), CAS_PCI_ROM_OFFSET + (offs))
2768 #define CAS_ROM_READ_2(sc, offs)                                        \
2769         CAS_READ_2((sc), CAS_PCI_ROM_OFFSET + (offs))
2770 #define CAS_ROM_READ_4(sc, offs)                                        \
2771         CAS_READ_4((sc), CAS_PCI_ROM_OFFSET + (offs))
2772
2773         lma = phy = 0;
2774         memset(enaddr, 0, sizeof(enaddr));
2775         memset(pcs, 0, sizeof(pcs));
2776
2777         /* Enable PCI Expansion ROM access. */
2778         CAS_WRITE_4(sc, CAS_BIM_LDEV_OEN,
2779             CAS_BIM_LDEV_OEN_PAD | CAS_BIM_LDEV_OEN_PROM);
2780
2781         /* Read PCI Expansion ROM header. */
2782         if (CAS_ROM_READ_2(sc, PCI_ROMHDR_SIG) != PCI_ROMHDR_SIG_MAGIC ||
2783             (i = CAS_ROM_READ_2(sc, PCI_ROMHDR_PTR_DATA)) <
2784             PCI_ROMHDR_SIZE) {
2785                 device_printf(dev, "unexpected PCI Expansion ROM header\n");
2786                 goto fail_prom;
2787         }
2788
2789         /* Read PCI Expansion ROM data. */
2790         if (CAS_ROM_READ_4(sc, i + PCI_ROM_SIG) != PCI_ROM_SIG_MAGIC ||
2791             CAS_ROM_READ_2(sc, i + PCI_ROM_VENDOR) != pci_get_vendor(dev) ||
2792             CAS_ROM_READ_2(sc, i + PCI_ROM_DEVICE) != pci_get_device(dev) ||
2793             (j = CAS_ROM_READ_2(sc, i + PCI_ROM_PTR_VPD)) <
2794             i + PCI_ROM_SIZE) {
2795                 device_printf(dev, "unexpected PCI Expansion ROM data\n");
2796                 goto fail_prom;
2797         }
2798
2799         /* Read PCI VPD. */
2800  next:
2801         if (PCI_VPDRES_ISLARGE(CAS_ROM_READ_1(sc,
2802             j + PCI_VPDRES_BYTE0)) == 0) {
2803                 device_printf(dev, "no large PCI VPD\n");
2804                 goto fail_prom;
2805         }
2806
2807         i = (CAS_ROM_READ_1(sc, j + PCI_VPDRES_LARGE_LEN_MSB) << 8) |
2808             CAS_ROM_READ_1(sc, j + PCI_VPDRES_LARGE_LEN_LSB);
2809         switch (PCI_VPDRES_LARGE_NAME(CAS_ROM_READ_1(sc,
2810             j + PCI_VPDRES_BYTE0))) {
2811         case PCI_VPDRES_TYPE_ID_STRING:
2812                 /* Skip identifier string. */
2813                 j += PCI_VPDRES_LARGE_SIZE + i;
2814                 goto next;
2815         case PCI_VPDRES_TYPE_VPD:
2816                 for (j += PCI_VPDRES_LARGE_SIZE; i > 0;
2817                     i -= PCI_VPD_SIZE + CAS_ROM_READ_1(sc, j + PCI_VPD_LEN),
2818                     j += PCI_VPD_SIZE + CAS_ROM_READ_1(sc, j + PCI_VPD_LEN)) {
2819                         if (CAS_ROM_READ_1(sc, j + PCI_VPD_KEY0) != 'Z')
2820                                 /* no Enhanced VPD */
2821                                 continue;
2822                         if (CAS_ROM_READ_1(sc, j + PCI_VPD_SIZE) != 'I')
2823                                 /* no instance property */
2824                                 continue;
2825                         if (CAS_ROM_READ_1(sc, j + PCI_VPD_SIZE + 3) == 'B') {
2826                                 /* byte array */
2827                                 if (CAS_ROM_READ_1(sc,
2828                                     j + PCI_VPD_SIZE + 4) != ETHER_ADDR_LEN)
2829                                         continue;
2830                                 bus_read_region_1(sc->sc_res[CAS_RES_MEM],
2831                                     CAS_PCI_ROM_OFFSET + j + PCI_VPD_SIZE + 5,
2832                                     buf, sizeof(buf));
2833                                 buf[sizeof(buf) - 1] = '\0';
2834                                 if (strcmp(buf, CAS_LOCAL_MAC_ADDRESS) != 0)
2835                                         continue;
2836                                 bus_read_region_1(sc->sc_res[CAS_RES_MEM],
2837                                     CAS_PCI_ROM_OFFSET + j + PCI_VPD_SIZE +
2838                                     5 + sizeof(CAS_LOCAL_MAC_ADDRESS),
2839                                     enaddr[lma], sizeof(enaddr[lma]));
2840                                 lma++;
2841                                 if (lma == 4 && phy == 4)
2842                                         break;
2843                         } else if (CAS_ROM_READ_1(sc, j + PCI_VPD_SIZE + 3) ==
2844                            'S') {
2845                                 /* string */
2846                                 if (CAS_ROM_READ_1(sc,
2847                                     j + PCI_VPD_SIZE + 4) !=
2848                                     sizeof(CAS_PHY_TYPE_PCS))
2849                                         continue;
2850                                 bus_read_region_1(sc->sc_res[CAS_RES_MEM],
2851                                     CAS_PCI_ROM_OFFSET + j + PCI_VPD_SIZE + 5,
2852                                     buf, sizeof(buf));
2853                                 buf[sizeof(buf) - 1] = '\0';
2854                                 if (strcmp(buf, CAS_PHY_INTERFACE) == 0)
2855                                         k = sizeof(CAS_PHY_INTERFACE);
2856                                 else if (strcmp(buf, CAS_PHY_TYPE) == 0)
2857                                         k = sizeof(CAS_PHY_TYPE);
2858                                 else
2859                                         continue;
2860                                 bus_read_region_1(sc->sc_res[CAS_RES_MEM],
2861                                     CAS_PCI_ROM_OFFSET + j + PCI_VPD_SIZE +
2862                                     5 + k, buf, sizeof(buf));
2863                                 buf[sizeof(buf) - 1] = '\0';
2864                                 if (strcmp(buf, CAS_PHY_TYPE_PCS) == 0)
2865                                         pcs[phy] = 1;
2866                                 phy++;
2867                                 if (lma == 4 && phy == 4)
2868                                         break;
2869                         }
2870                 }
2871                 break;
2872         default:
2873                 device_printf(dev, "unexpected PCI VPD\n");
2874                 goto fail_prom;
2875         }
2876
2877  fail_prom:
2878         CAS_WRITE_4(sc, CAS_BIM_LDEV_OEN, 0);
2879
2880         if (lma == 0) {
2881                 device_printf(dev, "could not determine Ethernet address\n");
2882                 goto fail;
2883         }
2884         i = 0;
2885         if (lma > 1 && pci_get_slot(dev) < nitems(enaddr))
2886                 i = pci_get_slot(dev);
2887         memcpy(sc->sc_enaddr, enaddr[i], ETHER_ADDR_LEN);
2888
2889         if (phy == 0) {
2890                 device_printf(dev, "could not determine PHY type\n");
2891                 goto fail;
2892         }
2893         i = 0;
2894         if (phy > 1 && pci_get_slot(dev) < nitems(pcs))
2895                 i = pci_get_slot(dev);
2896         if (pcs[i] != 0)
2897                 sc->sc_flags |= CAS_SERDES;
2898 #endif
2899
2900         if (cas_attach(sc) != 0) {
2901                 device_printf(dev, "could not be attached\n");
2902                 goto fail;
2903         }
2904
2905         if (bus_setup_intr(dev, sc->sc_res[CAS_RES_INTR], INTR_TYPE_NET |
2906             INTR_MPSAFE, cas_intr, NULL, sc, &sc->sc_ih) != 0) {
2907                 device_printf(dev, "failed to set up interrupt\n");
2908                 cas_detach(sc);
2909                 goto fail;
2910         }
2911         return (0);
2912
2913  fail:
2914         CAS_LOCK_DESTROY(sc);
2915         bus_release_resources(dev, cas_pci_res_spec, sc->sc_res);
2916         return (ENXIO);
2917 }
2918
2919 static int
2920 cas_pci_detach(device_t dev)
2921 {
2922         struct cas_softc *sc;
2923
2924         sc = device_get_softc(dev);
2925         bus_teardown_intr(dev, sc->sc_res[CAS_RES_INTR], sc->sc_ih);
2926         cas_detach(sc);
2927         CAS_LOCK_DESTROY(sc);
2928         bus_release_resources(dev, cas_pci_res_spec, sc->sc_res);
2929         return (0);
2930 }
2931
2932 static int
2933 cas_pci_suspend(device_t dev)
2934 {
2935
2936         cas_suspend(device_get_softc(dev));
2937         return (0);
2938 }
2939
2940 static int
2941 cas_pci_resume(device_t dev)
2942 {
2943
2944         cas_resume(device_get_softc(dev));
2945         return (0);
2946 }