~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,5 @@
	1	+// SPDX-License-Identifier: GPL-2.0
	2	+#include <linux/acpi.h>
1	3	#include <linux/ctype.h>
2	4	#include <linux/delay.h>
3	5	#include <linux/gpio/consumer.h>
..	..	@@ -5,6 +7,7 @@
5	7	#include <linux/i2c.h>
6	8	#include <linux/interrupt.h>
7	9	#include <linux/jiffies.h>
	10	+#include <linux/mdio/mdio-i2c.h>
8	11	#include <linux/module.h>
9	12	#include <linux/mutex.h>
10	13	#include <linux/of.h>
..	..	@@ -14,7 +17,6 @@
14	17	#include <linux/slab.h>
15	18	#include <linux/workqueue.h>
16	19
17		-#include "mdio-i2c.h"
18	20	#include "sfp.h"
19	21	#include "swphy.h"
20	22
..	..	@@ -34,6 +36,8 @@
34	36
35	37	SFP_E_INSERT = 0,
36	38	SFP_E_REMOVE,
	39	+ SFP_E_DEV_ATTACH,
	40	+ SFP_E_DEV_DETACH,
37	41	SFP_E_DEV_DOWN,
38	42	SFP_E_DEV_UP,
39	43	SFP_E_TX_FAULT,
..	..	@@ -43,16 +47,23 @@
43	47	SFP_E_TIMEOUT,
44	48
45	49	SFP_MOD_EMPTY = 0,
46		- SFP_MOD_PROBE,
47		- SFP_MOD_HPOWER,
48		- SFP_MOD_PRESENT,
49	50	SFP_MOD_ERROR,
	51	+ SFP_MOD_PROBE,
	52	+ SFP_MOD_WAITDEV,
	53	+ SFP_MOD_HPOWER,
	54	+ SFP_MOD_WAITPWR,
	55	+ SFP_MOD_PRESENT,
50	56
51		- SFP_DEV_DOWN = 0,
	57	+ SFP_DEV_DETACHED = 0,
	58	+ SFP_DEV_DOWN,
52	59	SFP_DEV_UP,
53	60
54	61	SFP_S_DOWN = 0,
	62	+ SFP_S_FAIL,
	63	+ SFP_S_WAIT,
55	64	SFP_S_INIT,
	65	+ SFP_S_INIT_PHY,
	66	+ SFP_S_INIT_TX_FAULT,
