[linux-2.6-block.git] / drivers / net / phy / sfp-bus.c

#include <linux/export.h>
#include <linux/kref.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/phylink.h>
#include <linux/rtnetlink.h>
#include <linux/slab.h>

#include "sfp.h"

/**
 * struct sfp_bus - internal representation of a sfp bus
 */
struct sfp_bus {
	/* private: */
	struct kref kref;
	struct list_head node;
	struct fwnode_handle *fwnode;

	const struct sfp_socket_ops *socket_ops;
	struct device *sfp_dev;
	struct sfp *sfp;

	const struct sfp_upstream_ops *upstream_ops;
	void *upstream;
	struct net_device *netdev;
	struct phy_device *phydev;

	bool registered;
	bool started;
};

/**
 * sfp_parse_port() - Parse the EEPROM base ID, setting the port type
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 * @id: a pointer to the module's &struct sfp_eeprom_id
 * @support: optional pointer to an array of unsigned long for the
 *   ethtool support mask
 *
 * Parse the EEPROM identification given in @id, and return one of
 * %PORT_TP, %PORT_FIBRE or %PORT_OTHER. If @support is non-%NULL,
 * also set the ethtool %ETHTOOL_LINK_MODE_xxx_BIT corresponding with
 * the connector type.
 *
 * If the port type is not known, returns %PORT_OTHER.
 */
int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
		   unsigned long *support)
{
	int port;

	/* port is the physical connector, set this from the connector field. */
	switch (id->base.connector) {
	case SFP_CONNECTOR_SC:
	case SFP_CONNECTOR_FIBERJACK:
	case SFP_CONNECTOR_LC:
	case SFP_CONNECTOR_MT_RJ:
	case SFP_CONNECTOR_MU:
	case SFP_CONNECTOR_OPTICAL_PIGTAIL:
		port = PORT_FIBRE;
		break;

	case SFP_CONNECTOR_RJ45:
		port = PORT_TP;
		break;

	case SFP_CONNECTOR_COPPER_PIGTAIL:
		port = PORT_DA;
		break;

	case SFP_CONNECTOR_UNSPEC:
		if (id->base.e1000_base_t) {
			port = PORT_TP;
			break;
		}
		/* fallthrough */
	case SFP_CONNECTOR_SG: /* guess */
	case SFP_CONNECTOR_MPO_1X12:
	case SFP_CONNECTOR_MPO_2X16:
	case SFP_CONNECTOR_HSSDC_II:
	case SFP_CONNECTOR_NOSEPARATE:
	case SFP_CONNECTOR_MXC_2X16:
		port = PORT_OTHER;
		break;
	default:
		dev_warn(bus->sfp_dev, "SFP: unknown connector id 0x%02x\n",
			 id->base.connector);
		port = PORT_OTHER;
		break;
	}

	if (support) {
		switch (port) {
		case PORT_FIBRE:
			phylink_set(support, FIBRE);
			break;

		case PORT_TP:
			phylink_set(support, TP);
			break;
		}
	}

	return port;
}
EXPORT_SYMBOL_GPL(sfp_parse_port);

/**
 * sfp_parse_support() - Parse the eeprom id for supported link modes
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 * @id: a pointer to the module's &struct sfp_eeprom_id
 * @support: pointer to an array of unsigned long for the ethtool support mask
 *
 * Parse the EEPROM identification information and derive the supported
 * ethtool link modes for the module.
 */
