1/*- 2 * Copyright (c) 2016 Stanislav Galabov. 3 * Copyright (c) 2011-2012 Stefan Bethke. 4 * Copyright (c) 2012 Adrian Chadd. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <sys/param.h> 30#include <sys/bus.h> 31#include <sys/errno.h> 32#include <sys/kernel.h> 33#include <sys/lock.h> 34#include <sys/malloc.h> 35#include <sys/module.h> 36#include <sys/mutex.h> 37#include <sys/socket.h> 38#include <sys/sockio.h> 39#include <sys/sysctl.h> 40#include <sys/systm.h> 41 42#include <net/if.h> 43#include <net/if_var.h> 44#include <net/ethernet.h> 45#include <net/if_media.h> 46#include <net/if_types.h> 47 48#include <machine/bus.h> 49#include <dev/mii/mii.h> 50#include <dev/mii/miivar.h> 51#include <dev/mdio/mdio.h> 52 53#include <dev/etherswitch/etherswitch.h> 54#include <dev/etherswitch/mtkswitch/mtkswitchvar.h> 55 56#include <dev/ofw/ofw_bus_subr.h> 57 58#include "mdio_if.h" 59#include "miibus_if.h" 60#include "etherswitch_if.h" 61 62#define DEBUG 63 64#if defined(DEBUG) 65static SYSCTL_NODE(_debug, OID_AUTO, mtkswitch, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 66 "mtkswitch"); 67#endif 68 69static inline int mtkswitch_portforphy(int phy); 70static int mtkswitch_ifmedia_upd(if_t ifp); 71static void mtkswitch_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr); 72static void mtkswitch_tick(void *arg); 73 74static const struct ofw_compat_data compat_data[] = { 75 { "ralink,rt3050-esw", MTK_SWITCH_RT3050 }, 76 { "ralink,rt3352-esw", MTK_SWITCH_RT3352 }, 77 { "ralink,rt5350-esw", MTK_SWITCH_RT5350 }, 78 { "mediatek,mt7620-gsw", MTK_SWITCH_MT7620 }, 79 { "mediatek,mt7621-gsw", MTK_SWITCH_MT7621 }, 80 { "mediatek,mt7628-esw", MTK_SWITCH_MT7628 }, 81 82 /* Sentinel */ 83 { NULL, MTK_SWITCH_NONE } 84}; 85 86static int 87mtkswitch_probe(device_t dev) 88{ 89 struct mtkswitch_softc *sc; 90 mtk_switch_type switch_type; 91 92 if (!ofw_bus_status_okay(dev)) 93 return (ENXIO); 94 95 switch_type = ofw_bus_search_compatible(dev, compat_data)->ocd_data; 96 if (switch_type == MTK_SWITCH_NONE) 97 return (ENXIO); 98 99 sc = device_get_softc(dev); 100 bzero(sc, sizeof(*sc)); 101 sc->sc_switchtype = switch_type; 102 103 device_set_desc(dev, "MTK Switch Driver"); 104 105 return (0); 106} 107 108static int 109mtkswitch_attach_phys(struct mtkswitch_softc *sc) 110{ 111 int phy, err = 0; 112 char name[IFNAMSIZ]; 113 114 /* PHYs need an interface, so we generate a dummy one */ 115 snprintf(name, IFNAMSIZ, "%sport", device_get_nameunit(sc->sc_dev)); 116 for (phy = 0; phy < sc->numphys; phy++) { 117 if ((sc->phymap & (1u << phy)) == 0) { 118 sc->ifp[phy] = NULL; 119 sc->ifname[phy] = NULL; 120 sc->miibus[phy] = NULL; 121 continue; 122 } 123 sc->ifp[phy] = if_alloc(IFT_ETHER); 124 if (sc->ifp[phy] == NULL) { 125 device_printf(sc->sc_dev, "couldn't allocate ifnet structure\n"); 126 err = ENOMEM; 127 break; 128 } 129 130 sc->ifp[phy]->if_softc = sc; 131 sc->ifp[phy]->if_flags |= IFF_UP | IFF_BROADCAST | 132 IFF_DRV_RUNNING | IFF_SIMPLEX; 133 sc->ifname[phy] = malloc(strlen(name) + 1, M_DEVBUF, M_WAITOK); 134 bcopy(name, sc->ifname[phy], strlen(name) + 1); 135 if_initname(sc->ifp[phy], sc->ifname[phy], 136 mtkswitch_portforphy(phy)); 137 err = mii_attach(sc->sc_dev, &sc->miibus[phy], sc->ifp[phy], 138 mtkswitch_ifmedia_upd, mtkswitch_ifmedia_sts, 139 BMSR_DEFCAPMASK, phy, MII_OFFSET_ANY, 0); 140 if (err != 0) { 141 device_printf(sc->sc_dev, 142 "attaching PHY %d failed\n", 143 phy); 144 } else { 145 DPRINTF(sc->sc_dev, "%s attached to pseudo interface " 146 "%s\n", device_get_nameunit(sc->miibus[phy]), 147 sc->ifp[phy]->if_xname); 148 } 149 } 150 return (err); 151} 152 153static int 154mtkswitch_set_vlan_mode(struct mtkswitch_softc *sc, uint32_t mode) 155{ 156 157 /* Check for invalid modes. */ 158 if ((mode & sc->info.es_vlan_caps) != mode) 159 return (EINVAL); 160 161 sc->vlan_mode = mode; 162 163 /* Reset VLANs. */ 164 sc->hal.mtkswitch_vlan_init_hw(sc); 165 166 return (0); 167} 168 169static int 170mtkswitch_attach(device_t dev) 171{ 172 struct mtkswitch_softc *sc; 173 int err = 0; 174 int port, rid; 175 176 sc = device_get_softc(dev); 177 178 /* sc->sc_switchtype is already decided in mtkswitch_probe() */ 179 sc->numports = MTKSWITCH_MAX_PORTS; 180 sc->numphys = MTKSWITCH_MAX_PHYS; 181 sc->cpuport = MTKSWITCH_CPU_PORT; 182 sc->sc_dev = dev; 183 184 /* Attach switch related functions */ 185 if (sc->sc_switchtype == MTK_SWITCH_NONE) { 186 device_printf(dev, "Unknown switch type\n"); 187 return (ENXIO); 188 } 189 190 if (sc->sc_switchtype == MTK_SWITCH_MT7620 || 191 sc->sc_switchtype == MTK_SWITCH_MT7621) 192 mtk_attach_switch_mt7620(sc); 193 else 194 mtk_attach_switch_rt3050(sc); 195 196 /* Allocate resources */ 197 rid = 0; 198 sc->sc_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 199 RF_ACTIVE); 200 if (sc->sc_res == NULL) { 201 device_printf(dev, "could not map memory\n"); 202 return (ENXIO); 203 } 204 205 mtx_init(&sc->sc_mtx, "mtkswitch", NULL, MTX_DEF); 206 207 /* Reset the switch */ 208 if (sc->hal.mtkswitch_reset(sc)) { 209 DPRINTF(dev, "%s: mtkswitch_reset: failed\n", __func__); 210 return (ENXIO); 211 } 212 213 err = sc->hal.mtkswitch_hw_setup(sc); 214 DPRINTF(dev, "%s: hw_setup: err=%d\n", __func__, err); 215 if (err != 0) 216 return (err); 217 218 err = sc->hal.mtkswitch_hw_global_setup(sc); 219 DPRINTF(dev, "%s: hw_global_setup: err=%d\n", __func__, err); 220 if (err != 0) 221 return (err); 222 223 /* Initialize the switch ports */ 224 for (port = 0; port < sc->numports; port++) { 225 sc->hal.mtkswitch_port_init(sc, port); 226 } 227 228 /* Attach the PHYs and complete the bus enumeration */ 229 err = mtkswitch_attach_phys(sc); 230 DPRINTF(dev, "%s: attach_phys: err=%d\n", __func__, err); 231 if (err != 0) 232 return (err); 233 234 /* Default to ingress filters off. */ 235 err = mtkswitch_set_vlan_mode(sc, ETHERSWITCH_VLAN_DOT1Q); 236 DPRINTF(dev, "%s: set_vlan_mode: err=%d\n", __func__, err); 237 if (err != 0) 238 return (err); 239 240 bus_generic_probe(dev); 241 bus_enumerate_hinted_children(dev); 242 err = bus_generic_attach(dev); 243 DPRINTF(dev, "%s: bus_generic_attach: err=%d\n", __func__, err); 244 if (err != 0) 245 return (err); 246 247 callout_init_mtx(&sc->callout_tick, &sc->sc_mtx, 0); 248 249 MTKSWITCH_LOCK(sc); 250 mtkswitch_tick(sc); 251 MTKSWITCH_UNLOCK(sc); 252 253 return (0); 254} 255 256static int 257mtkswitch_detach(device_t dev) 258{ 259 struct mtkswitch_softc *sc = device_get_softc(dev); 260 int phy; 261 262 callout_drain(&sc->callout_tick); 263 264 for (phy = 0; phy < MTKSWITCH_MAX_PHYS; phy++) { 265 if (sc->miibus[phy] != NULL) 266 device_delete_child(dev, sc->miibus[phy]); 267 if (sc->ifp[phy] != NULL) 268 if_free(sc->ifp[phy]); 269 free(sc->ifname[phy], M_DEVBUF); 270 } 271 272 bus_generic_detach(dev); 273 mtx_destroy(&sc->sc_mtx); 274 275 return (0); 276} 277 278/* PHY <-> port mapping is currently 1:1 */ 279static inline int 280mtkswitch_portforphy(int phy) 281{ 282 283 return (phy); 284} 285 286static inline int 287mtkswitch_phyforport(int port) 288{ 289 290 return (port); 291} 292 293static inline struct mii_data * 294mtkswitch_miiforport(struct mtkswitch_softc *sc, int port) 295{ 296 int phy = mtkswitch_phyforport(port); 297 298 if (phy < 0 || phy >= MTKSWITCH_MAX_PHYS || sc->miibus[phy] == NULL) 299 return (NULL); 300 301 return (device_get_softc(sc->miibus[phy])); 302} 303 304static inline if_t 305mtkswitch_ifpforport(struct mtkswitch_softc *sc, int port) 306{ 307 int phy = mtkswitch_phyforport(port); 308 309 if (phy < 0 || phy >= MTKSWITCH_MAX_PHYS) 310 return (NULL); 311 312 return (sc->ifp[phy]); 313} 314 315/* 316 * Convert port status to ifmedia. 317 */ 318static void 319mtkswitch_update_ifmedia(uint32_t portstatus, u_int *media_status, 320 u_int *media_active) 321{ 322 *media_active = IFM_ETHER; 323 *media_status = IFM_AVALID; 324 325 if ((portstatus & MTKSWITCH_LINK_UP) != 0) 326 *media_status |= IFM_ACTIVE; 327 else { 328 *media_active |= IFM_NONE; 329 return; 330 } 331 332 switch (portstatus & MTKSWITCH_SPEED_MASK) { 333 case MTKSWITCH_SPEED_10: 334 *media_active |= IFM_10_T; 335 break; 336 case MTKSWITCH_SPEED_100: 337 *media_active |= IFM_100_TX; 338 break; 339 case MTKSWITCH_SPEED_1000: 340 *media_active |= IFM_1000_T; 341 break; 342 } 343 344 if ((portstatus & MTKSWITCH_DUPLEX) != 0) 345 *media_active |= IFM_FDX; 346 else 347 *media_active |= IFM_HDX; 348 349 if ((portstatus & MTKSWITCH_TXFLOW) != 0) 350 *media_active |= IFM_ETH_TXPAUSE; 351 if ((portstatus & MTKSWITCH_RXFLOW) != 0) 352 *media_active |= IFM_ETH_RXPAUSE; 353} 354 355static void 356mtkswitch_miipollstat(struct mtkswitch_softc *sc) 357{ 358 struct mii_data *mii; 359 struct mii_softc *miisc; 360 uint32_t portstatus; 361 int i, port_flap = 0; 362 363 MTKSWITCH_LOCK_ASSERT(sc, MA_OWNED); 364 365 for (i = 0; i < sc->numphys; i++) { 366 if (sc->miibus[i] == NULL) 367 continue; 368 mii = device_get_softc(sc->miibus[i]); 369 portstatus = sc->hal.mtkswitch_get_port_status(sc, 370 mtkswitch_portforphy(i)); 371 372 /* If a port has flapped - mark it so we can flush the ATU */ 373 if (((mii->mii_media_status & IFM_ACTIVE) == 0 && 374 (portstatus & MTKSWITCH_LINK_UP) != 0) || 375 ((mii->mii_media_status & IFM_ACTIVE) != 0 && 376 (portstatus & MTKSWITCH_LINK_UP) == 0)) { 377 port_flap = 1; 378 } 379 380 mtkswitch_update_ifmedia(portstatus, &mii->mii_media_status, 381 &mii->mii_media_active); 382 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) { 383 if (IFM_INST(mii->mii_media.ifm_cur->ifm_media) != 384 miisc->mii_inst) 385 continue; 386 mii_phy_update(miisc, MII_POLLSTAT); 387 } 388 } 389 390 if (port_flap) 391 sc->hal.mtkswitch_atu_flush(sc); 392} 393 394static void 395mtkswitch_tick(void *arg) 396{ 397 struct mtkswitch_softc *sc = arg; 398 399 mtkswitch_miipollstat(sc); 400 callout_reset(&sc->callout_tick, hz, mtkswitch_tick, sc); 401} 402 403static void 404mtkswitch_lock(device_t dev) 405{ 406 struct mtkswitch_softc *sc = device_get_softc(dev); 407 408 MTKSWITCH_LOCK_ASSERT(sc, MA_NOTOWNED); 409 MTKSWITCH_LOCK(sc); 410} 411 412static void 413mtkswitch_unlock(device_t dev) 414{ 415 struct mtkswitch_softc *sc = device_get_softc(dev); 416 417 MTKSWITCH_LOCK_ASSERT(sc, MA_OWNED); 418 MTKSWITCH_UNLOCK(sc); 419} 420 421static etherswitch_info_t * 422mtkswitch_getinfo(device_t dev) 423{ 424 struct mtkswitch_softc *sc = device_get_softc(dev); 425 426 return (&sc->info); 427} 428 429static inline int 430mtkswitch_is_cpuport(struct mtkswitch_softc *sc, int port) 431{ 432 433 return (sc->cpuport == port); 434} 435 436static int 437mtkswitch_getport(device_t dev, etherswitch_port_t *p) 438{ 439 struct mtkswitch_softc *sc; 440 struct mii_data *mii; 441 struct ifmediareq *ifmr; 442 int err; 443 444 sc = device_get_softc(dev); 445 if (p->es_port < 0 || p->es_port > sc->info.es_nports) 446 return (ENXIO); 447 448 err = sc->hal.mtkswitch_port_vlan_get(sc, p); 449 if (err != 0) 450 return (err); 451 452 mii = mtkswitch_miiforport(sc, p->es_port); 453 if (mtkswitch_is_cpuport(sc, p->es_port)) { 454 /* fill in fixed values for CPU port */ 455 /* XXX is this valid in all cases? */ 456 p->es_flags |= ETHERSWITCH_PORT_CPU; 457 ifmr = &p->es_ifmr; 458 ifmr->ifm_count = 0; 459 ifmr->ifm_current = ifmr->ifm_active = 460 IFM_ETHER | IFM_1000_T | IFM_FDX; 461 ifmr->ifm_mask = 0; 462 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID; 463 } else if (mii != NULL) { 464 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr, 465 &mii->mii_media, SIOCGIFMEDIA); 466 if (err) 467 return (err); 468 } else { 469 ifmr = &p->es_ifmr; 470 ifmr->ifm_count = 0; 471 ifmr->ifm_current = ifmr->ifm_active = IFM_NONE; 472 ifmr->ifm_mask = 0; 473 ifmr->ifm_status = 0; 474 } 475 return (0); 476} 477 478static int 479mtkswitch_setport(device_t dev, etherswitch_port_t *p) 480{ 481 int err; 482 struct mtkswitch_softc *sc; 483 struct ifmedia *ifm; 484 struct mii_data *mii; 485 if_t ifp; 486 487 sc = device_get_softc(dev); 488 if (p->es_port < 0 || p->es_port > sc->info.es_nports) 489 return (ENXIO); 490 491 /* Port flags. */ 492 if (sc->vlan_mode == ETHERSWITCH_VLAN_DOT1Q) { 493 err = sc->hal.mtkswitch_port_vlan_setup(sc, p); 494 if (err) 495 return (err); 496 } 497 498 /* Do not allow media changes on CPU port. */ 499 if (mtkswitch_is_cpuport(sc, p->es_port)) 500 return (0); 501 502 mii = mtkswitch_miiforport(sc, p->es_port); 503 if (mii == NULL) 504 return (ENXIO); 505 506 ifp = mtkswitch_ifpforport(sc, p->es_port); 507 508 ifm = &mii->mii_media; 509 return (ifmedia_ioctl(ifp, &p->es_ifr, ifm, SIOCSIFMEDIA)); 510} 511 512static void 513mtkswitch_statchg(device_t dev) 514{ 515 516 DPRINTF(dev, "%s\n", __func__); 517} 518 519static int 520mtkswitch_ifmedia_upd(if_t ifp) 521{ 522 struct mtkswitch_softc *sc = if_getsoftc(ifp); 523 struct mii_data *mii = mtkswitch_miiforport(sc, if_getdunit(ifp)); 524 525 if (mii == NULL) 526 return (ENXIO); 527 mii_mediachg(mii); 528 return (0); 529} 530 531static void 532mtkswitch_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr) 533{ 534 struct mtkswitch_softc *sc = if_getsoftc(ifp); 535 struct mii_data *mii = mtkswitch_miiforport(sc, if_getdunit(ifp)); 536 537 DPRINTF(sc->sc_dev, "%s\n", __func__); 538 539 if (mii == NULL) 540 return; 541 mii_pollstat(mii); 542 ifmr->ifm_active = mii->mii_media_active; 543 ifmr->ifm_status = mii->mii_media_status; 544} 545 546static int 547mtkswitch_getconf(device_t dev, etherswitch_conf_t *conf) 548{ 549 struct mtkswitch_softc *sc; 550 551 sc = device_get_softc(dev); 552 553 /* Return the VLAN mode. */ 554 conf->cmd = ETHERSWITCH_CONF_VLAN_MODE; 555 conf->vlan_mode = sc->vlan_mode; 556 557 return (0); 558} 559 560static int 561mtkswitch_setconf(device_t dev, etherswitch_conf_t *conf) 562{ 563 struct mtkswitch_softc *sc; 564 int err; 565 566 sc = device_get_softc(dev); 567 568 /* Set the VLAN mode. */ 569 if (conf->cmd & ETHERSWITCH_CONF_VLAN_MODE) { 570 err = mtkswitch_set_vlan_mode(sc, conf->vlan_mode); 571 if (err != 0) 572 return (err); 573 } 574 575 return (0); 576} 577 578static int 579mtkswitch_getvgroup(device_t dev, etherswitch_vlangroup_t *e) 580{ 581 struct mtkswitch_softc *sc = device_get_softc(dev); 582 583 return (sc->hal.mtkswitch_vlan_getvgroup(sc, e)); 584} 585 586static int 587mtkswitch_setvgroup(device_t dev, etherswitch_vlangroup_t *e) 588{ 589 struct mtkswitch_softc *sc = device_get_softc(dev); 590 591 return (sc->hal.mtkswitch_vlan_setvgroup(sc, e)); 592} 593 594static int 595mtkswitch_readphy(device_t dev, int phy, int reg) 596{ 597 struct mtkswitch_softc *sc = device_get_softc(dev); 598 599 return (sc->hal.mtkswitch_phy_read(dev, phy, reg)); 600} 601 602static int 603mtkswitch_writephy(device_t dev, int phy, int reg, int val) 604{ 605 struct mtkswitch_softc *sc = device_get_softc(dev); 606 607 return (sc->hal.mtkswitch_phy_write(dev, phy, reg, val)); 608} 609 610static int 611mtkswitch_readreg(device_t dev, int addr) 612{ 613 struct mtkswitch_softc *sc = device_get_softc(dev); 614 615 return (sc->hal.mtkswitch_reg_read(dev, addr)); 616} 617 618static int 619mtkswitch_writereg(device_t dev, int addr, int value) 620{ 621 struct mtkswitch_softc *sc = device_get_softc(dev); 622 623 return (sc->hal.mtkswitch_reg_write(dev, addr, value)); 624} 625 626static device_method_t mtkswitch_methods[] = { 627 /* Device interface */ 628 DEVMETHOD(device_probe, mtkswitch_probe), 629 DEVMETHOD(device_attach, mtkswitch_attach), 630 DEVMETHOD(device_detach, mtkswitch_detach), 631 632 /* bus interface */ 633 DEVMETHOD(bus_add_child, device_add_child_ordered), 634 635 /* MII interface */ 636 DEVMETHOD(miibus_readreg, mtkswitch_readphy), 637 DEVMETHOD(miibus_writereg, mtkswitch_writephy), 638 DEVMETHOD(miibus_statchg, mtkswitch_statchg), 639 640 /* MDIO interface */ 641 DEVMETHOD(mdio_readreg, mtkswitch_readphy), 642 DEVMETHOD(mdio_writereg, mtkswitch_writephy), 643 644 /* ehterswitch interface */ 645 DEVMETHOD(etherswitch_lock, mtkswitch_lock), 646 DEVMETHOD(etherswitch_unlock, mtkswitch_unlock), 647 DEVMETHOD(etherswitch_getinfo, mtkswitch_getinfo), 648 DEVMETHOD(etherswitch_readreg, mtkswitch_readreg), 649 DEVMETHOD(etherswitch_writereg, mtkswitch_writereg), 650 DEVMETHOD(etherswitch_readphyreg, mtkswitch_readphy), 651 DEVMETHOD(etherswitch_writephyreg, mtkswitch_writephy), 652 DEVMETHOD(etherswitch_getport, mtkswitch_getport), 653 DEVMETHOD(etherswitch_setport, mtkswitch_setport), 654 DEVMETHOD(etherswitch_getvgroup, mtkswitch_getvgroup), 655 DEVMETHOD(etherswitch_setvgroup, mtkswitch_setvgroup), 656 DEVMETHOD(etherswitch_getconf, mtkswitch_getconf), 657 DEVMETHOD(etherswitch_setconf, mtkswitch_setconf), 658 659 DEVMETHOD_END 660}; 661 662DEFINE_CLASS_0(mtkswitch, mtkswitch_driver, mtkswitch_methods, 663 sizeof(struct mtkswitch_softc)); 664 665DRIVER_MODULE(mtkswitch, simplebus, mtkswitch_driver, 0, 0); 666DRIVER_MODULE(miibus, mtkswitch, miibus_driver, 0, 0); 667DRIVER_MODULE(mdio, mtkswitch, mdio_driver, 0, 0); 668DRIVER_MODULE(etherswitch, mtkswitch, etherswitch_driver, 0, 0); 669MODULE_VERSION(mtkswitch, 1); 670MODULE_DEPEND(mtkswitch, miibus, 1, 1, 1); 671MODULE_DEPEND(mtkswitch, etherswitch, 1, 1, 1); 672