56	67	SFP_S_WAIT_LOS,
57	68	SFP_S_LINK_UP,
58	69	SFP_S_TX_FAULT,
..	..	@@ -62,10 +73,12 @@
62	73
63	74	static const char * const mod_state_strings[] = {
64	75	[SFP_MOD_EMPTY] = "empty",
65		- [SFP_MOD_PROBE] = "probe",
66		- [SFP_MOD_HPOWER] = "hpower",
67		- [SFP_MOD_PRESENT] = "present",
68	76	[SFP_MOD_ERROR] = "error",
	77	+ [SFP_MOD_PROBE] = "probe",
	78	+ [SFP_MOD_WAITDEV] = "waitdev",
	79	+ [SFP_MOD_HPOWER] = "hpower",
	80	+ [SFP_MOD_WAITPWR] = "waitpwr",
	81	+ [SFP_MOD_PRESENT] = "present",
69	82	};
70	83
71	84	static const char *mod_state_to_str(unsigned short mod_state)
..	..	@@ -76,6 +89,7 @@
76	89	}
77	90
78	91	static const char * const dev_state_strings[] = {
	92	+ [SFP_DEV_DETACHED] = "detached",
79	93	[SFP_DEV_DOWN] = "down",
80	94	[SFP_DEV_UP] = "up",
81	95	};
..	..	@@ -90,6 +104,8 @@
90	104	static const char * const event_strings[] = {
91	105	[SFP_E_INSERT] = "insert",
92	106	[SFP_E_REMOVE] = "remove",
	107	+ [SFP_E_DEV_ATTACH] = "dev_attach",
	108	+ [SFP_E_DEV_DETACH] = "dev_detach",
93	109	[SFP_E_DEV_DOWN] = "dev_down",
94	110	[SFP_E_DEV_UP] = "dev_up",
95	111	[SFP_E_TX_FAULT] = "tx_fault",
..	..	@@ -108,7 +124,11 @@
108	124
109	125	static const char * const sm_state_strings[] = {
110	126	[SFP_S_DOWN] = "down",
	127	+ [SFP_S_FAIL] = "fail",
	128	+ [SFP_S_WAIT] = "wait",
111	129	[SFP_S_INIT] = "init",
	130	+ [SFP_S_INIT_PHY] = "init_phy",
	131	+ [SFP_S_INIT_TX_FAULT] = "init_tx_fault",
112	132	[SFP_S_WAIT_LOS] = "wait_los",
113	133	[SFP_S_LINK_UP] = "link_up",
114	134	[SFP_S_TX_FAULT] = "tx_fault",
..	..	@@ -139,29 +159,53 @@
139	159	GPIOD_ASIS,
140	160	};
141	161
142		-#define T_INIT_JIFFIES msecs_to_jiffies(300)
143		-#define T_RESET_US 10
144		-#define T_FAULT_RECOVER msecs_to_jiffies(1000)
	162	+/* t_start_up (SFF-8431) or t_init (SFF-8472) is the time required for a
	163	+ * non-cooled module to initialise its laser safety circuitry. We wait
	164	+ * an initial T_WAIT period before we check the tx fault to give any PHY
	165	+ * on board (for a copper SFP) time to initialise.
	166	+ */
	167	+#define T_WAIT msecs_to_jiffies(50)
	168	+#define T_START_UP msecs_to_jiffies(300)
	169	+#define T_START_UP_BAD_GPON msecs_to_jiffies(60000)
	170	+
	171	+/* t_reset is the time required to assert the TX_DISABLE signal to reset
	172	+ * an indicated TX_FAULT.
	173	+ */
	174	+#define T_RESET_US 10
	175	+#define T_FAULT_RECOVER msecs_to_jiffies(1000)
	176	+
	177	+/* N_FAULT_INIT is the number of recovery attempts at module initialisation
	178	+ * time. If the TX_FAULT signal is not deasserted after this number of
	179	+ * attempts at clearing it, we decide that the module is faulty.
	180	+ * N_FAULT is the same but after the module has initialised.
	181	+ */
	182	+#define N_FAULT_INIT 5
	183	+#define N_FAULT 5
	184	+
	185	+/* T_PHY_RETRY is the time interval between attempts to probe the PHY.
	186	+ * R_PHY_RETRY is the number of attempts.
	187	+ */
	188	+#define T_PHY_RETRY msecs_to_jiffies(50)
	189	+#define R_PHY_RETRY 12
145	190
146	191	/* SFP module presence detection is poor: the three MOD DEF signals are
147	192	* the same length on the PCB, which means it's possible for MOD DEF 0 to
148	193	* connect before the I2C bus on MOD DEF 1/2.
149	194	*
150		- * The SFP MSA specifies 300ms as t_init (the time taken for TX_FAULT to
151		- * be deasserted) but makes no mention of the earliest time before we can
152		- * access the I2C EEPROM. However, Avago modules require 300ms.
	195	+ * The SFF-8472 specifies t_serial ("Time from power on until module is
	196	+ * ready for data transmission over the two wire serial bus.") as 300ms.
153	197	*/
154		-#define T_PROBE_INIT msecs_to_jiffies(300)
155		-#define T_HPOWER_LEVEL msecs_to_jiffies(300)
156		-#define T_PROBE_RETRY msecs_to_jiffies(100)
	198	+#define T_SERIAL msecs_to_jiffies(300)
	199	+#define T_HPOWER_LEVEL msecs_to_jiffies(300)
	200	+#define T_PROBE_RETRY_INIT msecs_to_jiffies(100)
	201	+#define R_PROBE_RETRY_INIT 10
	202	+#define T_PROBE_RETRY_SLOW msecs_to_jiffies(5000)
	203	+#define R_PROBE_RETRY_SLOW 12
157	204
158	205	/* SFP modules appear to always have their PHY configured for bus address
159	206	* 0x56 (which with mdio-i2c, translates to a PHY address of 22).
160	207	*/
161	208	#define SFP_PHY_ADDR 22
162		-
163		-/* Give this long for the PHY to reset. */
164		-#define T_PHY_RESET_MS 50
165	209
166	210	struct sff_data {
167	211	unsigned int gpios;
..	..	@@ -175,6 +219,7 @@
175	219	struct sfp_bus *sfp_bus;
176	220	struct phy_device *mod_phy;
177	221	const struct sff_data *type;
	222	+ size_t i2c_block_size;
178	223	u32 max_power_mW;
179	224
180	225	unsigned int (get_state)(struct sfp );
..	..	@@ -183,21 +228,33 @@
183	228	int (write)(struct sfp , bool, u8, void *, size_t);
184	229
185	230	struct gpio_desc *gpio[GPIO_MAX];
	231	+ int gpio_irq[GPIO_MAX];
186	232
187		- bool attached;
	233	+ bool need_poll;
	234	+
188	235	struct mutex st_mutex; /* Protects state */
	236	+ unsigned int state_soft_mask;
189	237	unsigned int state;
190	238	struct delayed_work poll;
191	239	struct delayed_work timeout;
192	240	struct mutex sm_mutex; /* Protects state machine */
193	241	unsigned char sm_mod_state;
	242	+ unsigned char sm_mod_tries_init;
	243	+ unsigned char sm_mod_tries;
194	244	unsigned char sm_dev_state;
195	245	unsigned short sm_state;
196		- unsigned int sm_retries;
	246	+ unsigned char sm_fault_retries;
	247	+ unsigned char sm_phy_retries;
197	248
198	249	struct sfp_eeprom_id id;
	250	+ unsigned int module_power_mW;
	251	+ unsigned int module_t_start_up;
	252	+ bool tx_fault_ignore;
	253	+
199	254	#if IS_ENABLED(CONFIG_HWMON)
200	255	struct sfp_diag diag;
	256	+ struct delayed_work hwmon_probe;
	257	+ unsigned int hwmon_tries;
201	258	struct device *hwmon_dev;
202	259	char *hwmon_name;
203	260	#endif
..	..	@@ -206,7 +263,7 @@
206	263
207	264	static bool sff_module_supported(const struct sfp_eeprom_id *id)
208	265	{
209		- return id->base.phys_id == SFP_PHYS_ID_SFF &&
	266	+ return id->base.phys_id == SFF8024_ID_SFF_8472 &&
210	267	id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
211	268	}
212	269
..	..	@@ -217,8 +274,21 @@
217	274
218	275	static bool sfp_module_supported(const struct sfp_eeprom_id *id)
219	276	{
220		- return id->base.phys_id == SFP_PHYS_ID_SFP &&
221		- id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
	277	+ if (id->base.phys_id == SFF8024_ID_SFP &&
	278	+ id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP)
	279	+ return true;
	280	+
	281	+ /* SFP GPON module Ubiquiti U-Fiber Instant has in its EEPROM stored
	282	+ * phys id SFF instead of SFP. Therefore mark this module explicitly
	283	+ * as supported based on vendor name and pn match.
	284	+ */
	285	+ if (id->base.phys_id == SFF8024_ID_SFF_8472 &&
	286	+ id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP &&
	287	+ !memcmp(id->base.vendor_name, "UBNT ", 16) &&
	288	+ !memcmp(id->base.vendor_pn, "UF-INSTANT ", 16))
	289	+ return true;
	290	+
	291	+ return false;
222	292	}
223	293
224	294	static const struct sff_data sfp_data = {
..	..	@@ -281,6 +351,7 @@
281	351	{
282	352	struct i2c_msg msgs[2];
283	353	u8 bus_addr = a2 ? 0x51 : 0x50;
	354	+ size_t block_size = sfp->i2c_block_size;
284	355	size_t this_len;
285	356	int ret;
286	357
..	..	@@ -295,8 +366,8 @@
295	366
296	367	while (len) {
297	368	this_len = len;
298		- if (this_len > 16)
299		- this_len = 16;
	369	+ if (this_len > block_size)
	370	+ this_len = block_size;
300	371
301	372	msgs[1].len = this_len;
302	373
..	..	@@ -373,16 +444,6 @@
373	444	}
374	445
375	446	/* Interface */
376		-static unsigned int sfp_get_state(struct sfp *sfp)
377		-{
378		- return sfp->get_state(sfp);
379		-}
380		-
381		-static void sfp_set_state(struct sfp *sfp, unsigned int state)
382		-{
383		- sfp->set_state(sfp, state);
384		-}
385		-
386	447	static int sfp_read(struct sfp sfp, bool a2, u8 addr, void buf, size_t len)
387	448	{
388	449	return sfp->read(sfp, a2, addr, buf, len);
..	..	@@ -391,6 +452,89 @@
391	452	static int sfp_write(struct sfp sfp, bool a2, u8 addr, void buf, size_t len)
392	453	{
393	454	return sfp->write(sfp, a2, addr, buf, len);
	455	+}
	456	+
	457	+static unsigned int sfp_soft_get_state(struct sfp *sfp)
	458	+{
	459	+ unsigned int state = 0;
	460	+ u8 status;
	461	+ int ret;
	462	+
	463	+ ret = sfp_read(sfp, true, SFP_STATUS, &status, sizeof(status));
	464	+ if (ret == sizeof(status)) {
	465	+ if (status & SFP_STATUS_RX_LOS)
	466	+ state \|= SFP_F_LOS;
	467	+ if (status & SFP_STATUS_TX_FAULT)
	468	+ state \|= SFP_F_TX_FAULT;
	469	+ } else {
	470	+ dev_err_ratelimited(sfp->dev,
	471	+ "failed to read SFP soft status: %d\n",
	472	+ ret);
	473	+ /* Preserve the current state */
	474	+ state = sfp->state;
	475	+ }
	476	+
	477	+ return state & sfp->state_soft_mask;
	478	+}
	479	+
	480	+static void sfp_soft_set_state(struct sfp *sfp, unsigned int state)
	481	+{
	482	+ u8 status;
	483	+
	484	+ if (sfp_read(sfp, true, SFP_STATUS, &status, sizeof(status)) ==
	485	+ sizeof(status)) {
	486	+ if (state & SFP_F_TX_DISABLE)
	487	+ status \|= SFP_STATUS_TX_DISABLE_FORCE;
	488	+ else
	489	+ status &= ~SFP_STATUS_TX_DISABLE_FORCE;
	490	+
	491	+ sfp_write(sfp, true, SFP_STATUS, &status, sizeof(status));
	492	+ }
	493	+}
	494	+
	495	+static void sfp_soft_start_poll(struct sfp *sfp)
	496	+{
	497	+ const struct sfp_eeprom_id *id = &sfp->id;
	498	+
	499	+ sfp->state_soft_mask = 0;
	500	+ if (id->ext.enhopts & SFP_ENHOPTS_SOFT_TX_DISABLE &&
	501	+ !sfp->gpio[GPIO_TX_DISABLE])
	502	+ sfp->state_soft_mask \|= SFP_F_TX_DISABLE;
	503	+ if (id->ext.enhopts & SFP_ENHOPTS_SOFT_TX_FAULT &&
	504	+ !sfp->gpio[GPIO_TX_FAULT])
	505	+ sfp->state_soft_mask \|= SFP_F_TX_FAULT;
	506	+ if (id->ext.enhopts & SFP_ENHOPTS_SOFT_RX_LOS &&
	507	+ !sfp->gpio[GPIO_LOS])
	508	+ sfp->state_soft_mask \|= SFP_F_LOS;
	509	+
	510	+ if (sfp->state_soft_mask & (SFP_F_LOS \| SFP_F_TX_FAULT) &&
	511	+ !sfp->need_poll)
	512	+ mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
	513	+}
	514	+
	515	+static void sfp_soft_stop_poll(struct sfp *sfp)
	516	+{
	517	+ sfp->state_soft_mask = 0;
	518	+}
	519	+
	520	+static unsigned int sfp_get_state(struct sfp *sfp)
	521	+{
	522	+ unsigned int state = sfp->get_state(sfp);
	523	+
	524	+ if (state & SFP_F_PRESENT &&
	525	+ sfp->state_soft_mask & (SFP_F_LOS \| SFP_F_TX_FAULT))
	526	+ state \|= sfp_soft_get_state(sfp);
	527	+
	528	+ return state;
	529	+}
	530	+
	531	+static void sfp_set_state(struct sfp *sfp, unsigned int state)
	532	+{
	533	+ sfp->set_state(sfp, state);
	534	+
	535	+ if (state & SFP_F_PRESENT &&
	536	+ sfp->state_soft_mask & SFP_F_TX_DISABLE)
	537	+ sfp_soft_set_state(sfp, state);
394	538	}
395	539
396	540	static unsigned int sfp_check(void *buf, size_t len)
..	..	@@ -424,8 +568,9 @@
424	568	case hwmon_temp_crit:
425	569	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
426	570	return 0;
427		- /* fall through */
	571	+ fallthrough;
428	572	case hwmon_temp_input:
	573	+ case hwmon_temp_label:
429	574	return 0444;
430	575	default:
431	576	return 0;
..	..	@@ -442,8 +587,9 @@
442	587	case hwmon_in_crit:
443	588	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
444	589	return 0;
445		- /* fall through */
	590	+ fallthrough;
446	591	case hwmon_in_input:
	592	+ case hwmon_in_label:
447	593	return 0444;
448	594	default:
449	595	return 0;
..	..	@@ -460,8 +606,9 @@
460	606	case hwmon_curr_crit:
461	607	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
462	608	return 0;
463		- /* fall through */
	609	+ fallthrough;
464	610	case hwmon_curr_input:
	611	+ case hwmon_curr_label:
465	612	return 0444;
466	613	default:
467	614	return 0;
..	..	@@ -487,8 +634,9 @@
487	634	case hwmon_power_crit:
488	635	if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
489	636	return 0;
490		- /* fall through */
	637	+ fallthrough;
491	638	case hwmon_power_input:
	639	+ case hwmon_power_label:
492	640	return 0444;
493	641	default:
494	642	return 0;
..	..	@@ -984,9 +1132,63 @@
984	1132	}
985	1133	}
986	1134
	1135	+static const char *const sfp_hwmon_power_labels[] = {
	1136	+ "TX_power",
	1137	+ "RX_power",
	1138	+};
	1139	+
	1140	+static int sfp_hwmon_read_string(struct device *dev,
	1141	+ enum hwmon_sensor_types type,
	1142	+ u32 attr, int channel, const char **str)
	1143	+{
	1144	+ switch (type) {
	1145	+ case hwmon_curr:
	1146	+ switch (attr) {
	1147	+ case hwmon_curr_label:
	1148	+ *str = "bias";
	1149	+ return 0;
	1150	+ default:
	1151	+ return -EOPNOTSUPP;
	1152	+ }
	1153	+ break;
	1154	+ case hwmon_temp:
	1155	+ switch (attr) {
	1156	+ case hwmon_temp_label:
	1157	+ *str = "temperature";
	1158	+ return 0;
	1159	+ default:
	1160	+ return -EOPNOTSUPP;
	1161	+ }
	1162	+ break;
	1163	+ case hwmon_in:
	1164	+ switch (attr) {
	1165	+ case hwmon_in_label:
	1166	+ *str = "VCC";
	1167	+ return 0;
	1168	+ default:
	1169	+ return -EOPNOTSUPP;
	1170	+ }
	1171	+ break;
	1172	+ case hwmon_power:
	1173	+ switch (attr) {
	1174	+ case hwmon_power_label:
	1175	+ *str = sfp_hwmon_power_labels[channel];
	1176	+ return 0;
	1177	+ default:
	1178	+ return -EOPNOTSUPP;
	1179	+ }
	1180	+ break;
	1181	+ default:
	1182	+ return -EOPNOTSUPP;
	1183	+ }
	1184	+
	1185	+ return -EOPNOTSUPP;
	1186	+}
	1187	+
987	1188	static const struct hwmon_ops sfp_hwmon_ops = {
988	1189	.is_visible = sfp_hwmon_is_visible,
989	1190	.read = sfp_hwmon_read,
	1191	+ .read_string = sfp_hwmon_read_string,
990	1192	};
991	1193
992	1194	static u32 sfp_hwmon_chip_config[] = {
..	..	@@ -1004,7 +1206,8 @@
1004	1206	HWMON_T_MAX \| HWMON_T_MIN \|
1005	1207	HWMON_T_MAX_ALARM \| HWMON_T_MIN_ALARM \|
1006	1208	HWMON_T_CRIT \| HWMON_T_LCRIT \|
1007		- HWMON_T_CRIT_ALARM \| HWMON_T_LCRIT_ALARM,
	1209	+ HWMON_T_CRIT_ALARM \| HWMON_T_LCRIT_ALARM \|
	1210	+ HWMON_T_LABEL,
1008	1211	0,
1009	1212	};
1010	1213
..	..	@@ -1018,7 +1221,8 @@
1018	1221	HWMON_I_MAX \| HWMON_I_MIN \|
1019	1222	HWMON_I_MAX_ALARM \| HWMON_I_MIN_ALARM \|
1020	1223	HWMON_I_CRIT \| HWMON_I_LCRIT \|
1021		- HWMON_I_CRIT_ALARM \| HWMON_I_LCRIT_ALARM,
	1224	+ HWMON_I_CRIT_ALARM \| HWMON_I_LCRIT_ALARM \|
	1225	+ HWMON_I_LABEL,
1022	1226	0,
1023	1227	};
1024	1228
..	..	@@ -1032,7 +1236,8 @@
1032	1236	HWMON_C_MAX \| HWMON_C_MIN \|
1033	1237	HWMON_C_MAX_ALARM \| HWMON_C_MIN_ALARM \|
1034	1238	HWMON_C_CRIT \| HWMON_C_LCRIT \|
1035		- HWMON_C_CRIT_ALARM \| HWMON_C_LCRIT_ALARM,
	1239	+ HWMON_C_CRIT_ALARM \| HWMON_C_LCRIT_ALARM \|
	1240	+ HWMON_C_LABEL,
1036	1241	0,
1037	1242	};
1038	1243
..	..	@@ -1047,13 +1252,15 @@
1047	1252	HWMON_P_MAX \| HWMON_P_MIN \|
1048	1253	HWMON_P_MAX_ALARM \| HWMON_P_MIN_ALARM \|
1049	1254	HWMON_P_CRIT \| HWMON_P_LCRIT \|
1050		- HWMON_P_CRIT_ALARM \| HWMON_P_LCRIT_ALARM,
	1255	+ HWMON_P_CRIT_ALARM \| HWMON_P_LCRIT_ALARM \|
	1256	+ HWMON_P_LABEL,
1051	1257	/* Receive power */
1052	1258	HWMON_P_INPUT \|
1053	1259	HWMON_P_MAX \| HWMON_P_MIN \|
1054	1260	HWMON_P_MAX_ALARM \| HWMON_P_MIN_ALARM \|
1055	1261	HWMON_P_CRIT \| HWMON_P_LCRIT \|
1056		- HWMON_P_CRIT_ALARM \| HWMON_P_LCRIT_ALARM,
	1262	+ HWMON_P_CRIT_ALARM \| HWMON_P_LCRIT_ALARM \|
	1263	+ HWMON_P_LABEL,
1057	1264	0,
1058	1265	};
1059	1266
..	..	@@ -1076,10 +1283,57 @@
1076	1283	.info = sfp_hwmon_info,
1077	1284	};
1078	1285
1079		-static int sfp_hwmon_insert(struct sfp *sfp)
	1286	+static void sfp_hwmon_probe(struct work_struct *work)