void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
		       unsigned long *support)
{
	unsigned int br_min, br_nom, br_max;
	__ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, };

	/* Decode the bitrate information to MBd */
	br_min = br_nom = br_max = 0;
	if (id->base.br_nominal) {
		if (id->base.br_nominal != 255) {
			br_nom = id->base.br_nominal * 100;
			br_min = br_nom - id->base.br_nominal * id->ext.br_min;
			br_max = br_nom + id->base.br_nominal * id->ext.br_max;
		} else if (id->ext.br_max) {
			br_nom = 250 * id->ext.br_max;
			br_max = br_nom + br_nom * id->ext.br_min / 100;
			br_min = br_nom - br_nom * id->ext.br_min / 100;
		}

		/* When using passive cables, in case neither BR,min nor BR,max
		 * are specified, set br_min to 0 as the nominal value is then
		 * used as the maximum.
		 */
		if (br_min == br_max && id->base.sfp_ct_passive)
			br_min = 0;
	}

	/* Set ethtool support from the compliance fields. */
	if (id->base.e10g_base_sr)
		phylink_set(modes, 10000baseSR_Full);
	if (id->base.e10g_base_lr)
		phylink_set(modes, 10000baseLR_Full);
	if (id->base.e10g_base_lrm)
		phylink_set(modes, 10000baseLRM_Full);
	if (id->base.e10g_base_er)
		phylink_set(modes, 10000baseER_Full);
	if (id->base.e1000_base_sx ||
	    id->base.e1000_base_lx ||
	    id->base.e1000_base_cx)
		phylink_set(modes, 1000baseX_Full);
	if (id->base.e1000_base_t) {
		phylink_set(modes, 1000baseT_Half);
		phylink_set(modes, 1000baseT_Full);
	}

	/* 1000Base-PX or 1000Base-BX10 */
	if ((id->base.e_base_px || id->base.e_base_bx10) &&
	    br_min <= 1300 && br_max >= 1200)
		phylink_set(modes, 1000baseX_Full);

	/* For active or passive cables, select the link modes
	 * based on the bit rates and the cable compliance bytes.
	 */
	if ((id->base.sfp_ct_passive || id->base.sfp_ct_active) && br_nom) {
		/* This may look odd, but some manufacturers use 12000MBd */
		if (br_min <= 12000 && br_max >= 10300)
			phylink_set(modes, 10000baseCR_Full);
		if (br_min <= 3200 && br_max >= 3100)
			phylink_set(modes, 2500baseX_Full);
		if (br_min <= 1300 && br_max >= 1200)
			phylink_set(modes, 1000baseX_Full);
	}
	if (id->base.sfp_ct_passive) {
		if (id->base.passive.sff8431_app_e)
			phylink_set(modes, 10000baseCR_Full);
	}
	if (id->base.sfp_ct_active) {
		if (id->base.active.sff8431_app_e ||
		    id->base.active.sff8431_lim) {
			phylink_set(modes, 10000baseCR_Full);
		}
	}

	switch (id->base.extended_cc) {
	case 0x00: /* Unspecified */
		break;
	case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */
		phylink_set(modes, 100000baseSR4_Full);
		phylink_set(modes, 25000baseSR_Full);
		break;
	case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */
	case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */
		phylink_set(modes, 100000baseLR4_ER4_Full);
		break;
	case 0x0b: /* 100Gbase-CR4 or 25Gbase-CR CA-L */
	case 0x0c: /* 25Gbase-CR CA-S */
	case 0x0d: /* 25Gbase-CR CA-N */
		phylink_set(modes, 100000baseCR4_Full);
		phylink_set(modes, 25000baseCR_Full);
		break;
	default:
		dev_warn(bus->sfp_dev,
			 "Unknown/unsupported extended compliance code: 0x%02x\n",
			 id->base.extended_cc);
		break;
	}

	/* For fibre channel SFP, derive possible BaseX modes */
	if (id->base.fc_speed_100 ||
	    id->base.fc_speed_200 ||
	    id->base.fc_speed_400) {
		if (id->base.br_nominal >= 31)
			phylink_set(modes, 2500baseX_Full);
		if (id->base.br_nominal >= 12)
			phylink_set(modes, 1000baseX_Full);
	}

	/* If we haven't discovered any modes that this module supports, try
	 * the encoding and bitrate to determine supported modes. Some BiDi
	 * modules (eg, 1310nm/1550nm) are not 1000BASE-BX compliant due to
	 * the differing wavelengths, so do not set any transceiver bits.
	 */
	if (bitmap_empty(modes, __ETHTOOL_LINK_MODE_MASK_NBITS)) {
		/* If the encoding and bit rate allows 1000baseX */
		if (id->base.encoding == SFP_ENCODING_8B10B && br_nom &&
		    br_min <= 1300 && br_max >= 1200)
			phylink_set(modes, 1000baseX_Full);
	}

	bitmap_or(support, support, modes, __ETHTOOL_LINK_MODE_MASK_NBITS);

	phylink_set(support, Autoneg);
	phylink_set(support, Pause);
	phylink_set(support, Asym_Pause);
}
EXPORT_SYMBOL_GPL(sfp_parse_support);

