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_interface() - Parse the phy_interface_t 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 * 113 * Derive the phy_interface_t mode for the information found in the 114 * module's identifying EEPROM. There is no standard or defined way 115 * to derive this information, so we use some heuristics. 116 * 117 * If the encoding is 64b66b, then the module must be >= 10G, so 118 * return %PHY_INTERFACE_MODE_10GKR. 119 * 120 * If it's 8b10b, then it's 1G or slower. If it's definitely a fibre 121 * module, return %PHY_INTERFACE_MODE_1000BASEX mode, otherwise return 122 * %PHY_INTERFACE_MODE_SGMII mode. 123 * 124 * If the encoding is not known, return %PHY_INTERFACE_MODE_NA. 125 */ 126 phy_interface_t sfp_parse_interface(struct sfp_bus *bus, 127 const struct sfp_eeprom_id *id) 128 { 129 phy_interface_t iface; 130 131 /* Setting the serdes link mode is guesswork: there's no field in 132 * the EEPROM which indicates what mode should be used. 133 * 134 * If the module wants 64b66b, then it must be >= 10G. 135 * 136 * If it's a gigabit-only fiber module, it probably does not have 137 * a PHY, so switch to 802.3z negotiation mode. Otherwise, switch 138 * to SGMII mode (which is required to support non-gigabit speeds). 139 */ 140 switch (id->base.encoding) { 141 case SFP_ENCODING_8472_64B66B: 142 iface = PHY_INTERFACE_MODE_10GKR; 143 break; 144 145 case SFP_ENCODING_8B10B: 146 if (!id->base.e1000_base_t && 147 !id->base.e100_base_lx && 148 !id->base.e100_base_fx) 149 iface = PHY_INTERFACE_MODE_1000BASEX; 150 else 151 iface = PHY_INTERFACE_MODE_SGMII; 152 break; 153 154 default: 155 if (id->base.e1000_base_cx) { 156 iface = PHY_INTERFACE_MODE_1000BASEX; 157 break; 158 } 159 160 iface = PHY_INTERFACE_MODE_NA; 161 dev_err(bus->sfp_dev, 162 "SFP module encoding does not support 8b10b nor 64b66b\n"); 163 break; 164 } 165 166 return iface; 167 } 168 EXPORT_SYMBOL_GPL(sfp_parse_interface); 169 170 /** 171 * sfp_parse_support() - Parse the eeprom id for supported link modes 172 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 173 * @id: a pointer to the module's &struct sfp_eeprom_id 174 * @support: pointer to an array of unsigned long for the ethtool support mask 175 * 176 * Parse the EEPROM identification information and derive the supported 177 * ethtool link modes for the module. 178 */ 179 void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id, 180 unsigned long *support) 181 { 182 unsigned int br_min, br_nom, br_max; 183 184 phylink_set(support, Autoneg); 185 phylink_set(support, Pause); 186 phylink_set(support, Asym_Pause); 187 188 /* Decode the bitrate information to MBd */ 189 br_min = br_nom = br_max = 0; 190 if (id->base.br_nominal) { 191 if (id->base.br_nominal != 255) { 192 br_nom = id->base.br_nominal * 100; 193 br_min = br_nom + id->base.br_nominal * id->ext.br_min; 194 br_max = br_nom + id->base.br_nominal * id->ext.br_max; 195 } else if (id->ext.br_max) { 196 br_nom = 250 * id->ext.br_max; 197 br_max = br_nom + br_nom * id->ext.br_min / 100; 198 br_min = br_nom - br_nom * id->ext.br_min / 100; 199 } 200 } 201 202 /* Set ethtool support from the compliance fields. */ 203 if (id->base.e10g_base_sr) 204 phylink_set(support, 10000baseSR_Full); 205 if (id->base.e10g_base_lr) 206 phylink_set(support, 10000baseLR_Full); 207 if (id->base.e10g_base_lrm) 208 phylink_set(support, 10000baseLRM_Full); 209 if (id->base.e10g_base_er) 210 phylink_set(support, 10000baseER_Full); 211 if (id->base.e1000_base_sx || 212 id->base.e1000_base_lx || 213 id->base.e1000_base_cx) 214 phylink_set(support, 1000baseX_Full); 215 if (id->base.e1000_base_t) { 216 phylink_set(support, 1000baseT_Half); 217 phylink_set(support, 1000baseT_Full); 218 } 219 220 /* 1000Base-PX or 1000Base-BX10 */ 221 if ((id->base.e_base_px || id->base.e_base_bx10) && 222 br_min <= 1300 && br_max >= 1200) 223 phylink_set(support, 1000baseX_Full); 224 225 /* For active or passive cables, select the link modes 226 * based on the bit rates and the cable compliance bytes. 227 */ 228 if ((id->base.sfp_ct_passive || id->base.sfp_ct_active) && br_nom) { 229 /* This may look odd, but some manufacturers use 12000MBd */ 230 if (br_min <= 12000 && br_max >= 10300) 231 phylink_set(support, 10000baseCR_Full); 232 if (br_min <= 3200 && br_max >= 3100) 233 phylink_set(support, 2500baseX_Full); 234 if (br_min <= 1300 && br_max >= 1200) 235 phylink_set(support, 1000baseX_Full); 236 } 237 if (id->base.sfp_ct_passive) { 238 if (id->base.passive.sff8431_app_e) 239 phylink_set(support, 10000baseCR_Full); 240 } 241 if (id->base.sfp_ct_active) { 242 if (id->base.active.sff8431_app_e || 243 id->base.active.sff8431_lim) { 244 phylink_set(support, 10000baseCR_Full); 245 } 246 } 247 248 switch (id->base.extended_cc) { 249 case 0x00: /* Unspecified */ 250 break; 251 case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */ 252 phylink_set(support, 100000baseSR4_Full); 253 phylink_set(support, 25000baseSR_Full); 254 break; 255 case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */ 256 case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */ 257 phylink_set(support, 100000baseLR4_ER4_Full); 258 break; 259 case 0x0b: /* 100Gbase-CR4 or 25Gbase-CR CA-L */ 260 case 0x0c: /* 25Gbase-CR CA-S */ 261 case 0x0d: /* 25Gbase-CR CA-N */ 262 phylink_set(support, 100000baseCR4_Full); 263 phylink_set(support, 25000baseCR_Full); 264 break; 265 default: 266 dev_warn(bus->sfp_dev, 267 "Unknown/unsupported extended compliance code: 0x%02x\n", 268 id->base.extended_cc); 269 break; 270 } 271 272 /* For fibre channel SFP, derive possible BaseX modes */ 273 if (id->base.fc_speed_100 || 274 id->base.fc_speed_200 || 275 id->base.fc_speed_400) { 276 if (id->base.br_nominal >= 31) 277 phylink_set(support, 2500baseX_Full); 278 if (id->base.br_nominal >= 12) 279 phylink_set(support, 1000baseX_Full); 280 } 281 } 282 EXPORT_SYMBOL_GPL(sfp_parse_support); 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 if (bus->started) 352 bus->socket_ops->start(bus->sfp); 353 bus->registered = true; 354 return 0; 355 } 356 357 static void sfp_unregister_bus(struct sfp_bus *bus) 358 { 359 const struct sfp_upstream_ops *ops = bus->upstream_ops; 360 361 if (bus->registered) { 362 if (bus->started) 363 bus->socket_ops->stop(bus->sfp); 364 if (bus->phydev && ops && ops->disconnect_phy) 365 ops->disconnect_phy(bus->upstream); 366 } 367 bus->registered = false; 368 } 369 370 /** 371 * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module 372 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 373 * @modinfo: a &struct ethtool_modinfo 374 * 375 * Fill in the type and eeprom_len parameters in @modinfo for a module on 376 * the sfp bus specified by @bus. 377 * 378 * Returns 0 on success or a negative errno number. 379 */ 380 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo) 381 { 382 if (!bus->registered) 383 return -ENOIOCTLCMD; 384 return bus->socket_ops->module_info(bus->sfp, modinfo); 385 } 386 EXPORT_SYMBOL_GPL(sfp_get_module_info); 387 388 /** 389 * sfp_get_module_eeprom() - Read the SFP module EEPROM 390 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 391 * @ee: a &struct ethtool_eeprom 392 * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes) 393 * 394 * Read the EEPROM as specified by the supplied @ee. See the documentation 395 * for &struct ethtool_eeprom for the region to be read. 396 * 397 * Returns 0 on success or a negative errno number. 398 */ 399 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee, 400 u8 *data) 401 { 402 if (!bus->registered) 403 return -ENOIOCTLCMD; 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 /** 443 * sfp_register_upstream() - Register the neighbouring device 444 * @fwnode: firmware node for the SFP bus 445 * @ndev: network device associated with the interface 446 * @upstream: the upstream private data 447 * @ops: the upstream's &struct sfp_upstream_ops 448 * 449 * Register the upstream device (eg, PHY) with the SFP bus. MAC drivers 450 * should use phylink, which will call this function for them. Returns 451 * a pointer to the allocated &struct sfp_bus. 452 * 453 * On error, returns %NULL. 454 */ 455 struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode, 456 struct net_device *ndev, void *upstream, 457 const struct sfp_upstream_ops *ops) 458 { 459 struct sfp_bus *bus = sfp_bus_get(fwnode); 460 int ret = 0; 461 462 if (bus) { 463 rtnl_lock(); 464 bus->upstream_ops = ops; 465 bus->upstream = upstream; 466 bus->netdev = ndev; 467 468 if (bus->sfp) 469 ret = sfp_register_bus(bus); 470 rtnl_unlock(); 471 } 472 473 if (ret) { 474 sfp_bus_put(bus); 475 bus = NULL; 476 } 477 478 return bus; 479 } 480 EXPORT_SYMBOL_GPL(sfp_register_upstream); 481 482 /** 483 * sfp_unregister_upstream() - Unregister sfp bus 484 * @bus: a pointer to the &struct sfp_bus structure for the sfp module 485 * 486 * Unregister a previously registered upstream connection for the SFP 487 * module. @bus is returned from sfp_register_upstream(). 488 */ 489 void sfp_unregister_upstream(struct sfp_bus *bus) 490 { 491 rtnl_lock(); 492 if (bus->sfp) 493 sfp_unregister_bus(bus); 494 bus->upstream = NULL; 495 bus->netdev = NULL; 496 rtnl_unlock(); 497 498 sfp_bus_put(bus); 499 } 500 EXPORT_SYMBOL_GPL(sfp_unregister_upstream); 501 502 /* Socket driver entry points */ 503 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev) 504 { 505 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 506 int ret = 0; 507 508 if (ops && ops->connect_phy) 509 ret = ops->connect_phy(bus->upstream, phydev); 510 511 if (ret == 0) 512 bus->phydev = phydev; 513 514 return ret; 515 } 516 EXPORT_SYMBOL_GPL(sfp_add_phy); 517 518 void sfp_remove_phy(struct sfp_bus *bus) 519 { 520 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 521 522 if (ops && ops->disconnect_phy) 523 ops->disconnect_phy(bus->upstream); 524 bus->phydev = NULL; 525 } 526 EXPORT_SYMBOL_GPL(sfp_remove_phy); 527 528 void sfp_link_up(struct sfp_bus *bus) 529 { 530 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 531 532 if (ops && ops->link_up) 533 ops->link_up(bus->upstream); 534 } 535 EXPORT_SYMBOL_GPL(sfp_link_up); 536 537 void sfp_link_down(struct sfp_bus *bus) 538 { 539 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 540 541 if (ops && ops->link_down) 542 ops->link_down(bus->upstream); 543 } 544 EXPORT_SYMBOL_GPL(sfp_link_down); 545 546 int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id) 547 { 548 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 549 int ret = 0; 550 551 if (ops && ops->module_insert) 552 ret = ops->module_insert(bus->upstream, id); 553 554 return ret; 555 } 556 EXPORT_SYMBOL_GPL(sfp_module_insert); 557 558 void sfp_module_remove(struct sfp_bus *bus) 559 { 560 const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus); 561 562 if (ops && ops->module_remove) 563 ops->module_remove(bus->upstream); 564 } 565 EXPORT_SYMBOL_GPL(sfp_module_remove); 566 567 struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp, 568 const struct sfp_socket_ops *ops) 569 { 570 struct sfp_bus *bus = sfp_bus_get(dev->fwnode); 571 int ret = 0; 572 573 if (bus) { 574 rtnl_lock(); 575 bus->sfp_dev = dev; 576 bus->sfp = sfp; 577 bus->socket_ops = ops; 578 579 if (bus->netdev) 580 ret = sfp_register_bus(bus); 581 rtnl_unlock(); 582 } 583 584 if (ret) { 585 sfp_bus_put(bus); 586 bus = NULL; 587 } 588 589 return bus; 590 } 591 EXPORT_SYMBOL_GPL(sfp_register_socket); 592 593 void sfp_unregister_socket(struct sfp_bus *bus) 594 { 595 rtnl_lock(); 596 if (bus->netdev) 597 sfp_unregister_bus(bus); 598 bus->sfp_dev = NULL; 599 bus->sfp = NULL; 600 bus->socket_ops = NULL; 601 rtnl_unlock(); 602 603 sfp_bus_put(bus); 604 } 605 EXPORT_SYMBOL_GPL(sfp_unregister_socket); 606