1080	1287	{
	1288	+ struct sfp *sfp = container_of(work, struct sfp, hwmon_probe.work);
1081	1289	int err, i;
1082	1290
	1291	+ /* hwmon interface needs to access 16bit registers in atomic way to
	1292	+ * guarantee coherency of the diagnostic monitoring data. If it is not
	1293	+ * possible to guarantee coherency because EEPROM is broken in such way
	1294	+ * that does not support atomic 16bit read operation then we have to
	1295	+ * skip registration of hwmon device.
	1296	+ */
	1297	+ if (sfp->i2c_block_size < 2) {
	1298	+ dev_info(sfp->dev,
	1299	+ "skipping hwmon device registration due to broken EEPROM\n");
	1300	+ dev_info(sfp->dev,
	1301	+ "diagnostic EEPROM area cannot be read atomically to guarantee data coherency\n");
	1302	+ return;
	1303	+ }
	1304	+
	1305	+ err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag));
	1306	+ if (err < 0) {
	1307	+ if (sfp->hwmon_tries--) {
	1308	+ mod_delayed_work(system_wq, &sfp->hwmon_probe,
	1309	+ T_PROBE_RETRY_SLOW);
	1310	+ } else {
	1311	+ dev_warn(sfp->dev, "hwmon probe failed: %d\n", err);
	1312	+ }
	1313	+ return;
	1314	+ }
	1315	+
	1316	+ sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL);
	1317	+ if (!sfp->hwmon_name) {
	1318	+ dev_err(sfp->dev, "out of memory for hwmon name\n");
	1319	+ return;
	1320	+ }
	1321	+
	1322	+ for (i = 0; sfp->hwmon_name[i]; i++)
	1323	+ if (hwmon_is_bad_char(sfp->hwmon_name[i]))
	1324	+ sfp->hwmon_name[i] = '_';
	1325	+
	1326	+ sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev,
	1327	+ sfp->hwmon_name, sfp,
	1328	+ &sfp_hwmon_chip_info,
	1329	+ NULL);
	1330	+ if (IS_ERR(sfp->hwmon_dev))
	1331	+ dev_err(sfp->dev, "failed to register hwmon device: %ld\n",
	1332	+ PTR_ERR(sfp->hwmon_dev));
	1333	+}
	1334	+
	1335	+static int sfp_hwmon_insert(struct sfp *sfp)
	1336	+{
1083	1337	if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE)
1084	1338	return 0;
1085	1339
..	..	@@ -1092,33 +1346,32 @@
1092	1346	*/
1093	1347	return 0;
1094	1348
1095		- err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag));
1096		- if (err < 0)
1097		- return err;
	1349	+ mod_delayed_work(system_wq, &sfp->hwmon_probe, 1);
	1350	+ sfp->hwmon_tries = R_PROBE_RETRY_SLOW;
1098	1351
1099		- sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL);
1100		- if (!sfp->hwmon_name)
1101		- return -ENODEV;
1102		-
1103		- for (i = 0; sfp->hwmon_name[i]; i++)
1104		- if (hwmon_is_bad_char(sfp->hwmon_name[i]))
1105		- sfp->hwmon_name[i] = '_';
1106		-
1107		- sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev,
1108		- sfp->hwmon_name, sfp,
1109		- &sfp_hwmon_chip_info,
1110		- NULL);
1111		-
1112		- return PTR_ERR_OR_ZERO(sfp->hwmon_dev);
	1352	+ return 0;
1113	1353	}
1114	1354
1115	1355	static void sfp_hwmon_remove(struct sfp *sfp)
1116	1356	{
	1357	+ cancel_delayed_work_sync(&sfp->hwmon_probe);
1117	1358	if (!IS_ERR_OR_NULL(sfp->hwmon_dev)) {
1118	1359	hwmon_device_unregister(sfp->hwmon_dev);
1119	1360	sfp->hwmon_dev = NULL;
1120	1361	kfree(sfp->hwmon_name);
1121	1362	}
	1363	+}
	1364	+
	1365	+static int sfp_hwmon_init(struct sfp *sfp)
	1366	+{
	1367	+ INIT_DELAYED_WORK(&sfp->hwmon_probe, sfp_hwmon_probe);
	1368	+
	1369	+ return 0;
	1370	+}
	1371	+
	1372	+static void sfp_hwmon_exit(struct sfp *sfp)
	1373	+{
	1374	+ cancel_delayed_work_sync(&sfp->hwmon_probe);
1122	1375	}
1123	1376	#else
1124	1377	static int sfp_hwmon_insert(struct sfp *sfp)
..	..	@@ -1127,6 +1380,15 @@
1127	1380	}
1128	1381
1129	1382	static void sfp_hwmon_remove(struct sfp *sfp)
	1383	+{
	1384	+}
	1385	+
	1386	+static int sfp_hwmon_init(struct sfp *sfp)
	1387	+{
	1388	+ return 0;
	1389	+}
	1390	+
	1391	+static void sfp_hwmon_exit(struct sfp *sfp)
1130	1392	{
1131	1393	}
1132	1394	#endif
..	..	@@ -1179,7 +1441,7 @@
1179	1441	sfp_sm_set_timer(sfp, timeout);
1180	1442	}
1181	1443
1182		-static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state,
	1444	+static void sfp_sm_mod_next(struct sfp *sfp, unsigned int state,
1183	1445	unsigned int timeout)
1184	1446	{
1185	1447	sfp->sm_mod_state = state;
..	..	@@ -1188,28 +1450,30 @@
1188	1450
1189	1451	static void sfp_sm_phy_detach(struct sfp *sfp)
1190	1452	{
1191		- phy_stop(sfp->mod_phy);
1192	1453	sfp_remove_phy(sfp->sfp_bus);
1193	1454	phy_device_remove(sfp->mod_phy);
1194	1455	phy_device_free(sfp->mod_phy);
1195	1456	sfp->mod_phy = NULL;
1196	1457	}
1197	1458
1198		-static void sfp_sm_probe_phy(struct sfp *sfp)
	1459	+static int sfp_sm_probe_phy(struct sfp *sfp, bool is_c45)
1199	1460	{
1200	1461	struct phy_device *phy;
1201	1462	int err;
1202	1463
1203		- msleep(T_PHY_RESET_MS);
1204		-
1205		- phy = mdiobus_scan(sfp->i2c_mii, SFP_PHY_ADDR);
1206		- if (phy == ERR_PTR(-ENODEV)) {
1207		- dev_info(sfp->dev, "no PHY detected\n");
1208		- return;
1209		- }
	1464	+ phy = get_phy_device(sfp->i2c_mii, SFP_PHY_ADDR, is_c45);
	1465	+ if (phy == ERR_PTR(-ENODEV))
	1466	+ return PTR_ERR(phy);
1210	1467	if (IS_ERR(phy)) {
1211	1468	dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy));
1212		- return;
	1469	+ return PTR_ERR(phy);
	1470	+ }
	1471	+
	1472	+ err = phy_device_register(phy);
	1473	+ if (err) {
	1474	+ phy_device_free(phy);
	1475	+ dev_err(sfp->dev, "phy_device_register failed: %d\n", err);
	1476	+ return err;
1213	1477	}
1214	1478
1215	1479	err = sfp_add_phy(sfp->sfp_bus, phy);
..	..	@@ -1217,11 +1481,12 @@
1217	1481	phy_device_remove(phy);
1218	1482	phy_device_free(phy);
1219	1483	dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err);
1220		- return;
	1484	+ return err;
