1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Linux network driver for QLogic BR-series Converged Network Adapter. 4 */ 5 /* 6 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 7 * Copyright (c) 2014-2015 QLogic Corporation 8 * All rights reserved 9 * www.qlogic.com 10 */ 11 12 #include "cna.h" 13 14 #include <linux/netdevice.h> 15 #include <linux/skbuff.h> 16 #include <linux/ethtool.h> 17 #include <linux/rtnetlink.h> 18 19 #include "bna.h" 20 21 #include "bnad.h" 22 23 #define BNAD_NUM_TXF_COUNTERS 12 24 #define BNAD_NUM_RXF_COUNTERS 10 25 #define BNAD_NUM_CQ_COUNTERS (3 + 5) 26 #define BNAD_NUM_RXQ_COUNTERS 7 27 #define BNAD_NUM_TXQ_COUNTERS 5 28 29 static const char *bnad_net_stats_strings[] = { 30 "rx_packets", 31 "tx_packets", 32 "rx_bytes", 33 "tx_bytes", 34 "rx_errors", 35 "tx_errors", 36 "rx_dropped", 37 "tx_dropped", 38 "multicast", 39 "collisions", 40 "rx_length_errors", 41 "rx_crc_errors", 42 "rx_frame_errors", 43 "tx_fifo_errors", 44 45 "netif_queue_stop", 46 "netif_queue_wakeup", 47 "netif_queue_stopped", 48 "tso4", 49 "tso6", 50 "tso_err", 51 "tcpcsum_offload", 52 "udpcsum_offload", 53 "csum_help", 54 "tx_skb_too_short", 55 "tx_skb_stopping", 56 "tx_skb_max_vectors", 57 "tx_skb_mss_too_long", 58 "tx_skb_tso_too_short", 59 "tx_skb_tso_prepare", 60 "tx_skb_non_tso_too_long", 61 "tx_skb_tcp_hdr", 62 "tx_skb_udp_hdr", 63 "tx_skb_csum_err", 64 "tx_skb_headlen_too_long", 65 "tx_skb_headlen_zero", 66 "tx_skb_frag_zero", 67 "tx_skb_len_mismatch", 68 "tx_skb_map_failed", 69 "hw_stats_updates", 70 "netif_rx_dropped", 71 72 "link_toggle", 73 "cee_toggle", 74 75 "rxp_info_alloc_failed", 76 "mbox_intr_disabled", 77 "mbox_intr_enabled", 78 "tx_unmap_q_alloc_failed", 79 "rx_unmap_q_alloc_failed", 80 "rxbuf_alloc_failed", 81 "rxbuf_map_failed", 82 83 "mac_stats_clr_cnt", 84 "mac_frame_64", 85 "mac_frame_65_127", 86 "mac_frame_128_255", 87 "mac_frame_256_511", 88 "mac_frame_512_1023", 89 "mac_frame_1024_1518", 90 "mac_frame_1518_1522", 91 "mac_rx_bytes", 92 "mac_rx_packets", 93 "mac_rx_fcs_error", 94 "mac_rx_multicast", 95 "mac_rx_broadcast", 96 "mac_rx_control_frames", 97 "mac_rx_pause", 98 "mac_rx_unknown_opcode", 99 "mac_rx_alignment_error", 100 "mac_rx_frame_length_error", 101 "mac_rx_code_error", 102 "mac_rx_carrier_sense_error", 103 "mac_rx_undersize", 104 "mac_rx_oversize", 105 "mac_rx_fragments", 106 "mac_rx_jabber", 107 "mac_rx_drop", 108 109 "mac_tx_bytes", 110 "mac_tx_packets", 111 "mac_tx_multicast", 112 "mac_tx_broadcast", 113 "mac_tx_pause", 114 "mac_tx_deferral", 115 "mac_tx_excessive_deferral", 116 "mac_tx_single_collision", 117 "mac_tx_multiple_collision", 118 "mac_tx_late_collision", 119 "mac_tx_excessive_collision", 120 "mac_tx_total_collision", 121 "mac_tx_pause_honored", 122 "mac_tx_drop", 123 "mac_tx_jabber", 124 "mac_tx_fcs_error", 125 "mac_tx_control_frame", 126 "mac_tx_oversize", 127 "mac_tx_undersize", 128 "mac_tx_fragments", 129 130 "bpc_tx_pause_0", 131 "bpc_tx_pause_1", 132 "bpc_tx_pause_2", 133 "bpc_tx_pause_3", 134 "bpc_tx_pause_4", 135 "bpc_tx_pause_5", 136 "bpc_tx_pause_6", 137 "bpc_tx_pause_7", 138 "bpc_tx_zero_pause_0", 139 "bpc_tx_zero_pause_1", 140 "bpc_tx_zero_pause_2", 141 "bpc_tx_zero_pause_3", 142 "bpc_tx_zero_pause_4", 143 "bpc_tx_zero_pause_5", 144 "bpc_tx_zero_pause_6", 145 "bpc_tx_zero_pause_7", 146 "bpc_tx_first_pause_0", 147 "bpc_tx_first_pause_1", 148 "bpc_tx_first_pause_2", 149 "bpc_tx_first_pause_3", 150 "bpc_tx_first_pause_4", 151 "bpc_tx_first_pause_5", 152 "bpc_tx_first_pause_6", 153 "bpc_tx_first_pause_7", 154 155 "bpc_rx_pause_0", 156 "bpc_rx_pause_1", 157 "bpc_rx_pause_2", 158 "bpc_rx_pause_3", 159 "bpc_rx_pause_4", 160 "bpc_rx_pause_5", 161 "bpc_rx_pause_6", 162 "bpc_rx_pause_7", 163 "bpc_rx_zero_pause_0", 164 "bpc_rx_zero_pause_1", 165 "bpc_rx_zero_pause_2", 166 "bpc_rx_zero_pause_3", 167 "bpc_rx_zero_pause_4", 168 "bpc_rx_zero_pause_5", 169 "bpc_rx_zero_pause_6", 170 "bpc_rx_zero_pause_7", 171 "bpc_rx_first_pause_0", 172 "bpc_rx_first_pause_1", 173 "bpc_rx_first_pause_2", 174 "bpc_rx_first_pause_3", 175 "bpc_rx_first_pause_4", 176 "bpc_rx_first_pause_5", 177 "bpc_rx_first_pause_6", 178 "bpc_rx_first_pause_7", 179 180 "rad_rx_frames", 181 "rad_rx_octets", 182 "rad_rx_vlan_frames", 183 "rad_rx_ucast", 184 "rad_rx_ucast_octets", 185 "rad_rx_ucast_vlan", 186 "rad_rx_mcast", 187 "rad_rx_mcast_octets", 188 "rad_rx_mcast_vlan", 189 "rad_rx_bcast", 190 "rad_rx_bcast_octets", 191 "rad_rx_bcast_vlan", 192 "rad_rx_drops", 193 194 "rlb_rad_rx_frames", 195 "rlb_rad_rx_octets", 196 "rlb_rad_rx_vlan_frames", 197 "rlb_rad_rx_ucast", 198 "rlb_rad_rx_ucast_octets", 199 "rlb_rad_rx_ucast_vlan", 200 "rlb_rad_rx_mcast", 201 "rlb_rad_rx_mcast_octets", 202 "rlb_rad_rx_mcast_vlan", 203 "rlb_rad_rx_bcast", 204 "rlb_rad_rx_bcast_octets", 205 "rlb_rad_rx_bcast_vlan", 206 "rlb_rad_rx_drops", 207 208 "fc_rx_ucast_octets", 209 "fc_rx_ucast", 210 "fc_rx_ucast_vlan", 211 "fc_rx_mcast_octets", 212 "fc_rx_mcast", 213 "fc_rx_mcast_vlan", 214 "fc_rx_bcast_octets", 215 "fc_rx_bcast", 216 "fc_rx_bcast_vlan", 217 218 "fc_tx_ucast_octets", 219 "fc_tx_ucast", 220 "fc_tx_ucast_vlan", 221 "fc_tx_mcast_octets", 222 "fc_tx_mcast", 223 "fc_tx_mcast_vlan", 224 "fc_tx_bcast_octets", 225 "fc_tx_bcast", 226 "fc_tx_bcast_vlan", 227 "fc_tx_parity_errors", 228 "fc_tx_timeout", 229 "fc_tx_fid_parity_errors", 230 }; 231 232 #define BNAD_ETHTOOL_STATS_NUM ARRAY_SIZE(bnad_net_stats_strings) 233 234 static int 235 bnad_get_link_ksettings(struct net_device *netdev, 236 struct ethtool_link_ksettings *cmd) 237 { 238 ethtool_link_ksettings_zero_link_mode(cmd, supported); 239 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 240 241 ethtool_link_ksettings_add_link_mode(cmd, supported, 10000baseCR_Full); 242 ethtool_link_ksettings_add_link_mode(cmd, supported, 10000baseSR_Full); 243 ethtool_link_ksettings_add_link_mode(cmd, supported, 10000baseLR_Full); 244 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10000baseCR_Full); 245 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10000baseSR_Full); 246 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10000baseLR_Full); 247 cmd->base.autoneg = AUTONEG_DISABLE; 248 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE); 249 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE); 250 cmd->base.port = PORT_FIBRE; 251 cmd->base.phy_address = 0; 252 253 if (netif_carrier_ok(netdev)) { 254 cmd->base.speed = SPEED_10000; 255 cmd->base.duplex = DUPLEX_FULL; 256 } else { 257 cmd->base.speed = SPEED_UNKNOWN; 258 cmd->base.duplex = DUPLEX_UNKNOWN; 259 } 260 261 return 0; 262 } 263 264 static int 265 bnad_set_link_ksettings(struct net_device *netdev, 266 const struct ethtool_link_ksettings *cmd) 267 { 268 /* 10G full duplex setting supported only */ 269 if (cmd->base.autoneg == AUTONEG_ENABLE) 270 return -EOPNOTSUPP; 271 272 if ((cmd->base.speed == SPEED_10000) && 273 (cmd->base.duplex == DUPLEX_FULL)) 274 return 0; 275 276 return -EOPNOTSUPP; 277 } 278 279 static void 280 bnad_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo) 281 { 282 struct bnad *bnad = netdev_priv(netdev); 283 struct bfa_ioc_attr *ioc_attr; 284 unsigned long flags; 285 286 strscpy(drvinfo->driver, BNAD_NAME, sizeof(drvinfo->driver)); 287 288 ioc_attr = kzalloc(sizeof(*ioc_attr), GFP_KERNEL); 289 if (ioc_attr) { 290 spin_lock_irqsave(&bnad->bna_lock, flags); 291 bfa_nw_ioc_get_attr(&bnad->bna.ioceth.ioc, ioc_attr); 292 spin_unlock_irqrestore(&bnad->bna_lock, flags); 293 294 strscpy(drvinfo->fw_version, ioc_attr->adapter_attr.fw_ver, 295 sizeof(drvinfo->fw_version)); 296 kfree(ioc_attr); 297 } 298 299 strscpy(drvinfo->bus_info, pci_name(bnad->pcidev), 300 sizeof(drvinfo->bus_info)); 301 } 302 303 static void 304 bnad_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wolinfo) 305 { 306 wolinfo->supported = 0; 307 wolinfo->wolopts = 0; 308 } 309 310 static int bnad_get_coalesce(struct net_device *netdev, 311 struct ethtool_coalesce *coalesce, 312 struct kernel_ethtool_coalesce *kernel_coal, 313 struct netlink_ext_ack *extack) 314 { 315 struct bnad *bnad = netdev_priv(netdev); 316 unsigned long flags; 317 318 /* Lock rqd. to access bnad->bna_lock */ 319 spin_lock_irqsave(&bnad->bna_lock, flags); 320 coalesce->use_adaptive_rx_coalesce = 321 (bnad->cfg_flags & BNAD_CF_DIM_ENABLED) ? true : false; 322 spin_unlock_irqrestore(&bnad->bna_lock, flags); 323 324 coalesce->rx_coalesce_usecs = bnad->rx_coalescing_timeo * 325 BFI_COALESCING_TIMER_UNIT; 326 coalesce->tx_coalesce_usecs = bnad->tx_coalescing_timeo * 327 BFI_COALESCING_TIMER_UNIT; 328 coalesce->tx_max_coalesced_frames = BFI_TX_INTERPKT_COUNT; 329 330 return 0; 331 } 332 333 static int bnad_set_coalesce(struct net_device *netdev, 334 struct ethtool_coalesce *coalesce, 335 struct kernel_ethtool_coalesce *kernel_coal, 336 struct netlink_ext_ack *extack) 337 { 338 struct bnad *bnad = netdev_priv(netdev); 339 unsigned long flags; 340 int to_del = 0; 341 342 if (coalesce->rx_coalesce_usecs == 0 || 343 coalesce->rx_coalesce_usecs > 344 BFI_MAX_COALESCING_TIMEO * BFI_COALESCING_TIMER_UNIT) 345 return -EINVAL; 346 347 if (coalesce->tx_coalesce_usecs == 0 || 348 coalesce->tx_coalesce_usecs > 349 BFI_MAX_COALESCING_TIMEO * BFI_COALESCING_TIMER_UNIT) 350 return -EINVAL; 351 352 mutex_lock(&bnad->conf_mutex); 353 /* 354 * Do not need to store rx_coalesce_usecs here 355 * Every time DIM is disabled, we can get it from the 356 * stack. 357 */ 358 spin_lock_irqsave(&bnad->bna_lock, flags); 359 if (coalesce->use_adaptive_rx_coalesce) { 360 if (!(bnad->cfg_flags & BNAD_CF_DIM_ENABLED)) { 361 bnad->cfg_flags |= BNAD_CF_DIM_ENABLED; 362 bnad_dim_timer_start(bnad); 363 } 364 } else { 365 if (bnad->cfg_flags & BNAD_CF_DIM_ENABLED) { 366 bnad->cfg_flags &= ~BNAD_CF_DIM_ENABLED; 367 if (bnad->cfg_flags & BNAD_CF_DIM_ENABLED && 368 test_bit(BNAD_RF_DIM_TIMER_RUNNING, 369 &bnad->run_flags)) { 370 clear_bit(BNAD_RF_DIM_TIMER_RUNNING, 371 &bnad->run_flags); 372 to_del = 1; 373 } 374 spin_unlock_irqrestore(&bnad->bna_lock, flags); 375 if (to_del) 376 del_timer_sync(&bnad->dim_timer); 377 spin_lock_irqsave(&bnad->bna_lock, flags); 378 bnad_rx_coalescing_timeo_set(bnad); 379 } 380 } 381 if (bnad->tx_coalescing_timeo != coalesce->tx_coalesce_usecs / 382 BFI_COALESCING_TIMER_UNIT) { 383 bnad->tx_coalescing_timeo = coalesce->tx_coalesce_usecs / 384 BFI_COALESCING_TIMER_UNIT; 385 bnad_tx_coalescing_timeo_set(bnad); 386 } 387 388 if (bnad->rx_coalescing_timeo != coalesce->rx_coalesce_usecs / 389 BFI_COALESCING_TIMER_UNIT) { 390 bnad->rx_coalescing_timeo = coalesce->rx_coalesce_usecs / 391 BFI_COALESCING_TIMER_UNIT; 392 393 if (!(bnad->cfg_flags & BNAD_CF_DIM_ENABLED)) 394 bnad_rx_coalescing_timeo_set(bnad); 395 396 } 397 398 /* Add Tx Inter-pkt DMA count? */ 399 400 spin_unlock_irqrestore(&bnad->bna_lock, flags); 401 402 mutex_unlock(&bnad->conf_mutex); 403 return 0; 404 } 405 406 static void 407 bnad_get_ringparam(struct net_device *netdev, 408 struct ethtool_ringparam *ringparam, 409 struct kernel_ethtool_ringparam *kernel_ringparam, 410 struct netlink_ext_ack *extack) 411 { 412 struct bnad *bnad = netdev_priv(netdev); 413 414 ringparam->rx_max_pending = BNAD_MAX_RXQ_DEPTH; 415 ringparam->tx_max_pending = BNAD_MAX_TXQ_DEPTH; 416 417 ringparam->rx_pending = bnad->rxq_depth; 418 ringparam->tx_pending = bnad->txq_depth; 419 } 420 421 static int 422 bnad_set_ringparam(struct net_device *netdev, 423 struct ethtool_ringparam *ringparam, 424 struct kernel_ethtool_ringparam *kernel_ringparam, 425 struct netlink_ext_ack *extack) 426 { 427 int i, current_err, err = 0; 428 struct bnad *bnad = netdev_priv(netdev); 429 unsigned long flags; 430 431 mutex_lock(&bnad->conf_mutex); 432 if (ringparam->rx_pending == bnad->rxq_depth && 433 ringparam->tx_pending == bnad->txq_depth) { 434 mutex_unlock(&bnad->conf_mutex); 435 return 0; 436 } 437 438 if (ringparam->rx_pending < BNAD_MIN_Q_DEPTH || 439 ringparam->rx_pending > BNAD_MAX_RXQ_DEPTH || 440 !is_power_of_2(ringparam->rx_pending)) { 441 mutex_unlock(&bnad->conf_mutex); 442 return -EINVAL; 443 } 444 if (ringparam->tx_pending < BNAD_MIN_Q_DEPTH || 445 ringparam->tx_pending > BNAD_MAX_TXQ_DEPTH || 446 !is_power_of_2(ringparam->tx_pending)) { 447 mutex_unlock(&bnad->conf_mutex); 448 return -EINVAL; 449 } 450 451 if (ringparam->rx_pending != bnad->rxq_depth) { 452 bnad->rxq_depth = ringparam->rx_pending; 453 if (!netif_running(netdev)) { 454 mutex_unlock(&bnad->conf_mutex); 455 return 0; 456 } 457 458 for (i = 0; i < bnad->num_rx; i++) { 459 if (!bnad->rx_info[i].rx) 460 continue; 461 bnad_destroy_rx(bnad, i); 462 current_err = bnad_setup_rx(bnad, i); 463 if (current_err && !err) 464 err = current_err; 465 } 466 467 if (!err && bnad->rx_info[0].rx) { 468 /* restore rx configuration */ 469 bnad_restore_vlans(bnad, 0); 470 bnad_enable_default_bcast(bnad); 471 spin_lock_irqsave(&bnad->bna_lock, flags); 472 bnad_mac_addr_set_locked(bnad, netdev->dev_addr); 473 spin_unlock_irqrestore(&bnad->bna_lock, flags); 474 bnad->cfg_flags &= ~(BNAD_CF_ALLMULTI | 475 BNAD_CF_PROMISC); 476 bnad_set_rx_mode(netdev); 477 } 478 } 479 if (ringparam->tx_pending != bnad->txq_depth) { 480 bnad->txq_depth = ringparam->tx_pending; 481 if (!netif_running(netdev)) { 482 mutex_unlock(&bnad->conf_mutex); 483 return 0; 484 } 485 486 for (i = 0; i < bnad->num_tx; i++) { 487 if (!bnad->tx_info[i].tx) 488 continue; 489 bnad_destroy_tx(bnad, i); 490 current_err = bnad_setup_tx(bnad, i); 491 if (current_err && !err) 492 err = current_err; 493 } 494 } 495 496 mutex_unlock(&bnad->conf_mutex); 497 return err; 498 } 499 500 static void 501 bnad_get_pauseparam(struct net_device *netdev, 502 struct ethtool_pauseparam *pauseparam) 503 { 504 struct bnad *bnad = netdev_priv(netdev); 505 506 pauseparam->autoneg = 0; 507 pauseparam->rx_pause = bnad->bna.enet.pause_config.rx_pause; 508 pauseparam->tx_pause = bnad->bna.enet.pause_config.tx_pause; 509 } 510 511 static int 512 bnad_set_pauseparam(struct net_device *netdev, 513 struct ethtool_pauseparam *pauseparam) 514 { 515 struct bnad *bnad = netdev_priv(netdev); 516 struct bna_pause_config pause_config; 517 unsigned long flags; 518 519 if (pauseparam->autoneg == AUTONEG_ENABLE) 520 return -EINVAL; 521 522 mutex_lock(&bnad->conf_mutex); 523 if (pauseparam->rx_pause != bnad->bna.enet.pause_config.rx_pause || 524 pauseparam->tx_pause != bnad->bna.enet.pause_config.tx_pause) { 525 pause_config.rx_pause = pauseparam->rx_pause; 526 pause_config.tx_pause = pauseparam->tx_pause; 527 spin_lock_irqsave(&bnad->bna_lock, flags); 528 bna_enet_pause_config(&bnad->bna.enet, &pause_config); 529 spin_unlock_irqrestore(&bnad->bna_lock, flags); 530 } 531 mutex_unlock(&bnad->conf_mutex); 532 return 0; 533 } 534 535 static void bnad_get_txf_strings(u8 **string, int f_num) 536 { 537 ethtool_sprintf(string, "txf%d_ucast_octets", f_num); 538 ethtool_sprintf(string, "txf%d_ucast", f_num); 539 ethtool_sprintf(string, "txf%d_ucast_vlan", f_num); 540 ethtool_sprintf(string, "txf%d_mcast_octets", f_num); 541 ethtool_sprintf(string, "txf%d_mcast", f_num); 542 ethtool_sprintf(string, "txf%d_mcast_vlan", f_num); 543 ethtool_sprintf(string, "txf%d_bcast_octets", f_num); 544 ethtool_sprintf(string, "txf%d_bcast", f_num); 545 ethtool_sprintf(string, "txf%d_bcast_vlan", f_num); 546 ethtool_sprintf(string, "txf%d_errors", f_num); 547 ethtool_sprintf(string, "txf%d_filter_vlan", f_num); 548 ethtool_sprintf(string, "txf%d_filter_mac_sa", f_num); 549 } 550 551 static void bnad_get_rxf_strings(u8 **string, int f_num) 552 { 553 ethtool_sprintf(string, "rxf%d_ucast_octets", f_num); 554 ethtool_sprintf(string, "rxf%d_ucast", f_num); 555 ethtool_sprintf(string, "rxf%d_ucast_vlan", f_num); 556 ethtool_sprintf(string, "rxf%d_mcast_octets", f_num); 557 ethtool_sprintf(string, "rxf%d_mcast", f_num); 558 ethtool_sprintf(string, "rxf%d_mcast_vlan", f_num); 559 ethtool_sprintf(string, "rxf%d_bcast_octets", f_num); 560 ethtool_sprintf(string, "rxf%d_bcast", f_num); 561 ethtool_sprintf(string, "rxf%d_bcast_vlan", f_num); 562 ethtool_sprintf(string, "rxf%d_frame_drops", f_num); 563 } 564 565 static void bnad_get_cq_strings(u8 **string, int q_num) 566 { 567 ethtool_sprintf(string, "cq%d_producer_index", q_num); 568 ethtool_sprintf(string, "cq%d_consumer_index", q_num); 569 ethtool_sprintf(string, "cq%d_hw_producer_index", q_num); 570 ethtool_sprintf(string, "cq%d_intr", q_num); 571 ethtool_sprintf(string, "cq%d_poll", q_num); 572 ethtool_sprintf(string, "cq%d_schedule", q_num); 573 ethtool_sprintf(string, "cq%d_keep_poll", q_num); 574 ethtool_sprintf(string, "cq%d_complete", q_num); 575 } 576 577 static void bnad_get_rxq_strings(u8 **string, int q_num) 578 { 579 ethtool_sprintf(string, "rxq%d_packets", q_num); 580 ethtool_sprintf(string, "rxq%d_bytes", q_num); 581 ethtool_sprintf(string, "rxq%d_packets_with_error", q_num); 582 ethtool_sprintf(string, "rxq%d_allocbuf_failed", q_num); 583 ethtool_sprintf(string, "rxq%d_mapbuf_failed", q_num); 584 ethtool_sprintf(string, "rxq%d_producer_index", q_num); 585 ethtool_sprintf(string, "rxq%d_consumer_index", q_num); 586 } 587 588 static void bnad_get_txq_strings(u8 **string, int q_num) 589 { 590 ethtool_sprintf(string, "txq%d_packets", q_num); 591 ethtool_sprintf(string, "txq%d_bytes", q_num); 592 ethtool_sprintf(string, "txq%d_producer_index", q_num); 593 ethtool_sprintf(string, "txq%d_consumer_index", q_num); 594 ethtool_sprintf(string, "txq%d_hw_consumer_index", q_num); 595 } 596 597 static void 598 bnad_get_strings(struct net_device *netdev, u32 stringset, u8 *string) 599 { 600 struct bnad *bnad = netdev_priv(netdev); 601 int i, j, q_num; 602 u32 bmap; 603 604 if (stringset != ETH_SS_STATS) 605 return; 606 607 mutex_lock(&bnad->conf_mutex); 608 609 for (i = 0; i < BNAD_ETHTOOL_STATS_NUM; i++) { 610 BUG_ON(!(strlen(bnad_net_stats_strings[i]) < ETH_GSTRING_LEN)); 611 ethtool_puts(&string, bnad_net_stats_strings[i]); 612 } 613 614 bmap = bna_tx_rid_mask(&bnad->bna); 615 for (i = 0; bmap; i++) { 616 if (bmap & 1) 617 bnad_get_txf_strings(&string, i); 618 bmap >>= 1; 619 } 620 621 bmap = bna_rx_rid_mask(&bnad->bna); 622 for (i = 0; bmap; i++, bmap >>= 1) { 623 if (bmap & 1) 624 bnad_get_rxf_strings(&string, i); 625 bmap >>= 1; 626 } 627 628 q_num = 0; 629 for (i = 0; i < bnad->num_rx; i++) { 630 if (!bnad->rx_info[i].rx) 631 continue; 632 for (j = 0; j < bnad->num_rxp_per_rx; j++) 633 bnad_get_cq_strings(&string, q_num++); 634 } 635 636 q_num = 0; 637 for (i = 0; i < bnad->num_rx; i++) { 638 if (!bnad->rx_info[i].rx) 639 continue; 640 for (j = 0; j < bnad->num_rxp_per_rx; j++) { 641 bnad_get_rxq_strings(&string, q_num++); 642 if (bnad->rx_info[i].rx_ctrl[j].ccb && 643 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[1] && 644 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[1]->rxq) 645 bnad_get_rxq_strings(&string, q_num++); 646 } 647 } 648 649 q_num = 0; 650 for (i = 0; i < bnad->num_tx; i++) { 651 if (!bnad->tx_info[i].tx) 652 continue; 653 for (j = 0; j < bnad->num_txq_per_tx; j++) 654 bnad_get_txq_strings(&string, q_num++); 655 } 656 657 mutex_unlock(&bnad->conf_mutex); 658 } 659 660 static int 661 bnad_get_stats_count_locked(struct net_device *netdev) 662 { 663 struct bnad *bnad = netdev_priv(netdev); 664 int i, j, count = 0, rxf_active_num = 0, txf_active_num = 0; 665 u32 bmap; 666 667 bmap = bna_tx_rid_mask(&bnad->bna); 668 for (i = 0; bmap; i++) { 669 if (bmap & 1) 670 txf_active_num++; 671 bmap >>= 1; 672 } 673 bmap = bna_rx_rid_mask(&bnad->bna); 674 for (i = 0; bmap; i++) { 675 if (bmap & 1) 676 rxf_active_num++; 677 bmap >>= 1; 678 } 679 count = BNAD_ETHTOOL_STATS_NUM + 680 txf_active_num * BNAD_NUM_TXF_COUNTERS + 681 rxf_active_num * BNAD_NUM_RXF_COUNTERS; 682 683 for (i = 0; i < bnad->num_rx; i++) { 684 if (!bnad->rx_info[i].rx) 685 continue; 686 count += bnad->num_rxp_per_rx * BNAD_NUM_CQ_COUNTERS; 687 count += bnad->num_rxp_per_rx * BNAD_NUM_RXQ_COUNTERS; 688 for (j = 0; j < bnad->num_rxp_per_rx; j++) 689 if (bnad->rx_info[i].rx_ctrl[j].ccb && 690 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[1] && 691 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[1]->rxq) 692 count += BNAD_NUM_RXQ_COUNTERS; 693 } 694 695 for (i = 0; i < bnad->num_tx; i++) { 696 if (!bnad->tx_info[i].tx) 697 continue; 698 count += bnad->num_txq_per_tx * BNAD_NUM_TXQ_COUNTERS; 699 } 700 return count; 701 } 702 703 static int 704 bnad_per_q_stats_fill(struct bnad *bnad, u64 *buf, int bi) 705 { 706 int i, j; 707 struct bna_rcb *rcb = NULL; 708 struct bna_tcb *tcb = NULL; 709 710 for (i = 0; i < bnad->num_rx; i++) { 711 if (!bnad->rx_info[i].rx) 712 continue; 713 for (j = 0; j < bnad->num_rxp_per_rx; j++) 714 if (bnad->rx_info[i].rx_ctrl[j].ccb && 715 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[0] && 716 bnad->rx_info[i].rx_ctrl[j].ccb->rcb[0]->rxq) { 717 buf[bi++] = bnad->rx_info[i].rx_ctrl[j]. 718 ccb->producer_index; 719 buf[bi++] = 0; /* ccb->consumer_index */ 720 buf[bi++] = *(bnad->rx_info[i].rx_ctrl[j]. 721 ccb->hw_producer_index); 722 723 buf[bi++] = bnad->rx_info[i]. 724 rx_ctrl[j].rx_intr_ctr; 725 buf[bi++] = bnad->rx_info[i]. 726 rx_ctrl[j].rx_poll_ctr; 727 buf[bi++] = bnad->rx_info[i]. 728 rx_ctrl[j].rx_schedule; 729 buf[bi++] = bnad->rx_info[i]. 730 rx_ctrl[j].rx_keep_poll; 731 buf[bi++] = bnad->rx_info[i]. 732 rx_ctrl[j].rx_complete; 733 } 734 } 735 for (i = 0; i < bnad->num_rx; i++) { 736 if (!bnad->rx_info[i].rx) 737 continue; 738 for (j = 0; j < bnad->num_rxp_per_rx; j++) 739 if (bnad->rx_info[i].rx_ctrl[j].ccb) { 740 if (bnad->rx_info[i].rx_ctrl[j].ccb->rcb[0] && 741 bnad->rx_info[i].rx_ctrl[j].ccb-> 742 rcb[0]->rxq) { 743 rcb = bnad->rx_info[i].rx_ctrl[j]. 744 ccb->rcb[0]; 745 buf[bi++] = rcb->rxq->rx_packets; 746 buf[bi++] = rcb->rxq->rx_bytes; 747 buf[bi++] = rcb->rxq-> 748 rx_packets_with_error; 749 buf[bi++] = rcb->rxq-> 750 rxbuf_alloc_failed; 751 buf[bi++] = rcb->rxq->rxbuf_map_failed; 752 buf[bi++] = rcb->producer_index; 753 buf[bi++] = rcb->consumer_index; 754 } 755 if (bnad->rx_info[i].rx_ctrl[j].ccb->rcb[1] && 756 bnad->rx_info[i].rx_ctrl[j].ccb-> 757 rcb[1]->rxq) { 758 rcb = bnad->rx_info[i].rx_ctrl[j]. 759 ccb->rcb[1]; 760 buf[bi++] = rcb->rxq->rx_packets; 761 buf[bi++] = rcb->rxq->rx_bytes; 762 buf[bi++] = rcb->rxq-> 763 rx_packets_with_error; 764 buf[bi++] = rcb->rxq-> 765 rxbuf_alloc_failed; 766 buf[bi++] = rcb->rxq->rxbuf_map_failed; 767 buf[bi++] = rcb->producer_index; 768 buf[bi++] = rcb->consumer_index; 769 } 770 } 771 } 772 773 for (i = 0; i < bnad->num_tx; i++) { 774 if (!bnad->tx_info[i].tx) 775 continue; 776 for (j = 0; j < bnad->num_txq_per_tx; j++) 777 if (bnad->tx_info[i].tcb[j] && 778 bnad->tx_info[i].tcb[j]->txq) { 779 tcb = bnad->tx_info[i].tcb[j]; 780 buf[bi++] = tcb->txq->tx_packets; 781 buf[bi++] = tcb->txq->tx_bytes; 782 buf[bi++] = tcb->producer_index; 783 buf[bi++] = tcb->consumer_index; 784 buf[bi++] = *(tcb->hw_consumer_index); 785 } 786 } 787 788 return bi; 789 } 790 791 static void 792 bnad_get_ethtool_stats(struct net_device *netdev, struct ethtool_stats *stats, 793 u64 *buf) 794 { 795 struct bnad *bnad = netdev_priv(netdev); 796 int i, j, bi = 0; 797 unsigned long flags; 798 struct rtnl_link_stats64 net_stats64; 799 u64 *stats64; 800 u32 bmap; 801 802 mutex_lock(&bnad->conf_mutex); 803 if (bnad_get_stats_count_locked(netdev) != stats->n_stats) { 804 mutex_unlock(&bnad->conf_mutex); 805 return; 806 } 807 808 /* 809 * Used bna_lock to sync reads from bna_stats, which is written 810 * under the same lock 811 */ 812 spin_lock_irqsave(&bnad->bna_lock, flags); 813 814 memset(&net_stats64, 0, sizeof(net_stats64)); 815 bnad_netdev_qstats_fill(bnad, &net_stats64); 816 bnad_netdev_hwstats_fill(bnad, &net_stats64); 817 818 buf[bi++] = net_stats64.rx_packets; 819 buf[bi++] = net_stats64.tx_packets; 820 buf[bi++] = net_stats64.rx_bytes; 821 buf[bi++] = net_stats64.tx_bytes; 822 buf[bi++] = net_stats64.rx_errors; 823 buf[bi++] = net_stats64.tx_errors; 824 buf[bi++] = net_stats64.rx_dropped; 825 buf[bi++] = net_stats64.tx_dropped; 826 buf[bi++] = net_stats64.multicast; 827 buf[bi++] = net_stats64.collisions; 828 buf[bi++] = net_stats64.rx_length_errors; 829 buf[bi++] = net_stats64.rx_crc_errors; 830 buf[bi++] = net_stats64.rx_frame_errors; 831 buf[bi++] = net_stats64.tx_fifo_errors; 832 833 /* Get netif_queue_stopped from stack */ 834 bnad->stats.drv_stats.netif_queue_stopped = netif_queue_stopped(netdev); 835 836 /* Fill driver stats into ethtool buffers */ 837 stats64 = (u64 *)&bnad->stats.drv_stats; 838 for (i = 0; i < sizeof(struct bnad_drv_stats) / sizeof(u64); i++) 839 buf[bi++] = stats64[i]; 840 841 /* Fill hardware stats excluding the rxf/txf into ethtool bufs */ 842 stats64 = (u64 *) &bnad->stats.bna_stats->hw_stats; 843 for (i = 0; 844 i < offsetof(struct bfi_enet_stats, rxf_stats[0]) / 845 sizeof(u64); 846 i++) 847 buf[bi++] = stats64[i]; 848 849 /* Fill txf stats into ethtool buffers */ 850 bmap = bna_tx_rid_mask(&bnad->bna); 851 for (i = 0; bmap; i++) { 852 if (bmap & 1) { 853 stats64 = (u64 *)&bnad->stats.bna_stats-> 854 hw_stats.txf_stats[i]; 855 for (j = 0; j < sizeof(struct bfi_enet_stats_txf) / 856 sizeof(u64); j++) 857 buf[bi++] = stats64[j]; 858 } 859 bmap >>= 1; 860 } 861 862 /* Fill rxf stats into ethtool buffers */ 863 bmap = bna_rx_rid_mask(&bnad->bna); 864 for (i = 0; bmap; i++) { 865 if (bmap & 1) { 866 stats64 = (u64 *)&bnad->stats.bna_stats-> 867 hw_stats.rxf_stats[i]; 868 for (j = 0; j < sizeof(struct bfi_enet_stats_rxf) / 869 sizeof(u64); j++) 870 buf[bi++] = stats64[j]; 871 } 872 bmap >>= 1; 873 } 874 875 /* Fill per Q stats into ethtool buffers */ 876 bi = bnad_per_q_stats_fill(bnad, buf, bi); 877 878 spin_unlock_irqrestore(&bnad->bna_lock, flags); 879 880 mutex_unlock(&bnad->conf_mutex); 881 } 882 883 static int 884 bnad_get_sset_count(struct net_device *netdev, int sset) 885 { 886 switch (sset) { 887 case ETH_SS_STATS: 888 return bnad_get_stats_count_locked(netdev); 889 default: 890 return -EOPNOTSUPP; 891 } 892 } 893 894 static u32 895 bnad_get_flash_partition_by_offset(struct bnad *bnad, u32 offset, 896 u32 *base_offset) 897 { 898 struct bfa_flash_attr *flash_attr; 899 struct bnad_iocmd_comp fcomp; 900 u32 i, flash_part = 0, ret; 901 unsigned long flags = 0; 902 903 flash_attr = kzalloc(sizeof(struct bfa_flash_attr), GFP_KERNEL); 904 if (!flash_attr) 905 return 0; 906 907 fcomp.bnad = bnad; 908 fcomp.comp_status = 0; 909 910 init_completion(&fcomp.comp); 911 spin_lock_irqsave(&bnad->bna_lock, flags); 912 ret = bfa_nw_flash_get_attr(&bnad->bna.flash, flash_attr, 913 bnad_cb_completion, &fcomp); 914 if (ret != BFA_STATUS_OK) { 915 spin_unlock_irqrestore(&bnad->bna_lock, flags); 916 kfree(flash_attr); 917 return 0; 918 } 919 spin_unlock_irqrestore(&bnad->bna_lock, flags); 920 wait_for_completion(&fcomp.comp); 921 ret = fcomp.comp_status; 922 923 /* Check for the flash type & base offset value */ 924 if (ret == BFA_STATUS_OK) { 925 for (i = 0; i < flash_attr->npart; i++) { 926 if (offset >= flash_attr->part[i].part_off && 927 offset < (flash_attr->part[i].part_off + 928 flash_attr->part[i].part_size)) { 929 flash_part = flash_attr->part[i].part_type; 930 *base_offset = flash_attr->part[i].part_off; 931 break; 932 } 933 } 934 } 935 kfree(flash_attr); 936 return flash_part; 937 } 938 939 static int 940 bnad_get_eeprom_len(struct net_device *netdev) 941 { 942 return BFA_TOTAL_FLASH_SIZE; 943 } 944 945 static int 946 bnad_get_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom, 947 u8 *bytes) 948 { 949 struct bnad *bnad = netdev_priv(netdev); 950 struct bnad_iocmd_comp fcomp; 951 u32 flash_part = 0, base_offset = 0; 952 unsigned long flags = 0; 953 int ret = 0; 954 955 /* Fill the magic value */ 956 eeprom->magic = bnad->pcidev->vendor | (bnad->pcidev->device << 16); 957 958 /* Query the flash partition based on the offset */ 959 flash_part = bnad_get_flash_partition_by_offset(bnad, 960 eeprom->offset, &base_offset); 961 if (flash_part == 0) 962 return -EFAULT; 963 964 fcomp.bnad = bnad; 965 fcomp.comp_status = 0; 966 967 init_completion(&fcomp.comp); 968 spin_lock_irqsave(&bnad->bna_lock, flags); 969 ret = bfa_nw_flash_read_part(&bnad->bna.flash, flash_part, 970 bnad->id, bytes, eeprom->len, 971 eeprom->offset - base_offset, 972 bnad_cb_completion, &fcomp); 973 if (ret != BFA_STATUS_OK) { 974 spin_unlock_irqrestore(&bnad->bna_lock, flags); 975 goto done; 976 } 977 978 spin_unlock_irqrestore(&bnad->bna_lock, flags); 979 wait_for_completion(&fcomp.comp); 980 ret = fcomp.comp_status; 981 done: 982 return ret; 983 } 984 985 static int 986 bnad_set_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom, 987 u8 *bytes) 988 { 989 struct bnad *bnad = netdev_priv(netdev); 990 struct bnad_iocmd_comp fcomp; 991 u32 flash_part = 0, base_offset = 0; 992 unsigned long flags = 0; 993 int ret = 0; 994 995 /* Check if the flash update request is valid */ 996 if (eeprom->magic != (bnad->pcidev->vendor | 997 (bnad->pcidev->device << 16))) 998 return -EINVAL; 999 1000 /* Query the flash partition based on the offset */ 1001 flash_part = bnad_get_flash_partition_by_offset(bnad, 1002 eeprom->offset, &base_offset); 1003 if (flash_part == 0) 1004 return -EFAULT; 1005 1006 fcomp.bnad = bnad; 1007 fcomp.comp_status = 0; 1008 1009 init_completion(&fcomp.comp); 1010 spin_lock_irqsave(&bnad->bna_lock, flags); 1011 ret = bfa_nw_flash_update_part(&bnad->bna.flash, flash_part, 1012 bnad->id, bytes, eeprom->len, 1013 eeprom->offset - base_offset, 1014 bnad_cb_completion, &fcomp); 1015 if (ret != BFA_STATUS_OK) { 1016 spin_unlock_irqrestore(&bnad->bna_lock, flags); 1017 goto done; 1018 } 1019 1020 spin_unlock_irqrestore(&bnad->bna_lock, flags); 1021 wait_for_completion(&fcomp.comp); 1022 ret = fcomp.comp_status; 1023 done: 1024 return ret; 1025 } 1026 1027 static int 1028 bnad_flash_device(struct net_device *netdev, struct ethtool_flash *eflash) 1029 { 1030 struct bnad *bnad = netdev_priv(netdev); 1031 struct bnad_iocmd_comp fcomp; 1032 const struct firmware *fw; 1033 int ret = 0; 1034 1035 ret = request_firmware(&fw, eflash->data, &bnad->pcidev->dev); 1036 if (ret) { 1037 netdev_err(netdev, "can't load firmware %s\n", eflash->data); 1038 goto out; 1039 } 1040 1041 fcomp.bnad = bnad; 1042 fcomp.comp_status = 0; 1043 1044 init_completion(&fcomp.comp); 1045 spin_lock_irq(&bnad->bna_lock); 1046 ret = bfa_nw_flash_update_part(&bnad->bna.flash, BFA_FLASH_PART_FWIMG, 1047 bnad->id, (u8 *)fw->data, fw->size, 0, 1048 bnad_cb_completion, &fcomp); 1049 if (ret != BFA_STATUS_OK) { 1050 netdev_warn(netdev, "flash update failed with err=%d\n", ret); 1051 ret = -EIO; 1052 spin_unlock_irq(&bnad->bna_lock); 1053 goto out; 1054 } 1055 1056 spin_unlock_irq(&bnad->bna_lock); 1057 wait_for_completion(&fcomp.comp); 1058 if (fcomp.comp_status != BFA_STATUS_OK) { 1059 ret = -EIO; 1060 netdev_warn(netdev, 1061 "firmware image update failed with err=%d\n", 1062 fcomp.comp_status); 1063 } 1064 out: 1065 release_firmware(fw); 1066 return ret; 1067 } 1068 1069 static const struct ethtool_ops bnad_ethtool_ops = { 1070 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 1071 ETHTOOL_COALESCE_TX_MAX_FRAMES | 1072 ETHTOOL_COALESCE_USE_ADAPTIVE_RX, 1073 .get_drvinfo = bnad_get_drvinfo, 1074 .get_wol = bnad_get_wol, 1075 .get_link = ethtool_op_get_link, 1076 .get_coalesce = bnad_get_coalesce, 1077 .set_coalesce = bnad_set_coalesce, 1078 .get_ringparam = bnad_get_ringparam, 1079 .set_ringparam = bnad_set_ringparam, 1080 .get_pauseparam = bnad_get_pauseparam, 1081 .set_pauseparam = bnad_set_pauseparam, 1082 .get_strings = bnad_get_strings, 1083 .get_ethtool_stats = bnad_get_ethtool_stats, 1084 .get_sset_count = bnad_get_sset_count, 1085 .get_eeprom_len = bnad_get_eeprom_len, 1086 .get_eeprom = bnad_get_eeprom, 1087 .set_eeprom = bnad_set_eeprom, 1088 .flash_device = bnad_flash_device, 1089 .get_ts_info = ethtool_op_get_ts_info, 1090 .get_link_ksettings = bnad_get_link_ksettings, 1091 .set_link_ksettings = bnad_set_link_ksettings, 1092 }; 1093 1094 void 1095 bnad_set_ethtool_ops(struct net_device *netdev) 1096 { 1097 netdev->ethtool_ops = &bnad_ethtool_ops; 1098 } 1099