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