1221	1485	}
1222	1486
1223	1487	sfp->mod_phy = phy;
1224		- phy_start(phy);
	1488	+
	1489	+ return 0;
1225	1490	}
1226	1491
1227	1492	static void sfp_sm_link_up(struct sfp *sfp)
..	..	@@ -1237,15 +1502,19 @@
1237	1502
1238	1503	static void sfp_sm_link_check_los(struct sfp *sfp)
1239	1504	{
1240		- unsigned int los = sfp->state & SFP_F_LOS;
	1505	+ const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
	1506	+ const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
	1507	+ __be16 los_options = sfp->id.ext.options & (los_inverted \| los_normal);
	1508	+ bool los = false;
1241	1509
1242	1510	/* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL
1243		- * are set, we assume that no LOS signal is available.
	1511	+ * are set, we assume that no LOS signal is available. If both are
	1512	+ * set, we assume LOS is not implemented (and is meaningless.)
1244	1513	*/
1245		- if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED))
1246		- los ^= SFP_F_LOS;
1247		- else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL)))
1248		- los = 0;
	1514	+ if (los_options == los_inverted)
	1515	+ los = !(sfp->state & SFP_F_LOS);
	1516	+ else if (los_options == los_normal)
	1517	+ los = !!(sfp->state & SFP_F_LOS);
1249	1518
1250	1519	if (los)
1251	1520	sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
..	..	@@ -1255,23 +1524,27 @@
1255	1524
1256	1525	static bool sfp_los_event_active(struct sfp *sfp, unsigned int event)
1257	1526	{
1258		- return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1259		- event == SFP_E_LOS_LOW) \|\|
1260		- (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1261		- event == SFP_E_LOS_HIGH);
	1527	+ const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
	1528	+ const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
	1529	+ __be16 los_options = sfp->id.ext.options & (los_inverted \| los_normal);
	1530	+
	1531	+ return (los_options == los_inverted && event == SFP_E_LOS_LOW) \|\|
	1532	+ (los_options == los_normal && event == SFP_E_LOS_HIGH);
1262	1533	}
1263	1534
1264	1535	static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event)
1265	1536	{
1266		- return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1267		- event == SFP_E_LOS_HIGH) \|\|
1268		- (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1269		- event == SFP_E_LOS_LOW);
	1537	+ const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED);
	1538	+ const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL);
	1539	+ __be16 los_options = sfp->id.ext.options & (los_inverted \| los_normal);
	1540	+
	1541	+ return (los_options == los_inverted && event == SFP_E_LOS_HIGH) \|\|
	1542	+ (los_options == los_normal && event == SFP_E_LOS_LOW);
1270	1543	}
1271	1544
1272		-static void sfp_sm_fault(struct sfp *sfp, bool warn)
	1545	+static void sfp_sm_fault(struct sfp *sfp, unsigned int next_state, bool warn)
1273	1546	{
1274		- if (sfp->sm_retries && !--sfp->sm_retries) {
	1547	+ if (sfp->sm_fault_retries && !--sfp->sm_fault_retries) {
1275	1548	dev_err(sfp->dev,
1276	1549	"module persistently indicates fault, disabling\n");
1277	1550	sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0);
..	..	@@ -1279,115 +1552,251 @@
1279	1552	if (warn)
1280	1553	dev_err(sfp->dev, "module transmit fault indicated\n");
1281	1554
1282		- sfp_sm_next(sfp, SFP_S_TX_FAULT, T_FAULT_RECOVER);
	1555	+ sfp_sm_next(sfp, next_state, T_FAULT_RECOVER);
1283	1556	}
1284	1557	}
1285	1558
1286		-static void sfp_sm_mod_init(struct sfp *sfp)
	1559	+/* Probe a SFP for a PHY device if the module supports copper - the PHY
	1560	+ * normally sits at I2C bus address 0x56, and may either be a clause 22
	1561	+ * or clause 45 PHY.
	1562	+ *
	1563	+ * Clause 22 copper SFP modules normally operate in Cisco SGMII mode with
	1564	+ * negotiation enabled, but some may be in 1000base-X - which is for the
	1565	+ * PHY driver to determine.
	1566	+ *
	1567	+ * Clause 45 copper SFP+ modules (10G) appear to switch their interface
	1568	+ * mode according to the negotiated line speed.
	1569	+ */
	1570	+static int sfp_sm_probe_for_phy(struct sfp *sfp)
1287	1571	{
1288		- sfp_module_tx_enable(sfp);
	1572	+ int err = 0;
1289	1573
1290		- /* Wait t_init before indicating that the link is up, provided the
1291		- * current state indicates no TX_FAULT. If TX_FAULT clears before
1292		- * this time, that's fine too.
1293		- */
1294		- sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES);
1295		- sfp->sm_retries = 5;
	1574	+ switch (sfp->id.base.extended_cc) {
	1575	+ case SFF8024_ECC_10GBASE_T_SFI:
	1576	+ case SFF8024_ECC_10GBASE_T_SR:
	1577	+ case SFF8024_ECC_5GBASE_T:
	1578	+ case SFF8024_ECC_2_5GBASE_T:
	1579	+ err = sfp_sm_probe_phy(sfp, true);
	1580	+ break;
1296	1581
1297		- /* Setting the serdes link mode is guesswork: there's no
1298		- * field in the EEPROM which indicates what mode should
1299		- * be used.
1300		- *
1301		- * If it's a gigabit-only fiber module, it probably does
1302		- * not have a PHY, so switch to 802.3z negotiation mode.
1303		- * Otherwise, switch to SGMII mode (which is required to
1304		- * support non-gigabit speeds) and probe for a PHY.
1305		- */
1306		- if (sfp->id.base.e1000_base_t \|\|
1307		- sfp->id.base.e100_base_lx \|\|
1308		- sfp->id.base.e100_base_fx)
1309		- sfp_sm_probe_phy(sfp);
	1582	+ default:
	1583	+ if (sfp->id.base.e1000_base_t)
	1584	+ err = sfp_sm_probe_phy(sfp, false);
	1585	+ break;
	1586	+ }
	1587	+ return err;
1310	1588	}
1311	1589
1312		-static int sfp_sm_mod_hpower(struct sfp *sfp)
	1590	+static int sfp_module_parse_power(struct sfp *sfp)
1313	1591	{
1314		- u32 power;
1315		- u8 val;
1316		- int err;
	1592	+ u32 power_mW = 1000;
	1593	+ bool supports_a2;
1317	1594
1318		- power = 1000;
1319	1595	if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL))
1320		- power = 1500;
	1596	+ power_mW = 1500;
1321	1597	if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL))
1322		- power = 2000;
	1598	+ power_mW = 2000;
1323	1599
1324		- if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE &&
1325		- (sfp->id.ext.diagmon & (SFP_DIAGMON_DDM \| SFP_DIAGMON_ADDRMODE)) !=
1326		- SFP_DIAGMON_DDM) {
1327		- /* The module appears not to implement bus address 0xa2,
1328		- * or requires an address change sequence, so assume that
1329		- * the module powers up in the indicated power mode.
1330		- */
1331		- if (power > sfp->max_power_mW) {
	1600	+ supports_a2 = sfp->id.ext.sff8472_compliance !=
	1601	+ SFP_SFF8472_COMPLIANCE_NONE \|\|
	1602	+ sfp->id.ext.diagmon & SFP_DIAGMON_DDM;
	1603	+
	1604	+ if (power_mW > sfp->max_power_mW) {
	1605	+ /* Module power specification exceeds the allowed maximum. */
	1606	+ if (!supports_a2) {
	1607	+ /* The module appears not to implement bus address
	1608	+ * 0xa2, so assume that the module powers up in the
	1609	+ * indicated mode.
	1610	+ */
1332	1611	dev_err(sfp->dev,
1333	1612	"Host does not support %u.%uW modules\n",
1334		- power / 1000, (power / 100) % 10);
	1613	+ power_mW / 1000, (power_mW / 100) % 10);
1335	1614	return -EINVAL;
	1615	+ } else {
	1616	+ dev_warn(sfp->dev,
	1617	+ "Host does not support %u.%uW modules, module left in power mode 1\n",
	1618	+ power_mW / 1000, (power_mW / 100) % 10);
	1619	+ return 0;
1336	1620	}
	1621	+ }
	1622	+
	1623	+ if (power_mW <= 1000) {
	1624	+ /* Modules below 1W do not require a power change sequence */
	1625	+ sfp->module_power_mW = power_mW;
1337	1626	return 0;
1338	1627	}
1339	1628
1340		- if (power > sfp->max_power_mW) {
	1629	+ if (!supports_a2) {
	1630	+ /* The module power level is below the host maximum and the
	1631	+ * module appears not to implement bus address 0xa2, so assume
	1632	+ * that the module powers up in the indicated mode.
	1633	+ */
	1634	+ return 0;
	1635	+ }
	1636	+
	1637	+ /* If the module requires a higher power mode, but also requires
	1638	+ * an address change sequence, warn the user that the module may
	1639	+ * not be functional.
	1640	+ */
	1641	+ if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) {
1341	1642	dev_warn(sfp->dev,
1342		- "Host does not support %u.%uW modules, module left in power mode 1\n",
1343		- power / 1000, (power / 100) % 10);
	1643	+ "Address Change Sequence not supported but module requires %u.%uW, module may not be functional\n",
	1644	+ power_mW / 1000, (power_mW / 100) % 10);
1344	1645	return 0;
1345	1646	}
1346	1647
1347		- if (power <= 1000)
1348		- return 0;
	1648	+ sfp->module_power_mW = power_mW;
	1649	+
	1650	+ return 0;
	1651	+}
	1652	+
	1653	+static int sfp_sm_mod_hpower(struct sfp *sfp, bool enable)
	1654	+{
	1655	+ u8 val;
	1656	+ int err;
1349	1657
1350	1658	err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1351	1659	if (err != sizeof(val)) {
1352	1660	dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err);
1353		- err = -EAGAIN;
1354		- goto err;
	1661	+ return -EAGAIN;
1355	1662	}
1356	1663
1357		- val \|= BIT(0);
	1664	+ /* DM7052 reports as a high power module, responds to reads (with
	1665	+ * all bytes 0xff) at 0x51 but does not accept writes. In any case,
	1666	+ * if the bit is already set, we're already in high power mode.
	1667	+ */
	1668	+ if (!!(val & BIT(0)) == enable)
	1669	+ return 0;
	1670	+
	1671	+ if (enable)
	1672	+ val \|= BIT(0);
	1673	+ else
	1674	+ val &= ~BIT(0);
