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