Changeset 34243


Ignore:
Timestamp:
2012-11-18T13:26:35+01:00 (5 years ago)
Author:
juhosg
Message:

generic ar8216: allow to read/reset MIB counters via swconfig

Signed-off-by: Gabor Juhos <juhosg@…>

Location:
trunk/target/linux/generic/files/drivers/net/phy
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/files/drivers/net/phy/ar8216.c

    r34242 r34243  
    3333#include <linux/lockdep.h> 
    3434#include <linux/ar8216_platform.h> 
     35#include <linux/workqueue.h> 
    3536#include "ar8216.h" 
    3637 
     
    4041#define AR8X16_MAX_PORTS        8 
    4142 
     43#define AR8XXX_MIB_WORK_DELAY   2000 /* msecs */ 
     44 
    4245struct ar8216_priv; 
    4346 
    44 #define AR8XXX_CAP_GIGE         BIT(0) 
     47#define AR8XXX_CAP_GIGE                 BIT(0) 
     48#define AR8XXX_CAP_MIB_COUNTERS         BIT(1) 
    4549 
    4650enum { 
     
    4953        AR8XXX_VER_AR8316 = 0x10, 
    5054        AR8XXX_VER_AR8327 = 0x12, 
     55}; 
     56 
     57struct ar8xxx_mib_desc { 
     58        unsigned int size; 
     59        unsigned int offset; 
     60        const char *name; 
    5161}; 
    5262 
     
    6373        void (*vtu_flush)(struct ar8216_priv *priv); 
    6474        void (*vtu_load_vlan)(struct ar8216_priv *priv, u32 vid, u32 port_mask); 
     75 
     76        const struct ar8xxx_mib_desc *mib_decs; 
     77        unsigned num_mibs; 
    6578}; 
    6679 
     
    7891        bool initialized; 
    7992        bool port4_phy; 
    80         char buf[80]; 
     93        char buf[2048]; 
    8194 
    8295        bool init; 
    8396        bool mii_lo_first; 
     97 
     98        struct mutex mib_lock; 
     99        struct delayed_work mib_work; 
     100        int mib_next_port; 
     101        u64 *mib_stats; 
    84102 
    85103        /* all fields below are cleared on reset */ 
     
    91109}; 
    92110 
     111#define MIB_DESC(_s , _o, _n)   \ 
     112        {                       \ 
     113                .size = (_s),   \ 
     114                .offset = (_o), \ 
     115                .name = (_n),   \ 
     116        } 
     117 
     118static const struct ar8xxx_mib_desc ar8236_mibs[] = { 
     119        MIB_DESC(1, AR8216_STATS_RXBROAD, "RxBroad"), 
     120        MIB_DESC(1, AR8216_STATS_RXPAUSE, "RxPause"), 
     121        MIB_DESC(1, AR8216_STATS_RXMULTI, "RxMulti"), 
     122        MIB_DESC(1, AR8216_STATS_RXFCSERR, "RxFcsErr"), 
     123        MIB_DESC(1, AR8216_STATS_RXALIGNERR, "RxAlignErr"), 
     124        MIB_DESC(1, AR8216_STATS_RXRUNT, "RxRunt"), 
     125        MIB_DESC(1, AR8216_STATS_RXFRAGMENT, "RxFragment"), 
     126        MIB_DESC(1, AR8216_STATS_RX64BYTE, "Rx64Byte"), 
     127        MIB_DESC(1, AR8216_STATS_RX128BYTE, "Rx128Byte"), 
     128        MIB_DESC(1, AR8216_STATS_RX256BYTE, "Rx256Byte"), 
     129        MIB_DESC(1, AR8216_STATS_RX512BYTE, "Rx512Byte"), 
     130        MIB_DESC(1, AR8216_STATS_RX1024BYTE, "Rx1024Byte"), 
     131        MIB_DESC(1, AR8216_STATS_RX1518BYTE, "Rx1518Byte"), 
     132        MIB_DESC(1, AR8216_STATS_RXMAXBYTE, "RxMaxByte"), 
     133        MIB_DESC(1, AR8216_STATS_RXTOOLONG, "RxTooLong"), 
     134        MIB_DESC(2, AR8216_STATS_RXGOODBYTE, "RxGoodByte"), 
     135        MIB_DESC(2, AR8216_STATS_RXBADBYTE, "RxBadByte"), 
     136        MIB_DESC(1, AR8216_STATS_RXOVERFLOW, "RxOverFlow"), 
     137        MIB_DESC(1, AR8216_STATS_FILTERED, "Filtered"), 
     138        MIB_DESC(1, AR8216_STATS_TXBROAD, "TxBroad"), 
     139        MIB_DESC(1, AR8216_STATS_TXPAUSE, "TxPause"), 
     140        MIB_DESC(1, AR8216_STATS_TXMULTI, "TxMulti"), 
     141        MIB_DESC(1, AR8216_STATS_TXUNDERRUN, "TxUnderRun"), 
     142        MIB_DESC(1, AR8216_STATS_TX64BYTE, "Tx64Byte"), 
     143        MIB_DESC(1, AR8216_STATS_TX128BYTE, "Tx128Byte"), 
     144        MIB_DESC(1, AR8216_STATS_TX256BYTE, "Tx256Byte"), 
     145        MIB_DESC(1, AR8216_STATS_TX512BYTE, "Tx512Byte"), 
     146        MIB_DESC(1, AR8216_STATS_TX1024BYTE, "Tx1024Byte"), 
     147        MIB_DESC(1, AR8216_STATS_TX1518BYTE, "Tx1518Byte"), 
     148        MIB_DESC(1, AR8216_STATS_TXMAXBYTE, "TxMaxByte"), 
     149        MIB_DESC(1, AR8216_STATS_TXOVERSIZE, "TxOverSize"), 
     150        MIB_DESC(2, AR8216_STATS_TXBYTE, "TxByte"), 
     151        MIB_DESC(1, AR8216_STATS_TXCOLLISION, "TxCollision"), 
     152        MIB_DESC(1, AR8216_STATS_TXABORTCOL, "TxAbortCol"), 
     153        MIB_DESC(1, AR8216_STATS_TXMULTICOL, "TxMultiCol"), 
     154        MIB_DESC(1, AR8216_STATS_TXSINGLECOL, "TxSingleCol"), 
     155        MIB_DESC(1, AR8216_STATS_TXEXCDEFER, "TxExcDefer"), 
     156        MIB_DESC(1, AR8216_STATS_TXDEFER, "TxDefer"), 
     157        MIB_DESC(1, AR8216_STATS_TXLATECOL, "TxLateCol"), 
     158}; 
     159 
    93160#define to_ar8216(_dev) container_of(_dev, struct ar8216_priv, dev) 
    94161 
     
    96163{ 
    97164        return priv->chip->caps & AR8XXX_CAP_GIGE; 
     165} 
     166 
     167static inline bool ar8xxx_has_mib_counters(struct ar8216_priv *priv) 
     168{ 
     169        return priv->chip->caps & AR8XXX_CAP_MIB_COUNTERS; 
    98170} 
    99171 
     
    216288 
    217289        return v; 
     290} 
     291 
     292static inline void 
     293ar8216_reg_set(struct ar8216_priv *priv, int reg, u32 val) 
     294{ 
     295        u32 v; 
     296 
     297        lockdep_assert_held(&priv->reg_mutex); 
     298 
     299        v = priv->read(priv, reg); 
     300        v |= val; 
     301        priv->write(priv, reg, v); 
     302} 
     303 
     304static int 
     305ar8216_reg_wait(struct ar8216_priv *priv, u32 reg, u32 mask, u32 val, 
     306                unsigned timeout) 
     307{ 
     308        int i; 
     309 
     310        for (i = 0; i < timeout; i++) { 
     311                u32 t; 
     312 
     313                t = priv->read(priv, reg); 
     314                if ((t & mask) == val) 
     315                        return 0; 
     316 
     317                usleep_range(1000, 2000); 
     318        } 
     319 
     320        return -ETIMEDOUT; 
     321} 
     322 
     323static int 
     324ar8216_mib_capture(struct ar8216_priv *priv) 
     325{ 
     326        unsigned mib_func; 
     327        int ret; 
     328 
     329        lockdep_assert_held(&priv->mib_lock); 
     330 
     331        if (chip_is_ar8327(priv)) 
     332                mib_func = AR8327_REG_MIB_FUNC; 
     333        else 
     334                mib_func = AR8216_REG_MIB_FUNC; 
     335 
     336        /* Capture the hardware statistics for all ports */ 
     337        ar8216_rmw(priv, mib_func, AR8216_MIB_FUNC, 
     338                   (AR8216_MIB_FUNC_CAPTURE << AR8216_MIB_FUNC_S)); 
     339 
     340        /* Wait for the capturing to complete. */ 
     341        ret = ar8216_reg_wait(priv, mib_func, AR8216_MIB_BUSY, 0, 10); 
     342        if (ret) 
     343                goto out; 
     344 
     345        ret = 0; 
     346 
     347out: 
     348        return ret; 
     349} 
     350 
     351static int 
     352ar8216_mib_flush(struct ar8216_priv *priv) 
     353{ 
     354        unsigned mib_func; 
     355        int ret; 
     356 
     357        lockdep_assert_held(&priv->mib_lock); 
     358 
     359        if (chip_is_ar8327(priv)) 
     360                mib_func = AR8327_REG_MIB_FUNC; 
     361        else 
     362                mib_func = AR8216_REG_MIB_FUNC; 
     363 
     364        /* Flush hardware statistics for all ports */ 
     365        ar8216_rmw(priv, mib_func, AR8216_MIB_FUNC, 
     366                   (AR8216_MIB_FUNC_FLUSH << AR8216_MIB_FUNC_S)); 
     367 
     368        /* Wait for the capturing to complete. */ 
     369        ret = ar8216_reg_wait(priv, mib_func, AR8216_MIB_BUSY, 0, 10); 
     370        if (ret) 
     371                goto out; 
     372 
     373        ret = 0; 
     374 
     375out: 
     376        return ret; 
     377} 
     378 
     379static void 
     380ar8216_mib_fetch_port_stat(struct ar8216_priv *priv, int port, bool flush) 
     381{ 
     382        unsigned int base; 
     383        u64 *mib_stats; 
     384        int i; 
     385 
     386        lockdep_assert_held(&priv->mib_lock); 
     387 
     388        if (chip_is_ar8327(priv)) 
     389                base = AR8327_REG_PORT_STATS_BASE(port); 
     390        else 
     391                base = AR8216_REG_PORT_STATS_BASE(port); 
     392 
     393        mib_stats = &priv->mib_stats[port * priv->chip->num_mibs]; 
     394        for (i = 0; i < priv->chip->num_mibs; i++) { 
     395                const struct ar8xxx_mib_desc *mib; 
     396                u64 t; 
     397 
     398                mib = &priv->chip->mib_decs[i]; 
     399                t = priv->read(priv, base + mib->offset); 
     400                if (mib->size == 2) { 
     401                        u64 hi; 
     402 
     403                        hi = priv->read(priv, base + mib->offset + 4); 
     404                        t |= hi << 32; 
     405                } 
     406 
     407                if (flush) 
     408                        mib_stats[i] = 0; 
     409                else 
     410                        mib_stats[i] += t; 
     411        } 
    218412} 
    219413 
     
    528722        ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL, 
    529723                   AR8316_GCTRL_MTU, 9018 + 8 + 2); 
     724 
     725        /* Enable MIB counters */ 
     726        ar8216_rmw(priv, AR8216_REG_MIB_FUNC, AR8216_MIB_FUNC | AR8236_MIB_EN, 
     727                   (AR8216_MIB_FUNC_NO_OP << AR8216_MIB_FUNC_S) | 
     728                   AR8236_MIB_EN); 
    530729} 
    531730 
    532731static const struct ar8xxx_chip ar8236_chip = { 
     732        .caps = AR8XXX_CAP_MIB_COUNTERS, 
    533733        .hw_init = ar8236_hw_init, 
    534734        .init_globals = ar8236_init_globals, 
     
    539739        .vtu_flush = ar8216_vtu_flush, 
    540740        .vtu_load_vlan = ar8216_vtu_load_vlan, 
     741 
     742        .num_mibs = ARRAY_SIZE(ar8236_mibs), 
     743        .mib_decs = ar8236_mibs, 
    541744}; 
    542745 
     
    613816        ar8216_rmw(priv, AR8216_REG_GLOBAL_CTRL, 
    614817                   AR8316_GCTRL_MTU, 9018 + 8 + 2); 
     818 
     819        /* Enable MIB counters */ 
     820        ar8216_rmw(priv, AR8216_REG_MIB_FUNC, AR8216_MIB_FUNC | AR8236_MIB_EN, 
     821                   (AR8216_MIB_FUNC_NO_OP << AR8216_MIB_FUNC_S) | 
     822                   AR8236_MIB_EN); 
    615823} 
    616824 
    617825static const struct ar8xxx_chip ar8316_chip = { 
    618         .caps = AR8XXX_CAP_GIGE, 
     826        .caps = AR8XXX_CAP_GIGE | AR8XXX_CAP_MIB_COUNTERS, 
    619827        .hw_init = ar8316_hw_init, 
    620828        .init_globals = ar8316_init_globals, 
     
    625833        .vtu_flush = ar8216_vtu_flush, 
    626834        .vtu_load_vlan = ar8216_vtu_load_vlan, 
     835 
     836        .num_mibs = ARRAY_SIZE(ar8236_mibs), 
     837        .mib_decs = ar8236_mibs, 
    627838}; 
    628839 
     
    8081019        ar8216_rmw(priv, AR8327_REG_MAX_FRAME_SIZE, 
    8091020                   AR8327_MAX_FRAME_SIZE_MTU, 1518 + 8 + 2); 
     1021 
     1022        /* Enable MIB counters */ 
     1023        ar8216_reg_set(priv, AR8327_REG_MODULE_EN, 
     1024                       AR8327_MODULE_EN_MIB); 
    8101025} 
    8111026 
     
    9731188 
    9741189static const struct ar8xxx_chip ar8327_chip = { 
    975         .caps = AR8XXX_CAP_GIGE, 
     1190        .caps = AR8XXX_CAP_GIGE | AR8XXX_CAP_MIB_COUNTERS, 
    9761191        .hw_init = ar8327_hw_init, 
    9771192        .init_globals = ar8327_init_globals, 
     
    9821197        .vtu_flush = ar8327_vtu_flush, 
    9831198        .vtu_load_vlan = ar8327_vtu_load_vlan, 
     1199 
     1200        .num_mibs = ARRAY_SIZE(ar8236_mibs), 
     1201        .mib_decs = ar8236_mibs, 
    9841202}; 
    9851203 
     
    11981416} 
    11991417 
     1418static int 
     1419ar8216_sw_set_reset_mibs(struct switch_dev *dev, 
     1420                         const struct switch_attr *attr, 
     1421                         struct switch_val *val) 
     1422{ 
     1423        struct ar8216_priv *priv = to_ar8216(dev); 
     1424        unsigned int len; 
     1425        int ret; 
     1426 
     1427        if (!ar8xxx_has_mib_counters(priv)) 
     1428                return -EOPNOTSUPP; 
     1429 
     1430        mutex_lock(&priv->mib_lock); 
     1431 
     1432        len = priv->dev.ports * priv->chip->num_mibs * 
     1433              sizeof(*priv->mib_stats); 
     1434        memset(priv->mib_stats, '\0', len); 
     1435        ret = ar8216_mib_flush(priv); 
     1436        if (ret) 
     1437                goto unlock; 
     1438 
     1439        ret = 0; 
     1440 
     1441unlock: 
     1442        mutex_unlock(&priv->mib_lock); 
     1443        return ret; 
     1444} 
     1445 
     1446static int 
     1447ar8216_sw_set_port_reset_mib(struct switch_dev *dev, 
     1448                             const struct switch_attr *attr, 
     1449                             struct switch_val *val) 
     1450{ 
     1451        struct ar8216_priv *priv = to_ar8216(dev); 
     1452        int port; 
     1453        int ret; 
     1454 
     1455        if (!ar8xxx_has_mib_counters(priv)) 
     1456                return -EOPNOTSUPP; 
     1457 
     1458        port = val->port_vlan; 
     1459        if (port >= dev->ports) 
     1460                return -EINVAL; 
     1461 
     1462        mutex_lock(&priv->mib_lock); 
     1463        ret = ar8216_mib_capture(priv); 
     1464        if (ret) 
     1465                goto unlock; 
     1466 
     1467        ar8216_mib_fetch_port_stat(priv, port, true); 
     1468 
     1469        ret = 0; 
     1470 
     1471unlock: 
     1472        mutex_unlock(&priv->mib_lock); 
     1473        return ret; 
     1474} 
     1475 
     1476static int 
     1477ar8216_sw_get_port_mib(struct switch_dev *dev, 
     1478                       const struct switch_attr *attr, 
     1479                       struct switch_val *val) 
     1480{ 
     1481        struct ar8216_priv *priv = to_ar8216(dev); 
     1482        const struct ar8xxx_chip *chip = priv->chip; 
     1483        u64 *mib_stats; 
     1484        int port; 
     1485        int ret; 
     1486        char *buf = priv->buf; 
     1487        int i, len = 0; 
     1488 
     1489        if (!ar8xxx_has_mib_counters(priv)) 
     1490                return -EOPNOTSUPP; 
     1491 
     1492        port = val->port_vlan; 
     1493        if (port >= dev->ports) 
     1494                return -EINVAL; 
     1495 
     1496        mutex_lock(&priv->mib_lock); 
     1497        ret = ar8216_mib_capture(priv); 
     1498        if (ret) 
     1499                goto unlock; 
     1500 
     1501        ar8216_mib_fetch_port_stat(priv, port, false); 
     1502        mutex_unlock(&priv->mib_lock); 
     1503 
     1504        len += snprintf(buf + len, sizeof(priv->buf) - len, 
     1505                        "Port %d MIB counters\n", 
     1506                        port); 
     1507 
     1508        mib_stats = &priv->mib_stats[port * chip->num_mibs]; 
     1509        for (i = 0; i < chip->num_mibs; i++) 
     1510                len += snprintf(buf + len, sizeof(priv->buf) - len, 
     1511                                "%-12s: %llu\n", 
     1512                                chip->mib_decs[i].name, 
     1513                                mib_stats[i]); 
     1514 
     1515        val->value.s = buf; 
     1516        val->len = len; 
     1517 
     1518        ret = 0; 
     1519 
     1520unlock: 
     1521        mutex_unlock(&priv->mib_lock); 
     1522        return ret; 
     1523} 
     1524 
    12001525static struct switch_attr ar8216_globals[] = { 
    12011526        { 
     
    12071532                .max = 1 
    12081533        }, 
     1534        { 
     1535                .type = SWITCH_TYPE_NOVAL, 
     1536                .name = "reset_mibs", 
     1537                .description = "Reset all MIB counters", 
     1538                .set = ar8216_sw_set_reset_mibs, 
     1539        }, 
     1540 
    12091541}; 
    12101542 
    12111543static struct switch_attr ar8216_port[] = { 
     1544        { 
     1545                .type = SWITCH_TYPE_NOVAL, 
     1546                .name = "reset_mib", 
     1547                .description = "Reset single port MIB counters", 
     1548                .set = ar8216_sw_set_port_reset_mib, 
     1549        }, 
     1550        { 
     1551                .type = SWITCH_TYPE_STRING, 
     1552                .name = "mib", 
     1553                .description = "Get port's MIB counters", 
     1554                .set = NULL, 
     1555                .get = ar8216_sw_get_port_mib, 
     1556        }, 
    12121557}; 
    12131558 
     
    12991644} 
    13001645 
     1646static void 
     1647ar8xxx_mib_work_func(struct work_struct *work) 
     1648{ 
     1649        struct ar8216_priv *priv; 
     1650        int err; 
     1651 
     1652        priv = container_of(work, struct ar8216_priv, mib_work.work); 
     1653 
     1654        mutex_lock(&priv->mib_lock); 
     1655 
     1656        err = ar8216_mib_capture(priv); 
     1657        if (err) 
     1658                goto next_port; 
     1659 
     1660        ar8216_mib_fetch_port_stat(priv, priv->mib_next_port, false); 
     1661 
     1662next_port: 
     1663        priv->mib_next_port++; 
     1664        if (priv->mib_next_port > priv->dev.ports) 
     1665                priv->mib_next_port = 0; 
     1666 
     1667        mutex_unlock(&priv->mib_lock); 
     1668        schedule_delayed_work(&priv->mib_work, 
     1669                              msecs_to_jiffies(AR8XXX_MIB_WORK_DELAY)); 
     1670} 
     1671 
     1672static int 
     1673ar8xxx_mib_init(struct ar8216_priv *priv) 
     1674{ 
     1675        unsigned int len; 
     1676 
     1677        if (!ar8xxx_has_mib_counters(priv)) 
     1678                return 0; 
     1679 
     1680        BUG_ON(!priv->chip->mib_decs || !priv->chip->num_mibs); 
     1681 
     1682        len = priv->dev.ports * priv->chip->num_mibs * 
     1683              sizeof(*priv->mib_stats); 
     1684        priv->mib_stats = kzalloc(len, GFP_KERNEL); 
     1685 
     1686        if (!priv->mib_stats) 
     1687                return -ENOMEM; 
     1688 
     1689        mutex_init(&priv->mib_lock); 
     1690        INIT_DELAYED_WORK(&priv->mib_work, ar8xxx_mib_work_func); 
     1691 
     1692        return 0; 
     1693} 
     1694 
     1695static void 
     1696ar8xxx_mib_start(struct ar8216_priv *priv) 
     1697{ 
     1698        if (!ar8xxx_has_mib_counters(priv)) 
     1699                return; 
     1700 
     1701        schedule_delayed_work(&priv->mib_work, 
     1702                              msecs_to_jiffies(AR8XXX_MIB_WORK_DELAY)); 
     1703} 
     1704 
     1705static void 
     1706ar8xxx_mib_cleanup(struct ar8216_priv *priv) 
     1707{ 
     1708        if (!ar8xxx_has_mib_counters(priv)) 
     1709                return; 
     1710 
     1711        cancel_delayed_work(&priv->mib_work); 
     1712        kfree(priv->mib_stats); 
     1713} 
     1714 
    13011715static int 
    13021716ar8216_config_init(struct phy_device *pdev) 
     
    13931807        } 
    13941808 
     1809        ret = ar8xxx_mib_init(priv); 
     1810        if (ret) 
     1811                goto err_free_priv; 
     1812 
    13951813        ret = register_switch(&priv->dev, pdev->attached_dev); 
    13961814        if (ret) 
    1397                 goto err_free_priv; 
     1815                goto err_cleanup_mib; 
    13981816 
    13991817        printk(KERN_INFO "%s: %s switch driver attached.\n", 
     
    14041822        ret = priv->chip->hw_init(priv); 
    14051823        if (ret) 
    1406                 goto err_free_priv; 
     1824                goto err_cleanup_mib; 
    14071825 
    14081826        ret = ar8216_sw_reset_switch(&priv->dev); 
    14091827        if (ret) 
    1410                 goto err_free_priv; 
     1828                goto err_cleanup_mib; 
    14111829 
    14121830        dev->phy_ptr = priv; 
     
    14211839        priv->init = false; 
    14221840 
     1841        ar8xxx_mib_start(priv); 
     1842 
    14231843        return 0; 
    14241844 
     1845err_cleanup_mib: 
     1846        ar8xxx_mib_cleanup(priv); 
    14251847err_free_priv: 
    14261848        kfree(priv); 
     
    15121934        if (pdev->addr == 0) 
    15131935                unregister_switch(&priv->dev); 
     1936 
     1937        ar8xxx_mib_cleanup(priv); 
    15141938        kfree(priv); 
    15151939} 
  • trunk/target/linux/generic/files/drivers/net/phy/ar8216.h

    r32456 r34243  
    9595#define   AR8216_ATU_CTRL_AGE_TIME_S    0 
    9696 
     97#define AR8216_REG_MIB_FUNC             0x0080 
     98#define   AR8216_MIB_TIMER              BITS(0, 16) 
     99#define   AR8216_MIB_AT_HALF_EN         BIT(16) 
     100#define   AR8216_MIB_BUSY               BIT(17) 
     101#define   AR8216_MIB_FUNC               BITS(24, 3) 
     102#define   AR8216_MIB_FUNC_S             24 
     103#define   AR8216_MIB_FUNC_NO_OP         0x0 
     104#define   AR8216_MIB_FUNC_FLUSH         0x1 
     105#define   AR8216_MIB_FUNC_CAPTURE       0x3 
     106#define   AR8236_MIB_EN                 BIT(30) 
     107 
    97108#define AR8216_PORT_OFFSET(_i)          (0x0100 * (_i + 1)) 
    98109#define AR8216_REG_PORT_STATUS(_i)      (AR8216_PORT_OFFSET(_i) + 0x0000) 
     
    150161#define AR8216_REG_PORT_PRIO(_i)        (AR8216_PORT_OFFSET(_i) + 0x0010) 
    151162 
     163#define AR8216_REG_PORT_STATS_BASE(_i)  (0x20000 + (_i) * 0x100) 
     164 
     165#define AR8216_STATS_RXBROAD            0x00 
     166#define AR8216_STATS_RXPAUSE            0x04 
     167#define AR8216_STATS_RXMULTI            0x08 
     168#define AR8216_STATS_RXFCSERR           0x0c 
     169#define AR8216_STATS_RXALIGNERR         0x10 
     170#define AR8216_STATS_RXRUNT             0x14 
     171#define AR8216_STATS_RXFRAGMENT         0x18 
     172#define AR8216_STATS_RX64BYTE           0x1c 
     173#define AR8216_STATS_RX128BYTE          0x20 
     174#define AR8216_STATS_RX256BYTE          0x24 
     175#define AR8216_STATS_RX512BYTE          0x28 
     176#define AR8216_STATS_RX1024BYTE         0x2c 
     177#define AR8216_STATS_RX1518BYTE         0x30 
     178#define AR8216_STATS_RXMAXBYTE          0x34 
     179#define AR8216_STATS_RXTOOLONG          0x38 
     180#define AR8216_STATS_RXGOODBYTE         0x3c 
     181#define AR8216_STATS_RXBADBYTE          0x44 
     182#define AR8216_STATS_RXOVERFLOW         0x4c 
     183#define AR8216_STATS_FILTERED           0x50 
     184#define AR8216_STATS_TXBROAD            0x54 
     185#define AR8216_STATS_TXPAUSE            0x58 
     186#define AR8216_STATS_TXMULTI            0x5c 
     187#define AR8216_STATS_TXUNDERRUN         0x60 
     188#define AR8216_STATS_TX64BYTE           0x64 
     189#define AR8216_STATS_TX128BYTE          0x68 
     190#define AR8216_STATS_TX256BYTE          0x6c 
     191#define AR8216_STATS_TX512BYTE          0x70 
     192#define AR8216_STATS_TX1024BYTE         0x74 
     193#define AR8216_STATS_TX1518BYTE         0x78 
     194#define AR8216_STATS_TXMAXBYTE          0x7c 
     195#define AR8216_STATS_TXOVERSIZE         0x80 
     196#define AR8216_STATS_TXBYTE             0x84 
     197#define AR8216_STATS_TXCOLLISION        0x8c 
     198#define AR8216_STATS_TXABORTCOL         0x90 
     199#define AR8216_STATS_TXMULTICOL         0x94 
     200#define AR8216_STATS_TXSINGLECOL        0x98 
     201#define AR8216_STATS_TXEXCDEFER         0x9c 
     202#define AR8216_STATS_TXDEFER            0xa0 
     203#define AR8216_STATS_TXLATECOL          0xa4 
    152204 
    153205#define AR8236_REG_PORT_VLAN(_i)        (AR8216_PORT_OFFSET((_i)) + 0x0008) 
     
    208260#define AR8327_REG_INT_MASK0                    0x028 
    209261#define AR8327_REG_INT_MASK1                    0x02c 
     262 
     263#define AR8327_REG_MODULE_EN                    0x030 
     264#define   AR8327_MODULE_EN_MIB                  BIT(0) 
     265 
     266#define AR8327_REG_MIB_FUNC                     0x034 
     267#define   AR8327_MIB_CPU_KEEP                   BIT(20) 
     268 
    210269#define AR8327_REG_SERVICE_TAG                  0x048 
    211270#define AR8327_REG_LED_CTRL0                    0x050 
     
    307366#define AR8327_REG_PORT_PRIO(_i)                (0x664 + (_i) * 0xc) 
    308367 
     368#define AR8327_REG_PORT_STATS_BASE(_i)          (0x1000 + (_i) * 0x100) 
     369 
    309370/* port speed */ 
    310371enum { 
Note: See TracChangeset for help on using the changeset viewer.