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
ksz_update_port_member(struct ksz_device * dev,int port)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
port_r_cnt(struct ksz_device * dev,int port)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
ksz_mib_read_work(struct work_struct * work)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.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
ksz_init_mib_timer(struct ksz_device * dev)100 void 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 }
109 EXPORT_SYMBOL_GPL(ksz_init_mib_timer);
110
ksz_phy_read16(struct dsa_switch * ds,int addr,int reg)111 int 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 }
120 EXPORT_SYMBOL_GPL(ksz_phy_read16);
121
ksz_phy_write16(struct dsa_switch * ds,int addr,int reg,u16 val)122 int 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 }
130 EXPORT_SYMBOL_GPL(ksz_phy_write16);
131
ksz_mac_link_down(struct dsa_switch * ds,int port,unsigned int mode,phy_interface_t interface)132 void 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 }
144 EXPORT_SYMBOL_GPL(ksz_mac_link_down);
145
ksz_sset_count(struct dsa_switch * ds,int port,int sset)146 int 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 }
155 EXPORT_SYMBOL_GPL(ksz_sset_count);
156
ksz_get_ethtool_stats(struct dsa_switch * ds,int port,uint64_t * buf)157 void 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 }
173 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats);
174
ksz_port_bridge_join(struct dsa_switch * ds,int port,struct net_device * br)175 int 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 }
190 EXPORT_SYMBOL_GPL(ksz_port_bridge_join);
191
ksz_port_bridge_leave(struct dsa_switch * ds,int port,struct net_device * br)192 void 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 }
206 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave);
207
ksz_port_fast_age(struct dsa_switch * ds,int port)208 void 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 }
214 EXPORT_SYMBOL_GPL(ksz_port_fast_age);
215
ksz_port_fdb_dump(struct dsa_switch * ds,int port,dsa_fdb_dump_cb_t * cb,void * data)216 int 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, ×tamp,
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 }
245 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
246
ksz_port_mdb_add(struct dsa_switch * ds,int port,const struct switchdev_obj_port_mdb * mdb)247 int 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 }
290 EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
291
ksz_port_mdb_del(struct dsa_switch * ds,int port,const struct switchdev_obj_port_mdb * mdb)292 int 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
319 exit:
320 return ret;
321 }
322 EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
323
ksz_enable_port(struct dsa_switch * ds,int port,struct phy_device * phy)324 int 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 }
340 EXPORT_SYMBOL_GPL(ksz_enable_port);
341
ksz_switch_alloc(struct device * base,void * priv)342 struct 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 }
366 EXPORT_SYMBOL(ksz_switch_alloc);
367
ksz_switch_register(struct ksz_device * dev,const struct ksz_dev_ops * ops)368 int 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 of_node_put(ports);
425 return -EINVAL;
426 }
427 of_get_phy_mode(port,
428 &dev->ports[port_num].interface);
429 }
430 of_node_put(ports);
431 }
432 dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
433 "microchip,synclko-125");
434 }
435
436 ret = dsa_register_switch(dev->ds);
437 if (ret) {
438 dev->dev_ops->exit(dev);
439 return ret;
440 }
441
442 /* Read MIB counters every 30 seconds to avoid overflow. */
443 dev->mib_read_interval = msecs_to_jiffies(30000);
444
445 /* Start the MIB timer. */
446 schedule_delayed_work(&dev->mib_read, 0);
447
448 return 0;
449 }
450 EXPORT_SYMBOL(ksz_switch_register);
451
ksz_switch_remove(struct ksz_device * dev)452 void ksz_switch_remove(struct ksz_device *dev)
453 {
454 /* timer started */
455 if (dev->mib_read_interval) {
456 dev->mib_read_interval = 0;
457 cancel_delayed_work_sync(&dev->mib_read);
458 }
459
460 dev->dev_ops->exit(dev);
461 dsa_unregister_switch(dev->ds);
462
463 if (dev->reset_gpio)
464 gpiod_set_value_cansleep(dev->reset_gpio, 1);
465
466 }
467 EXPORT_SYMBOL(ksz_switch_remove);
468
469 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
470 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
471 MODULE_LICENSE("GPL");
472