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