e1d66d2
diff -up net-tools-1.60/mii-tool.c.mii-gigabit net-tools-1.60/mii-tool.c
e1d66d2
--- net-tools-1.60/mii-tool.c.mii-gigabit	2010-06-14 15:51:23.000000000 +0200
e1d66d2
+++ net-tools-1.60/mii-tool.c	2010-06-14 16:10:34.000000000 +0200
e1d66d2
@@ -57,7 +57,7 @@ static char version[] =
e1d66d2
 #define LPA_ABILITY_MASK	0x07e0
e1d66d2
 
e1d66d2
 /* Table of known MII's */
e1d66d2
-static struct {
e1d66d2
+static const struct {
e1d66d2
     u_short	id1, id2;
e1d66d2
     char	*name;
e1d66d2
 } mii_id[] = {
e1d66d2
@@ -76,6 +76,9 @@ static struct {
e1d66d2
     { 0x0181, 0x4410, "Quality QS6612" },
e1d66d2
     { 0x0282, 0x1c50, "SMSC 83C180" },
e1d66d2
     { 0x0300, 0xe540, "TDK 78Q2120" },
e1d66d2
+    { 0x0141, 0x0c20, "Yukon 88E1011" },
e1d66d2
+    { 0x0141, 0x0cc0, "Yukon-EC 88E1111" },
e1d66d2
+    { 0x0141, 0x0c90, "Yukon-2 88E1112" },
e1d66d2
 };
e1d66d2
 #define NMII (sizeof(mii_id)/sizeof(mii_id[0]))
e1d66d2
 
e1d66d2
@@ -139,40 +142,47 @@ static void mdio_write(int skfd, int loc
e1d66d2
 
e1d66d2
 const struct {
e1d66d2
     char	*name;
e1d66d2
-    u_short	value;
e1d66d2
+    u_short	value[2];
e1d66d2
 } media[] = {
e1d66d2
     /* The order through 100baseT4 matches bits in the BMSR */
e1d66d2
-    { "10baseT-HD",	LPA_10HALF },
e1d66d2
-    { "10baseT-FD",	LPA_10FULL },
e1d66d2
-    { "100baseTx-HD",	LPA_100HALF },
e1d66d2
-    { "100baseTx-FD",	LPA_100FULL },
e1d66d2
-    { "100baseT4",	LPA_100BASE4 },
e1d66d2
-    { "100baseTx",	LPA_100FULL | LPA_100HALF },
e1d66d2
-    { "10baseT",	LPA_10FULL | LPA_10HALF },
e1d66d2
+    { "10baseT-HD",     {LPA_10HALF} },
e1d66d2
+    { "10baseT-FD",     {LPA_10FULL} },
e1d66d2
+    { "100baseTx-HD",   {LPA_100HALF} },
e1d66d2
+    { "100baseTx-FD",   {LPA_100FULL} },
e1d66d2
+    { "100baseT4",      {LPA_100BASE4} },
e1d66d2
+    { "100baseTx",      {LPA_100FULL | LPA_100HALF} },
e1d66d2
+    { "10baseT",        {LPA_10FULL | LPA_10HALF} },
e1d66d2
+    { "1000baseT-HD",   {0, ADVERTISE_1000HALF} },
e1d66d2
+    { "1000baseT-FD",   {0, ADVERTISE_1000FULL} },
e1d66d2
+    { "1000baseT",      {0, ADVERTISE_1000HALF|ADVERTISE_1000FULL} },
e1d66d2
 };
e1d66d2
 #define NMEDIA (sizeof(media)/sizeof(media[0]))
e1d66d2
 	
e1d66d2
 /* Parse an argument list of media types */
e1d66d2
-static int parse_media(char *arg)
e1d66d2
+static int parse_media(char *arg, unsigned *bmcr2)
e1d66d2
 {
e1d66d2
     int mask, i;
e1d66d2
     char *s;
e1d66d2
     mask = strtoul(arg, &s, 16);
e1d66d2
     if ((*arg != '\0') && (*s == '\0')) {
e1d66d2
-	if ((mask & LPA_ABILITY_MASK) &&
e1d66d2
-	    !(mask & ~LPA_ABILITY_MASK))
e1d66d2
-	    return mask;
e1d66d2
-	goto failed;
e1d66d2
-    } else {
e1d66d2
-	mask = 0;
e1d66d2
-	s = strtok(arg, ", ");
e1d66d2
-	do {
e1d66d2
-	    for (i = 0; i < NMEDIA; i++)
e1d66d2
-		if (strcasecmp(media[i].name, s) == 0) break;
e1d66d2
-	    if (i == NMEDIA) goto failed;
e1d66d2
-	    mask |= media[i].value;
e1d66d2
-	} while ((s = strtok(NULL, ", ")) != NULL);
e1d66d2
-    }
e1d66d2
+        if ((mask & LPA_ABILITY_MASK) &&
e1d66d2
+            !(mask & ~LPA_ABILITY_MASK)) {
e1d66d2
+            *bmcr2 = 0;
e1d66d2
+            return mask;
e1d66d2
+        }
e1d66d2
+        goto failed;
e1d66d2
+    }
e1d66d2
+    mask = 0;
e1d66d2
+    *bmcr2 = 0;
e1d66d2
+    s = strtok(arg, ", ");
e1d66d2
+    do {
e1d66d2
+        for (i = 0; i < NMEDIA; i++)
e1d66d2
+        if (s && strcasecmp(media[i].name, s) == 0) break;
e1d66d2
+        if (i == NMEDIA) goto failed;
e1d66d2
+        mask |= media[i].value[0];
e1d66d2
+        *bmcr2 |= media[i].value[1];
e1d66d2
+    } while ((s = strtok(NULL, ", ")) != NULL);
e1d66d2
+
e1d66d2
     return mask;
e1d66d2
 failed:
e1d66d2
     fprintf(stderr, "Invalid media specification '%s'.\n", arg);
e1d66d2
@@ -181,11 +191,25 @@ failed:
e1d66d2
 
e1d66d2
 /*--------------------------------------------------------------------*/
e1d66d2
 
e1d66d2
-static char *media_list(int mask, int best)
e1d66d2
+static const char *media_list(unsigned mask, unsigned mask2, int best)
e1d66d2
 {
e1d66d2
     static char buf[100];
e1d66d2
     int i;
e1d66d2
     *buf = '\0';
e1d66d2
+
e1d66d2
+    if (mask & BMCR_SPEED1000) {
e1d66d2
+        if (mask2 & ADVERTISE_1000HALF) {
e1d66d2
+            strcat(buf, " ");
e1d66d2
+            strcat(buf, "1000baseT-HD");
e1d66d2
+            if (best) goto out;
e1d66d2
+        }
e1d66d2
+        if (mask2 & ADVERTISE_1000FULL) {
e1d66d2
+            strcat(buf, " ");
e1d66d2
+            strcat(buf, "1000baseT-FD");
e1d66d2
+            if (best) goto out;
e1d66d2
+        }
e1d66d2
+    }
e1d66d2
+
e1d66d2
     mask >>= 5;
e1d66d2
     for (i = 4; i >= 0; i--) {
e1d66d2
 	if (mask & (1<
e1d66d2
@@ -194,6 +218,7 @@ static char *media_list(int mask, int be
e1d66d2
 	    if (best) break;
e1d66d2
 	}
e1d66d2
     }
e1d66d2
+out:
e1d66d2
     if (mask & (1<<5))
e1d66d2
 	strcat(buf, " flow-control");
e1d66d2
     return buf;
e1d66d2
@@ -203,11 +228,11 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
 {
e1d66d2
     char buf[100];
e1d66d2
     int i, mii_val[32];
e1d66d2
-    int bmcr, bmsr, advert, lkpar;
e1d66d2
+    unsigned bmcr, bmsr, advert, lkpar, bmcr2, lpa2;
e1d66d2
     /* Some bits in the BMSR are latched, but we can't rely on being
e1d66d2
        the only reader, so only the current values are meaningful */
e1d66d2
     mdio_read(sock, MII_BMSR);
e1d66d2
-    for (i = 0; i < ((verbose > 1) ? 32 : 8); i++) {
e1d66d2
+    for (i = 0; i < ((verbose > 1) ? 32 : (MII_STAT1000+1)); i++) {
e1d66d2
         if ((i == MII_BMCR) || (i == MII_BMSR) || (i == MII_PHYSID1) ||
e1d66d2
             (i == MII_PHYSID2) || (i == MII_ADVERTISE) || (i == MII_LPA) ||
e1d66d2
             (i == MII_EXPANSION) || (i == MII_CTRL1000) || (i == MII_STAT1000) ||
e1d66d2
@@ -220,7 +245,7 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
         else
e1d66d2
             mii_val[i] = 0;
e1d66d2
     }
e1d66d2
-    if (mii_val[MII_BMCR] == 0xffff) {
e1d66d2
+    if (mii_val[MII_BMCR] == 0xffff  || mii_val[MII_BMSR] == 0x0000) {
e1d66d2
 	fprintf(stderr, "  No MII transceiver present!.\n");
e1d66d2
 	return -1;
e1d66d2
     }
e1d66d2
@@ -228,6 +253,7 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
     /* Descriptive rename. */
e1d66d2
     bmcr = mii_val[MII_BMCR]; bmsr = mii_val[MII_BMSR];
e1d66d2
     advert = mii_val[MII_ADVERTISE]; lkpar = mii_val[MII_LPA];
e1d66d2
+    bmcr2 = mii_val[MII_CTRL1000]; lpa2 = mii_val[MII_STAT1000];
e1d66d2
 
e1d66d2
     sprintf(buf, "%s: ", ifr.ifr_name);
e1d66d2
     if (bmcr & BMCR_ANENABLE) {
e1d66d2
@@ -235,7 +261,7 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
 	    if (advert & lkpar) {
e1d66d2
 		strcat(buf, (lkpar & LPA_LPACK) ?
e1d66d2
 		       "negotiated" : "no autonegotiation,");
e1d66d2
-		strcat(buf, media_list(advert & lkpar, 1));
e1d66d2
+		strcat(buf, media_list(advert & lkpar, bmcr2 & lpa2>>2, 1));
e1d66d2
 		strcat(buf, ", ");
e1d66d2
 	    } else {
e1d66d2
 		strcat(buf, "autonegotiation failed, ");
e1d66d2
@@ -245,8 +271,10 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
 	}
e1d66d2
     } else {
e1d66d2
 	sprintf(buf+strlen(buf), "%s Mbit, %s duplex, ",
e1d66d2
-	       (bmcr & BMCR_SPEED100) ? "100" : "10",
e1d66d2
-	       (bmcr & BMCR_FULLDPLX) ? "full" : "half");
e1d66d2
+		((bmcr2 & (ADVERTISE_1000HALF | ADVERTISE_1000FULL)) & lpa2 >> 2)
e1d66d2
+		? "1000"
e1d66d2
+		: (bmcr & BMCR_SPEED100) ? "100" : "10",
e1d66d2
+		(bmcr & BMCR_FULLDPLX) ? "full" : "half");
e1d66d2
     }
e1d66d2
     strcat(buf, (bmsr & BMSR_LSTATUS) ? "link ok" : "no link");
e1d66d2
 
e1d66d2
@@ -307,10 +335,10 @@ int show_basic_mii(int sock, int phy_id)
e1d66d2
 	if (bmsr & BMSR_RFAULT)
e1d66d2
 	    printf("remote fault, ");
e1d66d2
 	printf((bmsr & BMSR_LSTATUS) ? "link ok" : "no link");
e1d66d2
-	printf("\n  capabilities:%s", media_list(bmsr >> 6, 0));
e1d66d2
-	printf("\n  advertising: %s", media_list(advert, 0));
e1d66d2
+	printf("\n  capabilities:%s", media_list(bmsr >> 6, bmcr2, 0));
e1d66d2
+	printf("\n  advertising: %s", media_list(advert, lpa2 >> 2, 0));
e1d66d2
 	if (lkpar & LPA_ABILITY_MASK)
e1d66d2
-	    printf("\n  link partner:%s", media_list(lkpar, 0));
e1d66d2
+	    printf("\n  link partner:%s", media_list(lkpar, bmcr2, 0));
e1d66d2
 	printf("\n");
e1d66d2
     }
e1d66d2
     fflush(stdout);
e1d66d2
@@ -341,7 +369,7 @@ static int do_one_xcvr(int skfd, char *i
e1d66d2
 	printf("resetting the transceiver...\n");
e1d66d2
 	mdio_write(skfd, MII_BMCR, BMCR_RESET);
e1d66d2
     }
e1d66d2
-    if (nway_advertise) {
e1d66d2
+    if (nway_advertise > 0) {
e1d66d2
 	mdio_write(skfd, MII_ADVERTISE, nway_advertise | 1);
e1d66d2
 	opt_restart = 1;
e1d66d2
     }
e1d66d2
@@ -400,18 +428,20 @@ usage: %s [-VvRrwl] [-A media,... | -F m
e1d66d2
        -l, --log                   with -w, write events to syslog\n\
e1d66d2
        -A, --advertise=media,...   advertise only specified media\n\
e1d66d2
        -F, --force=media           force specified media technology\n\
e1d66d2
-media: 100baseT4, 100baseTx-FD, 100baseTx-HD, 10baseT-FD, 10baseT-HD,\n\
e1d66d2
+media: 1000baseTx-HD, 1000baseTx-FD,\n\
e1d66d2
+       100baseT4, 100baseTx-FD, 100baseTx-HD, 10baseT-FD, 10baseT-HD,\n\
e1d66d2
        (to advertise both HD and FD) 100baseTx, 10baseT\n";
e1d66d2
 
e1d66d2
 int main(int argc, char **argv)
e1d66d2
 {
e1d66d2
     int i, c, ret, errflag = 0;
e1d66d2
     char s[6];
e1d66d2
-    
e1d66d2
+    unsigned ctrl1000 = 0;
e1d66d2
+
e1d66d2
     while ((c = getopt_long(argc, argv, "A:F:p:lrRvVw?", longopts, 0)) != EOF)
e1d66d2
 	switch (c) {
e1d66d2
-	case 'A': nway_advertise = parse_media(optarg); break;
e1d66d2
-	case 'F': fixed_speed = parse_media(optarg); break;
e1d66d2
+	case 'A': nway_advertise = parse_media(optarg, &ctrl1000); break;
e1d66d2
+	case 'F': fixed_speed = parse_media(optarg, &ctrl1000); break;
e1d66d2
 	case 'p': override_phy = atoi(optarg); break;
e1d66d2
 	case 'r': opt_restart++;	break;
e1d66d2
 	case 'R': opt_reset++;		break;
e1d66d2
@@ -423,6 +453,10 @@ int main(int argc, char **argv)
e1d66d2
 	}
e1d66d2
     /* Check for a few inappropriate option combinations */
e1d66d2
     if (opt_watch) verbose = 0;
e1d66d2
+
e1d66d2
+    if ((nway_advertise < 0) || (fixed_speed < 0))
e1d66d2
+        return 2;
e1d66d2
+
e1d66d2
     if (errflag || (fixed_speed & (fixed_speed-1)) ||
e1d66d2
 	(fixed_speed && (opt_restart || nway_advertise))) {
e1d66d2
 	fprintf(stderr, usage, argv[0]);