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