/**
 * sfp_select_interface() - Select appropriate phy_interface_t mode
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 * @id: a pointer to the module's &struct sfp_eeprom_id
 * @link_modes: ethtool link modes mask
 *
 * Derive the phy_interface_t mode for the information found in the
 * module's identifying EEPROM and the link modes mask. There is no
 * standard or defined way to derive this information, so we decide
 * based upon the link mode mask.
 */
phy_interface_t sfp_select_interface(struct sfp_bus *bus,
				     const struct sfp_eeprom_id *id,
				     unsigned long *link_modes)
{
	if (phylink_test(link_modes, 10000baseCR_Full) ||
	    phylink_test(link_modes, 10000baseSR_Full) ||
	    phylink_test(link_modes, 10000baseLR_Full) ||
	    phylink_test(link_modes, 10000baseLRM_Full) ||
	    phylink_test(link_modes, 10000baseER_Full))
		return PHY_INTERFACE_MODE_10GKR;

	if (phylink_test(link_modes, 2500baseX_Full))
		return PHY_INTERFACE_MODE_2500BASEX;

	if (id->base.e1000_base_t ||
	    id->base.e100_base_lx ||
	    id->base.e100_base_fx)
		return PHY_INTERFACE_MODE_SGMII;

	if (phylink_test(link_modes, 1000baseX_Full))
		return PHY_INTERFACE_MODE_1000BASEX;

	dev_warn(bus->sfp_dev, "Unable to ascertain link mode\n");

	return PHY_INTERFACE_MODE_NA;
}
EXPORT_SYMBOL_GPL(sfp_select_interface);

static LIST_HEAD(sfp_buses);
static DEFINE_MUTEX(sfp_mutex);

static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus)
{
	return bus->registered ? bus->upstream_ops : NULL;
}

static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode)
{
	struct sfp_bus *sfp, *new, *found = NULL;

	new = kzalloc(sizeof(*new), GFP_KERNEL);

	mutex_lock(&sfp_mutex);

	list_for_each_entry(sfp, &sfp_buses, node) {
		if (sfp->fwnode == fwnode) {
			kref_get(&sfp->kref);
			found = sfp;
			break;
		}
	}

	if (!found && new) {
		kref_init(&new->kref);
		new->fwnode = fwnode;
		list_add(&new->node, &sfp_buses);
		found = new;
		new = NULL;
	}

	mutex_unlock(&sfp_mutex);

	kfree(new);

	return found;
}

static void sfp_bus_release(struct kref *kref)
{
	struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref);

	list_del(&bus->node);
	mutex_unlock(&sfp_mutex);
	kfree(bus);
}

static void sfp_bus_put(struct sfp_bus *bus)
{
	kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex);
}

static int sfp_register_bus(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = bus->upstream_ops;
	int ret;

	if (ops) {
		if (ops->link_down)
			ops->link_down(bus->upstream);
		if (ops->connect_phy && bus->phydev) {
			ret = ops->connect_phy(bus->upstream, bus->phydev);
			if (ret)
				return ret;
		}
	}
	if (bus->started)
		bus->socket_ops->start(bus->sfp);
	bus->netdev->sfp_bus = bus;
	bus->registered = true;
	return 0;
}

static void sfp_unregister_bus(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = bus->upstream_ops;

	bus->netdev->sfp_bus = NULL;
	if (bus->registered) {
		if (bus->started)
			bus->socket_ops->stop(bus->sfp);
		if (bus->phydev && ops && ops->disconnect_phy)
			ops->disconnect_phy(bus->upstream);
	}
	bus->registered = false;
}

/**
 * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 * @modinfo: a &struct ethtool_modinfo
 *
 * Fill in the type and eeprom_len parameters in @modinfo for a module on
 * the sfp bus specified by @bus.
 *
 * Returns 0 on success or a negative errno number.
 */
int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)
{
	return bus->socket_ops->module_info(bus->sfp, modinfo);
}
EXPORT_SYMBOL_GPL(sfp_get_module_info);

/**
 * sfp_get_module_eeprom() - Read the SFP module EEPROM
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 * @ee: a &struct ethtool_eeprom
 * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes)
 *
 * Read the EEPROM as specified by the supplied @ee. See the documentation
 * for &struct ethtool_eeprom for the region to be read.
 *
 * Returns 0 on success or a negative errno number.
 */
int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
			  u8 *data)
{
	return bus->socket_ops->module_eeprom(bus->sfp, ee, data);
}
EXPORT_SYMBOL_GPL(sfp_get_module_eeprom);

