net-next/hinic: Add ethtool and stats

Add ethtool operations and statistics operations.

Signed-off-by: Aviad Krawczyk <aviad.krawczyk@huawei.com>
Signed-off-by: Zhao Chen <zhaochen6@huawei.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_dev.h b/drivers/net/ethernet/huawei/hinic/hinic_dev.h
index 15d0c2e3797c965cd4c6bf1f27e822f2e3df3e50..5186cc9023aae513caa35c39ae56dbeaf89789f9 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_dev.h
+++ b/drivers/net/ethernet/huawei/hinic/hinic_dev.h
@@ -56,6 +56,9 @@ struct hinic_dev {
 
        struct hinic_txq                *txqs;
        struct hinic_rxq                *rxqs;
+
+       struct hinic_txq_stats          tx_stats;
+       struct hinic_rxq_stats          rx_stats;
 };
 
 #endif

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_main.c b/drivers/net/ethernet/huawei/hinic/hinic_main.c
index 599d8b590e9ade2f0e485d33c37ca795bcf4fb43..a417ca2d441cecc25452be333e1425f5e2eacd37 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_main.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_main.c
@@ -69,6 +69,186 @@ MODULE_PARM_DESC(rx_weight, "Number Rx packets for NAPI budget (default=64)");
 
 static int change_mac_addr(struct net_device *netdev, const u8 *addr);
 
