/home/tgr/dev/libnl/lib/route/ethtool.c

/*
 * lib/route/ethtool.c          Ethtool (link)
 *
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation version 2.1
 *      of the License.
 *
 * Copyright (c) 2010-2011 Thomas Graf <tgraf@suug.ch>
 */

/**
 * @ingroup link
 * @defgroup ethtool Ethtool
 * @{
 */

#include <netlink-local.h>
#include <netlink/netlink.h>
#include <netlink/attr.h>
#include <netlink/utils.h>
#include <netlink/object.h>
#include <netlink/route/rtnl.h>
#include <netlink/route/link.h>
#include <netlink/route/ethtool.h>
#include <netlink/route/link/api.h>

/** @cond SKIP */
#define ETHTOOL_ATTR_SETTINGS   0x0001
#define ETHTOOL_ATTR_DRVINFO    0x0002
/** @endcond */

static int settings_parse(struct rtnl_link *link, struct nlattr *attr)
{
        nla_memcpy(&link->l_ethtool.e_settings, attr, sizeof(struct ethtool_cmd));
        link->l_ethtool.e_mask |= ETHTOOL_ATTR_SETTINGS;
        return 0;
}

static struct {
        int (*parse)(struct rtnl_link *, struct nlattr *);
} ethtool_ops[] = {
        [IFLA_ETHTOOL_SETTINGS] = {     .parse = settings_parse, },
};

static struct nla_policy ethtool_policy[IFLA_ETHTOOL_MAX+1] = {
        [IFLA_ETHTOOL_SETTINGS] = { .minlen = sizeof(struct ethtool_cmd) },
        [IFLA_ETHTOOL_DRVINFO]  = { .type = NLA_NESTED },
};

static int parse_attr(struct rtnl_link *link, struct nlattr *attr)
{
        int type = nla_type(attr) - 1;

        if (type < 0 || type >= ARRAY_SIZE(ethtool_ops))
                return -NLE_INVAL;

        if (ethtool_ops[type].parse)
                return ethtool_ops[type].parse(link, attr);
        
        return 0;
}

int rtnl_ethtool_parse(struct rtnl_link *link, struct nlattr *attr)
{
        int remaining, err;
        struct nlattr *a;

        err = nla_validate(nla_data(attr), nla_len(attr), IFLA_ETHTOOL_MAX,
                           ethtool_policy);
        if (err < 0)
                return err;

        nla_for_each_nested(a, attr, remaining)
                parse_attr(link, a);

        return 0;
}

void rtnl_ethtool_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
{
        struct rtnl_ethtool *e = &link->l_ethtool;

        if (e->e_mask & ETHTOOL_ATTR_SETTINGS) {
                struct ethtool_cmd *cmd = &e->e_settings;
                char buf[256];

                nl_dump_line(p, "    ethtool:\n");
                nl_dump_line(p, "      supported: %s\n",
                        rtnl_ethtool_supported2str(cmd->supported, buf, sizeof(buf)));
                nl_dump_line(p, "      advertising: %s\n",
                        rtnl_ethtool_supported2str(cmd->advertising, buf, sizeof(buf)));

                nl_dump_line(p, "      duplex: %u\n", cmd->duplex);

                nl_dump_line(p, "      connector: %s\n",
                        rtnl_ethtool_connector2str(cmd->port, buf, sizeof(buf)));
                nl_dump_line(p, "      phy-address: %#x\n", cmd->phy_address);
                nl_dump_line(p, "      transceiver: %s\n",
                        rtnl_ethtool_transceiver2str(cmd->transceiver, buf, sizeof(buf)));

                nl_dump_line(p, "      autonegotiation: %s\n",
                        cmd->autoneg ? "enabled" : "disabled");

                nl_dump_line(p, "      max-tx-pkts: %u\n", cmd->maxtxpkt);
                nl_dump_line(p, "      max-rx-pkts: %u\n", cmd->maxrxpkt);

#if 0
        __u16   speed;          /* The forced speed (lower bits) in
                                 * Mbps. Please use
                                 * ethtool_cmd_speed()/_set() to
                                 * access it */
        __u8    mdio_support;
        __u16   speed_hi;       /* The forced speed (upper
                                 * bits) in Mbps. Please use
                                 * ethtool_cmd_speed()/_set() to
                                 * access it */
        __u8    eth_tp_mdix;
        __u8    reserved2;
        __u32   lp_advertising; /* Features the link partner advertises */
        __u32   reserved[2];
#endif

        }
}

