1 /* 2 * QLogic qlcnic NIC Driver 3 * Copyright (c) 2009-2013 QLogic Corporation 4 * 5 * See LICENSE.qlcnic for copyright and licensing details. 6 */ 7 8 #include <linux/types.h> 9 #include <linux/delay.h> 10 #include <linux/pci.h> 11 #include <linux/io.h> 12 #include <linux/netdevice.h> 13 #include <linux/ethtool.h> 14 15 #include "qlcnic.h" 16 17 struct qlcnic_stats { 18 char stat_string[ETH_GSTRING_LEN]; 19 int sizeof_stat; 20 int stat_offset; 21 }; 22 23 #define QLC_SIZEOF(m) FIELD_SIZEOF(struct qlcnic_adapter, m) 24 #define QLC_OFF(m) offsetof(struct qlcnic_adapter, m) 25 static const u32 qlcnic_fw_dump_level[] = { 26 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff 27 }; 28 29 static const struct qlcnic_stats qlcnic_gstrings_stats[] = { 30 {"xmit_called", QLC_SIZEOF(stats.xmitcalled), 31 QLC_OFF(stats.xmitcalled)}, 32 {"xmit_finished", QLC_SIZEOF(stats.xmitfinished), 33 QLC_OFF(stats.xmitfinished)}, 34 {"rx_dropped", QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)}, 35 {"tx_dropped", QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)}, 36 {"csummed", QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)}, 37 {"rx_pkts", QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)}, 38 {"lro_pkts", QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)}, 39 {"rx_bytes", QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)}, 40 {"tx_bytes", QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)}, 41 {"lrobytes", QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)}, 42 {"lso_frames", QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)}, 43 {"xmit_on", QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)}, 44 {"xmit_off", QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)}, 45 {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure), 46 QLC_OFF(stats.skb_alloc_failure)}, 47 {"null rxbuf", QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)}, 48 {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error), 49 QLC_OFF(stats.rx_dma_map_error)}, 50 {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error), 51 QLC_OFF(stats.tx_dma_map_error)}, 52 {"mac_filter_limit_overrun", QLC_SIZEOF(stats.mac_filter_limit_overrun), 53 QLC_OFF(stats.mac_filter_limit_overrun)}, 54 {"spurious intr", QLC_SIZEOF(stats.spurious_intr), 55 QLC_OFF(stats.spurious_intr)}, 56 57 }; 58 59 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = { 60 "rx unicast frames", 61 "rx multicast frames", 62 "rx broadcast frames", 63 "rx dropped frames", 64 "rx errors", 65 "rx local frames", 66 "rx numbytes", 67 "tx unicast frames", 68 "tx multicast frames", 69 "tx broadcast frames", 70 "tx dropped frames", 71 "tx errors", 72 "tx local frames", 73 "tx numbytes", 74 }; 75 76 static const char qlcnic_83xx_tx_stats_strings[][ETH_GSTRING_LEN] = { 77 "ctx_tx_bytes", 78 "ctx_tx_pkts", 79 "ctx_tx_errors", 80 "ctx_tx_dropped_pkts", 81 "ctx_tx_num_buffers", 82 }; 83 84 static const char qlcnic_83xx_mac_stats_strings[][ETH_GSTRING_LEN] = { 85 "mac_tx_frames", 86 "mac_tx_bytes", 87 "mac_tx_mcast_pkts", 88 "mac_tx_bcast_pkts", 89 "mac_tx_pause_cnt", 90 "mac_tx_ctrl_pkt", 91 "mac_tx_lt_64b_pkts", 92 "mac_tx_lt_127b_pkts", 93 "mac_tx_lt_255b_pkts", 94 "mac_tx_lt_511b_pkts", 95 "mac_tx_lt_1023b_pkts", 96 "mac_tx_lt_1518b_pkts", 97 "mac_tx_gt_1518b_pkts", 98 "mac_rx_frames", 99 "mac_rx_bytes", 100 "mac_rx_mcast_pkts", 101 "mac_rx_bcast_pkts", 102 "mac_rx_pause_cnt", 103 "mac_rx_ctrl_pkt", 104 "mac_rx_lt_64b_pkts", 105 "mac_rx_lt_127b_pkts", 106 "mac_rx_lt_255b_pkts", 107 "mac_rx_lt_511b_pkts", 108 "mac_rx_lt_1023b_pkts", 109 "mac_rx_lt_1518b_pkts", 110 "mac_rx_gt_1518b_pkts", 111 "mac_rx_length_error", 112 "mac_rx_length_small", 113 "mac_rx_length_large", 114 "mac_rx_jabber", 115 "mac_rx_dropped", 116 "mac_crc_error", 117 "mac_align_error", 118 "eswitch_frames", 119 "eswitch_bytes", 120 "eswitch_multicast_frames", 121 "eswitch_broadcast_frames", 122 "eswitch_unicast_frames", 123 "eswitch_error_free_frames", 124 "eswitch_error_free_bytes", 125 }; 126 127 #define QLCNIC_STATS_LEN ARRAY_SIZE(qlcnic_gstrings_stats) 128 129 static const char qlcnic_tx_ring_stats_strings[][ETH_GSTRING_LEN] = { 130 "xmit_on", 131 "xmit_off", 132 "xmit_called", 133 "xmit_finished", 134 }; 135 136 static const char qlcnic_83xx_rx_stats_strings[][ETH_GSTRING_LEN] = { 137 "ctx_rx_bytes", 138 "ctx_rx_pkts", 139 "ctx_lro_pkt_cnt", 140 "ctx_ip_csum_error", 141 "ctx_rx_pkts_wo_ctx", 142 "ctx_rx_pkts_drop_wo_sds_on_card", 143 "ctx_rx_pkts_drop_wo_sds_on_host", 144 "ctx_rx_osized_pkts", 145 "ctx_rx_pkts_dropped_wo_rds", 146 "ctx_rx_unexpected_mcast_pkts", 147 "ctx_invalid_mac_address", 148 "ctx_rx_rds_ring_prim_attempted", 149 "ctx_rx_rds_ring_prim_success", 150 "ctx_num_lro_flows_added", 151 "ctx_num_lro_flows_removed", 152 "ctx_num_lro_flows_active", 153 "ctx_pkts_dropped_unknown", 154 }; 155 156 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = { 157 "Register_Test_on_offline", 158 "Link_Test_on_offline", 159 "Interrupt_Test_offline", 160 "Internal_Loopback_offline", 161 "External_Loopback_offline", 162 "EEPROM_Test_offline" 163 }; 164 165 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test) 166 167 static inline int qlcnic_82xx_statistics(void) 168 { 169 return ARRAY_SIZE(qlcnic_device_gstrings_stats) + 170 ARRAY_SIZE(qlcnic_83xx_mac_stats_strings); 171 } 172 173 static inline int qlcnic_83xx_statistics(void) 174 { 175 return ARRAY_SIZE(qlcnic_83xx_tx_stats_strings) + 176 ARRAY_SIZE(qlcnic_83xx_mac_stats_strings) + 177 ARRAY_SIZE(qlcnic_83xx_rx_stats_strings); 178 } 179 180 static int qlcnic_dev_statistics_len(struct qlcnic_adapter *adapter) 181 { 182 if (qlcnic_82xx_check(adapter)) 183 return qlcnic_82xx_statistics(); 184 else if (qlcnic_83xx_check(adapter)) 185 return qlcnic_83xx_statistics(); 186 else 187 return -1; 188 } 189 190 #define QLCNIC_RING_REGS_COUNT 20 191 #define QLCNIC_RING_REGS_LEN (QLCNIC_RING_REGS_COUNT * sizeof(u32)) 192 #define QLCNIC_MAX_EEPROM_LEN 1024 193 194 static const u32 diag_registers[] = { 195 QLCNIC_CMDPEG_STATE, 196 QLCNIC_RCVPEG_STATE, 197 QLCNIC_FW_CAPABILITIES, 198 QLCNIC_CRB_DRV_ACTIVE, 199 QLCNIC_CRB_DEV_STATE, 200 QLCNIC_CRB_DRV_STATE, 201 QLCNIC_CRB_DRV_SCRATCH, 202 QLCNIC_CRB_DEV_PARTITION_INFO, 203 QLCNIC_CRB_DRV_IDC_VER, 204 QLCNIC_PEG_ALIVE_COUNTER, 205 QLCNIC_PEG_HALT_STATUS1, 206 QLCNIC_PEG_HALT_STATUS2, 207 -1 208 }; 209 210 211 static const u32 ext_diag_registers[] = { 212 CRB_XG_STATE_P3P, 213 ISR_INT_STATE_REG, 214 QLCNIC_CRB_PEG_NET_0+0x3c, 215 QLCNIC_CRB_PEG_NET_1+0x3c, 216 QLCNIC_CRB_PEG_NET_2+0x3c, 217 QLCNIC_CRB_PEG_NET_4+0x3c, 218 -1 219 }; 220 221 #define QLCNIC_MGMT_API_VERSION 2 222 #define QLCNIC_ETHTOOL_REGS_VER 3 223 224 static int qlcnic_get_regs_len(struct net_device *dev) 225 { 226 struct qlcnic_adapter *adapter = netdev_priv(dev); 227 u32 len; 228 229 if (qlcnic_83xx_check(adapter)) 230 len = qlcnic_83xx_get_regs_len(adapter); 231 else 232 len = sizeof(ext_diag_registers) + sizeof(diag_registers); 233 234 return QLCNIC_RING_REGS_LEN + len + QLCNIC_DEV_INFO_SIZE + 1; 235 } 236 237 static int qlcnic_get_eeprom_len(struct net_device *dev) 238 { 239 return QLCNIC_FLASH_TOTAL_SIZE; 240 } 241 242 static void 243 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) 244 { 245 struct qlcnic_adapter *adapter = netdev_priv(dev); 246 u32 fw_major, fw_minor, fw_build; 247 fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR); 248 fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR); 249 fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB); 250 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 251 "%d.%d.%d", fw_major, fw_minor, fw_build); 252 253 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 254 sizeof(drvinfo->bus_info)); 255 strlcpy(drvinfo->driver, qlcnic_driver_name, sizeof(drvinfo->driver)); 256 strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID, 257 sizeof(drvinfo->version)); 258 } 259 260 static int 261 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 262 { 263 struct qlcnic_adapter *adapter = netdev_priv(dev); 264 265 if (qlcnic_82xx_check(adapter)) 266 return qlcnic_82xx_get_settings(adapter, ecmd); 267 else if (qlcnic_83xx_check(adapter)) 268 return qlcnic_83xx_get_settings(adapter, ecmd); 269 270 return -EIO; 271 } 272 273 int qlcnic_82xx_get_settings(struct qlcnic_adapter *adapter, 274 struct ethtool_cmd *ecmd) 275 { 276 struct qlcnic_hardware_context *ahw = adapter->ahw; 277 u32 speed, reg; 278 int check_sfp_module = 0, err = 0; 279 u16 pcifn = ahw->pci_func; 280 281 /* read which mode */ 282 if (adapter->ahw->port_type == QLCNIC_GBE) { 283 ecmd->supported = (SUPPORTED_10baseT_Half | 284 SUPPORTED_10baseT_Full | 285 SUPPORTED_100baseT_Half | 286 SUPPORTED_100baseT_Full | 287 SUPPORTED_1000baseT_Half | 288 SUPPORTED_1000baseT_Full); 289 290 ecmd->advertising = (ADVERTISED_100baseT_Half | 291 ADVERTISED_100baseT_Full | 292 ADVERTISED_1000baseT_Half | 293 ADVERTISED_1000baseT_Full); 294 295 ethtool_cmd_speed_set(ecmd, adapter->ahw->link_speed); 296 ecmd->duplex = adapter->ahw->link_duplex; 297 ecmd->autoneg = adapter->ahw->link_autoneg; 298 299 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 300 u32 val = 0; 301 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR, &err); 302 303 if (val == QLCNIC_PORT_MODE_802_3_AP) { 304 ecmd->supported = SUPPORTED_1000baseT_Full; 305 ecmd->advertising = ADVERTISED_1000baseT_Full; 306 } else { 307 ecmd->supported = SUPPORTED_10000baseT_Full; 308 ecmd->advertising = ADVERTISED_10000baseT_Full; 309 } 310 311 if (netif_running(adapter->netdev) && ahw->has_link_events) { 312 if (ahw->linkup) { 313 reg = QLCRD32(adapter, 314 P3P_LINK_SPEED_REG(pcifn), &err); 315 speed = P3P_LINK_SPEED_VAL(pcifn, reg); 316 ahw->link_speed = speed * P3P_LINK_SPEED_MHZ; 317 } 318 319 ethtool_cmd_speed_set(ecmd, ahw->link_speed); 320 ecmd->autoneg = ahw->link_autoneg; 321 ecmd->duplex = ahw->link_duplex; 322 goto skip; 323 } 324 325 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN); 326 ecmd->duplex = DUPLEX_UNKNOWN; 327 ecmd->autoneg = AUTONEG_DISABLE; 328 } else 329 return -EIO; 330 331 skip: 332 ecmd->phy_address = adapter->ahw->physical_port; 333 ecmd->transceiver = XCVR_EXTERNAL; 334 335 switch (adapter->ahw->board_type) { 336 case QLCNIC_BRDTYPE_P3P_REF_QG: 337 case QLCNIC_BRDTYPE_P3P_4_GB: 338 case QLCNIC_BRDTYPE_P3P_4_GB_MM: 339 340 ecmd->supported |= SUPPORTED_Autoneg; 341 ecmd->advertising |= ADVERTISED_Autoneg; 342 case QLCNIC_BRDTYPE_P3P_10G_CX4: 343 case QLCNIC_BRDTYPE_P3P_10G_CX4_LP: 344 case QLCNIC_BRDTYPE_P3P_10000_BASE_T: 345 ecmd->supported |= SUPPORTED_TP; 346 ecmd->advertising |= ADVERTISED_TP; 347 ecmd->port = PORT_TP; 348 ecmd->autoneg = adapter->ahw->link_autoneg; 349 break; 350 case QLCNIC_BRDTYPE_P3P_IMEZ: 351 case QLCNIC_BRDTYPE_P3P_XG_LOM: 352 case QLCNIC_BRDTYPE_P3P_HMEZ: 353 ecmd->supported |= SUPPORTED_MII; 354 ecmd->advertising |= ADVERTISED_MII; 355 ecmd->port = PORT_MII; 356 ecmd->autoneg = AUTONEG_DISABLE; 357 break; 358 case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS: 359 case QLCNIC_BRDTYPE_P3P_10G_SFP_CT: 360 case QLCNIC_BRDTYPE_P3P_10G_SFP_QT: 361 ecmd->advertising |= ADVERTISED_TP; 362 ecmd->supported |= SUPPORTED_TP; 363 check_sfp_module = netif_running(adapter->netdev) && 364 ahw->has_link_events; 365 case QLCNIC_BRDTYPE_P3P_10G_XFP: 366 ecmd->supported |= SUPPORTED_FIBRE; 367 ecmd->advertising |= ADVERTISED_FIBRE; 368 ecmd->port = PORT_FIBRE; 369 ecmd->autoneg = AUTONEG_DISABLE; 370 break; 371 case QLCNIC_BRDTYPE_P3P_10G_TP: 372 if (adapter->ahw->port_type == QLCNIC_XGBE) { 373 ecmd->autoneg = AUTONEG_DISABLE; 374 ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP); 375 ecmd->advertising |= 376 (ADVERTISED_FIBRE | ADVERTISED_TP); 377 ecmd->port = PORT_FIBRE; 378 check_sfp_module = netif_running(adapter->netdev) && 379 ahw->has_link_events; 380 } else { 381 ecmd->autoneg = AUTONEG_ENABLE; 382 ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg); 383 ecmd->advertising |= 384 (ADVERTISED_TP | ADVERTISED_Autoneg); 385 ecmd->port = PORT_TP; 386 } 387 break; 388 default: 389 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n", 390 adapter->ahw->board_type); 391 return -EIO; 392 } 393 394 if (check_sfp_module) { 395 switch (adapter->ahw->module_type) { 396 case LINKEVENT_MODULE_OPTICAL_UNKNOWN: 397 case LINKEVENT_MODULE_OPTICAL_SRLR: 398 case LINKEVENT_MODULE_OPTICAL_LRM: 399 case LINKEVENT_MODULE_OPTICAL_SFP_1G: 400 ecmd->port = PORT_FIBRE; 401 break; 402 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE: 403 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN: 404 case LINKEVENT_MODULE_TWINAX: 405 ecmd->port = PORT_TP; 406 break; 407 default: 408 ecmd->port = PORT_OTHER; 409 } 410 } 411 412 return 0; 413 } 414 415 static int qlcnic_set_port_config(struct qlcnic_adapter *adapter, 416 struct ethtool_cmd *ecmd) 417 { 418 u32 ret = 0, config = 0; 419 /* read which mode */ 420 if (ecmd->duplex) 421 config |= 0x1; 422 423 if (ecmd->autoneg) 424 config |= 0x2; 425 426 switch (ethtool_cmd_speed(ecmd)) { 427 case SPEED_10: 428 config |= (0 << 8); 429 break; 430 case SPEED_100: 431 config |= (1 << 8); 432 break; 433 case SPEED_1000: 434 config |= (10 << 8); 435 break; 436 default: 437 return -EIO; 438 } 439 440 ret = qlcnic_fw_cmd_set_port(adapter, config); 441 442 if (ret == QLCNIC_RCODE_NOT_SUPPORTED) 443 return -EOPNOTSUPP; 444 else if (ret) 445 return -EIO; 446 return ret; 447 } 448 449 static int qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 450 { 451 u32 ret = 0; 452 struct qlcnic_adapter *adapter = netdev_priv(dev); 453 454 if (adapter->ahw->port_type != QLCNIC_GBE) 455 return -EOPNOTSUPP; 456 457 if (qlcnic_83xx_check(adapter)) 458 ret = qlcnic_83xx_set_settings(adapter, ecmd); 459 else 460 ret = qlcnic_set_port_config(adapter, ecmd); 461 462 if (!ret) 463 return ret; 464 465 adapter->ahw->link_speed = ethtool_cmd_speed(ecmd); 466 adapter->ahw->link_duplex = ecmd->duplex; 467 adapter->ahw->link_autoneg = ecmd->autoneg; 468 469 if (!netif_running(dev)) 470 return 0; 471 472 dev->netdev_ops->ndo_stop(dev); 473 return dev->netdev_ops->ndo_open(dev); 474 } 475 476 static int qlcnic_82xx_get_registers(struct qlcnic_adapter *adapter, 477 u32 *regs_buff) 478 { 479 int i, j = 0, err = 0; 480 481 for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++) 482 regs_buff[i] = QLC_SHARED_REG_RD32(adapter, diag_registers[j]); 483 j = 0; 484 while (ext_diag_registers[j] != -1) 485 regs_buff[i++] = QLCRD32(adapter, ext_diag_registers[j++], 486 &err); 487 return i; 488 } 489 490 static void 491 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p) 492 { 493 struct qlcnic_adapter *adapter = netdev_priv(dev); 494 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx; 495 struct qlcnic_host_sds_ring *sds_ring; 496 u32 *regs_buff = p; 497 int ring, i = 0; 498 499 memset(p, 0, qlcnic_get_regs_len(dev)); 500 501 regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) | 502 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device; 503 504 regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff)); 505 regs_buff[1] = QLCNIC_MGMT_API_VERSION; 506 507 if (qlcnic_82xx_check(adapter)) 508 i = qlcnic_82xx_get_registers(adapter, regs_buff); 509 else 510 i = qlcnic_83xx_get_registers(adapter, regs_buff); 511 512 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) 513 return; 514 515 regs_buff[i++] = 0xFFEFCDAB; /* Marker btw regs and ring count*/ 516 517 regs_buff[i++] = 1; /* No. of tx ring */ 518 regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer)); 519 regs_buff[i++] = readl(adapter->tx_ring->crb_cmd_producer); 520 521 regs_buff[i++] = 2; /* No. of rx ring */ 522 regs_buff[i++] = readl(recv_ctx->rds_rings[0].crb_rcv_producer); 523 regs_buff[i++] = readl(recv_ctx->rds_rings[1].crb_rcv_producer); 524 525 regs_buff[i++] = adapter->max_sds_rings; 526 527 for (ring = 0; ring < adapter->max_sds_rings; ring++) { 528 sds_ring = &(recv_ctx->sds_rings[ring]); 529 regs_buff[i++] = readl(sds_ring->crb_sts_consumer); 530 } 531 } 532 533 static u32 qlcnic_test_link(struct net_device *dev) 534 { 535 struct qlcnic_adapter *adapter = netdev_priv(dev); 536 int err = 0; 537 u32 val; 538 539 if (qlcnic_83xx_check(adapter)) { 540 val = qlcnic_83xx_test_link(adapter); 541 return (val & 1) ? 0 : 1; 542 } 543 val = QLCRD32(adapter, CRB_XG_STATE_P3P, &err); 544 if (err == -EIO) 545 return err; 546 val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val); 547 return (val == XG_LINK_UP_P3P) ? 0 : 1; 548 } 549 550 static int 551 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 552 u8 *bytes) 553 { 554 struct qlcnic_adapter *adapter = netdev_priv(dev); 555 int offset; 556 int ret = -1; 557 558 if (qlcnic_83xx_check(adapter)) 559 return 0; 560 if (eeprom->len == 0) 561 return -EINVAL; 562 563 eeprom->magic = (adapter->pdev)->vendor | 564 ((adapter->pdev)->device << 16); 565 offset = eeprom->offset; 566 567 if (qlcnic_82xx_check(adapter)) 568 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes, 569 eeprom->len); 570 if (ret < 0) 571 return ret; 572 573 return 0; 574 } 575 576 static void 577 qlcnic_get_ringparam(struct net_device *dev, 578 struct ethtool_ringparam *ring) 579 { 580 struct qlcnic_adapter *adapter = netdev_priv(dev); 581 582 ring->rx_pending = adapter->num_rxd; 583 ring->rx_jumbo_pending = adapter->num_jumbo_rxd; 584 ring->tx_pending = adapter->num_txd; 585 586 ring->rx_max_pending = adapter->max_rxd; 587 ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd; 588 ring->tx_max_pending = MAX_CMD_DESCRIPTORS; 589 } 590 591 static u32 592 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name) 593 { 594 u32 num_desc; 595 num_desc = max(val, min); 596 num_desc = min(num_desc, max); 597 num_desc = roundup_pow_of_two(num_desc); 598 599 if (val != num_desc) { 600 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n", 601 qlcnic_driver_name, r_name, num_desc, val); 602 } 603 604 return num_desc; 605 } 606 607 static int 608 qlcnic_set_ringparam(struct net_device *dev, 609 struct ethtool_ringparam *ring) 610 { 611 struct qlcnic_adapter *adapter = netdev_priv(dev); 612 u16 num_rxd, num_jumbo_rxd, num_txd; 613 614 if (ring->rx_mini_pending) 615 return -EOPNOTSUPP; 616 617 num_rxd = qlcnic_validate_ringparam(ring->rx_pending, 618 MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx"); 619 620 num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending, 621 MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd, 622 "rx jumbo"); 623 624 num_txd = qlcnic_validate_ringparam(ring->tx_pending, 625 MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx"); 626 627 if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd && 628 num_jumbo_rxd == adapter->num_jumbo_rxd) 629 return 0; 630 631 adapter->num_rxd = num_rxd; 632 adapter->num_jumbo_rxd = num_jumbo_rxd; 633 adapter->num_txd = num_txd; 634 635 return qlcnic_reset_context(adapter); 636 } 637 638 static void qlcnic_get_channels(struct net_device *dev, 639 struct ethtool_channels *channel) 640 { 641 struct qlcnic_adapter *adapter = netdev_priv(dev); 642 int min; 643 644 min = min_t(int, adapter->ahw->max_rx_ques, num_online_cpus()); 645 channel->max_rx = rounddown_pow_of_two(min); 646 channel->max_tx = min_t(int, QLCNIC_MAX_TX_RINGS, num_online_cpus()); 647 648 channel->rx_count = adapter->max_sds_rings; 649 channel->tx_count = adapter->max_drv_tx_rings; 650 } 651 652 static int qlcnic_set_channels(struct net_device *dev, 653 struct ethtool_channels *channel) 654 { 655 struct qlcnic_adapter *adapter = netdev_priv(dev); 656 int err; 657 int txq = 0; 658 659 if (channel->other_count || channel->combined_count) 660 return -EINVAL; 661 662 if (channel->rx_count) { 663 err = qlcnic_validate_max_rss(adapter, channel->rx_count); 664 if (err) 665 return err; 666 } 667 668 if (channel->tx_count) { 669 err = qlcnic_validate_max_tx_rings(adapter, channel->tx_count); 670 if (err) 671 return err; 672 txq = channel->tx_count; 673 } 674 675 err = qlcnic_set_max_rss(adapter, channel->rx_count, txq); 676 netdev_info(dev, "allocated 0x%x sds rings and 0x%x tx rings\n", 677 adapter->max_sds_rings, adapter->max_drv_tx_rings); 678 return err; 679 } 680 681 static void 682 qlcnic_get_pauseparam(struct net_device *netdev, 683 struct ethtool_pauseparam *pause) 684 { 685 struct qlcnic_adapter *adapter = netdev_priv(netdev); 686 int port = adapter->ahw->physical_port; 687 int err = 0; 688 __u32 val; 689 690 if (qlcnic_83xx_check(adapter)) { 691 qlcnic_83xx_get_pauseparam(adapter, pause); 692 return; 693 } 694 if (adapter->ahw->port_type == QLCNIC_GBE) { 695 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS)) 696 return; 697 /* get flow control settings */ 698 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err); 699 if (err == -EIO) 700 return; 701 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val); 702 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err); 703 if (err == -EIO) 704 return; 705 switch (port) { 706 case 0: 707 pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val)); 708 break; 709 case 1: 710 pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val)); 711 break; 712 case 2: 713 pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val)); 714 break; 715 case 3: 716 default: 717 pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val)); 718 break; 719 } 720 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 721 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS)) 722 return; 723 pause->rx_pause = 1; 724 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err); 725 if (err == -EIO) 726 return; 727 if (port == 0) 728 pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val)); 729 else 730 pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val)); 731 } else { 732 dev_err(&netdev->dev, "Unknown board type: %x\n", 733 adapter->ahw->port_type); 734 } 735 } 736 737 static int 738 qlcnic_set_pauseparam(struct net_device *netdev, 739 struct ethtool_pauseparam *pause) 740 { 741 struct qlcnic_adapter *adapter = netdev_priv(netdev); 742 int port = adapter->ahw->physical_port; 743 int err = 0; 744 __u32 val; 745 746 if (qlcnic_83xx_check(adapter)) 747 return qlcnic_83xx_set_pauseparam(adapter, pause); 748 749 /* read mode */ 750 if (adapter->ahw->port_type == QLCNIC_GBE) { 751 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS)) 752 return -EIO; 753 /* set flow control */ 754 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err); 755 if (err == -EIO) 756 return err; 757 758 if (pause->rx_pause) 759 qlcnic_gb_rx_flowctl(val); 760 else 761 qlcnic_gb_unset_rx_flowctl(val); 762 763 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), 764 val); 765 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), val); 766 /* set autoneg */ 767 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err); 768 if (err == -EIO) 769 return err; 770 switch (port) { 771 case 0: 772 if (pause->tx_pause) 773 qlcnic_gb_unset_gb0_mask(val); 774 else 775 qlcnic_gb_set_gb0_mask(val); 776 break; 777 case 1: 778 if (pause->tx_pause) 779 qlcnic_gb_unset_gb1_mask(val); 780 else 781 qlcnic_gb_set_gb1_mask(val); 782 break; 783 case 2: 784 if (pause->tx_pause) 785 qlcnic_gb_unset_gb2_mask(val); 786 else 787 qlcnic_gb_set_gb2_mask(val); 788 break; 789 case 3: 790 default: 791 if (pause->tx_pause) 792 qlcnic_gb_unset_gb3_mask(val); 793 else 794 qlcnic_gb_set_gb3_mask(val); 795 break; 796 } 797 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val); 798 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 799 if (!pause->rx_pause || pause->autoneg) 800 return -EOPNOTSUPP; 801 802 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS)) 803 return -EIO; 804 805 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err); 806 if (err == -EIO) 807 return err; 808 if (port == 0) { 809 if (pause->tx_pause) 810 qlcnic_xg_unset_xg0_mask(val); 811 else 812 qlcnic_xg_set_xg0_mask(val); 813 } else { 814 if (pause->tx_pause) 815 qlcnic_xg_unset_xg1_mask(val); 816 else 817 qlcnic_xg_set_xg1_mask(val); 818 } 819 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val); 820 } else { 821 dev_err(&netdev->dev, "Unknown board type: %x\n", 822 adapter->ahw->port_type); 823 } 824 return 0; 825 } 826 827 static int qlcnic_reg_test(struct net_device *dev) 828 { 829 struct qlcnic_adapter *adapter = netdev_priv(dev); 830 u32 data_read; 831 int err = 0; 832 833 if (qlcnic_83xx_check(adapter)) 834 return qlcnic_83xx_reg_test(adapter); 835 836 data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0), &err); 837 if (err == -EIO) 838 return err; 839 if ((data_read & 0xffff) != adapter->pdev->vendor) 840 return 1; 841 842 return 0; 843 } 844 845 static int qlcnic_eeprom_test(struct net_device *dev) 846 { 847 struct qlcnic_adapter *adapter = netdev_priv(dev); 848 849 if (qlcnic_82xx_check(adapter)) 850 return 0; 851 852 return qlcnic_83xx_flash_test(adapter); 853 } 854 855 static int qlcnic_get_sset_count(struct net_device *dev, int sset) 856 { 857 int len; 858 859 struct qlcnic_adapter *adapter = netdev_priv(dev); 860 switch (sset) { 861 case ETH_SS_TEST: 862 return QLCNIC_TEST_LEN; 863 case ETH_SS_STATS: 864 len = qlcnic_dev_statistics_len(adapter) + QLCNIC_STATS_LEN; 865 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) || 866 qlcnic_83xx_check(adapter)) 867 return len; 868 return qlcnic_82xx_statistics(); 869 default: 870 return -EOPNOTSUPP; 871 } 872 } 873 874 static int qlcnic_irq_test(struct net_device *netdev) 875 { 876 struct qlcnic_adapter *adapter = netdev_priv(netdev); 877 struct qlcnic_hardware_context *ahw = adapter->ahw; 878 struct qlcnic_cmd_args cmd; 879 int ret, max_sds_rings = adapter->max_sds_rings; 880 881 if (qlcnic_83xx_check(adapter)) 882 return qlcnic_83xx_interrupt_test(netdev); 883 884 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 885 return -EIO; 886 887 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST); 888 if (ret) 889 goto clear_diag_irq; 890 891 ahw->diag_cnt = 0; 892 ret = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_INTRPT_TEST); 893 if (ret) 894 goto free_diag_res; 895 896 cmd.req.arg[1] = ahw->pci_func; 897 ret = qlcnic_issue_cmd(adapter, &cmd); 898 if (ret) 899 goto done; 900 901 usleep_range(1000, 12000); 902 ret = !ahw->diag_cnt; 903 904 done: 905 qlcnic_free_mbx_args(&cmd); 906 907 free_diag_res: 908 qlcnic_diag_free_res(netdev, max_sds_rings); 909 910 clear_diag_irq: 911 adapter->max_sds_rings = max_sds_rings; 912 clear_bit(__QLCNIC_RESETTING, &adapter->state); 913 914 return ret; 915 } 916 917 #define QLCNIC_ILB_PKT_SIZE 64 918 #define QLCNIC_NUM_ILB_PKT 16 919 #define QLCNIC_ILB_MAX_RCV_LOOP 10 920 #define QLCNIC_LB_PKT_POLL_DELAY_MSEC 1 921 #define QLCNIC_LB_PKT_POLL_COUNT 20 922 923 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[]) 924 { 925 unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00}; 926 927 memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE); 928 929 memcpy(data, mac, ETH_ALEN); 930 memcpy(data + ETH_ALEN, mac, ETH_ALEN); 931 932 memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data)); 933 } 934 935 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[]) 936 { 937 unsigned char buff[QLCNIC_ILB_PKT_SIZE]; 938 qlcnic_create_loopback_buff(buff, mac); 939 return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE); 940 } 941 942 int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode) 943 { 944 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx; 945 struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0]; 946 struct sk_buff *skb; 947 int i, loop, cnt = 0; 948 949 for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) { 950 skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE); 951 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr); 952 skb_put(skb, QLCNIC_ILB_PKT_SIZE); 953 adapter->ahw->diag_cnt = 0; 954 qlcnic_xmit_frame(skb, adapter->netdev); 955 loop = 0; 956 957 do { 958 msleep(QLCNIC_LB_PKT_POLL_DELAY_MSEC); 959 qlcnic_process_rcv_ring_diag(sds_ring); 960 if (loop++ > QLCNIC_LB_PKT_POLL_COUNT) 961 break; 962 } while (!adapter->ahw->diag_cnt); 963 964 dev_kfree_skb_any(skb); 965 966 if (!adapter->ahw->diag_cnt) 967 dev_warn(&adapter->pdev->dev, 968 "LB Test: packet #%d was not received\n", 969 i + 1); 970 else 971 cnt++; 972 } 973 if (cnt != i) { 974 dev_err(&adapter->pdev->dev, 975 "LB Test: failed, TX[%d], RX[%d]\n", i, cnt); 976 if (mode != QLCNIC_ILB_MODE) 977 dev_warn(&adapter->pdev->dev, 978 "WARNING: Please check loopback cable\n"); 979 return -1; 980 } 981 return 0; 982 } 983 984 int qlcnic_loopback_test(struct net_device *netdev, u8 mode) 985 { 986 struct qlcnic_adapter *adapter = netdev_priv(netdev); 987 int max_drv_tx_rings = adapter->max_drv_tx_rings; 988 int max_sds_rings = adapter->max_sds_rings; 989 struct qlcnic_host_sds_ring *sds_ring; 990 struct qlcnic_hardware_context *ahw = adapter->ahw; 991 int loop = 0; 992 int ret; 993 994 if (qlcnic_83xx_check(adapter)) 995 return qlcnic_83xx_loopback_test(netdev, mode); 996 997 if (!(ahw->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) { 998 dev_info(&adapter->pdev->dev, 999 "Firmware do not support loopback test\n"); 1000 return -EOPNOTSUPP; 1001 } 1002 1003 dev_warn(&adapter->pdev->dev, "%s loopback test in progress\n", 1004 mode == QLCNIC_ILB_MODE ? "internal" : "external"); 1005 if (ahw->op_mode == QLCNIC_NON_PRIV_FUNC) { 1006 dev_warn(&adapter->pdev->dev, 1007 "Loopback test not supported in nonprivileged mode\n"); 1008 return 0; 1009 } 1010 1011 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 1012 return -EBUSY; 1013 1014 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST); 1015 if (ret) 1016 goto clear_it; 1017 1018 sds_ring = &adapter->recv_ctx->sds_rings[0]; 1019 ret = qlcnic_set_lb_mode(adapter, mode); 1020 if (ret) 1021 goto free_res; 1022 1023 ahw->diag_cnt = 0; 1024 do { 1025 msleep(500); 1026 qlcnic_process_rcv_ring_diag(sds_ring); 1027 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) { 1028 netdev_info(netdev, 1029 "Firmware didn't sent link up event to loopback request\n"); 1030 ret = -ETIMEDOUT; 1031 goto free_res; 1032 } else if (adapter->ahw->diag_cnt) { 1033 ret = adapter->ahw->diag_cnt; 1034 goto free_res; 1035 } 1036 } while (!QLCNIC_IS_LB_CONFIGURED(ahw->loopback_state)); 1037 1038 ret = qlcnic_do_lb_test(adapter, mode); 1039 1040 qlcnic_clear_lb_mode(adapter, mode); 1041 1042 free_res: 1043 qlcnic_diag_free_res(netdev, max_sds_rings); 1044 1045 clear_it: 1046 adapter->max_sds_rings = max_sds_rings; 1047 adapter->max_drv_tx_rings = max_drv_tx_rings; 1048 clear_bit(__QLCNIC_RESETTING, &adapter->state); 1049 return ret; 1050 } 1051 1052 static void 1053 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test, 1054 u64 *data) 1055 { 1056 memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN); 1057 1058 data[0] = qlcnic_reg_test(dev); 1059 if (data[0]) 1060 eth_test->flags |= ETH_TEST_FL_FAILED; 1061 1062 data[1] = (u64) qlcnic_test_link(dev); 1063 if (data[1]) 1064 eth_test->flags |= ETH_TEST_FL_FAILED; 1065 1066 if (eth_test->flags & ETH_TEST_FL_OFFLINE) { 1067 data[2] = qlcnic_irq_test(dev); 1068 if (data[2]) 1069 eth_test->flags |= ETH_TEST_FL_FAILED; 1070 1071 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE); 1072 if (data[3]) 1073 eth_test->flags |= ETH_TEST_FL_FAILED; 1074 1075 if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) { 1076 data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE); 1077 if (data[4]) 1078 eth_test->flags |= ETH_TEST_FL_FAILED; 1079 eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE; 1080 } 1081 1082 data[5] = qlcnic_eeprom_test(dev); 1083 if (data[5]) 1084 eth_test->flags |= ETH_TEST_FL_FAILED; 1085 } 1086 } 1087 1088 static void 1089 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 *data) 1090 { 1091 struct qlcnic_adapter *adapter = netdev_priv(dev); 1092 int index, i, num_stats; 1093 1094 switch (stringset) { 1095 case ETH_SS_TEST: 1096 memcpy(data, *qlcnic_gstrings_test, 1097 QLCNIC_TEST_LEN * ETH_GSTRING_LEN); 1098 break; 1099 case ETH_SS_STATS: 1100 num_stats = ARRAY_SIZE(qlcnic_tx_ring_stats_strings); 1101 for (i = 0; i < adapter->max_drv_tx_rings; i++) { 1102 for (index = 0; index < num_stats; index++) { 1103 sprintf(data, "tx_ring_%d %s", i, 1104 qlcnic_tx_ring_stats_strings[index]); 1105 data += ETH_GSTRING_LEN; 1106 } 1107 } 1108 1109 for (index = 0; index < QLCNIC_STATS_LEN; index++) { 1110 memcpy(data + index * ETH_GSTRING_LEN, 1111 qlcnic_gstrings_stats[index].stat_string, 1112 ETH_GSTRING_LEN); 1113 } 1114 1115 if (qlcnic_83xx_check(adapter)) { 1116 num_stats = ARRAY_SIZE(qlcnic_83xx_tx_stats_strings); 1117 for (i = 0; i < num_stats; i++, index++) 1118 memcpy(data + index * ETH_GSTRING_LEN, 1119 qlcnic_83xx_tx_stats_strings[i], 1120 ETH_GSTRING_LEN); 1121 num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings); 1122 for (i = 0; i < num_stats; i++, index++) 1123 memcpy(data + index * ETH_GSTRING_LEN, 1124 qlcnic_83xx_mac_stats_strings[i], 1125 ETH_GSTRING_LEN); 1126 num_stats = ARRAY_SIZE(qlcnic_83xx_rx_stats_strings); 1127 for (i = 0; i < num_stats; i++, index++) 1128 memcpy(data + index * ETH_GSTRING_LEN, 1129 qlcnic_83xx_rx_stats_strings[i], 1130 ETH_GSTRING_LEN); 1131 return; 1132 } else { 1133 num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings); 1134 for (i = 0; i < num_stats; i++, index++) 1135 memcpy(data + index * ETH_GSTRING_LEN, 1136 qlcnic_83xx_mac_stats_strings[i], 1137 ETH_GSTRING_LEN); 1138 } 1139 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) 1140 return; 1141 num_stats = ARRAY_SIZE(qlcnic_device_gstrings_stats); 1142 for (i = 0; i < num_stats; index++, i++) { 1143 memcpy(data + index * ETH_GSTRING_LEN, 1144 qlcnic_device_gstrings_stats[i], 1145 ETH_GSTRING_LEN); 1146 } 1147 } 1148 } 1149 1150 static u64 *qlcnic_fill_stats(u64 *data, void *stats, int type) 1151 { 1152 if (type == QLCNIC_MAC_STATS) { 1153 struct qlcnic_mac_statistics *mac_stats = 1154 (struct qlcnic_mac_statistics *)stats; 1155 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames); 1156 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes); 1157 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts); 1158 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts); 1159 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt); 1160 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt); 1161 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts); 1162 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts); 1163 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts); 1164 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts); 1165 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts); 1166 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts); 1167 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts); 1168 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames); 1169 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes); 1170 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts); 1171 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts); 1172 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt); 1173 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt); 1174 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts); 1175 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts); 1176 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts); 1177 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts); 1178 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts); 1179 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts); 1180 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts); 1181 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error); 1182 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small); 1183 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large); 1184 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber); 1185 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped); 1186 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error); 1187 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_align_error); 1188 } else if (type == QLCNIC_ESW_STATS) { 1189 struct __qlcnic_esw_statistics *esw_stats = 1190 (struct __qlcnic_esw_statistics *)stats; 1191 *data++ = QLCNIC_FILL_STATS(esw_stats->unicast_frames); 1192 *data++ = QLCNIC_FILL_STATS(esw_stats->multicast_frames); 1193 *data++ = QLCNIC_FILL_STATS(esw_stats->broadcast_frames); 1194 *data++ = QLCNIC_FILL_STATS(esw_stats->dropped_frames); 1195 *data++ = QLCNIC_FILL_STATS(esw_stats->errors); 1196 *data++ = QLCNIC_FILL_STATS(esw_stats->local_frames); 1197 *data++ = QLCNIC_FILL_STATS(esw_stats->numbytes); 1198 } 1199 return data; 1200 } 1201 1202 static void qlcnic_get_ethtool_stats(struct net_device *dev, 1203 struct ethtool_stats *stats, u64 *data) 1204 { 1205 struct qlcnic_adapter *adapter = netdev_priv(dev); 1206 struct qlcnic_host_tx_ring *tx_ring; 1207 struct qlcnic_esw_statistics port_stats; 1208 struct qlcnic_mac_statistics mac_stats; 1209 int index, ret, length, size, ring; 1210 char *p; 1211 1212 memset(data, 0, adapter->max_drv_tx_rings * 4 * sizeof(u64)); 1213 for (ring = 0, index = 0; ring < adapter->max_drv_tx_rings; ring++) { 1214 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) { 1215 tx_ring = &adapter->tx_ring[ring]; 1216 *data++ = tx_ring->xmit_on; 1217 *data++ = tx_ring->xmit_off; 1218 *data++ = tx_ring->xmit_called; 1219 *data++ = tx_ring->xmit_finished; 1220 } 1221 } 1222 memset(data, 0, stats->n_stats * sizeof(u64)); 1223 length = QLCNIC_STATS_LEN; 1224 for (index = 0; index < length; index++) { 1225 p = (char *)adapter + qlcnic_gstrings_stats[index].stat_offset; 1226 size = qlcnic_gstrings_stats[index].sizeof_stat; 1227 *data++ = (size == sizeof(u64)) ? (*(u64 *)p) : ((*(u32 *)p)); 1228 } 1229 1230 if (qlcnic_83xx_check(adapter)) { 1231 if (adapter->ahw->linkup) 1232 qlcnic_83xx_get_stats(adapter, data); 1233 return; 1234 } else { 1235 /* Retrieve MAC statistics from firmware */ 1236 memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics)); 1237 qlcnic_get_mac_stats(adapter, &mac_stats); 1238 data = qlcnic_fill_stats(data, &mac_stats, QLCNIC_MAC_STATS); 1239 } 1240 1241 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) 1242 return; 1243 1244 memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics)); 1245 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func, 1246 QLCNIC_QUERY_RX_COUNTER, &port_stats.rx); 1247 if (ret) 1248 return; 1249 1250 data = qlcnic_fill_stats(data, &port_stats.rx, QLCNIC_ESW_STATS); 1251 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func, 1252 QLCNIC_QUERY_TX_COUNTER, &port_stats.tx); 1253 if (ret) 1254 return; 1255 1256 qlcnic_fill_stats(data, &port_stats.tx, QLCNIC_ESW_STATS); 1257 } 1258 1259 static int qlcnic_set_led(struct net_device *dev, 1260 enum ethtool_phys_id_state state) 1261 { 1262 struct qlcnic_adapter *adapter = netdev_priv(dev); 1263 int max_sds_rings = adapter->max_sds_rings; 1264 int err = -EIO, active = 1; 1265 1266 if (qlcnic_83xx_check(adapter)) 1267 return qlcnic_83xx_set_led(dev, state); 1268 1269 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) { 1270 netdev_warn(dev, "LED test not supported for non " 1271 "privilege function\n"); 1272 return -EOPNOTSUPP; 1273 } 1274 1275 switch (state) { 1276 case ETHTOOL_ID_ACTIVE: 1277 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) 1278 return -EBUSY; 1279 1280 if (test_bit(__QLCNIC_RESETTING, &adapter->state)) 1281 break; 1282 1283 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) { 1284 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) 1285 break; 1286 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state); 1287 } 1288 1289 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) { 1290 err = 0; 1291 break; 1292 } 1293 1294 dev_err(&adapter->pdev->dev, 1295 "Failed to set LED blink state.\n"); 1296 break; 1297 1298 case ETHTOOL_ID_INACTIVE: 1299 active = 0; 1300 1301 if (test_bit(__QLCNIC_RESETTING, &adapter->state)) 1302 break; 1303 1304 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) { 1305 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) 1306 break; 1307 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state); 1308 } 1309 1310 if (adapter->nic_ops->config_led(adapter, 0, 0xf)) 1311 dev_err(&adapter->pdev->dev, 1312 "Failed to reset LED blink state.\n"); 1313 1314 break; 1315 1316 default: 1317 return -EINVAL; 1318 } 1319 1320 if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state)) 1321 qlcnic_diag_free_res(dev, max_sds_rings); 1322 1323 if (!active || err) 1324 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state); 1325 1326 return err; 1327 } 1328 1329 static void 1330 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1331 { 1332 struct qlcnic_adapter *adapter = netdev_priv(dev); 1333 u32 wol_cfg; 1334 int err = 0; 1335 1336 if (qlcnic_83xx_check(adapter)) 1337 return; 1338 wol->supported = 0; 1339 wol->wolopts = 0; 1340 1341 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err); 1342 if (err == -EIO) 1343 return; 1344 if (wol_cfg & (1UL << adapter->portnum)) 1345 wol->supported |= WAKE_MAGIC; 1346 1347 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err); 1348 if (wol_cfg & (1UL << adapter->portnum)) 1349 wol->wolopts |= WAKE_MAGIC; 1350 } 1351 1352 static int 1353 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1354 { 1355 struct qlcnic_adapter *adapter = netdev_priv(dev); 1356 u32 wol_cfg; 1357 int err = 0; 1358 1359 if (qlcnic_83xx_check(adapter)) 1360 return -EOPNOTSUPP; 1361 if (wol->wolopts & ~WAKE_MAGIC) 1362 return -EINVAL; 1363 1364 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err); 1365 if (err == -EIO) 1366 return err; 1367 if (!(wol_cfg & (1 << adapter->portnum))) 1368 return -EOPNOTSUPP; 1369 1370 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err); 1371 if (err == -EIO) 1372 return err; 1373 if (wol->wolopts & WAKE_MAGIC) 1374 wol_cfg |= 1UL << adapter->portnum; 1375 else 1376 wol_cfg &= ~(1UL << adapter->portnum); 1377 1378 QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg); 1379 1380 return 0; 1381 } 1382 1383 /* 1384 * Set the coalescing parameters. Currently only normal is supported. 1385 * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the 1386 * firmware coalescing to default. 1387 */ 1388 static int qlcnic_set_intr_coalesce(struct net_device *netdev, 1389 struct ethtool_coalesce *ethcoal) 1390 { 1391 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1392 struct qlcnic_nic_intr_coalesce *coal; 1393 u32 rx_coalesce_usecs, rx_max_frames; 1394 u32 tx_coalesce_usecs, tx_max_frames; 1395 1396 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) 1397 return -EINVAL; 1398 1399 /* 1400 * Return Error if unsupported values or 1401 * unsupported parameters are set. 1402 */ 1403 if (ethcoal->rx_coalesce_usecs > 0xffff || 1404 ethcoal->rx_max_coalesced_frames > 0xffff || 1405 ethcoal->tx_coalesce_usecs > 0xffff || 1406 ethcoal->tx_max_coalesced_frames > 0xffff || 1407 ethcoal->rx_coalesce_usecs_irq || 1408 ethcoal->rx_max_coalesced_frames_irq || 1409 ethcoal->tx_coalesce_usecs_irq || 1410 ethcoal->tx_max_coalesced_frames_irq || 1411 ethcoal->stats_block_coalesce_usecs || 1412 ethcoal->use_adaptive_rx_coalesce || 1413 ethcoal->use_adaptive_tx_coalesce || 1414 ethcoal->pkt_rate_low || 1415 ethcoal->rx_coalesce_usecs_low || 1416 ethcoal->rx_max_coalesced_frames_low || 1417 ethcoal->tx_coalesce_usecs_low || 1418 ethcoal->tx_max_coalesced_frames_low || 1419 ethcoal->pkt_rate_high || 1420 ethcoal->rx_coalesce_usecs_high || 1421 ethcoal->rx_max_coalesced_frames_high || 1422 ethcoal->tx_coalesce_usecs_high || 1423 ethcoal->tx_max_coalesced_frames_high) 1424 return -EINVAL; 1425 1426 coal = &adapter->ahw->coal; 1427 1428 if (qlcnic_83xx_check(adapter)) { 1429 if (!ethcoal->tx_coalesce_usecs || 1430 !ethcoal->tx_max_coalesced_frames || 1431 !ethcoal->rx_coalesce_usecs || 1432 !ethcoal->rx_max_coalesced_frames) { 1433 coal->flag = QLCNIC_INTR_DEFAULT; 1434 coal->type = QLCNIC_INTR_COAL_TYPE_RX; 1435 coal->rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US; 1436 coal->rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS; 1437 coal->tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US; 1438 coal->tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS; 1439 } else { 1440 tx_coalesce_usecs = ethcoal->tx_coalesce_usecs; 1441 tx_max_frames = ethcoal->tx_max_coalesced_frames; 1442 rx_coalesce_usecs = ethcoal->rx_coalesce_usecs; 1443 rx_max_frames = ethcoal->rx_max_coalesced_frames; 1444 coal->flag = 0; 1445 1446 if ((coal->rx_time_us == rx_coalesce_usecs) && 1447 (coal->rx_packets == rx_max_frames)) { 1448 coal->type = QLCNIC_INTR_COAL_TYPE_TX; 1449 coal->tx_time_us = tx_coalesce_usecs; 1450 coal->tx_packets = tx_max_frames; 1451 } else if ((coal->tx_time_us == tx_coalesce_usecs) && 1452 (coal->tx_packets == tx_max_frames)) { 1453 coal->type = QLCNIC_INTR_COAL_TYPE_RX; 1454 coal->rx_time_us = rx_coalesce_usecs; 1455 coal->rx_packets = rx_max_frames; 1456 } else { 1457 coal->type = QLCNIC_INTR_COAL_TYPE_RX; 1458 coal->rx_time_us = rx_coalesce_usecs; 1459 coal->rx_packets = rx_max_frames; 1460 coal->tx_time_us = tx_coalesce_usecs; 1461 coal->tx_packets = tx_max_frames; 1462 } 1463 } 1464 } else { 1465 if (!ethcoal->rx_coalesce_usecs || 1466 !ethcoal->rx_max_coalesced_frames) { 1467 coal->flag = QLCNIC_INTR_DEFAULT; 1468 coal->rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US; 1469 coal->rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS; 1470 } else { 1471 coal->flag = 0; 1472 coal->rx_time_us = ethcoal->rx_coalesce_usecs; 1473 coal->rx_packets = ethcoal->rx_max_coalesced_frames; 1474 } 1475 } 1476 1477 qlcnic_config_intr_coalesce(adapter); 1478 1479 return 0; 1480 } 1481 1482 static int qlcnic_get_intr_coalesce(struct net_device *netdev, 1483 struct ethtool_coalesce *ethcoal) 1484 { 1485 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1486 1487 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC) 1488 return -EINVAL; 1489 1490 ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us; 1491 ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets; 1492 ethcoal->tx_coalesce_usecs = adapter->ahw->coal.tx_time_us; 1493 ethcoal->tx_max_coalesced_frames = adapter->ahw->coal.tx_packets; 1494 1495 return 0; 1496 } 1497 1498 static u32 qlcnic_get_msglevel(struct net_device *netdev) 1499 { 1500 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1501 1502 return adapter->ahw->msg_enable; 1503 } 1504 1505 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl) 1506 { 1507 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1508 1509 adapter->ahw->msg_enable = msglvl; 1510 } 1511 1512 int qlcnic_enable_fw_dump_state(struct qlcnic_adapter *adapter) 1513 { 1514 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1515 u32 val; 1516 1517 if (qlcnic_84xx_check(adapter)) { 1518 if (qlcnic_83xx_lock_driver(adapter)) 1519 return -EBUSY; 1520 1521 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 1522 val &= ~QLC_83XX_IDC_DISABLE_FW_DUMP; 1523 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val); 1524 1525 qlcnic_83xx_unlock_driver(adapter); 1526 } else { 1527 fw_dump->enable = true; 1528 } 1529 1530 dev_info(&adapter->pdev->dev, "FW dump enabled\n"); 1531 1532 return 0; 1533 } 1534 1535 static int qlcnic_disable_fw_dump_state(struct qlcnic_adapter *adapter) 1536 { 1537 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1538 u32 val; 1539 1540 if (qlcnic_84xx_check(adapter)) { 1541 if (qlcnic_83xx_lock_driver(adapter)) 1542 return -EBUSY; 1543 1544 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 1545 val |= QLC_83XX_IDC_DISABLE_FW_DUMP; 1546 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val); 1547 1548 qlcnic_83xx_unlock_driver(adapter); 1549 } else { 1550 fw_dump->enable = false; 1551 } 1552 1553 dev_info(&adapter->pdev->dev, "FW dump disabled\n"); 1554 1555 return 0; 1556 } 1557 1558 bool qlcnic_check_fw_dump_state(struct qlcnic_adapter *adapter) 1559 { 1560 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1561 bool state; 1562 u32 val; 1563 1564 if (qlcnic_84xx_check(adapter)) { 1565 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL); 1566 state = (val & QLC_83XX_IDC_DISABLE_FW_DUMP) ? false : true; 1567 } else { 1568 state = fw_dump->enable; 1569 } 1570 1571 return state; 1572 } 1573 1574 static int 1575 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump) 1576 { 1577 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1578 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1579 1580 if (!fw_dump->tmpl_hdr) { 1581 netdev_err(adapter->netdev, "FW Dump not supported\n"); 1582 return -ENOTSUPP; 1583 } 1584 1585 if (fw_dump->clr) 1586 dump->len = fw_dump->tmpl_hdr->size + fw_dump->size; 1587 else 1588 dump->len = 0; 1589 1590 if (!qlcnic_check_fw_dump_state(adapter)) 1591 dump->flag = ETH_FW_DUMP_DISABLE; 1592 else 1593 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask; 1594 1595 dump->version = adapter->fw_version; 1596 return 0; 1597 } 1598 1599 static int 1600 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump, 1601 void *buffer) 1602 { 1603 int i, copy_sz; 1604 u32 *hdr_ptr; 1605 __le32 *data; 1606 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1607 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1608 1609 if (!fw_dump->tmpl_hdr) { 1610 netdev_err(netdev, "FW Dump not supported\n"); 1611 return -ENOTSUPP; 1612 } 1613 1614 if (!fw_dump->clr) { 1615 netdev_info(netdev, "Dump not available\n"); 1616 return -EINVAL; 1617 } 1618 /* Copy template header first */ 1619 copy_sz = fw_dump->tmpl_hdr->size; 1620 hdr_ptr = (u32 *) fw_dump->tmpl_hdr; 1621 data = buffer; 1622 for (i = 0; i < copy_sz/sizeof(u32); i++) 1623 *data++ = cpu_to_le32(*hdr_ptr++); 1624 1625 /* Copy captured dump data */ 1626 memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size); 1627 dump->len = copy_sz + fw_dump->size; 1628 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask; 1629 1630 /* Free dump area once data has been captured */ 1631 vfree(fw_dump->data); 1632 fw_dump->data = NULL; 1633 fw_dump->clr = 0; 1634 netdev_info(netdev, "extracted the FW dump Successfully\n"); 1635 return 0; 1636 } 1637 1638 static int qlcnic_set_dump_mask(struct qlcnic_adapter *adapter, u32 mask) 1639 { 1640 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1641 struct net_device *netdev = adapter->netdev; 1642 1643 if (!qlcnic_check_fw_dump_state(adapter)) { 1644 netdev_info(netdev, 1645 "Can not change driver mask to 0x%x. FW dump not enabled\n", 1646 mask); 1647 return -EOPNOTSUPP; 1648 } 1649 1650 fw_dump->tmpl_hdr->drv_cap_mask = mask; 1651 netdev_info(netdev, "Driver mask changed to: 0x%x\n", mask); 1652 return 0; 1653 } 1654 1655 static int 1656 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val) 1657 { 1658 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1659 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1660 bool valid_mask = false; 1661 int i, ret = 0; 1662 u32 state; 1663 1664 switch (val->flag) { 1665 case QLCNIC_FORCE_FW_DUMP_KEY: 1666 if (!fw_dump->tmpl_hdr) { 1667 netdev_err(netdev, "FW dump not supported\n"); 1668 ret = -EOPNOTSUPP; 1669 break; 1670 } 1671 1672 if (!qlcnic_check_fw_dump_state(adapter)) { 1673 netdev_info(netdev, "FW dump not enabled\n"); 1674 ret = -EOPNOTSUPP; 1675 break; 1676 } 1677 1678 if (fw_dump->clr) { 1679 netdev_info(netdev, 1680 "Previous dump not cleared, not forcing dump\n"); 1681 break; 1682 } 1683 1684 netdev_info(netdev, "Forcing a FW dump\n"); 1685 qlcnic_dev_request_reset(adapter, val->flag); 1686 break; 1687 case QLCNIC_DISABLE_FW_DUMP: 1688 if (!fw_dump->tmpl_hdr) { 1689 netdev_err(netdev, "FW dump not supported\n"); 1690 ret = -EOPNOTSUPP; 1691 break; 1692 } 1693 1694 ret = qlcnic_disable_fw_dump_state(adapter); 1695 break; 1696 1697 case QLCNIC_ENABLE_FW_DUMP: 1698 if (!fw_dump->tmpl_hdr) { 1699 netdev_err(netdev, "FW dump not supported\n"); 1700 ret = -EOPNOTSUPP; 1701 break; 1702 } 1703 1704 ret = qlcnic_enable_fw_dump_state(adapter); 1705 break; 1706 1707 case QLCNIC_FORCE_FW_RESET: 1708 netdev_info(netdev, "Forcing a FW reset\n"); 1709 qlcnic_dev_request_reset(adapter, val->flag); 1710 adapter->flags &= ~QLCNIC_FW_RESET_OWNER; 1711 break; 1712 1713 case QLCNIC_SET_QUIESCENT: 1714 case QLCNIC_RESET_QUIESCENT: 1715 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE); 1716 if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD)) 1717 netdev_info(netdev, "Device in FAILED state\n"); 1718 break; 1719 1720 default: 1721 if (!fw_dump->tmpl_hdr) { 1722 netdev_err(netdev, "FW dump not supported\n"); 1723 ret = -EOPNOTSUPP; 1724 break; 1725 } 1726 1727 for (i = 0; i < ARRAY_SIZE(qlcnic_fw_dump_level); i++) { 1728 if (val->flag == qlcnic_fw_dump_level[i]) { 1729 valid_mask = true; 1730 break; 1731 } 1732 } 1733 1734 if (valid_mask) { 1735 ret = qlcnic_set_dump_mask(adapter, val->flag); 1736 } else { 1737 netdev_info(netdev, "Invalid dump level: 0x%x\n", 1738 val->flag); 1739 ret = -EINVAL; 1740 } 1741 } 1742 return ret; 1743 } 1744 1745 const struct ethtool_ops qlcnic_ethtool_ops = { 1746 .get_settings = qlcnic_get_settings, 1747 .set_settings = qlcnic_set_settings, 1748 .get_drvinfo = qlcnic_get_drvinfo, 1749 .get_regs_len = qlcnic_get_regs_len, 1750 .get_regs = qlcnic_get_regs, 1751 .get_link = ethtool_op_get_link, 1752 .get_eeprom_len = qlcnic_get_eeprom_len, 1753 .get_eeprom = qlcnic_get_eeprom, 1754 .get_ringparam = qlcnic_get_ringparam, 1755 .set_ringparam = qlcnic_set_ringparam, 1756 .get_channels = qlcnic_get_channels, 1757 .set_channels = qlcnic_set_channels, 1758 .get_pauseparam = qlcnic_get_pauseparam, 1759 .set_pauseparam = qlcnic_set_pauseparam, 1760 .get_wol = qlcnic_get_wol, 1761 .set_wol = qlcnic_set_wol, 1762 .self_test = qlcnic_diag_test, 1763 .get_strings = qlcnic_get_strings, 1764 .get_ethtool_stats = qlcnic_get_ethtool_stats, 1765 .get_sset_count = qlcnic_get_sset_count, 1766 .get_coalesce = qlcnic_get_intr_coalesce, 1767 .set_coalesce = qlcnic_set_intr_coalesce, 1768 .set_phys_id = qlcnic_set_led, 1769 .set_msglevel = qlcnic_set_msglevel, 1770 .get_msglevel = qlcnic_get_msglevel, 1771 .get_dump_flag = qlcnic_get_dump_flag, 1772 .get_dump_data = qlcnic_get_dump_data, 1773 .set_dump = qlcnic_set_dump, 1774 }; 1775 1776 const struct ethtool_ops qlcnic_sriov_vf_ethtool_ops = { 1777 .get_settings = qlcnic_get_settings, 1778 .get_drvinfo = qlcnic_get_drvinfo, 1779 .get_regs_len = qlcnic_get_regs_len, 1780 .get_regs = qlcnic_get_regs, 1781 .get_link = ethtool_op_get_link, 1782 .get_eeprom_len = qlcnic_get_eeprom_len, 1783 .get_eeprom = qlcnic_get_eeprom, 1784 .get_ringparam = qlcnic_get_ringparam, 1785 .set_ringparam = qlcnic_set_ringparam, 1786 .get_channels = qlcnic_get_channels, 1787 .get_pauseparam = qlcnic_get_pauseparam, 1788 .get_wol = qlcnic_get_wol, 1789 .get_strings = qlcnic_get_strings, 1790 .get_ethtool_stats = qlcnic_get_ethtool_stats, 1791 .get_sset_count = qlcnic_get_sset_count, 1792 .get_coalesce = qlcnic_get_intr_coalesce, 1793 .set_coalesce = qlcnic_set_intr_coalesce, 1794 .set_msglevel = qlcnic_set_msglevel, 1795 .get_msglevel = qlcnic_get_msglevel, 1796 }; 1797