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