drivers/net/dsa/rtl8366.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Realtek SMI library helpers for the RTL8366x variants
   3  * RTL8366RB and RTL8366S
   4  *
   5  * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
   6  * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
   7  * Copyright (C) 2010 Antti Seppälä <a.seppala@gmail.com>
   8  * Copyright (C) 2010 Roman Yeryomin <roman@advem.lv>
   9  * Copyright (C) 2011 Colin Leitner <colin.leitner@googlemail.com>
  10  */
  11 #include <linux/if_bridge.h>
  12 #include <net/dsa.h>
  13
  14 #include "realtek-smi-core.h"
  15
  16 int rtl8366_mc_is_used(struct realtek_smi *smi, int mc_index, int *used)
  17 {
  18         int ret;
  19         int i;
  20
  21         *used = 0;
  22         for (i = 0; i < smi->num_ports; i++) {
  23                 int index = 0;
  24
  25                 ret = smi->ops->get_mc_index(smi, i, &index);
  26                 if (ret)
  27                         return ret;
  28
  29                 if (mc_index == index) {
  30                         *used = 1;
  31                         break;
  32                 }
  33         }
  34
  35         return 0;
  36 }
  37 EXPORT_SYMBOL_GPL(rtl8366_mc_is_used);
  38
  39 /**
  40  * rtl8366_obtain_mc() - retrieve or allocate a VLAN member configuration
  41  * @smi: the Realtek SMI device instance
  42  * @vid: the VLAN ID to look up or allocate
  43  * @vlanmc: the pointer will be assigned to a pointer to a valid member config
  44  * if successful
  45  * @return: index of a new member config or negative error number
  46  */
  47 static int rtl8366_obtain_mc(struct realtek_smi *smi, int vid,
  48                              struct rtl8366_vlan_mc *vlanmc)
  49 {
  50         struct rtl8366_vlan_4k vlan4k;
  51         int ret;
  52         int i;
  53
  54         /* Try to find an existing member config entry for this VID */
  55         for (i = 0; i < smi->num_vlan_mc; i++) {
  56                 ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
  57                 if (ret) {
  58                         dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
  59                                 i, vid);
  60                         return ret;
  61                 }
  62
  63                 if (vid == vlanmc->vid)
  64                         return i;
  65         }
  66
  67         /* We have no MC entry for this VID, try to find an empty one */
  68         for (i = 0; i < smi->num_vlan_mc; i++) {
  69                 ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
  70                 if (ret) {
  71                         dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
  72                                 i, vid);
  73                         return ret;
  74                 }
  75
  76                 if (vlanmc->vid == 0 && vlanmc->member == 0) {
  77                         /* Update the entry from the 4K table */
  78                         ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
  79                         if (ret) {
  80                                 dev_err(smi->dev, "error looking for 4K VLAN MC %d for VID %d\n",
  81                                         i, vid);
  82                                 return ret;
  83                         }
  84
  85                         vlanmc->vid = vid;
  86                         vlanmc->member = vlan4k.member;
  87                         vlanmc->untag = vlan4k.untag;
  88                         vlanmc->fid = vlan4k.fid;
  89                         ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
  90                         if (ret) {
  91                                 dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
  92                                         i, vid);
  93                                 return ret;
  94                         }
  95
  96                         dev_dbg(smi->dev, "created new MC at index %d for VID %d\n",
  97                                 i, vid);
  98                         return i;
  99                 }
 100         }
 101
 102         /* MC table is full, try to find an unused entry and replace it */
 103         for (i = 0; i < smi->num_vlan_mc; i++) {
 104                 int used;
 105
 106                 ret = rtl8366_mc_is_used(smi, i, &used);
 107                 if (ret)
 108                         return ret;
 109
 110                 if (!used) {
 111                         /* Update the entry from the 4K table */
 112                         ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 113                         if (ret)
 114                                 return ret;
 115
 116                         vlanmc->vid = vid;
 117                         vlanmc->member = vlan4k.member;
 118                         vlanmc->untag = vlan4k.untag;
 119                         vlanmc->fid = vlan4k.fid;
 120                         ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
 121                         if (ret) {
 122                                 dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
 123                                         i, vid);
 124                                 return ret;
 125                         }
 126                         dev_dbg(smi->dev, "recycled MC at index %i for VID %d\n",
 127                                 i, vid);
 128                         return i;
 129                 }
 130         }
 131
 132         dev_err(smi->dev, "all VLAN member configurations are in use\n");
 133         return -ENOSPC;
 134 }
 135
 136 int rtl8366_set_vlan(struct realtek_smi *smi, int vid, u32 member,
 137                      u32 untag, u32 fid)
 138 {
 139         struct rtl8366_vlan_mc vlanmc;
 140         struct rtl8366_vlan_4k vlan4k;
 141         int mc;
 142         int ret;
 143
 144         if (!smi->ops->is_vlan_valid(smi, vid))
 145                 return -EINVAL;
 146
 147         dev_dbg(smi->dev,
 148                 "setting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
 149                 vid, member, untag);
 150
 151         /* Update the 4K table */
 152         ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 153         if (ret)
 154                 return ret;
 155
 156         vlan4k.member |= member;
 157         vlan4k.untag |= untag;
 158         vlan4k.fid = fid;
 159         ret = smi->ops->set_vlan_4k(smi, &vlan4k);
 160         if (ret)
 161                 return ret;
 162
 163         dev_dbg(smi->dev,
 164                 "resulting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
 165                 vid, vlan4k.member, vlan4k.untag);
 166
 167         /* Find or allocate a member config for this VID */
 168         ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
 169         if (ret < 0)
 170                 return ret;
 171         mc = ret;
 172
 173         /* Update the MC entry */
 174         vlanmc.member |= member;
 175         vlanmc.untag |= untag;
 176         vlanmc.fid = fid;
 177
 178         /* Commit updates to the MC entry */
 179         ret = smi->ops->set_vlan_mc(smi, mc, &vlanmc);
 180         if (ret)
 181                 dev_err(smi->dev, "failed to commit changes to VLAN MC index %d for VID %d\n",
 182                         mc, vid);
 183         else
 184                 dev_dbg(smi->dev,
 185                         "resulting VLAN%d MC members: 0x%02x, untagged: 0x%02x\n",
 186                         vid, vlanmc.member, vlanmc.untag);
 187
 188         return ret;
 189 }
 190 EXPORT_SYMBOL_GPL(rtl8366_set_vlan);
 191
 192 int rtl8366_set_pvid(struct realtek_smi *smi, unsigned int port,
 193                      unsigned int vid)
 194 {
 195         struct rtl8366_vlan_mc vlanmc;
 196         int mc;
 197         int ret;
 198
 199         if (!smi->ops->is_vlan_valid(smi, vid))
 200                 return -EINVAL;
 201
 202         /* Find or allocate a member config for this VID */
 203         ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
 204         if (ret < 0)
 205                 return ret;
 206         mc = ret;
 207
 208         ret = smi->ops->set_mc_index(smi, port, mc);
 209         if (ret) {
 210                 dev_err(smi->dev, "set PVID: failed to set MC index %d for port %d\n",
 211                         mc, port);
 212                 return ret;
 213         }
 214
 215         dev_dbg(smi->dev, "set PVID: the PVID for port %d set to %d using existing MC index %d\n",
 216                 port, vid, mc);
 217
 218         return 0;
 219 }
 220 EXPORT_SYMBOL_GPL(rtl8366_set_pvid);
 221
 222 int rtl8366_enable_vlan4k(struct realtek_smi *smi, bool enable)
 223 {
 224         int ret;
 225
 226         /* To enable 4k VLAN, ordinary VLAN must be enabled first,
 227          * but if we disable 4k VLAN it is fine to leave ordinary
 228          * VLAN enabled.
 229          */
 230         if (enable) {
 231                 /* Make sure VLAN is ON */
 232                 ret = smi->ops->enable_vlan(smi, true);
 233                 if (ret)
 234                         return ret;
 235
 236                 smi->vlan_enabled = true;
 237         }
 238
 239         ret = smi->ops->enable_vlan4k(smi, enable);
 240         if (ret)
 241                 return ret;
 242
 243         smi->vlan4k_enabled = enable;
 244         return 0;
 245 }
 246 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan4k);
 247
 248 int rtl8366_enable_vlan(struct realtek_smi *smi, bool enable)
 249 {
 250         int ret;
 251
 252         ret = smi->ops->enable_vlan(smi, enable);
 253         if (ret)
 254                 return ret;
 255
 256         smi->vlan_enabled = enable;
 257
 258         /* If we turn VLAN off, make sure that we turn off
 259          * 4k VLAN as well, if that happened to be on.
 260          */
 261         if (!enable) {
 262                 smi->vlan4k_enabled = false;
 263                 ret = smi->ops->enable_vlan4k(smi, false);
 264         }
 265
 266         return ret;
 267 }
 268 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
 269
 270 int rtl8366_reset_vlan(struct realtek_smi *smi)
 271 {
 272         struct rtl8366_vlan_mc vlanmc;
 273         int ret;
 274         int i;
 275
 276         rtl8366_enable_vlan(smi, false);
 277         rtl8366_enable_vlan4k(smi, false);
 278
 279         /* Clear the 16 VLAN member configurations */
 280         vlanmc.vid = 0;
 281         vlanmc.priority = 0;
 282         vlanmc.member = 0;
 283         vlanmc.untag = 0;
 284         vlanmc.fid = 0;
 285         for (i = 0; i < smi->num_vlan_mc; i++) {
 286                 ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 287                 if (ret)
 288                         return ret;
 289         }
 290
 291         return 0;
 292 }
 293 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
 294
 295 int rtl8366_init_vlan(struct realtek_smi *smi)
 296 {
 297         int port;
 298         int ret;
 299
 300         ret = rtl8366_reset_vlan(smi);
 301         if (ret)
 302                 return ret;
 303
 304         /* Loop over the available ports, for each port, associate
 305          * it with the VLAN (port+1)
 306          */
 307         for (port = 0; port < smi->num_ports; port++) {
 308                 u32 mask;
 309
 310                 if (port == smi->cpu_port)
 311                         /* For the CPU port, make all ports members of this
 312                          * VLAN.
 313                          */
 314                         mask = GENMASK((int)smi->num_ports - 1, 0);
 315                 else
 316                         /* For all other ports, enable itself plus the
 317                          * CPU port.
 318                          */
 319                         mask = BIT(port) | BIT(smi->cpu_port);
 320
 321                 /* For each port, set the port as member of VLAN (port+1)
 322                  * and untagged, except for the CPU port: the CPU port (5) is
 323                  * member of VLAN 6 and so are ALL the other ports as well.
 324                  * Use filter 0 (no filter).
 325                  */
 326                 dev_info(smi->dev, "VLAN%d port mask for port %d, %08x\n",
 327                          (port + 1), port, mask);
 328                 ret = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
 329                 if (ret)
 330                         return ret;
 331
 332                 dev_info(smi->dev, "VLAN%d port %d, PVID set to %d\n",
 333                          (port + 1), port, (port + 1));
 334                 ret = rtl8366_set_pvid(smi, port, (port + 1));
 335                 if (ret)
 336                         return ret;
 337         }
 338
 339         return rtl8366_enable_vlan(smi, true);
 340 }
 341 EXPORT_SYMBOL_GPL(rtl8366_init_vlan);
 342
 343 int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
 344                            struct switchdev_trans *trans)
 345 {
 346         struct realtek_smi *smi = ds->priv;
 347         struct rtl8366_vlan_4k vlan4k;
 348         int ret;
 349
 350         /* Use VLAN nr port + 1 since VLAN0 is not valid */
 351         if (switchdev_trans_ph_prepare(trans)) {
 352                 if (!smi->ops->is_vlan_valid(smi, port + 1))
 353                         return -EINVAL;
 354
 355                 return 0;
 356         }
 357
 358         dev_info(smi->dev, "%s filtering on port %d\n",
 359                  vlan_filtering ? "enable" : "disable",
 360                  port);
 361
 362         /* TODO:
 363          * The hardware support filter ID (FID) 0..7, I have no clue how to
 364          * support this in the driver when the callback only says on/off.
 365          */
 366         ret = smi->ops->get_vlan_4k(smi, port + 1, &vlan4k);
 367         if (ret)
 368                 return ret;
 369
 370         /* Just set the filter to FID 1 for now then */
 371         ret = rtl8366_set_vlan(smi, port + 1,
 372                                vlan4k.member,
 373                                vlan4k.untag,
 374                                1);
 375         if (ret)
 376                 return ret;
 377
 378         return 0;
 379 }
 380 EXPORT_SYMBOL_GPL(rtl8366_vlan_filtering);
 381
 382 int rtl8366_vlan_prepare(struct dsa_switch *ds, int port,
 383                          const struct switchdev_obj_port_vlan *vlan)
 384 {
 385         struct realtek_smi *smi = ds->priv;
 386         u16 vid;
 387         int ret;
 388
 389         for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++)
 390                 if (!smi->ops->is_vlan_valid(smi, vid))
 391                         return -EINVAL;
 392
 393         dev_info(smi->dev, "prepare VLANs %04x..%04x\n",
 394                  vlan->vid_begin, vlan->vid_end);
 395
 396         /* Enable VLAN in the hardware
 397          * FIXME: what's with this 4k business?
 398          * Just rtl8366_enable_vlan() seems inconclusive.
 399          */
 400         ret = rtl8366_enable_vlan4k(smi, true);
 401         if (ret)
 402                 return ret;
 403
 404         return 0;
 405 }
 406 EXPORT_SYMBOL_GPL(rtl8366_vlan_prepare);
 407
 408 void rtl8366_vlan_add(struct dsa_switch *ds, int port,
 409                       const struct switchdev_obj_port_vlan *vlan)
 410 {
 411         bool untagged = !!(vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED);
 412         bool pvid = !!(vlan->flags & BRIDGE_VLAN_INFO_PVID);
 413         struct realtek_smi *smi = ds->priv;
 414         u32 member = 0;
 415         u32 untag = 0;
 416         u16 vid;
 417         int ret;
 418
 419         for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++)
 420                 if (!smi->ops->is_vlan_valid(smi, vid))
 421                         return;
 422
 423         dev_info(smi->dev, "add VLAN %d on port %d, %s, %s\n",
 424                  vlan->vid_begin,
 425                  port,
 426                  untagged ? "untagged" : "tagged",
 427                  pvid ? " PVID" : "no PVID");
 428
 429         if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
 430                 dev_err(smi->dev, "port is DSA or CPU port\n");
 431
 432         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
 433                 member |= BIT(port);
 434
 435                 if (untagged)
 436                         untag |= BIT(port);
 437
 438                 ret = rtl8366_set_vlan(smi, vid, member, untag, 0);
 439                 if (ret)
 440                         dev_err(smi->dev,
 441                                 "failed to set up VLAN %04x",
 442                                 vid);
 443
 444                 if (!pvid)
 445                         continue;
 446
 447                 ret = rtl8366_set_pvid(smi, port, vid);
 448                 if (ret)
 449                         dev_err(smi->dev,
 450                                 "failed to set PVID on port %d to VLAN %04x",
 451                                 port, vid);
 452
 453                 if (!ret)
 454                         dev_dbg(smi->dev, "VLAN add: added VLAN %d with PVID on port %d\n",
 455                                 vid, port);
 456         }
 457 }
 458 EXPORT_SYMBOL_GPL(rtl8366_vlan_add);
 459
 460 int rtl8366_vlan_del(struct dsa_switch *ds, int port,
 461                      const struct switchdev_obj_port_vlan *vlan)
 462 {
 463         struct realtek_smi *smi = ds->priv;
 464         u16 vid;
 465         int ret;
 466
 467         dev_info(smi->dev, "del VLAN on port %d\n", port);
 468
 469         for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
 470                 int i;
 471
 472                 dev_info(smi->dev, "del VLAN %04x\n", vid);
 473
 474                 for (i = 0; i < smi->num_vlan_mc; i++) {
 475                         struct rtl8366_vlan_mc vlanmc;
 476
 477                         ret = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 478                         if (ret)
 479                                 return ret;
 480
 481                         if (vid == vlanmc.vid) {
 482                                 /* Remove this port from the VLAN */
 483                                 vlanmc.member &= ~BIT(port);
 484                                 vlanmc.untag &= ~BIT(port);
 485                                 /*
 486                                  * If no ports are members of this VLAN
 487                                  * anymore then clear the whole member
 488                                  * config so it can be reused.
 489                                  */
 490                                 if (!vlanmc.member && vlanmc.untag) {
 491                                         vlanmc.vid = 0;
 492                                         vlanmc.priority = 0;
 493                                         vlanmc.fid = 0;
 494                                 }
 495                                 ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 496                                 if (ret) {
 497                                         dev_err(smi->dev,
 498                                                 "failed to remove VLAN %04x\n",
 499                                                 vid);
 500                                         return ret;
 501                                 }
 502                                 break;
 503                         }
 504                 }
 505         }
 506
 507         return 0;
 508 }
 509 EXPORT_SYMBOL_GPL(rtl8366_vlan_del);
 510
 511 void rtl8366_get_strings(struct dsa_switch *ds, int port, u32 stringset,
 512                          uint8_t *data)
 513 {
 514         struct realtek_smi *smi = ds->priv;
 515         struct rtl8366_mib_counter *mib;
 516         int i;
 517
 518         if (port >= smi->num_ports)
 519                 return;
 520
 521         for (i = 0; i < smi->num_mib_counters; i++) {
 522                 mib = &smi->mib_counters[i];
 523                 strncpy(data + i * ETH_GSTRING_LEN,
 524                         mib->name, ETH_GSTRING_LEN);
 525         }
 526 }
 527 EXPORT_SYMBOL_GPL(rtl8366_get_strings);
 528
 529 int rtl8366_get_sset_count(struct dsa_switch *ds, int port, int sset)
 530 {
 531         struct realtek_smi *smi = ds->priv;
 532
 533         /* We only support SS_STATS */
 534         if (sset != ETH_SS_STATS)
 535                 return 0;
 536         if (port >= smi->num_ports)
 537                 return -EINVAL;
 538
 539         return smi->num_mib_counters;
 540 }
 541 EXPORT_SYMBOL_GPL(rtl8366_get_sset_count);
 542
 543 void rtl8366_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *data)
 544 {
 545         struct realtek_smi *smi = ds->priv;
 546         int i;
 547         int ret;
 548
 549         if (port >= smi->num_ports)
 550                 return;
 551
 552         for (i = 0; i < smi->num_mib_counters; i++) {
 553                 struct rtl8366_mib_counter *mib;
 554                 u64 mibvalue = 0;
 555
 556                 mib = &smi->mib_counters[i];
 557                 ret = smi->ops->get_mib_counter(smi, port, mib, &mibvalue);
 558                 if (ret) {
 559                         dev_err(smi->dev, "error reading MIB counter %s\n",
 560                                 mib->name);
 561                 }
 562                 data[i] = mibvalue;
 563         }
 564 }
 565 EXPORT_SYMBOL_GPL(rtl8366_get_ethtool_stats);