drivers/net/netxen/netxen_nic_ethtool.c

   1 /*
   2  * Copyright (C) 2003 - 2006 NetXen, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18  * MA  02111-1307, USA.
  19  *
  20  * The full GNU General Public License is included in this distribution
  21  * in the file called LICENSE.
  22  *
  23  * Contact Information:
  24  *    info@netxen.com
  25  * NetXen,
  26  * 3965 Freedom Circle, Fourth floor,
  27  * Santa Clara, CA 95054
  28  *
  29  *
  30  * ethtool support for netxen nic
  31  *
  32  */
  33
  34 #include <linux/types.h>
  35 #include <linux/delay.h>
  36 #include <asm/uaccess.h>
  37 #include <linux/pci.h>
  38 #include <asm/io.h>
  39 #include <linux/netdevice.h>
  40 #include <linux/ethtool.h>
  41 #include <linux/version.h>
  42
  43 #include "netxen_nic.h"
  44 #include "netxen_nic_hw.h"
  45 #include "netxen_nic_phan_reg.h"
  46
  47 struct netxen_nic_stats {
  48         char stat_string[ETH_GSTRING_LEN];
  49         int sizeof_stat;
  50         int stat_offset;
  51 };
  52
  53 #define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
  54                         offsetof(struct netxen_adapter, m)
  55
  56 #define NETXEN_NIC_PORT_WINDOW 0x10000
  57 #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
  58
  59 static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
  60         {"rcvd_bad_skb", NETXEN_NIC_STAT(stats.rcvdbadskb)},
  61         {"xmit_called", NETXEN_NIC_STAT(stats.xmitcalled)},
  62         {"xmited_frames", NETXEN_NIC_STAT(stats.xmitedframes)},
  63         {"xmit_finished", NETXEN_NIC_STAT(stats.xmitfinished)},
  64         {"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
  65         {"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
  66         {"polled", NETXEN_NIC_STAT(stats.polled)},
  67         {"uphappy", NETXEN_NIC_STAT(stats.uphappy)},
  68         {"updropped", NETXEN_NIC_STAT(stats.updropped)},
  69         {"uplcong", NETXEN_NIC_STAT(stats.uplcong)},
  70         {"uphcong", NETXEN_NIC_STAT(stats.uphcong)},
  71         {"upmcong", NETXEN_NIC_STAT(stats.upmcong)},
  72         {"updunno", NETXEN_NIC_STAT(stats.updunno)},
  73         {"skb_freed", NETXEN_NIC_STAT(stats.skbfreed)},
  74         {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
  75         {"tx_null_skb", NETXEN_NIC_STAT(stats.txnullskb)},
  76         {"csummed", NETXEN_NIC_STAT(stats.csummed)},
  77         {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
  78         {"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
  79         {"tx_bytes", NETXEN_NIC_STAT(stats.txbytes)},
  80 };
  81
  82 #define NETXEN_NIC_STATS_LEN    ARRAY_SIZE(netxen_nic_gstrings_stats)
  83
  84 static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
  85         "Register_Test_on_offline",
  86         "Link_Test_on_offline"
  87 };
  88
  89 #define NETXEN_NIC_TEST_LEN sizeof(netxen_nic_gstrings_test) / ETH_GSTRING_LEN
  90
  91 #define NETXEN_NIC_REGS_COUNT 42
  92 #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
  93 #define NETXEN_MAX_EEPROM_LEN   1024
  94
  95 static int netxen_nic_get_eeprom_len(struct net_device *dev)
  96 {
  97         return NETXEN_FLASH_TOTAL_SIZE;
  98 }
  99
 100 static void
 101 netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
 102 {
 103         struct netxen_adapter *adapter = netdev_priv(dev);
 104         u32 fw_major = 0;
 105         u32 fw_minor = 0;
 106         u32 fw_build = 0;
 107
 108         strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
 109         strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
 110         fw_major = readl(NETXEN_CRB_NORMALIZE(adapter,
 111                                               NETXEN_FW_VERSION_MAJOR));
 112         fw_minor = readl(NETXEN_CRB_NORMALIZE(adapter,
 113                                               NETXEN_FW_VERSION_MINOR));
 114         fw_build = readl(NETXEN_CRB_NORMALIZE(adapter, NETXEN_FW_VERSION_SUB));
 115         sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
 116
 117         strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
 118         drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
 119         drvinfo->eedump_len = netxen_nic_get_eeprom_len(dev);
 120 }
 121
 122 static int
 123 netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 124 {
 125         struct netxen_adapter *adapter = netdev_priv(dev);
 126         struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
 127
 128         /* read which mode */
 129         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
 130                 ecmd->supported = (SUPPORTED_10baseT_Half |
 131                                    SUPPORTED_10baseT_Full |
 132                                    SUPPORTED_100baseT_Half |
 133                                    SUPPORTED_100baseT_Full |
 134                                    SUPPORTED_1000baseT_Half |
 135                                    SUPPORTED_1000baseT_Full);
 136
 137                 ecmd->advertising = (ADVERTISED_100baseT_Half |
 138                                      ADVERTISED_100baseT_Full |
 139                                      ADVERTISED_1000baseT_Half |
 140                                      ADVERTISED_1000baseT_Full);
 141
 142                 ecmd->port = PORT_TP;
 143
 144                 if (netif_running(dev)) {
 145                         ecmd->speed = adapter->link_speed;
 146                         ecmd->duplex = adapter->link_duplex;
 147                 } else
 148                         return -EIO;    /* link absent */
 149         } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
 150                 ecmd->supported = (SUPPORTED_TP |
 151                                    SUPPORTED_1000baseT_Full |
 152                                    SUPPORTED_10000baseT_Full);
 153                 ecmd->advertising = (ADVERTISED_TP |
 154                                      ADVERTISED_1000baseT_Full |
 155                                      ADVERTISED_10000baseT_Full);
 156                 ecmd->port = PORT_TP;
 157
 158                 ecmd->speed = SPEED_10000;
 159                 ecmd->duplex = DUPLEX_FULL;
 160                 ecmd->autoneg = AUTONEG_DISABLE;
 161         } else
 162                 return -EIO;
 163
 164         ecmd->phy_address = adapter->portnum;
 165         ecmd->transceiver = XCVR_EXTERNAL;
 166
 167         switch ((netxen_brdtype_t) boardinfo->board_type) {
 168         case NETXEN_BRDTYPE_P2_SB35_4G:
 169         case NETXEN_BRDTYPE_P2_SB31_2G:
 170                 ecmd->supported |= SUPPORTED_Autoneg;
 171                 ecmd->advertising |= ADVERTISED_Autoneg;
 172         case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
 173                 ecmd->supported |= SUPPORTED_TP;
 174                 ecmd->advertising |= ADVERTISED_TP;
 175                 ecmd->port = PORT_TP;
 176                 ecmd->autoneg = (boardinfo->board_type ==
 177                                  NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
 178                     (AUTONEG_DISABLE) : (adapter->link_autoneg);
 179                 break;
 180         case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
 181         case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
 182                 ecmd->supported |= SUPPORTED_MII;
 183                 ecmd->advertising |= ADVERTISED_MII;
 184                 ecmd->port = PORT_FIBRE;
 185                 ecmd->autoneg = AUTONEG_DISABLE;
 186                 break;
 187         case NETXEN_BRDTYPE_P2_SB31_10G:
 188                 ecmd->supported |= SUPPORTED_FIBRE;
 189                 ecmd->advertising |= ADVERTISED_FIBRE;
 190                 ecmd->port = PORT_FIBRE;
 191                 ecmd->autoneg = AUTONEG_DISABLE;
 192                 break;
 193         default:
 194                 printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
 195                        (netxen_brdtype_t) boardinfo->board_type);
 196                 return -EIO;
 197         }
 198
 199         return 0;
 200 }
 201
 202 static int
 203 netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 204 {
 205         struct netxen_adapter *adapter = netdev_priv(dev);
 206         __u32 status;
 207
 208         /* read which mode */
 209         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
 210                 /* autonegotiation */
 211                 if (adapter->phy_write
 212                     && adapter->phy_write(adapter,
 213                                           NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
 214                                           ecmd->autoneg) != 0)
 215                         return -EIO;
 216                 else
 217                         adapter->link_autoneg = ecmd->autoneg;
 218
 219                 if (adapter->phy_read
 220                     && adapter->phy_read(adapter,
 221                                          NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
 222                                          &status) != 0)
 223                         return -EIO;
 224
 225                 /* speed */
 226                 switch (ecmd->speed) {
 227                 case SPEED_10:
 228                         netxen_set_phy_speed(status, 0);
 229                         break;
 230                 case SPEED_100:
 231                         netxen_set_phy_speed(status, 1);
 232                         break;
 233                 case SPEED_1000:
 234                         netxen_set_phy_speed(status, 2);
 235                         break;
 236                 }
 237                 /* set duplex mode */
 238                 if (ecmd->duplex == DUPLEX_HALF)
 239                         netxen_clear_phy_duplex(status);
 240                 if (ecmd->duplex == DUPLEX_FULL)
 241                         netxen_set_phy_duplex(status);
 242                 if (adapter->phy_write
 243                     && adapter->phy_write(adapter,
 244                                           NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
 245                                           *((int *)&status)) != 0)
 246                         return -EIO;
 247                 else {
 248                         adapter->link_speed = ecmd->speed;
 249                         adapter->link_duplex = ecmd->duplex;
 250                 }
 251         } else
 252                 return -EOPNOTSUPP;
 253
 254         if (netif_running(dev)) {
 255                 dev->stop(dev);
 256                 dev->open(dev);
 257         }
 258         return 0;
 259 }
 260
 261 static int netxen_nic_get_regs_len(struct net_device *dev)
 262 {
 263         return NETXEN_NIC_REGS_LEN;
 264 }
 265
 266 struct netxen_niu_regs {
 267         __u32 reg[NETXEN_NIC_REGS_COUNT];
 268 };
 269
 270 static struct netxen_niu_regs niu_registers[] = {
 271         {
 272          /* GB Mode */
 273          {
 274           NETXEN_NIU_GB_SERDES_RESET,
 275           NETXEN_NIU_GB0_MII_MODE,
 276           NETXEN_NIU_GB1_MII_MODE,
 277           NETXEN_NIU_GB2_MII_MODE,
 278           NETXEN_NIU_GB3_MII_MODE,
 279           NETXEN_NIU_GB0_GMII_MODE,
 280           NETXEN_NIU_GB1_GMII_MODE,
 281           NETXEN_NIU_GB2_GMII_MODE,
 282           NETXEN_NIU_GB3_GMII_MODE,
 283           NETXEN_NIU_REMOTE_LOOPBACK,
 284           NETXEN_NIU_GB0_HALF_DUPLEX,
 285           NETXEN_NIU_GB1_HALF_DUPLEX,
 286           NETXEN_NIU_RESET_SYS_FIFOS,
 287           NETXEN_NIU_GB_CRC_DROP,
 288           NETXEN_NIU_GB_DROP_WRONGADDR,
 289           NETXEN_NIU_TEST_MUX_CTL,
 290
 291           NETXEN_NIU_GB_MAC_CONFIG_0(0),
 292           NETXEN_NIU_GB_MAC_CONFIG_1(0),
 293           NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
 294           NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
 295           NETXEN_NIU_GB_TEST_REG(0),
 296           NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
 297           NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
 298           NETXEN_NIU_GB_MII_MGMT_ADDR(0),
 299           NETXEN_NIU_GB_MII_MGMT_CTRL(0),
 300           NETXEN_NIU_GB_MII_MGMT_STATUS(0),
 301           NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
 302           NETXEN_NIU_GB_INTERFACE_CTRL(0),
 303           NETXEN_NIU_GB_INTERFACE_STATUS(0),
 304           NETXEN_NIU_GB_STATION_ADDR_0(0),
 305           NETXEN_NIU_GB_STATION_ADDR_1(0),
 306           -1,
 307           }
 308          },
 309         {
 310          /* XG Mode */
 311          {
 312           NETXEN_NIU_XG_SINGLE_TERM,
 313           NETXEN_NIU_XG_DRIVE_HI,
 314           NETXEN_NIU_XG_DRIVE_LO,
 315           NETXEN_NIU_XG_DTX,
 316           NETXEN_NIU_XG_DEQ,
 317           NETXEN_NIU_XG_WORD_ALIGN,
 318           NETXEN_NIU_XG_RESET,
 319           NETXEN_NIU_XG_POWER_DOWN,
 320           NETXEN_NIU_XG_RESET_PLL,
 321           NETXEN_NIU_XG_SERDES_LOOPBACK,
 322           NETXEN_NIU_XG_DO_BYTE_ALIGN,
 323           NETXEN_NIU_XG_TX_ENABLE,
 324           NETXEN_NIU_XG_RX_ENABLE,
 325           NETXEN_NIU_XG_STATUS,
 326           NETXEN_NIU_XG_PAUSE_THRESHOLD,
 327           NETXEN_NIU_XGE_CONFIG_0,
 328           NETXEN_NIU_XGE_CONFIG_1,
 329           NETXEN_NIU_XGE_IPG,
 330           NETXEN_NIU_XGE_STATION_ADDR_0_HI,
 331           NETXEN_NIU_XGE_STATION_ADDR_0_1,
 332           NETXEN_NIU_XGE_STATION_ADDR_1_LO,
 333           NETXEN_NIU_XGE_STATUS,
 334           NETXEN_NIU_XGE_MAX_FRAME_SIZE,
 335           NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
 336           NETXEN_NIU_XGE_TX_BYTE_CNT,
 337           NETXEN_NIU_XGE_TX_FRAME_CNT,
 338           NETXEN_NIU_XGE_RX_BYTE_CNT,
 339           NETXEN_NIU_XGE_RX_FRAME_CNT,
 340           NETXEN_NIU_XGE_AGGR_ERROR_CNT,
 341           NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
 342           NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
 343           NETXEN_NIU_XGE_CRC_ERROR_CNT,
 344           NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
 345           NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
 346           NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
 347           NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
 348           NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
 349           NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
 350           -1,
 351           }
 352          }
 353 };
 354
 355 static void
 356 netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 357 {
 358         struct netxen_adapter *adapter = netdev_priv(dev);
 359         __u32 mode, *regs_buff = p;
 360         void __iomem *addr;
 361         int i, window;
 362
 363         memset(p, 0, NETXEN_NIC_REGS_LEN);
 364         regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
 365             (adapter->pdev)->device;
 366         /* which mode */
 367         NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_MODE, &regs_buff[0]);
 368         mode = regs_buff[0];
 369
 370         /* Common registers to all the modes */
 371         NETXEN_NIC_LOCKED_READ_REG(NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER,
 372                                    &regs_buff[2]);
 373         /* GB/XGB Mode */
 374         mode = (mode / 2) - 1;
 375         window = 0;
 376         if (mode <= 1) {
 377                 for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
 378                         /* GB: port specific registers */
 379                         if (mode == 0 && i >= 19)
 380                                 window = physical_port[adapter->portnum] *
 381                                         NETXEN_NIC_PORT_WINDOW;
 382
 383                         NETXEN_NIC_LOCKED_READ_REG(niu_registers[mode].
 384                                                    reg[i - 3] + window,
 385                                                    &regs_buff[i]);
 386                 }
 387
 388         }
 389 }
 390
 391 static u32 netxen_nic_test_link(struct net_device *dev)
 392 {
 393         struct netxen_adapter *adapter = netdev_priv(dev);
 394         __u32 status;
 395         int val;
 396
 397         /* read which mode */
 398         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
 399                 if (adapter->phy_read
 400                     && adapter->phy_read(adapter,
 401                                          NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
 402                                          &status) != 0)
 403                         return -EIO;
 404                 else {
 405                         val = netxen_get_phy_link(status);
 406                         return !val;
 407                 }
 408         } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
 409                 val = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_XG_STATE));
 410                 return (val == XG_LINK_UP) ? 0 : 1;
 411         }
 412         return -EIO;
 413 }
 414
 415 static int
 416 netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 417                       u8 * bytes)
 418 {
 419         struct netxen_adapter *adapter = netdev_priv(dev);
 420         int offset;
 421         int ret;
 422
 423         if (eeprom->len == 0)
 424                 return -EINVAL;
 425
 426         eeprom->magic = (adapter->pdev)->vendor |
 427                         ((adapter->pdev)->device << 16);
 428         offset = eeprom->offset;
 429
 430         ret = netxen_rom_fast_read_words(adapter, offset, bytes,
 431                                                 eeprom->len);
 432         if (ret < 0)
 433                 return ret;
 434
 435         return 0;
 436 }
 437
 438 static int
 439 netxen_nic_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 440                         u8 * bytes)
 441 {
 442         struct netxen_adapter *adapter = netdev_priv(dev);
 443         int offset = eeprom->offset;
 444         static int flash_start;
 445         static int ready_to_flash;
 446         int ret;
 447
 448         if (flash_start == 0) {
 449                 netxen_halt_pegs(adapter);
 450                 ret = netxen_flash_unlock(adapter);
 451                 if (ret < 0) {
 452                         printk(KERN_ERR "%s: Flash unlock failed.\n",
 453                                 netxen_nic_driver_name);
 454                         return ret;
 455                 }
 456                 printk(KERN_INFO "%s: flash unlocked. \n",
 457                         netxen_nic_driver_name);
 458                 last_schedule_time = jiffies;
 459                 ret = netxen_flash_erase_secondary(adapter);
 460                 if (ret != FLASH_SUCCESS) {
 461                         printk(KERN_ERR "%s: Flash erase failed.\n",
 462                                 netxen_nic_driver_name);
 463                         return ret;
 464                 }
 465                 printk(KERN_INFO "%s: secondary flash erased successfully.\n",
 466                         netxen_nic_driver_name);
 467                 flash_start = 1;
 468                 return 0;
 469         }
 470
 471         if (offset == NETXEN_BOOTLD_START) {
 472                 ret = netxen_flash_erase_primary(adapter);
 473                 if (ret != FLASH_SUCCESS) {
 474                         printk(KERN_ERR "%s: Flash erase failed.\n",
 475                                 netxen_nic_driver_name);
 476                         return ret;
 477                 }
 478
 479                 ret = netxen_rom_se(adapter, NETXEN_USER_START);
 480                 if (ret != FLASH_SUCCESS)
 481                         return ret;
 482                 ret = netxen_rom_se(adapter, NETXEN_FIXED_START);
 483                 if (ret != FLASH_SUCCESS)
 484                         return ret;
 485
 486                 printk(KERN_INFO "%s: primary flash erased successfully\n",
 487                         netxen_nic_driver_name);
 488
 489                 ret = netxen_backup_crbinit(adapter);
 490                 if (ret != FLASH_SUCCESS) {
 491                         printk(KERN_ERR "%s: CRBinit backup failed.\n",
 492                                 netxen_nic_driver_name);
 493                         return ret;
 494                 }
 495                 printk(KERN_INFO "%s: CRBinit backup done.\n",
 496                         netxen_nic_driver_name);
 497                 ready_to_flash = 1;
 498         }
 499
 500         if (!ready_to_flash) {
 501                 printk(KERN_ERR "%s: Invalid write sequence, returning...\n",
 502                         netxen_nic_driver_name);
 503                 return -EINVAL;
 504         }
 505
 506         return netxen_rom_fast_write_words(adapter, offset, bytes, eeprom->len);
 507 }
 508
 509 static void
 510 netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
 511 {
 512         struct netxen_adapter *adapter = netdev_priv(dev);
 513         int i;
 514
 515         ring->rx_pending = 0;
 516         ring->rx_jumbo_pending = 0;
 517         for (i = 0; i < MAX_RCV_CTX; ++i) {
 518                 ring->rx_pending += adapter->recv_ctx[i].
 519                     rcv_desc[RCV_DESC_NORMAL_CTXID].max_rx_desc_count;
 520                 ring->rx_jumbo_pending += adapter->recv_ctx[i].
 521                     rcv_desc[RCV_DESC_JUMBO_CTXID].max_rx_desc_count;
 522         }
 523         ring->tx_pending = adapter->max_tx_desc_count;
 524
 525         ring->rx_max_pending = MAX_RCV_DESCRIPTORS;
 526         ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
 527         ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
 528         ring->rx_mini_max_pending = 0;
 529         ring->rx_mini_pending = 0;
 530 }
 531
 532 static void
 533 netxen_nic_get_pauseparam(struct net_device *dev,
 534                           struct ethtool_pauseparam *pause)
 535 {
 536         struct netxen_adapter *adapter = netdev_priv(dev);
 537         __u32 val;
 538         int port = physical_port[adapter->portnum];
 539
 540         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
 541                 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
 542                         return;
 543                 /* get flow control settings */
 544                 netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
 545                                 &val);
 546                 pause->rx_pause = netxen_gb_get_rx_flowctl(val);
 547                 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
 548                 switch (port) {
 549                         case 0:
 550                                 pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
 551                                 break;
 552                         case 1:
 553                                 pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
 554                                 break;
 555                         case 2:
 556                                 pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
 557                                 break;
 558                         case 3:
 559                         default:
 560                                 pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
 561                                 break;
 562                 }
 563         } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
 564                 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
 565                         return;
 566                 pause->rx_pause = 1;
 567                 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
 568                 if (port == 0)
 569                         pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
 570                 else
 571                         pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
 572         } else {
 573                 printk(KERN_ERR"%s: Unknown board type: %x\n",
 574                                 netxen_nic_driver_name, adapter->ahw.board_type);
 575         }
 576 }
 577
 578 static int
 579 netxen_nic_set_pauseparam(struct net_device *dev,
 580                           struct ethtool_pauseparam *pause)
 581 {
 582         struct netxen_adapter *adapter = netdev_priv(dev);
 583         __u32 val;
 584         int port = physical_port[adapter->portnum];
 585         /* read mode */
 586         if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
 587                 if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
 588                         return -EIO;
 589                 /* set flow control */
 590                 netxen_nic_read_w0(adapter,
 591                                         NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
 592
 593                 if (pause->rx_pause)
 594                         netxen_gb_rx_flowctl(val);
 595                 else
 596                         netxen_gb_unset_rx_flowctl(val);
 597
 598                 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
 599                                 val);
 600                 /* set autoneg */
 601                 netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
 602                 switch (port) {
 603                         case 0:
 604                                 if (pause->tx_pause)
 605                                         netxen_gb_unset_gb0_mask(val);
 606                                 else
 607                                         netxen_gb_set_gb0_mask(val);
 608                                 break;
 609                         case 1:
 610                                 if (pause->tx_pause)
 611                                         netxen_gb_unset_gb1_mask(val);
 612                                 else
 613                                         netxen_gb_set_gb1_mask(val);
 614                                 break;
 615                         case 2:
 616                                 if (pause->tx_pause)
 617                                         netxen_gb_unset_gb2_mask(val);
 618                                 else
 619                                         netxen_gb_set_gb2_mask(val);
 620                                 break;
 621                         case 3:
 622                         default:
 623                                 if (pause->tx_pause)
 624                                         netxen_gb_unset_gb3_mask(val);
 625                                 else
 626                                         netxen_gb_set_gb3_mask(val);
 627                                 break;
 628                 }
 629                 netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
 630         } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
 631                 if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
 632                         return -EIO;
 633                 netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
 634                 if (port == 0) {
 635                         if (pause->tx_pause)
 636                                 netxen_xg_unset_xg0_mask(val);
 637                         else
 638                                 netxen_xg_set_xg0_mask(val);
 639                 } else {
 640                         if (pause->tx_pause)
 641                                 netxen_xg_unset_xg1_mask(val);
 642                         else
 643                                 netxen_xg_set_xg1_mask(val);
 644                 }
 645                 netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
 646         } else {
 647                 printk(KERN_ERR "%s: Unknown board type: %x\n",
 648                                 netxen_nic_driver_name,
 649                                 adapter->ahw.board_type);
 650         }
 651         return 0;
 652 }
 653
 654 static int netxen_nic_reg_test(struct net_device *dev)
 655 {
 656         struct netxen_adapter *adapter = netdev_priv(dev);
 657         u32 data_read, data_written;
 658
 659         netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
 660         if ((data_read & 0xffff) != PHAN_VENDOR_ID)
 661         return 1;
 662
 663         data_written = (u32)0xa5a5a5a5;
 664
 665         netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
 666         data_read = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_SCRATCHPAD_TEST));
 667         if (data_written != data_read)
 668                 return 1;
 669
 670         return 0;
 671 }
 672
 673 static int netxen_get_sset_count(struct net_device *dev, int sset)
 674 {
 675         switch (sset) {
 676         case ETH_SS_TEST:
 677                 return NETXEN_NIC_TEST_LEN;
 678         case ETH_SS_STATS:
 679                 return NETXEN_NIC_STATS_LEN;
 680         default:
 681                 return -EOPNOTSUPP;
 682         }
 683 }
 684
 685 static void
 686 netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
 687                      u64 * data)
 688 {
 689         memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
 690         if ((data[0] = netxen_nic_reg_test(dev)))
 691                 eth_test->flags |= ETH_TEST_FL_FAILED;
 692         /* link test */
 693         if ((data[1] = (u64) netxen_nic_test_link(dev)))
 694                 eth_test->flags |= ETH_TEST_FL_FAILED;
 695 }
 696
 697 static void
 698 netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
 699 {
 700         int index;
 701
 702         switch (stringset) {
 703         case ETH_SS_TEST:
 704                 memcpy(data, *netxen_nic_gstrings_test,
 705                        NETXEN_NIC_TEST_LEN * ETH_GSTRING_LEN);
 706                 break;
 707         case ETH_SS_STATS:
 708                 for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
 709                         memcpy(data + index * ETH_GSTRING_LEN,
 710                                netxen_nic_gstrings_stats[index].stat_string,
 711                                ETH_GSTRING_LEN);
 712                 }
 713                 break;
 714         }
 715 }
 716
 717 static void
 718 netxen_nic_get_ethtool_stats(struct net_device *dev,
 719                              struct ethtool_stats *stats, u64 * data)
 720 {
 721         struct netxen_adapter *adapter = netdev_priv(dev);
 722         int index;
 723
 724         for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
 725                 char *p =
 726                     (char *)adapter +
 727                     netxen_nic_gstrings_stats[index].stat_offset;
 728                 data[index] =
 729                     (netxen_nic_gstrings_stats[index].sizeof_stat ==
 730                      sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
 731         }
 732 }
 733
 734 static u32 netxen_nic_get_rx_csum(struct net_device *dev)
 735 {
 736         struct netxen_adapter *adapter = netdev_priv(dev);
 737         return adapter->rx_csum;
 738 }
 739
 740 static int netxen_nic_set_rx_csum(struct net_device *dev, u32 data)
 741 {
 742         struct netxen_adapter *adapter = netdev_priv(dev);
 743         adapter->rx_csum = !!data;
 744         return 0;
 745 }
 746
 747 struct ethtool_ops netxen_nic_ethtool_ops = {
 748         .get_settings = netxen_nic_get_settings,
 749         .set_settings = netxen_nic_set_settings,
 750         .get_drvinfo = netxen_nic_get_drvinfo,
 751         .get_regs_len = netxen_nic_get_regs_len,
 752         .get_regs = netxen_nic_get_regs,
 753         .get_link = ethtool_op_get_link,
 754         .get_eeprom_len = netxen_nic_get_eeprom_len,
 755         .get_eeprom = netxen_nic_get_eeprom,
 756         .set_eeprom = netxen_nic_set_eeprom,
 757         .get_ringparam = netxen_nic_get_ringparam,
 758         .get_pauseparam = netxen_nic_get_pauseparam,
 759         .set_pauseparam = netxen_nic_set_pauseparam,
 760         .set_tx_csum = ethtool_op_set_tx_csum,
 761         .set_sg = ethtool_op_set_sg,
 762         .set_tso = ethtool_op_set_tso,
 763         .self_test = netxen_nic_diag_test,
 764         .get_strings = netxen_nic_get_strings,
 765         .get_ethtool_stats = netxen_nic_get_ethtool_stats,
 766         .get_sset_count = netxen_get_sset_count,
 767         .get_rx_csum = netxen_nic_get_rx_csum,
 768         .set_rx_csum = netxen_nic_set_rx_csum,
 769 };