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