1299910Ssgalabov/*- 2299910Ssgalabov * Copyright (c) 2016 Stanislav Galabov. 3299910Ssgalabov * Copyright (c) 2011-2012 Stefan Bethke. 4299910Ssgalabov * Copyright (c) 2012 Adrian Chadd. 5299910Ssgalabov * All rights reserved. 6299910Ssgalabov * 7299910Ssgalabov * Redistribution and use in source and binary forms, with or without 8299910Ssgalabov * modification, are permitted provided that the following conditions 9299910Ssgalabov * are met: 10299910Ssgalabov * 1. Redistributions of source code must retain the above copyright 11299910Ssgalabov * notice, this list of conditions and the following disclaimer. 12299910Ssgalabov * 2. Redistributions in binary form must reproduce the above copyright 13299910Ssgalabov * notice, this list of conditions and the following disclaimer in the 14299910Ssgalabov * documentation and/or other materials provided with the distribution. 15299910Ssgalabov * 16299910Ssgalabov * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17299910Ssgalabov * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18299910Ssgalabov * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19299910Ssgalabov * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20299910Ssgalabov * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21299910Ssgalabov * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22299910Ssgalabov * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23299910Ssgalabov * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24299910Ssgalabov * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25299910Ssgalabov * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26299910Ssgalabov * SUCH DAMAGE. 27299910Ssgalabov * 28299910Ssgalabov * $FreeBSD: releng/11.0/sys/dev/etherswitch/mtkswitch/mtkswitch.c 299910 2016-05-16 07:00:49Z sgalabov $ 29299910Ssgalabov */ 30299910Ssgalabov 31299910Ssgalabov#include <sys/param.h> 32299910Ssgalabov#include <sys/bus.h> 33299910Ssgalabov#include <sys/errno.h> 34299910Ssgalabov#include <sys/kernel.h> 35299910Ssgalabov#include <sys/lock.h> 36299910Ssgalabov#include <sys/malloc.h> 37299910Ssgalabov#include <sys/module.h> 38299910Ssgalabov#include <sys/mutex.h> 39299910Ssgalabov#include <sys/socket.h> 40299910Ssgalabov#include <sys/sockio.h> 41299910Ssgalabov#include <sys/sysctl.h> 42299910Ssgalabov#include <sys/systm.h> 43299910Ssgalabov 44299910Ssgalabov#include <net/if.h> 45299910Ssgalabov#include <net/if_var.h> 46299910Ssgalabov#include <net/ethernet.h> 47299910Ssgalabov#include <net/if_media.h> 48299910Ssgalabov#include <net/if_types.h> 49299910Ssgalabov 50299910Ssgalabov#include <machine/bus.h> 51299910Ssgalabov#include <dev/mii/mii.h> 52299910Ssgalabov#include <dev/mii/miivar.h> 53299910Ssgalabov#include <dev/mdio/mdio.h> 54299910Ssgalabov 55299910Ssgalabov#include <dev/etherswitch/etherswitch.h> 56299910Ssgalabov#include <dev/etherswitch/mtkswitch/mtkswitchvar.h> 57299910Ssgalabov 58299910Ssgalabov#include <dev/ofw/ofw_bus_subr.h> 59299910Ssgalabov 60299910Ssgalabov#include "mdio_if.h" 61299910Ssgalabov#include "miibus_if.h" 62299910Ssgalabov#include "etherswitch_if.h" 63299910Ssgalabov 64299910Ssgalabov#define DEBUG 65299910Ssgalabov 66299910Ssgalabov#if defined(DEBUG) 67299910Ssgalabovstatic SYSCTL_NODE(_debug, OID_AUTO, mtkswitch, CTLFLAG_RD, 0, "mtkswitch"); 68299910Ssgalabov#endif 69299910Ssgalabov 70299910Ssgalabovstatic inline int mtkswitch_portforphy(int phy); 71299910Ssgalabovstatic int mtkswitch_ifmedia_upd(struct ifnet *ifp); 72299910Ssgalabovstatic void mtkswitch_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr); 73299910Ssgalabovstatic void mtkswitch_tick(void *arg); 74299910Ssgalabov 75299910Ssgalabovstatic const struct ofw_compat_data compat_data[] = { 76299910Ssgalabov { "ralink,rt3050-esw", MTK_SWITCH_RT3050 }, 77299910Ssgalabov { "ralink,rt3352-esw", MTK_SWITCH_RT3352 }, 78299910Ssgalabov { "ralink,rt5350-esw", MTK_SWITCH_RT5350 }, 79299910Ssgalabov { "mediatek,mt7620-gsw", MTK_SWITCH_MT7620 }, 80299910Ssgalabov { "mediatek,mt7621-gsw", MTK_SWITCH_MT7621 }, 81299910Ssgalabov { "mediatek,mt7628-esw", MTK_SWITCH_MT7628 }, 82299910Ssgalabov 83299910Ssgalabov /* Sentinel */ 84299910Ssgalabov { NULL, MTK_SWITCH_NONE } 85299910Ssgalabov}; 86299910Ssgalabov 87299910Ssgalabovstatic int 88299910Ssgalabovmtkswitch_probe(device_t dev) 89299910Ssgalabov{ 90299910Ssgalabov struct mtkswitch_softc *sc; 91299910Ssgalabov mtk_switch_type switch_type; 92299910Ssgalabov 93299910Ssgalabov if (!ofw_bus_status_okay(dev)) 94299910Ssgalabov return (ENXIO); 95299910Ssgalabov 96299910Ssgalabov switch_type = ofw_bus_search_compatible(dev, compat_data)->ocd_data; 97299910Ssgalabov if (switch_type == MTK_SWITCH_NONE) 98299910Ssgalabov return (ENXIO); 99299910Ssgalabov 100299910Ssgalabov sc = device_get_softc(dev); 101299910Ssgalabov bzero(sc, sizeof(*sc)); 102299910Ssgalabov sc->sc_switchtype = switch_type; 103299910Ssgalabov 104299910Ssgalabov device_set_desc_copy(dev, "MTK Switch Driver"); 105299910Ssgalabov 106299910Ssgalabov return (0); 107299910Ssgalabov} 108299910Ssgalabov 109299910Ssgalabovstatic int 110299910Ssgalabovmtkswitch_attach_phys(struct mtkswitch_softc *sc) 111299910Ssgalabov{ 112299910Ssgalabov int phy, err = 0; 113299910Ssgalabov char name[IFNAMSIZ]; 114299910Ssgalabov 115299910Ssgalabov /* PHYs need an interface, so we generate a dummy one */ 116299910Ssgalabov snprintf(name, IFNAMSIZ, "%sport", device_get_nameunit(sc->sc_dev)); 117299910Ssgalabov for (phy = 0; phy < sc->numphys; phy++) { 118299910Ssgalabov if ((sc->phymap & (1u << phy)) == 0) { 119299910Ssgalabov sc->ifp[phy] = NULL; 120299910Ssgalabov sc->ifname[phy] = NULL; 121299910Ssgalabov sc->miibus[phy] = NULL; 122299910Ssgalabov continue; 123299910Ssgalabov } 124299910Ssgalabov sc->ifp[phy] = if_alloc(IFT_ETHER); 125299910Ssgalabov sc->ifp[phy]->if_softc = sc; 126299910Ssgalabov sc->ifp[phy]->if_flags |= IFF_UP | IFF_BROADCAST | 127299910Ssgalabov IFF_DRV_RUNNING | IFF_SIMPLEX; 128299910Ssgalabov sc->ifname[phy] = malloc(strlen(name) + 1, M_DEVBUF, M_WAITOK); 129299910Ssgalabov bcopy(name, sc->ifname[phy], strlen(name) + 1); 130299910Ssgalabov if_initname(sc->ifp[phy], sc->ifname[phy], 131299910Ssgalabov mtkswitch_portforphy(phy)); 132299910Ssgalabov err = mii_attach(sc->sc_dev, &sc->miibus[phy], sc->ifp[phy], 133299910Ssgalabov mtkswitch_ifmedia_upd, mtkswitch_ifmedia_sts, 134299910Ssgalabov BMSR_DEFCAPMASK, phy, MII_OFFSET_ANY, 0); 135299910Ssgalabov if (err != 0) { 136299910Ssgalabov device_printf(sc->sc_dev, 137299910Ssgalabov "attaching PHY %d failed\n", 138299910Ssgalabov phy); 139299910Ssgalabov } else { 140299910Ssgalabov DPRINTF(sc->sc_dev, "%s attached to pseudo interface " 141299910Ssgalabov "%s\n", device_get_nameunit(sc->miibus[phy]), 142299910Ssgalabov sc->ifp[phy]->if_xname); 143299910Ssgalabov } 144299910Ssgalabov } 145299910Ssgalabov return (err); 146299910Ssgalabov} 147299910Ssgalabov 148299910Ssgalabovstatic int 149299910Ssgalabovmtkswitch_set_vlan_mode(struct mtkswitch_softc *sc, uint32_t mode) 150299910Ssgalabov{ 151299910Ssgalabov 152299910Ssgalabov /* Check for invalid modes. */ 153299910Ssgalabov if ((mode & sc->info.es_vlan_caps) != mode) 154299910Ssgalabov return (EINVAL); 155299910Ssgalabov 156299910Ssgalabov sc->vlan_mode = mode; 157299910Ssgalabov 158299910Ssgalabov /* Reset VLANs. */ 159299910Ssgalabov sc->hal.mtkswitch_vlan_init_hw(sc); 160299910Ssgalabov 161299910Ssgalabov return (0); 162299910Ssgalabov} 163299910Ssgalabov 164299910Ssgalabovstatic int 165299910Ssgalabovmtkswitch_attach(device_t dev) 166299910Ssgalabov{ 167299910Ssgalabov struct mtkswitch_softc *sc; 168299910Ssgalabov int err = 0; 169299910Ssgalabov int port, rid; 170299910Ssgalabov 171299910Ssgalabov sc = device_get_softc(dev); 172299910Ssgalabov 173299910Ssgalabov /* sc->sc_switchtype is already decided in mtkswitch_probe() */ 174299910Ssgalabov sc->numports = MTKSWITCH_MAX_PORTS; 175299910Ssgalabov sc->numphys = MTKSWITCH_MAX_PHYS; 176299910Ssgalabov sc->cpuport = MTKSWITCH_CPU_PORT; 177299910Ssgalabov sc->sc_dev = dev; 178299910Ssgalabov 179299910Ssgalabov /* Attach switch related functions */ 180299910Ssgalabov if (sc->sc_switchtype == MTK_SWITCH_NONE) { 181299910Ssgalabov device_printf(dev, "Unknown switch type\n"); 182299910Ssgalabov return (ENXIO); 183299910Ssgalabov } 184299910Ssgalabov 185299910Ssgalabov if (sc->sc_switchtype == MTK_SWITCH_MT7620 || 186299910Ssgalabov sc->sc_switchtype == MTK_SWITCH_MT7621) 187299910Ssgalabov mtk_attach_switch_mt7620(sc); 188299910Ssgalabov else 189299910Ssgalabov mtk_attach_switch_rt3050(sc); 190299910Ssgalabov 191299910Ssgalabov /* Allocate resources */ 192299910Ssgalabov rid = 0; 193299910Ssgalabov sc->sc_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 194299910Ssgalabov RF_ACTIVE); 195299910Ssgalabov if (sc->sc_res == NULL) { 196299910Ssgalabov device_printf(dev, "could not map memory\n"); 197299910Ssgalabov return (ENXIO); 198299910Ssgalabov } 199299910Ssgalabov 200299910Ssgalabov mtx_init(&sc->sc_mtx, "mtkswitch", NULL, MTX_DEF); 201299910Ssgalabov 202299910Ssgalabov /* Reset the switch */ 203299910Ssgalabov if (sc->hal.mtkswitch_reset(sc)) { 204299910Ssgalabov DPRINTF(dev, "%s: mtkswitch_reset: failed\n", __func__); 205299910Ssgalabov return (ENXIO); 206299910Ssgalabov } 207299910Ssgalabov 208299910Ssgalabov err = sc->hal.mtkswitch_hw_setup(sc); 209299910Ssgalabov DPRINTF(dev, "%s: hw_setup: err=%d\n", __func__, err); 210299910Ssgalabov if (err != 0) 211299910Ssgalabov return (err); 212299910Ssgalabov 213299910Ssgalabov err = sc->hal.mtkswitch_hw_global_setup(sc); 214299910Ssgalabov DPRINTF(dev, "%s: hw_global_setup: err=%d\n", __func__, err); 215299910Ssgalabov if (err != 0) 216299910Ssgalabov return (err); 217299910Ssgalabov 218299910Ssgalabov /* Initialize the switch ports */ 219299910Ssgalabov for (port = 0; port < sc->numports; port++) { 220299910Ssgalabov sc->hal.mtkswitch_port_init(sc, port); 221299910Ssgalabov } 222299910Ssgalabov 223299910Ssgalabov /* Attach the PHYs and complete the bus enumeration */ 224299910Ssgalabov err = mtkswitch_attach_phys(sc); 225299910Ssgalabov DPRINTF(dev, "%s: attach_phys: err=%d\n", __func__, err); 226299910Ssgalabov if (err != 0) 227299910Ssgalabov return (err); 228299910Ssgalabov 229299910Ssgalabov /* Default to ingress filters off. */ 230299910Ssgalabov err = mtkswitch_set_vlan_mode(sc, ETHERSWITCH_VLAN_DOT1Q); 231299910Ssgalabov DPRINTF(dev, "%s: set_vlan_mode: err=%d\n", __func__, err); 232299910Ssgalabov if (err != 0) 233299910Ssgalabov return (err); 234299910Ssgalabov 235299910Ssgalabov bus_generic_probe(dev); 236299910Ssgalabov bus_enumerate_hinted_children(dev); 237299910Ssgalabov err = bus_generic_attach(dev); 238299910Ssgalabov DPRINTF(dev, "%s: bus_generic_attach: err=%d\n", __func__, err); 239299910Ssgalabov if (err != 0) 240299910Ssgalabov return (err); 241299910Ssgalabov 242299910Ssgalabov callout_init_mtx(&sc->callout_tick, &sc->sc_mtx, 0); 243299910Ssgalabov 244299910Ssgalabov MTKSWITCH_LOCK(sc); 245299910Ssgalabov mtkswitch_tick(sc); 246299910Ssgalabov MTKSWITCH_UNLOCK(sc); 247299910Ssgalabov 248299910Ssgalabov return (0); 249299910Ssgalabov} 250299910Ssgalabov 251299910Ssgalabovstatic int 252299910Ssgalabovmtkswitch_detach(device_t dev) 253299910Ssgalabov{ 254299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 255299910Ssgalabov int phy; 256299910Ssgalabov 257299910Ssgalabov callout_drain(&sc->callout_tick); 258299910Ssgalabov 259299910Ssgalabov for (phy = 0; phy < MTKSWITCH_MAX_PHYS; phy++) { 260299910Ssgalabov if (sc->miibus[phy] != NULL) 261299910Ssgalabov device_delete_child(dev, sc->miibus[phy]); 262299910Ssgalabov if (sc->ifp[phy] != NULL) 263299910Ssgalabov if_free(sc->ifp[phy]); 264299910Ssgalabov free(sc->ifname[phy], M_DEVBUF); 265299910Ssgalabov } 266299910Ssgalabov 267299910Ssgalabov bus_generic_detach(dev); 268299910Ssgalabov mtx_destroy(&sc->sc_mtx); 269299910Ssgalabov 270299910Ssgalabov return (0); 271299910Ssgalabov} 272299910Ssgalabov 273299910Ssgalabov/* PHY <-> port mapping is currently 1:1 */ 274299910Ssgalabovstatic inline int 275299910Ssgalabovmtkswitch_portforphy(int phy) 276299910Ssgalabov{ 277299910Ssgalabov 278299910Ssgalabov return (phy); 279299910Ssgalabov} 280299910Ssgalabov 281299910Ssgalabovstatic inline int 282299910Ssgalabovmtkswitch_phyforport(int port) 283299910Ssgalabov{ 284299910Ssgalabov 285299910Ssgalabov return (port); 286299910Ssgalabov} 287299910Ssgalabov 288299910Ssgalabovstatic inline struct mii_data * 289299910Ssgalabovmtkswitch_miiforport(struct mtkswitch_softc *sc, int port) 290299910Ssgalabov{ 291299910Ssgalabov int phy = mtkswitch_phyforport(port); 292299910Ssgalabov 293299910Ssgalabov if (phy < 0 || phy >= MTKSWITCH_MAX_PHYS || sc->miibus[phy] == NULL) 294299910Ssgalabov return (NULL); 295299910Ssgalabov 296299910Ssgalabov return (device_get_softc(sc->miibus[phy])); 297299910Ssgalabov} 298299910Ssgalabov 299299910Ssgalabovstatic inline struct ifnet * 300299910Ssgalabovmtkswitch_ifpforport(struct mtkswitch_softc *sc, int port) 301299910Ssgalabov{ 302299910Ssgalabov int phy = mtkswitch_phyforport(port); 303299910Ssgalabov 304299910Ssgalabov if (phy < 0 || phy >= MTKSWITCH_MAX_PHYS) 305299910Ssgalabov return (NULL); 306299910Ssgalabov 307299910Ssgalabov return (sc->ifp[phy]); 308299910Ssgalabov} 309299910Ssgalabov 310299910Ssgalabov/* 311299910Ssgalabov * Convert port status to ifmedia. 312299910Ssgalabov */ 313299910Ssgalabovstatic void 314299910Ssgalabovmtkswitch_update_ifmedia(uint32_t portstatus, u_int *media_status, 315299910Ssgalabov u_int *media_active) 316299910Ssgalabov{ 317299910Ssgalabov *media_active = IFM_ETHER; 318299910Ssgalabov *media_status = IFM_AVALID; 319299910Ssgalabov 320299910Ssgalabov if ((portstatus & MTKSWITCH_LINK_UP) != 0) 321299910Ssgalabov *media_status |= IFM_ACTIVE; 322299910Ssgalabov else { 323299910Ssgalabov *media_active |= IFM_NONE; 324299910Ssgalabov return; 325299910Ssgalabov } 326299910Ssgalabov 327299910Ssgalabov switch (portstatus & MTKSWITCH_SPEED_MASK) { 328299910Ssgalabov case MTKSWITCH_SPEED_10: 329299910Ssgalabov *media_active |= IFM_10_T; 330299910Ssgalabov break; 331299910Ssgalabov case MTKSWITCH_SPEED_100: 332299910Ssgalabov *media_active |= IFM_100_TX; 333299910Ssgalabov break; 334299910Ssgalabov case MTKSWITCH_SPEED_1000: 335299910Ssgalabov *media_active |= IFM_1000_T; 336299910Ssgalabov break; 337299910Ssgalabov } 338299910Ssgalabov 339299910Ssgalabov if ((portstatus & MTKSWITCH_DUPLEX) != 0) 340299910Ssgalabov *media_active |= IFM_FDX; 341299910Ssgalabov else 342299910Ssgalabov *media_active |= IFM_HDX; 343299910Ssgalabov 344299910Ssgalabov if ((portstatus & MTKSWITCH_TXFLOW) != 0) 345299910Ssgalabov *media_active |= IFM_ETH_TXPAUSE; 346299910Ssgalabov if ((portstatus & MTKSWITCH_RXFLOW) != 0) 347299910Ssgalabov *media_active |= IFM_ETH_RXPAUSE; 348299910Ssgalabov} 349299910Ssgalabov 350299910Ssgalabovstatic void 351299910Ssgalabovmtkswitch_miipollstat(struct mtkswitch_softc *sc) 352299910Ssgalabov{ 353299910Ssgalabov struct mii_data *mii; 354299910Ssgalabov struct mii_softc *miisc; 355299910Ssgalabov uint32_t portstatus; 356299910Ssgalabov int i, port_flap = 0; 357299910Ssgalabov 358299910Ssgalabov MTKSWITCH_LOCK_ASSERT(sc, MA_OWNED); 359299910Ssgalabov 360299910Ssgalabov for (i = 0; i < sc->numphys; i++) { 361299910Ssgalabov if (sc->miibus[i] == NULL) 362299910Ssgalabov continue; 363299910Ssgalabov mii = device_get_softc(sc->miibus[i]); 364299910Ssgalabov portstatus = sc->hal.mtkswitch_get_port_status(sc, 365299910Ssgalabov mtkswitch_portforphy(i)); 366299910Ssgalabov 367299910Ssgalabov /* If a port has flapped - mark it so we can flush the ATU */ 368299910Ssgalabov if (((mii->mii_media_status & IFM_ACTIVE) == 0 && 369299910Ssgalabov (portstatus & MTKSWITCH_LINK_UP) != 0) || 370299910Ssgalabov ((mii->mii_media_status & IFM_ACTIVE) != 0 && 371299910Ssgalabov (portstatus & MTKSWITCH_LINK_UP) == 0)) { 372299910Ssgalabov port_flap = 1; 373299910Ssgalabov } 374299910Ssgalabov 375299910Ssgalabov mtkswitch_update_ifmedia(portstatus, &mii->mii_media_status, 376299910Ssgalabov &mii->mii_media_active); 377299910Ssgalabov LIST_FOREACH(miisc, &mii->mii_phys, mii_list) { 378299910Ssgalabov if (IFM_INST(mii->mii_media.ifm_cur->ifm_media) != 379299910Ssgalabov miisc->mii_inst) 380299910Ssgalabov continue; 381299910Ssgalabov mii_phy_update(miisc, MII_POLLSTAT); 382299910Ssgalabov } 383299910Ssgalabov } 384299910Ssgalabov 385299910Ssgalabov if (port_flap) 386299910Ssgalabov sc->hal.mtkswitch_atu_flush(sc); 387299910Ssgalabov} 388299910Ssgalabov 389299910Ssgalabovstatic void 390299910Ssgalabovmtkswitch_tick(void *arg) 391299910Ssgalabov{ 392299910Ssgalabov struct mtkswitch_softc *sc = arg; 393299910Ssgalabov 394299910Ssgalabov mtkswitch_miipollstat(sc); 395299910Ssgalabov callout_reset(&sc->callout_tick, hz, mtkswitch_tick, sc); 396299910Ssgalabov} 397299910Ssgalabov 398299910Ssgalabovstatic void 399299910Ssgalabovmtkswitch_lock(device_t dev) 400299910Ssgalabov{ 401299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 402299910Ssgalabov 403299910Ssgalabov MTKSWITCH_LOCK_ASSERT(sc, MA_NOTOWNED); 404299910Ssgalabov MTKSWITCH_LOCK(sc); 405299910Ssgalabov} 406299910Ssgalabov 407299910Ssgalabovstatic void 408299910Ssgalabovmtkswitch_unlock(device_t dev) 409299910Ssgalabov{ 410299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 411299910Ssgalabov 412299910Ssgalabov MTKSWITCH_LOCK_ASSERT(sc, MA_OWNED); 413299910Ssgalabov MTKSWITCH_UNLOCK(sc); 414299910Ssgalabov} 415299910Ssgalabov 416299910Ssgalabovstatic etherswitch_info_t * 417299910Ssgalabovmtkswitch_getinfo(device_t dev) 418299910Ssgalabov{ 419299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 420299910Ssgalabov 421299910Ssgalabov return (&sc->info); 422299910Ssgalabov} 423299910Ssgalabov 424299910Ssgalabovstatic inline int 425299910Ssgalabovmtkswitch_is_cpuport(struct mtkswitch_softc *sc, int port) 426299910Ssgalabov{ 427299910Ssgalabov 428299910Ssgalabov return (sc->cpuport == port); 429299910Ssgalabov} 430299910Ssgalabov 431299910Ssgalabovstatic int 432299910Ssgalabovmtkswitch_getport(device_t dev, etherswitch_port_t *p) 433299910Ssgalabov{ 434299910Ssgalabov struct mtkswitch_softc *sc; 435299910Ssgalabov struct mii_data *mii; 436299910Ssgalabov struct ifmediareq *ifmr; 437299910Ssgalabov int err; 438299910Ssgalabov 439299910Ssgalabov sc = device_get_softc(dev); 440299910Ssgalabov if (p->es_port < 0 || p->es_port > sc->info.es_nports) 441299910Ssgalabov return (ENXIO); 442299910Ssgalabov 443299910Ssgalabov err = sc->hal.mtkswitch_port_vlan_get(sc, p); 444299910Ssgalabov if (err != 0) 445299910Ssgalabov return (err); 446299910Ssgalabov 447299910Ssgalabov mii = mtkswitch_miiforport(sc, p->es_port); 448299910Ssgalabov if (mtkswitch_is_cpuport(sc, p->es_port)) { 449299910Ssgalabov /* fill in fixed values for CPU port */ 450299910Ssgalabov /* XXX is this valid in all cases? */ 451299910Ssgalabov p->es_flags |= ETHERSWITCH_PORT_CPU; 452299910Ssgalabov ifmr = &p->es_ifmr; 453299910Ssgalabov ifmr->ifm_count = 0; 454299910Ssgalabov ifmr->ifm_current = ifmr->ifm_active = 455299910Ssgalabov IFM_ETHER | IFM_1000_T | IFM_FDX; 456299910Ssgalabov ifmr->ifm_mask = 0; 457299910Ssgalabov ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID; 458299910Ssgalabov } else if (mii != NULL) { 459299910Ssgalabov err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr, 460299910Ssgalabov &mii->mii_media, SIOCGIFMEDIA); 461299910Ssgalabov if (err) 462299910Ssgalabov return (err); 463299910Ssgalabov } else { 464299910Ssgalabov ifmr = &p->es_ifmr; 465299910Ssgalabov ifmr->ifm_count = 0; 466299910Ssgalabov ifmr->ifm_current = ifmr->ifm_active = IFM_NONE; 467299910Ssgalabov ifmr->ifm_mask = 0; 468299910Ssgalabov ifmr->ifm_status = 0; 469299910Ssgalabov } 470299910Ssgalabov return (0); 471299910Ssgalabov} 472299910Ssgalabov 473299910Ssgalabovstatic int 474299910Ssgalabovmtkswitch_setport(device_t dev, etherswitch_port_t *p) 475299910Ssgalabov{ 476299910Ssgalabov int err; 477299910Ssgalabov struct mtkswitch_softc *sc; 478299910Ssgalabov struct ifmedia *ifm; 479299910Ssgalabov struct mii_data *mii; 480299910Ssgalabov struct ifnet *ifp; 481299910Ssgalabov 482299910Ssgalabov sc = device_get_softc(dev); 483299910Ssgalabov if (p->es_port < 0 || p->es_port > sc->info.es_nports) 484299910Ssgalabov return (ENXIO); 485299910Ssgalabov 486299910Ssgalabov /* Port flags. */ 487299910Ssgalabov if (sc->vlan_mode == ETHERSWITCH_VLAN_DOT1Q) { 488299910Ssgalabov err = sc->hal.mtkswitch_port_vlan_setup(sc, p); 489299910Ssgalabov if (err) 490299910Ssgalabov return (err); 491299910Ssgalabov } 492299910Ssgalabov 493299910Ssgalabov /* Do not allow media changes on CPU port. */ 494299910Ssgalabov if (mtkswitch_is_cpuport(sc, p->es_port)) 495299910Ssgalabov return (0); 496299910Ssgalabov 497299910Ssgalabov mii = mtkswitch_miiforport(sc, p->es_port); 498299910Ssgalabov if (mii == NULL) 499299910Ssgalabov return (ENXIO); 500299910Ssgalabov 501299910Ssgalabov ifp = mtkswitch_ifpforport(sc, p->es_port); 502299910Ssgalabov 503299910Ssgalabov ifm = &mii->mii_media; 504299910Ssgalabov return (ifmedia_ioctl(ifp, &p->es_ifr, ifm, SIOCSIFMEDIA)); 505299910Ssgalabov} 506299910Ssgalabov 507299910Ssgalabovstatic void 508299910Ssgalabovmtkswitch_statchg(device_t dev) 509299910Ssgalabov{ 510299910Ssgalabov 511299910Ssgalabov DPRINTF(dev, "%s\n", __func__); 512299910Ssgalabov} 513299910Ssgalabov 514299910Ssgalabovstatic int 515299910Ssgalabovmtkswitch_ifmedia_upd(struct ifnet *ifp) 516299910Ssgalabov{ 517299910Ssgalabov struct mtkswitch_softc *sc = ifp->if_softc; 518299910Ssgalabov struct mii_data *mii = mtkswitch_miiforport(sc, ifp->if_dunit); 519299910Ssgalabov 520299910Ssgalabov if (mii == NULL) 521299910Ssgalabov return (ENXIO); 522299910Ssgalabov mii_mediachg(mii); 523299910Ssgalabov return (0); 524299910Ssgalabov} 525299910Ssgalabov 526299910Ssgalabovstatic void 527299910Ssgalabovmtkswitch_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 528299910Ssgalabov{ 529299910Ssgalabov struct mtkswitch_softc *sc = ifp->if_softc; 530299910Ssgalabov struct mii_data *mii = mtkswitch_miiforport(sc, ifp->if_dunit); 531299910Ssgalabov 532299910Ssgalabov DPRINTF(sc->sc_dev, "%s\n", __func__); 533299910Ssgalabov 534299910Ssgalabov if (mii == NULL) 535299910Ssgalabov return; 536299910Ssgalabov mii_pollstat(mii); 537299910Ssgalabov ifmr->ifm_active = mii->mii_media_active; 538299910Ssgalabov ifmr->ifm_status = mii->mii_media_status; 539299910Ssgalabov} 540299910Ssgalabov 541299910Ssgalabovstatic int 542299910Ssgalabovmtkswitch_getconf(device_t dev, etherswitch_conf_t *conf) 543299910Ssgalabov{ 544299910Ssgalabov struct mtkswitch_softc *sc; 545299910Ssgalabov 546299910Ssgalabov sc = device_get_softc(dev); 547299910Ssgalabov 548299910Ssgalabov /* Return the VLAN mode. */ 549299910Ssgalabov conf->cmd = ETHERSWITCH_CONF_VLAN_MODE; 550299910Ssgalabov conf->vlan_mode = sc->vlan_mode; 551299910Ssgalabov 552299910Ssgalabov return (0); 553299910Ssgalabov} 554299910Ssgalabov 555299910Ssgalabovstatic int 556299910Ssgalabovmtkswitch_setconf(device_t dev, etherswitch_conf_t *conf) 557299910Ssgalabov{ 558299910Ssgalabov struct mtkswitch_softc *sc; 559299910Ssgalabov int err; 560299910Ssgalabov 561299910Ssgalabov sc = device_get_softc(dev); 562299910Ssgalabov 563299910Ssgalabov /* Set the VLAN mode. */ 564299910Ssgalabov if (conf->cmd & ETHERSWITCH_CONF_VLAN_MODE) { 565299910Ssgalabov err = mtkswitch_set_vlan_mode(sc, conf->vlan_mode); 566299910Ssgalabov if (err != 0) 567299910Ssgalabov return (err); 568299910Ssgalabov } 569299910Ssgalabov 570299910Ssgalabov return (0); 571299910Ssgalabov} 572299910Ssgalabov 573299910Ssgalabovstatic int 574299910Ssgalabovmtkswitch_getvgroup(device_t dev, etherswitch_vlangroup_t *e) 575299910Ssgalabov{ 576299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 577299910Ssgalabov 578299910Ssgalabov return (sc->hal.mtkswitch_vlan_getvgroup(sc, e)); 579299910Ssgalabov} 580299910Ssgalabov 581299910Ssgalabovstatic int 582299910Ssgalabovmtkswitch_setvgroup(device_t dev, etherswitch_vlangroup_t *e) 583299910Ssgalabov{ 584299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 585299910Ssgalabov 586299910Ssgalabov return (sc->hal.mtkswitch_vlan_setvgroup(sc, e)); 587299910Ssgalabov} 588299910Ssgalabov 589299910Ssgalabovstatic int 590299910Ssgalabovmtkswitch_readphy(device_t dev, int phy, int reg) 591299910Ssgalabov{ 592299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 593299910Ssgalabov 594299910Ssgalabov return (sc->hal.mtkswitch_phy_read(dev, phy, reg)); 595299910Ssgalabov} 596299910Ssgalabov 597299910Ssgalabovstatic int 598299910Ssgalabovmtkswitch_writephy(device_t dev, int phy, int reg, int val) 599299910Ssgalabov{ 600299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 601299910Ssgalabov 602299910Ssgalabov return (sc->hal.mtkswitch_phy_write(dev, phy, reg, val)); 603299910Ssgalabov} 604299910Ssgalabov 605299910Ssgalabovstatic int 606299910Ssgalabovmtkswitch_readreg(device_t dev, int addr) 607299910Ssgalabov{ 608299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 609299910Ssgalabov 610299910Ssgalabov return (sc->hal.mtkswitch_reg_read(dev, addr)); 611299910Ssgalabov} 612299910Ssgalabov 613299910Ssgalabovstatic int 614299910Ssgalabovmtkswitch_writereg(device_t dev, int addr, int value) 615299910Ssgalabov{ 616299910Ssgalabov struct mtkswitch_softc *sc = device_get_softc(dev); 617299910Ssgalabov 618299910Ssgalabov return (sc->hal.mtkswitch_reg_write(dev, addr, value)); 619299910Ssgalabov} 620299910Ssgalabov 621299910Ssgalabovstatic device_method_t mtkswitch_methods[] = { 622299910Ssgalabov /* Device interface */ 623299910Ssgalabov DEVMETHOD(device_probe, mtkswitch_probe), 624299910Ssgalabov DEVMETHOD(device_attach, mtkswitch_attach), 625299910Ssgalabov DEVMETHOD(device_detach, mtkswitch_detach), 626299910Ssgalabov 627299910Ssgalabov /* bus interface */ 628299910Ssgalabov DEVMETHOD(bus_add_child, device_add_child_ordered), 629299910Ssgalabov 630299910Ssgalabov /* MII interface */ 631299910Ssgalabov DEVMETHOD(miibus_readreg, mtkswitch_readphy), 632299910Ssgalabov DEVMETHOD(miibus_writereg, mtkswitch_writephy), 633299910Ssgalabov DEVMETHOD(miibus_statchg, mtkswitch_statchg), 634299910Ssgalabov 635299910Ssgalabov /* MDIO interface */ 636299910Ssgalabov DEVMETHOD(mdio_readreg, mtkswitch_readphy), 637299910Ssgalabov DEVMETHOD(mdio_writereg, mtkswitch_writephy), 638299910Ssgalabov 639299910Ssgalabov /* ehterswitch interface */ 640299910Ssgalabov DEVMETHOD(etherswitch_lock, mtkswitch_lock), 641299910Ssgalabov DEVMETHOD(etherswitch_unlock, mtkswitch_unlock), 642299910Ssgalabov DEVMETHOD(etherswitch_getinfo, mtkswitch_getinfo), 643299910Ssgalabov DEVMETHOD(etherswitch_readreg, mtkswitch_readreg), 644299910Ssgalabov DEVMETHOD(etherswitch_writereg, mtkswitch_writereg), 645299910Ssgalabov DEVMETHOD(etherswitch_readphyreg, mtkswitch_readphy), 646299910Ssgalabov DEVMETHOD(etherswitch_writephyreg, mtkswitch_writephy), 647299910Ssgalabov DEVMETHOD(etherswitch_getport, mtkswitch_getport), 648299910Ssgalabov DEVMETHOD(etherswitch_setport, mtkswitch_setport), 649299910Ssgalabov DEVMETHOD(etherswitch_getvgroup, mtkswitch_getvgroup), 650299910Ssgalabov DEVMETHOD(etherswitch_setvgroup, mtkswitch_setvgroup), 651299910Ssgalabov DEVMETHOD(etherswitch_getconf, mtkswitch_getconf), 652299910Ssgalabov DEVMETHOD(etherswitch_setconf, mtkswitch_setconf), 653299910Ssgalabov 654299910Ssgalabov DEVMETHOD_END 655299910Ssgalabov}; 656299910Ssgalabov 657299910SsgalabovDEFINE_CLASS_0(mtkswitch, mtkswitch_driver, mtkswitch_methods, 658299910Ssgalabov sizeof(struct mtkswitch_softc)); 659299910Ssgalabovstatic devclass_t mtkswitch_devclass; 660299910Ssgalabov 661299910SsgalabovDRIVER_MODULE(mtkswitch, simplebus, mtkswitch_driver, mtkswitch_devclass, 0, 0); 662299910SsgalabovDRIVER_MODULE(miibus, mtkswitch, miibus_driver, miibus_devclass, 0, 0); 663299910SsgalabovDRIVER_MODULE(mdio, mtkswitch, mdio_driver, mdio_devclass, 0, 0); 664299910SsgalabovDRIVER_MODULE(etherswitch, mtkswitch, etherswitch_driver, etherswitch_devclass, 665299910Ssgalabov 0, 0); 666299910SsgalabovMODULE_VERSION(mtkswitch, 1); 667299910SsgalabovMODULE_DEPEND(mtkswitch, miibus, 1, 1, 1); 668299910SsgalabovMODULE_DEPEND(mtkswitch, etherswitch, 1, 1, 1); 669