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_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
 254 static int
 255 bnad_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, SPEED_UNKNOWN);
 270                 cmd->duplex = DUPLEX_UNKNOWN;
 271         }
 272         cmd->transceiver = XCVR_EXTERNAL;
 273         cmd->maxtxpkt = 0;
 274         cmd->maxrxpkt = 0;
 275
 276         return 0;
 277 }
 278
 279 static int
 280 bnad_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
 293 static void
 294 bnad_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
 318 static void
 319 bnad_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wolinfo)
 320 {
 321         wolinfo->supported = 0;
 322         wolinfo->wolopts = 0;
 323 }
 324
 325 static int
 326 bnad_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
 346 static int
 347 bnad_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
 417 static void
 418 bnad_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
 430 static int
 431 bnad_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
 507 static void
 508 bnad_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
 518 static int
 519 bnad_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
 542 static void
 543 bnad_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
 718 static int
 719 bnad_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
 761 static int
 762 bnad_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
 847 static void
 848 bnad_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
 928 static int
 929 bnad_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
 939 static u32
 940 bnad_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
 984 static int
 985 bnad_get_eeprom_len(struct net_device *netdev)
 986 {
 987         return BFA_TOTAL_FLASH_SIZE;
 988 }
 989
 990 static int
 991 bnad_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;
1028 done:
1029         return ret;
1030 }
1031
1032 static int
1033 bnad_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;
1070 done:
1071         return ret;
1072 }
1073
1074 static int
1075 bnad_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         }
1110 out:
1111         release_firmware(fw);
1112         return ret;
1113 }
1114
1115 static 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
1137 void
1138 bnad_set_ethtool_ops(struct net_device *netdev)
1139 {
1140         netdev->ethtool_ops = &bnad_ethtool_ops;
1141 }