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