drivers/net/ethernet/brocade/bna/bnad_ethtool.c

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