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->mib_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->mib_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_vlan_prepare(struct dsa_switch *ds, int port,
217			  const struct switchdev_obj_port_vlan *vlan)
218{
219	/* nothing needed */
220
221	return 0;
222}
223EXPORT_SYMBOL_GPL(ksz_port_vlan_prepare);
224
225int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb,
226		      void *data)
227{
228	struct ksz_device *dev = ds->priv;
229	int ret = 0;
230	u16 i = 0;
231	u16 entries = 0;
232	u8 timestamp = 0;
233	u8 fid;
234	u8 member;
235	struct alu_struct alu;
236
237	do {
238		alu.is_static = false;
239		ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid,
240						    &member, &timestamp,
241						    &entries);
242		if (!ret && (member & BIT(port))) {
243			ret = cb(alu.mac, alu.fid, alu.is_static, data);
244			if (ret)
245				break;
246		}
247		i++;
248	} while (i < entries);
249	if (i >= entries)
250		ret = 0;
251
252	return ret;
253}
254EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
255
256int ksz_port_mdb_prepare(struct dsa_switch *ds, int port,
257			 const struct switchdev_obj_port_mdb *mdb)
258{
259	/* nothing to do */
260	return 0;
261}
262EXPORT_SYMBOL_GPL(ksz_port_mdb_prepare);
263
264void ksz_port_mdb_add(struct dsa_switch *ds, int port,
265		      const struct switchdev_obj_port_mdb *mdb)
266{
267	struct ksz_device *dev = ds->priv;
268	struct alu_struct alu;
269	int index;
270	int empty = 0;
271
272	alu.port_forward = 0;
273	for (index = 0; index < dev->num_statics; index++) {
274		if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
275			/* Found one already in static MAC table. */
276			if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
277			    alu.fid == mdb->vid)
278				break;
279		/* Remember the first empty entry. */
280		} else if (!empty) {
281			empty = index + 1;
282		}
283	}
284
285	/* no available entry */
286	if (index == dev->num_statics && !empty)
287		return;
288
289	/* add entry */
290	if (index == dev->num_statics) {
291		index = empty - 1;
292		memset(&alu, 0, sizeof(alu));
293		memcpy(alu.mac, mdb->addr, ETH_ALEN);
294		alu.is_static = true;
295	}
296	alu.port_forward |= BIT(port);
297	if (mdb->vid) {
298		alu.is_use_fid = true;
299
300		/* Need a way to map VID to FID. */
301		alu.fid = mdb->vid;
302	}
303	dev->dev_ops->w_sta_mac_table(dev, index, &alu);
304}
305EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
306
307int ksz_port_mdb_del(struct dsa_switch *ds, int port,
308		     const struct switchdev_obj_port_mdb *mdb)
309{
310	struct ksz_device *dev = ds->priv;
311	struct alu_struct alu;
312	int index;
313	int ret = 0;
314
315	for (index = 0; index < dev->num_statics; index++) {
316		if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
317			/* Found one already in static MAC table. */
318			if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
319			    alu.fid == mdb->vid)
320				break;
321		}
322	}
323
324	/* no available entry */
325	if (index == dev->num_statics)
326		goto exit;
327
328	/* clear port */
329	alu.port_forward &= ~BIT(port);
330	if (!alu.port_forward)
331		alu.is_static = false;
332	dev->dev_ops->w_sta_mac_table(dev, index, &alu);
333
334exit:
335	return ret;
336}
337EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
338
339int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
340{
341	struct ksz_device *dev = ds->priv;
342
343	if (!dsa_is_user_port(ds, port))
344		return 0;
345
346	/* setup slave port */
347	dev->dev_ops->port_setup(dev, port, false);
348
349	/* port_stp_state_set() will be called after to enable the port so
350	 * there is no need to do anything.
351	 */
352
353	return 0;
354}
355EXPORT_SYMBOL_GPL(ksz_enable_port);
356
357struct ksz_device *ksz_switch_alloc(struct device *base, void *priv)
358{
359	struct dsa_switch *ds;
360	struct ksz_device *swdev;
361
362	ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
363	if (!ds)
364		return NULL;
365
366	ds->dev = base;
367	ds->num_ports = DSA_MAX_PORTS;
368
369	swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
370	if (!swdev)
371		return NULL;
372
373	ds->priv = swdev;
374	swdev->dev = base;
375
376	swdev->ds = ds;
377	swdev->priv = priv;
378
379	return swdev;
380}
381EXPORT_SYMBOL(ksz_switch_alloc);
382
383int ksz_switch_register(struct ksz_device *dev,
384			const struct ksz_dev_ops *ops)
385{
386	struct device_node *port, *ports;
387	phy_interface_t interface;
388	unsigned int port_num;
389	int ret;
390
391	if (dev->pdata)
392		dev->chip_id = dev->pdata->chip_id;
393
394	dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset",
395						  GPIOD_OUT_LOW);
396	if (IS_ERR(dev->reset_gpio))
397		return PTR_ERR(dev->reset_gpio);
398
399	if (dev->reset_gpio) {
400		gpiod_set_value_cansleep(dev->reset_gpio, 1);
401		usleep_range(10000, 12000);
402		gpiod_set_value_cansleep(dev->reset_gpio, 0);
403		msleep(100);
404	}
405
406	mutex_init(&dev->dev_mutex);
407	mutex_init(&dev->regmap_mutex);
408	mutex_init(&dev->alu_mutex);
409	mutex_init(&dev->vlan_mutex);
410
411	dev->dev_ops = ops;
412
413	if (dev->dev_ops->detect(dev))
414		return -EINVAL;
415
416	ret = dev->dev_ops->init(dev);
417	if (ret)
418		return ret;
419
420	/* Host port interface will be self detected, or specifically set in
421	 * device tree.
422	 */
423	for (port_num = 0; port_num < dev->port_cnt; ++port_num)
424		dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA;
425	if (dev->dev->of_node) {
426		ret = of_get_phy_mode(dev->dev->of_node, &interface);
427		if (ret == 0)
428			dev->compat_interface = interface;
429		ports = of_get_child_by_name(dev->dev->of_node, "ports");
430		if (ports)
431			for_each_available_child_of_node(ports, port) {
432				if (of_property_read_u32(port, "reg",
433							 &port_num))
434					continue;
435				if (port_num >= dev->mib_port_cnt)
436					return -EINVAL;
437				of_get_phy_mode(port,
438						&dev->ports[port_num].interface);
439			}
440		dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
441							 "microchip,synclko-125");
442	}
443
444	ret = dsa_register_switch(dev->ds);
445	if (ret) {
446		dev->dev_ops->exit(dev);
447		return ret;
448	}
449
450	/* Read MIB counters every 30 seconds to avoid overflow. */
451	dev->mib_read_interval = msecs_to_jiffies(30000);
452
453	/* Start the MIB timer. */
454	schedule_delayed_work(&dev->mib_read, 0);
455
456	return 0;
457}
458EXPORT_SYMBOL(ksz_switch_register);
459
460void ksz_switch_remove(struct ksz_device *dev)
461{
462	/* timer started */
463	if (dev->mib_read_interval) {
464		dev->mib_read_interval = 0;
465		cancel_delayed_work_sync(&dev->mib_read);
466	}
467
468	dev->dev_ops->exit(dev);
469	dsa_unregister_switch(dev->ds);
470
471	if (dev->reset_gpio)
472		gpiod_set_value_cansleep(dev->reset_gpio, 1);
473
474}
475EXPORT_SYMBOL(ksz_switch_remove);
476
477MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
478MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
479MODULE_LICENSE("GPL");
480