drivers/net/dsa/microchip/ksz_common.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Microchip switch driver main logic
   4  *
   5  * Copyright (C) 2017-2019 Microchip Technology Inc.
   6  */
   7
   8 #include <linux/delay.h>
   9 #include <linux/export.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/platform_data/microchip-ksz.h>
  14 #include <linux/phy.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/if_bridge.h>
  17 #include <linux/of_net.h>
  18 #include <net/dsa.h>
  19 #include <net/switchdev.h>
  20
  21 #include "ksz_common.h"
  22
  23 void ksz_update_port_member(struct ksz_device *dev, int port)
  24 {
  25         struct ksz_port *p = &dev->ports[port];
  26         struct dsa_switch *ds = dev->ds;
  27         u8 port_member = 0, cpu_port;
  28         const struct dsa_port *dp;
  29         int i, j;
  30
  31         if (!dsa_is_user_port(ds, port))
  32                 return;
  33
  34         dp = dsa_to_port(ds, port);
  35         cpu_port = BIT(dsa_upstream_port(ds, port));
  36
  37         for (i = 0; i < ds->num_ports; i++) {
  38                 const struct dsa_port *other_dp = dsa_to_port(ds, i);
  39                 struct ksz_port *other_p = &dev->ports[i];
  40                 u8 val = 0;
  41
  42                 if (!dsa_is_user_port(ds, i))
  43                         continue;
  44                 if (port == i)
  45                         continue;
  46                 if (!dsa_port_bridge_same(dp, other_dp))
  47                         continue;
  48                 if (other_p->stp_state != BR_STATE_FORWARDING)
  49                         continue;
  50
  51                 if (p->stp_state == BR_STATE_FORWARDING) {
  52                         val |= BIT(port);
  53                         port_member |= BIT(i);
  54                 }
  55
  56                 /* Retain port [i]'s relationship to other ports than [port] */
  57                 for (j = 0; j < ds->num_ports; j++) {
  58                         const struct dsa_port *third_dp;
  59                         struct ksz_port *third_p;
  60
  61                         if (j == i)
  62                                 continue;
  63                         if (j == port)
  64                                 continue;
  65                         if (!dsa_is_user_port(ds, j))
  66                                 continue;
  67                         third_p = &dev->ports[j];
  68                         if (third_p->stp_state != BR_STATE_FORWARDING)
  69                                 continue;
  70                         third_dp = dsa_to_port(ds, j);
  71                         if (dsa_port_bridge_same(other_dp, third_dp))
  72                                 val |= BIT(j);
  73                 }
  74
  75                 dev->dev_ops->cfg_port_member(dev, i, val | cpu_port);
  76         }
  77
  78         dev->dev_ops->cfg_port_member(dev, port, port_member | cpu_port);
  79 }
  80 EXPORT_SYMBOL_GPL(ksz_update_port_member);
  81
  82 static void port_r_cnt(struct ksz_device *dev, int port)
  83 {
  84         struct ksz_port_mib *mib = &dev->ports[port].mib;
  85         u64 *dropped;
  86
  87         /* Some ports may not have MIB counters before SWITCH_COUNTER_NUM. */
  88         while (mib->cnt_ptr < dev->reg_mib_cnt) {
  89                 dev->dev_ops->r_mib_cnt(dev, port, mib->cnt_ptr,
  90                                         &mib->counters[mib->cnt_ptr]);
  91                 ++mib->cnt_ptr;
  92         }
  93
  94         /* last one in storage */
  95         dropped = &mib->counters[dev->mib_cnt];
  96
  97         /* Some ports may not have MIB counters after SWITCH_COUNTER_NUM. */
  98         while (mib->cnt_ptr < dev->mib_cnt) {
  99                 dev->dev_ops->r_mib_pkt(dev, port, mib->cnt_ptr,
 100                                         dropped, &mib->counters[mib->cnt_ptr]);
 101                 ++mib->cnt_ptr;
 102         }
 103         mib->cnt_ptr = 0;
 104 }
 105
 106 static void ksz_mib_read_work(struct work_struct *work)
 107 {
 108         struct ksz_device *dev = container_of(work, struct ksz_device,
 109                                               mib_read.work);
 110         struct ksz_port_mib *mib;
 111         struct ksz_port *p;
 112         int i;
 113
 114         for (i = 0; i < dev->port_cnt; i++) {
 115                 if (dsa_is_unused_port(dev->ds, i))
 116                         continue;
 117
 118                 p = &dev->ports[i];
 119                 mib = &p->mib;
 120                 mutex_lock(&mib->cnt_mutex);
 121
 122                 /* Only read MIB counters when the port is told to do.
 123                  * If not, read only dropped counters when link is not up.
 124                  */
 125                 if (!p->read) {
 126                         const struct dsa_port *dp = dsa_to_port(dev->ds, i);
 127
 128                         if (!netif_carrier_ok(dp->slave))
 129                                 mib->cnt_ptr = dev->reg_mib_cnt;
 130                 }
 131                 port_r_cnt(dev, i);
 132                 p->read = false;
 133                 mutex_unlock(&mib->cnt_mutex);
 134         }
 135
 136         schedule_delayed_work(&dev->mib_read, dev->mib_read_interval);
 137 }
 138
 139 void ksz_init_mib_timer(struct ksz_device *dev)
 140 {
 141         int i;
 142
 143         INIT_DELAYED_WORK(&dev->mib_read, ksz_mib_read_work);
 144
 145         for (i = 0; i < dev->port_cnt; i++)
 146                 dev->dev_ops->port_init_cnt(dev, i);
 147 }
 148 EXPORT_SYMBOL_GPL(ksz_init_mib_timer);
 149
 150 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg)
 151 {
 152         struct ksz_device *dev = ds->priv;
 153         u16 val = 0xffff;
 154
 155         dev->dev_ops->r_phy(dev, addr, reg, &val);
 156
 157         return val;
 158 }
 159 EXPORT_SYMBOL_GPL(ksz_phy_read16);
 160
 161 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val)
 162 {
 163         struct ksz_device *dev = ds->priv;
 164
 165         dev->dev_ops->w_phy(dev, addr, reg, val);
 166
 167         return 0;
 168 }
 169 EXPORT_SYMBOL_GPL(ksz_phy_write16);
 170
 171 void ksz_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode,
 172                        phy_interface_t interface)
 173 {
 174         struct ksz_device *dev = ds->priv;
 175         struct ksz_port *p = &dev->ports[port];
 176
 177         /* Read all MIB counters when the link is going down. */
 178         p->read = true;
 179         /* timer started */
 180         if (dev->mib_read_interval)
 181                 schedule_delayed_work(&dev->mib_read, 0);
 182 }
 183 EXPORT_SYMBOL_GPL(ksz_mac_link_down);
 184
 185 int ksz_sset_count(struct dsa_switch *ds, int port, int sset)
 186 {
 187         struct ksz_device *dev = ds->priv;
 188
 189         if (sset != ETH_SS_STATS)
 190                 return 0;
 191
 192         return dev->mib_cnt;
 193 }
 194 EXPORT_SYMBOL_GPL(ksz_sset_count);
 195
 196 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf)
 197 {
 198         const struct dsa_port *dp = dsa_to_port(ds, port);
 199         struct ksz_device *dev = ds->priv;
 200         struct ksz_port_mib *mib;
 201
 202         mib = &dev->ports[port].mib;
 203         mutex_lock(&mib->cnt_mutex);
 204
 205         /* Only read dropped counters if no link. */
 206         if (!netif_carrier_ok(dp->slave))
 207                 mib->cnt_ptr = dev->reg_mib_cnt;
 208         port_r_cnt(dev, port);
 209         memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64));
 210         mutex_unlock(&mib->cnt_mutex);
 211 }
 212 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats);
 213
 214 int ksz_port_bridge_join(struct dsa_switch *ds, int port,
 215                          struct dsa_bridge bridge,
 216                          bool *tx_fwd_offload)
 217 {
 218         /* port_stp_state_set() will be called after to put the port in
 219          * appropriate state so there is no need to do anything.
 220          */
 221
 222         return 0;
 223 }
 224 EXPORT_SYMBOL_GPL(ksz_port_bridge_join);
 225
 226 void ksz_port_bridge_leave(struct dsa_switch *ds, int port,
 227                            struct dsa_bridge bridge)
 228 {
 229         /* port_stp_state_set() will be called after to put the port in
 230          * forwarding state so there is no need to do anything.
 231          */
 232 }
 233 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave);
 234
 235 void ksz_port_fast_age(struct dsa_switch *ds, int port)
 236 {
 237         struct ksz_device *dev = ds->priv;
 238
 239         dev->dev_ops->flush_dyn_mac_table(dev, port);
 240 }
 241 EXPORT_SYMBOL_GPL(ksz_port_fast_age);
 242
 243 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb,
 244                       void *data)
 245 {
 246         struct ksz_device *dev = ds->priv;
 247         int ret = 0;
 248         u16 i = 0;
 249         u16 entries = 0;
 250         u8 timestamp = 0;
 251         u8 fid;
 252         u8 member;
 253         struct alu_struct alu;
 254
 255         do {
 256                 alu.is_static = false;
 257                 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid,
 258                                                     &member, &timestamp,
 259                                                     &entries);
 260                 if (!ret && (member & BIT(port))) {
 261                         ret = cb(alu.mac, alu.fid, alu.is_static, data);
 262                         if (ret)
 263                                 break;
 264                 }
 265                 i++;
 266         } while (i < entries);
 267         if (i >= entries)
 268                 ret = 0;
 269
 270         return ret;
 271 }
 272 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
 273
 274 int ksz_port_mdb_add(struct dsa_switch *ds, int port,
 275                      const struct switchdev_obj_port_mdb *mdb)
 276 {
 277         struct ksz_device *dev = ds->priv;
 278         struct alu_struct alu;
 279         int index;
 280         int empty = 0;
 281
 282         alu.port_forward = 0;
 283         for (index = 0; index < dev->num_statics; index++) {
 284                 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
 285                         /* Found one already in static MAC table. */
 286                         if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
 287                             alu.fid == mdb->vid)
 288                                 break;
 289                 /* Remember the first empty entry. */
 290                 } else if (!empty) {
 291                         empty = index + 1;
 292                 }
 293         }
 294
 295         /* no available entry */
 296         if (index == dev->num_statics && !empty)
 297                 return -ENOSPC;
 298
 299         /* add entry */
 300         if (index == dev->num_statics) {
 301                 index = empty - 1;
 302                 memset(&alu, 0, sizeof(alu));
 303                 memcpy(alu.mac, mdb->addr, ETH_ALEN);
 304                 alu.is_static = true;
 305         }
 306         alu.port_forward |= BIT(port);
 307         if (mdb->vid) {
 308                 alu.is_use_fid = true;
 309
 310                 /* Need a way to map VID to FID. */
 311                 alu.fid = mdb->vid;
 312         }
 313         dev->dev_ops->w_sta_mac_table(dev, index, &alu);
 314
 315         return 0;
 316 }
 317 EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
 318
 319 int ksz_port_mdb_del(struct dsa_switch *ds, int port,
 320                      const struct switchdev_obj_port_mdb *mdb)
 321 {
 322         struct ksz_device *dev = ds->priv;
 323         struct alu_struct alu;
 324         int index;
 325
 326         for (index = 0; index < dev->num_statics; index++) {
 327                 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
 328                         /* Found one already in static MAC table. */
 329                         if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
 330                             alu.fid == mdb->vid)
 331                                 break;
 332                 }
 333         }
 334
 335         /* no available entry */
 336         if (index == dev->num_statics)
 337                 goto exit;
 338
 339         /* clear port */
 340         alu.port_forward &= ~BIT(port);
 341         if (!alu.port_forward)
 342                 alu.is_static = false;
 343         dev->dev_ops->w_sta_mac_table(dev, index, &alu);
 344
 345 exit:
 346         return 0;
 347 }
 348 EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
 349
 350 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
 351 {
 352         struct ksz_device *dev = ds->priv;
 353
 354         if (!dsa_is_user_port(ds, port))
 355                 return 0;
 356
 357         /* setup slave port */
 358         dev->dev_ops->port_setup(dev, port, false);
 359
 360         /* port_stp_state_set() will be called after to enable the port so
 361          * there is no need to do anything.
 362          */
 363
 364         return 0;
 365 }
 366 EXPORT_SYMBOL_GPL(ksz_enable_port);
 367
 368 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv)
 369 {
 370         struct dsa_switch *ds;
 371         struct ksz_device *swdev;
 372
 373         ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
 374         if (!ds)
 375                 return NULL;
 376
 377         ds->dev = base;
 378         ds->num_ports = DSA_MAX_PORTS;
 379
 380         swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
 381         if (!swdev)
 382                 return NULL;
 383
 384         ds->priv = swdev;
 385         swdev->dev = base;
 386
 387         swdev->ds = ds;
 388         swdev->priv = priv;
 389
 390         return swdev;
 391 }
 392 EXPORT_SYMBOL(ksz_switch_alloc);
 393
 394 int ksz_switch_register(struct ksz_device *dev,
 395                         const struct ksz_dev_ops *ops)
 396 {
 397         struct device_node *port, *ports;
 398         phy_interface_t interface;
 399         unsigned int port_num;
 400         int ret;
 401
 402         if (dev->pdata)
 403                 dev->chip_id = dev->pdata->chip_id;
 404
 405         dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset",
 406                                                   GPIOD_OUT_LOW);
 407         if (IS_ERR(dev->reset_gpio))
 408                 return PTR_ERR(dev->reset_gpio);
 409
 410         if (dev->reset_gpio) {
 411                 gpiod_set_value_cansleep(dev->reset_gpio, 1);
 412                 usleep_range(10000, 12000);
 413                 gpiod_set_value_cansleep(dev->reset_gpio, 0);
 414                 msleep(100);
 415         }
 416
 417         mutex_init(&dev->dev_mutex);
 418         mutex_init(&dev->regmap_mutex);
 419         mutex_init(&dev->alu_mutex);
 420         mutex_init(&dev->vlan_mutex);
 421
 422         dev->dev_ops = ops;
 423
 424         if (dev->dev_ops->detect(dev))
 425                 return -EINVAL;
 426
 427         ret = dev->dev_ops->init(dev);
 428         if (ret)
 429                 return ret;
 430
 431         /* Host port interface will be self detected, or specifically set in
 432          * device tree.
 433          */
 434         for (port_num = 0; port_num < dev->port_cnt; ++port_num)
 435                 dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA;
 436         if (dev->dev->of_node) {
 437                 ret = of_get_phy_mode(dev->dev->of_node, &interface);
 438                 if (ret == 0)
 439                         dev->compat_interface = interface;
 440                 ports = of_get_child_by_name(dev->dev->of_node, "ethernet-ports");
 441                 if (!ports)
 442                         ports = of_get_child_by_name(dev->dev->of_node, "ports");
 443                 if (ports)
 444                         for_each_available_child_of_node(ports, port) {
 445                                 if (of_property_read_u32(port, "reg",
 446                                                          &port_num))
 447                                         continue;
 448                                 if (!(dev->port_mask & BIT(port_num))) {
 449                                         of_node_put(port);
 450                                         return -EINVAL;
 451                                 }
 452                                 of_get_phy_mode(port,
 453                                                 &dev->ports[port_num].interface);
 454                         }
 455                 dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
 456                                                          "microchip,synclko-125");
 457         }
 458
 459         ret = dsa_register_switch(dev->ds);
 460         if (ret) {
 461                 dev->dev_ops->exit(dev);
 462                 return ret;
 463         }
 464
 465         /* Read MIB counters every 30 seconds to avoid overflow. */
 466         dev->mib_read_interval = msecs_to_jiffies(30000);
 467
 468         /* Start the MIB timer. */
 469         schedule_delayed_work(&dev->mib_read, 0);
 470
 471         return 0;
 472 }
 473 EXPORT_SYMBOL(ksz_switch_register);
 474
 475 void ksz_switch_remove(struct ksz_device *dev)
 476 {
 477         /* timer started */
 478         if (dev->mib_read_interval) {
 479                 dev->mib_read_interval = 0;
 480                 cancel_delayed_work_sync(&dev->mib_read);
 481         }
 482
 483         dev->dev_ops->exit(dev);
 484         dsa_unregister_switch(dev->ds);
 485
 486         if (dev->reset_gpio)
 487                 gpiod_set_value_cansleep(dev->reset_gpio, 1);
 488
 489 }
 490 EXPORT_SYMBOL(ksz_switch_remove);
 491
 492 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
 493 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
 494 MODULE_LICENSE("GPL");