drivers/net/phy/sfp-bus.c

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

DEFINITIONS
