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 static u32 mii_get_an(struct mii_if_info *mii, u16 addr) 37 { 38 int advert; 39 40 advert = mii->mdio_read(mii->dev, mii->phy_id, addr); 41 42 return mii_lpa_to_ethtool_lpa_t(advert); 43 } 44 45 /** 46 * mii_ethtool_gset - get settings that are specified in @ecmd 47 * @mii: MII interface 48 * @ecmd: requested ethtool_cmd 49 * 50 * The @ecmd parameter is expected to have been cleared before calling 51 * mii_ethtool_gset(). 52 * 53 * Returns 0 for success, negative on error. 54 */ 55 int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd) 56 { 57 struct net_device *dev = mii->dev; 58 u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0; 59 u32 nego; 60 61 ecmd->supported = 62 (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | 63 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | 64 SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII); 65 if (mii->supports_gmii) 66 ecmd->supported |= SUPPORTED_1000baseT_Half | 67 SUPPORTED_1000baseT_Full; 68 69 /* only supports twisted-pair */ 70 ecmd->port = PORT_MII; 71 72 /* only supports internal transceiver */ 73 ecmd->transceiver = XCVR_INTERNAL; 74 75 /* this isn't fully supported at higher layers */ 76 ecmd->phy_address = mii->phy_id; 77 ecmd->mdio_support = ETH_MDIO_SUPPORTS_C22; 78 79 ecmd->advertising = ADVERTISED_TP | ADVERTISED_MII; 80 81 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 82 bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR); 83 if (mii->supports_gmii) { 84 ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000); 85 stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000); 86 } 87 if (bmcr & BMCR_ANENABLE) { 88 ecmd->advertising |= ADVERTISED_Autoneg; 89 ecmd->autoneg = AUTONEG_ENABLE; 90 91 ecmd->advertising |= mii_get_an(mii, MII_ADVERTISE); 92 if (mii->supports_gmii) 93 ecmd->advertising |= 94 mii_ctrl1000_to_ethtool_adv_t(ctrl1000); 95 96 if (bmsr & BMSR_ANEGCOMPLETE) { 97 ecmd->lp_advertising = mii_get_an(mii, MII_LPA); 98 ecmd->lp_advertising |= 99 mii_stat1000_to_ethtool_lpa_t(stat1000); 100 } else { 101 ecmd->lp_advertising = 0; 102 } 103 104 nego = ecmd->advertising & ecmd->lp_advertising; 105 106 if (nego & (ADVERTISED_1000baseT_Full | 107 ADVERTISED_1000baseT_Half)) { 108 ethtool_cmd_speed_set(ecmd, SPEED_1000); 109 ecmd->duplex = !!(nego & ADVERTISED_1000baseT_Full); 110 } else if (nego & (ADVERTISED_100baseT_Full | 111 ADVERTISED_100baseT_Half)) { 112 ethtool_cmd_speed_set(ecmd, SPEED_100); 113 ecmd->duplex = !!(nego & ADVERTISED_100baseT_Full); 114 } else { 115 ethtool_cmd_speed_set(ecmd, SPEED_10); 116 ecmd->duplex = !!(nego & ADVERTISED_10baseT_Full); 117 } 118 } else { 119 ecmd->autoneg = AUTONEG_DISABLE; 120 121 ethtool_cmd_speed_set(ecmd, 122 ((bmcr & BMCR_SPEED1000 && 123 (bmcr & BMCR_SPEED100) == 0) ? 124 SPEED_1000 : 125 ((bmcr & BMCR_SPEED100) ? 126 SPEED_100 : SPEED_10))); 127 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; 128 } 129 130 mii->full_duplex = ecmd->duplex; 131 132 /* ignore maxtxpkt, maxrxpkt for now */ 133 134 return 0; 135 } 136 137 /** 138 * mii_ethtool_get_link_ksettings - get settings that are specified in @cmd 139 * @mii: MII interface 140 * @cmd: requested ethtool_link_ksettings 141 * 142 * The @cmd parameter is expected to have been cleared before calling 143 * mii_ethtool_get_link_ksettings(). 144 */ 145 void mii_ethtool_get_link_ksettings(struct mii_if_info *mii, 146 struct ethtool_link_ksettings *cmd) 147 { 148 struct net_device *dev = mii->dev; 149 u16 bmcr, bmsr, ctrl1000 = 0, stat1000 = 0; 150 u32 nego, supported, advertising, lp_advertising; 151 152 supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | 153 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | 154 SUPPORTED_Autoneg | SUPPORTED_TP | SUPPORTED_MII); 155 if (mii->supports_gmii) 156 supported |= SUPPORTED_1000baseT_Half | 157 SUPPORTED_1000baseT_Full; 158 159 /* only supports twisted-pair */ 160 cmd->base.port = PORT_MII; 161 162 /* this isn't fully supported at higher layers */ 163 cmd->base.phy_address = mii->phy_id; 164 cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22; 165 166 advertising = ADVERTISED_TP | ADVERTISED_MII; 167 168 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 169 bmsr = mii->mdio_read(dev, mii->phy_id, MII_BMSR); 170 if (mii->supports_gmii) { 171 ctrl1000 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000); 172 stat1000 = mii->mdio_read(dev, mii->phy_id, MII_STAT1000); 173 } 174 if (bmcr & BMCR_ANENABLE) { 175 advertising |= ADVERTISED_Autoneg; 176 cmd->base.autoneg = AUTONEG_ENABLE; 177 178 advertising |= mii_get_an(mii, MII_ADVERTISE); 179 if (mii->supports_gmii) 180 advertising |= mii_ctrl1000_to_ethtool_adv_t(ctrl1000); 181 182 if (bmsr & BMSR_ANEGCOMPLETE) { 183 lp_advertising = mii_get_an(mii, MII_LPA); 184 lp_advertising |= 185 mii_stat1000_to_ethtool_lpa_t(stat1000); 186 } else { 187 lp_advertising = 0; 188 } 189 190 nego = advertising & lp_advertising; 191 192 if (nego & (ADVERTISED_1000baseT_Full | 193 ADVERTISED_1000baseT_Half)) { 194 cmd->base.speed = SPEED_1000; 195 cmd->base.duplex = !!(nego & ADVERTISED_1000baseT_Full); 196 } else if (nego & (ADVERTISED_100baseT_Full | 197 ADVERTISED_100baseT_Half)) { 198 cmd->base.speed = SPEED_100; 199 cmd->base.duplex = !!(nego & ADVERTISED_100baseT_Full); 200 } else { 201 cmd->base.speed = SPEED_10; 202 cmd->base.duplex = !!(nego & ADVERTISED_10baseT_Full); 203 } 204 } else { 205 cmd->base.autoneg = AUTONEG_DISABLE; 206 207 cmd->base.speed = ((bmcr & BMCR_SPEED1000 && 208 (bmcr & BMCR_SPEED100) == 0) ? 209 SPEED_1000 : 210 ((bmcr & BMCR_SPEED100) ? 211 SPEED_100 : SPEED_10)); 212 cmd->base.duplex = (bmcr & BMCR_FULLDPLX) ? 213 DUPLEX_FULL : DUPLEX_HALF; 214 215 lp_advertising = 0; 216 } 217 218 mii->full_duplex = cmd->base.duplex; 219 220 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 221 supported); 222 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 223 advertising); 224 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising, 225 lp_advertising); 226 227 /* ignore maxtxpkt, maxrxpkt for now */ 228 } 229 230 /** 231 * mii_ethtool_sset - set settings that are specified in @ecmd 232 * @mii: MII interface 233 * @ecmd: requested ethtool_cmd 234 * 235 * Returns 0 for success, negative on error. 236 */ 237 int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd) 238 { 239 struct net_device *dev = mii->dev; 240 u32 speed = ethtool_cmd_speed(ecmd); 241 242 if (speed != SPEED_10 && 243 speed != SPEED_100 && 244 speed != SPEED_1000) 245 return -EINVAL; 246 if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL) 247 return -EINVAL; 248 if (ecmd->port != PORT_MII) 249 return -EINVAL; 250 if (ecmd->transceiver != XCVR_INTERNAL) 251 return -EINVAL; 252 if (ecmd->phy_address != mii->phy_id) 253 return -EINVAL; 254 if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE) 255 return -EINVAL; 256 if ((speed == SPEED_1000) && (!mii->supports_gmii)) 257 return -EINVAL; 258 259 /* ignore supported, maxtxpkt, maxrxpkt */ 260 261 if (ecmd->autoneg == AUTONEG_ENABLE) { 262 u32 bmcr, advert, tmp; 263 u32 advert2 = 0, tmp2 = 0; 264 265 if ((ecmd->advertising & (ADVERTISED_10baseT_Half | 266 ADVERTISED_10baseT_Full | 267 ADVERTISED_100baseT_Half | 268 ADVERTISED_100baseT_Full | 269 ADVERTISED_1000baseT_Half | 270 ADVERTISED_1000baseT_Full)) == 0) 271 return -EINVAL; 272 273 /* advertise only what has been requested */ 274 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE); 275 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4); 276 if (mii->supports_gmii) { 277 advert2 = mii->mdio_read(dev, mii->phy_id, MII_CTRL1000); 278 tmp2 = advert2 & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL); 279 } 280 tmp |= ethtool_adv_to_mii_adv_t(ecmd->advertising); 281 282 if (mii->supports_gmii) 283 tmp2 |= 284 ethtool_adv_to_mii_ctrl1000_t(ecmd->advertising); 285 if (advert != tmp) { 286 mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp); 287 mii->advertising = tmp; 288 } 289 if ((mii->supports_gmii) && (advert2 != tmp2)) 290 mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2); 291 292 /* turn on autonegotiation, and force a renegotiate */ 293 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 294 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); 295 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr); 296 297 mii->force_media = 0; 298 } else { 299 u32 bmcr, tmp; 300 301 /* turn off auto negotiation, set speed and duplexity */ 302 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 303 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 | 304 BMCR_SPEED1000 | BMCR_FULLDPLX); 305 if (speed == SPEED_1000) 306 tmp |= BMCR_SPEED1000; 307 else if (speed == SPEED_100) 308 tmp |= BMCR_SPEED100; 309 if (ecmd->duplex == DUPLEX_FULL) { 310 tmp |= BMCR_FULLDPLX; 311 mii->full_duplex = 1; 312 } else 313 mii->full_duplex = 0; 314 if (bmcr != tmp) 315 mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp); 316 317 mii->force_media = 1; 318 } 319 return 0; 320 } 321 322 /** 323 * mii_ethtool_set_link_ksettings - set settings that are specified in @cmd 324 * @mii: MII interfaces 325 * @cmd: requested ethtool_link_ksettings 326 * 327 * Returns 0 for success, negative on error. 328 */ 329 int mii_ethtool_set_link_ksettings(struct mii_if_info *mii, 330 const struct ethtool_link_ksettings *cmd) 331 { 332 struct net_device *dev = mii->dev; 333 u32 speed = cmd->base.speed; 334 335 if (speed != SPEED_10 && 336 speed != SPEED_100 && 337 speed != SPEED_1000) 338 return -EINVAL; 339 if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL) 340 return -EINVAL; 341 if (cmd->base.port != PORT_MII) 342 return -EINVAL; 343 if (cmd->base.phy_address != mii->phy_id) 344 return -EINVAL; 345 if (cmd->base.autoneg != AUTONEG_DISABLE && 346 cmd->base.autoneg != AUTONEG_ENABLE) 347 return -EINVAL; 348 if ((speed == SPEED_1000) && (!mii->supports_gmii)) 349 return -EINVAL; 350 351 /* ignore supported, maxtxpkt, maxrxpkt */ 352 353 if (cmd->base.autoneg == AUTONEG_ENABLE) { 354 u32 bmcr, advert, tmp; 355 u32 advert2 = 0, tmp2 = 0; 356 u32 advertising; 357 358 ethtool_convert_link_mode_to_legacy_u32( 359 &advertising, cmd->link_modes.advertising); 360 361 if ((advertising & (ADVERTISED_10baseT_Half | 362 ADVERTISED_10baseT_Full | 363 ADVERTISED_100baseT_Half | 364 ADVERTISED_100baseT_Full | 365 ADVERTISED_1000baseT_Half | 366 ADVERTISED_1000baseT_Full)) == 0) 367 return -EINVAL; 368 369 /* advertise only what has been requested */ 370 advert = mii->mdio_read(dev, mii->phy_id, MII_ADVERTISE); 371 tmp = advert & ~(ADVERTISE_ALL | ADVERTISE_100BASE4); 372 if (mii->supports_gmii) { 373 advert2 = mii->mdio_read(dev, mii->phy_id, 374 MII_CTRL1000); 375 tmp2 = advert2 & 376 ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL); 377 } 378 tmp |= ethtool_adv_to_mii_adv_t(advertising); 379 380 if (mii->supports_gmii) 381 tmp2 |= ethtool_adv_to_mii_ctrl1000_t(advertising); 382 if (advert != tmp) { 383 mii->mdio_write(dev, mii->phy_id, MII_ADVERTISE, tmp); 384 mii->advertising = tmp; 385 } 386 if ((mii->supports_gmii) && (advert2 != tmp2)) 387 mii->mdio_write(dev, mii->phy_id, MII_CTRL1000, tmp2); 388 389 /* turn on autonegotiation, and force a renegotiate */ 390 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 391 bmcr |= (BMCR_ANENABLE | BMCR_ANRESTART); 392 mii->mdio_write(dev, mii->phy_id, MII_BMCR, bmcr); 393 394 mii->force_media = 0; 395 } else { 396 u32 bmcr, tmp; 397 398 /* turn off auto negotiation, set speed and duplexity */ 399 bmcr = mii->mdio_read(dev, mii->phy_id, MII_BMCR); 400 tmp = bmcr & ~(BMCR_ANENABLE | BMCR_SPEED100 | 401 BMCR_SPEED1000 | BMCR_FULLDPLX); 402 if (speed == SPEED_1000) 403 tmp |= BMCR_SPEED1000; 404 else if (speed == SPEED_100) 405 tmp |= BMCR_SPEED100; 406 if (cmd->base.duplex == DUPLEX_FULL) { 407 tmp |= BMCR_FULLDPLX; 408 mii->full_duplex = 1; 409 } else { 410 mii->full_duplex = 0; 411 } 412 if (bmcr != tmp) 413 mii->mdio_write(dev, mii->phy_id, MII_BMCR, tmp); 414 415 mii->force_media = 1; 416 } 417 return 0; 418 } 419 420 /** 421 * mii_check_gmii_support - check if the MII supports Gb interfaces 422 * @mii: the MII interface 423 */ 424 int mii_check_gmii_support(struct mii_if_info *mii) 425 { 426 int reg; 427 428 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR); 429 if (reg & BMSR_ESTATEN) { 430 reg = mii->mdio_read(mii->dev, mii->phy_id, MII_ESTATUS); 431 if (reg & (ESTATUS_1000_TFULL | ESTATUS_1000_THALF)) 432 return 1; 433 } 434 435 return 0; 436 } 437 438 /** 439 * mii_link_ok - is link status up/ok 440 * @mii: the MII interface 441 * 442 * Returns 1 if the MII reports link status up/ok, 0 otherwise. 443 */ 444 int mii_link_ok (struct mii_if_info *mii) 445 { 446 /* first, a dummy read, needed to latch some MII phys */ 447 mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR); 448 if (mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR) & BMSR_LSTATUS) 449 return 1; 450 return 0; 451 } 452 453 /** 454 * mii_nway_restart - restart NWay (autonegotiation) for this interface 455 * @mii: the MII interface 456 * 457 * Returns 0 on success, negative on error. 458 */ 459 int mii_nway_restart (struct mii_if_info *mii) 460 { 461 int bmcr; 462 int r = -EINVAL; 463 464 /* if autoneg is off, it's an error */ 465 bmcr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR); 466 467 if (bmcr & BMCR_ANENABLE) { 468 bmcr |= BMCR_ANRESTART; 469 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, bmcr); 470 r = 0; 471 } 472 473 return r; 474 } 475 476 /** 477 * mii_check_link - check MII link status 478 * @mii: MII interface 479 * 480 * If the link status changed (previous != current), call 481 * netif_carrier_on() if current link status is Up or call 482 * netif_carrier_off() if current link status is Down. 483 */ 484 void mii_check_link (struct mii_if_info *mii) 485 { 486 int cur_link = mii_link_ok(mii); 487 int prev_link = netif_carrier_ok(mii->dev); 488 489 if (cur_link && !prev_link) 490 netif_carrier_on(mii->dev); 491 else if (prev_link && !cur_link) 492 netif_carrier_off(mii->dev); 493 } 494 495 /** 496 * mii_check_media - check the MII interface for a carrier/speed/duplex change 497 * @mii: the MII interface 498 * @ok_to_print: OK to print link up/down messages 499 * @init_media: OK to save duplex mode in @mii 500 * 501 * Returns 1 if the duplex mode changed, 0 if not. 502 * If the media type is forced, always returns 0. 503 */ 504 unsigned int mii_check_media (struct mii_if_info *mii, 505 unsigned int ok_to_print, 506 unsigned int init_media) 507 { 508 unsigned int old_carrier, new_carrier; 509 int advertise, lpa, media, duplex; 510 int lpa2 = 0; 511 512 /* check current and old link status */ 513 old_carrier = netif_carrier_ok(mii->dev) ? 1 : 0; 514 new_carrier = (unsigned int) mii_link_ok(mii); 515 516 /* if carrier state did not change, this is a "bounce", 517 * just exit as everything is already set correctly 518 */ 519 if ((!init_media) && (old_carrier == new_carrier)) 520 return 0; /* duplex did not change */ 521 522 /* no carrier, nothing much to do */ 523 if (!new_carrier) { 524 netif_carrier_off(mii->dev); 525 if (ok_to_print) 526 netdev_info(mii->dev, "link down\n"); 527 return 0; /* duplex did not change */ 528 } 529 530 /* 531 * we have carrier, see who's on the other end 532 */ 533 netif_carrier_on(mii->dev); 534 535 if (mii->force_media) { 536 if (ok_to_print) 537 netdev_info(mii->dev, "link up\n"); 538 return 0; /* duplex did not change */ 539 } 540 541 /* get MII advertise and LPA values */ 542 if ((!init_media) && (mii->advertising)) 543 advertise = mii->advertising; 544 else { 545 advertise = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE); 546 mii->advertising = advertise; 547 } 548 lpa = mii->mdio_read(mii->dev, mii->phy_id, MII_LPA); 549 if (mii->supports_gmii) 550 lpa2 = mii->mdio_read(mii->dev, mii->phy_id, MII_STAT1000); 551 552 /* figure out media and duplex from advertise and LPA values */ 553 media = mii_nway_result(lpa & advertise); 554 duplex = (media & ADVERTISE_FULL) ? 1 : 0; 555 if (lpa2 & LPA_1000FULL) 556 duplex = 1; 557 558 if (ok_to_print) 559 netdev_info(mii->dev, "link up, %uMbps, %s-duplex, lpa 0x%04X\n", 560 lpa2 & (LPA_1000FULL | LPA_1000HALF) ? 1000 : 561 media & (ADVERTISE_100FULL | ADVERTISE_100HALF) ? 562 100 : 10, 563 duplex ? "full" : "half", 564 lpa); 565 566 if ((init_media) || (mii->full_duplex != duplex)) { 567 mii->full_duplex = duplex; 568 return 1; /* duplex changed */ 569 } 570 571 return 0; /* duplex did not change */ 572 } 573 574 /** 575 * generic_mii_ioctl - main MII ioctl interface 576 * @mii_if: the MII interface 577 * @mii_data: MII ioctl data structure 578 * @cmd: MII ioctl command 579 * @duplex_chg_out: pointer to @duplex_changed status if there was no 580 * ioctl error 581 * 582 * Returns 0 on success, negative on error. 583 */ 584 int generic_mii_ioctl(struct mii_if_info *mii_if, 585 struct mii_ioctl_data *mii_data, int cmd, 586 unsigned int *duplex_chg_out) 587 { 588 int rc = 0; 589 unsigned int duplex_changed = 0; 590 591 if (duplex_chg_out) 592 *duplex_chg_out = 0; 593 594 mii_data->phy_id &= mii_if->phy_id_mask; 595 mii_data->reg_num &= mii_if->reg_num_mask; 596 597 switch(cmd) { 598 case SIOCGMIIPHY: 599 mii_data->phy_id = mii_if->phy_id; 600 /* fall through */ 601 602 case SIOCGMIIREG: 603 mii_data->val_out = 604 mii_if->mdio_read(mii_if->dev, mii_data->phy_id, 605 mii_data->reg_num); 606 break; 607 608 case SIOCSMIIREG: { 609 u16 val = mii_data->val_in; 610 611 if (mii_data->phy_id == mii_if->phy_id) { 612 switch(mii_data->reg_num) { 613 case MII_BMCR: { 614 unsigned int new_duplex = 0; 615 if (val & (BMCR_RESET|BMCR_ANENABLE)) 616 mii_if->force_media = 0; 617 else 618 mii_if->force_media = 1; 619 if (mii_if->force_media && 620 (val & BMCR_FULLDPLX)) 621 new_duplex = 1; 622 if (mii_if->full_duplex != new_duplex) { 623 duplex_changed = 1; 624 mii_if->full_duplex = new_duplex; 625 } 626 break; 627 } 628 case MII_ADVERTISE: 629 mii_if->advertising = val; 630 break; 631 default: 632 /* do nothing */ 633 break; 634 } 635 } 636 637 mii_if->mdio_write(mii_if->dev, mii_data->phy_id, 638 mii_data->reg_num, val); 639 break; 640 } 641 642 default: 643 rc = -EOPNOTSUPP; 644 break; 645 } 646 647 if ((rc == 0) && (duplex_chg_out) && (duplex_changed)) 648 *duplex_chg_out = 1; 649 650 return rc; 651 } 652 653 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>"); 654 MODULE_DESCRIPTION ("MII hardware support library"); 655 MODULE_LICENSE("GPL"); 656 657 EXPORT_SYMBOL(mii_link_ok); 658 EXPORT_SYMBOL(mii_nway_restart); 659 EXPORT_SYMBOL(mii_ethtool_gset); 660 EXPORT_SYMBOL(mii_ethtool_get_link_ksettings); 661 EXPORT_SYMBOL(mii_ethtool_sset); 662 EXPORT_SYMBOL(mii_ethtool_set_link_ksettings); 663 EXPORT_SYMBOL(mii_check_link); 664 EXPORT_SYMBOL(mii_check_media); 665 EXPORT_SYMBOL(mii_check_gmii_support); 666 EXPORT_SYMBOL(generic_mii_ioctl); 667 668