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, res; 340 341 ret = __phy_read(phydev, regnum); 342 if (ret >= 0) { 343 res = __phy_write(phydev, regnum, (ret & ~mask) | set); 344 if (res < 0) 345 ret = res; 346 } 347 348 return ret; 349 } 350 EXPORT_SYMBOL_GPL(__phy_modify); 351 352 /** 353 * phy_modify - Convenience function for modifying a given PHY register 354 * @phydev: the phy_device struct 355 * @regnum: register number to write 356 * @mask: bit mask of bits to clear 357 * @set: new value of bits set in mask to write to @regnum 358 * 359 * NOTE: MUST NOT be called from interrupt context, 360 * because the bus read/write functions may wait for an interrupt 361 * to conclude the operation. 362 */ 363 int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set) 364 { 365 int ret; 366 367 mutex_lock(&phydev->mdio.bus->mdio_lock); 368 ret = __phy_modify(phydev, regnum, mask, set); 369 mutex_unlock(&phydev->mdio.bus->mdio_lock); 370 371 return ret; 372 } 373 EXPORT_SYMBOL_GPL(phy_modify); 374 375 static int __phy_read_page(struct phy_device *phydev) 376 { 377 return phydev->drv->read_page(phydev); 378 } 379 380 static int __phy_write_page(struct phy_device *phydev, int page) 381 { 382 return phydev->drv->write_page(phydev, page); 383 } 384 385 /** 386 * phy_save_page() - take the bus lock and save the current page 387 * @phydev: a pointer to a &struct phy_device 388 * 389 * Take the MDIO bus lock, and return the current page number. On error, 390 * returns a negative errno. phy_restore_page() must always be called 391 * after this, irrespective of success or failure of this call. 392 */ 393 int phy_save_page(struct phy_device *phydev) 394 { 395 mutex_lock(&phydev->mdio.bus->mdio_lock); 396 return __phy_read_page(phydev); 397 } 398 EXPORT_SYMBOL_GPL(phy_save_page); 399 400 /** 401 * phy_select_page() - take the bus lock, save the current page, and set a page 402 * @phydev: a pointer to a &struct phy_device 403 * @page: desired page 404 * 405 * Take the MDIO bus lock to protect against concurrent access, save the 406 * current PHY page, and set the current page. On error, returns a 407 * negative errno, otherwise returns the previous page number. 408 * phy_restore_page() must always be called after this, irrespective 409 * of success or failure of this call. 410 */ 411 int phy_select_page(struct phy_device *phydev, int page) 412 { 413 int ret, oldpage; 414 415 oldpage = ret = phy_save_page(phydev); 416 if (ret < 0) 417 return ret; 418 419 if (oldpage != page) { 420 ret = __phy_write_page(phydev, page); 421 if (ret < 0) 422 return ret; 423 } 424 425 return oldpage; 426 } 427 EXPORT_SYMBOL_GPL(phy_select_page); 428 429 /** 430 * phy_restore_page() - restore the page register and release the bus lock 431 * @phydev: a pointer to a &struct phy_device 432 * @oldpage: the old page, return value from phy_save_page() or phy_select_page() 433 * @ret: operation's return code 434 * 435 * Release the MDIO bus lock, restoring @oldpage if it is a valid page. 436 * This function propagates the earliest error code from the group of 437 * operations. 438 * 439 * Returns: 440 * @oldpage if it was a negative value, otherwise 441 * @ret if it was a negative errno value, otherwise 442 * phy_write_page()'s negative value if it were in error, otherwise 443 * @ret. 444 */ 445 int phy_restore_page(struct phy_device *phydev, int oldpage, int ret) 446 { 447 int r; 448 449 if (oldpage >= 0) { 450 r = __phy_write_page(phydev, oldpage); 451 452 /* Propagate the operation return code if the page write 453 * was successful. 454 */ 455 if (ret >= 0 && r < 0) 456 ret = r; 457 } else { 458 /* Propagate the phy page selection error code */ 459 ret = oldpage; 460 } 461 462 mutex_unlock(&phydev->mdio.bus->mdio_lock); 463 464 return ret; 465 } 466 EXPORT_SYMBOL_GPL(phy_restore_page); 467 468 /** 469 * phy_read_paged() - Convenience function for reading a paged register 470 * @phydev: a pointer to a &struct phy_device 471 * @page: the page for the phy 472 * @regnum: register number 473 * 474 * Same rules as for phy_read(). 475 */ 476 int phy_read_paged(struct phy_device *phydev, int page, u32 regnum) 477 { 478 int ret = 0, oldpage; 479 480 oldpage = phy_select_page(phydev, page); 481 if (oldpage >= 0) 482 ret = __phy_read(phydev, regnum); 483 484 return phy_restore_page(phydev, oldpage, ret); 485 } 486 EXPORT_SYMBOL(phy_read_paged); 487 488 /** 489 * phy_write_paged() - Convenience function for writing a paged register 490 * @phydev: a pointer to a &struct phy_device 491 * @page: the page for the phy 492 * @regnum: register number 493 * @val: value to write 494 * 495 * Same rules as for phy_write(). 496 */ 497 int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val) 498 { 499 int ret = 0, oldpage; 500 501 oldpage = phy_select_page(phydev, page); 502 if (oldpage >= 0) 503 ret = __phy_write(phydev, regnum, val); 504 505 return phy_restore_page(phydev, oldpage, ret); 506 } 507 EXPORT_SYMBOL(phy_write_paged); 508 509 /** 510 * phy_modify_paged() - Convenience function for modifying a paged register 511 * @phydev: a pointer to a &struct phy_device 512 * @page: the page for the phy 513 * @regnum: register number 514 * @mask: bit mask of bits to clear 515 * @set: bit mask of bits to set 516 * 517 * Same rules as for phy_read() and phy_write(). 518 */ 519 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum, 520 u16 mask, u16 set) 521 { 522 int ret = 0, oldpage; 523 524 oldpage = phy_select_page(phydev, page); 525 if (oldpage >= 0) 526 ret = __phy_modify(phydev, regnum, mask, set); 527 528 return phy_restore_page(phydev, oldpage, ret); 529 } 530 EXPORT_SYMBOL(phy_modify_paged); 531