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