drivers/net/ethernet/qlogic/qede/qede_ethtool.c

   1 /* QLogic qede NIC Driver
   2 * Copyright (c) 2015 QLogic Corporation
   3 *
   4 * This software is available under the terms of the GNU General Public License
   5 * (GPL) Version 2, available from the file COPYING in the main directory of
   6 * this source tree.
   7 */
   8
   9 #include <linux/version.h>
  10 #include <linux/types.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/ethtool.h>
  13 #include <linux/string.h>
  14 #include <linux/pci.h>
  15 #include <linux/capability.h>
  16 #include "qede.h"
  17
  18 #define QEDE_STAT_OFFSET(stat_name) (offsetof(struct qede_stats, stat_name))
  19 #define QEDE_STAT_STRING(stat_name) (#stat_name)
  20 #define _QEDE_STAT(stat_name, pf_only) \
  21          {QEDE_STAT_OFFSET(stat_name), QEDE_STAT_STRING(stat_name), pf_only}
  22 #define QEDE_PF_STAT(stat_name)         _QEDE_STAT(stat_name, true)
  23 #define QEDE_STAT(stat_name)            _QEDE_STAT(stat_name, false)
  24
  25 #define QEDE_RQSTAT_OFFSET(stat_name) \
  26          (offsetof(struct qede_rx_queue, stat_name))
  27 #define QEDE_RQSTAT_STRING(stat_name) (#stat_name)
  28 #define QEDE_RQSTAT(stat_name) \
  29          {QEDE_RQSTAT_OFFSET(stat_name), QEDE_RQSTAT_STRING(stat_name)}
  30 static const struct {
  31         u64 offset;
  32         char string[ETH_GSTRING_LEN];
  33 } qede_rqstats_arr[] = {
  34         QEDE_RQSTAT(rx_hw_errors),
  35         QEDE_RQSTAT(rx_alloc_errors),
  36 };
  37
  38 #define QEDE_NUM_RQSTATS ARRAY_SIZE(qede_rqstats_arr)
  39 #define QEDE_RQSTATS_DATA(dev, sindex, rqindex) \
  40         (*((u64 *)(((char *)(dev->fp_array[(rqindex)].rxq)) +\
  41                     qede_rqstats_arr[(sindex)].offset)))
  42 static const struct {
  43         u64 offset;
  44         char string[ETH_GSTRING_LEN];
  45         bool pf_only;
  46 } qede_stats_arr[] = {
  47         QEDE_STAT(rx_ucast_bytes),
  48         QEDE_STAT(rx_mcast_bytes),
  49         QEDE_STAT(rx_bcast_bytes),
  50         QEDE_STAT(rx_ucast_pkts),
  51         QEDE_STAT(rx_mcast_pkts),
  52         QEDE_STAT(rx_bcast_pkts),
  53
  54         QEDE_STAT(tx_ucast_bytes),
  55         QEDE_STAT(tx_mcast_bytes),
  56         QEDE_STAT(tx_bcast_bytes),
  57         QEDE_STAT(tx_ucast_pkts),
  58         QEDE_STAT(tx_mcast_pkts),
  59         QEDE_STAT(tx_bcast_pkts),
  60
  61         QEDE_PF_STAT(rx_64_byte_packets),
  62         QEDE_PF_STAT(rx_127_byte_packets),
  63         QEDE_PF_STAT(rx_255_byte_packets),
  64         QEDE_PF_STAT(rx_511_byte_packets),
  65         QEDE_PF_STAT(rx_1023_byte_packets),
  66         QEDE_PF_STAT(rx_1518_byte_packets),
  67         QEDE_PF_STAT(rx_1522_byte_packets),
  68         QEDE_PF_STAT(rx_2047_byte_packets),
  69         QEDE_PF_STAT(rx_4095_byte_packets),
  70         QEDE_PF_STAT(rx_9216_byte_packets),
  71         QEDE_PF_STAT(rx_16383_byte_packets),
  72         QEDE_PF_STAT(tx_64_byte_packets),
  73         QEDE_PF_STAT(tx_65_to_127_byte_packets),
  74         QEDE_PF_STAT(tx_128_to_255_byte_packets),
  75         QEDE_PF_STAT(tx_256_to_511_byte_packets),
  76         QEDE_PF_STAT(tx_512_to_1023_byte_packets),
  77         QEDE_PF_STAT(tx_1024_to_1518_byte_packets),
  78         QEDE_PF_STAT(tx_1519_to_2047_byte_packets),
  79         QEDE_PF_STAT(tx_2048_to_4095_byte_packets),
  80         QEDE_PF_STAT(tx_4096_to_9216_byte_packets),
  81         QEDE_PF_STAT(tx_9217_to_16383_byte_packets),
  82
  83         QEDE_PF_STAT(rx_mac_crtl_frames),
  84         QEDE_PF_STAT(tx_mac_ctrl_frames),
  85         QEDE_PF_STAT(rx_pause_frames),
  86         QEDE_PF_STAT(tx_pause_frames),
  87         QEDE_PF_STAT(rx_pfc_frames),
  88         QEDE_PF_STAT(tx_pfc_frames),
  89
  90         QEDE_PF_STAT(rx_crc_errors),
  91         QEDE_PF_STAT(rx_align_errors),
  92         QEDE_PF_STAT(rx_carrier_errors),
  93         QEDE_PF_STAT(rx_oversize_packets),
  94         QEDE_PF_STAT(rx_jabbers),
  95         QEDE_PF_STAT(rx_undersize_packets),
  96         QEDE_PF_STAT(rx_fragments),
  97         QEDE_PF_STAT(tx_lpi_entry_count),
  98         QEDE_PF_STAT(tx_total_collisions),
  99         QEDE_PF_STAT(brb_truncates),
 100         QEDE_PF_STAT(brb_discards),
 101         QEDE_STAT(no_buff_discards),
 102         QEDE_PF_STAT(mftag_filter_discards),
 103         QEDE_PF_STAT(mac_filter_discards),
 104         QEDE_STAT(tx_err_drop_pkts),
 105
 106         QEDE_STAT(coalesced_pkts),
 107         QEDE_STAT(coalesced_events),
 108         QEDE_STAT(coalesced_aborts_num),
 109         QEDE_STAT(non_coalesced_pkts),
 110         QEDE_STAT(coalesced_bytes),
 111 };
 112
 113 #define QEDE_STATS_DATA(dev, index) \
 114         (*((u64 *)(((char *)(dev)) + offsetof(struct qede_dev, stats) \
 115                         + qede_stats_arr[(index)].offset)))
 116
 117 #define QEDE_NUM_STATS  ARRAY_SIZE(qede_stats_arr)
 118
 119 static void qede_get_strings_stats(struct qede_dev *edev, u8 *buf)
 120 {
 121         int i, j, k;
 122
 123         for (i = 0, j = 0; i < QEDE_NUM_STATS; i++) {
 124                 strcpy(buf + j * ETH_GSTRING_LEN,
 125                        qede_stats_arr[i].string);
 126                 j++;
 127         }
 128
 129         for (k = 0; k < QEDE_NUM_RQSTATS; k++, j++)
 130                 strcpy(buf + j * ETH_GSTRING_LEN,
 131                        qede_rqstats_arr[k].string);
 132 }
 133
 134 static void qede_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 135 {
 136         struct qede_dev *edev = netdev_priv(dev);
 137
 138         switch (stringset) {
 139         case ETH_SS_STATS:
 140                 qede_get_strings_stats(edev, buf);
 141                 break;
 142         default:
 143                 DP_VERBOSE(edev, QED_MSG_DEBUG,
 144                            "Unsupported stringset 0x%08x\n", stringset);
 145         }
 146 }
 147
 148 static void qede_get_ethtool_stats(struct net_device *dev,
 149                                    struct ethtool_stats *stats, u64 *buf)
 150 {
 151         struct qede_dev *edev = netdev_priv(dev);
 152         int sidx, cnt = 0;
 153         int qid;
 154
 155         qede_fill_by_demand_stats(edev);
 156
 157         mutex_lock(&edev->qede_lock);
 158
 159         for (sidx = 0; sidx < QEDE_NUM_STATS; sidx++)
 160                 buf[cnt++] = QEDE_STATS_DATA(edev, sidx);
 161
 162         for (sidx = 0; sidx < QEDE_NUM_RQSTATS; sidx++) {
 163                 buf[cnt] = 0;
 164                 for (qid = 0; qid < edev->num_rss; qid++)
 165                         buf[cnt] += QEDE_RQSTATS_DATA(edev, sidx, qid);
 166                 cnt++;
 167         }
 168
 169         mutex_unlock(&edev->qede_lock);
 170 }
 171
 172 static int qede_get_sset_count(struct net_device *dev, int stringset)
 173 {
 174         struct qede_dev *edev = netdev_priv(dev);
 175         int num_stats = QEDE_NUM_STATS;
 176
 177         switch (stringset) {
 178         case ETH_SS_STATS:
 179                 return num_stats + QEDE_NUM_RQSTATS;
 180
 181         default:
 182                 DP_VERBOSE(edev, QED_MSG_DEBUG,
 183                            "Unsupported stringset 0x%08x\n", stringset);
 184                 return -EINVAL;
 185         }
 186 }
 187
 188 static int qede_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 189 {
 190         struct qede_dev *edev = netdev_priv(dev);
 191         struct qed_link_output current_link;
 192
 193         memset(&current_link, 0, sizeof(current_link));
 194         edev->ops->common->get_link(edev->cdev, &current_link);
 195
 196         cmd->supported = current_link.supported_caps;
 197         cmd->advertising = current_link.advertised_caps;
 198         if ((edev->state == QEDE_STATE_OPEN) && (current_link.link_up)) {
 199                 ethtool_cmd_speed_set(cmd, current_link.speed);
 200                 cmd->duplex = current_link.duplex;
 201         } else {
 202                 cmd->duplex = DUPLEX_UNKNOWN;
 203                 ethtool_cmd_speed_set(cmd, SPEED_UNKNOWN);
 204         }
 205         cmd->port = current_link.port;
 206         cmd->autoneg = (current_link.autoneg) ? AUTONEG_ENABLE :
 207                                                 AUTONEG_DISABLE;
 208         cmd->lp_advertising = current_link.lp_caps;
 209
 210         return 0;
 211 }
 212
 213 static int qede_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 214 {
 215         struct qede_dev *edev = netdev_priv(dev);
 216         struct qed_link_output current_link;
 217         struct qed_link_params params;
 218         u32 speed;
 219
 220         if (edev->dev_info.common.is_mf) {
 221                 DP_INFO(edev,
 222                         "Link parameters can not be changed in MF mode\n");
 223                 return -EOPNOTSUPP;
 224         }
 225
 226         memset(&current_link, 0, sizeof(current_link));
 227         memset(&params, 0, sizeof(params));
 228         edev->ops->common->get_link(edev->cdev, &current_link);
 229
 230         speed = ethtool_cmd_speed(cmd);
 231         params.override_flags |= QED_LINK_OVERRIDE_SPEED_ADV_SPEEDS;
 232         params.override_flags |= QED_LINK_OVERRIDE_SPEED_AUTONEG;
 233         if (cmd->autoneg == AUTONEG_ENABLE) {
 234                 params.autoneg = true;
 235                 params.forced_speed = 0;
 236                 params.adv_speeds = cmd->advertising;
 237         } else { /* forced speed */
 238                 params.override_flags |= QED_LINK_OVERRIDE_SPEED_FORCED_SPEED;
 239                 params.autoneg = false;
 240                 params.forced_speed = speed;
 241                 switch (speed) {
 242                 case SPEED_10000:
 243                         if (!(current_link.supported_caps &
 244                             SUPPORTED_10000baseKR_Full)) {
 245                                 DP_INFO(edev, "10G speed not supported\n");
 246                                 return -EINVAL;
 247                         }
 248                         params.adv_speeds = SUPPORTED_10000baseKR_Full;
 249                         break;
 250                 case SPEED_40000:
 251                         if (!(current_link.supported_caps &
 252                             SUPPORTED_40000baseLR4_Full)) {
 253                                 DP_INFO(edev, "40G speed not supported\n");
 254                                 return -EINVAL;
 255                         }
 256                         params.adv_speeds = SUPPORTED_40000baseLR4_Full;
 257                         break;
 258                 default:
 259                         DP_INFO(edev, "Unsupported speed %u\n", speed);
 260                         return -EINVAL;
 261                 }
 262         }
 263
 264         params.link_up = true;
 265         edev->ops->common->set_link(edev->cdev, &params);
 266
 267         return 0;
 268 }
 269
 270 static void qede_get_drvinfo(struct net_device *ndev,
 271                              struct ethtool_drvinfo *info)
 272 {
 273         char mfw[ETHTOOL_FWVERS_LEN], storm[ETHTOOL_FWVERS_LEN];
 274         struct qede_dev *edev = netdev_priv(ndev);
 275
 276         strlcpy(info->driver, "qede", sizeof(info->driver));
 277         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
 278
 279         snprintf(storm, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d",
 280                  edev->dev_info.common.fw_major,
 281                  edev->dev_info.common.fw_minor,
 282                  edev->dev_info.common.fw_rev,
 283                  edev->dev_info.common.fw_eng);
 284
 285         snprintf(mfw, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d",
 286                  (edev->dev_info.common.mfw_rev >> 24) & 0xFF,
 287                  (edev->dev_info.common.mfw_rev >> 16) & 0xFF,
 288                  (edev->dev_info.common.mfw_rev >> 8) & 0xFF,
 289                  edev->dev_info.common.mfw_rev & 0xFF);
 290
 291         if ((strlen(storm) + strlen(mfw) + strlen("mfw storm  ")) <
 292             sizeof(info->fw_version)) {
 293                 snprintf(info->fw_version, sizeof(info->fw_version),
 294                          "mfw %s storm %s", mfw, storm);
 295         } else {
 296                 snprintf(info->fw_version, sizeof(info->fw_version),
 297                          "%s %s", mfw, storm);
 298         }
 299
 300         strlcpy(info->bus_info, pci_name(edev->pdev), sizeof(info->bus_info));
 301 }
 302
 303 static u32 qede_get_msglevel(struct net_device *ndev)
 304 {
 305         struct qede_dev *edev = netdev_priv(ndev);
 306
 307         return ((u32)edev->dp_level << QED_LOG_LEVEL_SHIFT) |
 308                edev->dp_module;
 309 }
 310
 311 static void qede_set_msglevel(struct net_device *ndev, u32 level)
 312 {
 313         struct qede_dev *edev = netdev_priv(ndev);
 314         u32 dp_module = 0;
 315         u8 dp_level = 0;
 316
 317         qede_config_debug(level, &dp_module, &dp_level);
 318
 319         edev->dp_level = dp_level;
 320         edev->dp_module = dp_module;
 321         edev->ops->common->update_msglvl(edev->cdev,
 322                                          dp_module, dp_level);
 323 }
 324
 325 static u32 qede_get_link(struct net_device *dev)
 326 {
 327         struct qede_dev *edev = netdev_priv(dev);
 328         struct qed_link_output current_link;
 329
 330         memset(&current_link, 0, sizeof(current_link));
 331         edev->ops->common->get_link(edev->cdev, &current_link);
 332
 333         return current_link.link_up;
 334 }
 335
 336 static void qede_update_mtu(struct qede_dev *edev, union qede_reload_args *args)
 337 {
 338         edev->ndev->mtu = args->mtu;
 339 }
 340
 341 /* Netdevice NDOs */
 342 #define ETH_MAX_JUMBO_PACKET_SIZE       9600
 343 #define ETH_MIN_PACKET_SIZE             60
 344 int qede_change_mtu(struct net_device *ndev, int new_mtu)
 345 {
 346         struct qede_dev *edev = netdev_priv(ndev);
 347         union qede_reload_args args;
 348
 349         if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
 350             ((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE)) {
 351                 DP_ERR(edev, "Can't support requested MTU size\n");
 352                 return -EINVAL;
 353         }
 354
 355         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 356                    "Configuring MTU size of %d\n", new_mtu);
 357
 358         /* Set the mtu field and re-start the interface if needed*/
 359         args.mtu = new_mtu;
 360
 361         if (netif_running(edev->ndev))
 362                 qede_reload(edev, &qede_update_mtu, &args);
 363
 364         qede_update_mtu(edev, &args);
 365
 366         return 0;
 367 }
 368
 369 static void qede_get_channels(struct net_device *dev,
 370                               struct ethtool_channels *channels)
 371 {
 372         struct qede_dev *edev = netdev_priv(dev);
 373
 374         channels->max_combined = QEDE_MAX_RSS_CNT(edev);
 375         channels->combined_count = QEDE_RSS_CNT(edev);
 376 }
 377
 378 static int qede_set_channels(struct net_device *dev,
 379                              struct ethtool_channels *channels)
 380 {
 381         struct qede_dev *edev = netdev_priv(dev);
 382
 383         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 384                    "set-channels command parameters: rx = %d, tx = %d, other = %d, combined = %d\n",
 385                    channels->rx_count, channels->tx_count,
 386                    channels->other_count, channels->combined_count);
 387
 388         /* We don't support separate rx / tx, nor `other' channels. */
 389         if (channels->rx_count || channels->tx_count ||
 390             channels->other_count || (channels->combined_count == 0) ||
 391             (channels->combined_count > QEDE_MAX_RSS_CNT(edev))) {
 392                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 393                            "command parameters not supported\n");
 394                 return -EINVAL;
 395         }
 396
 397         /* Check if there was a change in the active parameters */
 398         if (channels->combined_count == QEDE_RSS_CNT(edev)) {
 399                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 400                            "No change in active parameters\n");
 401                 return 0;
 402         }
 403
 404         /* We need the number of queues to be divisible between the hwfns */
 405         if (channels->combined_count % edev->dev_info.common.num_hwfns) {
 406                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 407                            "Number of channels must be divisable by %04x\n",
 408                            edev->dev_info.common.num_hwfns);
 409                 return -EINVAL;
 410         }
 411
 412         /* Set number of queues and reload if necessary */
 413         edev->req_rss = channels->combined_count;
 414         if (netif_running(dev))
 415                 qede_reload(edev, NULL, NULL);
 416
 417         return 0;
 418 }
 419
 420 static const struct ethtool_ops qede_ethtool_ops = {
 421         .get_settings = qede_get_settings,
 422         .set_settings = qede_set_settings,
 423         .get_drvinfo = qede_get_drvinfo,
 424         .get_msglevel = qede_get_msglevel,
 425         .set_msglevel = qede_set_msglevel,
 426         .get_link = qede_get_link,
 427         .get_strings = qede_get_strings,
 428         .get_ethtool_stats = qede_get_ethtool_stats,
 429         .get_sset_count = qede_get_sset_count,
 430
 431         .get_channels = qede_get_channels,
 432         .set_channels = qede_set_channels,
 433 };
 434
 435 void qede_set_ethtool_ops(struct net_device *dev)
 436 {
 437         dev->ethtool_ops = &qede_ethtool_ops;
 438 }