package/broadcom-57xx/src/bcmrobo.c

   1 /*
   2  * Broadcom BCM5325E/536x switch configuration module
   3  *
   4  * Copyright (C) 2007 Felix Fietkau <nbd@openwrt.org>
   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  * Based on:
  17  *   Broadcom 53xx RoboSwitch device driver.
  18  *
  19  *   Copyright 2007, Broadcom Corporation
  20  *   All Rights Reserved.
  21  *
  22  *   THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
  23  *   KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
  24  *   SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
  25  *   FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
  26  */
  27
  28
  29 #include <linux/autoconf.h>
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <asm/uaccess.h>
  33
  34 #include <typedefs.h>
  35 #include <osl.h>
  36 #include <sbutils.h>
  37 #include <sbconfig.h>
  38 #include <bcmendian.h>
  39 #include "bcmparams.h"
  40 #include <bcmnvram.h>
  41 #include <bcmdevs.h>
  42 #include "bcmrobo.h"
  43 #include "proto/ethernet.h"
  44 #include <switch-core.h>
  45
  46 #define DRIVER_NAME             "bcm57xx"
  47 #define DRIVER_VERSION  "0.1"
  48
  49 #ifndef GPIO_PIN_NOTDEFINED
  50 #define GPIO_PIN_NOTDEFINED     0x20
  51 #endif
  52
  53 #ifdef  BCMDBG
  54 #define ET_ERROR(args)  printk args
  55 #else   /* BCMDBG */
  56 #define ET_ERROR(args)
  57 #endif  /* BCMDBG */
  58 #define ET_MSG(args)
  59
  60 /*
  61  * Switch can be programmed through SPI interface, which
  62  * has a rreg and a wreg functions to read from and write to
  63  * registers.
  64  */
  65
  66 /* MII access registers */
  67 #define PSEUDO_PHYAD    0x1E    /* MII Pseudo PHY address */
  68 #define REG_MII_PAGE    0x10    /* MII Page register */
  69 #define REG_MII_ADDR    0x11    /* MII Address register */
  70 #define REG_MII_DATA0   0x18    /* MII Data register 0 */
  71 #define REG_MII_DATA1   0x19    /* MII Data register 1 */
  72 #define REG_MII_DATA2   0x1a    /* MII Data register 2 */
  73 #define REG_MII_DATA3   0x1b    /* MII Data register 3 */
  74
  75 /* Page numbers */
  76 #define PAGE_CTRL       0x00    /* Control page */
  77 #define PAGE_MMR        0x02    /* 5397 Management/Mirroring page */
  78 #define PAGE_VTBL       0x05    /* ARL/VLAN Table access page */
  79 #define PAGE_VLAN       0x34    /* VLAN page */
  80
  81 /* Control page registers */
  82 #define REG_CTRL_PORT0  0x00    /* Port 0 traffic control register */
  83 #define REG_CTRL_PORT1  0x01    /* Port 1 traffic control register */
  84 #define REG_CTRL_PORT2  0x02    /* Port 2 traffic control register */
  85 #define REG_CTRL_PORT3  0x03    /* Port 3 traffic control register */
  86 #define REG_CTRL_PORT4  0x04    /* Port 4 traffic control register */
  87 #define REG_CTRL_PORT5  0x05    /* Port 5 traffic control register */
  88 #define REG_CTRL_PORT6  0x06    /* Port 6 traffic control register */
  89 #define REG_CTRL_PORT7  0x07    /* Port 7 traffic control register */
  90 #define REG_CTRL_MODE   0x0B    /* Switch Mode register */
  91 #define REG_CTRL_MIIPO  0x0E    /* 5325: MII Port Override register */
  92 #define REG_CTRL_SRST   0x79    /* Software reset control register */
  93
  94 #define REG_DEVICE_ID   0x30    /* 539x Device id: */
  95 #define DEVID5325       0x25    /*  5325 (Not really be we fake it) */
  96 #define DEVID5395       0x95    /*  5395 */
  97 #define DEVID5397       0x97    /*  5397 */
  98 #define DEVID5398       0x98    /*  5398 */
  99
 100 /* VLAN page registers */
 101 #define REG_VLAN_CTRL0  0x00    /* VLAN Control 0 register */
 102 #define REG_VLAN_CTRL1  0x01    /* VLAN Control 1 register */
 103 #define REG_VLAN_CTRL4  0x04    /* VLAN Control 4 register */
 104 #define REG_VLAN_CTRL5  0x05    /* VLAN Control 5 register */
 105 #define REG_VLAN_ACCESS 0x06    /* VLAN Table Access register */
 106 #define REG_VLAN_WRITE  0x08    /* VLAN Write register */
 107 #define REG_VLAN_READ   0x0C    /* VLAN Read register */
 108 #define REG_VLAN_PTAG0  0x10    /* VLAN Default Port Tag register - port 0 */
 109 #define REG_VLAN_PTAG1  0x12    /* VLAN Default Port Tag register - port 1 */
 110 #define REG_VLAN_PTAG2  0x14    /* VLAN Default Port Tag register - port 2 */
 111 #define REG_VLAN_PTAG3  0x16    /* VLAN Default Port Tag register - port 3 */
 112 #define REG_VLAN_PTAG4  0x18    /* VLAN Default Port Tag register - port 4 */
 113 #define REG_VLAN_PTAG5  0x1a    /* VLAN Default Port Tag register - port 5 */
 114 #define REG_VLAN_PTAG6  0x1c    /* VLAN Default Port Tag register - port 6 */
 115 #define REG_VLAN_PTAG7  0x1e    /* VLAN Default Port Tag register - port 7 */
 116 #define REG_VLAN_PTAG8  0x20    /* 539x: VLAN Default Port Tag register - IMP port */
 117 #define REG_VLAN_PMAP   0x20    /* 5325: VLAN Priority Re-map register */
 118
 119 #define VLAN_NUMVLANS   16      /* # of VLANs */
 120
 121
 122 /* ARL/VLAN Table Access page registers */
 123 #define REG_VTBL_CTRL           0x00    /* ARL Read/Write Control */
 124 #define REG_VTBL_MINDX          0x02    /* MAC Address Index */
 125 #define REG_VTBL_VINDX          0x08    /* VID Table Index */
 126 #define REG_VTBL_ARL_E0         0x10    /* ARL Entry 0 */
 127 #define REG_VTBL_ARL_E1         0x18    /* ARL Entry 1 */
 128 #define REG_VTBL_DAT_E0         0x18    /* ARL Table Data Entry 0 */
 129 #define REG_VTBL_SCTRL          0x20    /* ARL Search Control */
 130 #define REG_VTBL_SADDR          0x22    /* ARL Search Address */
 131 #define REG_VTBL_SRES           0x24    /* ARL Search Result */
 132 #define REG_VTBL_SREXT          0x2c    /* ARL Search Result */
 133 #define REG_VTBL_VID_E0         0x30    /* VID Entry 0 */
 134 #define REG_VTBL_VID_E1         0x32    /* VID Entry 1 */
 135 #define REG_VTBL_PREG           0xFF    /* Page Register */
 136 #define REG_VTBL_ACCESS         0x60    /* VLAN table access register */
 137 #define REG_VTBL_INDX           0x61    /* VLAN table address index register */
 138 #define REG_VTBL_ENTRY          0x63    /* VLAN table entry register */
 139 #define REG_VTBL_ACCESS_5395    0x80    /* VLAN table access register */
 140 #define REG_VTBL_INDX_5395      0x81    /* VLAN table address index register */
 141 #define REG_VTBL_ENTRY_5395     0x83    /* VLAN table entry register */
 142
 143 /* SPI registers */
 144 #define REG_SPI_PAGE    0xff    /* SPI Page register */
 145
 146 /* Access switch registers through GPIO/SPI */
 147
 148 /* Minimum timing constants */
 149 #define SCK_EDGE_TIME   2       /* clock edge duration - 2us */
 150 #define MOSI_SETUP_TIME 1       /* input setup duration - 1us */
 151 #define SS_SETUP_TIME   1       /* select setup duration - 1us */
 152
 153 /* misc. constants */
 154 #define SPI_MAX_RETRY   100
 155
 156 static int config_attach(robo_info_t *robo);
 157 static void config_detach(robo_info_t *robo);
 158
 159 /* Enable GPIO access to the chip */
 160 static void
 161 gpio_enable(robo_info_t *robo)
 162 {
 163         /* Enable GPIO outputs with SCK and MOSI low, SS high */
 164         sb_gpioout(robo->sbh, robo->ss | robo->sck | robo->mosi, robo->ss, GPIO_DRV_PRIORITY);
 165         sb_gpioouten(robo->sbh, robo->ss | robo->sck | robo->mosi,
 166                      robo->ss | robo->sck | robo->mosi, GPIO_DRV_PRIORITY);
 167 }
 168
 169 /* Disable GPIO access to the chip */
 170 static void
 171 gpio_disable(robo_info_t *robo)
 172 {
 173         /* Disable GPIO outputs with all their current values */
 174         sb_gpioouten(robo->sbh, robo->ss | robo->sck | robo->mosi, 0, GPIO_DRV_PRIORITY);
 175 }
 176
 177 /* Write a byte stream to the chip thru SPI */
 178 static int
 179 spi_write(robo_info_t *robo, uint8 *buf, uint len)
 180 {
 181         uint i;
 182         uint8 mask;
 183
 184         /* Byte bang from LSB to MSB */
 185         for (i = 0; i < len; i++) {
 186                 /* Bit bang from MSB to LSB */
 187                 for (mask = 0x80; mask; mask >>= 1) {
 188                         /* Clock low */
 189                         sb_gpioout(robo->sbh, robo->sck, 0, GPIO_DRV_PRIORITY);
 190                         OSL_DELAY(SCK_EDGE_TIME);
 191
 192                         /* Sample on rising edge */
 193                         if (mask & buf[i])
 194                                 sb_gpioout(robo->sbh, robo->mosi, robo->mosi, GPIO_DRV_PRIORITY);
 195                         else
 196                                 sb_gpioout(robo->sbh, robo->mosi, 0, GPIO_DRV_PRIORITY);
 197                         OSL_DELAY(MOSI_SETUP_TIME);
 198
 199                         /* Clock high */
 200                         sb_gpioout(robo->sbh, robo->sck, robo->sck, GPIO_DRV_PRIORITY);
 201                         OSL_DELAY(SCK_EDGE_TIME);
 202                 }
 203         }
 204
 205         return 0;
 206 }
 207
 208 /* Read a byte stream from the chip thru SPI */
 209 static int
 210 spi_read(robo_info_t *robo, uint8 *buf, uint len)
 211 {
 212         uint i, timeout;
 213         uint8 rack, mask, byte;
 214
 215         /* Timeout after 100 tries without RACK */
 216         for (i = 0, rack = 0, timeout = SPI_MAX_RETRY; i < len && timeout;) {
 217                 /* Bit bang from MSB to LSB */
 218                 for (mask = 0x80, byte = 0; mask; mask >>= 1) {
 219                         /* Clock low */
 220                         sb_gpioout(robo->sbh, robo->sck, 0, GPIO_DRV_PRIORITY);
 221                         OSL_DELAY(SCK_EDGE_TIME);
 222
 223                         /* Sample on falling edge */
 224                         if (sb_gpioin(robo->sbh) & robo->miso)
 225                                 byte |= mask;
 226
 227                         /* Clock high */
 228                         sb_gpioout(robo->sbh, robo->sck, robo->sck, GPIO_DRV_PRIORITY);
 229                         OSL_DELAY(SCK_EDGE_TIME);
 230                 }
 231                 /* RACK when bit 0 is high */
 232                 if (!rack) {
 233                         rack = (byte & 1);
 234                         timeout--;
 235                         continue;
 236                 }
 237                 /* Byte bang from LSB to MSB */
 238                 buf[i] = byte;
 239                 i++;
 240         }
 241
 242         if (timeout == 0) {
 243                 ET_ERROR(("spi_read: timeout"));
 244                 return -1;
 245         }
 246
 247         return 0;
 248 }
 249
 250 /* Enable/disable SPI access */
 251 static void
 252 spi_select(robo_info_t *robo, uint8 spi)
 253 {
 254         if (spi) {
 255                 /* Enable SPI access */
 256                 sb_gpioout(robo->sbh, robo->ss, 0, GPIO_DRV_PRIORITY);
 257         } else {
 258                 /* Disable SPI access */
 259                 sb_gpioout(robo->sbh, robo->ss, robo->ss, GPIO_DRV_PRIORITY);
 260         }
 261         OSL_DELAY(SS_SETUP_TIME);
 262 }
 263
 264
 265 /* Select chip and page */
 266 static void
 267 spi_goto(robo_info_t *robo, uint8 page)
 268 {
 269         uint8 reg8 = REG_SPI_PAGE;      /* page select register */
 270         uint8 cmd8;
 271
 272         /* Issue the command only when we are on a different page */
 273         if (robo->page == page)
 274                 return;
 275
 276         robo->page = page;
 277
 278         /* Enable SPI access */
 279         spi_select(robo, 1);
 280
 281         /* Select new page with CID 0 */
 282         cmd8 = ((6 << 4) |              /* normal SPI */
 283                 1);                     /* write */
 284         spi_write(robo, &cmd8, 1);
 285         spi_write(robo, &reg8, 1);
 286         spi_write(robo, &page, 1);
 287
 288         /* Disable SPI access */
 289         spi_select(robo, 0);
 290 }
 291
 292 /* Write register thru SPI */
 293 static int
 294 spi_wreg(robo_info_t *robo, uint8 page, uint8 addr, void *val, int len)
 295 {
 296         int status = 0;
 297         uint8 cmd8;
 298         union {
 299                 uint8 val8;
 300                 uint16 val16;
 301                 uint32 val32;
 302         } bytes;
 303
 304         /* validate value length and buffer address */
 305         ASSERT(len == 1 || (len == 2 && !((int)val & 1)) ||
 306                (len == 4 && !((int)val & 3)));
 307
 308         /* Select chip and page */
 309         spi_goto(robo, page);
 310
 311         /* Enable SPI access */
 312         spi_select(robo, 1);
 313
 314         /* Write with CID 0 */
 315         cmd8 = ((6 << 4) |              /* normal SPI */
 316                 1);                     /* write */
 317         spi_write(robo, &cmd8, 1);
 318         spi_write(robo, &addr, 1);
 319         switch (len) {
 320         case 1:
 321                 bytes.val8 = *(uint8 *)val;
 322                 break;
 323         case 2:
 324                 bytes.val16 = htol16(*(uint16 *)val);
 325                 break;
 326         case 4:
 327                 bytes.val32 = htol32(*(uint32 *)val);
 328                 break;
 329         }
 330         spi_write(robo, (uint8 *)val, len);
 331
 332         ET_MSG(("%s: [0x%x-0x%x] := 0x%x (len %d)\n", __FUNCTION__, page, addr,
 333                 *(uint16 *)val, len));
 334         /* Disable SPI access */
 335         spi_select(robo, 0);
 336         return status;
 337 }
 338
 339 /* Read register thru SPI in fast SPI mode */
 340 static int
 341 spi_rreg(robo_info_t *robo, uint8 page, uint8 addr, void *val, int len)
 342 {
 343         int status = 0;
 344         uint8 cmd8;
 345         union {
 346                 uint8 val8;
 347                 uint16 val16;
 348                 uint32 val32;
 349         } bytes;
 350
 351         /* validate value length and buffer address */
 352         ASSERT(len == 1 || (len == 2 && !((int)val & 1)) ||
 353                (len == 4 && !((int)val & 3)));
 354
 355         /* Select chip and page */
 356         spi_goto(robo, page);
 357
 358         /* Enable SPI access */
 359         spi_select(robo, 1);
 360
 361         /* Fast SPI read with CID 0 and byte offset 0 */
 362         cmd8 = (1 << 4);                /* fast SPI */
 363         spi_write(robo, &cmd8, 1);
 364         spi_write(robo, &addr, 1);
 365         status = spi_read(robo, (uint8 *)&bytes, len);
 366         switch (len) {
 367         case 1:
 368                 *(uint8 *)val = bytes.val8;
 369                 break;
 370         case 2:
 371                 *(uint16 *)val = ltoh16(bytes.val16);
 372                 break;
 373         case 4:
 374                 *(uint32 *)val = ltoh32(bytes.val32);
 375                 break;
 376         }
 377
 378         ET_MSG(("%s: [0x%x-0x%x] => 0x%x (len %d)\n", __FUNCTION__, page, addr,
 379                 *(uint16 *)val, len));
 380
 381         /* Disable SPI access */
 382         spi_select(robo, 0);
 383         return status;
 384 }
 385
 386 /* SPI/gpio interface functions */
 387 static dev_ops_t spigpio = {
 388         gpio_enable,
 389         gpio_disable,
 390         spi_wreg,
 391         spi_rreg,
 392         "SPI (GPIO)"
 393 };
 394
 395
 396 /* Access switch registers through MII (MDC/MDIO) */
 397
 398 #define MII_MAX_RETRY   100
 399
 400 /* Write register thru MDC/MDIO */
 401 static  int
 402 mii_wreg(robo_info_t *robo, uint8 page, uint8 reg, void *val, int len)
 403 {
 404         uint16 cmd16, val16,val48[3];
 405         void *h = robo->h;
 406     uint32 val64[2];
 407         memset(val48,0,6);
 408         memset(val64,0,8);
 409         int i;
 410         uint8 *ptr = (uint8 *)val;
 411
 412         /* validate value length and buffer address */
 413         ASSERT(len == 1 || len == 6 || len == 8 ||
 414                ((len == 2) && !((int)val & 1)) || ((len == 4) && !((int)val & 3)));
 415
 416         ET_MSG(("%s: [0x%x-0x%x] := 0x%x (len %d)\n", __FUNCTION__, page, reg,
 417                   *(uint16 *)val, len));
 418
 419         /* set page number - MII register 0x10 */
 420         if (robo->page != page) {
 421                 cmd16 = ((page << 8) |          /* page number */
 422                          1);                    /* mdc/mdio access enable */
 423                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_PAGE, cmd16);
 424                 robo->page = page;
 425         }
 426
 427         switch (len) {
 428         case 8:
 429                 val16 = ptr[7];
 430                 val16 = ((val16 << 8) | ptr[6]);
 431                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA3, val16);
 432                 /* FALLTHRU */
 433
 434         case 6:
 435                 val16 = ptr[5];
 436                 val16 = ((val16 << 8) | ptr[4]);
 437                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA2, val16);
 438                 val16 = ptr[3];
 439                 val16 = ((val16 << 8) | ptr[2]);
 440                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA1, val16);
 441                 val16 = ptr[1];
 442                 val16 = ((val16 << 8) | ptr[0]);
 443                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA0, val16);
 444                 break;
 445
 446         case 4:
 447                 val16 = (uint16)((*(uint32 *)val) >> 16);
 448                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA1, val16);
 449                 val16 = (uint16)(*(uint32 *)val);
 450                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA0, val16);
 451                 break;
 452
 453         case 2:
 454                 val16 = *(uint16 *)val;
 455                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA0, val16);
 456                 break;
 457
 458         case 1:
 459                 val16 = *(uint8 *)val;
 460                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_DATA0, val16);
 461                 break;
 462         }
 463
 464         /* set register address - MII register 0x11 */
 465         cmd16 = ((reg << 8) |           /* register address */
 466                  1);            /* opcode write */
 467         robo->miiwr(h, PSEUDO_PHYAD, REG_MII_ADDR, cmd16);
 468
 469         /* is operation finished? */
 470         for (i = MII_MAX_RETRY; i > 0; i --) {
 471                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_ADDR);
 472                 if ((val16 & 3) == 0)
 473                         break;
 474         }
 475
 476         /* timed out */
 477         if (!i) {
 478                 ET_ERROR(("mii_wreg: timeout"));
 479                 return -1;
 480         }
 481         return 0;
 482 }
 483
 484 /* Read register thru MDC/MDIO */
 485 static  int
 486 mii_rreg(robo_info_t *robo, uint8 page, uint8 reg, void *val, int len)
 487 {
 488         uint16 cmd16, val16;
 489         void *h = robo->h;
 490         int i;
 491         uint8 *ptr = (uint8 *)val;
 492
 493         /* validate value length and buffer address */
 494         ASSERT(len == 1 || len == 6 || len == 8 ||
 495                ((len == 2) && !((int)val & 1)) || ((len == 4) && !((int)val & 3)));
 496
 497         /* set page number - MII register 0x10 */
 498         if (robo->page != page) {
 499                 cmd16 = ((page << 8) |          /* page number */
 500                          1);                    /* mdc/mdio access enable */
 501                 robo->miiwr(h, PSEUDO_PHYAD, REG_MII_PAGE, cmd16);
 502                 robo->page = page;
 503         }
 504
 505         /* set register address - MII register 0x11 */
 506         cmd16 = ((reg << 8) |           /* register address */
 507                  2);                    /* opcode read */
 508         robo->miiwr(h, PSEUDO_PHYAD, REG_MII_ADDR, cmd16);
 509
 510         /* is operation finished? */
 511         for (i = MII_MAX_RETRY; i > 0; i --) {
 512                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_ADDR);
 513                 if ((val16 & 3) == 0)
 514                         break;
 515         }
 516         /* timed out */
 517         if (!i) {
 518                 ET_ERROR(("mii_rreg: timeout"));
 519                 return -1;
 520         }
 521
 522         ET_MSG(("%s: [0x%x-0x%x] => 0x%x (len %d)\n", __FUNCTION__, page, reg, val16, len));
 523
 524         switch (len) {
 525         case 8:
 526                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA3);
 527                 ptr[7] = (val16 >> 8);
 528                 ptr[6] = (val16 & 0xff);
 529                 /* FALLTHRU */
 530
 531         case 6:
 532                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA2);
 533                 ptr[5] = (val16 >> 8);
 534                 ptr[4] = (val16 & 0xff);
 535                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA1);
 536                 ptr[3] = (val16 >> 8);
 537                 ptr[2] = (val16 & 0xff);
 538                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA0);
 539                 ptr[1] = (val16 >> 8);
 540                 ptr[0] = (val16 & 0xff);
 541                 break;
 542
 543         case 4:
 544                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA1);
 545                 *(uint32 *)val = (((uint32)val16) << 16);
 546                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA0);
 547                 *(uint32 *)val |= val16;
 548                 break;
 549
 550         case 2:
 551                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA0);
 552                 *(uint16 *)val = val16;
 553                 break;
 554         case 1:
 555                 val16 = robo->miird(h, PSEUDO_PHYAD, REG_MII_DATA0);
 556                 *(uint8 *)val = (uint8)(val16 & 0xff);
 557                 break;
 558         }
 559
 560         return 0;
 561 }
 562
 563 /* MII interface functions */
 564 static dev_ops_t mdcmdio = {
 565         NULL,
 566         NULL,
 567         mii_wreg,
 568         mii_rreg,
 569         "MII (MDC/MDIO)"
 570 };
 571
 572 /* High level switch configuration functions. */
 573
 574 static int
 575 findmatch(char *string, char *name)
 576 {
 577         uint len;
 578         char *c;
 579
 580         len = strlen(name);
 581         /* CSTYLED */
 582         while ((c = strchr(string, ',')) != NULL) {
 583                 if (len == (uint)(c - string) && !strncmp(string, name, len))
 584                         return 1;
 585                 string = c + 1;
 586         }
 587
 588         return (!strcmp(string, name));
 589 }
 590
 591 static uint
 592 getgpiopin(char *vars, char *pin_name, uint def_pin)
 593 {
 594         char name[] = "gpioXXXX";
 595         char *val;
 596         uint pin;
 597
 598         /* Go thru all possibilities till a match in pin name */
 599         for (pin = 0; pin < GPIO_NUMPINS; pin ++) {
 600                 snprintf(name, sizeof(name), "gpio%d", pin);
 601                 val = getvar(vars, name);
 602                 if (val && findmatch(val, pin_name))
 603                         return pin;
 604         }
 605
 606         if (def_pin != GPIO_PIN_NOTDEFINED) {
 607                 /* make sure the default pin is not used by someone else */
 608                 snprintf(name, sizeof(name), "gpio%d", def_pin);
 609                 if (getvar(vars, name)) {
 610                         def_pin =  GPIO_PIN_NOTDEFINED;
 611                 }
 612         }
 613
 614         return def_pin;
 615 }
 616
 617
 618 /* Port flags */
 619 #define FLAG_TAGGED     't'     /* output tagged (external ports only) */
 620 #define FLAG_UNTAG      'u'     /* input & output untagged (CPU port only, for OS (linux, ...) */
 621 #define FLAG_LAN        '*'     /* input & output untagged (CPU port only, for CFE */
 622
 623 /* port descriptor */
 624 typedef struct {
 625         uint32 untag;   /* untag enable bit (Page 0x05 Address 0x63-0x66 Bit[17:9]) */
 626         uint32 member;  /* vlan member bit (Page 0x05 Address 0x63-0x66 Bit[7:0]) */
 627         uint8 ptagr;    /* port tag register address (Page 0x34 Address 0x10-0x1F) */
 628         uint8 cpu;      /* is this cpu port? */
 629 } pdesc_t;
 630
 631 pdesc_t pdesc97[] = {
 632         /* 5395/5397/5398 is 0 ~ 7.  port 8 is IMP port. */
 633         /* port 0 */ {1 << 9, 1 << 0, REG_VLAN_PTAG0, 0},
 634         /* port 1 */ {1 << 10, 1 << 1, REG_VLAN_PTAG1, 0},
 635         /* port 2 */ {1 << 11, 1 << 2, REG_VLAN_PTAG2, 0},
 636         /* port 3 */ {1 << 12, 1 << 3, REG_VLAN_PTAG3, 0},
 637         /* port 4 */ {1 << 13, 1 << 4, REG_VLAN_PTAG4, 0},
 638         /* port 5 */ {1 << 14, 1 << 5, REG_VLAN_PTAG5, 0},
 639         /* port 6 */ {1 << 15, 1 << 6, REG_VLAN_PTAG6, 0},
 640         /* port 7 */ {1 << 16, 1 << 7, REG_VLAN_PTAG7, 0},
 641         /* mii port */ {1 << 17, 1 << 8, REG_VLAN_PTAG8, 1},
 642 };
 643
 644 pdesc_t pdesc25[] = {
 645         /* port 0 */ {1 << 6, 1 << 0, REG_VLAN_PTAG0, 0},
 646         /* port 1 */ {1 << 7, 1 << 1, REG_VLAN_PTAG1, 0},
 647         /* port 2 */ {1 << 8, 1 << 2, REG_VLAN_PTAG2, 0},
 648         /* port 3 */ {1 << 9, 1 << 3, REG_VLAN_PTAG3, 0},
 649         /* port 4 */ {1 << 10, 1 << 4, REG_VLAN_PTAG4, 0},
 650         /* mii port */ {1 << 11, 1 << 5, REG_VLAN_PTAG5, 1},
 651 };
 652
 653
 654 #define to_robo(driver) ((robo_info_t *) ((switch_driver *) driver)->priv)
 655 #define ROBO_START(driver) \
 656         do { \
 657                 robo_info_t *robo = to_robo(driver); \
 658                 if (robo->ops->enable_mgmtif) \
 659                         robo->ops->enable_mgmtif(robo)
 660
 661 #define ROBO_END(driver) \
 662                 if (robo->ops->disable_mgmtif) \
 663                         robo->ops->disable_mgmtif(robo); \
 664         } while (0)
 665
 666 int
 667 bcm_robo_reset(robo_info_t *robo)
 668 {
 669         int i, max_port_ind;
 670         uint8 val8;
 671         uint16 val16;
 672         uint32 val32;
 673         pdesc_t *pdesc;
 674         int pdescsz;
 675
 676 /* printk(KERN_WARNING "bcmrobo.c: bcm_robo_reset\n"); */
 677
 678         if (robo->ops->enable_mgmtif)
 679                 robo->ops->enable_mgmtif(robo);
 680
 681         /* setup global vlan configuration, FIXME: necessary? */
 682         /* VLAN Control 0 Register (Page 0x34, Address 0) */
 683         val8 = ((1 << 7) |              /* enable 802.1Q VLAN */
 684                 (3 << 5));              /* individual VLAN learning mode */
 685         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL0, &val8, sizeof(val8));
 686
 687         /* VLAN Control 1 Register (Page 0x34, Address 1) */
 688         robo->ops->read_reg(robo, PAGE_VLAN, REG_VLAN_CTRL0, &val8, sizeof(val8));
 689         val8 |= ((1 << 2) |             /* enable RSV multicast V Fwdmap */
 690                 (1 << 3));              /* enable RSV multicast V Untagmap */
 691         if (robo->devid == DEVID5325)
 692                 val8 |= (1 << 1);       /* enable RSV multicast V Tagging */
 693         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL1, &val8, sizeof(val8));
 694
 695         bcm_robo_set_macaddr(robo, NULL);
 696
 697         if (robo->devid == DEVID5325) {
 698                 /* VLAN Control 4 Register (Page 0x34, Address 4) */
 699                 val8 = (1 << 6);                /* drop frame with VID violation */
 700                 robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL4, &val8, sizeof(val8));
 701
 702                 /* VLAN Control 5 Register (Page 0x34, Address 5) */
 703                 val8 = (1 << 3);                /* drop frame when miss V table */
 704                 robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL5, &val8, sizeof(val8));
 705
 706                 pdesc = pdesc25;
 707                 pdescsz = sizeof(pdesc25) / sizeof(pdesc_t);
 708         } else {
 709                 pdesc = pdesc97;
 710                 pdescsz = sizeof(pdesc97) / sizeof(pdesc_t);
 711         }
 712
 713         if (robo->devid == DEVID5325) {
 714                 /* setup priority mapping - applies to tagged ingress frames */
 715                 /* Priority Re-map Register (Page 0x34, Address 0x20-0x23) */
 716                 /* FIXME: un-hardcode */
 717                 val32 = ((0 << 0) |     /* 0 -> 0 */
 718                          (1 << 3) |     /* 1 -> 1 */
 719                          (2 << 6) |     /* 2 -> 2 */
 720                          (3 << 9) |     /* 3 -> 3 */
 721                          (4 << 12) |    /* 4 -> 4 */
 722                          (5 << 15) |    /* 5 -> 5 */
 723                          (6 << 18) |    /* 6 -> 6 */
 724                          (7 << 21));    /* 7 -> 7 */
 725                 robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_PMAP, &val32, sizeof(val32));
 726         }
 727
 728         /* Set unmanaged mode */
 729         robo->ops->read_reg(robo, PAGE_CTRL, REG_CTRL_MODE, &val8, sizeof(val8));
 730         val8 &= (~(1 << 0));
 731         robo->ops->write_reg(robo, PAGE_CTRL, REG_CTRL_MODE, &val8, sizeof(val8));
 732
 733         /* No spanning tree for unmanaged mode */
 734         val8 = 0;
 735         max_port_ind = ((robo->devid == DEVID5398) ? REG_CTRL_PORT7 : REG_CTRL_PORT4);
 736         for (i = REG_CTRL_PORT0; i <= max_port_ind; i++) {
 737                 robo->ops->write_reg(robo, PAGE_CTRL, i, &val8, sizeof(val8));
 738         }
 739
 740         /* WAN port LED */
 741         val16 = 0x1f;
 742         robo->ops->write_reg(robo, PAGE_CTRL, 0x16, &val16, 2);
 743
 744         if (robo->ops->enable_mgmtif)
 745                 robo->ops->disable_mgmtif(robo);
 746
 747         return 0;
 748 }
 749
 750 /* Get access to the RoboSwitch */
 751 robo_info_t *
 752 bcm_robo_attach(sb_t *sbh, void *h, char *name, char *vars, miird_f miird, miiwr_f miiwr)
 753 {
 754         robo_info_t *robo;
 755         uint32 reset, idx;
 756         uint8 val8;
 757         uint16 val16;
 758
 759         /* Allocate and init private state */
 760         if (!(robo = MALLOC(sb_osh(sbh), sizeof(robo_info_t)))) {
 761                 ET_ERROR(("robo_attach: out of memory, malloced %d bytes", MALLOCED(sb_osh(sbh))));
 762                 return NULL;
 763         }
 764         bzero(robo, sizeof(robo_info_t));
 765
 766         robo->h = h;
 767         robo->sbh = sbh;
 768         robo->vars = vars;
 769         robo->miird = miird;
 770         robo->miiwr = miiwr;
 771         robo->page = -1;
 772         robo->name = name;
 773
 774         /* Trigger external reset by nvram variable existance */
 775         if ((reset = getgpiopin(robo->vars, "robo_reset", GPIO_PIN_NOTDEFINED)) !=
 776             GPIO_PIN_NOTDEFINED) {
 777                 /*
 778                  * Reset sequence: RESET low(50ms)->high(20ms)
 779                  *
 780                  * We have to perform a full sequence for we don't know how long
 781                  * it has been from power on till now.
 782                  */
 783                 ET_MSG(("%s: Using external reset in gpio pin %d\n", __FUNCTION__, reset));
 784                 reset = 1 << reset;
 785
 786                 /* Keep RESET low for 50 ms */
 787                 sb_gpioout(robo->sbh, reset, 0, GPIO_DRV_PRIORITY);
 788                 sb_gpioouten(robo->sbh, reset, reset, GPIO_DRV_PRIORITY);
 789                 bcm_mdelay(50);
 790
 791                 if (robo->devid == DEVID5395)
 792                         nvram_set("switch_type", "BCM5395");
 793                 else if(robo->devid == DEVID5397)
 794                         nvram_set("switch_type", "BCM5397");
 795                 else
 796                         nvram_set("switch_type", "unknown");
 797
 798                 /* Keep RESET high for at least 20 ms */
 799                 sb_gpioout(robo->sbh, reset, reset, GPIO_DRV_PRIORITY);
 800                 bcm_mdelay(20);
 801         } else {
 802                 /* In case we need it */
 803                 idx = sb_coreidx(robo->sbh);
 804
 805                 if (sb_setcore(robo->sbh, SB_ROBO, 0)) {
 806                         /* If we have an internal robo core, reset it using sb_core_reset */
 807                         ET_MSG(("%s: Resetting internal robo core\n", __FUNCTION__));
 808                         sb_core_reset(robo->sbh, 0, 0);
 809                 }
 810
 811                 sb_setcoreidx(robo->sbh, idx);
 812         }
 813
 814         if (miird && miiwr) {
 815                 uint16 tmp;
 816                 int rc, retry_count = 0;
 817
 818                 /* Read the PHY ID */
 819                 tmp = miird(h, PSEUDO_PHYAD, 2);
 820                 if (tmp != 0xffff) {
 821                         do {
 822                                 rc = mii_rreg(robo, PAGE_MMR, REG_DEVICE_ID, \
 823                                                           &robo->devid, sizeof(uint16));
 824                                 if (rc != 0)
 825                                         break;
 826                                 retry_count++;
 827                         } while ((robo->devid == 0) && (retry_count < 10));
 828
 829                         ET_MSG(("%s: devid read %ssuccesfully via mii: 0x%x\n", __FUNCTION__, \
 830                                 rc ? "un" : "", robo->devid));
 831                         ET_MSG(("%s: mii access to switch works\n", __FUNCTION__));
 832                         robo->ops = &mdcmdio;
 833                         if ((rc != 0) || (robo->devid == 0)) {
 834                                 ET_MSG(("%s: error reading devid, assuming 5325e\n", __FUNCTION__));
 835                                 robo->devid = DEVID5325;
 836                         }
 837                         ET_MSG(("%s: devid: 0x%x\n", __FUNCTION__, robo->devid));
 838                 }
 839         }
 840
 841         if ((robo->devid == DEVID5395) ||
 842             (robo->devid == DEVID5397) ||
 843             (robo->devid == DEVID5398)) {
 844                 uint8 srst_ctrl;
 845
 846                 /* If it is a 539x switch, use the soft reset register */
 847                 ET_MSG(("%s: Resetting 539x robo switch\n", __FUNCTION__));
 848
 849                 /* Reset the 539x switch core and register file */
 850                 srst_ctrl = 0x83;
 851                 mii_wreg(robo, PAGE_CTRL, REG_CTRL_SRST, &srst_ctrl, sizeof(uint8));
 852
 853                 bcm_mdelay(500);
 854
 855                 srst_ctrl = 0x00;
 856                 mii_wreg(robo, PAGE_CTRL, REG_CTRL_SRST, &srst_ctrl, sizeof(uint8));
 857         }
 858
 859         if (!robo->ops) {
 860                 int mosi, miso, ss, sck;
 861
 862                 robo->ops = &spigpio;
 863                 robo->devid = DEVID5325;
 864
 865                 /* Init GPIO mapping. Default 2, 3, 4, 5 */
 866                 ss = getgpiopin(vars, "robo_ss", 2);
 867                 if (ss == GPIO_PIN_NOTDEFINED) {
 868                         ET_ERROR(("robo_attach: robo_ss gpio fail: GPIO 2 in use"));
 869                         goto error;
 870                 }
 871                 robo->ss = 1 << ss;
 872                 sck = getgpiopin(vars, "robo_sck", 3);
 873                 if (sck == GPIO_PIN_NOTDEFINED) {
 874                         ET_ERROR(("robo_attach: robo_sck gpio fail: GPIO 3 in use"));
 875                         goto error;
 876                 }
 877                 robo->sck = 1 << sck;
 878                 mosi = getgpiopin(vars, "robo_mosi", 4);
 879                 if (mosi == GPIO_PIN_NOTDEFINED) {
 880                         ET_ERROR(("robo_attach: robo_mosi gpio fail: GPIO 4 in use"));
 881                         goto error;
 882                 }
 883                 robo->mosi = 1 << mosi;
 884                 miso = getgpiopin(vars, "robo_miso", 5);
 885                 if (miso == GPIO_PIN_NOTDEFINED) {
 886                         ET_ERROR(("robo_attach: robo_miso gpio fail: GPIO 5 in use"));
 887                         goto error;
 888                 }
 889                 robo->miso = 1 << miso;
 890                 ET_MSG(("%s: ss %d sck %d mosi %d miso %d\n", __FUNCTION__,
 891                         ss, sck, mosi, miso));
 892         }
 893
 894         /* sanity check */
 895         ASSERT(robo->ops);
 896         ASSERT(robo->ops->write_reg);
 897         ASSERT(robo->ops->read_reg);
 898         ASSERT((robo->devid == DEVID5325) ||
 899                (robo->devid == DEVID5395) ||
 900                (robo->devid == DEVID5397) ||
 901                (robo->devid == DEVID5398));
 902
 903         bcm_robo_reset(robo);
 904         config_attach(robo);
 905
 906         return robo;
 907
 908 error:
 909         MFREE(sb_osh(robo->sbh), robo, sizeof(robo_info_t));
 910         return NULL;
 911 }
 912
 913 /* Release access to the RoboSwitch */
 914 void
 915 bcm_robo_detach(robo_info_t *robo)
 916 {
 917         config_detach(robo);
 918         MFREE(sb_osh(robo->sbh), robo, sizeof(robo_info_t));
 919 }
 920
 921 /* Enable the device and set it to a known good state */
 922 int
 923 bcm_robo_enable_device(robo_info_t *robo)
 924 {
 925         uint8 reg_offset, reg_val;
 926         int ret = 0;
 927
 928         /* Enable management interface access */
 929         if (robo->ops->enable_mgmtif)
 930                 robo->ops->enable_mgmtif(robo);
 931
 932         if (robo->devid == DEVID5398) {
 933                 /* Disable unused ports: port 6 and 7 */
 934                 for (reg_offset = REG_CTRL_PORT6; reg_offset <= REG_CTRL_PORT7; reg_offset ++) {
 935                         /* Set bits [1:0] to disable RX and TX */
 936                         reg_val = 0x03;
 937                         robo->ops->write_reg(robo, PAGE_CTRL, reg_offset, &reg_val,
 938                                              sizeof(reg_val));
 939                 }
 940         }
 941
 942         if (robo->devid == DEVID5325) {
 943                 /* Must put the switch into Reverse MII mode! */
 944
 945                 /* MII port state override (page 0 register 14) */
 946                 robo->ops->read_reg(robo, PAGE_CTRL, REG_CTRL_MIIPO, &reg_val, sizeof(reg_val));
 947
 948                 /* Bit 4 enables reverse MII mode */
 949                 if (!(reg_val & (1 << 4))) {
 950                         /* Enable RvMII */
 951                         reg_val |= (1 << 4);
 952                         robo->ops->write_reg(robo, PAGE_CTRL, REG_CTRL_MIIPO, &reg_val,
 953                                              sizeof(reg_val));
 954
 955                         /* Read back */
 956                         robo->ops->read_reg(robo, PAGE_CTRL, REG_CTRL_MIIPO, &reg_val,
 957                                             sizeof(reg_val));
 958                         if (!(reg_val & (1 << 4))) {
 959                                 ET_ERROR(("robo_enable_device: enabling RvMII mode failed\n"));
 960                                 ret = -1;
 961                         }
 962                 }
 963         }
 964
 965         /* Disable management interface access */
 966         if (robo->ops->disable_mgmtif)
 967                 robo->ops->disable_mgmtif(robo);
 968
 969         return ret;
 970 }
 971
 972
 973 void bcm_robo_set_macaddr(robo_info_t *robo, char *mac_addr)
 974 {
 975         uint8 arl_entry[8] = { 0 }, arl_entry1[8] = { 0 };
 976
 977         if (mac_addr != NULL)
 978                 memcpy(robo->macaddr, mac_addr, 6);
 979
 980         mac_addr = robo->macaddr;
 981
 982         /* setup mac address */
 983         arl_entry[0] = mac_addr[5];
 984         arl_entry[1] = mac_addr[4];
 985         arl_entry[2] = mac_addr[3];
 986         arl_entry[3] = mac_addr[2];
 987         arl_entry[4] = mac_addr[1];
 988         arl_entry[5] = mac_addr[0];
 989
 990         if (robo->devid == DEVID5325) {
 991                 /* Init the entry 1 of the bin */
 992                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_ARL_E1, \
 993                                      arl_entry1, sizeof(arl_entry1));
 994                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_VID_E1, \
 995                                      arl_entry1, 1);
 996
 997                 /* Init the entry 0 of the bin */
 998                 arl_entry[6] = 0x8;             /* Port Id: MII */
 999                 arl_entry[7] = 0xc0;    /* Static Entry, Valid */
