sys/dev/etherswitch/e6000sw/e6000sw.c

   1 /*-
   2  * Copyright (c) 2015 Semihalf
   3  * Copyright (c) 2015 Stormshield
   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
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/bus.h>
  33 #include <sys/errno.h>
  34 #include <sys/kernel.h>
  35 #include <sys/kthread.h>
  36 #include <sys/module.h>
  37 #include <sys/socket.h>
  38 #include <sys/sockio.h>
  39
  40 #include <net/if.h>
  41 #include <net/if_media.h>
  42 #include <net/if_types.h>
  43
  44 #include <dev/etherswitch/etherswitch.h>
  45 #include <dev/mii/mii.h>
  46 #include <dev/mii/miivar.h>
  47
  48 #include <dev/ofw/ofw_bus.h>
  49 #include <dev/ofw/ofw_bus_subr.h>
  50
  51 #include "e6000swreg.h"
  52 #include "etherswitch_if.h"
  53 #include "miibus_if.h"
  54 #include "mdio_if.h"
  55
  56 MALLOC_DECLARE(M_E6000SW);
  57 MALLOC_DEFINE(M_E6000SW, "e6000sw", "e6000sw switch");
  58
  59 #define E6000SW_LOCK(_sc)               sx_xlock(&(_sc)->sx)
  60 #define E6000SW_UNLOCK(_sc)             sx_unlock(&(_sc)->sx)
  61 #define E6000SW_LOCK_ASSERT(_sc, _what) sx_assert(&(_sc)->sx, (_what))
  62 #define E6000SW_TRYLOCK(_sc)            sx_tryxlock(&(_sc)->sx)
  63
  64 typedef struct e6000sw_softc {
  65         device_t                dev;
  66         phandle_t               node;
  67
  68         struct sx               sx;
  69         struct ifnet            *ifp[E6000SW_MAX_PORTS];
  70         char                    *ifname[E6000SW_MAX_PORTS];
  71         device_t                miibus[E6000SW_MAX_PORTS];
  72         struct proc             *kproc;
  73
  74         uint32_t                swid;
  75         uint32_t                vlan_mode;
  76         uint32_t                cpuports_mask;
  77         uint32_t                fixed_mask;
  78         uint32_t                fixed25_mask;
  79         uint32_t                ports_mask;
  80         int                     phy_base;
  81         int                     sw_addr;
  82         int                     num_ports;
  83         boolean_t               multi_chip;
  84 } e6000sw_softc_t;
  85
  86 static etherswitch_info_t etherswitch_info = {
  87         .es_nports =            0,
  88         .es_nvlangroups =       0,
  89         .es_vlan_caps =         ETHERSWITCH_VLAN_PORT,
  90         .es_name =              "Marvell 6000 series switch"
  91 };
  92
  93 static void e6000sw_identify(driver_t *, device_t);
  94 static int e6000sw_probe(device_t);
  95 static int e6000sw_parse_fixed_link(e6000sw_softc_t *, phandle_t, uint32_t);
  96 static int e6000sw_parse_ethernet(e6000sw_softc_t *, phandle_t, uint32_t);
  97 static int e6000sw_attach(device_t);
  98 static int e6000sw_detach(device_t);
  99 static int e6000sw_readphy(device_t, int, int);
 100 static int e6000sw_writephy(device_t, int, int, int);
 101 static etherswitch_info_t* e6000sw_getinfo(device_t);
 102 static int e6000sw_getconf(device_t, etherswitch_conf_t *);
 103 static void e6000sw_lock(device_t);
 104 static void e6000sw_unlock(device_t);
 105 static int e6000sw_getport(device_t, etherswitch_port_t *);
 106 static int e6000sw_setport(device_t, etherswitch_port_t *);
 107 static int e6000sw_readreg_wrapper(device_t, int);
 108 static int e6000sw_writereg_wrapper(device_t, int, int);
 109 static int e6000sw_readphy_wrapper(device_t, int, int);
 110 static int e6000sw_writephy_wrapper(device_t, int, int, int);
 111 static int e6000sw_getvgroup_wrapper(device_t, etherswitch_vlangroup_t *);
 112 static int e6000sw_setvgroup_wrapper(device_t, etherswitch_vlangroup_t *);
 113 static int e6000sw_setvgroup(device_t, etherswitch_vlangroup_t *);
 114 static int e6000sw_getvgroup(device_t, etherswitch_vlangroup_t *);
 115 static void e6000sw_setup(device_t, e6000sw_softc_t *);
 116 static void e6000sw_port_vlan_conf(e6000sw_softc_t *);
 117 static void e6000sw_tick(void *);
 118 static void e6000sw_set_atustat(device_t, e6000sw_softc_t *, int, int);
 119 static int e6000sw_atu_flush(device_t, e6000sw_softc_t *, int);
 120 static __inline void e6000sw_writereg(e6000sw_softc_t *, int, int, int);
 121 static __inline uint32_t e6000sw_readreg(e6000sw_softc_t *, int, int);
 122 static int e6000sw_ifmedia_upd(struct ifnet *);
 123 static void e6000sw_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 124 static int e6000sw_atu_mac_table(device_t, e6000sw_softc_t *, struct atu_opt *,
 125     int);
 126 static int e6000sw_get_pvid(e6000sw_softc_t *, int, int *);
 127 static int e6000sw_set_pvid(e6000sw_softc_t *, int, int);
 128 static __inline bool e6000sw_is_cpuport(e6000sw_softc_t *, int);
 129 static __inline bool e6000sw_is_fixedport(e6000sw_softc_t *, int);
 130 static __inline bool e6000sw_is_fixed25port(e6000sw_softc_t *, int);
 131 static __inline bool e6000sw_is_phyport(e6000sw_softc_t *, int);
 132 static __inline bool e6000sw_is_portenabled(e6000sw_softc_t *, int);
 133 static __inline struct mii_data *e6000sw_miiforphy(e6000sw_softc_t *,
 134     unsigned int);
 135
 136 static device_method_t e6000sw_methods[] = {
 137         /* device interface */
 138         DEVMETHOD(device_identify,              e6000sw_identify),
 139         DEVMETHOD(device_probe,                 e6000sw_probe),
 140         DEVMETHOD(device_attach,                e6000sw_attach),
 141         DEVMETHOD(device_detach,                e6000sw_detach),
 142
 143         /* bus interface */
 144         DEVMETHOD(bus_add_child,                device_add_child_ordered),
 145
 146         /* mii interface */
 147         DEVMETHOD(miibus_readreg,               e6000sw_readphy),
 148         DEVMETHOD(miibus_writereg,              e6000sw_writephy),
 149
 150         /* etherswitch interface */
 151         DEVMETHOD(etherswitch_getinfo,          e6000sw_getinfo),
 152         DEVMETHOD(etherswitch_getconf,          e6000sw_getconf),
 153         DEVMETHOD(etherswitch_lock,             e6000sw_lock),
 154         DEVMETHOD(etherswitch_unlock,           e6000sw_unlock),
 155         DEVMETHOD(etherswitch_getport,          e6000sw_getport),
 156         DEVMETHOD(etherswitch_setport,          e6000sw_setport),
 157         DEVMETHOD(etherswitch_readreg,          e6000sw_readreg_wrapper),
 158         DEVMETHOD(etherswitch_writereg,         e6000sw_writereg_wrapper),
 159         DEVMETHOD(etherswitch_readphyreg,       e6000sw_readphy_wrapper),
 160         DEVMETHOD(etherswitch_writephyreg,      e6000sw_writephy_wrapper),
 161         DEVMETHOD(etherswitch_setvgroup,        e6000sw_setvgroup_wrapper),
 162         DEVMETHOD(etherswitch_getvgroup,        e6000sw_getvgroup_wrapper),
 163
 164         DEVMETHOD_END
 165 };
 166
 167 static devclass_t e6000sw_devclass;
 168
 169 DEFINE_CLASS_0(e6000sw, e6000sw_driver, e6000sw_methods,
 170     sizeof(e6000sw_softc_t));
 171
 172 DRIVER_MODULE(e6000sw, mdio, e6000sw_driver, e6000sw_devclass, 0, 0);
 173 DRIVER_MODULE(etherswitch, e6000sw, etherswitch_driver, etherswitch_devclass, 0,
 174     0);
 175 DRIVER_MODULE(miibus, e6000sw, miibus_driver, miibus_devclass, 0, 0);
 176 MODULE_DEPEND(e6000sw, mdio, 1, 1, 1);
 177
 178 #define SMI_CMD                 0
 179 #define SMI_CMD_BUSY            (1 << 15)
 180 #define SMI_CMD_OP_READ         ((2 << 10) | SMI_CMD_BUSY | (1 << 12))
 181 #define SMI_CMD_OP_WRITE        ((1 << 10) | SMI_CMD_BUSY | (1 << 12))
 182 #define SMI_DATA                1
 183
 184 #define MDIO_READ(dev, addr, reg)                                       \
 185         MDIO_READREG(device_get_parent(dev), (addr), (reg))
 186 #define MDIO_WRITE(dev, addr, reg, val)                                 \
 187         MDIO_WRITEREG(device_get_parent(dev), (addr), (reg), (val))
 188
 189 static void
 190 e6000sw_identify(driver_t *driver, device_t parent)
 191 {
 192
 193         if (device_find_child(parent, "e6000sw", -1) == NULL)
 194                 BUS_ADD_CHILD(parent, 0, "e6000sw", -1);
 195 }
 196
 197 static int
 198 e6000sw_probe(device_t dev)
 199 {
 200         e6000sw_softc_t *sc;
 201         const char *description;
 202         phandle_t switch_node;
 203
 204         switch_node = ofw_bus_find_compatible(OF_finddevice("/"),
 205             "marvell,mv88e6085");
 206
 207         if (switch_node == 0)
 208                 return (ENXIO);
 209
 210         if (bootverbose)
 211                 device_printf(dev, "Found switch_node: 0x%x\n", switch_node);
 212
 213         sc = device_get_softc(dev);
 214         sc->dev = dev;
 215         sc->node = switch_node;
 216
 217         if (OF_getencprop(sc->node, "reg", &sc->sw_addr,
 218             sizeof(sc->sw_addr)) < 0)
 219                 return (ENXIO);
 220
 221         /*
 222          * According to the Linux source code, all of the Switch IDs we support
 223          * are multi_chip capable, and should go into multi-chip mode if the
 224          * sw_addr != 0.
 225          */
 226         if (!OF_hasprop(sc->node, "single-chip-addressing") && sc->sw_addr != 0)
 227                 sc->multi_chip = true;
 228
 229         /*
 230          * Create temporary lock, just to satisfy assertions,
 231          * when obtaining the switch ID. Destroy immediately afterwards.
 232          */
 233         sx_init(&sc->sx, "e6000sw_tmp");
 234         E6000SW_LOCK(sc);
 235         sc->swid = e6000sw_readreg(sc, REG_PORT(0), SWITCH_ID) & 0xfff0;
 236         E6000SW_UNLOCK(sc);
 237         sx_destroy(&sc->sx);
 238
 239         switch (sc->swid) {
 240         case MV88E6141:
 241                 description = "Marvell 88E6141";
 242                 sc->phy_base = 0x10;
 243                 sc->num_ports = 6;
 244                 break;
 245         case MV88E6341:
 246                 description = "Marvell 88E6341";
 247                 sc->phy_base = 0x10;
 248                 sc->num_ports = 6;
 249                 break;
 250         case MV88E6352:
 251                 description = "Marvell 88E6352";
 252                 sc->num_ports = 7;
 253                 break;
 254         case MV88E6172:
 255                 description = "Marvell 88E6172";
 256                 sc->num_ports = 7;
 257                 break;
 258         case MV88E6176:
 259                 description = "Marvell 88E6176";
 260                 sc->num_ports = 7;
 261                 break;
 262         default:
 263                 device_printf(dev, "Unrecognized device, id 0x%x.\n", sc->swid);
 264                 return (ENXIO);
 265         }
 266
 267         device_set_desc(dev, description);
 268
 269         return (BUS_PROBE_DEFAULT);
 270 }
 271
 272 static int
 273 e6000sw_parse_fixed_link(e6000sw_softc_t *sc, phandle_t node, uint32_t port)
 274 {
 275         int speed;
 276         phandle_t fixed_link;
 277
 278         fixed_link = ofw_bus_find_child(node, "fixed-link");
 279
 280         if (fixed_link != 0) {
 281                 sc->fixed_mask |= (1 << port);
 282
 283                 if (OF_getencprop(fixed_link, "speed", &speed, sizeof(speed))> 0) {
 284                         if (speed == 2500 &&
 285                             (MVSWITCH(sc, MV88E6141) ||
 286                              MVSWITCH(sc, MV88E6341)))
 287                                 sc->fixed25_mask |= (1 << port);
 288                 } else {
 289                     device_printf(sc->dev,
 290                             "Port %d has a fixed-link node without a speed "
 291                             "property\n", port);
 292
 293                     return (ENXIO);
 294                 }
 295         }
 296
 297         return (0);
 298 }
 299
 300 static int
 301 e6000sw_parse_ethernet(e6000sw_softc_t *sc, phandle_t port_handle, uint32_t port) {
 302         phandle_t switch_eth, switch_eth_handle;
 303
 304         if (OF_getencprop(port_handle, "ethernet", (void*)&switch_eth_handle,
 305             sizeof(switch_eth_handle)) > 0) {
 306                 if (switch_eth_handle > 0) {
 307                         switch_eth = OF_node_from_xref(switch_eth_handle);
 308
 309                         device_printf(sc->dev, "CPU port at %d\n", port);
 310                         sc->cpuports_mask |= (1 << port);
 311
 312                         return (e6000sw_parse_fixed_link(sc, switch_eth, port));
 313                 } else
 314                         device_printf(sc->dev,
 315                                 "Port %d has ethernet property but it points "
 316                                 "to an invalid location\n", port);
 317         }
 318
 319         return (0);
 320 }
 321
 322 static int
 323 e6000sw_parse_child_fdt(e6000sw_softc_t *sc, phandle_t child, int *pport)
 324 {
 325         uint32_t port;
 326
 327         if (pport == NULL)
 328                 return (ENXIO);
 329
 330         if (OF_getencprop(child, "reg", (void *)&port, sizeof(port)) < 0)
 331                 return (ENXIO);
 332         if (port >= sc->num_ports)
 333                 return (ENXIO);
 334         *pport = port;
 335
 336         if (e6000sw_parse_fixed_link(sc, child, port) != 0)
 337                 return (ENXIO);
 338
 339         if (e6000sw_parse_ethernet(sc, child, port) != 0)
 340                 return (ENXIO);
 341
 342         if ((sc->fixed_mask & (1 << port)) != 0)
 343                 device_printf(sc->dev, "fixed port at %d\n", port);
 344         else
 345                 device_printf(sc->dev, "PHY at port %d\n", port);
 346
 347         return (0);
 348 }
 349
 350 static int
 351 e6000sw_init_interface(e6000sw_softc_t *sc, int port)
 352 {
 353         char name[IFNAMSIZ];
 354
 355         snprintf(name, IFNAMSIZ, "%sport", device_get_nameunit(sc->dev));
 356
 357         sc->ifp[port] = if_alloc(IFT_ETHER);
 358         if (sc->ifp[port] == NULL)
 359                 return (ENOMEM);
 360         sc->ifp[port]->if_softc = sc;
 361         sc->ifp[port]->if_flags |= IFF_UP | IFF_BROADCAST |
 362             IFF_DRV_RUNNING | IFF_SIMPLEX;
 363         sc->ifname[port] = malloc(strlen(name) + 1, M_E6000SW, M_NOWAIT);
 364         if (sc->ifname[port] == NULL) {
 365                 if_free(sc->ifp[port]);
 366                 return (ENOMEM);
 367         }
 368         memcpy(sc->ifname[port], name, strlen(name) + 1);
 369         if_initname(sc->ifp[port], sc->ifname[port], port);
 370
 371         return (0);
 372 }
 373
 374 static int
 375 e6000sw_attach_miibus(e6000sw_softc_t *sc, int port)
 376 {
 377         int err;
 378
 379         err = mii_attach(sc->dev, &sc->miibus[port], sc->ifp[port],
 380             e6000sw_ifmedia_upd, e6000sw_ifmedia_sts, BMSR_DEFCAPMASK,
 381             port + sc->phy_base, MII_OFFSET_ANY, 0);
 382         if (err != 0)
 383                 return (err);
 384
 385         return (0);
 386 }
 387
 388 static int
 389 e6000sw_attach(device_t dev)
 390 {
 391         e6000sw_softc_t *sc;
 392         phandle_t child, ports;
 393         int err, port;
 394         uint32_t reg;
 395
 396         err = 0;
 397         sc = device_get_softc(dev);
 398
 399         if (sc->multi_chip)
 400                 device_printf(dev, "multi-chip addressing mode\n");
 401         else
 402                 device_printf(dev, "single-chip addressing mode\n");
 403
 404         sx_init(&sc->sx, "e6000sw");
 405
 406         E6000SW_LOCK(sc);
 407         e6000sw_setup(dev, sc);
 408
 409         ports = ofw_bus_find_child(sc->node, "ports");
 410
 411         if (ports == 0) {
 412                 device_printf(dev, "failed to parse DTS: no ports found for "
 413                     "switch\n");
 414                 return (ENXIO);
 415         }
 416
 417         for (child = OF_child(ports); child != 0; child = OF_peer(child)) {
 418                 err = e6000sw_parse_child_fdt(sc, child, &port);
 419                 if (err != 0) {
 420                         device_printf(sc->dev, "failed to parse DTS\n");
 421                         goto out_fail;
 422                 }
 423
 424                 /* Port is in use. */
 425                 sc->ports_mask |= (1 << port);
 426
 427                 err = e6000sw_init_interface(sc, port);
 428                 if (err != 0) {
 429                         device_printf(sc->dev, "failed to init interface\n");
 430                         goto out_fail;
 431                 }
 432
 433                 if (e6000sw_is_fixedport(sc, port)) {
 434                         /* Link must be down to change speed force value. */
 435                         reg = e6000sw_readreg(sc, REG_PORT(port), PSC_CONTROL);
 436                         reg &= ~PSC_CONTROL_LINK_UP;
 437                         reg |= PSC_CONTROL_FORCED_LINK;
 438                         e6000sw_writereg(sc, REG_PORT(port), PSC_CONTROL, reg);
 439
 440                         /*
 441                          * Force speed, full-duplex, EEE off and flow-control
 442                          * on.
 443                          */
 444                         reg &= ~(PSC_CONTROL_SPD2500 | PSC_CONTROL_ALT_SPD |
 445                             PSC_CONTROL_FORCED_EEE);
 446                         if (e6000sw_is_fixed25port(sc, port))
 447                                 reg |= PSC_CONTROL_SPD2500;
 448                         else
 449                                 reg |= PSC_CONTROL_SPD1000;
 450                         reg |= PSC_CONTROL_FORCED_DPX | PSC_CONTROL_FULLDPX |
 451                             PSC_CONTROL_FORCED_LINK | PSC_CONTROL_LINK_UP |
 452                             PSC_CONTROL_FORCED_FC | PSC_CONTROL_FC_ON |
 453                             PSC_CONTROL_FORCED_SPD;
 454                         if (MVSWITCH(sc, MV88E6141) || MVSWITCH(sc, MV88E6341))
 455                             reg |= PSC_CONTROL_FORCED_EEE;
 456                         e6000sw_writereg(sc, REG_PORT(port), PSC_CONTROL, reg);
 457                 }
 458
 459                 /* Don't attach miibus at CPU/fixed ports */
 460                 if (!e6000sw_is_phyport(sc, port))
 461                         continue;
 462
 463                 err = e6000sw_attach_miibus(sc, port);
 464                 if (err != 0) {
 465                         device_printf(sc->dev, "failed to attach miibus\n");
 466                         goto out_fail;
 467                 }
 468         }
 469
 470         etherswitch_info.es_nports = sc->num_ports;
 471
 472         /* Default to port vlan. */
 473         e6000sw_port_vlan_conf(sc);
 474         E6000SW_UNLOCK(sc);
 475
 476         bus_generic_probe(dev);
 477         bus_generic_attach(dev);
 478
 479         kproc_create(e6000sw_tick, sc, &sc->kproc, 0, 0, "e6000sw tick kproc");
 480
 481         return (0);
 482
 483 out_fail:
 484         E6000SW_UNLOCK(sc);
 485         e6000sw_detach(dev);
 486
 487         return (err);
 488 }
 489
 490 static __inline int
 491 e6000sw_poll_done(e6000sw_softc_t *sc)
 492 {
 493         int i;
 494
 495         for (i = 0; i < E6000SW_SMI_TIMEOUT; i++) {
 496
 497                 if ((e6000sw_readreg(sc, REG_GLOBAL2, SMI_PHY_CMD_REG) &
 498                     (1 << PHY_CMD_SMI_BUSY)) == 0)
 499                         return (0);
 500
 501                 pause("e6000sw PHY poll", hz/1000);
 502         }
 503
 504         return (ETIMEDOUT);
 505 }
 506
 507 /*
 508  * PHY registers are paged. Put page index in reg 22 (accessible from every
 509  * page), then access specific register.
 510  */
 511 static int
 512 e6000sw_readphy(device_t dev, int phy, int reg)
 513 {
 514         e6000sw_softc_t *sc;
 515         uint32_t val;
 516         int err;
 517
 518         sc = device_get_softc(dev);
 519         if (!e6000sw_is_phyport(sc, phy) || reg >= E6000SW_NUM_PHY_REGS) {
 520                 device_printf(dev, "Wrong register address.\n");
 521                 return (EINVAL);
 522         }
 523
 524         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 525
 526         err = e6000sw_poll_done(sc);
 527         if (err != 0) {
 528                 device_printf(dev, "Timeout while waiting for switch\n");
 529                 return (err);
 530         }
 531
 532         val = 1 << PHY_CMD_SMI_BUSY;
 533         val |= PHY_CMD_MODE_MDIO << PHY_CMD_MODE;
 534         val |= PHY_CMD_OPCODE_READ << PHY_CMD_OPCODE;
 535         val |= (reg << PHY_CMD_REG_ADDR) & PHY_CMD_REG_ADDR_MASK;
 536         val |= (phy << PHY_CMD_DEV_ADDR) & PHY_CMD_DEV_ADDR_MASK;
 537         e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_CMD_REG, val);
 538
 539         err = e6000sw_poll_done(sc);
 540         if (err != 0) {
 541                 device_printf(dev, "Timeout while waiting for switch\n");
 542                 return (err);
 543         }
 544
 545         val = e6000sw_readreg(sc, REG_GLOBAL2, SMI_PHY_DATA_REG);
 546
 547         return (val & PHY_DATA_MASK);
 548 }
 549
 550 static int
 551 e6000sw_writephy(device_t dev, int phy, int reg, int data)
 552 {
 553         e6000sw_softc_t *sc;
 554         uint32_t val;
 555         int err;
 556
 557         sc = device_get_softc(dev);
 558         if (!e6000sw_is_phyport(sc, phy) || reg >= E6000SW_NUM_PHY_REGS) {
 559                 device_printf(dev, "Wrong register address.\n");
 560                 return (EINVAL);
 561         }
 562
 563         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 564
 565         err = e6000sw_poll_done(sc);
 566         if (err != 0) {
 567                 device_printf(dev, "Timeout while waiting for switch\n");
 568                 return (err);
 569         }
 570
 571         val = 1 << PHY_CMD_SMI_BUSY;
 572         val |= PHY_CMD_MODE_MDIO << PHY_CMD_MODE;
 573         val |= PHY_CMD_OPCODE_WRITE << PHY_CMD_OPCODE;
 574         val |= (reg << PHY_CMD_REG_ADDR) & PHY_CMD_REG_ADDR_MASK;
 575         val |= (phy << PHY_CMD_DEV_ADDR) & PHY_CMD_DEV_ADDR_MASK;
 576         e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_DATA_REG,
 577             data & PHY_DATA_MASK);
 578         e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_CMD_REG, val);
 579
 580         err = e6000sw_poll_done(sc);
 581         if (err != 0)
 582                 device_printf(dev, "Timeout while waiting for switch\n");
 583
 584         return (err);
 585 }
 586
 587 static int
 588 e6000sw_detach(device_t dev)
 589 {
 590         int phy;
 591         e6000sw_softc_t *sc;
 592
 593         sc = device_get_softc(dev);
 594         bus_generic_detach(dev);
 595         sx_destroy(&sc->sx);
 596         for (phy = 0; phy < sc->num_ports; phy++) {
 597                 if (sc->miibus[phy] != NULL)
 598                         device_delete_child(dev, sc->miibus[phy]);
 599                 if (sc->ifp[phy] != NULL)
 600                         if_free(sc->ifp[phy]);
 601                 if (sc->ifname[phy] != NULL)
 602                         free(sc->ifname[phy], M_E6000SW);
 603         }
 604
 605         return (0);
 606 }
 607
 608 static etherswitch_info_t*
 609 e6000sw_getinfo(device_t dev)
 610 {
 611
 612         return (&etherswitch_info);
 613 }
 614
 615 static int
 616 e6000sw_getconf(device_t dev, etherswitch_conf_t *conf)
 617 {
 618         struct e6000sw_softc *sc;
 619
 620         /* Return the VLAN mode. */
 621         sc = device_get_softc(dev);
 622         conf->cmd = ETHERSWITCH_CONF_VLAN_MODE;
 623         conf->vlan_mode = sc->vlan_mode;
 624
 625         return (0);
 626 }
 627
 628 static void
 629 e6000sw_lock(device_t dev)
 630 {
 631         struct e6000sw_softc *sc;
 632
 633         sc = device_get_softc(dev);
 634
 635         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 636         E6000SW_LOCK(sc);
 637 }
 638
 639 static void
 640 e6000sw_unlock(device_t dev)
 641 {
 642         struct e6000sw_softc *sc;
 643
 644         sc = device_get_softc(dev);
 645
 646         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 647         E6000SW_UNLOCK(sc);
 648 }
 649
 650 static int
 651 e6000sw_getport(device_t dev, etherswitch_port_t *p)
 652 {
 653         struct mii_data *mii;
 654         int err;
 655         struct ifmediareq *ifmr;
 656
 657         e6000sw_softc_t *sc = device_get_softc(dev);
 658         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 659
 660         if (p->es_port >= sc->num_ports || p->es_port < 0)
 661                 return (EINVAL);
 662         if (!e6000sw_is_portenabled(sc, p->es_port))
 663                 return (0);
 664
 665         err = 0;
 666         E6000SW_LOCK(sc);
 667         e6000sw_get_pvid(sc, p->es_port, &p->es_pvid);
 668
 669         if (e6000sw_is_fixedport(sc, p->es_port)) {
 670                 if (e6000sw_is_cpuport(sc, p->es_port))
 671                         p->es_flags |= ETHERSWITCH_PORT_CPU;
 672                 ifmr = &p->es_ifmr;
 673                 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
 674                 ifmr->ifm_count = 0;
 675                 if (e6000sw_is_fixed25port(sc, p->es_port))
 676                         ifmr->ifm_active = IFM_2500_T;
 677                 else
 678                         ifmr->ifm_active = IFM_1000_T;
 679                 ifmr->ifm_active |= IFM_ETHER | IFM_FDX;
 680                 ifmr->ifm_current = ifmr->ifm_active;
 681                 ifmr->ifm_mask = 0;
 682         } else {
 683                 mii = e6000sw_miiforphy(sc, p->es_port);
 684                 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr,
 685                     &mii->mii_media, SIOCGIFMEDIA);
 686         }
 687         E6000SW_UNLOCK(sc);
 688
 689         return (err);
 690 }
 691
 692 static int
 693 e6000sw_setport(device_t dev, etherswitch_port_t *p)
 694 {
 695         e6000sw_softc_t *sc;
 696         int err;
 697         struct mii_data *mii;
 698
 699         sc = device_get_softc(dev);
 700         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 701
 702         if (p->es_port >= sc->num_ports || p->es_port < 0)
 703                 return (EINVAL);
 704         if (!e6000sw_is_portenabled(sc, p->es_port))
 705                 return (0);
 706
 707         err = 0;
 708         E6000SW_LOCK(sc);
 709         if (p->es_pvid != 0)
 710                 e6000sw_set_pvid(sc, p->es_port, p->es_pvid);
 711         if (e6000sw_is_phyport(sc, p->es_port)) {
 712                 mii = e6000sw_miiforphy(sc, p->es_port);
 713                 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr, &mii->mii_media,
 714                     SIOCSIFMEDIA);
 715         }
 716         E6000SW_UNLOCK(sc);
 717
 718         return (err);
 719 }
 720
 721 /*
 722  * Registers in this switch are divided into sections, specified in
 723  * documentation. So as to access any of them, section index and reg index
 724  * is necessary. etherswitchcfg uses only one variable, so indexes were
 725  * compressed into addr_reg: 32 * section_index + reg_index.
 726  */
 727 static int
 728 e6000sw_readreg_wrapper(device_t dev, int addr_reg)
 729 {
 730
 731         if ((addr_reg > (REG_GLOBAL2 * 32 + REG_NUM_MAX)) ||
 732             (addr_reg < (REG_PORT(0) * 32))) {
 733                 device_printf(dev, "Wrong register address.\n");
 734                 return (EINVAL);
 735         }
 736
 737         return (e6000sw_readreg(device_get_softc(dev), addr_reg / 32,
 738             addr_reg % 32));
 739 }
 740
 741 static int
 742 e6000sw_writereg_wrapper(device_t dev, int addr_reg, int val)
 743 {
 744
 745         if ((addr_reg > (REG_GLOBAL2 * 32 + REG_NUM_MAX)) ||
 746             (addr_reg < (REG_PORT(0) * 32))) {
 747                 device_printf(dev, "Wrong register address.\n");
 748                 return (EINVAL);
 749         }
 750         e6000sw_writereg(device_get_softc(dev), addr_reg / 5,
 751             addr_reg % 32, val);
 752
 753         return (0);
 754 }
 755
 756 /*
 757  * These wrappers are necessary because PHY accesses from etherswitchcfg
 758  * need to be synchronized with locks, while miibus PHY accesses do not.
 759  */
 760 static int
 761 e6000sw_readphy_wrapper(device_t dev, int phy, int reg)
 762 {
 763         e6000sw_softc_t *sc;
 764         int ret;
 765
 766         sc = device_get_softc(dev);
 767         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 768
 769         E6000SW_LOCK(sc);
 770         ret = e6000sw_readphy(dev, phy, reg);
 771         E6000SW_UNLOCK(sc);
 772
 773         return (ret);
 774 }
 775
 776 static int
 777 e6000sw_writephy_wrapper(device_t dev, int phy, int reg, int data)
 778 {
 779         e6000sw_softc_t *sc;
 780         int ret;
 781
 782         sc = device_get_softc(dev);
 783         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 784
 785         E6000SW_LOCK(sc);
 786         ret = e6000sw_writephy(dev, phy, reg, data);
 787         E6000SW_UNLOCK(sc);
 788
 789         return (ret);
 790 }
 791
 792 /*
 793  * setvgroup/getvgroup called from etherswitchfcg need to be locked,
 794  * while internal calls do not.
 795  */
 796 static int
 797 e6000sw_setvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg)
 798 {
 799         e6000sw_softc_t *sc;
 800         int ret;
 801
 802         sc = device_get_softc(dev);
 803         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 804
 805         E6000SW_LOCK(sc);
 806         ret = e6000sw_setvgroup(dev, vg);
 807         E6000SW_UNLOCK(sc);
 808
 809         return (ret);
 810 }
 811
 812 static int
 813 e6000sw_getvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg)
 814 {
 815         e6000sw_softc_t *sc;
 816         int ret;
 817
 818         sc = device_get_softc(dev);
 819         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
 820
 821         E6000SW_LOCK(sc);
 822         ret = e6000sw_getvgroup(dev, vg);
 823         E6000SW_UNLOCK(sc);
 824
 825         return (ret);
 826 }
 827
 828 static __inline void
 829 e6000sw_port_vlan_assign(e6000sw_softc_t *sc, int port, uint32_t fid,
 830     uint32_t members)
 831 {
 832         uint32_t reg;
 833
 834         reg = e6000sw_readreg(sc, REG_PORT(port), PORT_VLAN_MAP);
 835         reg &= ~PORT_VLAN_MAP_TABLE_MASK;
 836         reg &= ~PORT_VLAN_MAP_FID_MASK;
 837         reg |= members & PORT_VLAN_MAP_TABLE_MASK & ~(1 << port);
 838         reg |= (fid << PORT_VLAN_MAP_FID) & PORT_VLAN_MAP_FID_MASK;
 839         e6000sw_writereg(sc, REG_PORT(port), PORT_VLAN_MAP, reg);
 840         reg = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL_1);
 841         reg &= ~PORT_CONTROL_1_FID_MASK;
 842         reg |= (fid >> 4) & PORT_CONTROL_1_FID_MASK;
 843         e6000sw_writereg(sc, REG_PORT(port), PORT_CONTROL_1, reg);
 844 }
 845
 846 static int
 847 e6000sw_set_port_vlan(e6000sw_softc_t *sc, etherswitch_vlangroup_t *vg)
 848 {
 849         uint32_t port;
 850
 851         port = vg->es_vlangroup;
 852         if (port > sc->num_ports)
 853                 return (EINVAL);
 854
 855         if (vg->es_member_ports != vg->es_untagged_ports) {
 856                 device_printf(sc->dev, "Tagged ports not supported.\n");
 857                 return (EINVAL);
 858         }
 859
 860         e6000sw_port_vlan_assign(sc, port, port + 1, vg->es_untagged_ports);
 861         vg->es_vid = port | ETHERSWITCH_VID_VALID;
 862
 863         return (0);
 864 }
 865
 866 static int
 867 e6000sw_setvgroup(device_t dev, etherswitch_vlangroup_t *vg)
 868 {
 869         e6000sw_softc_t *sc;
 870
 871         sc = device_get_softc(dev);
 872         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 873
 874         if (sc->vlan_mode == ETHERSWITCH_VLAN_PORT)
 875                 return (e6000sw_set_port_vlan(sc, vg));
 876
 877         return (EINVAL);
 878 }
 879
 880 static int
 881 e6000sw_get_port_vlan(e6000sw_softc_t *sc, etherswitch_vlangroup_t *vg)
 882 {
 883         uint32_t port, reg;
 884
 885         port = vg->es_vlangroup;
 886         if (port > sc->num_ports)
 887                 return (EINVAL);
 888
 889         if (!e6000sw_is_portenabled(sc, port)) {
 890                 vg->es_vid = port;
 891                 return (0);
 892         }
 893
 894         reg = e6000sw_readreg(sc, REG_PORT(port), PORT_VLAN_MAP);
 895         vg->es_untagged_ports = vg->es_member_ports =
 896             reg & PORT_VLAN_MAP_TABLE_MASK;
 897         vg->es_vid = port | ETHERSWITCH_VID_VALID;
 898         vg->es_fid = (reg & PORT_VLAN_MAP_FID_MASK) >> PORT_VLAN_MAP_FID;
 899         reg = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL_1);
 900         vg->es_fid |= (reg & PORT_CONTROL_1_FID_MASK) << 4;
 901
 902         return (0);
 903 }
 904
 905 static int
 906 e6000sw_getvgroup(device_t dev, etherswitch_vlangroup_t *vg)
 907 {
 908         e6000sw_softc_t *sc;
 909
 910         sc = device_get_softc(dev);
 911         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 912
 913         if (sc->vlan_mode == ETHERSWITCH_VLAN_PORT)
 914                 return (e6000sw_get_port_vlan(sc, vg));
 915
 916         return (EINVAL);
 917 }
 918
 919 static __inline struct mii_data*
 920 e6000sw_miiforphy(e6000sw_softc_t *sc, unsigned int phy)
 921 {
 922
 923         if (!e6000sw_is_phyport(sc, phy))
 924                 return (NULL);
 925
 926         return (device_get_softc(sc->miibus[phy]));
 927 }
 928
 929 static int
 930 e6000sw_ifmedia_upd(struct ifnet *ifp)
 931 {
 932         e6000sw_softc_t *sc;
 933         struct mii_data *mii;
 934
 935         sc = ifp->if_softc;
 936         mii = e6000sw_miiforphy(sc, ifp->if_dunit);
 937         if (mii == NULL)
 938                 return (ENXIO);
 939         mii_mediachg(mii);
 940
 941         return (0);
 942 }
 943
 944 static void
 945 e6000sw_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 946 {
 947         e6000sw_softc_t *sc;
 948         struct mii_data *mii;
 949
 950         sc = ifp->if_softc;
 951         mii = e6000sw_miiforphy(sc, ifp->if_dunit);
 952
 953         if (mii == NULL)
 954                 return;
 955
 956         mii_pollstat(mii);
 957         ifmr->ifm_active = mii->mii_media_active;
 958         ifmr->ifm_status = mii->mii_media_status;
 959 }
 960
 961 static int
 962 e6000sw_smi_waitready(e6000sw_softc_t *sc, int phy)
 963 {
 964         int i;
 965
 966         for (i = 0; i < E6000SW_SMI_TIMEOUT; i++) {
 967                 if ((MDIO_READ(sc->dev, phy, SMI_CMD) & SMI_CMD_BUSY) == 0)
 968                         return (0);
 969                 DELAY(1);
 970         }
 971
 972         return (1);
 973 }
 974
 975 static __inline uint32_t
 976 e6000sw_readreg(e6000sw_softc_t *sc, int addr, int reg)
 977 {
 978
 979         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
 980
 981         if (!sc->multi_chip)
 982                 return (MDIO_READ(sc->dev, addr, reg) & 0xffff);
 983
 984         if (e6000sw_smi_waitready(sc, sc->sw_addr)) {
 985                 printf("e6000sw: readreg timeout\n");
 986                 return (0xffff);
 987         }
 988         MDIO_WRITE(sc->dev, sc->sw_addr, SMI_CMD,
 989             SMI_CMD_OP_READ | (addr << 5) | reg);
 990         if (e6000sw_smi_waitready(sc, sc->sw_addr)) {
 991                 printf("e6000sw: readreg timeout\n");
 992                 return (0xffff);
 993         }
 994
 995         return (MDIO_READ(sc->dev, sc->sw_addr, SMI_DATA) & 0xffff);
 996 }
 997
 998 static __inline void
 999 e6000sw_writereg(e6000sw_softc_t *sc, int addr, int reg, int val)
