sys/dev/netif/msk/if_msk.c

   1 /******************************************************************************
   2  *
   3  * Name   : sky2.c
   4  * Project: Gigabit Ethernet Driver for FreeBSD 5.x/6.x
   5  * Version: $Revision: 1.23 $
   6  * Date   : $Date: 2005/12/22 09:04:11 $
   7  * Purpose: Main driver source file
   8  *
   9  *****************************************************************************/
  10
  11 /******************************************************************************
  12  *
  13  *      LICENSE:
  14  *      Copyright (C) Marvell International Ltd. and/or its affiliates
  15  *
  16  *      The computer program files contained in this folder ("Files")
  17  *      are provided to you under the BSD-type license terms provided
  18  *      below, and any use of such Files and any derivative works
  19  *      thereof created by you shall be governed by the following terms
  20  *      and conditions:
  21  *
  22  *      - Redistributions of source code must retain the above copyright
  23  *        notice, this list of conditions and the following disclaimer.
  24  *      - Redistributions in binary form must reproduce the above
  25  *        copyright notice, this list of conditions and the following
  26  *        disclaimer in the documentation and/or other materials provided
  27  *        with the distribution.
  28  *      - Neither the name of Marvell nor the names of its contributors
  29  *        may be used to endorse or promote products derived from this
  30  *        software without specific prior written permission.
  31  *
  32  *      THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  *      "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  *      LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  35  *      FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  36  *      COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  37  *      INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  38  *      BUT NOT LIMITED TO, PROCUREMENT OF  SUBSTITUTE GOODS OR SERVICES;
  39  *      LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40  *      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  41  *      STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  42  *      ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  43  *      OF THE POSSIBILITY OF SUCH DAMAGE.
  44  *      /LICENSE
  45  *
  46  *****************************************************************************/
  47
  48 /*-
  49  * Copyright (c) 1997, 1998, 1999, 2000
  50  *      Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
  51  *
  52  * Redistribution and use in source and binary forms, with or without
  53  * modification, are permitted provided that the following conditions
  54  * are met:
  55  * 1. Redistributions of source code must retain the above copyright
  56  *    notice, this list of conditions and the following disclaimer.
  57  * 2. Redistributions in binary form must reproduce the above copyright
  58  *    notice, this list of conditions and the following disclaimer in the
  59  *    documentation and/or other materials provided with the distribution.
  60  * 3. All advertising materials mentioning features or use of this software
  61  *    must display the following acknowledgement:
  62  *      This product includes software developed by Bill Paul.
  63  * 4. Neither the name of the author nor the names of any co-contributors
  64  *    may be used to endorse or promote products derived from this software
  65  *    without specific prior written permission.
  66  *
  67  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  68  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  69  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  70  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  71  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  72  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  73  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  74  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  75  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  76  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  77  * THE POSSIBILITY OF SUCH DAMAGE.
  78  */
  79 /*-
  80  * Copyright (c) 2003 Nathan L. Binkert <binkertn@umich.edu>
  81  *
  82  * Permission to use, copy, modify, and distribute this software for any
  83  * purpose with or without fee is hereby granted, provided that the above
  84  * copyright notice and this permission notice appear in all copies.
  85  *
  86  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  87  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  88  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  89  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  90  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  91  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  92  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  93  */
  94
  95 /* $FreeBSD: src/sys/dev/msk/if_msk.c,v 1.26 2007/12/05 09:41:58 remko Exp $ */
  96
  97 /*
  98  * Device driver for the Marvell Yukon II Ethernet controller.
  99  * Due to lack of documentation, this driver is based on the code from
 100  * sk(4) and Marvell's myk(4) driver for FreeBSD 5.x.
 101  */
 102
 103 #include <sys/param.h>
 104 #include <sys/endian.h>
 105 #include <sys/kernel.h>
 106 #include <sys/bus.h>
 107 #include <sys/in_cksum.h>
 108 #include <sys/interrupt.h>
 109 #include <sys/malloc.h>
 110 #include <sys/proc.h>
 111 #include <sys/rman.h>
 112 #include <sys/serialize.h>
 113 #include <sys/socket.h>
 114 #include <sys/sockio.h>
 115 #include <sys/sysctl.h>
 116
 117 #include <net/ethernet.h>
 118 #include <net/if.h>
 119 #include <net/bpf.h>
 120 #include <net/if_arp.h>
 121 #include <net/if_dl.h>
 122 #include <net/if_media.h>
 123 #include <net/ifq_var.h>
 124 #include <net/vlan/if_vlan_var.h>
 125
 126 #include <netinet/ip.h>
 127 #include <netinet/ip_var.h>
 128
 129 #include <dev/netif/mii_layer/miivar.h>
 130
 131 #include <bus/pci/pcireg.h>
 132 #include <bus/pci/pcivar.h>
 133
 134 #include "if_mskreg.h"
 135
 136 /* "device miibus" required.  See GENERIC if you get errors here. */
 137 #include "miibus_if.h"
 138
 139 #define MSK_CSUM_FEATURES       (CSUM_TCP | CSUM_UDP)
 140
 141 /*
 142  * Devices supported by this driver.
 143  */
 144 static const struct msk_product {
 145         uint16_t        msk_vendorid;
 146         uint16_t        msk_deviceid;
 147         const char      *msk_name;
 148 } msk_products[] = {
 149         { VENDORID_SK, DEVICEID_SK_YUKON2,
 150             "SK-9Sxx Gigabit Ethernet" },
 151         { VENDORID_SK, DEVICEID_SK_YUKON2_EXPR,
 152             "SK-9Exx Gigabit Ethernet"},
 153         { VENDORID_MARVELL, DEVICEID_MRVL_8021CU,
 154             "Marvell Yukon 88E8021CU Gigabit Ethernet" },
 155         { VENDORID_MARVELL, DEVICEID_MRVL_8021X,
 156             "Marvell Yukon 88E8021 SX/LX Gigabit Ethernet" },
 157         { VENDORID_MARVELL, DEVICEID_MRVL_8022CU,
 158             "Marvell Yukon 88E8022CU Gigabit Ethernet" },
 159         { VENDORID_MARVELL, DEVICEID_MRVL_8022X,
 160             "Marvell Yukon 88E8022 SX/LX Gigabit Ethernet" },
 161         { VENDORID_MARVELL, DEVICEID_MRVL_8061CU,
 162             "Marvell Yukon 88E8061CU Gigabit Ethernet" },
 163         { VENDORID_MARVELL, DEVICEID_MRVL_8061X,
 164             "Marvell Yukon 88E8061 SX/LX Gigabit Ethernet" },
 165         { VENDORID_MARVELL, DEVICEID_MRVL_8062CU,
 166             "Marvell Yukon 88E8062CU Gigabit Ethernet" },
 167         { VENDORID_MARVELL, DEVICEID_MRVL_8062X,
 168             "Marvell Yukon 88E8062 SX/LX Gigabit Ethernet" },
 169         { VENDORID_MARVELL, DEVICEID_MRVL_8035,
 170             "Marvell Yukon 88E8035 Gigabit Ethernet" },
 171         { VENDORID_MARVELL, DEVICEID_MRVL_8036,
 172             "Marvell Yukon 88E8036 Gigabit Ethernet" },
 173         { VENDORID_MARVELL, DEVICEID_MRVL_8038,
 174             "Marvell Yukon 88E8038 Gigabit Ethernet" },
 175         { VENDORID_MARVELL, DEVICEID_MRVL_8039,
 176             "Marvell Yukon 88E8039 Gigabit Ethernet" },
 177         { VENDORID_MARVELL, DEVICEID_MRVL_4361,
 178             "Marvell Yukon 88E8050 Gigabit Ethernet" },
 179         { VENDORID_MARVELL, DEVICEID_MRVL_4360,
 180             "Marvell Yukon 88E8052 Gigabit Ethernet" },
 181         { VENDORID_MARVELL, DEVICEID_MRVL_4362,
 182             "Marvell Yukon 88E8053 Gigabit Ethernet" },
 183         { VENDORID_MARVELL, DEVICEID_MRVL_4363,
 184             "Marvell Yukon 88E8055 Gigabit Ethernet" },
 185         { VENDORID_MARVELL, DEVICEID_MRVL_4364,
 186             "Marvell Yukon 88E8056 Gigabit Ethernet" },
 187         { VENDORID_MARVELL, DEVICEID_MRVL_436A,
 188             "Marvell Yukon 88E8058 Gigabit Ethernet" },
 189         { VENDORID_DLINK, DEVICEID_DLINK_DGE550SX,
 190             "D-Link 550SX Gigabit Ethernet" },
 191         { VENDORID_DLINK, DEVICEID_DLINK_DGE560T,
 192             "D-Link 560T Gigabit Ethernet" },
 193         { 0, 0, NULL }
 194 };
 195
 196 static const char *model_name[] = {
 197         "Yukon XL",
 198         "Yukon EC Ultra",
 199         "Yukon Unknown",
 200         "Yukon EC",
 201         "Yukon FE"
 202 };
 203
 204 static int      mskc_probe(device_t);
 205 static int      mskc_attach(device_t);
 206 static int      mskc_detach(device_t);
 207 static int      mskc_shutdown(device_t);
 208 static int      mskc_suspend(device_t);
 209 static int      mskc_resume(device_t);
 210 static void     mskc_intr(void *);
 211
 212 static void     mskc_reset(struct msk_softc *);
 213 static void     mskc_set_imtimer(struct msk_softc *);
 214 static void     mskc_intr_hwerr(struct msk_softc *);
 215 static int      mskc_handle_events(struct msk_softc *);
 216 static void     mskc_phy_power(struct msk_softc *, int);
 217 static int      mskc_setup_rambuffer(struct msk_softc *);
 218 static int      mskc_status_dma_alloc(struct msk_softc *);
 219 static void     mskc_status_dma_free(struct msk_softc *);
 220 static int      mskc_sysctl_proc_limit(SYSCTL_HANDLER_ARGS);
 221 static int      mskc_sysctl_intr_rate(SYSCTL_HANDLER_ARGS);
 222
 223 static int      msk_probe(device_t);
 224 static int      msk_attach(device_t);
 225 static int      msk_detach(device_t);
 226 static int      msk_miibus_readreg(device_t, int, int);
 227 static int      msk_miibus_writereg(device_t, int, int, int);
 228 static void     msk_miibus_statchg(device_t);
 229
 230 static void     msk_init(void *);
 231 static int      msk_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 232 static void     msk_start(struct ifnet *);
 233 static void     msk_watchdog(struct ifnet *);
 234 static int      msk_mediachange(struct ifnet *);
 235 static void     msk_mediastatus(struct ifnet *, struct ifmediareq *);
 236
 237 static void     msk_tick(void *);
 238 static void     msk_intr_phy(struct msk_if_softc *);
 239 static void     msk_intr_gmac(struct msk_if_softc *);
 240 static __inline void
 241                 msk_rxput(struct msk_if_softc *);
 242 static void     msk_handle_hwerr(struct msk_if_softc *, uint32_t);
 243 static void     msk_rxeof(struct msk_if_softc *, uint32_t, int,
 244                           struct mbuf_chain *);
 245 static void     msk_txeof(struct msk_if_softc *, int);
 246 static void     msk_set_prefetch(struct msk_softc *, int, bus_addr_t, uint32_t);
 247 static void     msk_set_rambuffer(struct msk_if_softc *);
 248 static void     msk_stop(struct msk_if_softc *);
 249
 250 static int      msk_txrx_dma_alloc(struct msk_if_softc *);
 251 static void     msk_txrx_dma_free(struct msk_if_softc *);
 252 static int      msk_init_rx_ring(struct msk_if_softc *);
 253 static void     msk_init_tx_ring(struct msk_if_softc *);
 254 static __inline void
 255                 msk_discard_rxbuf(struct msk_if_softc *, int);
 256 static int      msk_newbuf(struct msk_if_softc *, int, int);
 257 static int      msk_encap(struct msk_if_softc *, struct mbuf **);
 258
 259 #ifdef MSK_JUMBO
 260 static int msk_init_jumbo_rx_ring(struct msk_if_softc *);
 261 static __inline void msk_discard_jumbo_rxbuf(struct msk_if_softc *, int);
 262 static int msk_jumbo_newbuf(struct msk_if_softc *, int);
 263 static void msk_jumbo_rxeof(struct msk_if_softc *, uint32_t, int);
 264 static void *msk_jalloc(struct msk_if_softc *);
 265 static void msk_jfree(void *, void *);
 266 #endif
 267
 268 static int      msk_phy_readreg(struct msk_if_softc *, int, int);
 269 static int      msk_phy_writereg(struct msk_if_softc *, int, int, int);
 270
 271 static void     msk_setmulti(struct msk_if_softc *);
 272 static void     msk_setvlan(struct msk_if_softc *, struct ifnet *);
 273 static void     msk_setpromisc(struct msk_if_softc *);
 274
 275 static int      msk_dmamem_create(device_t, bus_size_t, bus_dma_tag_t *,
 276                                   void **, bus_addr_t *, bus_dmamap_t *);
 277 static void     msk_dmamem_destroy(bus_dma_tag_t, void *, bus_dmamap_t);
 278
 279 static device_method_t mskc_methods[] = {
 280         /* Device interface */
 281         DEVMETHOD(device_probe,         mskc_probe),
 282         DEVMETHOD(device_attach,        mskc_attach),
 283         DEVMETHOD(device_detach,        mskc_detach),
 284         DEVMETHOD(device_suspend,       mskc_suspend),
 285         DEVMETHOD(device_resume,        mskc_resume),
 286         DEVMETHOD(device_shutdown,      mskc_shutdown),
 287
 288         /* bus interface */
 289         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 290         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 291
 292         { NULL, NULL }
 293 };
 294
 295 static DEFINE_CLASS_0(mskc, mskc_driver, mskc_methods, sizeof(struct msk_softc));
 296 static devclass_t mskc_devclass;
 297
 298 static device_method_t msk_methods[] = {
 299         /* Device interface */
 300         DEVMETHOD(device_probe,         msk_probe),
 301         DEVMETHOD(device_attach,        msk_attach),
 302         DEVMETHOD(device_detach,        msk_detach),
 303         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 304
 305         /* bus interface */
 306         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 307         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 308
 309         /* MII interface */
 310         DEVMETHOD(miibus_readreg,       msk_miibus_readreg),
 311         DEVMETHOD(miibus_writereg,      msk_miibus_writereg),
 312         DEVMETHOD(miibus_statchg,       msk_miibus_statchg),
 313
 314         { NULL, NULL }
 315 };
 316
 317 static DEFINE_CLASS_0(msk, msk_driver, msk_methods, sizeof(struct msk_if_softc));
 318 static devclass_t msk_devclass;
 319
 320 DECLARE_DUMMY_MODULE(if_msk);
 321 DRIVER_MODULE(if_msk, pci, mskc_driver, mskc_devclass, NULL, NULL);
 322 DRIVER_MODULE(if_msk, mskc, msk_driver, msk_devclass, NULL, NULL);
 323 DRIVER_MODULE(miibus, msk, miibus_driver, miibus_devclass, NULL, NULL);
 324
 325 static int      mskc_intr_rate = 0;
 326 static int      mskc_process_limit = MSK_PROC_DEFAULT;
 327
 328 TUNABLE_INT("hw.mskc.intr_rate", &mskc_intr_rate);
 329 TUNABLE_INT("hw.mskc.process_limit", &mskc_process_limit);
 330
 331 static int
 332 msk_miibus_readreg(device_t dev, int phy, int reg)
 333 {
 334         struct msk_if_softc *sc_if;
 335
 336         if (phy != PHY_ADDR_MARV)
 337                 return (0);
 338
 339         sc_if = device_get_softc(dev);
 340
 341         return (msk_phy_readreg(sc_if, phy, reg));
 342 }
 343
 344 static int
 345 msk_phy_readreg(struct msk_if_softc *sc_if, int phy, int reg)
 346 {
 347         struct msk_softc *sc;
 348         int i, val;
 349
 350         sc = sc_if->msk_softc;
 351
 352         GMAC_WRITE_2(sc, sc_if->msk_port, GM_SMI_CTRL,
 353             GM_SMI_CT_PHY_AD(phy) | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD);
 354
 355         for (i = 0; i < MSK_TIMEOUT; i++) {
 356                 DELAY(1);
 357                 val = GMAC_READ_2(sc, sc_if->msk_port, GM_SMI_CTRL);
 358                 if ((val & GM_SMI_CT_RD_VAL) != 0) {
 359                         val = GMAC_READ_2(sc, sc_if->msk_port, GM_SMI_DATA);
 360                         break;
 361                 }
 362         }
 363
 364         if (i == MSK_TIMEOUT) {
 365                 if_printf(sc_if->msk_ifp, "phy failed to come ready\n");
 366                 val = 0;
 367         }
 368
 369         return (val);
 370 }
 371
 372 static int
 373 msk_miibus_writereg(device_t dev, int phy, int reg, int val)
 374 {
 375         struct msk_if_softc *sc_if;
 376
 377         if (phy != PHY_ADDR_MARV)
 378                 return (0);
 379
 380         sc_if = device_get_softc(dev);
 381
 382         return (msk_phy_writereg(sc_if, phy, reg, val));
 383 }
 384
 385 static int
 386 msk_phy_writereg(struct msk_if_softc *sc_if, int phy, int reg, int val)
 387 {
 388         struct msk_softc *sc;
 389         int i;
 390
 391         sc = sc_if->msk_softc;
 392
 393         GMAC_WRITE_2(sc, sc_if->msk_port, GM_SMI_DATA, val);
 394         GMAC_WRITE_2(sc, sc_if->msk_port, GM_SMI_CTRL,
 395             GM_SMI_CT_PHY_AD(phy) | GM_SMI_CT_REG_AD(reg));
 396         for (i = 0; i < MSK_TIMEOUT; i++) {
 397                 DELAY(1);
 398                 if ((GMAC_READ_2(sc, sc_if->msk_port, GM_SMI_CTRL) &
 399                     GM_SMI_CT_BUSY) == 0)
 400                         break;
 401         }
 402         if (i == MSK_TIMEOUT)
 403                 if_printf(sc_if->msk_ifp, "phy write timeout\n");
 404
 405         return (0);
 406 }
 407
 408 static void
 409 msk_miibus_statchg(device_t dev)
 410 {
 411         struct msk_if_softc *sc_if;
 412         struct msk_softc *sc;
 413         struct mii_data *mii;
 414         struct ifnet *ifp;
 415         uint32_t gmac;
 416
 417         sc_if = device_get_softc(dev);
 418         sc = sc_if->msk_softc;
 419
 420         mii = device_get_softc(sc_if->msk_miibus);
 421         ifp = sc_if->msk_ifp;
 422
 423         if (mii->mii_media_status & IFM_ACTIVE) {
 424                 if (IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE)
 425                         sc_if->msk_link = 1;
 426         } else
 427                 sc_if->msk_link = 0;
 428
 429         if (sc_if->msk_link != 0) {
 430                 /* Enable Tx FIFO Underrun. */
 431                 CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, GMAC_IRQ_MSK),
 432                     GM_IS_TX_FF_UR | GM_IS_RX_FF_OR);
 433                 /*
 434                  * Because mii(4) notify msk(4) that it detected link status
 435                  * change, there is no need to enable automatic
 436                  * speed/flow-control/duplex updates.
 437                  */
 438                 gmac = GM_GPCR_AU_ALL_DIS;
 439                 switch (IFM_SUBTYPE(mii->mii_media_active)) {
 440                 case IFM_1000_SX:
 441                 case IFM_1000_T:
 442                         gmac |= GM_GPCR_SPEED_1000;
 443                         break;
 444                 case IFM_100_TX:
 445                         gmac |= GM_GPCR_SPEED_100;
 446                         break;
 447                 case IFM_10_T:
 448                         break;
 449                 }
 450
 451                 if (((mii->mii_media_active & IFM_GMASK) & IFM_FDX) != 0)
 452                         gmac |= GM_GPCR_DUP_FULL;
 453                 /* Disable Rx flow control. */
 454                 if (((mii->mii_media_active & IFM_GMASK) & IFM_FLAG0) == 0)
 455                         gmac |= GM_GPCR_FC_RX_DIS;
 456                 /* Disable Tx flow control. */
 457                 if (((mii->mii_media_active & IFM_GMASK) & IFM_FLAG1) == 0)
 458                         gmac |= GM_GPCR_FC_TX_DIS;
 459                 gmac |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA;
 460                 GMAC_WRITE_2(sc, sc_if->msk_port, GM_GP_CTRL, gmac);
 461                 /* Read again to ensure writing. */
 462                 GMAC_READ_2(sc, sc_if->msk_port, GM_GP_CTRL);
 463
 464                 gmac = GMC_PAUSE_ON;
 465                 if (((mii->mii_media_active & IFM_GMASK) &
 466                     (IFM_FLAG0 | IFM_FLAG1)) == 0)
 467                         gmac = GMC_PAUSE_OFF;
 468                 /* Diable pause for 10/100 Mbps in half-duplex mode. */
 469                 if ((((mii->mii_media_active & IFM_GMASK) & IFM_FDX) == 0) &&
 470                     (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX ||
 471                     IFM_SUBTYPE(mii->mii_media_active) == IFM_10_T))
 472                         gmac = GMC_PAUSE_OFF;
 473                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, GMAC_CTRL), gmac);
 474
 475                 /* Enable PHY interrupt for FIFO underrun/overflow. */
 476                 msk_phy_writereg(sc_if, PHY_ADDR_MARV,
 477                     PHY_MARV_INT_MASK, PHY_M_IS_FIFO_ERROR);
 478         } else {
 479                 /*
 480                  * Link state changed to down.
 481                  * Disable PHY interrupts.
 482                  */
 483                 msk_phy_writereg(sc_if, PHY_ADDR_MARV, PHY_MARV_INT_MASK, 0);
 484                 /* Disable Rx/Tx MAC. */
 485                 gmac = GMAC_READ_2(sc, sc_if->msk_port, GM_GP_CTRL);
 486                 gmac &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
 487                 GMAC_WRITE_2(sc, sc_if->msk_port, GM_GP_CTRL, gmac);
 488                 /* Read again to ensure writing. */
 489                 GMAC_READ_2(sc, sc_if->msk_port, GM_GP_CTRL);
 490         }
 491 }
 492
 493 static void
 494 msk_setmulti(struct msk_if_softc *sc_if)
 495 {
 496         struct msk_softc *sc;
 497         struct ifnet *ifp;
 498         struct ifmultiaddr *ifma;
 499         uint32_t mchash[2];
 500         uint32_t crc;
 501         uint16_t mode;
 502
 503         sc = sc_if->msk_softc;
 504         ifp = sc_if->msk_ifp;
 505
 506         bzero(mchash, sizeof(mchash));
 507         mode = GMAC_READ_2(sc, sc_if->msk_port, GM_RX_CTRL);
 508         mode |= GM_RXCR_UCF_ENA;
 509         if ((ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI)) != 0) {
 510                 if ((ifp->if_flags & IFF_PROMISC) != 0)
 511                         mode &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
 512                 else if ((ifp->if_flags & IFF_ALLMULTI) != 0) {
 513                         mchash[0] = 0xffff;
 514                         mchash[1] = 0xffff;
 515                 }
 516         } else {
 517                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 518                         if (ifma->ifma_addr->sa_family != AF_LINK)
 519                                 continue;
 520                         crc = ether_crc32_be(LLADDR((struct sockaddr_dl *)
 521                             ifma->ifma_addr), ETHER_ADDR_LEN);
 522                         /* Just want the 6 least significant bits. */
 523                         crc &= 0x3f;
 524                         /* Set the corresponding bit in the hash table. */
 525                         mchash[crc >> 5] |= 1 << (crc & 0x1f);
 526                 }
 527                 mode |= GM_RXCR_MCF_ENA;
 528         }
 529
 530         GMAC_WRITE_2(sc, sc_if->msk_port, GM_MC_ADDR_H1,
 531             mchash[0] & 0xffff);
 532         GMAC_WRITE_2(sc, sc_if->msk_port, GM_MC_ADDR_H2,
 533             (mchash[0] >> 16) & 0xffff);
 534         GMAC_WRITE_2(sc, sc_if->msk_port, GM_MC_ADDR_H3,
 535             mchash[1] & 0xffff);
 536         GMAC_WRITE_2(sc, sc_if->msk_port, GM_MC_ADDR_H4,
 537             (mchash[1] >> 16) & 0xffff);
 538         GMAC_WRITE_2(sc, sc_if->msk_port, GM_RX_CTRL, mode);
 539 }
 540
 541 static void
 542 msk_setvlan(struct msk_if_softc *sc_if, struct ifnet *ifp)
 543 {
 544         struct msk_softc *sc;
 545
 546         sc = sc_if->msk_softc;
 547         if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) {
 548                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T),
 549                     RX_VLAN_STRIP_ON);
 550                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
 551                     TX_VLAN_TAG_ON);
 552         } else {
 553                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T),
 554                     RX_VLAN_STRIP_OFF);
 555                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
 556                     TX_VLAN_TAG_OFF);
 557         }
 558 }
 559
 560 static void
 561 msk_setpromisc(struct msk_if_softc *sc_if)
 562 {
 563         struct msk_softc *sc;
 564         struct ifnet *ifp;
 565         uint16_t mode;
 566
 567         sc = sc_if->msk_softc;
 568         ifp = sc_if->msk_ifp;
 569
 570         mode = GMAC_READ_2(sc, sc_if->msk_port, GM_RX_CTRL);
 571         if (ifp->if_flags & IFF_PROMISC)
 572                 mode &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
 573         else
 574                 mode |= (GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
 575         GMAC_WRITE_2(sc, sc_if->msk_port, GM_RX_CTRL, mode);
 576 }
 577
 578 static int
 579 msk_init_rx_ring(struct msk_if_softc *sc_if)
 580 {
 581         struct msk_ring_data *rd;
 582         struct msk_rxdesc *rxd;
 583         int i, prod;
 584
 585         sc_if->msk_cdata.msk_rx_cons = 0;
 586         sc_if->msk_cdata.msk_rx_prod = 0;
 587         sc_if->msk_cdata.msk_rx_putwm = MSK_PUT_WM;
 588
 589         rd = &sc_if->msk_rdata;
 590         bzero(rd->msk_rx_ring, sizeof(struct msk_rx_desc) * MSK_RX_RING_CNT);
 591         prod = sc_if->msk_cdata.msk_rx_prod;
 592         for (i = 0; i < MSK_RX_RING_CNT; i++) {
 593                 rxd = &sc_if->msk_cdata.msk_rxdesc[prod];
 594                 rxd->rx_m = NULL;
 595                 rxd->rx_le = &rd->msk_rx_ring[prod];
 596                 if (msk_newbuf(sc_if, prod, 1) != 0)
 597                         return (ENOBUFS);
 598                 MSK_INC(prod, MSK_RX_RING_CNT);
 599         }
 600
 601         /* Update prefetch unit. */
 602         sc_if->msk_cdata.msk_rx_prod = MSK_RX_RING_CNT - 1;
 603         CSR_WRITE_2(sc_if->msk_softc,
 604             Y2_PREF_Q_ADDR(sc_if->msk_rxq, PREF_UNIT_PUT_IDX_REG),
 605             sc_if->msk_cdata.msk_rx_prod);
 606
 607         return (0);
 608 }
 609
 610 #ifdef MSK_JUMBO
 611 static int
 612 msk_init_jumbo_rx_ring(struct msk_if_softc *sc_if)
 613 {
 614         struct msk_ring_data *rd;
 615         struct msk_rxdesc *rxd;
 616         int i, prod;
 617
 618         MSK_IF_LOCK_ASSERT(sc_if);
 619
 620         sc_if->msk_cdata.msk_rx_cons = 0;
 621         sc_if->msk_cdata.msk_rx_prod = 0;
 622         sc_if->msk_cdata.msk_rx_putwm = MSK_PUT_WM;
 623
 624         rd = &sc_if->msk_rdata;
 625         bzero(rd->msk_jumbo_rx_ring,
 626             sizeof(struct msk_rx_desc) * MSK_JUMBO_RX_RING_CNT);
 627         prod = sc_if->msk_cdata.msk_rx_prod;
 628         for (i = 0; i < MSK_JUMBO_RX_RING_CNT; i++) {
 629                 rxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[prod];
 630                 rxd->rx_m = NULL;
 631                 rxd->rx_le = &rd->msk_jumbo_rx_ring[prod];
 632                 if (msk_jumbo_newbuf(sc_if, prod) != 0)
 633                         return (ENOBUFS);
 634                 MSK_INC(prod, MSK_JUMBO_RX_RING_CNT);
 635         }
 636
 637         bus_dmamap_sync(sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
 638             sc_if->msk_cdata.msk_jumbo_rx_ring_map,
 639             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 640
 641         sc_if->msk_cdata.msk_rx_prod = MSK_JUMBO_RX_RING_CNT - 1;
 642         CSR_WRITE_2(sc_if->msk_softc,
 643             Y2_PREF_Q_ADDR(sc_if->msk_rxq, PREF_UNIT_PUT_IDX_REG),
 644             sc_if->msk_cdata.msk_rx_prod);
 645
 646         return (0);
 647 }
 648 #endif
 649
 650 static void
 651 msk_init_tx_ring(struct msk_if_softc *sc_if)
 652 {
 653         struct msk_ring_data *rd;
 654         struct msk_txdesc *txd;
 655         int i;
 656
 657         sc_if->msk_cdata.msk_tx_prod = 0;
 658         sc_if->msk_cdata.msk_tx_cons = 0;
 659         sc_if->msk_cdata.msk_tx_cnt = 0;
 660
 661         rd = &sc_if->msk_rdata;
 662         bzero(rd->msk_tx_ring, sizeof(struct msk_tx_desc) * MSK_TX_RING_CNT);
 663         for (i = 0; i < MSK_TX_RING_CNT; i++) {
 664                 txd = &sc_if->msk_cdata.msk_txdesc[i];
 665                 txd->tx_m = NULL;
 666                 txd->tx_le = &rd->msk_tx_ring[i];
 667         }
 668 }
 669
 670 static __inline void
 671 msk_discard_rxbuf(struct msk_if_softc *sc_if, int idx)
 672 {
 673         struct msk_rx_desc *rx_le;
 674         struct msk_rxdesc *rxd;
 675         struct mbuf *m;
 676
 677         rxd = &sc_if->msk_cdata.msk_rxdesc[idx];
 678         m = rxd->rx_m;
 679         rx_le = rxd->rx_le;
 680         rx_le->msk_control = htole32(m->m_len | OP_PACKET | HW_OWNER);
 681 }
 682
 683 #ifdef MSK_JUMBO
 684 static __inline void
 685 msk_discard_jumbo_rxbuf(struct msk_if_softc *sc_if, int idx)
 686 {
 687         struct msk_rx_desc *rx_le;
 688         struct msk_rxdesc *rxd;
 689         struct mbuf *m;
 690
 691         rxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[idx];
 692         m = rxd->rx_m;
 693         rx_le = rxd->rx_le;
 694         rx_le->msk_control = htole32(m->m_len | OP_PACKET | HW_OWNER);
 695 }
 696 #endif
 697
 698 static int
 699 msk_newbuf(struct msk_if_softc *sc_if, int idx, int init)
 700 {
 701         struct msk_rx_desc *rx_le;
 702         struct msk_rxdesc *rxd;
 703         struct mbuf *m;
 704         bus_dma_segment_t seg;
 705         bus_dmamap_t map;
 706         int error, nseg;
 707
 708         m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
 709         if (m == NULL)
 710                 return (ENOBUFS);
 711
 712         m->m_len = m->m_pkthdr.len = MCLBYTES;
 713         if ((sc_if->msk_flags & MSK_FLAG_RAMBUF) == 0)
 714                 m_adj(m, ETHER_ALIGN);
 715
 716         error = bus_dmamap_load_mbuf_segment(sc_if->msk_cdata.msk_rx_tag,
 717                         sc_if->msk_cdata.msk_rx_sparemap,
 718                         m, &seg, 1, &nseg, BUS_DMA_NOWAIT);
 719         if (error) {
 720                 m_freem(m);
 721                 if (init)
 722                         if_printf(&sc_if->arpcom.ac_if, "can't load RX mbuf\n");
 723                 return (error);
 724         }
 725
 726         rxd = &sc_if->msk_cdata.msk_rxdesc[idx];
 727         if (rxd->rx_m != NULL) {
 728                 bus_dmamap_sync(sc_if->msk_cdata.msk_rx_tag, rxd->rx_dmamap,
 729                     BUS_DMASYNC_POSTREAD);
 730                 bus_dmamap_unload(sc_if->msk_cdata.msk_rx_tag, rxd->rx_dmamap);
 731         }
 732
 733         map = rxd->rx_dmamap;
 734         rxd->rx_dmamap = sc_if->msk_cdata.msk_rx_sparemap;
 735         sc_if->msk_cdata.msk_rx_sparemap = map;
 736
 737         rxd->rx_m = m;
 738         rx_le = rxd->rx_le;
 739         rx_le->msk_addr = htole32(MSK_ADDR_LO(seg.ds_addr));
 740         rx_le->msk_control = htole32(seg.ds_len | OP_PACKET | HW_OWNER);
 741
 742         return (0);
 743 }
 744
 745 #ifdef MSK_JUMBO
 746 static int
 747 msk_jumbo_newbuf(struct msk_if_softc *sc_if, int idx)
 748 {
 749         struct msk_rx_desc *rx_le;
 750         struct msk_rxdesc *rxd;
 751         struct mbuf *m;
 752         bus_dma_segment_t segs[1];
 753         bus_dmamap_t map;
 754         int nsegs;
 755         void *buf;
 756
 757         MGETHDR(m, M_DONTWAIT, MT_DATA);
 758         if (m == NULL)
 759                 return (ENOBUFS);
 760         buf = msk_jalloc(sc_if);
 761         if (buf == NULL) {
 762                 m_freem(m);
 763                 return (ENOBUFS);
 764         }
 765         /* Attach the buffer to the mbuf. */
 766         MEXTADD(m, buf, MSK_JLEN, msk_jfree, (struct msk_if_softc *)sc_if, 0,
 767             EXT_NET_DRV);
 768         if ((m->m_flags & M_EXT) == 0) {
 769                 m_freem(m);
 770                 return (ENOBUFS);
 771         }
 772         m->m_pkthdr.len = m->m_len = MSK_JLEN;
 773         m_adj(m, ETHER_ALIGN);
 774
 775         if (bus_dmamap_load_mbuf_sg(sc_if->msk_cdata.msk_jumbo_rx_tag,
 776             sc_if->msk_cdata.msk_jumbo_rx_sparemap, m, segs, &nsegs,
 777             BUS_DMA_NOWAIT) != 0) {
 778                 m_freem(m);
 779                 return (ENOBUFS);
 780         }
 781         KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
 782
 783         rxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[idx];
 784         if (rxd->rx_m != NULL) {
 785                 bus_dmamap_sync(sc_if->msk_cdata.msk_jumbo_rx_tag,
 786                     rxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
 787                 bus_dmamap_unload(sc_if->msk_cdata.msk_jumbo_rx_tag,
 788                     rxd->rx_dmamap);
 789         }
 790         map = rxd->rx_dmamap;
 791         rxd->rx_dmamap = sc_if->msk_cdata.msk_jumbo_rx_sparemap;
 792         sc_if->msk_cdata.msk_jumbo_rx_sparemap = map;
 793         bus_dmamap_sync(sc_if->msk_cdata.msk_jumbo_rx_tag, rxd->rx_dmamap,
 794             BUS_DMASYNC_PREREAD);
 795         rxd->rx_m = m;
 796         rx_le = rxd->rx_le;
 797         rx_le->msk_addr = htole32(MSK_ADDR_LO(segs[0].ds_addr));
 798         rx_le->msk_control =
 799             htole32(segs[0].ds_len | OP_PACKET | HW_OWNER);
 800
 801         return (0);
 802 }
 803 #endif
 804
 805 /*
 806  * Set media options.
 807  */
 808 static int
 809 msk_mediachange(struct ifnet *ifp)
 810 {
 811         struct msk_if_softc *sc_if = ifp->if_softc;
 812         struct mii_data *mii;
 813         int error;
 814
 815         mii = device_get_softc(sc_if->msk_miibus);
 816         error = mii_mediachg(mii);
 817
 818         return (error);
 819 }
 820
 821 /*
 822  * Report current media status.
 823  */
 824 static void
 825 msk_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
 826 {
 827         struct msk_if_softc *sc_if = ifp->if_softc;
 828         struct mii_data *mii;
 829
 830         mii = device_get_softc(sc_if->msk_miibus);
 831         mii_pollstat(mii);
 832
 833         ifmr->ifm_active = mii->mii_media_active;
 834         ifmr->ifm_status = mii->mii_media_status;
 835 }
 836
 837 static int
 838 msk_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
 839 {
 840         struct msk_if_softc *sc_if;
 841         struct ifreq *ifr;
 842         struct mii_data *mii;
 843         int error, mask;
 844
 845         sc_if = ifp->if_softc;
 846         ifr = (struct ifreq *)data;
 847         error = 0;
 848
 849         switch(command) {
 850         case SIOCSIFMTU:
 851 #ifdef MSK_JUMBO
 852                 if (ifr->ifr_mtu > MSK_JUMBO_MTU || ifr->ifr_mtu < ETHERMIN) {
 853                         error = EINVAL;
 854                         break;
 855                 }
 856                 if (sc_if->msk_softc->msk_hw_id == CHIP_ID_YUKON_FE &&
 857                     ifr->ifr_mtu > MSK_MAX_FRAMELEN) {
 858                         error = EINVAL;
 859                         break;
 860                 }
 861                 ifp->if_mtu = ifr->ifr_mtu;
 862                 if ((ifp->if_flags & IFF_RUNNING) != 0)
 863                         msk_init(sc_if);
 864 #else
 865                 error = EOPNOTSUPP;
 866 #endif
 867                 break;
 868
 869         case SIOCSIFFLAGS:
 870                 if (ifp->if_flags & IFF_UP) {
 871                         if (ifp->if_flags & IFF_RUNNING) {
 872                                 if (((ifp->if_flags ^ sc_if->msk_if_flags)
 873                                     & IFF_PROMISC) != 0) {
 874                                         msk_setpromisc(sc_if);
 875                                         msk_setmulti(sc_if);
 876                                 }
 877                         } else {
 878                                 if (sc_if->msk_detach == 0)
 879                                         msk_init(sc_if);
 880                         }
 881                 } else {
 882                         if (ifp->if_flags & IFF_RUNNING)
 883                                 msk_stop(sc_if);
 884                 }
 885                 sc_if->msk_if_flags = ifp->if_flags;
 886                 break;
 887
 888         case SIOCADDMULTI:
 889         case SIOCDELMULTI:
 890                 if (ifp->if_flags & IFF_RUNNING)
 891                         msk_setmulti(sc_if);
 892                 break;
 893
 894         case SIOCGIFMEDIA:
 895         case SIOCSIFMEDIA:
 896                 mii = device_get_softc(sc_if->msk_miibus);
 897                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
 898                 break;
 899
 900         case SIOCSIFCAP:
 901                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
 902                 if ((mask & IFCAP_TXCSUM) != 0) {
 903                         ifp->if_capenable ^= IFCAP_TXCSUM;
 904                         if ((IFCAP_TXCSUM & ifp->if_capenable) != 0 &&
 905                             (IFCAP_TXCSUM & ifp->if_capabilities) != 0)
 906                                 ifp->if_hwassist |= MSK_CSUM_FEATURES;
 907                         else
 908                                 ifp->if_hwassist &= ~MSK_CSUM_FEATURES;
 909                 }
 910 #ifdef notyet
 911                 if ((mask & IFCAP_VLAN_HWTAGGING) != 0) {
 912                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 913                         msk_setvlan(sc_if, ifp);
 914                 }
 915 #endif
 916
 917                 if (sc_if->msk_framesize > MSK_MAX_FRAMELEN &&
 918                     sc_if->msk_softc->msk_hw_id == CHIP_ID_YUKON_EC_U) {
 919                         /*
 920                          * In Yukon EC Ultra, TSO & checksum offload is not
 921                          * supported for jumbo frame.
 922                          */
 923                         ifp->if_hwassist &= ~MSK_CSUM_FEATURES;
 924                         ifp->if_capenable &= ~IFCAP_TXCSUM;
 925                 }
 926                 break;
 927
 928         default:
 929                 error = ether_ioctl(ifp, command, data);
 930                 break;
 931         }
 932
 933         return (error);
 934 }
 935
 936 static int
 937 mskc_probe(device_t dev)
 938 {
 939         const struct msk_product *mp;
 940         uint16_t vendor, devid;
 941
 942         vendor = pci_get_vendor(dev);
 943         devid = pci_get_device(dev);
 944         for (mp = msk_products; mp->msk_name != NULL; ++mp) {
 945                 if (vendor == mp->msk_vendorid && devid == mp->msk_deviceid) {
 946                         device_set_desc(dev, mp->msk_name);
 947                         return (0);
 948                 }
 949         }
 950         return (ENXIO);
 951 }
 952
 953 static int
 954 mskc_setup_rambuffer(struct msk_softc *sc)
 955 {
 956         int next;
 957         int i;
 958
 959         /* Get adapter SRAM size. */
 960         sc->msk_ramsize = CSR_READ_1(sc, B2_E_0) * 4;
 961         if (bootverbose) {
 962                 device_printf(sc->msk_dev,
 963                     "RAM buffer size : %dKB\n", sc->msk_ramsize);
 964         }
 965         if (sc->msk_ramsize == 0)
 966                 return (0);
 967         sc->msk_pflags |= MSK_FLAG_RAMBUF;
 968
 969         /*
 970          * Give receiver 2/3 of memory and round down to the multiple
 971          * of 1024. Tx/Rx RAM buffer size of Yukon II shoud be multiple
 972          * of 1024.
 973          */
 974         sc->msk_rxqsize = rounddown((sc->msk_ramsize * 1024 * 2) / 3, 1024);
 975         sc->msk_txqsize = (sc->msk_ramsize * 1024) - sc->msk_rxqsize;
 976         for (i = 0, next = 0; i < sc->msk_num_port; i++) {
 977                 sc->msk_rxqstart[i] = next;
 978                 sc->msk_rxqend[i] = next + sc->msk_rxqsize - 1;
 979                 next = sc->msk_rxqend[i] + 1;
 980                 sc->msk_txqstart[i] = next;
 981                 sc->msk_txqend[i] = next + sc->msk_txqsize - 1;
 982                 next = sc->msk_txqend[i] + 1;
 983                 if (bootverbose) {
 984                         device_printf(sc->msk_dev,
 985                             "Port %d : Rx Queue %dKB(0x%08x:0x%08x)\n", i,
 986                             sc->msk_rxqsize / 1024, sc->msk_rxqstart[i],
 987                             sc->msk_rxqend[i]);
 988                         device_printf(sc->msk_dev,
 989                             "Port %d : Tx Queue %dKB(0x%08x:0x%08x)\n", i,
 990                             sc->msk_txqsize / 1024, sc->msk_txqstart[i],
 991                             sc->msk_txqend[i]);
 992                 }
 993         }
 994
 995         return (0);
 996 }
 997
 998 static void
 999 mskc_phy_power(struct msk_softc *sc, int mode)
1000 {
1001         uint32_t val;
1002         int i;
1003
1004         switch (mode) {
1005         case MSK_PHY_POWERUP:
1006                 /* Switch power to VCC (WA for VAUX problem). */
1007                 CSR_WRITE_1(sc, B0_POWER_CTRL,
1008                     PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON);
1009                 /* Disable Core Clock Division, set Clock Select to 0. */
1010                 CSR_WRITE_4(sc, B2_Y2_CLK_CTRL, Y2_CLK_DIV_DIS);
1011
1012                 val = 0;
1013                 if (sc->msk_hw_id == CHIP_ID_YUKON_XL &&
1014                     sc->msk_hw_rev > CHIP_REV_YU_XL_A1) {
1015                         /* Enable bits are inverted. */
1016                         val = Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
1017                               Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
1018                               Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS;
1019                 }
1020                 /*
1021                  * Enable PCI & Core Clock, enable clock gating for both Links.
1022                  */
1023                 CSR_WRITE_1(sc, B2_Y2_CLK_GATE, val);
1024
1025                 val = pci_read_config(sc->msk_dev, PCI_OUR_REG_1, 4);
1026                 val &= ~(PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD);
1027                 if (sc->msk_hw_id == CHIP_ID_YUKON_XL &&
1028                     sc->msk_hw_rev > CHIP_REV_YU_XL_A1) {
1029                         /* Deassert Low Power for 1st PHY. */
1030                         val |= PCI_Y2_PHY1_COMA;
1031                         if (sc->msk_num_port > 1)
1032                                 val |= PCI_Y2_PHY2_COMA;
1033                 } else if (sc->msk_hw_id == CHIP_ID_YUKON_EC_U) {
1034                         uint32_t our;
1035
1036                         CSR_WRITE_2(sc, B0_CTST, Y2_HW_WOL_ON);
1037
1038                         /* Enable all clocks. */
1039                         pci_write_config(sc->msk_dev, PCI_OUR_REG_3, 0, 4);
1040                         our = pci_read_config(sc->msk_dev, PCI_OUR_REG_4, 4);
1041                         our &= (PCI_FORCE_ASPM_REQUEST|PCI_ASPM_GPHY_LINK_DOWN|
1042                             PCI_ASPM_INT_FIFO_EMPTY|PCI_ASPM_CLKRUN_REQUEST);
1043                         /* Set all bits to 0 except bits 15..12. */
1044                         pci_write_config(sc->msk_dev, PCI_OUR_REG_4, our, 4);
1045                         /* Set to default value. */
1046                         pci_write_config(sc->msk_dev, PCI_OUR_REG_5, 0, 4);
1047                 }
1048                 /* Release PHY from PowerDown/COMA mode. */
1049                 pci_write_config(sc->msk_dev, PCI_OUR_REG_1, val, 4);
1050                 for (i = 0; i < sc->msk_num_port; i++) {
1051                         CSR_WRITE_2(sc, MR_ADDR(i, GMAC_LINK_CTRL),
1052                             GMLC_RST_SET);
1053                         CSR_WRITE_2(sc, MR_ADDR(i, GMAC_LINK_CTRL),
1054                             GMLC_RST_CLR);
1055                 }
1056                 break;
1057         case MSK_PHY_POWERDOWN:
1058                 val = pci_read_config(sc->msk_dev, PCI_OUR_REG_1, 4);
1059                 val |= PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD;
1060                 if (sc->msk_hw_id == CHIP_ID_YUKON_XL &&
1061                     sc->msk_hw_rev > CHIP_REV_YU_XL_A1) {
1062                         val &= ~PCI_Y2_PHY1_COMA;
1063                         if (sc->msk_num_port > 1)
1064                                 val &= ~PCI_Y2_PHY2_COMA;
1065                 }
1066                 pci_write_config(sc->msk_dev, PCI_OUR_REG_1, val, 4);
1067
1068                 val = Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS |
1069                       Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS |
1070                       Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS;
1071                 if (sc->msk_hw_id == CHIP_ID_YUKON_XL &&
1072                     sc->msk_hw_rev > CHIP_REV_YU_XL_A1) {
1073                         /* Enable bits are inverted. */
1074                         val = 0;
1075                 }
1076                 /*
1077                  * Disable PCI & Core Clock, disable clock gating for
1078                  * both Links.
1079                  */
1080                 CSR_WRITE_1(sc, B2_Y2_CLK_GATE, val);
1081                 CSR_WRITE_1(sc, B0_POWER_CTRL,
1082                     PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_ON | PC_VCC_OFF);
1083                 break;
1084         default:
1085                 break;
1086         }
1087 }
1088
1089 static void
1090 mskc_reset(struct msk_softc *sc)
1091 {
1092         bus_addr_t addr;
1093         uint16_t status;
1094         uint32_t val;
1095         int i;
1096
1097         CSR_WRITE_2(sc, B0_CTST, CS_RST_CLR);
1098
1099         /* Disable ASF. */
1100         if (sc->msk_hw_id < CHIP_ID_YUKON_XL) {
1101                 CSR_WRITE_4(sc, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
1102                 CSR_WRITE_2(sc, B0_CTST, Y2_ASF_DISABLE);
1103         }
1104         /*
1105          * Since we disabled ASF, S/W reset is required for Power Management.
1106          */
1107         CSR_WRITE_2(sc, B0_CTST, CS_RST_SET);
1108         CSR_WRITE_2(sc, B0_CTST, CS_RST_CLR);
1109
1110         /* Clear all error bits in the PCI status register. */
1111         status = pci_read_config(sc->msk_dev, PCIR_STATUS, 2);
1112         CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_ON);
1113
1114         pci_write_config(sc->msk_dev, PCIR_STATUS, status |
1115             PCIM_STATUS_PERR | PCIM_STATUS_SERR | PCIM_STATUS_RMABORT |
1116             PCIM_STATUS_RTABORT | PCIM_STATUS_PERRREPORT, 2);
1117         CSR_WRITE_2(sc, B0_CTST, CS_MRST_CLR);
1118
1119         switch (sc->msk_bustype) {
1120         case MSK_PEX_BUS:
1121                 /* Clear all PEX errors. */
1122                 CSR_PCI_WRITE_4(sc, PEX_UNC_ERR_STAT, 0xffffffff);
1123                 val = CSR_PCI_READ_4(sc, PEX_UNC_ERR_STAT);
1124                 if ((val & PEX_RX_OV) != 0) {
1125                         sc->msk_intrmask &= ~Y2_IS_HW_ERR;
1126                         sc->msk_intrhwemask &= ~Y2_IS_PCI_EXP;
1127                 }
1128                 break;
1129         case MSK_PCI_BUS:
1130         case MSK_PCIX_BUS:
1131                 /* Set Cache Line Size to 2(8bytes) if configured to 0. */
1132                 val = pci_read_config(sc->msk_dev, PCIR_CACHELNSZ, 1);
1133                 if (val == 0)
1134                         pci_write_config(sc->msk_dev, PCIR_CACHELNSZ, 2, 1);
1135                 if (sc->msk_bustype == MSK_PCIX_BUS) {
1136                         /* Set Cache Line Size opt. */
1137                         val = pci_read_config(sc->msk_dev, PCI_OUR_REG_1, 4);
1138                         val |= PCI_CLS_OPT;
1139                         pci_write_config(sc->msk_dev, PCI_OUR_REG_1, val, 4);
1140                 }
1141                 break;
1142         }
1143         /* Set PHY power state. */
1144         mskc_phy_power(sc, MSK_PHY_POWERUP);
1145
1146         /* Reset GPHY/GMAC Control */
1147         for (i = 0; i < sc->msk_num_port; i++) {
1148                 /* GPHY Control reset. */
1149                 CSR_WRITE_4(sc, MR_ADDR(i, GPHY_CTRL), GPC_RST_SET);
1150                 CSR_WRITE_4(sc, MR_ADDR(i, GPHY_CTRL), GPC_RST_CLR);
1151                 /* GMAC Control reset. */
1152                 CSR_WRITE_4(sc, MR_ADDR(i, GMAC_CTRL), GMC_RST_SET);
1153                 CSR_WRITE_4(sc, MR_ADDR(i, GMAC_CTRL), GMC_RST_CLR);
1154                 CSR_WRITE_4(sc, MR_ADDR(i, GMAC_CTRL), GMC_F_LOOPB_OFF);
1155         }
1156         CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
1157
1158         /* LED On. */
1159         CSR_WRITE_2(sc, B0_CTST, Y2_LED_STAT_ON);
1160
1161         /* Clear TWSI IRQ. */
1162         CSR_WRITE_4(sc, B2_I2C_IRQ, I2C_CLR_IRQ);
1163
1164         /* Turn off hardware timer. */
1165         CSR_WRITE_1(sc, B2_TI_CTRL, TIM_STOP);
1166         CSR_WRITE_1(sc, B2_TI_CTRL, TIM_CLR_IRQ);
1167
1168         /* Turn off descriptor polling. */
1169         CSR_WRITE_1(sc, B28_DPT_CTRL, DPT_STOP);
1170
1171         /* Turn off time stamps. */
1172         CSR_WRITE_1(sc, GMAC_TI_ST_CTRL, GMT_ST_STOP);
1173         CSR_WRITE_1(sc, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
1174
1175         /* Configure timeout values. */
1176         for (i = 0; i < sc->msk_num_port; i++) {
1177                 CSR_WRITE_2(sc, SELECT_RAM_BUFFER(i, B3_RI_CTRL), RI_RST_SET);
1178                 CSR_WRITE_2(sc, SELECT_RAM_BUFFER(i, B3_RI_CTRL), RI_RST_CLR);
1179                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_R1),
1180                     MSK_RI_TO_53);
1181                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_XA1),
1182                     MSK_RI_TO_53);
1183                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_XS1),
1184                     MSK_RI_TO_53);
1185                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_R1),
1186                     MSK_RI_TO_53);
1187                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_XA1),
1188                     MSK_RI_TO_53);
1189                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_XS1),
1190                     MSK_RI_TO_53);
1191                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_R2),
1192                     MSK_RI_TO_53);
1193                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_XA2),
1194                     MSK_RI_TO_53);
1195                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_WTO_XS2),
1196                     MSK_RI_TO_53);
1197                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_R2),
1198                     MSK_RI_TO_53);
1199                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_XA2),
1200                     MSK_RI_TO_53);
1201                 CSR_WRITE_1(sc, SELECT_RAM_BUFFER(i, B3_RI_RTO_XS2),
1202                     MSK_RI_TO_53);
1203         }
1204
1205         /* Disable all interrupts. */
1206         CSR_WRITE_4(sc, B0_HWE_IMSK, 0);
1207         CSR_READ_4(sc, B0_HWE_IMSK);
1208         CSR_WRITE_4(sc, B0_IMSK, 0);
1209         CSR_READ_4(sc, B0_IMSK);
1210
1211         /*
1212          * On dual port PCI-X card, there is an problem where status
1213          * can be received out of order due to split transactions.
1214          */
1215         if (sc->msk_bustype == MSK_PCIX_BUS && sc->msk_num_port > 1) {
1216                 uint16_t pcix_cmd;
1217                 uint8_t pcix;
1218
1219                 pcix = pci_get_pcixcap_ptr(sc->msk_dev);
1220
1221                 pcix_cmd = pci_read_config(sc->msk_dev, pcix + 2, 2);
1222                 /* Clear Max Outstanding Split Transactions. */
1223                 pcix_cmd &= ~0x70;
1224                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_ON);
1225                 pci_write_config(sc->msk_dev, pcix + 2, pcix_cmd, 2);
1226                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
1227         }
1228         if (sc->msk_bustype == MSK_PEX_BUS) {
1229                 uint16_t v, width;
1230
1231                 v = pci_read_config(sc->msk_dev, PEX_DEV_CTRL, 2);
1232                 /* Change Max. Read Request Size to 4096 bytes. */
1233                 v &= ~PEX_DC_MAX_RRS_MSK;
1234                 v |= PEX_DC_MAX_RD_RQ_SIZE(5);
1235                 pci_write_config(sc->msk_dev, PEX_DEV_CTRL, v, 2);
1236                 width = pci_read_config(sc->msk_dev, PEX_LNK_STAT, 2);
1237                 width = (width & PEX_LS_LINK_WI_MSK) >> 4;
1238                 v = pci_read_config(sc->msk_dev, PEX_LNK_CAP, 2);
1239                 v = (v & PEX_LS_LINK_WI_MSK) >> 4;
1240                 if (v != width) {
1241                         device_printf(sc->msk_dev,
1242                             "negotiated width of link(x%d) != "
1243                             "max. width of link(x%d)\n", width, v);
1244                 }
1245         }
1246
1247         /* Clear status list. */
1248         bzero(sc->msk_stat_ring,
1249             sizeof(struct msk_stat_desc) * MSK_STAT_RING_CNT);
1250         sc->msk_stat_cons = 0;
1251         CSR_WRITE_4(sc, STAT_CTRL, SC_STAT_RST_SET);
1252         CSR_WRITE_4(sc, STAT_CTRL, SC_STAT_RST_CLR);
1253         /* Set the status list base address. */
1254         addr = sc->msk_stat_ring_paddr;
1255         CSR_WRITE_4(sc, STAT_LIST_ADDR_LO, MSK_ADDR_LO(addr));
1256         CSR_WRITE_4(sc, STAT_LIST_ADDR_HI, MSK_ADDR_HI(addr));
1257         /* Set the status list last index. */
1258         CSR_WRITE_2(sc, STAT_LAST_IDX, MSK_STAT_RING_CNT - 1);
1259         if (sc->msk_hw_id == CHIP_ID_YUKON_EC &&
1260             sc->msk_hw_rev == CHIP_REV_YU_EC_A1) {
1261                 /* WA for dev. #4.3 */
1262                 CSR_WRITE_2(sc, STAT_TX_IDX_TH, ST_TXTH_IDX_MASK);
1263                 /* WA for dev. #4.18 */
1264                 CSR_WRITE_1(sc, STAT_FIFO_WM, 0x21);
1265                 CSR_WRITE_1(sc, STAT_FIFO_ISR_WM, 0x07);
1266         } else {
1267                 CSR_WRITE_2(sc, STAT_TX_IDX_TH, 0x0a);
1268                 CSR_WRITE_1(sc, STAT_FIFO_WM, 0x10);
1269                 if (sc->msk_hw_id == CHIP_ID_YUKON_XL &&
1270                     sc->msk_hw_rev == CHIP_REV_YU_XL_A0)
1271                         CSR_WRITE_1(sc, STAT_FIFO_ISR_WM, 0x04);
1272                 else
1273                         CSR_WRITE_1(sc, STAT_FIFO_ISR_WM, 0x10);
1274                 CSR_WRITE_4(sc, STAT_ISR_TIMER_INI, 0x0190);
1275         }
1276         /*
1277          * Use default value for STAT_ISR_TIMER_INI, STAT_LEV_TIMER_INI.
1278          */
1279         CSR_WRITE_4(sc, STAT_TX_TIMER_INI, MSK_USECS(sc, 1000));
1280
1281         /* Enable status unit. */
1282         CSR_WRITE_4(sc, STAT_CTRL, SC_STAT_OP_ON);
1283
1284         CSR_WRITE_1(sc, STAT_TX_TIMER_CTRL, TIM_START);
1285         CSR_WRITE_1(sc, STAT_LEV_TIMER_CTRL, TIM_START);
1286         CSR_WRITE_1(sc, STAT_ISR_TIMER_CTRL, TIM_START);
1287 }
1288
1289 static int
1290 msk_probe(device_t dev)
1291 {
1292         struct msk_softc *sc = device_get_softc(device_get_parent(dev));
1293         char desc[100];
1294
1295         /*
1296          * Not much to do here. We always know there will be
1297          * at least one GMAC present, and if there are two,
1298          * mskc_attach() will create a second device instance
1299          * for us.
1300          */
1301         ksnprintf(desc, sizeof(desc),
1302             "Marvell Technology Group Ltd. %s Id 0x%02x Rev 0x%02x",
1303             model_name[sc->msk_hw_id - CHIP_ID_YUKON_XL], sc->msk_hw_id,
1304             sc->msk_hw_rev);
1305         device_set_desc_copy(dev, desc);
1306
1307         return (0);
1308 }
1309
1310 static int
1311 msk_attach(device_t dev)
1312 {
1313         struct msk_softc *sc = device_get_softc(device_get_parent(dev));
1314         struct msk_if_softc *sc_if = device_get_softc(dev);
1315         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1316         int i, port, error;
1317         uint8_t eaddr[ETHER_ADDR_LEN];
1318
1319         port = *(int *)device_get_ivars(dev);
1320         KKASSERT(port == MSK_PORT_A || port == MSK_PORT_B);
1321
1322         kfree(device_get_ivars(dev), M_DEVBUF);
1323         device_set_ivars(dev, NULL);
1324
1325         callout_init(&sc_if->msk_tick_ch);
1326         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1327
1328         sc_if->msk_if_dev = dev;
1329         sc_if->msk_port = port;
1330         sc_if->msk_softc = sc;
1331         sc_if->msk_ifp = ifp;
1332         sc_if->msk_flags = sc->msk_pflags;
1333         sc->msk_if[port] = sc_if;
1334
1335         /* Setup Tx/Rx queue register offsets. */
1336         if (port == MSK_PORT_A) {
1337                 sc_if->msk_txq = Q_XA1;
1338                 sc_if->msk_txsq = Q_XS1;
1339                 sc_if->msk_rxq = Q_R1;
1340         } else {
1341                 sc_if->msk_txq = Q_XA2;
1342                 sc_if->msk_txsq = Q_XS2;
1343                 sc_if->msk_rxq = Q_R2;
1344         }
1345
1346         error = msk_txrx_dma_alloc(sc_if);
1347         if (error)
1348                 goto fail;
1349
1350         ifp->if_softc = sc_if;
1351         ifp->if_mtu = ETHERMTU;
1352         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1353         ifp->if_init = msk_init;
1354         ifp->if_ioctl = msk_ioctl;
1355         ifp->if_start = msk_start;
1356         ifp->if_watchdog = msk_watchdog;
1357         ifq_set_maxlen(&ifp->if_snd, MSK_TX_RING_CNT - 1);
1358         ifq_set_ready(&ifp->if_snd);
1359
1360 #ifdef notyet
1361         /*
1362          * IFCAP_RXCSUM capability is intentionally disabled as the hardware
1363          * has serious bug in Rx checksum offload for all Yukon II family
1364          * hardware. It seems there is a workaround to make it work somtimes.
1365          * However, the workaround also have to check OP code sequences to
1366          * verify whether the OP code is correct. Sometimes it should compute
1367          * IP/TCP/UDP checksum in driver in order to verify correctness of
1368          * checksum computed by hardware. If you have to compute checksum
1369          * with software to verify the hardware's checksum why have hardware
1370          * compute the checksum? I think there is no reason to spend time to
1371          * make Rx checksum offload work on Yukon II hardware.
1372          */
1373         ifp->if_capabilities = IFCAP_TXCSUM | IFCAP_VLAN_MTU |
1374                                IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM;
1375         ifp->if_hwassist = MSK_CSUM_FEATURES;
1376         ifp->if_capenable = ifp->if_capabilities;
1377 #endif
1378
1379         /*
1380          * Get station address for this interface. Note that
1381          * dual port cards actually come with three station
1382          * addresses: one for each port, plus an extra. The
1383          * extra one is used by the SysKonnect driver software
1384          * as a 'virtual' station address for when both ports
1385          * are operating in failover mode. Currently we don't
1386          * use this extra address.
1387          */
1388         for (i = 0; i < ETHER_ADDR_LEN; i++)
1389                 eaddr[i] = CSR_READ_1(sc, B2_MAC_1 + (port * 8) + i);
1390
1391         sc_if->msk_framesize = ifp->if_mtu + ETHER_HDR_LEN + EVL_ENCAPLEN;
1392
1393         /*
1394          * Do miibus setup.
1395          */
1396         error = mii_phy_probe(dev, &sc_if->msk_miibus,
1397                               msk_mediachange, msk_mediastatus);
1398         if (error) {
1399                 device_printf(sc_if->msk_if_dev, "no PHY found!\n");
1400                 goto fail;
1401         }
1402
1403         /*
1404          * Call MI attach routine.  Can't hold locks when calling into ether_*.
1405          */
1406         ether_ifattach(ifp, eaddr, &sc->msk_serializer);
1407 #if 0
1408         /*
1409          * Tell the upper layer(s) we support long frames.
1410          * Must appear after the call to ether_ifattach() because
1411          * ether_ifattach() sets ifi_hdrlen to the default value.
1412          */
1413         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
1414 #endif
1415
1416         return 0;
1417 fail:
1418         msk_detach(dev);
1419         sc->msk_if[port] = NULL;
1420         return (error);
1421 }
1422
1423 /*
1424  * Attach the interface. Allocate softc structures, do ifmedia
1425  * setup and ethernet/BPF attach.
1426  */
1427 static int
1428 mskc_attach(device_t dev)
1429 {
1430         struct msk_softc *sc;
1431         int error, *port, cpuid;
1432
1433         sc = device_get_softc(dev);
1434         sc->msk_dev = dev;
1435         lwkt_serialize_init(&sc->msk_serializer);
1436
1437         /*
1438          * Initailize sysctl variables
1439          */
1440         sc->msk_process_limit = mskc_process_limit;
1441         sc->msk_intr_rate = mskc_intr_rate;
1442
1443 #ifndef BURN_BRIDGES
1444         /*
1445          * Handle power management nonsense.
1446          */
1447         if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) {
1448                 uint32_t irq, bar0, bar1;
1449
1450                 /* Save important PCI config data. */
1451                 bar0 = pci_read_config(dev, PCIR_BAR(0), 4);
1452                 bar1 = pci_read_config(dev, PCIR_BAR(1), 4);
1453                 irq = pci_read_config(dev, PCIR_INTLINE, 4);
1454
1455                 /* Reset the power state. */
1456                 device_printf(dev, "chip is in D%d power mode "
1457                               "-- setting to D0\n", pci_get_powerstate(dev));
1458
1459                 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
1460
1461                 /* Restore PCI config data. */
1462                 pci_write_config(dev, PCIR_BAR(0), bar0, 4);
1463                 pci_write_config(dev, PCIR_BAR(1), bar1, 4);
1464                 pci_write_config(dev, PCIR_INTLINE, irq, 4);
1465         }
1466 #endif  /* BURN_BRIDGES */
1467
1468         /*
1469          * Map control/status registers.
1470          */
1471         pci_enable_busmaster(dev);
1472
1473         /*
1474          * Allocate I/O resource
1475          */
1476 #ifdef MSK_USEIOSPACE
1477         sc->msk_res_type = SYS_RES_IOPORT;
1478         sc->msk_res_rid = PCIR_BAR(1);
1479 #else
1480         sc->msk_res_type = SYS_RES_MEMORY;
1481         sc->msk_res_rid = PCIR_BAR(0);
1482 #endif
1483         sc->msk_res = bus_alloc_resource_any(dev, sc->msk_res_type,
1484                                              &sc->msk_res_rid, RF_ACTIVE);
1485         if (sc->msk_res == NULL) {
1486                 if (sc->msk_res_type == SYS_RES_MEMORY) {
1487                         sc->msk_res_type = SYS_RES_IOPORT;
1488                         sc->msk_res_rid = PCIR_BAR(1);
1489                 } else {
1490                         sc->msk_res_type = SYS_RES_MEMORY;
1491                         sc->msk_res_rid = PCIR_BAR(0);
1492                 }
1493                 sc->msk_res = bus_alloc_resource_any(dev, sc->msk_res_type,
1494                                                      &sc->msk_res_rid,
1495                                                      RF_ACTIVE);
1496                 if (sc->msk_res == NULL) {
1497                         device_printf(dev, "couldn't allocate %s resources\n",
1498                         sc->msk_res_type == SYS_RES_MEMORY ? "memory" : "I/O");
1499                         return (ENXIO);
1500                 }
1501         }
1502         sc->msk_res_bt = rman_get_bustag(sc->msk_res);
1503         sc->msk_res_bh = rman_get_bushandle(sc->msk_res);
1504
1505         /*
1506          * Allocate IRQ
1507          */
1508         sc->msk_irq_rid = 0;
1509         sc->msk_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
1510                                              &sc->msk_irq_rid,
1511                                              RF_SHAREABLE | RF_ACTIVE);
1512         if (sc->msk_irq == NULL) {
1513                 device_printf(dev, "couldn't allocate IRQ resources\n");
1514                 error = ENXIO;
1515                 goto fail;
1516         }
1517
1518         CSR_WRITE_2(sc, B0_CTST, CS_RST_CLR);
1519         sc->msk_hw_id = CSR_READ_1(sc, B2_CHIP_ID);
1520         sc->msk_hw_rev = (CSR_READ_1(sc, B2_MAC_CFG) >> 4) & 0x0f;
1521         /* Bail out if chip is not recognized. */
1522         if (sc->msk_hw_id < CHIP_ID_YUKON_XL ||
1523             sc->msk_hw_id > CHIP_ID_YUKON_FE) {
1524                 device_printf(dev, "unknown device: id=0x%02x, rev=0x%02x\n",
1525                     sc->msk_hw_id, sc->msk_hw_rev);
1526                 error = ENXIO;
1527                 goto fail;
1528         }
1529
1530         /*
1531          * Create sysctl tree
1532          */
1533         sysctl_ctx_init(&sc->msk_sysctl_ctx);
1534         sc->msk_sysctl_tree = SYSCTL_ADD_NODE(&sc->msk_sysctl_ctx,
1535                                               SYSCTL_STATIC_CHILDREN(_hw),
1536                                               OID_AUTO,
1537                                               device_get_nameunit(dev),
1538                                               CTLFLAG_RD, 0, "");
1539         if (sc->msk_sysctl_tree == NULL) {
1540                 device_printf(dev, "can't add sysctl node\n");
1541                 error = ENXIO;
1542                 goto fail;
1543         }
1544
1545         SYSCTL_ADD_PROC(&sc->msk_sysctl_ctx,
1546                         SYSCTL_CHILDREN(sc->msk_sysctl_tree),
1547                         OID_AUTO, "process_limit", CTLTYPE_INT | CTLFLAG_RW,
1548                         &sc->msk_process_limit, 0, mskc_sysctl_proc_limit,
1549                         "I", "max number of Rx events to process");
1550         SYSCTL_ADD_PROC(&sc->msk_sysctl_ctx,
1551                         SYSCTL_CHILDREN(sc->msk_sysctl_tree),
1552                         OID_AUTO, "intr_rate", CTLTYPE_INT | CTLFLAG_RW,
1553                         sc, 0, mskc_sysctl_intr_rate,
1554                         "I", "max number of interrupt per second");
1555         SYSCTL_ADD_INT(&sc->msk_sysctl_ctx,
1556                        SYSCTL_CHILDREN(sc->msk_sysctl_tree), OID_AUTO,
1557                        "defrag_avoided", CTLFLAG_RW, &sc->msk_defrag_avoided,
1558                        0, "# of avoided m_defrag on TX path");
1559         SYSCTL_ADD_INT(&sc->msk_sysctl_ctx,
1560                        SYSCTL_CHILDREN(sc->msk_sysctl_tree), OID_AUTO,
1561                        "leading_copied", CTLFLAG_RW, &sc->msk_leading_copied,
1562                        0, "# of leading copies on TX path");
1563         SYSCTL_ADD_INT(&sc->msk_sysctl_ctx,
1564                        SYSCTL_CHILDREN(sc->msk_sysctl_tree), OID_AUTO,
1565                        "trailing_copied", CTLFLAG_RW, &sc->msk_trailing_copied,
1566                        0, "# of trailing copies on TX path");
1567
1568         /* Soft reset. */
1569         CSR_WRITE_2(sc, B0_CTST, CS_RST_SET);
1570         CSR_WRITE_2(sc, B0_CTST, CS_RST_CLR);
1571         sc->msk_pmd = CSR_READ_1(sc, B2_PMD_TYP);
1572         if (sc->msk_pmd == 'L' || sc->msk_pmd == 'S')
1573                 sc->msk_coppertype = 0;
1574         else
1575                 sc->msk_coppertype = 1;
1576         /* Check number of MACs. */
1577         sc->msk_num_port = 1;
1578         if ((CSR_READ_1(sc, B2_Y2_HW_RES) & CFG_DUAL_MAC_MSK) ==
1579             CFG_DUAL_MAC_MSK) {
1580                 if (!(CSR_READ_1(sc, B2_Y2_CLK_GATE) & Y2_STATUS_LNK2_INAC))
1581                         sc->msk_num_port++;
1582         }
1583
1584         /* Check bus type. */
1585         if (pci_is_pcie(sc->msk_dev) == 0)
1586                 sc->msk_bustype = MSK_PEX_BUS;
1587         else if (pci_is_pcix(sc->msk_dev) == 0)
1588                 sc->msk_bustype = MSK_PCIX_BUS;
1589         else
1590                 sc->msk_bustype = MSK_PCI_BUS;
1591
1592         switch (sc->msk_hw_id) {
1593         case CHIP_ID_YUKON_EC:
1594         case CHIP_ID_YUKON_EC_U:
1595                 sc->msk_clock = 125;    /* 125 Mhz */
1596                 break;
1597         case CHIP_ID_YUKON_FE:
1598                 sc->msk_clock = 100;    /* 100 Mhz */
1599                 break;
1600         case CHIP_ID_YUKON_XL:
1601                 sc->msk_clock = 156;    /* 156 Mhz */
1602                 break;
1603         default:
1604                 sc->msk_clock = 156;    /* 156 Mhz */
1605                 break;
1606         }
1607
1608         error = mskc_status_dma_alloc(sc);
1609         if (error)
1610                 goto fail;
1611
1612         /* Set base interrupt mask. */
1613         sc->msk_intrmask = Y2_IS_HW_ERR | Y2_IS_STAT_BMU;
1614         sc->msk_intrhwemask = Y2_IS_TIST_OV | Y2_IS_MST_ERR |
1615             Y2_IS_IRQ_STAT | Y2_IS_PCI_EXP | Y2_IS_PCI_NEXP;
1616
1617         /* Reset the adapter. */
1618         mskc_reset(sc);
1619
1620         error = mskc_setup_rambuffer(sc);
1621         if (error)
1622                 goto fail;
1623
1624         sc->msk_devs[MSK_PORT_A] = device_add_child(dev, "msk", -1);
1625         if (sc->msk_devs[MSK_PORT_A] == NULL) {
1626                 device_printf(dev, "failed to add child for PORT_A\n");
1627                 error = ENXIO;
1628                 goto fail;
1629         }
1630         port = kmalloc(sizeof(*port), M_DEVBUF, M_WAITOK);
1631         *port = MSK_PORT_A;
1632         device_set_ivars(sc->msk_devs[MSK_PORT_A], port);
1633
1634         if (sc->msk_num_port > 1) {
1635                 sc->msk_devs[MSK_PORT_B] = device_add_child(dev, "msk", -1);
1636                 if (sc->msk_devs[MSK_PORT_B] == NULL) {
1637                         device_printf(dev, "failed to add child for PORT_B\n");
1638                         error = ENXIO;
1639                         goto fail;
1640                 }
1641                 port = kmalloc(sizeof(*port), M_DEVBUF, M_WAITOK);
1642                 *port = MSK_PORT_B;
1643                 device_set_ivars(sc->msk_devs[MSK_PORT_B], port);
1644         }
1645
1646         bus_generic_attach(dev);
1647
1648         error = bus_setup_intr(dev, sc->msk_irq, INTR_MPSAFE,
1649                                mskc_intr, sc, &sc->msk_intrhand,
1650                                &sc->msk_serializer);
1651         if (error) {
1652                 device_printf(dev, "couldn't set up interrupt handler\n");
1653                 goto fail;
1654         }
1655
1656         cpuid = ithread_cpuid(rman_get_start(sc->msk_irq));
1657         KKASSERT(cpuid >= 0 && cpuid < ncpus);
1658
1659         if (sc->msk_if[0] != NULL)
1660                 sc->msk_if[0]->msk_ifp->if_cpuid = cpuid;
1661         if (sc->msk_if[1] != NULL)
1662                 sc->msk_if[1]->msk_ifp->if_cpuid = cpuid;
1663         return 0;
1664 fail:
1665         mskc_detach(dev);
1666         return (error);
1667 }
1668
1669 /*
1670  * Shutdown hardware and free up resources. This can be called any
1671  * time after the mutex has been initialized. It is called in both
1672  * the error case in attach and the normal detach case so it needs
1673  * to be careful about only freeing resources that have actually been
1674  * allocated.
1675  */
1676 static int
1677 msk_detach(device_t dev)
1678 {
1679         struct msk_if_softc *sc_if = device_get_softc(dev);
1680
1681         if (device_is_attached(dev)) {
1682                 struct msk_softc *sc = sc_if->msk_softc;
1683                 struct ifnet *ifp = &sc_if->arpcom.ac_if;
1684
1685                 lwkt_serialize_enter(ifp->if_serializer);
1686
1687                 if (sc->msk_intrhand != NULL) {
1688                         if (sc->msk_if[MSK_PORT_A] != NULL)
1689                                 msk_stop(sc->msk_if[MSK_PORT_A]);
1690                         if (sc->msk_if[MSK_PORT_B] != NULL)
1691                                 msk_stop(sc->msk_if[MSK_PORT_B]);
1692
1693                         bus_teardown_intr(sc->msk_dev, sc->msk_irq,
1694                                           sc->msk_intrhand);
1695                         sc->msk_intrhand = NULL;
1696                 }
1697
1698                 lwkt_serialize_exit(ifp->if_serializer);
1699
1700                 ether_ifdetach(ifp);
1701         }
1702
1703         if (sc_if->msk_miibus != NULL)
1704                 device_delete_child(dev, sc_if->msk_miibus);
1705
1706         msk_txrx_dma_free(sc_if);
1707         return (0);
1708 }
1709
1710 static int
1711 mskc_detach(device_t dev)
1712 {
1713         struct msk_softc *sc = device_get_softc(dev);
1714         int *port, i;
1715
1716 #ifdef INVARIANTS
1717         if (device_is_attached(dev)) {
1718                 KASSERT(sc->msk_intrhand == NULL,
1719                         ("intr is not torn down yet\n"));
1720         }
1721 #endif
1722
1723         for (i = 0; i < sc->msk_num_port; ++i) {
1724                 if (sc->msk_devs[i] != NULL) {
1725                         port = device_get_ivars(sc->msk_devs[i]);
1726                         if (port != NULL) {
1727                                 kfree(port, M_DEVBUF);
1728                                 device_set_ivars(sc->msk_devs[i], NULL);
1729                         }
1730                         device_delete_child(dev, sc->msk_devs[i]);
1731                 }
1732         }
1733
1734         /* Disable all interrupts. */
1735         CSR_WRITE_4(sc, B0_IMSK, 0);
1736         CSR_READ_4(sc, B0_IMSK);
1737         CSR_WRITE_4(sc, B0_HWE_IMSK, 0);
1738         CSR_READ_4(sc, B0_HWE_IMSK);
1739
1740         /* LED Off. */
1741         CSR_WRITE_2(sc, B0_CTST, Y2_LED_STAT_OFF);
1742
1743         /* Put hardware reset. */
1744         CSR_WRITE_2(sc, B0_CTST, CS_RST_SET);
1745
1746         mskc_status_dma_free(sc);
1747
1748         if (sc->msk_irq != NULL) {
1749                 bus_release_resource(dev, SYS_RES_IRQ, sc->msk_irq_rid,
1750                                      sc->msk_irq);
1751         }
1752         if (sc->msk_res != NULL) {
1753                 bus_release_resource(dev, sc->msk_res_type, sc->msk_res_rid,
1754                                      sc->msk_res);
1755         }
1756
1757         if (sc->msk_sysctl_tree != NULL)
1758                 sysctl_ctx_free(&sc->msk_sysctl_ctx);
1759
1760         return (0);
1761 }
1762
1763 /* Create status DMA region. */
1764 static int
1765 mskc_status_dma_alloc(struct msk_softc *sc)
1766 {
1767         bus_dmamem_t dmem;
1768         int error;
1769
1770         error = bus_dmamem_coherent(NULL/* XXX parent */, MSK_STAT_ALIGN, 0,
1771                         BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
1772                         MSK_STAT_RING_SZ, BUS_DMA_WAITOK | BUS_DMA_ZERO, &dmem);
1773         if (error) {
1774                 device_printf(sc->msk_dev,
1775                     "failed to create status coherent DMA memory\n");
1776                 return error;
1777         }
1778         sc->msk_stat_tag = dmem.dmem_tag;
1779         sc->msk_stat_map = dmem.dmem_map;
1780         sc->msk_stat_ring = dmem.dmem_addr;
1781         sc->msk_stat_ring_paddr = dmem.dmem_busaddr;
1782
1783         return (0);
1784 }
1785
1786 static void
1787 mskc_status_dma_free(struct msk_softc *sc)
1788 {
1789         /* Destroy status block. */
1790         if (sc->msk_stat_tag) {
1791                 bus_dmamap_unload(sc->msk_stat_tag, sc->msk_stat_map);
1792                 bus_dmamem_free(sc->msk_stat_tag, sc->msk_stat_ring,
1793                                 sc->msk_stat_map);
1794                 bus_dma_tag_destroy(sc->msk_stat_tag);
1795                 sc->msk_stat_tag = NULL;
1796         }
1797 }
1798
1799 static int
1800 msk_txrx_dma_alloc(struct msk_if_softc *sc_if)
1801 {
1802         int error, i, j;
1803 #ifdef MSK_JUMBO
1804         struct msk_rxdesc *jrxd;
1805         struct msk_jpool_entry *entry;
1806         uint8_t *ptr;
1807 #endif
1808         bus_size_t rxalign;
1809
1810         /* Create parent DMA tag. */
1811         /*
1812          * XXX
1813          * It seems that Yukon II supports full 64bits DMA operations. But
1814          * it needs two descriptors(list elements) for 64bits DMA operations.
1815          * Since we don't know what DMA address mappings(32bits or 64bits)
1816          * would be used in advance for each mbufs, we limits its DMA space
1817          * to be in range of 32bits address space. Otherwise, we should check
1818          * what DMA address is used and chain another descriptor for the
1819          * 64bits DMA operation. This also means descriptor ring size is
1820          * variable. Limiting DMA address to be in 32bit address space greatly
1821          * simplyfies descriptor handling and possibly would increase
1822          * performance a bit due to efficient handling of descriptors.
1823          * Apart from harassing checksum offloading mechanisms, it seems
1824          * it's really bad idea to use a seperate descriptor for 64bit
1825          * DMA operation to save small descriptor memory. Anyway, I've
1826          * never seen these exotic scheme on ethernet interface hardware.
1827          */
1828         error = bus_dma_tag_create(
1829                     NULL,                       /* parent */
1830                     1, 0,                       /* alignment, boundary */
1831                     BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
1832                     BUS_SPACE_MAXADDR,          /* highaddr */
1833                     NULL, NULL,                 /* filter, filterarg */
1834                     BUS_SPACE_MAXSIZE_32BIT,    /* maxsize */
1835                     0,                          /* nsegments */
1836                     BUS_SPACE_MAXSIZE_32BIT,    /* maxsegsize */
1837                     0,                          /* flags */
1838                     &sc_if->msk_cdata.msk_parent_tag);
1839         if (error) {
1840                 device_printf(sc_if->msk_if_dev,
1841                               "failed to create parent DMA tag\n");
1842                 return error;
1843         }
1844
1845         /* Create DMA stuffs for Tx ring. */
1846         error = msk_dmamem_create(sc_if->msk_if_dev, MSK_TX_RING_SZ,
1847                                   &sc_if->msk_cdata.msk_tx_ring_tag,
1848                                   (void *)&sc_if->msk_rdata.msk_tx_ring,
1849                                   &sc_if->msk_rdata.msk_tx_ring_paddr,
1850                                   &sc_if->msk_cdata.msk_tx_ring_map);
1851         if (error) {
1852                 device_printf(sc_if->msk_if_dev,
1853                               "failed to create TX ring DMA stuffs\n");
1854                 return error;
1855         }
1856
1857         /* Create DMA stuffs for Rx ring. */
1858         error = msk_dmamem_create(sc_if->msk_if_dev, MSK_RX_RING_SZ,
1859                                   &sc_if->msk_cdata.msk_rx_ring_tag,
1860                                   (void *)&sc_if->msk_rdata.msk_rx_ring,
1861                                   &sc_if->msk_rdata.msk_rx_ring_paddr,
1862                                   &sc_if->msk_cdata.msk_rx_ring_map);
1863         if (error) {
1864                 device_printf(sc_if->msk_if_dev,
1865                               "failed to create RX ring DMA stuffs\n");
1866                 return error;
1867         }
1868
1869         /* Create tag for Tx buffers. */
1870         error = bus_dma_tag_create(sc_if->msk_cdata.msk_parent_tag,/* parent */
1871                     1, 0,                       /* alignment, boundary */
1872                     BUS_SPACE_MAXADDR,          /* lowaddr */
1873                     BUS_SPACE_MAXADDR,          /* highaddr */
1874                     NULL, NULL,                 /* filter, filterarg */
1875                     MSK_JUMBO_FRAMELEN,         /* maxsize */
1876                     MSK_MAXTXSEGS,              /* nsegments */
1877                     MSK_MAXSGSIZE,              /* maxsegsize */
1878                     BUS_DMA_ALLOCNOW | BUS_DMA_WAITOK |
1879                     BUS_DMA_ONEBPAGE,           /* flags */
1880                     &sc_if->msk_cdata.msk_tx_tag);
1881         if (error) {
1882                 device_printf(sc_if->msk_if_dev,
1883                               "failed to create Tx DMA tag\n");
1884                 return error;
1885         }
1886
1887         /* Create DMA maps for Tx buffers. */
1888         for (i = 0; i < MSK_TX_RING_CNT; i++) {
1889                 struct msk_txdesc *txd = &sc_if->msk_cdata.msk_txdesc[i];
1890
1891                 error = bus_dmamap_create(sc_if->msk_cdata.msk_tx_tag,
1892                                 BUS_DMA_WAITOK | BUS_DMA_ONEBPAGE,
1893                                 &txd->tx_dmamap);
1894                 if (error) {
1895                         device_printf(sc_if->msk_if_dev,
1896                                       "failed to create %dth Tx dmamap\n", i);
1897
1898                         for (j = 0; j < i; ++j) {
1899                                 txd = &sc_if->msk_cdata.msk_txdesc[j];
1900                                 bus_dmamap_destroy(sc_if->msk_cdata.msk_tx_tag,
1901                                                    txd->tx_dmamap);
1902                         }
1903                         bus_dma_tag_destroy(sc_if->msk_cdata.msk_tx_tag);
1904                         sc_if->msk_cdata.msk_tx_tag = NULL;
1905
1906                         return error;
1907                 }
1908         }
1909
1910         /*
1911          * Workaround hardware hang which seems to happen when Rx buffer
1912          * is not aligned on multiple of FIFO word(8 bytes).
1913          */
1914         if (sc_if->msk_flags & MSK_FLAG_RAMBUF)
1915                 rxalign = MSK_RX_BUF_ALIGN;
1916         else
1917                 rxalign = 1;
1918
1919         /* Create tag for Rx buffers. */
1920         error = bus_dma_tag_create(sc_if->msk_cdata.msk_parent_tag,/* parent */
1921                     rxalign, 0,                 /* alignment, boundary */
1922                     BUS_SPACE_MAXADDR,          /* lowaddr */
1923                     BUS_SPACE_MAXADDR,          /* highaddr */
1924                     NULL, NULL,                 /* filter, filterarg */
1925                     MCLBYTES,                   /* maxsize */
1926                     1,                          /* nsegments */
1927                     MCLBYTES,                   /* maxsegsize */
1928                     BUS_DMA_ALLOCNOW | BUS_DMA_ALIGNED |
1929                     BUS_DMA_WAITOK,             /* flags */
1930                     &sc_if->msk_cdata.msk_rx_tag);
1931         if (error) {
1932                 device_printf(sc_if->msk_if_dev,
1933                               "failed to create Rx DMA tag\n");
1934                 return error;
1935         }
1936
1937         /* Create DMA maps for Rx buffers. */
1938         error = bus_dmamap_create(sc_if->msk_cdata.msk_rx_tag, BUS_DMA_WAITOK,
1939                                   &sc_if->msk_cdata.msk_rx_sparemap);
1940         if (error) {
1941                 device_printf(sc_if->msk_if_dev,
1942                               "failed to create spare Rx dmamap\n");
1943                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_rx_tag);
1944                 sc_if->msk_cdata.msk_rx_tag = NULL;
1945                 return error;
1946         }
1947         for (i = 0; i < MSK_RX_RING_CNT; i++) {
1948                 struct msk_rxdesc *rxd = &sc_if->msk_cdata.msk_rxdesc[i];
1949
1950                 error = bus_dmamap_create(sc_if->msk_cdata.msk_rx_tag,
1951                                           BUS_DMA_WAITOK, &rxd->rx_dmamap);
1952                 if (error) {
1953                         device_printf(sc_if->msk_if_dev,
1954                                       "failed to create %dth Rx dmamap\n", i);
1955
1956                         for (j = 0; j < i; ++j) {
1957                                 rxd = &sc_if->msk_cdata.msk_rxdesc[j];
1958                                 bus_dmamap_destroy(sc_if->msk_cdata.msk_rx_tag,
1959                                                    rxd->rx_dmamap);
1960                         }
1961                         bus_dmamap_destroy(sc_if->msk_cdata.msk_rx_tag,
1962                                            sc_if->msk_cdata.msk_rx_sparemap);
1963                         bus_dma_tag_destroy(sc_if->msk_cdata.msk_rx_tag);
1964                         sc_if->msk_cdata.msk_rx_tag = NULL;
1965
1966                         return error;
1967                 }
1968         }
1969
1970 #ifdef MSK_JUMBO
1971         SLIST_INIT(&sc_if->msk_jfree_listhead);
1972         SLIST_INIT(&sc_if->msk_jinuse_listhead);
1973
1974         /* Create tag for jumbo Rx ring. */
1975         error = bus_dma_tag_create(sc_if->msk_cdata.msk_parent_tag,/* parent */
1976                     MSK_RING_ALIGN, 0,          /* alignment, boundary */
1977                     BUS_SPACE_MAXADDR,          /* lowaddr */
1978                     BUS_SPACE_MAXADDR,          /* highaddr */
1979                     NULL, NULL,                 /* filter, filterarg */
1980                     MSK_JUMBO_RX_RING_SZ,       /* maxsize */
1981                     1,                          /* nsegments */
1982                     MSK_JUMBO_RX_RING_SZ,       /* maxsegsize */
1983                     0,                          /* flags */
1984                     NULL, NULL,                 /* lockfunc, lockarg */
1985                     &sc_if->msk_cdata.msk_jumbo_rx_ring_tag);
1986         if (error != 0) {
1987                 device_printf(sc_if->msk_if_dev,
1988                     "failed to create jumbo Rx ring DMA tag\n");
1989                 goto fail;
1990         }
1991
1992         /* Allocate DMA'able memory and load the DMA map for jumbo Rx ring. */
1993         error = bus_dmamem_alloc(sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
1994             (void **)&sc_if->msk_rdata.msk_jumbo_rx_ring,
1995             BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
1996             &sc_if->msk_cdata.msk_jumbo_rx_ring_map);
1997         if (error != 0) {
1998                 device_printf(sc_if->msk_if_dev,
1999                     "failed to allocate DMA'able memory for jumbo Rx ring\n");
2000                 goto fail;
2001         }
2002
2003         ctx.msk_busaddr = 0;
2004         error = bus_dmamap_load(sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
2005             sc_if->msk_cdata.msk_jumbo_rx_ring_map,
2006             sc_if->msk_rdata.msk_jumbo_rx_ring, MSK_JUMBO_RX_RING_SZ,
2007             msk_dmamap_cb, &ctx, 0);
2008         if (error != 0) {
2009                 device_printf(sc_if->msk_if_dev,
2010                     "failed to load DMA'able memory for jumbo Rx ring\n");
2011                 goto fail;
2012         }
2013         sc_if->msk_rdata.msk_jumbo_rx_ring_paddr = ctx.msk_busaddr;
2014
2015         /* Create tag for jumbo buffer blocks. */
2016         error = bus_dma_tag_create(sc_if->msk_cdata.msk_parent_tag,/* parent */
2017                     PAGE_SIZE, 0,               /* alignment, boundary */
2018                     BUS_SPACE_MAXADDR,          /* lowaddr */
2019                     BUS_SPACE_MAXADDR,          /* highaddr */
2020                     NULL, NULL,                 /* filter, filterarg */
2021                     MSK_JMEM,                   /* maxsize */
2022                     1,                          /* nsegments */
2023                     MSK_JMEM,                   /* maxsegsize */
2024                     0,                          /* flags */
2025                     NULL, NULL,                 /* lockfunc, lockarg */
2026                     &sc_if->msk_cdata.msk_jumbo_tag);
2027         if (error != 0) {
2028                 device_printf(sc_if->msk_if_dev,
2029                     "failed to create jumbo Rx buffer block DMA tag\n");
2030                 goto fail;
2031         }
2032
2033         /* Create tag for jumbo Rx buffers. */
2034         error = bus_dma_tag_create(sc_if->msk_cdata.msk_parent_tag,/* parent */
2035                     PAGE_SIZE, 0,               /* alignment, boundary */
2036                     BUS_SPACE_MAXADDR,          /* lowaddr */
2037                     BUS_SPACE_MAXADDR,          /* highaddr */
2038                     NULL, NULL,                 /* filter, filterarg */
2039                     MCLBYTES * MSK_MAXRXSEGS,   /* maxsize */
2040                     MSK_MAXRXSEGS,              /* nsegments */
2041                     MSK_JLEN,                   /* maxsegsize */
2042                     0,                          /* flags */
2043                     NULL, NULL,                 /* lockfunc, lockarg */
2044                     &sc_if->msk_cdata.msk_jumbo_rx_tag);
2045         if (error != 0) {
2046                 device_printf(sc_if->msk_if_dev,
2047                     "failed to create jumbo Rx DMA tag\n");
2048                 goto fail;
2049         }
2050
2051         /* Create DMA maps for jumbo Rx buffers. */
2052         if ((error = bus_dmamap_create(sc_if->msk_cdata.msk_jumbo_rx_tag, 0,
2053             &sc_if->msk_cdata.msk_jumbo_rx_sparemap)) != 0) {
2054                 device_printf(sc_if->msk_if_dev,
2055                     "failed to create spare jumbo Rx dmamap\n");
2056                 goto fail;
2057         }
2058         for (i = 0; i < MSK_JUMBO_RX_RING_CNT; i++) {
2059                 jrxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[i];
2060                 jrxd->rx_m = NULL;
2061                 jrxd->rx_dmamap = NULL;
2062                 error = bus_dmamap_create(sc_if->msk_cdata.msk_jumbo_rx_tag, 0,
2063                     &jrxd->rx_dmamap);
2064                 if (error != 0) {
2065                         device_printf(sc_if->msk_if_dev,
2066                             "failed to create jumbo Rx dmamap\n");
2067                         goto fail;
2068                 }
2069         }
2070
2071         /* Allocate DMA'able memory and load the DMA map for jumbo buf. */
2072         error = bus_dmamem_alloc(sc_if->msk_cdata.msk_jumbo_tag,
2073             (void **)&sc_if->msk_rdata.msk_jumbo_buf,
2074             BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
2075             &sc_if->msk_cdata.msk_jumbo_map);
2076         if (error != 0) {
2077                 device_printf(sc_if->msk_if_dev,
2078                     "failed to allocate DMA'able memory for jumbo buf\n");
2079                 goto fail;
2080         }
2081
2082         ctx.msk_busaddr = 0;
2083         error = bus_dmamap_load(sc_if->msk_cdata.msk_jumbo_tag,
2084             sc_if->msk_cdata.msk_jumbo_map, sc_if->msk_rdata.msk_jumbo_buf,
2085             MSK_JMEM, msk_dmamap_cb, &ctx, 0);
2086         if (error != 0) {
2087                 device_printf(sc_if->msk_if_dev,
2088                     "failed to load DMA'able memory for jumbobuf\n");
2089                 goto fail;
2090         }
2091         sc_if->msk_rdata.msk_jumbo_buf_paddr = ctx.msk_busaddr;
2092
2093         /*
2094          * Now divide it up into 9K pieces and save the addresses
2095          * in an array.
2096          */
2097         ptr = sc_if->msk_rdata.msk_jumbo_buf;
2098         for (i = 0; i < MSK_JSLOTS; i++) {
2099                 sc_if->msk_cdata.msk_jslots[i] = ptr;
2100                 ptr += MSK_JLEN;
2101                 entry = malloc(sizeof(struct msk_jpool_entry),
2102                     M_DEVBUF, M_WAITOK);
2103                 if (entry == NULL) {
2104                         device_printf(sc_if->msk_if_dev,
2105                             "no memory for jumbo buffers!\n");
2106                         error = ENOMEM;
2107                         goto fail;
2108                 }
2109                 entry->slot = i;
2110                 SLIST_INSERT_HEAD(&sc_if->msk_jfree_listhead, entry,
2111                     jpool_entries);
2112         }
2113 #endif
2114         return 0;
2115 }
2116
2117 static void
2118 msk_txrx_dma_free(struct msk_if_softc *sc_if)
2119 {
2120         struct msk_txdesc *txd;
2121         struct msk_rxdesc *rxd;
2122 #ifdef MSK_JUMBO
2123         struct msk_rxdesc *jrxd;
2124         struct msk_jpool_entry *entry;
2125 #endif
2126         int i;
2127
2128 #ifdef MSK_JUMBO
2129         MSK_JLIST_LOCK(sc_if);
2130         while ((entry = SLIST_FIRST(&sc_if->msk_jinuse_listhead))) {
2131                 device_printf(sc_if->msk_if_dev,
2132                     "asked to free buffer that is in use!\n");
2133                 SLIST_REMOVE_HEAD(&sc_if->msk_jinuse_listhead, jpool_entries);
2134                 SLIST_INSERT_HEAD(&sc_if->msk_jfree_listhead, entry,
2135                     jpool_entries);
2136         }
2137
2138         while (!SLIST_EMPTY(&sc_if->msk_jfree_listhead)) {
2139                 entry = SLIST_FIRST(&sc_if->msk_jfree_listhead);
2140                 SLIST_REMOVE_HEAD(&sc_if->msk_jfree_listhead, jpool_entries);
2141                 free(entry, M_DEVBUF);
2142         }
2143         MSK_JLIST_UNLOCK(sc_if);
2144
2145         /* Destroy jumbo buffer block. */
2146         if (sc_if->msk_cdata.msk_jumbo_map)
2147                 bus_dmamap_unload(sc_if->msk_cdata.msk_jumbo_tag,
2148                     sc_if->msk_cdata.msk_jumbo_map);
2149
2150         if (sc_if->msk_rdata.msk_jumbo_buf) {
2151                 bus_dmamem_free(sc_if->msk_cdata.msk_jumbo_tag,
2152                     sc_if->msk_rdata.msk_jumbo_buf,
2153                     sc_if->msk_cdata.msk_jumbo_map);
2154                 sc_if->msk_rdata.msk_jumbo_buf = NULL;
2155                 sc_if->msk_cdata.msk_jumbo_map = NULL;
2156         }
2157
2158         /* Jumbo Rx ring. */
2159         if (sc_if->msk_cdata.msk_jumbo_rx_ring_tag) {
2160                 if (sc_if->msk_cdata.msk_jumbo_rx_ring_map)
2161                         bus_dmamap_unload(sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
2162                             sc_if->msk_cdata.msk_jumbo_rx_ring_map);
2163                 if (sc_if->msk_cdata.msk_jumbo_rx_ring_map &&
2164                     sc_if->msk_rdata.msk_jumbo_rx_ring)
2165                         bus_dmamem_free(sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
2166                             sc_if->msk_rdata.msk_jumbo_rx_ring,
2167                             sc_if->msk_cdata.msk_jumbo_rx_ring_map);
2168                 sc_if->msk_rdata.msk_jumbo_rx_ring = NULL;
2169                 sc_if->msk_cdata.msk_jumbo_rx_ring_map = NULL;
2170                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_jumbo_rx_ring_tag);
2171                 sc_if->msk_cdata.msk_jumbo_rx_ring_tag = NULL;
2172         }
2173
2174         /* Jumbo Rx buffers. */
2175         if (sc_if->msk_cdata.msk_jumbo_rx_tag) {
2176                 for (i = 0; i < MSK_JUMBO_RX_RING_CNT; i++) {
2177                         jrxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[i];
2178                         if (jrxd->rx_dmamap) {
2179                                 bus_dmamap_destroy(
2180                                     sc_if->msk_cdata.msk_jumbo_rx_tag,
2181                                     jrxd->rx_dmamap);
2182                                 jrxd->rx_dmamap = NULL;
2183                         }
2184                 }
2185                 if (sc_if->msk_cdata.msk_jumbo_rx_sparemap) {
2186                         bus_dmamap_destroy(sc_if->msk_cdata.msk_jumbo_rx_tag,
2187                             sc_if->msk_cdata.msk_jumbo_rx_sparemap);
2188                         sc_if->msk_cdata.msk_jumbo_rx_sparemap = 0;
2189                 }
2190                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_jumbo_rx_tag);
2191                 sc_if->msk_cdata.msk_jumbo_rx_tag = NULL;
2192         }
2193 #endif
2194
2195         /* Tx ring. */
2196         msk_dmamem_destroy(sc_if->msk_cdata.msk_tx_ring_tag,
2197                            sc_if->msk_rdata.msk_tx_ring,
2198                            sc_if->msk_cdata.msk_tx_ring_map);
2199
2200         /* Rx ring. */
2201         msk_dmamem_destroy(sc_if->msk_cdata.msk_rx_ring_tag,
2202                            sc_if->msk_rdata.msk_rx_ring,
2203                            sc_if->msk_cdata.msk_rx_ring_map);
2204
2205         /* Tx buffers. */
2206         if (sc_if->msk_cdata.msk_tx_tag) {
2207                 for (i = 0; i < MSK_TX_RING_CNT; i++) {
2208                         txd = &sc_if->msk_cdata.msk_txdesc[i];
2209                         bus_dmamap_destroy(sc_if->msk_cdata.msk_tx_tag,
2210                                            txd->tx_dmamap);
2211                 }
2212                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_tx_tag);
2213                 sc_if->msk_cdata.msk_tx_tag = NULL;
2214         }
2215
2216         /* Rx buffers. */
2217         if (sc_if->msk_cdata.msk_rx_tag) {
2218                 for (i = 0; i < MSK_RX_RING_CNT; i++) {
2219                         rxd = &sc_if->msk_cdata.msk_rxdesc[i];
2220                         bus_dmamap_destroy(sc_if->msk_cdata.msk_rx_tag,
2221                                            rxd->rx_dmamap);
2222                 }
2223                 bus_dmamap_destroy(sc_if->msk_cdata.msk_rx_tag,
2224                                    sc_if->msk_cdata.msk_rx_sparemap);
2225                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_rx_tag);
2226                 sc_if->msk_cdata.msk_rx_tag = NULL;
2227         }
2228
2229         if (sc_if->msk_cdata.msk_parent_tag) {
2230                 bus_dma_tag_destroy(sc_if->msk_cdata.msk_parent_tag);
2231                 sc_if->msk_cdata.msk_parent_tag = NULL;
2232         }
2233 }
2234
2235 #ifdef MSK_JUMBO
2236 /*
2237  * Allocate a jumbo buffer.
2238  */
2239 static void *
2240 msk_jalloc(struct msk_if_softc *sc_if)
2241 {
2242         struct msk_jpool_entry *entry;
2243
2244         MSK_JLIST_LOCK(sc_if);
2245
2246         entry = SLIST_FIRST(&sc_if->msk_jfree_listhead);
2247
2248         if (entry == NULL) {
2249                 MSK_JLIST_UNLOCK(sc_if);
2250                 return (NULL);
2251         }
2252
2253         SLIST_REMOVE_HEAD(&sc_if->msk_jfree_listhead, jpool_entries);
2254         SLIST_INSERT_HEAD(&sc_if->msk_jinuse_listhead, entry, jpool_entries);
2255
2256         MSK_JLIST_UNLOCK(sc_if);
2257
2258         return (sc_if->msk_cdata.msk_jslots[entry->slot]);
2259 }
2260
2261 /*
2262  * Release a jumbo buffer.
2263  */
2264 static void
2265 msk_jfree(void *buf, void *args)
2266 {
2267         struct msk_if_softc *sc_if;
2268         struct msk_jpool_entry *entry;
2269         int i;
2270
2271         /* Extract the softc struct pointer. */
2272         sc_if = (struct msk_if_softc *)args;
2273         KASSERT(sc_if != NULL, ("%s: can't find softc pointer!", __func__));
2274
2275         MSK_JLIST_LOCK(sc_if);
2276         /* Calculate the slot this buffer belongs to. */
2277         i = ((vm_offset_t)buf
2278              - (vm_offset_t)sc_if->msk_rdata.msk_jumbo_buf) / MSK_JLEN;
2279         KASSERT(i >= 0 && i < MSK_JSLOTS,
2280             ("%s: asked to free buffer that we don't manage!", __func__));
2281
2282         entry = SLIST_FIRST(&sc_if->msk_jinuse_listhead);
2283         KASSERT(entry != NULL, ("%s: buffer not in use!", __func__));
2284         entry->slot = i;
2285         SLIST_REMOVE_HEAD(&sc_if->msk_jinuse_listhead, jpool_entries);
2286         SLIST_INSERT_HEAD(&sc_if->msk_jfree_listhead, entry, jpool_entries);
2287         if (SLIST_EMPTY(&sc_if->msk_jinuse_listhead))
2288                 wakeup(sc_if);
2289
2290         MSK_JLIST_UNLOCK(sc_if);
2291 }
2292 #endif
2293
2294 static int
2295 msk_encap(struct msk_if_softc *sc_if, struct mbuf **m_head)
2296 {
2297         struct msk_txdesc *txd, *txd_last;
2298         struct msk_tx_desc *tx_le;
2299         struct mbuf *m;
2300         bus_dmamap_t map;
2301         bus_dma_segment_t txsegs[MSK_MAXTXSEGS];
2302         uint32_t control, prod, si;
2303         uint16_t offset, tcp_offset;
2304         int error, i, nsegs, maxsegs, defrag;
2305
2306         maxsegs = MSK_TX_RING_CNT - sc_if->msk_cdata.msk_tx_cnt -
2307                   MSK_RESERVED_TX_DESC_CNT;
2308         KASSERT(maxsegs >= MSK_SPARE_TX_DESC_CNT,
2309                 ("not enough spare TX desc\n"));
2310         if (maxsegs > MSK_MAXTXSEGS)
2311                 maxsegs = MSK_MAXTXSEGS;
2312
2313         /*
2314          * Align TX buffer to 64bytes boundary.  This greately improves
2315          * bulk data TX performance on my 88E8053 (+100Mbps) at least.
2316          * Try avoiding m_defrag(), if the mbufs are not chained together
2317          * by m_next (i.e. m->m_len == m->m_pkthdr.len).
2318          */
2319
2320 #define MSK_TXBUF_ALIGN 64
2321 #define MSK_TXBUF_MASK  (MSK_TXBUF_ALIGN - 1)
2322
2323         defrag = 1;
2324         m = *m_head;
2325         if (m->m_len == m->m_pkthdr.len) {
2326                 int space;
2327
2328                 space = ((uintptr_t)m->m_data & MSK_TXBUF_MASK);
2329                 if (space) {
2330                         if (M_WRITABLE(m)) {
2331                                 if (M_TRAILINGSPACE(m) >= space) {
2332                                         /* e.g. TCP ACKs */
2333                                         bcopy(m->m_data, m->m_data + space,
2334                                               m->m_len);
2335                                         m->m_data += space;
2336                                         defrag = 0;
2337                                         sc_if->msk_softc->msk_trailing_copied++;
2338                                 } else {
2339                                         space = MSK_TXBUF_ALIGN - space;
2340                                         if (M_LEADINGSPACE(m) >= space) {
2341                                                 /* e.g. Small UDP datagrams */
2342                                                 bcopy(m->m_data,
2343                                                       m->m_data - space,
2344                                                       m->m_len);
2345                                                 m->m_data -= space;
2346                                                 defrag = 0;
2347                                                 sc_if->msk_softc->
2348                                                 msk_leading_copied++;
2349                                         }
2350                                 }
2351                         }
2352                 } else {
2353                         /* e.g. on forwarding path */
2354                         defrag = 0;
2355                 }
2356         }
2357         if (defrag) {
2358                 m = m_defrag(*m_head, MB_DONTWAIT);
2359                 if (m == NULL) {
2360                         m_freem(*m_head);
2361                         *m_head = NULL;
2362                         return ENOBUFS;
2363                 }
2364                 *m_head = m;
2365         } else {
2366                 sc_if->msk_softc->msk_defrag_avoided++;
2367         }
2368
2369 #undef MSK_TXBUF_MASK
2370 #undef MSK_TXBUF_ALIGN
2371
2372         tcp_offset = offset = 0;
2373         if (m->m_pkthdr.csum_flags & MSK_CSUM_FEATURES) {
2374                 /*
2375                  * Since mbuf has no protocol specific structure information
2376                  * in it we have to inspect protocol information here to
2377                  * setup TSO and checksum offload. I don't know why Marvell
2378                  * made a such decision in chip design because other GigE
2379                  * hardwares normally takes care of all these chores in
2380                  * hardware. However, TSO performance of Yukon II is very
2381                  * good such that it's worth to implement it.
2382                  */
2383                 struct ether_header *eh;
2384                 struct ip *ip;
2385
2386                 /* TODO check for M_WRITABLE(m) */
2387
2388                 offset = sizeof(struct ether_header);
2389                 m = m_pullup(m, offset);
2390                 if (m == NULL) {
2391                         *m_head = NULL;
2392                         return (ENOBUFS);
2393                 }
2394                 eh = mtod(m, struct ether_header *);
2395                 /* Check if hardware VLAN insertion is off. */
2396                 if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2397                         offset = sizeof(struct ether_vlan_header);
2398                         m = m_pullup(m, offset);
2399                         if (m == NULL) {
2400                                 *m_head = NULL;
2401                                 return (ENOBUFS);
2402                         }
2403                 }
2404                 m = m_pullup(m, offset + sizeof(struct ip));
2405                 if (m == NULL) {
2406                         *m_head = NULL;
2407                         return (ENOBUFS);
2408                 }
2409                 ip = (struct ip *)(mtod(m, char *) + offset);
2410                 offset += (ip->ip_hl << 2);
2411                 tcp_offset = offset;
2412                 /*
2413                  * It seems that Yukon II has Tx checksum offload bug for
2414                  * small TCP packets that's less than 60 bytes in size
2415                  * (e.g. TCP window probe packet, pure ACK packet).
2416                  * Common work around like padding with zeros to make the
2417                  * frame minimum ethernet frame size didn't work at all.
2418                  * Instead of disabling checksum offload completely we
2419                  * resort to S/W checksum routine when we encounter short
2420                  * TCP frames.
2421                  * Short UDP packets appear to be handled correctly by
2422                  * Yukon II.
2423                  */
2424                 if (m->m_pkthdr.len < MSK_MIN_FRAMELEN &&
2425                     (m->m_pkthdr.csum_flags & CSUM_TCP) != 0) {
2426                         uint16_t csum;
2427
2428                         csum = in_cksum_skip(m, ntohs(ip->ip_len) + offset -
2429                             (ip->ip_hl << 2), offset);
2430                         *(uint16_t *)(m->m_data + offset +
2431                             m->m_pkthdr.csum_data) = csum;
2432                         m->m_pkthdr.csum_flags &= ~CSUM_TCP;
2433                 }
2434                 *m_head = m;
2435         }
2436
2437         prod = sc_if->msk_cdata.msk_tx_prod;
2438         txd = &sc_if->msk_cdata.msk_txdesc[prod];
2439         txd_last = txd;
2440         map = txd->tx_dmamap;
2441
2442         error = bus_dmamap_load_mbuf_defrag(sc_if->msk_cdata.msk_tx_tag, map,
2443                         m_head, txsegs, maxsegs, &nsegs, BUS_DMA_NOWAIT);
2444         if (error) {
2445                 m_freem(*m_head);
2446                 *m_head = NULL;
2447                 return error;
2448         }
2449         bus_dmamap_sync(sc_if->msk_cdata.msk_tx_tag, map, BUS_DMASYNC_PREWRITE);
2450
2451         m = *m_head;
2452         control = 0;
2453         tx_le = NULL;
2454
2455 #ifdef notyet
2456         /* Check if we have a VLAN tag to insert. */
2457         if ((m->m_flags & M_VLANTAG) != 0) {
2458                 tx_le = &sc_if->msk_rdata.msk_tx_ring[prod];
2459                 tx_le->msk_addr = htole32(0);
2460                 tx_le->msk_control = htole32(OP_VLAN | HW_OWNER |
2461                     htons(m->m_pkthdr.ether_vtag));
2462                 sc_if->msk_cdata.msk_tx_cnt++;
2463                 MSK_INC(prod, MSK_TX_RING_CNT);
2464                 control |= INS_VLAN;
2465         }
2466 #endif
2467         /* Check if we have to handle checksum offload. */
2468         if (m->m_pkthdr.csum_flags & MSK_CSUM_FEATURES) {
2469                 tx_le = &sc_if->msk_rdata.msk_tx_ring[prod];
2470                 tx_le->msk_addr = htole32(((tcp_offset + m->m_pkthdr.csum_data)
2471                     & 0xffff) | ((uint32_t)tcp_offset << 16));
2472                 tx_le->msk_control = htole32(1 << 16 | (OP_TCPLISW | HW_OWNER));
2473                 control = CALSUM | WR_SUM | INIT_SUM | LOCK_SUM;
2474                 if ((m->m_pkthdr.csum_flags & CSUM_UDP) != 0)
2475                         control |= UDPTCP;
2476                 sc_if->msk_cdata.msk_tx_cnt++;
2477                 MSK_INC(prod, MSK_TX_RING_CNT);
2478         }
2479
2480         si = prod;
2481         tx_le = &sc_if->msk_rdata.msk_tx_ring[prod];
2482         tx_le->msk_addr = htole32(MSK_ADDR_LO(txsegs[0].ds_addr));
2483         tx_le->msk_control = htole32(txsegs[0].ds_len | control |
2484             OP_PACKET);
2485         sc_if->msk_cdata.msk_tx_cnt++;
2486         MSK_INC(prod, MSK_TX_RING_CNT);
2487
2488         for (i = 1; i < nsegs; i++) {
2489                 tx_le = &sc_if->msk_rdata.msk_tx_ring[prod];
2490                 tx_le->msk_addr = htole32(MSK_ADDR_LO(txsegs[i].ds_addr));
2491                 tx_le->msk_control = htole32(txsegs[i].ds_len | control |
2492                     OP_BUFFER | HW_OWNER);
2493                 sc_if->msk_cdata.msk_tx_cnt++;
2494                 MSK_INC(prod, MSK_TX_RING_CNT);
2495         }
2496         /* Update producer index. */
2497         sc_if->msk_cdata.msk_tx_prod = prod;
2498
2499         /* Set EOP on the last desciptor. */
2500         prod = (prod + MSK_TX_RING_CNT - 1) % MSK_TX_RING_CNT;
2501         tx_le = &sc_if->msk_rdata.msk_tx_ring[prod];
2502         tx_le->msk_control |= htole32(EOP);
2503
2504         /* Turn the first descriptor ownership to hardware. */
2505         tx_le = &sc_if->msk_rdata.msk_tx_ring[si];
2506         tx_le->msk_control |= htole32(HW_OWNER);
2507
2508         txd = &sc_if->msk_cdata.msk_txdesc[prod];
2509         map = txd_last->tx_dmamap;
2510         txd_last->tx_dmamap = txd->tx_dmamap;
2511         txd->tx_dmamap = map;
2512         txd->tx_m = m;
2513
2514         return (0);
2515 }
2516
2517 static void
2518 msk_start(struct ifnet *ifp)
2519 {
2520         struct msk_if_softc *sc_if;
2521         struct mbuf *m_head;
2522         int enq;
2523
2524         sc_if = ifp->if_softc;
2525
2526         ASSERT_SERIALIZED(ifp->if_serializer);
2527
2528         if (!sc_if->msk_link) {
2529                 ifq_purge(&ifp->if_snd);
2530                 return;
2531         }
2532
2533         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
2534                 return;
2535
2536         enq = 0;
2537         while (!ifq_is_empty(&ifp->if_snd)) {
2538                 if (MSK_IS_OACTIVE(sc_if)) {
2539                         ifp->if_flags |= IFF_OACTIVE;
2540                         break;
2541                 }
2542
2543                 m_head = ifq_dequeue(&ifp->if_snd, NULL);
2544                 if (m_head == NULL)
2545                         break;
2546
2547                 /*
2548                  * Pack the data into the transmit ring. If we
2549                  * don't have room, set the OACTIVE flag and wait
2550                  * for the NIC to drain the ring.
2551                  */
2552                 if (msk_encap(sc_if, &m_head) != 0) {
2553                         ifp->if_oerrors++;
2554                         if (sc_if->msk_cdata.msk_tx_cnt == 0) {
2555                                 continue;
2556                         } else {
2557                                 ifp->if_flags |= IFF_OACTIVE;
2558                                 break;
2559                         }
2560                 }
2561                 enq = 1;
2562
2563                 /*
2564                  * If there's a BPF listener, bounce a copy of this frame
2565                  * to him.
2566                  */
2567                 BPF_MTAP(ifp, m_head);
2568         }
2569
2570         if (enq) {
2571                 /* Transmit */
2572                 CSR_WRITE_2(sc_if->msk_softc,
2573                     Y2_PREF_Q_ADDR(sc_if->msk_txq, PREF_UNIT_PUT_IDX_REG),
2574                     sc_if->msk_cdata.msk_tx_prod);
2575
2576                 /* Set a timeout in case the chip goes out to lunch. */
2577                 ifp->if_timer = MSK_TX_TIMEOUT;
2578         }
2579 }
2580
2581 static void
2582 msk_watchdog(struct ifnet *ifp)
2583 {
2584         struct msk_if_softc *sc_if = ifp->if_softc;
2585         uint32_t ridx;
2586         int idx;
2587
2588         ASSERT_SERIALIZED(ifp->if_serializer);
2589
2590         if (sc_if->msk_link == 0) {
2591                 if (bootverbose)
2592                         if_printf(sc_if->msk_ifp, "watchdog timeout "
2593                            "(missed link)\n");
2594                 ifp->if_oerrors++;
2595                 msk_init(sc_if);
2596                 return;
2597         }
2598
2599         /*
2600          * Reclaim first as there is a possibility of losing Tx completion
2601          * interrupts.
2602          */
2603         ridx = sc_if->msk_port == MSK_PORT_A ? STAT_TXA1_RIDX : STAT_TXA2_RIDX;
2604         idx = CSR_READ_2(sc_if->msk_softc, ridx);
2605         if (sc_if->msk_cdata.msk_tx_cons != idx) {
2606                 msk_txeof(sc_if, idx);
2607                 if (sc_if->msk_cdata.msk_tx_cnt == 0) {
2608                         if_printf(ifp, "watchdog timeout (missed Tx interrupts) "
2609                             "-- recovering\n");
2610                         if (!ifq_is_empty(&ifp->if_snd))
2611                                 if_devstart(ifp);
2612                         return;
2613                 }
2614         }
2615
2616         if_printf(ifp, "watchdog timeout\n");
2617         ifp->if_oerrors++;
2618         msk_init(sc_if);
2619         if (!ifq_is_empty(&ifp->if_snd))
2620                 if_devstart(ifp);
2621 }
2622
2623 static int
2624 mskc_shutdown(device_t dev)
2625 {
2626         struct msk_softc *sc = device_get_softc(dev);
2627         int i;
2628
2629         lwkt_serialize_enter(&sc->msk_serializer);
2630
2631         for (i = 0; i < sc->msk_num_port; i++) {
2632                 if (sc->msk_if[i] != NULL)
2633                         msk_stop(sc->msk_if[i]);
2634         }
2635
2636         /* Disable all interrupts. */
2637         CSR_WRITE_4(sc, B0_IMSK, 0);
2638         CSR_READ_4(sc, B0_IMSK);
2639         CSR_WRITE_4(sc, B0_HWE_IMSK, 0);
2640         CSR_READ_4(sc, B0_HWE_IMSK);
2641
2642         /* Put hardware reset. */
2643         CSR_WRITE_2(sc, B0_CTST, CS_RST_SET);
2644
2645         lwkt_serialize_exit(&sc->msk_serializer);
2646         return (0);
2647 }
2648
2649 static int
2650 mskc_suspend(device_t dev)
2651 {
2652         struct msk_softc *sc = device_get_softc(dev);
2653         int i;
2654
2655         lwkt_serialize_enter(&sc->msk_serializer);
2656
2657         for (i = 0; i < sc->msk_num_port; i++) {
2658                 if (sc->msk_if[i] != NULL && sc->msk_if[i]->msk_ifp != NULL &&
2659                     ((sc->msk_if[i]->msk_ifp->if_flags & IFF_RUNNING) != 0))
2660                         msk_stop(sc->msk_if[i]);
2661         }
2662
2663         /* Disable all interrupts. */
2664         CSR_WRITE_4(sc, B0_IMSK, 0);
2665         CSR_READ_4(sc, B0_IMSK);
2666         CSR_WRITE_4(sc, B0_HWE_IMSK, 0);
2667         CSR_READ_4(sc, B0_HWE_IMSK);
2668
2669         mskc_phy_power(sc, MSK_PHY_POWERDOWN);
2670
2671         /* Put hardware reset. */
2672         CSR_WRITE_2(sc, B0_CTST, CS_RST_SET);
2673         sc->msk_suspended = 1;
2674
2675         lwkt_serialize_exit(&sc->msk_serializer);
2676
2677         return (0);
2678 }
2679
2680 static int
2681 mskc_resume(device_t dev)
2682 {
2683         struct msk_softc *sc = device_get_softc(dev);
2684         int i;
2685
2686         lwkt_serialize_enter(&sc->msk_serializer);
2687
2688         mskc_reset(sc);
2689         for (i = 0; i < sc->msk_num_port; i++) {
2690                 if (sc->msk_if[i] != NULL && sc->msk_if[i]->msk_ifp != NULL &&
2691                     ((sc->msk_if[i]->msk_ifp->if_flags & IFF_UP) != 0))
2692                         msk_init(sc->msk_if[i]);
2693         }
2694         sc->msk_suspended = 0;
2695
2696         lwkt_serialize_exit(&sc->msk_serializer);
2697
2698         return (0);
2699 }
2700
2701 static void
2702 msk_rxeof(struct msk_if_softc *sc_if, uint32_t status, int len,
2703           struct mbuf_chain *chain)
2704 {
2705         struct mbuf *m;
2706         struct ifnet *ifp;
2707         struct msk_rxdesc *rxd;
2708         int cons, rxlen;
2709
2710         ifp = sc_if->msk_ifp;
2711
2712         cons = sc_if->msk_cdata.msk_rx_cons;
2713         do {
2714                 rxlen = status >> 16;
2715                 if ((status & GMR_FS_VLAN) != 0 &&
2716                     (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
2717                         rxlen -= EVL_ENCAPLEN;
2718                 if (len > sc_if->msk_framesize ||
2719                     ((status & GMR_FS_ANY_ERR) != 0) ||
2720                     ((status & GMR_FS_RX_OK) == 0) || (rxlen != len)) {
2721                         /* Don't count flow-control packet as errors. */
2722                         if ((status & GMR_FS_GOOD_FC) == 0)
2723                                 ifp->if_ierrors++;
2724                         msk_discard_rxbuf(sc_if, cons);
2725                         break;
2726                 }
2727                 rxd = &sc_if->msk_cdata.msk_rxdesc[cons];
2728                 m = rxd->rx_m;
2729                 if (msk_newbuf(sc_if, cons, 0) != 0) {
2730                         ifp->if_iqdrops++;
2731                         /* Reuse old buffer. */
2732                         msk_discard_rxbuf(sc_if, cons);
2733                         break;
2734                 }
2735                 m->m_pkthdr.rcvif = ifp;
2736                 m->m_pkthdr.len = m->m_len = len;
2737                 ifp->if_ipackets++;
2738 #ifdef notyet
2739                 /* Check for VLAN tagged packets. */
2740                 if ((status & GMR_FS_VLAN) != 0 &&
2741                     (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) {
2742                         m->m_pkthdr.ether_vtag = sc_if->msk_vtag;
2743                         m->m_flags |= M_VLANTAG;
2744                 }
2745 #endif
2746
2747                 ether_input_chain(ifp, m, NULL, chain);
2748         } while (0);
2749
2750         MSK_INC(sc_if->msk_cdata.msk_rx_cons, MSK_RX_RING_CNT);
2751         MSK_INC(sc_if->msk_cdata.msk_rx_prod, MSK_RX_RING_CNT);
2752 }
2753
2754 #ifdef MSK_JUMBO
2755 static void
2756 msk_jumbo_rxeof(struct msk_if_softc *sc_if, uint32_t status, int len)
2757 {
2758         struct mbuf *m;
2759         struct ifnet *ifp;
2760         struct msk_rxdesc *jrxd;
2761         int cons, rxlen;
2762
2763         ifp = sc_if->msk_ifp;
2764
2765         MSK_IF_LOCK_ASSERT(sc_if);
2766
2767         cons = sc_if->msk_cdata.msk_rx_cons;
2768         do {
2769                 rxlen = status >> 16;
2770                 if ((status & GMR_FS_VLAN) != 0 &&
2771                     (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
2772                         rxlen -= ETHER_VLAN_ENCAP_LEN;
2773                 if (len > sc_if->msk_framesize ||
2774                     ((status & GMR_FS_ANY_ERR) != 0) ||
2775                     ((status & GMR_FS_RX_OK) == 0) || (rxlen != len)) {
2776                         /* Don't count flow-control packet as errors. */
2777                         if ((status & GMR_FS_GOOD_FC) == 0)
2778                                 ifp->if_ierrors++;
2779                         msk_discard_jumbo_rxbuf(sc_if, cons);
2780                         break;
2781                 }
2782                 jrxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[cons];
2783                 m = jrxd->rx_m;
2784                 if (msk_jumbo_newbuf(sc_if, cons) != 0) {
2785                         ifp->if_iqdrops++;
2786                         /* Reuse old buffer. */
2787                         msk_discard_jumbo_rxbuf(sc_if, cons);
2788                         break;
2789                 }
2790                 m->m_pkthdr.rcvif = ifp;
2791                 m->m_pkthdr.len = m->m_len = len;
2792                 ifp->if_ipackets++;
2793                 /* Check for VLAN tagged packets. */
2794                 if ((status & GMR_FS_VLAN) != 0 &&
2795                     (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) {
2796                         m->m_pkthdr.ether_vtag = sc_if->msk_vtag;
2797                         m->m_flags |= M_VLANTAG;
2798                 }
2799                 MSK_IF_UNLOCK(sc_if);
2800                 (*ifp->if_input)(ifp, m);
2801                 MSK_IF_LOCK(sc_if);
2802         } while (0);
2803
2804         MSK_INC(sc_if->msk_cdata.msk_rx_cons, MSK_JUMBO_RX_RING_CNT);
2805         MSK_INC(sc_if->msk_cdata.msk_rx_prod, MSK_JUMBO_RX_RING_CNT);
2806 }
2807 #endif
2808
2809 static void
2810 msk_txeof(struct msk_if_softc *sc_if, int idx)
2811 {
2812         struct msk_txdesc *txd;
2813         struct msk_tx_desc *cur_tx;
2814         struct ifnet *ifp;
2815         uint32_t control;
2816         int cons, prog;
2817
2818         ifp = sc_if->msk_ifp;
2819
2820         /*
2821          * Go through our tx ring and free mbufs for those
2822          * frames that have been sent.
2823          */
2824         cons = sc_if->msk_cdata.msk_tx_cons;
2825         prog = 0;
2826         for (; cons != idx; MSK_INC(cons, MSK_TX_RING_CNT)) {
2827                 if (sc_if->msk_cdata.msk_tx_cnt <= 0)
2828                         break;
2829                 prog++;
2830                 cur_tx = &sc_if->msk_rdata.msk_tx_ring[cons];
2831                 control = le32toh(cur_tx->msk_control);
2832                 sc_if->msk_cdata.msk_tx_cnt--;
2833                 if ((control & EOP) == 0)
2834                         continue;
2835                 txd = &sc_if->msk_cdata.msk_txdesc[cons];
2836                 bus_dmamap_unload(sc_if->msk_cdata.msk_tx_tag, txd->tx_dmamap);
2837
2838                 ifp->if_opackets++;
2839                 KASSERT(txd->tx_m != NULL, ("%s: freeing NULL mbuf!",
2840                     __func__));
2841                 m_freem(txd->tx_m);
2842                 txd->tx_m = NULL;
2843         }
2844
2845         if (prog > 0) {
2846                 sc_if->msk_cdata.msk_tx_cons = cons;
2847                 if (!MSK_IS_OACTIVE(sc_if))
2848                         ifp->if_flags &= ~IFF_OACTIVE;
2849                 if (sc_if->msk_cdata.msk_tx_cnt == 0)
2850                         ifp->if_timer = 0;
2851                 /* No need to sync LEs as we didn't update LEs. */
2852         }
2853 }
2854
2855 static void
2856 msk_tick(void *xsc_if)
2857 {
2858         struct msk_if_softc *sc_if = xsc_if;
2859         struct ifnet *ifp = &sc_if->arpcom.ac_if;
2860         struct mii_data *mii;
2861
2862         lwkt_serialize_enter(ifp->if_serializer);
2863
2864         mii = device_get_softc(sc_if->msk_miibus);
2865
2866         mii_tick(mii);
2867         callout_reset(&sc_if->msk_tick_ch, hz, msk_tick, sc_if);
2868
2869         lwkt_serialize_exit(ifp->if_serializer);
2870 }
2871
2872 static void
2873 msk_intr_phy(struct msk_if_softc *sc_if)
2874 {
2875         uint16_t status;
2876
2877         msk_phy_readreg(sc_if, PHY_ADDR_MARV, PHY_MARV_INT_STAT);
2878         status = msk_phy_readreg(sc_if, PHY_ADDR_MARV, PHY_MARV_INT_STAT);
2879         /* Handle FIFO Underrun/Overflow? */
2880         if (status & PHY_M_IS_FIFO_ERROR) {
2881                 device_printf(sc_if->msk_if_dev,
2882                     "PHY FIFO underrun/overflow.\n");
2883         }
2884 }
2885
2886 static void
2887 msk_intr_gmac(struct msk_if_softc *sc_if)
2888 {
2889         struct msk_softc *sc;
2890         uint8_t status;
2891
2892         sc = sc_if->msk_softc;
2893         status = CSR_READ_1(sc, MR_ADDR(sc_if->msk_port, GMAC_IRQ_SRC));
2894
2895         /* GMAC Rx FIFO overrun. */
2896         if ((status & GM_IS_RX_FF_OR) != 0) {
2897                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T),
2898                     GMF_CLI_RX_FO);
2899                 device_printf(sc_if->msk_if_dev, "Rx FIFO overrun!\n");
2900         }
2901         /* GMAC Tx FIFO underrun. */
2902         if ((status & GM_IS_TX_FF_UR) != 0) {
2903                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
2904                     GMF_CLI_TX_FU);
2905                 device_printf(sc_if->msk_if_dev, "Tx FIFO underrun!\n");
2906                 /*
2907                  * XXX
2908                  * In case of Tx underrun, we may need to flush/reset
2909                  * Tx MAC but that would also require resynchronization
2910                  * with status LEs. Reintializing status LEs would
2911                  * affect other port in dual MAC configuration so it
2912                  * should be avoided as possible as we can.
2913                  * Due to lack of documentation it's all vague guess but
2914                  * it needs more investigation.
2915                  */
2916         }
2917 }
2918
2919 static void
2920 msk_handle_hwerr(struct msk_if_softc *sc_if, uint32_t status)
2921 {
2922         struct msk_softc *sc;
2923
2924         sc = sc_if->msk_softc;
2925         if ((status & Y2_IS_PAR_RD1) != 0) {
2926                 device_printf(sc_if->msk_if_dev,
2927                     "RAM buffer read parity error\n");
2928                 /* Clear IRQ. */
2929                 CSR_WRITE_2(sc, SELECT_RAM_BUFFER(sc_if->msk_port, B3_RI_CTRL),
2930                     RI_CLR_RD_PERR);
2931         }
2932         if ((status & Y2_IS_PAR_WR1) != 0) {
2933                 device_printf(sc_if->msk_if_dev,
2934                     "RAM buffer write parity error\n");
2935                 /* Clear IRQ. */
2936                 CSR_WRITE_2(sc, SELECT_RAM_BUFFER(sc_if->msk_port, B3_RI_CTRL),
2937                     RI_CLR_WR_PERR);
2938         }
2939         if ((status & Y2_IS_PAR_MAC1) != 0) {
2940                 device_printf(sc_if->msk_if_dev, "Tx MAC parity error\n");
2941                 /* Clear IRQ. */
2942                 CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
2943                     GMF_CLI_TX_PE);
2944         }
2945         if ((status & Y2_IS_PAR_RX1) != 0) {
2946                 device_printf(sc_if->msk_if_dev, "Rx parity error\n");
2947                 /* Clear IRQ. */
2948                 CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR), BMU_CLR_IRQ_PAR);
2949         }
2950         if ((status & (Y2_IS_TCP_TXS1 | Y2_IS_TCP_TXA1)) != 0) {
2951                 device_printf(sc_if->msk_if_dev, "TCP segmentation error\n");
2952                 /* Clear IRQ. */
2953                 CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR), BMU_CLR_IRQ_TCP);
2954         }
2955 }
2956
2957 static void
2958 mskc_intr_hwerr(struct msk_softc *sc)
2959 {
2960         uint32_t status;
2961         uint32_t tlphead[4];
2962
2963         status = CSR_READ_4(sc, B0_HWE_ISRC);
2964         /* Time Stamp timer overflow. */
2965         if ((status & Y2_IS_TIST_OV) != 0)
2966                 CSR_WRITE_1(sc, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ);
2967         if ((status & Y2_IS_PCI_NEXP) != 0) {
2968                 /*
2969                  * PCI Express Error occured which is not described in PEX
2970                  * spec.
2971                  * This error is also mapped either to Master Abort(
2972                  * Y2_IS_MST_ERR) or Target Abort (Y2_IS_IRQ_STAT) bit and
2973                  * can only be cleared there.
2974                  */
2975                 device_printf(sc->msk_dev,
2976                     "PCI Express protocol violation error\n");
2977         }
2978
2979         if ((status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) != 0) {
2980                 uint16_t v16;
2981
2982                 if ((status & Y2_IS_MST_ERR) != 0)
2983                         device_printf(sc->msk_dev,
2984                             "unexpected IRQ Status error\n");
2985                 else
2986                         device_printf(sc->msk_dev,
2987                             "unexpected IRQ Master error\n");
2988                 /* Reset all bits in the PCI status register. */
2989                 v16 = pci_read_config(sc->msk_dev, PCIR_STATUS, 2);
2990                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2991                 pci_write_config(sc->msk_dev, PCIR_STATUS, v16 |
2992                     PCIM_STATUS_PERR | PCIM_STATUS_SERR | PCIM_STATUS_RMABORT |
2993                     PCIM_STATUS_RTABORT | PCIM_STATUS_PERRREPORT, 2);
2994                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2995         }
2996
2997         /* Check for PCI Express Uncorrectable Error. */
2998         if ((status & Y2_IS_PCI_EXP) != 0) {
2999                 uint32_t v32;
3000
3001                 /*
3002                  * On PCI Express bus bridges are called root complexes (RC).
3003                  * PCI Express errors are recognized by the root complex too,
3004                  * which requests the system to handle the problem. After
3005                  * error occurence it may be that no access to the adapter
3006                  * may be performed any longer.
3007                  */
3008
3009                 v32 = CSR_PCI_READ_4(sc, PEX_UNC_ERR_STAT);
3010                 if ((v32 & PEX_UNSUP_REQ) != 0) {
3011                         /* Ignore unsupported request error. */
3012                         if (bootverbose) {
3013                                 device_printf(sc->msk_dev,
3014                                     "Uncorrectable PCI Express error\n");
3015                         }
3016                 }
3017                 if ((v32 & (PEX_FATAL_ERRORS | PEX_POIS_TLP)) != 0) {
3018                         int i;
3019
3020                         /* Get TLP header form Log Registers. */
3021                         for (i = 0; i < 4; i++)
3022                                 tlphead[i] = CSR_PCI_READ_4(sc,
3023                                     PEX_HEADER_LOG + i * 4);
3024                         /* Check for vendor defined broadcast message. */
3025                         if (!(tlphead[0] == 0x73004001 && tlphead[1] == 0x7f)) {
3026                                 sc->msk_intrhwemask &= ~Y2_IS_PCI_EXP;
3027                                 CSR_WRITE_4(sc, B0_HWE_IMSK,
3028                                     sc->msk_intrhwemask);
3029                                 CSR_READ_4(sc, B0_HWE_IMSK);
3030                         }
3031                 }
3032                 /* Clear the interrupt. */
3033                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_ON);
3034                 CSR_PCI_WRITE_4(sc, PEX_UNC_ERR_STAT, 0xffffffff);
3035                 CSR_WRITE_1(sc, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
3036         }
3037
3038         if ((status & Y2_HWE_L1_MASK) != 0 && sc->msk_if[MSK_PORT_A] != NULL)
3039                 msk_handle_hwerr(sc->msk_if[MSK_PORT_A], status);
3040         if ((status & Y2_HWE_L2_MASK) != 0 && sc->msk_if[MSK_PORT_B] != NULL)
3041                 msk_handle_hwerr(sc->msk_if[MSK_PORT_B], status >> 8);
3042 }
3043
3044 static __inline void
3045 msk_rxput(struct msk_if_softc *sc_if)
3046 {
3047         struct msk_softc *sc;
3048
3049         sc = sc_if->msk_softc;
3050 #ifdef MSK_JUMBO
3051         if (sc_if->msk_framesize > (MCLBYTES - ETHER_HDR_LEN)) {
3052                 bus_dmamap_sync(
3053                     sc_if->msk_cdata.msk_jumbo_rx_ring_tag,
3054                     sc_if->msk_cdata.msk_jumbo_rx_ring_map,
3055                     BUS_DMASYNC_PREWRITE);
3056         }
3057 #endif
3058         CSR_WRITE_2(sc, Y2_PREF_Q_ADDR(sc_if->msk_rxq,
3059             PREF_UNIT_PUT_IDX_REG), sc_if->msk_cdata.msk_rx_prod);
3060 }
3061
3062 static int
3063 mskc_handle_events(struct msk_softc *sc)
3064 {
3065         struct msk_if_softc *sc_if;
3066         int rxput[2];
3067         struct msk_stat_desc *sd;
3068         uint32_t control, status;
3069         int cons, idx, len, port, rxprog;
3070         struct mbuf_chain chain[MAXCPU];
3071
3072         idx = CSR_READ_2(sc, STAT_PUT_IDX);
3073         if (idx == sc->msk_stat_cons)
3074                 return (0);
3075
3076         ether_input_chain_init(chain);
3077
3078         rxput[MSK_PORT_A] = rxput[MSK_PORT_B] = 0;
3079
3080         rxprog = 0;
3081         for (cons = sc->msk_stat_cons; cons != idx;) {
3082                 sd = &sc->msk_stat_ring[cons];
3083                 control = le32toh(sd->msk_control);
3084                 if ((control & HW_OWNER) == 0)
3085                         break;
3086                 /*
3087                  * Marvell's FreeBSD driver updates status LE after clearing
3088                  * HW_OWNER. However we don't have a way to sync single LE
3089                  * with bus_dma(9) API. bus_dma(9) provides a way to sync
3090                  * an entire DMA map. So don't sync LE until we have a better
3091                  * way to sync LEs.
3092                  */
3093                 control &= ~HW_OWNER;
3094                 sd->msk_control = htole32(control);
3095                 status = le32toh(sd->msk_status);
3096                 len = control & STLE_LEN_MASK;
3097                 port = (control >> 16) & 0x01;
3098                 sc_if = sc->msk_if[port];
3099                 if (sc_if == NULL) {
3100                         device_printf(sc->msk_dev, "invalid port opcode "
3101                             "0x%08x\n", control & STLE_OP_MASK);
3102                         continue;
3103                 }
3104
3105                 switch (control & STLE_OP_MASK) {
3106                 case OP_RXVLAN:
3107                         sc_if->msk_vtag = ntohs(len);
3108                         break;
3109                 case OP_RXCHKSVLAN:
3110                         sc_if->msk_vtag = ntohs(len);
3111                         break;
3112                 case OP_RXSTAT:
3113 #ifdef MSK_JUMBO
3114                         if (sc_if->msk_framesize > (MCLBYTES - ETHER_HDR_LEN))
3115                                 msk_jumbo_rxeof(sc_if, status, len);
3116                         else
3117 #endif
3118                                 msk_rxeof(sc_if, status, len, chain);
3119                         rxprog++;
3120                         /*
3121                          * Because there is no way to sync single Rx LE
3122                          * put the DMA sync operation off until the end of
3123                          * event processing.
3124                          */
3125                         rxput[port]++;
3126                         /* Update prefetch unit if we've passed water mark. */
3127                         if (rxput[port] >= sc_if->msk_cdata.msk_rx_putwm) {
3128                                 msk_rxput(sc_if);
3129                                 rxput[port] = 0;
3130                         }
3131                         break;
3132                 case OP_TXINDEXLE:
3133                         if (sc->msk_if[MSK_PORT_A] != NULL) {
3134                                 msk_txeof(sc->msk_if[MSK_PORT_A],
3135                                     status & STLE_TXA1_MSKL);
3136                         }
3137                         if (sc->msk_if[MSK_PORT_B] != NULL) {
3138                                 msk_txeof(sc->msk_if[MSK_PORT_B],
3139                                     ((status & STLE_TXA2_MSKL) >>
3140                                     STLE_TXA2_SHIFTL) |
3141                                     ((len & STLE_TXA2_MSKH) <<
3142                                     STLE_TXA2_SHIFTH));
3143                         }
3144                         break;
3145                 default:
3146                         device_printf(sc->msk_dev, "unhandled opcode 0x%08x\n",
3147                             control & STLE_OP_MASK);
3148                         break;
3149                 }
3150                 MSK_INC(cons, MSK_STAT_RING_CNT);
3151                 if (rxprog > sc->msk_process_limit)
3152                         break;
3153         }
3154
3155         if (rxprog > 0)
3156                 ether_input_dispatch(chain);
3157
3158         sc->msk_stat_cons = cons;
3159         /* XXX We should sync status LEs here. See above notes. */
3160
3161         if (rxput[MSK_PORT_A] > 0)
3162                 msk_rxput(sc->msk_if[MSK_PORT_A]);
3163         if (rxput[MSK_PORT_B] > 0)
3164                 msk_rxput(sc->msk_if[MSK_PORT_B]);
3165
3166         return (sc->msk_stat_cons != CSR_READ_2(sc, STAT_PUT_IDX));
3167 }
3168
3169 /* Legacy interrupt handler for shared interrupt. */
3170 static void
3171 mskc_intr(void *xsc)
3172 {
3173         struct msk_softc *sc;
3174         struct msk_if_softc *sc_if0, *sc_if1;
3175         struct ifnet *ifp0, *ifp1;
3176         uint32_t status;
3177
3178         sc = xsc;
3179         ASSERT_SERIALIZED(&sc->msk_serializer);
3180
3181         /* Reading B0_Y2_SP_ISRC2 masks further interrupts. */
3182         status = CSR_READ_4(sc, B0_Y2_SP_ISRC2);
3183         if (status == 0 || status == 0xffffffff || sc->msk_suspended != 0 ||
3184             (status & sc->msk_intrmask) == 0) {
3185                 CSR_WRITE_4(sc, B0_Y2_SP_ICR, 2);
3186                 return;
3187         }
3188
3189         sc_if0 = sc->msk_if[MSK_PORT_A];
3190         sc_if1 = sc->msk_if[MSK_PORT_B];
3191         ifp0 = ifp1 = NULL;
3192         if (sc_if0 != NULL)
3193                 ifp0 = sc_if0->msk_ifp;
3194         if (sc_if1 != NULL)
3195                 ifp1 = sc_if1->msk_ifp;
3196
3197         if ((status & Y2_IS_IRQ_PHY1) != 0 && sc_if0 != NULL)
3198                 msk_intr_phy(sc_if0);
3199         if ((status & Y2_IS_IRQ_PHY2) != 0 && sc_if1 != NULL)
3200                 msk_intr_phy(sc_if1);
3201         if ((status & Y2_IS_IRQ_MAC1) != 0 && sc_if0 != NULL)
3202                 msk_intr_gmac(sc_if0);
3203         if ((status & Y2_IS_IRQ_MAC2) != 0 && sc_if1 != NULL)
3204                 msk_intr_gmac(sc_if1);
3205         if ((status & (Y2_IS_CHK_RX1 | Y2_IS_CHK_RX2)) != 0) {
3206                 device_printf(sc->msk_dev, "Rx descriptor error\n");
3207                 sc->msk_intrmask &= ~(Y2_IS_CHK_RX1 | Y2_IS_CHK_RX2);
3208                 CSR_WRITE_4(sc, B0_IMSK, sc->msk_intrmask);
3209                 CSR_READ_4(sc, B0_IMSK);
3210         }
3211         if ((status & (Y2_IS_CHK_TXA1 | Y2_IS_CHK_TXA2)) != 0) {
3212                 device_printf(sc->msk_dev, "Tx descriptor error\n");
3213                 sc->msk_intrmask &= ~(Y2_IS_CHK_TXA1 | Y2_IS_CHK_TXA2);
3214                 CSR_WRITE_4(sc, B0_IMSK, sc->msk_intrmask);
3215                 CSR_READ_4(sc, B0_IMSK);
3216         }
3217         if ((status & Y2_IS_HW_ERR) != 0)
3218                 mskc_intr_hwerr(sc);
3219
3220         while (mskc_handle_events(sc) != 0)
3221                 ;
3222         if ((status & Y2_IS_STAT_BMU) != 0)
3223                 CSR_WRITE_4(sc, STAT_CTRL, SC_STAT_CLR_IRQ);
3224
3225         /* Reenable interrupts. */
3226         CSR_WRITE_4(sc, B0_Y2_SP_ICR, 2);
3227
3228         if (ifp0 != NULL && (ifp0->if_flags & IFF_RUNNING) != 0 &&
3229             !ifq_is_empty(&ifp0->if_snd))
3230                 if_devstart(ifp0);
3231         if (ifp1 != NULL && (ifp1->if_flags & IFF_RUNNING) != 0 &&
3232             !ifq_is_empty(&ifp1->if_snd))
3233                 if_devstart(ifp1);
3234 }
3235
3236 static void
3237 msk_init(void *xsc)
3238 {
3239         struct msk_if_softc *sc_if = xsc;
3240         struct msk_softc *sc = sc_if->msk_softc;
3241         struct ifnet *ifp = sc_if->msk_ifp;
3242         struct mii_data  *mii;
3243         uint16_t eaddr[ETHER_ADDR_LEN / 2];
3244         uint16_t gmac;
3245         int error, i;
3246
3247         ASSERT_SERIALIZED(ifp->if_serializer);
3248
3249         mii = device_get_softc(sc_if->msk_miibus);
3250
3251         error = 0;
3252         /* Cancel pending I/O and free all Rx/Tx buffers. */
3253         msk_stop(sc_if);
3254
3255         sc_if->msk_framesize = ifp->if_mtu + ETHER_HDR_LEN + EVL_ENCAPLEN;
3256         if (sc_if->msk_framesize > MSK_MAX_FRAMELEN &&
3257             sc_if->msk_softc->msk_hw_id == CHIP_ID_YUKON_EC_U) {
3258                 /*
3259                  * In Yukon EC Ultra, TSO & checksum offload is not
3260                  * supported for jumbo frame.
3261                  */
3262                 ifp->if_hwassist &= ~MSK_CSUM_FEATURES;
3263                 ifp->if_capenable &= ~IFCAP_TXCSUM;
3264         }
3265
3266         /*
3267          * Initialize GMAC first.
3268          * Without this initialization, Rx MAC did not work as expected
3269          * and Rx MAC garbled status LEs and it resulted in out-of-order
3270          * or duplicated frame delivery which in turn showed very poor
3271          * Rx performance.(I had to write a packet analysis code that
3272          * could be embeded in driver to diagnose this issue.)
3273          * I've spent almost 2 months to fix this issue. If I have had
3274          * datasheet for Yukon II I wouldn't have encountered this. :-(
3275          */
3276         gmac = GM_GPCR_SPEED_100 | GM_GPCR_SPEED_1000 | GM_GPCR_DUP_FULL;
3277         GMAC_WRITE_2(sc, sc_if->msk_port, GM_GP_CTRL, gmac);
3278
3279         /* Dummy read the Interrupt Source Register. */
3280         CSR_READ_1(sc, MR_ADDR(sc_if->msk_port, GMAC_IRQ_SRC));
3281
3282         /* Set MIB Clear Counter Mode. */
3283         gmac = GMAC_READ_2(sc, sc_if->msk_port, GM_PHY_ADDR);
3284         GMAC_WRITE_2(sc, sc_if->msk_port, GM_PHY_ADDR, gmac | GM_PAR_MIB_CLR);
3285         /* Read all MIB Counters with Clear Mode set. */
3286         for (i = 0; i < GM_MIB_CNT_SIZE; i++)
3287                 GMAC_READ_2(sc, sc_if->msk_port, GM_MIB_CNT_BASE + 8 * i);
3288         /* Clear MIB Clear Counter Mode. */
3289         gmac &= ~GM_PAR_MIB_CLR;
3290         GMAC_WRITE_2(sc, sc_if->msk_port, GM_PHY_ADDR, gmac);
3291
3292         /* Disable FCS. */
3293         GMAC_WRITE_2(sc, sc_if->msk_port, GM_RX_CTRL, GM_RXCR_CRC_DIS);
3294
3295         /* Setup Transmit Control Register. */
3296         GMAC_WRITE_2(sc, sc_if->msk_port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF));
3297
3298         /* Setup Transmit Flow Control Register. */
3299         GMAC_WRITE_2(sc, sc_if->msk_port, GM_TX_FLOW_CTRL, 0xffff);
3300
3301         /* Setup Transmit Parameter Register. */
3302         GMAC_WRITE_2(sc, sc_if->msk_port, GM_TX_PARAM,
3303             TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) | TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) |
3304             TX_IPG_JAM_DATA(TX_IPG_JAM_DEF) | TX_BACK_OFF_LIM(TX_BOF_LIM_DEF));
3305
3306         gmac = DATA_BLIND_VAL(DATA_BLIND_DEF) |
3307             GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF);
3308
3309         if (sc_if->msk_framesize > MSK_MAX_FRAMELEN)
3310                 gmac |= GM_SMOD_JUMBO_ENA;
3311         GMAC_WRITE_2(sc, sc_if->msk_port, GM_SERIAL_MODE, gmac);
3312
3313         /* Set station address. */
3314         bcopy(IF_LLADDR(ifp), eaddr, ETHER_ADDR_LEN);
3315         for (i = 0; i < ETHER_ADDR_LEN /2; i++)
3316                 GMAC_WRITE_2(sc, sc_if->msk_port, GM_SRC_ADDR_1L + i * 4,
3317                     eaddr[i]);
3318         for (i = 0; i < ETHER_ADDR_LEN /2; i++)
3319                 GMAC_WRITE_2(sc, sc_if->msk_port, GM_SRC_ADDR_2L + i * 4,
3320                     eaddr[i]);
3321
3322         /* Disable interrupts for counter overflows. */
3323         GMAC_WRITE_2(sc, sc_if->msk_port, GM_TX_IRQ_MSK, 0);
3324         GMAC_WRITE_2(sc, sc_if->msk_port, GM_RX_IRQ_MSK, 0);
3325         GMAC_WRITE_2(sc, sc_if->msk_port, GM_TR_IRQ_MSK, 0);
3326
3327         /* Configure Rx MAC FIFO. */
3328         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T), GMF_RST_SET);
3329         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T), GMF_RST_CLR);
3330         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T),
3331             GMF_OPER_ON | GMF_RX_F_FL_ON);
3332
3333         /* Set promiscuous mode. */
3334         msk_setpromisc(sc_if);
3335
3336         /* Set multicast filter. */
3337         msk_setmulti(sc_if);
3338
3339         /* Flush Rx MAC FIFO on any flow control or error. */
3340         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_FL_MSK),
3341             GMR_FS_ANY_ERR);
3342
3343         /*
3344          * Set Rx FIFO flush threshold to 64 bytes 1 FIFO word
3345          * due to hardware hang on receipt of pause frames.
3346          */
3347         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_FL_THR),
3348             RX_GMF_FL_THR_DEF + 1);
3349
3350         /* Configure Tx MAC FIFO. */
3351         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T), GMF_RST_SET);
3352         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T), GMF_RST_CLR);
3353         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T), GMF_OPER_ON);
3354
3355         /* Configure hardware VLAN tag insertion/stripping. */
3356         msk_setvlan(sc_if, ifp);
3357
3358         if ((sc_if->msk_flags & MSK_FLAG_RAMBUF) == 0) {
3359                 /* Set Rx Pause threshould. */
3360                 CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, RX_GMF_LP_THR),
3361                     MSK_ECU_LLPP);
3362                 CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, RX_GMF_UP_THR),
3363                     MSK_ECU_ULPP);
3364                 if (sc_if->msk_framesize > MSK_MAX_FRAMELEN) {
3365                         /*
3366                          * Set Tx GMAC FIFO Almost Empty Threshold.
3367                          */
3368                         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_AE_THR),
3369                             MSK_ECU_JUMBO_WM << 16 | MSK_ECU_AE_THR);
3370                         /* Disable Store & Forward mode for Tx. */
3371                         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
3372                             TX_JUMBO_ENA | TX_STFW_DIS);
3373                 } else {
3374                         /* Enable Store & Forward mode for Tx. */
3375                         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T),
3376                             TX_JUMBO_DIS | TX_STFW_ENA);
3377                 }
3378         }
3379
3380         /*
3381          * Disable Force Sync bit and Alloc bit in Tx RAM interface
3382          * arbiter as we don't use Sync Tx queue.
3383          */
3384         CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, TXA_CTRL),
3385             TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
3386         /* Enable the RAM Interface Arbiter. */
3387         CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, TXA_CTRL), TXA_ENA_ARB);
3388
3389         /* Setup RAM buffer. */
3390         msk_set_rambuffer(sc_if);
3391
3392         /* Disable Tx sync Queue. */
3393         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txsq, RB_CTRL), RB_RST_SET);
3394
3395         /* Setup Tx Queue Bus Memory Interface. */
3396         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR), BMU_CLR_RESET);
3397         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR), BMU_OPER_INIT);
3398         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR), BMU_FIFO_OP_ON);
3399         CSR_WRITE_2(sc, Q_ADDR(sc_if->msk_txq, Q_WM), MSK_BMU_TX_WM);
3400         if (sc->msk_hw_id == CHIP_ID_YUKON_EC_U &&
3401             sc->msk_hw_rev == CHIP_REV_YU_EC_U_A0) {
3402                 /* Fix for Yukon-EC Ultra: set BMU FIFO level */
3403                 CSR_WRITE_2(sc, Q_ADDR(sc_if->msk_txq, Q_AL), MSK_ECU_TXFF_LEV);
3404         }
3405
3406         /* Setup Rx Queue Bus Memory Interface. */
3407         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR), BMU_CLR_RESET);
3408         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR), BMU_OPER_INIT);
3409         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR), BMU_FIFO_OP_ON);
3410         CSR_WRITE_2(sc, Q_ADDR(sc_if->msk_rxq, Q_WM), MSK_BMU_RX_WM);
3411         if (sc->msk_hw_id == CHIP_ID_YUKON_EC_U &&
3412             sc->msk_hw_rev >= CHIP_REV_YU_EC_U_A1) {
3413                 /* MAC Rx RAM Read is controlled by hardware. */
3414                 CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_F), F_M_RX_RAM_DIS);
3415         }
3416
3417         msk_set_prefetch(sc, sc_if->msk_txq,
3418             sc_if->msk_rdata.msk_tx_ring_paddr, MSK_TX_RING_CNT - 1);
3419         msk_init_tx_ring(sc_if);
3420
3421         /* Disable Rx checksum offload and RSS hash. */
3422         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR),
3423             BMU_DIS_RX_CHKSUM | BMU_DIS_RX_RSS_HASH);
3424 #ifdef MSK_JUMBO
3425         if (sc_if->msk_framesize > (MCLBYTES - ETHER_HDR_LEN)) {
3426                 msk_set_prefetch(sc, sc_if->msk_rxq,
3427                     sc_if->msk_rdata.msk_jumbo_rx_ring_paddr,
3428                     MSK_JUMBO_RX_RING_CNT - 1);
3429                 error = msk_init_jumbo_rx_ring(sc_if);
3430         } else
3431 #endif
3432         {
3433                 msk_set_prefetch(sc, sc_if->msk_rxq,
3434                     sc_if->msk_rdata.msk_rx_ring_paddr,
3435                     MSK_RX_RING_CNT - 1);
3436                 error = msk_init_rx_ring(sc_if);
3437         }
3438         if (error != 0) {
3439                 device_printf(sc_if->msk_if_dev,
3440                     "initialization failed: no memory for Rx buffers\n");
3441                 msk_stop(sc_if);
3442                 return;
3443         }
3444
3445         /* Configure interrupt handling. */
3446         if (sc_if->msk_port == MSK_PORT_A) {
3447                 sc->msk_intrmask |= Y2_IS_PORT_A;
3448                 sc->msk_intrhwemask |= Y2_HWE_L1_MASK;
3449         } else {
3450                 sc->msk_intrmask |= Y2_IS_PORT_B;
3451                 sc->msk_intrhwemask |= Y2_HWE_L2_MASK;
3452         }
3453         CSR_WRITE_4(sc, B0_HWE_IMSK, sc->msk_intrhwemask);
3454         CSR_READ_4(sc, B0_HWE_IMSK);
3455         CSR_WRITE_4(sc, B0_IMSK, sc->msk_intrmask);
3456         CSR_READ_4(sc, B0_IMSK);
3457
3458         sc_if->msk_link = 0;
3459         mii_mediachg(mii);
3460
3461         mskc_set_imtimer(sc);
3462
3463         ifp->if_flags |= IFF_RUNNING;
3464         ifp->if_flags &= ~IFF_OACTIVE;
3465
3466         callout_reset(&sc_if->msk_tick_ch, hz, msk_tick, sc_if);
3467 }
3468
3469 static void
3470 msk_set_rambuffer(struct msk_if_softc *sc_if)
3471 {
3472         struct msk_softc *sc;
3473         int ltpp, utpp;
3474
3475         if ((sc_if->msk_flags & MSK_FLAG_RAMBUF) == 0)
3476                 return;
3477
3478         sc = sc_if->msk_softc;
3479
3480         /* Setup Rx Queue. */
3481         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_rxq, RB_CTRL), RB_RST_CLR);
3482         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_START),
3483             sc->msk_rxqstart[sc_if->msk_port] / 8);
3484         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_END),
3485             sc->msk_rxqend[sc_if->msk_port] / 8);
3486         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_WP),
3487             sc->msk_rxqstart[sc_if->msk_port] / 8);
3488         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_RP),
3489             sc->msk_rxqstart[sc_if->msk_port] / 8);
3490
3491         utpp = (sc->msk_rxqend[sc_if->msk_port] + 1 -
3492             sc->msk_rxqstart[sc_if->msk_port] - MSK_RB_ULPP) / 8;
3493         ltpp = (sc->msk_rxqend[sc_if->msk_port] + 1 -
3494             sc->msk_rxqstart[sc_if->msk_port] - MSK_RB_LLPP_B) / 8;
3495         if (sc->msk_rxqsize < MSK_MIN_RXQ_SIZE)
3496                 ltpp += (MSK_RB_LLPP_B - MSK_RB_LLPP_S) / 8;
3497         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_RX_UTPP), utpp);
3498         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_rxq, RB_RX_LTPP), ltpp);
3499         /* Set Rx priority(RB_RX_UTHP/RB_RX_LTHP) thresholds? */
3500
3501         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_rxq, RB_CTRL), RB_ENA_OP_MD);
3502         CSR_READ_1(sc, RB_ADDR(sc_if->msk_rxq, RB_CTRL));
3503
3504         /* Setup Tx Queue. */
3505         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL), RB_RST_CLR);
3506         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_txq, RB_START),
3507             sc->msk_txqstart[sc_if->msk_port] / 8);
3508         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_txq, RB_END),
3509             sc->msk_txqend[sc_if->msk_port] / 8);
3510         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_txq, RB_WP),
3511             sc->msk_txqstart[sc_if->msk_port] / 8);
3512         CSR_WRITE_4(sc, RB_ADDR(sc_if->msk_txq, RB_RP),
3513             sc->msk_txqstart[sc_if->msk_port] / 8);
3514         /* Enable Store & Forward for Tx side. */
3515         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL), RB_ENA_STFWD);
3516         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL), RB_ENA_OP_MD);
3517         CSR_READ_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL));
3518 }
3519
3520 static void
3521 msk_set_prefetch(struct msk_softc *sc, int qaddr, bus_addr_t addr,
3522     uint32_t count)
3523 {
3524
3525         /* Reset the prefetch unit. */
3526         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_CTRL_REG),
3527             PREF_UNIT_RST_SET);
3528         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_CTRL_REG),
3529             PREF_UNIT_RST_CLR);
3530         /* Set LE base address. */
3531         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_ADDR_LOW_REG),
3532             MSK_ADDR_LO(addr));
3533         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_ADDR_HI_REG),
3534             MSK_ADDR_HI(addr));
3535         /* Set the list last index. */
3536         CSR_WRITE_2(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_LAST_IDX_REG),
3537             count);
3538         /* Turn on prefetch unit. */
3539         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_CTRL_REG),
3540             PREF_UNIT_OP_ON);
3541         /* Dummy read to ensure write. */
3542         CSR_READ_4(sc, Y2_PREF_Q_ADDR(qaddr, PREF_UNIT_CTRL_REG));
3543 }
3544
3545 static void
3546 msk_stop(struct msk_if_softc *sc_if)
3547 {
3548         struct msk_softc *sc = sc_if->msk_softc;
3549         struct ifnet *ifp = sc_if->msk_ifp;
3550         struct msk_txdesc *txd;
3551         struct msk_rxdesc *rxd;
3552 #ifdef MSK_JUMBO
3553         struct msk_rxdesc *jrxd;
3554 #endif
3555         uint32_t val;
3556         int i;
3557
3558         ASSERT_SERIALIZED(ifp->if_serializer);
3559
3560         callout_stop(&sc_if->msk_tick_ch);
3561         ifp->if_timer = 0;
3562
3563         /* Disable interrupts. */
3564         if (sc_if->msk_port == MSK_PORT_A) {
3565                 sc->msk_intrmask &= ~Y2_IS_PORT_A;
3566                 sc->msk_intrhwemask &= ~Y2_HWE_L1_MASK;
3567         } else {
3568                 sc->msk_intrmask &= ~Y2_IS_PORT_B;
3569                 sc->msk_intrhwemask &= ~Y2_HWE_L2_MASK;
3570         }
3571         CSR_WRITE_4(sc, B0_HWE_IMSK, sc->msk_intrhwemask);
3572         CSR_READ_4(sc, B0_HWE_IMSK);
3573         CSR_WRITE_4(sc, B0_IMSK, sc->msk_intrmask);
3574         CSR_READ_4(sc, B0_IMSK);
3575
3576         /* Disable Tx/Rx MAC. */
3577         val = GMAC_READ_2(sc, sc_if->msk_port, GM_GP_CTRL);
3578         val &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
3579         GMAC_WRITE_2(sc, sc_if->msk_port, GM_GP_CTRL, val);
3580         /* Read again to ensure writing. */
3581         GMAC_READ_2(sc, sc_if->msk_port, GM_GP_CTRL);
3582
3583         /* Stop Tx BMU. */
3584         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR), BMU_STOP);
3585         val = CSR_READ_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR));
3586         for (i = 0; i < MSK_TIMEOUT; i++) {
3587                 if ((val & (BMU_STOP | BMU_IDLE)) == 0) {
3588                         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR),
3589                             BMU_STOP);
3590                         val = CSR_READ_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR));
3591                 } else
3592                         break;
3593                 DELAY(1);
3594         }
3595         if (i == MSK_TIMEOUT)
3596                 device_printf(sc_if->msk_if_dev, "Tx BMU stop failed\n");
3597         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL),
3598             RB_RST_SET | RB_DIS_OP_MD);
3599
3600         /* Disable all GMAC interrupt. */
3601         CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, GMAC_IRQ_MSK), 0);
3602         /* Disable PHY interrupt. */
3603         msk_phy_writereg(sc_if, PHY_ADDR_MARV, PHY_MARV_INT_MASK, 0);
3604
3605         /* Disable the RAM Interface Arbiter. */
3606         CSR_WRITE_1(sc, MR_ADDR(sc_if->msk_port, TXA_CTRL), TXA_DIS_ARB);
3607
3608         /* Reset the PCI FIFO of the async Tx queue */
3609         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_txq, Q_CSR),
3610             BMU_RST_SET | BMU_FIFO_RST);
3611
3612         /* Reset the Tx prefetch units. */
3613         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(sc_if->msk_txq, PREF_UNIT_CTRL_REG),
3614             PREF_UNIT_RST_SET);
3615
3616         /* Reset the RAM Buffer async Tx queue. */
3617         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_txq, RB_CTRL), RB_RST_SET);
3618
3619         /* Reset Tx MAC FIFO. */
3620         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, TX_GMF_CTRL_T), GMF_RST_SET);
3621         /* Set Pause Off. */
3622         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, GMAC_CTRL), GMC_PAUSE_OFF);
3623
3624         /*
3625          * The Rx Stop command will not work for Yukon-2 if the BMU does not
3626          * reach the end of packet and since we can't make sure that we have
3627          * incoming data, we must reset the BMU while it is not during a DMA
3628          * transfer. Since it is possible that the Rx path is still active,
3629          * the Rx RAM buffer will be stopped first, so any possible incoming
3630          * data will not trigger a DMA. After the RAM buffer is stopped, the
3631          * BMU is polled until any DMA in progress is ended and only then it
3632          * will be reset.
3633          */
3634
3635         /* Disable the RAM Buffer receive queue. */
3636         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_rxq, RB_CTRL), RB_DIS_OP_MD);
3637         for (i = 0; i < MSK_TIMEOUT; i++) {
3638                 if (CSR_READ_1(sc, RB_ADDR(sc_if->msk_rxq, Q_RSL)) ==
3639                     CSR_READ_1(sc, RB_ADDR(sc_if->msk_rxq, Q_RL)))
3640                         break;
3641                 DELAY(1);
3642         }
3643         if (i == MSK_TIMEOUT)
3644                 device_printf(sc_if->msk_if_dev, "Rx BMU stop failed\n");
3645         CSR_WRITE_4(sc, Q_ADDR(sc_if->msk_rxq, Q_CSR),
3646             BMU_RST_SET | BMU_FIFO_RST);
3647         /* Reset the Rx prefetch unit. */
3648         CSR_WRITE_4(sc, Y2_PREF_Q_ADDR(sc_if->msk_rxq, PREF_UNIT_CTRL_REG),
3649             PREF_UNIT_RST_SET);
3650         /* Reset the RAM Buffer receive queue. */
3651         CSR_WRITE_1(sc, RB_ADDR(sc_if->msk_rxq, RB_CTRL), RB_RST_SET);
3652         /* Reset Rx MAC FIFO. */
3653         CSR_WRITE_4(sc, MR_ADDR(sc_if->msk_port, RX_GMF_CTRL_T), GMF_RST_SET);
3654
3655         /* Free Rx and Tx mbufs still in the queues. */
3656         for (i = 0; i < MSK_RX_RING_CNT; i++) {
3657                 rxd = &sc_if->msk_cdata.msk_rxdesc[i];
3658                 if (rxd->rx_m != NULL) {
3659                         bus_dmamap_unload(sc_if->msk_cdata.msk_rx_tag,
3660                             rxd->rx_dmamap);
3661                         m_freem(rxd->rx_m);
3662                         rxd->rx_m = NULL;
3663                 }
3664         }
3665 #ifdef MSK_JUMBO
3666         for (i = 0; i < MSK_JUMBO_RX_RING_CNT; i++) {
3667                 jrxd = &sc_if->msk_cdata.msk_jumbo_rxdesc[i];
3668                 if (jrxd->rx_m != NULL) {
3669                         bus_dmamap_sync(sc_if->msk_cdata.msk_jumbo_rx_tag,
3670                             jrxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
3671                         bus_dmamap_unload(sc_if->msk_cdata.msk_jumbo_rx_tag,
3672                             jrxd->rx_dmamap);
3673                         m_freem(jrxd->rx_m);
3674                         jrxd->rx_m = NULL;
3675                 }
3676         }
3677 #endif
3678         for (i = 0; i < MSK_TX_RING_CNT; i++) {
3679                 txd = &sc_if->msk_cdata.msk_txdesc[i];
3680                 if (txd->tx_m != NULL) {
3681                         bus_dmamap_unload(sc_if->msk_cdata.msk_tx_tag,
3682                             txd->tx_dmamap);
3683                         m_freem(txd->tx_m);
3684                         txd->tx_m = NULL;
3685                 }
3686         }
3687
3688         /*
3689          * Mark the interface down.
3690          */
3691         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
3692         sc_if->msk_link = 0;
3693 }
3694
3695 static int
3696 mskc_sysctl_proc_limit(SYSCTL_HANDLER_ARGS)
3697 {
3698         return sysctl_int_range(oidp, arg1, arg2, req,
3699                                 MSK_PROC_MIN, MSK_PROC_MAX);
3700 }
3701
3702 static int
3703 mskc_sysctl_intr_rate(SYSCTL_HANDLER_ARGS)
3704 {
3705         struct msk_softc *sc = arg1;
3706         struct lwkt_serialize *serializer = &sc->msk_serializer;
3707         int error = 0, v;
3708
3709         lwkt_serialize_enter(serializer);
3710
3711         v = sc->msk_intr_rate;
3712         error = sysctl_handle_int(oidp, &v, 0, req);
3713         if (error || req->newptr == NULL)
3714                 goto back;
3715         if (v < 0) {
3716                 error = EINVAL;
3717                 goto back;
3718         }
3719
3720         if (sc->msk_intr_rate != v) {
3721                 int flag = 0, i;
3722
3723                 sc->msk_intr_rate = v;
3724                 for (i = 0; i < 2; ++i) {
3725                         if (sc->msk_if[i] != NULL) {
3726                                 flag |= sc->msk_if[i]->
3727                                         arpcom.ac_if.if_flags & IFF_RUNNING;
3728                         }
3729                 }
3730                 if (flag)
3731                         mskc_set_imtimer(sc);
3732         }
3733 back:
3734         lwkt_serialize_exit(serializer);
3735         return error;
3736 }
3737
3738 static int
3739 msk_dmamem_create(device_t dev, bus_size_t size, bus_dma_tag_t *dtag,
3740                   void **addr, bus_addr_t *paddr, bus_dmamap_t *dmap)
3741 {
3742         struct msk_if_softc *sc_if = device_get_softc(dev);
3743         bus_dmamem_t dmem;
3744         int error;
3745
3746         error = bus_dmamem_coherent(sc_if->msk_cdata.msk_parent_tag,
3747                         MSK_RING_ALIGN, 0,
3748                         BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
3749                         size, BUS_DMA_WAITOK | BUS_DMA_ZERO, &dmem);
3750         if (error) {
3751                 device_printf(dev, "can't create coherent DMA memory\n");
3752                 return error;
3753         }
3754
3755         *dtag = dmem.dmem_tag;
3756         *dmap = dmem.dmem_map;
3757         *addr = dmem.dmem_addr;
3758         *paddr = dmem.dmem_busaddr;
3759
3760         return 0;
3761 }
3762
3763 static void
3764 msk_dmamem_destroy(bus_dma_tag_t dtag, void *addr, bus_dmamap_t dmap)
3765 {
3766         if (dtag != NULL) {
3767                 bus_dmamap_unload(dtag, dmap);
3768                 bus_dmamem_free(dtag, addr, dmap);
3769                 bus_dma_tag_destroy(dtag);
3770         }
3771 }
3772
3773 static void
3774 mskc_set_imtimer(struct msk_softc *sc)
3775 {
3776         if (sc->msk_intr_rate > 0) {
3777                 /*
3778                  * XXX myk(4) seems to use 125MHz for EC/FE/XL
3779                  *     and 78.125MHz for rest of chip types
3780                  */
3781                 CSR_WRITE_4(sc, B2_IRQM_INI,
3782                             MSK_USECS(sc, 1000000 / sc->msk_intr_rate));
3783                 CSR_WRITE_4(sc, B2_IRQM_MSK, sc->msk_intrmask);
3784                 CSR_WRITE_4(sc, B2_IRQM_CTRL, TIM_START);
3785         } else {
3786                 CSR_WRITE_4(sc, B2_IRQM_CTRL, TIM_STOP);
3787         }
3788 }