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(phydev: dev->phydev, data: 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(phydev: dev->phydev, data: 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(phydev: 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(clk: 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(clk: 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(riwt: 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(usec: 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(addr: priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
403 writel(val: reg_val, addr: priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
404 readl(addr: 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(addr: 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(addr: 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(addr: 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}
475

source code of linux/drivers/net/ethernet/samsung/sxgbe/sxgbe_ethtool.c