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