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
 134                 if (dev->dev_ops->r_mib_stat64)
 135                         dev->dev_ops->r_mib_stat64(dev, i);
 136
 137                 mutex_unlock(&mib->cnt_mutex);
 138         }
 139
 140         schedule_delayed_work(&dev->mib_read, dev->mib_read_interval);
 141 }
 142
 143 void ksz_init_mib_timer(struct ksz_device *dev)
 144 {
 145         int i;
 146
 147         INIT_DELAYED_WORK(&dev->mib_read, ksz_mib_read_work);
 148
 149         for (i = 0; i < dev->port_cnt; i++)
 150                 dev->dev_ops->port_init_cnt(dev, i);
 151 }
 152 EXPORT_SYMBOL_GPL(ksz_init_mib_timer);
 153
 154 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg)
 155 {
 156         struct ksz_device *dev = ds->priv;
 157         u16 val = 0xffff;
 158
 159         dev->dev_ops->r_phy(dev, addr, reg, &val);
 160
 161         return val;
 162 }
 163 EXPORT_SYMBOL_GPL(ksz_phy_read16);
 164
 165 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val)
 166 {
 167         struct ksz_device *dev = ds->priv;
 168
 169         dev->dev_ops->w_phy(dev, addr, reg, val);
 170
 171         return 0;
 172 }
 173 EXPORT_SYMBOL_GPL(ksz_phy_write16);
 174
 175 void ksz_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode,
 176                        phy_interface_t interface)
 177 {
 178         struct ksz_device *dev = ds->priv;
 179         struct ksz_port *p = &dev->ports[port];
 180
 181         /* Read all MIB counters when the link is going down. */
 182         p->read = true;
 183         /* timer started */
 184         if (dev->mib_read_interval)
 185                 schedule_delayed_work(&dev->mib_read, 0);
 186 }
 187 EXPORT_SYMBOL_GPL(ksz_mac_link_down);
 188
 189 int ksz_sset_count(struct dsa_switch *ds, int port, int sset)
 190 {
 191         struct ksz_device *dev = ds->priv;
 192
 193         if (sset != ETH_SS_STATS)
 194                 return 0;
 195
 196         return dev->mib_cnt;
 197 }
 198 EXPORT_SYMBOL_GPL(ksz_sset_count);
 199
 200 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf)
 201 {
 202         const struct dsa_port *dp = dsa_to_port(ds, port);
 203         struct ksz_device *dev = ds->priv;
 204         struct ksz_port_mib *mib;
 205
 206         mib = &dev->ports[port].mib;
 207         mutex_lock(&mib->cnt_mutex);
 208
 209         /* Only read dropped counters if no link. */
 210         if (!netif_carrier_ok(dp->slave))
 211                 mib->cnt_ptr = dev->reg_mib_cnt;
 212         port_r_cnt(dev, port);
 213         memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64));
 214         mutex_unlock(&mib->cnt_mutex);
 215 }
 216 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats);
 217
 218 int ksz_port_bridge_join(struct dsa_switch *ds, int port,
 219                          struct dsa_bridge bridge,
 220                          bool *tx_fwd_offload,
 221                          struct netlink_ext_ack *extack)
 222 {
 223         /* port_stp_state_set() will be called after to put the port in
 224          * appropriate state so there is no need to do anything.
 225          */
 226
 227         return 0;
 228 }
 229 EXPORT_SYMBOL_GPL(ksz_port_bridge_join);
 230
 231 void ksz_port_bridge_leave(struct dsa_switch *ds, int port,
 232                            struct dsa_bridge bridge)
 233 {
 234         /* port_stp_state_set() will be called after to put the port in
 235          * forwarding state so there is no need to do anything.
 236          */
 237 }
 238 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave);
 239
 240 void ksz_port_fast_age(struct dsa_switch *ds, int port)
 241 {
 242         struct ksz_device *dev = ds->priv;
 243
 244         dev->dev_ops->flush_dyn_mac_table(dev, port);
 245 }
 246 EXPORT_SYMBOL_GPL(ksz_port_fast_age);
 247
 248 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb,
 249                       void *data)
 250 {
 251         struct ksz_device *dev = ds->priv;
 252         int ret = 0;
 253         u16 i = 0;
 254         u16 entries = 0;
 255         u8 timestamp = 0;
 256         u8 fid;
 257         u8 member;
 258         struct alu_struct alu;
 259
 260         do {
 261                 alu.is_static = false;
 262                 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid,
 263                                                     &member, &timestamp,
 264                                                     &entries);
 265                 if (!ret && (member & BIT(port))) {
 266                         ret = cb(alu.mac, alu.fid, alu.is_static, data);
 267                         if (ret)
 268                                 break;
 269                 }
 270                 i++;
 271         } while (i < entries);
 272         if (i >= entries)
 273                 ret = 0;
 274
 275         return ret;
 276 }
 277 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
 278
 279 int ksz_port_mdb_add(struct dsa_switch *ds, int port,
 280                      const struct switchdev_obj_port_mdb *mdb,
 281                      struct dsa_db db)
 282 {
 283         struct ksz_device *dev = ds->priv;
 284         struct alu_struct alu;
 285         int index;
 286         int empty = 0;
 287
 288         alu.port_forward = 0;
 289         for (index = 0; index < dev->num_statics; index++) {
 290                 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
 291                         /* Found one already in static MAC table. */
 292                         if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
 293                             alu.fid == mdb->vid)
 294                                 break;
 295                 /* Remember the first empty entry. */
 296                 } else if (!empty) {
 297                         empty = index + 1;
 298                 }
 299         }
 300
 301         /* no available entry */
 302         if (index == dev->num_statics && !empty)
 303                 return -ENOSPC;
 304
 305         /* add entry */
 306         if (index == dev->num_statics) {
 307                 index = empty - 1;
 308                 memset(&alu, 0, sizeof(alu));
 309                 memcpy(alu.mac, mdb->addr, ETH_ALEN);
 310                 alu.is_static = true;
 311         }
 312         alu.port_forward |= BIT(port);
 313         if (mdb->vid) {
 314                 alu.is_use_fid = true;
 315
 316                 /* Need a way to map VID to FID. */
 317                 alu.fid = mdb->vid;
 318         }
 319         dev->dev_ops->w_sta_mac_table(dev, index, &alu);
 320
 321         return 0;
 322 }
 323 EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
 324
 325 int ksz_port_mdb_del(struct dsa_switch *ds, int port,
 326                      const struct switchdev_obj_port_mdb *mdb,
 327                      struct dsa_db db)
 328 {
 329         struct ksz_device *dev = ds->priv;
 330         struct alu_struct alu;
 331         int index;
 332
 333         for (index = 0; index < dev->num_statics; index++) {
 334                 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
 335                         /* Found one already in static MAC table. */
 336                         if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
 337                             alu.fid == mdb->vid)
 338                                 break;
 339                 }
 340         }
 341
 342         /* no available entry */
 343         if (index == dev->num_statics)
 344                 goto exit;
 345
 346         /* clear port */
 347         alu.port_forward &= ~BIT(port);
 348         if (!alu.port_forward)
 349                 alu.is_static = false;
 350         dev->dev_ops->w_sta_mac_table(dev, index, &alu);
 351
 352 exit:
 353         return 0;
 354 }
 355 EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
 356
 357 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
 358 {
 359         struct ksz_device *dev = ds->priv;
 360
 361         if (!dsa_is_user_port(ds, port))
 362                 return 0;
 363
 364         /* setup slave port */
 365         dev->dev_ops->port_setup(dev, port, false);
 366
 367         /* port_stp_state_set() will be called after to enable the port so
 368          * there is no need to do anything.
 369          */
 370
 371         return 0;
 372 }
 373 EXPORT_SYMBOL_GPL(ksz_enable_port);
 374
 375 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv)
 376 {
 377         struct dsa_switch *ds;
 378         struct ksz_device *swdev;
 379
 380         ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
 381         if (!ds)
 382                 return NULL;
 383
 384         ds->dev = base;
 385         ds->num_ports = DSA_MAX_PORTS;
 386
 387         swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
 388         if (!swdev)
 389                 return NULL;
 390
 391         ds->priv = swdev;
 392         swdev->dev = base;
 393
 394         swdev->ds = ds;
 395         swdev->priv = priv;
 396
 397         return swdev;
 398 }
 399 EXPORT_SYMBOL(ksz_switch_alloc);
 400
 401 int ksz_switch_register(struct ksz_device *dev,
 402                         const struct ksz_dev_ops *ops)
 403 {
 404         struct device_node *port, *ports;
 405         phy_interface_t interface;
 406         unsigned int port_num;
 407         int ret;
 408
 409         if (dev->pdata)
 410                 dev->chip_id = dev->pdata->chip_id;
 411
 412         dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset",
 413                                                   GPIOD_OUT_LOW);
 414         if (IS_ERR(dev->reset_gpio))
 415                 return PTR_ERR(dev->reset_gpio);
 416
 417         if (dev->reset_gpio) {
 418                 gpiod_set_value_cansleep(dev->reset_gpio, 1);
 419                 usleep_range(10000, 12000);
 420                 gpiod_set_value_cansleep(dev->reset_gpio, 0);
 421                 msleep(100);
 422         }
 423
 424         mutex_init(&dev->dev_mutex);
 425         mutex_init(&dev->regmap_mutex);
 426         mutex_init(&dev->alu_mutex);
 427         mutex_init(&dev->vlan_mutex);
 428
 429         dev->dev_ops = ops;
 430
 431         if (dev->dev_ops->detect(dev))
 432                 return -EINVAL;
 433
 434         ret = dev->dev_ops->init(dev);
 435         if (ret)
 436                 return ret;
 437
 438         /* Host port interface will be self detected, or specifically set in
 439          * device tree.
 440          */
 441         for (port_num = 0; port_num < dev->port_cnt; ++port_num)
 442                 dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA;
 443         if (dev->dev->of_node) {
 444                 ret = of_get_phy_mode(dev->dev->of_node, &interface);
 445                 if (ret == 0)
 446                         dev->compat_interface = interface;
 447                 ports = of_get_child_by_name(dev->dev->of_node, "ethernet-ports");
 448                 if (!ports)
 449                         ports = of_get_child_by_name(dev->dev->of_node, "ports");
 450                 if (ports)
 451                         for_each_available_child_of_node(ports, port) {
 452                                 if (of_property_read_u32(port, "reg",
 453                                                          &port_num))
 454                                         continue;
 455                                 if (!(dev->port_mask & BIT(port_num))) {
 456                                         of_node_put(port);
 457                                         return -EINVAL;
 458                                 }
 459                                 of_get_phy_mode(port,
 460                                                 &dev->ports[port_num].interface);
 461                         }
 462                 dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
 463                                                          "microchip,synclko-125");
 464                 dev->synclko_disable = of_property_read_bool(dev->dev->of_node,
 465                                                              "microchip,synclko-disable");
 466                 if (dev->synclko_125 && dev->synclko_disable) {
 467                         dev_err(dev->dev, "inconsistent synclko settings\n");
 468                         return -EINVAL;
 469                 }
 470         }
 471
 472         ret = dsa_register_switch(dev->ds);
 473         if (ret) {
 474                 dev->dev_ops->exit(dev);
 475                 return ret;
 476         }
 477
 478         /* Read MIB counters every 30 seconds to avoid overflow. */
 479         dev->mib_read_interval = msecs_to_jiffies(5000);
 480
 481         /* Start the MIB timer. */
 482         schedule_delayed_work(&dev->mib_read, 0);
 483
 484         return 0;
 485 }
 486 EXPORT_SYMBOL(ksz_switch_register);
 487
 488 void ksz_switch_remove(struct ksz_device *dev)
 489 {
 490         /* timer started */
 491         if (dev->mib_read_interval) {
 492                 dev->mib_read_interval = 0;
 493                 cancel_delayed_work_sync(&dev->mib_read);
 494         }
 495
 496         dev->dev_ops->exit(dev);
 497         dsa_unregister_switch(dev->ds);
 498
 499         if (dev->reset_gpio)
 500                 gpiod_set_value_cansleep(dev->reset_gpio, 1);
 501
 502 }
 503 EXPORT_SYMBOL(ksz_switch_remove);
 504
 505 MODULE_AUTHOR("Woojung Huh <[email protected]>");
 506 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
 507 MODULE_LICENSE("GPL");