/**
 * sfp_upstream_start() - Inform the SFP that the network device is up
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 *
 * Inform the SFP socket that the network device is now up, so that the
 * module can be enabled by allowing TX_DISABLE to be deasserted. This
 * should be called from the network device driver's &struct net_device_ops
 * ndo_open() method.
 */
void sfp_upstream_start(struct sfp_bus *bus)
{
	if (bus->registered)
		bus->socket_ops->start(bus->sfp);
	bus->started = true;
}
EXPORT_SYMBOL_GPL(sfp_upstream_start);

/**
 * sfp_upstream_stop() - Inform the SFP that the network device is down
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 *
 * Inform the SFP socket that the network device is now up, so that the
 * module can be disabled by asserting TX_DISABLE, disabling the laser
 * in optical modules. This should be called from the network device
 * driver's &struct net_device_ops ndo_stop() method.
 */
void sfp_upstream_stop(struct sfp_bus *bus)
{
	if (bus->registered)
		bus->socket_ops->stop(bus->sfp);
	bus->started = false;
}
EXPORT_SYMBOL_GPL(sfp_upstream_stop);

static void sfp_upstream_clear(struct sfp_bus *bus)
{
	bus->upstream_ops = NULL;
	bus->upstream = NULL;
	bus->netdev = NULL;
}

/**
 * sfp_register_upstream() - Register the neighbouring device
 * @fwnode: firmware node for the SFP bus
 * @ndev: network device associated with the interface
 * @upstream: the upstream private data
 * @ops: the upstream's &struct sfp_upstream_ops
 *
 * Register the upstream device (eg, PHY) with the SFP bus. MAC drivers
 * should use phylink, which will call this function for them. Returns
 * a pointer to the allocated &struct sfp_bus.
 *
 * On error, returns %NULL.
 */
struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode,
				      struct net_device *ndev, void *upstream,
				      const struct sfp_upstream_ops *ops)
{
	struct sfp_bus *bus = sfp_bus_get(fwnode);
	int ret = 0;

	if (bus) {
		rtnl_lock();
		bus->upstream_ops = ops;
		bus->upstream = upstream;
		bus->netdev = ndev;

		if (bus->sfp) {
			ret = sfp_register_bus(bus);
			if (ret)
				sfp_upstream_clear(bus);
		}
		rtnl_unlock();
	}

	if (ret) {
		sfp_bus_put(bus);
		bus = NULL;
	}

	return bus;
}
EXPORT_SYMBOL_GPL(sfp_register_upstream);

/**
 * sfp_unregister_upstream() - Unregister sfp bus
 * @bus: a pointer to the &struct sfp_bus structure for the sfp module
 *
 * Unregister a previously registered upstream connection for the SFP
 * module. @bus is returned from sfp_register_upstream().
 */
void sfp_unregister_upstream(struct sfp_bus *bus)
{
	rtnl_lock();
	if (bus->sfp)
		sfp_unregister_bus(bus);
	sfp_upstream_clear(bus);
	rtnl_unlock();

	sfp_bus_put(bus);
}
EXPORT_SYMBOL_GPL(sfp_unregister_upstream);

/* Socket driver entry points */
int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	int ret = 0;

	if (ops && ops->connect_phy)
		ret = ops->connect_phy(bus->upstream, phydev);

	if (ret == 0)
		bus->phydev = phydev;

	return ret;
}
EXPORT_SYMBOL_GPL(sfp_add_phy);

void sfp_remove_phy(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);

	if (ops && ops->disconnect_phy)
		ops->disconnect_phy(bus->upstream);
	bus->phydev = NULL;
}
EXPORT_SYMBOL_GPL(sfp_remove_phy);

void sfp_link_up(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);

	if (ops && ops->link_up)
		ops->link_up(bus->upstream);
}
EXPORT_SYMBOL_GPL(sfp_link_up);

void sfp_link_down(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);

	if (ops && ops->link_down)
		ops->link_down(bus->upstream);
}
EXPORT_SYMBOL_GPL(sfp_link_down);

int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	int ret = 0;

	if (ops && ops->module_insert)
		ret = ops->module_insert(bus->upstream, id);

	return ret;
}
EXPORT_SYMBOL_GPL(sfp_module_insert);

