sys/dev/etherswitch/arswitch/arswitch.c

   1 /*-
   2  * Copyright (c) 2011-2012 Stefan Bethke.
   3  * Copyright (c) 2012 Adrian Chadd.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/bus.h>
  32 #include <sys/errno.h>
  33 #include <sys/kernel.h>
  34 #include <sys/malloc.h>
  35 #include <sys/module.h>
  36 #include <sys/socket.h>
  37 #include <sys/sockio.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/systm.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
  49 #include <machine/bus.h>
  50 #include <dev/iicbus/iic.h>
  51 #include <dev/iicbus/iiconf.h>
  52 #include <dev/iicbus/iicbus.h>
  53 #include <dev/mii/mii.h>
  54 #include <dev/mii/miivar.h>
  55 #include <dev/mdio/mdio.h>
  56
  57 #include <dev/etherswitch/etherswitch.h>
  58
  59 #include <dev/etherswitch/arswitch/arswitchreg.h>
  60 #include <dev/etherswitch/arswitch/arswitchvar.h>
  61 #include <dev/etherswitch/arswitch/arswitch_reg.h>
  62 #include <dev/etherswitch/arswitch/arswitch_phy.h>
  63 #include <dev/etherswitch/arswitch/arswitch_vlans.h>
  64
  65 #include <dev/etherswitch/arswitch/arswitch_7240.h>
  66 #include <dev/etherswitch/arswitch/arswitch_8216.h>
  67 #include <dev/etherswitch/arswitch/arswitch_8226.h>
  68 #include <dev/etherswitch/arswitch/arswitch_8316.h>
  69 #include <dev/etherswitch/arswitch/arswitch_8327.h>
  70 #include <dev/etherswitch/arswitch/arswitch_9340.h>
  71
  72 #include "mdio_if.h"
  73 #include "miibus_if.h"
  74 #include "etherswitch_if.h"
  75
  76 #if     defined(DEBUG)
  77 static SYSCTL_NODE(_debug, OID_AUTO, arswitch, CTLFLAG_RD, 0, "arswitch");
  78 #endif
  79
  80 static inline int arswitch_portforphy(int phy);
  81 static void arswitch_tick(void *arg);
  82 static int arswitch_ifmedia_upd(struct ifnet *);
  83 static void arswitch_ifmedia_sts(struct ifnet *, struct ifmediareq *);
  84 static int ar8xxx_port_vlan_setup(struct arswitch_softc *sc,
  85     etherswitch_port_t *p);
  86 static int ar8xxx_port_vlan_get(struct arswitch_softc *sc,
  87     etherswitch_port_t *p);
  88
  89 static int
  90 arswitch_probe(device_t dev)
  91 {
  92         struct arswitch_softc *sc;
  93         uint32_t id;
  94         char *chipname, desc[256];
  95
  96         sc = device_get_softc(dev);
  97         bzero(sc, sizeof(*sc));
  98         sc->page = -1;
  99
 100         /* AR7240 probe */
 101         if (ar7240_probe(dev) == 0) {
 102                 chipname = "AR7240";
 103                 sc->sc_switchtype = AR8X16_SWITCH_AR7240;
 104                 sc->is_internal_switch = 1;
 105                 id = 0;
 106                 goto done;
 107         }
 108
 109         /* AR9340 probe */
 110         if (ar9340_probe(dev) == 0) {
 111                 chipname = "AR9340";
 112                 sc->sc_switchtype = AR8X16_SWITCH_AR9340;
 113                 sc->is_internal_switch = 1;
 114                 id = 0;
 115                 goto done;
 116         }
 117
 118         /* AR8xxx probe */
 119         id = arswitch_readreg(dev, AR8X16_REG_MASK_CTRL);
 120         sc->chip_rev = (id & AR8X16_MASK_CTRL_REV_MASK);
 121         sc->chip_ver = (id & AR8X16_MASK_CTRL_VER_MASK) > AR8X16_MASK_CTRL_VER_SHIFT;
 122         switch (id & (AR8X16_MASK_CTRL_VER_MASK | AR8X16_MASK_CTRL_REV_MASK)) {
 123         case 0x0101:
 124                 chipname = "AR8216";
 125                 sc->sc_switchtype = AR8X16_SWITCH_AR8216;
 126                 break;
 127         case 0x0201:
 128                 chipname = "AR8226";
 129                 sc->sc_switchtype = AR8X16_SWITCH_AR8226;
 130                 break;
 131         /* 0x0301 - AR8236 */
 132         case 0x1000:
 133         case 0x1001:
 134                 chipname = "AR8316";
 135                 sc->sc_switchtype = AR8X16_SWITCH_AR8316;
 136                 break;
 137         case 0x1202:
 138         case 0x1204:
 139                 chipname = "AR8327";
 140                 sc->sc_switchtype = AR8X16_SWITCH_AR8327;
 141                 sc->mii_lo_first = 1;
 142                 break;
 143         default:
 144                 chipname = NULL;
 145         }
 146
 147 done:
 148
 149         DPRINTF(dev, "chipname=%s, id=%08x\n", chipname, id);
 150         if (chipname != NULL) {
 151                 snprintf(desc, sizeof(desc),
 152                     "Atheros %s Ethernet Switch (ver %d rev %d)",
 153                     chipname,
 154                     sc->chip_ver,
 155                     sc->chip_rev);
 156                 device_set_desc_copy(dev, desc);
 157                 return (BUS_PROBE_DEFAULT);
 158         }
 159         return (ENXIO);
 160 }
 161
 162 static int
 163 arswitch_attach_phys(struct arswitch_softc *sc)
 164 {
 165         int phy, err = 0;
 166         char name[IFNAMSIZ];
 167
 168         /* PHYs need an interface, so we generate a dummy one */
 169         snprintf(name, IFNAMSIZ, "%sport", device_get_nameunit(sc->sc_dev));
 170         for (phy = 0; phy < sc->numphys; phy++) {
 171                 sc->ifp[phy] = if_alloc(IFT_ETHER);
 172                 sc->ifp[phy]->if_softc = sc;
 173                 sc->ifp[phy]->if_flags |= IFF_UP | IFF_BROADCAST |
 174                     IFF_DRV_RUNNING | IFF_SIMPLEX;
 175                 sc->ifname[phy] = malloc(strlen(name)+1, M_DEVBUF, M_WAITOK);
 176                 bcopy(name, sc->ifname[phy], strlen(name)+1);
 177                 if_initname(sc->ifp[phy], sc->ifname[phy],
 178                     arswitch_portforphy(phy));
 179                 err = mii_attach(sc->sc_dev, &sc->miibus[phy], sc->ifp[phy],
 180                     arswitch_ifmedia_upd, arswitch_ifmedia_sts, \
 181                     BMSR_DEFCAPMASK, phy, MII_OFFSET_ANY, 0);
 182 #if 0
 183                 DPRINTF(sc->sc_dev, "%s attached to pseudo interface %s\n",
 184                     device_get_nameunit(sc->miibus[phy]),
 185                     sc->ifp[phy]->if_xname);
 186 #endif
 187                 if (err != 0) {
 188                         device_printf(sc->sc_dev,
 189                             "attaching PHY %d failed\n",
 190                             phy);
 191                 }
 192         }
 193         return (err);
 194 }
 195
 196 static int
 197 arswitch_reset(device_t dev)
 198 {
 199
 200         arswitch_writereg(dev, AR8X16_REG_MASK_CTRL,
 201             AR8X16_MASK_CTRL_SOFT_RESET);
 202         DELAY(1000);
 203         if (arswitch_readreg(dev, AR8X16_REG_MASK_CTRL) &
 204             AR8X16_MASK_CTRL_SOFT_RESET) {
 205                 device_printf(dev, "unable to reset switch\n");
 206                 return (-1);
 207         }
 208         return (0);
 209 }
 210
 211 static int
 212 arswitch_set_vlan_mode(struct arswitch_softc *sc, uint32_t mode)
 213 {
 214
 215         /* Check for invalid modes. */
 216         if ((mode & sc->info.es_vlan_caps) != mode)
 217                 return (EINVAL);
 218
 219         switch (mode) {
 220         case ETHERSWITCH_VLAN_DOT1Q:
 221                 sc->vlan_mode = ETHERSWITCH_VLAN_DOT1Q;
 222                 break;
 223         case ETHERSWITCH_VLAN_PORT:
 224                 sc->vlan_mode = ETHERSWITCH_VLAN_PORT;
 225                 break;
 226         default:
 227                 sc->vlan_mode = 0;
 228         }
 229
 230         /* Reset VLANs. */
 231         sc->hal.arswitch_vlan_init_hw(sc);
 232
 233         return (0);
 234 }
 235
 236 static void
 237 ar8xxx_port_init(struct arswitch_softc *sc, int port)
 238 {
 239
 240         /* Port0 - CPU */
 241         if (port == AR8X16_PORT_CPU) {
 242                 arswitch_writereg(sc->sc_dev, AR8X16_REG_PORT_STS(0),
 243                     (AR8X16_IS_SWITCH(sc, AR8216) ?
 244                     AR8X16_PORT_STS_SPEED_100 : AR8X16_PORT_STS_SPEED_1000) |
 245                     (AR8X16_IS_SWITCH(sc, AR8216) ? 0 : AR8X16_PORT_STS_RXFLOW) |
 246                     (AR8X16_IS_SWITCH(sc, AR8216) ? 0 : AR8X16_PORT_STS_TXFLOW) |
 247                     AR8X16_PORT_STS_RXMAC |
 248                     AR8X16_PORT_STS_TXMAC |
 249                     AR8X16_PORT_STS_DUPLEX);
 250                 arswitch_writereg(sc->sc_dev, AR8X16_REG_PORT_CTRL(0),
 251                     arswitch_readreg(sc->sc_dev, AR8X16_REG_PORT_CTRL(0)) &
 252                     ~AR8X16_PORT_CTRL_HEADER);
 253         } else {
 254                 /* Set ports to auto negotiation. */
 255                 arswitch_writereg(sc->sc_dev, AR8X16_REG_PORT_STS(port),
 256                     AR8X16_PORT_STS_LINK_AUTO);
 257                 arswitch_writereg(sc->sc_dev, AR8X16_REG_PORT_CTRL(port),
 258                     arswitch_readreg(sc->sc_dev, AR8X16_REG_PORT_CTRL(port)) &
 259                     ~AR8X16_PORT_CTRL_HEADER);
 260         }
 261 }
 262
 263 static int
 264 ar8xxx_atu_flush(struct arswitch_softc *sc)
 265 {
 266         int ret;
 267
 268         ret = arswitch_waitreg(sc->sc_dev,
 269             AR8216_REG_ATU,
 270             AR8216_ATU_ACTIVE,
 271             0,
 272             1000);
 273
 274         if (ret)
 275                 device_printf(sc->sc_dev, "%s: waitreg failed\n", __func__);
 276
 277         if (!ret)
 278                 arswitch_writereg(sc->sc_dev,
 279                     AR8216_REG_ATU,
 280                     AR8216_ATU_OP_FLUSH);
 281
 282         return (ret);
 283 }
 284
 285 static int
 286 arswitch_attach(device_t dev)
 287 {
 288         struct arswitch_softc *sc;
 289         int err = 0;
 290         int port;
 291
 292         sc = device_get_softc(dev);
 293
 294         /* sc->sc_switchtype is already decided in arswitch_probe() */
 295         sc->sc_dev = dev;
 296         mtx_init(&sc->sc_mtx, "arswitch", NULL, MTX_DEF);
 297         sc->page = -1;
 298         strlcpy(sc->info.es_name, device_get_desc(dev),
 299             sizeof(sc->info.es_name));
 300
 301         /* Default HAL methods */
 302         sc->hal.arswitch_port_init = ar8xxx_port_init;
 303         sc->hal.arswitch_port_vlan_setup = ar8xxx_port_vlan_setup;
 304         sc->hal.arswitch_port_vlan_get = ar8xxx_port_vlan_get;
 305         sc->hal.arswitch_vlan_init_hw = ar8xxx_reset_vlans;
 306
 307         sc->hal.arswitch_vlan_getvgroup = ar8xxx_getvgroup;
 308         sc->hal.arswitch_vlan_setvgroup = ar8xxx_setvgroup;
 309
 310         sc->hal.arswitch_vlan_get_pvid = ar8xxx_get_pvid;
 311         sc->hal.arswitch_vlan_set_pvid = ar8xxx_set_pvid;
 312
 313         sc->hal.arswitch_get_dot1q_vlan = ar8xxx_get_dot1q_vlan;
 314         sc->hal.arswitch_set_dot1q_vlan = ar8xxx_set_dot1q_vlan;
 315         sc->hal.arswitch_flush_dot1q_vlan = ar8xxx_flush_dot1q_vlan;
 316         sc->hal.arswitch_purge_dot1q_vlan = ar8xxx_purge_dot1q_vlan;
 317         sc->hal.arswitch_get_port_vlan = ar8xxx_get_port_vlan;
 318         sc->hal.arswitch_set_port_vlan = ar8xxx_set_port_vlan;
 319
 320         sc->hal.arswitch_atu_flush = ar8xxx_atu_flush;
 321
 322         sc->hal.arswitch_phy_read = arswitch_readphy_internal;
 323         sc->hal.arswitch_phy_write = arswitch_writephy_internal;
 324
 325
 326         /*
 327          * Attach switch related functions
 328          */
 329         if (AR8X16_IS_SWITCH(sc, AR7240))
 330                 ar7240_attach(sc);
 331         else if (AR8X16_IS_SWITCH(sc, AR9340))
 332                 ar9340_attach(sc);
 333         else if (AR8X16_IS_SWITCH(sc, AR8216))
 334                 ar8216_attach(sc);
 335         else if (AR8X16_IS_SWITCH(sc, AR8226))
 336                 ar8226_attach(sc);
 337         else if (AR8X16_IS_SWITCH(sc, AR8316))
 338                 ar8316_attach(sc);
 339         else if (AR8X16_IS_SWITCH(sc, AR8327))
 340                 ar8327_attach(sc);
 341         else {
 342                 DPRINTF(dev, "%s: unknown switch (%d)?\n", __func__, sc->sc_switchtype);
 343                 return (ENXIO);
 344         }
 345
 346         /* Common defaults. */
 347         sc->info.es_nports = 5; /* XXX technically 6, but 6th not used */
 348
 349         /* XXX Defaults for externally connected AR8316 */
 350         sc->numphys = 4;
 351         sc->phy4cpu = 1;
 352         sc->is_rgmii = 1;
 353         sc->is_gmii = 0;
 354         sc->is_mii = 0;
 355
 356         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 357             "numphys", &sc->numphys);
 358         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 359             "phy4cpu", &sc->phy4cpu);
 360         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 361             "is_rgmii", &sc->is_rgmii);
 362         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 363             "is_gmii", &sc->is_gmii);
 364         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 365             "is_mii", &sc->is_mii);
 366
 367         if (sc->numphys > AR8X16_NUM_PHYS)
 368                 sc->numphys = AR8X16_NUM_PHYS;
 369
 370         /* Reset the switch. */
 371         if (arswitch_reset(dev)) {
 372                 DPRINTF(dev, "%s: arswitch_reset: failed\n", __func__);
 373                 return (ENXIO);
 374         }
 375
 376         err = sc->hal.arswitch_hw_setup(sc);
 377         DPRINTF(dev, "%s: hw_setup: err=%d\n", __func__, err);
 378         if (err != 0)
 379                 return (err);
 380
 381         err = sc->hal.arswitch_hw_global_setup(sc);
 382         DPRINTF(dev, "%s: hw_global_setup: err=%d\n", __func__, err);
 383         if (err != 0)
 384                 return (err);
 385
 386         /* Initialize the switch ports. */
 387         for (port = 0; port <= sc->numphys; port++) {
 388                 sc->hal.arswitch_port_init(sc, port);
 389         }
 390
 391         /*
 392          * Attach the PHYs and complete the bus enumeration.
 393          */
 394         err = arswitch_attach_phys(sc);
 395         DPRINTF(dev, "%s: attach_phys: err=%d\n", __func__, err);
 396         if (err != 0)
 397                 return (err);
 398
 399         /* Default to ingress filters off. */
 400         err = arswitch_set_vlan_mode(sc, 0);
 401         DPRINTF(dev, "%s: set_vlan_mode: err=%d\n", __func__, err);
 402         if (err != 0)
 403                 return (err);
 404
 405         bus_generic_probe(dev);
 406         bus_enumerate_hinted_children(dev);
 407         err = bus_generic_attach(dev);
 408         DPRINTF(dev, "%s: bus_generic_attach: err=%d\n", __func__, err);
 409         if (err != 0)
 410                 return (err);
 411
 412         callout_init_mtx(&sc->callout_tick, &sc->sc_mtx, 0);
 413
 414         ARSWITCH_LOCK(sc);
 415         arswitch_tick(sc);
 416         ARSWITCH_UNLOCK(sc);
 417
 418         return (err);
 419 }
 420
 421 static int
 422 arswitch_detach(device_t dev)
 423 {
 424         struct arswitch_softc *sc = device_get_softc(dev);
 425         int i;
 426
 427         callout_drain(&sc->callout_tick);
 428
 429         for (i=0; i < sc->numphys; i++) {
 430                 if (sc->miibus[i] != NULL)
 431                         device_delete_child(dev, sc->miibus[i]);
 432                 if (sc->ifp[i] != NULL)
 433                         if_free(sc->ifp[i]);
 434                 free(sc->ifname[i], M_DEVBUF);
 435         }
 436
 437         bus_generic_detach(dev);
 438         mtx_destroy(&sc->sc_mtx);
 439
 440         return (0);
 441 }
 442
 443 /*
 444  * Convert PHY number to port number. PHY0 is connected to port 1, PHY1 to
 445  * port 2, etc.
 446  */
 447 static inline int
 448 arswitch_portforphy(int phy)
 449 {
 450         return (phy+1);
 451 }
 452
 453 static inline struct mii_data *
 454 arswitch_miiforport(struct arswitch_softc *sc, int port)
 455 {
 456         int phy = port-1;
 457
 458         if (phy < 0 || phy >= sc->numphys)
 459                 return (NULL);
 460         return (device_get_softc(sc->miibus[phy]));
 461 }
 462
 463 static inline struct ifnet *
 464 arswitch_ifpforport(struct arswitch_softc *sc, int port)
 465 {
 466         int phy = port-1;
 467
 468         if (phy < 0 || phy >= sc->numphys)
 469                 return (NULL);
 470         return (sc->ifp[phy]);
 471 }
 472
 473 /*
 474  * Convert port status to ifmedia.
 475  */
 476 static void
 477 arswitch_update_ifmedia(int portstatus, u_int *media_status, u_int *media_active)
 478 {
 479         *media_active = IFM_ETHER;
 480         *media_status = IFM_AVALID;
 481
 482         if ((portstatus & AR8X16_PORT_STS_LINK_UP) != 0)
 483                 *media_status |= IFM_ACTIVE;
 484         else {
 485                 *media_active |= IFM_NONE;
 486                 return;
 487         }
 488         switch (portstatus & AR8X16_PORT_STS_SPEED_MASK) {
 489         case AR8X16_PORT_STS_SPEED_10:
 490                 *media_active |= IFM_10_T;
 491                 break;
 492         case AR8X16_PORT_STS_SPEED_100:
 493                 *media_active |= IFM_100_TX;
 494                 break;
 495         case AR8X16_PORT_STS_SPEED_1000:
 496                 *media_active |= IFM_1000_T;
 497                 break;
 498         }
 499         if ((portstatus & AR8X16_PORT_STS_DUPLEX) == 0)
 500                 *media_active |= IFM_FDX;
 501         else
 502                 *media_active |= IFM_HDX;
 503         if ((portstatus & AR8X16_PORT_STS_TXFLOW) != 0)
 504                 *media_active |= IFM_ETH_TXPAUSE;
 505         if ((portstatus & AR8X16_PORT_STS_RXFLOW) != 0)
 506                 *media_active |= IFM_ETH_RXPAUSE;
 507 }
 508
 509 /*
 510  * Poll the status for all PHYs.  We're using the switch port status because
 511  * thats a lot quicker to read than talking to all the PHYs.  Care must be
 512  * taken that the resulting ifmedia_active is identical to what the PHY will
 513  * compute, or gratuitous link status changes will occur whenever the PHYs
 514  * update function is called.
 515  */
 516 static void
 517 arswitch_miipollstat(struct arswitch_softc *sc)
 518 {
 519         int i;
 520         struct mii_data *mii;
 521         struct mii_softc *miisc;
 522         int portstatus;
 523         int port_flap = 0;
 524
 525         ARSWITCH_LOCK_ASSERT(sc, MA_OWNED);
 526
 527         for (i = 0; i < sc->numphys; i++) {
 528                 if (sc->miibus[i] == NULL)
 529                         continue;
 530                 mii = device_get_softc(sc->miibus[i]);
 531                 /* XXX This would be nice to have abstracted out to be per-chip */
 532                 /* AR8327/AR8337 has a different register base */
 533                 if (AR8X16_IS_SWITCH(sc, AR8327))
 534                         portstatus = arswitch_readreg(sc->sc_dev,
 535                             AR8327_REG_PORT_STATUS(arswitch_portforphy(i)));
 536                 else
 537                         portstatus = arswitch_readreg(sc->sc_dev,
 538                             AR8X16_REG_PORT_STS(arswitch_portforphy(i)));
 539 #if 0
 540                 DPRINTF(sc->sc_dev, "p[%d]=%b\n",
 541                     i,
 542                     portstatus,
 543                     "\20\3TXMAC\4RXMAC\5TXFLOW\6RXFLOW\7"
 544                     "DUPLEX\11LINK_UP\12LINK_AUTO\13LINK_PAUSE");
 545 #endif
 546                 /*
 547                  * If the current status is down, but we have a link
 548                  * status showing up, we need to do an ATU flush.
 549                  */
 550                 if ((mii->mii_media_status & IFM_ACTIVE) == 0 &&
 551                     (portstatus & AR8X16_PORT_STS_LINK_UP) != 0) {
 552                         device_printf(sc->sc_dev, "%s: port %d: port -> UP\n",
 553                             __func__,
 554                             i);
 555                         port_flap = 1;
 556                 }
 557                 /*
 558                  * and maybe if a port goes up->down?
 559                  */
 560                 if ((mii->mii_media_status & IFM_ACTIVE) != 0 &&
 561                     (portstatus & AR8X16_PORT_STS_LINK_UP) == 0) {
 562                         device_printf(sc->sc_dev, "%s: port %d: port -> DOWN\n",
 563                             __func__,
 564                             i);
 565                         port_flap = 1;
 566                 }
 567                 arswitch_update_ifmedia(portstatus, &mii->mii_media_status,
 568                     &mii->mii_media_active);
 569                 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) {
 570                         if (IFM_INST(mii->mii_media.ifm_cur->ifm_media) !=
 571                             miisc->mii_inst)
 572                                 continue;
 573                         mii_phy_update(miisc, MII_POLLSTAT);
 574                 }
 575         }
 576
 577         /* If a port went from down->up, flush the ATU */
 578         if (port_flap)
 579                 sc->hal.arswitch_atu_flush(sc);
 580 }
 581
 582 static void
 583 arswitch_tick(void *arg)
 584 {
 585         struct arswitch_softc *sc = arg;
 586
 587         arswitch_miipollstat(sc);
 588         callout_reset(&sc->callout_tick, hz, arswitch_tick, sc);
 589 }
 590
 591 static void
 592 arswitch_lock(device_t dev)
 593 {
 594         struct arswitch_softc *sc = device_get_softc(dev);
 595
 596         ARSWITCH_LOCK_ASSERT(sc, MA_NOTOWNED);
 597         ARSWITCH_LOCK(sc);
 598 }
 599
 600 static void
 601 arswitch_unlock(device_t dev)
 602 {
 603         struct arswitch_softc *sc = device_get_softc(dev);
 604
 605         ARSWITCH_LOCK_ASSERT(sc, MA_OWNED);
 606         ARSWITCH_UNLOCK(sc);
 607 }
 608
 609 static etherswitch_info_t *
 610 arswitch_getinfo(device_t dev)
 611 {
 612         struct arswitch_softc *sc = device_get_softc(dev);
 613
 614         return (&sc->info);
 615 }
 616
 617 static int
 618 ar8xxx_port_vlan_get(struct arswitch_softc *sc, etherswitch_port_t *p)
 619 {
 620         uint32_t reg;
 621
 622         ARSWITCH_LOCK(sc);
 623
 624         /* Retrieve the PVID. */
 625         sc->hal.arswitch_vlan_get_pvid(sc, p->es_port, &p->es_pvid);
 626
 627         /* Port flags. */
 628         reg = arswitch_readreg(sc->sc_dev, AR8X16_REG_PORT_CTRL(p->es_port));
 629         if (reg & AR8X16_PORT_CTRL_DOUBLE_TAG)
 630                 p->es_flags |= ETHERSWITCH_PORT_DOUBLE_TAG;
 631         reg >>= AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_SHIFT;
 632         if ((reg & 0x3) == AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_ADD)
 633                 p->es_flags |= ETHERSWITCH_PORT_ADDTAG;
 634         if ((reg & 0x3) == AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_STRIP)
 635                 p->es_flags |= ETHERSWITCH_PORT_STRIPTAG;
 636         ARSWITCH_UNLOCK(sc);
 637
 638         return (0);
 639 }
 640
 641 static int
 642 arswitch_is_cpuport(struct arswitch_softc *sc, int port)
 643 {
 644
 645         return ((port == AR8X16_PORT_CPU) ||
 646             ((AR8X16_IS_SWITCH(sc, AR8327) &&
 647               port == AR8327_PORT_GMAC6)));
 648 }
 649
 650 static int
 651 arswitch_getport(device_t dev, etherswitch_port_t *p)
 652 {
 653         struct arswitch_softc *sc;
 654         struct mii_data *mii;
 655         struct ifmediareq *ifmr;
 656         int err;
 657
 658         sc = device_get_softc(dev);
 659         /* XXX +1 is for AR8327; should make this configurable! */
 660         if (p->es_port < 0 || p->es_port > sc->info.es_nports)
 661                 return (ENXIO);
 662
 663         err = sc->hal.arswitch_port_vlan_get(sc, p);
 664         if (err != 0)
 665                 return (err);
 666
 667         mii = arswitch_miiforport(sc, p->es_port);
 668         if (arswitch_is_cpuport(sc, p->es_port)) {
 669                 /* fill in fixed values for CPU port */
 670                 /* XXX is this valid in all cases? */
 671                 p->es_flags |= ETHERSWITCH_PORT_CPU;
 672                 ifmr = &p->es_ifmr;
 673                 ifmr->ifm_count = 0;
 674                 ifmr->ifm_current = ifmr->ifm_active =
 675                     IFM_ETHER | IFM_1000_T | IFM_FDX;
 676                 ifmr->ifm_mask = 0;
 677                 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
 678         } else if (mii != NULL) {
 679                 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr,
 680                     &mii->mii_media, SIOCGIFMEDIA);
 681                 if (err)
 682                         return (err);
 683         } else {
 684                 return (ENXIO);
 685         }
 686         return (0);
 687 }
 688
 689 static int
 690 ar8xxx_port_vlan_setup(struct arswitch_softc *sc, etherswitch_port_t *p)
 691 {
 692         uint32_t reg;
 693         int err;
 694
 695         ARSWITCH_LOCK(sc);
 696
 697         /* Set the PVID. */
 698         if (p->es_pvid != 0)
 699                 sc->hal.arswitch_vlan_set_pvid(sc, p->es_port, p->es_pvid);
 700
 701         /* Mutually exclusive. */
 702         if (p->es_flags & ETHERSWITCH_PORT_ADDTAG &&
 703             p->es_flags & ETHERSWITCH_PORT_STRIPTAG) {
 704                 ARSWITCH_UNLOCK(sc);
 705                 return (EINVAL);
 706         }
 707
 708         reg = 0;
 709         if (p->es_flags & ETHERSWITCH_PORT_DOUBLE_TAG)
 710                 reg |= AR8X16_PORT_CTRL_DOUBLE_TAG;
 711         if (p->es_flags & ETHERSWITCH_PORT_ADDTAG)
 712                 reg |= AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_ADD <<
 713                     AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_SHIFT;
 714         if (p->es_flags & ETHERSWITCH_PORT_STRIPTAG)
 715                 reg |= AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_STRIP <<
 716                     AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_SHIFT;
 717
 718         err = arswitch_modifyreg(sc->sc_dev,
 719             AR8X16_REG_PORT_CTRL(p->es_port),
 720             0x3 << AR8X16_PORT_CTRL_EGRESS_VLAN_MODE_SHIFT |
 721             AR8X16_PORT_CTRL_DOUBLE_TAG, reg);
 722
 723         ARSWITCH_UNLOCK(sc);
 724         return (err);
 725 }
 726
 727 static int
 728 arswitch_setport(device_t dev, etherswitch_port_t *p)
 729 {
 730         int err;
 731         struct arswitch_softc *sc;
 732         struct ifmedia *ifm;
 733         struct mii_data *mii;
 734         struct ifnet *ifp;
 735
 736         sc = device_get_softc(dev);
 737         if (p->es_port < 0 || p->es_port > sc->info.es_nports)
 738                 return (ENXIO);
 739
 740         /* Port flags. */
 741         if (sc->vlan_mode == ETHERSWITCH_VLAN_DOT1Q) {
 742                 err = sc->hal.arswitch_port_vlan_setup(sc, p);
 743                 if (err)
 744                         return (err);
 745         }
 746
 747         /* Do not allow media changes on CPU port. */
 748         if (arswitch_is_cpuport(sc, p->es_port))
 749                 return (0);
 750
 751         mii = arswitch_miiforport(sc, p->es_port);
 752         if (mii == NULL)
 753                 return (ENXIO);
 754
 755         ifp = arswitch_ifpforport(sc, p->es_port);
 756
 757         ifm = &mii->mii_media;
 758         return (ifmedia_ioctl(ifp, &p->es_ifr, ifm, SIOCSIFMEDIA));
 759 }
 760
 761 static void
 762 arswitch_statchg(device_t dev)
 763 {
 764
 765         DPRINTF(dev, "%s\n", __func__);
 766 }
 767
 768 static int
 769 arswitch_ifmedia_upd(struct ifnet *ifp)
 770 {
 771         struct arswitch_softc *sc = ifp->if_softc;
 772         struct mii_data *mii = arswitch_miiforport(sc, ifp->if_dunit);
 773
 774         if (mii == NULL)
 775                 return (ENXIO);
 776         mii_mediachg(mii);
 777         return (0);
 778 }
 779
 780 static void
 781 arswitch_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 782 {
 783         struct arswitch_softc *sc = ifp->if_softc;
 784         struct mii_data *mii = arswitch_miiforport(sc, ifp->if_dunit);
 785
 786         DPRINTF(sc->sc_dev, "%s\n", __func__);
 787
 788         if (mii == NULL)
 789                 return;
 790         mii_pollstat(mii);
 791         ifmr->ifm_active = mii->mii_media_active;
 792         ifmr->ifm_status = mii->mii_media_status;
 793 }
 794
 795 static int
 796 arswitch_getconf(device_t dev, etherswitch_conf_t *conf)
 797 {
 798         struct arswitch_softc *sc;
 799
 800         sc = device_get_softc(dev);
 801
 802         /* Return the VLAN mode. */
 803         conf->cmd = ETHERSWITCH_CONF_VLAN_MODE;
 804         conf->vlan_mode = sc->vlan_mode;
 805
 806         return (0);
 807 }
 808
 809 static int
 810 arswitch_setconf(device_t dev, etherswitch_conf_t *conf)
 811 {
 812         struct arswitch_softc *sc;
 813         int err;
 814
 815         sc = device_get_softc(dev);
 816
 817         /* Set the VLAN mode. */
 818         if (conf->cmd & ETHERSWITCH_CONF_VLAN_MODE) {
 819                 err = arswitch_set_vlan_mode(sc, conf->vlan_mode);
 820                 if (err != 0)
 821                         return (err);
 822         }
 823
 824         return (0);
 825 }
 826
 827 static int
 828 arswitch_getvgroup(device_t dev, etherswitch_vlangroup_t *e)
 829 {
 830         struct arswitch_softc *sc = device_get_softc(dev);
 831
 832         return (sc->hal.arswitch_vlan_getvgroup(sc, e));
 833 }
 834
 835 static int
 836 arswitch_setvgroup(device_t dev, etherswitch_vlangroup_t *e)
 837 {
 838         struct arswitch_softc *sc = device_get_softc(dev);
 839
 840         return (sc->hal.arswitch_vlan_setvgroup(sc, e));
 841 }
 842
 843 static int
 844 arswitch_readphy(device_t dev, int phy, int reg)
 845 {
 846         struct arswitch_softc *sc = device_get_softc(dev);
 847
 848         return (sc->hal.arswitch_phy_read(dev, phy, reg));
 849 }
 850
 851 static int
 852 arswitch_writephy(device_t dev, int phy, int reg, int val)
 853 {
 854         struct arswitch_softc *sc = device_get_softc(dev);
 855
 856         return (sc->hal.arswitch_phy_write(dev, phy, reg, val));
 857 }
 858
 859 static device_method_t arswitch_methods[] = {
 860         /* Device interface */
 861         DEVMETHOD(device_probe,         arswitch_probe),
 862         DEVMETHOD(device_attach,        arswitch_attach),
 863         DEVMETHOD(device_detach,        arswitch_detach),
 864
 865         /* bus interface */
 866         DEVMETHOD(bus_add_child,        device_add_child_ordered),
 867
 868         /* MII interface */
 869         DEVMETHOD(miibus_readreg,       arswitch_readphy),
 870         DEVMETHOD(miibus_writereg,      arswitch_writephy),
 871         DEVMETHOD(miibus_statchg,       arswitch_statchg),
 872
 873         /* MDIO interface */
 874         DEVMETHOD(mdio_readreg,         arswitch_readphy),
 875         DEVMETHOD(mdio_writereg,        arswitch_writephy),
 876
 877         /* etherswitch interface */
 878         DEVMETHOD(etherswitch_lock,     arswitch_lock),
 879         DEVMETHOD(etherswitch_unlock,   arswitch_unlock),
 880         DEVMETHOD(etherswitch_getinfo,  arswitch_getinfo),
 881         DEVMETHOD(etherswitch_readreg,  arswitch_readreg),
 882         DEVMETHOD(etherswitch_writereg, arswitch_writereg),
 883         DEVMETHOD(etherswitch_readphyreg,       arswitch_readphy),
 884         DEVMETHOD(etherswitch_writephyreg,      arswitch_writephy),
 885         DEVMETHOD(etherswitch_getport,  arswitch_getport),
 886         DEVMETHOD(etherswitch_setport,  arswitch_setport),
 887         DEVMETHOD(etherswitch_getvgroup,        arswitch_getvgroup),
 888         DEVMETHOD(etherswitch_setvgroup,        arswitch_setvgroup),
 889         DEVMETHOD(etherswitch_getconf,  arswitch_getconf),
 890         DEVMETHOD(etherswitch_setconf,  arswitch_setconf),
 891
 892         DEVMETHOD_END
 893 };
 894
 895 DEFINE_CLASS_0(arswitch, arswitch_driver, arswitch_methods,
 896     sizeof(struct arswitch_softc));
 897 static devclass_t arswitch_devclass;
 898
 899 DRIVER_MODULE(arswitch, mdio, arswitch_driver, arswitch_devclass, 0, 0);
 900 DRIVER_MODULE(miibus, arswitch, miibus_driver, miibus_devclass, 0, 0);
 901 DRIVER_MODULE(mdio, arswitch, mdio_driver, mdio_devclass, 0, 0);
 902 DRIVER_MODULE(etherswitch, arswitch, etherswitch_driver, etherswitch_devclass, 0, 0);
 903 MODULE_VERSION(arswitch, 1);
 904 MODULE_DEPEND(arswitch, miibus, 1, 1, 1); /* XXX which versions? */
 905 MODULE_DEPEND(arswitch, etherswitch, 1, 1, 1); /* XXX which versions? */