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: %d\n", 475 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: %d\n", err); 1315 } 1316 return; 1317 } 1318 1319 sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL); 1320 if (!sfp->hwmon_name) { 1321 dev_err(sfp->dev, "out of memory for hwmon name\n"); 1322 return; 1323 } 1324 1325 for (i = 0; sfp->hwmon_name[i]; i++) 1326 if (hwmon_is_bad_char(sfp->hwmon_name[i])) 1327 sfp->hwmon_name[i] = '_'; 1328 1329 sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev, 1330 sfp->hwmon_name, sfp, 1331 &sfp_hwmon_chip_info, 1332 NULL); 1333 if (IS_ERR(sfp->hwmon_dev)) 1334 dev_err(sfp->dev, "failed to register hwmon device: %ld\n", 1335 PTR_ERR(sfp->hwmon_dev)); 1336 } 1337 1338 static int sfp_hwmon_insert(struct sfp *sfp) 1339 { 1340 if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE) 1341 return 0; 1342 1343 if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM)) 1344 return 0; 1345 1346 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) 1347 /* This driver in general does not support address 1348 * change. 1349 */ 1350 return 0; 1351 1352 mod_delayed_work(system_wq, &sfp->hwmon_probe, 1); 1353 sfp->hwmon_tries = R_PROBE_RETRY_SLOW; 1354 1355 return 0; 1356 } 1357 1358 static void sfp_hwmon_remove(struct sfp *sfp) 1359 { 1360 cancel_delayed_work_sync(&sfp->hwmon_probe); 1361 if (!IS_ERR_OR_NULL(sfp->hwmon_dev)) { 1362 hwmon_device_unregister(sfp->hwmon_dev); 1363 sfp->hwmon_dev = NULL; 1364 kfree(sfp->hwmon_name); 1365 } 1366 } 1367 1368 static int sfp_hwmon_init(struct sfp *sfp) 1369 { 1370 INIT_DELAYED_WORK(&sfp->hwmon_probe, sfp_hwmon_probe); 1371 1372 return 0; 1373 } 1374 1375 static void sfp_hwmon_exit(struct sfp *sfp) 1376 { 1377 cancel_delayed_work_sync(&sfp->hwmon_probe); 1378 } 1379 #else 1380 static int sfp_hwmon_insert(struct sfp *sfp) 1381 { 1382 return 0; 1383 } 1384 1385 static void sfp_hwmon_remove(struct sfp *sfp) 1386 { 1387 } 1388 1389 static int sfp_hwmon_init(struct sfp *sfp) 1390 { 1391 return 0; 1392 } 1393 1394 static void sfp_hwmon_exit(struct sfp *sfp) 1395 { 1396 } 1397 #endif 1398 1399 /* Helpers */ 1400 static void sfp_module_tx_disable(struct sfp *sfp) 1401 { 1402 dev_dbg(sfp->dev, "tx disable %u -> %u\n", 1403 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1); 1404 sfp->state |= SFP_F_TX_DISABLE; 1405 sfp_set_state(sfp, sfp->state); 1406 } 1407 1408 static void sfp_module_tx_enable(struct sfp *sfp) 1409 { 1410 dev_dbg(sfp->dev, "tx disable %u -> %u\n", 1411 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0); 1412 sfp->state &= ~SFP_F_TX_DISABLE; 1413 sfp_set_state(sfp, sfp->state); 1414 } 1415 1416 #if IS_ENABLED(CONFIG_DEBUG_FS) 1417 static int sfp_debug_state_show(struct seq_file *s, void *data) 1418 { 1419 struct sfp *sfp = s->private; 1420 1421 seq_printf(s, "Module state: %s\n", 1422 mod_state_to_str(sfp->sm_mod_state)); 1423 seq_printf(s, "Module probe attempts: %d %d\n", 1424 R_PROBE_RETRY_INIT - sfp->sm_mod_tries_init, 1425 R_PROBE_RETRY_SLOW - sfp->sm_mod_tries); 1426 seq_printf(s, "Device state: %s\n", 1427 dev_state_to_str(sfp->sm_dev_state)); 1428 seq_printf(s, "Main state: %s\n", 1429 sm_state_to_str(sfp->sm_state)); 1430 seq_printf(s, "Fault recovery remaining retries: %d\n", 1431 sfp->sm_fault_retries); 1432 seq_printf(s, "PHY probe remaining retries: %d\n", 1433 sfp->sm_phy_retries); 1434 seq_printf(s, "moddef0: %d\n", !!(sfp->state & SFP_F_PRESENT)); 1435 seq_printf(s, "rx_los: %d\n", !!(sfp->state & SFP_F_LOS)); 1436 seq_printf(s, "tx_fault: %d\n", !!(sfp->state & SFP_F_TX_FAULT)); 1437 seq_printf(s, "tx_disable: %d\n", !!(sfp->state & SFP_F_TX_DISABLE)); 1438 return 0; 1439 } 1440 DEFINE_SHOW_ATTRIBUTE(sfp_debug_state); 1441 1442 static void sfp_debugfs_init(struct sfp *sfp) 1443 { 1444 sfp->debugfs_dir = debugfs_create_dir(dev_name(sfp->dev), NULL); 1445 1446 debugfs_create_file("state", 0600, sfp->debugfs_dir, sfp, 1447 &sfp_debug_state_fops); 1448 } 1449 1450 static void sfp_debugfs_exit(struct sfp *sfp) 1451 { 1452 debugfs_remove_recursive(sfp->debugfs_dir); 1453 } 1454 #else 1455 static void sfp_debugfs_init(struct sfp *sfp) 1456 { 1457 } 1458 1459 static void sfp_debugfs_exit(struct sfp *sfp) 1460 { 1461 } 1462 #endif 1463 1464 static void sfp_module_tx_fault_reset(struct sfp *sfp) 1465 { 1466 unsigned int state = sfp->state; 1467 1468 if (state & SFP_F_TX_DISABLE) 1469 return; 1470 1471 sfp_set_state(sfp, state | SFP_F_TX_DISABLE); 1472 1473 udelay(T_RESET_US); 1474 1475 sfp_set_state(sfp, state); 1476 } 1477 1478 /* SFP state machine */ 1479 static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout) 1480 { 1481 if (timeout) 1482 mod_delayed_work(system_power_efficient_wq, &sfp->timeout, 1483 timeout); 1484 else 1485 cancel_delayed_work(&sfp->timeout); 1486 } 1487 1488 static void sfp_sm_next(struct sfp *sfp, unsigned int state, 1489 unsigned int timeout) 1490 { 1491 sfp->sm_state = state; 1492 sfp_sm_set_timer(sfp, timeout); 1493 } 1494 1495 static void sfp_sm_mod_next(struct sfp *sfp, unsigned int state, 1496 unsigned int timeout) 1497 { 1498 sfp->sm_mod_state = state; 1499 sfp_sm_set_timer(sfp, timeout); 1500 } 1501 1502 static void sfp_sm_phy_detach(struct sfp *sfp) 1503 { 1504 sfp_remove_phy(sfp->sfp_bus); 1505 phy_device_remove(sfp->mod_phy); 1506 phy_device_free(sfp->mod_phy); 1507 sfp->mod_phy = NULL; 1508 } 1509 1510 static int sfp_sm_probe_phy(struct sfp *sfp, bool is_c45) 1511 { 1512 struct phy_device *phy; 1513 int err; 1514 1515 phy = get_phy_device(sfp->i2c_mii, SFP_PHY_ADDR, is_c45); 1516 if (phy == ERR_PTR(-ENODEV)) 1517 return PTR_ERR(phy); 1518 if (IS_ERR(phy)) { 1519 dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy)); 1520 return PTR_ERR(phy); 1521 } 1522 1523 err = phy_device_register(phy); 1524 if (err) { 1525 phy_device_free(phy); 1526 dev_err(sfp->dev, "phy_device_register failed: %d\n", err); 1527 return err; 1528 } 1529 1530 err = sfp_add_phy(sfp->sfp_bus, phy); 1531 if (err) { 1532 phy_device_remove(phy); 1533 phy_device_free(phy); 1534 dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err); 1535 return err; 1536 } 1537 1538 sfp->mod_phy = phy; 1539 1540 return 0; 1541 } 1542 1543 static void sfp_sm_link_up(struct sfp *sfp) 1544 { 1545 sfp_link_up(sfp->sfp_bus); 1546 sfp_sm_next(sfp, SFP_S_LINK_UP, 0); 1547 } 1548 1549 static void sfp_sm_link_down(struct sfp *sfp) 1550 { 1551 sfp_link_down(sfp->sfp_bus); 1552 } 1553 1554 static void sfp_sm_link_check_los(struct sfp *sfp) 1555 { 1556 const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED); 1557 const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL); 1558 __be16 los_options = sfp->id.ext.options & (los_inverted | los_normal); 1559 bool los = false; 1560 1561 /* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL 1562 * are set, we assume that no LOS signal is available. If both are 1563 * set, we assume LOS is not implemented (and is meaningless.) 1564 */ 1565 if (los_options == los_inverted) 1566 los = !(sfp->state & SFP_F_LOS); 1567 else if (los_options == los_normal) 1568 los = !!(sfp->state & SFP_F_LOS); 1569 1570 if (los) 1571 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); 1572 else 1573 sfp_sm_link_up(sfp); 1574 } 1575 1576 static bool sfp_los_event_active(struct sfp *sfp, unsigned int event) 1577 { 1578 const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED); 1579 const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL); 1580 __be16 los_options = sfp->id.ext.options & (los_inverted | los_normal); 1581 1582 return (los_options == los_inverted && event == SFP_E_LOS_LOW) || 1583 (los_options == los_normal && event == SFP_E_LOS_HIGH); 1584 } 1585 1586 static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event) 1587 { 1588 const __be16 los_inverted = cpu_to_be16(SFP_OPTIONS_LOS_INVERTED); 1589 const __be16 los_normal = cpu_to_be16(SFP_OPTIONS_LOS_NORMAL); 1590 __be16 los_options = sfp->id.ext.options & (los_inverted | los_normal); 1591 1592 return (los_options == los_inverted && event == SFP_E_LOS_HIGH) || 1593 (los_options == los_normal && event == SFP_E_LOS_LOW); 1594 } 1595 1596 static void sfp_sm_fault(struct sfp *sfp, unsigned int next_state, bool warn) 1597 { 1598 if (sfp->sm_fault_retries && !--sfp->sm_fault_retries) { 1599 dev_err(sfp->dev, 1600 "module persistently indicates fault, disabling\n"); 1601 sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0); 1602 } else { 1603 if (warn) 1604 dev_err(sfp->dev, "module transmit fault indicated\n"); 1605 1606 sfp_sm_next(sfp, next_state, T_FAULT_RECOVER); 1607 } 1608 } 1609 1610 /* Probe a SFP for a PHY device if the module supports copper - the PHY 1611 * normally sits at I2C bus address 0x56, and may either be a clause 22 1612 * or clause 45 PHY. 1613 * 1614 * Clause 22 copper SFP modules normally operate in Cisco SGMII mode with 1615 * negotiation enabled, but some may be in 1000base-X - which is for the 1616 * PHY driver to determine. 1617 * 1618 * Clause 45 copper SFP+ modules (10G) appear to switch their interface 1619 * mode according to the negotiated line speed. 1620 */ 1621 static int sfp_sm_probe_for_phy(struct sfp *sfp) 1622 { 1623 int err = 0; 1624 1625 switch (sfp->id.base.extended_cc) { 1626 case SFF8024_ECC_10GBASE_T_SFI: 1627 case SFF8024_ECC_10GBASE_T_SR: 1628 case SFF8024_ECC_5GBASE_T: 1629 case SFF8024_ECC_2_5GBASE_T: 1630 err = sfp_sm_probe_phy(sfp, true); 1631 break; 1632 1633 default: 1634 if (sfp->id.base.e1000_base_t) 1635 err = sfp_sm_probe_phy(sfp, false); 1636 break; 1637 } 1638 return err; 1639 } 1640 1641 static int sfp_module_parse_power(struct sfp *sfp) 1642 { 1643 u32 power_mW = 1000; 1644 bool supports_a2; 1645 1646 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL)) 1647 power_mW = 1500; 1648 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL)) 1649 power_mW = 2000; 1650 1651 supports_a2 = sfp->id.ext.sff8472_compliance != 1652 SFP_SFF8472_COMPLIANCE_NONE || 1653 sfp->id.ext.diagmon & SFP_DIAGMON_DDM; 1654 1655 if (power_mW > sfp->max_power_mW) { 1656 /* Module power specification exceeds the allowed maximum. */ 1657 if (!supports_a2) { 1658 /* The module appears not to implement bus address 1659 * 0xa2, so assume that the module powers up in the 1660 * indicated mode. 1661 */ 1662 dev_err(sfp->dev, 1663 "Host does not support %u.%uW modules\n", 1664 power_mW / 1000, (power_mW / 100) % 10); 1665 return -EINVAL; 1666 } else { 1667 dev_warn(sfp->dev, 1668 "Host does not support %u.%uW modules, module left in power mode 1\n", 1669 power_mW / 1000, (power_mW / 100) % 10); 1670 return 0; 1671 } 1672 } 1673 1674 if (power_mW <= 1000) { 1675 /* Modules below 1W do not require a power change sequence */ 1676 sfp->module_power_mW = power_mW; 1677 return 0; 1678 } 1679 1680 if (!supports_a2) { 1681 /* The module power level is below the host maximum and the 1682 * module appears not to implement bus address 0xa2, so assume 1683 * that the module powers up in the indicated mode. 1684 */ 1685 return 0; 1686 } 1687 1688 /* If the module requires a higher power mode, but also requires 1689 * an address change sequence, warn the user that the module may 1690 * not be functional. 1691 */ 1692 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) { 1693 dev_warn(sfp->dev, 1694 "Address Change Sequence not supported but module requires %u.%uW, module may not be functional\n", 1695 power_mW / 1000, (power_mW / 100) % 10); 1696 return 0; 1697 } 1698 1699 sfp->module_power_mW = power_mW; 1700 1701 return 0; 1702 } 1703 1704 static int sfp_sm_mod_hpower(struct sfp *sfp, bool enable) 1705 { 1706 u8 val; 1707 int err; 1708 1709 err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1710 if (err != sizeof(val)) { 1711 dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err); 1712 return -EAGAIN; 1713 } 1714 1715 /* DM7052 reports as a high power module, responds to reads (with 1716 * all bytes 0xff) at 0x51 but does not accept writes. In any case, 1717 * if the bit is already set, we're already in high power mode. 1718 */ 1719 if (!!(val & BIT(0)) == enable) 1720 return 0; 1721 1722 if (enable) 1723 val |= BIT(0); 1724 else 1725 val &= ~BIT(0); 1726 1727 err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1728 if (err != sizeof(val)) { 1729 dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err); 1730 return -EAGAIN; 1731 } 1732 1733 if (enable) 1734 dev_info(sfp->dev, "Module switched to %u.%uW power level\n", 1735 sfp->module_power_mW / 1000, 1736 (sfp->module_power_mW / 100) % 10); 1737 1738 return 0; 1739 } 1740 1741 /* GPON modules based on Realtek RTL8672 and RTL9601C chips (e.g. V-SOL 1742 * V2801F, CarlitoxxPro CPGOS03-0490, Ubiquiti U-Fiber Instant, ...) do 1743 * not support multibyte reads from the EEPROM. Each multi-byte read 1744 * operation returns just one byte of EEPROM followed by zeros. There is 1745 * no way to identify which modules are using Realtek RTL8672 and RTL9601C 1746 * chips. Moreover every OEM of V-SOL V2801F module puts its own vendor 1747 * name and vendor id into EEPROM, so there is even no way to detect if 1748 * module is V-SOL V2801F. Therefore check for those zeros in the read 1749 * data and then based on check switch to reading EEPROM to one byte 1750 * at a time. 1751 */ 1752 static bool sfp_id_needs_byte_io(struct sfp *sfp, void *buf, size_t len) 1753 { 1754 size_t i, block_size = sfp->i2c_block_size; 1755 1756 /* Already using byte IO */ 1757 if (block_size == 1) 1758 return false; 1759 1760 for (i = 1; i < len; i += block_size) { 1761 if (memchr_inv(buf + i, '\0', min(block_size - 1, len - i))) 1762 return false; 1763 } 1764 return true; 1765 } 1766 1767 static int sfp_cotsworks_fixup_check(struct sfp *sfp, struct sfp_eeprom_id *id) 1768 { 1769 u8 check; 1770 int err; 1771 1772 if (id->base.phys_id != SFF8024_ID_SFF_8472 || 1773 id->base.phys_ext_id != SFP_PHYS_EXT_ID_SFP || 1774 id->base.connector != SFF8024_CONNECTOR_LC) { 1775 dev_warn(sfp->dev, "Rewriting fiber module EEPROM with corrected values\n"); 1776 id->base.phys_id = SFF8024_ID_SFF_8472; 1777 id->base.phys_ext_id = SFP_PHYS_EXT_ID_SFP; 1778 id->base.connector = SFF8024_CONNECTOR_LC; 1779 err = sfp_write(sfp, false, SFP_PHYS_ID, &id->base, 3); 1780 if (err != 3) { 1781 dev_err(sfp->dev, "Failed to rewrite module EEPROM: %d\n", err); 1782 return err; 1783 } 1784 1785 /* Cotsworks modules have been found to require a delay between write operations. */ 1786 mdelay(50); 1787 1788 /* Update base structure checksum */ 1789 check = sfp_check(&id->base, sizeof(id->base) - 1); 1790 err = sfp_write(sfp, false, SFP_CC_BASE, &check, 1); 1791 if (err != 1) { 1792 dev_err(sfp->dev, "Failed to update base structure checksum in fiber module EEPROM: %d\n", err); 1793 return err; 1794 } 1795 } 1796 return 0; 1797 } 1798 1799 static int sfp_sm_mod_probe(struct sfp *sfp, bool report) 1800 { 1801 /* SFP module inserted - read I2C data */ 1802 struct sfp_eeprom_id id; 1803 bool cotsworks_sfbg; 1804 bool cotsworks; 1805 u8 check; 1806 int ret; 1807 1808 /* Some SFP modules and also some Linux I2C drivers do not like reads 1809 * longer than 16 bytes, so read the EEPROM in chunks of 16 bytes at 1810 * a time. 1811 */ 1812 sfp->i2c_block_size = 16; 1813 1814 ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base)); 1815 if (ret < 0) { 1816 if (report) 1817 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret); 1818 return -EAGAIN; 1819 } 1820 1821 if (ret != sizeof(id.base)) { 1822 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1823 return -EAGAIN; 1824 } 1825 1826 /* Some SFP modules (e.g. Nokia 3FE46541AA) lock up if read from 1827 * address 0x51 is just one byte at a time. Also SFF-8472 requires 1828 * that EEPROM supports atomic 16bit read operation for diagnostic 1829 * fields, so do not switch to one byte reading at a time unless it 1830 * is really required and we have no other option. 1831 */ 1832 if (sfp_id_needs_byte_io(sfp, &id.base, sizeof(id.base))) { 1833 dev_info(sfp->dev, 1834 "Detected broken RTL8672/RTL9601C emulated EEPROM\n"); 1835 dev_info(sfp->dev, 1836 "Switching to reading EEPROM to one byte at a time\n"); 1837 sfp->i2c_block_size = 1; 1838 1839 ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base)); 1840 if (ret < 0) { 1841 if (report) 1842 dev_err(sfp->dev, "failed to read EEPROM: %d\n", 1843 ret); 1844 return -EAGAIN; 1845 } 1846 1847 if (ret != sizeof(id.base)) { 1848 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1849 return -EAGAIN; 1850 } 1851 } 1852 1853 /* Cotsworks do not seem to update the checksums when they 1854 * do the final programming with the final module part number, 1855 * serial number and date code. 1856 */ 1857 cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS ", 16); 1858 cotsworks_sfbg = !memcmp(id.base.vendor_pn, "SFBG", 4); 1859 1860 /* Cotsworks SFF module EEPROM do not always have valid phys_id, 1861 * phys_ext_id, and connector bytes. Rewrite SFF EEPROM bytes if 1862 * Cotsworks PN matches and bytes are not correct. 1863 */ 1864 if (cotsworks && cotsworks_sfbg) { 1865 ret = sfp_cotsworks_fixup_check(sfp, &id); 1866 if (ret < 0) 1867 return ret; 1868 } 1869 1870 /* Validate the checksum over the base structure */ 1871 check = sfp_check(&id.base, sizeof(id.base) - 1); 1872 if (check != id.base.cc_base) { 1873 if (cotsworks) { 1874 dev_warn(sfp->dev, 1875 "EEPROM base structure checksum failure (0x%02x != 0x%02x)\n", 1876 check, id.base.cc_base); 1877 } else { 1878 dev_err(sfp->dev, 1879 "EEPROM base structure checksum failure: 0x%02x != 0x%02x\n", 1880 check, id.base.cc_base); 1881 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1882 16, 1, &id, sizeof(id), true); 1883 return -EINVAL; 1884 } 1885 } 1886 1887 ret = sfp_read(sfp, false, SFP_CC_BASE + 1, &id.ext, sizeof(id.ext)); 1888 if (ret < 0) { 1889 if (report) 1890 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret); 1891 return -EAGAIN; 1892 } 1893 1894 if (ret != sizeof(id.ext)) { 1895 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1896 return -EAGAIN; 1897 } 1898 1899 check = sfp_check(&id.ext, sizeof(id.ext) - 1); 1900 if (check != id.ext.cc_ext) { 1901 if (cotsworks) { 1902 dev_warn(sfp->dev, 1903 "EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n", 1904 check, id.ext.cc_ext); 1905 } else { 1906 dev_err(sfp->dev, 1907 "EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n", 1908 check, id.ext.cc_ext); 1909 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1910 16, 1, &id, sizeof(id), true); 1911 memset(&id.ext, 0, sizeof(id.ext)); 1912 } 1913 } 1914 1915 sfp->id = id; 1916 1917 dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n", 1918 (int)sizeof(id.base.vendor_name), id.base.vendor_name, 1919 (int)sizeof(id.base.vendor_pn), id.base.vendor_pn, 1920 (int)sizeof(id.base.vendor_rev), id.base.vendor_rev, 1921 (int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn, 1922 (int)sizeof(id.ext.datecode), id.ext.datecode); 1923 1924 /* Check whether we support this module */ 1925 if (!sfp->type->module_supported(&id)) { 1926 dev_err(sfp->dev, 1927 "module is not supported - phys id 0x%02x 0x%02x\n", 1928 sfp->id.base.phys_id, sfp->id.base.phys_ext_id); 1929 return -EINVAL; 1930 } 1931 1932 /* If the module requires address swap mode, warn about it */ 1933 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) 1934 dev_warn(sfp->dev, 1935 "module address swap to access page 0xA2 is not supported.\n"); 1936 1937 /* Parse the module power requirement */ 1938 ret = sfp_module_parse_power(sfp); 1939 if (ret < 0) 1940 return ret; 1941 1942 if (!memcmp(id.base.vendor_name, "ALCATELLUCENT ", 16) && 1943 !memcmp(id.base.vendor_pn, "3FE46541AA ", 16)) 1944 sfp->module_t_start_up = T_START_UP_BAD_GPON; 1945 else 1946 sfp->module_t_start_up = T_START_UP; 1947 1948 return 0; 1949 } 1950 1951 static void sfp_sm_mod_remove(struct sfp *sfp) 1952 { 1953 if (sfp->sm_mod_state > SFP_MOD_WAITDEV) 1954 sfp_module_remove(sfp->sfp_bus); 1955 1956 sfp_hwmon_remove(sfp); 1957 1958 memset(&sfp->id, 0, sizeof(sfp->id)); 1959 sfp->module_power_mW = 0; 1960 1961 dev_info(sfp->dev, "module removed\n"); 1962 } 1963 1964 /* This state machine tracks the upstream's state */ 1965 static void sfp_sm_device(struct sfp *sfp, unsigned int event) 1966 { 1967 switch (sfp->sm_dev_state) { 1968 default: 1969 if (event == SFP_E_DEV_ATTACH) 1970 sfp->sm_dev_state = SFP_DEV_DOWN; 1971 break; 1972 1973 case SFP_DEV_DOWN: 1974 if (event == SFP_E_DEV_DETACH) 1975 sfp->sm_dev_state = SFP_DEV_DETACHED; 1976 else if (event == SFP_E_DEV_UP) 1977 sfp->sm_dev_state = SFP_DEV_UP; 1978 break; 1979 1980 case SFP_DEV_UP: 1981 if (event == SFP_E_DEV_DETACH) 1982 sfp->sm_dev_state = SFP_DEV_DETACHED; 1983 else if (event == SFP_E_DEV_DOWN) 1984 sfp->sm_dev_state = SFP_DEV_DOWN; 1985 break; 1986 } 1987 } 1988 1989 /* This state machine tracks the insert/remove state of the module, probes 1990 * the on-board EEPROM, and sets up the power level. 1991 */ 1992 static void sfp_sm_module(struct sfp *sfp, unsigned int event) 1993 { 1994 int err; 1995 1996 /* Handle remove event globally, it resets this state machine */ 1997 if (event == SFP_E_REMOVE) { 1998 if (sfp->sm_mod_state > SFP_MOD_PROBE) 1999 sfp_sm_mod_remove(sfp); 2000 sfp_sm_mod_next(sfp, SFP_MOD_EMPTY, 0); 2001 return; 2002 } 2003 2004 /* Handle device detach globally */ 2005 if (sfp->sm_dev_state < SFP_DEV_DOWN && 2006 sfp->sm_mod_state > SFP_MOD_WAITDEV) { 2007 if (sfp->module_power_mW > 1000 && 2008 sfp->sm_mod_state > SFP_MOD_HPOWER) 2009 sfp_sm_mod_hpower(sfp, false); 2010 sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0); 2011 return; 2012 } 2013 2014 switch (sfp->sm_mod_state) { 2015 default: 2016 if (event == SFP_E_INSERT) { 2017 sfp_sm_mod_next(sfp, SFP_MOD_PROBE, T_SERIAL); 2018 sfp->sm_mod_tries_init = R_PROBE_RETRY_INIT; 2019 sfp->sm_mod_tries = R_PROBE_RETRY_SLOW; 2020 } 2021 break; 2022 2023 case SFP_MOD_PROBE: 2024 /* Wait for T_PROBE_INIT to time out */ 2025 if (event != SFP_E_TIMEOUT) 2026 break; 2027 2028 err = sfp_sm_mod_probe(sfp, sfp->sm_mod_tries == 1); 2029 if (err == -EAGAIN) { 2030 if (sfp->sm_mod_tries_init && 2031 --sfp->sm_mod_tries_init) { 2032 sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT); 2033 break; 2034 } else if (sfp->sm_mod_tries && --sfp->sm_mod_tries) { 2035 if (sfp->sm_mod_tries == R_PROBE_RETRY_SLOW - 1) 2036 dev_warn(sfp->dev, 2037 "please wait, module slow to respond\n"); 2038 sfp_sm_set_timer(sfp, T_PROBE_RETRY_SLOW); 2039 break; 2040 } 2041 } 2042 if (err < 0) { 2043 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2044 break; 2045 } 2046 2047 err = sfp_hwmon_insert(sfp); 2048 if (err) 2049 dev_warn(sfp->dev, "hwmon probe failed: %d\n", err); 2050 2051 sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0); 2052 fallthrough; 2053 case SFP_MOD_WAITDEV: 2054 /* Ensure that the device is attached before proceeding */ 2055 if (sfp->sm_dev_state < SFP_DEV_DOWN) 2056 break; 2057 2058 /* Report the module insertion to the upstream device */ 2059 err = sfp_module_insert(sfp->sfp_bus, &sfp->id); 2060 if (err < 0) { 2061 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2062 break; 2063 } 2064 2065 /* If this is a power level 1 module, we are done */ 2066 if (sfp->module_power_mW <= 1000) 2067 goto insert; 2068 2069 sfp_sm_mod_next(sfp, SFP_MOD_HPOWER, 0); 2070 fallthrough; 2071 case SFP_MOD_HPOWER: 2072 /* Enable high power mode */ 2073 err = sfp_sm_mod_hpower(sfp, true); 2074 if (err < 0) { 2075 if (err != -EAGAIN) { 2076 sfp_module_remove(sfp->sfp_bus); 2077 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2078 } else { 2079 sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT); 2080 } 2081 break; 2082 } 2083 2084 sfp_sm_mod_next(sfp, SFP_MOD_WAITPWR, T_HPOWER_LEVEL); 2085 break; 2086 2087 case SFP_MOD_WAITPWR: 2088 /* Wait for T_HPOWER_LEVEL to time out */ 2089 if (event != SFP_E_TIMEOUT) 2090 break; 2091 2092 insert: 2093 sfp_sm_mod_next(sfp, SFP_MOD_PRESENT, 0); 2094 break; 2095 2096 case SFP_MOD_PRESENT: 2097 case SFP_MOD_ERROR: 2098 break; 2099 } 2100 } 2101 2102 static void sfp_sm_main(struct sfp *sfp, unsigned int event) 2103 { 2104 unsigned long timeout; 2105 int ret; 2106 2107 /* Some events are global */ 2108 if (sfp->sm_state != SFP_S_DOWN && 2109 (sfp->sm_mod_state != SFP_MOD_PRESENT || 2110 sfp->sm_dev_state != SFP_DEV_UP)) { 2111 if (sfp->sm_state == SFP_S_LINK_UP && 2112 sfp->sm_dev_state == SFP_DEV_UP) 2113 sfp_sm_link_down(sfp); 2114 if (sfp->sm_state > SFP_S_INIT) 2115 sfp_module_stop(sfp->sfp_bus); 2116 if (sfp->mod_phy) 2117 sfp_sm_phy_detach(sfp); 2118 sfp_module_tx_disable(sfp); 2119 sfp_soft_stop_poll(sfp); 2120 sfp_sm_next(sfp, SFP_S_DOWN, 0); 2121 return; 2122 } 2123 2124 /* The main state machine */ 2125 switch (sfp->sm_state) { 2126 case SFP_S_DOWN: 2127 if (sfp->sm_mod_state != SFP_MOD_PRESENT || 2128 sfp->sm_dev_state != SFP_DEV_UP) 2129 break; 2130 2131 if (!(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) 2132 sfp_soft_start_poll(sfp); 2133 2134 sfp_module_tx_enable(sfp); 2135 2136 /* Initialise the fault clearance retries */ 2137 sfp->sm_fault_retries = N_FAULT_INIT; 2138 2139 /* We need to check the TX_FAULT state, which is not defined 2140 * while TX_DISABLE is asserted. The earliest we want to do 2141 * anything (such as probe for a PHY) is 50ms. 2142 */ 2143 sfp_sm_next(sfp, SFP_S_WAIT, T_WAIT); 2144 break; 2145 2146 case SFP_S_WAIT: 2147 if (event != SFP_E_TIMEOUT) 2148 break; 2149 2150 if (sfp->state & SFP_F_TX_FAULT) { 2151 /* Wait up to t_init (SFF-8472) or t_start_up (SFF-8431) 2152 * from the TX_DISABLE deassertion for the module to 2153 * initialise, which is indicated by TX_FAULT 2154 * deasserting. 2155 */ 2156 timeout = sfp->module_t_start_up; 2157 if (timeout > T_WAIT) 2158 timeout -= T_WAIT; 2159 else 2160 timeout = 1; 2161 2162 sfp_sm_next(sfp, SFP_S_INIT, timeout); 2163 } else { 2164 /* TX_FAULT is not asserted, assume the module has 2165 * finished initialising. 2166 */ 2167 goto init_done; 2168 } 2169 break; 2170 2171 case SFP_S_INIT: 2172 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { 2173 /* TX_FAULT is still asserted after t_init 2174 * or t_start_up, so assume there is a fault. 2175 */ 2176 sfp_sm_fault(sfp, SFP_S_INIT_TX_FAULT, 2177 sfp->sm_fault_retries == N_FAULT_INIT); 2178 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { 2179 init_done: 2180 sfp->sm_phy_retries = R_PHY_RETRY; 2181 goto phy_probe; 2182 } 2183 break; 2184 2185 case SFP_S_INIT_PHY: 2186 if (event != SFP_E_TIMEOUT) 2187 break; 2188 phy_probe: 2189 /* TX_FAULT deasserted or we timed out with TX_FAULT 2190 * clear. Probe for the PHY and check the LOS state. 2191 */ 2192 ret = sfp_sm_probe_for_phy(sfp); 2193 if (ret == -ENODEV) { 2194 if (--sfp->sm_phy_retries) { 2195 sfp_sm_next(sfp, SFP_S_INIT_PHY, T_PHY_RETRY); 2196 break; 2197 } else { 2198 dev_info(sfp->dev, "no PHY detected\n"); 2199 } 2200 } else if (ret) { 2201 sfp_sm_next(sfp, SFP_S_FAIL, 0); 2202 break; 2203 } 2204 if (sfp_module_start(sfp->sfp_bus)) { 2205 sfp_sm_next(sfp, SFP_S_FAIL, 0); 2206 break; 2207 } 2208 sfp_sm_link_check_los(sfp); 2209 2210 /* Reset the fault retry count */ 2211 sfp->sm_fault_retries = N_FAULT; 2212 break; 2213 2214 case SFP_S_INIT_TX_FAULT: 2215 if (event == SFP_E_TIMEOUT) { 2216 sfp_module_tx_fault_reset(sfp); 2217 sfp_sm_next(sfp, SFP_S_INIT, sfp->module_t_start_up); 2218 } 2219 break; 2220 2221 case SFP_S_WAIT_LOS: 2222 if (event == SFP_E_TX_FAULT) 2223 sfp_sm_fault(sfp, SFP_S_TX_FAULT, true); 2224 else if (sfp_los_event_inactive(sfp, event)) 2225 sfp_sm_link_up(sfp); 2226 break; 2227 2228 case SFP_S_LINK_UP: 2229 if (event == SFP_E_TX_FAULT) { 2230 sfp_sm_link_down(sfp); 2231 sfp_sm_fault(sfp, SFP_S_TX_FAULT, true); 2232 } else if (sfp_los_event_active(sfp, event)) { 2233 sfp_sm_link_down(sfp); 2234 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); 2235 } 2236 break; 2237 2238 case SFP_S_TX_FAULT: 2239 if (event == SFP_E_TIMEOUT) { 2240 sfp_module_tx_fault_reset(sfp); 2241 sfp_sm_next(sfp, SFP_S_REINIT, sfp->module_t_start_up); 2242 } 2243 break; 2244 2245 case SFP_S_REINIT: 2246 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { 2247 sfp_sm_fault(sfp, SFP_S_TX_FAULT, false); 2248 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { 2249 dev_info(sfp->dev, "module transmit fault recovered\n"); 2250 sfp_sm_link_check_los(sfp); 2251 } 2252 break; 2253 2254 case SFP_S_TX_DISABLE: 2255 break; 2256 } 2257 } 2258 2259 static void sfp_sm_event(struct sfp *sfp, unsigned int event) 2260 { 2261 mutex_lock(&sfp->sm_mutex); 2262 2263 dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n", 2264 mod_state_to_str(sfp->sm_mod_state), 2265 dev_state_to_str(sfp->sm_dev_state), 2266 sm_state_to_str(sfp->sm_state), 2267 event_to_str(event)); 2268 2269 sfp_sm_device(sfp, event); 2270 sfp_sm_module(sfp, event); 2271 sfp_sm_main(sfp, event); 2272 2273 dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n", 2274 mod_state_to_str(sfp->sm_mod_state), 2275 dev_state_to_str(sfp->sm_dev_state), 2276 sm_state_to_str(sfp->sm_state)); 2277 2278 mutex_unlock(&sfp->sm_mutex); 2279 } 2280 2281 static void sfp_attach(struct sfp *sfp) 2282 { 2283 sfp_sm_event(sfp, SFP_E_DEV_ATTACH); 2284 } 2285 2286 static void sfp_detach(struct sfp *sfp) 2287 { 2288 sfp_sm_event(sfp, SFP_E_DEV_DETACH); 2289 } 2290 2291 static void sfp_start(struct sfp *sfp) 2292 { 2293 sfp_sm_event(sfp, SFP_E_DEV_UP); 2294 } 2295 2296 static void sfp_stop(struct sfp *sfp) 2297 { 2298 sfp_sm_event(sfp, SFP_E_DEV_DOWN); 2299 } 2300 2301 static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo) 2302 { 2303 /* locking... and check module is present */ 2304 2305 if (sfp->id.ext.sff8472_compliance && 2306 !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) { 2307 modinfo->type = ETH_MODULE_SFF_8472; 2308 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 2309 } else { 2310 modinfo->type = ETH_MODULE_SFF_8079; 2311 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; 2312 } 2313 return 0; 2314 } 2315 2316 static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee, 2317 u8 *data) 2318 { 2319 unsigned int first, last, len; 2320 int ret; 2321 2322 if (ee->len == 0) 2323 return -EINVAL; 2324 2325 first = ee->offset; 2326 last = ee->offset + ee->len; 2327 if (first < ETH_MODULE_SFF_8079_LEN) { 2328 len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN); 2329 len -= first; 2330 2331 ret = sfp_read(sfp, false, first, data, len); 2332 if (ret < 0) 2333 return ret; 2334 2335 first += len; 2336 data += len; 2337 } 2338 if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) { 2339 len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN); 2340 len -= first; 2341 first -= ETH_MODULE_SFF_8079_LEN; 2342 2343 ret = sfp_read(sfp, true, first, data, len); 2344 if (ret < 0) 2345 return ret; 2346 } 2347 return 0; 2348 } 2349 2350 static int sfp_module_eeprom_by_page(struct sfp *sfp, 2351 const struct ethtool_module_eeprom *page, 2352 struct netlink_ext_ack *extack) 2353 { 2354 if (page->bank) { 2355 NL_SET_ERR_MSG(extack, "Banks not supported"); 2356 return -EOPNOTSUPP; 2357 } 2358 2359 if (page->page) { 2360 NL_SET_ERR_MSG(extack, "Only page 0 supported"); 2361 return -EOPNOTSUPP; 2362 } 2363 2364 if (page->i2c_address != 0x50 && 2365 page->i2c_address != 0x51) { 2366 NL_SET_ERR_MSG(extack, "Only address 0x50 and 0x51 supported"); 2367 return -EOPNOTSUPP; 2368 } 2369 2370 return sfp_read(sfp, page->i2c_address == 0x51, page->offset, 2371 page->data, page->length); 2372 }; 2373 2374 static const struct sfp_socket_ops sfp_module_ops = { 2375 .attach = sfp_attach, 2376 .detach = sfp_detach, 2377 .start = sfp_start, 2378 .stop = sfp_stop, 2379 .module_info = sfp_module_info, 2380 .module_eeprom = sfp_module_eeprom, 2381 .module_eeprom_by_page = sfp_module_eeprom_by_page, 2382 }; 2383 2384 static void sfp_timeout(struct work_struct *work) 2385 { 2386 struct sfp *sfp = container_of(work, struct sfp, timeout.work); 2387 2388 rtnl_lock(); 2389 sfp_sm_event(sfp, SFP_E_TIMEOUT); 2390 rtnl_unlock(); 2391 } 2392 2393 static void sfp_check_state(struct sfp *sfp) 2394 { 2395 unsigned int state, i, changed; 2396 2397 mutex_lock(&sfp->st_mutex); 2398 state = sfp_get_state(sfp); 2399 changed = state ^ sfp->state; 2400 changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT; 2401 2402 for (i = 0; i < GPIO_MAX; i++) 2403 if (changed & BIT(i)) 2404 dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i], 2405 !!(sfp->state & BIT(i)), !!(state & BIT(i))); 2406 2407 state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT); 2408 sfp->state = state; 2409 2410 rtnl_lock(); 2411 if (changed & SFP_F_PRESENT) 2412 sfp_sm_event(sfp, state & SFP_F_PRESENT ? 2413 SFP_E_INSERT : SFP_E_REMOVE); 2414 2415 if (changed & SFP_F_TX_FAULT) 2416 sfp_sm_event(sfp, state & SFP_F_TX_FAULT ? 2417 SFP_E_TX_FAULT : SFP_E_TX_CLEAR); 2418 2419 if (changed & SFP_F_LOS) 2420 sfp_sm_event(sfp, state & SFP_F_LOS ? 2421 SFP_E_LOS_HIGH : SFP_E_LOS_LOW); 2422 rtnl_unlock(); 2423 mutex_unlock(&sfp->st_mutex); 2424 } 2425 2426 static irqreturn_t sfp_irq(int irq, void *data) 2427 { 2428 struct sfp *sfp = data; 2429 2430 sfp_check_state(sfp); 2431 2432 return IRQ_HANDLED; 2433 } 2434 2435 static void sfp_poll(struct work_struct *work) 2436 { 2437 struct sfp *sfp = container_of(work, struct sfp, poll.work); 2438 2439 sfp_check_state(sfp); 2440 2441 if (sfp->state_soft_mask & (SFP_F_LOS | SFP_F_TX_FAULT) || 2442 sfp->need_poll) 2443 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 2444 } 2445 2446 static struct sfp *sfp_alloc(struct device *dev) 2447 { 2448 struct sfp *sfp; 2449 2450 sfp = kzalloc(sizeof(*sfp), GFP_KERNEL); 2451 if (!sfp) 2452 return ERR_PTR(-ENOMEM); 2453 2454 sfp->dev = dev; 2455 2456 mutex_init(&sfp->sm_mutex); 2457 mutex_init(&sfp->st_mutex); 2458 INIT_DELAYED_WORK(&sfp->poll, sfp_poll); 2459 INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout); 2460 2461 sfp_hwmon_init(sfp); 2462 2463 return sfp; 2464 } 2465 2466 static void sfp_cleanup(void *data) 2467 { 2468 struct sfp *sfp = data; 2469 2470 sfp_hwmon_exit(sfp); 2471 2472 cancel_delayed_work_sync(&sfp->poll); 2473 cancel_delayed_work_sync(&sfp->timeout); 2474 if (sfp->i2c_mii) { 2475 mdiobus_unregister(sfp->i2c_mii); 2476 mdiobus_free(sfp->i2c_mii); 2477 } 2478 if (sfp->i2c) 2479 i2c_put_adapter(sfp->i2c); 2480 kfree(sfp); 2481 } 2482 2483 static int sfp_probe(struct platform_device *pdev) 2484 { 2485 const struct sff_data *sff; 2486 struct i2c_adapter *i2c; 2487 char *sfp_irq_name; 2488 struct sfp *sfp; 2489 int err, i; 2490 2491 sfp = sfp_alloc(&pdev->dev); 2492 if (IS_ERR(sfp)) 2493 return PTR_ERR(sfp); 2494 2495 platform_set_drvdata(pdev, sfp); 2496 2497 err = devm_add_action(sfp->dev, sfp_cleanup, sfp); 2498 if (err < 0) 2499 return err; 2500 2501 sff = sfp->type = &sfp_data; 2502 2503 if (pdev->dev.of_node) { 2504 struct device_node *node = pdev->dev.of_node; 2505 const struct of_device_id *id; 2506 struct device_node *np; 2507 2508 id = of_match_node(sfp_of_match, node); 2509 if (WARN_ON(!id)) 2510 return -EINVAL; 2511 2512 sff = sfp->type = id->data; 2513 2514 np = of_parse_phandle(node, "i2c-bus", 0); 2515 if (!np) { 2516 dev_err(sfp->dev, "missing 'i2c-bus' property\n"); 2517 return -ENODEV; 2518 } 2519 2520 i2c = of_find_i2c_adapter_by_node(np); 2521 of_node_put(np); 2522 } else if (has_acpi_companion(&pdev->dev)) { 2523 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 2524 struct fwnode_handle *fw = acpi_fwnode_handle(adev); 2525 struct fwnode_reference_args args; 2526 struct acpi_handle *acpi_handle; 2527 int ret; 2528 2529 ret = acpi_node_get_property_reference(fw, "i2c-bus", 0, &args); 2530 if (ret || !is_acpi_device_node(args.fwnode)) { 2531 dev_err(&pdev->dev, "missing 'i2c-bus' property\n"); 2532 return -ENODEV; 2533 } 2534 2535 acpi_handle = ACPI_HANDLE_FWNODE(args.fwnode); 2536 i2c = i2c_acpi_find_adapter_by_handle(acpi_handle); 2537 } else { 2538 return -EINVAL; 2539 } 2540 2541 if (!i2c) 2542 return -EPROBE_DEFER; 2543 2544 err = sfp_i2c_configure(sfp, i2c); 2545 if (err < 0) { 2546 i2c_put_adapter(i2c); 2547 return err; 2548 } 2549 2550 for (i = 0; i < GPIO_MAX; i++) 2551 if (sff->gpios & BIT(i)) { 2552 sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev, 2553 gpio_of_names[i], gpio_flags[i]); 2554 if (IS_ERR(sfp->gpio[i])) 2555 return PTR_ERR(sfp->gpio[i]); 2556 } 2557 2558 sfp->get_state = sfp_gpio_get_state; 2559 sfp->set_state = sfp_gpio_set_state; 2560 2561 /* Modules that have no detect signal are always present */ 2562 if (!(sfp->gpio[GPIO_MODDEF0])) 2563 sfp->get_state = sff_gpio_get_state; 2564 2565 device_property_read_u32(&pdev->dev, "maximum-power-milliwatt", 2566 &sfp->max_power_mW); 2567 if (!sfp->max_power_mW) 2568 sfp->max_power_mW = 1000; 2569 2570 dev_info(sfp->dev, "Host maximum power %u.%uW\n", 2571 sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10); 2572 2573 /* Get the initial state, and always signal TX disable, 2574 * since the network interface will not be up. 2575 */ 2576 sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE; 2577 2578 if (sfp->gpio[GPIO_RATE_SELECT] && 2579 gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT])) 2580 sfp->state |= SFP_F_RATE_SELECT; 2581 sfp_set_state(sfp, sfp->state); 2582 sfp_module_tx_disable(sfp); 2583 if (sfp->state & SFP_F_PRESENT) { 2584 rtnl_lock(); 2585 sfp_sm_event(sfp, SFP_E_INSERT); 2586 rtnl_unlock(); 2587 } 2588 2589 for (i = 0; i < GPIO_MAX; i++) { 2590 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) 2591 continue; 2592 2593 sfp->gpio_irq[i] = gpiod_to_irq(sfp->gpio[i]); 2594 if (sfp->gpio_irq[i] < 0) { 2595 sfp->gpio_irq[i] = 0; 2596 sfp->need_poll = true; 2597 continue; 2598 } 2599 2600 sfp_irq_name = devm_kasprintf(sfp->dev, GFP_KERNEL, 2601 "%s-%s", dev_name(sfp->dev), 2602 gpio_of_names[i]); 2603 2604 if (!sfp_irq_name) 2605 return -ENOMEM; 2606 2607 err = devm_request_threaded_irq(sfp->dev, sfp->gpio_irq[i], 2608 NULL, sfp_irq, 2609 IRQF_ONESHOT | 2610 IRQF_TRIGGER_RISING | 2611 IRQF_TRIGGER_FALLING, 2612 sfp_irq_name, sfp); 2613 if (err) { 2614 sfp->gpio_irq[i] = 0; 2615 sfp->need_poll = true; 2616 } 2617 } 2618 2619 if (sfp->need_poll) 2620 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 2621 2622 /* We could have an issue in cases no Tx disable pin is available or 2623 * wired as modules using a laser as their light source will continue to 2624 * be active when the fiber is removed. This could be a safety issue and 2625 * we should at least warn the user about that. 2626 */ 2627 if (!sfp->gpio[GPIO_TX_DISABLE]) 2628 dev_warn(sfp->dev, 2629 "No tx_disable pin: SFP modules will always be emitting.\n"); 2630 2631 sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops); 2632 if (!sfp->sfp_bus) 2633 return -ENOMEM; 2634 2635 sfp_debugfs_init(sfp); 2636 2637 return 0; 2638 } 2639 2640 static int sfp_remove(struct platform_device *pdev) 2641 { 2642 struct sfp *sfp = platform_get_drvdata(pdev); 2643 2644 sfp_debugfs_exit(sfp); 2645 sfp_unregister_socket(sfp->sfp_bus); 2646 2647 rtnl_lock(); 2648 sfp_sm_event(sfp, SFP_E_REMOVE); 2649 rtnl_unlock(); 2650 2651 return 0; 2652 } 2653 2654 static void sfp_shutdown(struct platform_device *pdev) 2655 { 2656 struct sfp *sfp = platform_get_drvdata(pdev); 2657 int i; 2658 2659 for (i = 0; i < GPIO_MAX; i++) { 2660 if (!sfp->gpio_irq[i]) 2661 continue; 2662 2663 devm_free_irq(sfp->dev, sfp->gpio_irq[i], sfp); 2664 } 2665 2666 cancel_delayed_work_sync(&sfp->poll); 2667 cancel_delayed_work_sync(&sfp->timeout); 2668 } 2669 2670 static struct platform_driver sfp_driver = { 2671 .probe = sfp_probe, 2672 .remove = sfp_remove, 2673 .shutdown = sfp_shutdown, 2674 .driver = { 2675 .name = "sfp", 2676 .of_match_table = sfp_of_match, 2677 }, 2678 }; 2679 2680 static int sfp_init(void) 2681 { 2682 poll_jiffies = msecs_to_jiffies(100); 2683 2684 return platform_driver_register(&sfp_driver); 2685 } 2686 module_init(sfp_init); 2687 2688 static void sfp_exit(void) 2689 { 2690 platform_driver_unregister(&sfp_driver); 2691 } 2692 module_exit(sfp_exit); 2693 2694 MODULE_ALIAS("platform:sfp"); 2695 MODULE_AUTHOR("Russell King"); 2696 MODULE_LICENSE("GPL v2"); 2697