void sfp_module_remove(struct sfp_bus *bus)
{
	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);

	if (ops && ops->module_remove)
		ops->module_remove(bus->upstream);
}
EXPORT_SYMBOL_GPL(sfp_module_remove);

static void sfp_socket_clear(struct sfp_bus *bus)
{
	bus->sfp_dev = NULL;
	bus->sfp = NULL;
	bus->socket_ops = NULL;
}

struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp,
				    const struct sfp_socket_ops *ops)
{
	struct sfp_bus *bus = sfp_bus_get(dev->fwnode);
	int ret = 0;

	if (bus) {
		rtnl_lock();
		bus->sfp_dev = dev;
		bus->sfp = sfp;
		bus->socket_ops = ops;

		if (bus->netdev) {
			ret = sfp_register_bus(bus);
			if (ret)
				sfp_socket_clear(bus);
		}
		rtnl_unlock();
	}

	if (ret) {
		sfp_bus_put(bus);
		bus = NULL;
	}

	return bus;
}
EXPORT_SYMBOL_GPL(sfp_register_socket);

void sfp_unregister_socket(struct sfp_bus *bus)
{
	rtnl_lock();
	if (bus->netdev)
		sfp_unregister_bus(bus);
	sfp_socket_clear(bus);
	rtnl_unlock();

	sfp_bus_put(bus);
}
EXPORT_SYMBOL_GPL(sfp_unregister_socket);
Commit	Line	Data
ce0aa27f RK	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
0a6fcd3f RK	11	/**
	12	* struct sfp_bus - internal representation of a sfp bus
	13	*/
ce0aa27f	14	struct sfp_bus {
0a6fcd3f	15	/* private: */
ce0aa27f RK	16	struct kref kref;
ce0aa27f RK	17	struct list_head node;
c19bb000	18	struct fwnode_handle *fwnode;
ce0aa27f RK	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
0a6fcd3f RK	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	*/
ce0aa27f RK	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:
ce0aa27f RK	60	port = PORT_FIBRE;
	61	break;
	62
	63	case SFP_CONNECTOR_RJ45:
ce0aa27f RK	64	port = PORT_TP;
	65	break;
	66
f10fcbcf RK	67	case SFP_CONNECTOR_COPPER_PIGTAIL:
	68	port = PORT_DA;
	69	break;
	70
ce0aa27f RK	71	case SFP_CONNECTOR_UNSPEC:
ce0aa27f RK	72	if (id->base.e1000_base_t) {
ce0aa27f RK	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:
ce0aa27f RK	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
f10fcbcf RK	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
ce0aa27f RK	104	return port;
	105	}
	106	EXPORT_SYMBOL_GPL(sfp_parse_port);
	107
0a6fcd3f RK	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	*/
ce0aa27f RK	117	void sfp_parse_support(struct sfp_bus bus, const struct sfp_eeprom_id id,
	118	unsigned long *support)
	119	{
9962acf7	120	unsigned int br_min, br_nom, br_max;
03145864	121	__ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, };
ce0aa27f	122
9962acf7 RK	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;
52c5cd1b	128	br_min = br_nom - id->base.br_nominal * id->ext.br_min;
9962acf7 RK	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	}
2b999ba8 AT	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;
9962acf7 RK	142	}
9962acf7 RK	143
ce0aa27f RK	144	/* Set ethtool support from the compliance fields. */
ce0aa27f RK	145	if (id->base.e10g_base_sr)
03145864	146	phylink_set(modes, 10000baseSR_Full);
ce0aa27f	147	if (id->base.e10g_base_lr)
03145864	148	phylink_set(modes, 10000baseLR_Full);
ce0aa27f	149	if (id->base.e10g_base_lrm)
03145864	150	phylink_set(modes, 10000baseLRM_Full);
ce0aa27f	151	if (id->base.e10g_base_er)
03145864	152	phylink_set(modes, 10000baseER_Full);
ce0aa27f RK	153	if (id->base.e1000_base_sx \|\|
	154	id->base.e1000_base_lx \|\|
	155	id->base.e1000_base_cx)