1000 {
1001
1002         E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
1003
1004         if (!sc->multi_chip) {
1005                 MDIO_WRITE(sc->dev, addr, reg, val);
1006                 return;
1007         }
1008
1009         if (e6000sw_smi_waitready(sc, sc->sw_addr)) {
1010                 printf("e6000sw: readreg timeout\n");
1011                 return;
1012         }
1013         MDIO_WRITE(sc->dev, sc->sw_addr, SMI_DATA, val);
1014         MDIO_WRITE(sc->dev, sc->sw_addr, SMI_CMD,
1015             SMI_CMD_OP_WRITE | (addr << 5) | reg);
1016         if (e6000sw_smi_waitready(sc, sc->sw_addr)) {
1017                 printf("e6000sw: readreg timeout\n");
1018                 return;
1019         }
1020 }
1021
1022 static __inline bool
1023 e6000sw_is_cpuport(e6000sw_softc_t *sc, int port)
1024 {
1025
1026         return ((sc->cpuports_mask & (1 << port)) ? true : false);
1027 }
1028
1029 static __inline bool
1030 e6000sw_is_fixedport(e6000sw_softc_t *sc, int port)
1031 {
1032
1033         return ((sc->fixed_mask & (1 << port)) ? true : false);
1034 }
1035
1036 static __inline bool
1037 e6000sw_is_fixed25port(e6000sw_softc_t *sc, int port)
1038 {
1039
1040         return ((sc->fixed25_mask & (1 << port)) ? true : false);
1041 }
1042
1043 static __inline bool
1044 e6000sw_is_phyport(e6000sw_softc_t *sc, int port)
1045 {
1046         uint32_t phy_mask;
1047         phy_mask = ~(sc->fixed_mask | sc->cpuports_mask);
1048
1049         return ((phy_mask & (1 << port)) ? true : false);
1050 }
1051
1052 static __inline bool
1053 e6000sw_is_portenabled(e6000sw_softc_t *sc, int port)
1054 {
1055
1056         return ((sc->ports_mask & (1 << port)) ? true : false);
1057 }
1058
1059 static __inline int
1060 e6000sw_set_pvid(e6000sw_softc_t *sc, int port, int pvid)
1061 {
1062
1063         e6000sw_writereg(sc, REG_PORT(port), PORT_VID, pvid &
1064             PORT_VID_DEF_VID_MASK);
1065
1066         return (0);
1067 }
1068
1069 static __inline int
1070 e6000sw_get_pvid(e6000sw_softc_t *sc, int port, int *pvid)
1071 {
1072
1073         if (pvid == NULL)
1074                 return (ENXIO);
1075
1076         *pvid = e6000sw_readreg(sc, REG_PORT(port), PORT_VID) &
1077             PORT_VID_DEF_VID_MASK;
1078
1079         return (0);
1080 }
1081
1082 /*
1083  * Convert port status to ifmedia.
1084  */
1085 static void
1086 e6000sw_update_ifmedia(uint16_t portstatus, u_int *media_status, u_int *media_active)
1087 {
1088         *media_active = IFM_ETHER;
1089         *media_status = IFM_AVALID;
1090
1091         if ((portstatus & PORT_STATUS_LINK_MASK) != 0)
1092                 *media_status |= IFM_ACTIVE;
1093         else {
1094                 *media_active |= IFM_NONE;
1095                 return;
1096         }
1097
1098         switch (portstatus & PORT_STATUS_SPEED_MASK) {
1099         case PORT_STATUS_SPEED_10:
1100                 *media_active |= IFM_10_T;
1101                 break;
1102         case PORT_STATUS_SPEED_100:
1103                 *media_active |= IFM_100_TX;
1104                 break;
1105         case PORT_STATUS_SPEED_1000:
1106                 *media_active |= IFM_1000_T;
1107                 break;
1108         }
1109
1110         if ((portstatus & PORT_STATUS_DUPLEX_MASK) == 0)
1111                 *media_active |= IFM_FDX;
1112         else
1113                 *media_active |= IFM_HDX;
1114 }
1115
1116 static void
1117 e6000sw_tick (void *arg)
1118 {
1119         e6000sw_softc_t *sc;
1120         struct mii_data *mii;
1121         struct mii_softc *miisc;
1122         uint16_t portstatus;
1123         int port;
1124
1125         sc = arg;
1126
1127         E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
1128
1129         for (;;) {
1130                 E6000SW_LOCK(sc);
1131                 for (port = 0; port < sc->num_ports; port++) {
1132                         /* Tick only on PHY ports */
1133                         if (!e6000sw_is_portenabled(sc, port) ||
1134                             !e6000sw_is_phyport(sc, port))
1135                                 continue;
1136
1137                         mii = e6000sw_miiforphy(sc, port);
1138                         if (mii == NULL)
1139                                 continue;
1140
1141                         portstatus = e6000sw_readreg(sc, REG_PORT(port),
1142                             PORT_STATUS);
1143
1144                         e6000sw_update_ifmedia(portstatus,
1145                             &mii->mii_media_status, &mii->mii_media_active);
1146
1147                         LIST_FOREACH(miisc, &mii->mii_phys, mii_list) {
1148                                 if (IFM_INST(mii->mii_media.ifm_cur->ifm_media)
1149                                     != miisc->mii_inst)
1150                                         continue;
1151                                 mii_phy_update(miisc, MII_POLLSTAT);
1152                         }
1153                 }
1154                 E6000SW_UNLOCK(sc);
1155                 pause("e6000sw tick", 1000);
1156         }
1157 }
1158
1159 static void
1160 e6000sw_setup(device_t dev, e6000sw_softc_t *sc)
1161 {
1162         uint16_t atu_ctrl, atu_age;
1163
1164         /* Set aging time */
1165         e6000sw_writereg(sc, REG_GLOBAL, ATU_CONTROL,
1166             (E6000SW_DEFAULT_AGETIME << ATU_CONTROL_AGETIME) |
1167             (1 << ATU_CONTROL_LEARN2ALL));
1168
1169         /* Send all with specific mac address to cpu port */
1170         e6000sw_writereg(sc, REG_GLOBAL2, MGMT_EN_2x, MGMT_EN_ALL);
1171         e6000sw_writereg(sc, REG_GLOBAL2, MGMT_EN_0x, MGMT_EN_ALL);
1172
1173         /* Disable Remote Management */
1174         e6000sw_writereg(sc, REG_GLOBAL, SWITCH_GLOBAL_CONTROL2, 0);
1175
1176         /* Disable loopback filter and flow control messages */
1177         e6000sw_writereg(sc, REG_GLOBAL2, SWITCH_MGMT,
1178             SWITCH_MGMT_PRI_MASK |
1179             (1 << SWITCH_MGMT_RSVD2CPU) |
1180             SWITCH_MGMT_FC_PRI_MASK |
1181             (1 << SWITCH_MGMT_FORCEFLOW));
1182
1183         e6000sw_atu_flush(dev, sc, NO_OPERATION);
1184         e6000sw_atu_mac_table(dev, sc, NULL, NO_OPERATION);
1185         e6000sw_set_atustat(dev, sc, 0, COUNT_ALL);
1186
1187         /* Set ATU AgeTime to 15 seconds */
1188         atu_age = 1;
1189
1190         atu_ctrl = e6000sw_readreg(sc, REG_GLOBAL, ATU_CONTROL);
1191
1192         /* Set new AgeTime field */
1193         atu_ctrl &= ~ATU_CONTROL_AGETIME_MASK;
1194         e6000sw_writereg(sc, REG_GLOBAL, ATU_CONTROL, atu_ctrl |
1195             (atu_age << ATU_CONTROL_AGETIME));
1196 }
1197
1198 static void
1199 e6000sw_port_vlan_conf(e6000sw_softc_t *sc)
1200 {
1201         int i, port, ret;
1202         uint32_t members;
1203
1204         /* Disable all ports */
1205         for (port = 0; port < sc->num_ports; port++) {
1206                 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL);
1207                 e6000sw_writereg(sc, REG_PORT(port), PORT_CONTROL,
1208                     (ret & ~PORT_CONTROL_ENABLE));
1209         }
1210
1211         /* Set port priority */
1212         for (port = 0; port < sc->num_ports; port++) {
1213                 if (!e6000sw_is_portenabled(sc, port))
1214                         continue;
1215                 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_VID);
1216                 ret &= ~PORT_VID_PRIORITY_MASK;
1217                 e6000sw_writereg(sc, REG_PORT(port), PORT_VID, ret);
1218         }
1219
1220         /* Set VID map */
1221         for (port = 0; port < sc->num_ports; port++) {
1222                 if (!e6000sw_is_portenabled(sc, port))
1223                         continue;
1224                 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_VID);
1225                 ret &= ~PORT_VID_DEF_VID_MASK;
1226                 ret |= (port + 1);
1227                 e6000sw_writereg(sc, REG_PORT(port), PORT_VID, ret);
1228         }
1229
1230         /* Enable all ports */
1231         for (port = 0; port < sc->num_ports; port++) {
1232                 if (!e6000sw_is_portenabled(sc, port))
1233                         continue;
1234                 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL);
1235                 e6000sw_writereg(sc, REG_PORT(port), PORT_CONTROL,
1236                     (ret | PORT_CONTROL_ENABLE));
1237         }
1238
1239         /* Set VLAN mode. */
1240         sc->vlan_mode = ETHERSWITCH_VLAN_PORT;
1241         etherswitch_info.es_nvlangroups = sc->num_ports;
1242         for (port = 0; port < sc->num_ports; port++) {
1243                 members = 0;
1244                 if (e6000sw_is_portenabled(sc, port)) {
1245                         for (i = 0; i < sc->num_ports; i++) {
1246                                 if (i == port || !e6000sw_is_portenabled(sc, i))
1247                                         continue;
1248                                 members |= (1 << i);
1249                         }
1250                 }
1251                 e6000sw_port_vlan_assign(sc, port, port + 1, members);
1252         }
1253 }
1254
1255 static void
1256 e6000sw_set_atustat(device_t dev, e6000sw_softc_t *sc, int bin, int flag)
1257 {
1258         uint16_t ret;
1259
1260         ret = e6000sw_readreg(sc, REG_GLOBAL2, ATU_STATS);
1261         e6000sw_writereg(sc, REG_GLOBAL2, ATU_STATS, (bin << ATU_STATS_BIN ) |
1262             (flag << ATU_STATS_FLAG));
1263 }
1264
1265 static int
1266 e6000sw_atu_mac_table(device_t dev, e6000sw_softc_t *sc, struct atu_opt *atu,
1267     int flag)
1268 {
1269         uint16_t ret_opt;
1270         uint16_t ret_data;
1271         int retries;
1272
1273         if (flag == NO_OPERATION)
1274                 return (0);
1275         else if ((flag & (LOAD_FROM_FIB | PURGE_FROM_FIB | GET_NEXT_IN_FIB |
1276             GET_VIOLATION_DATA | CLEAR_VIOLATION_DATA)) == 0) {
1277                 device_printf(dev, "Wrong Opcode for ATU operation\n");
1278                 return (EINVAL);
1279         }
1280
1281         ret_opt = e6000sw_readreg(sc, REG_GLOBAL, ATU_OPERATION);
1282
1283         if (ret_opt & ATU_UNIT_BUSY) {
1284                 device_printf(dev, "ATU unit is busy, cannot access"
1285                     "register\n");
1286                 return (EBUSY);
1287         } else {
1288                 if(flag & LOAD_FROM_FIB) {
1289                         ret_data = e6000sw_readreg(sc, REG_GLOBAL, ATU_DATA);
1290                         e6000sw_writereg(sc, REG_GLOBAL2, ATU_DATA, (ret_data &
1291                             ~ENTRY_STATE));
1292                 }
1293                 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR01, atu->mac_01);
1294                 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR23, atu->mac_23);
1295                 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR45, atu->mac_45);
1296                 e6000sw_writereg(sc, REG_GLOBAL, ATU_FID, atu->fid);
1297
1298                 e6000sw_writereg(sc, REG_GLOBAL, ATU_OPERATION, (ret_opt |
1299                     ATU_UNIT_BUSY | flag));
1300
1301                 retries = E6000SW_RETRIES;
1302                 while (--retries & (e6000sw_readreg(sc, REG_GLOBAL,
1303                     ATU_OPERATION) & ATU_UNIT_BUSY))
1304                         DELAY(1);
1305
1306                 if (retries == 0)
1307                         device_printf(dev, "Timeout while flushing\n");
1308                 else if (flag & GET_NEXT_IN_FIB) {
1309                         atu->mac_01 = e6000sw_readreg(sc, REG_GLOBAL,
1310                             ATU_MAC_ADDR01);
1311                         atu->mac_23 = e6000sw_readreg(sc, REG_GLOBAL,
1312                             ATU_MAC_ADDR23);
1313                         atu->mac_45 = e6000sw_readreg(sc, REG_GLOBAL,
1314                             ATU_MAC_ADDR45);
1315                 }
1316         }
1317
1318         return (0);
1319 }
1320
1321 static int
1322 e6000sw_atu_flush(device_t dev, e6000sw_softc_t *sc, int flag)
1323 {
1324         uint16_t ret;
1325         int retries;
1326
1327         if (flag == NO_OPERATION)
1328                 return (0);
1329
1330         ret = e6000sw_readreg(sc, REG_GLOBAL, ATU_OPERATION);
1331         if (ret & ATU_UNIT_BUSY) {
1332                 device_printf(dev, "Atu unit is busy, cannot flush\n");
1333                 return (EBUSY);
1334         } else {
1335                 e6000sw_writereg(sc, REG_GLOBAL, ATU_OPERATION, (ret |
1336                     ATU_UNIT_BUSY | flag));
1337                 retries = E6000SW_RETRIES;
1338                 while (--retries & (e6000sw_readreg(sc, REG_GLOBAL,
1339                     ATU_OPERATION) & ATU_UNIT_BUSY))
1340                         DELAY(1);
1341
1342                 if (retries == 0)
1343                         device_printf(dev, "Timeout while flushing\n");
1344         }
1345
1346         return (0);
1347 }