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