sys/dev/etherswitch/arswitch/arswitch_8327.c

   1 /*-
   2  * Copyright (c) 2011-2012 Stefan Bethke.
   3  * Copyright (c) 2014 Adrian Chadd.
   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  * $FreeBSD$
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/bus.h>
  32 #include <sys/errno.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/socket.h>
  36 #include <sys/sockio.h>
  37 #include <sys/sysctl.h>
  38 #include <sys/systm.h>
  39
  40 #include <net/if.h>
  41 #include <net/if_arp.h>
  42 #include <net/ethernet.h>
  43 #include <net/if_dl.h>
  44 #include <net/if_media.h>
  45 #include <net/if_types.h>
  46
  47 #include <machine/bus.h>
  48 #include <dev/iicbus/iic.h>
  49 #include <dev/iicbus/iiconf.h>
  50 #include <dev/iicbus/iicbus.h>
  51 #include <dev/mii/mii.h>
  52 #include <dev/mii/miivar.h>
  53 #include <dev/etherswitch/mdio.h>
  54
  55 #include <dev/etherswitch/etherswitch.h>
  56
  57 #include <dev/etherswitch/arswitch/arswitchreg.h>
  58 #include <dev/etherswitch/arswitch/arswitchvar.h>
  59 #include <dev/etherswitch/arswitch/arswitch_reg.h>
  60 #include <dev/etherswitch/arswitch/arswitch_phy.h>
  61 #include <dev/etherswitch/arswitch/arswitch_vlans.h>
  62
  63 #include <dev/etherswitch/arswitch/arswitch_8327.h>
  64
  65 #include "mdio_if.h"
  66 #include "miibus_if.h"
  67 #include "etherswitch_if.h"
  68
  69 /*
  70  * AR8327 TODO:
  71  *
  72  * There should be a default hardware setup hint set for the default
  73  * switch config.  Otherwise the default is "all ports in one vlangroup",
  74  * which means both CPU ports can see each other and that will quickly
  75  * lead to traffic storms/loops.
  76  */
  77
  78 static int
  79 ar8327_vlan_op(struct arswitch_softc *sc, uint32_t op, uint32_t vid,
  80     uint32_t data)
  81 {
  82         int err;
  83
  84         /*
  85          * Wait for the "done" bit to finish.
  86          */
  87         if (arswitch_waitreg(sc->sc_dev, AR8327_REG_VTU_FUNC1,
  88             AR8327_VTU_FUNC1_BUSY, 0, 5))
  89                 return (EBUSY);
  90
  91         /*
  92          * If it's a "load" operation, then ensure 'data' is loaded
  93          * in first.
  94          */
  95         if ((op & AR8327_VTU_FUNC1_OP) == AR8327_VTU_FUNC1_OP_LOAD) {
  96                 err = arswitch_writereg(sc->sc_dev, AR8327_REG_VTU_FUNC0, data);
  97                 if (err)
  98                         return (err);
  99         }
 100
 101         /*
 102          * Set the VID.
 103          */
 104         op |= ((vid & 0xfff) << AR8327_VTU_FUNC1_VID_S);
 105
 106         /*
 107          * Set busy bit to start loading in the command.
 108          */
 109         op |= AR8327_VTU_FUNC1_BUSY;
 110         arswitch_writereg(sc->sc_dev, AR8327_REG_VTU_FUNC1, op);
 111
 112         /*
 113          * Finally - wait for it to load.
 114          */
 115         if (arswitch_waitreg(sc->sc_dev, AR8327_REG_VTU_FUNC1,
 116             AR8327_VTU_FUNC1_BUSY, 0, 5))
 117                 return (EBUSY);
 118
 119         return (0);
 120 }
 121
 122 static void
 123 ar8327_phy_fixup(struct arswitch_softc *sc, int phy)
 124 {
 125         if (bootverbose)
 126                 device_printf(sc->sc_dev,
 127                     "%s: called; phy=%d; chiprev=%d\n", __func__,
 128                     phy,
 129                     sc->chip_rev);
 130         switch (sc->chip_rev) {
 131         case 1:
 132                 /* For 100M waveform */
 133                 arswitch_writedbg(sc->sc_dev, phy, 0, 0x02ea);
 134                 /* Turn on Gigabit clock */
 135                 arswitch_writedbg(sc->sc_dev, phy, 0x3d, 0x68a0);
 136                 break;
 137
 138         case 2:
 139                 arswitch_writemmd(sc->sc_dev, phy, 0x7, 0x3c);
 140                 arswitch_writemmd(sc->sc_dev, phy, 0x4007, 0x0);
 141                 /* fallthrough */
 142         case 4:
 143                 arswitch_writemmd(sc->sc_dev, phy, 0x3, 0x800d);
 144                 arswitch_writemmd(sc->sc_dev, phy, 0x4003, 0x803f);
 145
 146                 arswitch_writedbg(sc->sc_dev, phy, 0x3d, 0x6860);
 147                 arswitch_writedbg(sc->sc_dev, phy, 0x5, 0x2c46);
 148                 arswitch_writedbg(sc->sc_dev, phy, 0x3c, 0x6000);
 149                 break;
 150         }
 151 }
 152
 153 static uint32_t
 154 ar8327_get_pad_cfg(struct ar8327_pad_cfg *cfg)
 155 {
 156         uint32_t t;
 157
 158         if (!cfg)
 159                 return (0);
 160
 161         t = 0;
 162         switch (cfg->mode) {
 163         case AR8327_PAD_NC:
 164                 break;
 165
 166         case AR8327_PAD_MAC2MAC_MII:
 167                 t = AR8327_PAD_MAC_MII_EN;
 168                 if (cfg->rxclk_sel)
 169                         t |= AR8327_PAD_MAC_MII_RXCLK_SEL;
 170                 if (cfg->txclk_sel)
 171                         t |= AR8327_PAD_MAC_MII_TXCLK_SEL;
 172                 break;
 173
 174         case AR8327_PAD_MAC2MAC_GMII:
 175                 t = AR8327_PAD_MAC_GMII_EN;
 176                 if (cfg->rxclk_sel)
 177                         t |= AR8327_PAD_MAC_GMII_RXCLK_SEL;
 178                 if (cfg->txclk_sel)
 179                         t |= AR8327_PAD_MAC_GMII_TXCLK_SEL;
 180                 break;
 181
 182         case AR8327_PAD_MAC_SGMII:
 183                 t = AR8327_PAD_SGMII_EN;
 184
 185                 /*
 186                  * WAR for the Qualcomm Atheros AP136 board.
 187                  * It seems that RGMII TX/RX delay settings needs to be
 188                  * applied for SGMII mode as well, The ethernet is not
 189                  * reliable without this.
 190                  */
 191                 t |= cfg->txclk_delay_sel << AR8327_PAD_RGMII_TXCLK_DELAY_SEL_S;
 192                 t |= cfg->rxclk_delay_sel << AR8327_PAD_RGMII_RXCLK_DELAY_SEL_S;
 193                 if (cfg->rxclk_delay_en)
 194                         t |= AR8327_PAD_RGMII_RXCLK_DELAY_EN;
 195                 if (cfg->txclk_delay_en)
 196                         t |= AR8327_PAD_RGMII_TXCLK_DELAY_EN;
 197
 198                 if (cfg->sgmii_delay_en)
 199                         t |= AR8327_PAD_SGMII_DELAY_EN;
 200
 201                 break;
 202
 203         case AR8327_PAD_MAC2PHY_MII:
 204                 t = AR8327_PAD_PHY_MII_EN;
 205                 if (cfg->rxclk_sel)
 206                         t |= AR8327_PAD_PHY_MII_RXCLK_SEL;
 207                 if (cfg->txclk_sel)
 208                         t |= AR8327_PAD_PHY_MII_TXCLK_SEL;
 209                 break;
 210
 211         case AR8327_PAD_MAC2PHY_GMII:
 212                 t = AR8327_PAD_PHY_GMII_EN;
 213                 if (cfg->pipe_rxclk_sel)
 214                         t |= AR8327_PAD_PHY_GMII_PIPE_RXCLK_SEL;
 215                 if (cfg->rxclk_sel)
 216                         t |= AR8327_PAD_PHY_GMII_RXCLK_SEL;
 217                 if (cfg->txclk_sel)
 218                         t |= AR8327_PAD_PHY_GMII_TXCLK_SEL;
 219                 break;
 220
 221         case AR8327_PAD_MAC_RGMII:
 222                 t = AR8327_PAD_RGMII_EN;
 223                 t |= cfg->txclk_delay_sel << AR8327_PAD_RGMII_TXCLK_DELAY_SEL_S;
 224                 t |= cfg->rxclk_delay_sel << AR8327_PAD_RGMII_RXCLK_DELAY_SEL_S;
 225                 if (cfg->rxclk_delay_en)
 226                         t |= AR8327_PAD_RGMII_RXCLK_DELAY_EN;
 227                 if (cfg->txclk_delay_en)
 228                         t |= AR8327_PAD_RGMII_TXCLK_DELAY_EN;
 229                 break;
 230
 231         case AR8327_PAD_PHY_GMII:
 232                 t = AR8327_PAD_PHYX_GMII_EN;
 233                 break;
 234
 235         case AR8327_PAD_PHY_RGMII:
 236                 t = AR8327_PAD_PHYX_RGMII_EN;
 237                 break;
 238
 239         case AR8327_PAD_PHY_MII:
 240                 t = AR8327_PAD_PHYX_MII_EN;
 241                 break;
 242         }
 243
 244         return (t);
 245 }
 246
 247 /*
 248  * Map the hard-coded port config from the switch setup to
 249  * the chipset port config (status, duplex, flow, etc.)
 250  */
 251 static uint32_t
 252 ar8327_get_port_init_status(struct ar8327_port_cfg *cfg)
 253 {
 254         uint32_t t;
 255
 256         if (!cfg->force_link)
 257                 return (AR8X16_PORT_STS_LINK_AUTO);
 258
 259         t = AR8X16_PORT_STS_TXMAC | AR8X16_PORT_STS_RXMAC;
 260         t |= cfg->duplex ? AR8X16_PORT_STS_DUPLEX : 0;
 261         t |= cfg->rxpause ? AR8X16_PORT_STS_RXFLOW : 0;
 262         t |= cfg->txpause ? AR8X16_PORT_STS_TXFLOW : 0;
 263
 264         switch (cfg->speed) {
 265         case AR8327_PORT_SPEED_10:
 266                 t |= AR8X16_PORT_STS_SPEED_10;
 267                 break;
 268         case AR8327_PORT_SPEED_100:
 269                 t |= AR8X16_PORT_STS_SPEED_100;
 270                 break;
 271         case AR8327_PORT_SPEED_1000:
 272                 t |= AR8X16_PORT_STS_SPEED_1000;
 273                 break;
 274         }
 275
 276         return (t);
 277 }
 278
 279 /*
 280  * Fetch the port data for the given port.
 281  *
 282  * This goes and does dirty things with the hints space
 283  * to determine what the configuration parameters should be.
 284  *
 285  * Returns 1 if the structure was successfully parsed and
 286  * the contents are valid; 0 otherwise.
 287  */
 288 static int
 289 ar8327_fetch_pdata_port(struct arswitch_softc *sc,
 290     struct ar8327_port_cfg *pcfg,
 291     int port)
 292 {
 293         int val;
 294         char sbuf[128];
 295
 296         /* Check if force_link exists */
 297         val = 0;
 298         snprintf(sbuf, 128, "port.%d.force_link", port);
 299         (void) resource_int_value(device_get_name(sc->sc_dev),
 300             device_get_unit(sc->sc_dev),
 301             sbuf, &val);
 302         if (val != 1)
 303                 return (0);
 304         pcfg->force_link = 1;
 305
 306         /* force_link is set; let's parse the rest of the fields */
 307         snprintf(sbuf, 128, "port.%d.speed", port);
 308         if (resource_int_value(device_get_name(sc->sc_dev),
 309             device_get_unit(sc->sc_dev),
 310             sbuf, &val) == 0) {
 311                 switch (val) {
 312                 case 10:
 313                         pcfg->speed = AR8327_PORT_SPEED_10;
 314                         break;
 315                 case 100:
 316                         pcfg->speed = AR8327_PORT_SPEED_100;
 317                         break;
 318                 case 1000:
 319                         pcfg->speed = AR8327_PORT_SPEED_1000;
 320                         break;
 321                 default:
 322                         device_printf(sc->sc_dev,
 323                             "%s: invalid port %d duplex value (%d)\n",
 324                             __func__,
 325                             port,
 326                             val);
 327                         return (0);
 328                 }
 329         }
 330
 331         snprintf(sbuf, 128, "port.%d.duplex", port);
 332         if (resource_int_value(device_get_name(sc->sc_dev),
 333             device_get_unit(sc->sc_dev),
 334             sbuf, &val) == 0)
 335                 pcfg->duplex = val;
 336
 337         snprintf(sbuf, 128, "port.%d.txpause", port);
 338         if (resource_int_value(device_get_name(sc->sc_dev),
 339             device_get_unit(sc->sc_dev),
 340             sbuf, &val) == 0)
 341                 pcfg->txpause = val;
 342
 343         snprintf(sbuf, 128, "port.%d.rxpause", port);
 344         if (resource_int_value(device_get_name(sc->sc_dev),
 345             device_get_unit(sc->sc_dev),
 346             sbuf, &val) == 0)
 347                 pcfg->rxpause = val;
 348
 349 #if 1
 350         device_printf(sc->sc_dev,
 351             "%s: port %d: speed=%d, duplex=%d, txpause=%d, rxpause=%d\n",
 352             __func__,
 353             port,
 354             pcfg->speed,
 355             pcfg->duplex,
 356             pcfg->txpause,
 357             pcfg->rxpause);
 358 #endif
 359
 360         return (1);
 361 }
 362
 363 /*
 364  * Parse the pad configuration from the boot hints.
 365  *
 366  * The (mostly optional) fields are:
 367  *
 368  * uint32_t mode;
 369  * uint32_t rxclk_sel;
 370  * uint32_t txclk_sel;
 371  * uint32_t txclk_delay_sel;
 372  * uint32_t rxclk_delay_sel;
 373  * uint32_t txclk_delay_en;
 374  * uint32_t rxclk_delay_en;
 375  * uint32_t sgmii_delay_en;
 376  * uint32_t pipe_rxclk_sel;
 377  *
 378  * If mode isn't in the hints, 0 is returned.
 379  * Else the structure is fleshed out and 1 is returned.
 380  */
 381 static int
 382 ar8327_fetch_pdata_pad(struct arswitch_softc *sc,
 383     struct ar8327_pad_cfg *pc,
 384     int pad)
 385 {
 386         int val;
 387         char sbuf[128];
 388
 389         /* Check if mode exists */
 390         val = 0;
 391         snprintf(sbuf, 128, "pad.%d.mode", pad);
 392         if (resource_int_value(device_get_name(sc->sc_dev),
 393             device_get_unit(sc->sc_dev),
 394             sbuf, &val) != 0)
 395                 return (0);
 396
 397         /* assume that 'mode' exists and was found */
 398         pc->mode = val;
 399
 400         snprintf(sbuf, 128, "pad.%d.rxclk_sel", pad);
 401         if (resource_int_value(device_get_name(sc->sc_dev),
 402             device_get_unit(sc->sc_dev),
 403             sbuf, &val) == 0)
 404                 pc->rxclk_sel = val;
 405
 406         snprintf(sbuf, 128, "pad.%d.txclk_sel", pad);
 407         if (resource_int_value(device_get_name(sc->sc_dev),
 408             device_get_unit(sc->sc_dev),
 409             sbuf, &val) == 0)
 410                 pc->txclk_sel = val;
 411
 412         snprintf(sbuf, 128, "pad.%d.txclk_delay_sel", pad);
 413         if (resource_int_value(device_get_name(sc->sc_dev),
 414             device_get_unit(sc->sc_dev),
 415             sbuf, &val) == 0)
 416                 pc->txclk_delay_sel = val;
 417
 418         snprintf(sbuf, 128, "pad.%d.rxclk_delay_sel", pad);
 419         if (resource_int_value(device_get_name(sc->sc_dev),
 420             device_get_unit(sc->sc_dev),
 421             sbuf, &val) == 0)
 422                 pc->rxclk_delay_sel = val;
 423
 424         snprintf(sbuf, 128, "pad.%d.txclk_delay_en", pad);
 425         if (resource_int_value(device_get_name(sc->sc_dev),
 426             device_get_unit(sc->sc_dev),
 427             sbuf, &val) == 0)
 428                 pc->txclk_delay_en = val;
 429
 430         snprintf(sbuf, 128, "pad.%d.rxclk_delay_en", pad);
 431         if (resource_int_value(device_get_name(sc->sc_dev),
 432             device_get_unit(sc->sc_dev),
 433             sbuf, &val) == 0)
 434                 pc->rxclk_delay_en = val;
 435
 436         snprintf(sbuf, 128, "pad.%d.sgmii_delay_en", pad);
 437         if (resource_int_value(device_get_name(sc->sc_dev),
 438             device_get_unit(sc->sc_dev),
 439             sbuf, &val) == 0)
 440                 pc->sgmii_delay_en = val;
 441
 442         snprintf(sbuf, 128, "pad.%d.pipe_rxclk_sel", pad);
 443         if (resource_int_value(device_get_name(sc->sc_dev),
 444             device_get_unit(sc->sc_dev),
 445             sbuf, &val) == 0)
 446                 pc->pipe_rxclk_sel = val;
 447
 448         if (bootverbose) {
 449                 device_printf(sc->sc_dev,
 450                     "%s: pad %d: mode=%d, rxclk_sel=%d, txclk_sel=%d, "
 451                     "txclk_delay_sel=%d, rxclk_delay_sel=%d, txclk_delay_en=%d, "
 452                     "rxclk_enable_en=%d, sgmii_delay_en=%d, pipe_rxclk_sel=%d\n",
 453                     __func__,
 454                     pad,
 455                     pc->mode,
 456                     pc->rxclk_sel,
 457                     pc->txclk_sel,
 458                     pc->txclk_delay_sel,
 459                     pc->rxclk_delay_sel,
 460                     pc->txclk_delay_en,
 461                     pc->rxclk_delay_en,
 462                     pc->sgmii_delay_en,
 463                     pc->pipe_rxclk_sel);
 464         }
 465
 466         return (1);
 467 }
 468
 469 /*
 470  * Fetch the SGMII configuration block from the boot hints.
 471  */
 472 static int
 473 ar8327_fetch_pdata_sgmii(struct arswitch_softc *sc,
 474     struct ar8327_sgmii_cfg *scfg)
 475 {
 476         int val;
 477
 478         /* sgmii_ctrl */
 479         val = 0;
 480         if (resource_int_value(device_get_name(sc->sc_dev),
 481             device_get_unit(sc->sc_dev),
 482             "sgmii.ctrl", &val) != 0)
 483                 return (0);
 484         scfg->sgmii_ctrl = val;
 485
 486         /* serdes_aen */
 487         val = 0;
 488         if (resource_int_value(device_get_name(sc->sc_dev),
 489             device_get_unit(sc->sc_dev),
 490             "sgmii.serdes_aen", &val) != 0)
 491                 return (0);
 492         scfg->serdes_aen = val;
 493
 494         return (1);
 495 }
 496
 497 /*
 498  * Fetch the LED configuration from the boot hints.
 499  */
 500 static int
 501 ar8327_fetch_pdata_led(struct arswitch_softc *sc,
 502     struct ar8327_led_cfg *lcfg)
 503 {
 504         int val;
 505
 506         val = 0;
 507         if (resource_int_value(device_get_name(sc->sc_dev),
 508             device_get_unit(sc->sc_dev),
 509             "led.ctrl0", &val) != 0)
 510                 return (0);
 511         lcfg->led_ctrl0 = val;
 512
 513         val = 0;
 514         if (resource_int_value(device_get_name(sc->sc_dev),
 515             device_get_unit(sc->sc_dev),
 516             "led.ctrl1", &val) != 0)
 517                 return (0);
 518         lcfg->led_ctrl1 = val;
 519
 520         val = 0;
 521         if (resource_int_value(device_get_name(sc->sc_dev),
 522             device_get_unit(sc->sc_dev),
 523             "led.ctrl2", &val) != 0)
 524                 return (0);
 525         lcfg->led_ctrl2 = val;
 526
 527         val = 0;
 528         if (resource_int_value(device_get_name(sc->sc_dev),
 529             device_get_unit(sc->sc_dev),
 530             "led.ctrl3", &val) != 0)
 531                 return (0);
 532         lcfg->led_ctrl3 = val;
 533
 534         val = 0;
 535         if (resource_int_value(device_get_name(sc->sc_dev),
 536             device_get_unit(sc->sc_dev),
 537             "led.open_drain", &val) != 0)
 538                 return (0);
 539         lcfg->open_drain = val;
 540
 541         return (1);
 542 }
 543
 544 /*
 545  * Initialise the ar8327 specific hardware features from
 546  * the hints provided in the boot environment.
 547  */
 548 static int
 549 ar8327_init_pdata(struct arswitch_softc *sc)
 550 {
 551         struct ar8327_pad_cfg pc;
 552         struct ar8327_port_cfg port_cfg;
 553         struct ar8327_sgmii_cfg scfg;
 554         struct ar8327_led_cfg lcfg;
 555         uint32_t t, new_pos, pos;
 556
 557         /* Port 0 */
 558         bzero(&port_cfg, sizeof(port_cfg));
 559         sc->ar8327.port0_status = 0;
 560         if (ar8327_fetch_pdata_port(sc, &port_cfg, 0))
 561                 sc->ar8327.port0_status = ar8327_get_port_init_status(&port_cfg);
 562
 563         /* Port 6 */
 564         bzero(&port_cfg, sizeof(port_cfg));
 565         sc->ar8327.port6_status = 0;
 566         if (ar8327_fetch_pdata_port(sc, &port_cfg, 6))
 567                 sc->ar8327.port6_status = ar8327_get_port_init_status(&port_cfg);
 568
 569         /* Pad 0 */
 570         bzero(&pc, sizeof(pc));
 571         t = 0;
 572         if (ar8327_fetch_pdata_pad(sc, &pc, 0))
 573                 t = ar8327_get_pad_cfg(&pc);
 574 #if 0
 575                 if (AR8X16_IS_SWITCH(sc, AR8337))
 576                         t |= AR8337_PAD_MAC06_EXCHANGE_EN;
 577 #endif
 578         arswitch_writereg(sc->sc_dev, AR8327_REG_PAD0_MODE, t);
 579
 580         /* Pad 5 */
 581         bzero(&pc, sizeof(pc));
 582         t = 0;
 583         if (ar8327_fetch_pdata_pad(sc, &pc, 5))
 584                 t = ar8327_get_pad_cfg(&pc);
 585         arswitch_writereg(sc->sc_dev, AR8327_REG_PAD5_MODE, t);
 586
 587         /* Pad 6 */
 588         bzero(&pc, sizeof(pc));
 589         t = 0;
 590         if (ar8327_fetch_pdata_pad(sc, &pc, 6))
 591                 t = ar8327_get_pad_cfg(&pc);
 592         arswitch_writereg(sc->sc_dev, AR8327_REG_PAD6_MODE, t);
 593
 594         pos = arswitch_readreg(sc->sc_dev, AR8327_REG_POWER_ON_STRIP);
 595         new_pos = pos;
 596
 597         /* XXX LED config */
 598         bzero(&lcfg, sizeof(lcfg));
 599         if (ar8327_fetch_pdata_led(sc, &lcfg)) {
 600                 if (lcfg.open_drain)
 601                         new_pos |= AR8327_POWER_ON_STRIP_LED_OPEN_EN;
 602                 else
 603                         new_pos &= ~AR8327_POWER_ON_STRIP_LED_OPEN_EN;
 604
 605                 arswitch_writereg(sc->sc_dev, AR8327_REG_LED_CTRL0,
 606                     lcfg.led_ctrl0);
 607                 arswitch_writereg(sc->sc_dev, AR8327_REG_LED_CTRL1,
 608                     lcfg.led_ctrl1);
 609                 arswitch_writereg(sc->sc_dev, AR8327_REG_LED_CTRL2,
 610                     lcfg.led_ctrl2);
 611                 arswitch_writereg(sc->sc_dev, AR8327_REG_LED_CTRL3,
 612                     lcfg.led_ctrl3);
 613
 614                 if (new_pos != pos)
 615                         new_pos |= AR8327_POWER_ON_STRIP_POWER_ON_SEL;
 616         }
 617
 618         /* SGMII config */
 619         bzero(&scfg, sizeof(scfg));
 620         if (ar8327_fetch_pdata_sgmii(sc, &scfg)) {
 621                 device_printf(sc->sc_dev, "%s: SGMII cfg?\n", __func__);
 622                 t = scfg.sgmii_ctrl;
 623                 if (sc->chip_rev == 1)
 624                         t |= AR8327_SGMII_CTRL_EN_PLL |
 625                             AR8327_SGMII_CTRL_EN_RX |
 626                             AR8327_SGMII_CTRL_EN_TX;
 627                 else
 628                         t &= ~(AR8327_SGMII_CTRL_EN_PLL |
 629                             AR8327_SGMII_CTRL_EN_RX |
 630                             AR8327_SGMII_CTRL_EN_TX);
 631
 632                 arswitch_writereg(sc->sc_dev, AR8327_REG_SGMII_CTRL, t);
 633
 634                 if (scfg.serdes_aen)
 635                         new_pos &= ~AR8327_POWER_ON_STRIP_SERDES_AEN;
 636                 else
 637                         new_pos |= AR8327_POWER_ON_STRIP_SERDES_AEN;
 638         }
 639
 640         arswitch_writereg(sc->sc_dev, AR8327_REG_POWER_ON_STRIP, new_pos);
 641
 642         return (0);
 643 }
 644
 645 static int
 646 ar8327_hw_setup(struct arswitch_softc *sc)
 647 {
 648         int i;
 649         int err;
 650
 651         /* pdata fetch and setup */
 652         err = ar8327_init_pdata(sc);
 653         if (err != 0)
 654                 return (err);
 655
 656         /* XXX init leds */
 657
 658         for (i = 0; i < AR8327_NUM_PHYS; i++) {
 659                 /* phy fixup */
 660                 ar8327_phy_fixup(sc, i);
 661
 662                 /* start PHY autonegotiation? */
 663                 /* XXX is this done as part of the normal PHY setup? */
 664
 665         };
 666
 667         /* Let things settle */
 668         DELAY(1000);
 669
 670         return (0);
 671 }
 672
 673 /*
 674  * Initialise other global values, for the AR8327.
 675  */
 676 static int
 677 ar8327_hw_global_setup(struct arswitch_softc *sc)
 678 {
 679         uint32_t t;
 680
 681         /* enable CPU port and disable mirror port */
 682         t = AR8327_FWD_CTRL0_CPU_PORT_EN |
 683             AR8327_FWD_CTRL0_MIRROR_PORT;
 684         arswitch_writereg(sc->sc_dev, AR8327_REG_FWD_CTRL0, t);
 685
 686         /* forward multicast and broadcast frames to CPU */
 687         t = (AR8327_PORTS_ALL << AR8327_FWD_CTRL1_UC_FLOOD_S) |
 688             (AR8327_PORTS_ALL << AR8327_FWD_CTRL1_MC_FLOOD_S) |
 689             (AR8327_PORTS_ALL << AR8327_FWD_CTRL1_BC_FLOOD_S);
 690         arswitch_writereg(sc->sc_dev, AR8327_REG_FWD_CTRL1, t);
 691
 692         /* enable jumbo frames */
 693         /* XXX need to macro-shift the value! */
 694         arswitch_modifyreg(sc->sc_dev, AR8327_REG_MAX_FRAME_SIZE,
 695             AR8327_MAX_FRAME_SIZE_MTU, 9018 + 8 + 2);
 696
 697         /* Enable MIB counters */
 698         arswitch_modifyreg(sc->sc_dev, AR8327_REG_MODULE_EN,
 699             AR8327_MODULE_EN_MIB, AR8327_MODULE_EN_MIB);
 700
 701         /* Disable EEE on all ports due to stability issues */
 702         t = arswitch_readreg(sc->sc_dev, AR8327_REG_EEE_CTRL);
 703         t |= AR8327_EEE_CTRL_DISABLE_PHY(0) |
 704             AR8327_EEE_CTRL_DISABLE_PHY(1) |
 705             AR8327_EEE_CTRL_DISABLE_PHY(2) |
 706             AR8327_EEE_CTRL_DISABLE_PHY(3) |
 707             AR8327_EEE_CTRL_DISABLE_PHY(4);
 708         arswitch_writereg(sc->sc_dev, AR8327_REG_EEE_CTRL, t);
 709
 710         /* Set the right number of ports */
 711         /* GMAC0 (CPU), GMAC1..5 (PHYs), GMAC6 (CPU) */
 712         sc->info.es_nports = 7;
 713
 714         return (0);
 715 }
 716
 717 /*
 718  * Port setup.  Called at attach time.
 719  */
 720 static void
 721 ar8327_port_init(struct arswitch_softc *sc, int port)
 722 {
 723         uint32_t t;
 724         int ports;
 725
 726         /* For now, port can see all other ports */
 727         ports = 0x7f;
 728
 729         if (port == AR8X16_PORT_CPU)
 730                 t = sc->ar8327.port0_status;
 731         else if (port == 6)
 732                 t = sc->ar8327.port6_status;
 733         else
 734                 t = AR8X16_PORT_STS_LINK_AUTO;
 735
 736         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_STATUS(port), t);
 737         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_HEADER(port), 0);
 738
 739         /*
 740          * Default to 1 port group.
 741          */
 742         t = 1 << AR8327_PORT_VLAN0_DEF_SVID_S;
 743         t |= 1 << AR8327_PORT_VLAN0_DEF_CVID_S;
 744         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_VLAN0(port), t);
 745
 746         t = AR8327_PORT_VLAN1_OUT_MODE_UNTOUCH << AR8327_PORT_VLAN1_OUT_MODE_S;
 747         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_VLAN1(port), t);
 748
 749         /*
 750          * This doesn't configure any ports which this port can "see".
 751          * bits 0-6 control which ports a frame coming into this port
 752          * can be sent out to.
 753          *
 754          * So by doing this, we're making it impossible to send frames out
 755          * to that port.
 756          */
 757         t = AR8327_PORT_LOOKUP_LEARN;
 758         t |= AR8X16_PORT_CTRL_STATE_FORWARD << AR8327_PORT_LOOKUP_STATE_S;
 759
 760         /* So this allows traffic to any port except ourselves */
 761         t |= (ports & ~(1 << port));
 762         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_LOOKUP(port), t);
 763 }
 764
 765 static int
 766 ar8327_port_vlan_setup(struct arswitch_softc *sc, etherswitch_port_t *p)
 767 {
 768
 769         /* Check: ADDTAG/STRIPTAG - exclusive */
 770
 771         ARSWITCH_LOCK(sc);
 772
 773         /* Set the PVID. */
 774         if (p->es_pvid != 0)
 775                 sc->hal.arswitch_vlan_set_pvid(sc, p->es_port, p->es_pvid);
 776
 777         /*
 778          * DOUBLE_TAG
 779          * VLAN_MODE_ADD
 780          * VLAN_MODE_STRIP
 781          */
 782         ARSWITCH_UNLOCK(sc);
 783         return (0);
 784 }
 785
 786 /*
 787  * Get the port VLAN configuration.
 788  */
 789 static int
 790 ar8327_port_vlan_get(struct arswitch_softc *sc, etherswitch_port_t *p)
 791 {
 792
 793         ARSWITCH_LOCK(sc);
 794
 795         /* Retrieve the PVID */
 796         sc->hal.arswitch_vlan_get_pvid(sc, p->es_port, &p->es_pvid);
 797
 798         /* Retrieve the current port configuration from the VTU */
 799         /*
 800          * DOUBLE_TAG
 801          * VLAN_MODE_ADD
 802          * VLAN_MODE_STRIP
 803          */
 804
 805         ARSWITCH_UNLOCK(sc);
 806         return (0);
 807 }
 808
 809 static void
 810 ar8327_port_disable_mirror(struct arswitch_softc *sc, int port)
 811 {
 812
 813         arswitch_modifyreg(sc->sc_dev,
 814             AR8327_REG_PORT_LOOKUP(port),
 815             AR8327_PORT_LOOKUP_ING_MIRROR_EN,
 816             0);
 817         arswitch_modifyreg(sc->sc_dev,
 818             AR8327_REG_PORT_HOL_CTRL1(port),
 819             AR8327_PORT_HOL_CTRL1_EG_MIRROR_EN,
 820             0);
 821 }
 822
 823 static void
 824 ar8327_reset_vlans(struct arswitch_softc *sc)
 825 {
 826         int i;
 827         uint32_t t;
 828         int ports;
 829
 830         ARSWITCH_LOCK_ASSERT(sc, MA_NOTOWNED);
 831         ARSWITCH_LOCK(sc);
 832
 833         /* Clear the existing VLAN configuration */
 834         memset(sc->vid, 0, sizeof(sc->vid));
 835
 836         /*
 837          * Disable mirroring.
 838          */
 839         arswitch_modifyreg(sc->sc_dev, AR8327_REG_FWD_CTRL0,
 840             AR8327_FWD_CTRL0_MIRROR_PORT,
 841             (0xF << AR8327_FWD_CTRL0_MIRROR_PORT_S));
 842
 843         /*
 844          * XXX TODO: disable any Q-in-Q port configuration,
 845          * tagging, egress filters, etc.
 846          */
 847
 848         /*
 849          * For now, let's default to one portgroup, just so traffic
 850          * flows.  All ports can see other ports. There are two CPU GMACs
 851          * (GMAC0, GMAC6), GMAC1..GMAC5 are external PHYs.
 852          *
 853          * (ETHERSWITCH_VLAN_PORT)
 854          */
 855         ports = 0x7f;
 856
 857         /*
 858          * XXX TODO: set things up correctly for vlans!
 859          */
 860         for (i = 0; i < AR8327_NUM_PORTS; i++) {
 861                 int egress, ingress;
 862
 863                 if (sc->vlan_mode == ETHERSWITCH_VLAN_PORT) {
 864                         sc->vid[i] = i | ETHERSWITCH_VID_VALID;
 865                         /* set egress == out_keep */
 866                         ingress = AR8X16_PORT_VLAN_MODE_PORT_ONLY;
 867                         /* in_port_only, forward */
 868                         egress = AR8327_PORT_VLAN1_OUT_MODE_UNTOUCH;
 869                 } else if (sc->vlan_mode == ETHERSWITCH_VLAN_DOT1Q) {
 870                         ingress = AR8X16_PORT_VLAN_MODE_SECURE;
 871                         egress = AR8327_PORT_VLAN1_OUT_MODE_UNMOD;
 872                 } else {
 873                         /* set egress == out_keep */
 874                         ingress = AR8X16_PORT_VLAN_MODE_PORT_ONLY;
 875                         /* in_port_only, forward */
 876                         egress = AR8327_PORT_VLAN1_OUT_MODE_UNTOUCH;
 877                 }
 878
 879                 /* set pvid = 1; there's only one vlangroup to start with */
 880                 t = 1 << AR8327_PORT_VLAN0_DEF_SVID_S;
 881                 t |= 1 << AR8327_PORT_VLAN0_DEF_CVID_S;
 882                 arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_VLAN0(i), t);
 883
 884                 t = AR8327_PORT_VLAN1_PORT_VLAN_PROP;
 885                 t |= egress << AR8327_PORT_VLAN1_OUT_MODE_S;
 886                 arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_VLAN1(i), t);
 887
 888                 /* Ports can see other ports */
 889                 /* XXX not entirely true for dot1q? */
 890                 t = (ports & ~(1 << i));        /* all ports besides us */
 891                 t |= AR8327_PORT_LOOKUP_LEARN;
 892
 893                 t |= ingress << AR8327_PORT_LOOKUP_IN_MODE_S;
 894                 t |= AR8X16_PORT_CTRL_STATE_FORWARD << AR8327_PORT_LOOKUP_STATE_S;
 895                 arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_LOOKUP(i), t);
 896         }
 897
 898         /*
 899          * Disable port mirroring entirely.
 900          */
 901         for (i = 0; i < AR8327_NUM_PORTS; i++) {
 902                 ar8327_port_disable_mirror(sc, i);
 903         }
 904
 905         /*
 906          * If dot1q - set pvid; dot1q, etc.
 907          */
 908         if (sc->vlan_mode == ETHERSWITCH_VLAN_DOT1Q) {
 909                 sc->vid[0] = 1;
 910                 for (i = 0; i < AR8327_NUM_PORTS; i++) {
 911                         /* Each port - pvid 1 */
 912                         sc->hal.arswitch_vlan_set_pvid(sc, i, sc->vid[0]);
 913                 }
 914                 /* Initialise vlan1 - all ports, untagged */
 915                 sc->hal.arswitch_set_dot1q_vlan(sc, ports, ports, sc->vid[0]);
 916                 sc->vid[0] |= ETHERSWITCH_VID_VALID;
 917         }
 918
 919         ARSWITCH_UNLOCK(sc);
 920 }
 921
 922 static int
 923 ar8327_vlan_get_port(struct arswitch_softc *sc, uint32_t *ports, int vid)
 924 {
 925         int port;
 926         uint32_t reg;
 927
 928         ARSWITCH_LOCK_ASSERT(sc, MA_OWNED);
 929
 930         /* For port based vlans the vlanid is the same as the port index. */
 931         port = vid & ETHERSWITCH_VID_MASK;
 932         reg = arswitch_readreg(sc->sc_dev, AR8327_REG_PORT_LOOKUP(port));
 933         *ports = reg & 0x7f;
 934         return (0);
 935 }
 936
 937 static int
 938 ar8327_vlan_set_port(struct arswitch_softc *sc, uint32_t ports, int vid)
 939 {
 940         int err, port;
 941
 942         ARSWITCH_LOCK_ASSERT(sc, MA_OWNED);
 943
 944         /* For port based vlans the vlanid is the same as the port index. */
 945         port = vid & ETHERSWITCH_VID_MASK;
 946
 947         err = arswitch_modifyreg(sc->sc_dev, AR8327_REG_PORT_LOOKUP(port),
 948             0x7f, /* vlan membership mask */
 949             (ports & 0x7f));
 950
 951         if (err)
 952                 return (err);
 953         return (0);
 954 }
 955
 956 static int
 957 ar8327_vlan_getvgroup(struct arswitch_softc *sc, etherswitch_vlangroup_t *vg)
 958 {
 959
 960         return (ar8xxx_getvgroup(sc, vg));
 961 }
 962
 963 static int
 964 ar8327_vlan_setvgroup(struct arswitch_softc *sc, etherswitch_vlangroup_t *vg)
 965 {
 966
 967         return (ar8xxx_setvgroup(sc, vg));
 968 }
 969
 970 static int
 971 ar8327_get_pvid(struct arswitch_softc *sc, int port, int *pvid)
 972 {
 973         uint32_t reg;
 974
 975         ARSWITCH_LOCK_ASSERT(sc, MA_OWNED);
 976
 977         /*
 978          * XXX for now, assuming it's CVID; likely very wrong!
 979          */
 980         port = port & ETHERSWITCH_VID_MASK;
 981         reg = arswitch_readreg(sc->sc_dev, AR8327_REG_PORT_VLAN0(port));
 982         reg = reg >> AR8327_PORT_VLAN0_DEF_CVID_S;
 983         reg = reg & 0xfff;
 984
 985         *pvid = reg;
 986         return (0);
 987 }
 988
 989 static int
 990 ar8327_set_pvid(struct arswitch_softc *sc, int port, int pvid)
 991 {
 992         uint32_t t;
 993
 994         /* Limit pvid to valid values */
 995         pvid &= 0x7f;
 996
 997         t = pvid << AR8327_PORT_VLAN0_DEF_SVID_S;
 998         t |= pvid << AR8327_PORT_VLAN0_DEF_CVID_S;
 999         arswitch_writereg(sc->sc_dev, AR8327_REG_PORT_VLAN0(port), t);
1000
1001         return (0);
1002 }
1003
1004 static int
1005 ar8327_atu_flush(struct arswitch_softc *sc)
1006 {
1007
1008         int ret;
1009
1010         ret = arswitch_waitreg(sc->sc_dev,
1011             AR8327_REG_ATU_FUNC,
1012             AR8327_ATU_FUNC_BUSY,
1013             0,
1014             1000);
1015
1016         if (ret)
1017                 device_printf(sc->sc_dev, "%s: waitreg failed\n", __func__);
1018
1019         if (!ret)
1020                 arswitch_writereg(sc->sc_dev,
1021                     AR8327_REG_ATU_FUNC,
1022                     AR8327_ATU_FUNC_OP_FLUSH);
1023         return (ret);
1024 }
1025
1026 static int
1027 ar8327_flush_dot1q_vlan(struct arswitch_softc *sc)
1028 {
1029
1030         return (ar8327_vlan_op(sc, AR8327_VTU_FUNC1_OP_FLUSH, 0, 0));
1031 }
1032
1033 static int
1034 ar8327_purge_dot1q_vlan(struct arswitch_softc *sc, int vid)
1035 {
1036
1037         return (ar8327_vlan_op(sc, AR8327_VTU_FUNC1_OP_PURGE, vid, 0));
1038 }
1039
1040 static int
1041 ar8327_get_dot1q_vlan(struct arswitch_softc *sc, uint32_t *ports,
1042     uint32_t *untagged_ports, int vid)
1043 {
1044         int i, r;
1045         uint32_t op, reg, val;
1046
1047         op = AR8327_VTU_FUNC1_OP_GET_ONE;
1048
1049         /* Filter out the vid flags; only grab the VLAN ID */
1050         vid &= 0xfff;
1051
1052         /* XXX TODO: the VTU here stores egress mode - keep, tag, untagged, none */
1053         r = ar8327_vlan_op(sc, op, vid, 0);
1054         if (r != 0) {
1055                 device_printf(sc->sc_dev, "%s: %d: op failed\n", __func__, vid);
1056         }
1057
1058         reg = arswitch_readreg(sc->sc_dev, AR8327_REG_VTU_FUNC0);
1059         DPRINTF(sc->sc_dev, "%s: %d: reg=0x%08x\n", __func__, vid, reg);
1060
1061         /*
1062          * If any of the bits are set, update the port mask.
1063          * Worry about the port config itself when getport() is called.
1064          */
1065         *ports = 0;
1066         for (i = 0; i < AR8327_NUM_PORTS; i++) {
1067                 val = reg >> AR8327_VTU_FUNC0_EG_MODE_S(i);
1068                 val = val & 0x3;
1069                 /* XXX KEEP (unmodified?) */
1070                 if (val == AR8327_VTU_FUNC0_EG_MODE_TAG) {
1071                         *ports |= (1 << i);
1072                 } else if (val == AR8327_VTU_FUNC0_EG_MODE_UNTAG) {
1073                         *ports |= (1 << i);
1074                         *untagged_ports |= (1 << i);
1075                 }
1076         }
1077
1078         return (0);
1079 }
1080
1081 static int
1082 ar8327_set_dot1q_vlan(struct arswitch_softc *sc, uint32_t ports,
1083     uint32_t untagged_ports, int vid)
1084 {
1085         int i;
1086         uint32_t op, val, mode;
1087
1088         op = AR8327_VTU_FUNC1_OP_LOAD;
1089         vid &= 0xfff;
1090
1091         DPRINTF(sc->sc_dev,
1092             "%s: vid: %d, ports=0x%08x, untagged_ports=0x%08x\n",
1093             __func__,
1094             vid,
1095             ports,
1096             untagged_ports);
1097
1098         /*
1099          * Mark it as valid; and that it should use per-VLAN MAC table,
1100          * not VID=0 when doing MAC lookups
1101          */
1102         val = AR8327_VTU_FUNC0_VALID | AR8327_VTU_FUNC0_IVL;
1103
1104         for (i = 0; i < AR8327_NUM_PORTS; i++) {
1105                 if ((ports & BIT(i)) == 0)
1106                         mode = AR8327_VTU_FUNC0_EG_MODE_NOT;
1107                 else if (untagged_ports & BIT(i))
1108                         mode = AR8327_VTU_FUNC0_EG_MODE_UNTAG;
1109                 else
1110                         mode = AR8327_VTU_FUNC0_EG_MODE_TAG;
1111
1112                 val |= mode << AR8327_VTU_FUNC0_EG_MODE_S(i);
1113         }
1114
1115         return (ar8327_vlan_op(sc, op, vid, val));
1116 }
1117
1118 void
1119 ar8327_attach(struct arswitch_softc *sc)
1120 {
1121
1122         sc->hal.arswitch_hw_setup = ar8327_hw_setup;
1123         sc->hal.arswitch_hw_global_setup = ar8327_hw_global_setup;
1124
1125         sc->hal.arswitch_port_init = ar8327_port_init;
1126
1127         sc->hal.arswitch_vlan_getvgroup = ar8327_vlan_getvgroup;
1128         sc->hal.arswitch_vlan_setvgroup = ar8327_vlan_setvgroup;
1129         sc->hal.arswitch_port_vlan_setup = ar8327_port_vlan_setup;
1130         sc->hal.arswitch_port_vlan_get = ar8327_port_vlan_get;
1131         sc->hal.arswitch_flush_dot1q_vlan = ar8327_flush_dot1q_vlan;
1132         sc->hal.arswitch_purge_dot1q_vlan = ar8327_purge_dot1q_vlan;
1133         sc->hal.arswitch_set_dot1q_vlan = ar8327_set_dot1q_vlan;
1134         sc->hal.arswitch_get_dot1q_vlan = ar8327_get_dot1q_vlan;
1135
1136         sc->hal.arswitch_vlan_init_hw = ar8327_reset_vlans;
1137         sc->hal.arswitch_vlan_get_pvid = ar8327_get_pvid;
1138         sc->hal.arswitch_vlan_set_pvid = ar8327_set_pvid;
1139
1140         sc->hal.arswitch_get_port_vlan = ar8327_vlan_get_port;
1141         sc->hal.arswitch_set_port_vlan = ar8327_vlan_set_port;
1142
1143         sc->hal.arswitch_atu_flush = ar8327_atu_flush;
1144
1145         /*
1146          * Reading the PHY via the MDIO interface currently doesn't
1147          * work correctly.
1148          *
1149          * So for now, just go direct to the PHY registers themselves.
1150          * This has always worked  on external devices, but not internal
1151          * devices (AR934x, AR724x, AR933x.)
1152          */
1153         sc->hal.arswitch_phy_read = arswitch_readphy_external;
1154         sc->hal.arswitch_phy_write = arswitch_writephy_external;
1155
1156         /* Set the switch vlan capabilities. */
1157         sc->info.es_vlan_caps = ETHERSWITCH_VLAN_DOT1Q |
1158             ETHERSWITCH_VLAN_PORT | ETHERSWITCH_VLAN_DOUBLE_TAG;
1159         sc->info.es_nvlangroups = AR8X16_MAX_VLANS;
1160 }