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