LXR linux/drivers/net/dsa/microchip/ksz

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