1 /* 2 * Core PHY library, taken from phy.c 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License as published by the 6 * Free Software Foundation; either version 2 of the License, or (at your 7 * option) any later version. 8 */ 9 #include <linux/export.h> 10 #include <linux/phy.h> 11 12 const char *phy_speed_to_str(int speed) 13 { 14 switch (speed) { 15 case SPEED_10: 16 return "10Mbps"; 17 case SPEED_100: 18 return "100Mbps"; 19 case SPEED_1000: 20 return "1Gbps"; 21 case SPEED_2500: 22 return "2.5Gbps"; 23 case SPEED_5000: 24 return "5Gbps"; 25 case SPEED_10000: 26 return "10Gbps"; 27 case SPEED_14000: 28 return "14Gbps"; 29 case SPEED_20000: 30 return "20Gbps"; 31 case SPEED_25000: 32 return "25Gbps"; 33 case SPEED_40000: 34 return "40Gbps"; 35 case SPEED_50000: 36 return "50Gbps"; 37 case SPEED_56000: 38 return "56Gbps"; 39 case SPEED_100000: 40 return "100Gbps"; 41 case SPEED_UNKNOWN: 42 return "Unknown"; 43 default: 44 return "Unsupported (update phy-core.c)"; 45 } 46 } 47 EXPORT_SYMBOL_GPL(phy_speed_to_str); 48 49 const char *phy_duplex_to_str(unsigned int duplex) 50 { 51 if (duplex == DUPLEX_HALF) 52 return "Half"; 53 if (duplex == DUPLEX_FULL) 54 return "Full"; 55 if (duplex == DUPLEX_UNKNOWN) 56 return "Unknown"; 57 return "Unsupported (update phy-core.c)"; 58 } 59 EXPORT_SYMBOL_GPL(phy_duplex_to_str); 60 61 /* A mapping of all SUPPORTED settings to speed/duplex. This table 62 * must be grouped by speed and sorted in descending match priority 63 * - iow, descending speed. */ 64 static const struct phy_setting settings[] = { 65 { 66 .speed = SPEED_10000, 67 .duplex = DUPLEX_FULL, 68 .bit = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, 69 }, 70 { 71 .speed = SPEED_10000, 72 .duplex = DUPLEX_FULL, 73 .bit = ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, 74 }, 75 { 76 .speed = SPEED_10000, 77 .duplex = DUPLEX_FULL, 78 .bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 79 }, 80 { 81 .speed = SPEED_2500, 82 .duplex = DUPLEX_FULL, 83 .bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT, 84 }, 85 { 86 .speed = SPEED_1000, 87 .duplex = DUPLEX_FULL, 88 .bit = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, 89 }, 90 { 91 .speed = SPEED_1000, 92 .duplex = DUPLEX_FULL, 93 .bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 94 }, 95 { 96 .speed = SPEED_1000, 97 .duplex = DUPLEX_FULL, 98 .bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 99 }, 100 { 101 .speed = SPEED_1000, 102 .duplex = DUPLEX_HALF, 103 .bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 104 }, 105 { 106 .speed = SPEED_100, 107 .duplex = DUPLEX_FULL, 108 .bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT, 109 }, 110 { 111 .speed = SPEED_100, 112 .duplex = DUPLEX_HALF, 113 .bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT, 114 }, 115 { 116 .speed = SPEED_10, 117 .duplex = DUPLEX_FULL, 118 .bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT, 119 }, 120 { 121 .speed = SPEED_10, 122 .duplex = DUPLEX_HALF, 123 .bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT, 124 }, 125 }; 126 127 /** 128 * phy_lookup_setting - lookup a PHY setting 129 * @speed: speed to match 130 * @duplex: duplex to match 131 * @mask: allowed link modes 132 * @maxbit: bit size of link modes 133 * @exact: an exact match is required 134 * 135 * Search the settings array for a setting that matches the speed and 136 * duplex, and which is supported. 137 * 138 * If @exact is unset, either an exact match or %NULL for no match will 139 * be returned. 140 * 141 * If @exact is set, an exact match, the fastest supported setting at 142 * or below the specified speed, the slowest supported setting, or if 143 * they all fail, %NULL will be returned. 144 */ 145 const struct phy_setting * 146 phy_lookup_setting(int speed, int duplex, const unsigned long *mask, 147 size_t maxbit, bool exact) 148 { 149 const struct phy_setting *p, *match = NULL, *last = NULL; 150 int i; 151 152 for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) { 153 if (p->bit < maxbit && test_bit(p->bit, mask)) { 154 last = p; 155 if (p->speed == speed && p->duplex == duplex) { 156 /* Exact match for speed and duplex */ 157 match = p; 158 break; 159 } else if (!exact) { 160 if (!match && p->speed <= speed) 161 /* Candidate */ 162 match = p; 163 164 if (p->speed < speed) 165 break; 166 } 167 } 168 } 169 170 if (!match && !exact) 171 match = last; 172 173 return match; 174 } 175 EXPORT_SYMBOL_GPL(phy_lookup_setting); 176 177 size_t phy_speeds(unsigned int *speeds, size_t size, 178 unsigned long *mask, size_t maxbit) 179 { 180 size_t count; 181 int i; 182 183 for (i = 0, count = 0; i < ARRAY_SIZE(settings) && count < size; i++) 184 if (settings[i].bit < maxbit && 185 test_bit(settings[i].bit, mask) && 186 (count == 0 || speeds[count - 1] != settings[i].speed)) 187 speeds[count++] = settings[i].speed; 188 189 return count; 190 } 191 192 /** 193 * phy_resolve_aneg_linkmode - resolve the advertisments into phy settings 194 * @phydev: The phy_device struct 195 * 196 * Resolve our and the link partner advertisments into their corresponding 197 * speed and duplex. If full duplex was negotiated, extract the pause mode 198 * from the link partner mask. 199 */ 200 void phy_resolve_aneg_linkmode(struct phy_device *phydev) 201 { 202 u32 common = phydev->lp_advertising & phydev->advertising; 203 204 if (common & ADVERTISED_10000baseT_Full) { 205 phydev->speed = SPEED_10000; 206 phydev->duplex = DUPLEX_FULL; 207 } else if (common & ADVERTISED_1000baseT_Full) { 208 phydev->speed = SPEED_1000; 209 phydev->duplex = DUPLEX_FULL; 210 } else if (common & ADVERTISED_1000baseT_Half) { 211 phydev->speed = SPEED_1000; 212 phydev->duplex = DUPLEX_HALF; 213 } else if (common & ADVERTISED_100baseT_Full) { 214 phydev->speed = SPEED_100; 215 phydev->duplex = DUPLEX_FULL; 216 } else if (common & ADVERTISED_100baseT_Half) { 217 phydev->speed = SPEED_100; 218 phydev->duplex = DUPLEX_HALF; 219 } else if (common & ADVERTISED_10baseT_Full) { 220 phydev->speed = SPEED_10; 221 phydev->duplex = DUPLEX_FULL; 222 } else if (common & ADVERTISED_10baseT_Half) { 223 phydev->speed = SPEED_10; 224 phydev->duplex = DUPLEX_HALF; 225 } 226 227 if (phydev->duplex == DUPLEX_FULL) { 228 phydev->pause = !!(phydev->lp_advertising & ADVERTISED_Pause); 229 phydev->asym_pause = !!(phydev->lp_advertising & 230 ADVERTISED_Asym_Pause); 231 } 232 } 233 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode); 234 235 static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad, 236 u16 regnum) 237 { 238 /* Write the desired MMD Devad */ 239 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad); 240 241 /* Write the desired MMD register address */ 242 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum); 243 244 /* Select the Function : DATA with no post increment */ 245 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL, 246 devad | MII_MMD_CTRL_NOINCR); 247 } 248 249 /** 250 * phy_read_mmd - Convenience function for reading a register 251 * from an MMD on a given PHY. 252 * @phydev: The phy_device struct 253 * @devad: The MMD to read from (0..31) 254 * @regnum: The register on the MMD to read (0..65535) 255 * 256 * Same rules as for phy_read(); 257 */ 258 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum) 259 { 260 int val; 261 262 if (regnum > (u16)~0 || devad > 32) 263 return -EINVAL; 264 265 if (phydev->drv->read_mmd) { 266 val = phydev->drv->read_mmd(phydev, devad, regnum); 267 } else if (phydev->is_c45) { 268 u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff); 269 270 val = mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, addr); 271 } else { 272 struct mii_bus *bus = phydev->mdio.bus; 273 int phy_addr = phydev->mdio.addr; 274 275 mutex_lock(&bus->mdio_lock); 276 mmd_phy_indirect(bus, phy_addr, devad, regnum); 277 278 /* Read the content of the MMD's selected register */ 279 val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA); 280 mutex_unlock(&bus->mdio_lock); 281 } 282 return val; 283 } 284 EXPORT_SYMBOL(phy_read_mmd); 285 286 /** 287 * phy_write_mmd - Convenience function for writing a register 288 * on an MMD on a given PHY. 289 * @phydev: The phy_device struct 290 * @devad: The MMD to read from 291 * @regnum: The register on the MMD to read 292 * @val: value to write to @regnum 293 * 294 * Same rules as for phy_write(); 295 */ 296 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val) 297 { 298 int ret; 299 300 if (regnum > (u16)~0 || devad > 32) 301 return -EINVAL; 302 303 if (phydev->drv->write_mmd) { 304 ret = phydev->drv->write_mmd(phydev, devad, regnum, val); 305 } else if (phydev->is_c45) { 306 u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff); 307 308 ret = mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, 309 addr, val); 310 } else { 311 struct mii_bus *bus = phydev->mdio.bus; 312 int phy_addr = phydev->mdio.addr; 313 314 mutex_lock(&bus->mdio_lock); 315 mmd_phy_indirect(bus, phy_addr, devad, regnum); 316 317 /* Write the data into MMD's selected register */ 318 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, val); 319 mutex_unlock(&bus->mdio_lock); 320 321 ret = 0; 322 } 323 return ret; 324 } 325 EXPORT_SYMBOL(phy_write_mmd); 326 327 /** 328 * __phy_modify() - Convenience function for modifying a PHY register 329 * @phydev: a pointer to a &struct phy_device 330 * @regnum: register number 331 * @mask: bit mask of bits to clear 332 * @set: bit mask of bits to set 333 * 334 * Unlocked helper function which allows a PHY register to be modified as 335 * new register value = (old register value & ~mask) | set 336 */ 337 int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set) 338 { 339 int ret; 340 341 ret = __phy_read(phydev, regnum); 342 if (ret < 0) 343 return ret; 344 345 ret = __phy_write(phydev, regnum, (ret & ~mask) | set); 346 347 return ret < 0 ? ret : 0; 348 } 349 EXPORT_SYMBOL_GPL(__phy_modify); 350 351 /** 352 * phy_modify - Convenience function for modifying a given PHY register 353 * @phydev: the phy_device struct 354 * @regnum: register number to write 355 * @mask: bit mask of bits to clear 356 * @set: new value of bits set in mask to write to @regnum 357 * 358 * NOTE: MUST NOT be called from interrupt context, 359 * because the bus read/write functions may wait for an interrupt 360 * to conclude the operation. 361 */ 362 int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set) 363 { 364 int ret; 365 366 mutex_lock(&phydev->mdio.bus->mdio_lock); 367 ret = __phy_modify(phydev, regnum, mask, set); 368 mutex_unlock(&phydev->mdio.bus->mdio_lock); 369 370 return ret; 371 } 372 EXPORT_SYMBOL_GPL(phy_modify); 373 374 static int __phy_read_page(struct phy_device *phydev) 375 { 376 return phydev->drv->read_page(phydev); 377 } 378 379 static int __phy_write_page(struct phy_device *phydev, int page) 380 { 381 return phydev->drv->write_page(phydev, page); 382 } 383 384 /** 385 * phy_save_page() - take the bus lock and save the current page 386 * @phydev: a pointer to a &struct phy_device 387 * 388 * Take the MDIO bus lock, and return the current page number. On error, 389 * returns a negative errno. phy_restore_page() must always be called 390 * after this, irrespective of success or failure of this call. 391 */ 392 int phy_save_page(struct phy_device *phydev) 393 { 394 mutex_lock(&phydev->mdio.bus->mdio_lock); 395 return __phy_read_page(phydev); 396 } 397 EXPORT_SYMBOL_GPL(phy_save_page); 398 399 /** 400 * phy_select_page() - take the bus lock, save the current page, and set a page 401 * @phydev: a pointer to a &struct phy_device 402 * @page: desired page 403 * 404 * Take the MDIO bus lock to protect against concurrent access, save the 405 * current PHY page, and set the current page. On error, returns a 406 * negative errno, otherwise returns the previous page number. 407 * phy_restore_page() must always be called after this, irrespective 408 * of success or failure of this call. 409 */ 410 int phy_select_page(struct phy_device *phydev, int page) 411 { 412 int ret, oldpage; 413 414 oldpage = ret = phy_save_page(phydev); 415 if (ret < 0) 416 return ret; 417 418 if (oldpage != page) { 419 ret = __phy_write_page(phydev, page); 420 if (ret < 0) 421 return ret; 422 } 423 424 return oldpage; 425 } 426 EXPORT_SYMBOL_GPL(phy_select_page); 427 428 /** 429 * phy_restore_page() - restore the page register and release the bus lock 430 * @phydev: a pointer to a &struct phy_device 431 * @oldpage: the old page, return value from phy_save_page() or phy_select_page() 432 * @ret: operation's return code 433 * 434 * Release the MDIO bus lock, restoring @oldpage if it is a valid page. 435 * This function propagates the earliest error code from the group of 436 * operations. 437 * 438 * Returns: 439 * @oldpage if it was a negative value, otherwise 440 * @ret if it was a negative errno value, otherwise 441 * phy_write_page()'s negative value if it were in error, otherwise 442 * @ret. 443 */ 444 int phy_restore_page(struct phy_device *phydev, int oldpage, int ret) 445 { 446 int r; 447 448 if (oldpage >= 0) { 449 r = __phy_write_page(phydev, oldpage); 450 451 /* Propagate the operation return code if the page write 452 * was successful. 453 */ 454 if (ret >= 0 && r < 0) 455 ret = r; 456 } else { 457 /* Propagate the phy page selection error code */ 458 ret = oldpage; 459 } 460 461 mutex_unlock(&phydev->mdio.bus->mdio_lock); 462 463 return ret; 464 } 465 EXPORT_SYMBOL_GPL(phy_restore_page); 466 467 /** 468 * phy_read_paged() - Convenience function for reading a paged register 469 * @phydev: a pointer to a &struct phy_device 470 * @page: the page for the phy 471 * @regnum: register number 472 * 473 * Same rules as for phy_read(). 474 */ 475 int phy_read_paged(struct phy_device *phydev, int page, u32 regnum) 476 { 477 int ret = 0, oldpage; 478 479 oldpage = phy_select_page(phydev, page); 480 if (oldpage >= 0) 481 ret = __phy_read(phydev, regnum); 482 483 return phy_restore_page(phydev, oldpage, ret); 484 } 485 EXPORT_SYMBOL(phy_read_paged); 486 487 /** 488 * phy_write_paged() - Convenience function for writing a paged register 489 * @phydev: a pointer to a &struct phy_device 490 * @page: the page for the phy 491 * @regnum: register number 492 * @val: value to write 493 * 494 * Same rules as for phy_write(). 495 */ 496 int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val) 497 { 498 int ret = 0, oldpage; 499 500 oldpage = phy_select_page(phydev, page); 501 if (oldpage >= 0) 502 ret = __phy_write(phydev, regnum, val); 503 504 return phy_restore_page(phydev, oldpage, ret); 505 } 506 EXPORT_SYMBOL(phy_write_paged); 507 508 /** 509 * phy_modify_paged() - Convenience function for modifying a paged register 510 * @phydev: a pointer to a &struct phy_device 511 * @page: the page for the phy 512 * @regnum: register number 513 * @mask: bit mask of bits to clear 514 * @set: bit mask of bits to set 515 * 516 * Same rules as for phy_read() and phy_write(). 517 */ 518 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum, 519 u16 mask, u16 set) 520 { 521 int ret = 0, oldpage; 522 523 oldpage = phy_select_page(phydev, page); 524 if (oldpage >= 0) 525 ret = __phy_modify(phydev, regnum, mask, set); 526 527 return phy_restore_page(phydev, oldpage, ret); 528 } 529 EXPORT_SYMBOL(phy_modify_paged); 530