ether: Add Linux's MII code
authorBarret Rhoden <brho@cs.berkeley.edu>
Tue, 31 Oct 2017 21:12:07 +0000 (17:12 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 16 Nov 2017 15:46:55 +0000 (10:46 -0500)
From commit 569dbb88e80d ("Linux 4.13").

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/drivers/net/linux_mii.c [new file with mode: 0644]
kern/drivers/net/linux_mii.h [new file with mode: 0644]
kern/drivers/net/linux_uapi_mii.h [new file with mode: 0644]

diff --git a/kern/drivers/net/linux_mii.c b/kern/drivers/net/linux_mii.c
new file mode 100644 (file)
index 0000000..4461212
--- /dev/null
@@ -0,0 +1,667 @@
+/*
+
+       mii.c: MII interface library
+
+       Maintained by Jeff Garzik <jgarzik@pobox.com>
+       Copyright 2001,2002 Jeff Garzik
+
+       Various code came from myson803.c and other files by
+       Donald Becker.  Copyright:
+
+               Written 1998-2002 by Donald Becker.
+
+               This software may be used and distributed according
+               to the terms of the GNU General Public License (GPL),
+               incorporated herein by reference.  Drivers based on
+               or derived from this code fall under the GPL and must
+               retain the authorship, copyright and license notice.
+               This file is not a complete program and may only be
+               used when the entire operating system is licensed
+               under the GPL.
+
+               The author may be reached as becker@scyld.com, or C/O
+               Scyld Computing Corporation
+               410 Severn Ave., Suite 210
+               Annapolis MD 21403
+
+
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+
+static u32 mii_get_an(struct mii_if_info *mii, u16 addr)
+{
+       int advert;
+
+       advert = mii->mdio_read(mii->dev, mii->phy_id, addr);
+
+       return mii_lpa_to_ethtool_lpa_t(advert);
+}
+
+/**
+ * mii_ethtool_gset - get settings that are specified in @ecmd
+ * @mii: MII interface
+ * @ecmd: requested ethtool_cmd
+ *
+ * The @ecmd parameter is expected to have been cleared before calling
+ * mii_ethtool_gset().
+ *
+ * Returns 0 for success, negative on error.
+ */
+int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
+{
+       struct net_device *dev = mii->dev;
+       u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
+       u32 nego;
+
+       ecmd->supported =
+           (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
+            SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
+            SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
+       if (mii->supports_gmii)
+               ecmd->supported |= SUPPORTED_1000baseT_Half |
+                       SUPPORTED_1000baseT_Full;
+
+       /* only supports twisted-pair */
+       ecmd->port = PORT_MII;
+
+       /* only supports internal transceiver */
+       ecmd->transceiver = XCVR_INTERNAL;
+
+       /* this isn't fully supported at higher layers */
+       ecmd->phy_address = mii->phy_id;
+       ecmd->mdio_support = ETH_MDIO_SUPPORTS_C22;
+
+       ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
+
+       bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+       bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
+       if (mii->supports_gmii) {
+               ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
+               stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
+       }
+       if (bmcr & BMCR_ANENABLE) {
+               ecmd->advertising |= ADVERTISED_Autoneg;
+               ecmd->autoneg = AUTONEG_ENABLE;
+
+               ecmd->advertising |= mii_get_an(mii, MII_ADVERTISE);
+               if (mii->supports_gmii)
+                       ecmd->advertising |=
+                                       mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
+
+               if (bmsr & BMSR_ANEGCOMPLETE) {
+                       ecmd->lp_advertising = mii_get_an(mii, MII_LPA);
+                       ecmd->lp_advertising |=
+                                       mii_stat1000_to_ethtool_lpa_t(stat1000);
+               } else {
+                       ecmd->lp_advertising = 0;
+               }
+
+               nego = ecmd->advertising & ecmd->lp_advertising;
+
+               if (nego & (ADVERTISED_1000baseT_Full |
+                           ADVERTISED_1000baseT_Half)) {
+                       ethtool_cmd_speed_set(ecmd, SPEED_1000);
+                       ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full);
+               } else if (nego & (ADVERTISED_100baseT_Full |
+                                  ADVERTISED_100baseT_Half)) {
+                       ethtool_cmd_speed_set(ecmd, SPEED_100);
+                       ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full);
+               } else {
+                       ethtool_cmd_speed_set(ecmd, SPEED_10);
+                       ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full);
+               }
+       } else {
+               ecmd->autoneg = AUTONEG_DISABLE;
+
+               ethtool_cmd_speed_set(ecmd,
+                                     ((bmcr & BMCR_SPEED1000 &&
+                                       (bmcr & BMCR_SPEED100) == 0) ?
+                                      SPEED_1000 :
+                                      ((bmcr & BMCR_SPEED100) ?
+                                       SPEED_100 : SPEED_10)));
+               ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
+       }
+
+       mii->full_duplex = ecmd->duplex;
+
+       /* ignore maxtxpkt, maxrxpkt for now */
+
+       return 0;
+}
+
+/**
+ * mii_ethtool_get_link_ksettings - get settings that are specified in @cmd
+ * @mii: MII interface
+ * @cmd: requested ethtool_link_ksettings
+ *
+ * The @cmd parameter is expected to have been cleared before calling
+ * mii_ethtool_get_link_ksettings().
+ */
+void mii_ethtool_get_link_ksettings(struct mii_if_info *mii,
+                                   struct ethtool_link_ksettings *cmd)
+{
+       struct net_device *dev = mii->dev;
+       u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0;
+       u32 nego, supported, advertising, lp_advertising;
+
+       supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
+                    SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
+                    SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
+       if (mii->supports_gmii)
+               supported |= SUPPORTED_1000baseT_Half |
+                       SUPPORTED_1000baseT_Full;
+
+       /* only supports twisted-pair */
+       cmd->base.port = PORT_MII;
+
+       /* this isn't fully supported at higher layers */
+       cmd->base.phy_address = mii->phy_id;
+       cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
+
+       advertising = ADVERTISED_TP | ADVERTISED_MII;
+
+       bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+       bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR);
+       if (mii->supports_gmii) {
+               ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
+               stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
+       }
+       if (bmcr & BMCR_ANENABLE) {
+               advertising |= ADVERTISED_Autoneg;
+               cmd->base.autoneg = AUTONEG_ENABLE;
+
+               advertising |= mii_get_an(mii, MII_ADVERTISE);
+               if (mii->supports_gmii)
+                       advertising |= mii_ctrl1000_to_ethtool_adv_t(ctrl1000);
+
+               if (bmsr & BMSR_ANEGCOMPLETE) {
+                       lp_advertising = mii_get_an(mii, MII_LPA);
+                       lp_advertising |=
+                                       mii_stat1000_to_ethtool_lpa_t(stat1000);
+               } else {
+                       lp_advertising = 0;
+               }
+
+               nego = advertising & lp_advertising;
+
+               if (nego & (ADVERTISED_1000baseT_Full |
+                           ADVERTISED_1000baseT_Half)) {
+                       cmd->base.speed = SPEED_1000;
+                       cmd->base.duplex = !!(nego & ADVERTISED_1000baseT_Full);
+               } else if (nego & (ADVERTISED_100baseT_Full |
+                                  ADVERTISED_100baseT_Half)) {
+                       cmd->base.speed = SPEED_100;
+                       cmd->base.duplex = !!(nego & ADVERTISED_100baseT_Full);
+               } else {
+                       cmd->base.speed = SPEED_10;
+                       cmd->base.duplex = !!(nego & ADVERTISED_10baseT_Full);
+               }
+       } else {
+               cmd->base.autoneg = AUTONEG_DISABLE;
+
+               cmd->base.speed = ((bmcr & BMCR_SPEED1000 &&
+                                   (bmcr & BMCR_SPEED100) == 0) ?
+                                  SPEED_1000 :
+                                  ((bmcr & BMCR_SPEED100) ?
+                                   SPEED_100 : SPEED_10));
+               cmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
+                       DUPLEX_FULL : DUPLEX_HALF;
+
+               lp_advertising = 0;
+       }
+
+       mii->full_duplex = cmd->base.duplex;
+
+       ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
+                                               supported);
+       ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
+                                               advertising);
+       ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
+                                               lp_advertising);
+
+       /* ignore maxtxpkt, maxrxpkt for now */
+}
+
+/**
+ * mii_ethtool_sset - set settings that are specified in @ecmd
+ * @mii: MII interface
+ * @ecmd: requested ethtool_cmd
+ *
+ * Returns 0 for success, negative on error.
+ */
+int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
+{
+       struct net_device *dev = mii->dev;
+       u32 speed = ethtool_cmd_speed(ecmd);
+
+       if (speed != SPEED_10 &&
+           speed != SPEED_100 &&
+           speed != SPEED_1000)
+               return -EINVAL;
+       if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
+               return -EINVAL;
+       if (ecmd->port != PORT_MII)
+               return -EINVAL;
+       if (ecmd->transceiver != XCVR_INTERNAL)
+               return -EINVAL;
+       if (ecmd->phy_address != mii->phy_id)
+               return -EINVAL;
+       if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
+               return -EINVAL;
+       if ((speed == SPEED_1000) && (!mii->supports_gmii))
+               return -EINVAL;
+
+       /* ignore supported, maxtxpkt, maxrxpkt */
+
+       if (ecmd->autoneg == AUTONEG_ENABLE) {
+               u32 bmcr, advert, tmp;
+               u32 advert2 = 0, tmp2 = 0;
+
+               if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
+                                         ADVERTISED_10baseT_Full |
+                                         ADVERTISED_100baseT_Half |
+                                         ADVERTISED_100baseT_Full |
+                                         ADVERTISED_1000baseT_Half |
+                                         ADVERTISED_1000baseT_Full)) == 0)
+                       return -EINVAL;
+
+               /* advertise only what has been requested */
+               advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
+               tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
+               if (mii->supports_gmii) {
+                       advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
+                       tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
+               }
+               tmp |= ethtool_adv_to_mii_adv_t(ecmd->advertising);
+
+               if (mii->supports_gmii)
+                       tmp2 |=
+                             ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising);
+               if (advert != tmp) {
+                       mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
+                       mii->advertising = tmp;
+               }
+               if ((mii->supports_gmii) && (advert2 != tmp2))
+                       mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
+
+               /* turn on autonegotiation, and force a renegotiate */
+               bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+               bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
+               mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
+
+               mii->force_media = 0;
+       } else {
+               u32 bmcr, tmp;
+
+               /* turn off auto negotiation, set speed and duplexity */
+               bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+               tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
+                              BMCR_SPEED1000 | BMCR_FULLDPLX);
+               if (speed == SPEED_1000)
+                       tmp |= BMCR_SPEED1000;
+               else if (speed == SPEED_100)
+                       tmp |= BMCR_SPEED100;
+               if (ecmd->duplex == DUPLEX_FULL) {
+                       tmp |= BMCR_FULLDPLX;
+                       mii->full_duplex = 1;
+               } else
+                       mii->full_duplex = 0;
+               if (bmcr != tmp)
+                       mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
+
+               mii->force_media = 1;
+       }
+       return 0;
+}
+
+/**
+ * mii_ethtool_set_link_ksettings - set settings that are specified in @cmd
+ * @mii: MII interfaces
+ * @cmd: requested ethtool_link_ksettings
+ *
+ * Returns 0 for success, negative on error.
+ */
+int mii_ethtool_set_link_ksettings(struct mii_if_info *mii,
+                                  const struct ethtool_link_ksettings *cmd)
+{
+       struct net_device *dev = mii->dev;
+       u32 speed = cmd->base.speed;
+
+       if (speed != SPEED_10 &&
+           speed != SPEED_100 &&
+           speed != SPEED_1000)
+               return -EINVAL;
+       if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL)
+               return -EINVAL;
+       if (cmd->base.port != PORT_MII)
+               return -EINVAL;
+       if (cmd->base.phy_address != mii->phy_id)
+               return -EINVAL;
+       if (cmd->base.autoneg != AUTONEG_DISABLE &&
+           cmd->base.autoneg != AUTONEG_ENABLE)
+               return -EINVAL;
+       if ((speed == SPEED_1000) && (!mii->supports_gmii))
+               return -EINVAL;
+
+       /* ignore supported, maxtxpkt, maxrxpkt */
+
+       if (cmd->base.autoneg == AUTONEG_ENABLE) {
+               u32 bmcr, advert, tmp;
+               u32 advert2 = 0, tmp2 = 0;
+               u32 advertising;
+
+               ethtool_convert_link_mode_to_legacy_u32(
+                       &advertising, cmd->link_modes.advertising);
+
+               if ((advertising & (ADVERTISED_10baseT_Half |
+                                   ADVERTISED_10baseT_Full |
+                                   ADVERTISED_100baseT_Half |
+                                   ADVERTISED_100baseT_Full |
+                                   ADVERTISED_1000baseT_Half |
+                                   ADVERTISED_1000baseT_Full)) == 0)
+                       return -EINVAL;
+
+               /* advertise only what has been requested */
+               advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
+               tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
+               if (mii->supports_gmii) {
+                       advert2 = mii->mdio_read(dev, mii->phy_id,
+                                                MII_CTRL1000);
+                       tmp2 = advert2 &
+                               ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
+               }
+               tmp |= ethtool_adv_to_mii_adv_t(advertising);
+
+               if (mii->supports_gmii)
+                       tmp2 |= ethtool_adv_to_mii_ctrl1000_t(advertising);
+               if (advert != tmp) {
+                       mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
+                       mii->advertising = tmp;
+               }
+               if ((mii->supports_gmii) && (advert2 != tmp2))
+                       mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
+
+               /* turn on autonegotiation, and force a renegotiate */
+               bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+               bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
+               mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
+
+               mii->force_media = 0;
+       } else {
+               u32 bmcr, tmp;
+
+               /* turn off auto negotiation, set speed and duplexity */
+               bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
+               tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
+                              BMCR_SPEED1000 | BMCR_FULLDPLX);
+               if (speed == SPEED_1000)
+                       tmp |= BMCR_SPEED1000;
+               else if (speed == SPEED_100)
+                       tmp |= BMCR_SPEED100;
+               if (cmd->base.duplex == DUPLEX_FULL) {
+                       tmp |= BMCR_FULLDPLX;
+                       mii->full_duplex = 1;
+               } else {
+                       mii->full_duplex = 0;
+               }
+               if (bmcr != tmp)
+                       mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
+
+               mii->force_media = 1;
+       }
+       return 0;
+}
+
+/**
+ * mii_check_gmii_support - check if the MII supports Gb interfaces
+ * @mii: the MII interface
+ */
+int mii_check_gmii_support(struct mii_if_info *mii)
+{
+       int reg;
+
+       reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+       if (reg & BMSR_ESTATEN) {
+               reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
+               if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
+                       return 1;
+       }
+
+       return 0;
+}
+
+/**
+ * mii_link_ok - is link status up/ok
+ * @mii: the MII interface
+ *
+ * Returns 1 if the MII reports link status up/ok, 0 otherwise.
+ */
+int mii_link_ok (struct mii_if_info *mii)
+{
+       /* first, a dummy read, needed to latch some MII phys */
+       mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
+       if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
+               return 1;
+       return 0;
+}
+
+/**
+ * mii_nway_restart - restart NWay (autonegotiation) for this interface
+ * @mii: the MII interface
+ *
+ * Returns 0 on success, negative on error.
+ */
+int mii_nway_restart (struct mii_if_info *mii)
+{
+       int bmcr;
+       int r = -EINVAL;
+
+       /* if autoneg is off, it's an error */
+       bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
+
+       if (bmcr & BMCR_ANENABLE) {
+               bmcr |= BMCR_ANRESTART;
+               mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
+               r = 0;
+       }
+
+       return r;
+}
+
+/**
+ * mii_check_link - check MII link status
+ * @mii: MII interface
+ *
+ * If the link status changed (previous != current), call
+ * netif_carrier_on() if current link status is Up or call
+ * netif_carrier_off() if current link status is Down.
+ */
+void mii_check_link (struct mii_if_info *mii)
+{
+       int cur_link = mii_link_ok(mii);
+       int prev_link = netif_carrier_ok(mii->dev);
+
+       if (cur_link && !prev_link)
+               netif_carrier_on(mii->dev);
+       else if (prev_link && !cur_link)
+               netif_carrier_off(mii->dev);
+}
+
+/**
+ * mii_check_media - check the MII interface for a carrier/speed/duplex change
+ * @mii: the MII interface
+ * @ok_to_print: OK to print link up/down messages
+ * @init_media: OK to save duplex mode in @mii
+ *
+ * Returns 1 if the duplex mode changed, 0 if not.
+ * If the media type is forced, always returns 0.
+ */
+unsigned int mii_check_media (struct mii_if_info *mii,
+                             unsigned int ok_to_print,
+                             unsigned int init_media)
+{
+       unsigned int old_carrier, new_carrier;
+       int advertise, lpa, media, duplex;
+       int lpa2 = 0;
+
+       /* check current and old link status */
+       old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
+       new_carrier = (unsigned int) mii_link_ok(mii);
+
+       /* if carrier state did not change, this is a "bounce",
+        * just exit as everything is already set correctly
+        */
+       if ((!init_media) && (old_carrier == new_carrier))
+               return 0; /* duplex did not change */
+
+       /* no carrier, nothing much to do */
+       if (!new_carrier) {
+               netif_carrier_off(mii->dev);
+               if (ok_to_print)
+                       netdev_info(mii->dev, "link down\n");
+               return 0; /* duplex did not change */
+       }
+
+       /*
+        * we have carrier, see who's on the other end
+        */
+       netif_carrier_on(mii->dev);
+
+       if (mii->force_media) {
+               if (ok_to_print)
+                       netdev_info(mii->dev, "link up\n");
+               return 0; /* duplex did not change */
+       }
+
+       /* get MII advertise and LPA values */
+       if ((!init_media) && (mii->advertising))
+               advertise = mii->advertising;
+       else {
+               advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
+               mii->advertising = advertise;
+       }
+       lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
+       if (mii->supports_gmii)
+               lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
+
+       /* figure out media and duplex from advertise and LPA values */
+       media = mii_nway_result(lpa & advertise);
+       duplex = (media & ADVERTISE_FULL) ? 1 : 0;
+       if (lpa2 & LPA_1000FULL)
+               duplex = 1;
+
+       if (ok_to_print)
+               netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n",
+                           lpa2 & (LPA_1000FULL | LPA_1000HALF) ? 1000 :
+                           media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ?
+                           100 : 10,
+                           duplex ? "full" : "half",
+                           lpa);
+
+       if ((init_media) || (mii->full_duplex != duplex)) {
+               mii->full_duplex = duplex;
+               return 1; /* duplex changed */
+       }
+
+       return 0; /* duplex did not change */
+}
+
+/**
+ * generic_mii_ioctl - main MII ioctl interface
+ * @mii_if: the MII interface
+ * @mii_data: MII ioctl data structure
+ * @cmd: MII ioctl command
+ * @duplex_chg_out: pointer to @duplex_changed status if there was no
+ *     ioctl error
+ *
+ * Returns 0 on success, negative on error.
+ */
+int generic_mii_ioctl(struct mii_if_info *mii_if,
+                     struct mii_ioctl_data *mii_data, int cmd,
+                     unsigned int *duplex_chg_out)
+{
+       int rc = 0;
+       unsigned int duplex_changed = 0;
+
+       if (duplex_chg_out)
+               *duplex_chg_out = 0;
+
+       mii_data->phy_id &= mii_if->phy_id_mask;
+       mii_data->reg_num &= mii_if->reg_num_mask;
+
+       switch(cmd) {
+       case SIOCGMIIPHY:
+               mii_data->phy_id = mii_if->phy_id;
+               /* fall through */
+
+       case SIOCGMIIREG:
+               mii_data->val_out =
+                       mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
+                                         mii_data->reg_num);
+               break;
+
+       case SIOCSMIIREG: {
+               u16 val = mii_data->val_in;
+
+               if (mii_data->phy_id == mii_if->phy_id) {
+                       switch(mii_data->reg_num) {
+                       case MII_BMCR: {
+                               unsigned int new_duplex = 0;
+                               if (val & (BMCR_RESET|BMCR_ANENABLE))
+                                       mii_if->force_media = 0;
+                               else
+                                       mii_if->force_media = 1;
+                               if (mii_if->force_media &&
+                                   (val & BMCR_FULLDPLX))
+                                       new_duplex = 1;
+                               if (mii_if->full_duplex != new_duplex) {
+                                       duplex_changed = 1;
+                                       mii_if->full_duplex = new_duplex;
+                               }
+                               break;
+                       }
+                       case MII_ADVERTISE:
+                               mii_if->advertising = val;
+                               break;
+                       default:
+                               /* do nothing */
+                               break;
+                       }
+               }
+
+               mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
+                                  mii_data->reg_num, val);
+               break;
+       }
+
+       default:
+               rc = -EOPNOTSUPP;
+               break;
+       }
+
+       if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
+               *duplex_chg_out = 1;
+
+       return rc;
+}
+
+MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
+MODULE_DESCRIPTION ("MII hardware support library");
+MODULE_LICENSE("GPL");
+
+EXPORT_SYMBOL(mii_link_ok);
+EXPORT_SYMBOL(mii_nway_restart);
+EXPORT_SYMBOL(mii_ethtool_gset);
+EXPORT_SYMBOL(mii_ethtool_get_link_ksettings);
+EXPORT_SYMBOL(mii_ethtool_sset);
+EXPORT_SYMBOL(mii_ethtool_set_link_ksettings);
+EXPORT_SYMBOL(mii_check_link);
+EXPORT_SYMBOL(mii_check_media);
+EXPORT_SYMBOL(mii_check_gmii_support);
+EXPORT_SYMBOL(generic_mii_ioctl);
+
diff --git a/kern/drivers/net/linux_mii.h b/kern/drivers/net/linux_mii.h
new file mode 100644 (file)
index 0000000..e870bfa
--- /dev/null
@@ -0,0 +1,343 @@
+/*
+ * linux/mii.h: definitions for MII-compatible transceivers
+ * Originally drivers/net/sunhme.h.
+ *
+ * Copyright (C) 1996, 1999, 2001 David S. Miller (davem@redhat.com)
+ */
+#ifndef __LINUX_MII_H__
+#define __LINUX_MII_H__
+
+
+#include <linux/if.h>
+#include <uapi/linux/mii.h>
+
+struct ethtool_cmd;
+
+struct mii_if_info {
+       int phy_id;
+       int advertising;
+       int phy_id_mask;
+       int reg_num_mask;
+
+       unsigned int full_duplex : 1;   /* is full duplex? */
+       unsigned int force_media : 1;   /* is autoneg. disabled? */
+       unsigned int supports_gmii : 1; /* are GMII registers supported? */
+
+       struct net_device *dev;
+       int (*mdio_read) (struct net_device *dev, int phy_id, int location);
+       void (*mdio_write) (struct net_device *dev, int phy_id, int location, int val);
+};
+
+extern int mii_link_ok (struct mii_if_info *mii);
+extern int mii_nway_restart (struct mii_if_info *mii);
+extern int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
+extern void mii_ethtool_get_link_ksettings(
+       struct mii_if_info *mii, struct ethtool_link_ksettings *cmd);
+extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
+extern int mii_ethtool_set_link_ksettings(
+       struct mii_if_info *mii, const struct ethtool_link_ksettings *cmd);
+extern int mii_check_gmii_support(struct mii_if_info *mii);
+extern void mii_check_link (struct mii_if_info *mii);
+extern unsigned int mii_check_media (struct mii_if_info *mii,
+                                    unsigned int ok_to_print,
+                                    unsigned int init_media);
+extern int generic_mii_ioctl(struct mii_if_info *mii_if,
+                            struct mii_ioctl_data *mii_data, int cmd,
+                            unsigned int *duplex_changed);
+
+
+static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
+{
+       return (struct mii_ioctl_data *) &rq->ifr_ifru;
+}
+
+/**
+ * mii_nway_result
+ * @negotiated: value of MII ANAR and'd with ANLPAR
+ *
+ * Given a set of MII abilities, check each bit and returns the
+ * currently supported media, in the priority order defined by
+ * IEEE 802.3u.  We use LPA_xxx constants but note this is not the
+ * value of LPA solely, as described above.
+ *
+ * The one exception to IEEE 802.3u is that 100baseT4 is placed
+ * between 100T-full and 100T-half.  If your phy does not support
+ * 100T4 this is fine.  If your phy places 100T4 elsewhere in the
+ * priority order, you will need to roll your own function.
+ */
+static inline unsigned int mii_nway_result (unsigned int negotiated)
+{
+       unsigned int ret;
+
+       if (negotiated & LPA_100FULL)
+               ret = LPA_100FULL;
+       else if (negotiated & LPA_100BASE4)
+               ret = LPA_100BASE4;
+       else if (negotiated & LPA_100HALF)
+               ret = LPA_100HALF;
+       else if (negotiated & LPA_10FULL)
+               ret = LPA_10FULL;
+       else
+               ret = LPA_10HALF;
+
+       return ret;
+}
+
+/**
+ * mii_duplex
+ * @duplex_lock: Non-zero if duplex is locked at full
+ * @negotiated: value of MII ANAR and'd with ANLPAR
+ *
+ * A small helper function for a common case.  Returns one
+ * if the media is operating or locked at full duplex, and
+ * returns zero otherwise.
+ */
+static inline unsigned int mii_duplex (unsigned int duplex_lock,
+                                      unsigned int negotiated)
+{
+       if (duplex_lock)
+               return 1;
+       if (mii_nway_result(negotiated) & LPA_DUPLEX)
+               return 1;
+       return 0;
+}
+
+/**
+ * ethtool_adv_to_mii_adv_t
+ * @ethadv: the ethtool advertisement settings
+ *
+ * A small helper function that translates ethtool advertisement
+ * settings to phy autonegotiation advertisements for the
+ * MII_ADVERTISE register.
+ */
+static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv)
+{
+       u32 result = 0;
+
+       if (ethadv & ADVERTISED_10baseT_Half)
+               result |= ADVERTISE_10HALF;
+       if (ethadv & ADVERTISED_10baseT_Full)
+               result |= ADVERTISE_10FULL;
+       if (ethadv & ADVERTISED_100baseT_Half)
+               result |= ADVERTISE_100HALF;
+       if (ethadv & ADVERTISED_100baseT_Full)
+               result |= ADVERTISE_100FULL;
+       if (ethadv & ADVERTISED_Pause)
+               result |= ADVERTISE_PAUSE_CAP;
+       if (ethadv & ADVERTISED_Asym_Pause)
+               result |= ADVERTISE_PAUSE_ASYM;
+
+       return result;
+}
+
+/**
+ * mii_adv_to_ethtool_adv_t
+ * @adv: value of the MII_ADVERTISE register
+ *
+ * A small helper function that translates MII_ADVERTISE bits
+ * to ethtool advertisement settings.
+ */
+static inline u32 mii_adv_to_ethtool_adv_t(u32 adv)
+{
+       u32 result = 0;
+
+       if (adv & ADVERTISE_10HALF)
+               result |= ADVERTISED_10baseT_Half;
+       if (adv & ADVERTISE_10FULL)
+               result |= ADVERTISED_10baseT_Full;
+       if (adv & ADVERTISE_100HALF)
+               result |= ADVERTISED_100baseT_Half;
+       if (adv & ADVERTISE_100FULL)
+               result |= ADVERTISED_100baseT_Full;
+       if (adv & ADVERTISE_PAUSE_CAP)
+               result |= ADVERTISED_Pause;
+       if (adv & ADVERTISE_PAUSE_ASYM)
+               result |= ADVERTISED_Asym_Pause;
+
+       return result;
+}
+
+/**
+ * ethtool_adv_to_mii_ctrl1000_t
+ * @ethadv: the ethtool advertisement settings
+ *
+ * A small helper function that translates ethtool advertisement
+ * settings to phy autonegotiation advertisements for the
+ * MII_CTRL1000 register when in 1000T mode.
+ */
+static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv)
+{
+       u32 result = 0;
+
+       if (ethadv & ADVERTISED_1000baseT_Half)
+               result |= ADVERTISE_1000HALF;
+       if (ethadv & ADVERTISED_1000baseT_Full)
+               result |= ADVERTISE_1000FULL;
+
+       return result;
+}
+
+/**
+ * mii_ctrl1000_to_ethtool_adv_t
+ * @adv: value of the MII_CTRL1000 register
+ *
+ * A small helper function that translates MII_CTRL1000
+ * bits, when in 1000Base-T mode, to ethtool
+ * advertisement settings.
+ */
+static inline u32 mii_ctrl1000_to_ethtool_adv_t(u32 adv)
+{
+       u32 result = 0;
+
+       if (adv & ADVERTISE_1000HALF)
+               result |= ADVERTISED_1000baseT_Half;
+       if (adv & ADVERTISE_1000FULL)
+               result |= ADVERTISED_1000baseT_Full;
+
+       return result;
+}
+
+/**
+ * mii_lpa_to_ethtool_lpa_t
+ * @adv: value of the MII_LPA register
+ *
+ * A small helper function that translates MII_LPA
+ * bits, when in 1000Base-T mode, to ethtool
+ * LP advertisement settings.
+ */
+static inline u32 mii_lpa_to_ethtool_lpa_t(u32 lpa)
+{
+       u32 result = 0;
+
+       if (lpa & LPA_LPACK)
+               result |= ADVERTISED_Autoneg;
+
+       return result | mii_adv_to_ethtool_adv_t(lpa);
+}
+
+/**
+ * mii_stat1000_to_ethtool_lpa_t
+ * @adv: value of the MII_STAT1000 register
+ *
+ * A small helper function that translates MII_STAT1000
+ * bits, when in 1000Base-T mode, to ethtool
+ * advertisement settings.
+ */
+static inline u32 mii_stat1000_to_ethtool_lpa_t(u32 lpa)
+{
+       u32 result = 0;
+
+       if (lpa & LPA_1000HALF)
+               result |= ADVERTISED_1000baseT_Half;
+       if (lpa & LPA_1000FULL)
+               result |= ADVERTISED_1000baseT_Full;
+
+       return result;
+}
+
+/**
+ * ethtool_adv_to_mii_adv_x
+ * @ethadv: the ethtool advertisement settings
+ *
+ * A small helper function that translates ethtool advertisement
+ * settings to phy autonegotiation advertisements for the
+ * MII_CTRL1000 register when in 1000Base-X mode.
+ */
+static inline u32 ethtool_adv_to_mii_adv_x(u32 ethadv)
+{
+       u32 result = 0;
+
+       if (ethadv & ADVERTISED_1000baseT_Half)
+               result |= ADVERTISE_1000XHALF;
+       if (ethadv & ADVERTISED_1000baseT_Full)
+               result |= ADVERTISE_1000XFULL;
+       if (ethadv & ADVERTISED_Pause)
+               result |= ADVERTISE_1000XPAUSE;
+       if (ethadv & ADVERTISED_Asym_Pause)
+               result |= ADVERTISE_1000XPSE_ASYM;
+
+       return result;
+}
+
+/**
+ * mii_adv_to_ethtool_adv_x
+ * @adv: value of the MII_CTRL1000 register
+ *
+ * A small helper function that translates MII_CTRL1000
+ * bits, when in 1000Base-X mode, to ethtool
+ * advertisement settings.
+ */
+static inline u32 mii_adv_to_ethtool_adv_x(u32 adv)
+{
+       u32 result = 0;
+
+       if (adv & ADVERTISE_1000XHALF)
+               result |= ADVERTISED_1000baseT_Half;
+       if (adv & ADVERTISE_1000XFULL)
+               result |= ADVERTISED_1000baseT_Full;
+       if (adv & ADVERTISE_1000XPAUSE)
+               result |= ADVERTISED_Pause;
+       if (adv & ADVERTISE_1000XPSE_ASYM)
+               result |= ADVERTISED_Asym_Pause;
+
+       return result;
+}
+
+/**
+ * mii_lpa_to_ethtool_lpa_x
+ * @adv: value of the MII_LPA register
+ *
+ * A small helper function that translates MII_LPA
+ * bits, when in 1000Base-X mode, to ethtool
+ * LP advertisement settings.
+ */
+static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa)
+{
+       u32 result = 0;
+
+       if (lpa & LPA_LPACK)
+               result |= ADVERTISED_Autoneg;
+
+       return result | mii_adv_to_ethtool_adv_x(lpa);
+}
+
+/**
+ * mii_advertise_flowctrl - get flow control advertisement flags
+ * @cap: Flow control capabilities (FLOW_CTRL_RX, FLOW_CTRL_TX or both)
+ */
+static inline u16 mii_advertise_flowctrl(int cap)
+{
+       u16 adv = 0;
+
+       if (cap & FLOW_CTRL_RX)
+               adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
+       if (cap & FLOW_CTRL_TX)
+               adv ^= ADVERTISE_PAUSE_ASYM;
+
+       return adv;
+}
+
+/**
+ * mii_resolve_flowctrl_fdx
+ * @lcladv: value of MII ADVERTISE register
+ * @rmtadv: value of MII LPA register
+ *
+ * Resolve full duplex flow control as per IEEE 802.3-2005 table 28B-3
+ */
+static inline u8 mii_resolve_flowctrl_fdx(u16 lcladv, u16 rmtadv)
+{
+       u8 cap = 0;
+
+       if (lcladv & rmtadv & ADVERTISE_PAUSE_CAP) {
+               cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
+       } else if (lcladv & rmtadv & ADVERTISE_PAUSE_ASYM) {
+               if (lcladv & ADVERTISE_PAUSE_CAP)
+                       cap = FLOW_CTRL_RX;
+               else if (rmtadv & ADVERTISE_PAUSE_CAP)
+                       cap = FLOW_CTRL_TX;
+       }
+
+       return cap;
+}
+
+#endif /* __LINUX_MII_H__ */
diff --git a/kern/drivers/net/linux_uapi_mii.h b/kern/drivers/net/linux_uapi_mii.h
new file mode 100644 (file)
index 0000000..15d8510
--- /dev/null
@@ -0,0 +1,162 @@
+/*
+ * linux/mii.h: definitions for MII-compatible transceivers
+ * Originally drivers/net/sunhme.h.
+ *
+ * Copyright (C) 1996, 1999, 2001 David S. Miller (davem@redhat.com)
+ */
+
+#ifndef _UAPI__LINUX_MII_H__
+#define _UAPI__LINUX_MII_H__
+
+#include <linux/types.h>
+#include <linux/ethtool.h>
+
+/* Generic MII registers. */
+#define MII_BMCR               0x00    /* Basic mode control register */
+#define MII_BMSR               0x01    /* Basic mode status register  */
+#define MII_PHYSID1            0x02    /* PHYS ID 1                   */
+#define MII_PHYSID2            0x03    /* PHYS ID 2                   */
+#define MII_ADVERTISE          0x04    /* Advertisement control reg   */
+#define MII_LPA                        0x05    /* Link partner ability reg    */
+#define MII_EXPANSION          0x06    /* Expansion register          */
+#define MII_CTRL1000           0x09    /* 1000BASE-T control          */
+#define MII_STAT1000           0x0a    /* 1000BASE-T status           */
+#define        MII_MMD_CTRL            0x0d    /* MMD Access Control Register */
+#define        MII_MMD_DATA            0x0e    /* MMD Access Data Register */
+#define MII_ESTATUS            0x0f    /* Extended Status             */
+#define MII_DCOUNTER           0x12    /* Disconnect counter          */
+#define MII_FCSCOUNTER         0x13    /* False carrier counter       */
+#define MII_NWAYTEST           0x14    /* N-way auto-neg test reg     */
+#define MII_RERRCOUNTER                0x15    /* Receive error counter       */
+#define MII_SREVISION          0x16    /* Silicon revision            */
+#define MII_RESV1              0x17    /* Reserved...                 */
+#define MII_LBRERROR           0x18    /* Lpback, rx, bypass error    */
+#define MII_PHYADDR            0x19    /* PHY address                 */
+#define MII_RESV2              0x1a    /* Reserved...                 */
+#define MII_TPISTATUS          0x1b    /* TPI status for 10mbps       */
+#define MII_NCONFIG            0x1c    /* Network interface config    */
+
+/* Basic mode control register. */
+#define BMCR_RESV              0x003f  /* Unused...                   */
+#define BMCR_SPEED1000         0x0040  /* MSB of Speed (1000)         */
+#define BMCR_CTST              0x0080  /* Collision test              */
+#define BMCR_FULLDPLX          0x0100  /* Full duplex                 */
+#define BMCR_ANRESTART         0x0200  /* Auto negotiation restart    */
+#define BMCR_ISOLATE           0x0400  /* Isolate data paths from MII */
+#define BMCR_PDOWN             0x0800  /* Enable low power state      */
+#define BMCR_ANENABLE          0x1000  /* Enable auto negotiation     */
+#define BMCR_SPEED100          0x2000  /* Select 100Mbps              */
+#define BMCR_LOOPBACK          0x4000  /* TXD loopback bits           */
+#define BMCR_RESET             0x8000  /* Reset to default state      */
+#define BMCR_SPEED10           0x0000  /* Select 10Mbps               */
+
+/* Basic mode status register. */
+#define BMSR_ERCAP             0x0001  /* Ext-reg capability          */
+#define BMSR_JCD               0x0002  /* Jabber detected             */
+#define BMSR_LSTATUS           0x0004  /* Link status                 */
+#define BMSR_ANEGCAPABLE       0x0008  /* Able to do auto-negotiation */
+#define BMSR_RFAULT            0x0010  /* Remote fault detected       */
+#define BMSR_ANEGCOMPLETE      0x0020  /* Auto-negotiation complete   */
+#define BMSR_RESV              0x00c0  /* Unused...                   */
+#define BMSR_ESTATEN           0x0100  /* Extended Status in R15      */
+#define BMSR_100HALF2          0x0200  /* Can do 100BASE-T2 HDX       */
+#define BMSR_100FULL2          0x0400  /* Can do 100BASE-T2 FDX       */
+#define BMSR_10HALF            0x0800  /* Can do 10mbps, half-duplex  */
+#define BMSR_10FULL            0x1000  /* Can do 10mbps, full-duplex  */
+#define BMSR_100HALF           0x2000  /* Can do 100mbps, half-duplex */
+#define BMSR_100FULL           0x4000  /* Can do 100mbps, full-duplex */
+#define BMSR_100BASE4          0x8000  /* Can do 100mbps, 4k packets  */
+
+/* Advertisement control register. */
+#define ADVERTISE_SLCT         0x001f  /* Selector bits               */
+#define ADVERTISE_CSMA         0x0001  /* Only selector supported     */
+#define ADVERTISE_10HALF       0x0020  /* Try for 10mbps half-duplex  */
+#define ADVERTISE_1000XFULL    0x0020  /* Try for 1000BASE-X full-duplex */
+#define ADVERTISE_10FULL       0x0040  /* Try for 10mbps full-duplex  */
+#define ADVERTISE_1000XHALF    0x0040  /* Try for 1000BASE-X half-duplex */
+#define ADVERTISE_100HALF      0x0080  /* Try for 100mbps half-duplex */
+#define ADVERTISE_1000XPAUSE   0x0080  /* Try for 1000BASE-X pause    */
+#define ADVERTISE_100FULL      0x0100  /* Try for 100mbps full-duplex */
+#define ADVERTISE_1000XPSE_ASYM        0x0100  /* Try for 1000BASE-X asym pause */
+#define ADVERTISE_100BASE4     0x0200  /* Try for 100mbps 4k packets  */
+#define ADVERTISE_PAUSE_CAP    0x0400  /* Try for pause               */
+#define ADVERTISE_PAUSE_ASYM   0x0800  /* Try for asymetric pause     */
+#define ADVERTISE_RESV         0x1000  /* Unused...                   */
+#define ADVERTISE_RFAULT       0x2000  /* Say we can detect faults    */
+#define ADVERTISE_LPACK                0x4000  /* Ack link partners response  */
+#define ADVERTISE_NPAGE                0x8000  /* Next page bit               */
+
+#define ADVERTISE_FULL         (ADVERTISE_100FULL | ADVERTISE_10FULL | \
+                                 ADVERTISE_CSMA)
+#define ADVERTISE_ALL          (ADVERTISE_10HALF | ADVERTISE_10FULL | \
+                                 ADVERTISE_100HALF | ADVERTISE_100FULL)
+
+/* Link partner ability register. */
+#define LPA_SLCT               0x001f  /* Same as advertise selector  */
+#define LPA_10HALF             0x0020  /* Can do 10mbps half-duplex   */
+#define LPA_1000XFULL          0x0020  /* Can do 1000BASE-X full-duplex */
+#define LPA_10FULL             0x0040  /* Can do 10mbps full-duplex   */
+#define LPA_1000XHALF          0x0040  /* Can do 1000BASE-X half-duplex */
+#define LPA_100HALF            0x0080  /* Can do 100mbps half-duplex  */
+#define LPA_1000XPAUSE         0x0080  /* Can do 1000BASE-X pause     */
+#define LPA_100FULL            0x0100  /* Can do 100mbps full-duplex  */
+#define LPA_1000XPAUSE_ASYM    0x0100  /* Can do 1000BASE-X pause asym*/
+#define LPA_100BASE4           0x0200  /* Can do 100mbps 4k packets   */
+#define LPA_PAUSE_CAP          0x0400  /* Can pause                   */
+#define LPA_PAUSE_ASYM         0x0800  /* Can pause asymetrically     */
+#define LPA_RESV               0x1000  /* Unused...                   */
+#define LPA_RFAULT             0x2000  /* Link partner faulted        */
+#define LPA_LPACK              0x4000  /* Link partner acked us       */
+#define LPA_NPAGE              0x8000  /* Next page bit               */
+
+#define LPA_DUPLEX             (LPA_10FULL | LPA_100FULL)
+#define LPA_100                        (LPA_100FULL | LPA_100HALF | LPA_100BASE4)
+
+/* Expansion register for auto-negotiation. */
+#define EXPANSION_NWAY         0x0001  /* Can do N-way auto-nego      */
+#define EXPANSION_LCWP         0x0002  /* Got new RX page code word   */
+#define EXPANSION_ENABLENPAGE  0x0004  /* This enables npage words    */
+#define EXPANSION_NPCAPABLE    0x0008  /* Link partner supports npage */
+#define EXPANSION_MFAULTS      0x0010  /* Multiple faults detected    */
+#define EXPANSION_RESV         0xffe0  /* Unused...                   */
+
+#define ESTATUS_1000_TFULL     0x2000  /* Can do 1000BT Full          */
+#define ESTATUS_1000_THALF     0x1000  /* Can do 1000BT Half          */
+
+/* N-way test register. */
+#define NWAYTEST_RESV1         0x00ff  /* Unused...                   */
+#define NWAYTEST_LOOPBACK      0x0100  /* Enable loopback for N-way   */
+#define NWAYTEST_RESV2         0xfe00  /* Unused...                   */
+
+/* 1000BASE-T Control register */
+#define ADVERTISE_1000FULL     0x0200  /* Advertise 1000BASE-T full duplex */
+#define ADVERTISE_1000HALF     0x0100  /* Advertise 1000BASE-T half duplex */
+#define CTL1000_AS_MASTER      0x0800
+#define CTL1000_ENABLE_MASTER  0x1000
+
+/* 1000BASE-T Status register */
+#define LPA_1000LOCALRXOK      0x2000  /* Link partner local receiver status */
+#define LPA_1000REMRXOK                0x1000  /* Link partner remote receiver status */
+#define LPA_1000FULL           0x0800  /* Link partner 1000BASE-T full duplex */
+#define LPA_1000HALF           0x0400  /* Link partner 1000BASE-T half duplex */
+
+/* Flow control flags */
+#define FLOW_CTRL_TX           0x01
+#define FLOW_CTRL_RX           0x02
+
+/* MMD Access Control register fields */
+#define MII_MMD_CTRL_DEVAD_MASK        0x1f    /* Mask MMD DEVAD*/
+#define MII_MMD_CTRL_ADDR      0x0000  /* Address */
+#define MII_MMD_CTRL_NOINCR    0x4000  /* no post increment */
+#define MII_MMD_CTRL_INCR_RDWT 0x8000  /* post increment on reads & writes */
+#define MII_MMD_CTRL_INCR_ON_WT        0xC000  /* post increment on writes only */
+
+/* This structure is used in all SIOCxMIIxxx ioctl calls */
+struct mii_ioctl_data {
+       __u16           phy_id;
+       __u16           reg_num;
+       __u16           val_in;
+       __u16           val_out;
+};
+
+#endif /* _UAPI__LINUX_MII_H__ */