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