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