package/robocfg/src/robocfg.c

   1 /*
   2  * Broadcom BCM5325E/536x switch configuration utility
   3  *
   4  * Copyright (C) 2005 Oleg I. Vdovikin
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  * 02110-1301, USA.
  20  */
  21
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/param.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/socket.h>
  29
  30 /* linux stuff */
  31 typedef u_int64_t u64;
  32 typedef u_int32_t u32;
  33 typedef u_int16_t u16;
  34 typedef u_int8_t u8;
  35
  36 #include <linux/if.h>
  37 #include <linux/sockios.h>
  38 #include <linux/ethtool.h>
  39 #include <linux/mii.h>
  40
  41 #include "etc53xx.h"
  42 #define ROBO_PHY_ADDR   0x1E    /* robo switch phy address */
  43
  44 /* MII registers */
  45 #define REG_MII_PAGE    0x10    /* MII Page register */
  46 #define REG_MII_ADDR    0x11    /* MII Address register */
  47 #define REG_MII_DATA0   0x18    /* MII Data register 0 */
  48
  49 #define REG_MII_PAGE_ENABLE     1
  50 #define REG_MII_ADDR_WRITE      1
  51 #define REG_MII_ADDR_READ       2
  52
  53 /* Private et.o ioctls */
  54 #define SIOCGETCPHYRD           (SIOCDEVPRIVATE + 9)
  55 #define SIOCSETCPHYWR           (SIOCDEVPRIVATE + 10)
  56
  57 typedef struct {
  58         struct ifreq ifr;
  59         int fd;
  60         int et;                 /* use private ioctls */
  61 } robo_t;
  62
  63 static u16 mdio_read(robo_t *robo, u16 phy_id, u8 reg)
  64 {
  65         if (robo->et) {
  66                 int args[2] = { reg };
  67
  68                 if (phy_id != ROBO_PHY_ADDR) {
  69                         fprintf(stderr,
  70                                 "Access to real 'phy' registers unavaliable.\n"
  71                                 "Upgrade kernel driver.\n");
  72
  73                         return 0xffff;
  74                 }
  75
  76                 robo->ifr.ifr_data = (caddr_t) args;
  77                 if (ioctl(robo->fd, SIOCGETCPHYRD, (caddr_t)&robo->ifr) < 0) {
  78                         perror("SIOCGETCPHYRD");
  79                         exit(1);
  80                 }
  81
  82                 return args[1];
  83         } else {
  84                 struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&robo->ifr.ifr_data;
  85                 mii->phy_id = phy_id;
  86                 mii->reg_num = reg;
  87                 if (ioctl(robo->fd, SIOCGMIIREG, &robo->ifr) < 0) {
  88                         perror("SIOCGMIIREG");
  89                         exit(1);
  90                 }
  91                 return mii->val_out;
  92         }
  93 }
  94
  95 static void mdio_write(robo_t *robo, u16 phy_id, u8 reg, u16 val)
  96 {
  97         if (robo->et) {
  98                 int args[2] = { reg, val };
  99
 100                 if (phy_id != ROBO_PHY_ADDR) {
 101                         fprintf(stderr,
 102                                 "Access to real 'phy' registers unavaliable.\n"
 103                                 "Upgrade kernel driver.\n");
 104                         return;
 105                 }
 106
 107                 robo->ifr.ifr_data = (caddr_t) args;
 108                 if (ioctl(robo->fd, SIOCSETCPHYWR, (caddr_t)&robo->ifr) < 0) {
 109                         perror("SIOCGETCPHYWR");
 110                         exit(1);
 111                 }
 112         } else {
 113                 struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&robo->ifr.ifr_data;
 114                 mii->phy_id = phy_id;
 115                 mii->reg_num = reg;
 116                 mii->val_in = val;
 117                 if (ioctl(robo->fd, SIOCSMIIREG, &robo->ifr) < 0) {
 118                         perror("SIOCSMIIREG");
 119                         exit(1);
 120                 }
 121         }
 122 }
 123
 124 static int robo_reg(robo_t *robo, u8 page, u8 reg, u8 op)
 125 {
 126         int i = 3;
 127
 128         /* set page number */
 129         mdio_write(robo, ROBO_PHY_ADDR, REG_MII_PAGE,
 130                 (page << 8) | REG_MII_PAGE_ENABLE);
 131
 132         /* set register address */
 133         mdio_write(robo, ROBO_PHY_ADDR, REG_MII_ADDR,
 134                 (reg << 8) | op);
 135
 136         /* check if operation completed */
 137         while (i--) {
 138                 if ((mdio_read(robo, ROBO_PHY_ADDR, REG_MII_ADDR) & 3) == 0)
 139                         return 0;
 140         }
 141
 142         fprintf(stderr, "robo_reg: timeout\n");
 143         exit(1);
 144
 145         return 0;
 146 }
 147
 148 static void robo_read(robo_t *robo, u8 page, u8 reg, u16 *val, int count)
 149 {
 150         int i;
 151
 152         robo_reg(robo, page, reg, REG_MII_ADDR_READ);
 153
 154         for (i = 0; i < count; i++)
 155                 val[i] = mdio_read(robo, ROBO_PHY_ADDR, REG_MII_DATA0 + i);
 156 }
 157
 158 static u16 robo_read16(robo_t *robo, u8 page, u8 reg)
 159 {
 160         robo_reg(robo, page, reg, REG_MII_ADDR_READ);
 161
 162         return mdio_read(robo, ROBO_PHY_ADDR, REG_MII_DATA0);
 163 }
 164
 165 static u32 robo_read32(robo_t *robo, u8 page, u8 reg)
 166 {
 167         robo_reg(robo, page, reg, REG_MII_ADDR_READ);
 168
 169         return mdio_read(robo, ROBO_PHY_ADDR, REG_MII_DATA0) +
 170                 (mdio_read(robo, ROBO_PHY_ADDR, REG_MII_DATA0 + 1) << 16);
 171 }
 172
 173 static void robo_write16(robo_t *robo, u8 page, u8 reg, u16 val16)
 174 {
 175         /* write data */
 176         mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0, val16);
 177
 178         robo_reg(robo, page, reg, REG_MII_ADDR_WRITE);
 179 }
 180
 181 static void robo_write32(robo_t *robo, u8 page, u8 reg, u32 val32)
 182 {
 183         /* write data */
 184         mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0, val32 & 65535);
 185         mdio_write(robo, ROBO_PHY_ADDR, REG_MII_DATA0 + 1, val32 >> 16);
 186
 187         robo_reg(robo, page, reg, REG_MII_ADDR_WRITE);
 188 }
 189
 190 /* checks that attached switch is 5325E/5350 */
 191 static int robo_vlan5350(robo_t *robo)
 192 {
 193         /* set vlan access id to 15 and read it back */
 194         u16 val16 = 15;
 195         robo_write16(robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350, val16);
 196
 197         /* 5365 will refuse this as it does not have this reg */
 198         return (robo_read16(robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350) == val16);
 199 }
 200
 201 u8 port[6] = { 0, 1, 2, 3, 4, 8 };
 202 char ports[6] = { 'W', '4', '3', '2', '1', 'C' };
 203 char *rxtx[4] = { "enabled", "rx_disabled", "tx_disabled", "disabled" };
 204 char *stp[8] = { "none", "disable", "block", "listen", "learn", "forward", "6", "7" };
 205
 206 struct {
 207         char *name;
 208         u16 bmcr;
 209 } media[5] = { { "auto", BMCR_ANENABLE | BMCR_ANRESTART },
 210         { "10HD", 0 }, { "10FD", BMCR_FULLDPLX },
 211         { "100HD", BMCR_SPEED100 }, { "100FD", BMCR_SPEED100 | BMCR_FULLDPLX } };
 212
 213 struct {
 214         char *name;
 215         u16 value;
 216 } mdix[3] = { { "auto", 0x0000 }, { "on", 0x1800 }, { "off", 0x0800 } };
 217
 218 void usage()
 219 {
 220         fprintf(stderr, "Broadcom BCM5325E/536x switch configuration utility\n"
 221                 "Copyright (C) 2005 Oleg I. Vdovikin\n\n"
 222                 "This program is distributed in the hope that it will be useful,\n"
 223                 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 224                 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
 225                 "GNU General Public License for more details.\n\n");
 226
 227         fprintf(stderr, "Usage: robocfg <op> ... <op>\n"
 228                         "Operations are as below:\n"
 229                         "\tshow\n"
 230                         "\tswitch <enable|disable>\n"
 231                         "\tport <port_number> [state <%s|%s|%s|%s>]\n\t\t[stp %s|%s|%s|%s|%s|%s] [tag <vlan_tag>]\n"
 232                         "\t\t[media %s|%s|%s|%s|%s] [mdi-x %s|%s|%s]\n"
 233                         "\tvlan <vlan_number> [ports <ports_list>]\n"
 234                         "\tvlans <enable|disable|reset>\n\n"
 235                         "\tports_list should be one argument, space separated, quoted if needed,\n"
 236                         "\tport number could be followed by 't' to leave packet vlan tagged (CPU \n"
 237                         "\tport default) or by 'u' to untag packet (other ports default) before \n"
 238                         "\tbringing it to the port, '*' is ignored\n"
 239                         "\nSamples:\n"
 240                         "1) ASUS WL-500g Deluxe stock config (eth0 is WAN, eth0.1 is LAN):\n"
 241                         "robocfg switch disable vlans enable reset vlan 0 ports \"0 5u\" vlan 1 ports \"1 2 3 4 5t\""
 242                         " port 0 state enabled stp none switch enable\n"
 243                         "2) WRT54g, WL-500g Deluxe OpenWRT config (vlan0 is LAN, vlan1 is WAN):\n"
 244                         "robocfg switch disable vlans enable reset vlan 0 ports \"1 2 3 4 5t\" vlan 1 ports \"0 5t\""
 245                         " port 0 state enabled stp none switch enable\n",
 246                         rxtx[0], rxtx[1], rxtx[2], rxtx[3], stp[0], stp[1], stp[2], stp[3], stp[4], stp[5],
 247                         media[0].name, media[1].name, media[2].name, media[3].name, media[4].name,
 248                         mdix[0].name, mdix[1].name, mdix[2].name);
 249 }
 250
 251 static robo_t robo;
 252 int bcm53xx_probe(const char *dev)
 253 {
 254         struct ethtool_drvinfo info;
 255         unsigned int phyid;
 256         int ret;
 257
 258         fprintf(stderr, "probing %s\n", dev);
 259
 260         strcpy(robo.ifr.ifr_name, dev);
 261         memset(&info, 0, sizeof(info));
 262         info.cmd = ETHTOOL_GDRVINFO;
 263         robo.ifr.ifr_data = (caddr_t)&info;
 264         ret = ioctl(robo.fd, SIOCETHTOOL, (caddr_t)&robo.ifr);
 265         if (ret < 0) {
 266                 perror("SIOCETHTOOL");
 267                 return ret;
 268         }
 269
 270         if (    strcmp(info.driver, "et0") &&
 271                 strcmp(info.driver, "b44") &&
 272                 strcmp(info.driver, "bcm63xx_enet") ) {
 273                         fprintf(stderr, "driver not supported %s\n", info.driver);
 274                         return -ENOSYS;
 275         }
 276
 277         /* try access using MII ioctls - get phy address */
 278         robo.et = 0;
 279         if (ioctl(robo.fd, SIOCGMIIPHY, &robo.ifr) < 0)
 280                 robo.et = 1;
 281
 282         if (robo.et) {
 283                 unsigned int args[2] = { 2 };
 284
 285                 robo.ifr.ifr_data = (caddr_t) args;
 286                 ret = ioctl(robo.fd, SIOCGETCPHYRD, (caddr_t)&robo.ifr);
 287                 if (ret < 0) {
 288                         perror("SIOCGETCPHYRD");
 289                         return ret;
 290                 }
 291                 phyid = args[1] & 0xffff;
 292
 293                 args[0] = 3;
 294                 robo.ifr.ifr_data = (caddr_t) args;
 295                 ret = ioctl(robo.fd, SIOCGETCPHYRD, (caddr_t)&robo.ifr);
 296                 if (ret < 0) {
 297                         perror("SIOCGETCPHYRD");
 298                         return ret;
 299                 }
 300                 phyid |= args[1] << 16;
 301         } else {
 302                 struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&robo.ifr.ifr_data;
 303                 mii->phy_id = ROBO_PHY_ADDR;
 304                 mii->reg_num = 2;
 305                 ret = ioctl(robo.fd, SIOCGMIIREG, &robo.ifr);
 306                 if (ret < 0) {
 307                         perror("SIOCGMIIREG");
 308                         return ret;
 309                 }
 310                 phyid = mii->val_out & 0xffff;
 311
 312                 mii->phy_id = ROBO_PHY_ADDR;
 313                 mii->reg_num = 3;
 314                 ret = ioctl(robo.fd, SIOCGMIIREG, &robo.ifr);
 315                 if (ret < 0) {
 316                         perror("SIOCGMIIREG");
 317                         return ret;
 318                 }
 319                 phyid |= mii->val_out << 16;
 320         }
 321
 322         if (phyid == 0xffffffff || phyid == 0x55210022) {
 323                 perror("phyid");
 324                 return -EIO;
 325         }
 326
 327         return 0;
 328 }
 329
 330 int
 331 main(int argc, char *argv[])
 332 {
 333         u16 val16;
 334         u16 mac[3];
 335         int i = 0, j;
 336         int robo5350 = 0;
 337         u32 phyid;
 338
 339         if ((robo.fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 340                 perror("socket");
 341                 exit(1);
 342         }
 343
 344         if (bcm53xx_probe("eth1")) {
 345                 if (bcm53xx_probe("eth0")) {
 346                         perror("bcm53xx_probe");
 347                         exit(1);
 348                 }
 349         }
 350
 351         robo5350 = robo_vlan5350(&robo);
 352
 353         for (i = 1; i < argc;) {
 354                 if (strcasecmp(argv[i], "port") == 0 && (i + 1) < argc)
 355                 {
 356                         int index = atoi(argv[++i]);
 357                         /* read port specs */
 358                         while (++i < argc) {
 359                                 if (strcasecmp(argv[i], "state") == 0 && ++i < argc) {
 360                                         for (j = 0; j < 4 && strcasecmp(argv[i], rxtx[j]); j++);
 361                                         if (j < 4) {
 362                                                 /* change state */
 363                                                 robo_write16(&robo,ROBO_CTRL_PAGE, port[index],
 364                                                         (robo_read16(&robo, ROBO_CTRL_PAGE, port[index]) & ~(3 << 0)) | (j << 0));
 365                                         } else {
 366                                                 fprintf(stderr, "Invalid state '%s'.\n", argv[i]);
 367                                                 exit(1);
 368                                         }
 369                                 } else
 370                                 if (strcasecmp(argv[i], "stp") == 0 && ++i < argc) {
 371                                         for (j = 0; j < 8 && strcasecmp(argv[i], stp[j]); j++);
 372                                         if (j < 8) {
 373                                                 /* change stp */
 374                                                 robo_write16(&robo,ROBO_CTRL_PAGE, port[index],
 375                                                         (robo_read16(&robo, ROBO_CTRL_PAGE, port[index]) & ~(7 << 5)) | (j << 5));
 376                                         } else {
 377                                                 fprintf(stderr, "Invalid stp '%s'.\n", argv[i]);
 378                                                 exit(1);
 379                                         }
 380                                 } else
 381                                 if (strcasecmp(argv[i], "media") == 0 && ++i < argc) {
 382                                         for (j = 0; j < 5 && strcasecmp(argv[i], media[j].name); j++);
 383                                         if (j < 5) {
 384                                                 mdio_write(&robo, port[index], MII_BMCR, media[j].bmcr);
 385                                         } else {
 386                                                 fprintf(stderr, "Invalid media '%s'.\n", argv[i]);
 387                                                 exit(1);
 388                                         }
 389                                 } else
 390                                 if (strcasecmp(argv[i], "mdi-x") == 0 && ++i < argc) {
 391                                         for (j = 0; j < 3 && strcasecmp(argv[i], mdix[j].name); j++);
 392                                         if (j < 3) {
 393                                                 mdio_write(&robo, port[index], 0x1c, mdix[j].value |
 394                                                     (mdio_read(&robo, port[index], 0x1c) & ~0x1800));
 395                                         } else {
 396                                                 fprintf(stderr, "Invalid mdi-x '%s'.\n", argv[i]);
 397                                                 exit(1);
 398                                         }
 399                                 } else
 400                                 if (strcasecmp(argv[i], "tag") == 0 && ++i < argc) {
 401                                         j = atoi(argv[i]);
 402                                         /* change vlan tag */
 403                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_PORT0_DEF_TAG + (index << 1), j);
 404                                 } else break;
 405                         }
 406                 } else
 407                 if (strcasecmp(argv[i], "vlan") == 0 && (i + 1) < argc)
 408                 {
 409                         int index = atoi(argv[++i]);
 410                         while (++i < argc) {
 411                                 if (strcasecmp(argv[i], "ports") == 0 && ++i < argc) {
 412                                         char *ports = argv[i];
 413                                         int untag = 0;
 414                                         int member = 0;
 415
 416                                         while (*ports >= '0' && *ports <= '9') {
 417                                                 j = *ports++ - '0';
 418                                                 member |= 1 << j;
 419
 420                                                 /* untag if needed, CPU port requires special handling */
 421                                                 if (*ports == 'u' || (j != 5 && (*ports == ' ' || *ports == 0)))
 422                                                 {
 423                                                         untag |= 1 << j;
 424                                                         if (*ports) ports++;
 425                                                         /* change default vlan tag */
 426                                                         robo_write16(&robo, ROBO_VLAN_PAGE,
 427                                                                 ROBO_VLAN_PORT0_DEF_TAG + (j << 1), index);
 428                                                 } else
 429                                                 if (*ports == '*' || *ports == 't' || *ports == ' ') ports++;
 430                                                 else break;
 431
 432                                                 while (*ports == ' ') ports++;
 433                                         }
 434
 435                                         if (*ports) {
 436                                                 fprintf(stderr, "Invalid ports '%s'.\n", argv[i]);
 437                                                 exit(1);
 438                                         } else {
 439                                                 /* write config now */
 440                                                 val16 = (index) /* vlan */ | (1 << 12) /* write */ | (1 << 13) /* enable */;
 441                                                 if (robo5350) {
 442                                                         robo_write32(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_WRITE_5350,
 443                                                                 (1 << 20) /* valid */ | (untag << 6) | member);
 444                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350, val16);
 445                                                 } else {
 446                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_WRITE,
 447                                                                 (1 << 14)  /* valid */ | (untag << 7) | member);
 448                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS, val16);
 449                                                 }
 450                                         }
 451                                 } else break;
 452                         }
 453                 } else
 454                 if (strcasecmp(argv[i], "switch") == 0 && (i + 1) < argc)
 455                 {
 456                         /* enable/disable switching */
 457                         robo_write16(&robo, ROBO_CTRL_PAGE, ROBO_SWITCH_MODE,
 458                                 (robo_read16(&robo, ROBO_CTRL_PAGE, ROBO_SWITCH_MODE) & ~2) |
 459                                 (*argv[++i] == 'e' ? 2 : 0));
 460                         i++;
 461                 } else
 462                 if (strcasecmp(argv[i], "vlans") == 0 && (i + 1) < argc)
 463                 {
 464                         while (++i < argc) {
 465                                 if (strcasecmp(argv[i], "reset") == 0) {
 466                                         /* reset vlan validity bit */
 467                                         for (j = 0; j <= (robo5350 ? VLAN_ID_MAX5350 : VLAN_ID_MAX); j++)
 468                                         {
 469                                                 /* write config now */
 470                                                 val16 = (j) /* vlan */ | (1 << 12) /* write */ | (1 << 13) /* enable */;
 471                                                 if (robo5350) {
 472                                                         robo_write32(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_WRITE_5350, 0);
 473                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350, val16);
 474                                                 } else {
 475                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_WRITE, 0);
 476                                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS, val16);
 477                                                 }
 478                                         }
 479                                 } else
 480                                 if (strcasecmp(argv[i], "enable") == 0 || strcasecmp(argv[i], "disable") == 0)
 481                                 {
 482                                         int disable = (*argv[i] == 'd') || (*argv[i] == 'D');
 483                                         /* enable/disable vlans */
 484                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_CTRL0, disable ? 0 :
 485                                                 (1 << 7) /* 802.1Q VLAN */ | (3 << 5) /* mac check and hash */);
 486
 487                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_CTRL1, disable ? 0 :
 488                                                 (1 << 1) | (1 << 2) | (1 << 3) /* RSV multicast */);
 489
 490                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_CTRL4, disable ? 0 :
 491                                                 (1 << 6) /* drop invalid VID frames */);
 492
 493                                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_CTRL5, disable ? 0 :
 494                                                 (1 << 3) /* drop miss V table frames */);
 495
 496                                 } else break;
 497                         }
 498                 } else
 499                 if (strcasecmp(argv[i], "show") == 0)
 500                 {
 501                         break;
 502                 } else {
 503                         fprintf(stderr, "Invalid option %s\n", argv[i]);
 504                         usage();
 505                         exit(1);
 506                 }
 507         }
 508
 509         if (i == argc) {
 510                 if (argc == 1) usage();
 511                 return 0;
 512         }
 513
 514         /* show config */
 515
 516         printf("Switch: %sabled\n", robo_read16(&robo, ROBO_CTRL_PAGE, ROBO_SWITCH_MODE) & 2 ? "en" : "dis");
 517
 518         for (i = 0; i < 6; i++) {
 519                 printf(robo_read16(&robo, ROBO_STAT_PAGE, ROBO_LINK_STAT_SUMMARY) & (1 << port[i]) ?
 520                         "Port %d(%c): %s%s " : "Port %d(%c):  DOWN ", i, ports[i],
 521                         robo_read16(&robo, ROBO_STAT_PAGE, ROBO_SPEED_STAT_SUMMARY) & (1 << port[i]) ? "100" : " 10",
 522                         robo_read16(&robo, ROBO_STAT_PAGE, ROBO_DUPLEX_STAT_SUMMARY) & (1 << port[i]) ? "FD" : "HD");
 523
 524                 val16 = robo_read16(&robo, ROBO_CTRL_PAGE, port[i]);
 525
 526                 printf("%s stp: %s vlan: %d ", rxtx[val16 & 3], stp[(val16 >> 5) & 7],
 527                         robo_read16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_PORT0_DEF_TAG + (i << 1)));
 528
 529                 robo_read(&robo, ROBO_STAT_PAGE, ROBO_LSA_PORT0 + port[i] * 6, mac, 3);
 530
 531                 printf("mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
 532                         mac[2] >> 8, mac[2] & 255, mac[1] >> 8, mac[1] & 255, mac[0] >> 8, mac[0] & 255);
 533         }
 534
 535         val16 = robo_read16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_CTRL0);
 536
 537         printf("VLANs: %s %sabled%s%s\n",
 538                 robo5350 ? "BCM5325/535x" : "BCM536x",
 539                 (val16 & (1 << 7)) ? "en" : "dis",
 540                 (val16 & (1 << 6)) ? " mac_check" : "",
 541                 (val16 & (1 << 5)) ? " mac_hash" : "");
 542
 543         /* scan VLANs */
 544         for (i = 0; i <= (robo5350 ? VLAN_ID_MAX5350 : VLAN_ID_MAX); i++) {
 545                 /* issue read */
 546                 val16 = (i) /* vlan */ | (0 << 12) /* read */ | (1 << 13) /* enable */;
 547
 548                 if (robo5350) {
 549                         u32 val32;
 550                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350, val16);
 551                         /* actual read */
 552                         val32 = robo_read32(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_READ);
 553                         if ((val32 & (1 << 20)) /* valid */) {
 554                                 printf("vlan%d:", i);
 555                                 for (j = 0; j < 6; j++) {
 556                                         if (val32 & (1 << j)) {
 557                                                 printf(" %d%s", j, (val32 & (1 << (j + 6))) ?
 558                                                         (j == 5 ? "u" : "") : "t");
 559                                         }
 560                                 }
 561                                 printf("\n");
 562                         }
 563                 } else {
 564                         robo_write16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS, val16);
 565                         /* actual read */
 566                         val16 = robo_read16(&robo, ROBO_VLAN_PAGE, ROBO_VLAN_READ);
 567                         if ((val16 & (1 << 14)) /* valid */) {
 568                                 printf("vlan%d:", i);
 569                                 for (j = 0; j < 6; j++) {
 570                                         if (val16 & (1 << j)) {
 571                                                 printf(" %d%s", j, (val16 & (1 << (j + 7))) ?
 572                                                         (j == 5 ? "u" : "") : "t");
 573                                         }
 574                                 }
 575                                 printf("\n");
 576                         }
 577                 }
 578         }
 579
 580         return (0);
 581 }