1	// SPDX-License-Identifier: GPL-2.0
2	#include <linux/debugfs.h>
3	#include <linux/delay.h>
4	#include <linux/gpio/consumer.h>
5	#include <linux/hwmon.h>
6	#include <linux/i2c.h>
7	#include <linux/interrupt.h>
8	#include <linux/jiffies.h>
9	#include <linux/mdio/mdio-i2c.h>
10	#include <linux/module.h>
11	#include <linux/mutex.h>
12	#include <linux/of.h>
13	#include <linux/phy.h>
14	#include <linux/platform_device.h>
15	#include <linux/rtnetlink.h>
16	#include <linux/slab.h>
17	#include <linux/workqueue.h>
18
19	#include "sfp.h"
20	#include "swphy.h"
21
22	enum {
23	GPIO_MODDEF0,
24	GPIO_LOS,
25	GPIO_TX_FAULT,
26	GPIO_TX_DISABLE,
27	GPIO_RS0,
28	GPIO_RS1,
29	GPIO_MAX,
30
31	SFP_F_PRESENT = BIT(GPIO_MODDEF0),
32	SFP_F_LOS = BIT(GPIO_LOS),
33	SFP_F_TX_FAULT = BIT(GPIO_TX_FAULT),
34	SFP_F_TX_DISABLE = BIT(GPIO_TX_DISABLE),
35	SFP_F_RS0 = BIT(GPIO_RS0),
36	SFP_F_RS1 = BIT(GPIO_RS1),
37
38	SFP_F_OUTPUTS = SFP_F_TX_DISABLE | SFP_F_RS0 | SFP_F_RS1,
39
40	SFP_E_INSERT = 0,
41	SFP_E_REMOVE,
42	SFP_E_DEV_ATTACH,
43	SFP_E_DEV_DETACH,
44	SFP_E_DEV_DOWN,
45	SFP_E_DEV_UP,
46	SFP_E_TX_FAULT,
47	SFP_E_TX_CLEAR,
48	SFP_E_LOS_HIGH,
49	SFP_E_LOS_LOW,
50	SFP_E_TIMEOUT,
51
52	SFP_MOD_EMPTY = 0,
53	SFP_MOD_ERROR,
54	SFP_MOD_PROBE,
55	SFP_MOD_WAITDEV,
56	SFP_MOD_HPOWER,
57	SFP_MOD_WAITPWR,
58	SFP_MOD_PRESENT,
59
60	SFP_DEV_DETACHED = 0,
61	SFP_DEV_DOWN,
62	SFP_DEV_UP,
63
64	SFP_S_DOWN = 0,
65	SFP_S_FAIL,
66	SFP_S_WAIT,
67	SFP_S_INIT,
68	SFP_S_INIT_PHY,
69	SFP_S_INIT_TX_FAULT,
70	SFP_S_WAIT_LOS,
71	SFP_S_LINK_UP,
72	SFP_S_TX_FAULT,
73	SFP_S_REINIT,
74	SFP_S_TX_DISABLE,
75	};
76
77	static const char * const mod_state_strings[] = {
78	[SFP_MOD_EMPTY] = "empty",
79	[SFP_MOD_ERROR] = "error",
80	[SFP_MOD_PROBE] = "probe",
81	[SFP_MOD_WAITDEV] = "waitdev",
82	[SFP_MOD_HPOWER] = "hpower",
83	[SFP_MOD_WAITPWR] = "waitpwr",
84	[SFP_MOD_PRESENT] = "present",
85	};
86
87	static const char *mod_state_to_str(unsigned short mod_state)
88	{
89	if (mod_state >= ARRAY_SIZE(mod_state_strings))
90	return "Unknown module state";
91	return mod_state_strings[mod_state];
92	}
93
94	static const char * const dev_state_strings[] = {
95	[SFP_DEV_DETACHED] = "detached",
96	[SFP_DEV_DOWN] = "down",
97	[SFP_DEV_UP] = "up",
98	};
99
100	static const char *dev_state_to_str(unsigned short dev_state)
101	{
102	if (dev_state >= ARRAY_SIZE(dev_state_strings))
103	return "Unknown device state";
104	return dev_state_strings[dev_state];
105	}
106
107	static const char * const event_strings[] = {
108	[SFP_E_INSERT] = "insert",
109	[SFP_E_REMOVE] = "remove",
110	[SFP_E_DEV_ATTACH] = "dev_attach",
111	[SFP_E_DEV_DETACH] = "dev_detach",
112	[SFP_E_DEV_DOWN] = "dev_down",
113	[SFP_E_DEV_UP] = "dev_up",
114	[SFP_E_TX_FAULT] = "tx_fault",
115	[SFP_E_TX_CLEAR] = "tx_clear",
116	[SFP_E_LOS_HIGH] = "los_high",
117	[SFP_E_LOS_LOW] = "los_low",
118	[SFP_E_TIMEOUT] = "timeout",
119	};
120
121	static const char *event_to_str(unsigned short event)
122	{
123	if (event >= ARRAY_SIZE(event_strings))
124	return "Unknown event";
125	return event_strings[event];
126	}
127
128	static const char * const sm_state_strings[] = {
129	[SFP_S_DOWN] = "down",
130	[SFP_S_FAIL] = "fail",
131	[SFP_S_WAIT] = "wait",
132	[SFP_S_INIT] = "init",
133	[SFP_S_INIT_PHY] = "init_phy",
134	[SFP_S_INIT_TX_FAULT] = "init_tx_fault",
135	[SFP_S_WAIT_LOS] = "wait_los",
136	[SFP_S_LINK_UP] = "link_up",
137	[SFP_S_TX_FAULT] = "tx_fault",
138	[SFP_S_REINIT] = "reinit",
139	[SFP_S_TX_DISABLE] = "tx_disable",
140	};
141
142	static const char *sm_state_to_str(unsigned short sm_state)
143	{
144	if (sm_state >= ARRAY_SIZE(sm_state_strings))
145	return "Unknown state";
146	return sm_state_strings[sm_state];
147	}
148
149	static const char *gpio_names[] = {
150	"mod-def0",
151	"los",
152	"tx-fault",
153	"tx-disable",
154	"rate-select0",
155	"rate-select1",
156	};
157
158	static const enum gpiod_flags gpio_flags[] = {
159	GPIOD_IN,
160	GPIOD_IN,
161	GPIOD_IN,
162	GPIOD_ASIS,
163	GPIOD_ASIS,
164	GPIOD_ASIS,
165	};
166
167	/* t_start_up (SFF-8431) or t_init (SFF-8472) is the time required for a
168	* non-cooled module to initialise its laser safety circuitry. We wait
169	* an initial T_WAIT period before we check the tx fault to give any PHY
170	* on board (for a copper SFP) time to initialise.
171	*/
172	#define T_WAIT msecs_to_jiffies(50)
173	#define T_START_UP msecs_to_jiffies(300)
174	#define T_START_UP_BAD_GPON msecs_to_jiffies(60000)
175
176	/* t_reset is the time required to assert the TX_DISABLE signal to reset
177	* an indicated TX_FAULT.
178	*/
179	#define T_RESET_US 10
180	#define T_FAULT_RECOVER msecs_to_jiffies(1000)
181
182	/* N_FAULT_INIT is the number of recovery attempts at module initialisation
183	* time. If the TX_FAULT signal is not deasserted after this number of
184	* attempts at clearing it, we decide that the module is faulty.
185	* N_FAULT is the same but after the module has initialised.
186	*/
187	#define N_FAULT_INIT 5
188	#define N_FAULT 5
189
190	/* T_PHY_RETRY is the time interval between attempts to probe the PHY.
191	* R_PHY_RETRY is the number of attempts.
192	*/
193	#define T_PHY_RETRY msecs_to_jiffies(50)
194	#define R_PHY_RETRY 12
195
196	/* SFP module presence detection is poor: the three MOD DEF signals are
197	* the same length on the PCB, which means it's possible for MOD DEF 0 to
198	* connect before the I2C bus on MOD DEF 1/2.
199	*
200	* The SFF-8472 specifies t_serial ("Time from power on until module is
201	* ready for data transmission over the two wire serial bus.") as 300ms.
202	*/
203	#define T_SERIAL msecs_to_jiffies(300)
204	#define T_HPOWER_LEVEL msecs_to_jiffies(300)
205	#define T_PROBE_RETRY_INIT msecs_to_jiffies(100)
206	#define R_PROBE_RETRY_INIT 10
207	#define T_PROBE_RETRY_SLOW msecs_to_jiffies(5000)
208	#define R_PROBE_RETRY_SLOW 12
209
210	/* SFP modules appear to always have their PHY configured for bus address
211	* 0x56 (which with mdio-i2c, translates to a PHY address of 22).
212	* RollBall SFPs access phy via SFP Enhanced Digital Diagnostic Interface
213	* via address 0x51 (mdio-i2c will use RollBall protocol on this address).
214	*/
215	#define SFP_PHY_ADDR 22
216	#define SFP_PHY_ADDR_ROLLBALL 17
217
218	/* SFP_EEPROM_BLOCK_SIZE is the size of data chunk to read the EEPROM
219	* at a time. Some SFP modules and also some Linux I2C drivers do not like
220	* reads longer than 16 bytes.
221	*/
222	#define SFP_EEPROM_BLOCK_SIZE 16
223
224	struct sff_data {
225	unsigned int gpios;
226	bool (*module_supported)(const struct sfp_eeprom_id *id);
227	};
228
229	struct sfp {
230	struct device *dev;
231	struct i2c_adapter *i2c;
232	struct mii_bus *i2c_mii;
233	struct sfp_bus *sfp_bus;
234	enum mdio_i2c_proto mdio_protocol;
235	struct phy_device *mod_phy;
236	const struct sff_data *type;
237	size_t i2c_block_size;
238	u32 max_power_mW;
239
240	unsigned int (*get_state)(struct sfp *);
241	void (*set_state)(struct sfp *, unsigned int);
242	int (*read)(struct sfp *, bool, u8, void *, size_t);
243	int (*write)(struct sfp *, bool, u8, void *, size_t);
244
245	struct gpio_desc *gpio[GPIO_MAX];
246	int gpio_irq[GPIO_MAX];
247
248	bool need_poll;
249
250	/* Access rules:
251	* state_hw_drive: st_mutex held
252	* state_hw_mask: st_mutex held
253	* state_soft_mask: st_mutex held
254	* state: st_mutex held unless reading input bits
255	*/
256	struct mutex st_mutex; /* Protects state */
257	unsigned int state_hw_drive;
258	unsigned int state_hw_mask;
259	unsigned int state_soft_mask;
260	unsigned int state_ignore_mask;
261	unsigned int state;
262
263	struct delayed_work poll;
264	struct delayed_work timeout;
265	struct mutex sm_mutex; /* Protects state machine */
266	unsigned char sm_mod_state;
267	unsigned char sm_mod_tries_init;
268	unsigned char sm_mod_tries;
269	unsigned char sm_dev_state;
270	unsigned short sm_state;
271	unsigned char sm_fault_retries;
272	unsigned char sm_phy_retries;
273
274	struct sfp_eeprom_id id;
275	unsigned int module_power_mW;
276	unsigned int module_t_start_up;
277	unsigned int module_t_wait;
278
279	unsigned int rate_kbd;
280	unsigned int rs_threshold_kbd;
281	unsigned int rs_state_mask;
282
283	bool have_a2;
284
285	const struct sfp_quirk *quirk;
286
287	#if IS_ENABLED(CONFIG_HWMON)
288	struct sfp_diag diag;
289	struct delayed_work hwmon_probe;
290	unsigned int hwmon_tries;
291	struct device *hwmon_dev;
292	char *hwmon_name;
293	#endif
294
295	#if IS_ENABLED(CONFIG_DEBUG_FS)
296	struct dentry *debugfs_dir;
297	#endif
298	};
299
300	static bool sff_module_supported(const struct sfp_eeprom_id *id)
301	{
302	return id->base.phys_id == SFF8024_ID_SFF_8472 &&
303	id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
304	}
305
306	static const struct sff_data sff_data = {
307	.gpios = SFP_F_LOS | SFP_F_TX_FAULT | SFP_F_TX_DISABLE,
308	.module_supported = sff_module_supported,
309	};
310
311	static bool sfp_module_supported(const struct sfp_eeprom_id *id)
312	{
313	if (id->base.phys_id == SFF8024_ID_SFP &&
314	id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP)
315	return true;
316
317	/* SFP GPON module Ubiquiti U-Fiber Instant has in its EEPROM stored
318	* phys id SFF instead of SFP. Therefore mark this module explicitly
319	* as supported based on vendor name and pn match.
320	*/
321	if (id->base.phys_id == SFF8024_ID_SFF_8472 &&
322	id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP &&
323	!memcmp(p: id->base.vendor_name, q: "UBNT ", size: 16) &&
324	!memcmp(p: id->base.vendor_pn, q: "UF-INSTANT ", size: 16))
325	return true;
326
327	return false;
328	}
329
330	static const struct sff_data sfp_data = {
331	.gpios = SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT |
332	SFP_F_TX_DISABLE | SFP_F_RS0 | SFP_F_RS1,
333	.module_supported = sfp_module_supported,
334	};
335
336	static const struct of_device_id sfp_of_match[] = {
337	{ .compatible = "sff,sff", .data = &sff_data, },
338	{ .compatible = "sff,sfp", .data = &sfp_data, },
339	{ },
340	};
341	MODULE_DEVICE_TABLE(of, sfp_of_match);
342
343	static void sfp_fixup_long_startup(struct sfp *sfp)
344	{
345	sfp->module_t_start_up = T_START_UP_BAD_GPON;
346	}
347
348	static void sfp_fixup_ignore_los(struct sfp *sfp)
349	{
350	/* This forces LOS to zero, so we ignore transitions */
351	sfp->state_ignore_mask |= SFP_F_LOS;
352	/* Make sure that LOS options are clear */
353	sfp->id.ext.options &= ~cpu_to_be16(SFP_OPTIONS_LOS_INVERTED |
354	SFP_OPTIONS_LOS_NORMAL);
355	}
356
357	static void sfp_fixup_ignore_tx_fault(struct sfp *sfp)
358	{
359	sfp->state_ignore_mask |= SFP_F_TX_FAULT;
360	}
361
362	static void sfp_fixup_nokia(struct sfp *sfp)
363	{
364	sfp_fixup_long_startup(sfp);
365	sfp_fixup_ignore_los(sfp);
366	}
367
368	// For 10GBASE-T short-reach modules
369	static void sfp_fixup_10gbaset_30m(struct sfp *sfp)
370	{
371	sfp->id.base.connector = SFF8024_CONNECTOR_RJ45;
372	sfp->id.base.extended_cc = SFF8024_ECC_10GBASE_T_SR;
373	}
374
375	static void sfp_fixup_rollball_proto(struct sfp *sfp, unsigned int secs)
376	{
377	sfp->mdio_protocol = MDIO_I2C_ROLLBALL;
378	sfp->module_t_wait = msecs_to_jiffies(m: secs * 1000);
379	}
380
381	static void sfp_fixup_fs_10gt(struct sfp *sfp)
382	{
383	sfp_fixup_10gbaset_30m(sfp);
384
385	// These SFPs need 4 seconds before the PHY can be accessed
386	sfp_fixup_rollball_proto(sfp, secs: 4);
387	}
388
389	static void sfp_fixup_halny_gsfp(struct sfp *sfp)
390	{
391	/* Ignore the TX_FAULT and LOS signals on this module.
392	* these are possibly used for other purposes on this
393	* module, e.g. a serial port.
394	*/
395	sfp->state_hw_mask &= ~(SFP_F_TX_FAULT | SFP_F_LOS);
396	}
397
398	static void sfp_fixup_rollball(struct sfp *sfp)
399	{
400	// Rollball SFPs need 25 seconds before the PHY can be accessed
401	sfp_fixup_rollball_proto(sfp, secs: 25);
402	}
403
404	static void sfp_fixup_rollball_cc(struct sfp *sfp)
405	{
406	sfp_fixup_rollball(sfp);
407
408	/* Some RollBall SFPs may have wrong (zero) extended compliance code
409	* burned in EEPROM. For PHY probing we need the correct one.
410	*/
411	sfp->id.base.extended_cc = SFF8024_ECC_10GBASE_T_SFI;
412	}
413
414	static void sfp_quirk_2500basex(const struct sfp_eeprom_id *id,
415	unsigned long *modes,
416	unsigned long *interfaces)
417	{
418	linkmode_set_bit(nr: ETHTOOL_LINK_MODE_2500baseX_Full_BIT, addr: modes);
419	__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
420	}
421
422	static void sfp_quirk_disable_autoneg(const struct sfp_eeprom_id *id,
423	unsigned long *modes,
424	unsigned long *interfaces)
425	{
426	linkmode_clear_bit(nr: ETHTOOL_LINK_MODE_Autoneg_BIT, addr: modes);
427	}
428
429	static void sfp_quirk_oem_2_5g(const struct sfp_eeprom_id *id,
430	unsigned long *modes,
431	unsigned long *interfaces)
432	{
433	/* Copper 2.5G SFP */
434	linkmode_set_bit(nr: ETHTOOL_LINK_MODE_2500baseT_Full_BIT, addr: modes);
435	__set_bit(PHY_INTERFACE_MODE_2500BASEX, interfaces);
436	sfp_quirk_disable_autoneg(id, modes, interfaces);
437	}
438
439	static void sfp_quirk_ubnt_uf_instant(const struct sfp_eeprom_id *id,
440	unsigned long *modes,
441	unsigned long *interfaces)
442	{
443	/* Ubiquiti U-Fiber Instant module claims that support all transceiver
444	* types including 10G Ethernet which is not truth. So clear all claimed
445	* modes and set only one mode which module supports: 1000baseX_Full.
446	*/
447	linkmode_zero(dst: modes);
448	linkmode_set_bit(nr: ETHTOOL_LINK_MODE_1000baseX_Full_BIT, addr: modes);
449	}
450
451	#define SFP_QUIRK(_v, _p, _m, _f) \
452	{ .vendor = _v, .part = _p, .modes = _m, .fixup = _f, }
453	#define SFP_QUIRK_M(_v, _p, _m) SFP_QUIRK(_v, _p, _m, NULL)
454	#define SFP_QUIRK_F(_v, _p, _f) SFP_QUIRK(_v, _p, NULL, _f)
455
456	static const struct sfp_quirk sfp_quirks[] = {
457	// Alcatel Lucent G-010S-P can operate at 2500base-X, but incorrectly
458	// report 2500MBd NRZ in their EEPROM
459	SFP_QUIRK_M("ALCATELLUCENT", "G010SP", sfp_quirk_2500basex),
460
461	// Alcatel Lucent G-010S-A can operate at 2500base-X, but report 3.2GBd
462	// NRZ in their EEPROM
463	SFP_QUIRK("ALCATELLUCENT", "3FE46541AA", sfp_quirk_2500basex,
464	sfp_fixup_nokia),
465
466	// Fiberstore SFP-10G-T doesn't identify as copper, and uses the
467	// Rollball protocol to talk to the PHY.
468	SFP_QUIRK_F("FS", "SFP-10G-T", sfp_fixup_fs_10gt),
469
470	// Fiberstore GPON-ONU-34-20BI can operate at 2500base-X, but report 1.2GBd
471	// NRZ in their EEPROM
472	SFP_QUIRK("FS", "GPON-ONU-34-20BI", sfp_quirk_2500basex,
473	sfp_fixup_ignore_tx_fault),
474
475	SFP_QUIRK_F("HALNy", "HL-GSFP", sfp_fixup_halny_gsfp),
476
477	// HG MXPD-483II-F 2.5G supports 2500Base-X, but incorrectly reports
478	// 2600MBd in their EERPOM
479	SFP_QUIRK_M("HG GENUINE", "MXPD-483II", sfp_quirk_2500basex),
480
481	// Huawei MA5671A can operate at 2500base-X, but report 1.2GBd NRZ in
482	// their EEPROM
483	SFP_QUIRK("HUAWEI", "MA5671A", sfp_quirk_2500basex,
484	sfp_fixup_ignore_tx_fault),
485
486	// FS 2.5G Base-T
487	SFP_QUIRK_M("FS", "SFP-2.5G-T", sfp_quirk_oem_2_5g),
488
489	// Lantech 8330-262D-E can operate at 2500base-X, but incorrectly report
490	// 2500MBd NRZ in their EEPROM
491	SFP_QUIRK_M("Lantech", "8330-262D-E", sfp_quirk_2500basex),
492
493	SFP_QUIRK_M("UBNT", "UF-INSTANT", sfp_quirk_ubnt_uf_instant),
494
495	// Walsun HXSX-ATR[CI]-1 don't identify as copper, and use the
496	// Rollball protocol to talk to the PHY.
497	SFP_QUIRK_F("Walsun", "HXSX-ATRC-1", sfp_fixup_fs_10gt),
498	SFP_QUIRK_F("Walsun", "HXSX-ATRI-1", sfp_fixup_fs_10gt),
499
500	SFP_QUIRK_F("OEM", "SFP-10G-T", sfp_fixup_rollball_cc),
501	SFP_QUIRK_M("OEM", "SFP-2.5G-T", sfp_quirk_oem_2_5g),
502	SFP_QUIRK_F("OEM", "RTSFP-10", sfp_fixup_rollball_cc),
503	SFP_QUIRK_F("OEM", "RTSFP-10G", sfp_fixup_rollball_cc),
504	SFP_QUIRK_F("Turris", "RTSFP-10", sfp_fixup_rollball),
505	SFP_QUIRK_F("Turris", "RTSFP-10G", sfp_fixup_rollball),
506	};
507
508	static size_t sfp_strlen(const char *str, size_t maxlen)
509	{
510	size_t size, i;
511
512	/* Trailing characters should be filled with space chars, but
513	* some manufacturers can't read SFF-8472 and use NUL.
514	*/
515	for (i = 0, size = 0; i < maxlen; i++)
516	if (str[i] != ' ' && str[i] != '\0')
517	size = i + 1;
518
519	return size;
520	}
521
522	static bool sfp_match(const char *qs, const char *str, size_t len)
523	{
524	if (!qs)
525	return true;
526	if (strlen(qs) != len)
527	return false;
528	return !strncmp(qs, str, len);
529	}
530
531	static const struct sfp_quirk *sfp_lookup_quirk(const struct sfp_eeprom_id *id)
532	{
533	const struct sfp_quirk *q;
534	unsigned int i;
535	size_t vs, ps;
536
537	vs = sfp_strlen(str: id->base.vendor_name, ARRAY_SIZE(id->base.vendor_name));
538	ps = sfp_strlen(str: id->base.vendor_pn, ARRAY_SIZE(id->base.vendor_pn));
539
540	for (i = 0, q = sfp_quirks; i < ARRAY_SIZE(sfp_quirks); i++, q++)
541	if (sfp_match(qs: q->vendor, str: id->base.vendor_name, len: vs) &&
542	sfp_match(qs: q->part, str: id->base.vendor_pn, len: ps))
543	return q;
544
545	return NULL;
546	}
547
548	static unsigned long poll_jiffies;
549
550	static unsigned int sfp_gpio_get_state(struct sfp *sfp)
551	{
552	unsigned int i, state, v;
553
554	for (i = state = 0; i < GPIO_MAX; i++) {
555	if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
556	continue;
557
558	v = gpiod_get_value_cansleep(desc: sfp->gpio[i]);
559	if (v)
560	state |= BIT(i);
561	}
562
563	return state;
564	}
565
566	static unsigned int sff_gpio_get_state(struct sfp *sfp)
567	{
568	return sfp_gpio_get_state(sfp) | SFP_F_PRESENT;
569	}
570
571	static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state)
572	{
573	unsigned int drive;
574
575	if (state & SFP_F_PRESENT)
576	/* If the module is present, drive the requested signals */
577	drive = sfp->state_hw_drive;
578	else
579	/* Otherwise, let them float to the pull-ups */
580	drive = 0;
581
582	if (sfp->gpio[GPIO_TX_DISABLE]) {
583	if (drive & SFP_F_TX_DISABLE)
584	gpiod_direction_output(desc: sfp->gpio[GPIO_TX_DISABLE],
585	value: state & SFP_F_TX_DISABLE);
586	else
587	gpiod_direction_input(desc: sfp->gpio[GPIO_TX_DISABLE]);
588	}
589
590	if (sfp->gpio[GPIO_RS0]) {
591	if (drive & SFP_F_RS0)
592	gpiod_direction_output(desc: sfp->gpio[GPIO_RS0],
593	value: state & SFP_F_RS0);
594	else
595	gpiod_direction_input(desc: sfp->gpio[GPIO_RS0]);
596	}
597
598	if (sfp->gpio[GPIO_RS1]) {
599	if (drive & SFP_F_RS1)
600	gpiod_direction_output(desc: sfp->gpio[GPIO_RS1],
601	value: state & SFP_F_RS1);
602	else
603	gpiod_direction_input(desc: sfp->gpio[GPIO_RS1]);
604	}
605	}
606
607	static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
608	size_t len)
609	{
610	struct i2c_msg msgs[2];
611	u8 bus_addr = a2 ? 0x51 : 0x50;
612	size_t block_size = sfp->i2c_block_size;
613	size_t this_len;
614	int ret;
615
616	msgs[0].addr = bus_addr;
617	msgs[0].flags = 0;
618	msgs[0].len = 1;
619	msgs[0].buf = &dev_addr;
620	msgs[1].addr = bus_addr;
621	msgs[1].flags = I2C_M_RD;
622	msgs[1].len = len;
623	msgs[1].buf = buf;
624
625	while (len) {
626	this_len = len;
627	if (this_len > block_size)
628	this_len = block_size;
629
630	msgs[1].len = this_len;
631
632	ret = i2c_transfer(adap: sfp->i2c, msgs, ARRAY_SIZE(msgs));
633	if (ret < 0)
634	return ret;
635
636	if (ret != ARRAY_SIZE(msgs))
637	break;
638
639	msgs[1].buf += this_len;
640	dev_addr += this_len;
641	len -= this_len;
642	}
643
644	return msgs[1].buf - (u8 *)buf;
645	}
646
647	static int sfp_i2c_write(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
648	size_t len)
649	{
650	struct i2c_msg msgs[1];
651	u8 bus_addr = a2 ? 0x51 : 0x50;
652	int ret;
653
654	msgs[0].addr = bus_addr;
655	msgs[0].flags = 0;
656	msgs[0].len = 1 + len;
657	msgs[0].buf = kmalloc(size: 1 + len, GFP_KERNEL);
658	if (!msgs[0].buf)
659	return -ENOMEM;
660
661	msgs[0].buf[0] = dev_addr;
662	memcpy(&msgs[0].buf[1], buf, len);
663
664	ret = i2c_transfer(adap: sfp->i2c, msgs, ARRAY_SIZE(msgs));
665
666	kfree(objp: msgs[0].buf);
667
668	if (ret < 0)
669	return ret;
670
671	return ret == ARRAY_SIZE(msgs) ? len : 0;
672	}
673
674	static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c)
675	{
676	if (!i2c_check_functionality(adap: i2c, I2C_FUNC_I2C))
677	return -EINVAL;
678
679	sfp->i2c = i2c;
680	sfp->read = sfp_i2c_read;
681	sfp->write = sfp_i2c_write;
682
683	return 0;
684	}
685
686	static int sfp_i2c_mdiobus_create(struct sfp *sfp)
687	{
688	struct mii_bus *i2c_mii;
689	int ret;
690
691	i2c_mii = mdio_i2c_alloc(parent: sfp->dev, i2c: sfp->i2c, protocol: sfp->mdio_protocol);
692	if (IS_ERR(ptr: i2c_mii))
693	return PTR_ERR(ptr: i2c_mii);
694
695	i2c_mii->name = "SFP I2C Bus";
696	i2c_mii->phy_mask = ~0;
697
698	ret = mdiobus_register(i2c_mii);
699	if (ret < 0) {
700	mdiobus_free(bus: i2c_mii);
701	return ret;
702	}
703
704	sfp->i2c_mii = i2c_mii;
705
706	return 0;
707	}
708
709	static void sfp_i2c_mdiobus_destroy(struct sfp *sfp)
710	{
711	mdiobus_unregister(bus: sfp->i2c_mii);
712	sfp->i2c_mii = NULL;
713	}
714
715	/* Interface */
716	static int sfp_read(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
717	{
718	return sfp->read(sfp, a2, addr, buf, len);
719	}
720
721	static int sfp_write(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
722	{
723	return sfp->write(sfp, a2, addr, buf, len);
724	}
725
726	static int sfp_modify_u8(struct sfp *sfp, bool a2, u8 addr, u8 mask, u8 val)
727	{
728	int ret;
729	u8 old, v;
730
731	ret = sfp_read(sfp, a2, addr, buf: &old, len: sizeof(old));
732	if (ret != sizeof(old))
733	return ret;
734
735	v = (old & ~mask) | (val & mask);
736	if (v == old)
737	return sizeof(v);
738
739	return sfp_write(sfp, a2, addr, buf: &v, len: sizeof(v));
740	}
741
742	static unsigned int sfp_soft_get_state(struct sfp *sfp)
743	{
744	unsigned int state = 0;
745	u8 status;
746	int ret;
747
748	ret = sfp_read(sfp, a2: true, addr: SFP_STATUS, buf: &status, len: sizeof(status));
749	if (ret == sizeof(status)) {
750	if (status & SFP_STATUS_RX_LOS)
751	state |= SFP_F_LOS;
752	if (status & SFP_STATUS_TX_FAULT)
753	state |= SFP_F_TX_FAULT;
754	} else {
755	dev_err_ratelimited(sfp->dev,
756	"failed to read SFP soft status: %pe\n",
757	ERR_PTR(ret));
758	/* Preserve the current state */
759	state = sfp->state;
760	}
761
762	return state & sfp->state_soft_mask;
763	}
764
765	static void sfp_soft_set_state(struct sfp *sfp, unsigned int state,
766	unsigned int soft)
767	{
768	u8 mask = 0;
769	u8 val = 0;
770
771	if (soft & SFP_F_TX_DISABLE)
772	mask |= SFP_STATUS_TX_DISABLE_FORCE;
773	if (state & SFP_F_TX_DISABLE)
774	val |= SFP_STATUS_TX_DISABLE_FORCE;
775
776	if (soft & SFP_F_RS0)
777	mask |= SFP_STATUS_RS0_SELECT;
778	if (state & SFP_F_RS0)
779	val |= SFP_STATUS_RS0_SELECT;
780
781	if (mask)
782	sfp_modify_u8(sfp, a2: true, addr: SFP_STATUS, mask, val);
783
784	val = mask = 0;
785	if (soft & SFP_F_RS1)
786	mask |= SFP_EXT_STATUS_RS1_SELECT;
787	if (state & SFP_F_RS1)
788	val |= SFP_EXT_STATUS_RS1_SELECT;
789
790	if (mask)
791	sfp_modify_u8(sfp, a2: true, addr: SFP_EXT_STATUS, mask, val);
792	}
793
794	static void sfp_soft_start_poll(struct sfp *sfp)
795	{
796	const struct sfp_eeprom_id *id = &sfp->id;
797	unsigned int mask = 0;
798
799	if (id->ext.enhopts & SFP_ENHOPTS_SOFT_TX_DISABLE)
800	mask |= SFP_F_TX_DISABLE;
801	if (id->ext.enhopts & SFP_ENHOPTS_SOFT_TX_FAULT)
802	mask |= SFP_F_TX_FAULT;
803	if (id->ext.enhopts & SFP_ENHOPTS_SOFT_RX_LOS)
804	mask |= SFP_F_LOS;
805	if (id->ext.enhopts & SFP_ENHOPTS_SOFT_RATE_SELECT)
806	mask |= sfp->rs_state_mask;
807
808	mutex_lock(&sfp->st_mutex);
809	// Poll the soft state for hardware pins we want to ignore
810	sfp->state_soft_mask = ~sfp->state_hw_mask & ~sfp->state_ignore_mask &
811	mask;
812
813	if (sfp->state_soft_mask & (SFP_F_LOS | SFP_F_TX_FAULT) &&
814	!sfp->need_poll)
815	mod_delayed_work(wq: system_wq, dwork: &sfp->poll, delay: poll_jiffies);
816	mutex_unlock(lock: &sfp->st_mutex);
817	}
818
819	static void sfp_soft_stop_poll(struct sfp *sfp)
820	{
821	mutex_lock(&sfp->st_mutex);
822	sfp->state_soft_mask = 0;
823	mutex_unlock(lock: &sfp->st_mutex);
824	}
825
826	/* sfp_get_state() - must be called with st_mutex held, or in the
827	* initialisation path.
828	*/
829	static unsigned int sfp_get_state(struct sfp *sfp)
830	{
831	unsigned int soft = sfp->state_soft_mask & (SFP_F_LOS | SFP_F_TX_FAULT);
832	unsigned int state;
833
834	state = sfp->get_state(sfp) & sfp->state_hw_mask;
835	if (state & SFP_F_PRESENT && soft)
836	state |= sfp_soft_get_state(sfp);
837
838	return state;
839	}
840
841	/* sfp_set_state() - must be called with st_mutex held, or in the
842	* initialisation path.
843	*/
844	static void sfp_set_state(struct sfp *sfp, unsigned int state)
845	{
846	unsigned int soft;
847
848	sfp->set_state(sfp, state);
849
850	soft = sfp->state_soft_mask & SFP_F_OUTPUTS;
851	if (state & SFP_F_PRESENT && soft)
852	sfp_soft_set_state(sfp, state, soft);
853	}
854
855	static void sfp_mod_state(struct sfp *sfp, unsigned int mask, unsigned int set)
856	{
857	mutex_lock(&sfp->st_mutex);
858	sfp->state = (sfp->state & ~mask) | set;
859	sfp_set_state(sfp, state: sfp->state);
860	mutex_unlock(lock: &sfp->st_mutex);
861	}
862
863	static unsigned int sfp_check(void *buf, size_t len)
864	{
865	u8 *p, check;
866
867	for (p = buf, check = 0; len; p++, len--)
868	check += *p;
869
870	return check;
871	}
872
873	/* hwmon */
874	#if IS_ENABLED(CONFIG_HWMON)
875	static umode_t sfp_hwmon_is_visible(const void *data,
876	enum hwmon_sensor_types type,
877	u32 attr, int channel)
878	{
879	const struct sfp *sfp = data;
880
881	switch (type) {
882	case hwmon_temp:
883	switch (attr) {
884	case hwmon_temp_min_alarm:
885	case hwmon_temp_max_alarm:
886	case hwmon_temp_lcrit_alarm:
887	case hwmon_temp_crit_alarm:
888	case hwmon_temp_min:
889	case hwmon_temp_max:
890	case hwmon_temp_lcrit:
891	case hwmon_temp_crit:
892	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
893	return 0;
894	fallthrough;
895	case hwmon_temp_input:
896	case hwmon_temp_label:
897	return 0444;
898	default:
899	return 0;
900	}
901	case hwmon_in:
902	switch (attr) {
903	case hwmon_in_min_alarm:
904	case hwmon_in_max_alarm:
905	case hwmon_in_lcrit_alarm:
906	case hwmon_in_crit_alarm:
907	case hwmon_in_min:
908	case hwmon_in_max:
909	case hwmon_in_lcrit:
910	case hwmon_in_crit:
911	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
912	return 0;
913	fallthrough;
914	case hwmon_in_input:
915	case hwmon_in_label:
916	return 0444;
917	default:
918	return 0;
919	}
920	case hwmon_curr:
921	switch (attr) {
922	case hwmon_curr_min_alarm:
923	case hwmon_curr_max_alarm:
924	case hwmon_curr_lcrit_alarm:
925	case hwmon_curr_crit_alarm:
926	case hwmon_curr_min:
927	case hwmon_curr_max:
928	case hwmon_curr_lcrit:
929	case hwmon_curr_crit:
930	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
931	return 0;
932	fallthrough;
933	case hwmon_curr_input:
934	case hwmon_curr_label:
935	return 0444;
936	default:
937	return 0;
938	}
939	case hwmon_power:
940	/* External calibration of receive power requires
941	* floating point arithmetic. Doing that in the kernel
942	* is not easy, so just skip it. If the module does
943	* not require external calibration, we can however
944	* show receiver power, since FP is then not needed.
945	*/
946	if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL &&
947	channel == 1)
948	return 0;
949	switch (attr) {
950	case hwmon_power_min_alarm:
951	case hwmon_power_max_alarm:
952	case hwmon_power_lcrit_alarm:
953	case hwmon_power_crit_alarm:
954	case hwmon_power_min:
955	case hwmon_power_max:
956	case hwmon_power_lcrit:
957	case hwmon_power_crit:
958	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
959	return 0;
960	fallthrough;
961	case hwmon_power_input:
962	case hwmon_power_label:
963	return 0444;
964	default:
965	return 0;
966	}
967	default:
968	return 0;
969	}
970	}
971
972	static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value)
973	{
974	__be16 val;
975	int err;
976
977	err = sfp_read(sfp, a2: true, addr: reg, buf: &val, len: sizeof(val));
978	if (err < 0)
979	return err;
980
981	*value = be16_to_cpu(val);
982
983	return 0;
984	}
985
986	static void sfp_hwmon_to_rx_power(long *value)
987	{
988	*value = DIV_ROUND_CLOSEST(*value, 10);
989	}
990
991	static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset,
992	long *value)
993	{
994	if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL)
995	*value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset;
996	}
997
998	static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value)
999	{
1000	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope),
1001	be16_to_cpu(sfp->diag.cal_t_offset), value);
1002
1003	if (*value >= 0x8000)
1004	*value -= 0x10000;
1005
1006	*value = DIV_ROUND_CLOSEST(*value * 1000, 256);
1007	}
1008
1009	static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value)
1010	{
1011	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope),
1012	be16_to_cpu(sfp->diag.cal_v_offset), value);
1013
1014	*value = DIV_ROUND_CLOSEST(*value, 10);
1015	}
1016
1017	static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value)
1018	{
1019	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope),
1020	be16_to_cpu(sfp->diag.cal_txi_offset), value);
1021
1022	*value = DIV_ROUND_CLOSEST(*value, 500);
1023	}
1024
1025	static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value)
1026	{
1027	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope),
1028	be16_to_cpu(sfp->diag.cal_txpwr_offset), value);
1029
1030	*value = DIV_ROUND_CLOSEST(*value, 10);
1031	}
1032
1033	static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value)
1034	{
1035	int err;
1036
1037	err = sfp_hwmon_read_sensor(sfp, reg, value);
1038	if (err < 0)
1039	return err;
1040
1041	sfp_hwmon_calibrate_temp(sfp, value);
1042
1043	return 0;
1044	}
1045
1046	static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value)
1047	{
1048	int err;
1049
1050	err = sfp_hwmon_read_sensor(sfp, reg, value);
1051	if (err < 0)
1052	return err;
1053
1054	sfp_hwmon_calibrate_vcc(sfp, value);
1055
1056	return 0;
1057	}
1058
1059	static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value)
1060	{
1061	int err;
1062
1063	err = sfp_hwmon_read_sensor(sfp, reg, value);
1064	if (err < 0)
1065	return err;
1066
1067	sfp_hwmon_calibrate_bias(sfp, value);
1068
1069	return 0;
1070	}
1071
1072	static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value)
1073	{
1074	int err;
1075
1076	err = sfp_hwmon_read_sensor(sfp, reg, value);
1077	if (err < 0)
1078	return err;
1079
1080	sfp_hwmon_calibrate_tx_power(sfp, value);
1081
1082	return 0;
1083	}
1084
1085	static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value)
1086	{
1087	int err;
1088
1089	err = sfp_hwmon_read_sensor(sfp, reg, value);
1090	if (err < 0)
1091	return err;
1092
1093	sfp_hwmon_to_rx_power(value);
1094
1095	return 0;
1096	}
1097
1098	static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value)
1099	{
1100	u8 status;
1101	int err;
1102
1103	switch (attr) {
1104	case hwmon_temp_input:
1105	return sfp_hwmon_read_temp(sfp, reg: SFP_TEMP, value);
1106
1107	case hwmon_temp_lcrit:
1108	*value = be16_to_cpu(sfp->diag.temp_low_alarm);
1109	sfp_hwmon_calibrate_temp(sfp, value);
1110	return 0;
1111
1112	case hwmon_temp_min:
1113	*value = be16_to_cpu(sfp->diag.temp_low_warn);
1114	sfp_hwmon_calibrate_temp(sfp, value);
1115	return 0;
1116	case hwmon_temp_max:
1117	*value = be16_to_cpu(sfp->diag.temp_high_warn);
1118	sfp_hwmon_calibrate_temp(sfp, value);
1119	return 0;
1120
1121	case hwmon_temp_crit:
1122	*value = be16_to_cpu(sfp->diag.temp_high_alarm);
1123	sfp_hwmon_calibrate_temp(sfp, value);
1124	return 0;
1125
1126	case hwmon_temp_lcrit_alarm:
1127	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1128	if (err < 0)
1129	return err;
1130
1131	*value = !!(status & SFP_ALARM0_TEMP_LOW);
1132	return 0;
1133
1134	case hwmon_temp_min_alarm:
1135	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1136	if (err < 0)
1137	return err;
1138
1139	*value = !!(status & SFP_WARN0_TEMP_LOW);
1140	return 0;
1141
1142	case hwmon_temp_max_alarm:
1143	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1144	if (err < 0)
1145	return err;
1146
1147	*value = !!(status & SFP_WARN0_TEMP_HIGH);
1148	return 0;
1149
1150	case hwmon_temp_crit_alarm:
1151	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1152	if (err < 0)
1153	return err;
1154
1155	*value = !!(status & SFP_ALARM0_TEMP_HIGH);
1156	return 0;
1157	default:
1158	return -EOPNOTSUPP;
1159	}
1160
1161	return -EOPNOTSUPP;
1162	}
1163
1164	static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value)
1165	{
1166	u8 status;
1167	int err;
1168
1169	switch (attr) {
1170	case hwmon_in_input:
1171	return sfp_hwmon_read_vcc(sfp, reg: SFP_VCC, value);
1172
1173	case hwmon_in_lcrit:
1174	*value = be16_to_cpu(sfp->diag.volt_low_alarm);
1175	sfp_hwmon_calibrate_vcc(sfp, value);
1176	return 0;
1177
1178	case hwmon_in_min:
1179	*value = be16_to_cpu(sfp->diag.volt_low_warn);
1180	sfp_hwmon_calibrate_vcc(sfp, value);
1181	return 0;
1182
1183	case hwmon_in_max:
1184	*value = be16_to_cpu(sfp->diag.volt_high_warn);
1185	sfp_hwmon_calibrate_vcc(sfp, value);
1186	return 0;
1187
1188	case hwmon_in_crit:
1189	*value = be16_to_cpu(sfp->diag.volt_high_alarm);
1190	sfp_hwmon_calibrate_vcc(sfp, value);
1191	return 0;
1192
1193	case hwmon_in_lcrit_alarm:
1194	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1195	if (err < 0)
1196	return err;
1197
1198	*value = !!(status & SFP_ALARM0_VCC_LOW);
1199	return 0;
1200
1201	case hwmon_in_min_alarm:
1202	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1203	if (err < 0)
1204	return err;
1205
1206	*value = !!(status & SFP_WARN0_VCC_LOW);
1207	return 0;
1208
1209	case hwmon_in_max_alarm:
1210	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1211	if (err < 0)
1212	return err;
1213
1214	*value = !!(status & SFP_WARN0_VCC_HIGH);
1215	return 0;
1216
1217	case hwmon_in_crit_alarm:
1218	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1219	if (err < 0)
1220	return err;
1221
1222	*value = !!(status & SFP_ALARM0_VCC_HIGH);
1223	return 0;
1224	default:
1225	return -EOPNOTSUPP;
1226	}
1227
1228	return -EOPNOTSUPP;
1229	}
1230
1231	static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value)
1232	{
1233	u8 status;
1234	int err;
1235
1236	switch (attr) {
1237	case hwmon_curr_input:
1238	return sfp_hwmon_read_bias(sfp, reg: SFP_TX_BIAS, value);
1239
1240	case hwmon_curr_lcrit:
1241	*value = be16_to_cpu(sfp->diag.bias_low_alarm);
1242	sfp_hwmon_calibrate_bias(sfp, value);
1243	return 0;
1244
1245	case hwmon_curr_min:
1246	*value = be16_to_cpu(sfp->diag.bias_low_warn);
1247	sfp_hwmon_calibrate_bias(sfp, value);
1248	return 0;
1249
1250	case hwmon_curr_max:
1251	*value = be16_to_cpu(sfp->diag.bias_high_warn);
1252	sfp_hwmon_calibrate_bias(sfp, value);
1253	return 0;
1254
1255	case hwmon_curr_crit:
1256	*value = be16_to_cpu(sfp->diag.bias_high_alarm);
1257	sfp_hwmon_calibrate_bias(sfp, value);
1258	return 0;
1259
1260	case hwmon_curr_lcrit_alarm:
1261	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1262	if (err < 0)
1263	return err;
1264
1265	*value = !!(status & SFP_ALARM0_TX_BIAS_LOW);
1266	return 0;
1267
1268	case hwmon_curr_min_alarm:
1269	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1270	if (err < 0)
1271	return err;
1272
1273	*value = !!(status & SFP_WARN0_TX_BIAS_LOW);
1274	return 0;
1275
1276	case hwmon_curr_max_alarm:
1277	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1278	if (err < 0)
1279	return err;
1280
1281	*value = !!(status & SFP_WARN0_TX_BIAS_HIGH);
1282	return 0;
1283
1284	case hwmon_curr_crit_alarm:
1285	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1286	if (err < 0)
1287	return err;
1288
1289	*value = !!(status & SFP_ALARM0_TX_BIAS_HIGH);
1290	return 0;
1291	default:
1292	return -EOPNOTSUPP;
1293	}
1294
1295	return -EOPNOTSUPP;
1296	}
1297
1298	static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value)
1299	{
1300	u8 status;
1301	int err;
1302
1303	switch (attr) {
1304	case hwmon_power_input:
1305	return sfp_hwmon_read_tx_power(sfp, reg: SFP_TX_POWER, value);
1306
1307	case hwmon_power_lcrit:
1308	*value = be16_to_cpu(sfp->diag.txpwr_low_alarm);
1309	sfp_hwmon_calibrate_tx_power(sfp, value);
1310	return 0;
1311
1312	case hwmon_power_min:
1313	*value = be16_to_cpu(sfp->diag.txpwr_low_warn);
1314	sfp_hwmon_calibrate_tx_power(sfp, value);
1315	return 0;
1316
1317	case hwmon_power_max:
1318	*value = be16_to_cpu(sfp->diag.txpwr_high_warn);
1319	sfp_hwmon_calibrate_tx_power(sfp, value);
1320	return 0;
1321
1322	case hwmon_power_crit:
1323	*value = be16_to_cpu(sfp->diag.txpwr_high_alarm);
1324	sfp_hwmon_calibrate_tx_power(sfp, value);
1325	return 0;
1326
1327	case hwmon_power_lcrit_alarm:
1328	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1329	if (err < 0)
1330	return err;
1331
1332	*value = !!(status & SFP_ALARM0_TXPWR_LOW);
1333	return 0;
1334
1335	case hwmon_power_min_alarm:
1336	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1337	if (err < 0)
1338	return err;
1339
1340	*value = !!(status & SFP_WARN0_TXPWR_LOW);
1341	return 0;
1342
1343	case hwmon_power_max_alarm:
1344	err = sfp_read(sfp, a2: true, addr: SFP_WARN0, buf: &status, len: sizeof(status));
1345	if (err < 0)
1346	return err;
1347
1348	*value = !!(status & SFP_WARN0_TXPWR_HIGH);
1349	return 0;
1350
1351	case hwmon_power_crit_alarm:
1352	err = sfp_read(sfp, a2: true, addr: SFP_ALARM0, buf: &status, len: sizeof(status));
1353	if (err < 0)
1354	return err;
1355
1356	*value = !!(status & SFP_ALARM0_TXPWR_HIGH);
1357	return 0;
1358	default:
1359	return -EOPNOTSUPP;
1360	}
1361
1362	return -EOPNOTSUPP;
1363	}
1364
1365	static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value)
1366	{
1367	u8 status;
1368	int err;
1369
1370	switch (attr) {
1371	case hwmon_power_input:
1372	return sfp_hwmon_read_rx_power(sfp, reg: SFP_RX_POWER, value);
1373
1374	case hwmon_power_lcrit:
1375	*value = be16_to_cpu(sfp->diag.rxpwr_low_alarm);
1376	sfp_hwmon_to_rx_power(value);
1377	return 0;
1378
1379	case hwmon_power_min:
1380	*value = be16_to_cpu(sfp->diag.rxpwr_low_warn);
1381	sfp_hwmon_to_rx_power(value);
1382	return 0;
1383
1384	case hwmon_power_max:
1385	*value = be16_to_cpu(sfp->diag.rxpwr_high_warn);
1386	sfp_hwmon_to_rx_power(value);
1387	return 0;
1388
1389	case hwmon_power_crit:
1390	*value = be16_to_cpu(sfp->diag.rxpwr_high_alarm);
1391	sfp_hwmon_to_rx_power(value);
1392	return 0;
1393
1394	case hwmon_power_lcrit_alarm:
1395	err = sfp_read(sfp, a2: true, addr: SFP_ALARM1, buf: &status, len: sizeof(status));
1396	if (err < 0)
1397	return err;
1398
1399	*value = !!(status & SFP_ALARM1_RXPWR_LOW);
1400	return 0;
1401
1402	case hwmon_power_min_alarm:
1403	err = sfp_read(sfp, a2: true, addr: SFP_WARN1, buf: &status, len: sizeof(status));
1404	if (err < 0)
1405	return err;
1406
1407	*value = !!(status & SFP_WARN1_RXPWR_LOW);
1408	return 0;
1409
1410	case hwmon_power_max_alarm:
1411	err = sfp_read(sfp, a2: true, addr: SFP_WARN1, buf: &status, len: sizeof(status));
1412	if (err < 0)
1413	return err;
1414
1415	*value = !!(status & SFP_WARN1_RXPWR_HIGH);
1416	return 0;
1417
1418	case hwmon_power_crit_alarm:
1419	err = sfp_read(sfp, a2: true, addr: SFP_ALARM1, buf: &status, len: sizeof(status));
1420	if (err < 0)
1421	return err;
1422
1423	*value = !!(status & SFP_ALARM1_RXPWR_HIGH);
1424	return 0;
1425	default:
1426	return -EOPNOTSUPP;
1427	}
1428
1429	return -EOPNOTSUPP;
1430	}
1431
1432	static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
1433	u32 attr, int channel, long *value)
1434	{
1435	struct sfp *sfp = dev_get_drvdata(dev);
1436
1437	switch (type) {
1438	case hwmon_temp:
1439	return sfp_hwmon_temp(sfp, attr, value);
1440	case hwmon_in:
1441	return sfp_hwmon_vcc(sfp, attr, value);
1442	case hwmon_curr:
1443	return sfp_hwmon_bias(sfp, attr, value);
1444	case hwmon_power:
1445	switch (channel) {
1446	case 0:
1447	return sfp_hwmon_tx_power(sfp, attr, value);
1448	case 1:
1449	return sfp_hwmon_rx_power(sfp, attr, value);
1450	default:
1451	return -EOPNOTSUPP;
1452	}
1453	default:
1454	return -EOPNOTSUPP;
1455	}
1456	}
1457
1458	static const char *const sfp_hwmon_power_labels[] = {
1459	"TX_power",
1460	"RX_power",
1461	};
1462
1463	static int sfp_hwmon_read_string(struct device *dev,
1464	enum hwmon_sensor_types type,
1465	u32 attr, int channel, const char **str)
1466	{
1467	switch (type) {
1468	case hwmon_curr:
1469	switch (attr) {
1470	case hwmon_curr_label:
1471	*str = "bias";
1472	return 0;
1473	default:
1474	return -EOPNOTSUPP;
1475	}
1476	break;
1477	case hwmon_temp:
1478	switch (attr) {
1479	case hwmon_temp_label:
1480	*str = "temperature";
1481	return 0;
1482	default:
1483	return -EOPNOTSUPP;
1484	}
1485	break;
1486	case hwmon_in:
1487	switch (attr) {
1488	case hwmon_in_label:
1489	*str = "VCC";
1490	return 0;
1491	default:
1492	return -EOPNOTSUPP;
1493	}
1494	break;
1495	case hwmon_power:
1496	switch (attr) {
1497	case hwmon_power_label:
1498	*str = sfp_hwmon_power_labels[channel];
1499	return 0;
1500	default:
1501	return -EOPNOTSUPP;
1502	}
1503	break;
1504	default:
1505	return -EOPNOTSUPP;
1506	}
1507
1508	return -EOPNOTSUPP;
1509	}
1510
1511	static const struct hwmon_ops sfp_hwmon_ops = {
1512	.is_visible = sfp_hwmon_is_visible,
1513	.read = sfp_hwmon_read,
1514	.read_string = sfp_hwmon_read_string,
1515	};
1516
1517	static const struct hwmon_channel_info * const sfp_hwmon_info[] = {
1518	HWMON_CHANNEL_INFO(chip,
1519	HWMON_C_REGISTER_TZ),
1520	HWMON_CHANNEL_INFO(in,
1521	HWMON_I_INPUT |
1522	HWMON_I_MAX | HWMON_I_MIN |
1523	HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM |
1524	HWMON_I_CRIT | HWMON_I_LCRIT |
1525	HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM |
1526	HWMON_I_LABEL),
1527	HWMON_CHANNEL_INFO(temp,
1528	HWMON_T_INPUT |
1529	HWMON_T_MAX | HWMON_T_MIN |
1530	HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM |
1531	HWMON_T_CRIT | HWMON_T_LCRIT |
1532	HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM |
1533	HWMON_T_LABEL),
1534	HWMON_CHANNEL_INFO(curr,
1535	HWMON_C_INPUT |
1536	HWMON_C_MAX | HWMON_C_MIN |
1537	HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM |
1538	HWMON_C_CRIT | HWMON_C_LCRIT |
1539	HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM |
1540	HWMON_C_LABEL),
1541	HWMON_CHANNEL_INFO(power,
1542	/* Transmit power */
1543	HWMON_P_INPUT |
1544	HWMON_P_MAX | HWMON_P_MIN |
1545	HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1546	HWMON_P_CRIT | HWMON_P_LCRIT |
1547	HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM |
1548	HWMON_P_LABEL,
1549	/* Receive power */
1550	HWMON_P_INPUT |
1551	HWMON_P_MAX | HWMON_P_MIN |
1552	HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1553	HWMON_P_CRIT | HWMON_P_LCRIT |
1554	HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM |
1555	HWMON_P_LABEL),
1556	NULL,
1557	};
1558
1559	static const struct hwmon_chip_info sfp_hwmon_chip_info = {
1560	.ops = &sfp_hwmon_ops,
1561	.info = sfp_hwmon_info,
1562	};
1563
1564	static void sfp_hwmon_probe(struct work_struct *work)
1565	{
1566	struct sfp *sfp = container_of(work, struct sfp, hwmon_probe.work);
1567	int err;
1568
1569	/* hwmon interface needs to access 16bit registers in atomic way to
1570	* guarantee coherency of the diagnostic monitoring data. If it is not
1571	* possible to guarantee coherency because EEPROM is broken in such way
1572	* that does not support atomic 16bit read operation then we have to
1573	* skip registration of hwmon device.
1574	*/
1575	if (sfp->i2c_block_size < 2) {
1576	dev_info(sfp->dev,
1577	"skipping hwmon device registration due to broken EEPROM\n");
1578	dev_info(sfp->dev,
1579	"diagnostic EEPROM area cannot be read atomically to guarantee data coherency\n");
1580	return;
1581	}
1582
1583	err = sfp_read(sfp, a2: true, addr: 0, buf: &sfp->diag, len: sizeof(sfp->diag));
1584	if (err < 0) {
1585	if (sfp->hwmon_tries--) {
1586	mod_delayed_work(wq: system_wq, dwork: &sfp->hwmon_probe,
1587	T_PROBE_RETRY_SLOW);
1588	} else {
1589	dev_warn(sfp->dev, "hwmon probe failed: %pe\n",
1590	ERR_PTR(err));
1591	}
1592	return;
1593	}
1594
1595	sfp->hwmon_name = hwmon_sanitize_name(name: dev_name(dev: sfp->dev));
1596	if (IS_ERR(ptr: sfp->hwmon_name)) {
1597	dev_err(sfp->dev, "out of memory for hwmon name\n");
1598	return;
1599	}
1600
1601	sfp->hwmon_dev = hwmon_device_register_with_info(dev: sfp->dev,
1602	name: sfp->hwmon_name, drvdata: sfp,
1603	info: &sfp_hwmon_chip_info,
1604	NULL);
1605	if (IS_ERR(ptr: sfp->hwmon_dev))
1606	dev_err(sfp->dev, "failed to register hwmon device: %ld\n",
1607	PTR_ERR(sfp->hwmon_dev));
1608	}
1609
1610	static int sfp_hwmon_insert(struct sfp *sfp)
1611	{
1612	if (sfp->have_a2 && sfp->id.ext.diagmon & SFP_DIAGMON_DDM) {
1613	mod_delayed_work(wq: system_wq, dwork: &sfp->hwmon_probe, delay: 1);
1614	sfp->hwmon_tries = R_PROBE_RETRY_SLOW;
1615	}
1616
1617	return 0;
1618	}
1619
1620	static void sfp_hwmon_remove(struct sfp *sfp)
1621	{
1622	cancel_delayed_work_sync(dwork: &sfp->hwmon_probe);
1623	if (!IS_ERR_OR_NULL(ptr: sfp->hwmon_dev)) {
1624	hwmon_device_unregister(dev: sfp->hwmon_dev);
1625	sfp->hwmon_dev = NULL;
1626	kfree(objp: sfp->hwmon_name);
1627	}
1628	}
1629
1630	static int sfp_hwmon_init(struct sfp *sfp)
1631	{
1632	INIT_DELAYED_WORK(&sfp->hwmon_probe, sfp_hwmon_probe);
1633
1634	return 0;
1635	}
1636
1637	static void sfp_hwmon_exit(struct sfp *sfp)
1638	{
1639	cancel_delayed_work_sync(dwork: &sfp->hwmon_probe);
1640	}
1641	#else
1642	static int sfp_hwmon_insert(struct sfp *sfp)
1643	{
1644	return 0;
1645	}
1646
1647	static void sfp_hwmon_remove(struct sfp *sfp)
1648	{
1649	}
1650
1651	static int sfp_hwmon_init(struct sfp *sfp)
1652	{
1653	return 0;
1654	}
1655
1656	static void sfp_hwmon_exit(struct sfp *sfp)
1657	{
1658	}
1659	#endif
1660
1661	/* Helpers */
1662	static void sfp_module_tx_disable(struct sfp *sfp)
1663	{
1664	dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1665	sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1);
1666	sfp_mod_state(sfp, mask: SFP_F_TX_DISABLE, set: SFP_F_TX_DISABLE);
1667	}
1668
1669	static void sfp_module_tx_enable(struct sfp *sfp)
1670	{
1671	dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1672	sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0);
1673	sfp_mod_state(sfp, mask: SFP_F_TX_DISABLE, set: 0);
1674	}
1675
1676	#if IS_ENABLED(CONFIG_DEBUG_FS)
1677	static int sfp_debug_state_show(struct seq_file *s, void *data)
1678	{
1679	struct sfp *sfp = s->private;
1680
1681	seq_printf(m: s, fmt: "Module state: %s\n",
1682	mod_state_to_str(mod_state: sfp->sm_mod_state));
1683	seq_printf(m: s, fmt: "Module probe attempts: %d %d\n",
1684	R_PROBE_RETRY_INIT - sfp->sm_mod_tries_init,
1685	R_PROBE_RETRY_SLOW - sfp->sm_mod_tries);
1686	seq_printf(m: s, fmt: "Device state: %s\n",
1687	dev_state_to_str(dev_state: sfp->sm_dev_state));
1688	seq_printf(m: s, fmt: "Main state: %s\n",
1689	sm_state_to_str(sm_state: sfp->sm_state));
1690	seq_printf(m: s, fmt: "Fault recovery remaining retries: %d\n",
1691	sfp->sm_fault_retries);
1692	seq_printf(m: s, fmt: "PHY probe remaining retries: %d\n",
1693	sfp->sm_phy_retries);
1694	seq_printf(m: s, fmt: "Signalling rate: %u kBd\n", sfp->rate_kbd);
1695	seq_printf(m: s, fmt: "Rate select threshold: %u kBd\n",
1696	sfp->rs_threshold_kbd);
1697	seq_printf(m: s, fmt: "moddef0: %d\n", !!(sfp->state & SFP_F_PRESENT));
1698	seq_printf(m: s, fmt: "rx_los: %d\n", !!(sfp->state & SFP_F_LOS));
1699	seq_printf(m: s, fmt: "tx_fault: %d\n", !!(sfp->state & SFP_F_TX_FAULT));
1700	seq_printf(m: s, fmt: "tx_disable: %d\n", !!(sfp->state & SFP_F_TX_DISABLE));
1701	seq_printf(m: s, fmt: "rs0: %d\n", !!(sfp->state & SFP_F_RS0));
1702	seq_printf(m: s, fmt: "rs1: %d\n", !!(sfp->state & SFP_F_RS1));
1703	return 0;
1704	}
1705	DEFINE_SHOW_ATTRIBUTE(sfp_debug_state);
1706
1707	static void sfp_debugfs_init(struct sfp *sfp)
1708	{
1709	sfp->debugfs_dir = debugfs_create_dir(name: dev_name(dev: sfp->dev), NULL);
1710
1711	debugfs_create_file(name: "state", mode: 0600, parent: sfp->debugfs_dir, data: sfp,
1712	fops: &sfp_debug_state_fops);
1713	}
1714
1715	static void sfp_debugfs_exit(struct sfp *sfp)
1716	{
1717	debugfs_remove_recursive(dentry: sfp->debugfs_dir);
1718	}
1719	#else
1720	static void sfp_debugfs_init(struct sfp *sfp)
1721	{
1722	}
1723
1724	static void sfp_debugfs_exit(struct sfp *sfp)
1725	{
1726	}
1727	#endif
1728
1729	static void sfp_module_tx_fault_reset(struct sfp *sfp)
1730	{
1731	unsigned int state;
1732
1733	mutex_lock(&sfp->st_mutex);
1734	state = sfp->state;
1735	if (!(state & SFP_F_TX_DISABLE)) {
1736	sfp_set_state(sfp, state: state | SFP_F_TX_DISABLE);
1737
1738	udelay(T_RESET_US);
1739
1740	sfp_set_state(sfp, state);
1741	}
1742	mutex_unlock(lock: &sfp->st_mutex);
1743	}
1744
1745	/* SFP state machine */
1746	static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout)
1747	{
1748	if (timeout)
1749	mod_delayed_work(wq: system_power_efficient_wq, dwork: &sfp->timeout,
1750	delay: timeout);
1751	else
1752	cancel_delayed_work(dwork: &sfp->timeout);
1753	}
1754
1755	static void sfp_sm_next(struct sfp *sfp, unsigned int state,
1756	unsigned int timeout)
1757	{
1758	sfp->sm_state = state;
1759	sfp_sm_set_timer(sfp, timeout);
1760	}
1761
1762	static void sfp_sm_mod_next(struct sfp *sfp, unsigned int state,
1763	unsigned int timeout)
1764	{
1765	sfp->sm_mod_state = state;
1766	sfp_sm_set_timer(sfp, timeout);
1767	}
1768
1769	static void sfp_sm_phy_detach(struct sfp *sfp)
1770	{
1771	sfp_remove_phy(bus: sfp->sfp_bus);
1772	phy_device_remove(phydev: sfp->mod_phy);
1773	phy_device_free(phydev: sfp->mod_phy);
1774	sfp->mod_phy = NULL;
1775	}
1776
1777	static int sfp_sm_probe_phy(struct sfp *sfp, int addr, bool is_c45)
1778	{
1779	struct phy_device *phy;
1780	int err;
1781
1782	phy = get_phy_device(bus: sfp->i2c_mii, addr, is_c45);
1783	if (phy == ERR_PTR(error: -ENODEV))
1784	return PTR_ERR(ptr: phy);
1785	if (IS_ERR(ptr: phy)) {
1786	dev_err(sfp->dev, "mdiobus scan returned %pe\n", phy);
1787	return PTR_ERR(ptr: phy);
1788	}
1789
1790	/* Mark this PHY as being on a SFP module */
1791	phy->is_on_sfp_module = true;
1792
1793	err = phy_device_register(phy);
1794	if (err) {
1795	phy_device_free(phydev: phy);
1796	dev_err(sfp->dev, "phy_device_register failed: %pe\n",
1797	ERR_PTR(err));
1798	return err;
1799	}
1800
1801	err = sfp_add_phy(bus: sfp->sfp_bus, phydev: phy);
1802	if (err) {
1803	phy_device_remove(phydev: phy);
1804	phy_device_free(phydev: phy);
1805	dev_err(sfp->dev, "sfp_add_phy failed: %pe\n", ERR_PTR(err));
1806	return err;
1807	}
1808
1809	sfp->mod_phy = phy;
1810
1811	return 0;
1812	}
1813
1814	static void sfp_sm_link_up(struct sfp *sfp)
1815	{
1816	sfp_link_up(bus: sfp->sfp_bus);
1817	sfp_sm_next(sfp, state: SFP_S_LINK_UP, timeout: 0);
1818	}
1819
1820	static void sfp_sm_link_down(struct sfp *sfp)
1821	{
1822	sfp_link_down(bus: sfp->sfp_bus);
1823	}
1824
1825	static void sfp_sm_link_check_los(struct sfp *sfp)
1826	{
1827	const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
1828	const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
1829	__be16 los_options = sfp->id.ext.options & (los_inverted | los_normal);
1830	bool los = false;
1831
1832	/* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL
1833	* are set, we assume that no LOS signal is available. If both are
1834	* set, we assume LOS is not implemented (and is meaningless.)
1835	*/
1836	if (los_options == los_inverted)
1837	los = !(sfp->state & SFP_F_LOS);
1838	else if (los_options == los_normal)
1839	los = !!(sfp->state & SFP_F_LOS);
1840
1841	if (los)
1842	sfp_sm_next(sfp, state: SFP_S_WAIT_LOS, timeout: 0);
1843	else
1844	sfp_sm_link_up(sfp);
1845	}
1846
1847	static bool sfp_los_event_active(struct sfp *sfp, unsigned int event)
1848	{
1849	const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
1850	const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
1851	__be16 los_options = sfp->id.ext.options & (los_inverted | los_normal);
1852
1853	return (los_options == los_inverted && event == SFP_E_LOS_LOW) ||
1854	(los_options == los_normal && event == SFP_E_LOS_HIGH);
1855	}
1856
1857	static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event)
1858	{
1859	const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
1860	const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
1861	__be16 los_options = sfp->id.ext.options & (los_inverted | los_normal);
1862
1863	return (los_options == los_inverted && event == SFP_E_LOS_HIGH) ||
1864	(los_options == los_normal && event == SFP_E_LOS_LOW);
1865	}
1866
1867	static void sfp_sm_fault(struct sfp *sfp, unsigned int next_state, bool warn)
1868	{
1869	if (sfp->sm_fault_retries && !--sfp->sm_fault_retries) {
1870	dev_err(sfp->dev,
1871	"module persistently indicates fault, disabling\n");
1872	sfp_sm_next(sfp, state: SFP_S_TX_DISABLE, timeout: 0);
1873	} else {
1874	if (warn)
1875	dev_err(sfp->dev, "module transmit fault indicated\n");
1876
1877	sfp_sm_next(sfp, state: next_state, T_FAULT_RECOVER);
1878	}
1879	}
1880
1881	static int sfp_sm_add_mdio_bus(struct sfp *sfp)
1882	{
1883	if (sfp->mdio_protocol != MDIO_I2C_NONE)
1884	return sfp_i2c_mdiobus_create(sfp);
1885
1886	return 0;
1887	}
1888
1889	/* Probe a SFP for a PHY device if the module supports copper - the PHY
1890	* normally sits at I2C bus address 0x56, and may either be a clause 22
1891	* or clause 45 PHY.
1892	*
1893	* Clause 22 copper SFP modules normally operate in Cisco SGMII mode with
1894	* negotiation enabled, but some may be in 1000base-X - which is for the
1895	* PHY driver to determine.
1896	*
1897	* Clause 45 copper SFP+ modules (10G) appear to switch their interface
1898	* mode according to the negotiated line speed.
1899	*/
1900	static int sfp_sm_probe_for_phy(struct sfp *sfp)
1901	{
1902	int err = 0;
1903
1904	switch (sfp->mdio_protocol) {
1905	case MDIO_I2C_NONE:
1906	break;
1907
1908	case MDIO_I2C_MARVELL_C22:
1909	err = sfp_sm_probe_phy(sfp, SFP_PHY_ADDR, is_c45: false);
1910	break;
1911
1912	case MDIO_I2C_C45:
1913	err = sfp_sm_probe_phy(sfp, SFP_PHY_ADDR, is_c45: true);
1914	break;
1915
1916	case MDIO_I2C_ROLLBALL:
1917	err = sfp_sm_probe_phy(sfp, SFP_PHY_ADDR_ROLLBALL, is_c45: true);
1918	break;
1919	}
1920
1921	return err;
1922	}
1923
1924	static int sfp_module_parse_power(struct sfp *sfp)
1925	{
1926	u32 power_mW = 1000;
1927	bool supports_a2;
1928
1929	if (sfp->id.ext.sff8472_compliance >= SFP_SFF8472_COMPLIANCE_REV10_2 &&
1930	sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL))
1931	power_mW = 1500;
1932	/* Added in Rev 11.9, but there is no compliance code for this */
1933	if (sfp->id.ext.sff8472_compliance >= SFP_SFF8472_COMPLIANCE_REV11_4 &&
1934	sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL))
1935	power_mW = 2000;
1936
1937	/* Power level 1 modules (max. 1W) are always supported. */
1938	if (power_mW <= 1000) {
1939	sfp->module_power_mW = power_mW;
1940	return 0;
1941	}
1942
1943	supports_a2 = sfp->id.ext.sff8472_compliance !=
1944	SFP_SFF8472_COMPLIANCE_NONE ||
1945	sfp->id.ext.diagmon & SFP_DIAGMON_DDM;
1946
1947	if (power_mW > sfp->max_power_mW) {
1948	/* Module power specification exceeds the allowed maximum. */
1949	if (!supports_a2) {
1950	/* The module appears not to implement bus address
1951	* 0xa2, so assume that the module powers up in the
1952	* indicated mode.
1953	*/
1954	dev_err(sfp->dev,
1955	"Host does not support %u.%uW modules\n",
1956	power_mW / 1000, (power_mW / 100) % 10);
1957	return -EINVAL;
1958	} else {
1959	dev_warn(sfp->dev,
1960	"Host does not support %u.%uW modules, module left in power mode 1\n",
1961	power_mW / 1000, (power_mW / 100) % 10);
1962	return 0;
1963	}
1964	}
1965
1966	if (!supports_a2) {
1967	/* The module power level is below the host maximum and the
1968	* module appears not to implement bus address 0xa2, so assume
1969	* that the module powers up in the indicated mode.
1970	*/
1971	return 0;
1972	}
1973
1974	/* If the module requires a higher power mode, but also requires
1975	* an address change sequence, warn the user that the module may
1976	* not be functional.
1977	*/
1978	if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) {
1979	dev_warn(sfp->dev,
1980	"Address Change Sequence not supported but module requires %u.%uW, module may not be functional\n",
1981	power_mW / 1000, (power_mW / 100) % 10);
1982	return 0;
1983	}
1984
1985	sfp->module_power_mW = power_mW;
1986
1987	return 0;
1988	}
1989
1990	static int sfp_sm_mod_hpower(struct sfp *sfp, bool enable)
1991	{
1992	int err;
1993
1994	err = sfp_modify_u8(sfp, a2: true, addr: SFP_EXT_STATUS,
1995	mask: SFP_EXT_STATUS_PWRLVL_SELECT,
1996	val: enable ? SFP_EXT_STATUS_PWRLVL_SELECT : 0);
1997	if (err != sizeof(u8)) {
1998	dev_err(sfp->dev, "failed to %sable high power: %pe\n",
1999	enable ? "en" : "dis", ERR_PTR(err));
2000	return -EAGAIN;
2001	}
2002
2003	if (enable)
2004	dev_info(sfp->dev, "Module switched to %u.%uW power level\n",
2005	sfp->module_power_mW / 1000,
2006	(sfp->module_power_mW / 100) % 10);
2007
2008	return 0;
2009	}
2010
2011	static void sfp_module_parse_rate_select(struct sfp *sfp)
2012	{
2013	u8 rate_id;
2014
2015	sfp->rs_threshold_kbd = 0;
2016	sfp->rs_state_mask = 0;
2017
2018	if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_RATE_SELECT)))
2019	/* No support for RateSelect */
2020	return;
2021
2022	/* Default to INF-8074 RateSelect operation. The signalling threshold
2023	* rate is not well specified, so always select "Full Bandwidth", but
2024	* SFF-8079 reveals that it is understood that RS0 will be low for
2025	* 1.0625Gb/s and high for 2.125Gb/s. Choose a value half-way between.
2026	* This method exists prior to SFF-8472.
2027	*/
2028	sfp->rs_state_mask = SFP_F_RS0;
2029	sfp->rs_threshold_kbd = 1594;
2030
2031	/* Parse the rate identifier, which is complicated due to history:
2032	* SFF-8472 rev 9.5 marks this field as reserved.
2033	* SFF-8079 references SFF-8472 rev 9.5 and defines bit 0. SFF-8472
2034	* compliance is not required.
2035	* SFF-8472 rev 10.2 defines this field using values 0..4
2036	* SFF-8472 rev 11.0 redefines this field with bit 0 for SFF-8079
2037	* and even values.
2038	*/
2039	rate_id = sfp->id.base.rate_id;
2040	if (rate_id == 0)
2041	/* Unspecified */
2042	return;
2043
2044	/* SFF-8472 rev 10.0..10.4 did not account for SFF-8079 using bit 0,
2045	* and allocated value 3 to SFF-8431 independent tx/rx rate select.
2046	* Convert this to a SFF-8472 rev 11.0 rate identifier.
2047	*/
2048	if (sfp->id.ext.sff8472_compliance >= SFP_SFF8472_COMPLIANCE_REV10_2 &&
2049	sfp->id.ext.sff8472_compliance < SFP_SFF8472_COMPLIANCE_REV11_0 &&
2050	rate_id == 3)
2051	rate_id = SFF_RID_8431;
2052
2053	if (rate_id & SFF_RID_8079) {
2054	/* SFF-8079 RateSelect / Application Select in conjunction with
2055	* SFF-8472 rev 9.5. SFF-8079 defines rate_id as a bitfield
2056	* with only bit 0 used, which takes precedence over SFF-8472.
2057	*/
2058	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_APP_SELECT_SFF8079)) {
2059	/* SFF-8079 Part 1 - rate selection between Fibre
2060	* Channel 1.0625/2.125/4.25 Gbd modes. Note that RS0
2061	* is high for 2125, so we have to subtract 1 to
2062	* include it.
2063	*/
2064	sfp->rs_threshold_kbd = 2125 - 1;
2065	sfp->rs_state_mask = SFP_F_RS0;
2066	}
2067	return;
2068	}
2069
2070	/* SFF-8472 rev 9.5 does not define the rate identifier */
2071	if (sfp->id.ext.sff8472_compliance <= SFP_SFF8472_COMPLIANCE_REV9_5)
2072	return;
2073
2074	/* SFF-8472 rev 11.0 defines rate_id as a numerical value which will
2075	* always have bit 0 clear due to SFF-8079's bitfield usage of rate_id.
2076	*/
2077	switch (rate_id) {
2078	case SFF_RID_8431_RX_ONLY:
2079	sfp->rs_threshold_kbd = 4250;
2080	sfp->rs_state_mask = SFP_F_RS0;
2081	break;
2082
2083	case SFF_RID_8431_TX_ONLY:
2084	sfp->rs_threshold_kbd = 4250;
2085	sfp->rs_state_mask = SFP_F_RS1;
2086	break;
2087
2088	case SFF_RID_8431:
2089	sfp->rs_threshold_kbd = 4250;
2090	sfp->rs_state_mask = SFP_F_RS0 | SFP_F_RS1;
2091	break;
2092
2093	case SFF_RID_10G8G:
2094	sfp->rs_threshold_kbd = 9000;
2095	sfp->rs_state_mask = SFP_F_RS0 | SFP_F_RS1;
2096	break;
2097	}
2098	}
2099
2100	/* GPON modules based on Realtek RTL8672 and RTL9601C chips (e.g. V-SOL
2101	* V2801F, CarlitoxxPro CPGOS03-0490, Ubiquiti U-Fiber Instant, ...) do
2102	* not support multibyte reads from the EEPROM. Each multi-byte read
2103	* operation returns just one byte of EEPROM followed by zeros. There is
2104	* no way to identify which modules are using Realtek RTL8672 and RTL9601C
2105	* chips. Moreover every OEM of V-SOL V2801F module puts its own vendor
2106	* name and vendor id into EEPROM, so there is even no way to detect if
2107	* module is V-SOL V2801F. Therefore check for those zeros in the read
2108	* data and then based on check switch to reading EEPROM to one byte
2109	* at a time.
2110	*/
2111	static bool sfp_id_needs_byte_io(struct sfp *sfp, void *buf, size_t len)
2112	{
2113	size_t i, block_size = sfp->i2c_block_size;
2114
2115	/* Already using byte IO */
2116	if (block_size == 1)
2117	return false;
2118
2119	for (i = 1; i < len; i += block_size) {
2120	if (memchr_inv(p: buf + i, c: '\0', min(block_size - 1, len - i)))
2121	return false;
2122	}
2123	return true;
2124	}
2125
2126	static int sfp_cotsworks_fixup_check(struct sfp *sfp, struct sfp_eeprom_id *id)
2127	{
2128	u8 check;
2129	int err;
2130
2131	if (id->base.phys_id != SFF8024_ID_SFF_8472 ||
2132	id->base.phys_ext_id != SFP_PHYS_EXT_ID_SFP ||
2133	id->base.connector != SFF8024_CONNECTOR_LC) {
2134	dev_warn(sfp->dev, "Rewriting fiber module EEPROM with corrected values\n");
2135	id->base.phys_id = SFF8024_ID_SFF_8472;
2136	id->base.phys_ext_id = SFP_PHYS_EXT_ID_SFP;
2137	id->base.connector = SFF8024_CONNECTOR_LC;
2138	err = sfp_write(sfp, a2: false, addr: SFP_PHYS_ID, buf: &id->base, len: 3);
2139	if (err != 3) {
2140	dev_err(sfp->dev,
2141	"Failed to rewrite module EEPROM: %pe\n",
2142	ERR_PTR(err));
2143	return err;
2144	}
2145
2146	/* Cotsworks modules have been found to require a delay between write operations. */
2147	mdelay(50);
2148
2149	/* Update base structure checksum */
2150	check = sfp_check(buf: &id->base, len: sizeof(id->base) - 1);
2151	err = sfp_write(sfp, a2: false, addr: SFP_CC_BASE, buf: &check, len: 1);
2152	if (err != 1) {
2153	dev_err(sfp->dev,
2154	"Failed to update base structure checksum in fiber module EEPROM: %pe\n",
2155	ERR_PTR(err));
2156	return err;
2157	}
2158	}
2159	return 0;
2160	}
2161
2162	static int sfp_module_parse_sff8472(struct sfp *sfp)
2163	{
2164	/* If the module requires address swap mode, warn about it */
2165	if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)
2166	dev_warn(sfp->dev,
2167	"module address swap to access page 0xA2 is not supported.\n");
2168	else
2169	sfp->have_a2 = true;
2170
2171	return 0;
2172	}
2173
2174	static int sfp_sm_mod_probe(struct sfp *sfp, bool report)
2175	{
2176	/* SFP module inserted - read I2C data */
2177	struct sfp_eeprom_id id;
2178	bool cotsworks_sfbg;
2179	unsigned int mask;
2180	bool cotsworks;
2181	u8 check;
2182	int ret;
2183
2184	sfp->i2c_block_size = SFP_EEPROM_BLOCK_SIZE;
2185
2186	ret = sfp_read(sfp, a2: false, addr: 0, buf: &id.base, len: sizeof(id.base));
2187	if (ret < 0) {
2188	if (report)
2189	dev_err(sfp->dev, "failed to read EEPROM: %pe\n",
2190	ERR_PTR(ret));
2191	return -EAGAIN;
2192	}
2193
2194	if (ret != sizeof(id.base)) {
2195	dev_err(sfp->dev, "EEPROM short read: %pe\n", ERR_PTR(ret));
2196	return -EAGAIN;
2197	}
2198
2199	/* Some SFP modules (e.g. Nokia 3FE46541AA) lock up if read from
2200	* address 0x51 is just one byte at a time. Also SFF-8472 requires
2201	* that EEPROM supports atomic 16bit read operation for diagnostic
2202	* fields, so do not switch to one byte reading at a time unless it
2203	* is really required and we have no other option.
2204	*/
2205	if (sfp_id_needs_byte_io(sfp, buf: &id.base, len: sizeof(id.base))) {
2206	dev_info(sfp->dev,
2207	"Detected broken RTL8672/RTL9601C emulated EEPROM\n");
2208	dev_info(sfp->dev,
2209	"Switching to reading EEPROM to one byte at a time\n");
2210	sfp->i2c_block_size = 1;
2211
2212	ret = sfp_read(sfp, a2: false, addr: 0, buf: &id.base, len: sizeof(id.base));
2213	if (ret < 0) {
2214	if (report)
2215	dev_err(sfp->dev,
2216	"failed to read EEPROM: %pe\n",
2217	ERR_PTR(ret));
2218	return -EAGAIN;
2219	}
2220
2221	if (ret != sizeof(id.base)) {
2222	dev_err(sfp->dev, "EEPROM short read: %pe\n",
2223	ERR_PTR(ret));
2224	return -EAGAIN;
2225	}
2226	}
2227
2228	/* Cotsworks do not seem to update the checksums when they
2229	* do the final programming with the final module part number,
2230	* serial number and date code.
2231	*/
2232	cotsworks = !memcmp(p: id.base.vendor_name, q: "COTSWORKS ", size: 16);
2233	cotsworks_sfbg = !memcmp(p: id.base.vendor_pn, q: "SFBG", size: 4);
2234
2235	/* Cotsworks SFF module EEPROM do not always have valid phys_id,
2236	* phys_ext_id, and connector bytes. Rewrite SFF EEPROM bytes if
2237	* Cotsworks PN matches and bytes are not correct.
2238	*/
2239	if (cotsworks && cotsworks_sfbg) {
2240	ret = sfp_cotsworks_fixup_check(sfp, id: &id);
2241	if (ret < 0)
2242	return ret;
2243	}
2244
2245	/* Validate the checksum over the base structure */
2246	check = sfp_check(buf: &id.base, len: sizeof(id.base) - 1);
2247	if (check != id.base.cc_base) {
2248	if (cotsworks) {
2249	dev_warn(sfp->dev,
2250	"EEPROM base structure checksum failure (0x%02x != 0x%02x)\n",
2251	check, id.base.cc_base);
2252	} else {
2253	dev_err(sfp->dev,
2254	"EEPROM base structure checksum failure: 0x%02x != 0x%02x\n",
2255	check, id.base.cc_base);
2256	print_hex_dump(KERN_ERR, prefix_str: "sfp EE: ", prefix_type: DUMP_PREFIX_OFFSET,
2257	rowsize: 16, groupsize: 1, buf: &id, len: sizeof(id), ascii: true);
2258	return -EINVAL;
2259	}
2260	}
2261
2262	ret = sfp_read(sfp, a2: false, addr: SFP_CC_BASE + 1, buf: &id.ext, len: sizeof(id.ext));
2263	if (ret < 0) {
2264	if (report)
2265	dev_err(sfp->dev, "failed to read EEPROM: %pe\n",
2266	ERR_PTR(ret));
2267	return -EAGAIN;
2268	}
2269
2270	if (ret != sizeof(id.ext)) {
2271	dev_err(sfp->dev, "EEPROM short read: %pe\n", ERR_PTR(ret));
2272	return -EAGAIN;
2273	}
2274
2275	check = sfp_check(buf: &id.ext, len: sizeof(id.ext) - 1);
2276	if (check != id.ext.cc_ext) {
2277	if (cotsworks) {
2278	dev_warn(sfp->dev,
2279	"EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n",
2280	check, id.ext.cc_ext);
2281	} else {
2282	dev_err(sfp->dev,
2283	"EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n",
2284	check, id.ext.cc_ext);
2285	print_hex_dump(KERN_ERR, prefix_str: "sfp EE: ", prefix_type: DUMP_PREFIX_OFFSET,
2286	rowsize: 16, groupsize: 1, buf: &id, len: sizeof(id), ascii: true);
2287	memset(&id.ext, 0, sizeof(id.ext));
2288	}
2289	}
2290
2291	sfp->id = id;
2292
2293	dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n",
2294	(int)sizeof(id.base.vendor_name), id.base.vendor_name,
2295	(int)sizeof(id.base.vendor_pn), id.base.vendor_pn,
2296	(int)sizeof(id.base.vendor_rev), id.base.vendor_rev,
2297	(int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn,
2298	(int)sizeof(id.ext.datecode), id.ext.datecode);
2299
2300	/* Check whether we support this module */
2301	if (!sfp->type->module_supported(&id)) {
2302	dev_err(sfp->dev,
2303	"module is not supported - phys id 0x%02x 0x%02x\n",
2304	sfp->id.base.phys_id, sfp->id.base.phys_ext_id);
2305	return -EINVAL;
2306	}
2307
2308	if (sfp->id.ext.sff8472_compliance != SFP_SFF8472_COMPLIANCE_NONE) {
2309	ret = sfp_module_parse_sff8472(sfp);
2310	if (ret < 0)
2311	return ret;
2312	}
2313
2314	/* Parse the module power requirement */
2315	ret = sfp_module_parse_power(sfp);
2316	if (ret < 0)
2317	return ret;
2318
2319	sfp_module_parse_rate_select(sfp);
2320
2321	mask = SFP_F_PRESENT;
2322	if (sfp->gpio[GPIO_TX_DISABLE])
2323	mask |= SFP_F_TX_DISABLE;
2324	if (sfp->gpio[GPIO_TX_FAULT])
2325	mask |= SFP_F_TX_FAULT;
2326	if (sfp->gpio[GPIO_LOS])
2327	mask |= SFP_F_LOS;
2328	if (sfp->gpio[GPIO_RS0])
2329	mask |= SFP_F_RS0;
2330	if (sfp->gpio[GPIO_RS1])
2331	mask |= SFP_F_RS1;
2332
2333	sfp->module_t_start_up = T_START_UP;
2334	sfp->module_t_wait = T_WAIT;
2335
2336	sfp->state_ignore_mask = 0;
2337
2338	if (sfp->id.base.extended_cc == SFF8024_ECC_10GBASE_T_SFI ||
2339	sfp->id.base.extended_cc == SFF8024_ECC_10GBASE_T_SR ||
2340	sfp->id.base.extended_cc == SFF8024_ECC_5GBASE_T ||
2341	sfp->id.base.extended_cc == SFF8024_ECC_2_5GBASE_T)
2342	sfp->mdio_protocol = MDIO_I2C_C45;
2343	else if (sfp->id.base.e1000_base_t)
2344	sfp->mdio_protocol = MDIO_I2C_MARVELL_C22;
2345	else
2346	sfp->mdio_protocol = MDIO_I2C_NONE;
2347
2348	sfp->quirk = sfp_lookup_quirk(id: &id);
2349
2350	mutex_lock(&sfp->st_mutex);
2351	/* Initialise state bits to use from hardware */
2352	sfp->state_hw_mask = mask;
2353
2354	/* We want to drive the rate select pins that the module is using */
2355	sfp->state_hw_drive |= sfp->rs_state_mask;
2356
2357	if (sfp->quirk && sfp->quirk->fixup)
2358	sfp->quirk->fixup(sfp);
2359
2360	sfp->state_hw_mask &= ~sfp->state_ignore_mask;
2361	mutex_unlock(lock: &sfp->st_mutex);
2362
2363	return 0;
2364	}
2365
2366	static void sfp_sm_mod_remove(struct sfp *sfp)
2367	{
2368	if (sfp->sm_mod_state > SFP_MOD_WAITDEV)
2369	sfp_module_remove(bus: sfp->sfp_bus);
2370
2371	sfp_hwmon_remove(sfp);
2372
2373	memset(&sfp->id, 0, sizeof(sfp->id));
2374	sfp->module_power_mW = 0;
2375	sfp->state_hw_drive = SFP_F_TX_DISABLE;
2376	sfp->have_a2 = false;
2377
2378	dev_info(sfp->dev, "module removed\n");
2379	}
2380
2381	/* This state machine tracks the upstream's state */
2382	static void sfp_sm_device(struct sfp *sfp, unsigned int event)
2383	{
2384	switch (sfp->sm_dev_state) {
2385	default:
2386	if (event == SFP_E_DEV_ATTACH)
2387	sfp->sm_dev_state = SFP_DEV_DOWN;
2388	break;
2389
2390	case SFP_DEV_DOWN:
2391	if (event == SFP_E_DEV_DETACH)
2392	sfp->sm_dev_state = SFP_DEV_DETACHED;
2393	else if (event == SFP_E_DEV_UP)
2394	sfp->sm_dev_state = SFP_DEV_UP;
2395	break;
2396
2397	case SFP_DEV_UP:
2398	if (event == SFP_E_DEV_DETACH)
2399	sfp->sm_dev_state = SFP_DEV_DETACHED;
2400	else if (event == SFP_E_DEV_DOWN)
2401	sfp->sm_dev_state = SFP_DEV_DOWN;
2402	break;
2403	}
2404	}
2405
2406	/* This state machine tracks the insert/remove state of the module, probes
2407	* the on-board EEPROM, and sets up the power level.
2408	*/
2409	static void sfp_sm_module(struct sfp *sfp, unsigned int event)
2410	{
2411	int err;
2412
2413	/* Handle remove event globally, it resets this state machine */
2414	if (event == SFP_E_REMOVE) {
2415	if (sfp->sm_mod_state > SFP_MOD_PROBE)
2416	sfp_sm_mod_remove(sfp);
2417	sfp_sm_mod_next(sfp, state: SFP_MOD_EMPTY, timeout: 0);
2418	return;
2419	}
2420
2421	/* Handle device detach globally */
2422	if (sfp->sm_dev_state < SFP_DEV_DOWN &&
2423	sfp->sm_mod_state > SFP_MOD_WAITDEV) {
2424	if (sfp->module_power_mW > 1000 &&
2425	sfp->sm_mod_state > SFP_MOD_HPOWER)
2426	sfp_sm_mod_hpower(sfp, enable: false);
2427	sfp_sm_mod_next(sfp, state: SFP_MOD_WAITDEV, timeout: 0);
2428	return;
2429	}
2430
2431	switch (sfp->sm_mod_state) {
2432	default:
2433	if (event == SFP_E_INSERT) {
2434	sfp_sm_mod_next(sfp, state: SFP_MOD_PROBE, T_SERIAL);
2435	sfp->sm_mod_tries_init = R_PROBE_RETRY_INIT;
2436	sfp->sm_mod_tries = R_PROBE_RETRY_SLOW;
2437	}
2438	break;
2439
2440	case SFP_MOD_PROBE:
2441	/* Wait for T_PROBE_INIT to time out */
2442	if (event != SFP_E_TIMEOUT)
2443	break;
2444
2445	err = sfp_sm_mod_probe(sfp, report: sfp->sm_mod_tries == 1);
2446	if (err == -EAGAIN) {
2447	if (sfp->sm_mod_tries_init &&
2448	--sfp->sm_mod_tries_init) {
2449	sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT);
2450	break;
2451	} else if (sfp->sm_mod_tries && --sfp->sm_mod_tries) {
2452	if (sfp->sm_mod_tries == R_PROBE_RETRY_SLOW - 1)
2453	dev_warn(sfp->dev,
2454	"please wait, module slow to respond\n");
2455	sfp_sm_set_timer(sfp, T_PROBE_RETRY_SLOW);
2456	break;
2457	}
2458	}
2459	if (err < 0) {
2460	sfp_sm_mod_next(sfp, state: SFP_MOD_ERROR, timeout: 0);
2461	break;
2462	}
2463
2464	/* Force a poll to re-read the hardware signal state after
2465	* sfp_sm_mod_probe() changed state_hw_mask.
2466	*/
2467	mod_delayed_work(wq: system_wq, dwork: &sfp->poll, delay: 1);
2468
2469	err = sfp_hwmon_insert(sfp);
2470	if (err)
2471	dev_warn(sfp->dev, "hwmon probe failed: %pe\n",
2472	ERR_PTR(err));
2473
2474	sfp_sm_mod_next(sfp, state: SFP_MOD_WAITDEV, timeout: 0);
2475	fallthrough;
2476	case SFP_MOD_WAITDEV:
2477	/* Ensure that the device is attached before proceeding */
2478	if (sfp->sm_dev_state < SFP_DEV_DOWN)
2479	break;
2480
2481	/* Report the module insertion to the upstream device */
2482	err = sfp_module_insert(bus: sfp->sfp_bus, id: &sfp->id,
2483	quirk: sfp->quirk);
2484	if (err < 0) {
2485	sfp_sm_mod_next(sfp, state: SFP_MOD_ERROR, timeout: 0);
2486	break;
2487	}
2488
2489	/* If this is a power level 1 module, we are done */
2490	if (sfp->module_power_mW <= 1000)
2491	goto insert;
2492
2493	sfp_sm_mod_next(sfp, state: SFP_MOD_HPOWER, timeout: 0);
2494	fallthrough;
2495	case SFP_MOD_HPOWER:
2496	/* Enable high power mode */
2497	err = sfp_sm_mod_hpower(sfp, enable: true);
2498	if (err < 0) {
2499	if (err != -EAGAIN) {
2500	sfp_module_remove(bus: sfp->sfp_bus);
2501	sfp_sm_mod_next(sfp, state: SFP_MOD_ERROR, timeout: 0);
2502	} else {
2503	sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT);
2504	}
2505	break;
2506	}
2507
2508	sfp_sm_mod_next(sfp, state: SFP_MOD_WAITPWR, T_HPOWER_LEVEL);
2509	break;
2510
2511	case SFP_MOD_WAITPWR:
2512	/* Wait for T_HPOWER_LEVEL to time out */
2513	if (event != SFP_E_TIMEOUT)
2514	break;
2515
2516	insert:
2517	sfp_sm_mod_next(sfp, state: SFP_MOD_PRESENT, timeout: 0);
2518	break;
2519
2520	case SFP_MOD_PRESENT:
2521	case SFP_MOD_ERROR:
2522	break;
2523	}
2524	}
2525
2526	static void sfp_sm_main(struct sfp *sfp, unsigned int event)
2527	{
2528	unsigned long timeout;
2529	int ret;
2530
2531	/* Some events are global */
2532	if (sfp->sm_state != SFP_S_DOWN &&
2533	(sfp->sm_mod_state != SFP_MOD_PRESENT ||
2534	sfp->sm_dev_state != SFP_DEV_UP)) {
2535	if (sfp->sm_state == SFP_S_LINK_UP &&
2536	sfp->sm_dev_state == SFP_DEV_UP)
2537	sfp_sm_link_down(sfp);
2538	if (sfp->sm_state > SFP_S_INIT)
2539	sfp_module_stop(bus: sfp->sfp_bus);
2540	if (sfp->mod_phy)
2541	sfp_sm_phy_detach(sfp);
2542	if (sfp->i2c_mii)
2543	sfp_i2c_mdiobus_destroy(sfp);
2544	sfp_module_tx_disable(sfp);
2545	sfp_soft_stop_poll(sfp);
2546	sfp_sm_next(sfp, state: SFP_S_DOWN, timeout: 0);
2547	return;
2548	}
2549
2550	/* The main state machine */
2551	switch (sfp->sm_state) {
2552	case SFP_S_DOWN:
2553	if (sfp->sm_mod_state != SFP_MOD_PRESENT ||
2554	sfp->sm_dev_state != SFP_DEV_UP)
2555	break;
2556
2557	/* Only use the soft state bits if we have access to the A2h
2558	* memory, which implies that we have some level of SFF-8472
2559	* compliance.
2560	*/
2561	if (sfp->have_a2)
2562	sfp_soft_start_poll(sfp);
2563
2564	sfp_module_tx_enable(sfp);
2565
2566	/* Initialise the fault clearance retries */
2567	sfp->sm_fault_retries = N_FAULT_INIT;
2568
2569	/* We need to check the TX_FAULT state, which is not defined
2570	* while TX_DISABLE is asserted. The earliest we want to do
2571	* anything (such as probe for a PHY) is 50ms (or more on
2572	* specific modules).
2573	*/
2574	sfp_sm_next(sfp, state: SFP_S_WAIT, timeout: sfp->module_t_wait);
2575	break;
2576
2577	case SFP_S_WAIT:
2578	if (event != SFP_E_TIMEOUT)
2579	break;
2580
2581	if (sfp->state & SFP_F_TX_FAULT) {
2582	/* Wait up to t_init (SFF-8472) or t_start_up (SFF-8431)
2583	* from the TX_DISABLE deassertion for the module to
2584	* initialise, which is indicated by TX_FAULT
2585	* deasserting.
2586	*/
2587	timeout = sfp->module_t_start_up;
2588	if (timeout > sfp->module_t_wait)
2589	timeout -= sfp->module_t_wait;
2590	else
2591	timeout = 1;
2592
2593	sfp_sm_next(sfp, state: SFP_S_INIT, timeout);
2594	} else {
2595	/* TX_FAULT is not asserted, assume the module has
2596	* finished initialising.
2597	*/
2598	goto init_done;
2599	}
2600	break;
2601
2602	case SFP_S_INIT:
2603	if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
2604	/* TX_FAULT is still asserted after t_init
2605	* or t_start_up, so assume there is a fault.
2606	*/
2607	sfp_sm_fault(sfp, next_state: SFP_S_INIT_TX_FAULT,
2608	warn: sfp->sm_fault_retries == N_FAULT_INIT);
2609	} else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) {
2610	init_done:
2611	/* Create mdiobus and start trying for PHY */
2612	ret = sfp_sm_add_mdio_bus(sfp);
2613	if (ret < 0) {
2614	sfp_sm_next(sfp, state: SFP_S_FAIL, timeout: 0);
2615	break;
2616	}
2617	sfp->sm_phy_retries = R_PHY_RETRY;
2618	goto phy_probe;
2619	}
2620	break;
2621
2622	case SFP_S_INIT_PHY:
2623	if (event != SFP_E_TIMEOUT)
2624	break;
2625	phy_probe:
2626	/* TX_FAULT deasserted or we timed out with TX_FAULT
2627	* clear. Probe for the PHY and check the LOS state.
2628	*/
2629	ret = sfp_sm_probe_for_phy(sfp);
2630	if (ret == -ENODEV) {
2631	if (--sfp->sm_phy_retries) {
2632	sfp_sm_next(sfp, state: SFP_S_INIT_PHY, T_PHY_RETRY);
2633	break;
2634	} else {
2635	dev_info(sfp->dev, "no PHY detected\n");
2636	}
2637	} else if (ret) {
2638	sfp_sm_next(sfp, state: SFP_S_FAIL, timeout: 0);
2639	break;
2640	}
2641	if (sfp_module_start(bus: sfp->sfp_bus)) {
2642	sfp_sm_next(sfp, state: SFP_S_FAIL, timeout: 0);
2643	break;
2644	}
2645	sfp_sm_link_check_los(sfp);
2646
2647	/* Reset the fault retry count */
2648	sfp->sm_fault_retries = N_FAULT;
2649	break;
2650
2651	case SFP_S_INIT_TX_FAULT:
2652	if (event == SFP_E_TIMEOUT) {
2653	sfp_module_tx_fault_reset(sfp);
2654	sfp_sm_next(sfp, state: SFP_S_INIT, timeout: sfp->module_t_start_up);
2655	}
2656	break;
2657
2658	case SFP_S_WAIT_LOS:
2659	if (event == SFP_E_TX_FAULT)
2660	sfp_sm_fault(sfp, next_state: SFP_S_TX_FAULT, warn: true);
2661	else if (sfp_los_event_inactive(sfp, event))
2662	sfp_sm_link_up(sfp);
2663	break;
2664
2665	case SFP_S_LINK_UP:
2666	if (event == SFP_E_TX_FAULT) {
2667	sfp_sm_link_down(sfp);
2668	sfp_sm_fault(sfp, next_state: SFP_S_TX_FAULT, warn: true);
2669	} else if (sfp_los_event_active(sfp, event)) {
2670	sfp_sm_link_down(sfp);
2671	sfp_sm_next(sfp, state: SFP_S_WAIT_LOS, timeout: 0);
2672	}
2673	break;
2674
2675	case SFP_S_TX_FAULT:
2676	if (event == SFP_E_TIMEOUT) {
2677	sfp_module_tx_fault_reset(sfp);
2678	sfp_sm_next(sfp, state: SFP_S_REINIT, timeout: sfp->module_t_start_up);
2679	}
2680	break;
2681
2682	case SFP_S_REINIT:
2683	if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
2684	sfp_sm_fault(sfp, next_state: SFP_S_TX_FAULT, warn: false);
2685	} else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) {
2686	dev_info(sfp->dev, "module transmit fault recovered\n");
2687	sfp_sm_link_check_los(sfp);
2688	}
2689	break;
2690
2691	case SFP_S_TX_DISABLE:
2692	break;
2693	}
2694	}
2695
2696	static void __sfp_sm_event(struct sfp *sfp, unsigned int event)
2697	{
2698	dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n",
2699	mod_state_to_str(sfp->sm_mod_state),
2700	dev_state_to_str(sfp->sm_dev_state),
2701	sm_state_to_str(sfp->sm_state),
2702	event_to_str(event));
2703
2704	sfp_sm_device(sfp, event);
2705	sfp_sm_module(sfp, event);
2706	sfp_sm_main(sfp, event);
2707
2708	dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n",
2709	mod_state_to_str(sfp->sm_mod_state),
2710	dev_state_to_str(sfp->sm_dev_state),
2711	sm_state_to_str(sfp->sm_state));
2712	}
2713
2714	static void sfp_sm_event(struct sfp *sfp, unsigned int event)
2715	{
2716	mutex_lock(&sfp->sm_mutex);
2717	__sfp_sm_event(sfp, event);
2718	mutex_unlock(lock: &sfp->sm_mutex);
2719	}
2720
2721	static void sfp_attach(struct sfp *sfp)
2722	{
2723	sfp_sm_event(sfp, event: SFP_E_DEV_ATTACH);
2724	}
2725
2726	static void sfp_detach(struct sfp *sfp)
2727	{
2728	sfp_sm_event(sfp, event: SFP_E_DEV_DETACH);
2729	}
2730
2731	static void sfp_start(struct sfp *sfp)
2732	{
2733	sfp_sm_event(sfp, event: SFP_E_DEV_UP);
2734	}
2735
2736	static void sfp_stop(struct sfp *sfp)
2737	{
2738	sfp_sm_event(sfp, event: SFP_E_DEV_DOWN);
2739	}
2740
2741	static void sfp_set_signal_rate(struct sfp *sfp, unsigned int rate_kbd)
2742	{
2743	unsigned int set;
2744
2745	sfp->rate_kbd = rate_kbd;
2746
2747	if (rate_kbd > sfp->rs_threshold_kbd)
2748	set = sfp->rs_state_mask;
2749	else
2750	set = 0;
2751
2752	sfp_mod_state(sfp, mask: SFP_F_RS0 | SFP_F_RS1, set);
2753	}
2754
2755	static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo)
2756	{
2757	/* locking... and check module is present */
2758
2759	if (sfp->id.ext.sff8472_compliance &&
2760	!(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) {
2761	modinfo->type = ETH_MODULE_SFF_8472;
2762	modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
2763	} else {
2764	modinfo->type = ETH_MODULE_SFF_8079;
2765	modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
2766	}
2767	return 0;
2768	}
2769
2770	static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee,
2771	u8 *data)
2772	{
2773	unsigned int first, last, len;
2774	int ret;
2775
2776	if (!(sfp->state & SFP_F_PRESENT))
2777	return -ENODEV;
2778
2779	if (ee->len == 0)
2780	return -EINVAL;
2781
2782	first = ee->offset;
2783	last = ee->offset + ee->len;
2784	if (first < ETH_MODULE_SFF_8079_LEN) {
2785	len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN);
2786	len -= first;
2787
2788	ret = sfp_read(sfp, a2: false, addr: first, buf: data, len);
2789	if (ret < 0)
2790	return ret;
2791
2792	first += len;
2793	data += len;
2794	}
2795	if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) {
2796	len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN);
2797	len -= first;
2798	first -= ETH_MODULE_SFF_8079_LEN;
2799
2800	ret = sfp_read(sfp, a2: true, addr: first, buf: data, len);
2801	if (ret < 0)
2802	return ret;
2803	}
2804	return 0;
2805	}
2806
2807	static int sfp_module_eeprom_by_page(struct sfp *sfp,
2808	const struct ethtool_module_eeprom *page,
2809	struct netlink_ext_ack *extack)
2810	{
2811	if (!(sfp->state & SFP_F_PRESENT))
2812	return -ENODEV;
2813
2814	if (page->bank) {
2815	NL_SET_ERR_MSG(extack, "Banks not supported");
2816	return -EOPNOTSUPP;
2817	}
2818
2819	if (page->page) {
2820	NL_SET_ERR_MSG(extack, "Only page 0 supported");
2821	return -EOPNOTSUPP;
2822	}
2823
2824	if (page->i2c_address != 0x50 &&
2825	page->i2c_address != 0x51) {
2826	NL_SET_ERR_MSG(extack, "Only address 0x50 and 0x51 supported");
2827	return -EOPNOTSUPP;
2828	}
2829
2830	return sfp_read(sfp, a2: page->i2c_address == 0x51, addr: page->offset,
2831	buf: page->data, len: page->length);
2832	};
2833
2834	static const struct sfp_socket_ops sfp_module_ops = {
2835	.attach = sfp_attach,
2836	.detach = sfp_detach,
2837	.start = sfp_start,
2838	.stop = sfp_stop,
2839	.set_signal_rate = sfp_set_signal_rate,
2840	.module_info = sfp_module_info,
2841	.module_eeprom = sfp_module_eeprom,
2842	.module_eeprom_by_page = sfp_module_eeprom_by_page,
2843	};
2844
2845	static void sfp_timeout(struct work_struct *work)
2846	{
2847	struct sfp *sfp = container_of(work, struct sfp, timeout.work);
2848
2849	rtnl_lock();
2850	sfp_sm_event(sfp, event: SFP_E_TIMEOUT);
2851	rtnl_unlock();
2852	}
2853
2854	static void sfp_check_state(struct sfp *sfp)
2855	{
2856	unsigned int state, i, changed;
2857
2858	rtnl_lock();
2859	mutex_lock(&sfp->st_mutex);
2860	state = sfp_get_state(sfp);
2861	changed = state ^ sfp->state;
2862	changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT;
2863
2864	for (i = 0; i < GPIO_MAX; i++)
2865	if (changed & BIT(i))
2866	dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_names[i],
2867	!!(sfp->state & BIT(i)), !!(state & BIT(i)));
2868
2869	state |= sfp->state & SFP_F_OUTPUTS;
2870	sfp->state = state;
2871	mutex_unlock(lock: &sfp->st_mutex);
2872
2873	mutex_lock(&sfp->sm_mutex);
2874	if (changed & SFP_F_PRESENT)
2875	__sfp_sm_event(sfp, event: state & SFP_F_PRESENT ?
2876	SFP_E_INSERT : SFP_E_REMOVE);
2877
2878	if (changed & SFP_F_TX_FAULT)
2879	__sfp_sm_event(sfp, event: state & SFP_F_TX_FAULT ?
2880	SFP_E_TX_FAULT : SFP_E_TX_CLEAR);
2881
2882	if (changed & SFP_F_LOS)
2883	__sfp_sm_event(sfp, event: state & SFP_F_LOS ?
2884	SFP_E_LOS_HIGH : SFP_E_LOS_LOW);
2885	mutex_unlock(lock: &sfp->sm_mutex);
2886	rtnl_unlock();
2887	}
2888
2889	static irqreturn_t sfp_irq(int irq, void *data)
2890	{
2891	struct sfp *sfp = data;
2892
2893	sfp_check_state(sfp);
2894
2895	return IRQ_HANDLED;
2896	}
2897
2898	static void sfp_poll(struct work_struct *work)
2899	{
2900	struct sfp *sfp = container_of(work, struct sfp, poll.work);
2901
2902	sfp_check_state(sfp);
2903
2904	// st_mutex doesn't need to be held here for state_soft_mask,
2905	// it's unimportant if we race while reading this.
2906	if (sfp->state_soft_mask & (SFP_F_LOS | SFP_F_TX_FAULT) ||
2907	sfp->need_poll)
2908	mod_delayed_work(wq: system_wq, dwork: &sfp->poll, delay: poll_jiffies);
2909	}
2910
2911	static struct sfp *sfp_alloc(struct device *dev)
2912	{
2913	struct sfp *sfp;
2914
2915	sfp = kzalloc(size: sizeof(*sfp), GFP_KERNEL);
2916	if (!sfp)
2917	return ERR_PTR(error: -ENOMEM);
2918
2919	sfp->dev = dev;
2920	sfp->i2c_block_size = SFP_EEPROM_BLOCK_SIZE;
2921
2922	mutex_init(&sfp->sm_mutex);
2923	mutex_init(&sfp->st_mutex);
2924	INIT_DELAYED_WORK(&sfp->poll, sfp_poll);
2925	INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout);
2926
2927	sfp_hwmon_init(sfp);
2928
2929	return sfp;
2930	}
2931
2932	static void sfp_cleanup(void *data)
2933	{
2934	struct sfp *sfp = data;
2935
2936	sfp_hwmon_exit(sfp);
2937
2938	cancel_delayed_work_sync(dwork: &sfp->poll);
2939	cancel_delayed_work_sync(dwork: &sfp->timeout);
2940	if (sfp->i2c_mii) {
2941	mdiobus_unregister(bus: sfp->i2c_mii);
2942	mdiobus_free(bus: sfp->i2c_mii);
2943	}
2944	if (sfp->i2c)
2945	i2c_put_adapter(adap: sfp->i2c);
2946	kfree(objp: sfp);
2947	}
2948
2949	static int sfp_i2c_get(struct sfp *sfp)
2950	{
2951	struct fwnode_handle *h;
2952	struct i2c_adapter *i2c;
2953	int err;
2954
2955	h = fwnode_find_reference(dev_fwnode(sfp->dev), name: "i2c-bus", index: 0);
2956	if (IS_ERR(ptr: h)) {
2957	dev_err(sfp->dev, "missing 'i2c-bus' property\n");
2958	return -ENODEV;
2959	}
2960
2961	i2c = i2c_get_adapter_by_fwnode(fwnode: h);
2962	if (!i2c) {
2963	err = -EPROBE_DEFER;
2964	goto put;
2965	}
2966
2967	err = sfp_i2c_configure(sfp, i2c);
2968	if (err)
2969	i2c_put_adapter(adap: i2c);
2970	put:
2971	fwnode_handle_put(fwnode: h);
2972	return err;
2973	}
2974
2975	static int sfp_probe(struct platform_device *pdev)
2976	{
2977	const struct sff_data *sff;
2978	char *sfp_irq_name;
2979	struct sfp *sfp;
2980	int err, i;
2981
2982	sfp = sfp_alloc(dev: &pdev->dev);
2983	if (IS_ERR(ptr: sfp))
2984	return PTR_ERR(ptr: sfp);
2985
2986	platform_set_drvdata(pdev, data: sfp);
2987
2988	err = devm_add_action_or_reset(sfp->dev, sfp_cleanup, sfp);
2989	if (err < 0)
2990	return err;
2991
2992	sff = device_get_match_data(dev: sfp->dev);
2993	if (!sff)
2994	sff = &sfp_data;
2995
2996	sfp->type = sff;
2997
2998	err = sfp_i2c_get(sfp);
2999	if (err)
3000	return err;
3001
3002	for (i = 0; i < GPIO_MAX; i++)
3003	if (sff->gpios & BIT(i)) {
3004	sfp->gpio[i] = devm_gpiod_get_optional(dev: sfp->dev,
3005	con_id: gpio_names[i], flags: gpio_flags[i]);
3006	if (IS_ERR(ptr: sfp->gpio[i]))
3007	return PTR_ERR(ptr: sfp->gpio[i]);
3008	}
3009
3010	sfp->state_hw_mask = SFP_F_PRESENT;
3011	sfp->state_hw_drive = SFP_F_TX_DISABLE;
3012
3013	sfp->get_state = sfp_gpio_get_state;
3014	sfp->set_state = sfp_gpio_set_state;
3015
3016	/* Modules that have no detect signal are always present */
3017	if (!(sfp->gpio[GPIO_MODDEF0]))
3018	sfp->get_state = sff_gpio_get_state;
3019
3020	device_property_read_u32(dev: &pdev->dev, propname: "maximum-power-milliwatt",
3021	val: &sfp->max_power_mW);
3022	if (sfp->max_power_mW < 1000) {
3023	if (sfp->max_power_mW)
3024	dev_warn(sfp->dev,
3025	"Firmware bug: host maximum power should be at least 1W\n");
3026	sfp->max_power_mW = 1000;
3027	}
3028
3029	dev_info(sfp->dev, "Host maximum power %u.%uW\n",
3030	sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10);
3031
3032	/* Get the initial state, and always signal TX disable,
3033	* since the network interface will not be up.
3034	*/
3035	sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE;
3036
3037	if (sfp->gpio[GPIO_RS0] &&
3038	gpiod_get_value_cansleep(desc: sfp->gpio[GPIO_RS0]))
3039	sfp->state |= SFP_F_RS0;
3040	sfp_set_state(sfp, state: sfp->state);
3041	sfp_module_tx_disable(sfp);
3042	if (sfp->state & SFP_F_PRESENT) {
3043	rtnl_lock();
3044	sfp_sm_event(sfp, event: SFP_E_INSERT);
3045	rtnl_unlock();
3046	}
3047
3048	for (i = 0; i < GPIO_MAX; i++) {
3049	if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
3050	continue;
3051
3052	sfp->gpio_irq[i] = gpiod_to_irq(desc: sfp->gpio[i]);
3053	if (sfp->gpio_irq[i] < 0) {
3054	sfp->gpio_irq[i] = 0;
3055	sfp->need_poll = true;
3056	continue;
3057	}
3058
3059	sfp_irq_name = devm_kasprintf(dev: sfp->dev, GFP_KERNEL,
3060	fmt: "%s-%s", dev_name(dev: sfp->dev),
3061	gpio_names[i]);
3062
3063	if (!sfp_irq_name)
3064	return -ENOMEM;
3065
3066	err = devm_request_threaded_irq(dev: sfp->dev, irq: sfp->gpio_irq[i],
3067	NULL, thread_fn: sfp_irq,
3068	IRQF_ONESHOT |
3069	IRQF_TRIGGER_RISING |
3070	IRQF_TRIGGER_FALLING,
3071	devname: sfp_irq_name, dev_id: sfp);
3072	if (err) {
3073	sfp->gpio_irq[i] = 0;
3074	sfp->need_poll = true;
3075	}
3076	}
3077
3078	if (sfp->need_poll)
3079	mod_delayed_work(wq: system_wq, dwork: &sfp->poll, delay: poll_jiffies);
3080
3081	/* We could have an issue in cases no Tx disable pin is available or
3082	* wired as modules using a laser as their light source will continue to
3083	* be active when the fiber is removed. This could be a safety issue and
3084	* we should at least warn the user about that.
3085	*/
3086	if (!sfp->gpio[GPIO_TX_DISABLE])
3087	dev_warn(sfp->dev,
3088	"No tx_disable pin: SFP modules will always be emitting.\n");
3089
3090	sfp->sfp_bus = sfp_register_socket(dev: sfp->dev, sfp, ops: &sfp_module_ops);
3091	if (!sfp->sfp_bus)
3092	return -ENOMEM;
3093
3094	sfp_debugfs_init(sfp);
3095
3096	return 0;
3097	}
3098
3099	static int sfp_remove(struct platform_device *pdev)
3100	{
3101	struct sfp *sfp = platform_get_drvdata(pdev);
3102
3103	sfp_debugfs_exit(sfp);
3104	sfp_unregister_socket(bus: sfp->sfp_bus);
3105
3106	rtnl_lock();
3107	sfp_sm_event(sfp, event: SFP_E_REMOVE);
3108	rtnl_unlock();
3109
3110	return 0;
3111	}
3112
3113	static void sfp_shutdown(struct platform_device *pdev)
3114	{
3115	struct sfp *sfp = platform_get_drvdata(pdev);
3116	int i;
3117
3118	for (i = 0; i < GPIO_MAX; i++) {
3119	if (!sfp->gpio_irq[i])
3120	continue;
3121
3122	devm_free_irq(dev: sfp->dev, irq: sfp->gpio_irq[i], dev_id: sfp);
3123	}
3124
3125	cancel_delayed_work_sync(dwork: &sfp->poll);
3126	cancel_delayed_work_sync(dwork: &sfp->timeout);
3127	}
3128
3129	static struct platform_driver sfp_driver = {
3130	.probe = sfp_probe,
3131	.remove = sfp_remove,
3132	.shutdown = sfp_shutdown,
3133	.driver = {
3134	.name = "sfp",
3135	.of_match_table = sfp_of_match,
3136	},
3137	};
3138
3139	static int sfp_init(void)
3140	{
3141	poll_jiffies = msecs_to_jiffies(m: 100);
3142
3143	return platform_driver_register(&sfp_driver);
3144	}
3145	module_init(sfp_init);
3146
3147	static void sfp_exit(void)
3148	{
3149	platform_driver_unregister(&sfp_driver);
3150	}
3151	module_exit(sfp_exit);
3152
3153	MODULE_ALIAS("platform:sfp");
3154	MODULE_AUTHOR("Russell King");
3155	MODULE_LICENSE("GPL v2");
3156