target/linux/generic/files/drivers/net/phy/rtl8306.c

   1 /*
   2  * rtl8306.c: RTL8306S switch driver
   3  *
   4  * Copyright (C) 2009 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  * version 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <linux/if.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/list.h>
  20 #include <linux/if_ether.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/netlink.h>
  24 #include <net/genetlink.h>
  25 #include <linux/switch.h>
  26 #include <linux/delay.h>
  27 #include <linux/phy.h>
  28
  29 //#define DEBUG 1
  30
  31 /* Global (PHY0) */
  32 #define RTL8306_REG_PAGE                16
  33 #define RTL8306_REG_PAGE_LO             (1 << 15)
  34 #define RTL8306_REG_PAGE_HI             (1 << 1) /* inverted */
  35
  36 #define RTL8306_NUM_VLANS               16
  37 #define RTL8306_NUM_PORTS               6
  38 #define RTL8306_PORT_CPU                5
  39 #define RTL8306_NUM_PAGES               4
  40 #define RTL8306_NUM_REGS                32
  41
  42 #define RTL_NAME_S          "RTL8306S"
  43 #define RTL_NAME_SD         "RTL8306SD"
  44 #define RTL_NAME_SDM        "RTL8306SDM"
  45 #define RTL_NAME_UNKNOWN    "RTL8306(unknown)"
  46
  47 #define RTL8306_MAGIC   0x8306
  48
  49 static LIST_HEAD(phydevs);
  50
  51 struct rtl_priv {
  52         struct list_head list;
  53         struct switch_dev dev;
  54         int page;
  55         int type;
  56         int do_cpu;
  57         struct mii_bus *bus;
  58         char hwname[sizeof(RTL_NAME_UNKNOWN)];
  59 };
  60
  61 struct rtl_phyregs {
  62         int nway;
  63         int speed;
  64         int duplex;
  65 };
  66
  67 #define to_rtl(_dev) container_of(_dev, struct rtl_priv, dev)
  68
  69 enum {
  70         RTL_TYPE_S,
  71         RTL_TYPE_SD,
  72         RTL_TYPE_SDM,
  73 };
  74
  75 struct rtl_reg {
  76         int page;
  77         int phy;
  78         int reg;
  79         int bits;
  80         int shift;
  81         int inverted;
  82 };
  83
  84 #define RTL_VLAN_REGOFS(name) \
  85         (RTL_REG_VLAN1_##name - RTL_REG_VLAN0_##name)
  86
  87 #define RTL_PORT_REGOFS(name) \
  88         (RTL_REG_PORT1_##name - RTL_REG_PORT0_##name)
  89
  90 #define RTL_PORT_REG(id, reg) \
  91         (RTL_REG_PORT0_##reg + (id * RTL_PORT_REGOFS(reg)))
  92
  93 #define RTL_VLAN_REG(id, reg) \
  94         (RTL_REG_VLAN0_##reg + (id * RTL_VLAN_REGOFS(reg)))
  95
  96 #define RTL_GLOBAL_REGATTR(reg) \
  97         .id = RTL_REG_##reg, \
  98         .type = SWITCH_TYPE_INT, \
  99         .ofs = 0, \
 100         .set = rtl_attr_set_int, \
 101         .get = rtl_attr_get_int
 102
 103 #define RTL_PORT_REGATTR(reg) \
 104         .id = RTL_REG_PORT0_##reg, \
 105         .type = SWITCH_TYPE_INT, \
 106         .ofs = RTL_PORT_REGOFS(reg), \
 107         .set = rtl_attr_set_port_int, \
 108         .get = rtl_attr_get_port_int
 109
 110 #define RTL_VLAN_REGATTR(reg) \
 111         .id = RTL_REG_VLAN0_##reg, \
 112         .type = SWITCH_TYPE_INT, \
 113         .ofs = RTL_VLAN_REGOFS(reg), \
 114         .set = rtl_attr_set_vlan_int, \
 115         .get = rtl_attr_get_vlan_int
 116
 117 enum rtl_regidx {
 118         RTL_REG_CHIPID,
 119         RTL_REG_CHIPVER,
 120         RTL_REG_CHIPTYPE,
 121         RTL_REG_CPUPORT,
 122
 123         RTL_REG_EN_CPUPORT,
 124         RTL_REG_EN_TAG_OUT,
 125         RTL_REG_EN_TAG_CLR,
 126         RTL_REG_EN_TAG_IN,
 127         RTL_REG_TRAP_CPU,
 128         RTL_REG_TRUNK_PORTSEL,
 129         RTL_REG_EN_TRUNK,
 130         RTL_REG_RESET,
 131
 132         RTL_REG_VLAN_ENABLE,
 133         RTL_REG_VLAN_FILTER,
 134         RTL_REG_VLAN_TAG_ONLY,
 135         RTL_REG_VLAN_TAG_AWARE,
 136 #define RTL_VLAN_ENUM(id) \
 137         RTL_REG_VLAN##id##_VID, \
 138         RTL_REG_VLAN##id##_PORTMASK
 139         RTL_VLAN_ENUM(0),
 140         RTL_VLAN_ENUM(1),
 141         RTL_VLAN_ENUM(2),
 142         RTL_VLAN_ENUM(3),
 143         RTL_VLAN_ENUM(4),
 144         RTL_VLAN_ENUM(5),
 145         RTL_VLAN_ENUM(6),
 146         RTL_VLAN_ENUM(7),
 147         RTL_VLAN_ENUM(8),
 148         RTL_VLAN_ENUM(9),
 149         RTL_VLAN_ENUM(10),
 150         RTL_VLAN_ENUM(11),
 151         RTL_VLAN_ENUM(12),
 152         RTL_VLAN_ENUM(13),
 153         RTL_VLAN_ENUM(14),
 154         RTL_VLAN_ENUM(15),
 155 #define RTL_PORT_ENUM(id) \
 156         RTL_REG_PORT##id##_PVID, \
 157         RTL_REG_PORT##id##_NULL_VID_REPLACE, \
 158         RTL_REG_PORT##id##_NON_PVID_DISCARD, \
 159         RTL_REG_PORT##id##_VID_INSERT, \
 160         RTL_REG_PORT##id##_TAG_INSERT, \
 161         RTL_REG_PORT##id##_LINK, \
 162         RTL_REG_PORT##id##_SPEED, \
 163         RTL_REG_PORT##id##_NWAY, \
 164         RTL_REG_PORT##id##_NRESTART, \
 165         RTL_REG_PORT##id##_DUPLEX, \
 166         RTL_REG_PORT##id##_RXEN, \
 167         RTL_REG_PORT##id##_TXEN
 168         RTL_PORT_ENUM(0),
 169         RTL_PORT_ENUM(1),
 170         RTL_PORT_ENUM(2),
 171         RTL_PORT_ENUM(3),
 172         RTL_PORT_ENUM(4),
 173         RTL_PORT_ENUM(5),
 174 };
 175
 176 static const struct rtl_reg rtl_regs[] = {
 177         [RTL_REG_CHIPID]         = { 0, 4, 30, 16,  0, 0 },
 178         [RTL_REG_CHIPVER]        = { 0, 4, 31,  8,  0, 0 },
 179         [RTL_REG_CHIPTYPE]       = { 0, 4, 31,  2,  8, 0 },
 180
 181         /* CPU port number */
 182         [RTL_REG_CPUPORT]        = { 2, 4, 21,  3,  0, 0 },
 183         /* Enable CPU port function */
 184         [RTL_REG_EN_CPUPORT]     = { 3, 2, 21,  1, 15, 1 },
 185         /* Enable CPU port tag insertion */
 186         [RTL_REG_EN_TAG_OUT]     = { 3, 2, 21,  1, 12, 0 },
 187         /* Enable CPU port tag removal */
 188         [RTL_REG_EN_TAG_CLR]     = { 3, 2, 21,  1, 11, 0 },
 189         /* Enable CPU port tag checking */
 190         [RTL_REG_EN_TAG_IN]      = { 0, 4, 21,  1,  7, 0 },
 191         [RTL_REG_EN_TRUNK]       = { 0, 0, 19,  1, 11, 1 },
 192         [RTL_REG_TRUNK_PORTSEL]  = { 0, 0, 16,  1,  6, 1 },
 193         [RTL_REG_RESET]          = { 0, 0, 16,  1, 12, 0 },
 194
 195         [RTL_REG_TRAP_CPU]       = { 3, 2, 22,  1,  6, 0 },
 196
 197         [RTL_REG_VLAN_TAG_ONLY]  = { 0, 0, 16,  1,  8, 1 },
 198         [RTL_REG_VLAN_FILTER]    = { 0, 0, 16,  1,  9, 1 },
 199         [RTL_REG_VLAN_TAG_AWARE] = { 0, 0, 16,  1, 10, 1 },
 200         [RTL_REG_VLAN_ENABLE]    = { 0, 0, 18,  1,  8, 1 },
 201
 202 #define RTL_VLAN_REGS(id, phy, page, regofs) \
 203         [RTL_REG_VLAN##id##_VID] = { page, phy, 25 + regofs, 12, 0, 0 }, \
 204         [RTL_REG_VLAN##id##_PORTMASK] = { page, phy, 24 + regofs, 6, 0, 0 }
 205         RTL_VLAN_REGS( 0, 0, 0, 0),
 206         RTL_VLAN_REGS( 1, 1, 0, 0),
 207         RTL_VLAN_REGS( 2, 2, 0, 0),
 208         RTL_VLAN_REGS( 3, 3, 0, 0),
 209         RTL_VLAN_REGS( 4, 4, 0, 0),
 210         RTL_VLAN_REGS( 5, 0, 1, 2),
 211         RTL_VLAN_REGS( 6, 1, 1, 2),
 212         RTL_VLAN_REGS( 7, 2, 1, 2),
 213         RTL_VLAN_REGS( 8, 3, 1, 2),
 214         RTL_VLAN_REGS( 9, 4, 1, 2),
 215         RTL_VLAN_REGS(10, 0, 1, 4),
 216         RTL_VLAN_REGS(11, 1, 1, 4),
 217         RTL_VLAN_REGS(12, 2, 1, 4),
 218         RTL_VLAN_REGS(13, 3, 1, 4),
 219         RTL_VLAN_REGS(14, 4, 1, 4),
 220         RTL_VLAN_REGS(15, 0, 1, 6),
 221
 222 #define REG_PORT_SETTING(port, phy) \
 223         [RTL_REG_PORT##port##_SPEED] = { 0, phy, 0, 1, 13, 0 }, \
 224         [RTL_REG_PORT##port##_NWAY] = { 0, phy, 0, 1, 12, 0 }, \
 225         [RTL_REG_PORT##port##_NRESTART] = { 0, phy, 0, 1, 9, 0 }, \
 226         [RTL_REG_PORT##port##_DUPLEX] = { 0, phy, 0, 1, 8, 0 }, \
 227         [RTL_REG_PORT##port##_TXEN] = { 0, phy, 24, 1, 11, 0 }, \
 228         [RTL_REG_PORT##port##_RXEN] = { 0, phy, 24, 1, 10, 0 }, \
 229         [RTL_REG_PORT##port##_LINK] = { 0, phy, 1, 1, 2, 0 }, \
 230         [RTL_REG_PORT##port##_NULL_VID_REPLACE] = { 0, phy, 22, 1, 12, 0 }, \
 231         [RTL_REG_PORT##port##_NON_PVID_DISCARD] = { 0, phy, 22, 1, 11, 0 }, \
 232         [RTL_REG_PORT##port##_VID_INSERT] = { 0, phy, 22, 2, 9, 0 }, \
 233         [RTL_REG_PORT##port##_TAG_INSERT] = { 0, phy, 22, 2, 0, 0 }
 234
 235         REG_PORT_SETTING(0, 0),
 236         REG_PORT_SETTING(1, 1),
 237         REG_PORT_SETTING(2, 2),
 238         REG_PORT_SETTING(3, 3),
 239         REG_PORT_SETTING(4, 4),
 240         REG_PORT_SETTING(5, 6),
 241
 242 #define REG_PORT_PVID(phy, page, regofs) \
 243         { page, phy, 24 + regofs, 4, 12, 0 }
 244         [RTL_REG_PORT0_PVID] = REG_PORT_PVID(0, 0, 0),
 245         [RTL_REG_PORT1_PVID] = REG_PORT_PVID(1, 0, 0),
 246         [RTL_REG_PORT2_PVID] = REG_PORT_PVID(2, 0, 0),
 247         [RTL_REG_PORT3_PVID] = REG_PORT_PVID(3, 0, 0),
 248         [RTL_REG_PORT4_PVID] = REG_PORT_PVID(4, 0, 0),
 249         [RTL_REG_PORT5_PVID] = REG_PORT_PVID(0, 1, 2),
 250 };
 251
 252
 253 /* IFXMIPS compat stuff - remove after PHY layer migration */
 254 static struct switch_dev rtldev;
 255 /* END IFXMIPS compat stuff */
 256
 257
 258 static inline void
 259 rtl_set_page(struct rtl_priv *priv, unsigned int page)
 260 {
 261         struct mii_bus *bus = priv->bus;
 262         u16 pgsel;
 263
 264         if (priv->page == page)
 265                 return;
 266
 267         BUG_ON(page > RTL8306_NUM_PAGES);
 268         pgsel = bus->read(bus, 0, RTL8306_REG_PAGE);
 269         pgsel &= ~(RTL8306_REG_PAGE_LO | RTL8306_REG_PAGE_HI);
 270         if (page & (1 << 0))
 271                 pgsel |= RTL8306_REG_PAGE_LO;
 272         if (!(page & (1 << 1))) /* bit is inverted */
 273                 pgsel |= RTL8306_REG_PAGE_HI;
 274         bus->write(bus, 0, RTL8306_REG_PAGE, pgsel);
 275 }
 276
 277 static inline int
 278 rtl_w16(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg, u16 val)
 279 {
 280         struct rtl_priv *priv = to_rtl(dev);
 281         struct mii_bus *bus = priv->bus;
 282
 283         rtl_set_page(priv, page);
 284         bus->write(bus, phy, reg, val);
 285         bus->read(bus, phy, reg); /* flush */
 286         return 0;
 287 }
 288
 289 static inline int
 290 rtl_r16(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg)
 291 {
 292         struct rtl_priv *priv = to_rtl(dev);
 293         struct mii_bus *bus = priv->bus;
 294
 295         rtl_set_page(priv, page);
 296         return bus->read(bus, phy, reg);
 297 }
 298
 299 static inline u16
 300 rtl_rmw(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg, u16 mask, u16 val)
 301 {
 302         struct rtl_priv *priv = to_rtl(dev);
 303         struct mii_bus *bus = priv->bus;
 304         u16 r;
 305
 306         rtl_set_page(priv, page);
 307         r = bus->read(bus, phy, reg);
 308         r &= ~mask;
 309         r |= val;
 310         bus->write(bus, phy, reg, r);
 311         return bus->read(bus, phy, reg); /* flush */
 312 }
 313
 314
 315 static inline int
 316 rtl_get(struct switch_dev *dev, enum rtl_regidx s)
 317 {
 318         const struct rtl_reg *r = &rtl_regs[s];
 319         u16 val;
 320
 321         BUG_ON(s >= ARRAY_SIZE(rtl_regs));
 322         if (r->bits == 0) /* unimplemented */
 323                 return 0;
 324
 325         val = rtl_r16(dev, r->page, r->phy, r->reg);
 326
 327         if (r->shift > 0)
 328                 val >>= r->shift;
 329
 330         if (r->inverted)
 331                 val = ~val;
 332
 333         val &= (1 << r->bits) - 1;
 334
 335         return val;
 336 }
 337
 338 static int
 339 rtl_set(struct switch_dev *dev, enum rtl_regidx s, unsigned int val)
 340 {
 341         const struct rtl_reg *r = &rtl_regs[s];
 342         u16 mask = 0xffff;
 343
 344         BUG_ON(s >= ARRAY_SIZE(rtl_regs));
 345
 346         if (r->bits == 0) /* unimplemented */
 347                 return 0;
 348
 349         if (r->shift > 0)
 350                 val <<= r->shift;
 351
 352         if (r->inverted)
 353                 val = ~val;
 354
 355         if (r->bits != 16) {
 356                 mask = (1 << r->bits) - 1;
 357                 mask <<= r->shift;
 358         }
 359         val &= mask;
 360         return rtl_rmw(dev, r->page, r->phy, r->reg, mask, val);
 361 }
 362
 363 static void
 364 rtl_phy_save(struct switch_dev *dev, int port, struct rtl_phyregs *regs)
 365 {
 366         regs->nway = rtl_get(dev, RTL_PORT_REG(port, NWAY));
 367         regs->speed = rtl_get(dev, RTL_PORT_REG(port, SPEED));
 368         regs->duplex = rtl_get(dev, RTL_PORT_REG(port, DUPLEX));
 369 }
 370
 371 static void
 372 rtl_phy_restore(struct switch_dev *dev, int port, struct rtl_phyregs *regs)
 373 {
 374         rtl_set(dev, RTL_PORT_REG(port, NWAY), regs->nway);
 375         rtl_set(dev, RTL_PORT_REG(port, SPEED), regs->speed);
 376         rtl_set(dev, RTL_PORT_REG(port, DUPLEX), regs->duplex);
 377 }
 378
 379 static void
 380 rtl_port_set_enable(struct switch_dev *dev, int port, int enabled)
 381 {
 382         rtl_set(dev, RTL_PORT_REG(port, RXEN), enabled);
 383         rtl_set(dev, RTL_PORT_REG(port, TXEN), enabled);
 384
 385         if ((port >= 5) || !enabled)
 386                 return;
 387
 388         /* restart autonegotiation if enabled */
 389         rtl_set(dev, RTL_PORT_REG(port, NRESTART), 1);
 390 }
 391
 392 static int
 393 rtl_hw_apply(struct switch_dev *dev)
 394 {
 395         int i;
 396         int trunk_en, trunk_psel;
 397         struct rtl_phyregs port5;
 398
 399         rtl_phy_save(dev, 5, &port5);
 400
 401         /* disable rx/tx from PHYs */
 402         for (i = 0; i < RTL8306_NUM_PORTS - 1; i++) {
 403                 rtl_port_set_enable(dev, i, 0);
 404         }
 405
 406         /* save trunking status */
 407         trunk_en = rtl_get(dev, RTL_REG_EN_TRUNK);
 408         trunk_psel = rtl_get(dev, RTL_REG_TRUNK_PORTSEL);
 409
 410         /* trunk port 3 and 4
 411          * XXX: Big WTF, but RealTek seems to do it */
 412         rtl_set(dev, RTL_REG_EN_TRUNK, 1);
 413         rtl_set(dev, RTL_REG_TRUNK_PORTSEL, 1);
 414
 415         /* execute the software reset */
 416         rtl_set(dev, RTL_REG_RESET, 1);
 417
 418         /* wait for the reset to complete,
 419          * but don't wait for too long */
 420         for (i = 0; i < 10; i++) {
 421                 if (rtl_get(dev, RTL_REG_RESET) == 0)
 422                         break;
 423
 424                 msleep(1);
 425         }
 426
 427         /* enable rx/tx from PHYs */
 428         for (i = 0; i < RTL8306_NUM_PORTS - 1; i++) {
 429                 rtl_port_set_enable(dev, i, 1);
 430         }
 431
 432         /* restore trunking settings */
 433         rtl_set(dev, RTL_REG_EN_TRUNK, trunk_en);
 434         rtl_set(dev, RTL_REG_TRUNK_PORTSEL, trunk_psel);
 435         rtl_phy_restore(dev, 5, &port5);
 436
 437         return 0;
 438 }
 439
 440 static void
 441 rtl_hw_init(struct switch_dev *dev)
 442 {
 443         struct rtl_priv *priv = to_rtl(dev);
 444         int cpu_mask = 1 << dev->cpu_port;
 445         int i;
 446
 447         rtl_set(dev, RTL_REG_VLAN_ENABLE, 0);
 448         rtl_set(dev, RTL_REG_VLAN_FILTER, 0);
 449         rtl_set(dev, RTL_REG_EN_TRUNK, 0);
 450         rtl_set(dev, RTL_REG_TRUNK_PORTSEL, 0);
 451
 452         /* initialize cpu port settings */
 453         if (priv->do_cpu) {
 454                 rtl_set(dev, RTL_REG_CPUPORT, dev->cpu_port);
 455                 rtl_set(dev, RTL_REG_EN_CPUPORT, 1);
 456         } else {
 457                 rtl_set(dev, RTL_REG_CPUPORT, 7);
 458                 rtl_set(dev, RTL_REG_EN_CPUPORT, 0);
 459         }
 460         rtl_set(dev, RTL_REG_EN_TAG_OUT, 0);
 461         rtl_set(dev, RTL_REG_EN_TAG_IN, 0);
 462         rtl_set(dev, RTL_REG_EN_TAG_CLR, 0);
 463
 464         /* reset all vlans */
 465         for (i = 0; i < RTL8306_NUM_VLANS; i++) {
 466                 rtl_set(dev, RTL_VLAN_REG(i, VID), i);
 467                 rtl_set(dev, RTL_VLAN_REG(i, PORTMASK), 0);
 468         }
 469
 470         /* default to port isolation */
 471         for (i = 0; i < RTL8306_NUM_PORTS; i++) {
 472                 unsigned long mask;
 473
 474                 if ((1 << i) == cpu_mask)
 475                         mask = ((1 << RTL8306_NUM_PORTS) - 1) & ~cpu_mask; /* all bits set */
 476                 else
 477                         mask = cpu_mask | (1 << i);
 478
 479                 rtl_set(dev, RTL_VLAN_REG(i, PORTMASK), mask);
 480                 rtl_set(dev, RTL_PORT_REG(i, PVID), i);
 481                 rtl_set(dev, RTL_PORT_REG(i, NULL_VID_REPLACE), 1);
 482                 rtl_set(dev, RTL_PORT_REG(i, VID_INSERT), 1);
 483                 rtl_set(dev, RTL_PORT_REG(i, TAG_INSERT), 3);
 484         }
 485         rtl_hw_apply(dev);
 486 }
 487
 488 #ifdef DEBUG
 489 static int
 490 rtl_set_use_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 491 {
 492         struct rtl_priv *priv = to_rtl(dev);
 493         priv->do_cpu = val->value.i;
 494         rtl_hw_init(dev);
 495         return 0;
 496 }
 497
 498 static int
 499 rtl_get_use_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 500 {
 501         struct rtl_priv *priv = to_rtl(dev);
 502         val->value.i = priv->do_cpu;
 503         return 0;
 504 }
 505
 506 static int
 507 rtl_set_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 508 {
 509         dev->cpu_port = val->value.i;
 510         rtl_hw_init(dev);
 511         return 0;
 512 }
 513
 514 static int
 515 rtl_get_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 516 {
 517         val->value.i = dev->cpu_port;
 518         return 0;
 519 }
 520 #endif
 521
 522 static int
 523 rtl_reset(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 524 {
 525         rtl_hw_init(dev);
 526         return 0;
 527 }
 528
 529 static int
 530 rtl_attr_set_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 531 {
 532         int idx = attr->id + (val->port_vlan * attr->ofs);
 533         struct rtl_phyregs port;
 534
 535         if (attr->id >= ARRAY_SIZE(rtl_regs))
 536                 return -EINVAL;
 537
 538         if ((attr->max > 0) && (val->value.i > attr->max))
 539                 return -EINVAL;
 540
 541         /* access to phy register 22 on port 4/5
 542          * needs phy status save/restore */
 543         if ((val->port_vlan > 3) &&
 544                 (rtl_regs[idx].reg == 22) &&
 545                 (rtl_regs[idx].page == 0)) {
 546
 547                 rtl_phy_save(dev, val->port_vlan, &port);
 548                 rtl_set(dev, idx, val->value.i);
 549                 rtl_phy_restore(dev, val->port_vlan, &port);
 550         } else {
 551                 rtl_set(dev, idx, val->value.i);
 552         }
 553
 554         return 0;
 555 }
 556
 557 static int
 558 rtl_attr_get_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 559 {
 560         int idx = attr->id + (val->port_vlan * attr->ofs);
 561
 562         if (idx >= ARRAY_SIZE(rtl_regs))
 563                 return -EINVAL;
 564
 565         val->value.i = rtl_get(dev, idx);
 566         return 0;
 567 }
 568
 569 static int
 570 rtl_attr_set_port_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 571 {
 572         if (val->port_vlan >= RTL8306_NUM_PORTS)
 573                 return -EINVAL;
 574
 575         return rtl_attr_set_int(dev, attr, val);
 576 }
 577
 578 static int
 579 rtl_attr_get_port_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 580 {
 581         if (val->port_vlan >= RTL8306_NUM_PORTS)
 582                 return -EINVAL;
 583         return rtl_attr_get_int(dev, attr, val);
 584 }
 585
 586 static int
 587 rtl_attr_set_vlan_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 588 {
 589         if (val->port_vlan >= dev->vlans)
 590                 return -EINVAL;
 591
 592         return rtl_attr_set_int(dev, attr, val);
 593 }
 594
 595 static int
 596 rtl_attr_get_vlan_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 597 {
 598         if (val->port_vlan >= dev->vlans)
 599                 return -EINVAL;
 600
 601         return rtl_attr_get_int(dev, attr, val);
 602 }
 603
 604 static int
 605 rtl_get_ports(struct switch_dev *dev, struct switch_val *val)
 606 {
 607         unsigned int i, mask;
 608
 609         mask = rtl_get(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK));
 610         for (i = 0; i < RTL8306_NUM_PORTS; i++) {
 611                 struct switch_port *port;
 612
 613                 if (!(mask & (1 << i)))
 614                         continue;
 615
 616                 port = &val->value.ports[val->len];
 617                 port->id = i;
 618                 port->flags = 0;
 619                 val->len++;
 620         }
 621
 622         return 0;
 623 }
 624
 625 static int
 626 rtl_set_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 627 {
 628         struct rtl_priv *priv = to_rtl(dev);
 629         struct rtl_phyregs port;
 630         int en = val->value.i;
 631         int i;
 632
 633         rtl_set(dev, RTL_REG_EN_TAG_OUT, en && priv->do_cpu);
 634         rtl_set(dev, RTL_REG_EN_TAG_IN, en && priv->do_cpu);
 635         rtl_set(dev, RTL_REG_EN_TAG_CLR, en && priv->do_cpu);
 636         rtl_set(dev, RTL_REG_VLAN_TAG_AWARE, en);
 637         if (en)
 638                 rtl_set(dev, RTL_REG_VLAN_FILTER, en);
 639
 640         for (i = 0; i < RTL8306_NUM_PORTS; i++) {
 641                 if (i > 3)
 642                         rtl_phy_save(dev, val->port_vlan, &port);
 643                 rtl_set(dev, RTL_PORT_REG(i, NULL_VID_REPLACE), 1);
 644                 rtl_set(dev, RTL_PORT_REG(i, VID_INSERT), (en ? (i == dev->cpu_port ? 0 : 1) : 1));
 645                 rtl_set(dev, RTL_PORT_REG(i, TAG_INSERT), (en ? (i == dev->cpu_port ? 2 : 1) : 3));
 646                 if (i > 3)
 647                         rtl_phy_restore(dev, val->port_vlan, &port);
 648         }
 649         rtl_set(dev, RTL_REG_VLAN_ENABLE, en);
 650
 651         return 0;
 652 }
 653
 654 static int
 655 rtl_get_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
 656 {
 657         return rtl_get(dev, RTL_REG_VLAN_ENABLE);
 658 }
 659
 660 static int
 661 rtl_set_ports(struct switch_dev *dev, struct switch_val *val)
 662 {
 663         unsigned int mask = 0;
 664         unsigned int oldmask;
 665         int i;
 666
 667         for(i = 0; i < val->len; i++)
 668         {
 669                 struct switch_port *port = &val->value.ports[i];
 670                 bool tagged = false;
 671
 672                 mask |= (1 << port->id);
 673
 674                 if (port->id == dev->cpu_port)
 675                         continue;
 676
 677                 if ((i == dev->cpu_port) ||
 678                         (port->flags & (1 << SWITCH_PORT_FLAG_TAGGED)))
 679                         tagged = true;
 680
 681                 /* fix up PVIDs for added ports */
 682                 if (!tagged)
 683                         rtl_set(dev, RTL_PORT_REG(port->id, PVID), val->port_vlan);
 684
 685                 rtl_set(dev, RTL_PORT_REG(port->id, NON_PVID_DISCARD), (tagged ? 0 : 1));
 686                 rtl_set(dev, RTL_PORT_REG(port->id, VID_INSERT), (tagged ? 0 : 1));
 687                 rtl_set(dev, RTL_PORT_REG(port->id, TAG_INSERT), (tagged ? 2 : 1));
 688         }
 689
 690         oldmask = rtl_get(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK));
 691         rtl_set(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK), mask);
 692
 693         /* fix up PVIDs for removed ports, default to last vlan */
 694         oldmask &= ~mask;
 695         for (i = 0; i < RTL8306_NUM_PORTS; i++) {
 696                 if (!(oldmask & (1 << i)))
 697                         continue;
 698
 699                 if (i == dev->cpu_port)
 700                         continue;
 701
 702                 if (rtl_get(dev, RTL_PORT_REG(i, PVID)) == val->port_vlan)
 703                         rtl_set(dev, RTL_PORT_REG(i, PVID), dev->vlans - 1);
 704         }
 705
 706         return 0;
 707 }
 708
 709 static int
 710 rtl8306_config_init(struct phy_device *pdev)
 711 {
 712         struct net_device *netdev = pdev->attached_dev;
 713         struct rtl_priv *priv = pdev->priv;
 714         struct switch_dev *dev = &priv->dev;
 715         struct switch_val val;
 716         unsigned int chipid, chipver, chiptype;
 717         int err;
 718
 719         /* Only init the switch for the primary PHY */
 720         if (pdev->addr != 0)
 721                 return 0;
 722
 723         val.value.i = 1;
 724         memcpy(&priv->dev, &rtldev, sizeof(struct switch_dev));
 725         priv->do_cpu = 0;
 726         priv->page = -1;
 727         priv->bus = pdev->bus;
 728
 729         dev->priv = priv;
 730
 731         chipid = rtl_get(dev, RTL_REG_CHIPID);
 732         chipver = rtl_get(dev, RTL_REG_CHIPVER);
 733         chiptype = rtl_get(dev, RTL_REG_CHIPTYPE);
 734         switch(chiptype) {
 735         case 0:
 736         case 2:
 737                 strncpy(priv->hwname, RTL_NAME_S, sizeof(priv->hwname));
 738                 priv->type = RTL_TYPE_S;
 739                 break;
 740         case 1:
 741                 strncpy(priv->hwname, RTL_NAME_SD, sizeof(priv->hwname));
 742                 priv->type = RTL_TYPE_SD;
 743                 break;
 744         case 3:
 745                 strncpy(priv->hwname, RTL_NAME_SDM, sizeof(priv->hwname));
 746                 priv->type = RTL_TYPE_SDM;
 747                 break;
 748         default:
 749                 strncpy(priv->hwname, RTL_NAME_UNKNOWN, sizeof(priv->hwname));
 750                 break;
 751         }
 752
 753         dev->name = priv->hwname;
 754         rtl_hw_init(dev);
 755
 756         printk(KERN_INFO "Registering %s switch with Chip ID: 0x%04x, version: 0x%04x\n", priv->hwname, chipid, chipver);
 757
 758         err = register_switch(dev, netdev);
 759         if (err < 0) {
 760                 kfree(priv);
 761                 return err;
 762         }
 763
 764         return 0;
 765 }
 766
 767 static struct switch_attr rtl_globals[] = {
 768         {
 769                 .type = SWITCH_TYPE_INT,
 770                 .name = "reset",
 771                 .description = "Reset the switch",
 772                 .set = rtl_reset,
 773         },
 774         {
 775                 .type = SWITCH_TYPE_INT,
 776                 .name = "enable_vlan",
 777                 .description = "Enable VLAN mode",
 778                 .max = 1,
 779                 .set = rtl_set_vlan,
 780                 .get = rtl_get_vlan,
 781         },
 782         {
 783                 RTL_GLOBAL_REGATTR(EN_TRUNK),
 784                 .name = "trunk",
 785                 .description = "Enable port trunking",
 786                 .max = 1,
 787         },
 788         {
 789                 RTL_GLOBAL_REGATTR(TRUNK_PORTSEL),
 790                 .name = "trunk_sel",
 791                 .description = "Select ports for trunking (0: 0,1 - 1: 3,4)",
 792                 .max = 1,
 793         },
 794 #ifdef DEBUG
 795         {
 796                 RTL_GLOBAL_REGATTR(VLAN_FILTER),
 797                 .name = "vlan_filter",
 798                 .description = "Filter incoming packets for allowed VLANS",
 799                 .max = 1,
 800         },
 801         {
 802                 .type = SWITCH_TYPE_INT,
 803                 .name = "cpuport",
 804                 .description = "CPU Port",
 805                 .set = rtl_set_cpuport,
 806                 .get = rtl_get_cpuport,
 807                 .max = RTL8306_NUM_PORTS,
 808         },
 809         {
 810                 .type = SWITCH_TYPE_INT,
 811                 .name = "use_cpuport",
 812                 .description = "CPU Port handling flag",
 813                 .set = rtl_set_use_cpuport,
 814                 .get = rtl_get_use_cpuport,
 815                 .max = RTL8306_NUM_PORTS,
 816         },
 817         {
 818                 RTL_GLOBAL_REGATTR(TRAP_CPU),
 819                 .name = "trap_cpu",
 820                 .description = "VLAN trap to CPU",
 821                 .max = 1,
 822         },
 823         {
 824                 RTL_GLOBAL_REGATTR(VLAN_TAG_AWARE),
 825                 .name = "vlan_tag_aware",
 826                 .description = "Enable VLAN tag awareness",
 827                 .max = 1,
 828         },
 829         {
 830                 RTL_GLOBAL_REGATTR(VLAN_TAG_ONLY),
 831                 .name = "tag_only",
 832                 .description = "Only accept tagged packets",
 833                 .max = 1,
 834         },
 835 #endif
 836 };
 837 static struct switch_attr rtl_port[] = {
 838         {
 839                 RTL_PORT_REGATTR(PVID),
 840                 .name = "pvid",
 841                 .description = "Port VLAN ID",
 842                 .max = RTL8306_NUM_VLANS - 1,
 843         },
 844         {
 845                 RTL_PORT_REGATTR(LINK),
 846                 .name = "link",
 847                 .description = "get the current link state",
 848                 .max = 1,
 849                 .set = NULL,
 850         },
 851 #ifdef DEBUG
 852         {
 853                 RTL_PORT_REGATTR(NULL_VID_REPLACE),
 854                 .name = "null_vid",
 855                 .description = "NULL VID gets replaced by port default vid",
 856                 .max = 1,
 857         },
 858         {
 859                 RTL_PORT_REGATTR(NON_PVID_DISCARD),
 860                 .name = "non_pvid_discard",
 861                 .description = "discard packets with VID != PVID",
 862                 .max = 1,
 863         },
 864         {
 865                 RTL_PORT_REGATTR(VID_INSERT),
 866                 .name = "vid_insert_remove",
 867                 .description = "how should the switch insert and remove vids ?",
 868                 .max = 3,
 869         },
 870         {
 871                 RTL_PORT_REGATTR(TAG_INSERT),
 872                 .name = "tag_insert",
 873                 .description = "tag insertion handling",
 874                 .max = 3,
 875         },
 876 #endif
 877         {
 878                 RTL_PORT_REGATTR(SPEED),
 879                 .name = "speed",
 880                 .description = "current link speed",
 881                 .max = 1,
 882         },
 883         {
 884                 RTL_PORT_REGATTR(NWAY),
 885                 .name = "nway",
 886                 .description = "enable autonegotiation",
 887                 .max = 1,
 888         },
 889 };
 890
 891 static struct switch_attr rtl_vlan[] = {
 892         {
 893                 RTL_VLAN_REGATTR(VID),
 894                 .name = "vid",
 895                 .description = "VLAN ID",
 896                 .max = 4095,
 897         },
 898 };
 899
 900 /* template */
 901 static struct switch_dev rtldev = {
 902         .cpu_port = RTL8306_PORT_CPU,
 903         .ports = RTL8306_NUM_PORTS,
 904         .vlans = RTL8306_NUM_VLANS,
 905         .attr_global = {
 906                 .attr = rtl_globals,
 907                 .n_attr = ARRAY_SIZE(rtl_globals),
 908         },
 909         .attr_port = {
 910                 .attr = rtl_port,
 911                 .n_attr = ARRAY_SIZE(rtl_port),
 912         },
 913         .attr_vlan = {
 914                 .attr = rtl_vlan,
 915                 .n_attr = ARRAY_SIZE(rtl_vlan),
 916         },
 917
 918         .get_vlan_ports = rtl_get_ports,
 919         .set_vlan_ports = rtl_set_ports,
 920         .apply_config = rtl_hw_apply,
 921 };
 922
 923
 924 static int
 925 rtl8306_fixup(struct phy_device *pdev)
 926 {
 927         struct rtl_priv priv;
 928         u16 chipid;
 929
 930         /* Attach to primary LAN port and WAN port */
 931         if (pdev->addr != 0 && pdev->addr != 4)
 932                 return 0;
 933
 934         priv.page = -1;
 935         priv.bus = pdev->bus;
 936         chipid = rtl_get(&priv.dev, RTL_REG_CHIPID);
 937         if (chipid == 0x5988)
 938                 pdev->phy_id = RTL8306_MAGIC;
 939
 940         return 0;
 941 }
 942
 943 static int
 944 rtl8306_probe(struct phy_device *pdev)
 945 {
 946         struct rtl_priv *priv;
 947
 948         list_for_each_entry(priv, &phydevs, list) {
 949                 /*
 950                  * share one rtl_priv instance between virtual phy
 951                  * devices on the same bus
 952                  */
 953                 if (priv->bus == pdev->bus)
 954                         goto found;
 955         }
 956         priv = kzalloc(sizeof(struct rtl_priv), GFP_KERNEL);
 957         if (!priv)
 958                 return -ENOMEM;
 959
 960         priv->bus = pdev->bus;
 961
 962 found:
 963         pdev->priv = priv;
 964         return 0;
 965 }
 966
 967 static void
 968 rtl8306_remove(struct phy_device *pdev)
 969 {
 970         struct rtl_priv *priv = pdev->priv;
 971         unregister_switch(&priv->dev);
 972         kfree(priv);
 973 }
 974
 975 static int
 976 rtl8306_config_aneg(struct phy_device *pdev)
 977 {
 978         struct rtl_priv *priv = pdev->priv;
 979
 980         /* Only for WAN */
 981         if (pdev->addr == 0)
 982                 return 0;
 983
 984         /* Restart autonegotiation */
 985         rtl_set(&priv->dev, RTL_PORT_REG(4, NWAY), 1);
 986         rtl_set(&priv->dev, RTL_PORT_REG(4, NRESTART), 1);
 987
 988         return 0;
 989 }
 990
 991 static int
 992 rtl8306_read_status(struct phy_device *pdev)
 993 {
 994         struct rtl_priv *priv = pdev->priv;
 995         struct switch_dev *dev = &priv->dev;
 996
 997         if (pdev->addr == 4) {
 998                 /* WAN */
 999                 pdev->speed = rtl_get(dev, RTL_PORT_REG(4, SPEED)) ? SPEED_100 : SPEED_10;
1000                 pdev->duplex = rtl_get(dev, RTL_PORT_REG(4, DUPLEX)) ? DUPLEX_FULL : DUPLEX_HALF;
1001                 pdev->link = !!rtl_get(dev, RTL_PORT_REG(4, LINK));
1002         } else {
1003                 /* LAN */
1004                 pdev->speed = SPEED_100;
1005                 pdev->duplex = DUPLEX_FULL;
1006                 pdev->link = 1;
1007         }
1008
1009         /*
1010          * Bypass generic PHY status read,
1011          * it doesn't work with this switch
1012          */
1013         if (pdev->link) {
1014                 pdev->state = PHY_RUNNING;
1015                 netif_carrier_on(pdev->attached_dev);
1016                 pdev->adjust_link(pdev->attached_dev);
1017         } else {
1018                 pdev->state = PHY_NOLINK;
1019                 netif_carrier_off(pdev->attached_dev);
1020                 pdev->adjust_link(pdev->attached_dev);
1021         }
1022
1023         return 0;
1024 }
1025
1026
1027 static struct phy_driver rtl8306_driver = {
1028         .name           = "Realtek RTL8306S",
1029         .flags          = PHY_HAS_MAGICANEG,
1030         .phy_id         = RTL8306_MAGIC,
1031         .phy_id_mask    = 0xffffffff,
1032         .features       = PHY_BASIC_FEATURES,
1033         .probe          = &rtl8306_probe,
1034         .remove         = &rtl8306_remove,
1035         .config_init    = &rtl8306_config_init,
1036         .config_aneg    = &rtl8306_config_aneg,
1037         .read_status    = &rtl8306_read_status,
1038         .driver         = { .owner = THIS_MODULE,},
1039 };
1040
1041
1042 static int __init
1043 rtl_init(void)
1044 {
1045         phy_register_fixup_for_id(PHY_ANY_ID, rtl8306_fixup);
1046         return phy_driver_register(&rtl8306_driver);
1047 }
1048
1049 static void __exit
1050 rtl_exit(void)
1051 {
1052         phy_driver_unregister(&rtl8306_driver);
1053 }
1054
1055 module_init(rtl_init);
1056 module_exit(rtl_exit);
1057 MODULE_LICENSE("GPL");
1058