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 #include "cxgb4_cudbg.h"
  25
  26 #define EEPROM_MAGIC 0x38E2F10C
  27
  28 static u32 get_msglevel(struct net_device *dev)
  29 {
  30         return netdev2adap(dev)->msg_enable;
  31 }
  32
  33 static void set_msglevel(struct net_device *dev, u32 val)
  34 {
  35         netdev2adap(dev)->msg_enable = val;
  36 }
  37
  38 static const char stats_strings[][ETH_GSTRING_LEN] = {
  39         "tx_octets_ok           ",
  40         "tx_frames_ok           ",
  41         "tx_broadcast_frames    ",
  42         "tx_multicast_frames    ",
  43         "tx_unicast_frames      ",
  44         "tx_error_frames        ",
  45
  46         "tx_frames_64           ",
  47         "tx_frames_65_to_127    ",
  48         "tx_frames_128_to_255   ",
  49         "tx_frames_256_to_511   ",
  50         "tx_frames_512_to_1023  ",
  51         "tx_frames_1024_to_1518 ",
  52         "tx_frames_1519_to_max  ",
  53
  54         "tx_frames_dropped      ",
  55         "tx_pause_frames        ",
  56         "tx_ppp0_frames         ",
  57         "tx_ppp1_frames         ",
  58         "tx_ppp2_frames         ",
  59         "tx_ppp3_frames         ",
  60         "tx_ppp4_frames         ",
  61         "tx_ppp5_frames         ",
  62         "tx_ppp6_frames         ",
  63         "tx_ppp7_frames         ",
  64
  65         "rx_octets_ok           ",
  66         "rx_frames_ok           ",
  67         "rx_broadcast_frames    ",
  68         "rx_multicast_frames    ",
  69         "rx_unicast_frames      ",
  70
  71         "rx_frames_too_long     ",
  72         "rx_jabber_errors       ",
  73         "rx_fcs_errors          ",
  74         "rx_length_errors       ",
  75         "rx_symbol_errors       ",
  76         "rx_runt_frames         ",
  77
  78         "rx_frames_64           ",
  79         "rx_frames_65_to_127    ",
  80         "rx_frames_128_to_255   ",
  81         "rx_frames_256_to_511   ",
  82         "rx_frames_512_to_1023  ",
  83         "rx_frames_1024_to_1518 ",
  84         "rx_frames_1519_to_max  ",
  85
  86         "rx_pause_frames        ",
  87         "rx_ppp0_frames         ",
  88         "rx_ppp1_frames         ",
  89         "rx_ppp2_frames         ",
  90         "rx_ppp3_frames         ",
  91         "rx_ppp4_frames         ",
  92         "rx_ppp5_frames         ",
  93         "rx_ppp6_frames         ",
  94         "rx_ppp7_frames         ",
  95
  96         "rx_bg0_frames_dropped  ",
  97         "rx_bg1_frames_dropped  ",
  98         "rx_bg2_frames_dropped  ",
  99         "rx_bg3_frames_dropped  ",
 100         "rx_bg0_frames_trunc    ",
 101         "rx_bg1_frames_trunc    ",
 102         "rx_bg2_frames_trunc    ",
 103         "rx_bg3_frames_trunc    ",
 104
 105         "tso                    ",
 106         "tx_csum_offload        ",
 107         "rx_csum_good           ",
 108         "vlan_extractions       ",
 109         "vlan_insertions        ",
 110         "gro_packets            ",
 111         "gro_merged             ",
 112 };
 113
 114 static char adapter_stats_strings[][ETH_GSTRING_LEN] = {
 115         "db_drop                ",
 116         "db_full                ",
 117         "db_empty               ",
 118         "tcp_ipv4_out_rsts      ",
 119         "tcp_ipv4_in_segs       ",
 120         "tcp_ipv4_out_segs      ",
 121         "tcp_ipv4_retrans_segs  ",
 122         "tcp_ipv6_out_rsts      ",
 123         "tcp_ipv6_in_segs       ",
 124         "tcp_ipv6_out_segs      ",
 125         "tcp_ipv6_retrans_segs  ",
 126         "usm_ddp_frames         ",
 127         "usm_ddp_octets         ",
 128         "usm_ddp_drops          ",
 129         "rdma_no_rqe_mod_defer  ",
 130         "rdma_no_rqe_pkt_defer  ",
 131         "tp_err_ofld_no_neigh   ",
 132         "tp_err_ofld_cong_defer ",
 133         "write_coal_success     ",
 134         "write_coal_fail        ",
 135 };
 136
 137 static char channel_stats_strings[][ETH_GSTRING_LEN] = {
 138         "--------Channel--------- ",
 139         "tp_cpl_requests        ",
 140         "tp_cpl_responses       ",
 141         "tp_mac_in_errs         ",
 142         "tp_hdr_in_errs         ",
 143         "tp_tcp_in_errs         ",
 144         "tp_tcp6_in_errs        ",
 145         "tp_tnl_cong_drops      ",
 146         "tp_tnl_tx_drops        ",
 147         "tp_ofld_vlan_drops     ",
 148         "tp_ofld_chan_drops     ",
 149         "fcoe_octets_ddp        ",
 150         "fcoe_frames_ddp        ",
 151         "fcoe_frames_drop       ",
 152 };
 153
 154 static char loopback_stats_strings[][ETH_GSTRING_LEN] = {
 155         "-------Loopback----------- ",
 156         "octets_ok              ",
 157         "frames_ok              ",
 158         "bcast_frames           ",
 159         "mcast_frames           ",
 160         "ucast_frames           ",
 161         "error_frames           ",
 162         "frames_64              ",
 163         "frames_65_to_127       ",
 164         "frames_128_to_255      ",
 165         "frames_256_to_511      ",
 166         "frames_512_to_1023     ",
 167         "frames_1024_to_1518    ",
 168         "frames_1519_to_max     ",
 169         "frames_dropped         ",
 170         "bg0_frames_dropped     ",
 171         "bg1_frames_dropped     ",
 172         "bg2_frames_dropped     ",
 173         "bg3_frames_dropped     ",
 174         "bg0_frames_trunc       ",
 175         "bg1_frames_trunc       ",
 176         "bg2_frames_trunc       ",
 177         "bg3_frames_trunc       ",
 178 };
 179
 180 static int get_sset_count(struct net_device *dev, int sset)
 181 {
 182         switch (sset) {
 183         case ETH_SS_STATS:
 184                 return ARRAY_SIZE(stats_strings) +
 185                        ARRAY_SIZE(adapter_stats_strings) +
 186                        ARRAY_SIZE(channel_stats_strings) +
 187                        ARRAY_SIZE(loopback_stats_strings);
 188         default:
 189                 return -EOPNOTSUPP;
 190         }
 191 }
 192
 193 static int get_regs_len(struct net_device *dev)
 194 {
 195         struct adapter *adap = netdev2adap(dev);
 196
 197         return t4_get_regs_len(adap);
 198 }
 199
 200 static int get_eeprom_len(struct net_device *dev)
 201 {
 202         return EEPROMSIZE;
 203 }
 204
 205 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 206 {
 207         struct adapter *adapter = netdev2adap(dev);
 208         u32 exprom_vers;
 209
 210         strlcpy(info->driver, cxgb4_driver_name, sizeof(info->driver));
 211         strlcpy(info->version, cxgb4_driver_version,
 212                 sizeof(info->version));
 213         strlcpy(info->bus_info, pci_name(adapter->pdev),
 214                 sizeof(info->bus_info));
 215         info->regdump_len = get_regs_len(dev);
 216
 217         if (!adapter->params.fw_vers)
 218                 strcpy(info->fw_version, "N/A");
 219         else
 220                 snprintf(info->fw_version, sizeof(info->fw_version),
 221                          "%u.%u.%u.%u, TP %u.%u.%u.%u",
 222                          FW_HDR_FW_VER_MAJOR_G(adapter->params.fw_vers),
 223                          FW_HDR_FW_VER_MINOR_G(adapter->params.fw_vers),
 224                          FW_HDR_FW_VER_MICRO_G(adapter->params.fw_vers),
 225                          FW_HDR_FW_VER_BUILD_G(adapter->params.fw_vers),
 226                          FW_HDR_FW_VER_MAJOR_G(adapter->params.tp_vers),
 227                          FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers),
 228                          FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers),
 229                          FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers));
 230
 231         if (!t4_get_exprom_version(adapter, &exprom_vers))
 232                 snprintf(info->erom_version, sizeof(info->erom_version),
 233                          "%u.%u.%u.%u",
 234                          FW_HDR_FW_VER_MAJOR_G(exprom_vers),
 235                          FW_HDR_FW_VER_MINOR_G(exprom_vers),
 236                          FW_HDR_FW_VER_MICRO_G(exprom_vers),
 237                          FW_HDR_FW_VER_BUILD_G(exprom_vers));
 238 }
 239
 240 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
 241 {
 242         if (stringset == ETH_SS_STATS) {
 243                 memcpy(data, stats_strings, sizeof(stats_strings));
 244                 data += sizeof(stats_strings);
 245                 memcpy(data, adapter_stats_strings,
 246                        sizeof(adapter_stats_strings));
 247                 data += sizeof(adapter_stats_strings);
 248                 memcpy(data, channel_stats_strings,
 249                        sizeof(channel_stats_strings));
 250                 data += sizeof(channel_stats_strings);
 251                 memcpy(data, loopback_stats_strings,
 252                        sizeof(loopback_stats_strings));
 253         }
 254 }
 255
 256 /* port stats maintained per queue of the port. They should be in the same
 257  * order as in stats_strings above.
 258  */
 259 struct queue_port_stats {
 260         u64 tso;
 261         u64 tx_csum;
 262         u64 rx_csum;
 263         u64 vlan_ex;
 264         u64 vlan_ins;
 265         u64 gro_pkts;
 266         u64 gro_merged;
 267 };
 268
 269 struct adapter_stats {
 270         u64 db_drop;
 271         u64 db_full;
 272         u64 db_empty;
 273         u64 tcp_v4_out_rsts;
 274         u64 tcp_v4_in_segs;
 275         u64 tcp_v4_out_segs;
 276         u64 tcp_v4_retrans_segs;
 277         u64 tcp_v6_out_rsts;
 278         u64 tcp_v6_in_segs;
 279         u64 tcp_v6_out_segs;
 280         u64 tcp_v6_retrans_segs;
 281         u64 frames;
 282         u64 octets;
 283         u64 drops;
 284         u64 rqe_dfr_mod;
 285         u64 rqe_dfr_pkt;
 286         u64 ofld_no_neigh;
 287         u64 ofld_cong_defer;
 288         u64 wc_success;
 289         u64 wc_fail;
 290 };
 291
 292 struct channel_stats {
 293         u64 cpl_req;
 294         u64 cpl_rsp;
 295         u64 mac_in_errs;
 296         u64 hdr_in_errs;
 297         u64 tcp_in_errs;
 298         u64 tcp6_in_errs;
 299         u64 tnl_cong_drops;
 300         u64 tnl_tx_drops;
 301         u64 ofld_vlan_drops;
 302         u64 ofld_chan_drops;
 303         u64 octets_ddp;
 304         u64 frames_ddp;
 305         u64 frames_drop;
 306 };
 307
 308 static void collect_sge_port_stats(const struct adapter *adap,
 309                                    const struct port_info *p,
 310                                    struct queue_port_stats *s)
 311 {
 312         int i;
 313         const struct sge_eth_txq *tx = &adap->sge.ethtxq[p->first_qset];
 314         const struct sge_eth_rxq *rx = &adap->sge.ethrxq[p->first_qset];
 315
 316         memset(s, 0, sizeof(*s));
 317         for (i = 0; i < p->nqsets; i++, rx++, tx++) {
 318                 s->tso += tx->tso;
 319                 s->tx_csum += tx->tx_cso;
 320                 s->rx_csum += rx->stats.rx_cso;
 321                 s->vlan_ex += rx->stats.vlan_ex;
 322                 s->vlan_ins += tx->vlan_ins;
 323                 s->gro_pkts += rx->stats.lro_pkts;
 324                 s->gro_merged += rx->stats.lro_merged;
 325         }
 326 }
 327
 328 static void collect_adapter_stats(struct adapter *adap, struct adapter_stats *s)
 329 {
 330         struct tp_tcp_stats v4, v6;
 331         struct tp_rdma_stats rdma_stats;
 332         struct tp_err_stats err_stats;
 333         struct tp_usm_stats usm_stats;
 334         u64 val1, val2;
 335
 336         memset(s, 0, sizeof(*s));
 337
 338         spin_lock(&adap->stats_lock);
 339         t4_tp_get_tcp_stats(adap, &v4, &v6, false);
 340         t4_tp_get_rdma_stats(adap, &rdma_stats, false);
 341         t4_get_usm_stats(adap, &usm_stats, false);
 342         t4_tp_get_err_stats(adap, &err_stats, false);
 343         spin_unlock(&adap->stats_lock);
 344
 345         s->db_drop = adap->db_stats.db_drop;
 346         s->db_full = adap->db_stats.db_full;
 347         s->db_empty = adap->db_stats.db_empty;
 348
 349         s->tcp_v4_out_rsts = v4.tcp_out_rsts;
 350         s->tcp_v4_in_segs = v4.tcp_in_segs;
 351         s->tcp_v4_out_segs = v4.tcp_out_segs;
 352         s->tcp_v4_retrans_segs = v4.tcp_retrans_segs;
 353         s->tcp_v6_out_rsts = v6.tcp_out_rsts;
 354         s->tcp_v6_in_segs = v6.tcp_in_segs;
 355         s->tcp_v6_out_segs = v6.tcp_out_segs;
 356         s->tcp_v6_retrans_segs = v6.tcp_retrans_segs;
 357
 358         if (is_offload(adap)) {
 359                 s->frames = usm_stats.frames;
 360                 s->octets = usm_stats.octets;
 361                 s->drops = usm_stats.drops;
 362                 s->rqe_dfr_mod = rdma_stats.rqe_dfr_mod;
 363                 s->rqe_dfr_pkt = rdma_stats.rqe_dfr_pkt;
 364         }
 365
 366         s->ofld_no_neigh = err_stats.ofld_no_neigh;
 367         s->ofld_cong_defer = err_stats.ofld_cong_defer;
 368
 369         if (!is_t4(adap->params.chip)) {
 370                 int v;
 371
 372                 v = t4_read_reg(adap, SGE_STAT_CFG_A);
 373                 if (STATSOURCE_T5_G(v) == 7) {
 374                         val2 = t4_read_reg(adap, SGE_STAT_MATCH_A);
 375                         val1 = t4_read_reg(adap, SGE_STAT_TOTAL_A);
 376                         s->wc_success = val1 - val2;
 377                         s->wc_fail = val2;
 378                 }
 379         }
 380 }
 381
 382 static void collect_channel_stats(struct adapter *adap, struct channel_stats *s,
 383                                   u8 i)
 384 {
 385         struct tp_cpl_stats cpl_stats;
 386         struct tp_err_stats err_stats;
 387         struct tp_fcoe_stats fcoe_stats;
 388
 389         memset(s, 0, sizeof(*s));
 390
 391         spin_lock(&adap->stats_lock);
 392         t4_tp_get_cpl_stats(adap, &cpl_stats, false);
 393         t4_tp_get_err_stats(adap, &err_stats, false);
 394         t4_get_fcoe_stats(adap, i, &fcoe_stats, false);
 395         spin_unlock(&adap->stats_lock);
 396
 397         s->cpl_req = cpl_stats.req[i];
 398         s->cpl_rsp = cpl_stats.rsp[i];
 399         s->mac_in_errs = err_stats.mac_in_errs[i];
 400         s->hdr_in_errs = err_stats.hdr_in_errs[i];
 401         s->tcp_in_errs = err_stats.tcp_in_errs[i];
 402         s->tcp6_in_errs = err_stats.tcp6_in_errs[i];
 403         s->tnl_cong_drops = err_stats.tnl_cong_drops[i];
 404         s->tnl_tx_drops = err_stats.tnl_tx_drops[i];
 405         s->ofld_vlan_drops = err_stats.ofld_vlan_drops[i];
 406         s->ofld_chan_drops = err_stats.ofld_chan_drops[i];
 407         s->octets_ddp = fcoe_stats.octets_ddp;
 408         s->frames_ddp = fcoe_stats.frames_ddp;
 409         s->frames_drop = fcoe_stats.frames_drop;
 410 }
 411
 412 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
 413                       u64 *data)
 414 {
 415         struct port_info *pi = netdev_priv(dev);
 416         struct adapter *adapter = pi->adapter;
 417         struct lb_port_stats s;
 418         int i;
 419         u64 *p0;
 420
 421         t4_get_port_stats_offset(adapter, pi->tx_chan,
 422                                  (struct port_stats *)data,
 423                                  &pi->stats_base);
 424
 425         data += sizeof(struct port_stats) / sizeof(u64);
 426         collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
 427         data += sizeof(struct queue_port_stats) / sizeof(u64);
 428         collect_adapter_stats(adapter, (struct adapter_stats *)data);
 429         data += sizeof(struct adapter_stats) / sizeof(u64);
 430
 431         *data++ = (u64)pi->port_id;
 432         collect_channel_stats(adapter, (struct channel_stats *)data,
 433                               pi->port_id);
 434         data += sizeof(struct channel_stats) / sizeof(u64);
 435
 436         *data++ = (u64)pi->port_id;
 437         memset(&s, 0, sizeof(s));
 438         t4_get_lb_stats(adapter, pi->port_id, &s);
 439
 440         p0 = &s.octets;
 441         for (i = 0; i < ARRAY_SIZE(loopback_stats_strings) - 1; i++)
 442                 *data++ = (unsigned long long)*p0++;
 443 }
 444
 445 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
 446                      void *buf)
 447 {
 448         struct adapter *adap = netdev2adap(dev);
 449         size_t buf_size;
 450
 451         buf_size = t4_get_regs_len(adap);
 452         regs->version = mk_adap_vers(adap);
 453         t4_get_regs(adap, buf, buf_size);
 454 }
 455
 456 static int restart_autoneg(struct net_device *dev)
 457 {
 458         struct port_info *p = netdev_priv(dev);
 459
 460         if (!netif_running(dev))
 461                 return -EAGAIN;
 462         if (p->link_cfg.autoneg != AUTONEG_ENABLE)
 463                 return -EINVAL;
 464         t4_restart_aneg(p->adapter, p->adapter->pf, p->tx_chan);
 465         return 0;
 466 }
 467
 468 static int identify_port(struct net_device *dev,
 469                          enum ethtool_phys_id_state state)
 470 {
 471         unsigned int val;
 472         struct adapter *adap = netdev2adap(dev);
 473
 474         if (state == ETHTOOL_ID_ACTIVE)
 475                 val = 0xffff;
 476         else if (state == ETHTOOL_ID_INACTIVE)
 477                 val = 0;
 478         else
 479                 return -EINVAL;
 480
 481         return t4_identify_port(adap, adap->pf, netdev2pinfo(dev)->viid, val);
 482 }
 483
 484 /**
 485  *      from_fw_port_mod_type - translate Firmware Port/Module type to Ethtool
 486  *      @port_type: Firmware Port Type
 487  *      @mod_type: Firmware Module Type
 488  *
 489  *      Translate Firmware Port/Module type to Ethtool Port Type.
 490  */
 491 static int from_fw_port_mod_type(enum fw_port_type port_type,
 492                                  enum fw_port_module_type mod_type)
 493 {
 494         if (port_type == FW_PORT_TYPE_BT_SGMII ||
 495             port_type == FW_PORT_TYPE_BT_XFI ||
 496             port_type == FW_PORT_TYPE_BT_XAUI) {
 497                 return PORT_TP;
 498         } else if (port_type == FW_PORT_TYPE_FIBER_XFI ||
 499                    port_type == FW_PORT_TYPE_FIBER_XAUI) {
 500                 return PORT_FIBRE;
 501         } else if (port_type == FW_PORT_TYPE_SFP ||
 502                    port_type == FW_PORT_TYPE_QSFP_10G ||
 503                    port_type == FW_PORT_TYPE_QSA ||
 504                    port_type == FW_PORT_TYPE_QSFP ||
 505                    port_type == FW_PORT_TYPE_CR4_QSFP ||
 506                    port_type == FW_PORT_TYPE_CR_QSFP ||
 507                    port_type == FW_PORT_TYPE_CR2_QSFP ||
 508                    port_type == FW_PORT_TYPE_SFP28) {
 509                 if (mod_type == FW_PORT_MOD_TYPE_LR ||
 510                     mod_type == FW_PORT_MOD_TYPE_SR ||
 511                     mod_type == FW_PORT_MOD_TYPE_ER ||
 512                     mod_type == FW_PORT_MOD_TYPE_LRM)
 513                         return PORT_FIBRE;
 514                 else if (mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE ||
 515                          mod_type == FW_PORT_MOD_TYPE_TWINAX_ACTIVE)
 516                         return PORT_DA;
 517                 else
 518                         return PORT_OTHER;
 519         } else if (port_type == FW_PORT_TYPE_KR4_100G ||
 520                    port_type == FW_PORT_TYPE_KR_SFP28) {
 521                 return PORT_NONE;
 522         }
 523
 524         return PORT_OTHER;
 525 }
 526
 527 /**
 528  *      speed_to_fw_caps - translate Port Speed to Firmware Port Capabilities
 529  *      @speed: speed in Kb/s
 530  *
 531  *      Translates a specific Port Speed into a Firmware Port Capabilities
 532  *      value.
 533  */
 534 static unsigned int speed_to_fw_caps(int speed)
 535 {
 536         if (speed == 100)
 537                 return FW_PORT_CAP32_SPEED_100M;
 538         if (speed == 1000)
 539                 return FW_PORT_CAP32_SPEED_1G;
 540         if (speed == 10000)
 541                 return FW_PORT_CAP32_SPEED_10G;
 542         if (speed == 25000)
 543                 return FW_PORT_CAP32_SPEED_25G;
 544         if (speed == 40000)
 545                 return FW_PORT_CAP32_SPEED_40G;
 546         if (speed == 50000)
 547                 return FW_PORT_CAP32_SPEED_50G;
 548         if (speed == 100000)
 549                 return FW_PORT_CAP32_SPEED_100G;
 550         if (speed == 200000)
 551                 return FW_PORT_CAP32_SPEED_200G;
 552         if (speed == 400000)
 553                 return FW_PORT_CAP32_SPEED_400G;
 554         return 0;
 555 }
 556
 557 /**
 558  *      fw_caps_to_lmm - translate Firmware to ethtool Link Mode Mask
 559  *      @port_type: Firmware Port Type
 560  *      @fw_caps: Firmware Port Capabilities
 561  *      @link_mode_mask: ethtool Link Mode Mask
 562  *
 563  *      Translate a Firmware Port Capabilities specification to an ethtool
 564  *      Link Mode Mask.
 565  */
 566 static void fw_caps_to_lmm(enum fw_port_type port_type,
 567                            unsigned int fw_caps,
 568                            unsigned long *link_mode_mask)
 569 {
 570         #define SET_LMM(__lmm_name) \
 571                 __set_bit(ETHTOOL_LINK_MODE_ ## __lmm_name ## _BIT, \
 572                           link_mode_mask)
 573
 574         #define FW_CAPS_TO_LMM(__fw_name, __lmm_name) \
 575                 do { \
 576                         if (fw_caps & FW_PORT_CAP32_ ## __fw_name) \
 577                                 SET_LMM(__lmm_name); \
 578                 } while (0)
 579
 580         switch (port_type) {
 581         case FW_PORT_TYPE_BT_SGMII:
 582         case FW_PORT_TYPE_BT_XFI:
 583         case FW_PORT_TYPE_BT_XAUI:
 584                 SET_LMM(TP);
 585                 FW_CAPS_TO_LMM(SPEED_100M, 100baseT_Full);
 586                 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full);
 587                 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full);
 588                 break;
 589
 590         case FW_PORT_TYPE_KX4:
 591         case FW_PORT_TYPE_KX:
 592                 SET_LMM(Backplane);
 593                 FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full);
 594                 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKX4_Full);
 595                 break;
 596
 597         case FW_PORT_TYPE_KR:
 598                 SET_LMM(Backplane);
 599                 SET_LMM(10000baseKR_Full);
 600                 break;
 601
 602         case FW_PORT_TYPE_BP_AP:
 603                 SET_LMM(Backplane);
 604                 SET_LMM(10000baseR_FEC);
 605                 SET_LMM(10000baseKR_Full);
 606                 SET_LMM(1000baseKX_Full);
 607                 break;
 608
 609         case FW_PORT_TYPE_BP4_AP:
 610                 SET_LMM(Backplane);
 611                 SET_LMM(10000baseR_FEC);
 612                 SET_LMM(10000baseKR_Full);
 613                 SET_LMM(1000baseKX_Full);
 614                 SET_LMM(10000baseKX4_Full);
 615                 break;
 616
 617         case FW_PORT_TYPE_FIBER_XFI:
 618         case FW_PORT_TYPE_FIBER_XAUI:
 619         case FW_PORT_TYPE_SFP:
 620         case FW_PORT_TYPE_QSFP_10G:
 621         case FW_PORT_TYPE_QSA:
 622                 SET_LMM(FIBRE);
 623                 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full);
 624                 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full);
 625                 break;
 626
 627         case FW_PORT_TYPE_BP40_BA:
 628         case FW_PORT_TYPE_QSFP:
 629                 SET_LMM(FIBRE);
 630                 SET_LMM(40000baseSR4_Full);
 631                 break;
 632
 633         case FW_PORT_TYPE_CR_QSFP:
 634         case FW_PORT_TYPE_SFP28:
 635                 SET_LMM(FIBRE);
 636                 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full);
 637                 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full);
 638                 FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full);
 639                 break;
 640
 641         case FW_PORT_TYPE_KR_SFP28:
 642                 SET_LMM(Backplane);
 643                 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full);
 644                 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full);
 645                 FW_CAPS_TO_LMM(SPEED_25G, 25000baseKR_Full);
 646                 break;
 647
 648         case FW_PORT_TYPE_CR2_QSFP:
 649                 SET_LMM(FIBRE);
 650                 SET_LMM(50000baseSR2_Full);
 651                 break;
 652
 653         case FW_PORT_TYPE_KR4_100G:
 654         case FW_PORT_TYPE_CR4_QSFP:
 655                 SET_LMM(FIBRE);
 656                 FW_CAPS_TO_LMM(SPEED_40G, 40000baseSR4_Full);
 657                 FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full);
 658                 FW_CAPS_TO_LMM(SPEED_50G, 50000baseCR2_Full);
 659                 FW_CAPS_TO_LMM(SPEED_100G, 100000baseCR4_Full);
 660                 break;
 661
 662         default:
 663                 break;
 664         }
 665
 666         FW_CAPS_TO_LMM(ANEG, Autoneg);
 667         FW_CAPS_TO_LMM(802_3_PAUSE, Pause);
 668         FW_CAPS_TO_LMM(802_3_ASM_DIR, Asym_Pause);
 669
 670         #undef FW_CAPS_TO_LMM
 671         #undef SET_LMM
 672 }
 673
 674 /**
 675  *      lmm_to_fw_caps - translate ethtool Link Mode Mask to Firmware
 676  *      capabilities
 677  *      @et_lmm: ethtool Link Mode Mask
 678  *
 679  *      Translate ethtool Link Mode Mask into a Firmware Port capabilities
 680  *      value.
 681  */
 682 static unsigned int lmm_to_fw_caps(const unsigned long *link_mode_mask)
 683 {
 684         unsigned int fw_caps = 0;
 685
 686         #define LMM_TO_FW_CAPS(__lmm_name, __fw_name) \
 687                 do { \
 688                         if (test_bit(ETHTOOL_LINK_MODE_ ## __lmm_name ## _BIT, \
 689                                      link_mode_mask)) \
 690                                 fw_caps |= FW_PORT_CAP32_ ## __fw_name; \
 691                 } while (0)
 692
 693         LMM_TO_FW_CAPS(100baseT_Full, SPEED_100M);
 694         LMM_TO_FW_CAPS(1000baseT_Full, SPEED_1G);
 695         LMM_TO_FW_CAPS(10000baseT_Full, SPEED_10G);
 696         LMM_TO_FW_CAPS(40000baseSR4_Full, SPEED_40G);
 697         LMM_TO_FW_CAPS(25000baseCR_Full, SPEED_25G);
 698         LMM_TO_FW_CAPS(50000baseCR2_Full, SPEED_50G);
 699         LMM_TO_FW_CAPS(100000baseCR4_Full, SPEED_100G);
 700
 701         #undef LMM_TO_FW_CAPS
 702
 703         return fw_caps;
 704 }
 705
 706 static int get_link_ksettings(struct net_device *dev,
 707                               struct ethtool_link_ksettings *link_ksettings)
 708 {
 709         struct port_info *pi = netdev_priv(dev);
 710         struct ethtool_link_settings *base = &link_ksettings->base;
 711
 712         /* For the nonce, the Firmware doesn't send up Port State changes
 713          * when the Virtual Interface attached to the Port is down.  So
 714          * if it's down, let's grab any changes.
 715          */
 716         if (!netif_running(dev))
 717                 (void)t4_update_port_info(pi);
 718
 719         ethtool_link_ksettings_zero_link_mode(link_ksettings, supported);
 720         ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);
 721         ethtool_link_ksettings_zero_link_mode(link_ksettings, lp_advertising);
 722
 723         base->port = from_fw_port_mod_type(pi->port_type, pi->mod_type);
 724
 725         if (pi->mdio_addr >= 0) {
 726                 base->phy_address = pi->mdio_addr;
 727                 base->mdio_support = (pi->port_type == FW_PORT_TYPE_BT_SGMII
 728                                       ? ETH_MDIO_SUPPORTS_C22
 729                                       : ETH_MDIO_SUPPORTS_C45);
 730         } else {
 731                 base->phy_address = 255;
 732                 base->mdio_support = 0;
 733         }
 734
 735         fw_caps_to_lmm(pi->port_type, pi->link_cfg.pcaps,
 736                        link_ksettings->link_modes.supported);
 737         fw_caps_to_lmm(pi->port_type, pi->link_cfg.acaps,
 738                        link_ksettings->link_modes.advertising);
 739         fw_caps_to_lmm(pi->port_type, pi->link_cfg.lpacaps,
 740                        link_ksettings->link_modes.lp_advertising);
 741
 742         if (netif_carrier_ok(dev)) {
 743                 base->speed = pi->link_cfg.speed;
 744                 base->duplex = DUPLEX_FULL;
 745         } else {
 746                 base->speed = SPEED_UNKNOWN;
 747                 base->duplex = DUPLEX_UNKNOWN;
 748         }
 749
 750         if (pi->link_cfg.fc & PAUSE_RX) {
 751                 if (pi->link_cfg.fc & PAUSE_TX) {
 752                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 753                                                              advertising,
 754                                                              Pause);
 755                 } else {
 756                         ethtool_link_ksettings_add_link_mode(link_ksettings,
 757                                                              advertising,
 758                                                              Asym_Pause);
 759                 }
 760         } else if (pi->link_cfg.fc & PAUSE_TX) {
 761                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 762                                                      advertising,
 763                                                      Asym_Pause);
 764         }
 765
 766         base->autoneg = pi->link_cfg.autoneg;
 767         if (pi->link_cfg.pcaps & FW_PORT_CAP32_ANEG)
 768                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 769                                                      supported, Autoneg);
 770         if (pi->link_cfg.autoneg)
 771                 ethtool_link_ksettings_add_link_mode(link_ksettings,
 772                                                      advertising, Autoneg);
 773
 774         return 0;
 775 }
 776
 777 static int set_link_ksettings(struct net_device *dev,
 778                             const struct ethtool_link_ksettings *link_ksettings)
 779 {
 780         struct port_info *pi = netdev_priv(dev);
 781         struct link_config *lc = &pi->link_cfg;
 782         const struct ethtool_link_settings *base = &link_ksettings->base;
 783         struct link_config old_lc;
 784         unsigned int fw_caps;
 785         int ret = 0;
 786
 787         /* only full-duplex supported */
 788         if (base->duplex != DUPLEX_FULL)
 789                 return -EINVAL;
 790
 791         if (!(lc->pcaps & FW_PORT_CAP32_ANEG)) {
 792                 /* PHY offers a single speed.  See if that's what's
 793                  * being requested.
 794                  */
 795                 if (base->autoneg == AUTONEG_DISABLE &&
 796                     (lc->pcaps & speed_to_fw_caps(base->speed)))
 797                         return 0;
 798                 return -EINVAL;
 799         }
 800
 801         old_lc = *lc;
 802         if (base->autoneg == AUTONEG_DISABLE) {
 803                 fw_caps = speed_to_fw_caps(base->speed);
 804
 805                 if (!(lc->pcaps & fw_caps))
 806                         return -EINVAL;
 807                 lc->speed_caps = fw_caps;
 808                 lc->acaps = 0;
 809         } else {
 810                 fw_caps =
 811                          lmm_to_fw_caps(link_ksettings->link_modes.advertising);
 812                 if (!(lc->pcaps & fw_caps))
 813                         return -EINVAL;
 814                 lc->speed_caps = 0;
 815                 lc->acaps = fw_caps | FW_PORT_CAP32_ANEG;
 816         }
 817         lc->autoneg = base->autoneg;
 818
 819         /* If the firmware rejects the Link Configuration request, back out
 820          * the changes and report the error.
 821          */
 822         ret = t4_link_l1cfg(pi->adapter, pi->adapter->mbox, pi->tx_chan, lc);
 823         if (ret)
 824                 *lc = old_lc;
 825
 826         return ret;
 827 }
 828
 829 /* Translate the Firmware FEC value into the ethtool value. */
 830 static inline unsigned int fwcap_to_eth_fec(unsigned int fw_fec)
 831 {
 832         unsigned int eth_fec = 0;
 833
 834         if (fw_fec & FW_PORT_CAP32_FEC_RS)
 835                 eth_fec |= ETHTOOL_FEC_RS;
 836         if (fw_fec & FW_PORT_CAP32_FEC_BASER_RS)
 837                 eth_fec |= ETHTOOL_FEC_BASER;
 838
 839         /* if nothing is set, then FEC is off */
 840         if (!eth_fec)
 841                 eth_fec = ETHTOOL_FEC_OFF;
 842
 843         return eth_fec;
 844 }
 845
 846 /* Translate Common Code FEC value into ethtool value. */
 847 static inline unsigned int cc_to_eth_fec(unsigned int cc_fec)
 848 {
 849         unsigned int eth_fec = 0;
 850
 851         if (cc_fec & FEC_AUTO)
 852                 eth_fec |= ETHTOOL_FEC_AUTO;
 853         if (cc_fec & FEC_RS)
 854                 eth_fec |= ETHTOOL_FEC_RS;
 855         if (cc_fec & FEC_BASER_RS)
 856                 eth_fec |= ETHTOOL_FEC_BASER;
 857
 858         /* if nothing is set, then FEC is off */
 859         if (!eth_fec)
 860                 eth_fec = ETHTOOL_FEC_OFF;
 861
 862         return eth_fec;
 863 }
 864
 865 /* Translate ethtool FEC value into Common Code value. */
 866 static inline unsigned int eth_to_cc_fec(unsigned int eth_fec)
 867 {
 868         unsigned int cc_fec = 0;
 869
 870         if (eth_fec & ETHTOOL_FEC_OFF)
 871                 return cc_fec;
 872
 873         if (eth_fec & ETHTOOL_FEC_AUTO)
 874                 cc_fec |= FEC_AUTO;
 875         if (eth_fec & ETHTOOL_FEC_RS)
 876                 cc_fec |= FEC_RS;
 877         if (eth_fec & ETHTOOL_FEC_BASER)
 878                 cc_fec |= FEC_BASER_RS;
 879
 880         return cc_fec;
 881 }
 882
 883 static int get_fecparam(struct net_device *dev, struct ethtool_fecparam *fec)
 884 {
 885         const struct port_info *pi = netdev_priv(dev);
 886         const struct link_config *lc = &pi->link_cfg;
 887
 888         /* Translate the Firmware FEC Support into the ethtool value.  We
 889          * always support IEEE 802.3 "automatic" selection of Link FEC type if
 890          * any FEC is supported.
 891          */
 892         fec->fec = fwcap_to_eth_fec(lc->pcaps);
 893         if (fec->fec != ETHTOOL_FEC_OFF)
 894                 fec->fec |= ETHTOOL_FEC_AUTO;
 895
 896         /* Translate the current internal FEC parameters into the
 897          * ethtool values.
 898          */
 899         fec->active_fec = cc_to_eth_fec(lc->fec);
 900
 901         return 0;
 902 }
 903
 904 static int set_fecparam(struct net_device *dev, struct ethtool_fecparam *fec)
 905 {
 906         struct port_info *pi = netdev_priv(dev);
 907         struct link_config *lc = &pi->link_cfg;
 908         struct link_config old_lc;
 909         int ret;
 910
 911         /* Save old Link Configuration in case the L1 Configure below
 912          * fails.
 913          */
 914         old_lc = *lc;
 915
 916         /* Try to perform the L1 Configure and return the result of that
 917          * effort.  If it fails, revert the attempted change.
 918          */
 919         lc->requested_fec = eth_to_cc_fec(fec->fec);
 920         ret = t4_link_l1cfg(pi->adapter, pi->adapter->mbox,
 921                             pi->tx_chan, lc);
 922         if (ret)
 923                 *lc = old_lc;
 924         return ret;
 925 }
 926
 927 static void get_pauseparam(struct net_device *dev,
 928                            struct ethtool_pauseparam *epause)
 929 {
 930         struct port_info *p = netdev_priv(dev);
 931
 932         epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
 933         epause->rx_pause = (p->link_cfg.fc & PAUSE_RX) != 0;
 934         epause->tx_pause = (p->link_cfg.fc & PAUSE_TX) != 0;
 935 }
 936
 937 static int set_pauseparam(struct net_device *dev,
 938                           struct ethtool_pauseparam *epause)
 939 {
 940         struct port_info *p = netdev_priv(dev);
 941         struct link_config *lc = &p->link_cfg;
 942
 943         if (epause->autoneg == AUTONEG_DISABLE)
 944                 lc->requested_fc = 0;
 945         else if (lc->pcaps & FW_PORT_CAP32_ANEG)
 946                 lc->requested_fc = PAUSE_AUTONEG;
 947         else
 948                 return -EINVAL;
 949
 950         if (epause->rx_pause)
 951                 lc->requested_fc |= PAUSE_RX;
 952         if (epause->tx_pause)
 953                 lc->requested_fc |= PAUSE_TX;
 954         if (netif_running(dev))
 955                 return t4_link_l1cfg(p->adapter, p->adapter->mbox, p->tx_chan,
 956                                      lc);
 957         return 0;
 958 }
 959
 960 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 961 {
 962         const struct port_info *pi = netdev_priv(dev);
 963         const struct sge *s = &pi->adapter->sge;
 964
 965         e->rx_max_pending = MAX_RX_BUFFERS;
 966         e->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
 967         e->rx_jumbo_max_pending = 0;
 968         e->tx_max_pending = MAX_TXQ_ENTRIES;
 969
 970         e->rx_pending = s->ethrxq[pi->first_qset].fl.size - 8;
 971         e->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
 972         e->rx_jumbo_pending = 0;
 973         e->tx_pending = s->ethtxq[pi->first_qset].q.size;
 974 }
 975
 976 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
 977 {
 978         int i;
 979         const struct port_info *pi = netdev_priv(dev);
 980         struct adapter *adapter = pi->adapter;
 981         struct sge *s = &adapter->sge;
 982
 983         if (e->rx_pending > MAX_RX_BUFFERS || e->rx_jumbo_pending ||
 984             e->tx_pending > MAX_TXQ_ENTRIES ||
 985             e->rx_mini_pending > MAX_RSPQ_ENTRIES ||
 986             e->rx_mini_pending < MIN_RSPQ_ENTRIES ||
 987             e->rx_pending < MIN_FL_ENTRIES || e->tx_pending < MIN_TXQ_ENTRIES)
 988                 return -EINVAL;
 989
 990         if (adapter->flags & FULL_INIT_DONE)
 991                 return -EBUSY;
 992
 993         for (i = 0; i < pi->nqsets; ++i) {
 994                 s->ethtxq[pi->first_qset + i].q.size = e->tx_pending;
 995                 s->ethrxq[pi->first_qset + i].fl.size = e->rx_pending + 8;
 996                 s->ethrxq[pi->first_qset + i].rspq.size = e->rx_mini_pending;
 997         }
 998         return 0;
 999 }
