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