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