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_eee *edata)
137{
138	struct sxgbe_priv_data *priv = netdev_priv(dev);
139
140	if (!priv->hw_cap.eee)
141		return -EOPNOTSUPP;
142
143	edata->eee_enabled = priv->eee_enabled;
144	edata->eee_active = priv->eee_active;
145	edata->tx_lpi_timer = priv->tx_lpi_timer;
146
147	return phy_ethtool_get_eee(dev->phydev, edata);
148}
149
150static int sxgbe_set_eee(struct net_device *dev,
151			 struct ethtool_eee *edata)
152{
153	struct sxgbe_priv_data *priv = netdev_priv(dev);
154
155	priv->eee_enabled = edata->eee_enabled;
156
157	if (!priv->eee_enabled) {
158		sxgbe_disable_eee_mode(priv);
159	} else {
160		/* We are asking for enabling the EEE but it is safe
161		 * to verify all by invoking the eee_init function.
162		 * In case of failure it will return an error.
163		 */
164		priv->eee_enabled = sxgbe_eee_init(priv);
165		if (!priv->eee_enabled)
166			return -EOPNOTSUPP;
167
168		/* Do not change tx_lpi_timer in case of failure */
169		priv->tx_lpi_timer = edata->tx_lpi_timer;
170	}
171
172	return phy_ethtool_set_eee(dev->phydev, edata);
173}
174
175static void sxgbe_getdrvinfo(struct net_device *dev,
176			     struct ethtool_drvinfo *info)
177{
178	strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
179	strscpy(info->version, DRV_VERSION, sizeof(info->version));
180}
181
182static u32 sxgbe_getmsglevel(struct net_device *dev)
183{
184	struct sxgbe_priv_data *priv = netdev_priv(dev);
185	return priv->msg_enable;
186}
187
188static void sxgbe_setmsglevel(struct net_device *dev, u32 level)
189{
190	struct sxgbe_priv_data *priv = netdev_priv(dev);
191	priv->msg_enable = level;
192}
193
194static void sxgbe_get_strings(struct net_device *dev, u32 stringset, u8 *data)
195{
196	int i;
197	u8 *p = data;
198
199	switch (stringset) {
200	case ETH_SS_STATS:
201		for (i = 0; i < SXGBE_STATS_LEN; i++) {
202			memcpy(p, sxgbe_gstrings_stats[i].stat_string,
203			       ETH_GSTRING_LEN);
204			p += ETH_GSTRING_LEN;
205		}
206		break;
207	default:
208		WARN_ON(1);
209		break;
210	}
211}
212
213static int sxgbe_get_sset_count(struct net_device *netdev, int sset)
214{
215	int len;
216
217	switch (sset) {
218	case ETH_SS_STATS:
219		len = SXGBE_STATS_LEN;
220		return len;
221	default:
222		return -EINVAL;
223	}
224}
225
226static void sxgbe_get_ethtool_stats(struct net_device *dev,
227				    struct ethtool_stats *dummy, u64 *data)
228{
229	struct sxgbe_priv_data *priv = netdev_priv(dev);
230	int i;
231	char *p;
232
233	if (priv->eee_enabled) {
234		int val = phy_get_eee_err(dev->phydev);
235
236		if (val)
237			priv->xstats.eee_wakeup_error_n = val;
238	}
239
240	for (i = 0; i < SXGBE_STATS_LEN; i++) {
241		p = (char *)priv + sxgbe_gstrings_stats[i].stat_offset;
242		data[i] = (sxgbe_gstrings_stats[i].sizeof_stat == sizeof(u64))
243			? (*(u64 *)p) : (*(u32 *)p);
244	}
245}
246
247static void sxgbe_get_channels(struct net_device *dev,
248			       struct ethtool_channels *channel)
249{
250	channel->max_rx = SXGBE_MAX_RX_CHANNELS;
251	channel->max_tx = SXGBE_MAX_TX_CHANNELS;
252	channel->rx_count = SXGBE_RX_QUEUES;
253	channel->tx_count = SXGBE_TX_QUEUES;
254}
255
256static u32 sxgbe_riwt2usec(u32 riwt, struct sxgbe_priv_data *priv)
257{
258	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
259
260	if (!clk)
261		return 0;
262
263	return (riwt * 256) / (clk / 1000000);
264}
265
266static u32 sxgbe_usec2riwt(u32 usec, struct sxgbe_priv_data *priv)
267{
268	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
269
270	if (!clk)
271		return 0;
272
273	return (usec * (clk / 1000000)) / 256;
274}
275
276static int sxgbe_get_coalesce(struct net_device *dev,
277			      struct ethtool_coalesce *ec,
278			      struct kernel_ethtool_coalesce *kernel_coal,
279			      struct netlink_ext_ack *extack)
280{
281	struct sxgbe_priv_data *priv = netdev_priv(dev);
282
283	if (priv->use_riwt)
284		ec->rx_coalesce_usecs = sxgbe_riwt2usec(priv->rx_riwt, priv);
285
286	return 0;
287}
288
289static int sxgbe_set_coalesce(struct net_device *dev,
290			      struct ethtool_coalesce *ec,
291			      struct kernel_ethtool_coalesce *kernel_coal,
292			      struct netlink_ext_ack *extack)
293{
294	struct sxgbe_priv_data *priv = netdev_priv(dev);
295	unsigned int rx_riwt;
296
297	if (!ec->rx_coalesce_usecs)
298		return -EINVAL;
299
300	rx_riwt = sxgbe_usec2riwt(ec->rx_coalesce_usecs, priv);
301
302	if ((rx_riwt > SXGBE_MAX_DMA_RIWT) || (rx_riwt < SXGBE_MIN_DMA_RIWT))
303		return -EINVAL;
304	else if (!priv->use_riwt)
305		return -EOPNOTSUPP;
306
307	priv->rx_riwt = rx_riwt;
308	priv->hw->dma->rx_watchdog(priv->ioaddr, priv->rx_riwt);
309
310	return 0;
311}
312
313static int sxgbe_get_rss_hash_opts(struct sxgbe_priv_data *priv,
314				   struct ethtool_rxnfc *cmd)
315{
316	cmd->data = 0;
317
318	/* Report default options for RSS on sxgbe */
319	switch (cmd->flow_type) {
320	case TCP_V4_FLOW:
321	case UDP_V4_FLOW:
322		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
323		fallthrough;
324	case SCTP_V4_FLOW:
325	case AH_ESP_V4_FLOW:
326	case AH_V4_FLOW:
327	case ESP_V4_FLOW:
328	case IPV4_FLOW:
329		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
330		break;
331	case TCP_V6_FLOW:
332	case UDP_V6_FLOW:
333		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
334		fallthrough;
335	case SCTP_V6_FLOW:
336	case AH_ESP_V6_FLOW:
337	case AH_V6_FLOW:
338	case ESP_V6_FLOW:
339	case IPV6_FLOW:
340		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
341		break;
342	default:
343		return -EINVAL;
344	}
345
346	return 0;
347}
348
349static int sxgbe_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
350			   u32 *rule_locs)
351{
352	struct sxgbe_priv_data *priv = netdev_priv(dev);
353	int ret = -EOPNOTSUPP;
354
355	switch (cmd->cmd) {
356	case ETHTOOL_GRXFH:
357		ret = sxgbe_get_rss_hash_opts(priv, cmd);
358		break;
359	default:
360		break;
361	}
362
363	return ret;
364}
365
366static int sxgbe_set_rss_hash_opt(struct sxgbe_priv_data *priv,
367				  struct ethtool_rxnfc *cmd)
368{
369	u32 reg_val = 0;
370
371	/* RSS does not support anything other than hashing
372	 * to queues on src and dst IPs and ports
373	 */
374	if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST |
375			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
376		return -EINVAL;
377
378	switch (cmd->flow_type) {
379	case TCP_V4_FLOW:
380	case TCP_V6_FLOW:
381		if (!(cmd->data & RXH_IP_SRC) ||
382		    !(cmd->data & RXH_IP_DST) ||
383		    !(cmd->data & RXH_L4_B_0_1) ||
384		    !(cmd->data & RXH_L4_B_2_3))
385			return -EINVAL;
386		reg_val = SXGBE_CORE_RSS_CTL_TCP4TE;
387		break;
388	case UDP_V4_FLOW:
389	case UDP_V6_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_UDP4TE;
396		break;
397	case SCTP_V4_FLOW:
398	case AH_ESP_V4_FLOW:
399	case AH_V4_FLOW:
400	case ESP_V4_FLOW:
401	case AH_ESP_V6_FLOW:
402	case AH_V6_FLOW:
403	case ESP_V6_FLOW:
404	case SCTP_V6_FLOW:
405	case IPV4_FLOW:
406	case IPV6_FLOW:
407		if (!(cmd->data & RXH_IP_SRC) ||
408		    !(cmd->data & RXH_IP_DST) ||
409		    (cmd->data & RXH_L4_B_0_1) ||
410		    (cmd->data & RXH_L4_B_2_3))
411			return -EINVAL;
412		reg_val = SXGBE_CORE_RSS_CTL_IP2TE;
413		break;
414	default:
415		return -EINVAL;
416	}
417
418	/* Read SXGBE RSS control register and update */
419	reg_val |= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
420	writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
421	readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
422
423	return 0;
424}
425
426static int sxgbe_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
427{
428	struct sxgbe_priv_data *priv = netdev_priv(dev);
429	int ret = -EOPNOTSUPP;
430
431	switch (cmd->cmd) {
432	case ETHTOOL_SRXFH:
433		ret = sxgbe_set_rss_hash_opt(priv, cmd);
434		break;
435	default:
436		break;
437	}
438
439	return ret;
440}
441
442static void sxgbe_get_regs(struct net_device *dev,
443			   struct ethtool_regs *regs, void *space)
444{
445	struct sxgbe_priv_data *priv = netdev_priv(dev);
446	u32 *reg_space = (u32 *)space;
447	int reg_offset;
448	int reg_ix = 0;
449	void __iomem *ioaddr = priv->ioaddr;
450
451	memset(reg_space, 0x0, REG_SPACE_SIZE);
452
453	/* MAC registers */
454	for (reg_offset = START_MAC_REG_OFFSET;
455	     reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) {
456		reg_space[reg_ix] = readl(ioaddr + reg_offset);
457		reg_ix++;
458	}
459
460	/* MTL registers */
461	for (reg_offset = START_MTL_REG_OFFSET;
462	     reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) {
463		reg_space[reg_ix] = readl(ioaddr + reg_offset);
464		reg_ix++;
465	}
466
467	/* DMA registers */
468	for (reg_offset = START_DMA_REG_OFFSET;
469	     reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) {
470		reg_space[reg_ix] = readl(ioaddr + reg_offset);
471		reg_ix++;
472	}
473
474	BUG_ON(reg_ix * 4 > REG_SPACE_SIZE);
475}
476
477static int sxgbe_get_regs_len(struct net_device *dev)
478{
479	return REG_SPACE_SIZE;
480}
481
482static const struct ethtool_ops sxgbe_ethtool_ops = {
483	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
484	.get_drvinfo = sxgbe_getdrvinfo,
485	.get_msglevel = sxgbe_getmsglevel,
486	.set_msglevel = sxgbe_setmsglevel,
487	.get_link = ethtool_op_get_link,
488	.get_strings = sxgbe_get_strings,
489	.get_ethtool_stats = sxgbe_get_ethtool_stats,
490	.get_sset_count = sxgbe_get_sset_count,
491	.get_channels = sxgbe_get_channels,
492	.get_coalesce = sxgbe_get_coalesce,
493	.set_coalesce = sxgbe_set_coalesce,
494	.get_rxnfc = sxgbe_get_rxnfc,
495	.set_rxnfc = sxgbe_set_rxnfc,
496	.get_regs = sxgbe_get_regs,
497	.get_regs_len = sxgbe_get_regs_len,
498	.get_eee = sxgbe_get_eee,
499	.set_eee = sxgbe_set_eee,
500	.get_link_ksettings = phy_ethtool_get_link_ksettings,
501	.set_link_ksettings = phy_ethtool_set_link_ksettings,
502};
503
504void sxgbe_set_ethtool_ops(struct net_device *netdev)
505{
506	netdev->ethtool_ops = &sxgbe_ethtool_ops;
507}
508