03145864	156	phylink_set(modes, 1000baseX_Full);
ce0aa27f	157	if (id->base.e1000_base_t) {
03145864 RK	158	phylink_set(modes, 1000baseT_Half);
03145864 RK	159	phylink_set(modes, 1000baseT_Full);
ce0aa27f RK	160	}
ce0aa27f RK	161
9962acf7 RK	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)
d7f7e001	165	phylink_set(modes, 1000baseX_Full);
9962acf7	166
f10fcbcf RK	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)
03145864	173	phylink_set(modes, 10000baseCR_Full);
f10fcbcf	174	if (br_min <= 3200 && br_max >= 3100)
03145864	175	phylink_set(modes, 2500baseX_Full);
f10fcbcf	176	if (br_min <= 1300 && br_max >= 1200)
03145864	177	phylink_set(modes, 1000baseX_Full);
f10fcbcf RK	178	}
	179	if (id->base.sfp_ct_passive) {
	180	if (id->base.passive.sff8431_app_e)
03145864	181	phylink_set(modes, 10000baseCR_Full);
f10fcbcf RK	182	}
	183	if (id->base.sfp_ct_active) {
	184	if (id->base.active.sff8431_app_e \|\|
	185	id->base.active.sff8431_lim) {
03145864	186	phylink_set(modes, 10000baseCR_Full);
f10fcbcf RK	187	}
	188	}
	189
ce0aa27f RK	190	switch (id->base.extended_cc) {
	191	case 0x00: /* Unspecified */
	192	break;
	193	case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */
03145864 RK	194	phylink_set(modes, 100000baseSR4_Full);
03145864 RK	195	phylink_set(modes, 25000baseSR_Full);
ce0aa27f RK	196	break;
	197	case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */
	198	case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */
03145864	199	phylink_set(modes, 100000baseLR4_ER4_Full);
ce0aa27f RK	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 */
03145864 RK	204	phylink_set(modes, 100000baseCR4_Full);
03145864 RK	205	phylink_set(modes, 25000baseCR_Full);
ce0aa27f RK	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)
03145864	219	phylink_set(modes, 2500baseX_Full);
ce0aa27f	220	if (id->base.br_nominal >= 12)
03145864	221	phylink_set(modes, 1000baseX_Full);
ce0aa27f	222	}
03145864 RK	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);
ce0aa27f RK	241	}
	242	EXPORT_SYMBOL_GPL(sfp_parse_support);
	243
a9c79364 RK	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
ce0aa27f RK	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
c19bb000	291	static struct sfp_bus sfp_bus_get(struct fwnode_handle fwnode)
ce0aa27f RK	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) {
c19bb000	300	if (sfp->fwnode == fwnode) {
ce0aa27f RK	301	kref_get(&sfp->kref);
	302	found = sfp;
	303	break;
	304	}
	305	}
	306
	307	if (!found && new) {
	308	kref_init(&new->kref);
c19bb000	309	new->fwnode = fwnode;
ce0aa27f RK	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
b6e67d6d	322	static void sfp_bus_release(struct kref *kref)
ce0aa27f RK	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	if (bus->started)
	351	bus->socket_ops->start(bus->sfp);
126d6848	352	bus->netdev->sfp_bus = bus;
ce0aa27f RK	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
126d6848	361	bus->netdev->sfp_bus = NULL;
ce0aa27f RK	362	if (bus->registered) {
	363	if (bus->started)
	364	bus->socket_ops->stop(bus->sfp);
	365	if (bus->phydev && ops && ops->disconnect_phy)
	366	ops->disconnect_phy(bus->upstream);
	367	}
	368	bus->registered = false;
	369	}
	370
0a6fcd3f RK	371	/**
	372	* sfp_get_module_info() - Get the ethtool_modinfo for a SFP module
	373	* @bus: a pointer to the &struct sfp_bus structure for the sfp module
	374	* @modinfo: a &struct ethtool_modinfo
	375	*
	376	* Fill in the type and eeprom_len parameters in @modinfo for a module on
	377	* the sfp bus specified by @bus.
	378	*
	379	* Returns 0 on success or a negative errno number.
	380	*/
ce0aa27f RK	381	int sfp_get_module_info(struct sfp_bus bus, struct ethtool_modinfo modinfo)
ce0aa27f RK	382	{
ce0aa27f RK	383	return bus->socket_ops->module_info(bus->sfp, modinfo);
	384	}
	385	EXPORT_SYMBOL_GPL(sfp_get_module_info);
	386
