xref: /openbmc/linux/net/dsa/master.c (revision 0a671dc5)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /*
3   * Handling of a master device, switching frames via its switch fabric CPU port
4   *
5   * Copyright (c) 2017 Savoir-faire Linux Inc.
6   *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7   */
8  
9  #include "dsa_priv.h"
10  
11  static int dsa_master_get_regs_len(struct net_device *dev)
12  {
13  	struct dsa_port *cpu_dp = dev->dsa_ptr;
14  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
15  	struct dsa_switch *ds = cpu_dp->ds;
16  	int port = cpu_dp->index;
17  	int ret = 0;
18  	int len;
19  
20  	if (ops->get_regs_len) {
21  		len = ops->get_regs_len(dev);
22  		if (len < 0)
23  			return len;
24  		ret += len;
25  	}
26  
27  	ret += sizeof(struct ethtool_drvinfo);
28  	ret += sizeof(struct ethtool_regs);
29  
30  	if (ds->ops->get_regs_len) {
31  		len = ds->ops->get_regs_len(ds, port);
32  		if (len < 0)
33  			return len;
34  		ret += len;
35  	}
36  
37  	return ret;
38  }
39  
40  static void dsa_master_get_regs(struct net_device *dev,
41  				struct ethtool_regs *regs, void *data)
42  {
43  	struct dsa_port *cpu_dp = dev->dsa_ptr;
44  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
45  	struct dsa_switch *ds = cpu_dp->ds;
46  	struct ethtool_drvinfo *cpu_info;
47  	struct ethtool_regs *cpu_regs;
48  	int port = cpu_dp->index;
49  	int len;
50  
51  	if (ops->get_regs_len && ops->get_regs) {
52  		len = ops->get_regs_len(dev);
53  		if (len < 0)
54  			return;
55  		regs->len = len;
56  		ops->get_regs(dev, regs, data);
57  		data += regs->len;
58  	}
59  
60  	cpu_info = (struct ethtool_drvinfo *)data;
61  	strlcpy(cpu_info->driver, "dsa", sizeof(cpu_info->driver));
62  	data += sizeof(*cpu_info);
63  	cpu_regs = (struct ethtool_regs *)data;
64  	data += sizeof(*cpu_regs);
65  
66  	if (ds->ops->get_regs_len && ds->ops->get_regs) {
67  		len = ds->ops->get_regs_len(ds, port);
68  		if (len < 0)
69  			return;
70  		cpu_regs->len = len;
71  		ds->ops->get_regs(ds, port, cpu_regs, data);
72  	}
73  }
74  
75  static void dsa_master_get_ethtool_stats(struct net_device *dev,
76  					 struct ethtool_stats *stats,
77  					 uint64_t *data)
78  {
79  	struct dsa_port *cpu_dp = dev->dsa_ptr;
80  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
81  	struct dsa_switch *ds = cpu_dp->ds;
82  	int port = cpu_dp->index;
83  	int count = 0;
84  
85  	if (ops->get_sset_count && ops->get_ethtool_stats) {
86  		count = ops->get_sset_count(dev, ETH_SS_STATS);
87  		ops->get_ethtool_stats(dev, stats, data);
88  	}
89  
90  	if (ds->ops->get_ethtool_stats)
91  		ds->ops->get_ethtool_stats(ds, port, data + count);
92  }
93  
94  static void dsa_master_get_ethtool_phy_stats(struct net_device *dev,
95  					     struct ethtool_stats *stats,
96  					     uint64_t *data)
97  {
98  	struct dsa_port *cpu_dp = dev->dsa_ptr;
99  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
100  	struct dsa_switch *ds = cpu_dp->ds;
101  	int port = cpu_dp->index;
102  	int count = 0;
103  
104  	if (dev->phydev && !ops->get_ethtool_phy_stats) {
105  		count = phy_ethtool_get_sset_count(dev->phydev);
106  		if (count >= 0)
107  			phy_ethtool_get_stats(dev->phydev, stats, data);
108  	} else if (ops->get_sset_count && ops->get_ethtool_phy_stats) {
109  		count = ops->get_sset_count(dev, ETH_SS_PHY_STATS);
110  		ops->get_ethtool_phy_stats(dev, stats, data);
111  	}
112  
113  	if (count < 0)
114  		count = 0;
115  
116  	if (ds->ops->get_ethtool_phy_stats)
117  		ds->ops->get_ethtool_phy_stats(ds, port, data + count);
118  }
119  
120  static int dsa_master_get_sset_count(struct net_device *dev, int sset)
121  {
122  	struct dsa_port *cpu_dp = dev->dsa_ptr;
123  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
124  	struct dsa_switch *ds = cpu_dp->ds;
125  	int count = 0;
126  
127  	if (sset == ETH_SS_PHY_STATS && dev->phydev &&
128  	    !ops->get_ethtool_phy_stats)
129  		count = phy_ethtool_get_sset_count(dev->phydev);
130  	else if (ops->get_sset_count)
131  		count = ops->get_sset_count(dev, sset);
132  
133  	if (count < 0)
134  		count = 0;
135  
136  	if (ds->ops->get_sset_count)
137  		count += ds->ops->get_sset_count(ds, cpu_dp->index, sset);
138  
139  	return count;
140  }
141  
142  static void dsa_master_get_strings(struct net_device *dev, uint32_t stringset,
143  				   uint8_t *data)
144  {
145  	struct dsa_port *cpu_dp = dev->dsa_ptr;
146  	const struct ethtool_ops *ops = cpu_dp->orig_ethtool_ops;
147  	struct dsa_switch *ds = cpu_dp->ds;
148  	int port = cpu_dp->index;
149  	int len = ETH_GSTRING_LEN;
150  	int mcount = 0, count;
151  	unsigned int i;
152  	uint8_t pfx[4];
153  	uint8_t *ndata;
154  
155  	snprintf(pfx, sizeof(pfx), "p%.2d", port);
156  	/* We do not want to be NULL-terminated, since this is a prefix */
157  	pfx[sizeof(pfx) - 1] = '_';
158  
159  	if (stringset == ETH_SS_PHY_STATS && dev->phydev &&
160  	    !ops->get_ethtool_phy_stats) {
161  		mcount = phy_ethtool_get_sset_count(dev->phydev);
162  		if (mcount < 0)
163  			mcount = 0;
164  		else
165  			phy_ethtool_get_strings(dev->phydev, data);
166  	} else if (ops->get_sset_count && ops->get_strings) {
167  		mcount = ops->get_sset_count(dev, stringset);
168  		if (mcount < 0)
169  			mcount = 0;
170  		ops->get_strings(dev, stringset, data);
171  	}
172  
173  	if (ds->ops->get_strings) {
174  		ndata = data + mcount * len;
175  		/* This function copies ETH_GSTRINGS_LEN bytes, we will mangle
176  		 * the output after to prepend our CPU port prefix we
177  		 * constructed earlier
178  		 */
179  		ds->ops->get_strings(ds, port, stringset, ndata);
180  		count = ds->ops->get_sset_count(ds, port, stringset);
181  		for (i = 0; i < count; i++) {
182  			memmove(ndata + (i * len + sizeof(pfx)),
183  				ndata + i * len, len - sizeof(pfx));
184  			memcpy(ndata + i * len, pfx, sizeof(pfx));
185  		}
186  	}
187  }
188  
189  static int dsa_master_get_phys_port_name(struct net_device *dev,
190  					 char *name, size_t len)
191  {
192  	struct dsa_port *cpu_dp = dev->dsa_ptr;
193  
194  	if (snprintf(name, len, "p%d", cpu_dp->index) >= len)
195  		return -EINVAL;
196  
197  	return 0;
198  }
199  
200  static int dsa_master_ethtool_setup(struct net_device *dev)
201  {
202  	struct dsa_port *cpu_dp = dev->dsa_ptr;
203  	struct dsa_switch *ds = cpu_dp->ds;
204  	struct ethtool_ops *ops;
205  
206  	ops = devm_kzalloc(ds->dev, sizeof(*ops), GFP_KERNEL);
207  	if (!ops)
208  		return -ENOMEM;
209  
210  	cpu_dp->orig_ethtool_ops = dev->ethtool_ops;
211  	if (cpu_dp->orig_ethtool_ops)
212  		memcpy(ops, cpu_dp->orig_ethtool_ops, sizeof(*ops));
213  
214  	ops->get_regs_len = dsa_master_get_regs_len;
215  	ops->get_regs = dsa_master_get_regs;
216  	ops->get_sset_count = dsa_master_get_sset_count;
217  	ops->get_ethtool_stats = dsa_master_get_ethtool_stats;
218  	ops->get_strings = dsa_master_get_strings;
219  	ops->get_ethtool_phy_stats = dsa_master_get_ethtool_phy_stats;
220  
221  	dev->ethtool_ops = ops;
222  
223  	return 0;
224  }
225  
226  static void dsa_master_ethtool_teardown(struct net_device *dev)
227  {
228  	struct dsa_port *cpu_dp = dev->dsa_ptr;
229  
230  	dev->ethtool_ops = cpu_dp->orig_ethtool_ops;
231  	cpu_dp->orig_ethtool_ops = NULL;
232  }
233  
234  static int dsa_master_ndo_setup(struct net_device *dev)
235  {
236  	struct dsa_port *cpu_dp = dev->dsa_ptr;
237  	struct dsa_switch *ds = cpu_dp->ds;
238  	struct net_device_ops *ops;
239  
240  	if (dev->netdev_ops->ndo_get_phys_port_name)
241  		return 0;
242  
243  	ops = devm_kzalloc(ds->dev, sizeof(*ops), GFP_KERNEL);
244  	if (!ops)
245  		return -ENOMEM;
246  
247  	cpu_dp->orig_ndo_ops = dev->netdev_ops;
248  	if (cpu_dp->orig_ndo_ops)
249  		memcpy(ops, cpu_dp->orig_ndo_ops, sizeof(*ops));
250  
251  	ops->ndo_get_phys_port_name = dsa_master_get_phys_port_name;
252  
253  	dev->netdev_ops  = ops;
254  
255  	return 0;
256  }
257  
258  static void dsa_master_ndo_teardown(struct net_device *dev)
259  {
260  	struct dsa_port *cpu_dp = dev->dsa_ptr;
261  
262  	dev->netdev_ops = cpu_dp->orig_ndo_ops;
263  	cpu_dp->orig_ndo_ops = NULL;
264  }
265  
266  static ssize_t tagging_show(struct device *d, struct device_attribute *attr,
267  			    char *buf)
268  {
269  	struct net_device *dev = to_net_dev(d);
270  	struct dsa_port *cpu_dp = dev->dsa_ptr;
271  
272  	return sprintf(buf, "%s\n",
273  		       dsa_tag_protocol_to_str(cpu_dp->tag_ops));
274  }
275  static DEVICE_ATTR_RO(tagging);
276  
277  static struct attribute *dsa_slave_attrs[] = {
278  	&dev_attr_tagging.attr,
279  	NULL
280  };
281  
282  static const struct attribute_group dsa_group = {
283  	.name	= "dsa",
284  	.attrs	= dsa_slave_attrs,
285  };
286  
287  static void dsa_master_set_mtu(struct net_device *dev, struct dsa_port *cpu_dp)
288  {
289  	unsigned int mtu = ETH_DATA_LEN + cpu_dp->tag_ops->overhead;
290  	int err;
291  
292  	rtnl_lock();
293  	if (mtu <= dev->max_mtu) {
294  		err = dev_set_mtu(dev, mtu);
295  		if (err)
296  			netdev_dbg(dev, "Unable to set MTU to include for DSA overheads\n");
297  	}
298  	rtnl_unlock();
299  }
300  
301  static void dsa_master_reset_mtu(struct net_device *dev)
302  {
303  	int err;
304  
305  	rtnl_lock();
306  	err = dev_set_mtu(dev, ETH_DATA_LEN);
307  	if (err)
308  		netdev_dbg(dev,
309  			   "Unable to reset MTU to exclude DSA overheads\n");
310  	rtnl_unlock();
311  }
312  
313  static struct lock_class_key dsa_master_addr_list_lock_key;
314  
315  int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp)
316  {
317  	int ret;
318  
319  	dsa_master_set_mtu(dev,  cpu_dp);
320  
321  	/* If we use a tagging format that doesn't have an ethertype
322  	 * field, make sure that all packets from this point on get
323  	 * sent to the tag format's receive function.
324  	 */
325  	wmb();
326  
327  	dev->dsa_ptr = cpu_dp;
328  	lockdep_set_class(&dev->addr_list_lock,
329  			  &dsa_master_addr_list_lock_key);
330  
331  	ret = dsa_master_ethtool_setup(dev);
332  	if (ret)
333  		return ret;
334  
335  	ret = dsa_master_ndo_setup(dev);
336  	if (ret)
337  		goto out_err_ethtool_teardown;
338  
339  	ret = sysfs_create_group(&dev->dev.kobj, &dsa_group);
340  	if (ret)
341  		goto out_err_ndo_teardown;
342  
343  	return ret;
344  
345  out_err_ndo_teardown:
346  	dsa_master_ndo_teardown(dev);
347  out_err_ethtool_teardown:
348  	dsa_master_ethtool_teardown(dev);
349  	return ret;
350  }
351  
352  void dsa_master_teardown(struct net_device *dev)
353  {
354  	sysfs_remove_group(&dev->dev.kobj, &dsa_group);
355  	dsa_master_ndo_teardown(dev);
356  	dsa_master_ethtool_teardown(dev);
357  	dsa_master_reset_mtu(dev);
358  
359  	dev->dsa_ptr = NULL;
360  
361  	/* If we used a tagging format that doesn't have an ethertype
362  	 * field, make sure that all packets from this point get sent
363  	 * without the tag and go through the regular receive path.
364  	 */
365  	wmb();
366  }
367