drivers/net/ethernet/chelsio/cxgb4/cxgb4_ethtool.c

   1 /*
   2  *  Copyright (C) 2013-2015 Chelsio Communications.  All rights reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify it
   5  *  under the terms and conditions of the GNU General Public License,
   6  *  version 2, as published by the Free Software Foundation.
   7  *
   8  *  This program is distributed in the hope it will be useful, but WITHOUT
   9  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  *  more details.
  12  *
  13  *  The full GNU General Public License is included in this distribution in
  14  *  the file called "COPYING".
  15  *
  16  */
  17
  18 #include <linux/firmware.h>
  19 #include <linux/mdio.h>
  20
  21 #include "cxgb4.h"
  22 #include "t4_regs.h"
  23 #include "t4fw_api.h"
  24
  25 #define EEPROM_MAGIC 0x38E2F10C
  26
  27 static u32 get_msglevel(struct net_device *dev)
  28 {
  29         return netdev2adap(dev)->msg_enable;
  30 }
  31
  32 static void set_msglevel(struct net_device *dev, u32 val)
  33 {
  34         netdev2adap(dev)->msg_enable = val;
  35 }
  36
  37 static const char stats_strings[][ETH_GSTRING_LEN] = {
  38         "TxOctetsOK         ",
  39         "TxFramesOK         ",
  40         "TxBroadcastFrames  ",
  41         "TxMulticastFrames  ",
  42         "TxUnicastFrames    ",
  43         "TxErrorFrames      ",
  44
  45         "TxFrames64         ",
  46         "TxFrames65To127    ",
  47         "TxFrames128To255   ",
  48         "TxFrames256To511   ",
  49         "TxFrames512To1023  ",
  50         "TxFrames1024To1518 ",
  51         "TxFrames1519ToMax  ",
  52
  53         "TxFramesDropped    ",
  54         "TxPauseFrames      ",
  55         "TxPPP0Frames       ",
  56         "TxPPP1Frames       ",
  57         "TxPPP2Frames       ",
  58         "TxPPP3Frames       ",
  59         "TxPPP4Frames       ",
  60         "TxPPP5Frames       ",
  61         "TxPPP6Frames       ",
  62         "TxPPP7Frames       ",
  63
  64         "RxOctetsOK         ",
  65         "RxFramesOK         ",
  66         "RxBroadcastFrames  ",
  67         "RxMulticastFrames  ",
  68         "RxUnicastFrames    ",
  69
  70         "RxFramesTooLong    ",
  71         "RxJabberErrors     ",
  72         "RxFCSErrors        ",
  73         "RxLengthErrors     ",
  74         "RxSymbolErrors     ",
  75         "RxRuntFrames       ",
  76
  77         "RxFrames64         ",
  78         "RxFrames65To127    ",
  79         "RxFrames128To255   ",
  80         "RxFrames256To511   ",
  81         "RxFrames512To1023  ",
  82         "RxFrames1024To1518 ",
  83         "RxFrames1519ToMax  ",
  84
  85         "RxPauseFrames      ",
  86         "RxPPP0Frames       ",
  87         "RxPPP1Frames       ",
  88         "RxPPP2Frames       ",
  89         "RxPPP3Frames       ",
  90         "RxPPP4Frames       ",
  91         "RxPPP5Frames       ",
  92         "RxPPP6Frames       ",
  93         "RxPPP7Frames       ",
  94
  95         "RxBG0FramesDropped ",
  96         "RxBG1FramesDropped ",
  97         "RxBG2FramesDropped ",
  98         "RxBG3FramesDropped ",
  99         "RxBG0FramesTrunc   ",
 100         "RxBG1FramesTrunc   ",
 101         "RxBG2FramesTrunc   ",
 102         "RxBG3FramesTrunc   ",
 103
 104         "TSO                ",
 105         "TxCsumOffload      ",
 106         "RxCsumGood         ",
 107         "VLANextractions    ",
 108         "VLANinsertions     ",
 109         "GROpackets         ",
 110         "GROmerged          ",
 111 };
 112
 113 static char adapter_stats_strings[][ETH_GSTRING_LEN] = {
 114         "db_drop                ",
 115         "db_full                ",
 116         "db_empty               ",
 117         "tcp_ipv4_out_rsts      ",
 118         "tcp_ipv4_in_segs       ",
 119         "tcp_ipv4_out_segs      ",
 120         "tcp_ipv4_retrans_segs  ",
 121         "tcp_ipv6_out_rsts      ",
 122         "tcp_ipv6_in_segs       ",
 123         "tcp_ipv6_out_segs      ",
 124         "tcp_ipv6_retrans_segs  ",
 125         "usm_ddp_frames         ",
 126         "usm_ddp_octets         ",
 127         "usm_ddp_drops          ",
 128         "rdma_no_rqe_mod_defer  ",
 129         "rdma_no_rqe_pkt_defer  ",
 130         "tp_err_ofld_no_neigh   ",
 131         "tp_err_ofld_cong_defer ",
 132         "write_coal_success     ",
 133         "write_coal_fail        ",
 134 };
 135
 136 static char channel_stats_strings[][ETH_GSTRING_LEN] = {
 137         "--------Channel--------- ",
 138         "tp_cpl_requests        ",
 139         "tp_cpl_responses       ",
 140         "tp_mac_in_errs         ",
 141         "tp_hdr_in_errs         ",
 142         "tp_tcp_in_errs         ",
 143         "tp_tcp6_in_errs        ",
 144         "tp_tnl_cong_drops      ",
 145         "tp_tnl_tx_drops        ",
 146         "tp_ofld_vlan_drops     ",
 147         "tp_ofld_chan_drops     ",
 148         "fcoe_octets_ddp        ",
 149         "fcoe_frames_ddp        ",
 150         "fcoe_frames_drop       ",
 151 };
 152
 153 static char loopback_stats_strings[][ETH_GSTRING_LEN] = {
 154         "-------Loopback----------- ",
 155         "octets_ok              ",
 156         "frames_ok              ",
 157         "bcast_frames           ",
 158         "mcast_frames           ",
 159         "ucast_frames           ",
 160         "error_frames           ",
 161         "frames_64              ",
 162         "frames_65_to_127       ",
 163         "frames_128_to_255      ",
 164         "frames_256_to_511      ",
 165         "frames_512_to_1023     ",
 166         "frames_1024_to_1518    ",
 167         "frames_1519_to_max     ",
 168         "frames_dropped         ",
 169         "bg0_frames_dropped     ",
 170         "bg1_frames_dropped     ",
 171         "bg2_frames_dropped     ",
 172         "bg3_frames_dropped     ",
 173         "bg0_frames_trunc       ",
 174         "bg1_frames_trunc       ",
 175         "bg2_frames_trunc       ",
 176         "bg3_frames_trunc       ",
 177 };
 178
 179 static int get_sset_count(struct net_device *dev, int sset)
 180 {
 181         switch (sset) {
 182         case ETH_SS_STATS:
 183                 return ARRAY_SIZE(stats_strings) +
 184                        ARRAY_SIZE(adapter_stats_strings) +
 185                        ARRAY_SIZE(channel_stats_strings) +
 186                        ARRAY_SIZE(loopback_stats_strings);
 187         default:
 188                 return -EOPNOTSUPP;
 189         }
 190 }
 191
 192 static int get_regs_len(struct net_device *dev)
 193 {
 194         struct adapter *adap = netdev2adap(dev);
 195
 196         return t4_get_regs_len(adap);
 197 }
 198
 199 static int get_eeprom_len(struct net_device *dev)
 200 {
 201         return EEPROMSIZE;
 202 }
 203
 204 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 205 {
 206         struct adapter *adapter = netdev2adap(dev);
 207         u32 exprom_vers;
 208
 209         strlcpy(info->driver, cxgb4_driver_name, sizeof(info->driver));
 210         strlcpy(info->version, cxgb4_driver_version,
 211                 sizeof(info->version));
 212         strlcpy(info->bus_info, pci_name(adapter->pdev),
 213                 sizeof(info->bus_info));
 214
 215         if (adapter->params.fw_vers)
 216                 snprintf(info->fw_version, sizeof(info->fw_version),
 217                          "%u.%u.%u.%u, TP %u.%u.%u.%u",
 218                          FW_HDR_FW_VER_MAJOR_G(adapter->params.fw_vers),
 219                          FW_HDR_FW_VER_MINOR_G(adapter->params.fw_vers),
 220                          FW_HDR_FW_VER_MICRO_G(adapter->params.fw_vers),
 221                          FW_HDR_FW_VER_BUILD_G(adapter->params.fw_vers),
 222                          FW_HDR_FW_VER_MAJOR_G(adapter->params.tp_vers),
 223                          FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers),
 224                          FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers),
 225                          FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers));
 226
 227         if (!t4_get_exprom_version(adapter, &exprom_vers))
 228                 snprintf(info->erom_version, sizeof(info->erom_version),
 229                          "%u.%u.%u.%u",
 230                          FW_HDR_FW_VER_MAJOR_G(exprom_vers),
 231                          FW_HDR_FW_VER_MINOR_G(exprom_vers),
 232                          FW_HDR_FW_VER_MICRO_G(exprom_vers),
 233                          FW_HDR_FW_VER_BUILD_G(exprom_vers));
 234 }
 235
 236 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
 237 {
 238         if (stringset == ETH_SS_STATS) {
 239                 memcpy(data, stats_strings, sizeof(stats_strings));
 240                 data += sizeof(stats_strings);
 241                 memcpy(data, adapter_stats_strings,
 242                        sizeof(adapter_stats_strings));
 243                 data += sizeof(adapter_stats_strings);
 244                 memcpy(data, channel_stats_strings,
 245                        sizeof(channel_stats_strings));
 246                 data += sizeof(channel_stats_strings);
 247                 memcpy(data, loopback_stats_strings,
 248                        sizeof(loopback_stats_strings));
 249         }
 250 }
 251
 252 /* port stats maintained per queue of the port. They should be in the same
 253  * order as in stats_strings above.
 254  */
 255 struct queue_port_stats {
 256         u64 tso;
 257         u64 tx_csum;
 258         u64 rx_csum;
 259         u64 vlan_ex;
 260         u64 vlan_ins;
 261         u64 gro_pkts;
 262         u64 gro_merged;
 263 };
 264
 265 struct adapter_stats {
 266         u64 db_drop;
 267         u64 db_full;
 268         u64 db_empty;
 269         u64 tcp_v4_out_rsts;
 270         u64 tcp_v4_in_segs;
 271         u64 tcp_v4_out_segs;
 272         u64 tcp_v4_retrans_segs;
 273         u64 tcp_v6_out_rsts;
 274         u64 tcp_v6_in_segs;
 275         u64 tcp_v6_out_segs;
 276         u64 tcp_v6_retrans_segs;
 277         u64 frames;
 278         u64 octets;
 279         u64 drops;
 280         u64 rqe_dfr_mod;
 281         u64 rqe_dfr_pkt;
 282         u64 ofld_no_neigh;
 283         u64 ofld_cong_defer;
 284         u64 wc_success;
 285         u64 wc_fail;
 286 };
 287
 288 struct channel_stats {
 289         u64 cpl_req;
 290         u64 cpl_rsp;
 291         u64 mac_in_errs;
 292         u64 hdr_in_errs;
 293         u64 tcp_in_errs;
 294         u64 tcp6_in_errs;
 295         u64 tnl_cong_drops;
 296         u64 tnl_tx_drops;
 297         u64 ofld_vlan_drops;
 298         u64 ofld_chan_drops;
 299         u64 octets_ddp;
 300         u64 frames_ddp;
 301         u64 frames_drop;
 302 };
 303
 304 static void collect_sge_port_stats(const struct adapter *adap,
 305                                    const struct port_info *p,
 306                                    struct queue_port_stats *s)
 307 {
 308         int i;
 309         const struct sge_eth_txq *tx = &adap->sge.ethtxq[p->first_qset];
 310         const struct sge_eth_rxq *rx = &adap->sge.ethrxq[p->first_qset];
 311
 312         memset(s, 0, sizeof(*s));
 313         for (i = 0; i < p->nqsets; i++, rx++, tx++) {
 314                 s->tso += tx->tso;
 315                 s->tx_csum += tx->tx_cso;
 316                 s->rx_csum += rx->stats.rx_cso;
 317                 s->vlan_ex += rx->stats.vlan_ex;
 318                 s->vlan_ins += tx->vlan_ins;
 319                 s->gro_pkts += rx->stats.lro_pkts;
 320                 s->gro_merged += rx->stats.lro_merged;
 321         }
 322 }
 323
 324 static void collect_adapter_stats(struct adapter *adap, struct adapter_stats *s)
 325 {
 326         struct tp_tcp_stats v4, v6;
 327         struct tp_rdma_stats rdma_stats;
 328         struct tp_err_stats err_stats;
 329         struct tp_usm_stats usm_stats;
 330         u64 val1, val2;
 331
 332         memset(s, 0, sizeof(*s));
 333
 334         spin_lock(&adap->stats_lock);
 335         t4_tp_get_tcp_stats(adap, &v4, &v6);
 336         t4_tp_get_rdma_stats(adap, &rdma_stats);
 337         t4_get_usm_stats(adap, &usm_stats);
 338         t4_tp_get_err_stats(adap, &err_stats);
 339         spin_unlock(&adap->stats_lock);
 340
 341         s->db_drop = adap->db_stats.db_drop;
 342         s->db_full = adap->db_stats.db_full;
 343         s->db_empty = adap->db_stats.db_empty;
 344
 345         s->tcp_v4_out_rsts = v4.tcp_out_rsts;
 346         s->tcp_v4_in_segs = v4.tcp_in_segs;
 347         s->tcp_v4_out_segs = v4.tcp_out_segs;
 348         s->tcp_v4_retrans_segs = v4.tcp_retrans_segs;
 349         s->tcp_v6_out_rsts = v6.tcp_out_rsts;
 350         s->tcp_v6_in_segs = v6.tcp_in_segs;
 351         s->tcp_v6_out_segs = v6.tcp_out_segs;
 352         s->tcp_v6_retrans_segs = v6.tcp_retrans_segs;
 353
 354         if (is_offload(adap)) {
 355                 s->frames = usm_stats.frames;
 356                 s->octets = usm_stats.octets;
 357                 s->drops = usm_stats.drops;
 358                 s->rqe_dfr_mod = rdma_stats.rqe_dfr_mod;
 359                 s->rqe_dfr_pkt = rdma_stats.rqe_dfr_pkt;
 360         }
 361
 362         s->ofld_no_neigh = err_stats.ofld_no_neigh;
 363         s->ofld_cong_defer = err_stats.ofld_cong_defer;
 364
 365         if (!is_t4(adap->params.chip)) {
 366                 int v;
 367
 368                 v = t4_read_reg(adap, SGE_STAT_CFG_A);
 369                 if (STATSOURCE_T5_G(v) == 7) {
 370                         val2 = t4_read_reg(adap, SGE_STAT_MATCH_A);
 371                         val1 = t4_read_reg(adap, SGE_STAT_TOTAL_A);
 372                         s->wc_success = val1 - val2;
 373                         s->wc_fail = val2;
 374                 }
 375         }
 376 }
 377
 378 static void collect_channel_stats(struct adapter *adap, struct channel_stats *s,
 379                                   u8 i)
 380 {
 381         struct tp_cpl_stats cpl_stats;
 382         struct tp_err_stats err_stats;
 383         struct tp_fcoe_stats fcoe_stats;
 384
 385         memset(s, 0, sizeof(*s));
 386
 387         spin_lock(&adap->stats_lock);
 388         t4_tp_get_cpl_stats(adap, &cpl_stats);
 389         t4_tp_get_err_stats(adap, &err_stats);
 390         t4_get_fcoe_stats(adap, i, &fcoe_stats);
 391         spin_unlock(&adap->stats_lock);
 392
 393         s->cpl_req = cpl_stats.req[i];
 394         s->cpl_rsp = cpl_stats.rsp[i];
 395         s->mac_in_errs = err_stats.mac_in_errs[i];
 396         s->hdr_in_errs = err_stats.hdr_in_errs[i];
 397         s->tcp_in_errs = err_stats.tcp_in_errs[i];
 398         s->tcp6_in_errs = err_stats.tcp6_in_errs[i];
 399         s->tnl_cong_drops = err_stats.tnl_cong_drops[i];
 400         s->tnl_tx_drops = err_stats.tnl_tx_drops[i];
 401         s->ofld_vlan_drops = err_stats.ofld_vlan_drops[i];
 402         s->ofld_chan_drops = err_stats.ofld_chan_drops[i];
 403         s->octets_ddp = fcoe_stats.octets_ddp;
 404         s->frames_ddp = fcoe_stats.frames_ddp;
 405         s->frames_drop = fcoe_stats.frames_drop;
 406 }
 407
 408 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
 409                       u64 *data)
 410 {
 411         struct port_info *pi = netdev_priv(dev);
 412         struct adapter *adapter = pi->adapter;
 413         struct lb_port_stats s;
 414         int i;
 415         u64 *p0;
 416
 417         t4_get_port_stats_offset(adapter, pi->tx_chan,
 418                                  (struct port_stats *)data,
 419                                  &pi->stats_base);
 420
 421         data += sizeof(struct port_stats) / sizeof(u64);
 422         collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
 423         data += sizeof(struct queue_port_stats) / sizeof(u64);
 424         collect_adapter_stats(adapter, (struct adapter_stats *)data);
 425         data += sizeof(struct adapter_stats) / sizeof(u64);
 426
 427         *data++ = (u64)pi->port_id;
 428         collect_channel_stats(adapter, (struct channel_stats *)data,
 429                               pi->port_id);
 430         data += sizeof(struct channel_stats) / sizeof(u64);
 431
 432         *data++ = (u64)pi->port_id;
 433         memset(&s, 0, sizeof(s));
 434         t4_get_lb_stats(adapter, pi->port_id, &s);
 435
 436         p0 = &s.octets;
 437         for (i = 0; i < ARRAY_SIZE(loopback_stats_strings) - 1; i++)
 438                 *data++ = (unsigned long long)*p0++;
 439 }
 440
 441 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
 442                      void *buf)
 443 {
 444         struct adapter *adap = netdev2adap(dev);
 445         size_t buf_size;
 446
 447         buf_size = t4_get_regs_len(adap);
 448         regs->version = mk_adap_vers(adap);
 449         t4_get_regs(adap, buf, buf_size);
 450 }
 451
 452 static int restart_autoneg(struct net_device *dev)
 453 {
 454         struct port_info *p = netdev_priv(dev);
 455
 456         if (!netif_running(dev))
 457                 return -EAGAIN;
 458         if (p->link_cfg.autoneg != AUTONEG_ENABLE)
 459                 return -EINVAL;
 460         t4_restart_aneg(p->adapter, p->adapter->pf, p->tx_chan);
 461         return 0;
 462 }
 463
 464 static int identify_port(struct net_device *dev,
 465                          enum ethtool_phys_id_state state)
 466 {
 467         unsigned int val;
 468         struct adapter *adap = netdev2adap(dev);
 469
 470         if (state == ETHTOOL_ID_ACTIVE)
 471                 val = 0xffff;
 472         else if (state == ETHTOOL_ID_INACTIVE)
 473                 val = 0;
 474         else
 475                 return -EINVAL;
 476
 477         return t4_identify_port(adap, adap->pf, netdev2pinfo(dev)->viid, val);
 478 }
 479
 480 static unsigned int from_fw_linkcaps(enum fw_port_type type, unsigned int caps)
 481 {
 482         unsigned int v = 0;
 483
 484         if (type == FW_PORT_TYPE_BT_SGMII || type == FW_PORT_TYPE_BT_XFI ||
 485             type == FW_PORT_TYPE_BT_XAUI) {
 486                 v |= SUPPORTED_TP;
 487                 if (caps & FW_PORT_CAP_SPEED_100M)
 488                         v |= SUPPORTED_100baseT_Full;
 489                 if (caps & FW_PORT_CAP_SPEED_1G)
 490                         v |= SUPPORTED_1000baseT_Full;
 491                 if (caps & FW_PORT_CAP_SPEED_10G)
 492                         v |= SUPPORTED_10000baseT_Full;
 493         } else if (type == FW_PORT_TYPE_KX4 || type == FW_PORT_TYPE_KX) {
 494                 v |= SUPPORTED_Backplane;
 495                 if (caps & FW_PORT_CAP_SPEED_1G)
 496                         v |= SUPPORTED_1000baseKX_Full;
 497                 if (caps & FW_PORT_CAP_SPEED_10G)
 498                         v |= SUPPORTED_10000baseKX4_Full;
 499         } else if (type == FW_PORT_TYPE_KR) {
 500                 v |= SUPPORTED_Backplane | SUPPORTED_10000baseKR_Full;
 501         } else if (type == FW_PORT_TYPE_BP_AP) {
 502                 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
 503                      SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full;
 504         } else if (type == FW_PORT_TYPE_BP4_AP) {
 505                 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
 506                      SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full |
 507                      SUPPORTED_10000baseKX4_Full;
 508         } else if (type == FW_PORT_TYPE_FIBER_XFI ||
 509                    type == FW_PORT_TYPE_FIBER_XAUI ||
 510                    type == FW_PORT_TYPE_SFP ||
 511                    type == FW_PORT_TYPE_QSFP_10G ||
 512                    type == FW_PORT_TYPE_QSA) {
 513                 v |= SUPPORTED_FIBRE;
 514                 if (caps & FW_PORT_CAP_SPEED_1G)
 515                         v |= SUPPORTED_1000baseT_Full;
 516                 if (caps & FW_PORT_CAP_SPEED_10G)
 517                         v |= SUPPORTED_10000baseT_Full;
 518         } else if (type == FW_PORT_TYPE_BP40_BA ||
 519                    type == FW_PORT_TYPE_QSFP) {
 520                 v |= SUPPORTED_40000baseSR4_Full;
 521                 v |= SUPPORTED_FIBRE;
 522         }
 523
 524         if (caps & FW_PORT_CAP_ANEG)
 525                 v |= SUPPORTED_Autoneg;
 526         return v;
 527 }
 528
 529 static unsigned int to_fw_linkcaps(unsigned int caps)
 530 {
 531         unsigned int v = 0;
 532
 533         if (caps & ADVERTISED_100baseT_Full)
 534                 v |= FW_PORT_CAP_SPEED_100M;
 535         if (caps & ADVERTISED_1000baseT_Full)
 536                 v |= FW_PORT_CAP_SPEED_1G;
 537         if (caps & ADVERTISED_10000baseT_Full)
 538                 v |= FW_PORT_CAP_SPEED_10G;
 539         if (caps & ADVERTISED_40000baseSR4_Full)
 540                 v |= FW_PORT_CAP_SPEED_40G;
 541         return v;
 542 }
 543
 544 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 545 {
 546         const struct port_info *p = netdev_priv(dev);
 547
 548         if (p->port_type == FW_PORT_TYPE_BT_SGMII ||
 549             p->port_type == FW_PORT_TYPE_BT_XFI ||
 550             p->port_type == FW_PORT_TYPE_BT_XAUI) {
 551                 cmd->port = PORT_TP;
 552         } else if (p->port_type == FW_PORT_TYPE_FIBER_XFI ||
 553                    p->port_type == FW_PORT_TYPE_FIBER_XAUI) {
 554                 cmd->port = PORT_FIBRE;
 555         } else if (p->port_type == FW_PORT_TYPE_SFP ||
 556                    p->port_type == FW_PORT_TYPE_QSFP_10G ||
 557                    p->port_type == FW_PORT_TYPE_QSA ||
 558                    p->port_type == FW_PORT_TYPE_QSFP) {
 559                 if (p->mod_type == FW_PORT_MOD_TYPE_LR ||
 560                     p->mod_type == FW_PORT_MOD_TYPE_SR ||
 561                     p->mod_type == FW_PORT_MOD_TYPE_ER ||
 562                     p->mod_type == FW_PORT_MOD_TYPE_LRM)
 563                         cmd->port = PORT_FIBRE;
 564                 else if (p->mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE ||
 565                          p->mod_type == FW_PORT_MOD_TYPE_TWINAX_ACTIVE)
 566                         cmd->port = PORT_DA;
 567                 else
 568                         cmd->port = PORT_OTHER;
 569         } else {
 570                 cmd->port = PORT_OTHER;
 571         }
 572
 573         if (p->mdio_addr >= 0) {
 574                 cmd->phy_address = p->mdio_addr;
 575                 cmd->transceiver = XCVR_EXTERNAL;
 576                 cmd->mdio_support = p->port_type == FW_PORT_TYPE_BT_SGMII ?
 577                         MDIO_SUPPORTS_C22 : MDIO_SUPPORTS_C45;
 578         } else {
 579                 cmd->phy_address = 0;  /* not really, but no better option */
 580                 cmd->transceiver = XCVR_INTERNAL;
 581                 cmd->mdio_support = 0;
 582         }
 583
 584         cmd->supported = from_fw_linkcaps(p->port_type, p->link_cfg.supported);
 585         cmd->advertising = from_fw_linkcaps(p->port_type,
 586                                             p->link_cfg.advertising);
 587         ethtool_cmd_speed_set(cmd,
 588                               netif_carrier_ok(dev) ? p->link_cfg.speed : 0);
 589         cmd->duplex = DUPLEX_FULL;
 590         cmd->autoneg = p->link_cfg.autoneg;
 591         cmd->maxtxpkt = 0;
 592         cmd->maxrxpkt = 0;
 593         return 0;
 594 }
 595
 596 static unsigned int speed_to_caps(int speed)
 597 {
 598         if (speed == 100)
 599                 return FW_PORT_CAP_SPEED_100M;
 600         if (speed == 1000)
 601                 return FW_PORT_CAP_SPEED_1G;
 602         if (speed == 10000)
 603                 return FW_PORT_CAP_SPEED_10G;
 604         if (speed == 40000)
 605                 return FW_PORT_CAP_SPEED_40G;
 606         return 0;
 607 }
 608
 609 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 610 {
 611         unsigned int cap;
 612         struct port_info *p = netdev_priv(dev);
 613         struct link_config *lc = &p->link_cfg;
 614         u32 speed = ethtool_cmd_speed(cmd);
 615
 616         if (cmd->duplex != DUPLEX_FULL)     /* only full-duplex supported */
 617                 return -EINVAL;
 618
 619         if (!(lc->supported & FW_PORT_CAP_ANEG)) {
 620                 /* PHY offers a single speed.  See if that's what's
 621                  * being requested.
 622                  */
 623                 if (cmd->autoneg == AUTONEG_DISABLE &&
 624                     (lc->supported & speed_to_caps(speed)))
 625                         return 0;
 626                 return -EINVAL;
 627         }
 628
 629         if (cmd->autoneg == AUTONEG_DISABLE) {
 630                 cap = speed_to_caps(speed);
 631
 632                 if (!(lc->supported & cap) ||
 633                     (speed == 1000) ||
 634                     (speed == 10000) ||
 635                     (speed == 40000))
 636                         return -EINVAL;
 637                 lc->requested_speed = cap;
 638                 lc->advertising = 0;
 639         } else {
 640                 cap = to_fw_linkcaps(cmd->advertising);
 641                 if (!(lc->supported & cap))
 642                         return -EINVAL;
 643                 lc->requested_speed = 0;
 644                 lc->advertising = cap | FW_PORT_CAP_ANEG;
 645         }
 646         lc->autoneg = cmd->autoneg;
 647
 648         if (netif_running(dev))
 649                 return t4_link_l1cfg(p->adapter, p->adapter->pf, p->tx_chan,
 650                                      lc);
 651         return 0;
 652 }
 653
 654 static void get_pauseparam(struct net_device *dev,
 655                            struct ethtool_pauseparam *epause)
 656 {
 657         struct port_info *p = netdev_priv(dev);
 658
 659         epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
 660         epause->rx_pause = (p->link_cfg.fc & PAUSE_RX) != 0;
 661         epause->tx_pause = (p->link_cfg.fc & PAUSE_TX) != 0;
 662 }
 663
 664 static int set_pauseparam(struct net_device *dev,
 665                           struct ethtool_pauseparam *epause)
 666 {
 667         struct port_info *p = netdev_priv(dev);
 668         struct link_config *lc = &p->link_cfg;
 669
 670         if (epause->autoneg == AUTONEG_DISABLE)
 671                 lc->requested_fc = 0;
 672         else if (lc->supported & FW_PORT_CAP_ANEG)
 673                 lc->requested_fc = PAUSE_AUTONEG;
 674         else
 675                 return -EINVAL;
 676
 677         if (epause->rx_pause)
 678                 lc->requested_fc |= PAUSE_RX;
 679         if (epause->tx_pause)
 680                 lc->requested_fc |= PAUSE_TX;
 681         if (netif_running(dev))
 682                 return t4_link_l1cfg(p->adapter, p->adapter->pf, p->tx_chan,
 683                                      lc);
 684         return 0;
 685 }
 686
 687 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 688 {
 689         const struct port_info *pi = netdev_priv(dev);
 690         const struct sge *s = &pi->adapter->sge;
 691
 692         e->rx_max_pending = MAX_RX_BUFFERS;
 693         e->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
 694         e->rx_jumbo_max_pending = 0;
 695         e->tx_max_pending = MAX_TXQ_ENTRIES;
 696
 697         e->rx_pending = s->ethrxq[pi->first_qset].fl.size - 8;
 698         e->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
 699         e->rx_jumbo_pending = 0;
 700         e->tx_pending = s->ethtxq[pi->first_qset].q.size;
 701 }
 702
 703 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 704 {
 705         int i;
 706         const struct port_info *pi = netdev_priv(dev);
 707         struct adapter *adapter = pi->adapter;
 708         struct sge *s = &adapter->sge;
 709
 710         if (e->rx_pending > MAX_RX_BUFFERS || e->rx_jumbo_pending ||
 711             e->tx_pending > MAX_TXQ_ENTRIES ||
 712             e->rx_mini_pending > MAX_RSPQ_ENTRIES ||
 713             e->rx_mini_pending < MIN_RSPQ_ENTRIES ||
 714             e->rx_pending < MIN_FL_ENTRIES || e->tx_pending < MIN_TXQ_ENTRIES)
 715                 return -EINVAL;
 716
 717         if (adapter->flags & FULL_INIT_DONE)
 718                 return -EBUSY;
 719
 720         for (i = 0; i < pi->nqsets; ++i) {
 721                 s->ethtxq[pi->first_qset + i].q.size = e->tx_pending;
 722                 s->ethrxq[pi->first_qset + i].fl.size = e->rx_pending + 8;
 723                 s->ethrxq[pi->first_qset + i].rspq.size = e->rx_mini_pending;
 724         }
 725         return 0;
 726 }
 727
 728 /**
 729  * set_rx_intr_params - set a net devices's RX interrupt holdoff paramete!
 730  * @dev: the network device
 731  * @us: the hold-off time in us, or 0 to disable timer
 732  * @cnt: the hold-off packet count, or 0 to disable counter
 733  *
 734  * Set the RX interrupt hold-off parameters for a network device.
 735  */
 736 static int set_rx_intr_params(struct net_device *dev,
 737                               unsigned int us, unsigned int cnt)
 738 {
 739         int i, err;
 740         struct port_info *pi = netdev_priv(dev);
 741         struct adapter *adap = pi->adapter;
 742         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
 743
 744         for (i = 0; i < pi->nqsets; i++, q++) {
 745                 err = cxgb4_set_rspq_intr_params(&q->rspq, us, cnt);
 746                 if (err)
 747                         return err;
 748         }
 749         return 0;
 750 }
 751
 752 static int set_adaptive_rx_setting(struct net_device *dev, int adaptive_rx)
 753 {
 754         int i;
 755         struct port_info *pi = netdev_priv(dev);
 756         struct adapter *adap = pi->adapter;
 757         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
 758
 759         for (i = 0; i < pi->nqsets; i++, q++)
 760                 q->rspq.adaptive_rx = adaptive_rx;
 761
 762         return 0;
 763 }
 764
 765 static int get_adaptive_rx_setting(struct net_device *dev)
 766 {
 767         struct port_info *pi = netdev_priv(dev);
 768         struct adapter *adap = pi->adapter;
 769         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
 770
 771         return q->rspq.adaptive_rx;
 772 }
 773
 774 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
 775 {
 776         set_adaptive_rx_setting(dev, c->use_adaptive_rx_coalesce);
 777         return set_rx_intr_params(dev, c->rx_coalesce_usecs,
 778                                   c->rx_max_coalesced_frames);
 779 }
 780
 781 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
 782 {
 783         const struct port_info *pi = netdev_priv(dev);
 784         const struct adapter *adap = pi->adapter;
 785         const struct sge_rspq *rq = &adap->sge.ethrxq[pi->first_qset].rspq;
 786
 787         c->rx_coalesce_usecs = qtimer_val(adap, rq);
 788         c->rx_max_coalesced_frames = (rq->intr_params & QINTR_CNT_EN_F) ?
 789                 adap->sge.counter_val[rq->pktcnt_idx] : 0;
 790         c->use_adaptive_rx_coalesce = get_adaptive_rx_setting(dev);
 791         return 0;
 792 }
 793
 794 /**
 795  *      eeprom_ptov - translate a physical EEPROM address to virtual
 796  *      @phys_addr: the physical EEPROM address
 797  *      @fn: the PCI function number
 798  *      @sz: size of function-specific area
 799  *
 800  *      Translate a physical EEPROM address to virtual.  The first 1K is
 801  *      accessed through virtual addresses starting at 31K, the rest is
 802  *      accessed through virtual addresses starting at 0.
 803  *
 804  *      The mapping is as follows:
 805  *      [0..1K) -> [31K..32K)
 806  *      [1K..1K+A) -> [31K-A..31K)
 807  *      [1K+A..ES) -> [0..ES-A-1K)
 808  *
 809  *      where A = @fn * @sz, and ES = EEPROM size.
 810  */
 811 static int eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
 812 {
 813         fn *= sz;
 814         if (phys_addr < 1024)
 815                 return phys_addr + (31 << 10);
 816         if (phys_addr < 1024 + fn)
 817                 return 31744 - fn + phys_addr - 1024;
 818         if (phys_addr < EEPROMSIZE)
 819                 return phys_addr - 1024 - fn;
 820         return -EINVAL;
 821 }
 822
 823 /* The next two routines implement eeprom read/write from physical addresses.
 824  */
 825 static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v)
 826 {
 827         int vaddr = eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE);
 828
 829         if (vaddr >= 0)
 830                 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v);
 831         return vaddr < 0 ? vaddr : 0;
 832 }
 833
 834 static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v)
 835 {
 836         int vaddr = eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE);
 837
 838         if (vaddr >= 0)
 839                 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v);
 840         return vaddr < 0 ? vaddr : 0;
 841 }
 842
 843 #define EEPROM_MAGIC 0x38E2F10C
 844
 845 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
 846                       u8 *data)
 847 {
 848         int i, err = 0;
 849         struct adapter *adapter = netdev2adap(dev);
 850         u8 *buf = kmalloc(EEPROMSIZE, GFP_KERNEL);
 851
 852         if (!buf)
 853                 return -ENOMEM;
 854
 855         e->magic = EEPROM_MAGIC;
 856         for (i = e->offset & ~3; !err && i < e->offset + e->len; i += 4)
 857                 err = eeprom_rd_phys(adapter, i, (u32 *)&buf[i]);
 858
 859         if (!err)
 860                 memcpy(data, buf + e->offset, e->len);
 861         kfree(buf);
 862         return err;
 863 }
 864
 865 static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 866                       u8 *data)
 867 {
 868         u8 *buf;
 869         int err = 0;
 870         u32 aligned_offset, aligned_len, *p;
 871         struct adapter *adapter = netdev2adap(dev);
 872
 873         if (eeprom->magic != EEPROM_MAGIC)
 874                 return -EINVAL;
 875
 876         aligned_offset = eeprom->offset & ~3;
 877         aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3;
 878
 879         if (adapter->pf > 0) {
 880                 u32 start = 1024 + adapter->pf * EEPROMPFSIZE;
 881
 882                 if (aligned_offset < start ||
 883                     aligned_offset + aligned_len > start + EEPROMPFSIZE)
 884                         return -EPERM;
 885         }
 886
 887         if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) {
 888                 /* RMW possibly needed for first or last words.
 889                  */
 890                 buf = kmalloc(aligned_len, GFP_KERNEL);
 891                 if (!buf)
 892                         return -ENOMEM;
 893                 err = eeprom_rd_phys(adapter, aligned_offset, (u32 *)buf);
 894                 if (!err && aligned_len > 4)
 895                         err = eeprom_rd_phys(adapter,
 896                                              aligned_offset + aligned_len - 4,
 897                                              (u32 *)&buf[aligned_len - 4]);
 898                 if (err)
 899                         goto out;
 900                 memcpy(buf + (eeprom->offset & 3), data, eeprom->len);
 901         } else {
 902                 buf = data;
 903         }
 904
 905         err = t4_seeprom_wp(adapter, false);
 906         if (err)
 907                 goto out;
 908
 909         for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) {
 910                 err = eeprom_wr_phys(adapter, aligned_offset, *p);
 911                 aligned_offset += 4;
 912         }
 913
 914         if (!err)
 915                 err = t4_seeprom_wp(adapter, true);
 916 out:
 917         if (buf != data)
 918                 kfree(buf);
 919         return err;
 920 }
 921
 922 static int set_flash(struct net_device *netdev, struct ethtool_flash *ef)
 923 {
 924         int ret;
 925         const struct firmware *fw;
 926         struct adapter *adap = netdev2adap(netdev);
 927         unsigned int mbox = PCIE_FW_MASTER_M + 1;
 928
 929         ef->data[sizeof(ef->data) - 1] = '\0';
 930         ret = request_firmware(&fw, ef->data, adap->pdev_dev);
 931         if (ret < 0)
 932                 return ret;
 933
 934         /* If the adapter has been fully initialized then we'll go ahead and
 935          * try to get the firmware's cooperation in upgrading to the new
 936          * firmware image otherwise we'll try to do the entire job from the
 937          * host ... and we always "force" the operation in this path.
 938          */
 939         if (adap->flags & FULL_INIT_DONE)
 940                 mbox = adap->mbox;
 941
 942         ret = t4_fw_upgrade(adap, mbox, fw->data, fw->size, 1);
 943         release_firmware(fw);
 944         if (!ret)
 945                 dev_info(adap->pdev_dev,
 946                          "loaded firmware %s, reload cxgb4 driver\n", ef->data);
 947         return ret;
 948 }
 949
 950 static u32 get_rss_table_size(struct net_device *dev)
 951 {
 952         const struct port_info *pi = netdev_priv(dev);
 953
 954         return pi->rss_size;
 955 }
 956
 957 static int get_rss_table(struct net_device *dev, u32 *p, u8 *key, u8 *hfunc)
 958 {
 959         const struct port_info *pi = netdev_priv(dev);
 960         unsigned int n = pi->rss_size;
 961
 962         if (hfunc)
 963                 *hfunc = ETH_RSS_HASH_TOP;
 964         if (!p)
 965                 return 0;
 966         while (n--)
 967                 p[n] = pi->rss[n];
 968         return 0;
 969 }
 970
 971 static int set_rss_table(struct net_device *dev, const u32 *p, const u8 *key,
 972                          const u8 hfunc)
 973 {
 974         unsigned int i;
 975         struct port_info *pi = netdev_priv(dev);
 976
 977         /* We require at least one supported parameter to be changed and no
 978          * change in any of the unsupported parameters
 979          */
 980         if (key ||
 981             (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
 982                 return -EOPNOTSUPP;
 983         if (!p)
 984                 return 0;
 985
 986         for (i = 0; i < pi->rss_size; i++)
 987                 pi->rss[i] = p[i];
 988         if (pi->adapter->flags & FULL_INIT_DONE)
 989                 return cxgb4_write_rss(pi, pi->rss);
 990         return 0;
 991 }
 992
 993 static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
 994                      u32 *rules)
 995 {
 996         const struct port_info *pi = netdev_priv(dev);
 997
 998         switch (info->cmd) {
 999         case ETHTOOL_GRXFH: {
1000                 unsigned int v = pi->rss_mode;
1001
1002                 info->data = 0;
1003                 switch (info->flow_type) {
1004                 case TCP_V4_FLOW:
1005                         if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F)
1006                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1007                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1008                         else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1009                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1010                         break;
1011                 case UDP_V4_FLOW:
1012                         if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) &&
1013                             (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
1014                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1015                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1016                         else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1017                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1018                         break;
1019                 case SCTP_V4_FLOW:
1020                 case AH_ESP_V4_FLOW:
1021                 case IPV4_FLOW:
1022                         if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1023                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1024                         break;
1025                 case TCP_V6_FLOW:
1026                         if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F)
1027                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1028                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1029                         else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1030                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1031                         break;
1032                 case UDP_V6_FLOW:
1033                         if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) &&
1034                             (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
1035                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1036                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1037                         else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1038                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1039                         break;
1040                 case SCTP_V6_FLOW:
1041                 case AH_ESP_V6_FLOW:
1042                 case IPV6_FLOW:
1043                         if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1044                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1045                         break;
1046                 }
1047                 return 0;
1048         }
1049         case ETHTOOL_GRXRINGS:
1050                 info->data = pi->nqsets;
1051                 return 0;
1052         }
1053         return -EOPNOTSUPP;
1054 }
1055
1056 static const struct ethtool_ops cxgb_ethtool_ops = {
1057         .get_settings      = get_settings,
1058         .set_settings      = set_settings,
1059         .get_drvinfo       = get_drvinfo,
1060         .get_msglevel      = get_msglevel,
1061         .set_msglevel      = set_msglevel,
1062         .get_ringparam     = get_sge_param,
1063         .set_ringparam     = set_sge_param,
1064         .get_coalesce      = get_coalesce,
1065         .set_coalesce      = set_coalesce,
1066         .get_eeprom_len    = get_eeprom_len,
1067         .get_eeprom        = get_eeprom,
1068         .set_eeprom        = set_eeprom,
1069         .get_pauseparam    = get_pauseparam,
1070         .set_pauseparam    = set_pauseparam,
1071         .get_link          = ethtool_op_get_link,
1072         .get_strings       = get_strings,
1073         .set_phys_id       = identify_port,
1074         .nway_reset        = restart_autoneg,
1075         .get_sset_count    = get_sset_count,
1076         .get_ethtool_stats = get_stats,
1077         .get_regs_len      = get_regs_len,
1078         .get_regs          = get_regs,
1079         .get_rxnfc         = get_rxnfc,
1080         .get_rxfh_indir_size = get_rss_table_size,
1081         .get_rxfh          = get_rss_table,
1082         .set_rxfh          = set_rss_table,
1083         .flash_device      = set_flash,
1084 };
1085
1086 void cxgb4_set_ethtool_ops(struct net_device *netdev)
1087 {
1088         netdev->ethtool_ops = &cxgb_ethtool_ops;
1089 }