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