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