+static void set_link_speed(struct ethtool_link_ksettings *link_ksettings,
+                          enum hinic_speed speed)
+{
+       switch (speed) {
+       case HINIC_SPEED_10MB_LINK:
+               link_ksettings->base.speed = SPEED_10;
+               break;
+
+       case HINIC_SPEED_100MB_LINK:
+               link_ksettings->base.speed = SPEED_100;
+               break;
+
+       case HINIC_SPEED_1000MB_LINK:
+               link_ksettings->base.speed = SPEED_1000;
+               break;
+
+       case HINIC_SPEED_10GB_LINK:
+               link_ksettings->base.speed = SPEED_10000;
+               break;
+
+       case HINIC_SPEED_25GB_LINK:
+               link_ksettings->base.speed = SPEED_25000;
+               break;
+
+       case HINIC_SPEED_40GB_LINK:
+               link_ksettings->base.speed = SPEED_40000;
+               break;
+
+       case HINIC_SPEED_100GB_LINK:
+               link_ksettings->base.speed = SPEED_100000;
+               break;
+
+       default:
+               link_ksettings->base.speed = SPEED_UNKNOWN;
+               break;
+       }
+}
+
+static int hinic_get_link_ksettings(struct net_device *netdev,
+                                   struct ethtool_link_ksettings
+                                   *link_ksettings)
+{
+       struct hinic_dev *nic_dev = netdev_priv(netdev);
+       enum hinic_port_link_state link_state;
+       struct hinic_port_cap port_cap;
+       int err;
+
+       ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);
+       ethtool_link_ksettings_add_link_mode(link_ksettings, supported,
+                                            Autoneg);
+
+       link_ksettings->base.speed   = SPEED_UNKNOWN;
+       link_ksettings->base.autoneg = AUTONEG_DISABLE;
+       link_ksettings->base.duplex  = DUPLEX_UNKNOWN;
+
+       err = hinic_port_get_cap(nic_dev, &port_cap);
+       if (err) {
+               netif_err(nic_dev, drv, netdev,
+                         "Failed to get port capabilities\n");
+               return err;
+       }
+
+       err = hinic_port_link_state(nic_dev, &link_state);
+       if (err) {
+               netif_err(nic_dev, drv, netdev,
+                         "Failed to get port link state\n");
+               return err;
+       }
+
+       if (link_state != HINIC_LINK_STATE_UP) {
+               netif_info(nic_dev, drv, netdev, "No link\n");
+               return err;
+       }
+
+       set_link_speed(link_ksettings, port_cap.speed);
+
+       if (!!(port_cap.autoneg_cap & HINIC_AUTONEG_SUPPORTED))
+               ethtool_link_ksettings_add_link_mode(link_ksettings,
+                                                    advertising, Autoneg);
+
+       if (port_cap.autoneg_state == HINIC_AUTONEG_ACTIVE)
+               link_ksettings->base.autoneg = AUTONEG_ENABLE;
+
+       link_ksettings->base.duplex = (port_cap.duplex == HINIC_DUPLEX_FULL) ?
+                                      DUPLEX_FULL : DUPLEX_HALF;
+       return 0;
+}
+
+static void hinic_get_drvinfo(struct net_device *netdev,
+                             struct ethtool_drvinfo *info)
+{
+       struct hinic_dev *nic_dev = netdev_priv(netdev);
+       struct hinic_hwdev *hwdev = nic_dev->hwdev;
+       struct hinic_hwif *hwif = hwdev->hwif;
+
+       strlcpy(info->driver, HINIC_DRV_NAME, sizeof(info->driver));
+       strlcpy(info->bus_info, pci_name(hwif->pdev), sizeof(info->bus_info));
+}
+
+static void hinic_get_ringparam(struct net_device *netdev,
+                               struct ethtool_ringparam *ring)
+{
+       ring->rx_max_pending = HINIC_RQ_DEPTH;
+       ring->tx_max_pending = HINIC_SQ_DEPTH;
+       ring->rx_pending = HINIC_RQ_DEPTH;
+       ring->tx_pending = HINIC_SQ_DEPTH;
+}
+
+static void hinic_get_channels(struct net_device *netdev,
+                              struct ethtool_channels *channels)
+{
+       struct hinic_dev *nic_dev = netdev_priv(netdev);
+       struct hinic_hwdev *hwdev = nic_dev->hwdev;
+
+       channels->max_rx = hwdev->nic_cap.max_qps;
+       channels->max_tx = hwdev->nic_cap.max_qps;
+       channels->max_other    = 0;
+       channels->max_combined = 0;
+       channels->rx_count = hinic_hwdev_num_qps(hwdev);
+       channels->tx_count = hinic_hwdev_num_qps(hwdev);
+       channels->other_count    = 0;
+       channels->combined_count = 0;
+}
+
+static const struct ethtool_ops hinic_ethtool_ops = {
+       .get_link_ksettings = hinic_get_link_ksettings,
+       .get_drvinfo = hinic_get_drvinfo,
+       .get_link = ethtool_op_get_link,
+       .get_ringparam = hinic_get_ringparam,
+       .get_channels = hinic_get_channels,
+};
+
+static void update_rx_stats(struct hinic_dev *nic_dev, struct hinic_rxq *rxq)
+{
+       struct hinic_rxq_stats *nic_rx_stats = &nic_dev->rx_stats;
+       struct hinic_rxq_stats rx_stats;
+
+       u64_stats_init(&rx_stats.syncp);
+
+       hinic_rxq_get_stats(rxq, &rx_stats);
+
+       u64_stats_update_begin(&nic_rx_stats->syncp);
+       nic_rx_stats->bytes += rx_stats.bytes;
+       nic_rx_stats->pkts  += rx_stats.pkts;
+       u64_stats_update_end(&nic_rx_stats->syncp);
+
+       hinic_rxq_clean_stats(rxq);
+}
+
+static void update_tx_stats(struct hinic_dev *nic_dev, struct hinic_txq *txq)
+{
+       struct hinic_txq_stats *nic_tx_stats = &nic_dev->tx_stats;
+       struct hinic_txq_stats tx_stats;
+
+       u64_stats_init(&tx_stats.syncp);
+
+       hinic_txq_get_stats(txq, &tx_stats);
+
+       u64_stats_update_begin(&nic_tx_stats->syncp);
+       nic_tx_stats->bytes += tx_stats.bytes;
+       nic_tx_stats->pkts += tx_stats.pkts;
+       nic_tx_stats->tx_busy += tx_stats.tx_busy;
+       nic_tx_stats->tx_wake += tx_stats.tx_wake;
+       nic_tx_stats->tx_dropped += tx_stats.tx_dropped;
+       u64_stats_update_end(&nic_tx_stats->syncp);
+
+       hinic_txq_clean_stats(txq);
+}
+
+static void update_nic_stats(struct hinic_dev *nic_dev)
+{
+       int i, num_qps = hinic_hwdev_num_qps(nic_dev->hwdev);
+
+       for (i = 0; i < num_qps; i++)
+               update_rx_stats(nic_dev, &nic_dev->rxqs[i]);
+
+       for (i = 0; i < num_qps; i++)
+               update_tx_stats(nic_dev, &nic_dev->txqs[i]);
+}
+
 /**
  * create_txqs - Create the Logical Tx Queues of specific NIC device
  * @nic_dev: the specific NIC device
@@ -303,6 +483,8 @@ static int hinic_close(struct net_device *netdev)
        netif_carrier_off(netdev);
        netif_tx_disable(netdev);
 
+       update_nic_stats(nic_dev);
+
        up(&nic_dev->mgmt_lock);
 
        err = hinic_port_set_func_state(nic_dev, HINIC_FUNC_PORT_DISABLE);
@@ -580,6 +762,31 @@ static void hinic_tx_timeout(struct net_device *netdev)
        netif_err(nic_dev, drv, netdev, "Tx timeout\n");
 }
 
+static void hinic_get_stats64(struct net_device *netdev,
+                             struct rtnl_link_stats64 *stats)
+{
+       struct hinic_dev *nic_dev = netdev_priv(netdev);
+       struct hinic_rxq_stats *nic_rx_stats;
+       struct hinic_txq_stats *nic_tx_stats;
+
+       nic_rx_stats = &nic_dev->rx_stats;
+       nic_tx_stats = &nic_dev->tx_stats;
+
+       down(&nic_dev->mgmt_lock);
+
+       if (nic_dev->flags & HINIC_INTF_UP)
+               update_nic_stats(nic_dev);
+
+       up(&nic_dev->mgmt_lock);
+
+       stats->rx_bytes   = nic_rx_stats->bytes;
+       stats->rx_packets = nic_rx_stats->pkts;
+
+       stats->tx_bytes   = nic_tx_stats->bytes;
+       stats->tx_packets = nic_tx_stats->pkts;
+       stats->tx_errors  = nic_tx_stats->tx_dropped;
+}
+
 static const struct net_device_ops hinic_netdev_ops = {
        .ndo_open = hinic_open,
        .ndo_stop = hinic_close,
@@ -591,7 +798,7 @@ static const struct net_device_ops hinic_netdev_ops = {
        .ndo_set_rx_mode = hinic_set_rx_mode,
        .ndo_start_xmit = hinic_xmit_frame,
        .ndo_tx_timeout = hinic_tx_timeout,
-       /* more operations should be filled */
+       .ndo_get_stats64 = hinic_get_stats64,
 };
 
 static void netdev_features_init(struct net_device *netdev)
