1// SPDX-License-Identifier: GPL-2.0-only 2#include <linux/export.h> 3#include <linux/kref.h> 4#include <linux/list.h> 5#include <linux/mutex.h> 6#include <linux/phylink.h> 7#include <linux/property.h> 8#include <linux/rtnetlink.h> 9#include <linux/slab.h> 10 11#include "sfp.h" 12 13struct sfp_quirk { 14 const char *vendor; 15 const char *part; 16 void (*modes)(const struct sfp_eeprom_id *id, unsigned long *modes); 17}; 18 19/** 20 * struct sfp_bus - internal representation of a sfp bus 21 */ 22struct sfp_bus { 23 /* private: */ 24 struct kref kref; 25 struct list_head node; 26 struct fwnode_handle *fwnode; 27 28 const struct sfp_socket_ops *socket_ops; 29 struct device *sfp_dev; 30 struct sfp *sfp; 31 const struct sfp_quirk *sfp_quirk; 32 33 const struct sfp_upstream_ops *upstream_ops; 34 void *upstream; 35 struct phy_device *phydev; 36 37 bool registered; 38 bool started; 39}; 40 41static void sfp_quirk_2500basex(const struct sfp_eeprom_id *id, 42 unsigned long *modes) 43{ 44 phylink_set(modes, 2500baseX_Full); 45} 46 47static void sfp_quirk_ubnt_uf_instant(const struct sfp_eeprom_id *id, 48 unsigned long *modes) 49{ 50 /* Ubiquiti U-Fiber Instant module claims that support all transceiver 51 * types including 10G Ethernet which is not truth. So clear all claimed 52 * modes and set only one mode which module supports: 1000baseX_Full. 53 */ 54 phylink_zero(modes); 55 phylink_set(modes, 1000baseX_Full); 56} 57 58static const struct sfp_quirk sfp_quirks[] = { 59 { 60 // Alcatel Lucent G-010S-P can operate at 2500base-X, but 61 // incorrectly report 2500MBd NRZ in their EEPROM 62 .vendor = "ALCATELLUCENT", 63 .part = "G010SP", 64 .modes = sfp_quirk_2500basex, 65 }, { 66 // Alcatel Lucent G-010S-A can operate at 2500base-X, but 67 // report 3.2GBd NRZ in their EEPROM 68 .vendor = "ALCATELLUCENT", 69 .part = "3FE46541AA", 70 .modes = sfp_quirk_2500basex, 71 }, { 72 // Huawei MA5671A can operate at 2500base-X, but report 1.2GBd 73 // NRZ in their EEPROM 74 .vendor = "HUAWEI", 75 .part = "MA5671A", 76 .modes = sfp_quirk_2500basex, 77 }, { 78 // Lantech 8330-262D-E can operate at 2500base-X, but 79 // incorrectly report 2500MBd NRZ in their EEPROM 80 .vendor = "Lantech", 81 .part = "8330-262D-E", 82 .modes = sfp_quirk_2500basex, 83 }, { 84 .vendor = "UBNT", 85 .part = "UF-INSTANT", 86 .modes = sfp_quirk_ubnt_uf_instant, 87 }, 88}; 89 90static size_t sfp_strlen(const char *str, size_t maxlen) 91{ 92 size_t size, i; 93 94 /* Trailing characters should be filled with space chars */ 95 for (i = 0, size = 0; i < maxlen; i++) 96 if (str[i] != ' ') 97 size = i + 1; 98 99 return size; 100} 101 102static bool sfp_match(const char *qs, const char *str, size_t len) 103{ 104 if (!qs) 105 return true; 106 if (strlen(qs) != len) 107 return false; 108 return !strncmp(qs, str, len); 109} 110 111static const struct sfp_quirk *sfp_lookup_quirk(const struct sfp_eeprom_id *id) 112{ 113 const struct sfp_quirk *q; 114 unsigned int i; 115 size_t vs, ps; 116 117 vs = sfp_strlen(id->base.vendor_name, ARRAY_SIZE(id->base.vendor_name)); 118 ps = sfp_strlen(id->base.vendor_pn, ARRAY_SIZE(id->base.vendor_pn)); 119 120 for (i = 0, q = sfp_quirks; i < ARRAY_SIZE(sfp_quirks); i++, q++) 121 if (sfp_match(q->vendor, id->base.vendor_name, vs) && 122 sfp_match(q->part, id->base.vendor_pn, ps)) 123 return q; 124 125 return NULL; 126} 127 128/** 129 * sfp_parse_port() - Parse the EEPROM base ID, setting the port type 130 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 131 * @id: a pointer to the module's &struct sfp_eeprom_id 132 * @support: optional pointer to an array of unsigned long for the 133 * ethtool support mask 134 * 135 * Parse the EEPROM identification given in @id, and return one of 136 * %PORT_TP, %PORT_FIBRE or %PORT_OTHER. If @support is non-%NULL, 137 * also set the ethtool %ETHTOOL_LINK_MODE_xxx_BIT corresponding with 138 * the connector type. 139 * 140 * If the port type is not known, returns %PORT_OTHER. 141 */ 142int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id, 143 unsigned long *support) 144{ 145 int port; 146 147 /* port is the physical connector, set this from the connector field. */ 148 switch (id->base.connector) { 149 case SFF8024_CONNECTOR_SC: 150 case SFF8024_CONNECTOR_FIBERJACK: 151 case SFF8024_CONNECTOR_LC: 152 case SFF8024_CONNECTOR_MT_RJ: 153 case SFF8024_CONNECTOR_MU: 154 case SFF8024_CONNECTOR_OPTICAL_PIGTAIL: 155 case SFF8024_CONNECTOR_MPO_1X12: 156 case SFF8024_CONNECTOR_MPO_2X16: 157 port = PORT_FIBRE; 158 break; 159 160 case SFF8024_CONNECTOR_RJ45: 161 port = PORT_TP; 162 break; 163 164 case SFF8024_CONNECTOR_COPPER_PIGTAIL: 165 port = PORT_DA; 166 break; 167 168 case SFF8024_CONNECTOR_UNSPEC: 169 if (id->base.e1000_base_t) { 170 port = PORT_TP; 171 break; 172 } 173 fallthrough; 174 case SFF8024_CONNECTOR_SG: /* guess */ 175 case SFF8024_CONNECTOR_HSSDC_II: 176 case SFF8024_CONNECTOR_NOSEPARATE: 177 case SFF8024_CONNECTOR_MXC_2X16: 178 port = PORT_OTHER; 179 break; 180 default: 181 dev_warn(bus->sfp_dev, "SFP: unknown connector id 0x%02x\n", 182 id->base.connector); 183 port = PORT_OTHER; 184 break; 185 } 186 187 if (support) { 188 switch (port) { 189 case PORT_FIBRE: 190 phylink_set(support, FIBRE); 191 break; 192 193 case PORT_TP: 194 phylink_set(support, TP); 195 break; 196 } 197 } 198 199 return port; 200} 201EXPORT_SYMBOL_GPL(sfp_parse_port); 202 203/** 204 * sfp_may_have_phy() - indicate whether the module may have a PHY 205 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 206 * @id: a pointer to the module's &struct sfp_eeprom_id 207 * 208 * Parse the EEPROM identification given in @id, and return whether 209 * this module may have a PHY. 210 */ 211bool sfp_may_have_phy(struct sfp_bus *bus, const struct sfp_eeprom_id *id) 212{ 213 if (id->base.e1000_base_t) 214 return true; 215 216 if (id->base.phys_id != SFF8024_ID_DWDM_SFP) { 217 switch (id->base.extended_cc) { 218 case SFF8024_ECC_10GBASE_T_SFI: 219 case SFF8024_ECC_10GBASE_T_SR: 220 case SFF8024_ECC_5GBASE_T: 221 case SFF8024_ECC_2_5GBASE_T: 222 return true; 223 } 224 } 225 226 return false; 227} 228EXPORT_SYMBOL_GPL(sfp_may_have_phy); 229 230/** 231 * sfp_parse_support() - Parse the eeprom id for supported link modes 232 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 233 * @id: a pointer to the module's &struct sfp_eeprom_id 234 * @support: pointer to an array of unsigned long for the ethtool support mask 235 * 236 * Parse the EEPROM identification information and derive the supported 237 * ethtool link modes for the module. 238 */ 239void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id, 240 unsigned long *support) 241{ 242 unsigned int br_min, br_nom, br_max; 243 __ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, }; 244 245 /* Decode the bitrate information to MBd */ 246 br_min = br_nom = br_max = 0; 247 if (id->base.br_nominal) { 248 if (id->base.br_nominal != 255) { 249 br_nom = id->base.br_nominal * 100; 250 br_min = br_nom - id->base.br_nominal * id->ext.br_min; 251 br_max = br_nom + id->base.br_nominal * id->ext.br_max; 252 } else if (id->ext.br_max) { 253 br_nom = 250 * id->ext.br_max; 254 br_max = br_nom + br_nom * id->ext.br_min / 100; 255 br_min = br_nom - br_nom * id->ext.br_min / 100; 256 } 257 258 /* When using passive cables, in case neither BR,min nor BR,max 259 * are specified, set br_min to 0 as the nominal value is then 260 * used as the maximum. 261 */ 262 if (br_min == br_max && id->base.sfp_ct_passive) 263 br_min = 0; 264 } 265 266 /* Set ethtool support from the compliance fields. */ 267 if (id->base.e10g_base_sr) 268 phylink_set(modes, 10000baseSR_Full); 269 if (id->base.e10g_base_lr) 270 phylink_set(modes, 10000baseLR_Full); 271 if (id->base.e10g_base_lrm) 272 phylink_set(modes, 10000baseLRM_Full); 273 if (id->base.e10g_base_er) 274 phylink_set(modes, 10000baseER_Full); 275 if (id->base.e1000_base_sx || 276 id->base.e1000_base_lx || 277 id->base.e1000_base_cx) 278 phylink_set(modes, 1000baseX_Full); 279 if (id->base.e1000_base_t) { 280 phylink_set(modes, 1000baseT_Half); 281 phylink_set(modes, 1000baseT_Full); 282 } 283 284 /* 1000Base-PX or 1000Base-BX10 */ 285 if ((id->base.e_base_px || id->base.e_base_bx10) && 286 br_min <= 1300 && br_max >= 1200) 287 phylink_set(modes, 1000baseX_Full); 288 289 /* For active or passive cables, select the link modes 290 * based on the bit rates and the cable compliance bytes. 291 */ 292 if ((id->base.sfp_ct_passive || id->base.sfp_ct_active) && br_nom) { 293 /* This may look odd, but some manufacturers use 12000MBd */ 294 if (br_min <= 12000 && br_max >= 10300) 295 phylink_set(modes, 10000baseCR_Full); 296 if (br_min <= 3200 && br_max >= 3100) 297 phylink_set(modes, 2500baseX_Full); 298 if (br_min <= 1300 && br_max >= 1200) 299 phylink_set(modes, 1000baseX_Full); 300 } 301 if (id->base.sfp_ct_passive) { 302 if (id->base.passive.sff8431_app_e) 303 phylink_set(modes, 10000baseCR_Full); 304 } 305 if (id->base.sfp_ct_active) { 306 if (id->base.active.sff8431_app_e || 307 id->base.active.sff8431_lim) { 308 phylink_set(modes, 10000baseCR_Full); 309 } 310 } 311 312 switch (id->base.extended_cc) { 313 case SFF8024_ECC_UNSPEC: 314 break; 315 case SFF8024_ECC_100GBASE_SR4_25GBASE_SR: 316 phylink_set(modes, 100000baseSR4_Full); 317 phylink_set(modes, 25000baseSR_Full); 318 break; 319 case SFF8024_ECC_100GBASE_LR4_25GBASE_LR: 320 case SFF8024_ECC_100GBASE_ER4_25GBASE_ER: 321 phylink_set(modes, 100000baseLR4_ER4_Full); 322 break; 323 case SFF8024_ECC_100GBASE_CR4: 324 phylink_set(modes, 100000baseCR4_Full); 325 fallthrough; 326 case SFF8024_ECC_25GBASE_CR_S: 327 case SFF8024_ECC_25GBASE_CR_N: 328 phylink_set(modes, 25000baseCR_Full); 329 break; 330 case SFF8024_ECC_10GBASE_T_SFI: 331 case SFF8024_ECC_10GBASE_T_SR: 332 phylink_set(modes, 10000baseT_Full); 333 break; 334 case SFF8024_ECC_5GBASE_T: 335 phylink_set(modes, 5000baseT_Full); 336 break; 337 case SFF8024_ECC_2_5GBASE_T: 338 phylink_set(modes, 2500baseT_Full); 339 break; 340 default: 341 dev_warn(bus->sfp_dev, 342 "Unknown/unsupported extended compliance code: 0x%02x\n", 343 id->base.extended_cc); 344 break; 345 } 346 347 /* For fibre channel SFP, derive possible BaseX modes */ 348 if (id->base.fc_speed_100 || 349 id->base.fc_speed_200 || 350 id->base.fc_speed_400) { 351 if (id->base.br_nominal >= 31) 352 phylink_set(modes, 2500baseX_Full); 353 if (id->base.br_nominal >= 12) 354 phylink_set(modes, 1000baseX_Full); 355 } 356 357 /* If we haven't discovered any modes that this module supports, try 358 * the bitrate to determine supported modes. Some BiDi modules (eg, 359 * 1310nm/1550nm) are not 1000BASE-BX compliant due to the differing 360 * wavelengths, so do not set any transceiver bits. 361 */ 362 if (bitmap_empty(modes, __ETHTOOL_LINK_MODE_MASK_NBITS)) { 363 /* If the bit rate allows 1000baseX */ 364 if (br_nom && br_min <= 1300 && br_max >= 1200) 365 phylink_set(modes, 1000baseX_Full); 366 } 367 368 if (bus->sfp_quirk) 369 bus->sfp_quirk->modes(id, modes); 370 371 bitmap_or(support, support, modes, __ETHTOOL_LINK_MODE_MASK_NBITS); 372 373 phylink_set(support, Autoneg); 374 phylink_set(support, Pause); 375 phylink_set(support, Asym_Pause); 376} 377EXPORT_SYMBOL_GPL(sfp_parse_support); 378 379/** 380 * sfp_select_interface() - Select appropriate phy_interface_t mode 381 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 382 * @link_modes: ethtool link modes mask 383 * 384 * Derive the phy_interface_t mode for the SFP module from the link 385 * modes mask. 386 */ 387phy_interface_t sfp_select_interface(struct sfp_bus *bus, 388 unsigned long *link_modes) 389{ 390 if (phylink_test(link_modes, 10000baseCR_Full) || 391 phylink_test(link_modes, 10000baseSR_Full) || 392 phylink_test(link_modes, 10000baseLR_Full) || 393 phylink_test(link_modes, 10000baseLRM_Full) || 394 phylink_test(link_modes, 10000baseER_Full) || 395 phylink_test(link_modes, 10000baseT_Full)) 396 return PHY_INTERFACE_MODE_10GBASER; 397 398 if (phylink_test(link_modes, 2500baseX_Full)) 399 return PHY_INTERFACE_MODE_2500BASEX; 400 401 if (phylink_test(link_modes, 1000baseT_Half) || 402 phylink_test(link_modes, 1000baseT_Full)) 403 return PHY_INTERFACE_MODE_SGMII; 404 405 if (phylink_test(link_modes, 1000baseX_Full)) 406 return PHY_INTERFACE_MODE_1000BASEX; 407 408 dev_warn(bus->sfp_dev, "Unable to ascertain link mode\n"); 409 410 return PHY_INTERFACE_MODE_NA; 411} 412EXPORT_SYMBOL_GPL(sfp_select_interface); 413 414static LIST_HEAD(sfp_buses); 415static DEFINE_MUTEX(sfp_mutex); 416 417static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus) 418{ 419 return bus->registered ? bus->upstream_ops : NULL; 420} 421 422static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode) 423{ 424 struct sfp_bus *sfp, *new, *found = NULL; 425 426 new = kzalloc(sizeof(*new), GFP_KERNEL); 427 428 mutex_lock(&sfp_mutex); 429 430 list_for_each_entry(sfp, &sfp_buses, node) { 431 if (sfp->fwnode == fwnode) { 432 kref_get(&sfp->kref); 433 found = sfp; 434 break; 435 } 436 } 437 438 if (!found && new) { 439 kref_init(&new->kref); 440 new->fwnode = fwnode; 441 list_add(&new->node, &sfp_buses); 442 found = new; 443 new = NULL; 444 } 445 446 mutex_unlock(&sfp_mutex); 447 448 kfree(new); 449 450 return found; 451} 452 453static void sfp_bus_release(struct kref *kref) 454{ 455 struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref); 456 457 list_del(&bus->node); 458 mutex_unlock(&sfp_mutex); 459 kfree(bus); 460} 461 462/** 463 * sfp_bus_put() - put a reference on the &struct sfp_bus 464 * @bus: the &struct sfp_bus found via sfp_bus_find_fwnode() 465 * 466 * Put a reference on the &struct sfp_bus and free the underlying structure 467 * if this was the last reference. 468 */ 469void sfp_bus_put(struct sfp_bus *bus) 470{ 471 if (bus) 472 kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex); 473} 474EXPORT_SYMBOL_GPL(sfp_bus_put); 475 476static int sfp_register_bus(struct sfp_bus *bus) 477{ 478 const struct sfp_upstream_ops *ops = bus->upstream_ops; 479 int ret; 480 481 if (ops) { 482 if (ops->link_down) 483 ops->link_down(bus->upstream); 484 if (ops->connect_phy && bus->phydev) { 485 ret = ops->connect_phy(bus->upstream, bus->phydev); 486 if (ret) 487 return ret; 488 } 489 } 490 bus->registered = true; 491 bus->socket_ops->attach(bus->sfp); 492 if (bus->started) 493 bus->socket_ops->start(bus->sfp); 494 bus->upstream_ops->attach(bus->upstream, bus); 495 return 0; 496} 497 498static void sfp_unregister_bus(struct sfp_bus *bus) 499{ 500 const struct sfp_upstream_ops *ops = bus->upstream_ops; 501 502 if (bus->registered) { 503 bus->upstream_ops->detach(bus->upstream, bus); 504 if (bus->started) 505 bus->socket_ops->stop(bus->sfp); 506 bus->socket_ops->detach(bus->sfp); 507 if (bus->phydev && ops && ops->disconnect_phy) 508 ops->disconnect_phy(bus->upstream); 509 } 510 bus->registered = false; 511} 512 513/** 514 * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module 515 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 516 * @modinfo: a &struct ethtool_modinfo 517 * 518 * Fill in the type and eeprom_len parameters in @modinfo for a module on 519 * the sfp bus specified by @bus. 520 * 521 * Returns 0 on success or a negative errno number. 522 */ 523int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo) 524{ 525 return bus->socket_ops->module_info(bus->sfp, modinfo); 526} 527EXPORT_SYMBOL_GPL(sfp_get_module_info); 528 529/** 530 * sfp_get_module_eeprom() - Read the SFP module EEPROM 531 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 532 * @ee: a &struct ethtool_eeprom 533 * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes) 534 * 535 * Read the EEPROM as specified by the supplied @ee. See the documentation 536 * for &struct ethtool_eeprom for the region to be read. 537 * 538 * Returns 0 on success or a negative errno number. 539 */ 540int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee, 541 u8 *data) 542{ 543 return bus->socket_ops->module_eeprom(bus->sfp, ee, data); 544} 545EXPORT_SYMBOL_GPL(sfp_get_module_eeprom); 546 547/** 548 * sfp_upstream_start() - Inform the SFP that the network device is up 549 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 550 * 551 * Inform the SFP socket that the network device is now up, so that the 552 * module can be enabled by allowing TX_DISABLE to be deasserted. This 553 * should be called from the network device driver's &struct net_device_ops 554 * ndo_open() method. 555 */ 556void sfp_upstream_start(struct sfp_bus *bus) 557{ 558 if (bus->registered) 559 bus->socket_ops->start(bus->sfp); 560 bus->started = true; 561} 562EXPORT_SYMBOL_GPL(sfp_upstream_start); 563 564/** 565 * sfp_upstream_stop() - Inform the SFP that the network device is down 566 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 567 * 568 * Inform the SFP socket that the network device is now up, so that the 569 * module can be disabled by asserting TX_DISABLE, disabling the laser 570 * in optical modules. This should be called from the network device 571 * driver's &struct net_device_ops ndo_stop() method. 572 */ 573void sfp_upstream_stop(struct sfp_bus *bus) 574{ 575 if (bus->registered) 576 bus->socket_ops->stop(bus->sfp); 577 bus->started = false; 578} 579EXPORT_SYMBOL_GPL(sfp_upstream_stop); 580 581static void sfp_upstream_clear(struct sfp_bus *bus) 582{ 583 bus->upstream_ops = NULL; 584 bus->upstream = NULL; 585} 586 587/** 588 * sfp_bus_find_fwnode() - parse and locate the SFP bus from fwnode 589 * @fwnode: firmware node for the parent device (MAC or PHY) 590 * 591 * Parse the parent device's firmware node for a SFP bus, and locate 592 * the sfp_bus structure, incrementing its reference count. This must 593 * be put via sfp_bus_put() when done. 594 * 595 * Returns: 596 * - on success, a pointer to the sfp_bus structure, 597 * - %NULL if no SFP is specified, 598 * - on failure, an error pointer value: 599 * 600 * - corresponding to the errors detailed for 601 * fwnode_property_get_reference_args(). 602 * - %-ENOMEM if we failed to allocate the bus. 603 * - an error from the upstream's connect_phy() method. 604 */ 605struct sfp_bus *sfp_bus_find_fwnode(struct fwnode_handle *fwnode) 606{ 607 struct fwnode_reference_args ref; 608 struct sfp_bus *bus; 609 int ret; 610 611 ret = fwnode_property_get_reference_args(fwnode, "sfp", NULL, 612 0, 0, &ref); 613 if (ret == -ENOENT) 614 return NULL; 615 else if (ret < 0) 616 return ERR_PTR(ret); 617 618 if (!fwnode_device_is_available(ref.fwnode)) { 619 fwnode_handle_put(ref.fwnode); 620 return NULL; 621 } 622 623 bus = sfp_bus_get(ref.fwnode); 624 fwnode_handle_put(ref.fwnode); 625 if (!bus) 626 return ERR_PTR(-ENOMEM); 627 628 return bus; 629} 630EXPORT_SYMBOL_GPL(sfp_bus_find_fwnode); 631 632/** 633 * sfp_bus_add_upstream() - parse and register the neighbouring device 634 * @bus: the &struct sfp_bus found via sfp_bus_find_fwnode() 635 * @upstream: the upstream private data 636 * @ops: the upstream's &struct sfp_upstream_ops 637 * 638 * Add upstream driver for the SFP bus, and if the bus is complete, register 639 * the SFP bus using sfp_register_upstream(). This takes a reference on the 640 * bus, so it is safe to put the bus after this call. 641 * 642 * Returns: 643 * - on success, a pointer to the sfp_bus structure, 644 * - %NULL if no SFP is specified, 645 * - on failure, an error pointer value: 646 * 647 * - corresponding to the errors detailed for 648 * fwnode_property_get_reference_args(). 649 * - %-ENOMEM if we failed to allocate the bus. 650 * - an error from the upstream's connect_phy() method. 651 */ 652int sfp_bus_add_upstream(struct sfp_bus *bus, void *upstream, 653 const struct sfp_upstream_ops *ops) 654{ 655 int ret; 656 657 /* If no bus, return success */ 658 if (!bus) 659 return 0; 660 661 rtnl_lock(); 662 kref_get(&bus->kref); 663 bus->upstream_ops = ops; 664 bus->upstream = upstream; 665 666 if (bus->sfp) { 667 ret = sfp_register_bus(bus); 668 if (ret) 669 sfp_upstream_clear(bus); 670 } else { 671 ret = 0; 672 } 673 rtnl_unlock(); 674 675 if (ret) 676 sfp_bus_put(bus); 677 678 return ret; 679} 680EXPORT_SYMBOL_GPL(sfp_bus_add_upstream); 681 682/** 683 * sfp_bus_del_upstream() - Delete a sfp bus 684 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 685 * 686 * Delete a previously registered upstream connection for the SFP 687 * module. @bus should have been added by sfp_bus_add_upstream(). 688 */ 689void sfp_bus_del_upstream(struct sfp_bus *bus) 690{ 691 if (bus) { 692 rtnl_lock(); 693 if (bus->sfp) 694 sfp_unregister_bus(bus); 695 sfp_upstream_clear(bus); 696 rtnl_unlock(); 697 698 sfp_bus_put(bus); 699 } 700} 701EXPORT_SYMBOL_GPL(sfp_bus_del_upstream); 702 703/* Socket driver entry points */ 704int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev) 705{ 706 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 707 int ret = 0; 708 709 if (ops && ops->connect_phy) 710 ret = ops->connect_phy(bus->upstream, phydev); 711 712 if (ret == 0) 713 bus->phydev = phydev; 714 715 return ret; 716} 717EXPORT_SYMBOL_GPL(sfp_add_phy); 718 719void sfp_remove_phy(struct sfp_bus *bus) 720{ 721 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 722 723 if (ops && ops->disconnect_phy) 724 ops->disconnect_phy(bus->upstream); 725 bus->phydev = NULL; 726} 727EXPORT_SYMBOL_GPL(sfp_remove_phy); 728 729void sfp_link_up(struct sfp_bus *bus) 730{ 731 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 732 733 if (ops && ops->link_up) 734 ops->link_up(bus->upstream); 735} 736EXPORT_SYMBOL_GPL(sfp_link_up); 737 738void sfp_link_down(struct sfp_bus *bus) 739{ 740 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 741 742 if (ops && ops->link_down) 743 ops->link_down(bus->upstream); 744} 745EXPORT_SYMBOL_GPL(sfp_link_down); 746 747int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id) 748{ 749 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 750 int ret = 0; 751 752 bus->sfp_quirk = sfp_lookup_quirk(id); 753 754 if (ops && ops->module_insert) 755 ret = ops->module_insert(bus->upstream, id); 756 757 return ret; 758} 759EXPORT_SYMBOL_GPL(sfp_module_insert); 760 761void sfp_module_remove(struct sfp_bus *bus) 762{ 763 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 764 765 if (ops && ops->module_remove) 766 ops->module_remove(bus->upstream); 767 768 bus->sfp_quirk = NULL; 769} 770EXPORT_SYMBOL_GPL(sfp_module_remove); 771 772int sfp_module_start(struct sfp_bus *bus) 773{ 774 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 775 int ret = 0; 776 777 if (ops && ops->module_start) 778 ret = ops->module_start(bus->upstream); 779 780 return ret; 781} 782EXPORT_SYMBOL_GPL(sfp_module_start); 783 784void sfp_module_stop(struct sfp_bus *bus) 785{ 786 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 787 788 if (ops && ops->module_stop) 789 ops->module_stop(bus->upstream); 790} 791EXPORT_SYMBOL_GPL(sfp_module_stop); 792 793static void sfp_socket_clear(struct sfp_bus *bus) 794{ 795 bus->sfp_dev = NULL; 796 bus->sfp = NULL; 797 bus->socket_ops = NULL; 798} 799 800struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp, 801 const struct sfp_socket_ops *ops) 802{ 803 struct sfp_bus *bus = sfp_bus_get(dev->fwnode); 804 int ret = 0; 805 806 if (bus) { 807 rtnl_lock(); 808 bus->sfp_dev = dev; 809 bus->sfp = sfp; 810 bus->socket_ops = ops; 811 812 if (bus->upstream_ops) { 813 ret = sfp_register_bus(bus); 814 if (ret) 815 sfp_socket_clear(bus); 816 } 817 rtnl_unlock(); 818 } 819 820 if (ret) { 821 sfp_bus_put(bus); 822 bus = NULL; 823 } 824 825 return bus; 826} 827EXPORT_SYMBOL_GPL(sfp_register_socket); 828 829void sfp_unregister_socket(struct sfp_bus *bus) 830{ 831 rtnl_lock(); 832 if (bus->upstream_ops) 833 sfp_unregister_bus(bus); 834 sfp_socket_clear(bus); 835 rtnl_unlock(); 836 837 sfp_bus_put(bus); 838} 839EXPORT_SYMBOL_GPL(sfp_unregister_socket); 840