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