target/linux/mediatek/files-5.4/drivers/net/phy/mtk/mt753x/mt753x_swconfig.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2018 MediaTek Inc.
   4  * Author: Weijie Gao <weijie.gao@mediatek.com>
   5  */
   6
   7 #include <linux/if.h>
   8 #include <linux/list.h>
   9 #include <linux/if_ether.h>
  10 #include <linux/skbuff.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/netlink.h>
  13 #include <linux/bitops.h>
  14 #include <net/genetlink.h>
  15 #include <linux/delay.h>
  16 #include <linux/phy.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/lockdep.h>
  20 #include <linux/workqueue.h>
  21 #include <linux/of_device.h>
  22
  23 #include "mt753x.h"
  24 #include "mt753x_swconfig.h"
  25 #include "mt753x_regs.h"
  26
  27 #define MT753X_PORT_MIB_TXB_ID  18      /* TxByte */
  28 #define MT753X_PORT_MIB_RXB_ID  37      /* RxByte */
  29
  30 #define MIB_DESC(_s, _o, _n)   \
  31         {                       \
  32                 .size = (_s),   \
  33                 .offset = (_o), \
  34                 .name = (_n),   \
  35         }
  36
  37 struct mt753x_mib_desc {
  38         unsigned int size;
  39         unsigned int offset;
  40         const char *name;
  41 };
  42
  43 static const struct mt753x_mib_desc mt753x_mibs[] = {
  44         MIB_DESC(1, STATS_TDPC, "TxDrop"),
  45         MIB_DESC(1, STATS_TCRC, "TxCRC"),
  46         MIB_DESC(1, STATS_TUPC, "TxUni"),
  47         MIB_DESC(1, STATS_TMPC, "TxMulti"),
  48         MIB_DESC(1, STATS_TBPC, "TxBroad"),
  49         MIB_DESC(1, STATS_TCEC, "TxCollision"),
  50         MIB_DESC(1, STATS_TSCEC, "TxSingleCol"),
  51         MIB_DESC(1, STATS_TMCEC, "TxMultiCol"),
  52         MIB_DESC(1, STATS_TDEC, "TxDefer"),
  53         MIB_DESC(1, STATS_TLCEC, "TxLateCol"),
  54         MIB_DESC(1, STATS_TXCEC, "TxExcCol"),
  55         MIB_DESC(1, STATS_TPPC, "TxPause"),
  56         MIB_DESC(1, STATS_TL64PC, "Tx64Byte"),
  57         MIB_DESC(1, STATS_TL65PC, "Tx65Byte"),
  58         MIB_DESC(1, STATS_TL128PC, "Tx128Byte"),
  59         MIB_DESC(1, STATS_TL256PC, "Tx256Byte"),
  60         MIB_DESC(1, STATS_TL512PC, "Tx512Byte"),
  61         MIB_DESC(1, STATS_TL1024PC, "Tx1024Byte"),
  62         MIB_DESC(2, STATS_TOC, "TxByte"),
  63         MIB_DESC(1, STATS_RDPC, "RxDrop"),
  64         MIB_DESC(1, STATS_RFPC, "RxFiltered"),
  65         MIB_DESC(1, STATS_RUPC, "RxUni"),
  66         MIB_DESC(1, STATS_RMPC, "RxMulti"),
  67         MIB_DESC(1, STATS_RBPC, "RxBroad"),
  68         MIB_DESC(1, STATS_RAEPC, "RxAlignErr"),
  69         MIB_DESC(1, STATS_RCEPC, "RxCRC"),
  70         MIB_DESC(1, STATS_RUSPC, "RxUnderSize"),
  71         MIB_DESC(1, STATS_RFEPC, "RxFragment"),
  72         MIB_DESC(1, STATS_ROSPC, "RxOverSize"),
  73         MIB_DESC(1, STATS_RJEPC, "RxJabber"),
  74         MIB_DESC(1, STATS_RPPC, "RxPause"),
  75         MIB_DESC(1, STATS_RL64PC, "Rx64Byte"),
  76         MIB_DESC(1, STATS_RL65PC, "Rx65Byte"),
  77         MIB_DESC(1, STATS_RL128PC, "Rx128Byte"),
  78         MIB_DESC(1, STATS_RL256PC, "Rx256Byte"),
  79         MIB_DESC(1, STATS_RL512PC, "Rx512Byte"),
  80         MIB_DESC(1, STATS_RL1024PC, "Rx1024Byte"),
  81         MIB_DESC(2, STATS_ROC, "RxByte"),
  82         MIB_DESC(1, STATS_RDPC_CTRL, "RxCtrlDrop"),
  83         MIB_DESC(1, STATS_RDPC_ING, "RxIngDrop"),
  84         MIB_DESC(1, STATS_RDPC_ARL, "RxARLDrop")
  85 };
  86
  87 enum {
  88         /* Global attributes. */
  89         MT753X_ATTR_ENABLE_VLAN,
  90 };
  91
  92 static int mt753x_get_vlan_enable(struct switch_dev *dev,
  93                                   const struct switch_attr *attr,
  94                                   struct switch_val *val)
  95 {
  96         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
  97
  98         val->value.i = gsw->global_vlan_enable;
  99
 100         return 0;
 101 }
 102
 103 static int mt753x_set_vlan_enable(struct switch_dev *dev,
 104                                   const struct switch_attr *attr,
 105                                   struct switch_val *val)
 106 {
 107         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 108
 109         gsw->global_vlan_enable = val->value.i != 0;
 110
 111         return 0;
 112 }
 113
 114 static int mt753x_get_port_pvid(struct switch_dev *dev, int port, int *val)
 115 {
 116         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 117
 118         if (port >= MT753X_NUM_PORTS)
 119                 return -EINVAL;
 120
 121         *val = mt753x_reg_read(gsw, PPBV1(port));
 122         *val &= GRP_PORT_VID_M;
 123
 124         return 0;
 125 }
 126
 127 static int mt753x_set_port_pvid(struct switch_dev *dev, int port, int pvid)
 128 {
 129         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 130
 131         if (port >= MT753X_NUM_PORTS)
 132                 return -EINVAL;
 133
 134         if (pvid < MT753X_MIN_VID || pvid > MT753X_MAX_VID)
 135                 return -EINVAL;
 136
 137         gsw->port_entries[port].pvid = pvid;
 138
 139         return 0;
 140 }
 141
 142 static int mt753x_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 143 {
 144         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 145         u32 member;
 146         u32 etags;
 147         int i;
 148
 149         val->len = 0;
 150
 151         if (val->port_vlan < 0 || val->port_vlan >= MT753X_NUM_VLANS)
 152                 return -EINVAL;
 153
 154         mt753x_vlan_ctrl(gsw, VTCR_READ_VLAN_ENTRY, val->port_vlan);
 155
 156         member = mt753x_reg_read(gsw, VAWD1);
 157         member &= PORT_MEM_M;
 158         member >>= PORT_MEM_S;
 159
 160         etags = mt753x_reg_read(gsw, VAWD2);
 161
 162         for (i = 0; i < MT753X_NUM_PORTS; i++) {
 163                 struct switch_port *p;
 164                 int etag;
 165
 166                 if (!(member & BIT(i)))
 167                         continue;
 168
 169                 p = &val->value.ports[val->len++];
 170                 p->id = i;
 171
 172                 etag = (etags >> PORT_ETAG_S(i)) & PORT_ETAG_M;
 173
 174                 if (etag == ETAG_CTRL_TAG)
 175                         p->flags |= BIT(SWITCH_PORT_FLAG_TAGGED);
 176                 else if (etag != ETAG_CTRL_UNTAG)
 177                         dev_info(gsw->dev,
 178                                  "vlan egress tag control neither untag nor tag.\n");
 179         }
 180
 181         return 0;
 182 }
 183
 184 static int mt753x_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 185 {
 186         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 187         u8 member = 0;
 188         u8 etags = 0;
 189         int i;
 190
 191         if (val->port_vlan < 0 || val->port_vlan >= MT753X_NUM_VLANS ||
 192             val->len > MT753X_NUM_PORTS)
 193                 return -EINVAL;
 194
 195         for (i = 0; i < val->len; i++) {
 196                 struct switch_port *p = &val->value.ports[i];
 197
 198                 if (p->id >= MT753X_NUM_PORTS)
 199                         return -EINVAL;
 200
 201                 member |= BIT(p->id);
 202
 203                 if (p->flags & BIT(SWITCH_PORT_FLAG_TAGGED))
 204                         etags |= BIT(p->id);
 205         }
 206
 207         gsw->vlan_entries[val->port_vlan].member = member;
 208         gsw->vlan_entries[val->port_vlan].etags = etags;
 209
 210         return 0;
 211 }
 212
 213 static int mt753x_set_vid(struct switch_dev *dev,
 214                           const struct switch_attr *attr,
 215                           struct switch_val *val)
 216 {
 217         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 218         int vlan;
 219         u16 vid;
 220
 221         vlan = val->port_vlan;
 222         vid = (u16)val->value.i;
 223
 224         if (vlan < 0 || vlan >= MT753X_NUM_VLANS)
 225                 return -EINVAL;
 226
 227         if (vid < MT753X_MIN_VID || vid > MT753X_MAX_VID)
 228                 return -EINVAL;
 229
 230         gsw->vlan_entries[vlan].vid = vid;
 231         return 0;
 232 }
 233
 234 static int mt753x_get_vid(struct switch_dev *dev,
 235                           const struct switch_attr *attr,
 236                           struct switch_val *val)
 237 {
 238         val->value.i = val->port_vlan;
 239         return 0;
 240 }
 241
 242 static int mt753x_get_port_link(struct switch_dev *dev, int port,
 243                                 struct switch_port_link *link)
 244 {
 245         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 246         u32 speed, pmsr;
 247
 248         if (port < 0 || port >= MT753X_NUM_PORTS)
 249                 return -EINVAL;
 250
 251         pmsr = mt753x_reg_read(gsw, PMSR(port));
 252
 253         link->link = pmsr & MAC_LNK_STS;
 254         link->duplex = pmsr & MAC_DPX_STS;
 255         speed = (pmsr & MAC_SPD_STS_M) >> MAC_SPD_STS_S;
 256
 257         switch (speed) {
 258         case MAC_SPD_10:
 259                 link->speed = SWITCH_PORT_SPEED_10;
 260                 break;
 261         case MAC_SPD_100:
 262                 link->speed = SWITCH_PORT_SPEED_100;
 263                 break;
 264         case MAC_SPD_1000:
 265                 link->speed = SWITCH_PORT_SPEED_1000;
 266                 break;
 267         case MAC_SPD_2500:
 268                 /* TODO: swconfig has no support for 2500 now */
 269                 link->speed = SWITCH_PORT_SPEED_UNKNOWN;
 270                 break;
 271         }
 272
 273         return 0;
 274 }
 275
 276 static int mt753x_set_port_link(struct switch_dev *dev, int port,
 277                                 struct switch_port_link *link)
 278 {
 279 #ifndef MODULE
 280         if (port >= MT753X_NUM_PHYS)
 281                 return -EINVAL;
 282
 283         return switch_generic_set_link(dev, port, link);
 284 #else
 285         return -ENOTSUPP;
 286 #endif
 287 }
 288
 289 static u64 get_mib_counter(struct gsw_mt753x *gsw, int i, int port)
 290 {
 291         unsigned int offset;
 292         u64 lo, hi, hi2;
 293
 294         offset = mt753x_mibs[i].offset;
 295
 296         if (mt753x_mibs[i].size == 1)
 297                 return mt753x_reg_read(gsw, MIB_COUNTER_REG(port, offset));
 298
 299         do {
 300                 hi = mt753x_reg_read(gsw, MIB_COUNTER_REG(port, offset + 4));
 301                 lo = mt753x_reg_read(gsw, MIB_COUNTER_REG(port, offset));
 302                 hi2 = mt753x_reg_read(gsw, MIB_COUNTER_REG(port, offset + 4));
 303         } while (hi2 != hi);
 304
 305         return (hi << 32) | lo;
 306 }
 307
 308 static int mt753x_get_port_mib(struct switch_dev *dev,
 309                                const struct switch_attr *attr,
 310                                struct switch_val *val)
 311 {
 312         static char buf[4096];
 313         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 314         int i, len = 0;
 315
 316         if (val->port_vlan >= MT753X_NUM_PORTS)
 317                 return -EINVAL;
 318
 319         len += snprintf(buf + len, sizeof(buf) - len,
 320                         "Port %d MIB counters\n", val->port_vlan);
 321
 322         for (i = 0; i < ARRAY_SIZE(mt753x_mibs); ++i) {
 323                 u64 counter;
 324
 325                 len += snprintf(buf + len, sizeof(buf) - len,
 326                                 "%-11s: ", mt753x_mibs[i].name);
 327                 counter = get_mib_counter(gsw, i, val->port_vlan);
 328                 len += snprintf(buf + len, sizeof(buf) - len, "%llu\n",
 329                                 counter);
 330         }
 331
 332         val->value.s = buf;
 333         val->len = len;
 334         return 0;
 335 }
 336
 337 static int mt753x_get_port_stats(struct switch_dev *dev, int port,
 338                                  struct switch_port_stats *stats)
 339 {
 340         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 341
 342         if (port < 0 || port >= MT753X_NUM_PORTS)
 343                 return -EINVAL;
 344
 345         stats->tx_bytes = get_mib_counter(gsw, MT753X_PORT_MIB_TXB_ID, port);
 346         stats->rx_bytes = get_mib_counter(gsw, MT753X_PORT_MIB_RXB_ID, port);
 347
 348         return 0;
 349 }
 350
 351 static void mt753x_port_isolation(struct gsw_mt753x *gsw)
 352 {
 353         int i;
 354
 355         for (i = 0; i < MT753X_NUM_PORTS; i++)
 356                 mt753x_reg_write(gsw, PCR(i),
 357                                  BIT(gsw->cpu_port) << PORT_MATRIX_S);
 358
 359         mt753x_reg_write(gsw, PCR(gsw->cpu_port), PORT_MATRIX_M);
 360
 361         for (i = 0; i < MT753X_NUM_PORTS; i++)
 362                 mt753x_reg_write(gsw, PVC(i),
 363                                  (0x8100 << STAG_VPID_S) |
 364                                  (VA_TRANSPARENT_PORT << VLAN_ATTR_S));
 365 }
 366
 367 static int mt753x_apply_config(struct switch_dev *dev)
 368 {
 369         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 370
 371         if (!gsw->global_vlan_enable) {
 372                 mt753x_port_isolation(gsw);
 373                 return 0;
 374         }
 375
 376         mt753x_apply_vlan_config(gsw);
 377
 378         return 0;
 379 }
 380
 381 static int mt753x_reset_switch(struct switch_dev *dev)
 382 {
 383         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 384         int i;
 385
 386         memset(gsw->port_entries, 0, sizeof(gsw->port_entries));
 387         memset(gsw->vlan_entries, 0, sizeof(gsw->vlan_entries));
 388
 389         /* set default vid of each vlan to the same number of vlan, so the vid
 390          * won't need be set explicitly.
 391          */
 392         for (i = 0; i < MT753X_NUM_VLANS; i++)
 393                 gsw->vlan_entries[i].vid = i;
 394
 395         return 0;
 396 }
 397
 398 static int mt753x_phy_read16(struct switch_dev *dev, int addr, u8 reg,
 399                              u16 *value)
 400 {
 401         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 402
 403         *value = gsw->mii_read(gsw, addr, reg);
 404
 405         return 0;
 406 }
 407
 408 static int mt753x_phy_write16(struct switch_dev *dev, int addr, u8 reg,
 409                               u16 value)
 410 {
 411         struct gsw_mt753x *gsw = container_of(dev, struct gsw_mt753x, swdev);
 412
 413         gsw->mii_write(gsw, addr, reg, value);
 414
 415         return 0;
 416 }
 417
 418 static const struct switch_attr mt753x_global[] = {
 419         {
 420                 .type = SWITCH_TYPE_INT,
 421                 .name = "enable_vlan",
 422                 .description = "VLAN mode (1:enabled)",
 423                 .max = 1,
 424                 .id = MT753X_ATTR_ENABLE_VLAN,
 425                 .get = mt753x_get_vlan_enable,
 426                 .set = mt753x_set_vlan_enable,
 427         }
 428 };
 429
 430 static const struct switch_attr mt753x_port[] = {
 431         {
 432                 .type = SWITCH_TYPE_STRING,
 433                 .name = "mib",
 434                 .description = "Get MIB counters for port",
 435                 .get = mt753x_get_port_mib,
 436                 .set = NULL,
 437         },
 438 };
 439
 440 static const struct switch_attr mt753x_vlan[] = {
 441         {
 442                 .type = SWITCH_TYPE_INT,
 443                 .name = "vid",
 444                 .description = "VLAN ID (0-4094)",
 445                 .set = mt753x_set_vid,
 446                 .get = mt753x_get_vid,
 447                 .max = 4094,
 448         },
 449 };
 450
 451 static const struct switch_dev_ops mt753x_swdev_ops = {
 452         .attr_global = {
 453                 .attr = mt753x_global,
 454                 .n_attr = ARRAY_SIZE(mt753x_global),
 455         },
 456         .attr_port = {
 457                 .attr = mt753x_port,
 458                 .n_attr = ARRAY_SIZE(mt753x_port),
 459         },
 460         .attr_vlan = {
 461                 .attr = mt753x_vlan,
 462                 .n_attr = ARRAY_SIZE(mt753x_vlan),
 463         },
 464         .get_vlan_ports = mt753x_get_vlan_ports,
 465         .set_vlan_ports = mt753x_set_vlan_ports,
 466         .get_port_pvid = mt753x_get_port_pvid,
 467         .set_port_pvid = mt753x_set_port_pvid,
 468         .get_port_link = mt753x_get_port_link,
 469         .set_port_link = mt753x_set_port_link,
 470         .get_port_stats = mt753x_get_port_stats,
 471         .apply_config = mt753x_apply_config,
 472         .reset_switch = mt753x_reset_switch,
 473         .phy_read16 = mt753x_phy_read16,
 474         .phy_write16 = mt753x_phy_write16,
 475 };
 476
 477 int mt753x_swconfig_init(struct gsw_mt753x *gsw)
 478 {
 479         struct device_node *np = gsw->dev->of_node;
 480         struct switch_dev *swdev;
 481         int ret;
 482
 483         if (of_property_read_u32(np, "mediatek,cpuport", &gsw->cpu_port))
 484                 gsw->cpu_port = MT753X_DFL_CPU_PORT;
 485
 486         swdev = &gsw->swdev;
 487
 488         swdev->name = gsw->name;
 489         swdev->alias = gsw->name;
 490         swdev->cpu_port = gsw->cpu_port;
 491         swdev->ports = MT753X_NUM_PORTS;
 492         swdev->vlans = MT753X_NUM_VLANS;
 493         swdev->ops = &mt753x_swdev_ops;
 494
 495         ret = register_switch(swdev, NULL);
 496         if (ret) {
 497                 dev_notice(gsw->dev, "Failed to register switch %s\n",
 498                            swdev->name);
 499                 return ret;
 500         }
 501
 502         mt753x_apply_config(swdev);
 503
 504         return 0;
 505 }
 506
 507 void mt753x_swconfig_destroy(struct gsw_mt753x *gsw)
 508 {
 509         unregister_switch(&gsw->swdev);
 510 }