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