| 1 | /* |
| 2 | * mdio.c: Generic support for MDIO-compatible transceivers |
| 3 | * Copyright 2006-2009 Solarflare Communications Inc. |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify it |
| 6 | * under the terms of the GNU General Public License version 2 as published |
| 7 | * by the Free Software Foundation, incorporated herein by reference. |
| 8 | */ |
| 9 | |
| 10 | #include <linux/kernel.h> |
| 11 | #include <linux/capability.h> |
| 12 | #include <linux/errno.h> |
| 13 | #include <linux/ethtool.h> |
| 14 | #include <linux/mdio.h> |
| 15 | #include <linux/module.h> |
| 16 | |
| 17 | MODULE_DESCRIPTION("Generic support for MDIO-compatible transceivers"); |
| 18 | MODULE_AUTHOR("Copyright 2006-2009 Solarflare Communications Inc."); |
| 19 | MODULE_LICENSE("GPL"); |
| 20 | |
| 21 | /** |
| 22 | * mdio45_probe - probe for an MDIO (clause 45) device |
| 23 | * @mdio: MDIO interface |
| 24 | * @prtad: Expected PHY address |
| 25 | * |
| 26 | * This sets @prtad and @mmds in the MDIO interface if successful. |
| 27 | * Returns 0 on success, negative on error. |
| 28 | */ |
| 29 | int mdio45_probe(struct mdio_if_info *mdio, int prtad) |
| 30 | { |
| 31 | int mmd, stat2, devs1, devs2; |
| 32 | |
| 33 | /* Assume PHY must have at least one of PMA/PMD, WIS, PCS, PHY |
| 34 | * XS or DTE XS; give up if none is present. */ |
| 35 | for (mmd = 1; mmd <= 5; mmd++) { |
| 36 | /* Is this MMD present? */ |
| 37 | stat2 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_STAT2); |
| 38 | if (stat2 < 0 || |
| 39 | (stat2 & MDIO_STAT2_DEVPRST) != MDIO_STAT2_DEVPRST_VAL) |
| 40 | continue; |
| 41 | |
| 42 | /* It should tell us about all the other MMDs */ |
| 43 | devs1 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_DEVS1); |
| 44 | devs2 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_DEVS2); |
| 45 | if (devs1 < 0 || devs2 < 0) |
| 46 | continue; |
| 47 | |
| 48 | mdio->prtad = prtad; |
| 49 | mdio->mmds = devs1 | (devs2 << 16); |
| 50 | return 0; |
| 51 | } |
| 52 | |
| 53 | return -ENODEV; |
| 54 | } |
| 55 | EXPORT_SYMBOL(mdio45_probe); |
| 56 | |
| 57 | /** |
| 58 | * mdio_set_flag - set or clear flag in an MDIO register |
| 59 | * @mdio: MDIO interface |
| 60 | * @prtad: PHY address |
| 61 | * @devad: MMD address |
| 62 | * @addr: Register address |
| 63 | * @mask: Mask for flag (single bit set) |
| 64 | * @sense: New value of flag |
| 65 | * |
| 66 | * This debounces changes: it does not write the register if the flag |
| 67 | * already has the proper value. Returns 0 on success, negative on error. |
| 68 | */ |
| 69 | int mdio_set_flag(const struct mdio_if_info *mdio, |
| 70 | int prtad, int devad, u16 addr, int mask, |
| 71 | bool sense) |
| 72 | { |
| 73 | int old_val = mdio->mdio_read(mdio->dev, prtad, devad, addr); |
| 74 | int new_val; |
| 75 | |
| 76 | if (old_val < 0) |
| 77 | return old_val; |
| 78 | if (sense) |
| 79 | new_val = old_val | mask; |
| 80 | else |
| 81 | new_val = old_val & ~mask; |
| 82 | if (old_val == new_val) |
| 83 | return 0; |
| 84 | return mdio->mdio_write(mdio->dev, prtad, devad, addr, new_val); |
| 85 | } |
| 86 | EXPORT_SYMBOL(mdio_set_flag); |
| 87 | |
| 88 | /** |
| 89 | * mdio_link_ok - is link status up/OK |
| 90 | * @mdio: MDIO interface |
| 91 | * @mmd_mask: Mask for MMDs to check |
| 92 | * |
| 93 | * Returns 1 if the PHY reports link status up/OK, 0 otherwise. |
| 94 | * @mmd_mask is normally @mdio->mmds, but if loopback is enabled |
| 95 | * the MMDs being bypassed should be excluded from the mask. |
| 96 | */ |
| 97 | int mdio45_links_ok(const struct mdio_if_info *mdio, u32 mmd_mask) |
| 98 | { |
| 99 | int devad, reg; |
| 100 | |
| 101 | if (!mmd_mask) { |
| 102 | /* Use absence of XGMII faults in lieu of link state */ |
| 103 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, |
| 104 | MDIO_MMD_PHYXS, MDIO_STAT2); |
| 105 | return reg >= 0 && !(reg & MDIO_STAT2_RXFAULT); |
| 106 | } |
| 107 | |
| 108 | for (devad = 0; mmd_mask; devad++) { |
| 109 | if (mmd_mask & (1 << devad)) { |
| 110 | mmd_mask &= ~(1 << devad); |
| 111 | |
| 112 | /* Reset the latched status and fault flags */ |
| 113 | mdio->mdio_read(mdio->dev, mdio->prtad, |
| 114 | devad, MDIO_STAT1); |
| 115 | if (devad == MDIO_MMD_PMAPMD || devad == MDIO_MMD_PCS || |
| 116 | devad == MDIO_MMD_PHYXS || devad == MDIO_MMD_DTEXS) |
| 117 | mdio->mdio_read(mdio->dev, mdio->prtad, |
| 118 | devad, MDIO_STAT2); |
| 119 | |
| 120 | /* Check the current status and fault flags */ |
| 121 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, |
| 122 | devad, MDIO_STAT1); |
| 123 | if (reg < 0 || |
| 124 | (reg & (MDIO_STAT1_FAULT | MDIO_STAT1_LSTATUS)) != |
| 125 | MDIO_STAT1_LSTATUS) |
| 126 | return false; |
| 127 | } |
| 128 | } |
| 129 | |
| 130 | return true; |
| 131 | } |
| 132 | EXPORT_SYMBOL(mdio45_links_ok); |
| 133 | |
| 134 | /** |
| 135 | * mdio45_nway_restart - restart auto-negotiation for this interface |
| 136 | * @mdio: MDIO interface |
| 137 | * |
| 138 | * Returns 0 on success, negative on error. |
| 139 | */ |
| 140 | int mdio45_nway_restart(const struct mdio_if_info *mdio) |
| 141 | { |
| 142 | if (!(mdio->mmds & MDIO_DEVS_AN)) |
| 143 | return -EOPNOTSUPP; |
| 144 | |
| 145 | mdio_set_flag(mdio, mdio->prtad, MDIO_MMD_AN, MDIO_CTRL1, |
| 146 | MDIO_AN_CTRL1_RESTART, true); |
| 147 | return 0; |
| 148 | } |
| 149 | EXPORT_SYMBOL(mdio45_nway_restart); |
| 150 | |
| 151 | static u32 mdio45_get_an(const struct mdio_if_info *mdio, u16 addr) |
| 152 | { |
| 153 | u32 result = 0; |
| 154 | int reg; |
| 155 | |
| 156 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, addr); |
| 157 | if (reg & ADVERTISE_10HALF) |
| 158 | result |= ADVERTISED_10baseT_Half; |
| 159 | if (reg & ADVERTISE_10FULL) |
| 160 | result |= ADVERTISED_10baseT_Full; |
| 161 | if (reg & ADVERTISE_100HALF) |
| 162 | result |= ADVERTISED_100baseT_Half; |
| 163 | if (reg & ADVERTISE_100FULL) |
| 164 | result |= ADVERTISED_100baseT_Full; |
| 165 | return result; |
| 166 | } |
| 167 | |
| 168 | /** |
| 169 | * mdio45_ethtool_gset_npage - get settings for ETHTOOL_GSET |
| 170 | * @mdio: MDIO interface |
| 171 | * @ecmd: Ethtool request structure |
| 172 | * @npage_adv: Modes currently advertised on next pages |
| 173 | * @npage_lpa: Modes advertised by link partner on next pages |
| 174 | * |
| 175 | * Since the CSRs for auto-negotiation using next pages are not fully |
| 176 | * standardised, this function does not attempt to decode them. The |
| 177 | * caller must pass them in. |
| 178 | */ |
| 179 | void mdio45_ethtool_gset_npage(const struct mdio_if_info *mdio, |
| 180 | struct ethtool_cmd *ecmd, |
| 181 | u32 npage_adv, u32 npage_lpa) |
| 182 | { |
| 183 | int reg; |
| 184 | |
| 185 | ecmd->transceiver = XCVR_INTERNAL; |
| 186 | ecmd->phy_address = mdio->prtad; |
| 187 | ecmd->mdio_support = |
| 188 | mdio->mode_support & (MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22); |
| 189 | |
| 190 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 191 | MDIO_CTRL2); |
| 192 | switch (reg & MDIO_PMA_CTRL2_TYPE) { |
| 193 | case MDIO_PMA_CTRL2_10GBT: |
| 194 | case MDIO_PMA_CTRL2_1000BT: |
| 195 | case MDIO_PMA_CTRL2_100BTX: |
| 196 | case MDIO_PMA_CTRL2_10BT: |
| 197 | ecmd->port = PORT_TP; |
| 198 | ecmd->supported = SUPPORTED_TP; |
| 199 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 200 | MDIO_SPEED); |
| 201 | if (reg & MDIO_SPEED_10G) |
| 202 | ecmd->supported |= SUPPORTED_10000baseT_Full; |
| 203 | if (reg & MDIO_PMA_SPEED_1000) |
| 204 | ecmd->supported |= (SUPPORTED_1000baseT_Full | |
| 205 | SUPPORTED_1000baseT_Half); |
| 206 | if (reg & MDIO_PMA_SPEED_100) |
| 207 | ecmd->supported |= (SUPPORTED_100baseT_Full | |
| 208 | SUPPORTED_100baseT_Half); |
| 209 | if (reg & MDIO_PMA_SPEED_10) |
| 210 | ecmd->supported |= (SUPPORTED_10baseT_Full | |
| 211 | SUPPORTED_10baseT_Half); |
| 212 | ecmd->advertising = ADVERTISED_TP; |
| 213 | break; |
| 214 | |
| 215 | case MDIO_PMA_CTRL2_10GBCX4: |
| 216 | ecmd->port = PORT_OTHER; |
| 217 | ecmd->supported = 0; |
| 218 | ecmd->advertising = 0; |
| 219 | break; |
| 220 | |
| 221 | case MDIO_PMA_CTRL2_10GBKX4: |
| 222 | case MDIO_PMA_CTRL2_10GBKR: |
| 223 | case MDIO_PMA_CTRL2_1000BKX: |
| 224 | ecmd->port = PORT_OTHER; |
| 225 | ecmd->supported = SUPPORTED_Backplane; |
| 226 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 227 | MDIO_PMA_EXTABLE); |
| 228 | if (reg & MDIO_PMA_EXTABLE_10GBKX4) |
| 229 | ecmd->supported |= SUPPORTED_10000baseKX4_Full; |
| 230 | if (reg & MDIO_PMA_EXTABLE_10GBKR) |
| 231 | ecmd->supported |= SUPPORTED_10000baseKR_Full; |
| 232 | if (reg & MDIO_PMA_EXTABLE_1000BKX) |
| 233 | ecmd->supported |= SUPPORTED_1000baseKX_Full; |
| 234 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 235 | MDIO_PMA_10GBR_FECABLE); |
| 236 | if (reg & MDIO_PMA_10GBR_FECABLE_ABLE) |
| 237 | ecmd->supported |= SUPPORTED_10000baseR_FEC; |
| 238 | ecmd->advertising = ADVERTISED_Backplane; |
| 239 | break; |
| 240 | |
| 241 | /* All the other defined modes are flavours of optical */ |
| 242 | default: |
| 243 | ecmd->port = PORT_FIBRE; |
| 244 | ecmd->supported = SUPPORTED_FIBRE; |
| 245 | ecmd->advertising = ADVERTISED_FIBRE; |
| 246 | break; |
| 247 | } |
| 248 | |
| 249 | if (mdio->mmds & MDIO_DEVS_AN) { |
| 250 | ecmd->supported |= SUPPORTED_Autoneg; |
| 251 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, |
| 252 | MDIO_CTRL1); |
| 253 | if (reg & MDIO_AN_CTRL1_ENABLE) { |
| 254 | ecmd->autoneg = AUTONEG_ENABLE; |
| 255 | ecmd->advertising |= |
| 256 | ADVERTISED_Autoneg | |
| 257 | mdio45_get_an(mdio, MDIO_AN_ADVERTISE) | |
| 258 | npage_adv; |
| 259 | } else { |
| 260 | ecmd->autoneg = AUTONEG_DISABLE; |
| 261 | } |
| 262 | } else { |
| 263 | ecmd->autoneg = AUTONEG_DISABLE; |
| 264 | } |
| 265 | |
| 266 | if (ecmd->autoneg) { |
| 267 | u32 modes = 0; |
| 268 | int an_stat = mdio->mdio_read(mdio->dev, mdio->prtad, |
| 269 | MDIO_MMD_AN, MDIO_STAT1); |
| 270 | |
| 271 | /* If AN is complete and successful, report best common |
| 272 | * mode, otherwise report best advertised mode. */ |
| 273 | if (an_stat & MDIO_AN_STAT1_COMPLETE) { |
| 274 | ecmd->lp_advertising = |
| 275 | mdio45_get_an(mdio, MDIO_AN_LPA) | npage_lpa; |
| 276 | if (an_stat & MDIO_AN_STAT1_LPABLE) |
| 277 | ecmd->lp_advertising |= ADVERTISED_Autoneg; |
| 278 | modes = ecmd->advertising & ecmd->lp_advertising; |
| 279 | } |
| 280 | if ((modes & ~ADVERTISED_Autoneg) == 0) |
| 281 | modes = ecmd->advertising; |
| 282 | |
| 283 | if (modes & (ADVERTISED_10000baseT_Full | |
| 284 | ADVERTISED_10000baseKX4_Full | |
| 285 | ADVERTISED_10000baseKR_Full)) { |
| 286 | ecmd->speed = SPEED_10000; |
| 287 | ecmd->duplex = DUPLEX_FULL; |
| 288 | } else if (modes & (ADVERTISED_1000baseT_Full | |
| 289 | ADVERTISED_1000baseT_Half | |
| 290 | ADVERTISED_1000baseKX_Full)) { |
| 291 | ecmd->speed = SPEED_1000; |
| 292 | ecmd->duplex = !(modes & ADVERTISED_1000baseT_Half); |
| 293 | } else if (modes & (ADVERTISED_100baseT_Full | |
| 294 | ADVERTISED_100baseT_Half)) { |
| 295 | ecmd->speed = SPEED_100; |
| 296 | ecmd->duplex = !!(modes & ADVERTISED_100baseT_Full); |
| 297 | } else { |
| 298 | ecmd->speed = SPEED_10; |
| 299 | ecmd->duplex = !!(modes & ADVERTISED_10baseT_Full); |
| 300 | } |
| 301 | } else { |
| 302 | /* Report forced settings */ |
| 303 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 304 | MDIO_CTRL1); |
| 305 | ecmd->speed = (((reg & MDIO_PMA_CTRL1_SPEED1000) ? 100 : 1) * |
| 306 | ((reg & MDIO_PMA_CTRL1_SPEED100) ? 100 : 10)); |
| 307 | ecmd->duplex = (reg & MDIO_CTRL1_FULLDPLX || |
| 308 | ecmd->speed == SPEED_10000); |
| 309 | } |
| 310 | |
| 311 | /* 10GBASE-T MDI/MDI-X */ |
| 312 | if (ecmd->port == PORT_TP && ecmd->speed == SPEED_10000) { |
| 313 | switch (mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
| 314 | MDIO_PMA_10GBT_SWAPPOL)) { |
| 315 | case MDIO_PMA_10GBT_SWAPPOL_ABNX | MDIO_PMA_10GBT_SWAPPOL_CDNX: |
| 316 | ecmd->eth_tp_mdix = ETH_TP_MDI; |
| 317 | break; |
| 318 | case 0: |
| 319 | ecmd->eth_tp_mdix = ETH_TP_MDI_X; |
| 320 | break; |
| 321 | default: |
| 322 | /* It's complicated... */ |
| 323 | ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID; |
| 324 | break; |
| 325 | } |
| 326 | } |
| 327 | } |
| 328 | EXPORT_SYMBOL(mdio45_ethtool_gset_npage); |
| 329 | |
| 330 | /** |
| 331 | * mdio45_ethtool_spauseparam_an - set auto-negotiated pause parameters |
| 332 | * @mdio: MDIO interface |
| 333 | * @ecmd: Ethtool request structure |
| 334 | * |
| 335 | * This function assumes that the PHY has an auto-negotiation MMD. It |
| 336 | * will enable and disable advertising of flow control as appropriate. |
| 337 | */ |
| 338 | void mdio45_ethtool_spauseparam_an(const struct mdio_if_info *mdio, |
| 339 | const struct ethtool_pauseparam *ecmd) |
| 340 | { |
| 341 | int adv, old_adv; |
| 342 | |
| 343 | WARN_ON(!(mdio->mmds & MDIO_DEVS_AN)); |
| 344 | |
| 345 | old_adv = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, |
| 346 | MDIO_AN_ADVERTISE); |
| 347 | adv = old_adv & ~(ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM); |
| 348 | if (ecmd->autoneg) |
| 349 | adv |= mii_advertise_flowctrl( |
| 350 | (ecmd->rx_pause ? FLOW_CTRL_RX : 0) | |
| 351 | (ecmd->tx_pause ? FLOW_CTRL_TX : 0)); |
| 352 | if (adv != old_adv) { |
| 353 | mdio->mdio_write(mdio->dev, mdio->prtad, MDIO_MMD_AN, |
| 354 | MDIO_AN_ADVERTISE, adv); |
| 355 | mdio45_nway_restart(mdio); |
| 356 | } |
| 357 | } |
| 358 | EXPORT_SYMBOL(mdio45_ethtool_spauseparam_an); |
| 359 | |
| 360 | /** |
| 361 | * mdio_mii_ioctl - MII ioctl interface for MDIO (clause 22 or 45) PHYs |
| 362 | * @mdio: MDIO interface |
| 363 | * @mii_data: MII ioctl data structure |
| 364 | * @cmd: MII ioctl command |
| 365 | * |
| 366 | * Returns 0 on success, negative on error. |
| 367 | */ |
| 368 | int mdio_mii_ioctl(const struct mdio_if_info *mdio, |
| 369 | struct mii_ioctl_data *mii_data, int cmd) |
| 370 | { |
| 371 | int prtad, devad; |
| 372 | u16 addr = mii_data->reg_num; |
| 373 | |
| 374 | /* Validate/convert cmd to one of SIOC{G,S}MIIREG */ |
| 375 | switch (cmd) { |
| 376 | case SIOCGMIIPHY: |
| 377 | if (mdio->prtad == MDIO_PRTAD_NONE) |
| 378 | return -EOPNOTSUPP; |
| 379 | mii_data->phy_id = mdio->prtad; |
| 380 | cmd = SIOCGMIIREG; |
| 381 | break; |
| 382 | case SIOCGMIIREG: |
| 383 | case SIOCSMIIREG: |
| 384 | break; |
| 385 | default: |
| 386 | return -EOPNOTSUPP; |
| 387 | } |
| 388 | |
| 389 | /* Validate/convert phy_id */ |
| 390 | if ((mdio->mode_support & MDIO_SUPPORTS_C45) && |
| 391 | mdio_phy_id_is_c45(mii_data->phy_id)) { |
| 392 | prtad = mdio_phy_id_prtad(mii_data->phy_id); |
| 393 | devad = mdio_phy_id_devad(mii_data->phy_id); |
| 394 | } else if ((mdio->mode_support & MDIO_SUPPORTS_C22) && |
| 395 | mii_data->phy_id < 0x20) { |
| 396 | prtad = mii_data->phy_id; |
| 397 | devad = MDIO_DEVAD_NONE; |
| 398 | addr &= 0x1f; |
| 399 | } else if ((mdio->mode_support & MDIO_EMULATE_C22) && |
| 400 | mdio->prtad != MDIO_PRTAD_NONE && |
| 401 | mii_data->phy_id == mdio->prtad) { |
| 402 | /* Remap commonly-used MII registers. */ |
| 403 | prtad = mdio->prtad; |
| 404 | switch (addr) { |
| 405 | case MII_BMCR: |
| 406 | case MII_BMSR: |
| 407 | case MII_PHYSID1: |
| 408 | case MII_PHYSID2: |
| 409 | devad = __ffs(mdio->mmds); |
| 410 | break; |
| 411 | case MII_ADVERTISE: |
| 412 | case MII_LPA: |
| 413 | if (!(mdio->mmds & MDIO_DEVS_AN)) |
| 414 | return -EINVAL; |
| 415 | devad = MDIO_MMD_AN; |
| 416 | if (addr == MII_ADVERTISE) |
| 417 | addr = MDIO_AN_ADVERTISE; |
| 418 | else |
| 419 | addr = MDIO_AN_LPA; |
| 420 | break; |
| 421 | default: |
| 422 | return -EINVAL; |
| 423 | } |
| 424 | } else { |
| 425 | return -EINVAL; |
| 426 | } |
| 427 | |
| 428 | if (cmd == SIOCGMIIREG) { |
| 429 | int rc = mdio->mdio_read(mdio->dev, prtad, devad, addr); |
| 430 | if (rc < 0) |
| 431 | return rc; |
| 432 | mii_data->val_out = rc; |
| 433 | return 0; |
| 434 | } else { |
| 435 | return mdio->mdio_write(mdio->dev, prtad, devad, addr, |
| 436 | mii_data->val_in); |
| 437 | } |
| 438 | } |
| 439 | EXPORT_SYMBOL(mdio_mii_ioctl); |