1000
1001 /**
1002  * set_rx_intr_params - set a net devices's RX interrupt holdoff paramete!
1003  * @dev: the network device
1004  * @us: the hold-off time in us, or 0 to disable timer
1005  * @cnt: the hold-off packet count, or 0 to disable counter
1006  *
1007  * Set the RX interrupt hold-off parameters for a network device.
1008  */
1009 static int set_rx_intr_params(struct net_device *dev,
1010                               unsigned int us, unsigned int cnt)
1011 {
1012         int i, err;
1013         struct port_info *pi = netdev_priv(dev);
1014         struct adapter *adap = pi->adapter;
1015         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
1016
1017         for (i = 0; i < pi->nqsets; i++, q++) {
1018                 err = cxgb4_set_rspq_intr_params(&q->rspq, us, cnt);
1019                 if (err)
1020                         return err;
1021         }
1022         return 0;
1023 }
1024
1025 static int set_adaptive_rx_setting(struct net_device *dev, int adaptive_rx)
1026 {
1027         int i;
1028         struct port_info *pi = netdev_priv(dev);
1029         struct adapter *adap = pi->adapter;
1030         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
1031
1032         for (i = 0; i < pi->nqsets; i++, q++)
1033                 q->rspq.adaptive_rx = adaptive_rx;
1034
1035         return 0;
1036 }
1037
1038 static int get_adaptive_rx_setting(struct net_device *dev)
1039 {
1040         struct port_info *pi = netdev_priv(dev);
1041         struct adapter *adap = pi->adapter;
1042         struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
1043
1044         return q->rspq.adaptive_rx;
1045 }
1046
1047 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
1048 {
1049         set_adaptive_rx_setting(dev, c->use_adaptive_rx_coalesce);
1050         return set_rx_intr_params(dev, c->rx_coalesce_usecs,
1051                                   c->rx_max_coalesced_frames);
1052 }
1053
1054 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
1055 {
1056         const struct port_info *pi = netdev_priv(dev);
1057         const struct adapter *adap = pi->adapter;
1058         const struct sge_rspq *rq = &adap->sge.ethrxq[pi->first_qset].rspq;
1059
1060         c->rx_coalesce_usecs = qtimer_val(adap, rq);
1061         c->rx_max_coalesced_frames = (rq->intr_params & QINTR_CNT_EN_F) ?
1062                 adap->sge.counter_val[rq->pktcnt_idx] : 0;
1063         c->use_adaptive_rx_coalesce = get_adaptive_rx_setting(dev);
1064         return 0;
1065 }
1066
1067 /**
1068  *      eeprom_ptov - translate a physical EEPROM address to virtual
1069  *      @phys_addr: the physical EEPROM address
1070  *      @fn: the PCI function number
1071  *      @sz: size of function-specific area
1072  *
1073  *      Translate a physical EEPROM address to virtual.  The first 1K is
1074  *      accessed through virtual addresses starting at 31K, the rest is
1075  *      accessed through virtual addresses starting at 0.
1076  *
1077  *      The mapping is as follows:
1078  *      [0..1K) -> [31K..32K)
1079  *      [1K..1K+A) -> [31K-A..31K)
1080  *      [1K+A..ES) -> [0..ES-A-1K)
1081  *
1082  *      where A = @fn * @sz, and ES = EEPROM size.
1083  */
1084 static int eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
1085 {
1086         fn *= sz;
1087         if (phys_addr < 1024)
1088                 return phys_addr + (31 << 10);
1089         if (phys_addr < 1024 + fn)
1090                 return 31744 - fn + phys_addr - 1024;
1091         if (phys_addr < EEPROMSIZE)
1092                 return phys_addr - 1024 - fn;
1093         return -EINVAL;
1094 }
1095
1096 /* The next two routines implement eeprom read/write from physical addresses.
1097  */
1098 static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v)
1099 {
1100         int vaddr = eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE);
1101
1102         if (vaddr >= 0)
1103                 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v);
1104         return vaddr < 0 ? vaddr : 0;
1105 }
1106
1107 static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v)
1108 {
1109         int vaddr = eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE);
1110
1111         if (vaddr >= 0)
1112                 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v);
1113         return vaddr < 0 ? vaddr : 0;
1114 }
1115
1116 #define EEPROM_MAGIC 0x38E2F10C
1117
1118 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
1119                       u8 *data)
1120 {
1121         int i, err = 0;
1122         struct adapter *adapter = netdev2adap(dev);
1123         u8 *buf = kvzalloc(EEPROMSIZE, GFP_KERNEL);
1124
1125         if (!buf)
1126                 return -ENOMEM;
1127
1128         e->magic = EEPROM_MAGIC;
1129         for (i = e->offset & ~3; !err && i < e->offset + e->len; i += 4)
1130                 err = eeprom_rd_phys(adapter, i, (u32 *)&buf[i]);
1131
1132         if (!err)
1133                 memcpy(data, buf + e->offset, e->len);
1134         kvfree(buf);
1135         return err;
1136 }
1137
1138 static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
1139                       u8 *data)
1140 {
1141         u8 *buf;
1142         int err = 0;
1143         u32 aligned_offset, aligned_len, *p;
1144         struct adapter *adapter = netdev2adap(dev);
1145
1146         if (eeprom->magic != EEPROM_MAGIC)
1147                 return -EINVAL;
1148
1149         aligned_offset = eeprom->offset & ~3;
1150         aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3;
1151
1152         if (adapter->pf > 0) {
1153                 u32 start = 1024 + adapter->pf * EEPROMPFSIZE;
1154
1155                 if (aligned_offset < start ||
1156                     aligned_offset + aligned_len > start + EEPROMPFSIZE)
1157                         return -EPERM;
1158         }
1159
1160         if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) {
1161                 /* RMW possibly needed for first or last words.
1162                  */
1163                 buf = kvzalloc(aligned_len, GFP_KERNEL);
1164                 if (!buf)
1165                         return -ENOMEM;
1166                 err = eeprom_rd_phys(adapter, aligned_offset, (u32 *)buf);
1167                 if (!err && aligned_len > 4)
1168                         err = eeprom_rd_phys(adapter,
1169                                              aligned_offset + aligned_len - 4,
1170                                              (u32 *)&buf[aligned_len - 4]);
1171                 if (err)
1172                         goto out;
1173                 memcpy(buf + (eeprom->offset & 3), data, eeprom->len);
1174         } else {
1175                 buf = data;
1176         }
1177
1178         err = t4_seeprom_wp(adapter, false);
1179         if (err)
1180                 goto out;
1181
1182         for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) {
1183                 err = eeprom_wr_phys(adapter, aligned_offset, *p);
1184                 aligned_offset += 4;
1185         }
1186
1187         if (!err)
1188                 err = t4_seeprom_wp(adapter, true);
1189 out:
1190         if (buf != data)
1191                 kvfree(buf);
1192         return err;
1193 }
1194
1195 static int set_flash(struct net_device *netdev, struct ethtool_flash *ef)
1196 {
1197         int ret;
1198         const struct firmware *fw;
1199         struct adapter *adap = netdev2adap(netdev);
1200         unsigned int mbox = PCIE_FW_MASTER_M + 1;
1201         u32 pcie_fw;
1202         unsigned int master;
1203         u8 master_vld = 0;
1204
1205         pcie_fw = t4_read_reg(adap, PCIE_FW_A);
1206         master = PCIE_FW_MASTER_G(pcie_fw);
1207         if (pcie_fw & PCIE_FW_MASTER_VLD_F)
1208                 master_vld = 1;
1209         /* if csiostor is the master return */
1210         if (master_vld && (master != adap->pf)) {
1211                 dev_warn(adap->pdev_dev,
1212                          "cxgb4 driver needs to be loaded as MASTER to support FW flash\n");
1213                 return -EOPNOTSUPP;
1214         }
1215
1216         ef->data[sizeof(ef->data) - 1] = '\0';
1217         ret = request_firmware(&fw, ef->data, adap->pdev_dev);
1218         if (ret < 0)
1219                 return ret;
1220
1221         /* If the adapter has been fully initialized then we'll go ahead and
1222          * try to get the firmware's cooperation in upgrading to the new
1223          * firmware image otherwise we'll try to do the entire job from the
1224          * host ... and we always "force" the operation in this path.
1225          */
1226         if (adap->flags & FULL_INIT_DONE)
1227                 mbox = adap->mbox;
1228
1229         ret = t4_fw_upgrade(adap, mbox, fw->data, fw->size, 1);
1230         release_firmware(fw);
1231         if (!ret)
1232                 dev_info(adap->pdev_dev,
1233                          "loaded firmware %s, reload cxgb4 driver\n", ef->data);
1234         return ret;
1235 }
1236
1237 static int get_ts_info(struct net_device *dev, struct ethtool_ts_info *ts_info)
1238 {
1239         struct port_info *pi = netdev_priv(dev);
1240         struct  adapter *adapter = pi->adapter;
1241
1242         ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
1243                                    SOF_TIMESTAMPING_RX_SOFTWARE |
1244                                    SOF_TIMESTAMPING_SOFTWARE;
1245
1246         ts_info->so_timestamping |= SOF_TIMESTAMPING_RX_HARDWARE |
1247                                     SOF_TIMESTAMPING_TX_HARDWARE |
1248                                     SOF_TIMESTAMPING_RAW_HARDWARE;
1249
1250         ts_info->tx_types = (1 << HWTSTAMP_TX_OFF) |
1251                             (1 << HWTSTAMP_TX_ON);
1252
1253         ts_info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
1254                               (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
1255                               (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
1256                               (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
1257                               (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
1258                               (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ);
1259
1260         if (adapter->ptp_clock)
1261                 ts_info->phc_index = ptp_clock_index(adapter->ptp_clock);
1262         else
1263                 ts_info->phc_index = -1;
1264
1265         return 0;
1266 }
1267
1268 static u32 get_rss_table_size(struct net_device *dev)
1269 {
1270         const struct port_info *pi = netdev_priv(dev);
1271
1272         return pi->rss_size;
1273 }
1274
1275 static int get_rss_table(struct net_device *dev, u32 *p, u8 *key, u8 *hfunc)
1276 {
1277         const struct port_info *pi = netdev_priv(dev);
1278         unsigned int n = pi->rss_size;
1279
1280         if (hfunc)
1281                 *hfunc = ETH_RSS_HASH_TOP;
1282         if (!p)
1283                 return 0;
1284         while (n--)
1285                 p[n] = pi->rss[n];
1286         return 0;
1287 }
1288
1289 static int set_rss_table(struct net_device *dev, const u32 *p, const u8 *key,
1290                          const u8 hfunc)
1291 {
1292         unsigned int i;
1293         struct port_info *pi = netdev_priv(dev);
1294
1295         /* We require at least one supported parameter to be changed and no
1296          * change in any of the unsupported parameters
1297          */
1298         if (key ||
1299             (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1300                 return -EOPNOTSUPP;
1301         if (!p)
1302                 return 0;
1303
1304         /* Interface must be brought up atleast once */
1305         if (pi->adapter->flags & FULL_INIT_DONE) {
1306                 for (i = 0; i < pi->rss_size; i++)
1307                         pi->rss[i] = p[i];
1308
1309                 return cxgb4_write_rss(pi, pi->rss);
1310         }
1311
1312         return -EPERM;
1313 }
1314
1315 static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
1316                      u32 *rules)
1317 {
1318         const struct port_info *pi = netdev_priv(dev);
1319
1320         switch (info->cmd) {
1321         case ETHTOOL_GRXFH: {
1322                 unsigned int v = pi->rss_mode;
1323
1324                 info->data = 0;
1325                 switch (info->flow_type) {
1326                 case TCP_V4_FLOW:
1327                         if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F)
1328                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1329                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1330                         else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1331                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1332                         break;
1333                 case UDP_V4_FLOW:
1334                         if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) &&
1335                             (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
1336                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1337                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1338                         else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1339                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1340                         break;
1341                 case SCTP_V4_FLOW:
1342                 case AH_ESP_V4_FLOW:
1343                 case IPV4_FLOW:
1344                         if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
1345                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1346                         break;
1347                 case TCP_V6_FLOW:
1348                         if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F)
1349                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1350                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1351                         else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1352                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1353                         break;
1354                 case UDP_V6_FLOW:
1355                         if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) &&
1356                             (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
1357                                 info->data = RXH_IP_SRC | RXH_IP_DST |
1358                                              RXH_L4_B_0_1 | RXH_L4_B_2_3;
1359                         else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1360                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1361                         break;
1362                 case SCTP_V6_FLOW:
1363                 case AH_ESP_V6_FLOW:
1364                 case IPV6_FLOW:
1365                         if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
1366                                 info->data = RXH_IP_SRC | RXH_IP_DST;
1367                         break;
1368                 }
1369                 return 0;
1370         }
1371         case ETHTOOL_GRXRINGS:
1372                 info->data = pi->nqsets;
1373                 return 0;
1374         }
1375         return -EOPNOTSUPP;
1376 }
1377
1378 static int set_dump(struct net_device *dev, struct ethtool_dump *eth_dump)
1379 {
1380         struct adapter *adapter = netdev2adap(dev);
1381         u32 len = 0;
1382
1383         len = sizeof(struct cudbg_hdr) +
1384               sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY;
1385         len += cxgb4_get_dump_length(adapter, eth_dump->flag);
1386
1387         adapter->eth_dump.flag = eth_dump->flag;
1388         adapter->eth_dump.len = len;
1389         return 0;
1390 }
1391
1392 static int get_dump_flag(struct net_device *dev, struct ethtool_dump *eth_dump)
1393 {
1394         struct adapter *adapter = netdev2adap(dev);
1395
1396         eth_dump->flag = adapter->eth_dump.flag;
1397         eth_dump->len = adapter->eth_dump.len;
1398         eth_dump->version = adapter->eth_dump.version;
1399         return 0;
1400 }
1401
1402 static int get_dump_data(struct net_device *dev, struct ethtool_dump *eth_dump,
1403                          void *buf)
1404 {
1405         struct adapter *adapter = netdev2adap(dev);
1406         u32 len = 0;
1407         int ret = 0;
1408
1409         if (adapter->eth_dump.flag == CXGB4_ETH_DUMP_NONE)
1410                 return -ENOENT;
1411
1412         len = sizeof(struct cudbg_hdr) +
1413               sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY;
1414         len += cxgb4_get_dump_length(adapter, adapter->eth_dump.flag);
1415         if (eth_dump->len < len)
1416                 return -ENOMEM;
1417
1418         ret = cxgb4_cudbg_collect(adapter, buf, &len, adapter->eth_dump.flag);
1419         if (ret)
1420                 return ret;
1421
1422         eth_dump->flag = adapter->eth_dump.flag;
1423         eth_dump->len = len;
1424         eth_dump->version = adapter->eth_dump.version;
1425         return 0;
1426 }
1427
1428 static const struct ethtool_ops cxgb_ethtool_ops = {
1429         .get_link_ksettings = get_link_ksettings,
1430         .set_link_ksettings = set_link_ksettings,
1431         .get_fecparam      = get_fecparam,
1432         .set_fecparam      = set_fecparam,
1433         .get_drvinfo       = get_drvinfo,
1434         .get_msglevel      = get_msglevel,
1435         .set_msglevel      = set_msglevel,
1436         .get_ringparam     = get_sge_param,
1437         .set_ringparam     = set_sge_param,
1438         .get_coalesce      = get_coalesce,
1439         .set_coalesce      = set_coalesce,
1440         .get_eeprom_len    = get_eeprom_len,
1441         .get_eeprom        = get_eeprom,
1442         .set_eeprom        = set_eeprom,
1443         .get_pauseparam    = get_pauseparam,
1444         .set_pauseparam    = set_pauseparam,
1445         .get_link          = ethtool_op_get_link,
1446         .get_strings       = get_strings,
1447         .set_phys_id       = identify_port,
1448         .nway_reset        = restart_autoneg,
1449         .get_sset_count    = get_sset_count,
1450         .get_ethtool_stats = get_stats,
1451         .get_regs_len      = get_regs_len,
1452         .get_regs          = get_regs,
1453         .get_rxnfc         = get_rxnfc,
1454         .get_rxfh_indir_size = get_rss_table_size,
1455         .get_rxfh          = get_rss_table,
1456         .set_rxfh          = set_rss_table,
1457         .flash_device      = set_flash,
1458         .get_ts_info       = get_ts_info,
1459         .set_dump          = set_dump,
1460         .get_dump_flag     = get_dump_flag,
1461         .get_dump_data     = get_dump_data,
1462 };
1463
1464 void cxgb4_set_ethtool_ops(struct net_device *netdev)
1465 {
1466         netdev->ethtool_ops = &cxgb_ethtool_ops;
1467 }