1358	1675
1359	1676	err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1360	1677	if (err != sizeof(val)) {
1361	1678	dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err);
1362		- err = -EAGAIN;
1363		- goto err;
	1679	+ return -EAGAIN;
1364	1680	}
1365	1681
1366		- dev_info(sfp->dev, "Module switched to %u.%uW power level\n",
1367		- power / 1000, (power / 100) % 10);
1368		- return T_HPOWER_LEVEL;
	1682	+ if (enable)
	1683	+ dev_info(sfp->dev, "Module switched to %u.%uW power level\n",
	1684	+ sfp->module_power_mW / 1000,
	1685	+ (sfp->module_power_mW / 100) % 10);
1369	1686
1370		-err:
1371		- return err;
	1687	+ return 0;
1372	1688	}
1373	1689
1374		-static int sfp_sm_mod_probe(struct sfp *sfp)
	1690	+/* GPON modules based on Realtek RTL8672 and RTL9601C chips (e.g. V-SOL
	1691	+ * V2801F, CarlitoxxPro CPGOS03-0490, Ubiquiti U-Fiber Instant, ...) do
	1692	+ * not support multibyte reads from the EEPROM. Each multi-byte read
	1693	+ * operation returns just one byte of EEPROM followed by zeros. There is
	1694	+ * no way to identify which modules are using Realtek RTL8672 and RTL9601C
	1695	+ * chips. Moreover every OEM of V-SOL V2801F module puts its own vendor
	1696	+ * name and vendor id into EEPROM, so there is even no way to detect if
	1697	+ * module is V-SOL V2801F. Therefore check for those zeros in the read
	1698	+ * data and then based on check switch to reading EEPROM to one byte
	1699	+ * at a time.
	1700	+ */
	1701	+static bool sfp_id_needs_byte_io(struct sfp sfp, void buf, size_t len)
	1702	+{
	1703	+ size_t i, block_size = sfp->i2c_block_size;
	1704	+
	1705	+ /* Already using byte IO */
	1706	+ if (block_size == 1)
	1707	+ return false;
	1708	+
	1709	+ for (i = 1; i < len; i += block_size) {
	1710	+ if (memchr_inv(buf + i, '\0', min(block_size - 1, len - i)))
	1711	+ return false;
	1712	+ }
	1713	+ return true;
	1714	+}
	1715	+
	1716	+static int sfp_cotsworks_fixup_check(struct sfp sfp, struct sfp_eeprom_id id)
	1717	+{
	1718	+ u8 check;
	1719	+ int err;
	1720	+
	1721	+ if (id->base.phys_id != SFF8024_ID_SFF_8472 \|\|
	1722	+ id->base.phys_ext_id != SFP_PHYS_EXT_ID_SFP \|\|
	1723	+ id->base.connector != SFF8024_CONNECTOR_LC) {
	1724	+ dev_warn(sfp->dev, "Rewriting fiber module EEPROM with corrected values\n");
	1725	+ id->base.phys_id = SFF8024_ID_SFF_8472;
	1726	+ id->base.phys_ext_id = SFP_PHYS_EXT_ID_SFP;
	1727	+ id->base.connector = SFF8024_CONNECTOR_LC;
	1728	+ err = sfp_write(sfp, false, SFP_PHYS_ID, &id->base, 3);
	1729	+ if (err != 3) {
	1730	+ dev_err(sfp->dev, "Failed to rewrite module EEPROM: %d\n", err);
	1731	+ return err;
	1732	+ }
	1733	+
	1734	+ /* Cotsworks modules have been found to require a delay between write operations. */
	1735	+ mdelay(50);
	1736	+
	1737	+ /* Update base structure checksum */
	1738	+ check = sfp_check(&id->base, sizeof(id->base) - 1);
	1739	+ err = sfp_write(sfp, false, SFP_CC_BASE, &check, 1);
	1740	+ if (err != 1) {
	1741	+ dev_err(sfp->dev, "Failed to update base structure checksum in fiber module EEPROM: %d\n", err);
	1742	+ return err;
	1743	+ }
	1744	+ }
	1745	+ return 0;
	1746	+}
	1747	+
	1748	+static int sfp_sm_mod_probe(struct sfp *sfp, bool report)
1375	1749	{
1376	1750	/* SFP module inserted - read I2C data */
1377	1751	struct sfp_eeprom_id id;
	1752	+ bool cotsworks_sfbg;
1378	1753	bool cotsworks;
1379	1754	u8 check;
1380	1755	int ret;
1381	1756
1382		- ret = sfp_read(sfp, false, 0, &id, sizeof(id));
	1757	+ /* Some SFP modules and also some Linux I2C drivers do not like reads
	1758	+ * longer than 16 bytes, so read the EEPROM in chunks of 16 bytes at
	1759	+ * a time.
	1760	+ */
	1761	+ sfp->i2c_block_size = 16;
	1762	+
	1763	+ ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base));
1383	1764	if (ret < 0) {
1384		- dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret);
	1765	+ if (report)
	1766	+ dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret);
1385	1767	return -EAGAIN;
1386	1768	}
1387	1769
1388		- if (ret != sizeof(id)) {
	1770	+ if (ret != sizeof(id.base)) {
1389	1771	dev_err(sfp->dev, "EEPROM short read: %d\n", ret);
1390	1772	return -EAGAIN;
	1773	+ }
	1774	+
	1775	+ /* Some SFP modules (e.g. Nokia 3FE46541AA) lock up if read from
	1776	+ * address 0x51 is just one byte at a time. Also SFF-8472 requires
	1777	+ * that EEPROM supports atomic 16bit read operation for diagnostic
	1778	+ * fields, so do not switch to one byte reading at a time unless it
	1779	+ * is really required and we have no other option.
	1780	+ */
	1781	+ if (sfp_id_needs_byte_io(sfp, &id.base, sizeof(id.base))) {
	1782	+ dev_info(sfp->dev,
	1783	+ "Detected broken RTL8672/RTL9601C emulated EEPROM\n");
	1784	+ dev_info(sfp->dev,
	1785	+ "Switching to reading EEPROM to one byte at a time\n");
	1786	+ sfp->i2c_block_size = 1;
	1787	+
	1788	+ ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base));
	1789	+ if (ret < 0) {
	1790	+ if (report)
	1791	+ dev_err(sfp->dev, "failed to read EEPROM: %d\n",
	1792	+ ret);
	1793	+ return -EAGAIN;
	1794	+ }
	1795	+
	1796	+ if (ret != sizeof(id.base)) {
	1797	+ dev_err(sfp->dev, "EEPROM short read: %d\n", ret);
	1798	+ return -EAGAIN;
	1799	+ }
1391	1800	}
1392	1801
1393	1802	/* Cotsworks do not seem to update the checksums when they
..	..	@@ -1395,6 +1804,17 @@
1395	1804	* serial number and date code.
1396	1805	*/
1397	1806	cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS ", 16);
	1807	+ cotsworks_sfbg = !memcmp(id.base.vendor_pn, "SFBG", 4);
	1808	+
	1809	+ /* Cotsworks SFF module EEPROM do not always have valid phys_id,
	1810	+ * phys_ext_id, and connector bytes. Rewrite SFF EEPROM bytes if
	1811	+ * Cotsworks PN matches and bytes are not correct.
	1812	+ */
	1813	+ if (cotsworks && cotsworks_sfbg) {
	1814	+ ret = sfp_cotsworks_fixup_check(sfp, &id);
	1815	+ if (ret < 0)
	1816	+ return ret;
	1817	+ }
