xref: /linux/drivers/net/phy/sfp-bus.c (revision e3b9f1e81de2083f359bacd2a94bf1c024f2ede0) 
1 #include <linux/export.h>
2 #include <linux/kref.h>
3 #include <linux/list.h>
4 #include <linux/mutex.h>
5 #include <linux/phylink.h>
6 #include <linux/rtnetlink.h>
7 #include <linux/slab.h>
8 
9 #include "sfp.h"
10 
11 /**
12  * struct sfp_bus - internal representation of a sfp bus
13  */
14 struct sfp_bus {
15 	/* private: */
16 	struct kref kref;
17 	struct list_head node;
18 	struct fwnode_handle *fwnode;
19 
20 	const struct sfp_socket_ops *socket_ops;
21 	struct device *sfp_dev;
22 	struct sfp *sfp;
23 
24 	const struct sfp_upstream_ops *upstream_ops;
25 	void *upstream;
26 	struct net_device *netdev;
27 	struct phy_device *phydev;
28 
29 	bool registered;
30 	bool started;
31 };
32 
33 /**
34  * sfp_parse_port() - Parse the EEPROM base ID, setting the port type
35  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
36  * @id: a pointer to the module's &struct sfp_eeprom_id
37  * @support: optional pointer to an array of unsigned long for the
38  *   ethtool support mask
39  *
40  * Parse the EEPROM identification given in @id, and return one of
41  * %PORT_TP, %PORT_FIBRE or %PORT_OTHER. If @support is non-%NULL,
42  * also set the ethtool %ETHTOOL_LINK_MODE_xxx_BIT corresponding with
43  * the connector type.
44  *
45  * If the port type is not known, returns %PORT_OTHER.
46  */
47 int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
48 		   unsigned long *support)
49 {
50 	int port;
51 
52 	/* port is the physical connector, set this from the connector field. */
53 	switch (id->base.connector) {
54 	case SFP_CONNECTOR_SC:
55 	case SFP_CONNECTOR_FIBERJACK:
56 	case SFP_CONNECTOR_LC:
57 	case SFP_CONNECTOR_MT_RJ:
58 	case SFP_CONNECTOR_MU:
59 	case SFP_CONNECTOR_OPTICAL_PIGTAIL:
60 		port = PORT_FIBRE;
61 		break;
62 
63 	case SFP_CONNECTOR_RJ45:
64 		port = PORT_TP;
65 		break;
66 
67 	case SFP_CONNECTOR_COPPER_PIGTAIL:
68 		port = PORT_DA;
69 		break;
70 
71 	case SFP_CONNECTOR_UNSPEC:
72 		if (id->base.e1000_base_t) {
73 			port = PORT_TP;
74 			break;
75 		}
76 		/* fallthrough */
77 	case SFP_CONNECTOR_SG: /* guess */
78 	case SFP_CONNECTOR_MPO_1X12:
79 	case SFP_CONNECTOR_MPO_2X16:
80 	case SFP_CONNECTOR_HSSDC_II:
81 	case SFP_CONNECTOR_NOSEPARATE:
82 	case SFP_CONNECTOR_MXC_2X16:
83 		port = PORT_OTHER;
84 		break;
85 	default:
86 		dev_warn(bus->sfp_dev, "SFP: unknown connector id 0x%02x\n",
87 			 id->base.connector);
88 		port = PORT_OTHER;
89 		break;
90 	}
91 
92 	if (support) {
93 		switch (port) {
94 		case PORT_FIBRE:
95 			phylink_set(support, FIBRE);
96 			break;
97 
98 		case PORT_TP:
99 			phylink_set(support, TP);
100 			break;
101 		}
102 	}
103 
104 	return port;
105 }
106 EXPORT_SYMBOL_GPL(sfp_parse_port);
107 
108 /**
109  * sfp_parse_interface() - Parse the phy_interface_t
110  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
111  * @id: a pointer to the module's &struct sfp_eeprom_id
112  *
113  * Derive the phy_interface_t mode for the information found in the
114  * module's identifying EEPROM. There is no standard or defined way
115  * to derive this information, so we use some heuristics.
116  *
117  * If the encoding is 64b66b, then the module must be >= 10G, so
118  * return %PHY_INTERFACE_MODE_10GKR.
119  *
120  * If it's 8b10b, then it's 1G or slower. If it's definitely a fibre
121  * module, return %PHY_INTERFACE_MODE_1000BASEX mode, otherwise return
122  * %PHY_INTERFACE_MODE_SGMII mode.
123  *
124  * If the encoding is not known, return %PHY_INTERFACE_MODE_NA.
125  */
126 phy_interface_t sfp_parse_interface(struct sfp_bus *bus,
127 				    const struct sfp_eeprom_id *id)
128 {
129 	phy_interface_t iface;
130 
131 	/* Setting the serdes link mode is guesswork: there's no field in
132 	 * the EEPROM which indicates what mode should be used.
133 	 *
134 	 * If the module wants 64b66b, then it must be >= 10G.
135 	 *
136 	 * If it's a gigabit-only fiber module, it probably does not have
137 	 * a PHY, so switch to 802.3z negotiation mode. Otherwise, switch
138 	 * to SGMII mode (which is required to support non-gigabit speeds).
139 	 */
140 	switch (id->base.encoding) {
141 	case SFP_ENCODING_8472_64B66B:
142 		iface = PHY_INTERFACE_MODE_10GKR;
143 		break;
144 
145 	case SFP_ENCODING_8B10B:
146 		if (!id->base.e1000_base_t &&
147 		    !id->base.e100_base_lx &&
148 		    !id->base.e100_base_fx)
149 			iface = PHY_INTERFACE_MODE_1000BASEX;
150 		else
151 			iface = PHY_INTERFACE_MODE_SGMII;
152 		break;
153 
154 	default:
155 		if (id->base.e1000_base_cx) {
156 			iface = PHY_INTERFACE_MODE_1000BASEX;
157 			break;
158 		}
159 
160 		iface = PHY_INTERFACE_MODE_NA;
161 		dev_err(bus->sfp_dev,
162 			"SFP module encoding does not support 8b10b nor 64b66b\n");
163 		break;
164 	}
165 
166 	return iface;
167 }
168 EXPORT_SYMBOL_GPL(sfp_parse_interface);
169 
170 /**
171  * sfp_parse_support() - Parse the eeprom id for supported link modes
172  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
173  * @id: a pointer to the module's &struct sfp_eeprom_id
174  * @support: pointer to an array of unsigned long for the ethtool support mask
175  *
176  * Parse the EEPROM identification information and derive the supported
177  * ethtool link modes for the module.
178  */
179 void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
180 		       unsigned long *support)
181 {
182 	unsigned int br_min, br_nom, br_max;
183 
184 	phylink_set(support, Autoneg);
185 	phylink_set(support, Pause);
186 	phylink_set(support, Asym_Pause);
187 
188 	/* Decode the bitrate information to MBd */
189 	br_min = br_nom = br_max = 0;
190 	if (id->base.br_nominal) {
191 		if (id->base.br_nominal != 255) {
192 			br_nom = id->base.br_nominal * 100;
193 			br_min = br_nom + id->base.br_nominal * id->ext.br_min;
194 			br_max = br_nom + id->base.br_nominal * id->ext.br_max;
195 		} else if (id->ext.br_max) {
196 			br_nom = 250 * id->ext.br_max;
197 			br_max = br_nom + br_nom * id->ext.br_min / 100;
198 			br_min = br_nom - br_nom * id->ext.br_min / 100;
199 		}
200 	}
201 
202 	/* Set ethtool support from the compliance fields. */
203 	if (id->base.e10g_base_sr)
204 		phylink_set(support, 10000baseSR_Full);
205 	if (id->base.e10g_base_lr)
206 		phylink_set(support, 10000baseLR_Full);
207 	if (id->base.e10g_base_lrm)
208 		phylink_set(support, 10000baseLRM_Full);
209 	if (id->base.e10g_base_er)
210 		phylink_set(support, 10000baseER_Full);
211 	if (id->base.e1000_base_sx ||
212 	    id->base.e1000_base_lx ||
213 	    id->base.e1000_base_cx)
214 		phylink_set(support, 1000baseX_Full);
215 	if (id->base.e1000_base_t) {
216 		phylink_set(support, 1000baseT_Half);
217 		phylink_set(support, 1000baseT_Full);
218 	}
219 
220 	/* 1000Base-PX or 1000Base-BX10 */
221 	if ((id->base.e_base_px || id->base.e_base_bx10) &&
222 	    br_min <= 1300 && br_max >= 1200)
223 		phylink_set(support, 1000baseX_Full);
224 
225 	/* For active or passive cables, select the link modes
226 	 * based on the bit rates and the cable compliance bytes.
227 	 */
228 	if ((id->base.sfp_ct_passive || id->base.sfp_ct_active) && br_nom) {
229 		/* This may look odd, but some manufacturers use 12000MBd */
230 		if (br_min <= 12000 && br_max >= 10300)
231 			phylink_set(support, 10000baseCR_Full);
232 		if (br_min <= 3200 && br_max >= 3100)
233 			phylink_set(support, 2500baseX_Full);
234 		if (br_min <= 1300 && br_max >= 1200)
235 			phylink_set(support, 1000baseX_Full);
236 	}
237 	if (id->base.sfp_ct_passive) {
238 		if (id->base.passive.sff8431_app_e)
239 			phylink_set(support, 10000baseCR_Full);
240 	}
241 	if (id->base.sfp_ct_active) {
242 		if (id->base.active.sff8431_app_e ||
243 		    id->base.active.sff8431_lim) {
244 			phylink_set(support, 10000baseCR_Full);
245 		}
246 	}
247 
248 	switch (id->base.extended_cc) {
249 	case 0x00: /* Unspecified */
250 		break;
251 	case 0x02: /* 100Gbase-SR4 or 25Gbase-SR */
252 		phylink_set(support, 100000baseSR4_Full);
253 		phylink_set(support, 25000baseSR_Full);
254 		break;
255 	case 0x03: /* 100Gbase-LR4 or 25Gbase-LR */
256 	case 0x04: /* 100Gbase-ER4 or 25Gbase-ER */
257 		phylink_set(support, 100000baseLR4_ER4_Full);
258 		break;
259 	case 0x0b: /* 100Gbase-CR4 or 25Gbase-CR CA-L */
260 	case 0x0c: /* 25Gbase-CR CA-S */
261 	case 0x0d: /* 25Gbase-CR CA-N */
262 		phylink_set(support, 100000baseCR4_Full);
263 		phylink_set(support, 25000baseCR_Full);
264 		break;
265 	default:
266 		dev_warn(bus->sfp_dev,
267 			 "Unknown/unsupported extended compliance code: 0x%02x\n",
268 			 id->base.extended_cc);
269 		break;
270 	}
271 
272 	/* For fibre channel SFP, derive possible BaseX modes */
273 	if (id->base.fc_speed_100 ||
274 	    id->base.fc_speed_200 ||
275 	    id->base.fc_speed_400) {
276 		if (id->base.br_nominal >= 31)
277 			phylink_set(support, 2500baseX_Full);
278 		if (id->base.br_nominal >= 12)
279 			phylink_set(support, 1000baseX_Full);
280 	}
281 }
282 EXPORT_SYMBOL_GPL(sfp_parse_support);
283 
284 static LIST_HEAD(sfp_buses);
285 static DEFINE_MUTEX(sfp_mutex);
286 
287 static const struct sfp_upstream_ops *sfp_get_upstream_ops(struct sfp_bus *bus)
288 {
289 	return bus->registered ? bus->upstream_ops : NULL;
290 }
291 
292 static struct sfp_bus *sfp_bus_get(struct fwnode_handle *fwnode)
293 {
294 	struct sfp_bus *sfp, *new, *found = NULL;
295 
296 	new = kzalloc(sizeof(*new), GFP_KERNEL);
297 
298 	mutex_lock(&sfp_mutex);
299 
300 	list_for_each_entry(sfp, &sfp_buses, node) {
301 		if (sfp->fwnode == fwnode) {
302 			kref_get(&sfp->kref);
303 			found = sfp;
304 			break;
305 		}
306 	}
307 
308 	if (!found && new) {
309 		kref_init(&new->kref);
310 		new->fwnode = fwnode;
311 		list_add(&new->node, &sfp_buses);
312 		found = new;
313 		new = NULL;
314 	}
315 
316 	mutex_unlock(&sfp_mutex);
317 
318 	kfree(new);
319 
320 	return found;
321 }
322 
323 static void sfp_bus_release(struct kref *kref)
324 {
325 	struct sfp_bus *bus = container_of(kref, struct sfp_bus, kref);
326 
327 	list_del(&bus->node);
328 	mutex_unlock(&sfp_mutex);
329 	kfree(bus);
330 }
331 
332 static void sfp_bus_put(struct sfp_bus *bus)
333 {
334 	kref_put_mutex(&bus->kref, sfp_bus_release, &sfp_mutex);
335 }
336 
337 static int sfp_register_bus(struct sfp_bus *bus)
338 {
339 	const struct sfp_upstream_ops *ops = bus->upstream_ops;
340 	int ret;
341 
342 	if (ops) {
343 		if (ops->link_down)
344 			ops->link_down(bus->upstream);
345 		if (ops->connect_phy && bus->phydev) {
346 			ret = ops->connect_phy(bus->upstream, bus->phydev);
347 			if (ret)
348 				return ret;
349 		}
350 	}
351 	if (bus->started)
352 		bus->socket_ops->start(bus->sfp);
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 
361 	if (bus->registered) {
362 		if (bus->started)
363 			bus->socket_ops->stop(bus->sfp);
364 		if (bus->phydev && ops && ops->disconnect_phy)
365 			ops->disconnect_phy(bus->upstream);
366 	}
367 	bus->registered = false;
368 }
369 
370 /**
371  * sfp_get_module_info() - Get the ethtool_modinfo for a SFP module
372  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
373  * @modinfo: a &struct ethtool_modinfo
374  *
375  * Fill in the type and eeprom_len parameters in @modinfo for a module on
376  * the sfp bus specified by @bus.
377  *
378  * Returns 0 on success or a negative errno number.
379  */
380 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)
381 {
382 	if (!bus->registered)
383 		return -ENOIOCTLCMD;
384 	return bus->socket_ops->module_info(bus->sfp, modinfo);
385 }
386 EXPORT_SYMBOL_GPL(sfp_get_module_info);
387 
388 /**
389  * sfp_get_module_eeprom() - Read the SFP module EEPROM
390  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
391  * @ee: a &struct ethtool_eeprom
392  * @data: buffer to contain the EEPROM data (must be at least @ee->len bytes)
393  *
394  * Read the EEPROM as specified by the supplied @ee. See the documentation
395  * for &struct ethtool_eeprom for the region to be read.
396  *
397  * Returns 0 on success or a negative errno number.
398  */
399 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
400 			  u8 *data)
401 {
402 	if (!bus->registered)
403 		return -ENOIOCTLCMD;
404 	return bus->socket_ops->module_eeprom(bus->sfp, ee, data);
405 }
406 EXPORT_SYMBOL_GPL(sfp_get_module_eeprom);
407 
408 /**
409  * sfp_upstream_start() - Inform the SFP that the network device is up
410  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
411  *
412  * Inform the SFP socket that the network device is now up, so that the
413  * module can be enabled by allowing TX_DISABLE to be deasserted. This
414  * should be called from the network device driver's &struct net_device_ops
415  * ndo_open() method.
416  */
417 void sfp_upstream_start(struct sfp_bus *bus)
418 {
419 	if (bus->registered)
420 		bus->socket_ops->start(bus->sfp);
421 	bus->started = true;
422 }
423 EXPORT_SYMBOL_GPL(sfp_upstream_start);
424 
425 /**
426  * sfp_upstream_stop() - Inform the SFP that the network device is down
427  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
428  *
429  * Inform the SFP socket that the network device is now up, so that the
430  * module can be disabled by asserting TX_DISABLE, disabling the laser
431  * in optical modules. This should be called from the network device
432  * driver's &struct net_device_ops ndo_stop() method.
433  */
434 void sfp_upstream_stop(struct sfp_bus *bus)
435 {
436 	if (bus->registered)
437 		bus->socket_ops->stop(bus->sfp);
438 	bus->started = false;
439 }
440 EXPORT_SYMBOL_GPL(sfp_upstream_stop);
441 
442 /**
443  * sfp_register_upstream() - Register the neighbouring device
444  * @fwnode: firmware node for the SFP bus
445  * @ndev: network device associated with the interface
446  * @upstream: the upstream private data
447  * @ops: the upstream's &struct sfp_upstream_ops
448  *
449  * Register the upstream device (eg, PHY) with the SFP bus. MAC drivers
450  * should use phylink, which will call this function for them. Returns
451  * a pointer to the allocated &struct sfp_bus.
452  *
453  * On error, returns %NULL.
454  */
455 struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode,
456 				      struct net_device *ndev, void *upstream,
457 				      const struct sfp_upstream_ops *ops)
458 {
459 	struct sfp_bus *bus = sfp_bus_get(fwnode);
460 	int ret = 0;
461 
462 	if (bus) {
463 		rtnl_lock();
464 		bus->upstream_ops = ops;
465 		bus->upstream = upstream;
466 		bus->netdev = ndev;
467 
468 		if (bus->sfp)
469 			ret = sfp_register_bus(bus);
470 		rtnl_unlock();
471 	}
472 
473 	if (ret) {
474 		sfp_bus_put(bus);
475 		bus = NULL;
476 	}
477 
478 	return bus;
479 }
480 EXPORT_SYMBOL_GPL(sfp_register_upstream);
481 
482 /**
483  * sfp_unregister_upstream() - Unregister sfp bus
484  * @bus: a pointer to the &struct sfp_bus structure for the sfp module
485  *
486  * Unregister a previously registered upstream connection for the SFP
487  * module. @bus is returned from sfp_register_upstream().
488  */
489 void sfp_unregister_upstream(struct sfp_bus *bus)
490 {
491 	rtnl_lock();
492 	if (bus->sfp)
493 		sfp_unregister_bus(bus);
494 	bus->upstream = NULL;
495 	bus->netdev = NULL;
496 	rtnl_unlock();
497 
498 	sfp_bus_put(bus);
499 }
500 EXPORT_SYMBOL_GPL(sfp_unregister_upstream);
501 
502 /* Socket driver entry points */
503 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev)
504 {
505 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
506 	int ret = 0;
507 
508 	if (ops && ops->connect_phy)
509 		ret = ops->connect_phy(bus->upstream, phydev);
510 
511 	if (ret == 0)
512 		bus->phydev = phydev;
513 
514 	return ret;
515 }
516 EXPORT_SYMBOL_GPL(sfp_add_phy);
517 
518 void sfp_remove_phy(struct sfp_bus *bus)
519 {
520 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
521 
522 	if (ops && ops->disconnect_phy)
523 		ops->disconnect_phy(bus->upstream);
524 	bus->phydev = NULL;
525 }
526 EXPORT_SYMBOL_GPL(sfp_remove_phy);
527 
528 void sfp_link_up(struct sfp_bus *bus)
529 {
530 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
531 
532 	if (ops && ops->link_up)
533 		ops->link_up(bus->upstream);
534 }
535 EXPORT_SYMBOL_GPL(sfp_link_up);
536 
537 void sfp_link_down(struct sfp_bus *bus)
538 {
539 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
540 
541 	if (ops && ops->link_down)
542 		ops->link_down(bus->upstream);
543 }
544 EXPORT_SYMBOL_GPL(sfp_link_down);
545 
546 int sfp_module_insert(struct sfp_bus *bus, const struct sfp_eeprom_id *id)
547 {
548 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
549 	int ret = 0;
550 
551 	if (ops && ops->module_insert)
552 		ret = ops->module_insert(bus->upstream, id);
553 
554 	return ret;
555 }
556 EXPORT_SYMBOL_GPL(sfp_module_insert);
557 
558 void sfp_module_remove(struct sfp_bus *bus)
559 {
560 	const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
561 
562 	if (ops && ops->module_remove)
563 		ops->module_remove(bus->upstream);
564 }
565 EXPORT_SYMBOL_GPL(sfp_module_remove);
566 
567 struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp,
568 				    const struct sfp_socket_ops *ops)
569 {
570 	struct sfp_bus *bus = sfp_bus_get(dev->fwnode);
571 	int ret = 0;
572 
573 	if (bus) {
574 		rtnl_lock();
575 		bus->sfp_dev = dev;
576 		bus->sfp = sfp;
577 		bus->socket_ops = ops;
578 
579 		if (bus->netdev)
580 			ret = sfp_register_bus(bus);
581 		rtnl_unlock();
582 	}
583 
584 	if (ret) {
585 		sfp_bus_put(bus);
586 		bus = NULL;
587 	}
588 
589 	return bus;
590 }
591 EXPORT_SYMBOL_GPL(sfp_register_socket);
592 
593 void sfp_unregister_socket(struct sfp_bus *bus)
594 {
595 	rtnl_lock();
596 	if (bus->netdev)
597 		sfp_unregister_bus(bus);
598 	bus->sfp_dev = NULL;
599 	bus->sfp = NULL;
600 	bus->socket_ops = NULL;
601 	rtnl_unlock();
602 
603 	sfp_bus_put(bus);
604 }
605 EXPORT_SYMBOL_GPL(sfp_unregister_socket);
606