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