0a6fcd3f RK	387	/**
	388	* sfp_get_module_eeprom() - Read the SFP module EEPROM
	389	* @bus: a pointer to the &struct sfp_bus structure for the sfp module
	390	* @ee: a &struct ethtool_eeprom
	391	* @data: buffer to contain the EEPROM data (must be at least @ee->len bytes)
	392	*
	393	* Read the EEPROM as specified by the supplied @ee. See the documentation
	394	* for &struct ethtool_eeprom for the region to be read.
	395	*
	396	* Returns 0 on success or a negative errno number.
	397	*/
ce0aa27f	398	int sfp_get_module_eeprom(struct sfp_bus bus, struct ethtool_eeprom ee,
516b29ed	399	u8 *data)
ce0aa27f	400	{
ce0aa27f RK	401	return bus->socket_ops->module_eeprom(bus->sfp, ee, data);
	402	}
	403	EXPORT_SYMBOL_GPL(sfp_get_module_eeprom);
	404
0a6fcd3f RK	405	/**
	406	* sfp_upstream_start() - Inform the SFP that the network device is up
	407	* @bus: a pointer to the &struct sfp_bus structure for the sfp module
	408	*
	409	* Inform the SFP socket that the network device is now up, so that the
	410	* module can be enabled by allowing TX_DISABLE to be deasserted. This
	411	* should be called from the network device driver's &struct net_device_ops
	412	* ndo_open() method.
	413	*/
ce0aa27f RK	414	void sfp_upstream_start(struct sfp_bus *bus)
	415	{
	416	if (bus->registered)
	417	bus->socket_ops->start(bus->sfp);
	418	bus->started = true;
	419	}
	420	EXPORT_SYMBOL_GPL(sfp_upstream_start);
	421
0a6fcd3f RK	422	/**
	423	* sfp_upstream_stop() - Inform the SFP that the network device is down
	424	* @bus: a pointer to the &struct sfp_bus structure for the sfp module
	425	*
	426	* Inform the SFP socket that the network device is now up, so that the
	427	* module can be disabled by asserting TX_DISABLE, disabling the laser
	428	* in optical modules. This should be called from the network device
	429	* driver's &struct net_device_ops ndo_stop() method.
	430	*/
ce0aa27f RK	431	void sfp_upstream_stop(struct sfp_bus *bus)
	432	{
	433	if (bus->registered)
	434	bus->socket_ops->stop(bus->sfp);
	435	bus->started = false;
	436	}
	437	EXPORT_SYMBOL_GPL(sfp_upstream_stop);
	438
f20a4c46 RK	439	static void sfp_upstream_clear(struct sfp_bus *bus)
	440	{
	441	bus->upstream_ops = NULL;
	442	bus->upstream = NULL;
	443	bus->netdev = NULL;
	444	}
	445
0a6fcd3f RK	446	/**
0a6fcd3f RK	447	* sfp_register_upstream() - Register the neighbouring device
4bb7df7d	448	* @fwnode: firmware node for the SFP bus
0a6fcd3f RK	449	* @ndev: network device associated with the interface
	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	*/
c19bb000	459	struct sfp_bus sfp_register_upstream(struct fwnode_handle fwnode,
516b29ed FF	460	struct net_device ndev, void upstream,
516b29ed FF	461	const struct sfp_upstream_ops *ops)
ce0aa27f	462	{
c19bb000	463	struct sfp_bus *bus = sfp_bus_get(fwnode);
ce0aa27f RK	464	int ret = 0;
	465
	466	if (bus) {
	467	rtnl_lock();
	468	bus->upstream_ops = ops;
	469	bus->upstream = upstream;
	470	bus->netdev = ndev;
	471
f20a4c46	472	if (bus->sfp) {
ce0aa27f	473	ret = sfp_register_bus(bus);
f20a4c46 RK	474	if (ret)
	475	sfp_upstream_clear(bus);
	476	}
ce0aa27f RK	477	rtnl_unlock();
	478	}
	479
	480	if (ret) {
	481	sfp_bus_put(bus);
	482	bus = NULL;
	483	}
	484
	485	return bus;
	486	}
	487	EXPORT_SYMBOL_GPL(sfp_register_upstream);
	488
0a6fcd3f RK	489	/**
	490	* sfp_unregister_upstream() - Unregister sfp bus
	491	* @bus: a pointer to the &struct sfp_bus structure for the sfp module
	492	*
	493	* Unregister a previously registered upstream connection for the SFP
	494	* module. @bus is returned from sfp_register_upstream().
	495	*/
