1 /* 2 * QLogic qlcnic NIC Driver 3 * Copyright (c) 2009-2010 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 26 static const struct qlcnic_stats qlcnic_gstrings_stats[] = { 27 {"xmit_called", 28 QLC_SIZEOF(stats.xmitcalled), QLC_OFF(stats.xmitcalled)}, 29 {"xmit_finished", 30 QLC_SIZEOF(stats.xmitfinished), QLC_OFF(stats.xmitfinished)}, 31 {"rx_dropped", 32 QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)}, 33 {"tx_dropped", 34 QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)}, 35 {"csummed", 36 QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)}, 37 {"rx_pkts", 38 QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)}, 39 {"lro_pkts", 40 QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)}, 41 {"rx_bytes", 42 QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)}, 43 {"tx_bytes", 44 QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)}, 45 {"lrobytes", 46 QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)}, 47 {"lso_frames", 48 QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)}, 49 {"xmit_on", 50 QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)}, 51 {"xmit_off", 52 QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)}, 53 {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure), 54 QLC_OFF(stats.skb_alloc_failure)}, 55 {"null rxbuf", 56 QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)}, 57 {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error), 58 QLC_OFF(stats.rx_dma_map_error)}, 59 {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error), 60 QLC_OFF(stats.tx_dma_map_error)}, 61 62 }; 63 64 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = { 65 "rx unicast frames", 66 "rx multicast frames", 67 "rx broadcast frames", 68 "rx dropped frames", 69 "rx errors", 70 "rx local frames", 71 "rx numbytes", 72 "tx unicast frames", 73 "tx multicast frames", 74 "tx broadcast frames", 75 "tx dropped frames", 76 "tx errors", 77 "tx local frames", 78 "tx numbytes", 79 }; 80 81 static const char qlcnic_mac_stats_strings [][ETH_GSTRING_LEN] = { 82 "mac_tx_frames", 83 "mac_tx_bytes", 84 "mac_tx_mcast_pkts", 85 "mac_tx_bcast_pkts", 86 "mac_tx_pause_cnt", 87 "mac_tx_ctrl_pkt", 88 "mac_tx_lt_64b_pkts", 89 "mac_tx_lt_127b_pkts", 90 "mac_tx_lt_255b_pkts", 91 "mac_tx_lt_511b_pkts", 92 "mac_tx_lt_1023b_pkts", 93 "mac_tx_lt_1518b_pkts", 94 "mac_tx_gt_1518b_pkts", 95 "mac_rx_frames", 96 "mac_rx_bytes", 97 "mac_rx_mcast_pkts", 98 "mac_rx_bcast_pkts", 99 "mac_rx_pause_cnt", 100 "mac_rx_ctrl_pkt", 101 "mac_rx_lt_64b_pkts", 102 "mac_rx_lt_127b_pkts", 103 "mac_rx_lt_255b_pkts", 104 "mac_rx_lt_511b_pkts", 105 "mac_rx_lt_1023b_pkts", 106 "mac_rx_lt_1518b_pkts", 107 "mac_rx_gt_1518b_pkts", 108 "mac_rx_length_error", 109 "mac_rx_length_small", 110 "mac_rx_length_large", 111 "mac_rx_jabber", 112 "mac_rx_dropped", 113 "mac_rx_crc_error", 114 "mac_align_error", 115 }; 116 117 #define QLCNIC_STATS_LEN ARRAY_SIZE(qlcnic_gstrings_stats) 118 #define QLCNIC_MAC_STATS_LEN ARRAY_SIZE(qlcnic_mac_stats_strings) 119 #define QLCNIC_DEVICE_STATS_LEN ARRAY_SIZE(qlcnic_device_gstrings_stats) 120 #define QLCNIC_TOTAL_STATS_LEN QLCNIC_STATS_LEN + QLCNIC_MAC_STATS_LEN 121 122 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = { 123 "Register_Test_on_offline", 124 "Link_Test_on_offline", 125 "Interrupt_Test_offline", 126 "Internal_Loopback_offline", 127 "External_Loopback_offline" 128 }; 129 130 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test) 131 132 #define QLCNIC_RING_REGS_COUNT 20 133 #define QLCNIC_RING_REGS_LEN (QLCNIC_RING_REGS_COUNT * sizeof(u32)) 134 #define QLCNIC_MAX_EEPROM_LEN 1024 135 136 static const u32 diag_registers[] = { 137 CRB_CMDPEG_STATE, 138 CRB_RCVPEG_STATE, 139 CRB_XG_STATE_P3P, 140 CRB_FW_CAPABILITIES_1, 141 ISR_INT_STATE_REG, 142 QLCNIC_CRB_DRV_ACTIVE, 143 QLCNIC_CRB_DEV_STATE, 144 QLCNIC_CRB_DRV_STATE, 145 QLCNIC_CRB_DRV_SCRATCH, 146 QLCNIC_CRB_DEV_PARTITION_INFO, 147 QLCNIC_CRB_DRV_IDC_VER, 148 QLCNIC_PEG_ALIVE_COUNTER, 149 QLCNIC_PEG_HALT_STATUS1, 150 QLCNIC_PEG_HALT_STATUS2, 151 QLCNIC_CRB_PEG_NET_0+0x3c, 152 QLCNIC_CRB_PEG_NET_1+0x3c, 153 QLCNIC_CRB_PEG_NET_2+0x3c, 154 QLCNIC_CRB_PEG_NET_4+0x3c, 155 -1 156 }; 157 158 #define QLCNIC_MGMT_API_VERSION 2 159 #define QLCNIC_DEV_INFO_SIZE 1 160 #define QLCNIC_ETHTOOL_REGS_VER 2 161 static int qlcnic_get_regs_len(struct net_device *dev) 162 { 163 return sizeof(diag_registers) + QLCNIC_RING_REGS_LEN + 164 QLCNIC_DEV_INFO_SIZE + 1; 165 } 166 167 static int qlcnic_get_eeprom_len(struct net_device *dev) 168 { 169 return QLCNIC_FLASH_TOTAL_SIZE; 170 } 171 172 static void 173 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) 174 { 175 struct qlcnic_adapter *adapter = netdev_priv(dev); 176 u32 fw_major, fw_minor, fw_build; 177 178 fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR); 179 fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR); 180 fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB); 181 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 182 "%d.%d.%d", fw_major, fw_minor, fw_build); 183 184 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 185 sizeof(drvinfo->bus_info)); 186 strlcpy(drvinfo->driver, qlcnic_driver_name, sizeof(drvinfo->driver)); 187 strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID, 188 sizeof(drvinfo->version)); 189 } 190 191 static int 192 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 193 { 194 struct qlcnic_adapter *adapter = netdev_priv(dev); 195 int check_sfp_module = 0; 196 197 /* read which mode */ 198 if (adapter->ahw->port_type == QLCNIC_GBE) { 199 ecmd->supported = (SUPPORTED_10baseT_Half | 200 SUPPORTED_10baseT_Full | 201 SUPPORTED_100baseT_Half | 202 SUPPORTED_100baseT_Full | 203 SUPPORTED_1000baseT_Half | 204 SUPPORTED_1000baseT_Full); 205 206 ecmd->advertising = (ADVERTISED_100baseT_Half | 207 ADVERTISED_100baseT_Full | 208 ADVERTISED_1000baseT_Half | 209 ADVERTISED_1000baseT_Full); 210 211 ethtool_cmd_speed_set(ecmd, adapter->ahw->link_speed); 212 ecmd->duplex = adapter->ahw->link_duplex; 213 ecmd->autoneg = adapter->ahw->link_autoneg; 214 215 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 216 u32 val; 217 218 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR); 219 if (val == QLCNIC_PORT_MODE_802_3_AP) { 220 ecmd->supported = SUPPORTED_1000baseT_Full; 221 ecmd->advertising = ADVERTISED_1000baseT_Full; 222 } else { 223 ecmd->supported = SUPPORTED_10000baseT_Full; 224 ecmd->advertising = ADVERTISED_10000baseT_Full; 225 } 226 227 if (netif_running(dev) && adapter->ahw->has_link_events) { 228 ethtool_cmd_speed_set(ecmd, adapter->ahw->link_speed); 229 ecmd->autoneg = adapter->ahw->link_autoneg; 230 ecmd->duplex = adapter->ahw->link_duplex; 231 goto skip; 232 } 233 234 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN); 235 ecmd->duplex = DUPLEX_UNKNOWN; 236 ecmd->autoneg = AUTONEG_DISABLE; 237 } else 238 return -EIO; 239 240 skip: 241 ecmd->phy_address = adapter->ahw->physical_port; 242 ecmd->transceiver = XCVR_EXTERNAL; 243 244 switch (adapter->ahw->board_type) { 245 case QLCNIC_BRDTYPE_P3P_REF_QG: 246 case QLCNIC_BRDTYPE_P3P_4_GB: 247 case QLCNIC_BRDTYPE_P3P_4_GB_MM: 248 249 ecmd->supported |= SUPPORTED_Autoneg; 250 ecmd->advertising |= ADVERTISED_Autoneg; 251 case QLCNIC_BRDTYPE_P3P_10G_CX4: 252 case QLCNIC_BRDTYPE_P3P_10G_CX4_LP: 253 case QLCNIC_BRDTYPE_P3P_10000_BASE_T: 254 ecmd->supported |= SUPPORTED_TP; 255 ecmd->advertising |= ADVERTISED_TP; 256 ecmd->port = PORT_TP; 257 ecmd->autoneg = adapter->ahw->link_autoneg; 258 break; 259 case QLCNIC_BRDTYPE_P3P_IMEZ: 260 case QLCNIC_BRDTYPE_P3P_XG_LOM: 261 case QLCNIC_BRDTYPE_P3P_HMEZ: 262 ecmd->supported |= SUPPORTED_MII; 263 ecmd->advertising |= ADVERTISED_MII; 264 ecmd->port = PORT_MII; 265 ecmd->autoneg = AUTONEG_DISABLE; 266 break; 267 case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS: 268 case QLCNIC_BRDTYPE_P3P_10G_SFP_CT: 269 case QLCNIC_BRDTYPE_P3P_10G_SFP_QT: 270 ecmd->advertising |= ADVERTISED_TP; 271 ecmd->supported |= SUPPORTED_TP; 272 check_sfp_module = netif_running(dev) && 273 adapter->ahw->has_link_events; 274 case QLCNIC_BRDTYPE_P3P_10G_XFP: 275 ecmd->supported |= SUPPORTED_FIBRE; 276 ecmd->advertising |= ADVERTISED_FIBRE; 277 ecmd->port = PORT_FIBRE; 278 ecmd->autoneg = AUTONEG_DISABLE; 279 break; 280 case QLCNIC_BRDTYPE_P3P_10G_TP: 281 if (adapter->ahw->port_type == QLCNIC_XGBE) { 282 ecmd->autoneg = AUTONEG_DISABLE; 283 ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP); 284 ecmd->advertising |= 285 (ADVERTISED_FIBRE | ADVERTISED_TP); 286 ecmd->port = PORT_FIBRE; 287 check_sfp_module = netif_running(dev) && 288 adapter->ahw->has_link_events; 289 } else { 290 ecmd->autoneg = AUTONEG_ENABLE; 291 ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg); 292 ecmd->advertising |= 293 (ADVERTISED_TP | ADVERTISED_Autoneg); 294 ecmd->port = PORT_TP; 295 } 296 break; 297 default: 298 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n", 299 adapter->ahw->board_type); 300 return -EIO; 301 } 302 303 if (check_sfp_module) { 304 switch (adapter->ahw->module_type) { 305 case LINKEVENT_MODULE_OPTICAL_UNKNOWN: 306 case LINKEVENT_MODULE_OPTICAL_SRLR: 307 case LINKEVENT_MODULE_OPTICAL_LRM: 308 case LINKEVENT_MODULE_OPTICAL_SFP_1G: 309 ecmd->port = PORT_FIBRE; 310 break; 311 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE: 312 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN: 313 case LINKEVENT_MODULE_TWINAX: 314 ecmd->port = PORT_TP; 315 break; 316 default: 317 ecmd->port = PORT_OTHER; 318 } 319 } 320 321 return 0; 322 } 323 324 static int 325 qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 326 { 327 u32 config = 0; 328 u32 ret = 0; 329 struct qlcnic_adapter *adapter = netdev_priv(dev); 330 331 if (adapter->ahw->port_type != QLCNIC_GBE) 332 return -EOPNOTSUPP; 333 334 /* read which mode */ 335 if (ecmd->duplex) 336 config |= 0x1; 337 338 if (ecmd->autoneg) 339 config |= 0x2; 340 341 switch (ethtool_cmd_speed(ecmd)) { 342 case SPEED_10: 343 config |= (0 << 8); 344 break; 345 case SPEED_100: 346 config |= (1 << 8); 347 break; 348 case SPEED_1000: 349 config |= (10 << 8); 350 break; 351 default: 352 return -EIO; 353 } 354 355 ret = qlcnic_fw_cmd_set_port(adapter, config); 356 357 if (ret == QLCNIC_RCODE_NOT_SUPPORTED) 358 return -EOPNOTSUPP; 359 else if (ret) 360 return -EIO; 361 362 adapter->ahw->link_speed = ethtool_cmd_speed(ecmd); 363 adapter->ahw->link_duplex = ecmd->duplex; 364 adapter->ahw->link_autoneg = ecmd->autoneg; 365 366 if (!netif_running(dev)) 367 return 0; 368 369 dev->netdev_ops->ndo_stop(dev); 370 return dev->netdev_ops->ndo_open(dev); 371 } 372 373 static void 374 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p) 375 { 376 struct qlcnic_adapter *adapter = netdev_priv(dev); 377 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx; 378 struct qlcnic_host_sds_ring *sds_ring; 379 u32 *regs_buff = p; 380 int ring, i = 0, j = 0; 381 382 memset(p, 0, qlcnic_get_regs_len(dev)); 383 regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) | 384 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device; 385 386 regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff)); 387 regs_buff[1] = QLCNIC_MGMT_API_VERSION; 388 389 for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++) 390 regs_buff[i] = QLCRD32(adapter, diag_registers[j]); 391 392 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) 393 return; 394 395 regs_buff[i++] = 0xFFEFCDAB; /* Marker btw regs and ring count*/ 396 397 regs_buff[i++] = 1; /* No. of tx ring */ 398 regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer)); 399 regs_buff[i++] = readl(adapter->tx_ring->crb_cmd_producer); 400 401 regs_buff[i++] = 2; /* No. of rx ring */ 402 regs_buff[i++] = readl(recv_ctx->rds_rings[0].crb_rcv_producer); 403 regs_buff[i++] = readl(recv_ctx->rds_rings[1].crb_rcv_producer); 404 405 regs_buff[i++] = adapter->max_sds_rings; 406 407 for (ring = 0; ring < adapter->max_sds_rings; ring++) { 408 sds_ring = &(recv_ctx->sds_rings[ring]); 409 regs_buff[i++] = readl(sds_ring->crb_sts_consumer); 410 } 411 } 412 413 static u32 qlcnic_test_link(struct net_device *dev) 414 { 415 struct qlcnic_adapter *adapter = netdev_priv(dev); 416 u32 val; 417 418 val = QLCRD32(adapter, CRB_XG_STATE_P3P); 419 val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val); 420 return (val == XG_LINK_UP_P3P) ? 0 : 1; 421 } 422 423 static int 424 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 425 u8 *bytes) 426 { 427 struct qlcnic_adapter *adapter = netdev_priv(dev); 428 int offset; 429 int ret; 430 431 if (eeprom->len == 0) 432 return -EINVAL; 433 434 eeprom->magic = (adapter->pdev)->vendor | 435 ((adapter->pdev)->device << 16); 436 offset = eeprom->offset; 437 438 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes, 439 eeprom->len); 440 if (ret < 0) 441 return ret; 442 443 return 0; 444 } 445 446 static void 447 qlcnic_get_ringparam(struct net_device *dev, 448 struct ethtool_ringparam *ring) 449 { 450 struct qlcnic_adapter *adapter = netdev_priv(dev); 451 452 ring->rx_pending = adapter->num_rxd; 453 ring->rx_jumbo_pending = adapter->num_jumbo_rxd; 454 ring->tx_pending = adapter->num_txd; 455 456 ring->rx_max_pending = adapter->max_rxd; 457 ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd; 458 ring->tx_max_pending = MAX_CMD_DESCRIPTORS; 459 } 460 461 static u32 462 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name) 463 { 464 u32 num_desc; 465 num_desc = max(val, min); 466 num_desc = min(num_desc, max); 467 num_desc = roundup_pow_of_two(num_desc); 468 469 if (val != num_desc) { 470 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n", 471 qlcnic_driver_name, r_name, num_desc, val); 472 } 473 474 return num_desc; 475 } 476 477 static int 478 qlcnic_set_ringparam(struct net_device *dev, 479 struct ethtool_ringparam *ring) 480 { 481 struct qlcnic_adapter *adapter = netdev_priv(dev); 482 u16 num_rxd, num_jumbo_rxd, num_txd; 483 484 if (ring->rx_mini_pending) 485 return -EOPNOTSUPP; 486 487 num_rxd = qlcnic_validate_ringparam(ring->rx_pending, 488 MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx"); 489 490 num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending, 491 MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd, 492 "rx jumbo"); 493 494 num_txd = qlcnic_validate_ringparam(ring->tx_pending, 495 MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx"); 496 497 if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd && 498 num_jumbo_rxd == adapter->num_jumbo_rxd) 499 return 0; 500 501 adapter->num_rxd = num_rxd; 502 adapter->num_jumbo_rxd = num_jumbo_rxd; 503 adapter->num_txd = num_txd; 504 505 return qlcnic_reset_context(adapter); 506 } 507 508 static void qlcnic_get_channels(struct net_device *dev, 509 struct ethtool_channels *channel) 510 { 511 int min; 512 struct qlcnic_adapter *adapter = netdev_priv(dev); 513 514 min = min_t(int, adapter->ahw->max_rx_ques, num_online_cpus()); 515 channel->max_rx = rounddown_pow_of_two(min); 516 channel->max_tx = adapter->ahw->max_tx_ques; 517 518 channel->rx_count = adapter->max_sds_rings; 519 channel->tx_count = adapter->ahw->max_tx_ques; 520 } 521 522 static int qlcnic_set_channels(struct net_device *dev, 523 struct ethtool_channels *channel) 524 { 525 struct qlcnic_adapter *adapter = netdev_priv(dev); 526 int err; 527 528 if (channel->other_count || channel->combined_count || 529 channel->tx_count != channel->max_tx) 530 return -EINVAL; 531 532 err = qlcnic_validate_max_rss(dev, channel->max_rx, channel->rx_count); 533 if (err) 534 return err; 535 536 err = qlcnic_set_max_rss(adapter, channel->rx_count); 537 netdev_info(dev, "allocated 0x%x sds rings\n", 538 adapter->max_sds_rings); 539 return err; 540 } 541 542 static void 543 qlcnic_get_pauseparam(struct net_device *netdev, 544 struct ethtool_pauseparam *pause) 545 { 546 struct qlcnic_adapter *adapter = netdev_priv(netdev); 547 int port = adapter->ahw->physical_port; 548 __u32 val; 549 550 if (adapter->ahw->port_type == QLCNIC_GBE) { 551 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS)) 552 return; 553 /* get flow control settings */ 554 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port)); 555 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val); 556 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL); 557 switch (port) { 558 case 0: 559 pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val)); 560 break; 561 case 1: 562 pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val)); 563 break; 564 case 2: 565 pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val)); 566 break; 567 case 3: 568 default: 569 pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val)); 570 break; 571 } 572 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 573 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS)) 574 return; 575 pause->rx_pause = 1; 576 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL); 577 if (port == 0) 578 pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val)); 579 else 580 pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val)); 581 } else { 582 dev_err(&netdev->dev, "Unknown board type: %x\n", 583 adapter->ahw->port_type); 584 } 585 } 586 587 static int 588 qlcnic_set_pauseparam(struct net_device *netdev, 589 struct ethtool_pauseparam *pause) 590 { 591 struct qlcnic_adapter *adapter = netdev_priv(netdev); 592 int port = adapter->ahw->physical_port; 593 __u32 val; 594 595 /* read mode */ 596 if (adapter->ahw->port_type == QLCNIC_GBE) { 597 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS)) 598 return -EIO; 599 /* set flow control */ 600 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port)); 601 602 if (pause->rx_pause) 603 qlcnic_gb_rx_flowctl(val); 604 else 605 qlcnic_gb_unset_rx_flowctl(val); 606 607 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), 608 val); 609 /* set autoneg */ 610 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL); 611 switch (port) { 612 case 0: 613 if (pause->tx_pause) 614 qlcnic_gb_unset_gb0_mask(val); 615 else 616 qlcnic_gb_set_gb0_mask(val); 617 break; 618 case 1: 619 if (pause->tx_pause) 620 qlcnic_gb_unset_gb1_mask(val); 621 else 622 qlcnic_gb_set_gb1_mask(val); 623 break; 624 case 2: 625 if (pause->tx_pause) 626 qlcnic_gb_unset_gb2_mask(val); 627 else 628 qlcnic_gb_set_gb2_mask(val); 629 break; 630 case 3: 631 default: 632 if (pause->tx_pause) 633 qlcnic_gb_unset_gb3_mask(val); 634 else 635 qlcnic_gb_set_gb3_mask(val); 636 break; 637 } 638 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val); 639 } else if (adapter->ahw->port_type == QLCNIC_XGBE) { 640 if (!pause->rx_pause || pause->autoneg) 641 return -EOPNOTSUPP; 642 643 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS)) 644 return -EIO; 645 646 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL); 647 if (port == 0) { 648 if (pause->tx_pause) 649 qlcnic_xg_unset_xg0_mask(val); 650 else 651 qlcnic_xg_set_xg0_mask(val); 652 } else { 653 if (pause->tx_pause) 654 qlcnic_xg_unset_xg1_mask(val); 655 else 656 qlcnic_xg_set_xg1_mask(val); 657 } 658 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val); 659 } else { 660 dev_err(&netdev->dev, "Unknown board type: %x\n", 661 adapter->ahw->port_type); 662 } 663 return 0; 664 } 665 666 static int qlcnic_reg_test(struct net_device *dev) 667 { 668 struct qlcnic_adapter *adapter = netdev_priv(dev); 669 u32 data_read; 670 671 data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0)); 672 if ((data_read & 0xffff) != adapter->pdev->vendor) 673 return 1; 674 675 return 0; 676 } 677 678 static int qlcnic_get_sset_count(struct net_device *dev, int sset) 679 { 680 struct qlcnic_adapter *adapter = netdev_priv(dev); 681 switch (sset) { 682 case ETH_SS_TEST: 683 return QLCNIC_TEST_LEN; 684 case ETH_SS_STATS: 685 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) 686 return QLCNIC_TOTAL_STATS_LEN + QLCNIC_DEVICE_STATS_LEN; 687 return QLCNIC_TOTAL_STATS_LEN; 688 default: 689 return -EOPNOTSUPP; 690 } 691 } 692 693 static int qlcnic_irq_test(struct net_device *netdev) 694 { 695 struct qlcnic_adapter *adapter = netdev_priv(netdev); 696 int max_sds_rings = adapter->max_sds_rings; 697 int ret; 698 struct qlcnic_cmd_args cmd; 699 700 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 701 return -EIO; 702 703 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST); 704 if (ret) 705 goto clear_it; 706 707 adapter->ahw->diag_cnt = 0; 708 memset(&cmd, 0, sizeof(cmd)); 709 cmd.req.cmd = QLCNIC_CDRP_CMD_INTRPT_TEST; 710 cmd.req.arg1 = adapter->ahw->pci_func; 711 qlcnic_issue_cmd(adapter, &cmd); 712 ret = cmd.rsp.cmd; 713 714 if (ret) 715 goto done; 716 717 msleep(10); 718 719 ret = !adapter->ahw->diag_cnt; 720 721 done: 722 qlcnic_diag_free_res(netdev, max_sds_rings); 723 724 clear_it: 725 adapter->max_sds_rings = max_sds_rings; 726 clear_bit(__QLCNIC_RESETTING, &adapter->state); 727 return ret; 728 } 729 730 #define QLCNIC_ILB_PKT_SIZE 64 731 #define QLCNIC_NUM_ILB_PKT 16 732 #define QLCNIC_ILB_MAX_RCV_LOOP 10 733 734 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[]) 735 { 736 unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00}; 737 738 memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE); 739 740 memcpy(data, mac, ETH_ALEN); 741 memcpy(data + ETH_ALEN, mac, ETH_ALEN); 742 743 memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data)); 744 } 745 746 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[]) 747 { 748 unsigned char buff[QLCNIC_ILB_PKT_SIZE]; 749 qlcnic_create_loopback_buff(buff, mac); 750 return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE); 751 } 752 753 static int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode) 754 { 755 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx; 756 struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0]; 757 struct sk_buff *skb; 758 int i, loop, cnt = 0; 759 760 for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) { 761 skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE); 762 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr); 763 skb_put(skb, QLCNIC_ILB_PKT_SIZE); 764 765 adapter->ahw->diag_cnt = 0; 766 qlcnic_xmit_frame(skb, adapter->netdev); 767 768 loop = 0; 769 do { 770 msleep(1); 771 qlcnic_process_rcv_ring_diag(sds_ring); 772 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) 773 break; 774 } while (!adapter->ahw->diag_cnt); 775 776 dev_kfree_skb_any(skb); 777 778 if (!adapter->ahw->diag_cnt) 779 QLCDB(adapter, DRV, 780 "LB Test: packet #%d was not received\n", i + 1); 781 else 782 cnt++; 783 } 784 if (cnt != i) { 785 dev_warn(&adapter->pdev->dev, "LB Test failed\n"); 786 if (mode != QLCNIC_ILB_MODE) { 787 dev_warn(&adapter->pdev->dev, 788 "WARNING: Please make sure external" 789 "loopback connector is plugged in\n"); 790 } 791 return -1; 792 } 793 return 0; 794 } 795 796 static int qlcnic_loopback_test(struct net_device *netdev, u8 mode) 797 { 798 struct qlcnic_adapter *adapter = netdev_priv(netdev); 799 int max_sds_rings = adapter->max_sds_rings; 800 struct qlcnic_host_sds_ring *sds_ring; 801 int loop = 0; 802 int ret; 803 804 if (!(adapter->ahw->capabilities & 805 QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) { 806 netdev_info(netdev, "Firmware is not loopback test capable\n"); 807 return -EOPNOTSUPP; 808 } 809 810 QLCDB(adapter, DRV, "%s loopback test in progress\n", 811 mode == QLCNIC_ILB_MODE ? "internal" : "external"); 812 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) { 813 netdev_warn(netdev, "Loopback test not supported for non " 814 "privilege function\n"); 815 return 0; 816 } 817 818 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 819 return -EBUSY; 820 821 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST); 822 if (ret) 823 goto clear_it; 824 825 sds_ring = &adapter->recv_ctx->sds_rings[0]; 826 827 ret = qlcnic_set_lb_mode(adapter, mode); 828 if (ret) 829 goto free_res; 830 831 adapter->ahw->diag_cnt = 0; 832 do { 833 msleep(500); 834 qlcnic_process_rcv_ring_diag(sds_ring); 835 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) { 836 netdev_info(netdev, "firmware didnt respond to loopback" 837 " configure request\n"); 838 ret = -QLCNIC_FW_NOT_RESPOND; 839 goto free_res; 840 } else if (adapter->ahw->diag_cnt) { 841 ret = adapter->ahw->diag_cnt; 842 goto free_res; 843 } 844 } while (!QLCNIC_IS_LB_CONFIGURED(adapter->ahw->loopback_state)); 845 846 ret = qlcnic_do_lb_test(adapter, mode); 847 848 qlcnic_clear_lb_mode(adapter); 849 850 free_res: 851 qlcnic_diag_free_res(netdev, max_sds_rings); 852 853 clear_it: 854 adapter->max_sds_rings = max_sds_rings; 855 clear_bit(__QLCNIC_RESETTING, &adapter->state); 856 return ret; 857 } 858 859 static void 860 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test, 861 u64 *data) 862 { 863 memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN); 864 865 data[0] = qlcnic_reg_test(dev); 866 if (data[0]) 867 eth_test->flags |= ETH_TEST_FL_FAILED; 868 869 data[1] = (u64) qlcnic_test_link(dev); 870 if (data[1]) 871 eth_test->flags |= ETH_TEST_FL_FAILED; 872 873 if (eth_test->flags & ETH_TEST_FL_OFFLINE) { 874 data[2] = qlcnic_irq_test(dev); 875 if (data[2]) 876 eth_test->flags |= ETH_TEST_FL_FAILED; 877 878 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE); 879 if (data[3]) 880 eth_test->flags |= ETH_TEST_FL_FAILED; 881 if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) { 882 data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE); 883 if (data[4]) 884 eth_test->flags |= ETH_TEST_FL_FAILED; 885 eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE; 886 } 887 } 888 } 889 890 static void 891 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 * data) 892 { 893 struct qlcnic_adapter *adapter = netdev_priv(dev); 894 int index, i, j; 895 896 switch (stringset) { 897 case ETH_SS_TEST: 898 memcpy(data, *qlcnic_gstrings_test, 899 QLCNIC_TEST_LEN * ETH_GSTRING_LEN); 900 break; 901 case ETH_SS_STATS: 902 for (index = 0; index < QLCNIC_STATS_LEN; index++) { 903 memcpy(data + index * ETH_GSTRING_LEN, 904 qlcnic_gstrings_stats[index].stat_string, 905 ETH_GSTRING_LEN); 906 } 907 for (j = 0; j < QLCNIC_MAC_STATS_LEN; index++, j++) { 908 memcpy(data + index * ETH_GSTRING_LEN, 909 qlcnic_mac_stats_strings[j], 910 ETH_GSTRING_LEN); 911 } 912 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) 913 return; 914 for (i = 0; i < QLCNIC_DEVICE_STATS_LEN; index++, i++) { 915 memcpy(data + index * ETH_GSTRING_LEN, 916 qlcnic_device_gstrings_stats[i], 917 ETH_GSTRING_LEN); 918 } 919 } 920 } 921 922 static void 923 qlcnic_fill_stats(int *index, u64 *data, void *stats, int type) 924 { 925 int ind = *index; 926 927 if (type == QLCNIC_MAC_STATS) { 928 struct qlcnic_mac_statistics *mac_stats = 929 (struct qlcnic_mac_statistics *)stats; 930 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames); 931 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes); 932 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts); 933 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts); 934 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt); 935 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt); 936 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts); 937 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts); 938 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts); 939 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts); 940 data[ind++] = 941 QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts); 942 data[ind++] = 943 QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts); 944 data[ind++] = 945 QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts); 946 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames); 947 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes); 948 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts); 949 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts); 950 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt); 951 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt); 952 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts); 953 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts); 954 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts); 955 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts); 956 data[ind++] = 957 QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts); 958 data[ind++] = 959 QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts); 960 data[ind++] = 961 QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts); 962 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error); 963 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small); 964 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large); 965 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber); 966 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped); 967 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error); 968 data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_align_error); 969 } else if (type == QLCNIC_ESW_STATS) { 970 struct __qlcnic_esw_statistics *esw_stats = 971 (struct __qlcnic_esw_statistics *)stats; 972 data[ind++] = QLCNIC_FILL_STATS(esw_stats->unicast_frames); 973 data[ind++] = QLCNIC_FILL_STATS(esw_stats->multicast_frames); 974 data[ind++] = QLCNIC_FILL_STATS(esw_stats->broadcast_frames); 975 data[ind++] = QLCNIC_FILL_STATS(esw_stats->dropped_frames); 976 data[ind++] = QLCNIC_FILL_STATS(esw_stats->errors); 977 data[ind++] = QLCNIC_FILL_STATS(esw_stats->local_frames); 978 data[ind++] = QLCNIC_FILL_STATS(esw_stats->numbytes); 979 } 980 981 *index = ind; 982 } 983 984 static void 985 qlcnic_get_ethtool_stats(struct net_device *dev, 986 struct ethtool_stats *stats, u64 * data) 987 { 988 struct qlcnic_adapter *adapter = netdev_priv(dev); 989 struct qlcnic_esw_statistics port_stats; 990 struct qlcnic_mac_statistics mac_stats; 991 int index, ret; 992 993 for (index = 0; index < QLCNIC_STATS_LEN; index++) { 994 char *p = 995 (char *)adapter + 996 qlcnic_gstrings_stats[index].stat_offset; 997 data[index] = 998 (qlcnic_gstrings_stats[index].sizeof_stat == 999 sizeof(u64)) ? *(u64 *)p:(*(u32 *)p); 1000 } 1001 1002 /* Retrieve MAC statistics from firmware */ 1003 memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics)); 1004 qlcnic_get_mac_stats(adapter, &mac_stats); 1005 qlcnic_fill_stats(&index, data, &mac_stats, QLCNIC_MAC_STATS); 1006 1007 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) 1008 return; 1009 1010 memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics)); 1011 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func, 1012 QLCNIC_QUERY_RX_COUNTER, &port_stats.rx); 1013 if (ret) 1014 return; 1015 1016 qlcnic_fill_stats(&index, data, &port_stats.rx, QLCNIC_ESW_STATS); 1017 1018 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func, 1019 QLCNIC_QUERY_TX_COUNTER, &port_stats.tx); 1020 if (ret) 1021 return; 1022 1023 qlcnic_fill_stats(&index, data, &port_stats.tx, QLCNIC_ESW_STATS); 1024 } 1025 1026 static int qlcnic_set_led(struct net_device *dev, 1027 enum ethtool_phys_id_state state) 1028 { 1029 struct qlcnic_adapter *adapter = netdev_priv(dev); 1030 int max_sds_rings = adapter->max_sds_rings; 1031 int err = -EIO, active = 1; 1032 1033 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) { 1034 netdev_warn(dev, "LED test not supported for non " 1035 "privilege function\n"); 1036 return -EOPNOTSUPP; 1037 } 1038 1039 switch (state) { 1040 case ETHTOOL_ID_ACTIVE: 1041 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) 1042 return -EBUSY; 1043 1044 if (test_bit(__QLCNIC_RESETTING, &adapter->state)) 1045 break; 1046 1047 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) { 1048 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) 1049 break; 1050 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state); 1051 } 1052 1053 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) { 1054 err = 0; 1055 break; 1056 } 1057 1058 dev_err(&adapter->pdev->dev, 1059 "Failed to set LED blink state.\n"); 1060 break; 1061 1062 case ETHTOOL_ID_INACTIVE: 1063 active = 0; 1064 1065 if (test_bit(__QLCNIC_RESETTING, &adapter->state)) 1066 break; 1067 1068 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) { 1069 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) 1070 break; 1071 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state); 1072 } 1073 1074 if (adapter->nic_ops->config_led(adapter, 0, 0xf)) 1075 dev_err(&adapter->pdev->dev, 1076 "Failed to reset LED blink state.\n"); 1077 1078 break; 1079 1080 default: 1081 return -EINVAL; 1082 } 1083 1084 if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state)) 1085 qlcnic_diag_free_res(dev, max_sds_rings); 1086 1087 if (!active || err) 1088 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state); 1089 1090 return err; 1091 } 1092 1093 static void 1094 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1095 { 1096 struct qlcnic_adapter *adapter = netdev_priv(dev); 1097 u32 wol_cfg; 1098 1099 wol->supported = 0; 1100 wol->wolopts = 0; 1101 1102 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV); 1103 if (wol_cfg & (1UL << adapter->portnum)) 1104 wol->supported |= WAKE_MAGIC; 1105 1106 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG); 1107 if (wol_cfg & (1UL << adapter->portnum)) 1108 wol->wolopts |= WAKE_MAGIC; 1109 } 1110 1111 static int 1112 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1113 { 1114 struct qlcnic_adapter *adapter = netdev_priv(dev); 1115 u32 wol_cfg; 1116 1117 if (wol->wolopts & ~WAKE_MAGIC) 1118 return -EOPNOTSUPP; 1119 1120 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV); 1121 if (!(wol_cfg & (1 << adapter->portnum))) 1122 return -EOPNOTSUPP; 1123 1124 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG); 1125 if (wol->wolopts & WAKE_MAGIC) 1126 wol_cfg |= 1UL << adapter->portnum; 1127 else 1128 wol_cfg &= ~(1UL << adapter->portnum); 1129 1130 QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg); 1131 1132 return 0; 1133 } 1134 1135 /* 1136 * Set the coalescing parameters. Currently only normal is supported. 1137 * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the 1138 * firmware coalescing to default. 1139 */ 1140 static int qlcnic_set_intr_coalesce(struct net_device *netdev, 1141 struct ethtool_coalesce *ethcoal) 1142 { 1143 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1144 1145 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) 1146 return -EINVAL; 1147 1148 /* 1149 * Return Error if unsupported values or 1150 * unsupported parameters are set. 1151 */ 1152 if (ethcoal->rx_coalesce_usecs > 0xffff || 1153 ethcoal->rx_max_coalesced_frames > 0xffff || 1154 ethcoal->tx_coalesce_usecs || 1155 ethcoal->tx_max_coalesced_frames || 1156 ethcoal->rx_coalesce_usecs_irq || 1157 ethcoal->rx_max_coalesced_frames_irq || 1158 ethcoal->tx_coalesce_usecs_irq || 1159 ethcoal->tx_max_coalesced_frames_irq || 1160 ethcoal->stats_block_coalesce_usecs || 1161 ethcoal->use_adaptive_rx_coalesce || 1162 ethcoal->use_adaptive_tx_coalesce || 1163 ethcoal->pkt_rate_low || 1164 ethcoal->rx_coalesce_usecs_low || 1165 ethcoal->rx_max_coalesced_frames_low || 1166 ethcoal->tx_coalesce_usecs_low || 1167 ethcoal->tx_max_coalesced_frames_low || 1168 ethcoal->pkt_rate_high || 1169 ethcoal->rx_coalesce_usecs_high || 1170 ethcoal->rx_max_coalesced_frames_high || 1171 ethcoal->tx_coalesce_usecs_high || 1172 ethcoal->tx_max_coalesced_frames_high) 1173 return -EINVAL; 1174 1175 if (!ethcoal->rx_coalesce_usecs || 1176 !ethcoal->rx_max_coalesced_frames) { 1177 adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT; 1178 adapter->ahw->coal.rx_time_us = 1179 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US; 1180 adapter->ahw->coal.rx_packets = 1181 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS; 1182 } else { 1183 adapter->ahw->coal.flag = 0; 1184 adapter->ahw->coal.rx_time_us = ethcoal->rx_coalesce_usecs; 1185 adapter->ahw->coal.rx_packets = 1186 ethcoal->rx_max_coalesced_frames; 1187 } 1188 1189 qlcnic_config_intr_coalesce(adapter); 1190 1191 return 0; 1192 } 1193 1194 static int qlcnic_get_intr_coalesce(struct net_device *netdev, 1195 struct ethtool_coalesce *ethcoal) 1196 { 1197 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1198 1199 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC) 1200 return -EINVAL; 1201 1202 ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us; 1203 ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets; 1204 1205 return 0; 1206 } 1207 1208 static u32 qlcnic_get_msglevel(struct net_device *netdev) 1209 { 1210 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1211 1212 return adapter->ahw->msg_enable; 1213 } 1214 1215 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl) 1216 { 1217 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1218 1219 adapter->ahw->msg_enable = msglvl; 1220 } 1221 1222 static int 1223 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump) 1224 { 1225 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1226 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1227 1228 if (!fw_dump->tmpl_hdr) { 1229 netdev_err(adapter->netdev, "FW Dump not supported\n"); 1230 return -ENOTSUPP; 1231 } 1232 1233 if (fw_dump->clr) 1234 dump->len = fw_dump->tmpl_hdr->size + fw_dump->size; 1235 else 1236 dump->len = 0; 1237 1238 if (!fw_dump->enable) 1239 dump->flag = ETH_FW_DUMP_DISABLE; 1240 else 1241 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask; 1242 1243 dump->version = adapter->fw_version; 1244 return 0; 1245 } 1246 1247 static int 1248 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump, 1249 void *buffer) 1250 { 1251 int i, copy_sz; 1252 u32 *hdr_ptr; 1253 __le32 *data; 1254 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1255 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1256 1257 if (!fw_dump->tmpl_hdr) { 1258 netdev_err(netdev, "FW Dump not supported\n"); 1259 return -ENOTSUPP; 1260 } 1261 1262 if (!fw_dump->clr) { 1263 netdev_info(netdev, "Dump not available\n"); 1264 return -EINVAL; 1265 } 1266 /* Copy template header first */ 1267 copy_sz = fw_dump->tmpl_hdr->size; 1268 hdr_ptr = (u32 *) fw_dump->tmpl_hdr; 1269 data = buffer; 1270 for (i = 0; i < copy_sz/sizeof(u32); i++) 1271 *data++ = cpu_to_le32(*hdr_ptr++); 1272 1273 /* Copy captured dump data */ 1274 memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size); 1275 dump->len = copy_sz + fw_dump->size; 1276 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask; 1277 1278 /* Free dump area once data has been captured */ 1279 vfree(fw_dump->data); 1280 fw_dump->data = NULL; 1281 fw_dump->clr = 0; 1282 netdev_info(netdev, "extracted the FW dump Successfully\n"); 1283 return 0; 1284 } 1285 1286 static int 1287 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val) 1288 { 1289 int i; 1290 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1291 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump; 1292 u32 state; 1293 1294 switch (val->flag) { 1295 case QLCNIC_FORCE_FW_DUMP_KEY: 1296 if (!fw_dump->tmpl_hdr) { 1297 netdev_err(netdev, "FW dump not supported\n"); 1298 return -ENOTSUPP; 1299 } 1300 if (!fw_dump->enable) { 1301 netdev_info(netdev, "FW dump not enabled\n"); 1302 return 0; 1303 } 1304 if (fw_dump->clr) { 1305 netdev_info(netdev, 1306 "Previous dump not cleared, not forcing dump\n"); 1307 return 0; 1308 } 1309 netdev_info(netdev, "Forcing a FW dump\n"); 1310 qlcnic_dev_request_reset(adapter); 1311 break; 1312 case QLCNIC_DISABLE_FW_DUMP: 1313 if (fw_dump->enable && fw_dump->tmpl_hdr) { 1314 netdev_info(netdev, "Disabling FW dump\n"); 1315 fw_dump->enable = 0; 1316 } 1317 return 0; 1318 case QLCNIC_ENABLE_FW_DUMP: 1319 if (!fw_dump->tmpl_hdr) { 1320 netdev_err(netdev, "FW dump not supported\n"); 1321 return -ENOTSUPP; 1322 } 1323 if (!fw_dump->enable) { 1324 netdev_info(netdev, "Enabling FW dump\n"); 1325 fw_dump->enable = 1; 1326 } 1327 return 0; 1328 case QLCNIC_FORCE_FW_RESET: 1329 netdev_info(netdev, "Forcing a FW reset\n"); 1330 qlcnic_dev_request_reset(adapter); 1331 adapter->flags &= ~QLCNIC_FW_RESET_OWNER; 1332 return 0; 1333 case QLCNIC_SET_QUIESCENT: 1334 case QLCNIC_RESET_QUIESCENT: 1335 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE); 1336 if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD)) 1337 netdev_info(netdev, "Device in FAILED state\n"); 1338 return 0; 1339 default: 1340 if (!fw_dump->tmpl_hdr) { 1341 netdev_err(netdev, "FW dump not supported\n"); 1342 return -ENOTSUPP; 1343 } 1344 for (i = 0; i < ARRAY_SIZE(FW_DUMP_LEVELS); i++) { 1345 if (val->flag == FW_DUMP_LEVELS[i]) { 1346 fw_dump->tmpl_hdr->drv_cap_mask = 1347 val->flag; 1348 netdev_info(netdev, "Driver mask changed to: 0x%x\n", 1349 fw_dump->tmpl_hdr->drv_cap_mask); 1350 return 0; 1351 } 1352 } 1353 netdev_info(netdev, "Invalid dump level: 0x%x\n", val->flag); 1354 return -EINVAL; 1355 } 1356 return 0; 1357 } 1358 1359 const struct ethtool_ops qlcnic_ethtool_ops = { 1360 .get_settings = qlcnic_get_settings, 1361 .set_settings = qlcnic_set_settings, 1362 .get_drvinfo = qlcnic_get_drvinfo, 1363 .get_regs_len = qlcnic_get_regs_len, 1364 .get_regs = qlcnic_get_regs, 1365 .get_link = ethtool_op_get_link, 1366 .get_eeprom_len = qlcnic_get_eeprom_len, 1367 .get_eeprom = qlcnic_get_eeprom, 1368 .get_ringparam = qlcnic_get_ringparam, 1369 .set_ringparam = qlcnic_set_ringparam, 1370 .get_channels = qlcnic_get_channels, 1371 .set_channels = qlcnic_set_channels, 1372 .get_pauseparam = qlcnic_get_pauseparam, 1373 .set_pauseparam = qlcnic_set_pauseparam, 1374 .get_wol = qlcnic_get_wol, 1375 .set_wol = qlcnic_set_wol, 1376 .self_test = qlcnic_diag_test, 1377 .get_strings = qlcnic_get_strings, 1378 .get_ethtool_stats = qlcnic_get_ethtool_stats, 1379 .get_sset_count = qlcnic_get_sset_count, 1380 .get_coalesce = qlcnic_get_intr_coalesce, 1381 .set_coalesce = qlcnic_set_intr_coalesce, 1382 .set_phys_id = qlcnic_set_led, 1383 .set_msglevel = qlcnic_set_msglevel, 1384 .get_msglevel = qlcnic_get_msglevel, 1385 .get_dump_flag = qlcnic_get_dump_flag, 1386 .get_dump_data = qlcnic_get_dump_data, 1387 .set_dump = qlcnic_set_dump, 1388 }; 1389 1390 const struct ethtool_ops qlcnic_ethtool_failed_ops = { 1391 .get_settings = qlcnic_get_settings, 1392 .get_drvinfo = qlcnic_get_drvinfo, 1393 .set_msglevel = qlcnic_set_msglevel, 1394 .get_msglevel = qlcnic_get_msglevel, 1395 }; 1396