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