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/rtnetlink.h> 8 #include <linux/slab.h> 9 10 #include "sfp.h" 11 12 /** 13 * struct sfp_bus - internal representation of a sfp bus 14 */ 15 struct sfp_bus { 16 /* private: */ 17 struct kref kref; 18 struct list_head node; 19 struct fwnode_handle *fwnode; 20 21 const struct sfp_socket_ops *socket_ops; 22 struct device *sfp_dev; 23 struct sfp *sfp; 24 25 const struct sfp_upstream_ops *upstream_ops; 26 void *upstream; 27 struct net_device *netdev; 28 struct phy_device *phydev; 29 30 bool registered; 31 bool started; 32 }; 33 34 /** 35 * sfp_parse_port() - Parse the EEPROM base ID, setting the port type 36 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 37 * @id: a pointer to the module's &struct sfp_eeprom_id 38 * @support: optional pointer to an array of unsigned long for the 39 * ethtool support mask 40 * 41 * Parse the EEPROM identification given in @id, and return one of 42 * %PORT_TP, %PORT_FIBRE or %PORT_OTHER. If @support is non-%NULL, 43 * also set the ethtool %ETHTOOL_LINK_MODE_xxx_BIT corresponding with 44 * the connector type. 45 * 46 * If the port type is not known, returns %PORT_OTHER. 47 */ 48 int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id, 49 unsigned long *support) 50 { 51 int port; 52 53 /* port is the physical connector, set this from the connector field. */ 54 switch (id->base.connector) { 55 case SFP_CONNECTOR_SC: 56 case SFP_CONNECTOR_FIBERJACK: 57 case SFP_CONNECTOR_LC: 58 case SFP_CONNECTOR_MT_RJ: 59 case SFP_CONNECTOR_MU: 60 case SFP_CONNECTOR_OPTICAL_PIGTAIL: 61 port = PORT_FIBRE; 62 break; 63 64 case SFP_CONNECTOR_RJ45: 65 port = PORT_TP; 66 break; 67 68 case SFP_CONNECTOR_COPPER_PIGTAIL: 69 port = PORT_DA; 70 break; 71 72 case SFP_CONNECTOR_UNSPEC: 73 if (id->base.e1000_base_t) { 74 port = PORT_TP; 75 break; 76 } 77 /* fallthrough */ 78 case SFP_CONNECTOR_SG: /* guess */ 79 case SFP_CONNECTOR_MPO_1X12: 80 case SFP_CONNECTOR_MPO_2X16: 81 case SFP_CONNECTOR_HSSDC_II: 82 case SFP_CONNECTOR_NOSEPARATE: 83 case SFP_CONNECTOR_MXC_2X16: 84 port = PORT_OTHER; 85 break; 86 default: 87 dev_warn(bus->sfp_dev, "SFP: unknown connector id 0x%02x\n", 88 id->base.connector); 89 port = PORT_OTHER; 90 break; 91 } 92 93 if (support) { 94 switch (port) { 95 case PORT_FIBRE: 96 phylink_set(support, FIBRE); 97 break; 98 99 case PORT_TP: 100 phylink_set(support, TP); 101 break; 102 } 103 } 104 105 return port; 106 } 107 EXPORT_SYMBOL_GPL(sfp_parse_port); 108 109 /** 110 * sfp_parse_support() - Parse the eeprom id for supported link modes 111 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 112 * @id: a pointer to the module's &struct sfp_eeprom_id 113 * @support: pointer to an array of unsigned long for the ethtool support mask 114 * 115 * Parse the EEPROM identification information and derive the supported 116 * ethtool link modes for the module. 117 */ 118 void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id, 119 unsigned long *support) 120 { 121 unsigned int br_min, br_nom, br_max; 122 __ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, }; 123 124 /* Decode the bitrate information to MBd */ 125 br_min = br_nom = br_max = 0; 126 if (id->base.br_nominal) { 127 if (id->base.br_nominal != 255) { 128 br_nom = id->base.br_nominal * 100; 129 br_min = br_nom - id->base.br_nominal * id->ext.br_min; 130 br_max = br_nom + id->base.br_nominal * id->ext.br_max; 131 } else if (id->ext.br_max) { 132 br_nom = 250 * id->ext.br_max; 133 br_max = br_nom + br_nom * id->ext.br_min / 100; 134 br_min = br_nom - br_nom * id->ext.br_min / 100; 135 } 136 137 /* When using passive cables, in case neither BR,min nor BR,max 138 * are specified, set br_min to 0 as the nominal value is then 139 * used as the maximum. 140 */ 141 if (br_min == br_max && id->base.sfp_ct_passive) 142 br_min = 0; 143 } 144 145 /* Set ethtool support from the compliance fields. */ 146 if (id->base.e10g_base_sr) 147 phylink_set(modes, 10000baseSR_Full); 148 if (id->base.e10g_base_lr) 149 phylink_set(modes, 10000baseLR_Full); 150 if (id->base.e10g_base_lrm) 151 phylink_set(modes, 10000baseLRM_Full); 152 if (id->base.e10g_base_er) 153 phylink_set(modes, 10000baseER_Full); 154 if (id->base.e1000_base_sx || 155 id->base.e1000_base_lx || 156 id->base.e1000_base_cx) 157 phylink_set(modes, 1000baseX_Full); 158 if (id->base.e1000_base_t) { 159 phylink_set(modes, 1000baseT_Half); 160 phylink_set(modes, 1000baseT_Full); 161 } 162 163 /* 1000Base-PX or 1000Base-BX10 */ 164 if ((id->base.e_base_px || id->base.e_base_bx10) && 165 br_min <= 1300 && br_max >= 1200) 166 phylink_set(modes, 1000baseX_Full); 167 168 /* For active or passive cables, select the link modes 169 * based on the bit rates and the cable compliance bytes. 170 */ 171 if ((id->base.sfp_ct_passive || id->base.sfp_ct_active) && br_nom) { 172 /* This may look odd, but some manufacturers use 12000MBd */ 173 if (br_min <= 12000 && br_max >= 10300) 174 phylink_set(modes, 10000baseCR_Full); 175 if (br_min <= 3200 && br_max >= 3100) 176 phylink_set(modes, 2500baseX_Full); 177 if (br_min <= 1300 && br_max >= 1200) 178 phylink_set(modes, 1000baseX_Full); 179 } 180 if (id->base.sfp_ct_passive) { 181 if (id->base.passive.sff8431_app_e) 182 phylink_set(modes, 10000baseCR_Full); 183 } 184 if (id->base.sfp_ct_active) { 185 if (id->base.active.sff8431_app_e || 186 id->base.active.sff8431_lim) { 187 phylink_set(modes, 10000baseCR_Full); 188 } 189 } 190 191 switch (id->base.extended_cc) { 192 case 0x00: /* Unspecified */ 193 break; 194 case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */ 195 phylink_set(modes, 100000baseSR4_Full); 196 phylink_set(modes, 25000baseSR_Full); 197 break; 198 case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */ 199 case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */ 200 phylink_set(modes, 100000baseLR4_ER4_Full); 201 break; 202 case 0x0b: /* 100Gbase-CR4 or 25Gbase-CR CA-L */ 203 case 0x0c: /* 25Gbase-CR CA-S */ 204 case 0x0d: /* 25Gbase-CR CA-N */ 205 phylink_set(modes, 100000baseCR4_Full); 206 phylink_set(modes, 25000baseCR_Full); 207 break; 208 default: 209 dev_warn(bus->sfp_dev, 210 "Unknown/unsupported extended compliance code: 0x%02x\n", 211 id->base.extended_cc); 212 break; 213 } 214 215 /* For fibre channel SFP, derive possible BaseX modes */ 216 if (id->base.fc_speed_100 || 217 id->base.fc_speed_200 || 218 id->base.fc_speed_400) { 219 if (id->base.br_nominal >= 31) 220 phylink_set(modes, 2500baseX_Full); 221 if (id->base.br_nominal >= 12) 222 phylink_set(modes, 1000baseX_Full); 223 } 224 225 /* If we haven't discovered any modes that this module supports, try 226 * the encoding and bitrate to determine supported modes. Some BiDi 227 * modules (eg, 1310nm/1550nm) are not 1000BASE-BX compliant due to 228 * the differing wavelengths, so do not set any transceiver bits. 229 */ 230 if (bitmap_empty(modes, __ETHTOOL_LINK_MODE_MASK_NBITS)) { 231 /* If the encoding and bit rate allows 1000baseX */ 232 if (id->base.encoding == SFP_ENCODING_8B10B && br_nom && 233 br_min <= 1300 && br_max >= 1200) 234 phylink_set(modes, 1000baseX_Full); 235 } 236 237 bitmap_or(support, support, modes, __ETHTOOL_LINK_MODE_MASK_NBITS); 238 239 phylink_set(support, Autoneg); 240 phylink_set(support, Pause); 241 phylink_set(support, Asym_Pause); 242 } 243 EXPORT_SYMBOL_GPL(sfp_parse_support); 244 245 /** 246 * sfp_select_interface() - Select appropriate phy_interface_t mode 247 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 248 * @id: a pointer to the module's &struct sfp_eeprom_id 249 * @link_modes: ethtool link modes mask 250 * 251 * Derive the phy_interface_t mode for the information found in the 252 * module's identifying EEPROM and the link modes mask. There is no 253 * standard or defined way to derive this information, so we decide 254 * based upon the link mode mask. 255 */ 256 phy_interface_t sfp_select_interface(struct sfp_bus *bus, 257 const struct sfp_eeprom_id *id, 258 unsigned long *link_modes) 259 { 260 if (phylink_test(link_modes, 10000baseCR_Full) || 261 phylink_test(link_modes, 10000baseSR_Full) || 262 phylink_test(link_modes, 10000baseLR_Full) || 263 phylink_test(link_modes, 10000baseLRM_Full) || 264 phylink_test(link_modes, 10000baseER_Full)) 265 return PHY_INTERFACE_MODE_10GKR; 266 267 if (phylink_test(link_modes, 2500baseX_Full)) 268 return PHY_INTERFACE_MODE_2500BASEX; 269 270 if (id->base.e1000_base_t || 271 id->base.e100_base_lx || 272 id->base.e100_base_fx) 273 return PHY_INTERFACE_MODE_SGMII; 274 275 if (phylink_test(link_modes, 1000baseX_Full)) 276 return PHY_INTERFACE_MODE_1000BASEX; 277 278 dev_warn(bus->sfp_dev, "Unable to ascertain link mode\n"); 279 280 return PHY_INTERFACE_MODE_NA; 281 } 282 EXPORT_SYMBOL_GPL(sfp_select_interface); 283 284 static LIST_HEAD(sfp_buses); 285 static DEFINE_MUTEX(sfp_mutex); 286 287 static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus) 288 { 289 return bus->registered ? bus->upstream_ops : NULL; 290 } 291 292 static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode) 293 { 294 struct sfp_bus *sfp, *new, *found = NULL; 295 296 new = kzalloc(sizeof(*new), GFP_KERNEL); 297 298 mutex_lock(&sfp_mutex); 299 300 list_for_each_entry(sfp, &sfp_buses, node) { 301 if (sfp->fwnode == fwnode) { 302 kref_get(&sfp->kref); 303 found = sfp; 304 break; 305 } 306 } 307 308 if (!found && new) { 309 kref_init(&new->kref); 310 new->fwnode = fwnode; 311 list_add(&new->node, &sfp_buses); 312 found = new; 313 new = NULL; 314 } 315 316 mutex_unlock(&sfp_mutex); 317 318 kfree(new); 319 320 return found; 321 } 322 323 static void sfp_bus_release(struct kref *kref) 324 { 325 struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref); 326 327 list_del(&bus->node); 328 mutex_unlock(&sfp_mutex); 329 kfree(bus); 330 } 331 332 static void sfp_bus_put(struct sfp_bus *bus) 333 { 334 kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex); 335 } 336 337 static int sfp_register_bus(struct sfp_bus *bus) 338 { 339 const struct sfp_upstream_ops *ops = bus->upstream_ops; 340 int ret; 341 342 if (ops) { 343 if (ops->link_down) 344 ops->link_down(bus->upstream); 345 if (ops->connect_phy && bus->phydev) { 346 ret = ops->connect_phy(bus->upstream, bus->phydev); 347 if (ret) 348 return ret; 349 } 350 } 351 bus->socket_ops->attach(bus->sfp); 352 if (bus->started) 353 bus->socket_ops->start(bus->sfp); 354 bus->netdev->sfp_bus = bus; 355 bus->registered = true; 356 return 0; 357 } 358 359 static void sfp_unregister_bus(struct sfp_bus *bus) 360 { 361 const struct sfp_upstream_ops *ops = bus->upstream_ops; 362 363 bus->netdev->sfp_bus = NULL; 364 if (bus->registered) { 365 if (bus->started) 366 bus->socket_ops->stop(bus->sfp); 367 bus->socket_ops->detach(bus->sfp); 368 if (bus->phydev && ops && ops->disconnect_phy) 369 ops->disconnect_phy(bus->upstream); 370 } 371 bus->registered = false; 372 } 373 374 /** 375 * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module 376 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 377 * @modinfo: a &struct ethtool_modinfo 378 * 379 * Fill in the type and eeprom_len parameters in @modinfo for a module on 380 * the sfp bus specified by @bus. 381 * 382 * Returns 0 on success or a negative errno number. 383 */ 384 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo) 385 { 386 return bus->socket_ops->module_info(bus->sfp, modinfo); 387 } 388 EXPORT_SYMBOL_GPL(sfp_get_module_info); 389 390 /** 391 * sfp_get_module_eeprom() - Read the SFP module EEPROM 392 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 393 * @ee: a &struct ethtool_eeprom 394 * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes) 395 * 396 * Read the EEPROM as specified by the supplied @ee. See the documentation 397 * for &struct ethtool_eeprom for the region to be read. 398 * 399 * Returns 0 on success or a negative errno number. 400 */ 401 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee, 402 u8 *data) 403 { 404 return bus->socket_ops->module_eeprom(bus->sfp, ee, data); 405 } 406 EXPORT_SYMBOL_GPL(sfp_get_module_eeprom); 407 408 /** 409 * sfp_upstream_start() - Inform the SFP that the network device is up 410 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 411 * 412 * Inform the SFP socket that the network device is now up, so that the 413 * module can be enabled by allowing TX_DISABLE to be deasserted. This 414 * should be called from the network device driver's &struct net_device_ops 415 * ndo_open() method. 416 */ 417 void sfp_upstream_start(struct sfp_bus *bus) 418 { 419 if (bus->registered) 420 bus->socket_ops->start(bus->sfp); 421 bus->started = true; 422 } 423 EXPORT_SYMBOL_GPL(sfp_upstream_start); 424 425 /** 426 * sfp_upstream_stop() - Inform the SFP that the network device is down 427 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 428 * 429 * Inform the SFP socket that the network device is now up, so that the 430 * module can be disabled by asserting TX_DISABLE, disabling the laser 431 * in optical modules. This should be called from the network device 432 * driver's &struct net_device_ops ndo_stop() method. 433 */ 434 void sfp_upstream_stop(struct sfp_bus *bus) 435 { 436 if (bus->registered) 437 bus->socket_ops->stop(bus->sfp); 438 bus->started = false; 439 } 440 EXPORT_SYMBOL_GPL(sfp_upstream_stop); 441 442 static void sfp_upstream_clear(struct sfp_bus *bus) 443 { 444 bus->upstream_ops = NULL; 445 bus->upstream = NULL; 446 bus->netdev = NULL; 447 } 448 449 /** 450 * sfp_register_upstream() - Register the neighbouring device 451 * @fwnode: firmware node for the SFP bus 452 * @ndev: network device associated with the interface 453 * @upstream: the upstream private data 454 * @ops: the upstream's &struct sfp_upstream_ops 455 * 456 * Register the upstream device (eg, PHY) with the SFP bus. MAC drivers 457 * should use phylink, which will call this function for them. Returns 458 * a pointer to the allocated &struct sfp_bus. 459 * 460 * On error, returns %NULL. 461 */ 462 struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode, 463 struct net_device *ndev, void *upstream, 464 const struct sfp_upstream_ops *ops) 465 { 466 struct sfp_bus *bus = sfp_bus_get(fwnode); 467 int ret = 0; 468 469 if (bus) { 470 rtnl_lock(); 471 bus->upstream_ops = ops; 472 bus->upstream = upstream; 473 bus->netdev = ndev; 474 475 if (bus->sfp) { 476 ret = sfp_register_bus(bus); 477 if (ret) 478 sfp_upstream_clear(bus); 479 } 480 rtnl_unlock(); 481 } 482 483 if (ret) { 484 sfp_bus_put(bus); 485 bus = NULL; 486 } 487 488 return bus; 489 } 490 EXPORT_SYMBOL_GPL(sfp_register_upstream); 491 492 /** 493 * sfp_unregister_upstream() - Unregister sfp bus 494 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 495 * 496 * Unregister a previously registered upstream connection for the SFP 497 * module. @bus is returned from sfp_register_upstream(). 498 */ 499 void sfp_unregister_upstream(struct sfp_bus *bus) 500 { 501 rtnl_lock(); 502 if (bus->sfp) 503 sfp_unregister_bus(bus); 504 sfp_upstream_clear(bus); 505 rtnl_unlock(); 506 507 sfp_bus_put(bus); 508 } 509 EXPORT_SYMBOL_GPL(sfp_unregister_upstream); 510 511 /* Socket driver entry points */ 512 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev) 513 { 514 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 515 int ret = 0; 516 517 if (ops && ops->connect_phy) 518 ret = ops->connect_phy(bus->upstream, phydev); 519 520 if (ret == 0) 521 bus->phydev = phydev; 522 523 return ret; 524 } 525 EXPORT_SYMBOL_GPL(sfp_add_phy); 526 527 void sfp_remove_phy(struct sfp_bus *bus) 528 { 529 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 530 531 if (ops && ops->disconnect_phy) 532 ops->disconnect_phy(bus->upstream); 533 bus->phydev = NULL; 534 } 535 EXPORT_SYMBOL_GPL(sfp_remove_phy); 536 537 void sfp_link_up(struct sfp_bus *bus) 538 { 539 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 540 541 if (ops && ops->link_up) 542 ops->link_up(bus->upstream); 543 } 544 EXPORT_SYMBOL_GPL(sfp_link_up); 545 546 void sfp_link_down(struct sfp_bus *bus) 547 { 548 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 549 550 if (ops && ops->link_down) 551 ops->link_down(bus->upstream); 552 } 553 EXPORT_SYMBOL_GPL(sfp_link_down); 554 555 int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id) 556 { 557 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 558 int ret = 0; 559 560 if (ops && ops->module_insert) 561 ret = ops->module_insert(bus->upstream, id); 562 563 return ret; 564 } 565 EXPORT_SYMBOL_GPL(sfp_module_insert); 566 567 void sfp_module_remove(struct sfp_bus *bus) 568 { 569 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 570 571 if (ops && ops->module_remove) 572 ops->module_remove(bus->upstream); 573 } 574 EXPORT_SYMBOL_GPL(sfp_module_remove); 575 576 static void sfp_socket_clear(struct sfp_bus *bus) 577 { 578 bus->sfp_dev = NULL; 579 bus->sfp = NULL; 580 bus->socket_ops = NULL; 581 } 582 583 struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp, 584 const struct sfp_socket_ops *ops) 585 { 586 struct sfp_bus *bus = sfp_bus_get(dev->fwnode); 587 int ret = 0; 588 589 if (bus) { 590 rtnl_lock(); 591 bus->sfp_dev = dev; 592 bus->sfp = sfp; 593 bus->socket_ops = ops; 594 595 if (bus->netdev) { 596 ret = sfp_register_bus(bus); 597 if (ret) 598 sfp_socket_clear(bus); 599 } 600 rtnl_unlock(); 601 } 602 603 if (ret) { 604 sfp_bus_put(bus); 605 bus = NULL; 606 } 607 608 return bus; 609 } 610 EXPORT_SYMBOL_GPL(sfp_register_socket); 611 612 void sfp_unregister_socket(struct sfp_bus *bus) 613 { 614 rtnl_lock(); 615 if (bus->netdev) 616 sfp_unregister_bus(bus); 617 sfp_socket_clear(bus); 618 rtnl_unlock(); 619 620 sfp_bus_put(bus); 621 } 622 EXPORT_SYMBOL_GPL(sfp_unregister_socket); 623