371 lines
9.1 KiB
C
371 lines
9.1 KiB
C
/*
|
|
* Copyright (C) 2012 Antony Pavlov <antonynpavlov@gmail.com>
|
|
*
|
|
* This file is part of barebox.
|
|
* See file CREDITS for list of people who contributed to this
|
|
* project.
|
|
*
|
|
* This program is based on Donald Becker's "mii-diag" and
|
|
* David A. Hinds' "mii-tool".
|
|
*
|
|
* mii-tool is written/copyright 2000 by David A. Hinds
|
|
* <dhinds@pcmcia.sourceforge.org>
|
|
*
|
|
* mii-diag is written/copyright 1997-2000 by Donald Becker
|
|
* <becker@scyld.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <command.h>
|
|
#include <init.h>
|
|
#include <driver.h>
|
|
#include <malloc.h>
|
|
#include <errno.h>
|
|
#include <fs.h>
|
|
#include <fcntl.h>
|
|
#include <getopt.h>
|
|
#include <linux/stat.h>
|
|
#include <xfuncs.h>
|
|
#include <net.h>
|
|
#include <linux/mii.h>
|
|
#include <linux/phy.h>
|
|
#include <linux/err.h>
|
|
|
|
const struct {
|
|
char *name;
|
|
u_short value[2];
|
|
} media[] = {
|
|
/* The order through 100baseT4 matches bits in the BMSR */
|
|
{ "10baseT-HD", {ADVERTISE_10HALF} },
|
|
{ "10baseT-FD", {ADVERTISE_10FULL} },
|
|
{ "100baseTx-HD", {ADVERTISE_100HALF} },
|
|
{ "100baseTx-FD", {ADVERTISE_100FULL} },
|
|
{ "100baseT4", {LPA_100BASE4} },
|
|
{ "100baseTx", {ADVERTISE_100FULL | ADVERTISE_100HALF} },
|
|
{ "10baseT", {ADVERTISE_10FULL | ADVERTISE_10HALF} },
|
|
{ "1000baseT-HD", {0, ADVERTISE_1000HALF} },
|
|
{ "1000baseT-FD", {0, ADVERTISE_1000FULL} },
|
|
{ "1000baseT", {0, ADVERTISE_1000HALF | ADVERTISE_1000FULL} },
|
|
};
|
|
#define NMEDIA (sizeof(media)/sizeof(media[0]))
|
|
|
|
static const char *media_list(unsigned mask, unsigned mask2, int best)
|
|
{
|
|
static char buf[256];
|
|
int i;
|
|
|
|
*buf = '\0';
|
|
|
|
if (mask2) {
|
|
if (mask2 & ADVERTISE_1000FULL) {
|
|
strcat(buf, " ");
|
|
strcat(buf, "1000baseT-FD");
|
|
if (best)
|
|
goto out;
|
|
}
|
|
|
|
if (mask2 & ADVERTISE_1000HALF) {
|
|
strcat(buf, " ");
|
|
strcat(buf, "1000baseT-HD");
|
|
if (best)
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
mask >>= 5;
|
|
for (i = 4; i >= 0; i--) {
|
|
if (mask & (1 << i)) {
|
|
strcat(buf, " ");
|
|
strcat(buf, media[i].name);
|
|
if (best)
|
|
break;
|
|
}
|
|
}
|
|
|
|
out:
|
|
if (mask & (1 << 5))
|
|
strcat(buf, " flow-control");
|
|
|
|
return buf;
|
|
}
|
|
|
|
static int show_basic_mii(struct mii_bus *mii, struct phy_device *phydev,
|
|
int verbose)
|
|
{
|
|
char buf[100];
|
|
int i, mii_val[32];
|
|
unsigned bmcr, bmsr, advert, lkpar, bmcr2 = 0, lpa2 = 0;
|
|
struct phy_driver *phydrv;
|
|
int is_phy_gbit;
|
|
|
|
/* Some bits in the BMSR are latched, but we can't rely on being
|
|
the only reader, so only the current values are meaningful */
|
|
mii->read(mii, phydev->addr, MII_BMSR);
|
|
|
|
for (i = 0; i < 32; i++)
|
|
mii_val[i] = mii->read(mii, phydev->addr, i);
|
|
|
|
printf((mii->parent->id) < 0 ? "%s: %s:" : "%s: %s%d: ",
|
|
phydev->cdev.name, mii->parent->name, mii->parent->id);
|
|
|
|
|
|
if (mii_val[MII_BMCR] == 0xffff || mii_val[MII_BMSR] == 0x0000) {
|
|
eprintf(" No MII transceiver present!.\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Descriptive rename. */
|
|
bmcr = mii_val[MII_BMCR];
|
|
bmsr = mii_val[MII_BMSR];
|
|
advert = mii_val[MII_ADVERTISE];
|
|
lkpar = mii_val[MII_LPA];
|
|
|
|
phydrv = to_phy_driver(phydev->dev.driver);
|
|
is_phy_gbit = phydrv->features &
|
|
(SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full);
|
|
|
|
if (is_phy_gbit) {
|
|
bmcr2 = mii_val[MII_CTRL1000];
|
|
lpa2 = mii_val[MII_STAT1000];
|
|
}
|
|
|
|
*buf = '\0';
|
|
if (bmcr & BMCR_ANENABLE) {
|
|
if (bmsr & BMSR_ANEGCOMPLETE) {
|
|
if (advert & lkpar) {
|
|
sprintf(buf, "%s%s, ", (lkpar & LPA_LPACK) ?
|
|
"negotiated" : "no autonegotiation,",
|
|
media_list(advert & lkpar,
|
|
bmcr2 & lpa2 >> 2, 1));
|
|
} else {
|
|
sprintf(buf, "autonegotiation failed, ");
|
|
}
|
|
} else if (bmcr & BMCR_ANRESTART) {
|
|
sprintf(buf, "autonegotiation restarted, ");
|
|
}
|
|
} else {
|
|
int speed1000;
|
|
|
|
speed1000 = ((bmcr2
|
|
& (ADVERTISE_1000HALF
|
|
| ADVERTISE_1000FULL)) & lpa2 >> 2);
|
|
sprintf(buf, "%s Mbit, %s duplex, ",
|
|
speed1000 ? "1000"
|
|
: (bmcr & BMCR_SPEED100) ? "100" : "10",
|
|
(bmcr & BMCR_FULLDPLX) ? "full" : "half");
|
|
}
|
|
|
|
strcat(buf, (bmsr & BMSR_LSTATUS) ? "link ok" : "no link");
|
|
|
|
printf("%s\n", buf);
|
|
|
|
if (verbose > 1) {
|
|
printf(" registers for MII PHY: ");
|
|
for (i = 0; i < 32; i++)
|
|
printf("%s %4.4x",
|
|
((i % 8) ? "" : "\n "), mii_val[i]);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
if (verbose) {
|
|
printf(" product info: %s ", phydrv->drv.name);
|
|
printf("(vendor %02x:%02x:%02x, model %d rev %d)\n",
|
|
mii_val[2] >> 10, (mii_val[2] >> 2) & 0xff,
|
|
((mii_val[2] << 6) | (mii_val[3] >> 10)) & 0xff,
|
|
(mii_val[3] >> 4) & 0x3f, mii_val[3] & 0x0f);
|
|
|
|
printf(" basic mode: ");
|
|
if (bmcr & BMCR_RESET)
|
|
printf("software reset, ");
|
|
if (bmcr & BMCR_LOOPBACK)
|
|
printf("loopback, ");
|
|
if (bmcr & BMCR_ISOLATE)
|
|
printf("isolate, ");
|
|
if (bmcr & BMCR_CTST)
|
|
printf("collision test, ");
|
|
if (bmcr & BMCR_ANENABLE) {
|
|
printf("autonegotiation enabled\n");
|
|
} else {
|
|
printf("%s Mbit, %s duplex\n",
|
|
(bmcr & BMCR_SPEED100) ? "100" : "10",
|
|
(bmcr & BMCR_FULLDPLX) ? "full" : "half");
|
|
}
|
|
printf(" basic status: ");
|
|
if (bmsr & BMSR_ANEGCOMPLETE)
|
|
printf("autonegotiation complete, ");
|
|
else if (bmcr & BMCR_ANRESTART)
|
|
printf("autonegotiation restarted, ");
|
|
if (bmsr & BMSR_RFAULT)
|
|
printf("remote fault, ");
|
|
printf((bmsr & BMSR_LSTATUS) ? "link ok" : "no link");
|
|
printf("\n capabilities:%s", media_list(bmsr >> 6, bmcr2, 0));
|
|
printf("\n advertising: %s", media_list(advert, bmcr2, 0));
|
|
|
|
#define LPA_ABILITY_MASK (LPA_10HALF | LPA_10FULL \
|
|
| LPA_100HALF | LPA_100FULL \
|
|
| LPA_100BASE4 | LPA_PAUSE_CAP)
|
|
|
|
if (lkpar & LPA_ABILITY_MASK)
|
|
printf("\n link partner:%s",
|
|
media_list(lkpar, lpa2 >> 2, 0));
|
|
printf("\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void mdiobus_show(struct device_d *dev, char *phydevname, int verbose)
|
|
{
|
|
struct mii_bus *mii = to_mii_bus(dev);
|
|
int i;
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++) {
|
|
struct phy_device *phydev;
|
|
|
|
phydev = mdiobus_scan(mii, i);
|
|
if (IS_ERR(phydev) || !phydev->registered)
|
|
continue;
|
|
|
|
/*
|
|
* If we are looking for a secific phy, called
|
|
* 'phydevname', but current phydev is not it, skip to
|
|
* the next iteration
|
|
*/
|
|
if (phydevname &&
|
|
strcmp(phydev->cdev.name, phydevname))
|
|
continue;
|
|
|
|
show_basic_mii(mii, phydev, verbose);
|
|
|
|
/*
|
|
* We were looking for a specific device and at this
|
|
* point we already shown the info about it so end the
|
|
* loop and exit
|
|
*/
|
|
if (phydevname)
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
enum miitool_operations {
|
|
MIITOOL_NOOP,
|
|
MIITOOL_SHOW,
|
|
MIITOOL_REGISTER,
|
|
};
|
|
|
|
static int do_miitool(int argc, char *argv[])
|
|
{
|
|
char *phydevname = NULL;
|
|
char *regstr = NULL;
|
|
char *endp;
|
|
struct mii_bus *mii;
|
|
int opt, ret;
|
|
int verbose = 0;
|
|
struct phy_device *phydev;
|
|
enum miitool_operations action = MIITOOL_NOOP;
|
|
int addr, bus;
|
|
|
|
while ((opt = getopt(argc, argv, "vs:r:")) > 0) {
|
|
switch (opt) {
|
|
case 'a':
|
|
addr = simple_strtol(optarg, NULL, 0);
|
|
break;
|
|
case 'b':
|
|
bus = simple_strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 's':
|
|
action = MIITOOL_SHOW;
|
|
phydevname = xstrdup(optarg);
|
|
break;
|
|
case 'r':
|
|
action = MIITOOL_REGISTER;
|
|
regstr = optarg;
|
|
break;
|
|
case 'v':
|
|
verbose++;
|
|
break;
|
|
default:
|
|
ret = COMMAND_ERROR_USAGE;
|
|
goto free_phydevname;
|
|
}
|
|
}
|
|
|
|
switch (action) {
|
|
case MIITOOL_REGISTER:
|
|
bus = simple_strtoul(regstr, &endp, 0);
|
|
if (*endp != ':') {
|
|
printf("No colon between bus and address\n");
|
|
return COMMAND_ERROR_USAGE;
|
|
}
|
|
endp++;
|
|
addr = simple_strtoul(endp, NULL, 0);
|
|
|
|
if (addr >= PHY_MAX_ADDR)
|
|
printf("Address out of range (max %d)\n", PHY_MAX_ADDR - 1);
|
|
|
|
mii = mdiobus_get_bus(bus);
|
|
if (!mii) {
|
|
printf("Can't find MDIO bus #%d\n", bus);
|
|
ret = COMMAND_ERROR;
|
|
goto free_phydevname;
|
|
}
|
|
|
|
phydev = phy_device_create(mii, addr, -1);
|
|
ret = phy_register_device(phydev);
|
|
if (ret) {
|
|
printf("failed to register phy %s: %s\n",
|
|
dev_name(&phydev->dev), strerror(-ret));
|
|
goto free_phydevname;
|
|
} else {
|
|
printf("registered phy %s\n", dev_name(&phydev->dev));
|
|
}
|
|
break;
|
|
default:
|
|
case MIITOOL_SHOW:
|
|
for_each_mii_bus(mii) {
|
|
mdiobus_detect(&mii->dev);
|
|
mdiobus_show(&mii->dev, phydevname, verbose);
|
|
}
|
|
break;
|
|
}
|
|
|
|
ret = COMMAND_SUCCESS;
|
|
|
|
free_phydevname:
|
|
free(phydevname);
|
|
return ret;
|
|
}
|
|
|
|
BAREBOX_CMD_HELP_START(miitool)
|
|
BAREBOX_CMD_HELP_TEXT("This utility checks or sets the status of a network interface's")
|
|
BAREBOX_CMD_HELP_TEXT("Media Independent Interface (MII) unit as well as allowing to")
|
|
BAREBOX_CMD_HELP_TEXT("register dummy PHY devices for raw MDIO access. Most fast ethernet")
|
|
BAREBOX_CMD_HELP_TEXT("adapters use an MII to autonegotiate link speed and duplex setting.")
|
|
BAREBOX_CMD_HELP_TEXT("")
|
|
BAREBOX_CMD_HELP_TEXT("Options:")
|
|
BAREBOX_CMD_HELP_OPT("-v", "increase verbosity")
|
|
BAREBOX_CMD_HELP_OPT("-s <devname>", "show PHY status (not providing PHY prints status of all)")
|
|
BAREBOX_CMD_HELP_OPT("-r <busno>:<adr>", "register a PHY")
|
|
BAREBOX_CMD_HELP_END
|
|
|
|
BAREBOX_CMD_START(miitool)
|
|
.cmd = do_miitool,
|
|
BAREBOX_CMD_DESC("view media-independent interface status")
|
|
BAREBOX_CMD_OPTS("[-vsr]")
|
|
BAREBOX_CMD_GROUP(CMD_GRP_NET)
|
|
BAREBOX_CMD_HELP(cmd_miitool_help)
|
|
BAREBOX_CMD_END
|