sys/dev/rt/if_rt.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2015-2016, Stanislav Galabov
   5  * Copyright (c) 2014, Aleksandr A. Mityaev
   6  * Copyright (c) 2011, Aleksandr Rybalko
   7  * based on hard work
   8  * by Alexander Egorenkov <egorenar@gmail.com>
   9  * and by Damien Bergamini <damien.bergamini@free.fr>
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice unmodified, this list of conditions, and the following
  17  *    disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "if_rtvar.h"
  39 #include "if_rtreg.h"
  40
  41 #include <net/if.h>
  42 #include <net/if_var.h>
  43 #include <net/if_arp.h>
  44 #include <net/ethernet.h>
  45 #include <net/if_dl.h>
  46 #include <net/if_media.h>
  47 #include <net/if_types.h>
  48 #include <net/if_vlan_var.h>
  49
  50 #include <net/bpf.h>
  51
  52 #include <machine/bus.h>
  53 #include <machine/cache.h>
  54 #include <machine/cpufunc.h>
  55 #include <machine/resource.h>
  56 #include <vm/vm_param.h>
  57 #include <vm/vm.h>
  58 #include <vm/pmap.h>
  59 #include <machine/pmap.h>
  60 #include <sys/bus.h>
  61 #include <sys/rman.h>
  62
  63 #include "opt_platform.h"
  64 #include "opt_rt305x.h"
  65
  66 #ifdef FDT
  67 #include <dev/ofw/openfirm.h>
  68 #include <dev/ofw/ofw_bus.h>
  69 #include <dev/ofw/ofw_bus_subr.h>
  70 #endif
  71
  72 #include <dev/mii/mii.h>
  73 #include <dev/mii/miivar.h>
  74
  75 #ifdef RT_MDIO
  76 #include <dev/mdio/mdio.h>
  77 #include <dev/etherswitch/miiproxy.h>
  78 #include "mdio_if.h"
  79 #endif
  80
  81 #if 0
  82 #include <mips/rt305x/rt305x_sysctlvar.h>
  83 #include <mips/rt305x/rt305xreg.h>
  84 #endif
  85
  86 #ifdef IF_RT_PHY_SUPPORT
  87 #include "miibus_if.h"
  88 #endif
  89
  90 /*
  91  * Defines and macros
  92  */
  93 #define RT_MAX_AGG_SIZE                 3840
  94
  95 #define RT_TX_DATA_SEG0_SIZE            MJUMPAGESIZE
  96
  97 #define RT_MS(_v, _f)                   (((_v) & _f) >> _f##_S)
  98 #define RT_SM(_v, _f)                   (((_v) << _f##_S) & _f)
  99
 100 #define RT_TX_WATCHDOG_TIMEOUT          5
 101
 102 #define RT_CHIPID_RT2880 0x2880
 103 #define RT_CHIPID_RT3050 0x3050
 104 #define RT_CHIPID_RT5350 0x5350
 105 #define RT_CHIPID_MT7620 0x7620
 106 #define RT_CHIPID_MT7621 0x7621
 107
 108 #ifdef FDT
 109 /* more specific and new models should go first */
 110 static const struct ofw_compat_data rt_compat_data[] = {
 111         { "ralink,rt2880-eth",          RT_CHIPID_RT2880 },
 112         { "ralink,rt3050-eth",          RT_CHIPID_RT3050 },
 113         { "ralink,rt3352-eth",          RT_CHIPID_RT3050 },
 114         { "ralink,rt3883-eth",          RT_CHIPID_RT3050 },
 115         { "ralink,rt5350-eth",          RT_CHIPID_RT5350 },
 116         { "ralink,mt7620a-eth",         RT_CHIPID_MT7620 },
 117         { "mediatek,mt7620-eth",        RT_CHIPID_MT7620 },
 118         { "ralink,mt7621-eth",          RT_CHIPID_MT7621 },
 119         { "mediatek,mt7621-eth",        RT_CHIPID_MT7621 },
 120         { NULL,                         0 }
 121 };
 122 #endif
 123
 124 /*
 125  * Static function prototypes
 126  */
 127 static int      rt_probe(device_t dev);
 128 static int      rt_attach(device_t dev);
 129 static int      rt_detach(device_t dev);
 130 static int      rt_shutdown(device_t dev);
 131 static int      rt_suspend(device_t dev);
 132 static int      rt_resume(device_t dev);
 133 static void     rt_init_locked(void *priv);
 134 static void     rt_init(void *priv);
 135 static void     rt_stop_locked(void *priv);
 136 static void     rt_stop(void *priv);
 137 static void     rt_start(struct ifnet *ifp);
 138 static int      rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
 139 static void     rt_periodic(void *arg);
 140 static void     rt_tx_watchdog(void *arg);
 141 static void     rt_intr(void *arg);
 142 static void     rt_rt5350_intr(void *arg);
 143 static void     rt_tx_coherent_intr(struct rt_softc *sc);
 144 static void     rt_rx_coherent_intr(struct rt_softc *sc);
 145 static void     rt_rx_delay_intr(struct rt_softc *sc);
 146 static void     rt_tx_delay_intr(struct rt_softc *sc);
 147 static void     rt_rx_intr(struct rt_softc *sc, int qid);
 148 static void     rt_tx_intr(struct rt_softc *sc, int qid);
 149 static void     rt_rx_done_task(void *context, int pending);
 150 static void     rt_tx_done_task(void *context, int pending);
 151 static void     rt_periodic_task(void *context, int pending);
 152 static int      rt_rx_eof(struct rt_softc *sc,
 153                     struct rt_softc_rx_ring *ring, int limit);
 154 static void     rt_tx_eof(struct rt_softc *sc,
 155                     struct rt_softc_tx_ring *ring);
 156 static void     rt_update_stats(struct rt_softc *sc);
 157 static void     rt_watchdog(struct rt_softc *sc);
 158 static void     rt_update_raw_counters(struct rt_softc *sc);
 159 static void     rt_intr_enable(struct rt_softc *sc, uint32_t intr_mask);
 160 static void     rt_intr_disable(struct rt_softc *sc, uint32_t intr_mask);
 161 static int      rt_txrx_enable(struct rt_softc *sc);
 162 static int      rt_alloc_rx_ring(struct rt_softc *sc,
 163                     struct rt_softc_rx_ring *ring, int qid);
 164 static void     rt_reset_rx_ring(struct rt_softc *sc,
 165                     struct rt_softc_rx_ring *ring);
 166 static void     rt_free_rx_ring(struct rt_softc *sc,
 167                     struct rt_softc_rx_ring *ring);
 168 static int      rt_alloc_tx_ring(struct rt_softc *sc,
 169                     struct rt_softc_tx_ring *ring, int qid);
 170 static void     rt_reset_tx_ring(struct rt_softc *sc,
 171                     struct rt_softc_tx_ring *ring);
 172 static void     rt_free_tx_ring(struct rt_softc *sc,
 173                     struct rt_softc_tx_ring *ring);
 174 static void     rt_dma_map_addr(void *arg, bus_dma_segment_t *segs,
 175                     int nseg, int error);
 176 static void     rt_sysctl_attach(struct rt_softc *sc);
 177 #ifdef IF_RT_PHY_SUPPORT
 178 void            rt_miibus_statchg(device_t);
 179 #endif
 180 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 181 static int      rt_miibus_readreg(device_t, int, int);
 182 static int      rt_miibus_writereg(device_t, int, int, int);
 183 #endif
 184 static int      rt_ifmedia_upd(struct ifnet *);
 185 static void     rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 186
 187 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
 188     "RT driver parameters");
 189 #ifdef IF_RT_DEBUG
 190 static int rt_debug = 0;
 191 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
 192     "RT debug level");
 193 #endif
 194
 195 static int
 196 rt_probe(device_t dev)
 197 {
 198         struct rt_softc *sc = device_get_softc(dev);
 199         char buf[80];
 200 #ifdef FDT
 201         const struct ofw_compat_data * cd;
 202
 203         cd = ofw_bus_search_compatible(dev, rt_compat_data);
 204         if (cd->ocd_data == 0)
 205                 return (ENXIO);
 206
 207         sc->rt_chipid = (unsigned int)(cd->ocd_data);
 208 #else
 209 #if defined(MT7620)
 210         sc->rt_chipid = RT_CHIPID_MT7620;
 211 #elif defined(MT7621)
 212         sc->rt_chipid = RT_CHIPID_MT7621;
 213 #elif defined(RT5350)
 214         sc->rt_chipid = RT_CHIPID_RT5350;
 215 #else
 216         sc->rt_chipid = RT_CHIPID_RT3050;
 217 #endif
 218 #endif
 219         snprintf(buf, sizeof(buf), "Ralink %cT%x onChip Ethernet driver",
 220                 sc->rt_chipid >= 0x7600 ? 'M' : 'R', sc->rt_chipid);
 221         device_set_desc_copy(dev, buf);
 222         return (BUS_PROBE_GENERIC);
 223 }
 224
 225 /*
 226  * macaddr_atoi - translate string MAC address to uint8_t array
 227  */
 228 static int
 229 macaddr_atoi(const char *str, uint8_t *mac)
 230 {
 231         int count, i;
 232         unsigned int amac[ETHER_ADDR_LEN];      /* Aligned version */
 233
 234         count = sscanf(str, "%x%*c%x%*c%x%*c%x%*c%x%*c%x",
 235             &amac[0], &amac[1], &amac[2],
 236             &amac[3], &amac[4], &amac[5]);
 237         if (count < ETHER_ADDR_LEN) {
 238                 memset(mac, 0, ETHER_ADDR_LEN);
 239                 return (1);
 240         }
 241
 242         /* Copy aligned to result */
 243         for (i = 0; i < ETHER_ADDR_LEN; i ++)
 244                 mac[i] = (amac[i] & 0xff);
 245
 246         return (0);
 247 }
 248
 249 #ifdef USE_GENERATED_MAC_ADDRESS
 250 /*
 251  * generate_mac(uin8_t *mac)
 252  * This is MAC address generator for cases when real device MAC address
 253  * unknown or not yet accessible.
 254  * Use 'b','s','d' signature and 3 octets from CRC32 on kenv.
 255  * MAC = 'b', 's', 'd', CRC[3]^CRC[2], CRC[1], CRC[0]
 256  *
 257  * Output - MAC address, that do not change between reboots, if hints or
 258  * bootloader info unchange.
 259  */
 260 static void
 261 generate_mac(uint8_t *mac)
 262 {
 263         unsigned char *cp;
 264         int i = 0;
 265         uint32_t crc = 0xffffffff;
 266
 267         /* Generate CRC32 on kenv */
 268         for (cp = kenvp[0]; cp != NULL; cp = kenvp[++i]) {
 269                 crc = calculate_crc32c(crc, cp, strlen(cp) + 1);
 270         }
 271         crc = ~crc;
 272
 273         mac[0] = 'b';
 274         mac[1] = 's';
 275         mac[2] = 'd';
 276         mac[3] = (crc >> 24) ^ ((crc >> 16) & 0xff);
 277         mac[4] = (crc >> 8) & 0xff;
 278         mac[5] = crc & 0xff;
 279 }
 280 #endif
 281
 282 /*
 283  * ether_request_mac - try to find usable MAC address.
 284  */
 285 static int
 286 ether_request_mac(device_t dev, uint8_t *mac)
 287 {
 288         char *var;
 289
 290         /*
 291          * "ethaddr" is passed via envp on RedBoot platforms
 292          * "kmac" is passed via argv on RouterBOOT platforms
 293          */
 294 #if defined(RT305X_UBOOT) ||  defined(__REDBOOT__) || defined(__ROUTERBOOT__)
 295         if ((var = kern_getenv("ethaddr")) != NULL ||
 296             (var = kern_getenv("kmac")) != NULL ) {
 297
 298                 if(!macaddr_atoi(var, mac)) {
 299                         printf("%s: use %s macaddr from KENV\n",
 300                             device_get_nameunit(dev), var);
 301                         freeenv(var);
 302                         return (0);
 303                 }
 304                 freeenv(var);
 305         }
 306 #endif
 307
 308         /*
 309          * Try from hints
 310          * hint.[dev].[unit].macaddr
 311          */
 312         if (!resource_string_value(device_get_name(dev),
 313             device_get_unit(dev), "macaddr", (const char **)&var)) {
 314
 315                 if(!macaddr_atoi(var, mac)) {
 316                         printf("%s: use %s macaddr from hints\n",
 317                             device_get_nameunit(dev), var);
 318                         return (0);
 319                 }
 320         }
 321
 322 #ifdef USE_GENERATED_MAC_ADDRESS
 323         generate_mac(mac);
 324
 325         device_printf(dev, "use generated %02x:%02x:%02x:%02x:%02x:%02x "
 326             "macaddr\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 327 #else
 328         /* Hardcoded */
 329         mac[0] = 0x00;
 330         mac[1] = 0x18;
 331         mac[2] = 0xe7;
 332         mac[3] = 0xd5;
 333         mac[4] = 0x83;
 334         mac[5] = 0x90;
 335
 336         device_printf(dev, "use hardcoded 00:18:e7:d5:83:90 macaddr\n");
 337 #endif
 338
 339         return (0);
 340 }
 341
 342 /*
 343  * Reset hardware
 344  */
 345 static void
 346 reset_freng(struct rt_softc *sc)
 347 {
 348         /* XXX hard reset kills everything so skip it ... */
 349         return;
 350 }
 351
 352 static int
 353 rt_attach(device_t dev)
 354 {
 355         struct rt_softc *sc;
 356         struct ifnet *ifp;
 357         int error, i;
 358
 359         sc = device_get_softc(dev);
 360         sc->dev = dev;
 361
 362         mtx_init(&sc->lock, device_get_nameunit(dev), MTX_NETWORK_LOCK,
 363             MTX_DEF | MTX_RECURSE);
 364
 365         sc->mem_rid = 0;
 366         sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->mem_rid,
 367             RF_ACTIVE | RF_SHAREABLE);
 368         if (sc->mem == NULL) {
 369                 device_printf(dev, "could not allocate memory resource\n");
 370                 error = ENXIO;
 371                 goto fail;
 372         }
 373
 374         sc->bst = rman_get_bustag(sc->mem);
 375         sc->bsh = rman_get_bushandle(sc->mem);
 376
 377         sc->irq_rid = 0;
 378         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid,
 379             RF_ACTIVE);
 380         if (sc->irq == NULL) {
 381                 device_printf(dev,
 382                     "could not allocate interrupt resource\n");
 383                 error = ENXIO;
 384                 goto fail;
 385         }
 386
 387 #ifdef IF_RT_DEBUG
 388         sc->debug = rt_debug;
 389
 390         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
 391                 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
 392                 "debug", CTLFLAG_RW, &sc->debug, 0, "rt debug level");
 393 #endif
 394
 395         /* Reset hardware */
 396         reset_freng(sc);
 397
 398
 399         if (sc->rt_chipid == RT_CHIPID_MT7620) {
 400                 sc->csum_fail_ip = MT7620_RXD_SRC_IP_CSUM_FAIL;
 401                 sc->csum_fail_l4 = MT7620_RXD_SRC_L4_CSUM_FAIL;
 402         } else if (sc->rt_chipid == RT_CHIPID_MT7621) {
 403                 sc->csum_fail_ip = MT7621_RXD_SRC_IP_CSUM_FAIL;
 404                 sc->csum_fail_l4 = MT7621_RXD_SRC_L4_CSUM_FAIL;
 405         } else {
 406                 sc->csum_fail_ip = RT305X_RXD_SRC_IP_CSUM_FAIL;
 407                 sc->csum_fail_l4 = RT305X_RXD_SRC_L4_CSUM_FAIL;
 408         }
 409
 410         /* Fill in soc-specific registers map */
 411         switch(sc->rt_chipid) {
 412           case RT_CHIPID_MT7620:
 413           case RT_CHIPID_MT7621:
 414                 sc->gdma1_base = MT7620_GDMA1_BASE;
 415                 /* fallthrough */
 416           case RT_CHIPID_RT5350:
 417                 device_printf(dev, "%cT%x Ethernet MAC (rev 0x%08x)\n",
 418                         sc->rt_chipid >= 0x7600 ? 'M' : 'R',
 419                         sc->rt_chipid, sc->mac_rev);
 420                 /* RT5350: No GDMA, PSE, CDMA, PPE */
 421                 RT_WRITE(sc, GE_PORT_BASE + 0x0C00, // UDPCS, TCPCS, IPCS=1
 422                         RT_READ(sc, GE_PORT_BASE + 0x0C00) | (0x7<<16));
 423                 sc->delay_int_cfg=RT5350_PDMA_BASE+RT5350_DELAY_INT_CFG;
 424                 sc->fe_int_status=RT5350_FE_INT_STATUS;
 425                 sc->fe_int_enable=RT5350_FE_INT_ENABLE;
 426                 sc->pdma_glo_cfg=RT5350_PDMA_BASE+RT5350_PDMA_GLO_CFG;
 427                 sc->pdma_rst_idx=RT5350_PDMA_BASE+RT5350_PDMA_RST_IDX;
 428                 for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++) {
 429                   sc->tx_base_ptr[i]=RT5350_PDMA_BASE+RT5350_TX_BASE_PTR(i);
 430                   sc->tx_max_cnt[i]=RT5350_PDMA_BASE+RT5350_TX_MAX_CNT(i);
 431                   sc->tx_ctx_idx[i]=RT5350_PDMA_BASE+RT5350_TX_CTX_IDX(i);
 432                   sc->tx_dtx_idx[i]=RT5350_PDMA_BASE+RT5350_TX_DTX_IDX(i);
 433                 }
 434                 sc->rx_ring_count=2;
 435                 sc->rx_base_ptr[0]=RT5350_PDMA_BASE+RT5350_RX_BASE_PTR0;
 436                 sc->rx_max_cnt[0]=RT5350_PDMA_BASE+RT5350_RX_MAX_CNT0;
 437                 sc->rx_calc_idx[0]=RT5350_PDMA_BASE+RT5350_RX_CALC_IDX0;
 438                 sc->rx_drx_idx[0]=RT5350_PDMA_BASE+RT5350_RX_DRX_IDX0;
 439                 sc->rx_base_ptr[1]=RT5350_PDMA_BASE+RT5350_RX_BASE_PTR1;
 440                 sc->rx_max_cnt[1]=RT5350_PDMA_BASE+RT5350_RX_MAX_CNT1;
 441                 sc->rx_calc_idx[1]=RT5350_PDMA_BASE+RT5350_RX_CALC_IDX1;
 442                 sc->rx_drx_idx[1]=RT5350_PDMA_BASE+RT5350_RX_DRX_IDX1;
 443                 sc->int_rx_done_mask=RT5350_INT_RXQ0_DONE;
 444                 sc->int_tx_done_mask=RT5350_INT_TXQ0_DONE;
 445                 break;
 446           default:
 447                 device_printf(dev, "RT305XF Ethernet MAC (rev 0x%08x)\n",
 448                         sc->mac_rev);
 449                 sc->gdma1_base = GDMA1_BASE;
 450                 sc->delay_int_cfg=PDMA_BASE+DELAY_INT_CFG;
 451                 sc->fe_int_status=GE_PORT_BASE+FE_INT_STATUS;
 452                 sc->fe_int_enable=GE_PORT_BASE+FE_INT_ENABLE;
 453                 sc->pdma_glo_cfg=PDMA_BASE+PDMA_GLO_CFG;
 454                 sc->pdma_rst_idx=PDMA_BASE+PDMA_RST_IDX;
 455                 for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++) {
 456                   sc->tx_base_ptr[i]=PDMA_BASE+TX_BASE_PTR(i);
 457                   sc->tx_max_cnt[i]=PDMA_BASE+TX_MAX_CNT(i);
 458                   sc->tx_ctx_idx[i]=PDMA_BASE+TX_CTX_IDX(i);
 459                   sc->tx_dtx_idx[i]=PDMA_BASE+TX_DTX_IDX(i);
 460                 }
 461                 sc->rx_ring_count=1;
 462                 sc->rx_base_ptr[0]=PDMA_BASE+RX_BASE_PTR0;
 463                 sc->rx_max_cnt[0]=PDMA_BASE+RX_MAX_CNT0;
 464                 sc->rx_calc_idx[0]=PDMA_BASE+RX_CALC_IDX0;
 465                 sc->rx_drx_idx[0]=PDMA_BASE+RX_DRX_IDX0;
 466                 sc->int_rx_done_mask=INT_RX_DONE;
 467                 sc->int_tx_done_mask=INT_TXQ0_DONE;
 468         }
 469
 470         if (sc->gdma1_base != 0)
 471                 RT_WRITE(sc, sc->gdma1_base + GDMA_FWD_CFG,
 472                 (
 473                 GDM_ICS_EN | /* Enable IP Csum */
 474                 GDM_TCS_EN | /* Enable TCP Csum */
 475                 GDM_UCS_EN | /* Enable UDP Csum */
 476                 GDM_STRPCRC | /* Strip CRC from packet */
 477                 GDM_DST_PORT_CPU << GDM_UFRC_P_SHIFT | /* fwd UCast to CPU */
 478                 GDM_DST_PORT_CPU << GDM_BFRC_P_SHIFT | /* fwd BCast to CPU */
 479                 GDM_DST_PORT_CPU << GDM_MFRC_P_SHIFT | /* fwd MCast to CPU */
 480                 GDM_DST_PORT_CPU << GDM_OFRC_P_SHIFT   /* fwd Other to CPU */
 481                 ));
 482
 483         if (sc->rt_chipid == RT_CHIPID_RT2880)
 484                 RT_WRITE(sc, MDIO_CFG, MDIO_2880_100T_INIT);
 485
 486         /* allocate Tx and Rx rings */
 487         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++) {
 488                 error = rt_alloc_tx_ring(sc, &sc->tx_ring[i], i);
 489                 if (error != 0) {
 490                         device_printf(dev, "could not allocate Tx ring #%d\n",
 491                             i);
 492                         goto fail;
 493                 }
 494         }
 495
 496         sc->tx_ring_mgtqid = 5;
 497         for (i = 0; i < sc->rx_ring_count; i++) {
 498                 error = rt_alloc_rx_ring(sc, &sc->rx_ring[i], i);
 499                 if (error != 0) {
 500                         device_printf(dev, "could not allocate Rx ring\n");
 501                         goto fail;
 502                 }
 503         }
 504
 505         callout_init(&sc->periodic_ch, 0);
 506         callout_init_mtx(&sc->tx_watchdog_ch, &sc->lock, 0);
 507
 508         ifp = sc->ifp = if_alloc(IFT_ETHER);
 509         if (ifp == NULL) {
 510                 device_printf(dev, "could not if_alloc()\n");
 511                 error = ENOMEM;
 512                 goto fail;
 513         }
 514
 515         ifp->if_softc = sc;
 516         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
 517         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 518         ifp->if_init = rt_init;
 519         ifp->if_ioctl = rt_ioctl;
 520         ifp->if_start = rt_start;
 521 #define RT_TX_QLEN      256
 522
 523         IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
 524         ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
 525         IFQ_SET_READY(&ifp->if_snd);
 526
 527 #ifdef IF_RT_PHY_SUPPORT
 528         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
 529             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
 530         if (error != 0) {
 531                 device_printf(dev, "attaching PHYs failed\n");
 532                 error = ENXIO;
 533                 goto fail;
 534         }
 535 #else
 536         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
 537         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
 538             NULL);
 539         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 540
 541 #endif /* IF_RT_PHY_SUPPORT */
 542
 543         ether_request_mac(dev, sc->mac_addr);
 544         ether_ifattach(ifp, sc->mac_addr);
 545
 546         /*
 547          * Tell the upper layer(s) we support long frames.
 548          */
 549         ifp->if_hdrlen = sizeof(struct ether_vlan_header);
 550         ifp->if_capabilities |= IFCAP_VLAN_MTU;
 551         ifp->if_capenable |= IFCAP_VLAN_MTU;
 552         ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
 553         ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
 554
 555         /* init task queue */
 556         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
 557         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 558         TASK_INIT(&sc->periodic_task, 0, rt_periodic_task, sc);
 559
 560         sc->rx_process_limit = 100;
 561
 562         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
 563             taskqueue_thread_enqueue, &sc->taskqueue);
 564
 565         taskqueue_start_threads(&sc->taskqueue, 1, PI_NET, "%s taskq",
 566             device_get_nameunit(sc->dev));
 567
 568         rt_sysctl_attach(sc);
 569
 570         /* set up interrupt */
 571         error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE,
 572             NULL, (sc->rt_chipid == RT_CHIPID_RT5350 ||
 573             sc->rt_chipid == RT_CHIPID_MT7620 ||
 574             sc->rt_chipid == RT_CHIPID_MT7621) ? rt_rt5350_intr : rt_intr,
 575             sc, &sc->irqh);
 576         if (error != 0) {
 577                 printf("%s: could not set up interrupt\n",
 578                         device_get_nameunit(dev));
 579                 goto fail;
 580         }
 581 #ifdef IF_RT_DEBUG
 582         device_printf(dev, "debug var at %#08x\n", (u_int)&(sc->debug));
 583 #endif
 584
 585         return (0);
 586
 587 fail:
 588         /* free Tx and Rx rings */
 589         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++)
 590                 rt_free_tx_ring(sc, &sc->tx_ring[i]);
 591
 592         for (i = 0; i < sc->rx_ring_count; i++)
 593                 rt_free_rx_ring(sc, &sc->rx_ring[i]);
 594
 595         mtx_destroy(&sc->lock);
 596
 597         if (sc->mem != NULL)
 598                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid,
 599                     sc->mem);
 600
 601         if (sc->irq != NULL)
 602                 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid,
 603                     sc->irq);
 604
 605         return (error);
 606 }
 607
 608 /*
 609  * Set media options.
 610  */
 611 static int
 612 rt_ifmedia_upd(struct ifnet *ifp)
 613 {
 614         struct rt_softc *sc;
 615 #ifdef IF_RT_PHY_SUPPORT
 616         struct mii_data *mii;
 617         struct mii_softc *miisc;
 618         int error = 0;
 619
 620         sc = ifp->if_softc;
 621         RT_SOFTC_LOCK(sc);
 622
 623         mii = device_get_softc(sc->rt_miibus);
 624         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
 625                 PHY_RESET(miisc);
 626         error = mii_mediachg(mii);
 627         RT_SOFTC_UNLOCK(sc);
 628
 629         return (error);
 630
 631 #else /* !IF_RT_PHY_SUPPORT */
 632
 633         struct ifmedia *ifm;
 634         struct ifmedia_entry *ife;
 635
 636         sc = ifp->if_softc;
 637         ifm = &sc->rt_ifmedia;
 638         ife = ifm->ifm_cur;
 639
 640         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
 641                 return (EINVAL);
 642
 643         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
 644                 device_printf(sc->dev,
 645                     "AUTO is not supported for multiphy MAC");
 646                 return (EINVAL);
 647         }
 648
 649         /*
 650          * Ignore everything
 651          */
 652         return (0);
 653 #endif /* IF_RT_PHY_SUPPORT */
 654 }
 655
 656 /*
 657  * Report current media status.
 658  */
 659 static void
 660 rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 661 {
 662 #ifdef IF_RT_PHY_SUPPORT
 663         struct rt_softc *sc;
 664         struct mii_data *mii;
 665
 666         sc = ifp->if_softc;
 667
 668         RT_SOFTC_LOCK(sc);
 669         mii = device_get_softc(sc->rt_miibus);
 670         mii_pollstat(mii);
 671         ifmr->ifm_active = mii->mii_media_active;
 672         ifmr->ifm_status = mii->mii_media_status;
 673         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 674         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
 675         RT_SOFTC_UNLOCK(sc);
 676 #else /* !IF_RT_PHY_SUPPORT */
 677
 678         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
 679         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 680 #endif /* IF_RT_PHY_SUPPORT */
 681 }
 682
 683 static int
 684 rt_detach(device_t dev)
 685 {
 686         struct rt_softc *sc;
 687         struct ifnet *ifp;
 688         int i;
 689
 690         sc = device_get_softc(dev);
 691         ifp = sc->ifp;
 692
 693         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 694
 695         RT_SOFTC_LOCK(sc);
 696
 697         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 698
 699         callout_stop(&sc->periodic_ch);
 700         callout_stop(&sc->tx_watchdog_ch);
 701
 702         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
 703         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
 704         taskqueue_drain(sc->taskqueue, &sc->periodic_task);
 705
 706         /* free Tx and Rx rings */
 707         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++)
 708                 rt_free_tx_ring(sc, &sc->tx_ring[i]);
 709         for (i = 0; i < sc->rx_ring_count; i++)
 710                 rt_free_rx_ring(sc, &sc->rx_ring[i]);
 711
 712         RT_SOFTC_UNLOCK(sc);
 713
 714 #ifdef IF_RT_PHY_SUPPORT
 715         if (sc->rt_miibus != NULL)
 716                 device_delete_child(dev, sc->rt_miibus);
 717 #endif
 718
 719         ether_ifdetach(ifp);
 720         if_free(ifp);
 721
 722         taskqueue_free(sc->taskqueue);
 723
 724         mtx_destroy(&sc->lock);
 725
 726         bus_generic_detach(dev);
 727         bus_teardown_intr(dev, sc->irq, sc->irqh);
 728         bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
 729         bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem);
 730
 731         return (0);
 732 }
 733
 734 static int
 735 rt_shutdown(device_t dev)
 736 {
 737         struct rt_softc *sc;
 738
 739         sc = device_get_softc(dev);
 740         RT_DPRINTF(sc, RT_DEBUG_ANY, "shutting down\n");
 741         rt_stop(sc);
 742
 743         return (0);
 744 }
 745
 746 static int
 747 rt_suspend(device_t dev)
 748 {
 749         struct rt_softc *sc;
 750
 751         sc = device_get_softc(dev);
 752         RT_DPRINTF(sc, RT_DEBUG_ANY, "suspending\n");
 753         rt_stop(sc);
 754
 755         return (0);
 756 }
 757
 758 static int
 759 rt_resume(device_t dev)
 760 {
 761         struct rt_softc *sc;
 762         struct ifnet *ifp;
 763
 764         sc = device_get_softc(dev);
 765         ifp = sc->ifp;
 766
 767         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 768
 769         if (ifp->if_flags & IFF_UP)
 770                 rt_init(sc);
 771
 772         return (0);
 773 }
 774
 775 /*
 776  * rt_init_locked - Run initialization process having locked mtx.
 777  */
 778 static void
 779 rt_init_locked(void *priv)
 780 {
 781         struct rt_softc *sc;
 782         struct ifnet *ifp;
 783 #ifdef IF_RT_PHY_SUPPORT
 784         struct mii_data *mii;
 785 #endif
 786         int i, ntries;
 787         uint32_t tmp;
 788
 789         sc = priv;
 790         ifp = sc->ifp;
 791 #ifdef IF_RT_PHY_SUPPORT
 792         mii = device_get_softc(sc->rt_miibus);
 793 #endif
 794
 795         RT_DPRINTF(sc, RT_DEBUG_ANY, "initializing\n");
 796
 797         RT_SOFTC_ASSERT_LOCKED(sc);
 798
 799         /* hardware reset */
 800         //RT_WRITE(sc, GE_PORT_BASE + FE_RST_GLO, PSE_RESET);
 801         //rt305x_sysctl_set(SYSCTL_RSTCTRL, SYSCTL_RSTCTRL_FRENG);
 802
 803         /* Fwd to CPU (uni|broad|multi)cast and Unknown */
 804         if (sc->gdma1_base != 0)
 805                 RT_WRITE(sc, sc->gdma1_base + GDMA_FWD_CFG,
 806                 (
 807                 GDM_ICS_EN | /* Enable IP Csum */
 808                 GDM_TCS_EN | /* Enable TCP Csum */
 809                 GDM_UCS_EN | /* Enable UDP Csum */
 810                 GDM_STRPCRC | /* Strip CRC from packet */
 811                 GDM_DST_PORT_CPU << GDM_UFRC_P_SHIFT | /* fwd UCast to CPU */
 812                 GDM_DST_PORT_CPU << GDM_BFRC_P_SHIFT | /* fwd BCast to CPU */
 813                 GDM_DST_PORT_CPU << GDM_MFRC_P_SHIFT | /* fwd MCast to CPU */
 814                 GDM_DST_PORT_CPU << GDM_OFRC_P_SHIFT   /* fwd Other to CPU */
 815                 ));
 816
 817         /* disable DMA engine */
 818         RT_WRITE(sc, sc->pdma_glo_cfg, 0);
 819         RT_WRITE(sc, sc->pdma_rst_idx, 0xffffffff);
 820
 821         /* wait while DMA engine is busy */
 822         for (ntries = 0; ntries < 100; ntries++) {
 823                 tmp = RT_READ(sc, sc->pdma_glo_cfg);
 824                 if (!(tmp & (FE_TX_DMA_BUSY | FE_RX_DMA_BUSY)))
 825                         break;
 826                 DELAY(1000);
 827         }
 828
 829         if (ntries == 100) {
 830                 device_printf(sc->dev, "timeout waiting for DMA engine\n");
 831                 goto fail;
 832         }
 833
 834         /* reset Rx and Tx rings */
 835         tmp = FE_RST_DRX_IDX0 |
 836                 FE_RST_DTX_IDX3 |
 837                 FE_RST_DTX_IDX2 |
 838                 FE_RST_DTX_IDX1 |
 839                 FE_RST_DTX_IDX0;
 840
 841         RT_WRITE(sc, sc->pdma_rst_idx, tmp);
 842
 843         /* XXX switch set mac address */
 844         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++)
 845                 rt_reset_tx_ring(sc, &sc->tx_ring[i]);
 846
 847         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++) {
 848                 /* update TX_BASE_PTRx */
 849                 RT_WRITE(sc, sc->tx_base_ptr[i],
 850                         sc->tx_ring[i].desc_phys_addr);
 851                 RT_WRITE(sc, sc->tx_max_cnt[i],
 852                         RT_SOFTC_TX_RING_DESC_COUNT);
 853                 RT_WRITE(sc, sc->tx_ctx_idx[i], 0);
 854         }
 855
 856         /* init Rx ring */
 857         for (i = 0; i < sc->rx_ring_count; i++)
 858                 rt_reset_rx_ring(sc, &sc->rx_ring[i]);
 859
 860         /* update RX_BASE_PTRx */
 861         for (i = 0; i < sc->rx_ring_count; i++) {
 862                 RT_WRITE(sc, sc->rx_base_ptr[i],
 863                         sc->rx_ring[i].desc_phys_addr);
 864                 RT_WRITE(sc, sc->rx_max_cnt[i],
 865                         RT_SOFTC_RX_RING_DATA_COUNT);
 866                 RT_WRITE(sc, sc->rx_calc_idx[i],
 867                         RT_SOFTC_RX_RING_DATA_COUNT - 1);
 868         }
 869
 870         /* write back DDONE, 16byte burst enable RX/TX DMA */
 871         tmp = FE_TX_WB_DDONE | FE_DMA_BT_SIZE16 | FE_RX_DMA_EN | FE_TX_DMA_EN;
 872         if (sc->rt_chipid == RT_CHIPID_MT7620 ||
 873             sc->rt_chipid == RT_CHIPID_MT7621)
 874                 tmp |= (1<<31);
 875         RT_WRITE(sc, sc->pdma_glo_cfg, tmp);
 876
 877         /* disable interrupts mitigation */
 878         RT_WRITE(sc, sc->delay_int_cfg, 0);
 879
 880         /* clear pending interrupts */
 881         RT_WRITE(sc, sc->fe_int_status, 0xffffffff);
 882
 883         /* enable interrupts */
 884         if (sc->rt_chipid == RT_CHIPID_RT5350 ||
 885             sc->rt_chipid == RT_CHIPID_MT7620 ||
 886             sc->rt_chipid == RT_CHIPID_MT7621)
 887           tmp = RT5350_INT_TX_COHERENT |
 888                 RT5350_INT_RX_COHERENT |
 889                 RT5350_INT_TXQ3_DONE |
 890                 RT5350_INT_TXQ2_DONE |
 891                 RT5350_INT_TXQ1_DONE |
 892                 RT5350_INT_TXQ0_DONE |
 893                 RT5350_INT_RXQ1_DONE |
 894                 RT5350_INT_RXQ0_DONE;
 895         else
 896           tmp = CNT_PPE_AF |
 897                 CNT_GDM_AF |
 898                 PSE_P2_FC |
 899                 GDM_CRC_DROP |
 900                 PSE_BUF_DROP |
 901                 GDM_OTHER_DROP |
 902                 PSE_P1_FC |
 903                 PSE_P0_FC |
 904                 PSE_FQ_EMPTY |
 905                 INT_TX_COHERENT |
 906                 INT_RX_COHERENT |
 907                 INT_TXQ3_DONE |
 908                 INT_TXQ2_DONE |
 909                 INT_TXQ1_DONE |
 910                 INT_TXQ0_DONE |
 911                 INT_RX_DONE;
 912
 913         sc->intr_enable_mask = tmp;
 914
 915         RT_WRITE(sc, sc->fe_int_enable, tmp);
 916
 917         if (rt_txrx_enable(sc) != 0)
 918                 goto fail;
 919
 920 #ifdef IF_RT_PHY_SUPPORT
 921         if (mii) mii_mediachg(mii);
 922 #endif /* IF_RT_PHY_SUPPORT */
 923
 924         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 925         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 926
 927         sc->periodic_round = 0;
 928
 929         callout_reset(&sc->periodic_ch, hz / 10, rt_periodic, sc);
 930
 931         return;
 932
 933 fail:
 934         rt_stop_locked(sc);
 935 }
 936
 937 /*
 938  * rt_init - lock and initialize device.
 939  */
 940 static void
 941 rt_init(void *priv)
 942 {
 943         struct rt_softc *sc;
 944
 945         sc = priv;
 946         RT_SOFTC_LOCK(sc);
 947         rt_init_locked(sc);
 948         RT_SOFTC_UNLOCK(sc);
 949 }
 950
 951 /*
 952  * rt_stop_locked - stop TX/RX w/ lock
 953  */
 954 static void
 955 rt_stop_locked(void *priv)
 956 {
 957         struct rt_softc *sc;
 958         struct ifnet *ifp;
 959
 960         sc = priv;
 961         ifp = sc->ifp;
 962
 963         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 964
 965         RT_SOFTC_ASSERT_LOCKED(sc);
 966         sc->tx_timer = 0;
 967         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 968         callout_stop(&sc->periodic_ch);
 969         callout_stop(&sc->tx_watchdog_ch);
 970         RT_SOFTC_UNLOCK(sc);
 971         taskqueue_block(sc->taskqueue);
 972
 973         /*
 974          * Sometime rt_stop_locked called from isr and we get panic
 975          * When found, I fix it
 976          */
 977 #ifdef notyet
 978         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
 979         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
 980         taskqueue_drain(sc->taskqueue, &sc->periodic_task);
 981 #endif
 982         RT_SOFTC_LOCK(sc);
 983
 984         /* disable interrupts */
 985         RT_WRITE(sc, sc->fe_int_enable, 0);
 986
 987         if(sc->rt_chipid != RT_CHIPID_RT5350 &&
 988            sc->rt_chipid != RT_CHIPID_MT7620 &&
 989            sc->rt_chipid != RT_CHIPID_MT7621) {
 990                 /* reset adapter */
 991                 RT_WRITE(sc, GE_PORT_BASE + FE_RST_GLO, PSE_RESET);
 992         }
 993
 994         if (sc->gdma1_base != 0)
 995                 RT_WRITE(sc, sc->gdma1_base + GDMA_FWD_CFG,
 996                 (
 997                 GDM_ICS_EN | /* Enable IP Csum */
 998                 GDM_TCS_EN | /* Enable TCP Csum */
 999                 GDM_UCS_EN | /* Enable UDP Csum */
1000                 GDM_STRPCRC | /* Strip CRC from packet */
1001                 GDM_DST_PORT_CPU << GDM_UFRC_P_SHIFT | /* fwd UCast to CPU */
1002                 GDM_DST_PORT_CPU << GDM_BFRC_P_SHIFT | /* fwd BCast to CPU */
1003                 GDM_DST_PORT_CPU << GDM_MFRC_P_SHIFT | /* fwd MCast to CPU */
1004                 GDM_DST_PORT_CPU << GDM_OFRC_P_SHIFT   /* fwd Other to CPU */
1005                 ));
1006 }
1007
1008 static void
1009 rt_stop(void *priv)
1010 {
1011         struct rt_softc *sc;
1012
1013         sc = priv;
1014         RT_SOFTC_LOCK(sc);
1015         rt_stop_locked(sc);
1016         RT_SOFTC_UNLOCK(sc);
1017 }
1018
1019 /*
1020  * rt_tx_data - transmit packet.
1021  */
1022 static int
1023 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
1024 {
1025         struct ifnet *ifp;
1026         struct rt_softc_tx_ring *ring;
1027         struct rt_softc_tx_data *data;
1028         struct rt_txdesc *desc;
1029         struct mbuf *m_d;
1030         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
1031         int error, ndmasegs, ndescs, i;
1032
1033         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
1034                 ("%s: Tx data: invalid qid=%d\n",
1035                  device_get_nameunit(sc->dev), qid));
1036
1037         RT_SOFTC_TX_RING_ASSERT_LOCKED(&sc->tx_ring[qid]);
1038
1039         ifp = sc->ifp;
1040         ring = &sc->tx_ring[qid];
1041         desc = &ring->desc[ring->desc_cur];
1042         data = &ring->data[ring->data_cur];
1043
1044         error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m,
1045             dma_seg, &ndmasegs, 0);
1046         if (error != 0) {
1047                 /* too many fragments, linearize */
1048
1049                 RT_DPRINTF(sc, RT_DEBUG_TX,
1050                         "could not load mbuf DMA map, trying to linearize "
1051                         "mbuf: ndmasegs=%d, len=%d, error=%d\n",
1052                         ndmasegs, m->m_pkthdr.len, error);
1053
1054                 m_d = m_collapse(m, M_NOWAIT, 16);
1055                 if (m_d == NULL) {
1056                         m_freem(m);
1057                         m = NULL;
1058                         return (ENOMEM);
1059                 }
1060                 m = m_d;
1061
1062                 sc->tx_defrag_packets++;
1063
1064                 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag,
1065                     data->dma_map, m, dma_seg, &ndmasegs, 0);
1066                 if (error != 0) {
1067                         device_printf(sc->dev, "could not load mbuf DMA map: "
1068                             "ndmasegs=%d, len=%d, error=%d\n",
1069                             ndmasegs, m->m_pkthdr.len, error);
1070                         m_freem(m);
1071                         return (error);
1072                 }
1073         }
1074
1075         if (m->m_pkthdr.len == 0)
1076                 ndmasegs = 0;
1077
1078         /* determine how many Tx descs are required */
1079         ndescs = 1 + ndmasegs / 2;
1080         if ((ring->desc_queued + ndescs) >
1081             (RT_SOFTC_TX_RING_DESC_COUNT - 2)) {
1082                 RT_DPRINTF(sc, RT_DEBUG_TX,
1083                     "there are not enough Tx descs\n");
1084
1085                 sc->no_tx_desc_avail++;
1086
1087                 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
1088                 m_freem(m);
1089                 return (EFBIG);
1090         }
1091
1092         data->m = m;
1093
1094         /* set up Tx descs */
1095         for (i = 0; i < ndmasegs; i += 2) {
1096
1097                 /* TODO: this needs to be refined as MT7620 for example has
1098                  * a different word3 layout than RT305x and RT5350 (the last
1099                  * one doesn't use word3 at all). And so does MT7621...
1100                  */
1101
1102                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
1103                         /* Set destination */
1104                         if (sc->rt_chipid != RT_CHIPID_MT7620)
1105                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
1106
1107                         if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
1108                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
1109                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
1110                         /* Set queue id */
1111                         desc->qn = qid;
1112                         /* No PPPoE */
1113                         desc->pppoe = 0;
1114                         /* No VLAN */
1115                         desc->vid = 0;
1116                 } else {
1117                         desc->vid = 0;
1118                         desc->pppoe = 0;
1119                         desc->qn = 0;
1120                         desc->dst = 2;
1121                 }
1122
1123                 desc->sdp0 = htole32(dma_seg[i].ds_addr);
1124                 desc->sdl0 = htole16(dma_seg[i].ds_len |
1125                     ( ((i+1) == ndmasegs )?RT_TXDESC_SDL0_LASTSEG:0 ));
1126
1127                 if ((i+1) < ndmasegs) {
1128                         desc->sdp1 = htole32(dma_seg[i+1].ds_addr);
1129                         desc->sdl1 = htole16(dma_seg[i+1].ds_len |
1130                             ( ((i+2) == ndmasegs )?RT_TXDESC_SDL1_LASTSEG:0 ));
1131                 } else {
1132                         desc->sdp1 = 0;
1133                         desc->sdl1 = 0;
1134                 }
1135
1136                 if ((i+2) < ndmasegs) {
1137                         ring->desc_queued++;
1138                         ring->desc_cur = (ring->desc_cur + 1) %
1139                             RT_SOFTC_TX_RING_DESC_COUNT;
1140                 }
1141                 desc = &ring->desc[ring->desc_cur];
1142         }
1143
1144         RT_DPRINTF(sc, RT_DEBUG_TX, "sending data: len=%d, ndmasegs=%d, "
1145             "DMA ds_len=%d/%d/%d/%d/%d\n",
1146             m->m_pkthdr.len, ndmasegs,
1147             (int) dma_seg[0].ds_len,
1148             (int) dma_seg[1].ds_len,
1149             (int) dma_seg[2].ds_len,
1150             (int) dma_seg[3].ds_len,
1151             (int) dma_seg[4].ds_len);
1152
1153         bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
1154                 BUS_DMASYNC_PREWRITE);
1155         bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
1156                 BUS_DMASYNC_PREWRITE);
1157         bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
1158                 BUS_DMASYNC_PREWRITE);
1159
1160         ring->desc_queued++;
1161         ring->desc_cur = (ring->desc_cur + 1) % RT_SOFTC_TX_RING_DESC_COUNT;
1162
1163         ring->data_queued++;
1164         ring->data_cur = (ring->data_cur + 1) % RT_SOFTC_TX_RING_DATA_COUNT;
1165
1166         /* kick Tx */
1167         RT_WRITE(sc, sc->tx_ctx_idx[qid], ring->desc_cur);
1168
1169         return (0);
1170 }
1171
1172 /*
1173  * rt_start - start Transmit/Receive
1174  */
1175 static void
1176 rt_start(struct ifnet *ifp)
1177 {
1178         struct rt_softc *sc;
1179         struct mbuf *m;
1180         int qid = 0 /* XXX must check QoS priority */;
1181
1182         sc = ifp->if_softc;
1183
1184         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1185                 return;
1186
1187         for (;;) {
1188                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1189                 if (m == NULL)
1190                         break;
1191
1192                 m->m_pkthdr.rcvif = NULL;
1193
1194                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
1195
1196                 if (sc->tx_ring[qid].data_queued >=
1197                     RT_SOFTC_TX_RING_DATA_COUNT) {
1198                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1199
1200                         RT_DPRINTF(sc, RT_DEBUG_TX,
1201                             "if_start: Tx ring with qid=%d is full\n", qid);
1202
1203                         m_freem(m);
1204
1205                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1206                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1207
1208                         sc->tx_data_queue_full[qid]++;
1209
1210                         break;
1211                 }
1212
1213                 if (rt_tx_data(sc, m, qid) != 0) {
1214                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1215
1216                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1217
1218                         break;
1219                 }
1220
1221                 RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1222                 sc->tx_timer = RT_TX_WATCHDOG_TIMEOUT;
1223                 callout_reset(&sc->tx_watchdog_ch, hz, rt_tx_watchdog, sc);
1224         }
1225 }
1226
1227 /*
1228  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
1229  * filtering done by attached Ethernet switch.
1230  */
1231 static void
1232 rt_update_promisc(struct ifnet *ifp)
1233 {
1234         struct rt_softc *sc;
1235
1236         sc = ifp->if_softc;
1237         printf("%s: %s promiscuous mode\n",
1238                 device_get_nameunit(sc->dev),
1239                 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
1240 }
1241
1242 /*
1243  * rt_ioctl - ioctl handler.
1244  */
1245 static int
1246 rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1247 {
1248         struct rt_softc *sc;
1249         struct ifreq *ifr;
1250 #ifdef IF_RT_PHY_SUPPORT
1251         struct mii_data *mii;
1252 #endif /* IF_RT_PHY_SUPPORT */
1253         int error, startall;
1254
1255         sc = ifp->if_softc;
1256         ifr = (struct ifreq *) data;
1257
1258         error = 0;
1259
1260         switch (cmd) {
1261         case SIOCSIFFLAGS:
1262                 startall = 0;
1263                 RT_SOFTC_LOCK(sc);
1264                 if (ifp->if_flags & IFF_UP) {
1265                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1266                                 if ((ifp->if_flags ^ sc->if_flags) &
1267                                     IFF_PROMISC)
1268                                         rt_update_promisc(ifp);
1269                         } else {
1270                                 rt_init_locked(sc);
1271                                 startall = 1;
1272                         }
1273                 } else {
1274                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1275                                 rt_stop_locked(sc);
1276                 }
1277                 sc->if_flags = ifp->if_flags;
1278                 RT_SOFTC_UNLOCK(sc);
1279                 break;
1280         case SIOCGIFMEDIA:
1281         case SIOCSIFMEDIA:
1282 #ifdef IF_RT_PHY_SUPPORT
1283                 mii = device_get_softc(sc->rt_miibus);
1284                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1285 #else
1286                 error = ifmedia_ioctl(ifp, ifr, &sc->rt_ifmedia, cmd);
1287 #endif /* IF_RT_PHY_SUPPORT */
1288                 break;
1289         default:
1290                 error = ether_ioctl(ifp, cmd, data);
1291                 break;
1292         }
1293         return (error);
1294 }
1295
1296 /*
1297  * rt_periodic - Handler of PERIODIC interrupt
1298  */
1299 static void
1300 rt_periodic(void *arg)
1301 {
1302         struct rt_softc *sc;
1303
1304         sc = arg;
1305         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic\n");
1306         taskqueue_enqueue(sc->taskqueue, &sc->periodic_task);
1307 }
1308
1309 /*
1310  * rt_tx_watchdog - Handler of TX Watchdog
1311  */
1312 static void
1313 rt_tx_watchdog(void *arg)
1314 {
1315         struct rt_softc *sc;
1316         struct ifnet *ifp;
1317
1318         sc = arg;
1319         ifp = sc->ifp;
1320
1321         if (sc->tx_timer == 0)
1322                 return;
1323
1324         if (--sc->tx_timer == 0) {
1325                 device_printf(sc->dev, "Tx watchdog timeout: resetting\n");
1326 #ifdef notyet
1327                 /*
1328                  * XXX: Commented out, because reset break input.
1329                  */
1330                 rt_stop_locked(sc);
1331                 rt_init_locked(sc);
1332 #endif
1333                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1334                 sc->tx_watchdog_timeouts++;
1335         }
1336         callout_reset(&sc->tx_watchdog_ch, hz, rt_tx_watchdog, sc);
1337 }
1338
1339 /*
1340  * rt_cnt_ppe_af - Handler of PPE Counter Table Almost Full interrupt
1341  */
1342 static void
1343 rt_cnt_ppe_af(struct rt_softc *sc)
1344 {
1345
1346         RT_DPRINTF(sc, RT_DEBUG_INTR, "PPE Counter Table Almost Full\n");
1347 }
1348
1349 /*
1350  * rt_cnt_gdm_af - Handler of GDMA 1 & 2 Counter Table Almost Full interrupt
1351  */
1352 static void
1353 rt_cnt_gdm_af(struct rt_softc *sc)
1354 {
1355
1356         RT_DPRINTF(sc, RT_DEBUG_INTR,
1357             "GDMA 1 & 2 Counter Table Almost Full\n");
1358 }
1359
1360 /*
1361  * rt_pse_p2_fc - Handler of PSE port2 (GDMA 2) flow control interrupt
1362  */
1363 static void
1364 rt_pse_p2_fc(struct rt_softc *sc)
1365 {
1366
1367         RT_DPRINTF(sc, RT_DEBUG_INTR,
1368             "PSE port2 (GDMA 2) flow control asserted.\n");
1369 }
1370
1371 /*
1372  * rt_gdm_crc_drop - Handler of GDMA 1/2 discard a packet due to CRC error
1373  * interrupt
1374  */
1375 static void
1376 rt_gdm_crc_drop(struct rt_softc *sc)
1377 {
1378
1379         RT_DPRINTF(sc, RT_DEBUG_INTR,
1380             "GDMA 1 & 2 discard a packet due to CRC error\n");
1381 }
1382
1383 /*
1384  * rt_pse_buf_drop - Handler of buffer sharing limitation interrupt
1385  */
1386 static void
1387 rt_pse_buf_drop(struct rt_softc *sc)
1388 {
1389
1390         RT_DPRINTF(sc, RT_DEBUG_INTR,
1391             "PSE discards a packet due to buffer sharing limitation\n");
1392 }
1393
1394 /*
1395  * rt_gdm_other_drop - Handler of discard on other reason interrupt
1396  */
1397 static void
1398 rt_gdm_other_drop(struct rt_softc *sc)
1399 {
1400
1401         RT_DPRINTF(sc, RT_DEBUG_INTR,
1402             "GDMA 1 & 2 discard a packet due to other reason\n");
1403 }
1404
1405 /*
1406  * rt_pse_p1_fc - Handler of PSE port1 (GDMA 1) flow control interrupt
1407  */
1408 static void
1409 rt_pse_p1_fc(struct rt_softc *sc)
1410 {
1411
1412         RT_DPRINTF(sc, RT_DEBUG_INTR,
1413             "PSE port1 (GDMA 1) flow control asserted.\n");
1414 }
1415
1416 /*
1417  * rt_pse_p0_fc - Handler of PSE port0 (CDMA) flow control interrupt
1418  */
1419 static void
1420 rt_pse_p0_fc(struct rt_softc *sc)
1421 {
1422
1423         RT_DPRINTF(sc, RT_DEBUG_INTR,
1424             "PSE port0 (CDMA) flow control asserted.\n");
1425 }
1426
1427 /*
1428  * rt_pse_fq_empty - Handler of PSE free Q empty threshold reached interrupt
1429  */
1430 static void
1431 rt_pse_fq_empty(struct rt_softc *sc)
1432 {
1433
1434         RT_DPRINTF(sc, RT_DEBUG_INTR,
1435             "PSE free Q empty threshold reached & forced drop "
1436                     "condition occurred.\n");
1437 }
1438
1439 /*
1440  * rt_intr - main ISR
1441  */
1442 static void
1443 rt_intr(void *arg)
1444 {
1445         struct rt_softc *sc;
1446         struct ifnet *ifp;
1447         uint32_t status;
1448
1449         sc = arg;
1450         ifp = sc->ifp;
1451
1452         /* acknowledge interrupts */
1453         status = RT_READ(sc, sc->fe_int_status);
1454         RT_WRITE(sc, sc->fe_int_status, status);
1455
1456         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
1457
1458         if (status == 0xffffffff ||     /* device likely went away */
1459                 status == 0)            /* not for us */
1460                 return;
1461
1462         sc->interrupts++;
1463
1464         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1465                 return;
1466
1467         if (status & CNT_PPE_AF)
1468                 rt_cnt_ppe_af(sc);
1469
1470         if (status & CNT_GDM_AF)
1471                 rt_cnt_gdm_af(sc);
1472
1473         if (status & PSE_P2_FC)
1474                 rt_pse_p2_fc(sc);
1475
1476         if (status & GDM_CRC_DROP)
1477                 rt_gdm_crc_drop(sc);
1478
1479         if (status & PSE_BUF_DROP)
1480                 rt_pse_buf_drop(sc);
1481
1482         if (status & GDM_OTHER_DROP)
1483                 rt_gdm_other_drop(sc);
1484
1485         if (status & PSE_P1_FC)
1486                 rt_pse_p1_fc(sc);
1487
1488         if (status & PSE_P0_FC)
1489                 rt_pse_p0_fc(sc);
1490
1491         if (status & PSE_FQ_EMPTY)
1492                 rt_pse_fq_empty(sc);
1493
1494         if (status & INT_TX_COHERENT)
1495                 rt_tx_coherent_intr(sc);
1496
1497         if (status & INT_RX_COHERENT)
1498                 rt_rx_coherent_intr(sc);
1499
1500         if (status & RX_DLY_INT)
1501                 rt_rx_delay_intr(sc);
1502
1503         if (status & TX_DLY_INT)
1504                 rt_tx_delay_intr(sc);
1505
1506         if (status & INT_RX_DONE)
1507                 rt_rx_intr(sc, 0);
1508
1509         if (status & INT_TXQ3_DONE)
1510                 rt_tx_intr(sc, 3);
1511
1512         if (status & INT_TXQ2_DONE)
1513                 rt_tx_intr(sc, 2);
1514
1515         if (status & INT_TXQ1_DONE)
1516                 rt_tx_intr(sc, 1);
1517
1518         if (status & INT_TXQ0_DONE)
1519                 rt_tx_intr(sc, 0);
1520 }
1521
1522 /*
1523  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
1524  */
1525 static void
1526 rt_rt5350_intr(void *arg)
1527 {
1528         struct rt_softc *sc;
1529         struct ifnet *ifp;
1530         uint32_t status;
1531
1532         sc = arg;
1533         ifp = sc->ifp;
1534
1535         /* acknowledge interrupts */
1536         status = RT_READ(sc, sc->fe_int_status);
1537         RT_WRITE(sc, sc->fe_int_status, status);
1538
1539         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
1540
1541         if (status == 0xffffffff ||     /* device likely went away */
1542                 status == 0)            /* not for us */
1543                 return;
1544
1545         sc->interrupts++;
1546
1547         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1548                 return;
1549
1550         if (status & RT5350_INT_TX_COHERENT)
1551                 rt_tx_coherent_intr(sc);
1552         if (status & RT5350_INT_RX_COHERENT)
1553                 rt_rx_coherent_intr(sc);
1554         if (status & RT5350_RX_DLY_INT)
1555                 rt_rx_delay_intr(sc);
1556         if (status & RT5350_TX_DLY_INT)
1557                 rt_tx_delay_intr(sc);
1558         if (status & RT5350_INT_RXQ1_DONE)
1559                 rt_rx_intr(sc, 1);
1560         if (status & RT5350_INT_RXQ0_DONE)
1561                 rt_rx_intr(sc, 0);
1562         if (status & RT5350_INT_TXQ3_DONE)
1563                 rt_tx_intr(sc, 3);
1564         if (status & RT5350_INT_TXQ2_DONE)
1565                 rt_tx_intr(sc, 2);
1566         if (status & RT5350_INT_TXQ1_DONE)
1567                 rt_tx_intr(sc, 1);
1568         if (status & RT5350_INT_TXQ0_DONE)
1569                 rt_tx_intr(sc, 0);
1570 }
1571
1572 static void
1573 rt_tx_coherent_intr(struct rt_softc *sc)
1574 {
1575         uint32_t tmp;
1576         int i;
1577
1578         RT_DPRINTF(sc, RT_DEBUG_INTR, "Tx coherent interrupt\n");
1579
1580         sc->tx_coherent_interrupts++;
1581
1582         /* restart DMA engine */
1583         tmp = RT_READ(sc, sc->pdma_glo_cfg);
1584         tmp &= ~(FE_TX_WB_DDONE | FE_TX_DMA_EN);
1585         RT_WRITE(sc, sc->pdma_glo_cfg, tmp);
1586
1587         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++)
1588                 rt_reset_tx_ring(sc, &sc->tx_ring[i]);
1589
1590         for (i = 0; i < RT_SOFTC_TX_RING_COUNT; i++) {
1591                 RT_WRITE(sc, sc->tx_base_ptr[i],
1592                         sc->tx_ring[i].desc_phys_addr);
1593                 RT_WRITE(sc, sc->tx_max_cnt[i],
1594                         RT_SOFTC_TX_RING_DESC_COUNT);
1595                 RT_WRITE(sc, sc->tx_ctx_idx[i], 0);
1596         }
1597
1598         rt_txrx_enable(sc);
1599 }
1600
1601 /*
1602  * rt_rx_coherent_intr
1603  */
1604 static void
1605 rt_rx_coherent_intr(struct rt_softc *sc)
1606 {
1607         uint32_t tmp;
1608         int i;
1609
1610         RT_DPRINTF(sc, RT_DEBUG_INTR, "Rx coherent interrupt\n");
1611
1612         sc->rx_coherent_interrupts++;
1613
1614         /* restart DMA engine */
1615         tmp = RT_READ(sc, sc->pdma_glo_cfg);
1616         tmp &= ~(FE_RX_DMA_EN);
1617         RT_WRITE(sc, sc->pdma_glo_cfg, tmp);
1618
1619         /* init Rx ring */
1620         for (i = 0; i < sc->rx_ring_count; i++)
1621                 rt_reset_rx_ring(sc, &sc->rx_ring[i]);
1622
1623         for (i = 0; i < sc->rx_ring_count; i++) {
1624                 RT_WRITE(sc, sc->rx_base_ptr[i],
1625                         sc->rx_ring[i].desc_phys_addr);
1626                 RT_WRITE(sc, sc->rx_max_cnt[i],
1627                         RT_SOFTC_RX_RING_DATA_COUNT);
1628                 RT_WRITE(sc, sc->rx_calc_idx[i],
1629                         RT_SOFTC_RX_RING_DATA_COUNT - 1);
1630         }
1631
1632         rt_txrx_enable(sc);
1633 }
1634
1635 /*
1636  * rt_rx_intr - a packet received
1637  */
1638 static void
1639 rt_rx_intr(struct rt_softc *sc, int qid)
1640 {
1641         KASSERT(qid >= 0 && qid < sc->rx_ring_count,
1642                 ("%s: Rx interrupt: invalid qid=%d\n",
1643                  device_get_nameunit(sc->dev), qid));
1644
1645         RT_DPRINTF(sc, RT_DEBUG_INTR, "Rx interrupt\n");
1646         sc->rx_interrupts[qid]++;
1647         RT_SOFTC_LOCK(sc);
1648
1649         if (!(sc->intr_disable_mask & (sc->int_rx_done_mask << qid))) {
1650                 rt_intr_disable(sc, (sc->int_rx_done_mask << qid));
1651                 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
1652         }
1653
1654         sc->intr_pending_mask |= (sc->int_rx_done_mask << qid);
1655         RT_SOFTC_UNLOCK(sc);
1656 }
1657
1658 static void
1659 rt_rx_delay_intr(struct rt_softc *sc)
1660 {
1661
1662         RT_DPRINTF(sc, RT_DEBUG_INTR, "Rx delay interrupt\n");
1663         sc->rx_delay_interrupts++;
1664 }
1665
1666 static void
1667 rt_tx_delay_intr(struct rt_softc *sc)
1668 {
1669
1670         RT_DPRINTF(sc, RT_DEBUG_INTR, "Tx delay interrupt\n");
1671         sc->tx_delay_interrupts++;
1672 }
1673
1674 /*
1675  * rt_tx_intr - Transsmition of packet done
1676  */
1677 static void
1678 rt_tx_intr(struct rt_softc *sc, int qid)
1679 {
1680
1681         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
1682                 ("%s: Tx interrupt: invalid qid=%d\n",
1683                  device_get_nameunit(sc->dev), qid));
1684
1685         RT_DPRINTF(sc, RT_DEBUG_INTR, "Tx interrupt: qid=%d\n", qid);
1686
1687         sc->tx_interrupts[qid]++;
1688         RT_SOFTC_LOCK(sc);
1689
1690         if (!(sc->intr_disable_mask & (sc->int_tx_done_mask << qid))) {
1691                 rt_intr_disable(sc, (sc->int_tx_done_mask << qid));
1692                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
1693         }
1694
1695         sc->intr_pending_mask |= (sc->int_tx_done_mask << qid);
1696         RT_SOFTC_UNLOCK(sc);
1697 }
1698
1699 /*
1700  * rt_rx_done_task - run RX task
1701  */
1702 static void
1703 rt_rx_done_task(void *context, int pending)
1704 {
1705         struct rt_softc *sc;
1706         struct ifnet *ifp;
1707         int again;
1708
1709         sc = context;
1710         ifp = sc->ifp;
1711
1712         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
1713
1714         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1715                 return;
1716
1717         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
1718
1719         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
1720
1721         RT_SOFTC_LOCK(sc);
1722
1723         if ((sc->intr_pending_mask & sc->int_rx_done_mask) || again) {
1724                 RT_DPRINTF(sc, RT_DEBUG_RX,
1725                     "Rx done task: scheduling again\n");
1726                 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
1727         } else {
1728                 rt_intr_enable(sc, sc->int_rx_done_mask);
1729         }
1730
1731         RT_SOFTC_UNLOCK(sc);
1732 }
1733
1734 /*
1735  * rt_tx_done_task - check for pending TX task in all queues
1736  */
1737 static void
1738 rt_tx_done_task(void *context, int pending)
1739 {
1740         struct rt_softc *sc;
1741         struct ifnet *ifp;
1742         uint32_t intr_mask;
1743         int i;
1744
1745         sc = context;
1746         ifp = sc->ifp;
1747
1748         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
1749
1750         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1751                 return;
1752
1753         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
1754                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
1755                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
1756                         rt_tx_eof(sc, &sc->tx_ring[i]);
1757                 }
1758         }
1759
1760         sc->tx_timer = 0;
1761
1762         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1763
1764         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
1765            sc->rt_chipid == RT_CHIPID_MT7620 ||
1766            sc->rt_chipid == RT_CHIPID_MT7621)
1767           intr_mask = (
1768                 RT5350_INT_TXQ3_DONE |
1769                 RT5350_INT_TXQ2_DONE |
1770                 RT5350_INT_TXQ1_DONE |
1771                 RT5350_INT_TXQ0_DONE);
1772         else
1773           intr_mask = (
1774                 INT_TXQ3_DONE |
1775                 INT_TXQ2_DONE |
1776                 INT_TXQ1_DONE |
1777                 INT_TXQ0_DONE);
1778
1779         RT_SOFTC_LOCK(sc);
1780
1781         rt_intr_enable(sc, ~sc->intr_pending_mask &
1782             (sc->intr_disable_mask & intr_mask));
1783
1784         if (sc->intr_pending_mask & intr_mask) {
1785                 RT_DPRINTF(sc, RT_DEBUG_TX,
1786                     "Tx done task: scheduling again\n");
1787                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
1788         }
1789
1790         RT_SOFTC_UNLOCK(sc);
1791
1792         if (!IFQ_IS_EMPTY(&ifp->if_snd))
1793                 rt_start(ifp);
1794 }
1795
1796 /*
1797  * rt_periodic_task - run periodic task
1798  */
1799 static void
1800 rt_periodic_task(void *context, int pending)
1801 {
1802         struct rt_softc *sc;
1803         struct ifnet *ifp;
1804
1805         sc = context;
1806         ifp = sc->ifp;
1807
1808         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
1809             sc->periodic_round);
1810
1811         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1812                 return;
1813
1814         RT_SOFTC_LOCK(sc);
1815         sc->periodic_round++;
1816         rt_update_stats(sc);
1817
1818         if ((sc->periodic_round % 10) == 0) {
1819                 rt_update_raw_counters(sc);
1820                 rt_watchdog(sc);
1821         }
1822
1823         RT_SOFTC_UNLOCK(sc);
1824         callout_reset(&sc->periodic_ch, hz / 10, rt_periodic, sc);
1825 }
1826
1827 /*
1828  * rt_rx_eof - check for frames that done by DMA engine and pass it into
1829  * network subsystem.
1830  */
1831 static int
1832 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
1833 {
1834         struct ifnet *ifp;
1835 /*      struct rt_softc_rx_ring *ring; */
1836         struct rt_rxdesc *desc;
1837         struct rt_softc_rx_data *data;
1838         struct mbuf *m, *mnew;
1839         bus_dma_segment_t segs[1];
1840         bus_dmamap_t dma_map;
1841         uint32_t index, desc_flags;
1842         int error, nsegs, len, nframes;
1843
1844         ifp = sc->ifp;
1845 /*      ring = &sc->rx_ring[0]; */
1846
1847         nframes = 0;
1848
1849         while (limit != 0) {
1850                 index = RT_READ(sc, sc->rx_drx_idx[0]);
1851                 if (ring->cur == index)
1852                         break;
1853
1854                 desc = &ring->desc[ring->cur];
1855                 data = &ring->data[ring->cur];
1856
1857                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
1858                     BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1859
1860 #ifdef IF_RT_DEBUG
1861                 if ( sc->debug & RT_DEBUG_RX ) {
1862                         printf("\nRX Descriptor[%#08x] dump:\n", (u_int)desc);
1863                         hexdump(desc, 16, 0, 0);
1864                         printf("-----------------------------------\n");
1865                 }
1866 #endif
1867
1868                 /* XXX Sometime device don`t set DDONE bit */
1869 #ifdef DDONE_FIXED
1870                 if (!(desc->sdl0 & htole16(RT_RXDESC_SDL0_DDONE))) {
1871                         RT_DPRINTF(sc, RT_DEBUG_RX, "DDONE=0, try next\n");
1872                         break;
1873                 }
1874 #endif
1875
1876                 len = le16toh(desc->sdl0) & 0x3fff;
1877                 RT_DPRINTF(sc, RT_DEBUG_RX, "new frame len=%d\n", len);
1878
1879                 nframes++;
1880
1881                 mnew = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
1882                     MJUMPAGESIZE);
1883                 if (mnew == NULL) {
1884                         sc->rx_mbuf_alloc_errors++;
1885                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1886                         goto skip;
1887                 }
1888
1889                 mnew->m_len = mnew->m_pkthdr.len = MJUMPAGESIZE;
1890
1891                 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag,
1892                     ring->spare_dma_map, mnew, segs, &nsegs, BUS_DMA_NOWAIT);
1893                 if (error != 0) {
1894                         RT_DPRINTF(sc, RT_DEBUG_RX,
1895                             "could not load Rx mbuf DMA map: "
1896                             "error=%d, nsegs=%d\n",
1897                             error, nsegs);
1898
1899                         m_freem(mnew);
1900
1901                         sc->rx_mbuf_dmamap_errors++;
1902                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1903
1904                         goto skip;
1905                 }
1906
1907                 KASSERT(nsegs == 1, ("%s: too many DMA segments",
1908                         device_get_nameunit(sc->dev)));
1909
1910                 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
1911                         BUS_DMASYNC_POSTREAD);
1912                 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
1913
1914                 dma_map = data->dma_map;
1915                 data->dma_map = ring->spare_dma_map;
1916                 ring->spare_dma_map = dma_map;
1917
1918                 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
1919                         BUS_DMASYNC_PREREAD);
1920
1921                 m = data->m;
1922                 desc_flags = desc->word3;
1923
1924                 data->m = mnew;
1925                 /* Add 2 for proper align of RX IP header */
1926                 desc->sdp0 = htole32(segs[0].ds_addr+2);
1927                 desc->sdl0 = htole32(segs[0].ds_len-2);
1928                 desc->word3 = 0;
1929
1930                 RT_DPRINTF(sc, RT_DEBUG_RX,
1931                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
1932
1933                 m->m_pkthdr.rcvif = ifp;
1934                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
1935                 m->m_data += 2;
1936                 m->m_pkthdr.len = m->m_len = len;
1937
1938                 /* check for crc errors */
1939                 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
1940                         /*check for valid checksum*/
1941                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
1942                                 RT_DPRINTF(sc, RT_DEBUG_RX,
1943                                     "rxdesc: crc error\n");
1944
1945                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1946
1947                                 if (!(ifp->if_flags & IFF_PROMISC)) {
1948                                     m_freem(m);
1949                                     goto skip;
1950                                 }
1951                         }
1952                         if ((desc_flags & sc->csum_fail_ip) == 0) {
1953                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
1954                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
1955                                 m->m_pkthdr.csum_data = 0xffff;
1956                         }
1957                         m->m_flags &= ~M_HASFCS;
1958                 }
1959
1960                 (*ifp->if_input)(ifp, m);
1961 skip:
1962                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
1963
1964                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
1965                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1966
1967                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
1968
1969                 limit--;
1970         }
1971
1972         if (ring->cur == 0)
1973                 RT_WRITE(sc, sc->rx_calc_idx[0],
1974                         RT_SOFTC_RX_RING_DATA_COUNT - 1);
1975         else
1976                 RT_WRITE(sc, sc->rx_calc_idx[0],
1977                         ring->cur - 1);
1978
1979         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx eof: nframes=%d\n", nframes);
1980
1981         sc->rx_packets += nframes;
1982
1983         return (limit == 0);
1984 }
1985
1986 /*
1987  * rt_tx_eof - check for successful transmitted frames and mark their
1988  * descriptor as free.
1989  */
1990 static void
1991 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
1992 {
1993         struct ifnet *ifp;
1994         struct rt_txdesc *desc;
1995         struct rt_softc_tx_data *data;
1996         uint32_t index;
1997         int ndescs, nframes;
1998
1999         ifp = sc->ifp;
2000
2001         ndescs = 0;
2002         nframes = 0;
2003
2004         for (;;) {
2005                 index = RT_READ(sc, sc->tx_dtx_idx[ring->qid]);
2006                 if (ring->desc_next == index)
2007                         break;
2008
2009                 ndescs++;
2010
2011                 desc = &ring->desc[ring->desc_next];
2012
2013                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2014                         BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2015
2016                 if (desc->sdl0 & htole16(RT_TXDESC_SDL0_LASTSEG) ||
2017                         desc->sdl1 & htole16(RT_TXDESC_SDL1_LASTSEG)) {
2018                         nframes++;
2019
2020                         data = &ring->data[ring->data_next];
2021
2022                         bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
2023                                 BUS_DMASYNC_POSTWRITE);
2024                         bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
2025
2026                         m_freem(data->m);
2027
2028                         data->m = NULL;
2029
2030                         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2031
2032                         RT_SOFTC_TX_RING_LOCK(ring);
2033                         ring->data_queued--;
2034                         ring->data_next = (ring->data_next + 1) %
2035                             RT_SOFTC_TX_RING_DATA_COUNT;
2036                         RT_SOFTC_TX_RING_UNLOCK(ring);
2037                 }
2038
2039                 desc->sdl0 &= ~htole16(RT_TXDESC_SDL0_DDONE);
2040
2041                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2042                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2043
2044                 RT_SOFTC_TX_RING_LOCK(ring);
2045                 ring->desc_queued--;
2046                 ring->desc_next = (ring->desc_next + 1) %
2047                     RT_SOFTC_TX_RING_DESC_COUNT;
2048                 RT_SOFTC_TX_RING_UNLOCK(ring);
2049         }
2050
2051         RT_DPRINTF(sc, RT_DEBUG_TX,
2052             "Tx eof: qid=%d, ndescs=%d, nframes=%d\n", ring->qid, ndescs,
2053             nframes);
2054 }
2055
2056 /*
2057  * rt_update_stats - query statistics counters and update related variables.
2058  */
2059 static void
2060 rt_update_stats(struct rt_softc *sc)
2061 {
2062         struct ifnet *ifp;
2063
2064         ifp = sc->ifp;
2065         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
2066         /* XXX do update stats here */
2067 }
2068
2069 /*
2070  * rt_watchdog - reinit device on watchdog event.
2071  */
2072 static void
2073 rt_watchdog(struct rt_softc *sc)
2074 {
2075         uint32_t tmp;
2076 #ifdef notyet
2077         int ntries;
2078 #endif
2079         if(sc->rt_chipid != RT_CHIPID_RT5350 &&
2080            sc->rt_chipid != RT_CHIPID_MT7620 &&
2081            sc->rt_chipid != RT_CHIPID_MT7621) {
2082                 tmp = RT_READ(sc, PSE_BASE + CDMA_OQ_STA);
2083
2084                 RT_DPRINTF(sc, RT_DEBUG_WATCHDOG,
2085                            "watchdog: PSE_IQ_STA=0x%08x\n", tmp);
2086         }
2087         /* XXX: do not reset */
2088 #ifdef notyet
2089         if (((tmp >> P0_IQ_PCNT_SHIFT) & 0xff) != 0) {
2090                 sc->tx_queue_not_empty[0]++;
2091
2092                 for (ntries = 0; ntries < 10; ntries++) {
2093                         tmp = RT_READ(sc, PSE_BASE + PSE_IQ_STA);
2094                         if (((tmp >> P0_IQ_PCNT_SHIFT) & 0xff) == 0)
2095                                 break;
2096
2097                         DELAY(1);
2098                 }
2099         }
2100
2101         if (((tmp >> P1_IQ_PCNT_SHIFT) & 0xff) != 0) {
2102                 sc->tx_queue_not_empty[1]++;
2103
2104                 for (ntries = 0; ntries < 10; ntries++) {
2105                         tmp = RT_READ(sc, PSE_BASE + PSE_IQ_STA);
2106                         if (((tmp >> P1_IQ_PCNT_SHIFT) & 0xff) == 0)
2107                                 break;
2108
2109                         DELAY(1);
2110                 }
2111         }
2112 #endif
2113 }
2114
2115 /*
2116  * rt_update_raw_counters - update counters.
2117  */
2118 static void
2119 rt_update_raw_counters(struct rt_softc *sc)
2120 {
2121
2122         sc->tx_bytes    += RT_READ(sc, CNTR_BASE + GDMA_TX_GBCNT0);
2123         sc->tx_packets  += RT_READ(sc, CNTR_BASE + GDMA_TX_GPCNT0);
2124         sc->tx_skip     += RT_READ(sc, CNTR_BASE + GDMA_TX_SKIPCNT0);
2125         sc->tx_collision+= RT_READ(sc, CNTR_BASE + GDMA_TX_COLCNT0);
2126
2127         sc->rx_bytes    += RT_READ(sc, CNTR_BASE + GDMA_RX_GBCNT0);
2128         sc->rx_packets  += RT_READ(sc, CNTR_BASE + GDMA_RX_GPCNT0);
2129         sc->rx_crc_err  += RT_READ(sc, CNTR_BASE + GDMA_RX_CSUM_ERCNT0);
2130         sc->rx_short_err+= RT_READ(sc, CNTR_BASE + GDMA_RX_SHORT_ERCNT0);
2131         sc->rx_long_err += RT_READ(sc, CNTR_BASE + GDMA_RX_LONG_ERCNT0);
2132         sc->rx_phy_err  += RT_READ(sc, CNTR_BASE + GDMA_RX_FERCNT0);
2133         sc->rx_fifo_overflows+= RT_READ(sc, CNTR_BASE + GDMA_RX_OERCNT0);
2134 }
2135
2136 static void
2137 rt_intr_enable(struct rt_softc *sc, uint32_t intr_mask)
2138 {
2139         uint32_t tmp;
2140
2141         sc->intr_disable_mask &= ~intr_mask;
2142         tmp = sc->intr_enable_mask & ~sc->intr_disable_mask;
2143         RT_WRITE(sc, sc->fe_int_enable, tmp);
2144 }
2145
2146 static void
2147 rt_intr_disable(struct rt_softc *sc, uint32_t intr_mask)
2148 {
2149         uint32_t tmp;
2150
2151         sc->intr_disable_mask |= intr_mask;
2152         tmp = sc->intr_enable_mask & ~sc->intr_disable_mask;
2153         RT_WRITE(sc, sc->fe_int_enable, tmp);
2154 }
2155
2156 /*
2157  * rt_txrx_enable - enable TX/RX DMA
2158  */
2159 static int
2160 rt_txrx_enable(struct rt_softc *sc)
2161 {
2162         struct ifnet *ifp;
2163         uint32_t tmp;
2164         int ntries;
2165
2166         ifp = sc->ifp;
2167
2168         /* enable Tx/Rx DMA engine */
2169         for (ntries = 0; ntries < 200; ntries++) {
2170                 tmp = RT_READ(sc, sc->pdma_glo_cfg);
2171                 if (!(tmp & (FE_TX_DMA_BUSY | FE_RX_DMA_BUSY)))
2172                         break;
2173
2174                 DELAY(1000);
2175         }
2176
2177         if (ntries == 200) {
2178                 device_printf(sc->dev, "timeout waiting for DMA engine\n");
2179                 return (-1);
2180         }
2181
2182         DELAY(50);
2183
2184         tmp |= FE_TX_WB_DDONE | FE_RX_DMA_EN | FE_TX_DMA_EN;
2185         RT_WRITE(sc, sc->pdma_glo_cfg, tmp);
2186
2187         /* XXX set Rx filter */
2188         return (0);
2189 }
2190
2191 /*
2192  * rt_alloc_rx_ring - allocate RX DMA ring buffer
2193  */
2194 static int
2195 rt_alloc_rx_ring(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int qid)
2196 {
2197         struct rt_rxdesc *desc;
2198         struct rt_softc_rx_data *data;
2199         bus_dma_segment_t segs[1];
2200         int i, nsegs, error;
2201
2202         error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
2203                 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
2204                 RT_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt_rxdesc), 1,
2205                 RT_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt_rxdesc),
2206                 0, NULL, NULL, &ring->desc_dma_tag);
2207         if (error != 0) {
2208                 device_printf(sc->dev,
2209                     "could not create Rx desc DMA tag\n");
2210                 goto fail;
2211         }
2212
2213         error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc,
2214             BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map);
2215         if (error != 0) {
2216                 device_printf(sc->dev,
2217                     "could not allocate Rx desc DMA memory\n");
2218                 goto fail;
2219         }
2220
2221         error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map,
2222                 ring->desc,
2223                 RT_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt_rxdesc),
2224                 rt_dma_map_addr, &ring->desc_phys_addr, 0);
2225         if (error != 0) {
2226                 device_printf(sc->dev, "could not load Rx desc DMA map\n");
2227                 goto fail;
2228         }
2229
2230         error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
2231             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
2232                 MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL,
2233                 &ring->data_dma_tag);
2234         if (error != 0) {
2235                 device_printf(sc->dev,
2236                     "could not create Rx data DMA tag\n");
2237                 goto fail;
2238         }
2239
2240         for (i = 0; i < RT_SOFTC_RX_RING_DATA_COUNT; i++) {
2241                 desc = &ring->desc[i];
2242                 data = &ring->data[i];
2243
2244                 error = bus_dmamap_create(ring->data_dma_tag, 0,
2245                     &data->dma_map);
2246                 if (error != 0) {
2247                         device_printf(sc->dev, "could not create Rx data DMA "
2248                             "map\n");
2249                         goto fail;
2250                 }
2251
2252                 data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
2253                     MJUMPAGESIZE);
2254                 if (data->m == NULL) {
2255                         device_printf(sc->dev, "could not allocate Rx mbuf\n");
2256                         error = ENOMEM;
2257                         goto fail;
2258                 }
2259
2260                 data->m->m_len = data->m->m_pkthdr.len = MJUMPAGESIZE;
2261
2262                 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag,
2263                     data->dma_map, data->m, segs, &nsegs, BUS_DMA_NOWAIT);
2264                 if (error != 0) {
2265                         device_printf(sc->dev,
2266                             "could not load Rx mbuf DMA map\n");
2267                         goto fail;
2268                 }
2269
2270                 KASSERT(nsegs == 1, ("%s: too many DMA segments",
2271                         device_get_nameunit(sc->dev)));
2272
2273                 /* Add 2 for proper align of RX IP header */
2274                 desc->sdp0 = htole32(segs[0].ds_addr+2);
2275                 desc->sdl0 = htole32(segs[0].ds_len-2);
2276         }
2277
2278         error = bus_dmamap_create(ring->data_dma_tag, 0,
2279             &ring->spare_dma_map);
2280         if (error != 0) {
2281                 device_printf(sc->dev,
2282                     "could not create Rx spare DMA map\n");
2283                 goto fail;
2284         }
2285
2286         bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2287                 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2288         ring->qid = qid;
2289         return (0);
2290
2291 fail:
2292         rt_free_rx_ring(sc, ring);
2293         return (error);
2294 }
2295
2296 /*
2297  * rt_reset_rx_ring - reset RX ring buffer
2298  */
2299 static void
2300 rt_reset_rx_ring(struct rt_softc *sc, struct rt_softc_rx_ring *ring)
2301 {
2302         struct rt_rxdesc *desc;
2303         int i;
2304
2305         for (i = 0; i < RT_SOFTC_RX_RING_DATA_COUNT; i++) {
2306                 desc = &ring->desc[i];
2307                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
2308         }
2309
2310         bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2311                 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
2312         ring->cur = 0;
2313 }
2314
2315 /*
2316  * rt_free_rx_ring - free memory used by RX ring buffer
2317  */
2318 static void
2319 rt_free_rx_ring(struct rt_softc *sc, struct rt_softc_rx_ring *ring)
2320 {
2321         struct rt_softc_rx_data *data;
2322         int i;
2323
2324         if (ring->desc != NULL) {
2325                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2326                         BUS_DMASYNC_POSTWRITE);
2327                 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map);
2328                 bus_dmamem_free(ring->desc_dma_tag, ring->desc,
2329                         ring->desc_dma_map);
2330         }
2331
2332         if (ring->desc_dma_tag != NULL)
2333                 bus_dma_tag_destroy(ring->desc_dma_tag);
2334
2335         for (i = 0; i < RT_SOFTC_RX_RING_DATA_COUNT; i++) {
2336                 data = &ring->data[i];
2337
2338                 if (data->m != NULL) {
2339                         bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
2340                                 BUS_DMASYNC_POSTREAD);
2341                         bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
2342                         m_freem(data->m);
2343                 }
2344
2345                 if (data->dma_map != NULL)
2346                         bus_dmamap_destroy(ring->data_dma_tag, data->dma_map);
2347         }
2348
2349         if (ring->spare_dma_map != NULL)
2350                 bus_dmamap_destroy(ring->data_dma_tag, ring->spare_dma_map);
2351
2352         if (ring->data_dma_tag != NULL)
2353                 bus_dma_tag_destroy(ring->data_dma_tag);
2354 }
2355
2356 /*
2357  * rt_alloc_tx_ring - allocate TX ring buffer
2358  */
2359 static int
2360 rt_alloc_tx_ring(struct rt_softc *sc, struct rt_softc_tx_ring *ring, int qid)
2361 {
2362         struct rt_softc_tx_data *data;
2363         int error, i;
2364
2365         mtx_init(&ring->lock, device_get_nameunit(sc->dev), NULL, MTX_DEF);
2366
2367         error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
2368                 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
2369                 RT_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt_txdesc), 1,
2370                 RT_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt_txdesc),
2371                 0, NULL, NULL, &ring->desc_dma_tag);
2372         if (error != 0) {
2373                 device_printf(sc->dev,
2374                     "could not create Tx desc DMA tag\n");
2375                 goto fail;
2376         }
2377
2378         error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc,
2379             BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map);
2380         if (error != 0) {
2381                 device_printf(sc->dev,
2382                     "could not allocate Tx desc DMA memory\n");
2383                 goto fail;
2384         }
2385
2386         error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map,
2387             ring->desc, (RT_SOFTC_TX_RING_DESC_COUNT *
2388             sizeof(struct rt_txdesc)), rt_dma_map_addr,
2389             &ring->desc_phys_addr, 0);
2390         if (error != 0) {
2391                 device_printf(sc->dev, "could not load Tx desc DMA map\n");
2392                 goto fail;
2393         }
2394
2395         ring->desc_queued = 0;
2396         ring->desc_cur = 0;
2397         ring->desc_next = 0;
2398
2399         error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
2400             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
2401             RT_SOFTC_TX_RING_DATA_COUNT * RT_TX_DATA_SEG0_SIZE, 1,
2402             RT_SOFTC_TX_RING_DATA_COUNT * RT_TX_DATA_SEG0_SIZE,
2403             0, NULL, NULL, &ring->seg0_dma_tag);
2404         if (error != 0) {
2405                 device_printf(sc->dev,
2406                     "could not create Tx seg0 DMA tag\n");
2407                 goto fail;
2408         }
2409
2410         error = bus_dmamem_alloc(ring->seg0_dma_tag, (void **) &ring->seg0,
2411             BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->seg0_dma_map);
2412         if (error != 0) {
2413                 device_printf(sc->dev,
2414                     "could not allocate Tx seg0 DMA memory\n");
2415                 goto fail;
2416         }
2417
2418         error = bus_dmamap_load(ring->seg0_dma_tag, ring->seg0_dma_map,
2419             ring->seg0,
2420             RT_SOFTC_TX_RING_DATA_COUNT * RT_TX_DATA_SEG0_SIZE,
2421             rt_dma_map_addr, &ring->seg0_phys_addr, 0);
2422         if (error != 0) {
2423                 device_printf(sc->dev, "could not load Tx seg0 DMA map\n");
2424                 goto fail;
2425         }
2426
2427         error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
2428             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
2429             MJUMPAGESIZE, RT_SOFTC_MAX_SCATTER, MJUMPAGESIZE, 0, NULL, NULL,
2430             &ring->data_dma_tag);
2431         if (error != 0) {
2432                 device_printf(sc->dev,
2433                     "could not create Tx data DMA tag\n");
2434                 goto fail;
2435         }
2436
2437         for (i = 0; i < RT_SOFTC_TX_RING_DATA_COUNT; i++) {
2438                 data = &ring->data[i];
2439
2440                 error = bus_dmamap_create(ring->data_dma_tag, 0,
2441                     &data->dma_map);
2442                 if (error != 0) {
2443                         device_printf(sc->dev, "could not create Tx data DMA "
2444                             "map\n");
2445                         goto fail;
2446                 }
2447         }
2448
2449         ring->data_queued = 0;
2450         ring->data_cur = 0;
2451         ring->data_next = 0;
2452
2453         ring->qid = qid;
2454         return (0);
2455
2456 fail:
2457         rt_free_tx_ring(sc, ring);
2458         return (error);
2459 }
2460
2461 /*
2462  * rt_reset_tx_ring - reset TX ring buffer to empty state
2463  */
2464 static void
2465 rt_reset_tx_ring(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
2466 {
2467         struct rt_softc_tx_data *data;
2468         struct rt_txdesc *desc;
2469         int i;
2470
2471         for (i = 0; i < RT_SOFTC_TX_RING_DESC_COUNT; i++) {
2472                 desc = &ring->desc[i];
2473
2474                 desc->sdl0 = 0;
2475                 desc->sdl1 = 0;
2476         }
2477
2478         ring->desc_queued = 0;
2479         ring->desc_cur = 0;
2480         ring->desc_next = 0;
2481
2482         bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2483                 BUS_DMASYNC_PREWRITE);
2484
2485         bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
2486                 BUS_DMASYNC_PREWRITE);
2487
2488         for (i = 0; i < RT_SOFTC_TX_RING_DATA_COUNT; i++) {
2489                 data = &ring->data[i];
2490
2491                 if (data->m != NULL) {
2492                         bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
2493                                 BUS_DMASYNC_POSTWRITE);
2494                         bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
2495                         m_freem(data->m);
2496                         data->m = NULL;
2497                 }
2498         }
2499
2500         ring->data_queued = 0;
2501         ring->data_cur = 0;
2502         ring->data_next = 0;
2503 }
2504
2505 /*
2506  * rt_free_tx_ring - free RX ring buffer
2507  */
2508 static void
2509 rt_free_tx_ring(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
2510 {
2511         struct rt_softc_tx_data *data;
2512         int i;
2513
2514         if (ring->desc != NULL) {
2515                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
2516                         BUS_DMASYNC_POSTWRITE);
2517                 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map);
2518                 bus_dmamem_free(ring->desc_dma_tag, ring->desc,
2519                         ring->desc_dma_map);
2520         }
2521
2522         if (ring->desc_dma_tag != NULL)
2523                 bus_dma_tag_destroy(ring->desc_dma_tag);
2524
2525         if (ring->seg0 != NULL) {
2526                 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
2527                         BUS_DMASYNC_POSTWRITE);
2528                 bus_dmamap_unload(ring->seg0_dma_tag, ring->seg0_dma_map);
2529                 bus_dmamem_free(ring->seg0_dma_tag, ring->seg0,
2530                         ring->seg0_dma_map);
2531         }
2532
2533         if (ring->seg0_dma_tag != NULL)
2534                 bus_dma_tag_destroy(ring->seg0_dma_tag);
2535
2536         for (i = 0; i < RT_SOFTC_TX_RING_DATA_COUNT; i++) {
2537                 data = &ring->data[i];
2538
2539                 if (data->m != NULL) {
2540                         bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
2541                                 BUS_DMASYNC_POSTWRITE);
2542                         bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
2543                         m_freem(data->m);
2544                 }
2545
2546                 if (data->dma_map != NULL)
2547                         bus_dmamap_destroy(ring->data_dma_tag, data->dma_map);
2548         }
2549
2550         if (ring->data_dma_tag != NULL)
2551                 bus_dma_tag_destroy(ring->data_dma_tag);
2552
2553         mtx_destroy(&ring->lock);
2554 }
2555
2556 /*
2557  * rt_dma_map_addr - get address of busdma segment
2558  */
2559 static void
2560 rt_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
2561 {
2562         if (error != 0)
2563                 return;
2564
2565         KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
2566
2567         *(bus_addr_t *) arg = segs[0].ds_addr;
2568 }
2569
2570 /*
2571  * rt_sysctl_attach - attach sysctl nodes for NIC counters.
2572  */
2573 static void
2574 rt_sysctl_attach(struct rt_softc *sc)
2575 {
2576         struct sysctl_ctx_list *ctx;
2577         struct sysctl_oid *tree;
2578         struct sysctl_oid *stats;
2579
2580         ctx = device_get_sysctl_ctx(sc->dev);
2581         tree = device_get_sysctl_tree(sc->dev);
2582
2583         /* statistic counters */
2584         stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
2585             "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "statistic");
2586
2587         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2588             "interrupts", CTLFLAG_RD, &sc->interrupts,
2589             "all interrupts");
2590
2591         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2592             "tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts,
2593             "Tx coherent interrupts");
2594
2595         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2596             "rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts,
2597             "Rx coherent interrupts");
2598
2599         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2600             "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts[0],
2601             "Rx interrupts");
2602
2603         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2604             "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts,
2605             "Rx delay interrupts");
2606
2607         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2608             "TXQ3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3],
2609             "Tx AC3 interrupts");
2610
2611         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2612             "TXQ2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2],
2613             "Tx AC2 interrupts");
2614
2615         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2616             "TXQ1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1],
2617             "Tx AC1 interrupts");
2618
2619         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2620             "TXQ0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0],
2621             "Tx AC0 interrupts");
2622
2623         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2624             "tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts,
2625             "Tx delay interrupts");
2626
2627         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2628             "TXQ3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued,
2629             0, "Tx AC3 descriptors queued");
2630
2631         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2632             "TXQ3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].data_queued,
2633             0, "Tx AC3 data queued");
2634
2635         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2636             "TXQ2_desc_queued", CTLFLAG_RD, &sc->tx_ring[2].desc_queued,
2637             0, "Tx AC2 descriptors queued");
2638
2639         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2640             "TXQ2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].data_queued,
2641             0, "Tx AC2 data queued");
2642
2643         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2644             "TXQ1_desc_queued", CTLFLAG_RD, &sc->tx_ring[1].desc_queued,
2645             0, "Tx AC1 descriptors queued");
2646
2647         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2648             "TXQ1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].data_queued,
2649             0, "Tx AC1 data queued");
2650
2651         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2652             "TXQ0_desc_queued", CTLFLAG_RD, &sc->tx_ring[0].desc_queued,
2653             0, "Tx AC0 descriptors queued");
2654
2655         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2656             "TXQ0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued,
2657             0, "Tx AC0 data queued");
2658
2659         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2660             "TXQ3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3],
2661             "Tx AC3 data queue full");
2662
2663         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2664             "TXQ2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2],
2665             "Tx AC2 data queue full");
2666
2667         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2668             "TXQ1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1],
2669             "Tx AC1 data queue full");
2670
2671         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2672             "TXQ0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0],
2673             "Tx AC0 data queue full");
2674
2675         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2676             "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts,
2677             "Tx watchdog timeouts");
2678
2679         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2680             "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets,
2681             "Tx defragmented packets");
2682
2683         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2684             "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail,
2685             "no Tx descriptors available");
2686
2687         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2688             "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors,
2689             "Rx mbuf allocation errors");
2690
2691         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2692             "rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors,
2693             "Rx mbuf DMA mapping errors");
2694
2695         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2696             "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0],
2697             "Tx queue 0 not empty");
2698
2699         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2700             "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1],
2701             "Tx queue 1 not empty");
2702
2703         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2704             "rx_packets", CTLFLAG_RD, &sc->rx_packets,
2705             "Rx packets");
2706
2707         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2708             "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_err,
2709             "Rx CRC errors");
2710
2711         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2712             "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_err,
2713             "Rx PHY errors");
2714
2715         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2716             "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets,
2717             "Rx duplicate packets");
2718
2719         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2720             "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows,
2721             "Rx FIFO overflows");
2722
2723         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2724             "rx_bytes", CTLFLAG_RD, &sc->rx_bytes,
2725             "Rx bytes");
2726
2727         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2728             "rx_long_err", CTLFLAG_RD, &sc->rx_long_err,
2729             "Rx too long frame errors");
2730
2731         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2732             "rx_short_err", CTLFLAG_RD, &sc->rx_short_err,
2733             "Rx too short frame errors");
2734
2735         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2736             "tx_bytes", CTLFLAG_RD, &sc->tx_bytes,
2737             "Tx bytes");
2738
2739         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2740             "tx_packets", CTLFLAG_RD, &sc->tx_packets,
2741             "Tx packets");
2742
2743         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2744             "tx_skip", CTLFLAG_RD, &sc->tx_skip,
2745             "Tx skip count for GDMA ports");
2746
2747         SYSCTL_ADD_ULONG(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
2748             "tx_collision", CTLFLAG_RD, &sc->tx_collision,
2749             "Tx collision count for GDMA ports");
2750 }
2751
2752 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
2753 /* This code is only work RT2880 and same chip. */
2754 /* TODO: make RT3052 and later support code. But nobody need it? */
2755 static int
2756 rt_miibus_readreg(device_t dev, int phy, int reg)
2757 {
2758         struct rt_softc *sc = device_get_softc(dev);
2759         int dat;
2760
2761         /*
2762          * PSEUDO_PHYAD is a special value for indicate switch attached.
2763          * No one PHY use PSEUDO_PHYAD (0x1e) address.
2764          */
2765 #ifndef RT_MDIO
2766         if (phy == 31) {
2767                 /* Fake PHY ID for bfeswitch attach */
2768                 switch (reg) {
2769                 case MII_BMSR:
2770                         return (BMSR_EXTSTAT|BMSR_MEDIAMASK);
2771                 case MII_PHYIDR1:
2772                         return (0x40);          /* As result of faking */
2773                 case MII_PHYIDR2:               /* PHY will detect as */
2774                         return (0x6250);                /* bfeswitch */
2775                 }
2776         }
2777 #endif
2778
2779         /* Wait prev command done if any */
2780         while (RT_READ(sc, MDIO_ACCESS) & MDIO_CMD_ONGO);
2781         dat = ((phy << MDIO_PHY_ADDR_SHIFT) & MDIO_PHY_ADDR_MASK) |
2782             ((reg << MDIO_PHYREG_ADDR_SHIFT) & MDIO_PHYREG_ADDR_MASK);
2783         RT_WRITE(sc, MDIO_ACCESS, dat);
2784         RT_WRITE(sc, MDIO_ACCESS, dat | MDIO_CMD_ONGO);
2785         while (RT_READ(sc, MDIO_ACCESS) & MDIO_CMD_ONGO);
2786
2787         return (RT_READ(sc, MDIO_ACCESS) & MDIO_PHY_DATA_MASK);
2788 }
2789
2790 static int
2791 rt_miibus_writereg(device_t dev, int phy, int reg, int val)
2792 {
2793         struct rt_softc *sc = device_get_softc(dev);
2794         int dat;
2795
2796         /* Wait prev command done if any */
2797         while (RT_READ(sc, MDIO_ACCESS) & MDIO_CMD_ONGO);
2798         dat = MDIO_CMD_WR |
2799             ((phy << MDIO_PHY_ADDR_SHIFT) & MDIO_PHY_ADDR_MASK) |
2800             ((reg << MDIO_PHYREG_ADDR_SHIFT) & MDIO_PHYREG_ADDR_MASK) |
2801             (val & MDIO_PHY_DATA_MASK);
2802         RT_WRITE(sc, MDIO_ACCESS, dat);
2803         RT_WRITE(sc, MDIO_ACCESS, dat | MDIO_CMD_ONGO);
2804         while (RT_READ(sc, MDIO_ACCESS) & MDIO_CMD_ONGO);
2805
2806         return (0);
2807 }
2808 #endif
2809
2810 #ifdef IF_RT_PHY_SUPPORT
2811 void
2812 rt_miibus_statchg(device_t dev)
2813 {
2814         struct rt_softc *sc = device_get_softc(dev);
2815         struct mii_data *mii;
2816
2817         mii = device_get_softc(sc->rt_miibus);
2818
2819         if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
2820             (IFM_ACTIVE | IFM_AVALID)) {
2821                 switch (IFM_SUBTYPE(mii->mii_media_active)) {
2822                 case IFM_10_T:
2823                 case IFM_100_TX:
2824                         /* XXX check link here */
2825                         sc->flags |= 1;
2826                         break;
2827                 default:
2828                         break;
2829                 }
2830         }
2831 }
2832 #endif /* IF_RT_PHY_SUPPORT */
2833
2834 static device_method_t rt_dev_methods[] =
2835 {
2836         DEVMETHOD(device_probe, rt_probe),
2837         DEVMETHOD(device_attach, rt_attach),
2838         DEVMETHOD(device_detach, rt_detach),
2839         DEVMETHOD(device_shutdown, rt_shutdown),
2840         DEVMETHOD(device_suspend, rt_suspend),
2841         DEVMETHOD(device_resume, rt_resume),
2842
2843 #ifdef IF_RT_PHY_SUPPORT
2844         /* MII interface */
2845         DEVMETHOD(miibus_readreg,       rt_miibus_readreg),
2846         DEVMETHOD(miibus_writereg,      rt_miibus_writereg),
2847         DEVMETHOD(miibus_statchg,       rt_miibus_statchg),
2848 #endif
2849
2850         DEVMETHOD_END
2851 };
2852
2853 static driver_t rt_driver =
2854 {
2855         "rt",
2856         rt_dev_methods,
2857         sizeof(struct rt_softc)
2858 };
2859
2860 static devclass_t rt_dev_class;
2861
2862 DRIVER_MODULE(rt, nexus, rt_driver, rt_dev_class, 0, 0);
2863 #ifdef FDT
2864 DRIVER_MODULE(rt, simplebus, rt_driver, rt_dev_class, 0, 0);
2865 #endif
2866
2867 MODULE_DEPEND(rt, ether, 1, 1, 1);
2868 MODULE_DEPEND(rt, miibus, 1, 1, 1);
2869
2870 #ifdef RT_MDIO
2871 MODULE_DEPEND(rt, mdio, 1, 1, 1);
2872
2873 static int rtmdio_probe(device_t);
2874 static int rtmdio_attach(device_t);
2875 static int rtmdio_detach(device_t);
2876
2877 static struct mtx miibus_mtx;
2878
2879 MTX_SYSINIT(miibus_mtx, &miibus_mtx, "rt mii lock", MTX_DEF);
2880
2881 /*
2882  * Declare an additional, separate driver for accessing the MDIO bus.
2883  */
2884 static device_method_t rtmdio_methods[] = {
2885         /* Device interface */
2886         DEVMETHOD(device_probe,         rtmdio_probe),
2887         DEVMETHOD(device_attach,        rtmdio_attach),
2888         DEVMETHOD(device_detach,        rtmdio_detach),
2889
2890         /* bus interface */
2891         DEVMETHOD(bus_add_child,        device_add_child_ordered),
2892
2893         /* MDIO access */
2894         DEVMETHOD(mdio_readreg,         rt_miibus_readreg),
2895         DEVMETHOD(mdio_writereg,        rt_miibus_writereg),
2896 };
2897
2898 DEFINE_CLASS_0(rtmdio, rtmdio_driver, rtmdio_methods,
2899     sizeof(struct rt_softc));
2900 static devclass_t rtmdio_devclass;
2901
2902 DRIVER_MODULE(miiproxy, rt, miiproxy_driver, miiproxy_devclass, 0, 0);
2903 DRIVER_MODULE(rtmdio, simplebus, rtmdio_driver, rtmdio_devclass, 0, 0);
2904 DRIVER_MODULE(mdio, rtmdio, mdio_driver, mdio_devclass, 0, 0);
2905
2906 static int
2907 rtmdio_probe(device_t dev)
2908 {
2909         if (!ofw_bus_status_okay(dev))
2910                 return (ENXIO);
2911
2912         if (!ofw_bus_is_compatible(dev, "ralink,rt2880-mdio"))
2913                 return (ENXIO);
2914
2915         device_set_desc(dev, "FV built-in ethernet interface, MDIO controller");
2916         return(0);
2917 }
2918
2919 static int
2920 rtmdio_attach(device_t dev)
2921 {
2922         struct rt_softc *sc;
2923         int     error;
2924
2925         sc = device_get_softc(dev);
2926         sc->dev = dev;
2927         sc->mem_rid = 0;
2928         sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
2929             &sc->mem_rid, RF_ACTIVE | RF_SHAREABLE);
2930         if (sc->mem == NULL) {
2931                 device_printf(dev, "couldn't map memory\n");
2932                 error = ENXIO;
2933                 goto fail;
2934         }
2935
2936         sc->bst = rman_get_bustag(sc->mem);
2937         sc->bsh = rman_get_bushandle(sc->mem);
2938
2939         bus_generic_probe(dev);
2940         bus_enumerate_hinted_children(dev);
2941         error = bus_generic_attach(dev);
2942 fail:
2943         return(error);
2944 }
2945
2946 static int
2947 rtmdio_detach(device_t dev)
2948 {
2949         return(0);
2950 }
2951 #endif