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