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/property.h>
8 #include <linux/rtnetlink.h>
9 #include <linux/slab.h>
10 
11 #include "sfp.h"
12 
13 /**
14  * struct sfp_bus - internal representation of a sfp bus
15  */
16 struct sfp_bus {
17 	/* private: */
18 	struct kref kref;
19 	struct list_head node;
20 	struct fwnode_handle *fwnode;
21 
22 	const struct sfp_socket_ops *socket_ops;
23 	struct device *sfp_dev;
24 	struct sfp *sfp;
25 	const struct sfp_quirk *sfp_quirk;
26 
27 	const struct sfp_upstream_ops *upstream_ops;
28 	void *upstream;
29 	struct phy_device *phydev;
30 
31 	bool registered;
32 	bool started;
33 };
34 
35 /**
36  * sfp_parse_port() - Parse the EEPROM base ID, setting the port type
37  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
38  * @id: a pointer to the module's &struct sfp_eeprom_id
39  * @support: optional pointer to an array of unsigned long for the
40  *   ethtool support mask
41  *
42  * Parse the EEPROM identification given in @id, and return one of
43  * %PORT_TP, %PORT_FIBRE or %PORT_OTHER. If @support is non-%NULL,
44  * also set the ethtool %ETHTOOL_LINK_MODE_xxx_BIT corresponding with
45  * the connector type.
46  *
47  * If the port type is not known, returns %PORT_OTHER.
48  */
sfp_parse_port(struct sfp_bus * bus,const struct sfp_eeprom_id * id,unsigned long * support)49 int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
50 		   unsigned long *support)
51 {
52 	int port;
53 
54 	/* port is the physical connector, set this from the connector field. */
55 	switch (id->base.connector) {
56 	case SFF8024_CONNECTOR_SC:
57 	case SFF8024_CONNECTOR_FIBERJACK:
58 	case SFF8024_CONNECTOR_LC:
59 	case SFF8024_CONNECTOR_MT_RJ:
60 	case SFF8024_CONNECTOR_MU:
61 	case SFF8024_CONNECTOR_OPTICAL_PIGTAIL:
62 	case SFF8024_CONNECTOR_MPO_1X12:
63 	case SFF8024_CONNECTOR_MPO_2X16:
64 		port = PORT_FIBRE;
65 		break;
66 
67 	case SFF8024_CONNECTOR_RJ45:
68 		port = PORT_TP;
69 		break;
70 
71 	case SFF8024_CONNECTOR_COPPER_PIGTAIL:
72 		port = PORT_DA;
73 		break;
74 
75 	case SFF8024_CONNECTOR_UNSPEC:
76 		if (id->base.e1000_base_t) {
77 			port = PORT_TP;
78 			break;
79 		}
80 		fallthrough;
81 	case SFF8024_CONNECTOR_SG: /* guess */
82 	case SFF8024_CONNECTOR_HSSDC_II:
83 	case SFF8024_CONNECTOR_NOSEPARATE:
84 	case SFF8024_CONNECTOR_MXC_2X16:
85 		port = PORT_OTHER;
86 		break;
87 	default:
88 		dev_warn(bus->sfp_dev, "SFP: unknown connector id 0x%02x\n",
89 			 id->base.connector);
90 		port = PORT_OTHER;
91 		break;
92 	}
93 
94 	if (support) {
95 		switch (port) {
96 		case PORT_FIBRE:
97 			phylink_set(support, FIBRE);
98 			break;
99 
100 		case PORT_TP:
101 			phylink_set(support, TP);
102 			break;
103 		}
104 	}
105 
106 	return port;
107 }
108 EXPORT_SYMBOL_GPL(sfp_parse_port);
109 
110 /**
111  * sfp_may_have_phy() - indicate whether the module may have a PHY
112  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
113  * @id: a pointer to the module's &struct sfp_eeprom_id
114  *
115  * Parse the EEPROM identification given in @id, and return whether
116  * this module may have a PHY.
117  */
sfp_may_have_phy(struct sfp_bus * bus,const struct sfp_eeprom_id * id)118 bool sfp_may_have_phy(struct sfp_bus *bus, const struct sfp_eeprom_id *id)
119 {
120 	if (id->base.e1000_base_t)
121 		return true;
122 
123 	if (id->base.phys_id != SFF8024_ID_DWDM_SFP) {
124 		switch (id->base.extended_cc) {
125 		case SFF8024_ECC_10GBASE_T_SFI:
126 		case SFF8024_ECC_10GBASE_T_SR:
127 		case SFF8024_ECC_5GBASE_T:
128 		case SFF8024_ECC_2_5GBASE_T:
129 			return true;
130 		}
131 	}
132 
133 	return false;
134 }
135 EXPORT_SYMBOL_GPL(sfp_may_have_phy);
136 
137 /**
138  * sfp_parse_support() - Parse the eeprom id for supported link modes
139  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
140  * @id: a pointer to the module's &struct sfp_eeprom_id
141  * @support: pointer to an array of unsigned long for the ethtool support mask
142  * @interfaces: pointer to an array of unsigned long for phy interface modes
143  *		mask
144  *
145  * Parse the EEPROM identification information and derive the supported
146  * ethtool link modes for the module.
147  */
sfp_parse_support(struct sfp_bus * bus,const struct sfp_eeprom_id * id,unsigned long * support,unsigned long * interfaces)148 void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
149 		       unsigned long *support, unsigned long *interfaces)
150 {
151 	unsigned int br_min, br_nom, br_max;
152 	__ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = { 0, };
153 
154 	/* Decode the bitrate information to MBd */
155 	br_min = br_nom = br_max = 0;
156 	if (id->base.br_nominal) {
157 		if (id->base.br_nominal != 255) {
158 			br_nom = id->base.br_nominal * 100;
159 			br_min = br_nom - id->base.br_nominal * id->ext.br_min;
160 			br_max = br_nom + id->base.br_nominal * id->ext.br_max;
161 		} else if (id->ext.br_max) {
162 			br_nom = 250 * id->ext.br_max;
163 			br_max = br_nom + br_nom * id->ext.br_min / 100;
164 			br_min = br_nom - br_nom * id->ext.br_min / 100;
165 		}
166 
167 		/* When using passive cables, in case neither BR,min nor BR,max
168 		 * are specified, set br_min to 0 as the nominal value is then
169 		 * used as the maximum.
170 		 */
171 		if (br_min == br_max && id->base.sfp_ct_passive)
172 			br_min = 0;
173 	}
174 
175 	/* Set ethtool support from the compliance fields. */
176 	if (id->base.e10g_base_sr) {
177 		phylink_set(modes, 10000baseSR_Full);
178 		__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
179 	}
180 	if (id->base.e10g_base_lr) {
181 		phylink_set(modes, 10000baseLR_Full);
182 		__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
183 	}
184 	if (id->base.e10g_base_lrm) {
185 		phylink_set(modes, 10000baseLRM_Full);
186 		__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
187 	}
188 	if (id->base.e10g_base_er) {
189 		phylink_set(modes, 10000baseER_Full);
190 		__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
191 	}
192 	if (id->base.e1000_base_sx ||
193 	    id->base.e1000_base_lx ||
194 	    id->base.e1000_base_cx) {
195 		phylink_set(modes, 1000baseX_Full);
196 		__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
197 	}
198 	if (id->base.e1000_base_t) {
199 		phylink_set(modes, 1000baseT_Half);
200 		phylink_set(modes, 1000baseT_Full);
201 		__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
202 		__set_bit(PHY_INTERFACE_MODE_SGMII, interfaces);
203 	}
204 
205 	/* 1000Base-PX or 1000Base-BX10 */
206 	if ((id->base.e_base_px || id->base.e_base_bx10) &&
207 	    br_min <= 1300 && br_max >= 1200) {
208 		phylink_set(modes, 1000baseX_Full);
209 		__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
210 	}
211 
212 	/* 100Base-FX, 100Base-LX, 100Base-PX, 100Base-BX10 */
213 	if (id->base.e100_base_fx || id->base.e100_base_lx) {
214 		phylink_set(modes, 100baseFX_Full);
215 		__set_bit(PHY_INTERFACE_MODE_100BASEX, interfaces);
216 	}
217 	if ((id->base.e_base_px || id->base.e_base_bx10) && br_nom == 100) {
218 		phylink_set(modes, 100baseFX_Full);
219 		__set_bit(PHY_INTERFACE_MODE_100BASEX, interfaces);
220 	}
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 			__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
230 		}
231 		if (br_min <= 3200 && br_max >= 3100) {
232 			phylink_set(modes, 2500baseX_Full);
233 			__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
234 		}
235 		if (br_min <= 1300 && br_max >= 1200) {
236 			phylink_set(modes, 1000baseX_Full);
237 			__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
238 		}
239 	}
240 	if (id->base.sfp_ct_passive) {
241 		if (id->base.passive.sff8431_app_e) {
242 			phylink_set(modes, 10000baseCR_Full);
243 			__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
244 		}
245 	}
246 	if (id->base.sfp_ct_active) {
247 		if (id->base.active.sff8431_app_e ||
248 		    id->base.active.sff8431_lim) {
249 			phylink_set(modes, 10000baseCR_Full);
250 			__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
251 		}
252 	}
253 
254 	switch (id->base.extended_cc) {
255 	case SFF8024_ECC_UNSPEC:
256 		break;
257 	case SFF8024_ECC_100GBASE_SR4_25GBASE_SR:
258 		phylink_set(modes, 100000baseSR4_Full);
259 		phylink_set(modes, 25000baseSR_Full);
260 		__set_bit(PHY_INTERFACE_MODE_25GBASER, interfaces);
261 		break;
262 	case SFF8024_ECC_100GBASE_LR4_25GBASE_LR:
263 	case SFF8024_ECC_100GBASE_ER4_25GBASE_ER:
264 		phylink_set(modes, 100000baseLR4_ER4_Full);
265 		break;
266 	case SFF8024_ECC_100GBASE_CR4:
267 		phylink_set(modes, 100000baseCR4_Full);
268 		fallthrough;
269 	case SFF8024_ECC_25GBASE_CR_S:
270 	case SFF8024_ECC_25GBASE_CR_N:
271 		phylink_set(modes, 25000baseCR_Full);
272 		__set_bit(PHY_INTERFACE_MODE_25GBASER, interfaces);
273 		break;
274 	case SFF8024_ECC_10GBASE_T_SFI:
275 	case SFF8024_ECC_10GBASE_T_SR:
276 		phylink_set(modes, 10000baseT_Full);
277 		__set_bit(PHY_INTERFACE_MODE_10GBASER, interfaces);
278 		break;
279 	case SFF8024_ECC_5GBASE_T:
280 		phylink_set(modes, 5000baseT_Full);
281 		__set_bit(PHY_INTERFACE_MODE_5GBASER, interfaces);
282 		break;
283 	case SFF8024_ECC_2_5GBASE_T:
284 		phylink_set(modes, 2500baseT_Full);
285 		__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
286 		break;
287 	default:
288 		dev_warn(bus->sfp_dev,
289 			 "Unknown/unsupported extended compliance code: 0x%02x\n",
290 			 id->base.extended_cc);
291 		break;
292 	}
293 
294 	/* For fibre channel SFP, derive possible BaseX modes */
295 	if (id->base.fc_speed_100 ||
296 	    id->base.fc_speed_200 ||
297 	    id->base.fc_speed_400) {
298 		if (id->base.br_nominal >= 31) {
299 			phylink_set(modes, 2500baseX_Full);
300 			__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
301 		}
302 		if (id->base.br_nominal >= 12) {
303 			phylink_set(modes, 1000baseX_Full);
304 			__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
305 		}
306 	}
307 
308 	/* If we haven't discovered any modes that this module supports, try
309 	 * the bitrate to determine supported modes. Some BiDi modules (eg,
310 	 * 1310nm/1550nm) are not 1000BASE-BX compliant due to the differing
311 	 * wavelengths, so do not set any transceiver bits.
312 	 *
313 	 * Do the same for modules supporting 2500BASE-X. Note that some
314 	 * modules use 2500Mbaud rather than 3100 or 3200Mbaud for
315 	 * 2500BASE-X, so we allow some slack here.
316 	 */
317 	if (bitmap_empty(modes, __ETHTOOL_LINK_MODE_MASK_NBITS) && br_nom) {
318 		if (br_min <= 1300 && br_max >= 1200) {
319 			phylink_set(modes, 1000baseX_Full);
320 			__set_bit(PHY_INTERFACE_MODE_1000BASEX, interfaces);
321 		}
322 		if (br_min <= 3200 && br_max >= 2500) {
323 			phylink_set(modes, 2500baseX_Full);
324 			__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
325 		}
326 	}
327 
328 	if (bus->sfp_quirk && bus->sfp_quirk->modes)
329 		bus->sfp_quirk->modes(id, modes, interfaces);
330 
331 	linkmode_or(support, support, modes);
332 
333 	phylink_set(support, Autoneg);
334 	phylink_set(support, Pause);
335 	phylink_set(support, Asym_Pause);
336 }
337 EXPORT_SYMBOL_GPL(sfp_parse_support);
338 
339 /**
340  * sfp_select_interface() - Select appropriate phy_interface_t mode
341  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
342  * @link_modes: ethtool link modes mask
343  *
344  * Derive the phy_interface_t mode for the SFP module from the link
345  * modes mask.
346  */
sfp_select_interface(struct sfp_bus * bus,unsigned long * link_modes)347 phy_interface_t sfp_select_interface(struct sfp_bus *bus,
348 				     unsigned long *link_modes)
349 {
350 	if (phylink_test(link_modes, 25000baseCR_Full) ||
351 	    phylink_test(link_modes, 25000baseKR_Full) ||
352 	    phylink_test(link_modes, 25000baseSR_Full))
353 		return PHY_INTERFACE_MODE_25GBASER;
354 
355 	if (phylink_test(link_modes, 10000baseCR_Full) ||
356 	    phylink_test(link_modes, 10000baseSR_Full) ||
357 	    phylink_test(link_modes, 10000baseLR_Full) ||
358 	    phylink_test(link_modes, 10000baseLRM_Full) ||
359 	    phylink_test(link_modes, 10000baseER_Full) ||
360 	    phylink_test(link_modes, 10000baseT_Full))
361 		return PHY_INTERFACE_MODE_10GBASER;
362 
363 	if (phylink_test(link_modes, 5000baseT_Full))
364 		return PHY_INTERFACE_MODE_5GBASER;
365 
366 	if (phylink_test(link_modes, 2500baseX_Full))
367 		return PHY_INTERFACE_MODE_2500BASEX;
368 
369 	if (phylink_test(link_modes, 1000baseT_Half) ||
370 	    phylink_test(link_modes, 1000baseT_Full))
371 		return PHY_INTERFACE_MODE_SGMII;
372 
373 	if (phylink_test(link_modes, 1000baseX_Full))
374 		return PHY_INTERFACE_MODE_1000BASEX;
375 
376 	if (phylink_test(link_modes, 100baseFX_Full))
377 		return PHY_INTERFACE_MODE_100BASEX;
378 
379 	dev_warn(bus->sfp_dev, "Unable to ascertain link mode\n");
380 
381 	return PHY_INTERFACE_MODE_NA;
382 }
383 EXPORT_SYMBOL_GPL(sfp_select_interface);
384 
385 static LIST_HEAD(sfp_buses);
386 static DEFINE_MUTEX(sfp_mutex);
387 
sfp_get_upstream_ops(struct sfp_bus * bus)388 static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus)
389 {
390 	return bus->registered ? bus->upstream_ops : NULL;
391 }
392 
sfp_bus_get(struct fwnode_handle * fwnode)393 static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode)
394 {
395 	struct sfp_bus *sfp, *new, *found = NULL;
396 
397 	new = kzalloc(sizeof(*new), GFP_KERNEL);
398 
399 	mutex_lock(&sfp_mutex);
400 
401 	list_for_each_entry(sfp, &sfp_buses, node) {
402 		if (sfp->fwnode == fwnode) {
403 			kref_get(&sfp->kref);
404 			found = sfp;
405 			break;
406 		}
407 	}
408 
409 	if (!found && new) {
410 		kref_init(&new->kref);
411 		new->fwnode = fwnode;
412 		list_add(&new->node, &sfp_buses);
413 		found = new;
414 		new = NULL;
415 	}
416 
417 	mutex_unlock(&sfp_mutex);
418 
419 	kfree(new);
420 
421 	return found;
422 }
423 
sfp_bus_release(struct kref * kref)424 static void sfp_bus_release(struct kref *kref)
425 {
426 	struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref);
427 
428 	list_del(&bus->node);
429 	mutex_unlock(&sfp_mutex);
430 	kfree(bus);
431 }
432 
433 /**
434  * sfp_bus_put() - put a reference on the &struct sfp_bus
435  * @bus: the &struct sfp_bus found via sfp_bus_find_fwnode()
436  *
437  * Put a reference on the &struct sfp_bus and free the underlying structure
438  * if this was the last reference.
439  */
sfp_bus_put(struct sfp_bus * bus)440 void sfp_bus_put(struct sfp_bus *bus)
441 {
442 	if (bus)
443 		kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex);
444 }
445 EXPORT_SYMBOL_GPL(sfp_bus_put);
446 
sfp_register_bus(struct sfp_bus * bus)447 static int sfp_register_bus(struct sfp_bus *bus)
448 {
449 	const struct sfp_upstream_ops *ops = bus->upstream_ops;
450 	int ret;
451 
452 	if (ops) {
453 		if (ops->link_down)
454 			ops->link_down(bus->upstream);
455 		if (ops->connect_phy && bus->phydev) {
456 			ret = ops->connect_phy(bus->upstream, bus->phydev);
457 			if (ret)
458 				return ret;
459 		}
460 	}
461 	bus->registered = true;
462 	bus->socket_ops->attach(bus->sfp);
463 	if (bus->started)
464 		bus->socket_ops->start(bus->sfp);
465 	bus->upstream_ops->attach(bus->upstream, bus);
466 	return 0;
467 }
468 
sfp_unregister_bus(struct sfp_bus * bus)469 static void sfp_unregister_bus(struct sfp_bus *bus)
470 {
471 	const struct sfp_upstream_ops *ops = bus->upstream_ops;
472 
473 	if (bus->registered) {
474 		bus->upstream_ops->detach(bus->upstream, bus);
475 		if (bus->started)
476 			bus->socket_ops->stop(bus->sfp);
477 		bus->socket_ops->detach(bus->sfp);
478 		if (bus->phydev && ops && ops->disconnect_phy)
479 			ops->disconnect_phy(bus->upstream);
480 	}
481 	bus->registered = false;
482 }
483 
484 /**
485  * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module
486  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
487  * @modinfo: a &struct ethtool_modinfo
488  *
489  * Fill in the type and eeprom_len parameters in @modinfo for a module on
490  * the sfp bus specified by @bus.
491  *
492  * Returns 0 on success or a negative errno number.
493  */
sfp_get_module_info(struct sfp_bus * bus,struct ethtool_modinfo * modinfo)494 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)
495 {
496 	return bus->socket_ops->module_info(bus->sfp, modinfo);
497 }
498 EXPORT_SYMBOL_GPL(sfp_get_module_info);
499 
500 /**
501  * sfp_get_module_eeprom() - Read the SFP module EEPROM
502  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
503  * @ee: a &struct ethtool_eeprom
504  * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes)
505  *
506  * Read the EEPROM as specified by the supplied @ee. See the documentation
507  * for &struct ethtool_eeprom for the region to be read.
508  *
509  * Returns 0 on success or a negative errno number.
510  */
sfp_get_module_eeprom(struct sfp_bus * bus,struct ethtool_eeprom * ee,u8 * data)511 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
512 			  u8 *data)
513 {
514 	return bus->socket_ops->module_eeprom(bus->sfp, ee, data);
515 }
516 EXPORT_SYMBOL_GPL(sfp_get_module_eeprom);
517 
518 /**
519  * sfp_get_module_eeprom_by_page() - Read a page from the SFP module EEPROM
520  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
521  * @page: a &struct ethtool_module_eeprom
522  * @extack: extack for reporting problems
523  *
524  * Read an EEPROM page as specified by the supplied @page. See the
525  * documentation for &struct ethtool_module_eeprom for the page to be read.
526  *
527  * Returns 0 on success or a negative errno number. More error
528  * information might be provided via extack
529  */
sfp_get_module_eeprom_by_page(struct sfp_bus * bus,const struct ethtool_module_eeprom * page,struct netlink_ext_ack * extack)530 int sfp_get_module_eeprom_by_page(struct sfp_bus *bus,
531 				  const struct ethtool_module_eeprom *page,
532 				  struct netlink_ext_ack *extack)
533 {
534 	return bus->socket_ops->module_eeprom_by_page(bus->sfp, page, extack);
535 }
536 EXPORT_SYMBOL_GPL(sfp_get_module_eeprom_by_page);
537 
538 /**
539  * sfp_upstream_start() - Inform the SFP that the network device is up
540  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
541  *
542  * Inform the SFP socket that the network device is now up, so that the
543  * module can be enabled by allowing TX_DISABLE to be deasserted. This
544  * should be called from the network device driver's &struct net_device_ops
545  * ndo_open() method.
546  */
sfp_upstream_start(struct sfp_bus * bus)547 void sfp_upstream_start(struct sfp_bus *bus)
548 {
549 	if (bus->registered)
550 		bus->socket_ops->start(bus->sfp);
551 	bus->started = true;
552 }
553 EXPORT_SYMBOL_GPL(sfp_upstream_start);
554 
555 /**
556  * sfp_upstream_stop() - Inform the SFP that the network device is down
557  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
558  *
559  * Inform the SFP socket that the network device is now up, so that the
560  * module can be disabled by asserting TX_DISABLE, disabling the laser
561  * in optical modules. This should be called from the network device
562  * driver's &struct net_device_ops ndo_stop() method.
563  */
sfp_upstream_stop(struct sfp_bus * bus)564 void sfp_upstream_stop(struct sfp_bus *bus)
565 {
566 	if (bus->registered)
567 		bus->socket_ops->stop(bus->sfp);
568 	bus->started = false;
569 }
570 EXPORT_SYMBOL_GPL(sfp_upstream_stop);
571 
sfp_upstream_clear(struct sfp_bus * bus)572 static void sfp_upstream_clear(struct sfp_bus *bus)
573 {
574 	bus->upstream_ops = NULL;
575 	bus->upstream = NULL;
576 }
577 
578 /**
579  * sfp_bus_find_fwnode() - parse and locate the SFP bus from fwnode
580  * @fwnode: firmware node for the parent device (MAC or PHY)
581  *
582  * Parse the parent device's firmware node for a SFP bus, and locate
583  * the sfp_bus structure, incrementing its reference count.  This must
584  * be put via sfp_bus_put() when done.
585  *
586  * Returns:
587  *	- on success, a pointer to the sfp_bus structure,
588  *	- %NULL if no SFP is specified,
589  *	- on failure, an error pointer value:
590  *
591  *	- corresponding to the errors detailed for
592  *	  fwnode_property_get_reference_args().
593  *	- %-ENOMEM if we failed to allocate the bus.
594  *	- an error from the upstream's connect_phy() method.
595  */
sfp_bus_find_fwnode(struct fwnode_handle * fwnode)596 struct sfp_bus *sfp_bus_find_fwnode(struct fwnode_handle *fwnode)
597 {
598 	struct fwnode_reference_args ref;
599 	struct sfp_bus *bus;
600 	int ret;
601 
602 	ret = fwnode_property_get_reference_args(fwnode, "sfp", NULL,
603 						 0, 0, &ref);
604 	if (ret == -ENOENT)
605 		return NULL;
606 	else if (ret < 0)
607 		return ERR_PTR(ret);
608 
609 	if (!fwnode_device_is_available(ref.fwnode)) {
610 		fwnode_handle_put(ref.fwnode);
611 		return NULL;
612 	}
613 
614 	bus = sfp_bus_get(ref.fwnode);
615 	fwnode_handle_put(ref.fwnode);
616 	if (!bus)
617 		return ERR_PTR(-ENOMEM);
618 
619 	return bus;
620 }
621 EXPORT_SYMBOL_GPL(sfp_bus_find_fwnode);
622 
623 /**
624  * sfp_bus_add_upstream() - parse and register the neighbouring device
625  * @bus: the &struct sfp_bus found via sfp_bus_find_fwnode()
626  * @upstream: the upstream private data
627  * @ops: the upstream's &struct sfp_upstream_ops
628  *
629  * Add upstream driver for the SFP bus, and if the bus is complete, register
630  * the SFP bus using sfp_register_upstream().  This takes a reference on the
631  * bus, so it is safe to put the bus after this call.
632  *
633  * Returns:
634  *	- on success, a pointer to the sfp_bus structure,
635  *	- %NULL if no SFP is specified,
636  *	- on failure, an error pointer value:
637  *
638  *	- corresponding to the errors detailed for
639  *	  fwnode_property_get_reference_args().
640  *	- %-ENOMEM if we failed to allocate the bus.
641  *	- an error from the upstream's connect_phy() method.
642  */
sfp_bus_add_upstream(struct sfp_bus * bus,void * upstream,const struct sfp_upstream_ops * ops)643 int sfp_bus_add_upstream(struct sfp_bus *bus, void *upstream,
644 			 const struct sfp_upstream_ops *ops)
645 {
646 	int ret;
647 
648 	/* If no bus, return success */
649 	if (!bus)
650 		return 0;
651 
652 	rtnl_lock();
653 	kref_get(&bus->kref);
654 	bus->upstream_ops = ops;
655 	bus->upstream = upstream;
656 
657 	if (bus->sfp) {
658 		ret = sfp_register_bus(bus);
659 		if (ret)
660 			sfp_upstream_clear(bus);
661 	} else {
662 		ret = 0;
663 	}
664 	rtnl_unlock();
665 
666 	if (ret)
667 		sfp_bus_put(bus);
668 
669 	return ret;
670 }
671 EXPORT_SYMBOL_GPL(sfp_bus_add_upstream);
672 
673 /**
674  * sfp_bus_del_upstream() - Delete a sfp bus
675  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
676  *
677  * Delete a previously registered upstream connection for the SFP
678  * module. @bus should have been added by sfp_bus_add_upstream().
679  */
sfp_bus_del_upstream(struct sfp_bus * bus)680 void sfp_bus_del_upstream(struct sfp_bus *bus)
681 {
682 	if (bus) {
683 		rtnl_lock();
684 		if (bus->sfp)
685 			sfp_unregister_bus(bus);
686 		sfp_upstream_clear(bus);
687 		rtnl_unlock();
688 
689 		sfp_bus_put(bus);
690 	}
691 }
692 EXPORT_SYMBOL_GPL(sfp_bus_del_upstream);
693 
694 /* Socket driver entry points */
sfp_add_phy(struct sfp_bus * bus,struct phy_device * phydev)695 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev)
696 {
697 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
698 	int ret = 0;
699 
700 	if (ops && ops->connect_phy)
701 		ret = ops->connect_phy(bus->upstream, phydev);
702 
703 	if (ret == 0)
704 		bus->phydev = phydev;
705 
706 	return ret;
707 }
708 EXPORT_SYMBOL_GPL(sfp_add_phy);
709 
sfp_remove_phy(struct sfp_bus * bus)710 void sfp_remove_phy(struct sfp_bus *bus)
711 {
712 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
713 
714 	if (ops && ops->disconnect_phy)
715 		ops->disconnect_phy(bus->upstream);
716 	bus->phydev = NULL;
717 }
718 EXPORT_SYMBOL_GPL(sfp_remove_phy);
719 
sfp_link_up(struct sfp_bus * bus)720 void sfp_link_up(struct sfp_bus *bus)
721 {
722 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
723 
724 	if (ops && ops->link_up)
725 		ops->link_up(bus->upstream);
726 }
727 EXPORT_SYMBOL_GPL(sfp_link_up);
728 
sfp_link_down(struct sfp_bus * bus)729 void sfp_link_down(struct sfp_bus *bus)
730 {
731 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
732 
733 	if (ops && ops->link_down)
734 		ops->link_down(bus->upstream);
735 }
736 EXPORT_SYMBOL_GPL(sfp_link_down);
737 
sfp_module_insert(struct sfp_bus * bus,const struct sfp_eeprom_id * id,const struct sfp_quirk * quirk)738 int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
739 		      const struct sfp_quirk *quirk)
740 {
741 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
742 	int ret = 0;
743 
744 	bus->sfp_quirk = quirk;
745 
746 	if (ops && ops->module_insert)
747 		ret = ops->module_insert(bus->upstream, id);
748 
749 	return ret;
750 }
751 EXPORT_SYMBOL_GPL(sfp_module_insert);
752 
sfp_module_remove(struct sfp_bus * bus)753 void sfp_module_remove(struct sfp_bus *bus)
754 {
755 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
756 
757 	if (ops && ops->module_remove)
758 		ops->module_remove(bus->upstream);
759 
760 	bus->sfp_quirk = NULL;
761 }
762 EXPORT_SYMBOL_GPL(sfp_module_remove);
763 
sfp_module_start(struct sfp_bus * bus)764 int sfp_module_start(struct sfp_bus *bus)
765 {
766 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
767 	int ret = 0;
768 
769 	if (ops && ops->module_start)
770 		ret = ops->module_start(bus->upstream);
771 
772 	return ret;
773 }
774 EXPORT_SYMBOL_GPL(sfp_module_start);
775 
sfp_module_stop(struct sfp_bus * bus)776 void sfp_module_stop(struct sfp_bus *bus)
777 {
778 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
779 
780 	if (ops && ops->module_stop)
781 		ops->module_stop(bus->upstream);
782 }
783 EXPORT_SYMBOL_GPL(sfp_module_stop);
784 
sfp_socket_clear(struct sfp_bus * bus)785 static void sfp_socket_clear(struct sfp_bus *bus)
786 {
787 	bus->sfp_dev = NULL;
788 	bus->sfp = NULL;
789 	bus->socket_ops = NULL;
790 }
791 
sfp_register_socket(struct device * dev,struct sfp * sfp,const struct sfp_socket_ops * ops)792 struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp,
793 				    const struct sfp_socket_ops *ops)
794 {
795 	struct sfp_bus *bus = sfp_bus_get(dev->fwnode);
796 	int ret = 0;
797 
798 	if (bus) {
799 		rtnl_lock();
800 		bus->sfp_dev = dev;
801 		bus->sfp = sfp;
802 		bus->socket_ops = ops;
803 
804 		if (bus->upstream_ops) {
805 			ret = sfp_register_bus(bus);
806 			if (ret)
807 				sfp_socket_clear(bus);
808 		}
809 		rtnl_unlock();
810 	}
811 
812 	if (ret) {
813 		sfp_bus_put(bus);
814 		bus = NULL;
815 	}
816 
817 	return bus;
818 }
819 EXPORT_SYMBOL_GPL(sfp_register_socket);
820 
sfp_unregister_socket(struct sfp_bus * bus)821 void sfp_unregister_socket(struct sfp_bus *bus)
822 {
823 	rtnl_lock();
824 	if (bus->upstream_ops)
825 		sfp_unregister_bus(bus);
826 	sfp_socket_clear(bus);
827 	rtnl_unlock();
828 
829 	sfp_bus_put(bus);
830 }
831 EXPORT_SYMBOL_GPL(sfp_unregister_socket);
832