@@ -663,6 +870,8 @@ static void link_status_event_handler(void *handle, void *buf_in, u16 in_size,
 static int nic_dev_init(struct pci_dev *pdev)
 {
        struct hinic_rx_mode_work *rx_mode_work;
+       struct hinic_txq_stats *tx_stats;
+       struct hinic_rxq_stats *rx_stats;
        struct hinic_dev *nic_dev;
        struct net_device *netdev;
        struct hinic_hwdev *hwdev;
@@ -689,6 +898,7 @@ static int nic_dev_init(struct pci_dev *pdev)
        }
 
        netdev->netdev_ops = &hinic_netdev_ops;
+       netdev->ethtool_ops = &hinic_ethtool_ops;
 
        nic_dev = netdev_priv(netdev);
        nic_dev->netdev = netdev;
@@ -702,6 +912,12 @@ static int nic_dev_init(struct pci_dev *pdev)
 
        sema_init(&nic_dev->mgmt_lock, 1);
 
+       tx_stats = &nic_dev->tx_stats;
+       rx_stats = &nic_dev->rx_stats;
+
+       u64_stats_init(&tx_stats->syncp);
+       u64_stats_init(&rx_stats->syncp);
+
        nic_dev->vlan_bitmap = devm_kzalloc(&pdev->dev,
                                            VLAN_BITMAP_SIZE(nic_dev),
                                            GFP_KERNEL);

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_port.c b/drivers/net/ethernet/huawei/hinic/hinic_port.c
index 528ec6febd041616f4107d2467b2ba19b07b5e7d..4d4e3f05fb5fbff66fc4a9b857c9ff5a3adfca72 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_port.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_port.c
@@ -346,3 +346,34 @@ int hinic_port_set_func_state(struct hinic_dev *nic_dev,
 
        return 0;
 }
+
+/**
+ * hinic_port_get_cap - get port capabilities
+ * @nic_dev: nic device
+ * @port_cap: returned port capabilities
+ *
+ * Return 0 - Success, negative - Failure
+ **/
+int hinic_port_get_cap(struct hinic_dev *nic_dev,
+                      struct hinic_port_cap *port_cap)
+{
+       struct hinic_hwdev *hwdev = nic_dev->hwdev;
+       struct hinic_hwif *hwif = hwdev->hwif;
+       struct pci_dev *pdev = hwif->pdev;
+       u16 out_size;
+       int err;
+
+       port_cap->func_idx = HINIC_HWIF_FUNC_IDX(hwif);
+
+       err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_CAP,
+                                port_cap, sizeof(*port_cap),
+                                port_cap, &out_size);
+       if (err || (out_size != sizeof(*port_cap)) || port_cap->status) {
+               dev_err(&pdev->dev,
+                       "Failed to get port capabilities, ret = %d\n",
+                       port_cap->status);
+               return -EINVAL;
+       }
+
+       return 0;
+}

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_port.h b/drivers/net/ethernet/huawei/hinic/hinic_port.h
index 17f9d7fc5a0ac2f0b2d9a04209214178d69a6cc5..9404365195ddff0679fea6c94d2cc41ddcd90482 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_port.h
+++ b/drivers/net/ethernet/huawei/hinic/hinic_port.h
@@ -45,6 +45,33 @@ enum hinic_func_port_state {
        HINIC_FUNC_PORT_ENABLE  = 2,
 };
 
