drivers/net/phy/sfp-bus.c

   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         __ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, };
 184
 185         /* Decode the bitrate information to MBd */
 186         br_min = br_nom = br_max = 0;
 187         if (id->base.br_nominal) {
 188                 if (id->base.br_nominal != 255) {
 189                         br_nom = id->base.br_nominal * 100;
 190                         br_min = br_nom + id->base.br_nominal * id->ext.br_min;
 191                         br_max = br_nom + id->base.br_nominal * id->ext.br_max;
 192                 } else if (id->ext.br_max) {
 193                         br_nom = 250 * id->ext.br_max;
 194                         br_max = br_nom + br_nom * id->ext.br_min / 100;
 195                         br_min = br_nom - br_nom * id->ext.br_min / 100;
 196                 }
 197         }
 198
 199         /* Set ethtool support from the compliance fields. */
 200         if (id->base.e10g_base_sr)
 201                 phylink_set(modes, 10000baseSR_Full);
 202         if (id->base.e10g_base_lr)
 203                 phylink_set(modes, 10000baseLR_Full);
 204         if (id->base.e10g_base_lrm)
 205                 phylink_set(modes, 10000baseLRM_Full);
 206         if (id->base.e10g_base_er)
 207                 phylink_set(modes, 10000baseER_Full);
 208         if (id->base.e1000_base_sx ||
 209             id->base.e1000_base_lx ||
 210             id->base.e1000_base_cx)
 211                 phylink_set(modes, 1000baseX_Full);
 212         if (id->base.e1000_base_t) {
 213                 phylink_set(modes, 1000baseT_Half);
 214                 phylink_set(modes, 1000baseT_Full);
 215         }
 216
 217         /* 1000Base-PX or 1000Base-BX10 */
 218         if ((id->base.e_base_px || id->base.e_base_bx10) &&
 219             br_min <= 1300 && br_max >= 1200)
 220                 phylink_set(support, 1000baseX_Full);
 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                 if (br_min <= 3200 && br_max >= 3100)
 230                         phylink_set(modes, 2500baseX_Full);
 231                 if (br_min <= 1300 && br_max >= 1200)
 232                         phylink_set(modes, 1000baseX_Full);
 233         }
 234         if (id->base.sfp_ct_passive) {
 235                 if (id->base.passive.sff8431_app_e)
 236                         phylink_set(modes, 10000baseCR_Full);
 237         }
 238         if (id->base.sfp_ct_active) {
 239                 if (id->base.active.sff8431_app_e ||
 240                     id->base.active.sff8431_lim) {
 241                         phylink_set(modes, 10000baseCR_Full);
 242                 }
 243         }
 244
 245         switch (id->base.extended_cc) {
 246         case 0x00: /* Unspecified */
 247                 break;
 248         case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */
 249                 phylink_set(modes, 100000baseSR4_Full);
 250                 phylink_set(modes, 25000baseSR_Full);
 251                 break;
 252         case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */
 253         case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */
 254                 phylink_set(modes, 100000baseLR4_ER4_Full);
 255                 break;
 256         case 0x0b: /* 100Gbase-CR4 or 25Gbase-CR CA-L */
 257         case 0x0c: /* 25Gbase-CR CA-S */
 258         case 0x0d: /* 25Gbase-CR CA-N */
 259                 phylink_set(modes, 100000baseCR4_Full);
 260                 phylink_set(modes, 25000baseCR_Full);
 261                 break;
 262         default:
 263                 dev_warn(bus->sfp_dev,
 264                          "Unknown/unsupported extended compliance code: 0x%02x\n",
 265                          id->base.extended_cc);
 266                 break;
 267         }
 268
 269         /* For fibre channel SFP, derive possible BaseX modes */
 270         if (id->base.fc_speed_100 ||
 271             id->base.fc_speed_200 ||
 272             id->base.fc_speed_400) {
 273                 if (id->base.br_nominal >= 31)
 274                         phylink_set(modes, 2500baseX_Full);
 275                 if (id->base.br_nominal >= 12)
 276                         phylink_set(modes, 1000baseX_Full);
 277         }
 278
 279         /* If we haven't discovered any modes that this module supports, try
 280          * the encoding and bitrate to determine supported modes. Some BiDi
 281          * modules (eg, 1310nm/1550nm) are not 1000BASE-BX compliant due to
 282          * the differing wavelengths, so do not set any transceiver bits.
 283          */
 284         if (bitmap_empty(modes, __ETHTOOL_LINK_MODE_MASK_NBITS)) {
 285                 /* If the encoding and bit rate allows 1000baseX */
 286                 if (id->base.encoding == SFP_ENCODING_8B10B && br_nom &&
 287                     br_min <= 1300 && br_max >= 1200)
 288                         phylink_set(modes, 1000baseX_Full);
 289         }
 290
 291         bitmap_or(support, support, modes, __ETHTOOL_LINK_MODE_MASK_NBITS);
 292
 293         phylink_set(support, Autoneg);
 294         phylink_set(support, Pause);
 295         phylink_set(support, Asym_Pause);
 296 }
 297 EXPORT_SYMBOL_GPL(sfp_parse_support);
 298
 299 static LIST_HEAD(sfp_buses);
 300 static DEFINE_MUTEX(sfp_mutex);
 301
 302 static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus)
 303 {
 304         return bus->registered ? bus->upstream_ops : NULL;
 305 }
 306
 307 static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode)
 308 {
 309         struct sfp_bus *sfp, *new, *found = NULL;
 310
 311         new = kzalloc(sizeof(*new), GFP_KERNEL);
 312
 313         mutex_lock(&sfp_mutex);
 314
 315         list_for_each_entry(sfp, &sfp_buses, node) {
 316                 if (sfp->fwnode == fwnode) {
 317                         kref_get(&sfp->kref);
 318                         found = sfp;
 319                         break;
 320                 }
 321         }
 322
 323         if (!found && new) {
 324                 kref_init(&new->kref);
 325                 new->fwnode = fwnode;
 326                 list_add(&new->node, &sfp_buses);
 327                 found = new;
 328                 new = NULL;
 329         }
 330
 331         mutex_unlock(&sfp_mutex);
 332
 333         kfree(new);
 334
 335         return found;
 336 }
 337
 338 static void sfp_bus_release(struct kref *kref)
 339 {
 340         struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref);
 341
 342         list_del(&bus->node);
 343         mutex_unlock(&sfp_mutex);
 344         kfree(bus);
 345 }
 346
 347 static void sfp_bus_put(struct sfp_bus *bus)
 348 {
 349         kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex);
 350 }
 351
 352 static int sfp_register_bus(struct sfp_bus *bus)
 353 {
 354         const struct sfp_upstream_ops *ops = bus->upstream_ops;
 355         int ret;
 356
 357         if (ops) {
 358                 if (ops->link_down)
 359                         ops->link_down(bus->upstream);
 360                 if (ops->connect_phy && bus->phydev) {
 361                         ret = ops->connect_phy(bus->upstream, bus->phydev);
 362                         if (ret)
 363                                 return ret;
 364                 }
 365         }
 366         if (bus->started)
 367                 bus->socket_ops->start(bus->sfp);
 368         bus->registered = true;
 369         return 0;
 370 }
 371
 372 static void sfp_unregister_bus(struct sfp_bus *bus)
 373 {
 374         const struct sfp_upstream_ops *ops = bus->upstream_ops;
 375
 376         if (bus->registered) {
 377                 if (bus->started)
 378                         bus->socket_ops->stop(bus->sfp);
 379                 if (bus->phydev && ops && ops->disconnect_phy)
 380                         ops->disconnect_phy(bus->upstream);
 381         }
 382         bus->registered = false;
 383 }
 384
 385 /**
 386  * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module
 387  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 388  * @modinfo: a &struct ethtool_modinfo
 389  *
 390  * Fill in the type and eeprom_len parameters in @modinfo for a module on
 391  * the sfp bus specified by @bus.
 392  *
 393  * Returns 0 on success or a negative errno number.
 394  */
 395 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)
 396 {
 397         if (!bus->registered)
 398                 return -ENOIOCTLCMD;
 399         return bus->socket_ops->module_info(bus->sfp, modinfo);
 400 }
 401 EXPORT_SYMBOL_GPL(sfp_get_module_info);
 402
 403 /**
 404  * sfp_get_module_eeprom() - Read the SFP module EEPROM
 405  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 406  * @ee: a &struct ethtool_eeprom
 407  * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes)
 408  *
 409  * Read the EEPROM as specified by the supplied @ee. See the documentation
 410  * for &struct ethtool_eeprom for the region to be read.
 411  *
 412  * Returns 0 on success or a negative errno number.
 413  */
 414 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
 415                           u8 *data)
 416 {
 417         if (!bus->registered)
 418                 return -ENOIOCTLCMD;
 419         return bus->socket_ops->module_eeprom(bus->sfp, ee, data);
 420 }
 421 EXPORT_SYMBOL_GPL(sfp_get_module_eeprom);
 422
 423 /**
 424  * sfp_upstream_start() - Inform the SFP that the network device is up
 425  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 426  *
 427  * Inform the SFP socket that the network device is now up, so that the
 428  * module can be enabled by allowing TX_DISABLE to be deasserted. This
 429  * should be called from the network device driver's &struct net_device_ops
 430  * ndo_open() method.
 431  */
 432 void sfp_upstream_start(struct sfp_bus *bus)
 433 {
 434         if (bus->registered)
 435                 bus->socket_ops->start(bus->sfp);
 436         bus->started = true;
 437 }
 438 EXPORT_SYMBOL_GPL(sfp_upstream_start);
 439
 440 /**
 441  * sfp_upstream_stop() - Inform the SFP that the network device is down
 442  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 443  *
 444  * Inform the SFP socket that the network device is now up, so that the
 445  * module can be disabled by asserting TX_DISABLE, disabling the laser
 446  * in optical modules. This should be called from the network device
 447  * driver's &struct net_device_ops ndo_stop() method.
 448  */
 449 void sfp_upstream_stop(struct sfp_bus *bus)
 450 {
 451         if (bus->registered)
 452                 bus->socket_ops->stop(bus->sfp);
 453         bus->started = false;
 454 }
 455 EXPORT_SYMBOL_GPL(sfp_upstream_stop);
 456
 457 /**
 458  * sfp_register_upstream() - Register the neighbouring device
 459  * @fwnode: firmware node for the SFP bus
 460  * @ndev: network device associated with the interface
 461  * @upstream: the upstream private data
 462  * @ops: the upstream's &struct sfp_upstream_ops
 463  *
 464  * Register the upstream device (eg, PHY) with the SFP bus. MAC drivers
 465  * should use phylink, which will call this function for them. Returns
 466  * a pointer to the allocated &struct sfp_bus.
 467  *
 468  * On error, returns %NULL.
 469  */
 470 struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode,
 471                                       struct net_device *ndev, void *upstream,
 472                                       const struct sfp_upstream_ops *ops)
 473 {
 474         struct sfp_bus *bus = sfp_bus_get(fwnode);
 475         int ret = 0;
 476
 477         if (bus) {
 478                 rtnl_lock();
 479                 bus->upstream_ops = ops;
 480                 bus->upstream = upstream;
 481                 bus->netdev = ndev;
 482
 483                 if (bus->sfp)
 484                         ret = sfp_register_bus(bus);
 485                 rtnl_unlock();
 486         }
 487
 488         if (ret) {
 489                 sfp_bus_put(bus);
 490                 bus = NULL;
 491         }
 492
 493         return bus;
 494 }
 495 EXPORT_SYMBOL_GPL(sfp_register_upstream);
 496
 497 /**
 498  * sfp_unregister_upstream() - Unregister sfp bus
 499  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 500  *
 501  * Unregister a previously registered upstream connection for the SFP
 502  * module. @bus is returned from sfp_register_upstream().
 503  */
 504 void sfp_unregister_upstream(struct sfp_bus *bus)
 505 {
 506         rtnl_lock();
 507         if (bus->sfp)
 508                 sfp_unregister_bus(bus);
 509         bus->upstream = NULL;
 510         bus->netdev = NULL;
 511         rtnl_unlock();
 512
 513         sfp_bus_put(bus);
 514 }
 515 EXPORT_SYMBOL_GPL(sfp_unregister_upstream);
 516
 517 /* Socket driver entry points */
 518 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev)
 519 {
 520         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 521         int ret = 0;
 522
 523         if (ops && ops->connect_phy)
 524                 ret = ops->connect_phy(bus->upstream, phydev);
 525
 526         if (ret == 0)
 527                 bus->phydev = phydev;
 528
 529         return ret;
 530 }
 531 EXPORT_SYMBOL_GPL(sfp_add_phy);
 532
 533 void sfp_remove_phy(struct sfp_bus *bus)
 534 {
 535         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 536
 537         if (ops && ops->disconnect_phy)
 538                 ops->disconnect_phy(bus->upstream);
 539         bus->phydev = NULL;
 540 }
 541 EXPORT_SYMBOL_GPL(sfp_remove_phy);
 542
 543 void sfp_link_up(struct sfp_bus *bus)
 544 {
 545         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 546
 547         if (ops && ops->link_up)
 548                 ops->link_up(bus->upstream);
 549 }
 550 EXPORT_SYMBOL_GPL(sfp_link_up);
 551
 552 void sfp_link_down(struct sfp_bus *bus)
 553 {
 554         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 555
 556         if (ops && ops->link_down)
 557                 ops->link_down(bus->upstream);
 558 }
 559 EXPORT_SYMBOL_GPL(sfp_link_down);
 560
 561 int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id)
 562 {
 563         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 564         int ret = 0;
 565
 566         if (ops && ops->module_insert)
 567                 ret = ops->module_insert(bus->upstream, id);
 568
 569         return ret;
 570 }
 571 EXPORT_SYMBOL_GPL(sfp_module_insert);
 572
 573 void sfp_module_remove(struct sfp_bus *bus)
 574 {
 575         const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 576
 577         if (ops && ops->module_remove)
 578                 ops->module_remove(bus->upstream);
 579 }
 580 EXPORT_SYMBOL_GPL(sfp_module_remove);
 581
 582 struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp,
 583                                     const struct sfp_socket_ops *ops)
 584 {
 585         struct sfp_bus *bus = sfp_bus_get(dev->fwnode);
 586         int ret = 0;
 587
 588         if (bus) {
 589                 rtnl_lock();
 590                 bus->sfp_dev = dev;
 591                 bus->sfp = sfp;
 592                 bus->socket_ops = ops;
 593
 594                 if (bus->netdev)
 595                         ret = sfp_register_bus(bus);
 596                 rtnl_unlock();
 597         }
 598
 599         if (ret) {
 600                 sfp_bus_put(bus);
 601                 bus = NULL;
 602         }
 603
 604         return bus;
 605 }
 606 EXPORT_SYMBOL_GPL(sfp_register_socket);
 607
 608 void sfp_unregister_socket(struct sfp_bus *bus)
 609 {
 610         rtnl_lock();
 611         if (bus->netdev)
 612                 sfp_unregister_bus(bus);
 613         bus->sfp_dev = NULL;
 614         bus->sfp = NULL;
 615         bus->socket_ops = NULL;
 616         rtnl_unlock();
 617
 618         sfp_bus_put(bus);
 619 }
 620 EXPORT_SYMBOL_GPL(sfp_unregister_socket);