1 // SPDX-License-Identifier: GPL-2.0
3 * Microchip switch driver main logic
5 * Copyright (C) 2017-2019 Microchip Technology Inc.
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>
19 #include <net/switchdev.h>
21 #include "ksz_common.h"
23 void ksz_update_port_member(struct ksz_device *dev, int port)
28 for (i = 0; i < dev->port_cnt; i++) {
29 if (i == port || i == dev->cpu_port)
32 if (!(dev->member & (1 << i)))
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);
41 EXPORT_SYMBOL_GPL(ksz_update_port_member);
43 static void port_r_cnt(struct ksz_device *dev, int port)
45 struct ksz_port_mib *mib = &dev->ports[port].mib;
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]);
55 /* last one in storage */
56 dropped = &mib->counters[dev->mib_cnt];
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]);
67 static void ksz_mib_read_work(struct work_struct *work)
69 struct ksz_device *dev = container_of(work, struct ksz_device,
71 struct ksz_port_mib *mib;
75 for (i = 0; i < dev->mib_port_cnt; i++) {
76 if (dsa_is_unused_port(dev->ds, i))
81 mutex_lock(&mib->cnt_mutex);
83 /* Only read MIB counters when the port is told to do.
84 * If not, read only dropped counters when link is not up.
87 const struct dsa_port *dp = dsa_to_port(dev->ds, i);
89 if (!netif_carrier_ok(dp->slave))
90 mib->cnt_ptr = dev->reg_mib_cnt;
94 mutex_unlock(&mib->cnt_mutex);
97 schedule_delayed_work(&dev->mib_read, dev->mib_read_interval);
100 void ksz_init_mib_timer(struct ksz_device *dev)
104 INIT_DELAYED_WORK(&dev->mib_read, ksz_mib_read_work);
106 /* Read MIB counters every 30 seconds to avoid overflow. */
107 dev->mib_read_interval = msecs_to_jiffies(30000);
109 for (i = 0; i < dev->mib_port_cnt; i++)
110 dev->dev_ops->port_init_cnt(dev, i);
112 /* Start the timer 2 seconds later. */
113 schedule_delayed_work(&dev->mib_read, msecs_to_jiffies(2000));
115 EXPORT_SYMBOL_GPL(ksz_init_mib_timer);
117 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg)
119 struct ksz_device *dev = ds->priv;
122 dev->dev_ops->r_phy(dev, addr, reg, &val);
126 EXPORT_SYMBOL_GPL(ksz_phy_read16);
128 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val)
130 struct ksz_device *dev = ds->priv;
132 dev->dev_ops->w_phy(dev, addr, reg, val);
136 EXPORT_SYMBOL_GPL(ksz_phy_write16);
138 void ksz_mac_link_down(struct dsa_switch *ds, int port, unsigned int mode,
139 phy_interface_t interface)
141 struct ksz_device *dev = ds->priv;
142 struct ksz_port *p = &dev->ports[port];
144 /* Read all MIB counters when the link is going down. */
146 schedule_delayed_work(&dev->mib_read, 0);
148 EXPORT_SYMBOL_GPL(ksz_mac_link_down);
150 int ksz_sset_count(struct dsa_switch *ds, int port, int sset)
152 struct ksz_device *dev = ds->priv;
154 if (sset != ETH_SS_STATS)
159 EXPORT_SYMBOL_GPL(ksz_sset_count);
161 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf)
163 const struct dsa_port *dp = dsa_to_port(ds, port);
164 struct ksz_device *dev = ds->priv;
165 struct ksz_port_mib *mib;
167 mib = &dev->ports[port].mib;
168 mutex_lock(&mib->cnt_mutex);
170 /* Only read dropped counters if no link. */
171 if (!netif_carrier_ok(dp->slave))
172 mib->cnt_ptr = dev->reg_mib_cnt;
173 port_r_cnt(dev, port);
174 memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64));
175 mutex_unlock(&mib->cnt_mutex);
177 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats);
179 int ksz_port_bridge_join(struct dsa_switch *ds, int port,
180 struct net_device *br)
182 struct ksz_device *dev = ds->priv;
184 mutex_lock(&dev->dev_mutex);
185 dev->br_member |= (1 << port);
186 mutex_unlock(&dev->dev_mutex);
188 /* port_stp_state_set() will be called after to put the port in
189 * appropriate state so there is no need to do anything.
194 EXPORT_SYMBOL_GPL(ksz_port_bridge_join);
196 void ksz_port_bridge_leave(struct dsa_switch *ds, int port,
197 struct net_device *br)
199 struct ksz_device *dev = ds->priv;
201 mutex_lock(&dev->dev_mutex);
202 dev->br_member &= ~(1 << port);
203 dev->member &= ~(1 << port);
204 mutex_unlock(&dev->dev_mutex);
206 /* port_stp_state_set() will be called after to put the port in
207 * forwarding state so there is no need to do anything.
210 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave);
212 void ksz_port_fast_age(struct dsa_switch *ds, int port)
214 struct ksz_device *dev = ds->priv;
216 dev->dev_ops->flush_dyn_mac_table(dev, port);
218 EXPORT_SYMBOL_GPL(ksz_port_fast_age);
220 int ksz_port_vlan_prepare(struct dsa_switch *ds, int port,
221 const struct switchdev_obj_port_vlan *vlan)
227 EXPORT_SYMBOL_GPL(ksz_port_vlan_prepare);
229 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb,
232 struct ksz_device *dev = ds->priv;
239 struct alu_struct alu;
242 alu.is_static = false;
243 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid,
246 if (!ret && (member & BIT(port))) {
247 ret = cb(alu.mac, alu.fid, alu.is_static, data);
252 } while (i < entries);
258 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
260 int ksz_port_mdb_prepare(struct dsa_switch *ds, int port,
261 const struct switchdev_obj_port_mdb *mdb)
266 EXPORT_SYMBOL_GPL(ksz_port_mdb_prepare);
268 void ksz_port_mdb_add(struct dsa_switch *ds, int port,
269 const struct switchdev_obj_port_mdb *mdb)
271 struct ksz_device *dev = ds->priv;
272 struct alu_struct alu;
276 alu.port_forward = 0;
277 for (index = 0; index < dev->num_statics; index++) {
278 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
279 /* Found one already in static MAC table. */
280 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
283 /* Remember the first empty entry. */
289 /* no available entry */
290 if (index == dev->num_statics && !empty)
294 if (index == dev->num_statics) {
296 memset(&alu, 0, sizeof(alu));
297 memcpy(alu.mac, mdb->addr, ETH_ALEN);
298 alu.is_static = true;
300 alu.port_forward |= BIT(port);
302 alu.is_use_fid = true;
304 /* Need a way to map VID to FID. */
307 dev->dev_ops->w_sta_mac_table(dev, index, &alu);
309 EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
311 int ksz_port_mdb_del(struct dsa_switch *ds, int port,
312 const struct switchdev_obj_port_mdb *mdb)
314 struct ksz_device *dev = ds->priv;
315 struct alu_struct alu;
319 for (index = 0; index < dev->num_statics; index++) {
320 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
321 /* Found one already in static MAC table. */
322 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
328 /* no available entry */
329 if (index == dev->num_statics)
333 alu.port_forward &= ~BIT(port);
334 if (!alu.port_forward)
335 alu.is_static = false;
336 dev->dev_ops->w_sta_mac_table(dev, index, &alu);
341 EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
343 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
345 struct ksz_device *dev = ds->priv;
347 if (!dsa_is_user_port(ds, port))
350 /* setup slave port */
351 dev->dev_ops->port_setup(dev, port, false);
353 /* port_stp_state_set() will be called after to enable the port so
354 * there is no need to do anything.
359 EXPORT_SYMBOL_GPL(ksz_enable_port);
361 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv)
363 struct dsa_switch *ds;
364 struct ksz_device *swdev;
366 ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
371 ds->num_ports = DSA_MAX_PORTS;
373 swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
385 EXPORT_SYMBOL(ksz_switch_alloc);
387 int ksz_switch_register(struct ksz_device *dev,
388 const struct ksz_dev_ops *ops)
390 struct device_node *port, *ports;
391 phy_interface_t interface;
392 unsigned int port_num;
396 dev->chip_id = dev->pdata->chip_id;
398 dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset",
400 if (IS_ERR(dev->reset_gpio))
401 return PTR_ERR(dev->reset_gpio);
403 if (dev->reset_gpio) {
404 gpiod_set_value_cansleep(dev->reset_gpio, 1);
405 usleep_range(10000, 12000);
406 gpiod_set_value_cansleep(dev->reset_gpio, 0);
407 usleep_range(100, 1000);
410 mutex_init(&dev->dev_mutex);
411 mutex_init(&dev->regmap_mutex);
412 mutex_init(&dev->alu_mutex);
413 mutex_init(&dev->vlan_mutex);
417 if (dev->dev_ops->detect(dev))
420 ret = dev->dev_ops->init(dev);
424 /* Host port interface will be self detected, or specifically set in
427 for (port_num = 0; port_num < dev->port_cnt; ++port_num)
428 dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA;
429 if (dev->dev->of_node) {
430 ret = of_get_phy_mode(dev->dev->of_node, &interface);
432 dev->compat_interface = interface;
433 ports = of_get_child_by_name(dev->dev->of_node, "ports");
435 for_each_available_child_of_node(ports, port) {
436 if (of_property_read_u32(port, "reg",
439 if (port_num >= dev->port_cnt)
441 of_get_phy_mode(port,
442 &dev->ports[port_num].interface);
444 dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
445 "microchip,synclko-125");
448 ret = dsa_register_switch(dev->ds);
450 dev->dev_ops->exit(dev);
456 EXPORT_SYMBOL(ksz_switch_register);
458 void ksz_switch_remove(struct ksz_device *dev)
461 if (dev->mib_read_interval)
462 cancel_delayed_work_sync(&dev->mib_read);
464 dev->dev_ops->exit(dev);
465 dsa_unregister_switch(dev->ds);
468 gpiod_set_value_cansleep(dev->reset_gpio, 1);
471 EXPORT_SYMBOL(ksz_switch_remove);
473 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
474 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
475 MODULE_LICENSE("GPL");