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