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_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);