1398	1818
1399	1819	/* Validate the checksum over the base structure */
1400	1820	check = sfp_check(&id.base, sizeof(id.base) - 1);
..	..	@@ -1411,6 +1831,18 @@
1411	1831	16, 1, &id, sizeof(id), true);
1412	1832	return -EINVAL;
1413	1833	}
	1834	+ }
	1835	+
	1836	+ ret = sfp_read(sfp, false, SFP_CC_BASE + 1, &id.ext, sizeof(id.ext));
	1837	+ if (ret < 0) {
	1838	+ if (report)
	1839	+ dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret);
	1840	+ return -EAGAIN;
	1841	+ }
	1842	+
	1843	+ if (ret != sizeof(id.ext)) {
	1844	+ dev_err(sfp->dev, "EEPROM short read: %d\n", ret);
	1845	+ return -EAGAIN;
1414	1846	}
1415	1847
1416	1848	check = sfp_check(&id.ext, sizeof(id.ext) - 1);
..	..	@@ -1439,7 +1871,7 @@
1439	1871	(int)sizeof(id.ext.datecode), id.ext.datecode);
1440	1872
1441	1873	/* Check whether we support this module */
1442		- if (!sfp->type->module_supported(&sfp->id)) {
	1874	+ if (!sfp->type->module_supported(&id)) {
1443	1875	dev_err(sfp->dev,
1444	1876	"module is not supported - phys id 0x%02x 0x%02x\n",
1445	1877	sfp->id.base.phys_id, sfp->id.base.phys_ext_id);
..	..	@@ -1451,31 +1883,332 @@
1451	1883	dev_warn(sfp->dev,
1452	1884	"module address swap to access page 0xA2 is not supported.\n");
1453	1885
1454		- ret = sfp_hwmon_insert(sfp);
	1886	+ /* Parse the module power requirement */
	1887	+ ret = sfp_module_parse_power(sfp);
1455	1888	if (ret < 0)
1456	1889	return ret;
1457	1890
1458		- ret = sfp_module_insert(sfp->sfp_bus, &sfp->id);
1459		- if (ret < 0)
1460		- return ret;
	1891	+ if (!memcmp(id.base.vendor_name, "ALCATELLUCENT ", 16) &&
	1892	+ !memcmp(id.base.vendor_pn, "3FE46541AA ", 16))
	1893	+ sfp->module_t_start_up = T_START_UP_BAD_GPON;
	1894	+ else
	1895	+ sfp->module_t_start_up = T_START_UP;
1461	1896
1462		- return sfp_sm_mod_hpower(sfp);
	1897	+ if (!memcmp(id.base.vendor_name, "HUAWEI ", 16) &&
	1898	+ !memcmp(id.base.vendor_pn, "MA5671A ", 16))
	1899	+ sfp->tx_fault_ignore = true;
	1900	+ else
	1901	+ sfp->tx_fault_ignore = false;
	1902	+
	1903	+ return 0;
1463	1904	}
1464	1905
1465	1906	static void sfp_sm_mod_remove(struct sfp *sfp)
1466	1907	{
1467		- sfp_module_remove(sfp->sfp_bus);
	1908	+ if (sfp->sm_mod_state > SFP_MOD_WAITDEV)
	1909	+ sfp_module_remove(sfp->sfp_bus);
1468	1910
1469	1911	sfp_hwmon_remove(sfp);
1470	1912
1471		- if (sfp->mod_phy)
1472		- sfp_sm_phy_detach(sfp);
1473		-
1474		- sfp_module_tx_disable(sfp);
1475		-
1476	1913	memset(&sfp->id, 0, sizeof(sfp->id));
	1914	+ sfp->module_power_mW = 0;
1477	1915
1478	1916	dev_info(sfp->dev, "module removed\n");
	1917	+}
	1918	+
	1919	+/* This state machine tracks the upstream's state */
	1920	+static void sfp_sm_device(struct sfp *sfp, unsigned int event)
	1921	+{
	1922	+ switch (sfp->sm_dev_state) {
	1923	+ default:
	1924	+ if (event == SFP_E_DEV_ATTACH)
	1925	+ sfp->sm_dev_state = SFP_DEV_DOWN;
	1926	+ break;
	1927	+
	1928	+ case SFP_DEV_DOWN:
	1929	+ if (event == SFP_E_DEV_DETACH)
	1930	+ sfp->sm_dev_state = SFP_DEV_DETACHED;
	1931	+ else if (event == SFP_E_DEV_UP)
	1932	+ sfp->sm_dev_state = SFP_DEV_UP;
	1933	+ break;
	1934	+
	1935	+ case SFP_DEV_UP:
	1936	+ if (event == SFP_E_DEV_DETACH)
	1937	+ sfp->sm_dev_state = SFP_DEV_DETACHED;
	1938	+ else if (event == SFP_E_DEV_DOWN)
	1939	+ sfp->sm_dev_state = SFP_DEV_DOWN;
	1940	+ break;
	1941	+ }
	1942	+}
	1943	+
	1944	+/* This state machine tracks the insert/remove state of the module, probes
	1945	+ * the on-board EEPROM, and sets up the power level.
	1946	+ */
	1947	+static void sfp_sm_module(struct sfp *sfp, unsigned int event)
	1948	+{
	1949	+ int err;
	1950	+
	1951	+ /* Handle remove event globally, it resets this state machine */
	1952	+ if (event == SFP_E_REMOVE) {
	1953	+ if (sfp->sm_mod_state > SFP_MOD_PROBE)
	1954	+ sfp_sm_mod_remove(sfp);
	1955	+ sfp_sm_mod_next(sfp, SFP_MOD_EMPTY, 0);
	1956	+ return;
	1957	+ }
	1958	+
	1959	+ /* Handle device detach globally */
	1960	+ if (sfp->sm_dev_state < SFP_DEV_DOWN &&
	1961	+ sfp->sm_mod_state > SFP_MOD_WAITDEV) {
	1962	+ if (sfp->module_power_mW > 1000 &&
	1963	+ sfp->sm_mod_state > SFP_MOD_HPOWER)
	1964	+ sfp_sm_mod_hpower(sfp, false);
	1965	+ sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0);
	1966	+ return;
	1967	+ }
	1968	+
	1969	+ switch (sfp->sm_mod_state) {
	1970	+ default:
	1971	+ if (event == SFP_E_INSERT) {
	1972	+ sfp_sm_mod_next(sfp, SFP_MOD_PROBE, T_SERIAL);
	1973	+ sfp->sm_mod_tries_init = R_PROBE_RETRY_INIT;
	1974	+ sfp->sm_mod_tries = R_PROBE_RETRY_SLOW;
	1975	+ }
	1976	+ break;
	1977	+
	1978	+ case SFP_MOD_PROBE:
	1979	+ /* Wait for T_PROBE_INIT to time out */
	1980	+ if (event != SFP_E_TIMEOUT)
	1981	+ break;
	1982	+
	1983	+ err = sfp_sm_mod_probe(sfp, sfp->sm_mod_tries == 1);
	1984	+ if (err == -EAGAIN) {
	1985	+ if (sfp->sm_mod_tries_init &&
	1986	+ --sfp->sm_mod_tries_init) {
	1987	+ sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT);
	1988	+ break;
	1989	+ } else if (sfp->sm_mod_tries && --sfp->sm_mod_tries) {
	1990	+ if (sfp->sm_mod_tries == R_PROBE_RETRY_SLOW - 1)
	1991	+ dev_warn(sfp->dev,
	1992	+ "please wait, module slow to respond\n");
	1993	+ sfp_sm_set_timer(sfp, T_PROBE_RETRY_SLOW);
	1994	+ break;
	1995	+ }
	1996	+ }
	1997	+ if (err < 0) {
	1998	+ sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0);
	1999	+ break;
	2000	+ }
	2001	+
	2002	+ err = sfp_hwmon_insert(sfp);
	2003	+ if (err)
	2004	+ dev_warn(sfp->dev, "hwmon probe failed: %d\n", err);
	2005	+
	2006	+ sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0);
	2007	+ fallthrough;
	2008	+ case SFP_MOD_WAITDEV:
	2009	+ /* Ensure that the device is attached before proceeding */
	2010	+ if (sfp->sm_dev_state < SFP_DEV_DOWN)
	2011	+ break;
	2012	+
	2013	+ /* Report the module insertion to the upstream device */
	2014	+ err = sfp_module_insert(sfp->sfp_bus, &sfp->id);
	2015	+ if (err < 0) {
	2016	+ sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0);
	2017	+ break;
	2018	+ }
	2019	+
	2020	+ /* If this is a power level 1 module, we are done */
	2021	+ if (sfp->module_power_mW <= 1000)
	2022	+ goto insert;
	2023	+
	2024	+ sfp_sm_mod_next(sfp, SFP_MOD_HPOWER, 0);
	2025	+ fallthrough;
	2026	+ case SFP_MOD_HPOWER:
	2027	+ /* Enable high power mode */
	2028	+ err = sfp_sm_mod_hpower(sfp, true);
	2029	+ if (err < 0) {
	2030	+ if (err != -EAGAIN) {
	2031	+ sfp_module_remove(sfp->sfp_bus);
	2032	+ sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0);
	2033	+ } else {
	2034	+ sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT);
	2035	+ }
	2036	+ break;
	2037	+ }
	2038	+
	2039	+ sfp_sm_mod_next(sfp, SFP_MOD_WAITPWR, T_HPOWER_LEVEL);
	2040	+ break;
	2041	+
	2042	+ case SFP_MOD_WAITPWR:
	2043	+ /* Wait for T_HPOWER_LEVEL to time out */
	2044	+ if (event != SFP_E_TIMEOUT)
	2045	+ break;
	2046	+
	2047	+ insert:
	2048	+ sfp_sm_mod_next(sfp, SFP_MOD_PRESENT, 0);
	2049	+ break;
	2050	+
	2051	+ case SFP_MOD_PRESENT:
	2052	+ case SFP_MOD_ERROR:
	2053	+ break;
	2054	+ }
	2055	+}
	2056	+
	2057	+static void sfp_sm_main(struct sfp *sfp, unsigned int event)
	2058	+{
	2059	+ unsigned long timeout;
	2060	+ int ret;
	2061	+
	2062	+ /* Some events are global */
	2063	+ if (sfp->sm_state != SFP_S_DOWN &&
	2064	+ (sfp->sm_mod_state != SFP_MOD_PRESENT \|\|
	2065	+ sfp->sm_dev_state != SFP_DEV_UP)) {
	2066	+ if (sfp->sm_state == SFP_S_LINK_UP &&
	2067	+ sfp->sm_dev_state == SFP_DEV_UP)
	2068	+ sfp_sm_link_down(sfp);
	2069	+ if (sfp->sm_state > SFP_S_INIT)
	2070	+ sfp_module_stop(sfp->sfp_bus);
	2071	+ if (sfp->mod_phy)
	2072	+ sfp_sm_phy_detach(sfp);
	2073	+ sfp_module_tx_disable(sfp);
	2074	+ sfp_soft_stop_poll(sfp);
	2075	+ sfp_sm_next(sfp, SFP_S_DOWN, 0);
	2076	+ return;
	2077	+ }
	2078	+
	2079	+ /* The main state machine */
	2080	+ switch (sfp->sm_state) {
	2081	+ case SFP_S_DOWN:
	2082	+ if (sfp->sm_mod_state != SFP_MOD_PRESENT \|\|
	2083	+ sfp->sm_dev_state != SFP_DEV_UP)
	2084	+ break;
	2085	+
	2086	+ if (!(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE))
	2087	+ sfp_soft_start_poll(sfp);
	2088	+
	2089	+ sfp_module_tx_enable(sfp);
	2090	+
	2091	+ /* Initialise the fault clearance retries */
	2092	+ sfp->sm_fault_retries = N_FAULT_INIT;
	2093	+
	2094	+ /* We need to check the TX_FAULT state, which is not defined
	2095	+ * while TX_DISABLE is asserted. The earliest we want to do
	2096	+ * anything (such as probe for a PHY) is 50ms.
	2097	+ */
	2098	+ sfp_sm_next(sfp, SFP_S_WAIT, T_WAIT);
	2099	+ break;
	2100	+
	2101	+ case SFP_S_WAIT:
	2102	+ if (event != SFP_E_TIMEOUT)
	2103	+ break;
	2104	+
	2105	+ if (sfp->state & SFP_F_TX_FAULT) {
	2106	+ /* Wait up to t_init (SFF-8472) or t_start_up (SFF-8431)
	2107	+ * from the TX_DISABLE deassertion for the module to
	2108	+ * initialise, which is indicated by TX_FAULT
	2109	+ * deasserting.
	2110	+ */
	2111	+ timeout = sfp->module_t_start_up;
	2112	+ if (timeout > T_WAIT)
	2113	+ timeout -= T_WAIT;
	2114	+ else
	2115	+ timeout = 1;
	2116	+
	2117	+ sfp_sm_next(sfp, SFP_S_INIT, timeout);
	2118	+ } else {
	2119	+ /* TX_FAULT is not asserted, assume the module has
	2120	+ * finished initialising.
	2121	+ */
	2122	+ goto init_done;
	2123	+ }
	2124	+ break;
	2125	+
	2126	+ case SFP_S_INIT:
	2127	+ if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
	2128	+ /* TX_FAULT is still asserted after t_init or
	2129	+ * or t_start_up, so assume there is a fault.
	2130	+ */
	2131	+ sfp_sm_fault(sfp, SFP_S_INIT_TX_FAULT,
	2132	+ sfp->sm_fault_retries == N_FAULT_INIT);
	2133	+ } else if (event == SFP_E_TIMEOUT \|\| event == SFP_E_TX_CLEAR) {
	2134	+ init_done:
	2135	+ sfp->sm_phy_retries = R_PHY_RETRY;
	2136	+ goto phy_probe;
	2137	+ }
	2138	+ break;
	2139	+
	2140	+ case SFP_S_INIT_PHY:
	2141	+ if (event != SFP_E_TIMEOUT)
	2142	+ break;
	2143	+ phy_probe:
	2144	+ /* TX_FAULT deasserted or we timed out with TX_FAULT
	2145	+ * clear. Probe for the PHY and check the LOS state.
	2146	+ */
	2147	+ ret = sfp_sm_probe_for_phy(sfp);
	2148	+ if (ret == -ENODEV) {
	2149	+ if (--sfp->sm_phy_retries) {
	2150	+ sfp_sm_next(sfp, SFP_S_INIT_PHY, T_PHY_RETRY);
	2151	+ break;
	2152	+ } else {
	2153	+ dev_info(sfp->dev, "no PHY detected\n");
	2154	+ }
	2155	+ } else if (ret) {
	2156	+ sfp_sm_next(sfp, SFP_S_FAIL, 0);
	2157	+ break;
	2158	+ }
	2159	+ if (sfp_module_start(sfp->sfp_bus)) {
	2160	+ sfp_sm_next(sfp, SFP_S_FAIL, 0);
	2161	+ break;
	2162	+ }
	2163	+ sfp_sm_link_check_los(sfp);
	2164	+
	2165	+ /* Reset the fault retry count */
	2166	+ sfp->sm_fault_retries = N_FAULT;
	2167	+ break;
	2168	+
	2169	+ case SFP_S_INIT_TX_FAULT:
	2170	+ if (event == SFP_E_TIMEOUT) {
	2171	+ sfp_module_tx_fault_reset(sfp);
	2172	+ sfp_sm_next(sfp, SFP_S_INIT, sfp->module_t_start_up);
	2173	+ }
	2174	+ break;
	2175	+
	2176	+ case SFP_S_WAIT_LOS:
	2177	+ if (event == SFP_E_TX_FAULT)
	2178	+ sfp_sm_fault(sfp, SFP_S_TX_FAULT, true);
	2179	+ else if (sfp_los_event_inactive(sfp, event))
	2180	+ sfp_sm_link_up(sfp);
	2181	+ break;
	2182	+
	2183	+ case SFP_S_LINK_UP:
	2184	+ if (event == SFP_E_TX_FAULT) {
	2185	+ sfp_sm_link_down(sfp);
	2186	+ sfp_sm_fault(sfp, SFP_S_TX_FAULT, true);
	2187	+ } else if (sfp_los_event_active(sfp, event)) {
	2188	+ sfp_sm_link_down(sfp);
	2189	+ sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
	2190	+ }
	2191	+ break;
	2192	+
	2193	+ case SFP_S_TX_FAULT:
	2194	+ if (event == SFP_E_TIMEOUT) {
	2195	+ sfp_module_tx_fault_reset(sfp);
	2196	+ sfp_sm_next(sfp, SFP_S_REINIT, sfp->module_t_start_up);
	2197	+ }
	2198	+ break;
	2199	+
	2200	+ case SFP_S_REINIT:
	2201	+ if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
	2202	+ sfp_sm_fault(sfp, SFP_S_TX_FAULT, false);
	2203	+ } else if (event == SFP_E_TIMEOUT \|\| event == SFP_E_TX_CLEAR) {
	2204	+ dev_info(sfp->dev, "module transmit fault recovered\n");
	2205	+ sfp_sm_link_check_los(sfp);
	2206	+ }
	2207	+ break;
	2208	+
	2209	+ case SFP_S_TX_DISABLE:
	2210	+ break;
	2211	+ }
