drivers/net/mii.c

   1 /*
   2
   3         mii.c: MII interface library
   4
   5         Maintained by Jeff Garzik <jgarzik@pobox.com>
   6         Copyright 2001,2002 Jeff Garzik
   7
   8         Various code came from myson803.c and other files by
   9         Donald Becker.  Copyright:
  10
  11                 Written 1998-2002 by Donald Becker.
  12
  13                 This software may be used and distributed according
  14                 to the terms of the GNU General Public License (GPL),
  15                 incorporated herein by reference.  Drivers based on
  16                 or derived from this code fall under the GPL and must
  17                 retain the authorship, copyright and license notice.
  18                 This file is not a complete program and may only be
  19                 used when the entire operating system is licensed
  20                 under the GPL.
  21
  22                 The author may be reached as becker@scyld.com, or C/O
  23                 Scyld Computing Corporation
  24                 410 Severn Ave., Suite 210
  25                 Annapolis MD 21403
  26
  27
  28  */
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/ethtool.h>
  34 #include <linux/mii.h>
  35
  36 /**
  37  * mii_ethtool_gset - get settings that are specified in @ecmd
  38  * @mii: MII interface
  39  * @ecmd: requested ethtool_cmd
  40  *
  41  * Returns 0 for success, negative on error.
  42  */
  43 int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
  44 {
  45         struct net_device *dev = mii->dev;
  46         u32 advert, bmcr, lpa, nego;
  47         u32 advert2 = 0, bmcr2 = 0, lpa2 = 0;
  48
  49         ecmd->supported =
  50             (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
  51              SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
  52              SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII);
  53         if (mii->supports_gmii)
  54                 ecmd->supported |= SUPPORTED_1000baseT_Half |
  55                         SUPPORTED_1000baseT_Full;
  56
  57         /* only supports twisted-pair */
  58         ecmd->port = PORT_MII;
  59
  60         /* only supports internal transceiver */
  61         ecmd->transceiver = XCVR_INTERNAL;
  62
  63         /* this isn't fully supported at higher layers */
  64         ecmd->phy_address = mii->phy_id;
  65
  66         ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
  67         advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
  68         if (mii->supports_gmii)
  69                 advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
  70
  71         if (advert & ADVERTISE_10HALF)
  72                 ecmd->advertising |= ADVERTISED_10baseT_Half;
  73         if (advert & ADVERTISE_10FULL)
  74                 ecmd->advertising |= ADVERTISED_10baseT_Full;
  75         if (advert & ADVERTISE_100HALF)
  76                 ecmd->advertising |= ADVERTISED_100baseT_Half;
  77         if (advert & ADVERTISE_100FULL)
  78                 ecmd->advertising |= ADVERTISED_100baseT_Full;
  79         if (advert2 & ADVERTISE_1000HALF)
  80                 ecmd->advertising |= ADVERTISED_1000baseT_Half;
  81         if (advert2 & ADVERTISE_1000FULL)
  82                 ecmd->advertising |= ADVERTISED_1000baseT_Full;
  83
  84         bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
  85         lpa = mii->mdio_read(dev, mii->phy_id, MII_LPA);
  86         if (mii->supports_gmii) {
  87                 bmcr2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
  88                 lpa2 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000);
  89         }
  90         if (bmcr & BMCR_ANENABLE) {
  91                 ecmd->advertising |= ADVERTISED_Autoneg;
  92                 ecmd->autoneg = AUTONEG_ENABLE;
  93
  94                 nego = mii_nway_result(advert & lpa);
  95                 if ((bmcr2 & (ADVERTISE_1000HALF | ADVERTISE_1000FULL)) &
  96                     (lpa2 >> 2))
  97                         ecmd->speed = SPEED_1000;
  98                 else if (nego == LPA_100FULL || nego == LPA_100HALF)
  99                         ecmd->speed = SPEED_100;
 100                 else
 101                         ecmd->speed = SPEED_10;
 102                 if ((lpa2 & LPA_1000FULL) || nego == LPA_100FULL ||
 103                     nego == LPA_10FULL) {
 104                         ecmd->duplex = DUPLEX_FULL;
 105                         mii->full_duplex = 1;
 106                 } else {
 107                         ecmd->duplex = DUPLEX_HALF;
 108                         mii->full_duplex = 0;
 109                 }
 110         } else {
 111                 ecmd->autoneg = AUTONEG_DISABLE;
 112
 113                 ecmd->speed = ((bmcr & BMCR_SPEED1000 &&
 114                                 (bmcr & BMCR_SPEED100) == 0) ? SPEED_1000 :
 115                                (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10);
 116                 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
 117         }
 118
 119         /* ignore maxtxpkt, maxrxpkt for now */
 120
 121         return 0;
 122 }
 123
 124 /**
 125  * mii_ethtool_sset - set settings that are specified in @ecmd
 126  * @mii: MII interface
 127  * @ecmd: requested ethtool_cmd
 128  *
 129  * Returns 0 for success, negative on error.
 130  */
 131 int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd)
 132 {
 133         struct net_device *dev = mii->dev;
 134
 135         if (ecmd->speed != SPEED_10 &&
 136             ecmd->speed != SPEED_100 &&
 137             ecmd->speed != SPEED_1000)
 138                 return -EINVAL;
 139         if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
 140                 return -EINVAL;
 141         if (ecmd->port != PORT_MII)
 142                 return -EINVAL;
 143         if (ecmd->transceiver != XCVR_INTERNAL)
 144                 return -EINVAL;
 145         if (ecmd->phy_address != mii->phy_id)
 146                 return -EINVAL;
 147         if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
 148                 return -EINVAL;
 149         if ((ecmd->speed == SPEED_1000) && (!mii->supports_gmii))
 150                 return -EINVAL;
 151
 152         /* ignore supported, maxtxpkt, maxrxpkt */
 153
 154         if (ecmd->autoneg == AUTONEG_ENABLE) {
 155                 u32 bmcr, advert, tmp;
 156                 u32 advert2 = 0, tmp2 = 0;
 157
 158                 if ((ecmd->advertising & (ADVERTISED_10baseT_Half |
 159                                           ADVERTISED_10baseT_Full |
 160                                           ADVERTISED_100baseT_Half |
 161                                           ADVERTISED_100baseT_Full |
 162                                           ADVERTISED_1000baseT_Half |
 163                                           ADVERTISED_1000baseT_Full)) == 0)
 164                         return -EINVAL;
 165
 166                 /* advertise only what has been requested */
 167                 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE);
 168                 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4);
 169                 if (mii->supports_gmii) {
 170                         advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000);
 171                         tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
 172                 }
 173                 if (ecmd->advertising & ADVERTISED_10baseT_Half)
 174                         tmp |= ADVERTISE_10HALF;
 175                 if (ecmd->advertising & ADVERTISED_10baseT_Full)
 176                         tmp |= ADVERTISE_10FULL;
 177                 if (ecmd->advertising & ADVERTISED_100baseT_Half)
 178                         tmp |= ADVERTISE_100HALF;
 179                 if (ecmd->advertising & ADVERTISED_100baseT_Full)
 180                         tmp |= ADVERTISE_100FULL;
 181                 if (mii->supports_gmii) {
 182                         if (ecmd->advertising & ADVERTISED_1000baseT_Half)
 183                                 tmp2 |= ADVERTISE_1000HALF;
 184                         if (ecmd->advertising & ADVERTISED_1000baseT_Full)
 185                                 tmp2 |= ADVERTISE_1000FULL;
 186                 }
 187                 if (advert != tmp) {
 188                         mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp);
 189                         mii->advertising = tmp;
 190                 }
 191                 if ((mii->supports_gmii) && (advert2 != tmp2))
 192                         mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2);
 193
 194                 /* turn on autonegotiation, and force a renegotiate */
 195                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
 196                 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART);
 197                 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr);
 198
 199                 mii->force_media = 0;
 200         } else {
 201                 u32 bmcr, tmp;
 202
 203                 /* turn off auto negotiation, set speed and duplexity */
 204                 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR);
 205                 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 |
 206                                BMCR_SPEED1000 | BMCR_FULLDPLX);
 207                 if (ecmd->speed == SPEED_1000)
 208                         tmp |= BMCR_SPEED1000;
 209                 else if (ecmd->speed == SPEED_100)
 210                         tmp |= BMCR_SPEED100;
 211                 if (ecmd->duplex == DUPLEX_FULL) {
 212                         tmp |= BMCR_FULLDPLX;
 213                         mii->full_duplex = 1;
 214                 } else
 215                         mii->full_duplex = 0;
 216                 if (bmcr != tmp)
 217                         mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp);
 218
 219                 mii->force_media = 1;
 220         }
 221         return 0;
 222 }
 223
 224 /**
 225  * mii_check_gmii_support - check if the MII supports Gb interfaces
 226  * @mii: the MII interface
 227  */
 228 int mii_check_gmii_support(struct mii_if_info *mii)
 229 {
 230         int reg;
 231
 232         reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
 233         if (reg & BMSR_ESTATEN) {
 234                 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS);
 235                 if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF))
 236                         return 1;
 237         }
 238
 239         return 0;
 240 }
 241
 242 /**
 243  * mii_link_ok - is link status up/ok
 244  * @mii: the MII interface
 245  *
 246  * Returns 1 if the MII reports link status up/ok, 0 otherwise.
 247  */
 248 int mii_link_ok (struct mii_if_info *mii)
 249 {
 250         /* first, a dummy read, needed to latch some MII phys */
 251         mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
 252         if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS)
 253                 return 1;
 254         return 0;
 255 }
 256
 257 /**
 258  * mii_nway_restart - restart NWay (autonegotiation) for this interface
 259  * @mii: the MII interface
 260  *
 261  * Returns 0 on success, negative on error.
 262  */
 263 int mii_nway_restart (struct mii_if_info *mii)
 264 {
 265         int bmcr;
 266         int r = -EINVAL;
 267
 268         /* if autoneg is off, it's an error */
 269         bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
 270
 271         if (bmcr & BMCR_ANENABLE) {
 272                 bmcr |= BMCR_ANRESTART;
 273                 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr);
 274                 r = 0;
 275         }
 276
 277         return r;
 278 }
 279
 280 /**
 281  * mii_check_link - check MII link status
 282  * @mii: MII interface
 283  *
 284  * If the link status changed (previous != current), call
 285  * netif_carrier_on() if current link status is Up or call
 286  * netif_carrier_off() if current link status is Down.
 287  */
 288 void mii_check_link (struct mii_if_info *mii)
 289 {
 290         int cur_link = mii_link_ok(mii);
 291         int prev_link = netif_carrier_ok(mii->dev);
 292
 293         if (cur_link && !prev_link)
 294                 netif_carrier_on(mii->dev);
 295         else if (prev_link && !cur_link)
 296                 netif_carrier_off(mii->dev);
 297 }
 298
 299 /**
 300  * mii_check_media - check the MII interface for a duplex change
 301  * @mii: the MII interface
 302  * @ok_to_print: OK to print link up/down messages
 303  * @init_media: OK to save duplex mode in @mii
 304  *
 305  * Returns 1 if the duplex mode changed, 0 if not.
 306  * If the media type is forced, always returns 0.
 307  */
 308 unsigned int mii_check_media (struct mii_if_info *mii,
 309                               unsigned int ok_to_print,
 310                               unsigned int init_media)
 311 {
 312         unsigned int old_carrier, new_carrier;
 313         int advertise, lpa, media, duplex;
 314         int lpa2 = 0;
 315
 316         /* if forced media, go no further */
 317         if (mii->force_media)
 318                 return 0; /* duplex did not change */
 319
 320         /* check current and old link status */
 321         old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0;
 322         new_carrier = (unsigned int) mii_link_ok(mii);
 323
 324         /* if carrier state did not change, this is a "bounce",
 325          * just exit as everything is already set correctly
 326          */
 327         if ((!init_media) && (old_carrier == new_carrier))
 328                 return 0; /* duplex did not change */
 329
 330         /* no carrier, nothing much to do */
 331         if (!new_carrier) {
 332                 netif_carrier_off(mii->dev);
 333                 if (ok_to_print)
 334                         printk(KERN_INFO "%s: link down\n", mii->dev->name);
 335                 return 0; /* duplex did not change */
 336         }
 337
 338         /*
 339          * we have carrier, see who's on the other end
 340          */
 341         netif_carrier_on(mii->dev);
 342
 343         /* get MII advertise and LPA values */
 344         if ((!init_media) && (mii->advertising))
 345                 advertise = mii->advertising;
 346         else {
 347                 advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
 348                 mii->advertising = advertise;
 349         }
 350         lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA);
 351         if (mii->supports_gmii)
 352                 lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000);
 353
 354         /* figure out media and duplex from advertise and LPA values */
 355         media = mii_nway_result(lpa & advertise);
 356         duplex = (media & ADVERTISE_FULL) ? 1 : 0;
 357         if (lpa2 & LPA_1000FULL)
 358                 duplex = 1;
 359
 360         if (ok_to_print)
 361                 printk(KERN_INFO "%s: link up, %sMbps, %s-duplex, lpa 0x%04X\n",
 362                        mii->dev->name,
 363                        lpa2 & (LPA_1000FULL | LPA_1000HALF) ? "1000" :
 364                        media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ? "100" : "10",
 365                        duplex ? "full" : "half",
 366                        lpa);
 367
 368         if ((init_media) || (mii->full_duplex != duplex)) {
 369                 mii->full_duplex = duplex;
 370                 return 1; /* duplex changed */
 371         }
 372
 373         return 0; /* duplex did not change */
 374 }
 375
 376 /**
 377  * generic_mii_ioctl - main MII ioctl interface
 378  * @mii_if: the MII interface
 379  * @mii_data: MII ioctl data structure
 380  * @cmd: MII ioctl command
 381  * @duplex_chg_out: pointer to @duplex_changed status if there was no
 382  *      ioctl error
 383  *
 384  * Returns 0 on success, negative on error.
 385  */
 386 int generic_mii_ioctl(struct mii_if_info *mii_if,
 387                       struct mii_ioctl_data *mii_data, int cmd,
 388                       unsigned int *duplex_chg_out)
 389 {
 390         int rc = 0;
 391         unsigned int duplex_changed = 0;
 392
 393         if (duplex_chg_out)
 394                 *duplex_chg_out = 0;
 395
 396         mii_data->phy_id &= mii_if->phy_id_mask;
 397         mii_data->reg_num &= mii_if->reg_num_mask;
 398
 399         switch(cmd) {
 400         case SIOCGMIIPHY:
 401                 mii_data->phy_id = mii_if->phy_id;
 402                 /* fall through */
 403
 404         case SIOCGMIIREG:
 405                 mii_data->val_out =
 406                         mii_if->mdio_read(mii_if->dev, mii_data->phy_id,
 407                                           mii_data->reg_num);
 408                 break;
 409
 410         case SIOCSMIIREG: {
 411                 u16 val = mii_data->val_in;
 412
 413                 if (!capable(CAP_NET_ADMIN))
 414                         return -EPERM;
 415
 416                 if (mii_data->phy_id == mii_if->phy_id) {
 417                         switch(mii_data->reg_num) {
 418                         case MII_BMCR: {
 419                                 unsigned int new_duplex = 0;
 420                                 if (val & (BMCR_RESET|BMCR_ANENABLE))
 421                                         mii_if->force_media = 0;
 422                                 else
 423                                         mii_if->force_media = 1;
 424                                 if (mii_if->force_media &&
 425                                     (val & BMCR_FULLDPLX))
 426                                         new_duplex = 1;
 427                                 if (mii_if->full_duplex != new_duplex) {
 428                                         duplex_changed = 1;
 429                                         mii_if->full_duplex = new_duplex;
 430                                 }
 431                                 break;
 432                         }
 433                         case MII_ADVERTISE:
 434                                 mii_if->advertising = val;
 435                                 break;
 436                         default:
 437                                 /* do nothing */
 438                                 break;
 439                         }
 440                 }
 441
 442                 mii_if->mdio_write(mii_if->dev, mii_data->phy_id,
 443                                    mii_data->reg_num, val);
 444                 break;
 445         }
 446
 447         default:
 448                 rc = -EOPNOTSUPP;
 449                 break;
 450         }
 451
 452         if ((rc == 0) && (duplex_chg_out) && (duplex_changed))
 453                 *duplex_chg_out = 1;
 454
 455         return rc;
 456 }
 457
 458 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
 459 MODULE_DESCRIPTION ("MII hardware support library");
 460 MODULE_LICENSE("GPL");
 461
 462 EXPORT_SYMBOL(mii_link_ok);
 463 EXPORT_SYMBOL(mii_nway_restart);
 464 EXPORT_SYMBOL(mii_ethtool_gset);
 465 EXPORT_SYMBOL(mii_ethtool_sset);
 466 EXPORT_SYMBOL(mii_check_link);
 467 EXPORT_SYMBOL(mii_check_media);
 468 EXPORT_SYMBOL(mii_check_gmii_support);
 469 EXPORT_SYMBOL(generic_mii_ioctl);
 470