root/drivers/net/dsa/microchip/ksz_common.c

DEFINITIONS

1. ksz_update_port_member
2. port_r_cnt
3. ksz_mib_read_work
4. mib_monitor
5. ksz_init_mib_timer
6. ksz_phy_read16
7. ksz_phy_write16
8. ksz_adjust_link
9. ksz_sset_count
10. ksz_get_ethtool_stats
11. ksz_port_bridge_join
12. ksz_port_bridge_leave
13. ksz_port_fast_age
14. ksz_port_vlan_prepare
15. ksz_port_fdb_dump
16. ksz_port_mdb_prepare
17. ksz_port_mdb_add
18. ksz_port_mdb_del
19. ksz_enable_port
20. ksz_disable_port
21. ksz_switch_alloc
22. ksz_switch_register
23. ksz_switch_remove

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