generic: ar8216: group MIB counters and use two basic ones only by default
authorChuanhong Guo <gch981213@gmail.com>
Thu, 11 Apr 2019 13:45:45 +0000 (21:45 +0800)
committerPetr Štetiar <ynezz@true.cz>
Mon, 20 May 2019 19:17:57 +0000 (21:17 +0200)
There are too many MIB counters that almost nobody needs since commit
d6366ce3665f ("generic: ar8216: mib_work_func: read all port mibs
everytime").

In the worker function to poll MIB data, it deals with all ports instead
of only one port every time, which introduces too many mdio operations
that it becomes a heavy CPU load even on not-emulated MDIO bus.

This commit groups MIB counters and enable only TxBytes and RxGoodBytes
by default (both of which are necessary to get swconfig led working.)
and adds an swconfig attribute to allow enabling all counters if users
need them.

Signed-off-by: Chuanhong Guo <gch981213@gmail.com>
target/linux/generic/files/drivers/net/phy/ar8216.c
target/linux/generic/files/drivers/net/phy/ar8216.h
target/linux/generic/files/drivers/net/phy/ar8327.c

index 748a626..683241c 100644 (file)
 extern const struct ar8xxx_chip ar8327_chip;
 extern const struct ar8xxx_chip ar8337_chip;
 
-#define MIB_DESC(_s , _o, _n)  \
-       {                       \
-               .size = (_s),   \
-               .offset = (_o), \
-               .name = (_n),   \
+#define MIB_DESC_BASIC(_s , _o, _n)            \
+       {                                       \
+               .size = (_s),                   \
+               .offset = (_o),                 \
+               .name = (_n),                   \
+               .type = AR8XXX_MIB_BASIC,       \
+       }
+
+#define MIB_DESC_EXT(_s , _o, _n)              \
+       {                                       \
+               .size = (_s),                   \
+               .offset = (_o),                 \
+               .name = (_n),                   \
+               .type = AR8XXX_MIB_EXTENDED,    \
        }
 
 static const struct ar8xxx_mib_desc ar8216_mibs[] = {
-       MIB_DESC(1, AR8216_STATS_RXBROAD, "RxBroad"),
-       MIB_DESC(1, AR8216_STATS_RXPAUSE, "RxPause"),
-       MIB_DESC(1, AR8216_STATS_RXMULTI, "RxMulti"),
-       MIB_DESC(1, AR8216_STATS_RXFCSERR, "RxFcsErr"),
-       MIB_DESC(1, AR8216_STATS_RXALIGNERR, "RxAlignErr"),
-       MIB_DESC(1, AR8216_STATS_RXRUNT, "RxRunt"),
-       MIB_DESC(1, AR8216_STATS_RXFRAGMENT, "RxFragment"),
-       MIB_DESC(1, AR8216_STATS_RX64BYTE, "Rx64Byte"),
-       MIB_DESC(1, AR8216_STATS_RX128BYTE, "Rx128Byte"),
-       MIB_DESC(1, AR8216_STATS_RX256BYTE, "Rx256Byte"),
-       MIB_DESC(1, AR8216_STATS_RX512BYTE, "Rx512Byte"),
-       MIB_DESC(1, AR8216_STATS_RX1024BYTE, "Rx1024Byte"),
-       MIB_DESC(1, AR8216_STATS_RXMAXBYTE, "RxMaxByte"),
-       MIB_DESC(1, AR8216_STATS_RXTOOLONG, "RxTooLong"),
-       MIB_DESC(2, AR8216_STATS_RXGOODBYTE, "RxGoodByte"),
-       MIB_DESC(2, AR8216_STATS_RXBADBYTE, "RxBadByte"),
-       MIB_DESC(1, AR8216_STATS_RXOVERFLOW, "RxOverFlow"),
-       MIB_DESC(1, AR8216_STATS_FILTERED, "Filtered"),
-       MIB_DESC(1, AR8216_STATS_TXBROAD, "TxBroad"),
-       MIB_DESC(1, AR8216_STATS_TXPAUSE, "TxPause"),
-       MIB_DESC(1, AR8216_STATS_TXMULTI, "TxMulti"),
-       MIB_DESC(1, AR8216_STATS_TXUNDERRUN, "TxUnderRun"),
-       MIB_DESC(1, AR8216_STATS_TX64BYTE, "Tx64Byte"),
-       MIB_DESC(1, AR8216_STATS_TX128BYTE, "Tx128Byte"),
-       MIB_DESC(1, AR8216_STATS_TX256BYTE, "Tx256Byte"),
-       MIB_DESC(1, AR8216_STATS_TX512BYTE, "Tx512Byte"),
-       MIB_DESC(1, AR8216_STATS_TX1024BYTE, "Tx1024Byte"),
-       MIB_DESC(1, AR8216_STATS_TXMAXBYTE, "TxMaxByte"),
-       MIB_DESC(1, AR8216_STATS_TXOVERSIZE, "TxOverSize"),
-       MIB_DESC(2, AR8216_STATS_TXBYTE, "TxByte"),
-       MIB_DESC(1, AR8216_STATS_TXCOLLISION, "TxCollision"),
-       MIB_DESC(1, AR8216_STATS_TXABORTCOL, "TxAbortCol"),
-       MIB_DESC(1, AR8216_STATS_TXMULTICOL, "TxMultiCol"),
-       MIB_DESC(1, AR8216_STATS_TXSINGLECOL, "TxSingleCol"),
-       MIB_DESC(1, AR8216_STATS_TXEXCDEFER, "TxExcDefer"),
-       MIB_DESC(1, AR8216_STATS_TXDEFER, "TxDefer"),
-       MIB_DESC(1, AR8216_STATS_TXLATECOL, "TxLateCol"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXBROAD, "RxBroad"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXPAUSE, "RxPause"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXMULTI, "RxMulti"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXFCSERR, "RxFcsErr"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXALIGNERR, "RxAlignErr"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXRUNT, "RxRunt"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXFRAGMENT, "RxFragment"),
+       MIB_DESC_EXT(1, AR8216_STATS_RX64BYTE, "Rx64Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RX128BYTE, "Rx128Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RX256BYTE, "Rx256Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RX512BYTE, "Rx512Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RX1024BYTE, "Rx1024Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXMAXBYTE, "RxMaxByte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXTOOLONG, "RxTooLong"),
+       MIB_DESC_BASIC(2, AR8216_STATS_RXGOODBYTE, "RxGoodByte"),
+       MIB_DESC_EXT(2, AR8216_STATS_RXBADBYTE, "RxBadByte"),
+       MIB_DESC_EXT(1, AR8216_STATS_RXOVERFLOW, "RxOverFlow"),
+       MIB_DESC_EXT(1, AR8216_STATS_FILTERED, "Filtered"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXBROAD, "TxBroad"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXPAUSE, "TxPause"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXMULTI, "TxMulti"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXUNDERRUN, "TxUnderRun"),
+       MIB_DESC_EXT(1, AR8216_STATS_TX64BYTE, "Tx64Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TX128BYTE, "Tx128Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TX256BYTE, "Tx256Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TX512BYTE, "Tx512Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TX1024BYTE, "Tx1024Byte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXMAXBYTE, "TxMaxByte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXOVERSIZE, "TxOverSize"),
+       MIB_DESC_BASIC(2, AR8216_STATS_TXBYTE, "TxByte"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXCOLLISION, "TxCollision"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXABORTCOL, "TxAbortCol"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXMULTICOL, "TxMultiCol"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXSINGLECOL, "TxSingleCol"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXEXCDEFER, "TxExcDefer"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXDEFER, "TxDefer"),
+       MIB_DESC_EXT(1, AR8216_STATS_TXLATECOL, "TxLateCol"),
 };
 
 const struct ar8xxx_mib_desc ar8236_mibs[39] = {
-       MIB_DESC(1, AR8236_STATS_RXBROAD, "RxBroad"),
-       MIB_DESC(1, AR8236_STATS_RXPAUSE, "RxPause"),
-       MIB_DESC(1, AR8236_STATS_RXMULTI, "RxMulti"),
-       MIB_DESC(1, AR8236_STATS_RXFCSERR, "RxFcsErr"),
-       MIB_DESC(1, AR8236_STATS_RXALIGNERR, "RxAlignErr"),
-       MIB_DESC(1, AR8236_STATS_RXRUNT, "RxRunt"),
-       MIB_DESC(1, AR8236_STATS_RXFRAGMENT, "RxFragment"),
-       MIB_DESC(1, AR8236_STATS_RX64BYTE, "Rx64Byte"),
-       MIB_DESC(1, AR8236_STATS_RX128BYTE, "Rx128Byte"),
-       MIB_DESC(1, AR8236_STATS_RX256BYTE, "Rx256Byte"),
-       MIB_DESC(1, AR8236_STATS_RX512BYTE, "Rx512Byte"),
-       MIB_DESC(1, AR8236_STATS_RX1024BYTE, "Rx1024Byte"),
-       MIB_DESC(1, AR8236_STATS_RX1518BYTE, "Rx1518Byte"),
-       MIB_DESC(1, AR8236_STATS_RXMAXBYTE, "RxMaxByte"),
-       MIB_DESC(1, AR8236_STATS_RXTOOLONG, "RxTooLong"),
-       MIB_DESC(2, AR8236_STATS_RXGOODBYTE, "RxGoodByte"),
-       MIB_DESC(2, AR8236_STATS_RXBADBYTE, "RxBadByte"),
-       MIB_DESC(1, AR8236_STATS_RXOVERFLOW, "RxOverFlow"),
-       MIB_DESC(1, AR8236_STATS_FILTERED, "Filtered"),
-       MIB_DESC(1, AR8236_STATS_TXBROAD, "TxBroad"),
-       MIB_DESC(1, AR8236_STATS_TXPAUSE, "TxPause"),
-       MIB_DESC(1, AR8236_STATS_TXMULTI, "TxMulti"),
-       MIB_DESC(1, AR8236_STATS_TXUNDERRUN, "TxUnderRun"),
-       MIB_DESC(1, AR8236_STATS_TX64BYTE, "Tx64Byte"),
-       MIB_DESC(1, AR8236_STATS_TX128BYTE, "Tx128Byte"),
-       MIB_DESC(1, AR8236_STATS_TX256BYTE, "Tx256Byte"),
-       MIB_DESC(1, AR8236_STATS_TX512BYTE, "Tx512Byte"),
-       MIB_DESC(1, AR8236_STATS_TX1024BYTE, "Tx1024Byte"),
-       MIB_DESC(1, AR8236_STATS_TX1518BYTE, "Tx1518Byte"),
-       MIB_DESC(1, AR8236_STATS_TXMAXBYTE, "TxMaxByte"),
-       MIB_DESC(1, AR8236_STATS_TXOVERSIZE, "TxOverSize"),
-       MIB_DESC(2, AR8236_STATS_TXBYTE, "TxByte"),
-       MIB_DESC(1, AR8236_STATS_TXCOLLISION, "TxCollision"),
-       MIB_DESC(1, AR8236_STATS_TXABORTCOL, "TxAbortCol"),
-       MIB_DESC(1, AR8236_STATS_TXMULTICOL, "TxMultiCol"),
-       MIB_DESC(1, AR8236_STATS_TXSINGLECOL, "TxSingleCol"),
-       MIB_DESC(1, AR8236_STATS_TXEXCDEFER, "TxExcDefer"),
-       MIB_DESC(1, AR8236_STATS_TXDEFER, "TxDefer"),
-       MIB_DESC(1, AR8236_STATS_TXLATECOL, "TxLateCol"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXBROAD, "RxBroad"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXPAUSE, "RxPause"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXMULTI, "RxMulti"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXFCSERR, "RxFcsErr"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXALIGNERR, "RxAlignErr"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXRUNT, "RxRunt"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXFRAGMENT, "RxFragment"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX64BYTE, "Rx64Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX128BYTE, "Rx128Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX256BYTE, "Rx256Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX512BYTE, "Rx512Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX1024BYTE, "Rx1024Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RX1518BYTE, "Rx1518Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXMAXBYTE, "RxMaxByte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXTOOLONG, "RxTooLong"),
+       MIB_DESC_BASIC(2, AR8236_STATS_RXGOODBYTE, "RxGoodByte"),
+       MIB_DESC_EXT(2, AR8236_STATS_RXBADBYTE, "RxBadByte"),
+       MIB_DESC_EXT(1, AR8236_STATS_RXOVERFLOW, "RxOverFlow"),
+       MIB_DESC_EXT(1, AR8236_STATS_FILTERED, "Filtered"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXBROAD, "TxBroad"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXPAUSE, "TxPause"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXMULTI, "TxMulti"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXUNDERRUN, "TxUnderRun"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX64BYTE, "Tx64Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX128BYTE, "Tx128Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX256BYTE, "Tx256Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX512BYTE, "Tx512Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX1024BYTE, "Tx1024Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TX1518BYTE, "Tx1518Byte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXMAXBYTE, "TxMaxByte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXOVERSIZE, "TxOverSize"),
+       MIB_DESC_BASIC(2, AR8236_STATS_TXBYTE, "TxByte"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXCOLLISION, "TxCollision"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXABORTCOL, "TxAbortCol"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXMULTICOL, "TxMultiCol"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXSINGLECOL, "TxSingleCol"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXEXCDEFER, "TxExcDefer"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXDEFER, "TxDefer"),
+       MIB_DESC_EXT(1, AR8236_STATS_TXLATECOL, "TxLateCol"),
 };
 
 static DEFINE_MUTEX(ar8xxx_dev_list_lock);
@@ -431,6 +440,8 @@ ar8xxx_mib_fetch_port_stat(struct ar8xxx_priv *priv, int port, bool flush)
                u64 t;
 
                mib = &priv->chip->mib_decs[i];
+               if (mib->type > priv->mib_type)
+                       continue;
                t = ar8xxx_read(priv, base + mib->offset);
                if (mib->size == 2) {
                        u64 hi;
@@ -1477,6 +1488,32 @@ ar8xxx_sw_get_mib_poll_interval(struct switch_dev *dev,
        return 0;
 }
 
+int
+ar8xxx_sw_set_mib_type(struct switch_dev *dev,
+                              const struct switch_attr *attr,
+                              struct switch_val *val)
+{
+       struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev);
+
+       if (!ar8xxx_has_mib_counters(priv))
+               return -EOPNOTSUPP;
+       priv->mib_type = val->value.i;
+       return 0;
+}
+
+int
+ar8xxx_sw_get_mib_type(struct switch_dev *dev,
+                              const struct switch_attr *attr,
+                              struct switch_val *val)
+{
+       struct ar8xxx_priv *priv = swdev_to_ar8xxx(dev);
+
+       if (!ar8xxx_has_mib_counters(priv))
+               return -EOPNOTSUPP;
+       val->value.i = priv->mib_type;
+       return 0;
+}
+
 int
 ar8xxx_sw_set_mirror_rx_enable(struct switch_dev *dev,
                               const struct switch_attr *attr,
@@ -1667,6 +1704,8 @@ ar8xxx_sw_get_port_mib(struct switch_dev *dev,
 
        mib_stats = &priv->mib_stats[port * chip->num_mibs];
        for (i = 0; i < chip->num_mibs; i++) {
+               if (chip->mib_decs[i].type > priv->mib_type)
+                       continue;
                mib_name = chip->mib_decs[i].name;
                mib_data = mib_stats[i];
                len += snprintf(buf + len, sizeof(priv->buf) - len,
@@ -1897,6 +1936,13 @@ static const struct switch_attr ar8xxx_sw_attr_globals[] = {
                .set = ar8xxx_sw_set_mib_poll_interval,
                .get = ar8xxx_sw_get_mib_poll_interval
        },
+       {
+               .type = SWITCH_TYPE_INT,
+               .name = "ar8xxx_mib_type",
+               .description = "MIB type (0=basic 1=extended)",
+               .set = ar8xxx_sw_set_mib_type,
+               .get = ar8xxx_sw_get_mib_type
+       },
        {
                .type = SWITCH_TYPE_INT,
                .name = "enable_mirror_rx",
index 8f77c91..93170d5 100644 (file)
@@ -389,6 +389,12 @@ enum {
        AR8216_PORT_STATE_FORWARD = 4
 };
 
+/* mib counter type */
+enum {
+       AR8XXX_MIB_BASIC = 0,
+       AR8XXX_MIB_EXTENDED = 1
+};
+
 enum {
        AR8XXX_VER_AR8216 = 0x01,
        AR8XXX_VER_AR8236 = 0x03,
@@ -415,6 +421,7 @@ struct ar8xxx_mib_desc {
        unsigned int size;
        unsigned int offset;
        const char *name;
+       u8 type;
 };
 
 struct ar8xxx_chip {
@@ -490,6 +497,7 @@ struct ar8xxx_priv {
        struct delayed_work mib_work;
        u64 *mib_stats;
        u32 mib_poll_interval;
+       u8 mib_type;
 
        struct list_head list;
        unsigned int use_count;
@@ -552,6 +560,14 @@ ar8xxx_sw_get_mib_poll_interval(struct switch_dev *dev,
                               const struct switch_attr *attr,
                               struct switch_val *val);
 int
+ar8xxx_sw_set_mib_type(struct switch_dev *dev,
+                              const struct switch_attr *attr,
+                              struct switch_val *val);
+int
+ar8xxx_sw_get_mib_type(struct switch_dev *dev,
+                              const struct switch_attr *attr,
+                              struct switch_val *val);
+int
 ar8xxx_sw_set_mirror_rx_enable(struct switch_dev *dev,
                               const struct switch_attr *attr,
                               struct switch_val *val);
index c296416..1878585 100644 (file)
@@ -1328,6 +1328,13 @@ static const struct switch_attr ar8327_sw_attr_globals[] = {
                .set = ar8xxx_sw_set_mib_poll_interval,
                .get = ar8xxx_sw_get_mib_poll_interval
        },
+       {
+               .type = SWITCH_TYPE_INT,
+               .name = "ar8xxx_mib_type",
+               .description = "MIB type (0=basic 1=extended)",
+               .set = ar8xxx_sw_set_mib_type,
+               .get = ar8xxx_sw_get_mib_type
+       },
        {
                .type = SWITCH_TYPE_INT,
                .name = "enable_mirror_rx",