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 24 struct 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 37 static 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 135 static 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 148 static 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 173 static 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 180 static u32 sxgbe_getmsglevel(struct net_device *dev) 181 { 182 struct sxgbe_priv_data *priv = netdev_priv(dev); 183 return priv->msg_enable; 184 } 185 186 static 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 192 static 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 211 static 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 224 static 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 245 static 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 254 static 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 264 static 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 274 static 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 287 static 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 311 static int sxgbe_get_rss_hash_opts(struct sxgbe_priv_data *priv, 312 struct ethtool_rxnfc *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 347 static int sxgbe_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, 348 u32 *rule_locs) 349 { 350 struct sxgbe_priv_data *priv = netdev_priv(dev); 351 int ret = -EOPNOTSUPP; 352 353 switch (cmd->cmd) { 354 case ETHTOOL_GRXFH: 355 ret = sxgbe_get_rss_hash_opts(priv, cmd); 356 break; 357 default: 358 break; 359 } 360 361 return ret; 362 } 363 364 static int sxgbe_set_rss_hash_opt(struct sxgbe_priv_data *priv, 365 struct ethtool_rxnfc *cmd) 366 { 367 u32 reg_val = 0; 368 369 /* RSS does not support anything other than hashing 370 * to queues on src and dst IPs and ports 371 */ 372 if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST | 373 RXH_L4_B_0_1 | RXH_L4_B_2_3)) 374 return -EINVAL; 375 376 switch (cmd->flow_type) { 377 case TCP_V4_FLOW: 378 case TCP_V6_FLOW: 379 if (!(cmd->data & RXH_IP_SRC) || 380 !(cmd->data & RXH_IP_DST) || 381 !(cmd->data & RXH_L4_B_0_1) || 382 !(cmd->data & RXH_L4_B_2_3)) 383 return -EINVAL; 384 reg_val = SXGBE_CORE_RSS_CTL_TCP4TE; 385 break; 386 case UDP_V4_FLOW: 387 case UDP_V6_FLOW: 388 if (!(cmd->data & RXH_IP_SRC) || 389 !(cmd->data & RXH_IP_DST) || 390 !(cmd->data & RXH_L4_B_0_1) || 391 !(cmd->data & RXH_L4_B_2_3)) 392 return -EINVAL; 393 reg_val = SXGBE_CORE_RSS_CTL_UDP4TE; 394 break; 395 case SCTP_V4_FLOW: 396 case AH_ESP_V4_FLOW: 397 case AH_V4_FLOW: 398 case ESP_V4_FLOW: 399 case AH_ESP_V6_FLOW: 400 case AH_V6_FLOW: 401 case ESP_V6_FLOW: 402 case SCTP_V6_FLOW: 403 case IPV4_FLOW: 404 case IPV6_FLOW: 405 if (!(cmd->data & RXH_IP_SRC) || 406 !(cmd->data & RXH_IP_DST) || 407 (cmd->data & RXH_L4_B_0_1) || 408 (cmd->data & RXH_L4_B_2_3)) 409 return -EINVAL; 410 reg_val = SXGBE_CORE_RSS_CTL_IP2TE; 411 break; 412 default: 413 return -EINVAL; 414 } 415 416 /* Read SXGBE RSS control register and update */ 417 reg_val |= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG); 418 writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG); 419 readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG); 420 421 return 0; 422 } 423 424 static int sxgbe_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 425 { 426 struct sxgbe_priv_data *priv = netdev_priv(dev); 427 int ret = -EOPNOTSUPP; 428 429 switch (cmd->cmd) { 430 case ETHTOOL_SRXFH: 431 ret = sxgbe_set_rss_hash_opt(priv, cmd); 432 break; 433 default: 434 break; 435 } 436 437 return ret; 438 } 439 440 static void sxgbe_get_regs(struct net_device *dev, 441 struct ethtool_regs *regs, void *space) 442 { 443 struct sxgbe_priv_data *priv = netdev_priv(dev); 444 u32 *reg_space = (u32 *)space; 445 int reg_offset; 446 int reg_ix = 0; 447 void __iomem *ioaddr = priv->ioaddr; 448 449 memset(reg_space, 0x0, REG_SPACE_SIZE); 450 451 /* MAC registers */ 452 for (reg_offset = START_MAC_REG_OFFSET; 453 reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) { 454 reg_space[reg_ix] = readl(ioaddr + reg_offset); 455 reg_ix++; 456 } 457 458 /* MTL registers */ 459 for (reg_offset = START_MTL_REG_OFFSET; 460 reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) { 461 reg_space[reg_ix] = readl(ioaddr + reg_offset); 462 reg_ix++; 463 } 464 465 /* DMA registers */ 466 for (reg_offset = START_DMA_REG_OFFSET; 467 reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) { 468 reg_space[reg_ix] = readl(ioaddr + reg_offset); 469 reg_ix++; 470 } 471 472 BUG_ON(reg_ix * 4 > REG_SPACE_SIZE); 473 } 474 475 static int sxgbe_get_regs_len(struct net_device *dev) 476 { 477 return REG_SPACE_SIZE; 478 } 479 480 static const struct ethtool_ops sxgbe_ethtool_ops = { 481 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS, 482 .get_drvinfo = sxgbe_getdrvinfo, 483 .get_msglevel = sxgbe_getmsglevel, 484 .set_msglevel = sxgbe_setmsglevel, 485 .get_link = ethtool_op_get_link, 486 .get_strings = sxgbe_get_strings, 487 .get_ethtool_stats = sxgbe_get_ethtool_stats, 488 .get_sset_count = sxgbe_get_sset_count, 489 .get_channels = sxgbe_get_channels, 490 .get_coalesce = sxgbe_get_coalesce, 491 .set_coalesce = sxgbe_set_coalesce, 492 .get_rxnfc = sxgbe_get_rxnfc, 493 .set_rxnfc = sxgbe_set_rxnfc, 494 .get_regs = sxgbe_get_regs, 495 .get_regs_len = sxgbe_get_regs_len, 496 .get_eee = sxgbe_get_eee, 497 .set_eee = sxgbe_set_eee, 498 .get_link_ksettings = phy_ethtool_get_link_ksettings, 499 .set_link_ksettings = phy_ethtool_set_link_ksettings, 500 }; 501 502 void sxgbe_set_ethtool_ops(struct net_device *netdev) 503 { 504 netdev->ethtool_ops = &sxgbe_ethtool_ops; 505 } 506