/drivers/net/vmxnet3/vmxnet3_ethtool.c
C | 901 lines | 696 code | 135 blank | 70 comment | 101 complexity | 61d6ce344e6ca9bb73dc22ac312b31c7 MD5 | raw file
1/* 2 * Linux driver for VMware's vmxnet3 ethernet NIC. 3 * 4 * Copyright (C) 2008-2016, VMware, Inc. All Rights Reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; version 2 of the License and no later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 13 * NON INFRINGEMENT. See the GNU General Public License for more 14 * details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * The full GNU General Public License is included in this distribution in 21 * the file called "COPYING". 22 * 23 * Maintained by: pv-drivers@vmware.com 24 * 25 */ 26 27 28#include "vmxnet3_int.h" 29 30struct vmxnet3_stat_desc { 31 char desc[ETH_GSTRING_LEN]; 32 int offset; 33}; 34 35 36/* per tq stats maintained by the device */ 37static const struct vmxnet3_stat_desc 38vmxnet3_tq_dev_stats[] = { 39 /* description, offset */ 40 { "Tx Queue#", 0 }, 41 { " TSO pkts tx", offsetof(struct UPT1_TxStats, TSOPktsTxOK) }, 42 { " TSO bytes tx", offsetof(struct UPT1_TxStats, TSOBytesTxOK) }, 43 { " ucast pkts tx", offsetof(struct UPT1_TxStats, ucastPktsTxOK) }, 44 { " ucast bytes tx", offsetof(struct UPT1_TxStats, ucastBytesTxOK) }, 45 { " mcast pkts tx", offsetof(struct UPT1_TxStats, mcastPktsTxOK) }, 46 { " mcast bytes tx", offsetof(struct UPT1_TxStats, mcastBytesTxOK) }, 47 { " bcast pkts tx", offsetof(struct UPT1_TxStats, bcastPktsTxOK) }, 48 { " bcast bytes tx", offsetof(struct UPT1_TxStats, bcastBytesTxOK) }, 49 { " pkts tx err", offsetof(struct UPT1_TxStats, pktsTxError) }, 50 { " pkts tx discard", offsetof(struct UPT1_TxStats, pktsTxDiscard) }, 51}; 52 53/* per tq stats maintained by the driver */ 54static const struct vmxnet3_stat_desc 55vmxnet3_tq_driver_stats[] = { 56 /* description, offset */ 57 {" drv dropped tx total", offsetof(struct vmxnet3_tq_driver_stats, 58 drop_total) }, 59 { " too many frags", offsetof(struct vmxnet3_tq_driver_stats, 60 drop_too_many_frags) }, 61 { " giant hdr", offsetof(struct vmxnet3_tq_driver_stats, 62 drop_oversized_hdr) }, 63 { " hdr err", offsetof(struct vmxnet3_tq_driver_stats, 64 drop_hdr_inspect_err) }, 65 { " tso", offsetof(struct vmxnet3_tq_driver_stats, 66 drop_tso) }, 67 { " ring full", offsetof(struct vmxnet3_tq_driver_stats, 68 tx_ring_full) }, 69 { " pkts linearized", offsetof(struct vmxnet3_tq_driver_stats, 70 linearized) }, 71 { " hdr cloned", offsetof(struct vmxnet3_tq_driver_stats, 72 copy_skb_header) }, 73 { " giant hdr", offsetof(struct vmxnet3_tq_driver_stats, 74 oversized_hdr) }, 75}; 76 77/* per rq stats maintained by the device */ 78static const struct vmxnet3_stat_desc 79vmxnet3_rq_dev_stats[] = { 80 { "Rx Queue#", 0 }, 81 { " LRO pkts rx", offsetof(struct UPT1_RxStats, LROPktsRxOK) }, 82 { " LRO byte rx", offsetof(struct UPT1_RxStats, LROBytesRxOK) }, 83 { " ucast pkts rx", offsetof(struct UPT1_RxStats, ucastPktsRxOK) }, 84 { " ucast bytes rx", offsetof(struct UPT1_RxStats, ucastBytesRxOK) }, 85 { " mcast pkts rx", offsetof(struct UPT1_RxStats, mcastPktsRxOK) }, 86 { " mcast bytes rx", offsetof(struct UPT1_RxStats, mcastBytesRxOK) }, 87 { " bcast pkts rx", offsetof(struct UPT1_RxStats, bcastPktsRxOK) }, 88 { " bcast bytes rx", offsetof(struct UPT1_RxStats, bcastBytesRxOK) }, 89 { " pkts rx OOB", offsetof(struct UPT1_RxStats, pktsRxOutOfBuf) }, 90 { " pkts rx err", offsetof(struct UPT1_RxStats, pktsRxError) }, 91}; 92 93/* per rq stats maintained by the driver */ 94static const struct vmxnet3_stat_desc 95vmxnet3_rq_driver_stats[] = { 96 /* description, offset */ 97 { " drv dropped rx total", offsetof(struct vmxnet3_rq_driver_stats, 98 drop_total) }, 99 { " err", offsetof(struct vmxnet3_rq_driver_stats, 100 drop_err) }, 101 { " fcs", offsetof(struct vmxnet3_rq_driver_stats, 102 drop_fcs) }, 103 { " rx buf alloc fail", offsetof(struct vmxnet3_rq_driver_stats, 104 rx_buf_alloc_failure) }, 105}; 106 107/* global stats maintained by the driver */ 108static const struct vmxnet3_stat_desc 109vmxnet3_global_stats[] = { 110 /* description, offset */ 111 { "tx timeout count", offsetof(struct vmxnet3_adapter, 112 tx_timeout_count) } 113}; 114 115 116void 117vmxnet3_get_stats64(struct net_device *netdev, 118 struct rtnl_link_stats64 *stats) 119{ 120 struct vmxnet3_adapter *adapter; 121 struct vmxnet3_tq_driver_stats *drvTxStats; 122 struct vmxnet3_rq_driver_stats *drvRxStats; 123 struct UPT1_TxStats *devTxStats; 124 struct UPT1_RxStats *devRxStats; 125 unsigned long flags; 126 int i; 127 128 adapter = netdev_priv(netdev); 129 130 /* Collect the dev stats into the shared area */ 131 spin_lock_irqsave(&adapter->cmd_lock, flags); 132 VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS); 133 spin_unlock_irqrestore(&adapter->cmd_lock, flags); 134 135 for (i = 0; i < adapter->num_tx_queues; i++) { 136 devTxStats = &adapter->tqd_start[i].stats; 137 drvTxStats = &adapter->tx_queue[i].stats; 138 stats->tx_packets += devTxStats->ucastPktsTxOK + 139 devTxStats->mcastPktsTxOK + 140 devTxStats->bcastPktsTxOK; 141 stats->tx_bytes += devTxStats->ucastBytesTxOK + 142 devTxStats->mcastBytesTxOK + 143 devTxStats->bcastBytesTxOK; 144 stats->tx_errors += devTxStats->pktsTxError; 145 stats->tx_dropped += drvTxStats->drop_total; 146 } 147 148 for (i = 0; i < adapter->num_rx_queues; i++) { 149 devRxStats = &adapter->rqd_start[i].stats; 150 drvRxStats = &adapter->rx_queue[i].stats; 151 stats->rx_packets += devRxStats->ucastPktsRxOK + 152 devRxStats->mcastPktsRxOK + 153 devRxStats->bcastPktsRxOK; 154 155 stats->rx_bytes += devRxStats->ucastBytesRxOK + 156 devRxStats->mcastBytesRxOK + 157 devRxStats->bcastBytesRxOK; 158 159 stats->rx_errors += devRxStats->pktsRxError; 160 stats->rx_dropped += drvRxStats->drop_total; 161 stats->multicast += devRxStats->mcastPktsRxOK; 162 } 163} 164 165static int 166vmxnet3_get_sset_count(struct net_device *netdev, int sset) 167{ 168 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 169 switch (sset) { 170 case ETH_SS_STATS: 171 return (ARRAY_SIZE(vmxnet3_tq_dev_stats) + 172 ARRAY_SIZE(vmxnet3_tq_driver_stats)) * 173 adapter->num_tx_queues + 174 (ARRAY_SIZE(vmxnet3_rq_dev_stats) + 175 ARRAY_SIZE(vmxnet3_rq_driver_stats)) * 176 adapter->num_rx_queues + 177 ARRAY_SIZE(vmxnet3_global_stats); 178 default: 179 return -EOPNOTSUPP; 180 } 181} 182 183 184/* This is a version 2 of the vmxnet3 ethtool_regs which goes hand in hand with 185 * the version 2 of the vmxnet3 support for ethtool(8) --register-dump. 186 * Therefore, if any registers are added, removed or modified, then a version 187 * bump and a corresponding change in the vmxnet3 support for ethtool(8) 188 * --register-dump would be required. 189 */ 190static int 191vmxnet3_get_regs_len(struct net_device *netdev) 192{ 193 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 194 195 return ((9 /* BAR1 registers */ + 196 (1 + adapter->intr.num_intrs) + 197 (1 + adapter->num_tx_queues * 17 /* Tx queue registers */) + 198 (1 + adapter->num_rx_queues * 23 /* Rx queue registers */)) * 199 sizeof(u32)); 200} 201 202 203static void 204vmxnet3_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo) 205{ 206 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 207 208 strlcpy(drvinfo->driver, vmxnet3_driver_name, sizeof(drvinfo->driver)); 209 210 strlcpy(drvinfo->version, VMXNET3_DRIVER_VERSION_REPORT, 211 sizeof(drvinfo->version)); 212 213 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 214 sizeof(drvinfo->bus_info)); 215} 216 217 218static void 219vmxnet3_get_strings(struct net_device *netdev, u32 stringset, u8 *buf) 220{ 221 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 222 if (stringset == ETH_SS_STATS) { 223 int i, j; 224 for (j = 0; j < adapter->num_tx_queues; j++) { 225 for (i = 0; i < ARRAY_SIZE(vmxnet3_tq_dev_stats); i++) { 226 memcpy(buf, vmxnet3_tq_dev_stats[i].desc, 227 ETH_GSTRING_LEN); 228 buf += ETH_GSTRING_LEN; 229 } 230 for (i = 0; i < ARRAY_SIZE(vmxnet3_tq_driver_stats); 231 i++) { 232 memcpy(buf, vmxnet3_tq_driver_stats[i].desc, 233 ETH_GSTRING_LEN); 234 buf += ETH_GSTRING_LEN; 235 } 236 } 237 238 for (j = 0; j < adapter->num_rx_queues; j++) { 239 for (i = 0; i < ARRAY_SIZE(vmxnet3_rq_dev_stats); i++) { 240 memcpy(buf, vmxnet3_rq_dev_stats[i].desc, 241 ETH_GSTRING_LEN); 242 buf += ETH_GSTRING_LEN; 243 } 244 for (i = 0; i < ARRAY_SIZE(vmxnet3_rq_driver_stats); 245 i++) { 246 memcpy(buf, vmxnet3_rq_driver_stats[i].desc, 247 ETH_GSTRING_LEN); 248 buf += ETH_GSTRING_LEN; 249 } 250 } 251 252 for (i = 0; i < ARRAY_SIZE(vmxnet3_global_stats); i++) { 253 memcpy(buf, vmxnet3_global_stats[i].desc, 254 ETH_GSTRING_LEN); 255 buf += ETH_GSTRING_LEN; 256 } 257 } 258} 259 260netdev_features_t vmxnet3_fix_features(struct net_device *netdev, 261 netdev_features_t features) 262{ 263 /* If Rx checksum is disabled, then LRO should also be disabled */ 264 if (!(features & NETIF_F_RXCSUM)) 265 features &= ~NETIF_F_LRO; 266 267 return features; 268} 269 270int vmxnet3_set_features(struct net_device *netdev, netdev_features_t features) 271{ 272 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 273 unsigned long flags; 274 netdev_features_t changed = features ^ netdev->features; 275 276 if (changed & (NETIF_F_RXCSUM | NETIF_F_LRO | 277 NETIF_F_HW_VLAN_CTAG_RX)) { 278 if (features & NETIF_F_RXCSUM) 279 adapter->shared->devRead.misc.uptFeatures |= 280 UPT1_F_RXCSUM; 281 else 282 adapter->shared->devRead.misc.uptFeatures &= 283 ~UPT1_F_RXCSUM; 284 285 /* update hardware LRO capability accordingly */ 286 if (features & NETIF_F_LRO) 287 adapter->shared->devRead.misc.uptFeatures |= 288 UPT1_F_LRO; 289 else 290 adapter->shared->devRead.misc.uptFeatures &= 291 ~UPT1_F_LRO; 292 293 if (features & NETIF_F_HW_VLAN_CTAG_RX) 294 adapter->shared->devRead.misc.uptFeatures |= 295 UPT1_F_RXVLAN; 296 else 297 adapter->shared->devRead.misc.uptFeatures &= 298 ~UPT1_F_RXVLAN; 299 300 spin_lock_irqsave(&adapter->cmd_lock, flags); 301 VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD, 302 VMXNET3_CMD_UPDATE_FEATURE); 303 spin_unlock_irqrestore(&adapter->cmd_lock, flags); 304 } 305 return 0; 306} 307 308static void 309vmxnet3_get_ethtool_stats(struct net_device *netdev, 310 struct ethtool_stats *stats, u64 *buf) 311{ 312 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 313 unsigned long flags; 314 u8 *base; 315 int i; 316 int j = 0; 317 318 spin_lock_irqsave(&adapter->cmd_lock, flags); 319 VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS); 320 spin_unlock_irqrestore(&adapter->cmd_lock, flags); 321 322 /* this does assume each counter is 64-bit wide */ 323 for (j = 0; j < adapter->num_tx_queues; j++) { 324 base = (u8 *)&adapter->tqd_start[j].stats; 325 *buf++ = (u64)j; 326 for (i = 1; i < ARRAY_SIZE(vmxnet3_tq_dev_stats); i++) 327 *buf++ = *(u64 *)(base + 328 vmxnet3_tq_dev_stats[i].offset); 329 330 base = (u8 *)&adapter->tx_queue[j].stats; 331 for (i = 0; i < ARRAY_SIZE(vmxnet3_tq_driver_stats); i++) 332 *buf++ = *(u64 *)(base + 333 vmxnet3_tq_driver_stats[i].offset); 334 } 335 336 for (j = 0; j < adapter->num_rx_queues; j++) { 337 base = (u8 *)&adapter->rqd_start[j].stats; 338 *buf++ = (u64) j; 339 for (i = 1; i < ARRAY_SIZE(vmxnet3_rq_dev_stats); i++) 340 *buf++ = *(u64 *)(base + 341 vmxnet3_rq_dev_stats[i].offset); 342 343 base = (u8 *)&adapter->rx_queue[j].stats; 344 for (i = 0; i < ARRAY_SIZE(vmxnet3_rq_driver_stats); i++) 345 *buf++ = *(u64 *)(base + 346 vmxnet3_rq_driver_stats[i].offset); 347 } 348 349 base = (u8 *)adapter; 350 for (i = 0; i < ARRAY_SIZE(vmxnet3_global_stats); i++) 351 *buf++ = *(u64 *)(base + vmxnet3_global_stats[i].offset); 352} 353 354 355/* This is a version 2 of the vmxnet3 ethtool_regs which goes hand in hand with 356 * the version 2 of the vmxnet3 support for ethtool(8) --register-dump. 357 * Therefore, if any registers are added, removed or modified, then a version 358 * bump and a corresponding change in the vmxnet3 support for ethtool(8) 359 * --register-dump would be required. 360 */ 361static void 362vmxnet3_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *p) 363{ 364 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 365 u32 *buf = p; 366 int i = 0, j = 0; 367 368 memset(p, 0, vmxnet3_get_regs_len(netdev)); 369 370 regs->version = 2; 371 372 /* Update vmxnet3_get_regs_len if we want to dump more registers */ 373 374 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_VRRS); 375 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_UVRS); 376 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_DSAL); 377 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_DSAH); 378 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_CMD); 379 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_MACL); 380 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_MACH); 381 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_ICR); 382 buf[j++] = VMXNET3_READ_BAR1_REG(adapter, VMXNET3_REG_ECR); 383 384 buf[j++] = adapter->intr.num_intrs; 385 for (i = 0; i < adapter->intr.num_intrs; i++) { 386 buf[j++] = VMXNET3_READ_BAR0_REG(adapter, VMXNET3_REG_IMR 387 + i * VMXNET3_REG_ALIGN); 388 } 389 390 buf[j++] = adapter->num_tx_queues; 391 for (i = 0; i < adapter->num_tx_queues; i++) { 392 struct vmxnet3_tx_queue *tq = &adapter->tx_queue[i]; 393 394 buf[j++] = VMXNET3_READ_BAR0_REG(adapter, VMXNET3_REG_TXPROD + 395 i * VMXNET3_REG_ALIGN); 396 397 buf[j++] = VMXNET3_GET_ADDR_LO(tq->tx_ring.basePA); 398 buf[j++] = VMXNET3_GET_ADDR_HI(tq->tx_ring.basePA); 399 buf[j++] = tq->tx_ring.size; 400 buf[j++] = tq->tx_ring.next2fill; 401 buf[j++] = tq->tx_ring.next2comp; 402 buf[j++] = tq->tx_ring.gen; 403 404 buf[j++] = VMXNET3_GET_ADDR_LO(tq->data_ring.basePA); 405 buf[j++] = VMXNET3_GET_ADDR_HI(tq->data_ring.basePA); 406 buf[j++] = tq->data_ring.size; 407 buf[j++] = tq->txdata_desc_size; 408 409 buf[j++] = VMXNET3_GET_ADDR_LO(tq->comp_ring.basePA); 410 buf[j++] = VMXNET3_GET_ADDR_HI(tq->comp_ring.basePA); 411 buf[j++] = tq->comp_ring.size; 412 buf[j++] = tq->comp_ring.next2proc; 413 buf[j++] = tq->comp_ring.gen; 414 415 buf[j++] = tq->stopped; 416 } 417 418 buf[j++] = adapter->num_rx_queues; 419 for (i = 0; i < adapter->num_rx_queues; i++) { 420 struct vmxnet3_rx_queue *rq = &adapter->rx_queue[i]; 421 422 buf[j++] = VMXNET3_READ_BAR0_REG(adapter, VMXNET3_REG_RXPROD + 423 i * VMXNET3_REG_ALIGN); 424 buf[j++] = VMXNET3_READ_BAR0_REG(adapter, VMXNET3_REG_RXPROD2 + 425 i * VMXNET3_REG_ALIGN); 426 427 buf[j++] = VMXNET3_GET_ADDR_LO(rq->rx_ring[0].basePA); 428 buf[j++] = VMXNET3_GET_ADDR_HI(rq->rx_ring[0].basePA); 429 buf[j++] = rq->rx_ring[0].size; 430 buf[j++] = rq->rx_ring[0].next2fill; 431 buf[j++] = rq->rx_ring[0].next2comp; 432 buf[j++] = rq->rx_ring[0].gen; 433 434 buf[j++] = VMXNET3_GET_ADDR_LO(rq->rx_ring[1].basePA); 435 buf[j++] = VMXNET3_GET_ADDR_HI(rq->rx_ring[1].basePA); 436 buf[j++] = rq->rx_ring[1].size; 437 buf[j++] = rq->rx_ring[1].next2fill; 438 buf[j++] = rq->rx_ring[1].next2comp; 439 buf[j++] = rq->rx_ring[1].gen; 440 441 buf[j++] = VMXNET3_GET_ADDR_LO(rq->data_ring.basePA); 442 buf[j++] = VMXNET3_GET_ADDR_HI(rq->data_ring.basePA); 443 buf[j++] = rq->rx_ring[0].size; 444 buf[j++] = rq->data_ring.desc_size; 445 446 buf[j++] = VMXNET3_GET_ADDR_LO(rq->comp_ring.basePA); 447 buf[j++] = VMXNET3_GET_ADDR_HI(rq->comp_ring.basePA); 448 buf[j++] = rq->comp_ring.size; 449 buf[j++] = rq->comp_ring.next2proc; 450 buf[j++] = rq->comp_ring.gen; 451 } 452} 453 454 455static void 456vmxnet3_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 457{ 458 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 459 460 wol->supported = WAKE_UCAST | WAKE_ARP | WAKE_MAGIC; 461 wol->wolopts = adapter->wol; 462} 463 464 465static int 466vmxnet3_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 467{ 468 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 469 470 if (wol->wolopts & (WAKE_PHY | WAKE_MCAST | WAKE_BCAST | 471 WAKE_MAGICSECURE)) { 472 return -EOPNOTSUPP; 473 } 474 475 adapter->wol = wol->wolopts; 476 477 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 478 479 return 0; 480} 481 482 483static int 484vmxnet3_get_link_ksettings(struct net_device *netdev, 485 struct ethtool_link_ksettings *ecmd) 486{ 487 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 488 489 ethtool_link_ksettings_zero_link_mode(ecmd, supported); 490 ethtool_link_ksettings_add_link_mode(ecmd, supported, 10000baseT_Full); 491 ethtool_link_ksettings_add_link_mode(ecmd, supported, 1000baseT_Full); 492 ethtool_link_ksettings_add_link_mode(ecmd, supported, TP); 493 ethtool_link_ksettings_zero_link_mode(ecmd, advertising); 494 ethtool_link_ksettings_add_link_mode(ecmd, advertising, TP); 495 ecmd->base.port = PORT_TP; 496 497 if (adapter->link_speed) { 498 ecmd->base.speed = adapter->link_speed; 499 ecmd->base.duplex = DUPLEX_FULL; 500 } else { 501 ecmd->base.speed = SPEED_UNKNOWN; 502 ecmd->base.duplex = DUPLEX_UNKNOWN; 503 } 504 return 0; 505} 506 507 508static void 509vmxnet3_get_ringparam(struct net_device *netdev, 510 struct ethtool_ringparam *param) 511{ 512 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 513 514 param->rx_max_pending = VMXNET3_RX_RING_MAX_SIZE; 515 param->tx_max_pending = VMXNET3_TX_RING_MAX_SIZE; 516 param->rx_mini_max_pending = VMXNET3_VERSION_GE_3(adapter) ? 517 VMXNET3_RXDATA_DESC_MAX_SIZE : 0; 518 param->rx_jumbo_max_pending = VMXNET3_RX_RING2_MAX_SIZE; 519 520 param->rx_pending = adapter->rx_ring_size; 521 param->tx_pending = adapter->tx_ring_size; 522 param->rx_mini_pending = VMXNET3_VERSION_GE_3(adapter) ? 523 adapter->rxdata_desc_size : 0; 524 param->rx_jumbo_pending = adapter->rx_ring2_size; 525} 526 527 528static int 529vmxnet3_set_ringparam(struct net_device *netdev, 530 struct ethtool_ringparam *param) 531{ 532 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 533 u32 new_tx_ring_size, new_rx_ring_size, new_rx_ring2_size; 534 u16 new_rxdata_desc_size; 535 u32 sz; 536 int err = 0; 537 538 if (param->tx_pending == 0 || param->tx_pending > 539 VMXNET3_TX_RING_MAX_SIZE) 540 return -EINVAL; 541 542 if (param->rx_pending == 0 || param->rx_pending > 543 VMXNET3_RX_RING_MAX_SIZE) 544 return -EINVAL; 545 546 if (param->rx_jumbo_pending == 0 || 547 param->rx_jumbo_pending > VMXNET3_RX_RING2_MAX_SIZE) 548 return -EINVAL; 549 550 /* if adapter not yet initialized, do nothing */ 551 if (adapter->rx_buf_per_pkt == 0) { 552 netdev_err(netdev, "adapter not completely initialized, " 553 "ring size cannot be changed yet\n"); 554 return -EOPNOTSUPP; 555 } 556 557 if (VMXNET3_VERSION_GE_3(adapter)) { 558 if (param->rx_mini_pending > VMXNET3_RXDATA_DESC_MAX_SIZE) 559 return -EINVAL; 560 } else if (param->rx_mini_pending != 0) { 561 return -EINVAL; 562 } 563 564 /* round it up to a multiple of VMXNET3_RING_SIZE_ALIGN */ 565 new_tx_ring_size = (param->tx_pending + VMXNET3_RING_SIZE_MASK) & 566 ~VMXNET3_RING_SIZE_MASK; 567 new_tx_ring_size = min_t(u32, new_tx_ring_size, 568 VMXNET3_TX_RING_MAX_SIZE); 569 if (new_tx_ring_size > VMXNET3_TX_RING_MAX_SIZE || (new_tx_ring_size % 570 VMXNET3_RING_SIZE_ALIGN) != 0) 571 return -EINVAL; 572 573 /* ring0 has to be a multiple of 574 * rx_buf_per_pkt * VMXNET3_RING_SIZE_ALIGN 575 */ 576 sz = adapter->rx_buf_per_pkt * VMXNET3_RING_SIZE_ALIGN; 577 new_rx_ring_size = (param->rx_pending + sz - 1) / sz * sz; 578 new_rx_ring_size = min_t(u32, new_rx_ring_size, 579 VMXNET3_RX_RING_MAX_SIZE / sz * sz); 580 if (new_rx_ring_size > VMXNET3_RX_RING_MAX_SIZE || (new_rx_ring_size % 581 sz) != 0) 582 return -EINVAL; 583 584 /* ring2 has to be a multiple of VMXNET3_RING_SIZE_ALIGN */ 585 new_rx_ring2_size = (param->rx_jumbo_pending + VMXNET3_RING_SIZE_MASK) & 586 ~VMXNET3_RING_SIZE_MASK; 587 new_rx_ring2_size = min_t(u32, new_rx_ring2_size, 588 VMXNET3_RX_RING2_MAX_SIZE); 589 590 /* rx data ring buffer size has to be a multiple of 591 * VMXNET3_RXDATA_DESC_SIZE_ALIGN 592 */ 593 new_rxdata_desc_size = 594 (param->rx_mini_pending + VMXNET3_RXDATA_DESC_SIZE_MASK) & 595 ~VMXNET3_RXDATA_DESC_SIZE_MASK; 596 new_rxdata_desc_size = min_t(u16, new_rxdata_desc_size, 597 VMXNET3_RXDATA_DESC_MAX_SIZE); 598 599 if (new_tx_ring_size == adapter->tx_ring_size && 600 new_rx_ring_size == adapter->rx_ring_size && 601 new_rx_ring2_size == adapter->rx_ring2_size && 602 new_rxdata_desc_size == adapter->rxdata_desc_size) { 603 return 0; 604 } 605 606 /* 607 * Reset_work may be in the middle of resetting the device, wait for its 608 * completion. 609 */ 610 while (test_and_set_bit(VMXNET3_STATE_BIT_RESETTING, &adapter->state)) 611 usleep_range(1000, 2000); 612 613 if (netif_running(netdev)) { 614 vmxnet3_quiesce_dev(adapter); 615 vmxnet3_reset_dev(adapter); 616 617 /* recreate the rx queue and the tx queue based on the 618 * new sizes */ 619 vmxnet3_tq_destroy_all(adapter); 620 vmxnet3_rq_destroy_all(adapter); 621 622 err = vmxnet3_create_queues(adapter, new_tx_ring_size, 623 new_rx_ring_size, new_rx_ring2_size, 624 adapter->txdata_desc_size, 625 new_rxdata_desc_size); 626 if (err) { 627 /* failed, most likely because of OOM, try default 628 * size */ 629 netdev_err(netdev, "failed to apply new sizes, " 630 "try the default ones\n"); 631 new_rx_ring_size = VMXNET3_DEF_RX_RING_SIZE; 632 new_rx_ring2_size = VMXNET3_DEF_RX_RING2_SIZE; 633 new_tx_ring_size = VMXNET3_DEF_TX_RING_SIZE; 634 new_rxdata_desc_size = VMXNET3_VERSION_GE_3(adapter) ? 635 VMXNET3_DEF_RXDATA_DESC_SIZE : 0; 636 637 err = vmxnet3_create_queues(adapter, 638 new_tx_ring_size, 639 new_rx_ring_size, 640 new_rx_ring2_size, 641 adapter->txdata_desc_size, 642 new_rxdata_desc_size); 643 if (err) { 644 netdev_err(netdev, "failed to create queues " 645 "with default sizes. Closing it\n"); 646 goto out; 647 } 648 } 649 650 err = vmxnet3_activate_dev(adapter); 651 if (err) 652 netdev_err(netdev, "failed to re-activate, error %d." 653 " Closing it\n", err); 654 } 655 adapter->tx_ring_size = new_tx_ring_size; 656 adapter->rx_ring_size = new_rx_ring_size; 657 adapter->rx_ring2_size = new_rx_ring2_size; 658 adapter->rxdata_desc_size = new_rxdata_desc_size; 659 660out: 661 clear_bit(VMXNET3_STATE_BIT_RESETTING, &adapter->state); 662 if (err) 663 vmxnet3_force_close(adapter); 664 665 return err; 666} 667 668 669static int 670vmxnet3_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info, 671 u32 *rules) 672{ 673 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 674 switch (info->cmd) { 675 case ETHTOOL_GRXRINGS: 676 info->data = adapter->num_rx_queues; 677 return 0; 678 } 679 return -EOPNOTSUPP; 680} 681 682#ifdef VMXNET3_RSS 683static u32 684vmxnet3_get_rss_indir_size(struct net_device *netdev) 685{ 686 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 687 struct UPT1_RSSConf *rssConf = adapter->rss_conf; 688 689 return rssConf->indTableSize; 690} 691 692static int 693vmxnet3_get_rss(struct net_device *netdev, u32 *p, u8 *key, u8 *hfunc) 694{ 695 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 696 struct UPT1_RSSConf *rssConf = adapter->rss_conf; 697 unsigned int n = rssConf->indTableSize; 698 699 if (hfunc) 700 *hfunc = ETH_RSS_HASH_TOP; 701 if (!p) 702 return 0; 703 while (n--) 704 p[n] = rssConf->indTable[n]; 705 return 0; 706 707} 708 709static int 710vmxnet3_set_rss(struct net_device *netdev, const u32 *p, const u8 *key, 711 const u8 hfunc) 712{ 713 unsigned int i; 714 unsigned long flags; 715 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 716 struct UPT1_RSSConf *rssConf = adapter->rss_conf; 717 718 /* We do not allow change in unsupported parameters */ 719 if (key || 720 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)) 721 return -EOPNOTSUPP; 722 if (!p) 723 return 0; 724 for (i = 0; i < rssConf->indTableSize; i++) 725 rssConf->indTable[i] = p[i]; 726 727 spin_lock_irqsave(&adapter->cmd_lock, flags); 728 VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD, 729 VMXNET3_CMD_UPDATE_RSSIDT); 730 spin_unlock_irqrestore(&adapter->cmd_lock, flags); 731 732 return 0; 733 734} 735#endif 736 737static int 738vmxnet3_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *ec) 739{ 740 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 741 742 if (!VMXNET3_VERSION_GE_3(adapter)) 743 return -EOPNOTSUPP; 744 745 switch (adapter->coal_conf->coalMode) { 746 case VMXNET3_COALESCE_DISABLED: 747 /* struct ethtool_coalesce is already initialized to 0 */ 748 break; 749 case VMXNET3_COALESCE_ADAPT: 750 ec->use_adaptive_rx_coalesce = true; 751 break; 752 case VMXNET3_COALESCE_STATIC: 753 ec->tx_max_coalesced_frames = 754 adapter->coal_conf->coalPara.coalStatic.tx_comp_depth; 755 ec->rx_max_coalesced_frames = 756 adapter->coal_conf->coalPara.coalStatic.rx_depth; 757 break; 758 case VMXNET3_COALESCE_RBC: { 759 u32 rbc_rate; 760 761 rbc_rate = adapter->coal_conf->coalPara.coalRbc.rbc_rate; 762 ec->rx_coalesce_usecs = VMXNET3_COAL_RBC_USECS(rbc_rate); 763 } 764 break; 765 default: 766 return -EOPNOTSUPP; 767 } 768 769 return 0; 770} 771 772static int 773vmxnet3_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *ec) 774{ 775 struct vmxnet3_adapter *adapter = netdev_priv(netdev); 776 struct Vmxnet3_DriverShared *shared = adapter->shared; 777 union Vmxnet3_CmdInfo *cmdInfo = &shared->cu.cmdInfo; 778 unsigned long flags; 779 780 if (!VMXNET3_VERSION_GE_3(adapter)) 781 return -EOPNOTSUPP; 782 783 if ((ec->rx_coalesce_usecs == 0) && 784 (ec->use_adaptive_rx_coalesce == 0) && 785 (ec->tx_max_coalesced_frames == 0) && 786 (ec->rx_max_coalesced_frames == 0)) { 787 memset(adapter->coal_conf, 0, sizeof(*adapter->coal_conf)); 788 adapter->coal_conf->coalMode = VMXNET3_COALESCE_DISABLED; 789 goto done; 790 } 791 792 if (ec->rx_coalesce_usecs != 0) { 793 u32 rbc_rate; 794 795 if ((ec->use_adaptive_rx_coalesce != 0) || 796 (ec->tx_max_coalesced_frames != 0) || 797 (ec->rx_max_coalesced_frames != 0)) { 798 return -EINVAL; 799 } 800 801 rbc_rate = VMXNET3_COAL_RBC_RATE(ec->rx_coalesce_usecs); 802 if (rbc_rate < VMXNET3_COAL_RBC_MIN_RATE || 803 rbc_rate > VMXNET3_COAL_RBC_MAX_RATE) { 804 return -EINVAL; 805 } 806 807 memset(adapter->coal_conf, 0, sizeof(*adapter->coal_conf)); 808 adapter->coal_conf->coalMode = VMXNET3_COALESCE_RBC; 809 adapter->coal_conf->coalPara.coalRbc.rbc_rate = rbc_rate; 810 goto done; 811 } 812 813 if (ec->use_adaptive_rx_coalesce != 0) { 814 if ((ec->rx_coalesce_usecs != 0) || 815 (ec->tx_max_coalesced_frames != 0) || 816 (ec->rx_max_coalesced_frames != 0)) { 817 return -EINVAL; 818 } 819 memset(adapter->coal_conf, 0, sizeof(*adapter->coal_conf)); 820 adapter->coal_conf->coalMode = VMXNET3_COALESCE_ADAPT; 821 goto done; 822 } 823 824 if ((ec->tx_max_coalesced_frames != 0) || 825 (ec->rx_max_coalesced_frames != 0)) { 826 if ((ec->rx_coalesce_usecs != 0) || 827 (ec->use_adaptive_rx_coalesce != 0)) { 828 return -EINVAL; 829 } 830 831 if ((ec->tx_max_coalesced_frames > 832 VMXNET3_COAL_STATIC_MAX_DEPTH) || 833 (ec->rx_max_coalesced_frames > 834 VMXNET3_COAL_STATIC_MAX_DEPTH)) { 835 return -EINVAL; 836 } 837 838 memset(adapter->coal_conf, 0, sizeof(*adapter->coal_conf)); 839 adapter->coal_conf->coalMode = VMXNET3_COALESCE_STATIC; 840 841 adapter->coal_conf->coalPara.coalStatic.tx_comp_depth = 842 (ec->tx_max_coalesced_frames ? 843 ec->tx_max_coalesced_frames : 844 VMXNET3_COAL_STATIC_DEFAULT_DEPTH); 845 846 adapter->coal_conf->coalPara.coalStatic.rx_depth = 847 (ec->rx_max_coalesced_frames ? 848 ec->rx_max_coalesced_frames : 849 VMXNET3_COAL_STATIC_DEFAULT_DEPTH); 850 851 adapter->coal_conf->coalPara.coalStatic.tx_depth = 852 VMXNET3_COAL_STATIC_DEFAULT_DEPTH; 853 goto done; 854 } 855 856done: 857 adapter->default_coal_mode = false; 858 if (netif_running(netdev)) { 859 spin_lock_irqsave(&adapter->cmd_lock, flags); 860 cmdInfo->varConf.confVer = 1; 861 cmdInfo->varConf.confLen = 862 cpu_to_le32(sizeof(*adapter->coal_conf)); 863 cmdInfo->varConf.confPA = cpu_to_le64(adapter->coal_conf_pa); 864 VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD, 865 VMXNET3_CMD_SET_COALESCE); 866 spin_unlock_irqrestore(&adapter->cmd_lock, flags); 867 } 868 869 return 0; 870} 871 872static const struct ethtool_ops vmxnet3_ethtool_ops = { 873 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS | 874 ETHTOOL_COALESCE_MAX_FRAMES | 875 ETHTOOL_COALESCE_USE_ADAPTIVE_RX, 876 .get_drvinfo = vmxnet3_get_drvinfo, 877 .get_regs_len = vmxnet3_get_regs_len, 878 .get_regs = vmxnet3_get_regs, 879 .get_wol = vmxnet3_get_wol, 880 .set_wol = vmxnet3_set_wol, 881 .get_link = ethtool_op_get_link, 882 .get_coalesce = vmxnet3_get_coalesce, 883 .set_coalesce = vmxnet3_set_coalesce, 884 .get_strings = vmxnet3_get_strings, 885 .get_sset_count = vmxnet3_get_sset_count, 886 .get_ethtool_stats = vmxnet3_get_ethtool_stats, 887 .get_ringparam = vmxnet3_get_ringparam, 888 .set_ringparam = vmxnet3_set_ringparam, 889 .get_rxnfc = vmxnet3_get_rxnfc, 890#ifdef VMXNET3_RSS 891 .get_rxfh_indir_size = vmxnet3_get_rss_indir_size, 892 .get_rxfh = vmxnet3_get_rss, 893 .set_rxfh = vmxnet3_set_rss, 894#endif 895 .get_link_ksettings = vmxnet3_get_link_ksettings, 896}; 897 898void vmxnet3_set_ethtool_ops(struct net_device *netdev) 899{ 900 netdev->ethtool_ops = &vmxnet3_ethtool_ops; 901}