drivers/net/ethernet/cavium/thunder/nicvf_ethtool.c

   1 /*
   2  * Copyright (C) 2015 Cavium, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License
   6  * as published by the Free Software Foundation.
   7  */
   8
   9 /* ETHTOOL Support for VNIC_VF Device*/
  10
  11 #include <linux/pci.h>
  12
  13 #include "nic_reg.h"
  14 #include "nic.h"
  15 #include "nicvf_queues.h"
  16 #include "q_struct.h"
  17 #include "thunder_bgx.h"
  18
  19 #define DRV_NAME        "thunder-nicvf"
  20 #define DRV_VERSION     "1.0"
  21
  22 struct nicvf_stat {
  23         char name[ETH_GSTRING_LEN];
  24         unsigned int index;
  25 };
  26
  27 #define NICVF_HW_STAT(stat) { \
  28         .name = #stat, \
  29         .index = offsetof(struct nicvf_hw_stats, stat) / sizeof(u64), \
  30 }
  31
  32 #define NICVF_DRV_STAT(stat) { \
  33         .name = #stat, \
  34         .index = offsetof(struct nicvf_drv_stats, stat) / sizeof(u64), \
  35 }
  36
  37 static const struct nicvf_stat nicvf_hw_stats[] = {
  38         NICVF_HW_STAT(rx_bytes),
  39         NICVF_HW_STAT(rx_frames),
  40         NICVF_HW_STAT(rx_ucast_frames),
  41         NICVF_HW_STAT(rx_bcast_frames),
  42         NICVF_HW_STAT(rx_mcast_frames),
  43         NICVF_HW_STAT(rx_drops),
  44         NICVF_HW_STAT(rx_drop_red),
  45         NICVF_HW_STAT(rx_drop_red_bytes),
  46         NICVF_HW_STAT(rx_drop_overrun),
  47         NICVF_HW_STAT(rx_drop_overrun_bytes),
  48         NICVF_HW_STAT(rx_drop_bcast),
  49         NICVF_HW_STAT(rx_drop_mcast),
  50         NICVF_HW_STAT(rx_drop_l3_bcast),
  51         NICVF_HW_STAT(rx_drop_l3_mcast),
  52         NICVF_HW_STAT(rx_fcs_errors),
  53         NICVF_HW_STAT(rx_l2_errors),
  54         NICVF_HW_STAT(tx_bytes),
  55         NICVF_HW_STAT(tx_frames),
  56         NICVF_HW_STAT(tx_ucast_frames),
  57         NICVF_HW_STAT(tx_bcast_frames),
  58         NICVF_HW_STAT(tx_mcast_frames),
  59         NICVF_HW_STAT(tx_drops),
  60 };
  61
  62 static const struct nicvf_stat nicvf_drv_stats[] = {
  63         NICVF_DRV_STAT(rx_bgx_truncated_pkts),
  64         NICVF_DRV_STAT(rx_jabber_errs),
  65         NICVF_DRV_STAT(rx_fcs_errs),
  66         NICVF_DRV_STAT(rx_bgx_errs),
  67         NICVF_DRV_STAT(rx_prel2_errs),
  68         NICVF_DRV_STAT(rx_l2_hdr_malformed),
  69         NICVF_DRV_STAT(rx_oversize),
  70         NICVF_DRV_STAT(rx_undersize),
  71         NICVF_DRV_STAT(rx_l2_len_mismatch),
  72         NICVF_DRV_STAT(rx_l2_pclp),
  73         NICVF_DRV_STAT(rx_ip_ver_errs),
  74         NICVF_DRV_STAT(rx_ip_csum_errs),
  75         NICVF_DRV_STAT(rx_ip_hdr_malformed),
  76         NICVF_DRV_STAT(rx_ip_payload_malformed),
  77         NICVF_DRV_STAT(rx_ip_ttl_errs),
  78         NICVF_DRV_STAT(rx_l3_pclp),
  79         NICVF_DRV_STAT(rx_l4_malformed),
  80         NICVF_DRV_STAT(rx_l4_csum_errs),
  81         NICVF_DRV_STAT(rx_udp_len_errs),
  82         NICVF_DRV_STAT(rx_l4_port_errs),
  83         NICVF_DRV_STAT(rx_tcp_flag_errs),
  84         NICVF_DRV_STAT(rx_tcp_offset_errs),
  85         NICVF_DRV_STAT(rx_l4_pclp),
  86         NICVF_DRV_STAT(rx_truncated_pkts),
  87
  88         NICVF_DRV_STAT(tx_desc_fault),
  89         NICVF_DRV_STAT(tx_hdr_cons_err),
  90         NICVF_DRV_STAT(tx_subdesc_err),
  91         NICVF_DRV_STAT(tx_max_size_exceeded),
  92         NICVF_DRV_STAT(tx_imm_size_oflow),
  93         NICVF_DRV_STAT(tx_data_seq_err),
  94         NICVF_DRV_STAT(tx_mem_seq_err),
  95         NICVF_DRV_STAT(tx_lock_viol),
  96         NICVF_DRV_STAT(tx_data_fault),
  97         NICVF_DRV_STAT(tx_tstmp_conflict),
  98         NICVF_DRV_STAT(tx_tstmp_timeout),
  99         NICVF_DRV_STAT(tx_mem_fault),
 100         NICVF_DRV_STAT(tx_csum_overlap),
 101         NICVF_DRV_STAT(tx_csum_overflow),
 102
 103         NICVF_DRV_STAT(tx_tso),
 104         NICVF_DRV_STAT(tx_timeout),
 105         NICVF_DRV_STAT(txq_stop),
 106         NICVF_DRV_STAT(txq_wake),
 107         NICVF_DRV_STAT(rcv_buffer_alloc_failures),
 108         NICVF_DRV_STAT(page_alloc),
 109 };
 110
 111 static const struct nicvf_stat nicvf_queue_stats[] = {
 112         { "bytes", 0 },
 113         { "frames", 1 },
 114 };
 115
 116 static const unsigned int nicvf_n_hw_stats = ARRAY_SIZE(nicvf_hw_stats);
 117 static const unsigned int nicvf_n_drv_stats = ARRAY_SIZE(nicvf_drv_stats);
 118 static const unsigned int nicvf_n_queue_stats = ARRAY_SIZE(nicvf_queue_stats);
 119
 120 static int nicvf_get_link_ksettings(struct net_device *netdev,
 121                                     struct ethtool_link_ksettings *cmd)
 122 {
 123         struct nicvf *nic = netdev_priv(netdev);
 124         u32 supported, advertising;
 125
 126         supported = 0;
 127         advertising = 0;
 128
 129         if (!nic->link_up) {
 130                 cmd->base.duplex = DUPLEX_UNKNOWN;
 131                 cmd->base.speed = SPEED_UNKNOWN;
 132                 return 0;
 133         }
 134
 135         switch (nic->speed) {
 136         case SPEED_1000:
 137                 cmd->base.port = PORT_MII | PORT_TP;
 138                 cmd->base.autoneg = AUTONEG_ENABLE;
 139                 supported |= SUPPORTED_MII | SUPPORTED_TP;
 140                 supported |= SUPPORTED_1000baseT_Full |
 141                                   SUPPORTED_1000baseT_Half |
 142                                   SUPPORTED_100baseT_Full  |
 143                                   SUPPORTED_100baseT_Half  |
 144                                   SUPPORTED_10baseT_Full   |
 145                                   SUPPORTED_10baseT_Half;
 146                 supported |= SUPPORTED_Autoneg;
 147                 advertising |= ADVERTISED_1000baseT_Full |
 148                                     ADVERTISED_1000baseT_Half |
 149                                     ADVERTISED_100baseT_Full  |
 150                                     ADVERTISED_100baseT_Half  |
 151                                     ADVERTISED_10baseT_Full   |
 152                                     ADVERTISED_10baseT_Half;
 153                 break;
 154         case SPEED_10000:
 155                 if (nic->mac_type == BGX_MODE_RXAUI) {
 156                         cmd->base.port = PORT_TP;
 157                         supported |= SUPPORTED_TP;
 158                 } else {
 159                         cmd->base.port = PORT_FIBRE;
 160                         supported |= SUPPORTED_FIBRE;
 161                 }
 162                 cmd->base.autoneg = AUTONEG_DISABLE;
 163                 supported |= SUPPORTED_10000baseT_Full;
 164                 break;
 165         case SPEED_40000:
 166                 cmd->base.port = PORT_FIBRE;
 167                 cmd->base.autoneg = AUTONEG_DISABLE;
 168                 supported |= SUPPORTED_FIBRE;
 169                 supported |= SUPPORTED_40000baseCR4_Full;
 170                 break;
 171         }
 172         cmd->base.duplex = nic->duplex;
 173         cmd->base.speed = nic->speed;
 174
 175         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 176                                                 supported);
 177         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 178                                                 advertising);
 179
 180         return 0;
 181 }
 182
 183 static u32 nicvf_get_link(struct net_device *netdev)
 184 {
 185         struct nicvf *nic = netdev_priv(netdev);
 186
 187         return nic->link_up;
 188 }
 189
 190 static void nicvf_get_drvinfo(struct net_device *netdev,
 191                               struct ethtool_drvinfo *info)
 192 {
 193         struct nicvf *nic = netdev_priv(netdev);
 194
 195         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 196         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 197         strlcpy(info->bus_info, pci_name(nic->pdev), sizeof(info->bus_info));
 198 }
 199
 200 static u32 nicvf_get_msglevel(struct net_device *netdev)
 201 {
 202         struct nicvf *nic = netdev_priv(netdev);
 203
 204         return nic->msg_enable;
 205 }
 206
 207 static void nicvf_set_msglevel(struct net_device *netdev, u32 lvl)
 208 {
 209         struct nicvf *nic = netdev_priv(netdev);
 210
 211         nic->msg_enable = lvl;
 212 }
 213
 214 static void nicvf_get_qset_strings(struct nicvf *nic, u8 **data, int qset)
 215 {
 216         int stats, qidx;
 217         int start_qidx = qset * MAX_RCV_QUEUES_PER_QS;
 218
 219         for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) {
 220                 for (stats = 0; stats < nicvf_n_queue_stats; stats++) {
 221                         sprintf(*data, "rxq%d: %s", qidx + start_qidx,
 222                                 nicvf_queue_stats[stats].name);
 223                         *data += ETH_GSTRING_LEN;
 224                 }
 225         }
 226
 227         for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) {
 228                 for (stats = 0; stats < nicvf_n_queue_stats; stats++) {
 229                         sprintf(*data, "txq%d: %s", qidx + start_qidx,
 230                                 nicvf_queue_stats[stats].name);
 231                         *data += ETH_GSTRING_LEN;
 232                 }
 233         }
 234 }
 235
 236 static void nicvf_get_strings(struct net_device *netdev, u32 sset, u8 *data)
 237 {
 238         struct nicvf *nic = netdev_priv(netdev);
 239         int stats;
 240         int sqs;
 241
 242         if (sset != ETH_SS_STATS)
 243                 return;
 244
 245         for (stats = 0; stats < nicvf_n_hw_stats; stats++) {
 246                 memcpy(data, nicvf_hw_stats[stats].name, ETH_GSTRING_LEN);
 247                 data += ETH_GSTRING_LEN;
 248         }
 249
 250         for (stats = 0; stats < nicvf_n_drv_stats; stats++) {
 251                 memcpy(data, nicvf_drv_stats[stats].name, ETH_GSTRING_LEN);
 252                 data += ETH_GSTRING_LEN;
 253         }
 254
 255         nicvf_get_qset_strings(nic, &data, 0);
 256
 257         for (sqs = 0; sqs < nic->sqs_count; sqs++) {
 258                 if (!nic->snicvf[sqs])
 259                         continue;
 260                 nicvf_get_qset_strings(nic->snicvf[sqs], &data, sqs + 1);
 261         }
 262
 263         for (stats = 0; stats < BGX_RX_STATS_COUNT; stats++) {
 264                 sprintf(data, "bgx_rxstat%d: ", stats);
 265                 data += ETH_GSTRING_LEN;
 266         }
 267
 268         for (stats = 0; stats < BGX_TX_STATS_COUNT; stats++) {
 269                 sprintf(data, "bgx_txstat%d: ", stats);
 270                 data += ETH_GSTRING_LEN;
 271         }
 272 }
 273
 274 static int nicvf_get_sset_count(struct net_device *netdev, int sset)
 275 {
 276         struct nicvf *nic = netdev_priv(netdev);
 277         int qstats_count;
 278         int sqs;
 279
 280         if (sset != ETH_SS_STATS)
 281                 return -EINVAL;
 282
 283         qstats_count = nicvf_n_queue_stats *
 284                        (nic->qs->rq_cnt + nic->qs->sq_cnt);
 285         for (sqs = 0; sqs < nic->sqs_count; sqs++) {
 286                 struct nicvf *snic;
 287
 288                 snic = nic->snicvf[sqs];
 289                 if (!snic)
 290                         continue;
 291                 qstats_count += nicvf_n_queue_stats *
 292                                 (snic->qs->rq_cnt + snic->qs->sq_cnt);
 293         }
 294
 295         return nicvf_n_hw_stats + nicvf_n_drv_stats +
 296                 qstats_count +
 297                 BGX_RX_STATS_COUNT + BGX_TX_STATS_COUNT;
 298 }
 299
 300 static void nicvf_get_qset_stats(struct nicvf *nic,
 301                                  struct ethtool_stats *stats, u64 **data)
 302 {
 303         int stat, qidx;
 304
 305         if (!nic)
 306                 return;
 307
 308         for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) {
 309                 nicvf_update_rq_stats(nic, qidx);
 310                 for (stat = 0; stat < nicvf_n_queue_stats; stat++)
 311                         *((*data)++) = ((u64 *)&nic->qs->rq[qidx].stats)
 312                                         [nicvf_queue_stats[stat].index];
 313         }
 314
 315         for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) {
 316                 nicvf_update_sq_stats(nic, qidx);
 317                 for (stat = 0; stat < nicvf_n_queue_stats; stat++)
 318                         *((*data)++) = ((u64 *)&nic->qs->sq[qidx].stats)
 319                                         [nicvf_queue_stats[stat].index];
 320         }
 321 }
 322
 323 static void nicvf_get_ethtool_stats(struct net_device *netdev,
 324                                     struct ethtool_stats *stats, u64 *data)
 325 {
 326         struct nicvf *nic = netdev_priv(netdev);
 327         int stat, tmp_stats;
 328         int sqs, cpu;
 329
 330         nicvf_update_stats(nic);
 331
 332         /* Update LMAC stats */
 333         nicvf_update_lmac_stats(nic);
 334
 335         for (stat = 0; stat < nicvf_n_hw_stats; stat++)
 336                 *(data++) = ((u64 *)&nic->hw_stats)
 337                                 [nicvf_hw_stats[stat].index];
 338         for (stat = 0; stat < nicvf_n_drv_stats; stat++) {
 339                 tmp_stats = 0;
 340                 for_each_possible_cpu(cpu)
 341                         tmp_stats += ((u64 *)per_cpu_ptr(nic->drv_stats, cpu))
 342                                      [nicvf_drv_stats[stat].index];
 343                 *(data++) = tmp_stats;
 344         }
 345
 346         nicvf_get_qset_stats(nic, stats, &data);
 347
 348         for (sqs = 0; sqs < nic->sqs_count; sqs++) {
 349                 if (!nic->snicvf[sqs])
 350                         continue;
 351                 nicvf_get_qset_stats(nic->snicvf[sqs], stats, &data);
 352         }
 353
 354         for (stat = 0; stat < BGX_RX_STATS_COUNT; stat++)
 355                 *(data++) = nic->bgx_stats.rx_stats[stat];
 356         for (stat = 0; stat < BGX_TX_STATS_COUNT; stat++)
 357                 *(data++) = nic->bgx_stats.tx_stats[stat];
 358 }
 359
 360 static int nicvf_get_regs_len(struct net_device *dev)
 361 {
 362         return sizeof(u64) * NIC_VF_REG_COUNT;
 363 }
 364
 365 static void nicvf_get_regs(struct net_device *dev,
 366                            struct ethtool_regs *regs, void *reg)
 367 {
 368         struct nicvf *nic = netdev_priv(dev);
 369         u64 *p = (u64 *)reg;
 370         u64 reg_offset;
 371         int mbox, key, stat, q;
 372         int i = 0;
 373
 374         regs->version = 0;
 375         memset(p, 0, NIC_VF_REG_COUNT);
 376
 377         p[i++] = nicvf_reg_read(nic, NIC_VNIC_CFG);
 378         /* Mailbox registers */
 379         for (mbox = 0; mbox < NIC_PF_VF_MAILBOX_SIZE; mbox++)
 380                 p[i++] = nicvf_reg_read(nic,
 381                                         NIC_VF_PF_MAILBOX_0_1 | (mbox << 3));
 382
 383         p[i++] = nicvf_reg_read(nic, NIC_VF_INT);
 384         p[i++] = nicvf_reg_read(nic, NIC_VF_INT_W1S);
 385         p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1C);
 386         p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1S);
 387         p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG);
 388
 389         for (key = 0; key < RSS_HASH_KEY_SIZE; key++)
 390                 p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_KEY_0_4 | (key << 3));
 391
 392         /* Tx/Rx statistics */
 393         for (stat = 0; stat < TX_STATS_ENUM_LAST; stat++)
 394                 p[i++] = nicvf_reg_read(nic,
 395                                         NIC_VNIC_TX_STAT_0_4 | (stat << 3));
 396
 397         for (i = 0; i < RX_STATS_ENUM_LAST; i++)
 398                 p[i++] = nicvf_reg_read(nic,
 399                                         NIC_VNIC_RX_STAT_0_13 | (stat << 3));
 400
 401         p[i++] = nicvf_reg_read(nic, NIC_QSET_RQ_GEN_CFG);
 402
 403         /* All completion queue's registers */
 404         for (q = 0; q < MAX_CMP_QUEUES_PER_QS; q++) {
 405                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG, q);
 406                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG2, q);
 407                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_THRESH, q);
 408                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_BASE, q);
 409                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_HEAD, q);
 410                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_TAIL, q);
 411                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DOOR, q);
 412                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS, q);
 413                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS2, q);
 414                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DEBUG, q);
 415         }
 416
 417         /* All receive queue's registers */
 418         for (q = 0; q < MAX_RCV_QUEUES_PER_QS; q++) {
 419                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RQ_0_7_CFG, q);
 420                 p[i++] = nicvf_queue_reg_read(nic,
 421                                                   NIC_QSET_RQ_0_7_STAT_0_1, q);
 422                 reg_offset = NIC_QSET_RQ_0_7_STAT_0_1 | (1 << 3);
 423                 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q);
 424         }
 425
 426         for (q = 0; q < MAX_SND_QUEUES_PER_QS; q++) {
 427                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_CFG, q);
 428                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_THRESH, q);
 429                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_BASE, q);
 430                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_HEAD, q);
 431                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_TAIL, q);
 432                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DOOR, q);
 433                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STATUS, q);
 434                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DEBUG, q);
 435                 /* Padding, was NIC_QSET_SQ_0_7_CNM_CHG, which
 436                  * produces bus errors when read
 437                  */
 438                 p[i++] = 0;
 439                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STAT_0_1, q);
 440                 reg_offset = NIC_QSET_SQ_0_7_STAT_0_1 | (1 << 3);
 441                 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q);
 442         }
 443
 444         for (q = 0; q < MAX_RCV_BUF_DESC_RINGS_PER_QS; q++) {
 445                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_CFG, q);
 446                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_THRESH, q);
 447                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_BASE, q);
 448                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_HEAD, q);
 449                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_TAIL, q);
 450                 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_DOOR, q);
 451                 p[i++] = nicvf_queue_reg_read(nic,
 452                                               NIC_QSET_RBDR_0_1_STATUS0, q);
 453                 p[i++] = nicvf_queue_reg_read(nic,
 454                                               NIC_QSET_RBDR_0_1_STATUS1, q);
 455                 reg_offset = NIC_QSET_RBDR_0_1_PREFETCH_STATUS;
 456                 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q);
 457         }
 458 }
 459
 460 static int nicvf_get_coalesce(struct net_device *netdev,
 461                               struct ethtool_coalesce *cmd)
 462 {
 463         struct nicvf *nic = netdev_priv(netdev);
 464
 465         cmd->rx_coalesce_usecs = nic->cq_coalesce_usecs;
 466         return 0;
 467 }
 468
 469 static void nicvf_get_ringparam(struct net_device *netdev,
 470                                 struct ethtool_ringparam *ring)
 471 {
 472         struct nicvf *nic = netdev_priv(netdev);
 473         struct queue_set *qs = nic->qs;
 474
 475         ring->rx_max_pending = MAX_CMP_QUEUE_LEN;
 476         ring->rx_pending = qs->cq_len;
 477         ring->tx_max_pending = MAX_SND_QUEUE_LEN;
 478         ring->tx_pending = qs->sq_len;
 479 }
 480
 481 static int nicvf_set_ringparam(struct net_device *netdev,
 482                                struct ethtool_ringparam *ring)
 483 {
 484         struct nicvf *nic = netdev_priv(netdev);
 485         struct queue_set *qs = nic->qs;
 486         u32 rx_count, tx_count;
 487
 488         /* Due to HW errata this is not supported on T88 pass 1.x silicon */
 489         if (pass1_silicon(nic->pdev))
 490                 return -EINVAL;
 491
 492         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 493                 return -EINVAL;
 494
 495         tx_count = clamp_t(u32, ring->tx_pending,
 496                            MIN_SND_QUEUE_LEN, MAX_SND_QUEUE_LEN);
 497         rx_count = clamp_t(u32, ring->rx_pending,
 498                            MIN_CMP_QUEUE_LEN, MAX_CMP_QUEUE_LEN);
 499
 500         if ((tx_count == qs->sq_len) && (rx_count == qs->cq_len))
 501                 return 0;
 502
 503         /* Permitted lengths are 1K, 2K, 4K, 8K, 16K, 32K, 64K */
 504         qs->sq_len = rounddown_pow_of_two(tx_count);
 505         qs->cq_len = rounddown_pow_of_two(rx_count);
 506
 507         if (netif_running(netdev)) {
 508                 nicvf_stop(netdev);
 509                 nicvf_open(netdev);
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int nicvf_get_rss_hash_opts(struct nicvf *nic,
 516                                    struct ethtool_rxnfc *info)
 517 {
 518         info->data = 0;
 519
 520         switch (info->flow_type) {
 521         case TCP_V4_FLOW:
 522         case TCP_V6_FLOW:
 523         case UDP_V4_FLOW:
 524         case UDP_V6_FLOW:
 525         case SCTP_V4_FLOW:
 526         case SCTP_V6_FLOW:
 527                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 528         case IPV4_FLOW:
 529         case IPV6_FLOW:
 530                 info->data |= RXH_IP_SRC | RXH_IP_DST;
 531                 break;
 532         default:
 533                 return -EINVAL;
 534         }
 535
 536         return 0;
 537 }
 538
 539 static int nicvf_get_rxnfc(struct net_device *dev,
 540                            struct ethtool_rxnfc *info, u32 *rules)
 541 {
 542         struct nicvf *nic = netdev_priv(dev);
 543         int ret = -EOPNOTSUPP;
 544
 545         switch (info->cmd) {
 546         case ETHTOOL_GRXRINGS:
 547                 info->data = nic->rx_queues;
 548                 ret = 0;
 549                 break;
 550         case ETHTOOL_GRXFH:
 551                 return nicvf_get_rss_hash_opts(nic, info);
 552         default:
 553                 break;
 554         }
 555         return ret;
 556 }
 557
 558 static int nicvf_set_rss_hash_opts(struct nicvf *nic,
 559                                    struct ethtool_rxnfc *info)
 560 {
 561         struct nicvf_rss_info *rss = &nic->rss_info;
 562         u64 rss_cfg = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG);
 563
 564         if (!rss->enable)
 565                 netdev_err(nic->netdev,
 566                            "RSS is disabled, hash cannot be set\n");
 567
 568         netdev_info(nic->netdev, "Set RSS flow type = %d, data = %lld\n",
 569                     info->flow_type, info->data);
 570
 571         if (!(info->data & RXH_IP_SRC) || !(info->data & RXH_IP_DST))
 572                 return -EINVAL;
 573
 574         switch (info->flow_type) {
 575         case TCP_V4_FLOW:
 576         case TCP_V6_FLOW:
 577                 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 578                 case 0:
 579                         rss_cfg &= ~(1ULL << RSS_HASH_TCP);
 580                         break;
 581                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 582                         rss_cfg |= (1ULL << RSS_HASH_TCP);
 583                         break;
 584                 default:
 585                         return -EINVAL;
 586                 }
 587                 break;
 588         case UDP_V4_FLOW:
 589         case UDP_V6_FLOW:
 590                 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 591                 case 0:
 592                         rss_cfg &= ~(1ULL << RSS_HASH_UDP);
 593                         break;
 594                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 595                         rss_cfg |= (1ULL << RSS_HASH_UDP);
 596                         break;
 597                 default:
 598                         return -EINVAL;
 599                 }
 600                 break;
 601         case SCTP_V4_FLOW:
 602         case SCTP_V6_FLOW:
 603                 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 604                 case 0:
 605                         rss_cfg &= ~(1ULL << RSS_HASH_L4ETC);
 606                         break;
 607                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 608                         rss_cfg |= (1ULL << RSS_HASH_L4ETC);
 609                         break;
 610                 default:
 611                         return -EINVAL;
 612                 }
 613                 break;
 614         case IPV4_FLOW:
 615         case IPV6_FLOW:
 616                 rss_cfg = RSS_HASH_IP;
 617                 break;
 618         default:
 619                 return -EINVAL;
 620         }
 621
 622         nicvf_reg_write(nic, NIC_VNIC_RSS_CFG, rss_cfg);
 623         return 0;
 624 }
 625
 626 static int nicvf_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info)
 627 {
 628         struct nicvf *nic = netdev_priv(dev);
 629
 630         switch (info->cmd) {
 631         case ETHTOOL_SRXFH:
 632                 return nicvf_set_rss_hash_opts(nic, info);
 633         default:
 634                 break;
 635         }
 636         return -EOPNOTSUPP;
 637 }
 638
 639 static u32 nicvf_get_rxfh_key_size(struct net_device *netdev)
 640 {
 641         return RSS_HASH_KEY_SIZE * sizeof(u64);
 642 }
 643
 644 static u32 nicvf_get_rxfh_indir_size(struct net_device *dev)
 645 {
 646         struct nicvf *nic = netdev_priv(dev);
 647
 648         return nic->rss_info.rss_size;
 649 }
 650
 651 static int nicvf_get_rxfh(struct net_device *dev, u32 *indir, u8 *hkey,
 652                           u8 *hfunc)
 653 {
 654         struct nicvf *nic = netdev_priv(dev);
 655         struct nicvf_rss_info *rss = &nic->rss_info;
 656         int idx;
 657
 658         if (indir) {
 659                 for (idx = 0; idx < rss->rss_size; idx++)
 660                         indir[idx] = rss->ind_tbl[idx];
 661         }
 662
 663         if (hkey)
 664                 memcpy(hkey, rss->key, RSS_HASH_KEY_SIZE * sizeof(u64));
 665
 666         if (hfunc)
 667                 *hfunc = ETH_RSS_HASH_TOP;
 668
 669         return 0;
 670 }
 671
 672 static int nicvf_set_rxfh(struct net_device *dev, const u32 *indir,
 673                           const u8 *hkey, const u8 hfunc)
 674 {
 675         struct nicvf *nic = netdev_priv(dev);
 676         struct nicvf_rss_info *rss = &nic->rss_info;
 677         int idx;
 678
 679         if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
 680                 return -EOPNOTSUPP;
 681
 682         if (!rss->enable) {
 683                 netdev_err(nic->netdev,
 684                            "RSS is disabled, cannot change settings\n");
 685                 return -EIO;
 686         }
 687
 688         if (indir) {
 689                 for (idx = 0; idx < rss->rss_size; idx++)
 690                         rss->ind_tbl[idx] = indir[idx];
 691         }
 692
 693         if (hkey) {
 694                 memcpy(rss->key, hkey, RSS_HASH_KEY_SIZE * sizeof(u64));
 695                 nicvf_set_rss_key(nic);
 696         }
 697
 698         nicvf_config_rss(nic);
 699         return 0;
 700 }
 701
 702 /* Get no of queues device supports and current queue count */
 703 static void nicvf_get_channels(struct net_device *dev,
 704                                struct ethtool_channels *channel)
 705 {
 706         struct nicvf *nic = netdev_priv(dev);
 707
 708         memset(channel, 0, sizeof(*channel));
 709
 710         channel->max_rx = nic->max_queues;
 711         channel->max_tx = nic->max_queues;
 712
 713         channel->rx_count = nic->rx_queues;
 714         channel->tx_count = nic->tx_queues;
 715 }
 716
 717 /* Set no of Tx, Rx queues to be used */
 718 static int nicvf_set_channels(struct net_device *dev,
 719                               struct ethtool_channels *channel)
 720 {
 721         struct nicvf *nic = netdev_priv(dev);
 722         int err = 0;
 723         bool if_up = netif_running(dev);
 724         u8 cqcount, txq_count;
 725
 726         if (!channel->rx_count || !channel->tx_count)
 727                 return -EINVAL;
 728         if (channel->rx_count > nic->max_queues)
 729                 return -EINVAL;
 730         if (channel->tx_count > nic->max_queues)
 731                 return -EINVAL;
 732
 733         if (nic->xdp_prog &&
 734             ((channel->tx_count + channel->rx_count) > nic->max_queues)) {
 735                 netdev_err(nic->netdev,
 736                            "XDP mode, RXQs + TXQs > Max %d\n",
 737                            nic->max_queues);
 738                 return -EINVAL;
 739         }
 740
 741         if (if_up)
 742                 nicvf_stop(dev);
 743
 744         nic->rx_queues = channel->rx_count;
 745         nic->tx_queues = channel->tx_count;
 746         if (!nic->xdp_prog)
 747                 nic->xdp_tx_queues = 0;
 748         else
 749                 nic->xdp_tx_queues = channel->rx_count;
 750
 751         txq_count = nic->xdp_tx_queues + nic->tx_queues;
 752         cqcount = max(nic->rx_queues, txq_count);
 753
 754         if (cqcount > MAX_CMP_QUEUES_PER_QS) {
 755                 nic->sqs_count = roundup(cqcount, MAX_CMP_QUEUES_PER_QS);
 756                 nic->sqs_count = (nic->sqs_count / MAX_CMP_QUEUES_PER_QS) - 1;
 757         } else {
 758                 nic->sqs_count = 0;
 759         }
 760
 761         nic->qs->rq_cnt = min_t(u8, nic->rx_queues, MAX_RCV_QUEUES_PER_QS);
 762         nic->qs->sq_cnt = min_t(u8, txq_count, MAX_SND_QUEUES_PER_QS);
 763         nic->qs->cq_cnt = max(nic->qs->rq_cnt, nic->qs->sq_cnt);
 764
 765         err = nicvf_set_real_num_queues(dev, nic->tx_queues, nic->rx_queues);
 766         if (err)
 767                 return err;
 768
 769         if (if_up)
 770                 nicvf_open(dev);
 771
 772         netdev_info(dev, "Setting num Tx rings to %d, Rx rings to %d success\n",
 773                     nic->tx_queues, nic->rx_queues);
 774
 775         return err;
 776 }
 777
 778 static void nicvf_get_pauseparam(struct net_device *dev,
 779                                  struct ethtool_pauseparam *pause)
 780 {
 781         struct nicvf *nic = netdev_priv(dev);
 782         union nic_mbx mbx = {};
 783
 784         /* Supported only for 10G/40G interfaces */
 785         if ((nic->mac_type == BGX_MODE_SGMII) ||
 786             (nic->mac_type == BGX_MODE_QSGMII) ||
 787             (nic->mac_type == BGX_MODE_RGMII))
 788                 return;
 789
 790         mbx.pfc.msg = NIC_MBOX_MSG_PFC;
 791         mbx.pfc.get = 1;
 792         if (!nicvf_send_msg_to_pf(nic, &mbx)) {
 793                 pause->autoneg = nic->pfc.autoneg;
 794                 pause->rx_pause = nic->pfc.fc_rx;
 795                 pause->tx_pause = nic->pfc.fc_tx;
 796         }
 797 }
 798
 799 static int nicvf_set_pauseparam(struct net_device *dev,
 800                                 struct ethtool_pauseparam *pause)
 801 {
 802         struct nicvf *nic = netdev_priv(dev);
 803         union nic_mbx mbx = {};
 804
 805         /* Supported only for 10G/40G interfaces */
 806         if ((nic->mac_type == BGX_MODE_SGMII) ||
 807             (nic->mac_type == BGX_MODE_QSGMII) ||
 808             (nic->mac_type == BGX_MODE_RGMII))
 809                 return -EOPNOTSUPP;
 810
 811         if (pause->autoneg)
 812                 return -EOPNOTSUPP;
 813
 814         mbx.pfc.msg = NIC_MBOX_MSG_PFC;
 815         mbx.pfc.get = 0;
 816         mbx.pfc.fc_rx = pause->rx_pause;
 817         mbx.pfc.fc_tx = pause->tx_pause;
 818         if (nicvf_send_msg_to_pf(nic, &mbx))
 819                 return -EAGAIN;
 820
 821         nic->pfc.fc_rx = pause->rx_pause;
 822         nic->pfc.fc_tx = pause->tx_pause;
 823
 824         return 0;
 825 }
 826
 827 static const struct ethtool_ops nicvf_ethtool_ops = {
 828         .get_link               = nicvf_get_link,
 829         .get_drvinfo            = nicvf_get_drvinfo,
 830         .get_msglevel           = nicvf_get_msglevel,
 831         .set_msglevel           = nicvf_set_msglevel,
 832         .get_strings            = nicvf_get_strings,
 833         .get_sset_count         = nicvf_get_sset_count,
 834         .get_ethtool_stats      = nicvf_get_ethtool_stats,
 835         .get_regs_len           = nicvf_get_regs_len,
 836         .get_regs               = nicvf_get_regs,
 837         .get_coalesce           = nicvf_get_coalesce,
 838         .get_ringparam          = nicvf_get_ringparam,
 839         .set_ringparam          = nicvf_set_ringparam,
 840         .get_rxnfc              = nicvf_get_rxnfc,
 841         .set_rxnfc              = nicvf_set_rxnfc,
 842         .get_rxfh_key_size      = nicvf_get_rxfh_key_size,
 843         .get_rxfh_indir_size    = nicvf_get_rxfh_indir_size,
 844         .get_rxfh               = nicvf_get_rxfh,
 845         .set_rxfh               = nicvf_set_rxfh,
 846         .get_channels           = nicvf_get_channels,
 847         .set_channels           = nicvf_set_channels,
 848         .get_pauseparam         = nicvf_get_pauseparam,
 849         .set_pauseparam         = nicvf_set_pauseparam,
 850         .get_ts_info            = ethtool_op_get_ts_info,
 851         .get_link_ksettings     = nicvf_get_link_ksettings,
 852 };
 853
 854 void nicvf_set_ethtool_ops(struct net_device *netdev)
 855 {
 856         netdev->ethtool_ops = &nicvf_ethtool_ops;
 857 }