sxgbe_ethtool.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/* 10G controller driver for Samsung SoCs
  3 *
  4 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
  5 *		http://www.samsung.com
  6 *
  7 * Author: Siva Reddy Kallam <siva.kallam@samsung.com>
  8 */
  9
 10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 11
 12#include <linux/clk.h>
 13#include <linux/interrupt.h>
 14#include <linux/kernel.h>
 15#include <linux/netdevice.h>
 16#include <linux/net_tstamp.h>
 17#include <linux/phy.h>
 18#include <linux/ptp_clock_kernel.h>
 19
 20#include "sxgbe_common.h"
 21#include "sxgbe_reg.h"
 22#include "sxgbe_dma.h"
 23
 24struct sxgbe_stats {
 25	char stat_string[ETH_GSTRING_LEN];
 26	int sizeof_stat;
 27	int stat_offset;
 28};
 29
 30#define SXGBE_STAT(m)						\
 31{								\
 32	#m,							\
 33	sizeof_field(struct sxgbe_extra_stats, m),		\
 34	offsetof(struct sxgbe_priv_data, xstats.m)		\
 35}
 36
 37static const struct sxgbe_stats sxgbe_gstrings_stats[] = {
 38	/* TX/RX IRQ events */
 39	SXGBE_STAT(tx_process_stopped_irq),
 40	SXGBE_STAT(tx_ctxt_desc_err),
 41	SXGBE_STAT(tx_threshold),
 42	SXGBE_STAT(rx_threshold),
 43	SXGBE_STAT(tx_pkt_n),
 44	SXGBE_STAT(rx_pkt_n),
 45	SXGBE_STAT(normal_irq_n),
 46	SXGBE_STAT(tx_normal_irq_n),
 47	SXGBE_STAT(rx_normal_irq_n),
 48	SXGBE_STAT(napi_poll),
 49	SXGBE_STAT(tx_clean),
 50	SXGBE_STAT(tx_reset_ic_bit),
 51	SXGBE_STAT(rx_process_stopped_irq),
 52	SXGBE_STAT(rx_underflow_irq),
 53
 54	/* Bus access errors */
 55	SXGBE_STAT(fatal_bus_error_irq),
 56	SXGBE_STAT(tx_read_transfer_err),
 57	SXGBE_STAT(tx_write_transfer_err),
 58	SXGBE_STAT(tx_desc_access_err),
 59	SXGBE_STAT(tx_buffer_access_err),
 60	SXGBE_STAT(tx_data_transfer_err),
 61	SXGBE_STAT(rx_read_transfer_err),
 62	SXGBE_STAT(rx_write_transfer_err),
 63	SXGBE_STAT(rx_desc_access_err),
 64	SXGBE_STAT(rx_buffer_access_err),
 65	SXGBE_STAT(rx_data_transfer_err),
 66
 67	/* EEE-LPI stats */
 68	SXGBE_STAT(tx_lpi_entry_n),
 69	SXGBE_STAT(tx_lpi_exit_n),
 70	SXGBE_STAT(rx_lpi_entry_n),
 71	SXGBE_STAT(rx_lpi_exit_n),
 72	SXGBE_STAT(eee_wakeup_error_n),
 73
 74	/* RX specific */
 75	/* L2 error */
 76	SXGBE_STAT(rx_code_gmii_err),
 77	SXGBE_STAT(rx_watchdog_err),
 78	SXGBE_STAT(rx_crc_err),
 79	SXGBE_STAT(rx_gaint_pkt_err),
 80	SXGBE_STAT(ip_hdr_err),
 81	SXGBE_STAT(ip_payload_err),
 82	SXGBE_STAT(overflow_error),
 83
 84	/* L2 Pkt type */
 85	SXGBE_STAT(len_pkt),
 86	SXGBE_STAT(mac_ctl_pkt),
 87	SXGBE_STAT(dcb_ctl_pkt),
 88	SXGBE_STAT(arp_pkt),
 89	SXGBE_STAT(oam_pkt),
 90	SXGBE_STAT(untag_okt),
 91	SXGBE_STAT(other_pkt),
 92	SXGBE_STAT(svlan_tag_pkt),
 93	SXGBE_STAT(cvlan_tag_pkt),
 94	SXGBE_STAT(dvlan_ocvlan_icvlan_pkt),
 95	SXGBE_STAT(dvlan_osvlan_isvlan_pkt),
 96	SXGBE_STAT(dvlan_osvlan_icvlan_pkt),
 97	SXGBE_STAT(dvan_ocvlan_icvlan_pkt),
 98
 99	/* L3/L4 Pkt type */
100	SXGBE_STAT(not_ip_pkt),
101	SXGBE_STAT(ip4_tcp_pkt),
102	SXGBE_STAT(ip4_udp_pkt),
103	SXGBE_STAT(ip4_icmp_pkt),
104	SXGBE_STAT(ip4_unknown_pkt),
105	SXGBE_STAT(ip6_tcp_pkt),
106	SXGBE_STAT(ip6_udp_pkt),
107	SXGBE_STAT(ip6_icmp_pkt),
108	SXGBE_STAT(ip6_unknown_pkt),
109
110	/* Filter specific */
111	SXGBE_STAT(vlan_filter_match),
112	SXGBE_STAT(sa_filter_fail),
113	SXGBE_STAT(da_filter_fail),
114	SXGBE_STAT(hash_filter_pass),
115	SXGBE_STAT(l3_filter_match),
116	SXGBE_STAT(l4_filter_match),
117
118	/* RX context specific */
119	SXGBE_STAT(timestamp_dropped),
120	SXGBE_STAT(rx_msg_type_no_ptp),
121	SXGBE_STAT(rx_ptp_type_sync),
122	SXGBE_STAT(rx_ptp_type_follow_up),
123	SXGBE_STAT(rx_ptp_type_delay_req),
124	SXGBE_STAT(rx_ptp_type_delay_resp),
125	SXGBE_STAT(rx_ptp_type_pdelay_req),
126	SXGBE_STAT(rx_ptp_type_pdelay_resp),
127	SXGBE_STAT(rx_ptp_type_pdelay_follow_up),
128	SXGBE_STAT(rx_ptp_announce),
129	SXGBE_STAT(rx_ptp_mgmt),
130	SXGBE_STAT(rx_ptp_signal),
131	SXGBE_STAT(rx_ptp_resv_msg_type),
132};
133#define SXGBE_STATS_LEN ARRAY_SIZE(sxgbe_gstrings_stats)
134
135static int sxgbe_get_eee(struct net_device *dev,
136			 struct ethtool_keee *edata)
137{
138	struct sxgbe_priv_data *priv = netdev_priv(dev);
139
140	if (!priv->hw_cap.eee)
141		return -EOPNOTSUPP;
142
143	edata->tx_lpi_timer = priv->tx_lpi_timer;
144
145	return phy_ethtool_get_eee(dev->phydev, edata);
146}
147
148static int sxgbe_set_eee(struct net_device *dev,
149			 struct ethtool_keee *edata)
150{
151	struct sxgbe_priv_data *priv = netdev_priv(dev);
152
153	priv->eee_enabled = edata->eee_enabled;
154
155	if (!priv->eee_enabled) {
156		sxgbe_disable_eee_mode(priv);
157	} else {
158		/* We are asking for enabling the EEE but it is safe
159		 * to verify all by invoking the eee_init function.
160		 * In case of failure it will return an error.
161		 */
162		priv->eee_enabled = sxgbe_eee_init(priv);
163		if (!priv->eee_enabled)
164			return -EOPNOTSUPP;
165
166		/* Do not change tx_lpi_timer in case of failure */
167		priv->tx_lpi_timer = edata->tx_lpi_timer;
168	}
169
170	return phy_ethtool_set_eee(dev->phydev, edata);
171}
172
173static void sxgbe_getdrvinfo(struct net_device *dev,
174			     struct ethtool_drvinfo *info)
175{
176	strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
177	strscpy(info->version, DRV_VERSION, sizeof(info->version));
178}
179
180static u32 sxgbe_getmsglevel(struct net_device *dev)
181{
182	struct sxgbe_priv_data *priv = netdev_priv(dev);
183	return priv->msg_enable;
184}
185
186static void sxgbe_setmsglevel(struct net_device *dev, u32 level)
187{
188	struct sxgbe_priv_data *priv = netdev_priv(dev);
189	priv->msg_enable = level;
190}
191
192static void sxgbe_get_strings(struct net_device *dev, u32 stringset, u8 *data)
193{
194	int i;
195	u8 *p = data;
196
197	switch (stringset) {
198	case ETH_SS_STATS:
199		for (i = 0; i < SXGBE_STATS_LEN; i++) {
200			memcpy(p, sxgbe_gstrings_stats[i].stat_string,
201			       ETH_GSTRING_LEN);
202			p += ETH_GSTRING_LEN;
203		}
204		break;
205	default:
206		WARN_ON(1);
207		break;
208	}
209}
210
211static int sxgbe_get_sset_count(struct net_device *netdev, int sset)
212{
213	int len;
214
215	switch (sset) {
216	case ETH_SS_STATS:
217		len = SXGBE_STATS_LEN;
218		return len;
219	default:
220		return -EINVAL;
221	}
222}
223
224static void sxgbe_get_ethtool_stats(struct net_device *dev,
225				    struct ethtool_stats *dummy, u64 *data)
226{
227	struct sxgbe_priv_data *priv = netdev_priv(dev);
228	int i;
229	char *p;
230
231	if (priv->eee_enabled) {
232		int val = phy_get_eee_err(dev->phydev);
233
234		if (val)
235			priv->xstats.eee_wakeup_error_n = val;
236	}
237
238	for (i = 0; i < SXGBE_STATS_LEN; i++) {
239		p = (char *)priv + sxgbe_gstrings_stats[i].stat_offset;
240		data[i] = (sxgbe_gstrings_stats[i].sizeof_stat == sizeof(u64))
241			? (*(u64 *)p) : (*(u32 *)p);
242	}
243}
244
245static void sxgbe_get_channels(struct net_device *dev,
246			       struct ethtool_channels *channel)
247{
248	channel->max_rx = SXGBE_MAX_RX_CHANNELS;
249	channel->max_tx = SXGBE_MAX_TX_CHANNELS;
250	channel->rx_count = SXGBE_RX_QUEUES;
251	channel->tx_count = SXGBE_TX_QUEUES;
252}
253
254static u32 sxgbe_riwt2usec(u32 riwt, struct sxgbe_priv_data *priv)
255{
256	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
257
258	if (!clk)
259		return 0;
260
261	return (riwt * 256) / (clk / 1000000);
262}
263
264static u32 sxgbe_usec2riwt(u32 usec, struct sxgbe_priv_data *priv)
265{
266	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
267
268	if (!clk)
269		return 0;
270
271	return (usec * (clk / 1000000)) / 256;
272}
273
274static int sxgbe_get_coalesce(struct net_device *dev,
275			      struct ethtool_coalesce *ec,
276			      struct kernel_ethtool_coalesce *kernel_coal,
277			      struct netlink_ext_ack *extack)
278{
279	struct sxgbe_priv_data *priv = netdev_priv(dev);
280
281	if (priv->use_riwt)
282		ec->rx_coalesce_usecs = sxgbe_riwt2usec(priv->rx_riwt, priv);
283
284	return 0;
285}
286
287static int sxgbe_set_coalesce(struct net_device *dev,
288			      struct ethtool_coalesce *ec,
289			      struct kernel_ethtool_coalesce *kernel_coal,
290			      struct netlink_ext_ack *extack)
291{
292	struct sxgbe_priv_data *priv = netdev_priv(dev);
293	unsigned int rx_riwt;
294
295	if (!ec->rx_coalesce_usecs)
296		return -EINVAL;
297
298	rx_riwt = sxgbe_usec2riwt(ec->rx_coalesce_usecs, priv);
299
300	if ((rx_riwt > SXGBE_MAX_DMA_RIWT) || (rx_riwt < SXGBE_MIN_DMA_RIWT))
301		return -EINVAL;
302	else if (!priv->use_riwt)
303		return -EOPNOTSUPP;
304
305	priv->rx_riwt = rx_riwt;
306	priv->hw->dma->rx_watchdog(priv->ioaddr, priv->rx_riwt);
307
308	return 0;
309}
310
311static int sxgbe_get_rxfh_fields(struct net_device *dev,
312				 struct ethtool_rxfh_fields *cmd)
313{
314	cmd->data = 0;
315
316	/* Report default options for RSS on sxgbe */
317	switch (cmd->flow_type) {
318	case TCP_V4_FLOW:
319	case UDP_V4_FLOW:
320		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
321		fallthrough;
322	case SCTP_V4_FLOW:
323	case AH_ESP_V4_FLOW:
324	case AH_V4_FLOW:
325	case ESP_V4_FLOW:
326	case IPV4_FLOW:
327		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
328		break;
329	case TCP_V6_FLOW:
330	case UDP_V6_FLOW:
331		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
332		fallthrough;
333	case SCTP_V6_FLOW:
334	case AH_ESP_V6_FLOW:
335	case AH_V6_FLOW:
336	case ESP_V6_FLOW:
337	case IPV6_FLOW:
338		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
339		break;
340	default:
341		return -EINVAL;
342	}
343
344	return 0;
345}
346
347static int sxgbe_set_rxfh_fields(struct net_device *dev,
348				 const struct ethtool_rxfh_fields *cmd,
349				 struct netlink_ext_ack *extack)
350{
351	struct sxgbe_priv_data *priv = netdev_priv(dev);
352	u32 reg_val = 0;
353
354	/* RSS does not support anything other than hashing
355	 * to queues on src and dst IPs and ports
356	 */
357	if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST |
358			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
359		return -EINVAL;
360
361	switch (cmd->flow_type) {
362	case TCP_V4_FLOW:
363	case TCP_V6_FLOW:
364		if (!(cmd->data & RXH_IP_SRC) ||
365		    !(cmd->data & RXH_IP_DST) ||
366		    !(cmd->data & RXH_L4_B_0_1) ||
367		    !(cmd->data & RXH_L4_B_2_3))
368			return -EINVAL;
369		reg_val = SXGBE_CORE_RSS_CTL_TCP4TE;
370		break;
371	case UDP_V4_FLOW:
372	case UDP_V6_FLOW:
373		if (!(cmd->data & RXH_IP_SRC) ||
374		    !(cmd->data & RXH_IP_DST) ||
375		    !(cmd->data & RXH_L4_B_0_1) ||
376		    !(cmd->data & RXH_L4_B_2_3))
377			return -EINVAL;
378		reg_val = SXGBE_CORE_RSS_CTL_UDP4TE;
379		break;
380	case SCTP_V4_FLOW:
381	case AH_ESP_V4_FLOW:
382	case AH_V4_FLOW:
383	case ESP_V4_FLOW:
384	case AH_ESP_V6_FLOW:
385	case AH_V6_FLOW:
386	case ESP_V6_FLOW:
387	case SCTP_V6_FLOW:
388	case IPV4_FLOW:
389	case IPV6_FLOW:
390		if (!(cmd->data & RXH_IP_SRC) ||
391		    !(cmd->data & RXH_IP_DST) ||
392		    (cmd->data & RXH_L4_B_0_1) ||
393		    (cmd->data & RXH_L4_B_2_3))
394			return -EINVAL;
395		reg_val = SXGBE_CORE_RSS_CTL_IP2TE;
396		break;
397	default:
398		return -EINVAL;
399	}
400
401	/* Read SXGBE RSS control register and update */
402	reg_val |= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
403	writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
404	readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
405
406	return 0;
407}
408
409static void sxgbe_get_regs(struct net_device *dev,
410			   struct ethtool_regs *regs, void *space)
411{
412	struct sxgbe_priv_data *priv = netdev_priv(dev);
413	u32 *reg_space = (u32 *)space;
414	int reg_offset;
415	int reg_ix = 0;
416	void __iomem *ioaddr = priv->ioaddr;
417
418	memset(reg_space, 0x0, REG_SPACE_SIZE);
419
420	/* MAC registers */
421	for (reg_offset = START_MAC_REG_OFFSET;
422	     reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) {
423		reg_space[reg_ix] = readl(ioaddr + reg_offset);
424		reg_ix++;
425	}
426
427	/* MTL registers */
428	for (reg_offset = START_MTL_REG_OFFSET;
429	     reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) {
430		reg_space[reg_ix] = readl(ioaddr + reg_offset);
431		reg_ix++;
432	}
433
434	/* DMA registers */
435	for (reg_offset = START_DMA_REG_OFFSET;
436	     reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) {
437		reg_space[reg_ix] = readl(ioaddr + reg_offset);
438		reg_ix++;
439	}
440
441	BUG_ON(reg_ix * 4 > REG_SPACE_SIZE);
442}
443
444static int sxgbe_get_regs_len(struct net_device *dev)
445{
446	return REG_SPACE_SIZE;
447}
448
449static const struct ethtool_ops sxgbe_ethtool_ops = {
450	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
451	.get_drvinfo = sxgbe_getdrvinfo,
452	.get_msglevel = sxgbe_getmsglevel,
453	.set_msglevel = sxgbe_setmsglevel,
454	.get_link = ethtool_op_get_link,
455	.get_strings = sxgbe_get_strings,
456	.get_ethtool_stats = sxgbe_get_ethtool_stats,
457	.get_sset_count = sxgbe_get_sset_count,
458	.get_channels = sxgbe_get_channels,
459	.get_coalesce = sxgbe_get_coalesce,
460	.set_coalesce = sxgbe_set_coalesce,
461	.get_rxfh_fields = sxgbe_get_rxfh_fields,
462	.set_rxfh_fields = sxgbe_set_rxfh_fields,
463	.get_regs = sxgbe_get_regs,
464	.get_regs_len = sxgbe_get_regs_len,
465	.get_eee = sxgbe_get_eee,
466	.set_eee = sxgbe_set_eee,
467	.get_link_ksettings = phy_ethtool_get_link_ksettings,
468	.set_link_ksettings = phy_ethtool_set_link_ksettings,
469};
470
471void sxgbe_set_ethtool_ops(struct net_device *netdev)
472{
473	netdev->ethtool_ops = &sxgbe_ethtool_ops;
474}