ce0aa27f RK	496	void sfp_unregister_upstream(struct sfp_bus *bus)
	497	{
	498	rtnl_lock();
0b2122e4 RK	499	if (bus->sfp)
0b2122e4 RK	500	sfp_unregister_bus(bus);
f20a4c46	501	sfp_upstream_clear(bus);
ce0aa27f RK	502	rtnl_unlock();
	503
	504	sfp_bus_put(bus);
	505	}
	506	EXPORT_SYMBOL_GPL(sfp_unregister_upstream);
	507
ce0aa27f RK	508	/* Socket driver entry points */
	509	int sfp_add_phy(struct sfp_bus bus, struct phy_device phydev)
	510	{
	511	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	512	int ret = 0;
	513
	514	if (ops && ops->connect_phy)
	515	ret = ops->connect_phy(bus->upstream, phydev);
	516
	517	if (ret == 0)
	518	bus->phydev = phydev;
	519
	520	return ret;
	521	}
	522	EXPORT_SYMBOL_GPL(sfp_add_phy);
	523
	524	void sfp_remove_phy(struct sfp_bus *bus)
	525	{
	526	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	527
	528	if (ops && ops->disconnect_phy)
	529	ops->disconnect_phy(bus->upstream);
	530	bus->phydev = NULL;
	531	}
	532	EXPORT_SYMBOL_GPL(sfp_remove_phy);
	533
ce0aa27f RK	534	void sfp_link_up(struct sfp_bus *bus)
	535	{
	536	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	537
	538	if (ops && ops->link_up)
	539	ops->link_up(bus->upstream);
	540	}
	541	EXPORT_SYMBOL_GPL(sfp_link_up);
	542
	543	void sfp_link_down(struct sfp_bus *bus)
	544	{
	545	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	546
	547	if (ops && ops->link_down)
	548	ops->link_down(bus->upstream);
	549	}
	550	EXPORT_SYMBOL_GPL(sfp_link_down);
	551
	552	int sfp_module_insert(struct sfp_bus bus, const struct sfp_eeprom_id id)
	553	{
	554	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	555	int ret = 0;
	556
	557	if (ops && ops->module_insert)
	558	ret = ops->module_insert(bus->upstream, id);
	559
	560	return ret;
	561	}
	562	EXPORT_SYMBOL_GPL(sfp_module_insert);
	563
	564	void sfp_module_remove(struct sfp_bus *bus)
	565	{
	566	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
	567
	568	if (ops && ops->module_remove)
	569	ops->module_remove(bus->upstream);
	570	}
	571	EXPORT_SYMBOL_GPL(sfp_module_remove);
	572
f20a4c46 RK	573	static void sfp_socket_clear(struct sfp_bus *bus)
	574	{
	575	bus->sfp_dev = NULL;
	576	bus->sfp = NULL;
	577	bus->socket_ops = NULL;
	578	}
	579
ce0aa27f RK	580	struct sfp_bus sfp_register_socket(struct device dev, struct sfp *sfp,
	581	const struct sfp_socket_ops *ops)
	582	{
c19bb000	583	struct sfp_bus *bus = sfp_bus_get(dev->fwnode);
ce0aa27f RK	584	int ret = 0;
	585
	586	if (bus) {
	587	rtnl_lock();
	588	bus->sfp_dev = dev;
	589	bus->sfp = sfp;
	590	bus->socket_ops = ops;
	591
f20a4c46	592	if (bus->netdev) {
ce0aa27f	593	ret = sfp_register_bus(bus);
f20a4c46 RK	594	if (ret)
	595	sfp_socket_clear(bus);
	596	}
ce0aa27f RK	597	rtnl_unlock();
	598	}
	599
	600	if (ret) {
	601	sfp_bus_put(bus);
	602	bus = NULL;
	603	}
	604
	605	return bus;
	606	}
	607	EXPORT_SYMBOL_GPL(sfp_register_socket);
	608
	609	void sfp_unregister_socket(struct sfp_bus *bus)
	610	{
	611	rtnl_lock();
0b2122e4 RK	612	if (bus->netdev)
0b2122e4 RK	613	sfp_unregister_bus(bus);
f20a4c46	614	sfp_socket_clear(bus);
ce0aa27f RK	615	rtnl_unlock();
	616
	617	sfp_bus_put(bus);
	618	}
	619	EXPORT_SYMBOL_GPL(sfp_unregister_socket);