?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmc: core: Reset HPI enabled state during re-init and in case of errors
[linux/fpc-iii.git] / drivers / net / phy / sfp.c
blobfd8bb998ae52d946ca5b29172a4553176addc726
1 #include <linux/ctype.h>
2 #include <linux/delay.h>
3 #include <linux/gpio/consumer.h>
4 #include <linux/hwmon.h>
5 #include <linux/i2c.h>
6 #include <linux/interrupt.h>
7 #include <linux/jiffies.h>
8 #include <linux/module.h>
9 #include <linux/mutex.h>
10 #include <linux/of.h>
11 #include <linux/phy.h>
12 #include <linux/platform_device.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/slab.h>
15 #include <linux/workqueue.h>
16
17 #include "mdio-i2c.h"
18 #include "sfp.h"
19 #include "swphy.h"
20
21 enum {
22 GPIO_MODDEF0,
23 GPIO_LOS,
24 GPIO_TX_FAULT,
25 GPIO_TX_DISABLE,
26 GPIO_RATE_SELECT,
27 GPIO_MAX,
28
29 SFP_F_PRESENT = BIT(GPIO_MODDEF0),
30 SFP_F_LOS = BIT(GPIO_LOS),
31 SFP_F_TX_FAULT = BIT(GPIO_TX_FAULT),
32 SFP_F_TX_DISABLE = BIT(GPIO_TX_DISABLE),
33 SFP_F_RATE_SELECT = BIT(GPIO_RATE_SELECT),
34
35 SFP_E_INSERT = 0,
36 SFP_E_REMOVE,
37 SFP_E_DEV_DOWN,
38 SFP_E_DEV_UP,
39 SFP_E_TX_FAULT,
40 SFP_E_TX_CLEAR,
41 SFP_E_LOS_HIGH,
42 SFP_E_LOS_LOW,
43 SFP_E_TIMEOUT,
44
45 SFP_MOD_EMPTY = 0,
46 SFP_MOD_PROBE,
47 SFP_MOD_HPOWER,
48 SFP_MOD_PRESENT,
49 SFP_MOD_ERROR,
50
51 SFP_DEV_DOWN = 0,
52 SFP_DEV_UP,
53
54 SFP_S_DOWN = 0,
55 SFP_S_INIT,
56 SFP_S_WAIT_LOS,
57 SFP_S_LINK_UP,
58 SFP_S_TX_FAULT,
59 SFP_S_REINIT,
60 SFP_S_TX_DISABLE,
61 };
62
63 static const char * const mod_state_strings[] = {
64 [SFP_MOD_EMPTY] = "empty",
65 [SFP_MOD_PROBE] = "probe",
66 [SFP_MOD_HPOWER] = "hpower",
67 [SFP_MOD_PRESENT] = "present",
68 [SFP_MOD_ERROR] = "error",
69 };
70
71 static const char *mod_state_to_str(unsigned short mod_state)
72 {
73 if (mod_state >= ARRAY_SIZE(mod_state_strings))
74 return "Unknown module state";
75 return mod_state_strings[mod_state];
76 }
77
78 static const char * const dev_state_strings[] = {
79 [SFP_DEV_DOWN] = "down",
80 [SFP_DEV_UP] = "up",
81 };
82
83 static const char *dev_state_to_str(unsigned short dev_state)
84 {
85 if (dev_state >= ARRAY_SIZE(dev_state_strings))
86 return "Unknown device state";
87 return dev_state_strings[dev_state];
88 }
89
90 static const char * const event_strings[] = {
91 [SFP_E_INSERT] = "insert",
92 [SFP_E_REMOVE] = "remove",
93 [SFP_E_DEV_DOWN] = "dev_down",
94 [SFP_E_DEV_UP] = "dev_up",
95 [SFP_E_TX_FAULT] = "tx_fault",
96 [SFP_E_TX_CLEAR] = "tx_clear",
97 [SFP_E_LOS_HIGH] = "los_high",
98 [SFP_E_LOS_LOW] = "los_low",
99 [SFP_E_TIMEOUT] = "timeout",
100 };
101
102 static const char *event_to_str(unsigned short event)
103 {
104 if (event >= ARRAY_SIZE(event_strings))
105 return "Unknown event";
106 return event_strings[event];
107 }
108
109 static const char * const sm_state_strings[] = {
110 [SFP_S_DOWN] = "down",
111 [SFP_S_INIT] = "init",
112 [SFP_S_WAIT_LOS] = "wait_los",
113 [SFP_S_LINK_UP] = "link_up",
114 [SFP_S_TX_FAULT] = "tx_fault",
115 [SFP_S_REINIT] = "reinit",
116 [SFP_S_TX_DISABLE] = "rx_disable",
117 };
118
119 static const char *sm_state_to_str(unsigned short sm_state)
120 {
121 if (sm_state >= ARRAY_SIZE(sm_state_strings))
122 return "Unknown state";
123 return sm_state_strings[sm_state];
124 }
125
126 static const char *gpio_of_names[] = {
127 "mod-def0",
128 "los",
129 "tx-fault",
130 "tx-disable",
131 "rate-select0",
132 };
133
134 static const enum gpiod_flags gpio_flags[] = {
135 GPIOD_IN,
136 GPIOD_IN,
137 GPIOD_IN,
138 GPIOD_ASIS,
139 GPIOD_ASIS,
140 };
141
142 #define T_INIT_JIFFIES msecs_to_jiffies(300)
143 #define T_RESET_US 10
144 #define T_FAULT_RECOVER msecs_to_jiffies(1000)
145
146 /* SFP module presence detection is poor: the three MOD DEF signals are
147 * the same length on the PCB, which means it's possible for MOD DEF 0 to
148 * connect before the I2C bus on MOD DEF 1/2.
149 *
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.
153 */
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)
157
158 /* SFP modules appear to always have their PHY configured for bus address
159 * 0x56 (which with mdio-i2c, translates to a PHY address of 22).
160 */
161 #define SFP_PHY_ADDR 22
162
163 /* Give this long for the PHY to reset. */
164 #define T_PHY_RESET_MS 50
165
166 struct sff_data {
167 unsigned int gpios;
168 bool (*module_supported)(const struct sfp_eeprom_id *id);
169 };
170
171 struct sfp {
172 struct device *dev;
173 struct i2c_adapter *i2c;
174 struct mii_bus *i2c_mii;
175 struct sfp_bus *sfp_bus;
176 struct phy_device *mod_phy;
177 const struct sff_data *type;
178 u32 max_power_mW;
179
180 unsigned int (*get_state)(struct sfp *);
181 void (*set_state)(struct sfp *, unsigned int);
182 int (*read)(struct sfp *, bool, u8, void *, size_t);
183 int (*write)(struct sfp *, bool, u8, void *, size_t);
184
185 struct gpio_desc *gpio[GPIO_MAX];
186
187 unsigned int state;
188 struct delayed_work poll;
189 struct delayed_work timeout;
190 struct mutex sm_mutex;
191 unsigned char sm_mod_state;
192 unsigned char sm_dev_state;
193 unsigned short sm_state;
194 unsigned int sm_retries;
195
196 struct sfp_eeprom_id id;
197 #if IS_ENABLED(CONFIG_HWMON)
198 struct sfp_diag diag;
199 struct device *hwmon_dev;
200 char *hwmon_name;
201 #endif
202
203 };
204
205 static bool sff_module_supported(const struct sfp_eeprom_id *id)
206 {
207 return id->base.phys_id == SFP_PHYS_ID_SFF &&
208 id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
209 }
210
211 static const struct sff_data sff_data = {
212 .gpios = SFP_F_LOS | SFP_F_TX_FAULT | SFP_F_TX_DISABLE,
213 .module_supported = sff_module_supported,
214 };
215
216 static bool sfp_module_supported(const struct sfp_eeprom_id *id)
217 {
218 return id->base.phys_id == SFP_PHYS_ID_SFP &&
219 id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
220 }
221
222 static const struct sff_data sfp_data = {
223 .gpios = SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT |
224 SFP_F_TX_DISABLE | SFP_F_RATE_SELECT,
225 .module_supported = sfp_module_supported,
226 };
227
228 static const struct of_device_id sfp_of_match[] = {
229 { .compatible = "sff,sff", .data = &sff_data, },
230 { .compatible = "sff,sfp", .data = &sfp_data, },
231 { },
232 };
233 MODULE_DEVICE_TABLE(of, sfp_of_match);
234
235 static unsigned long poll_jiffies;
236
237 static unsigned int sfp_gpio_get_state(struct sfp *sfp)
238 {
239 unsigned int i, state, v;
240
241 for (i = state = 0; i < GPIO_MAX; i++) {
242 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
243 continue;
244
245 v = gpiod_get_value_cansleep(sfp->gpio[i]);
246 if (v)
247 state |= BIT(i);
248 }
249
250 return state;
251 }
252
253 static unsigned int sff_gpio_get_state(struct sfp *sfp)
254 {
255 return sfp_gpio_get_state(sfp) | SFP_F_PRESENT;
256 }
257
258 static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state)
259 {
260 if (state & SFP_F_PRESENT) {
261 /* If the module is present, drive the signals */
262 if (sfp->gpio[GPIO_TX_DISABLE])
263 gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE],
264 state & SFP_F_TX_DISABLE);
265 if (state & SFP_F_RATE_SELECT)
266 gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT],
267 state & SFP_F_RATE_SELECT);
268 } else {
269 /* Otherwise, let them float to the pull-ups */
270 if (sfp->gpio[GPIO_TX_DISABLE])
271 gpiod_direction_input(sfp->gpio[GPIO_TX_DISABLE]);
272 if (state & SFP_F_RATE_SELECT)
273 gpiod_direction_input(sfp->gpio[GPIO_RATE_SELECT]);
274 }
275 }
276
277 static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
278 size_t len)
279 {
280 struct i2c_msg msgs[2];
281 u8 bus_addr = a2 ? 0x51 : 0x50;
282 int ret;
283
284 msgs[0].addr = bus_addr;
285 msgs[0].flags = 0;
286 msgs[0].len = 1;
287 msgs[0].buf = &dev_addr;
288 msgs[1].addr = bus_addr;
289 msgs[1].flags = I2C_M_RD;
290 msgs[1].len = len;
291 msgs[1].buf = buf;
292
293 ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs));
294 if (ret < 0)
295 return ret;
296
297 return ret == ARRAY_SIZE(msgs) ? len : 0;
298 }
299
300 static int sfp_i2c_write(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
301 size_t len)
302 {
303 struct i2c_msg msgs[1];
304 u8 bus_addr = a2 ? 0x51 : 0x50;
305 int ret;
306
307 msgs[0].addr = bus_addr;
308 msgs[0].flags = 0;
309 msgs[0].len = 1 + len;
310 msgs[0].buf = kmalloc(1 + len, GFP_KERNEL);
311 if (!msgs[0].buf)
312 return -ENOMEM;
313
314 msgs[0].buf[0] = dev_addr;
315 memcpy(&msgs[0].buf[1], buf, len);
316
317 ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs));
318
319 kfree(msgs[0].buf);
320
321 if (ret < 0)
322 return ret;
323
324 return ret == ARRAY_SIZE(msgs) ? len : 0;
325 }
326
327 static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c)
328 {
329 struct mii_bus *i2c_mii;
330 int ret;
331
332 if (!i2c_check_functionality(i2c, I2C_FUNC_I2C))
333 return -EINVAL;
334
335 sfp->i2c = i2c;
336 sfp->read = sfp_i2c_read;
337 sfp->write = sfp_i2c_write;
338
339 i2c_mii = mdio_i2c_alloc(sfp->dev, i2c);
340 if (IS_ERR(i2c_mii))
341 return PTR_ERR(i2c_mii);
342
343 i2c_mii->name = "SFP I2C Bus";
344 i2c_mii->phy_mask = ~0;
345
346 ret = mdiobus_register(i2c_mii);
347 if (ret < 0) {
348 mdiobus_free(i2c_mii);
349 return ret;
350 }
351
352 sfp->i2c_mii = i2c_mii;
353
354 return 0;
355 }
356
357 /* Interface */
358 static unsigned int sfp_get_state(struct sfp *sfp)
359 {
360 return sfp->get_state(sfp);
361 }
362
363 static void sfp_set_state(struct sfp *sfp, unsigned int state)
364 {
365 sfp->set_state(sfp, state);
366 }
367
368 static int sfp_read(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
369 {
370 return sfp->read(sfp, a2, addr, buf, len);
371 }
372
373 static int sfp_write(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
374 {
375 return sfp->write(sfp, a2, addr, buf, len);
376 }
377
378 static unsigned int sfp_check(void *buf, size_t len)
379 {
380 u8 *p, check;
381
382 for (p = buf, check = 0; len; p++, len--)
383 check += *p;
384
385 return check;
386 }
387
388 /* hwmon */
389 #if IS_ENABLED(CONFIG_HWMON)
390 static umode_t sfp_hwmon_is_visible(const void *data,
391 enum hwmon_sensor_types type,
392 u32 attr, int channel)
393 {
394 const struct sfp *sfp = data;
395
396 switch (type) {
397 case hwmon_temp:
398 switch (attr) {
399 case hwmon_temp_min_alarm:
400 case hwmon_temp_max_alarm:
401 case hwmon_temp_lcrit_alarm:
402 case hwmon_temp_crit_alarm:
403 case hwmon_temp_min:
404 case hwmon_temp_max:
405 case hwmon_temp_lcrit:
406 case hwmon_temp_crit:
407 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
408 return 0;
409 /* fall through */
410 case hwmon_temp_input:
411 return 0444;
412 default:
413 return 0;
414 }
415 case hwmon_in:
416 switch (attr) {
417 case hwmon_in_min_alarm:
418 case hwmon_in_max_alarm:
419 case hwmon_in_lcrit_alarm:
420 case hwmon_in_crit_alarm:
421 case hwmon_in_min:
422 case hwmon_in_max:
423 case hwmon_in_lcrit:
424 case hwmon_in_crit:
425 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
426 return 0;
427 /* fall through */
428 case hwmon_in_input:
429 return 0444;
430 default:
431 return 0;
432 }
433 case hwmon_curr:
434 switch (attr) {
435 case hwmon_curr_min_alarm:
436 case hwmon_curr_max_alarm:
437 case hwmon_curr_lcrit_alarm:
438 case hwmon_curr_crit_alarm:
439 case hwmon_curr_min:
440 case hwmon_curr_max:
441 case hwmon_curr_lcrit:
442 case hwmon_curr_crit:
443 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
444 return 0;
445 /* fall through */
446 case hwmon_curr_input:
447 return 0444;
448 default:
449 return 0;
450 }
451 case hwmon_power:
452 /* External calibration of receive power requires
453 * floating point arithmetic. Doing that in the kernel
454 * is not easy, so just skip it. If the module does
455 * not require external calibration, we can however
456 * show receiver power, since FP is then not needed.
457 */
458 if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL &&
459 channel == 1)
460 return 0;
461 switch (attr) {
462 case hwmon_power_min_alarm:
463 case hwmon_power_max_alarm:
464 case hwmon_power_lcrit_alarm:
465 case hwmon_power_crit_alarm:
466 case hwmon_power_min:
467 case hwmon_power_max:
468 case hwmon_power_lcrit:
469 case hwmon_power_crit:
470 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
471 return 0;
472 /* fall through */
473 case hwmon_power_input:
474 return 0444;
475 default:
476 return 0;
477 }
478 default:
479 return 0;
480 }
481 }
482
483 static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value)
484 {
485 __be16 val;
486 int err;
487
488 err = sfp_read(sfp, true, reg, &val, sizeof(val));
489 if (err < 0)
490 return err;
491
492 *value = be16_to_cpu(val);
493
494 return 0;
495 }
496
497 static void sfp_hwmon_to_rx_power(long *value)
498 {
499 *value = DIV_ROUND_CLOSEST(*value, 100);
500 }
501
502 static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset,
503 long *value)
504 {
505 if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL)
506 *value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset;
507 }
508
509 static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value)
510 {
511 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope),
512 be16_to_cpu(sfp->diag.cal_t_offset), value);
513
514 if (*value >= 0x8000)
515 *value -= 0x10000;
516
517 *value = DIV_ROUND_CLOSEST(*value * 1000, 256);
518 }
519
520 static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value)
521 {
522 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope),
523 be16_to_cpu(sfp->diag.cal_v_offset), value);
524
525 *value = DIV_ROUND_CLOSEST(*value, 10);
526 }
527
528 static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value)
529 {
530 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope),
531 be16_to_cpu(sfp->diag.cal_txi_offset), value);
532
533 *value = DIV_ROUND_CLOSEST(*value, 500);
534 }
535
536 static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value)
537 {
538 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope),
539 be16_to_cpu(sfp->diag.cal_txpwr_offset), value);
540
541 *value = DIV_ROUND_CLOSEST(*value, 10);
542 }
543
544 static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value)
545 {
546 int err;
547
548 err = sfp_hwmon_read_sensor(sfp, reg, value);
549 if (err < 0)
550 return err;
551
552 sfp_hwmon_calibrate_temp(sfp, value);
553
554 return 0;
555 }
556
557 static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value)
558 {
559 int err;
560
561 err = sfp_hwmon_read_sensor(sfp, reg, value);
562 if (err < 0)
563 return err;
564
565 sfp_hwmon_calibrate_vcc(sfp, value);
566
567 return 0;
568 }
569
570 static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value)
571 {
572 int err;
573
574 err = sfp_hwmon_read_sensor(sfp, reg, value);
575 if (err < 0)
576 return err;
577
578 sfp_hwmon_calibrate_bias(sfp, value);
579
580 return 0;
581 }
582
583 static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value)
584 {
585 int err;
586
587 err = sfp_hwmon_read_sensor(sfp, reg, value);
588 if (err < 0)
589 return err;
590
591 sfp_hwmon_calibrate_tx_power(sfp, value);
592
593 return 0;
594 }
595
596 static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value)
597 {
598 int err;
599
600 err = sfp_hwmon_read_sensor(sfp, reg, value);
601 if (err < 0)
602 return err;
603
604 sfp_hwmon_to_rx_power(value);
605
606 return 0;
607 }
608
609 static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value)
610 {
611 u8 status;
612 int err;
613
614 switch (attr) {
615 case hwmon_temp_input:
616 return sfp_hwmon_read_temp(sfp, SFP_TEMP, value);
617
618 case hwmon_temp_lcrit:
619 *value = be16_to_cpu(sfp->diag.temp_low_alarm);
620 sfp_hwmon_calibrate_temp(sfp, value);
621 return 0;
622
623 case hwmon_temp_min:
624 *value = be16_to_cpu(sfp->diag.temp_low_warn);
625 sfp_hwmon_calibrate_temp(sfp, value);
626 return 0;
627 case hwmon_temp_max:
628 *value = be16_to_cpu(sfp->diag.temp_high_warn);
629 sfp_hwmon_calibrate_temp(sfp, value);
630 return 0;
631
632 case hwmon_temp_crit:
633 *value = be16_to_cpu(sfp->diag.temp_high_alarm);
634 sfp_hwmon_calibrate_temp(sfp, value);
635 return 0;
636
637 case hwmon_temp_lcrit_alarm:
638 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
639 if (err < 0)
640 return err;
641
642 *value = !!(status & SFP_ALARM0_TEMP_LOW);
643 return 0;
644
645 case hwmon_temp_min_alarm:
646 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
647 if (err < 0)
648 return err;
649
650 *value = !!(status & SFP_WARN0_TEMP_LOW);
651 return 0;
652
653 case hwmon_temp_max_alarm:
654 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
655 if (err < 0)
656 return err;
657
658 *value = !!(status & SFP_WARN0_TEMP_HIGH);
659 return 0;
660
661 case hwmon_temp_crit_alarm:
662 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
663 if (err < 0)
664 return err;
665
666 *value = !!(status & SFP_ALARM0_TEMP_HIGH);
667 return 0;
668 default:
669 return -EOPNOTSUPP;
670 }
671
672 return -EOPNOTSUPP;
673 }
674
675 static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value)
676 {
677 u8 status;
678 int err;
679
680 switch (attr) {
681 case hwmon_in_input:
682 return sfp_hwmon_read_vcc(sfp, SFP_VCC, value);
683
684 case hwmon_in_lcrit:
685 *value = be16_to_cpu(sfp->diag.volt_low_alarm);
686 sfp_hwmon_calibrate_vcc(sfp, value);
687 return 0;
688
689 case hwmon_in_min:
690 *value = be16_to_cpu(sfp->diag.volt_low_warn);
691 sfp_hwmon_calibrate_vcc(sfp, value);
692 return 0;
693
694 case hwmon_in_max:
695 *value = be16_to_cpu(sfp->diag.volt_high_warn);
696 sfp_hwmon_calibrate_vcc(sfp, value);
697 return 0;
698
699 case hwmon_in_crit:
700 *value = be16_to_cpu(sfp->diag.volt_high_alarm);
701 sfp_hwmon_calibrate_vcc(sfp, value);
702 return 0;
703
704 case hwmon_in_lcrit_alarm:
705 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
706 if (err < 0)
707 return err;
708
709 *value = !!(status & SFP_ALARM0_VCC_LOW);
710 return 0;
711
712 case hwmon_in_min_alarm:
713 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
714 if (err < 0)
715 return err;
716
717 *value = !!(status & SFP_WARN0_VCC_LOW);
718 return 0;
719
720 case hwmon_in_max_alarm:
721 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
722 if (err < 0)
723 return err;
724
725 *value = !!(status & SFP_WARN0_VCC_HIGH);
726 return 0;
727
728 case hwmon_in_crit_alarm:
729 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
730 if (err < 0)
731 return err;
732
733 *value = !!(status & SFP_ALARM0_VCC_HIGH);
734 return 0;
735 default:
736 return -EOPNOTSUPP;
737 }
738
739 return -EOPNOTSUPP;
740 }
741
742 static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value)
743 {
744 u8 status;
745 int err;
746
747 switch (attr) {
748 case hwmon_curr_input:
749 return sfp_hwmon_read_bias(sfp, SFP_TX_BIAS, value);
750
751 case hwmon_curr_lcrit:
752 *value = be16_to_cpu(sfp->diag.bias_low_alarm);
753 sfp_hwmon_calibrate_bias(sfp, value);
754 return 0;
755
756 case hwmon_curr_min:
757 *value = be16_to_cpu(sfp->diag.bias_low_warn);
758 sfp_hwmon_calibrate_bias(sfp, value);
759 return 0;
760
761 case hwmon_curr_max:
762 *value = be16_to_cpu(sfp->diag.bias_high_warn);
763 sfp_hwmon_calibrate_bias(sfp, value);
764 return 0;
765
766 case hwmon_curr_crit:
767 *value = be16_to_cpu(sfp->diag.bias_high_alarm);
768 sfp_hwmon_calibrate_bias(sfp, value);
769 return 0;
770
771 case hwmon_curr_lcrit_alarm:
772 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
773 if (err < 0)
774 return err;
775
776 *value = !!(status & SFP_ALARM0_TX_BIAS_LOW);
777 return 0;
778
779 case hwmon_curr_min_alarm:
780 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
781 if (err < 0)
782 return err;
783
784 *value = !!(status & SFP_WARN0_TX_BIAS_LOW);
785 return 0;
786
787 case hwmon_curr_max_alarm:
788 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
789 if (err < 0)
790 return err;
791
792 *value = !!(status & SFP_WARN0_TX_BIAS_HIGH);
793 return 0;
794
795 case hwmon_curr_crit_alarm:
796 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
797 if (err < 0)
798 return err;
799
800 *value = !!(status & SFP_ALARM0_TX_BIAS_HIGH);
801 return 0;
802 default:
803 return -EOPNOTSUPP;
804 }
805
806 return -EOPNOTSUPP;
807 }
808
809 static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value)
810 {
811 u8 status;
812 int err;
813
814 switch (attr) {
815 case hwmon_power_input:
816 return sfp_hwmon_read_tx_power(sfp, SFP_TX_POWER, value);
817
818 case hwmon_power_lcrit:
819 *value = be16_to_cpu(sfp->diag.txpwr_low_alarm);
820 sfp_hwmon_calibrate_tx_power(sfp, value);
821 return 0;
822
823 case hwmon_power_min:
824 *value = be16_to_cpu(sfp->diag.txpwr_low_warn);
825 sfp_hwmon_calibrate_tx_power(sfp, value);
826 return 0;
827
828 case hwmon_power_max:
829 *value = be16_to_cpu(sfp->diag.txpwr_high_warn);
830 sfp_hwmon_calibrate_tx_power(sfp, value);
831 return 0;
832
833 case hwmon_power_crit:
834 *value = be16_to_cpu(sfp->diag.txpwr_high_alarm);
835 sfp_hwmon_calibrate_tx_power(sfp, value);
836 return 0;
837
838 case hwmon_power_lcrit_alarm:
839 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
840 if (err < 0)
841 return err;
842
843 *value = !!(status & SFP_ALARM0_TXPWR_LOW);
844 return 0;
845
846 case hwmon_power_min_alarm:
847 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
848 if (err < 0)
849 return err;
850
851 *value = !!(status & SFP_WARN0_TXPWR_LOW);
852 return 0;
853
854 case hwmon_power_max_alarm:
855 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
856 if (err < 0)
857 return err;
858
859 *value = !!(status & SFP_WARN0_TXPWR_HIGH);
860 return 0;
861
862 case hwmon_power_crit_alarm:
863 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
864 if (err < 0)
865 return err;
866
867 *value = !!(status & SFP_ALARM0_TXPWR_HIGH);
868 return 0;
869 default:
870 return -EOPNOTSUPP;
871 }
872
873 return -EOPNOTSUPP;
874 }
875
876 static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value)
877 {
878 u8 status;
879 int err;
880
881 switch (attr) {
882 case hwmon_power_input:
883 return sfp_hwmon_read_rx_power(sfp, SFP_RX_POWER, value);
884
885 case hwmon_power_lcrit:
886 *value = be16_to_cpu(sfp->diag.rxpwr_low_alarm);
887 sfp_hwmon_to_rx_power(value);
888 return 0;
889
890 case hwmon_power_min:
891 *value = be16_to_cpu(sfp->diag.rxpwr_low_warn);
892 sfp_hwmon_to_rx_power(value);
893 return 0;
894
895 case hwmon_power_max:
896 *value = be16_to_cpu(sfp->diag.rxpwr_high_warn);
897 sfp_hwmon_to_rx_power(value);
898 return 0;
899
900 case hwmon_power_crit:
901 *value = be16_to_cpu(sfp->diag.rxpwr_high_alarm);
902 sfp_hwmon_to_rx_power(value);
903 return 0;
904
905 case hwmon_power_lcrit_alarm:
906 err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status));
907 if (err < 0)
908 return err;
909
910 *value = !!(status & SFP_ALARM1_RXPWR_LOW);
911 return 0;
912
913 case hwmon_power_min_alarm:
914 err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status));
915 if (err < 0)
916 return err;
917
918 *value = !!(status & SFP_WARN1_RXPWR_LOW);
919 return 0;
920
921 case hwmon_power_max_alarm:
922 err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status));
923 if (err < 0)
924 return err;
925
926 *value = !!(status & SFP_WARN1_RXPWR_HIGH);
927 return 0;
928
929 case hwmon_power_crit_alarm:
930 err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status));
931 if (err < 0)
932 return err;
933
934 *value = !!(status & SFP_ALARM1_RXPWR_HIGH);
935 return 0;
936 default:
937 return -EOPNOTSUPP;
938 }
939
940 return -EOPNOTSUPP;
941 }
942
943 static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
944 u32 attr, int channel, long *value)
945 {
946 struct sfp *sfp = dev_get_drvdata(dev);
947
948 switch (type) {
949 case hwmon_temp:
950 return sfp_hwmon_temp(sfp, attr, value);
951 case hwmon_in:
952 return sfp_hwmon_vcc(sfp, attr, value);
953 case hwmon_curr:
954 return sfp_hwmon_bias(sfp, attr, value);
955 case hwmon_power:
956 switch (channel) {
957 case 0:
958 return sfp_hwmon_tx_power(sfp, attr, value);
959 case 1:
960 return sfp_hwmon_rx_power(sfp, attr, value);
961 default:
962 return -EOPNOTSUPP;
963 }
964 default:
965 return -EOPNOTSUPP;
966 }
967 }
968
969 static const struct hwmon_ops sfp_hwmon_ops = {
970 .is_visible = sfp_hwmon_is_visible,
971 .read = sfp_hwmon_read,
972 };
973
974 static u32 sfp_hwmon_chip_config[] = {
975 HWMON_C_REGISTER_TZ,
976 0,
977 };
978
979 static const struct hwmon_channel_info sfp_hwmon_chip = {
980 .type = hwmon_chip,
981 .config = sfp_hwmon_chip_config,
982 };
983
984 static u32 sfp_hwmon_temp_config[] = {
985 HWMON_T_INPUT |
986 HWMON_T_MAX | HWMON_T_MIN |
987 HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM |
988 HWMON_T_CRIT | HWMON_T_LCRIT |
989 HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM,
990 0,
991 };
992
993 static const struct hwmon_channel_info sfp_hwmon_temp_channel_info = {
994 .type = hwmon_temp,
995 .config = sfp_hwmon_temp_config,
996 };
997
998 static u32 sfp_hwmon_vcc_config[] = {
999 HWMON_I_INPUT |
1000 HWMON_I_MAX | HWMON_I_MIN |
1001 HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM |
1002 HWMON_I_CRIT | HWMON_I_LCRIT |
1003 HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM,
1004 0,
1005 };
1006
1007 static const struct hwmon_channel_info sfp_hwmon_vcc_channel_info = {
1008 .type = hwmon_in,
1009 .config = sfp_hwmon_vcc_config,
1010 };
1011
1012 static u32 sfp_hwmon_bias_config[] = {
1013 HWMON_C_INPUT |
1014 HWMON_C_MAX | HWMON_C_MIN |
1015 HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM |
1016 HWMON_C_CRIT | HWMON_C_LCRIT |
1017 HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM,
1018 0,
1019 };
1020
1021 static const struct hwmon_channel_info sfp_hwmon_bias_channel_info = {
1022 .type = hwmon_curr,
1023 .config = sfp_hwmon_bias_config,
1024 };
1025
1026 static u32 sfp_hwmon_power_config[] = {
1027 /* Transmit power */
1028 HWMON_P_INPUT |
1029 HWMON_P_MAX | HWMON_P_MIN |
1030 HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1031 HWMON_P_CRIT | HWMON_P_LCRIT |
1032 HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM,
1033 /* Receive power */
1034 HWMON_P_INPUT |
1035 HWMON_P_MAX | HWMON_P_MIN |
1036 HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1037 HWMON_P_CRIT | HWMON_P_LCRIT |
1038 HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM,
1039 0,
1040 };
1041
1042 static const struct hwmon_channel_info sfp_hwmon_power_channel_info = {
1043 .type = hwmon_power,
1044 .config = sfp_hwmon_power_config,
1045 };
1046
1047 static const struct hwmon_channel_info *sfp_hwmon_info[] = {
1048 &sfp_hwmon_chip,
1049 &sfp_hwmon_vcc_channel_info,
1050 &sfp_hwmon_temp_channel_info,
1051 &sfp_hwmon_bias_channel_info,
1052 &sfp_hwmon_power_channel_info,
1053 NULL,
1054 };
1055
1056 static const struct hwmon_chip_info sfp_hwmon_chip_info = {
1057 .ops = &sfp_hwmon_ops,
1058 .info = sfp_hwmon_info,
1059 };
1060
1061 static int sfp_hwmon_insert(struct sfp *sfp)
1062 {
1063 int err, i;
1064
1065 if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE)
1066 return 0;
1067
1068 if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM))
1069 return 0;
1070
1071 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)
1072 /* This driver in general does not support address
1073 * change.
1074 */
1075 return 0;
1076
1077 err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag));
1078 if (err < 0)
1079 return err;
1080
1081 sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL);
1082 if (!sfp->hwmon_name)
1083 return -ENODEV;
1084
1085 for (i = 0; sfp->hwmon_name[i]; i++)
1086 if (hwmon_is_bad_char(sfp->hwmon_name[i]))
1087 sfp->hwmon_name[i] = '_';
1088
1089 sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev,
1090 sfp->hwmon_name, sfp,
1091 &sfp_hwmon_chip_info,
1092 NULL);
1093
1094 return PTR_ERR_OR_ZERO(sfp->hwmon_dev);
1095 }
1096
1097 static void sfp_hwmon_remove(struct sfp *sfp)
1098 {
1099 if (!IS_ERR_OR_NULL(sfp->hwmon_dev)) {
1100 hwmon_device_unregister(sfp->hwmon_dev);
1101 sfp->hwmon_dev = NULL;
1102 kfree(sfp->hwmon_name);
1103 }
1104 }
1105 #else
1106 static int sfp_hwmon_insert(struct sfp *sfp)
1107 {
1108 return 0;
1109 }
1110
1111 static void sfp_hwmon_remove(struct sfp *sfp)
1112 {
1113 }
1114 #endif
1115
1116 /* Helpers */
1117 static void sfp_module_tx_disable(struct sfp *sfp)
1118 {
1119 dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1120 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1);
1121 sfp->state |= SFP_F_TX_DISABLE;
1122 sfp_set_state(sfp, sfp->state);
1123 }
1124
1125 static void sfp_module_tx_enable(struct sfp *sfp)
1126 {
1127 dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1128 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0);
1129 sfp->state &= ~SFP_F_TX_DISABLE;
1130 sfp_set_state(sfp, sfp->state);
1131 }
1132
1133 static void sfp_module_tx_fault_reset(struct sfp *sfp)
1134 {
1135 unsigned int state = sfp->state;
1136
1137 if (state & SFP_F_TX_DISABLE)
1138 return;
1139
1140 sfp_set_state(sfp, state | SFP_F_TX_DISABLE);
1141
1142 udelay(T_RESET_US);
1143
1144 sfp_set_state(sfp, state);
1145 }
1146
1147 /* SFP state machine */
1148 static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout)
1149 {
1150 if (timeout)
1151 mod_delayed_work(system_power_efficient_wq, &sfp->timeout,
1152 timeout);
1153 else
1154 cancel_delayed_work(&sfp->timeout);
1155 }
1156
1157 static void sfp_sm_next(struct sfp *sfp, unsigned int state,
1158 unsigned int timeout)
1159 {
1160 sfp->sm_state = state;
1161 sfp_sm_set_timer(sfp, timeout);
1162 }
1163
1164 static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state,
1165 unsigned int timeout)
1166 {
1167 sfp->sm_mod_state = state;
1168 sfp_sm_set_timer(sfp, timeout);
1169 }
1170
1171 static void sfp_sm_phy_detach(struct sfp *sfp)
1172 {
1173 phy_stop(sfp->mod_phy);
1174 sfp_remove_phy(sfp->sfp_bus);
1175 phy_device_remove(sfp->mod_phy);
1176 phy_device_free(sfp->mod_phy);
1177 sfp->mod_phy = NULL;
1178 }
1179
1180 static void sfp_sm_probe_phy(struct sfp *sfp)
1181 {
1182 struct phy_device *phy;
1183 int err;
1184
1185 msleep(T_PHY_RESET_MS);
1186
1187 phy = mdiobus_scan(sfp->i2c_mii, SFP_PHY_ADDR);
1188 if (phy == ERR_PTR(-ENODEV)) {
1189 dev_info(sfp->dev, "no PHY detected\n");
1190 return;
1191 }
1192 if (IS_ERR(phy)) {
1193 dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy));
1194 return;
1195 }
1196
1197 err = sfp_add_phy(sfp->sfp_bus, phy);
1198 if (err) {
1199 phy_device_remove(phy);
1200 phy_device_free(phy);
1201 dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err);
1202 return;
1203 }
1204
1205 sfp->mod_phy = phy;
1206 phy_start(phy);
1207 }
1208
1209 static void sfp_sm_link_up(struct sfp *sfp)
1210 {
1211 sfp_link_up(sfp->sfp_bus);
1212 sfp_sm_next(sfp, SFP_S_LINK_UP, 0);
1213 }
1214
1215 static void sfp_sm_link_down(struct sfp *sfp)
1216 {
1217 sfp_link_down(sfp->sfp_bus);
1218 }
1219
1220 static void sfp_sm_link_check_los(struct sfp *sfp)
1221 {
1222 unsigned int los = sfp->state & SFP_F_LOS;
1223
1224 /* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL
1225 * are set, we assume that no LOS signal is available.
1226 */
1227 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED))
1228 los ^= SFP_F_LOS;
1229 else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL)))
1230 los = 0;
1231
1232 if (los)
1233 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
1234 else
1235 sfp_sm_link_up(sfp);
1236 }
1237
1238 static bool sfp_los_event_active(struct sfp *sfp, unsigned int event)
1239 {
1240 return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1241 event == SFP_E_LOS_LOW) ||
1242 (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1243 event == SFP_E_LOS_HIGH);
1244 }
1245
1246 static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event)
1247 {
1248 return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1249 event == SFP_E_LOS_HIGH) ||
1250 (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1251 event == SFP_E_LOS_LOW);
1252 }
1253
1254 static void sfp_sm_fault(struct sfp *sfp, bool warn)
1255 {
1256 if (sfp->sm_retries && !--sfp->sm_retries) {
1257 dev_err(sfp->dev,
1258 "module persistently indicates fault, disabling\n");
1259 sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0);
1260 } else {
1261 if (warn)
1262 dev_err(sfp->dev, "module transmit fault indicated\n");
1263
1264 sfp_sm_next(sfp, SFP_S_TX_FAULT, T_FAULT_RECOVER);
1265 }
1266 }
1267
1268 static void sfp_sm_mod_init(struct sfp *sfp)
1269 {
1270 sfp_module_tx_enable(sfp);
1271
1272 /* Wait t_init before indicating that the link is up, provided the
1273 * current state indicates no TX_FAULT. If TX_FAULT clears before
1274 * this time, that's fine too.
1275 */
1276 sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES);
1277 sfp->sm_retries = 5;
1278
1279 /* Setting the serdes link mode is guesswork: there's no
1280 * field in the EEPROM which indicates what mode should
1281 * be used.
1282 *
1283 * If it's a gigabit-only fiber module, it probably does
1284 * not have a PHY, so switch to 802.3z negotiation mode.
1285 * Otherwise, switch to SGMII mode (which is required to
1286 * support non-gigabit speeds) and probe for a PHY.
1287 */
1288 if (sfp->id.base.e1000_base_t ||
1289 sfp->id.base.e100_base_lx ||
1290 sfp->id.base.e100_base_fx)
1291 sfp_sm_probe_phy(sfp);
1292 }
1293
1294 static int sfp_sm_mod_hpower(struct sfp *sfp)
1295 {
1296 u32 power;
1297 u8 val;
1298 int err;
1299
1300 power = 1000;
1301 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL))
1302 power = 1500;
1303 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL))
1304 power = 2000;
1305
1306 if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE &&
1307 (sfp->id.ext.diagmon & (SFP_DIAGMON_DDM | SFP_DIAGMON_ADDRMODE)) !=
1308 SFP_DIAGMON_DDM) {
1309 /* The module appears not to implement bus address 0xa2,
1310 * or requires an address change sequence, so assume that
1311 * the module powers up in the indicated power mode.
1312 */
1313 if (power > sfp->max_power_mW) {
1314 dev_err(sfp->dev,
1315 "Host does not support %u.%uW modules\n",
1316 power / 1000, (power / 100) % 10);
1317 return -EINVAL;
1318 }
1319 return 0;
1320 }
1321
1322 if (power > sfp->max_power_mW) {
1323 dev_warn(sfp->dev,
1324 "Host does not support %u.%uW modules, module left in power mode 1\n",
1325 power / 1000, (power / 100) % 10);
1326 return 0;
1327 }
1328
1329 if (power <= 1000)
1330 return 0;
1331
1332 err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1333 if (err != sizeof(val)) {
1334 dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err);
1335 err = -EAGAIN;
1336 goto err;
1337 }
1338
1339 val |= BIT(0);
1340
1341 err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1342 if (err != sizeof(val)) {
1343 dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err);
1344 err = -EAGAIN;
1345 goto err;
1346 }
1347
1348 dev_info(sfp->dev, "Module switched to %u.%uW power level\n",
1349 power / 1000, (power / 100) % 10);
1350 return T_HPOWER_LEVEL;
1351
1352 err:
1353 return err;
1354 }
1355
1356 static int sfp_sm_mod_probe(struct sfp *sfp)
1357 {
1358 /* SFP module inserted - read I2C data */
1359 struct sfp_eeprom_id id;
1360 bool cotsworks;
1361 u8 check;
1362 int ret;
1363
1364 ret = sfp_read(sfp, false, 0, &id, sizeof(id));
1365 if (ret < 0) {
1366 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret);
1367 return -EAGAIN;
1368 }
1369
1370 if (ret != sizeof(id)) {
1371 dev_err(sfp->dev, "EEPROM short read: %d\n", ret);
1372 return -EAGAIN;
1373 }
1374
1375 /* Cotsworks do not seem to update the checksums when they
1376 * do the final programming with the final module part number,
1377 * serial number and date code.
1378 */
1379 cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS ", 16);
1380
1381 /* Validate the checksum over the base structure */
1382 check = sfp_check(&id.base, sizeof(id.base) - 1);
1383 if (check != id.base.cc_base) {
1384 if (cotsworks) {
1385 dev_warn(sfp->dev,
1386 "EEPROM base structure checksum failure (0x%02x != 0x%02x)\n",
1387 check, id.base.cc_base);
1388 } else {
1389 dev_err(sfp->dev,
1390 "EEPROM base structure checksum failure: 0x%02x != 0x%02x\n",
1391 check, id.base.cc_base);
1392 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET,
1393 16, 1, &id, sizeof(id), true);
1394 return -EINVAL;
1395 }
1396 }
1397
1398 check = sfp_check(&id.ext, sizeof(id.ext) - 1);
1399 if (check != id.ext.cc_ext) {
1400 if (cotsworks) {
1401 dev_warn(sfp->dev,
1402 "EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n",
1403 check, id.ext.cc_ext);
1404 } else {
1405 dev_err(sfp->dev,
1406 "EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n",
1407 check, id.ext.cc_ext);
1408 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET,
1409 16, 1, &id, sizeof(id), true);
1410 memset(&id.ext, 0, sizeof(id.ext));
1411 }
1412 }
1413
1414 sfp->id = id;
1415
1416 dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n",
1417 (int)sizeof(id.base.vendor_name), id.base.vendor_name,
1418 (int)sizeof(id.base.vendor_pn), id.base.vendor_pn,
1419 (int)sizeof(id.base.vendor_rev), id.base.vendor_rev,
1420 (int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn,
1421 (int)sizeof(id.ext.datecode), id.ext.datecode);
1422
1423 /* Check whether we support this module */
1424 if (!sfp->type->module_supported(&sfp->id)) {
1425 dev_err(sfp->dev,
1426 "module is not supported - phys id 0x%02x 0x%02x\n",
1427 sfp->id.base.phys_id, sfp->id.base.phys_ext_id);
1428 return -EINVAL;
1429 }
1430
1431 /* If the module requires address swap mode, warn about it */
1432 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)
1433 dev_warn(sfp->dev,
1434 "module address swap to access page 0xA2 is not supported.\n");
1435
1436 ret = sfp_hwmon_insert(sfp);
1437 if (ret < 0)
1438 return ret;
1439
1440 ret = sfp_module_insert(sfp->sfp_bus, &sfp->id);
1441 if (ret < 0)
1442 return ret;
1443
1444 return sfp_sm_mod_hpower(sfp);
1445 }
1446
1447 static void sfp_sm_mod_remove(struct sfp *sfp)
1448 {
1449 sfp_module_remove(sfp->sfp_bus);
1450
1451 sfp_hwmon_remove(sfp);
1452
1453 if (sfp->mod_phy)
1454 sfp_sm_phy_detach(sfp);
1455
1456 sfp_module_tx_disable(sfp);
1457
1458 memset(&sfp->id, 0, sizeof(sfp->id));
1459
1460 dev_info(sfp->dev, "module removed\n");
1461 }
1462
1463 static void sfp_sm_event(struct sfp *sfp, unsigned int event)
1464 {
1465 mutex_lock(&sfp->sm_mutex);
1466
1467 dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n",
1468 mod_state_to_str(sfp->sm_mod_state),
1469 dev_state_to_str(sfp->sm_dev_state),
1470 sm_state_to_str(sfp->sm_state),
1471 event_to_str(event));
1472
1473 /* This state machine tracks the insert/remove state of
1474 * the module, and handles probing the on-board EEPROM.
1475 */
1476 switch (sfp->sm_mod_state) {
1477 default:
1478 if (event == SFP_E_INSERT) {
1479 sfp_module_tx_disable(sfp);
1480 sfp_sm_ins_next(sfp, SFP_MOD_PROBE, T_PROBE_INIT);
1481 }
1482 break;
1483
1484 case SFP_MOD_PROBE:
1485 if (event == SFP_E_REMOVE) {
1486 sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
1487 } else if (event == SFP_E_TIMEOUT) {
1488 int val = sfp_sm_mod_probe(sfp);
1489
1490 if (val == 0)
1491 sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
1492 else if (val > 0)
1493 sfp_sm_ins_next(sfp, SFP_MOD_HPOWER, val);
1494 else if (val != -EAGAIN)
1495 sfp_sm_ins_next(sfp, SFP_MOD_ERROR, 0);
1496 else
1497 sfp_sm_set_timer(sfp, T_PROBE_RETRY);
1498 }
1499 break;
1500
1501 case SFP_MOD_HPOWER:
1502 if (event == SFP_E_TIMEOUT) {
1503 sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
1504 break;
1505 }
1506 /* fallthrough */
1507 case SFP_MOD_PRESENT:
1508 case SFP_MOD_ERROR:
1509 if (event == SFP_E_REMOVE) {
1510 sfp_sm_mod_remove(sfp);
1511 sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
1512 }
1513 break;
1514 }
1515
1516 /* This state machine tracks the netdev up/down state */
1517 switch (sfp->sm_dev_state) {
1518 default:
1519 if (event == SFP_E_DEV_UP)
1520 sfp->sm_dev_state = SFP_DEV_UP;
1521 break;
1522
1523 case SFP_DEV_UP:
1524 if (event == SFP_E_DEV_DOWN) {
1525 /* If the module has a PHY, avoid raising TX disable
1526 * as this resets the PHY. Otherwise, raise it to
1527 * turn the laser off.
1528 */
1529 if (!sfp->mod_phy)
1530 sfp_module_tx_disable(sfp);
1531 sfp->sm_dev_state = SFP_DEV_DOWN;
1532 }
1533 break;
1534 }
1535
1536 /* Some events are global */
1537 if (sfp->sm_state != SFP_S_DOWN &&
1538 (sfp->sm_mod_state != SFP_MOD_PRESENT ||
1539 sfp->sm_dev_state != SFP_DEV_UP)) {
1540 if (sfp->sm_state == SFP_S_LINK_UP &&
1541 sfp->sm_dev_state == SFP_DEV_UP)
1542 sfp_sm_link_down(sfp);
1543 if (sfp->mod_phy)
1544 sfp_sm_phy_detach(sfp);
1545 sfp_sm_next(sfp, SFP_S_DOWN, 0);
1546 mutex_unlock(&sfp->sm_mutex);
1547 return;
1548 }
1549
1550 /* The main state machine */
1551 switch (sfp->sm_state) {
1552 case SFP_S_DOWN:
1553 if (sfp->sm_mod_state == SFP_MOD_PRESENT &&
1554 sfp->sm_dev_state == SFP_DEV_UP)
1555 sfp_sm_mod_init(sfp);
1556 break;
1557
1558 case SFP_S_INIT:
1559 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT)
1560 sfp_sm_fault(sfp, true);
1561 else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR)
1562 sfp_sm_link_check_los(sfp);
1563 break;
1564
1565 case SFP_S_WAIT_LOS:
1566 if (event == SFP_E_TX_FAULT)
1567 sfp_sm_fault(sfp, true);
1568 else if (sfp_los_event_inactive(sfp, event))
1569 sfp_sm_link_up(sfp);
1570 break;
1571
1572 case SFP_S_LINK_UP:
1573 if (event == SFP_E_TX_FAULT) {
1574 sfp_sm_link_down(sfp);
1575 sfp_sm_fault(sfp, true);
1576 } else if (sfp_los_event_active(sfp, event)) {
1577 sfp_sm_link_down(sfp);
1578 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
1579 }
1580 break;
1581
1582 case SFP_S_TX_FAULT:
1583 if (event == SFP_E_TIMEOUT) {
1584 sfp_module_tx_fault_reset(sfp);
1585 sfp_sm_next(sfp, SFP_S_REINIT, T_INIT_JIFFIES);
1586 }
1587 break;
1588
1589 case SFP_S_REINIT:
1590 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
1591 sfp_sm_fault(sfp, false);
1592 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) {
1593 dev_info(sfp->dev, "module transmit fault recovered\n");
1594 sfp_sm_link_check_los(sfp);
1595 }
1596 break;
1597
1598 case SFP_S_TX_DISABLE:
1599 break;
1600 }
1601
1602 dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n",
1603 mod_state_to_str(sfp->sm_mod_state),
1604 dev_state_to_str(sfp->sm_dev_state),
1605 sm_state_to_str(sfp->sm_state));
1606
1607 mutex_unlock(&sfp->sm_mutex);
1608 }
1609
1610 static void sfp_start(struct sfp *sfp)
1611 {
1612 sfp_sm_event(sfp, SFP_E_DEV_UP);
1613 }
1614
1615 static void sfp_stop(struct sfp *sfp)
1616 {
1617 sfp_sm_event(sfp, SFP_E_DEV_DOWN);
1618 }
1619
1620 static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo)
1621 {
1622 /* locking... and check module is present */
1623
1624 if (sfp->id.ext.sff8472_compliance &&
1625 !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) {
1626 modinfo->type = ETH_MODULE_SFF_8472;
1627 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1628 } else {
1629 modinfo->type = ETH_MODULE_SFF_8079;
1630 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
1631 }
1632 return 0;
1633 }
1634
1635 static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee,
1636 u8 *data)
1637 {
1638 unsigned int first, last, len;
1639 int ret;
1640
1641 if (ee->len == 0)
1642 return -EINVAL;
1643
1644 first = ee->offset;
1645 last = ee->offset + ee->len;
1646 if (first < ETH_MODULE_SFF_8079_LEN) {
1647 len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN);
1648 len -= first;
1649
1650 ret = sfp_read(sfp, false, first, data, len);
1651 if (ret < 0)
1652 return ret;
1653
1654 first += len;
1655 data += len;
1656 }
1657 if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) {
1658 len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN);
1659 len -= first;
1660 first -= ETH_MODULE_SFF_8079_LEN;
1661
1662 ret = sfp_read(sfp, true, first, data, len);
1663 if (ret < 0)
1664 return ret;
1665 }
1666 return 0;
1667 }
1668
1669 static const struct sfp_socket_ops sfp_module_ops = {
1670 .start = sfp_start,
1671 .stop = sfp_stop,
1672 .module_info = sfp_module_info,
1673 .module_eeprom = sfp_module_eeprom,
1674 };
1675
1676 static void sfp_timeout(struct work_struct *work)
1677 {
1678 struct sfp *sfp = container_of(work, struct sfp, timeout.work);
1679
1680 rtnl_lock();
1681 sfp_sm_event(sfp, SFP_E_TIMEOUT);
1682 rtnl_unlock();
1683 }
1684
1685 static void sfp_check_state(struct sfp *sfp)
1686 {
1687 unsigned int state, i, changed;
1688
1689 state = sfp_get_state(sfp);
1690 changed = state ^ sfp->state;
1691 changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT;
1692
1693 for (i = 0; i < GPIO_MAX; i++)
1694 if (changed & BIT(i))
1695 dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i],
1696 !!(sfp->state & BIT(i)), !!(state & BIT(i)));
1697
1698 state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT);
1699 sfp->state = state;
1700
1701 rtnl_lock();
1702 if (changed & SFP_F_PRESENT)
1703 sfp_sm_event(sfp, state & SFP_F_PRESENT ?
1704 SFP_E_INSERT : SFP_E_REMOVE);
1705
1706 if (changed & SFP_F_TX_FAULT)
1707 sfp_sm_event(sfp, state & SFP_F_TX_FAULT ?
1708 SFP_E_TX_FAULT : SFP_E_TX_CLEAR);
1709
1710 if (changed & SFP_F_LOS)
1711 sfp_sm_event(sfp, state & SFP_F_LOS ?
1712 SFP_E_LOS_HIGH : SFP_E_LOS_LOW);
1713 rtnl_unlock();
1714 }
1715
1716 static irqreturn_t sfp_irq(int irq, void *data)
1717 {
1718 struct sfp *sfp = data;
1719
1720 sfp_check_state(sfp);
1721
1722 return IRQ_HANDLED;
1723 }
1724
1725 static void sfp_poll(struct work_struct *work)
1726 {
1727 struct sfp *sfp = container_of(work, struct sfp, poll.work);
1728
1729 sfp_check_state(sfp);
1730 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
1731 }
1732
1733 static struct sfp *sfp_alloc(struct device *dev)
1734 {
1735 struct sfp *sfp;
1736
1737 sfp = kzalloc(sizeof(*sfp), GFP_KERNEL);
1738 if (!sfp)
1739 return ERR_PTR(-ENOMEM);
1740
1741 sfp->dev = dev;
1742
1743 mutex_init(&sfp->sm_mutex);
1744 INIT_DELAYED_WORK(&sfp->poll, sfp_poll);
1745 INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout);
1746
1747 return sfp;
1748 }
1749
1750 static void sfp_cleanup(void *data)
1751 {
1752 struct sfp *sfp = data;
1753
1754 cancel_delayed_work_sync(&sfp->poll);
1755 cancel_delayed_work_sync(&sfp->timeout);
1756 if (sfp->i2c_mii) {
1757 mdiobus_unregister(sfp->i2c_mii);
1758 mdiobus_free(sfp->i2c_mii);
1759 }
1760 if (sfp->i2c)
1761 i2c_put_adapter(sfp->i2c);
1762 kfree(sfp);
1763 }
1764
1765 static int sfp_probe(struct platform_device *pdev)
1766 {
1767 const struct sff_data *sff;
1768 struct sfp *sfp;
1769 bool poll = false;
1770 int irq, err, i;
1771
1772 sfp = sfp_alloc(&pdev->dev);
1773 if (IS_ERR(sfp))
1774 return PTR_ERR(sfp);
1775
1776 platform_set_drvdata(pdev, sfp);
1777
1778 err = devm_add_action(sfp->dev, sfp_cleanup, sfp);
1779 if (err < 0)
1780 return err;
1781
1782 sff = sfp->type = &sfp_data;
1783
1784 if (pdev->dev.of_node) {
1785 struct device_node *node = pdev->dev.of_node;
1786 const struct of_device_id *id;
1787 struct i2c_adapter *i2c;
1788 struct device_node *np;
1789
1790 id = of_match_node(sfp_of_match, node);
1791 if (WARN_ON(!id))
1792 return -EINVAL;
1793
1794 sff = sfp->type = id->data;
1795
1796 np = of_parse_phandle(node, "i2c-bus", 0);
1797 if (!np) {
1798 dev_err(sfp->dev, "missing 'i2c-bus' property\n");
1799 return -ENODEV;
1800 }
1801
1802 i2c = of_find_i2c_adapter_by_node(np);
1803 of_node_put(np);
1804 if (!i2c)
1805 return -EPROBE_DEFER;
1806
1807 err = sfp_i2c_configure(sfp, i2c);
1808 if (err < 0) {
1809 i2c_put_adapter(i2c);
1810 return err;
1811 }
1812 }
1813
1814 for (i = 0; i < GPIO_MAX; i++)
1815 if (sff->gpios & BIT(i)) {
1816 sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev,
1817 gpio_of_names[i], gpio_flags[i]);
1818 if (IS_ERR(sfp->gpio[i]))
1819 return PTR_ERR(sfp->gpio[i]);
1820 }
1821
1822 sfp->get_state = sfp_gpio_get_state;
1823 sfp->set_state = sfp_gpio_set_state;
1824
1825 /* Modules that have no detect signal are always present */
1826 if (!(sfp->gpio[GPIO_MODDEF0]))
1827 sfp->get_state = sff_gpio_get_state;
1828
1829 device_property_read_u32(&pdev->dev, "maximum-power-milliwatt",
1830 &sfp->max_power_mW);
1831 if (!sfp->max_power_mW)
1832 sfp->max_power_mW = 1000;
1833
1834 dev_info(sfp->dev, "Host maximum power %u.%uW\n",
1835 sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10);
1836
1837 sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops);
1838 if (!sfp->sfp_bus)
1839 return -ENOMEM;
1840
1841 /* Get the initial state, and always signal TX disable,
1842 * since the network interface will not be up.
1843 */
1844 sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE;
1845
1846 if (sfp->gpio[GPIO_RATE_SELECT] &&
1847 gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT]))
1848 sfp->state |= SFP_F_RATE_SELECT;
1849 sfp_set_state(sfp, sfp->state);
1850 sfp_module_tx_disable(sfp);
1851 rtnl_lock();
1852 if (sfp->state & SFP_F_PRESENT)
1853 sfp_sm_event(sfp, SFP_E_INSERT);
1854 rtnl_unlock();
1855
1856 for (i = 0; i < GPIO_MAX; i++) {
1857 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
1858 continue;
1859
1860 irq = gpiod_to_irq(sfp->gpio[i]);
1861 if (!irq) {
1862 poll = true;
1863 continue;
1864 }
1865
1866 err = devm_request_threaded_irq(sfp->dev, irq, NULL, sfp_irq,
1867 IRQF_ONESHOT |
1868 IRQF_TRIGGER_RISING |
1869 IRQF_TRIGGER_FALLING,
1870 dev_name(sfp->dev), sfp);
1871 if (err)
1872 poll = true;
1873 }
1874
1875 if (poll)
1876 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
1877
1878 /* We could have an issue in cases no Tx disable pin is available or
1879 * wired as modules using a laser as their light source will continue to
1880 * be active when the fiber is removed. This could be a safety issue and
1881 * we should at least warn the user about that.
1882 */
1883 if (!sfp->gpio[GPIO_TX_DISABLE])
1884 dev_warn(sfp->dev,
1885 "No tx_disable pin: SFP modules will always be emitting.\n");
1886
1887 return 0;
1888 }
1889
1890 static int sfp_remove(struct platform_device *pdev)
1891 {
1892 struct sfp *sfp = platform_get_drvdata(pdev);
1893
1894 sfp_unregister_socket(sfp->sfp_bus);
1895
1896 return 0;
1897 }
1898
1899 static struct platform_driver sfp_driver = {
1900 .probe = sfp_probe,
1901 .remove = sfp_remove,
1902 .driver = {
1903 .name = "sfp",
1904 .of_match_table = sfp_of_match,
1905 },
1906 };
1907
1908 static int sfp_init(void)
1909 {
1910 poll_jiffies = msecs_to_jiffies(100);
1911
1912 return platform_driver_register(&sfp_driver);
1913 }
1914 module_init(sfp_init);
1915
1916 static void sfp_exit(void)
1917 {
1918 platform_driver_unregister(&sfp_driver);
1919 }
1920 module_exit(sfp_exit);
1921
1922 MODULE_ALIAS("platform:sfp");
1923 MODULE_AUTHOR("Russell King");
1924 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support