1479	2212	}
1480	2213
1481	2214	static void sfp_sm_event(struct sfp *sfp, unsigned int event)
..	..	@@ -1488,134 +2221,9 @@
1488	2221	sm_state_to_str(sfp->sm_state),
1489	2222	event_to_str(event));
1490	2223
1491		- /* This state machine tracks the insert/remove state of
1492		- * the module, and handles probing the on-board EEPROM.
1493		- */
1494		- switch (sfp->sm_mod_state) {
1495		- default:
1496		- if (event == SFP_E_INSERT && sfp->attached) {
1497		- sfp_module_tx_disable(sfp);
1498		- sfp_sm_ins_next(sfp, SFP_MOD_PROBE, T_PROBE_INIT);
1499		- }
1500		- break;
1501		-
1502		- case SFP_MOD_PROBE:
1503		- if (event == SFP_E_REMOVE) {
1504		- sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
1505		- } else if (event == SFP_E_TIMEOUT) {
1506		- int val = sfp_sm_mod_probe(sfp);
1507		-
1508		- if (val == 0)
1509		- sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
1510		- else if (val > 0)
1511		- sfp_sm_ins_next(sfp, SFP_MOD_HPOWER, val);
1512		- else if (val != -EAGAIN)
1513		- sfp_sm_ins_next(sfp, SFP_MOD_ERROR, 0);
1514		- else
1515		- sfp_sm_set_timer(sfp, T_PROBE_RETRY);
1516		- }
1517		- break;
1518		-
1519		- case SFP_MOD_HPOWER:
1520		- if (event == SFP_E_TIMEOUT) {
1521		- sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
1522		- break;
1523		- }
1524		- /* fallthrough */
1525		- case SFP_MOD_PRESENT:
1526		- case SFP_MOD_ERROR:
1527		- if (event == SFP_E_REMOVE) {
1528		- sfp_sm_mod_remove(sfp);
1529		- sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
1530		- }
1531		- break;
1532		- }
1533		-
1534		- /* This state machine tracks the netdev up/down state */
1535		- switch (sfp->sm_dev_state) {
1536		- default:
1537		- if (event == SFP_E_DEV_UP)
1538		- sfp->sm_dev_state = SFP_DEV_UP;
1539		- break;
1540		-
1541		- case SFP_DEV_UP:
1542		- if (event == SFP_E_DEV_DOWN) {
1543		- /* If the module has a PHY, avoid raising TX disable
1544		- * as this resets the PHY. Otherwise, raise it to
1545		- * turn the laser off.
1546		- */
1547		- if (!sfp->mod_phy)
1548		- sfp_module_tx_disable(sfp);
1549		- sfp->sm_dev_state = SFP_DEV_DOWN;
1550		- }
1551		- break;
1552		- }
1553		-
1554		- /* Some events are global */
1555		- if (sfp->sm_state != SFP_S_DOWN &&
1556		- (sfp->sm_mod_state != SFP_MOD_PRESENT \|\|
1557		- sfp->sm_dev_state != SFP_DEV_UP)) {
1558		- if (sfp->sm_state == SFP_S_LINK_UP &&
1559		- sfp->sm_dev_state == SFP_DEV_UP)
1560		- sfp_sm_link_down(sfp);
1561		- if (sfp->mod_phy)
1562		- sfp_sm_phy_detach(sfp);
1563		- sfp_sm_next(sfp, SFP_S_DOWN, 0);
1564		- mutex_unlock(&sfp->sm_mutex);
1565		- return;
1566		- }
1567		-
1568		- /* The main state machine */
1569		- switch (sfp->sm_state) {
1570		- case SFP_S_DOWN:
1571		- if (sfp->sm_mod_state == SFP_MOD_PRESENT &&
1572		- sfp->sm_dev_state == SFP_DEV_UP)
1573		- sfp_sm_mod_init(sfp);
1574		- break;
1575		-
1576		- case SFP_S_INIT:
1577		- if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT)
1578		- sfp_sm_fault(sfp, true);
1579		- else if (event == SFP_E_TIMEOUT \|\| event == SFP_E_TX_CLEAR)
1580		- sfp_sm_link_check_los(sfp);
1581		- break;
1582		-
1583		- case SFP_S_WAIT_LOS:
1584		- if (event == SFP_E_TX_FAULT)
1585		- sfp_sm_fault(sfp, true);
1586		- else if (sfp_los_event_inactive(sfp, event))
1587		- sfp_sm_link_up(sfp);
1588		- break;
1589		-
1590		- case SFP_S_LINK_UP:
1591		- if (event == SFP_E_TX_FAULT) {
1592		- sfp_sm_link_down(sfp);
1593		- sfp_sm_fault(sfp, true);
1594		- } else if (sfp_los_event_active(sfp, event)) {
1595		- sfp_sm_link_down(sfp);
1596		- sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
1597		- }
1598		- break;
1599		-
1600		- case SFP_S_TX_FAULT:
1601		- if (event == SFP_E_TIMEOUT) {
1602		- sfp_module_tx_fault_reset(sfp);
1603		- sfp_sm_next(sfp, SFP_S_REINIT, T_INIT_JIFFIES);
1604		- }
1605		- break;
1606		-
1607		- case SFP_S_REINIT:
1608		- if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
1609		- sfp_sm_fault(sfp, false);
1610		- } else if (event == SFP_E_TIMEOUT \|\| event == SFP_E_TX_CLEAR) {
1611		- dev_info(sfp->dev, "module transmit fault recovered\n");
1612		- sfp_sm_link_check_los(sfp);
1613		- }
1614		- break;
1615		-
1616		- case SFP_S_TX_DISABLE:
1617		- break;
1618		- }
	2224	+ sfp_sm_device(sfp, event);
	2225	+ sfp_sm_module(sfp, event);
	2226	+ sfp_sm_main(sfp, event);