1000
1001                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_ARL_E0, \
1002                                      arl_entry, sizeof(arl_entry));
1003                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_MINDX, \
1004                                      arl_entry, ETHER_ADDR_LEN);
1005
1006         } else {
1007                 /* Initialize the MAC Addr Index Register */
1008                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_MINDX, \
1009                                      arl_entry, ETHER_ADDR_LEN);
1010         }
1011 }
1012
1013 static int handle_reset(void *driver, char *buf, int nr)
1014 {
1015         ROBO_START(driver);
1016         bcm_robo_reset(robo);
1017         ROBO_END(driver);
1018
1019         return 0;
1020 }
1021
1022
1023 static int handle_enable_read(void *driver, char *buf, int nr)
1024 {
1025         int ret;
1026         uint8 val8;
1027
1028         ROBO_START(driver);
1029         robo->ops->read_reg(robo, PAGE_CTRL, REG_CTRL_MODE, &val8, sizeof(val8));
1030         ret = sprintf(buf, "%d\n", !!(val8 & (1 << 1)));
1031         ROBO_END(driver);
1032
1033         return ret;
1034 }
1035
1036 static int handle_enable_write(void *driver, char *buf, int nr)
1037 {
1038         uint8 val8;
1039
1040 /* printk(KERN_WARNING "bcmrobo.c: handle_enable_write\n"); */
1041
1042         ROBO_START(driver);
1043         robo->ops->read_reg(robo, PAGE_CTRL, REG_CTRL_MODE, &val8, sizeof(val8));
1044         val8 &= ~(1 << 1);
1045         val8 |= ((buf[0] == '1') << 1);
1046         robo->ops->write_reg(robo, PAGE_CTRL, REG_CTRL_MODE, &val8, sizeof(val8));
1047         ROBO_END(driver);
1048
1049         return 0;
1050 }
1051
1052 static int handle_enable_vlan_read(void *driver, char *buf, int nr)
1053 {
1054         uint8 val8;
1055
1056         ROBO_START(driver);
1057         robo->ops->read_reg(robo, PAGE_VLAN, REG_VLAN_CTRL0, &val8, sizeof(val8));
1058         ROBO_END(driver);
1059
1060         return sprintf(buf, "%d\n", (((val8 & (1 << 7)) == (1 << 7)) ? 1 : 0));
1061 }
1062 static int handle_enable_vlan_write(void *driver, char *buf, int nr)
1063 {
1064         int disable = ((buf[0] != '1') ? 1 : 0);
1065
1066         uint8 val8;
1067         uint16 val16;
1068         pdesc_t *pdesc;
1069         int pdescsz;
1070         uint16 vid;
1071         uint8 arl_entry[8] = { 0 }, arl_entry1[8] = { 0 };
1072
1073 /* printk(KERN_WARNING "bcmrobo.c: handle_enable_vlan_write\n"); */
1074
1075         ROBO_START(driver);
1076
1077         /* setup global vlan configuration */
1078         /* VLAN Control 0 Register (Page 0x34, Address 0) */
1079         val8 = disable ? 0 :
1080                 ((1 << 7) |             /* enable/disable 802.1Q VLAN */
1081                 (3 << 5));              /* individual VLAN learning mode */
1082         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL0, &val8, sizeof(val8));
1083
1084         /* VLAN Control 1 Register (Page 0x34, Address 1) */
1085         val8 = disable ? 0 :
1086                 ((1 << 2) |             /* enable/disable RSV multicast V Fwdmap */
1087                 (1 << 3));              /* enable/disable RSV multicast V Untagmap */
1088         if (robo->devid == DEVID5325)
1089                 val8 |= disable ? 0 : (1 << 1);         /* enable/disable RSV multicast V Tagging */
1090         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL1, &val8, sizeof(val8));
1091
1092         if ( disable == 0 ) {           /* FIXME: ok to stop here when disabling? */
1093                 arl_entry[0] = robo->macaddr[5];
1094                 arl_entry[1] = robo->macaddr[4];
1095                 arl_entry[2] = robo->macaddr[3];
1096                 arl_entry[3] = robo->macaddr[2];
1097                 arl_entry[4] = robo->macaddr[1];
1098                 arl_entry[5] = robo->macaddr[0];
1099
1100                 if (robo->devid == DEVID5325) {
1101                         /* Init the entry 1 of the bin */
1102                         robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_ARL_E1, \
1103                                              arl_entry1, sizeof(arl_entry1));
1104                         robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_VID_E1, \
1105                                              arl_entry1, 1);
1106
1107                         /* Init the entry 0 of the bin */
1108                         arl_entry[6] = 0x8;             /* Port Id: MII */
1109                         arl_entry[7] = 0xc0;    /* Static Entry, Valid */
1110
1111                         robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_ARL_E0, \
1112                                              arl_entry, sizeof(arl_entry));
1113                         robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_MINDX, \
1114                                              arl_entry, ETHER_ADDR_LEN);
1115
1116                         /* VLAN Control 4 Register (Page 0x34, Address 4) */
1117                         val8 = (1 << 6);                /* drop frame with VID violation */
1118                         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL4, &val8, sizeof(val8));
1119
1120                         /* VLAN Control 5 Register (Page 0x34, Address 5) */
1121                         val8 = (1 << 3);                /* drop frame when miss V table */
1122                         robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_CTRL5, &val8, sizeof(val8));
1123
1124                         pdesc = pdesc25;
1125                         pdescsz = sizeof(pdesc25) / sizeof(pdesc_t);
1126                 } else {
1127                         /* Initialize the MAC Addr Index Register */
1128                         robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_MINDX, \
1129                                              arl_entry, ETHER_ADDR_LEN);
1130
1131                         pdesc = pdesc97;
1132                         pdescsz = sizeof(pdesc97) / sizeof(pdesc_t);
1133                 }
1134
1135                 /* setup each vlan. max. 16 vlans. */
1136                 /* force vlan id to be equal to vlan number */
1137                 for (vid = 0; vid < VLAN_NUMVLANS; vid ++) {
1138
1139                         /* Add static ARL entries */
1140                         if (robo->devid == DEVID5325) {
1141                                 val8 = vid;
1142                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_VID_E0, \
1143                                                      &val8, sizeof(val8));
1144                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_VINDX, \
1145                                                      &val8, sizeof(val8));
1146
1147                                 /* Write the entry */
1148                                 val8 = 0x80;
1149                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_CTRL, \
1150                                                      &val8, sizeof(val8));
1151                                 /* Wait for write to complete */
1152                                 SPINWAIT((robo->ops->read_reg(robo, PAGE_VTBL, REG_VTBL_CTRL, \
1153                                          &val8, sizeof(val8)), ((val8 & 0x80) != 0)),
1154                                          100 /* usec */);
1155                         } else {
1156                                 /* Set the VLAN Id in VLAN ID Index Register */
1157                                 val8 = vid;
1158                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_VINDX, \
1159                                                      &val8, sizeof(val8));
1160
1161                                 /* Set the MAC addr and VLAN Id in ARL Table MAC/VID Entry 0
1162                                  * Register.
1163                                  */
1164                                 arl_entry[6] = vid;
1165                                 arl_entry[7] = 0x0;
1166                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_ARL_E0, \
1167                                                      arl_entry, sizeof(arl_entry));
1168
1169                                 /* Set the Static bit , Valid bit and Port ID fields in
1170                                  * ARL Table Data Entry 0 Register
1171                                  */
1172                                 val16 = 0xc008;
1173                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_DAT_E0, \
1174                                                      &val16, sizeof(val16));
1175
1176                                 /* Clear the ARL_R/W bit and set the START/DONE bit in
1177                                  * the ARL Read/Write Control Register.
1178                                  */
1179                                 val8 = 0x80;
1180                                 robo->ops->write_reg(robo, PAGE_VTBL, REG_VTBL_CTRL, \
1181                                                      &val8, sizeof(val8));
1182                                 /* Wait for write to complete */
1183                                 SPINWAIT((robo->ops->read_reg(robo, PAGE_VTBL, REG_VTBL_CTRL, \
1184                                          &val8, sizeof(val8)), ((val8 & 0x80) != 0)),
1185                                          100 /* usec */);
1186                         }
1187                 }
1188         }
1189
1190         ROBO_END(driver);
1191         return 0;
1192 }
1193
1194 static int handle_vlan_port_read(void *driver, char *buf, int nr)
1195 {
1196         /* FIXME: yeah, some work is missing here */
1197         return sprintf(buf, "bcmrobo.c: handle_vlan_port_read unimplimented\n");
1198 }
1199
1200 static int handle_vlan_port_write(void *driver, char *buf, int nr)
1201 {
1202
1203         switch_driver *d = (switch_driver *) driver;
1204         switch_vlan_config *c = switch_parse_vlan(d, buf);
1205
1206         uint8 val8;
1207         uint16 val16;
1208         uint32 val32;
1209         int j;
1210         pdesc_t *pdesc;
1211         int pdescsz;
1212
1213 /* printk(KERN_WARNING "bcmrobo.c: handle_vlan_port_write, nr %d\n", nr); */
1214
1215         if (c == NULL)
1216                 return -EINVAL;
1217
1218         ROBO_START(driver);
1219
1220         if (robo->devid == DEVID5325) {
1221                 pdesc = pdesc25;
1222                 pdescsz = sizeof(pdesc25) / sizeof(pdesc_t);
1223         } else {
1224                 pdesc = pdesc97;
1225                 pdescsz = sizeof(pdesc97) / sizeof(pdesc_t);
1226         }
1227
1228
1229         for (j = 0; j < d->ports; j++) {
1230                 if ((c->untag | c->pvid) & (1 << j))
1231                         if ((j != d->cpuport) || (c->untag & (1 << j))) {
1232
1233                                 /* change default vlan tag */
1234
1235 /* printk(KERN_WARNING "bcmrobo.c: set default vlan tag, port %d -> vlan %d\n", j, nr); */
1236
1237                                 val16 = ((0 << 13) |            /* priority - always 0 */
1238                                         nr);                    /* vlan id */
1239                                 robo->ops->write_reg(robo, PAGE_VLAN, pdesc[j].ptagr, &val16, sizeof(val16));
1240                         }
1241         }
1242
1243
1244         if (robo->devid == DEVID5325) {
1245                 val32 = ((c->untag << 6) |              /* untag enable */
1246                          c->port);                      /* vlan members */
1247                 val32 |= ((1 << 20) |           /* valid write */
1248                           ((nr >> 4) << 12));  /* vlan id bit[11:4] */
1249                 /* VLAN Write Register (Page 0x34, Address 0x08-0x0B) */
1250                 robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_WRITE, &val32,
1251                                      sizeof(val32));
1252                 /* VLAN Table Access Register (Page 0x34, Address 0x06-0x07) */
1253                 val16 = ((1 << 13) |    /* start command */
1254                          (1 << 12) |    /* write state */
1255                          nr);          /* vlan id */
1256                 robo->ops->write_reg(robo, PAGE_VLAN, REG_VLAN_ACCESS, &val16,
1257                                      sizeof(val16));
1258         } else {
1259                 uint8 vtble, vtbli, vtbla;
1260                 val32 = ((c->untag << 9) |              /* untag enable */
1261                          c->port);                      /* vlan members */
1262
1263                 if (robo->devid == DEVID5395) {
1264                         vtble = REG_VTBL_ENTRY_5395;
1265                         vtbli = REG_VTBL_INDX_5395;
1266                         vtbla = REG_VTBL_ACCESS_5395;
1267                 } else {
1268                         vtble = REG_VTBL_ENTRY;
1269                         vtbli = REG_VTBL_INDX;
1270                         vtbla = REG_VTBL_ACCESS;
1271                 }
1272
1273                 /* VLAN Table Entry Register (Page 0x05, Address 0x63-0x66/0x83-0x86) */
1274                 robo->ops->write_reg(robo, PAGE_VTBL, vtble, &val32,
1275                                      sizeof(val32));
1276                 /* VLAN Table Address Index Reg (Page 0x05, Address 0x61-0x62/0x81-0x82) */
1277                 val16 = nr;        /* vlan id */
1278                 robo->ops->write_reg(robo, PAGE_VTBL, vtbli, &val16,
1279                                      sizeof(val16));
1280
1281                 /* VLAN Table Access Register (Page 0x34, Address 0x60/0x80) */
1282                 val8 = ((1 << 7) |      /* start command */
1283                         0);             /* write */
1284                 robo->ops->write_reg(robo, PAGE_VTBL, vtbla, &val8,
1285                                      sizeof(val8));
1286         }
1287
1288         ROBO_END(driver);
1289         return 0;
1290 }
1291
1292 static int __init config_attach(robo_info_t *robo)
1293 {
1294         switch_config cfg[] = {
1295                 {"enable", handle_enable_read, handle_enable_write},
1296                 {"reset", NULL, handle_reset},
1297                 {"enable_vlan", handle_enable_vlan_read, handle_enable_vlan_write},
1298                 {NULL, NULL, NULL}
1299         };
1300         switch_config vlan[] = {
1301                 {"ports", handle_vlan_port_read, handle_vlan_port_write},
1302                 {NULL, NULL, NULL}
1303         };
1304         switch_driver driver = {
1305                 name: DRIVER_NAME,
1306                 version: DRIVER_VERSION,
1307                 interface: robo->name,
1308                 cpuport: 8,
1309                 ports: 9,
1310                 vlans: 16,
1311                 driver_handlers: cfg,
1312                 port_handlers: NULL,
1313                 vlan_handlers: vlan,
1314         };
1315         if (robo->devid == DEVID5325) {
1316                 driver.ports = 6;
1317                 driver.cpuport = 5;
1318         }
1319         driver.priv = (void *) robo;
1320
1321         return switch_register_driver(&driver);
1322 }
1323
1324 static void __exit config_detach(robo_info_t *robo)
1325 {
1326         switch_unregister_driver(DRIVER_NAME);
1327 }
1328
1329