static const struct trans_tbl ethtool_supported[] = {
        __ADD(SUPPORTED_10baseT_Half, 10baseT-Half)
        __ADD(SUPPORTED_10baseT_Full, 10baseT-Full)
        __ADD(SUPPORTED_100baseT_Half, 100baseT-Half)
        __ADD(SUPPORTED_100baseT_Full, 100baseT-Full)
        __ADD(SUPPORTED_1000baseT_Half, 1000baseT-Half)
        __ADD(SUPPORTED_1000baseT_Full, 1000baseT-Full)
        __ADD(SUPPORTED_Autoneg, Autoneg)
        __ADD(SUPPORTED_TP, TP)
        __ADD(SUPPORTED_AUI, AUI)
        __ADD(SUPPORTED_MII, MII)
        __ADD(SUPPORTED_FIBRE, FIBRE)
        __ADD(SUPPORTED_BNC, BNC)
        __ADD(SUPPORTED_10000baseT_Full, 10000baseT-Full)
        __ADD(SUPPORTED_Pause, Pause)
        __ADD(SUPPORTED_Asym_Pause, Asym-Pause)
        __ADD(SUPPORTED_2500baseX_Full, 2500baseX-Full)
        __ADD(SUPPORTED_Backplane, Backplane)
        __ADD(SUPPORTED_1000baseKX_Full, 1000baseKX-Full)
        __ADD(SUPPORTED_10000baseKX4_Full, 10000baseKX4-Full)
        __ADD(SUPPORTED_10000baseKR_Full, 10000baseKR-Full)
        __ADD(SUPPORTED_10000baseR_FEC, 1000baseR-FEC)
        __ADD(SUPPORTED_20000baseMLD2_Full, 20000baseMLD2-Full)
        __ADD(SUPPORTED_20000baseKR2_Full, 20000baseKR2-Full)
};

char *rtnl_ethtool_supported2str(int supported, char *buf, size_t len)
{
        return __flags2str(supported, buf, len, ethtool_supported,
                           ARRAY_SIZE(ethtool_supported));
}

uint32_t rtnl_ethtool_get_supported(struct rtnl_link *link)
{
        return 0;
}

uint32_t rtnl_ethtool_get_advertising(struct rtnl_link *link)
{
        return 0;
}

static const struct trans_tbl ethtool_connectors[] = {
        __ADD(PORT_TP, tp)
        __ADD(PORT_AUI, aui)
        __ADD(PORT_MII, mii)
        __ADD(PORT_FIBRE, fibre)
        __ADD(PORT_BNC, bnc)
        __ADD(PORT_DA, da)
        __ADD(PORT_NONE, none)
        __ADD(PORT_OTHER, other)
};

char *rtnl_ethtool_connector2str(int connector, char *buf, size_t len)
{
        return __type2str(connector, buf, len, ethtool_connectors,
                          ARRAY_SIZE(ethtool_connectors));
}

int rtnl_ethtool_str2connector(const char *name)
{
        return __str2type(name, ethtool_connectors,
                          ARRAY_SIZE(ethtool_connectors));
}

static const struct trans_tbl ethtool_xcvrs[] = {
        __ADD(XCVR_INTERNAL, internal)
        __ADD(XCVR_EXTERNAL, external)
        __ADD(XCVR_DUMMY1, dummy1)
        __ADD(XCVR_DUMMY2, dummy2)
        __ADD(XCVR_DUMMY3, dummy3)
};

char *rtnl_ethtool_transceiver2str(int xcvr, char *buf, size_t len)
{
        return __type2str(xcvr, buf, len, ethtool_xcvrs,
                          ARRAY_SIZE(ethtool_xcvrs));
}

int rtnl_ethtool_str2transceiver(const char *name)
{
        return __str2type(name, ethtool_xcvrs, ARRAY_SIZE(ethtool_xcvrs));
}


/** @} */