1619	2227
1620	2228	dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n",
1621	2229	mod_state_to_str(sfp->sm_mod_state),
..	..	@@ -1627,15 +2235,12 @@
1627	2235
1628	2236	static void sfp_attach(struct sfp *sfp)
1629	2237	{
1630		- sfp->attached = true;
1631		- if (sfp->state & SFP_F_PRESENT)
1632		- sfp_sm_event(sfp, SFP_E_INSERT);
	2238	+ sfp_sm_event(sfp, SFP_E_DEV_ATTACH);
1633	2239	}
1634	2240
1635	2241	static void sfp_detach(struct sfp *sfp)
1636	2242	{
1637		- sfp->attached = false;
1638		- sfp_sm_event(sfp, SFP_E_REMOVE);
	2243	+ sfp_sm_event(sfp, SFP_E_DEV_DETACH);
1639	2244	}
1640	2245
1641	2246	static void sfp_start(struct sfp *sfp)
..	..	@@ -1722,7 +2327,10 @@
1722	2327	mutex_lock(&sfp->st_mutex);
1723	2328	state = sfp_get_state(sfp);
1724	2329	changed = state ^ sfp->state;
1725		- changed &= SFP_F_PRESENT \| SFP_F_LOS \| SFP_F_TX_FAULT;
	2330	+ if (sfp->tx_fault_ignore)
	2331	+ changed &= SFP_F_PRESENT \| SFP_F_LOS;
	2332	+ else
	2333	+ changed &= SFP_F_PRESENT \| SFP_F_LOS \| SFP_F_TX_FAULT;
1726	2334
1727	2335	for (i = 0; i < GPIO_MAX; i++)
1728	2336	if (changed & BIT(i))
..	..	@@ -1762,7 +2370,10 @@
1762	2370	struct sfp *sfp = container_of(work, struct sfp, poll.work);
1763	2371
1764	2372	sfp_check_state(sfp);
1765		- mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
	2373	+
	2374	+ if (sfp->state_soft_mask & (SFP_F_LOS \| SFP_F_TX_FAULT) \|\|
	2375	+ sfp->need_poll)
	2376	+ mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
1766	2377	}
1767	2378
1768	2379	static struct sfp sfp_alloc(struct device dev)
..	..	@@ -1780,12 +2391,16 @@
1780	2391	INIT_DELAYED_WORK(&sfp->poll, sfp_poll);
1781	2392	INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout);
1782	2393
	2394	+ sfp_hwmon_init(sfp);
	2395	+
1783	2396	return sfp;
1784	2397	}
1785	2398
1786	2399	static void sfp_cleanup(void *data)
1787	2400	{
1788	2401	struct sfp *sfp = data;
	2402	+
	2403	+ sfp_hwmon_exit(sfp);
1789	2404
1790	2405	cancel_delayed_work_sync(&sfp->poll);
1791	2406	cancel_delayed_work_sync(&sfp->timeout);
..	..	@@ -1801,9 +2416,10 @@
1801	2416	static int sfp_probe(struct platform_device *pdev)
1802	2417	{
1803	2418	const struct sff_data *sff;
	2419	+ struct i2c_adapter *i2c;
	2420	+ char *sfp_irq_name;
1804	2421	struct sfp *sfp;
1805		- bool poll = false;
1806		- int irq, err, i;
	2422	+ int err, i;
1807	2423
1808	2424	sfp = sfp_alloc(&pdev->dev);
1809	2425	if (IS_ERR(sfp))
..	..	@@ -1811,7 +2427,7 @@
1811	2427
1812	2428	platform_set_drvdata(pdev, sfp);
1813	2429
1814		- err = devm_add_action(sfp->dev, sfp_cleanup, sfp);
	2430	+ err = devm_add_action_or_reset(sfp->dev, sfp_cleanup, sfp);
1815	2431	if (err < 0)
1816	2432	return err;
1817	2433
..	..	@@ -1820,7 +2436,6 @@
1820	2436	if (pdev->dev.of_node) {
1821	2437	struct device_node *node = pdev->dev.of_node;
1822	2438	const struct of_device_id *id;
1823		- struct i2c_adapter *i2c;
1824	2439	struct device_node *np;
1825	2440
1826	2441	id = of_match_node(sfp_of_match, node);
..	..	@@ -1837,14 +2452,32 @@
1837	2452
1838	2453	i2c = of_find_i2c_adapter_by_node(np);
1839	2454	of_node_put(np);
1840		- if (!i2c)
1841		- return -EPROBE_DEFER;
	2455	+ } else if (has_acpi_companion(&pdev->dev)) {
	2456	+ struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
	2457	+ struct fwnode_handle *fw = acpi_fwnode_handle(adev);
	2458	+ struct fwnode_reference_args args;
	2459	+ struct acpi_handle *acpi_handle;
	2460	+ int ret;
1842	2461
1843		- err = sfp_i2c_configure(sfp, i2c);
1844		- if (err < 0) {
1845		- i2c_put_adapter(i2c);
1846		- return err;
	2462	+ ret = acpi_node_get_property_reference(fw, "i2c-bus", 0, &args);
	2463	+ if (ret \|\| !is_acpi_device_node(args.fwnode)) {
	2464	+ dev_err(&pdev->dev, "missing 'i2c-bus' property\n");
	2465	+ return -ENODEV;
1847	2466	}
	2467	+
	2468	+ acpi_handle = ACPI_HANDLE_FWNODE(args.fwnode);
	2469	+ i2c = i2c_acpi_find_adapter_by_handle(acpi_handle);
	2470	+ } else {
	2471	+ return -EINVAL;
	2472	+ }
	2473	+
	2474	+ if (!i2c)
	2475	+ return -EPROBE_DEFER;
	2476	+
	2477	+ err = sfp_i2c_configure(sfp, i2c);
	2478	+ if (err < 0) {
	2479	+ i2c_put_adapter(i2c);
	2480	+ return err;
1848	2481	}
1849	2482
1850	2483	for (i = 0; i < GPIO_MAX; i++)
..	..	@@ -1880,28 +2513,43 @@
1880	2513	sfp->state \|= SFP_F_RATE_SELECT;
1881	2514	sfp_set_state(sfp, sfp->state);
1882	2515	sfp_module_tx_disable(sfp);
	2516	+ if (sfp->state & SFP_F_PRESENT) {
	2517	+ rtnl_lock();
	2518	+ sfp_sm_event(sfp, SFP_E_INSERT);
	2519	+ rtnl_unlock();
	2520	+ }
1883	2521
1884	2522	for (i = 0; i < GPIO_MAX; i++) {
1885	2523	if (gpio_flags[i] != GPIOD_IN \|\| !sfp->gpio[i])
1886	2524	continue;
1887	2525
1888		- irq = gpiod_to_irq(sfp->gpio[i]);
1889		- if (irq < 0) {
1890		- irq = 0;
1891		- poll = true;
	2526	+ sfp->gpio_irq[i] = gpiod_to_irq(sfp->gpio[i]);
	2527	+ if (sfp->gpio_irq[i] < 0) {
	2528	+ sfp->gpio_irq[i] = 0;
	2529	+ sfp->need_poll = true;
1892	2530	continue;
1893	2531	}
1894	2532
1895		- err = devm_request_threaded_irq(sfp->dev, irq, NULL, sfp_irq,
	2533	+ sfp_irq_name = devm_kasprintf(sfp->dev, GFP_KERNEL,
	2534	+ "%s-%s", dev_name(sfp->dev),
	2535	+ gpio_of_names[i]);
	2536	+
	2537	+ if (!sfp_irq_name)
	2538	+ return -ENOMEM;
	2539	+
	2540	+ err = devm_request_threaded_irq(sfp->dev, sfp->gpio_irq[i],
	2541	+ NULL, sfp_irq,
1896	2542	IRQF_ONESHOT \|
1897	2543	IRQF_TRIGGER_RISING \|
1898	2544	IRQF_TRIGGER_FALLING,
1899		- dev_name(sfp->dev), sfp);
1900		- if (err)
1901		- poll = true;
	2545	+ sfp_irq_name, sfp);
	2546	+ if (err) {
	2547	+ sfp->gpio_irq[i] = 0;
	2548	+ sfp->need_poll = true;
	2549	+ }
1902	2550	}
1903	2551
1904		- if (poll)
	2552	+ if (sfp->need_poll)
1905	2553	mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
1906	2554
1907	2555	/* We could have an issue in cases no Tx disable pin is available or
..	..	@@ -1926,12 +2574,33 @@
1926	2574
1927	2575	sfp_unregister_socket(sfp->sfp_bus);
1928	2576
	2577	+ rtnl_lock();
	2578	+ sfp_sm_event(sfp, SFP_E_REMOVE);
	2579	+ rtnl_unlock();
	2580	+
1929	2581	return 0;
	2582	+}
	2583	+
	2584	+static void sfp_shutdown(struct platform_device *pdev)
	2585	+{
	2586	+ struct sfp *sfp = platform_get_drvdata(pdev);
	2587	+ int i;
	2588	+
	2589	+ for (i = 0; i < GPIO_MAX; i++) {
	2590	+ if (!sfp->gpio_irq[i])
	2591	+ continue;
	2592	+
	2593	+ devm_free_irq(sfp->dev, sfp->gpio_irq[i], sfp);
	2594	+ }
	2595	+
	2596	+ cancel_delayed_work_sync(&sfp->poll);
	2597	+ cancel_delayed_work_sync(&sfp->timeout);
1930	2598	}
1931	2599
1932	2600	static struct platform_driver sfp_driver = {
1933	2601	.probe = sfp_probe,
1934	2602	.remove = sfp_remove,
	2603	+ .shutdown = sfp_shutdown,
1935	2604	.driver = {
1936	2605	.name = "sfp",
1937	2606	.of_match_table = sfp_of_match,