+enum hinic_autoneg_cap {
+       HINIC_AUTONEG_UNSUPPORTED,
+       HINIC_AUTONEG_SUPPORTED,
+};
+
+enum hinic_autoneg_state {
+       HINIC_AUTONEG_DISABLED,
+       HINIC_AUTONEG_ACTIVE,
+};
+
+enum hinic_duplex {
+       HINIC_DUPLEX_HALF,
+       HINIC_DUPLEX_FULL,
+};
+
+enum hinic_speed {
+       HINIC_SPEED_10MB_LINK = 0,
+       HINIC_SPEED_100MB_LINK,
+       HINIC_SPEED_1000MB_LINK,
+       HINIC_SPEED_10GB_LINK,
+       HINIC_SPEED_25GB_LINK,
+       HINIC_SPEED_40GB_LINK,
+       HINIC_SPEED_100GB_LINK,
+
+       HINIC_SPEED_UNKNOWN = 0xFF,
+};
+
 struct hinic_port_mac_cmd {
        u8              status;
        u8              version;
@@ -125,6 +152,21 @@ struct hinic_port_func_state_cmd {
        u8      rsvd2[3];
 };
 
+struct hinic_port_cap {
+       u8      status;
+       u8      version;
+       u8      rsvd0[6];
+
+       u16     func_idx;
+       u16     rsvd1;
+       u8      port_type;
+       u8      autoneg_cap;
+       u8      autoneg_state;
+       u8      duplex;
+       u8      speed;
+       u8      rsvd2[3];
+};
+
 int hinic_port_add_mac(struct hinic_dev *nic_dev, const u8 *addr,
                       u16 vlan_id);
 
@@ -150,4 +192,7 @@ int hinic_port_set_state(struct hinic_dev *nic_dev,
 int hinic_port_set_func_state(struct hinic_dev *nic_dev,
                              enum hinic_func_port_state state);
 
+int hinic_port_get_cap(struct hinic_dev *nic_dev,
+                      struct hinic_port_cap *port_cap);
+
 #endif

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_rx.c b/drivers/net/ethernet/huawei/hinic/hinic_rx.c
index b1212e498f95a82f633a224fd40d4ef010069a5b..1d4f712b15a824505584f0327005ad2cd9b289ce 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_rx.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_rx.c
@@ -57,6 +57,25 @@ void hinic_rxq_clean_stats(struct hinic_rxq *rxq)
        u64_stats_update_end(&rxq_stats->syncp);
 }
 
+/**
+ * hinic_rxq_get_stats - get statistics of Rx Queue
+ * @rxq: Logical Rx Queue
+ * @stats: return updated stats here
+ **/
+void hinic_rxq_get_stats(struct hinic_rxq *rxq, struct hinic_rxq_stats *stats)
+{
+       struct hinic_rxq_stats *rxq_stats = &rxq->rxq_stats;
+       unsigned int start;
+
+       u64_stats_update_begin(&stats->syncp);
+       do {
+               start = u64_stats_fetch_begin(&rxq_stats->syncp);
+               stats->pkts = rxq_stats->pkts;
+               stats->bytes = rxq_stats->bytes;
+       } while (u64_stats_fetch_retry(&rxq_stats->syncp, start));
+       u64_stats_update_end(&stats->syncp);
+}
+
 /**
  * rxq_stats_init - Initialize the statistics of specific queue
  * @rxq: Logical Rx Queue

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_rx.h b/drivers/net/ethernet/huawei/hinic/hinic_rx.h
index 538c8861e8dd9fa02e2d3ff4a439be36feb15119..27c9af4b1c12a388f08baab8500a3c11d3fbe672 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_rx.h
+++ b/drivers/net/ethernet/huawei/hinic/hinic_rx.h
@@ -45,6 +45,8 @@ struct hinic_rxq {
 
 void hinic_rxq_clean_stats(struct hinic_rxq *rxq);
 
+void hinic_rxq_get_stats(struct hinic_rxq *rxq, struct hinic_rxq_stats *stats);
+
 int hinic_init_rxq(struct hinic_rxq *rxq, struct hinic_rq *rq,
                   struct net_device *netdev);
 

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_tx.c b/drivers/net/ethernet/huawei/hinic/hinic_tx.c
index 90ab2d971383093bf2cc0271b0d4d519b33cca98..5bf6a32faa46ee238d27f007429ee66c9aa1efe9 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_tx.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_tx.c
@@ -66,6 +66,28 @@ void hinic_txq_clean_stats(struct hinic_txq *txq)
        u64_stats_update_end(&txq_stats->syncp);
 }
 
+/**
+ * hinic_txq_get_stats - get statistics of Tx Queue
+ * @txq: Logical Tx Queue
+ * @stats: return updated stats here
+ **/
+void hinic_txq_get_stats(struct hinic_txq *txq, struct hinic_txq_stats *stats)
+{
+       struct hinic_txq_stats *txq_stats = &txq->txq_stats;
+       unsigned int start;
+
+       u64_stats_update_begin(&stats->syncp);
+       do {
+               start = u64_stats_fetch_begin(&txq_stats->syncp);
+               stats->pkts    = txq_stats->pkts;
+               stats->bytes   = txq_stats->bytes;
+               stats->tx_busy = txq_stats->tx_busy;
+               stats->tx_wake = txq_stats->tx_wake;
+               stats->tx_dropped = txq_stats->tx_dropped;
+       } while (u64_stats_fetch_retry(&txq_stats->syncp, start));
+       u64_stats_update_end(&stats->syncp);
+}
+
 /**
  * txq_stats_init - Initialize the statistics of specific queue
  * @txq: Logical Tx Queue

diff --git a/drivers/net/ethernet/huawei/hinic/hinic_tx.h b/drivers/net/ethernet/huawei/hinic/hinic_tx.h
index 7123c7f7e06a23e5f12dd1e013cb0ad7cf5b61f1..1fa55dce5aa7b06b95cca3b229aac3145e27eeac 100644 (file)
--- a/drivers/net/ethernet/huawei/hinic/hinic_tx.h
+++ b/drivers/net/ethernet/huawei/hinic/hinic_tx.h
@@ -50,6 +50,8 @@ struct hinic_txq {
 
 void hinic_txq_clean_stats(struct hinic_txq *txq);
 
+void hinic_txq_get_stats(struct hinic_txq *txq, struct hinic_txq_stats *stats);
+
 netdev_tx_t hinic_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
 
 int hinic_init_txq(struct hinic_txq *txq, struct hinic_sq *sq,