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] = "rx_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 1645 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL)) 1646 power_mW = 1500; 1647 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL)) 1648 power_mW = 2000; 1649 1650 if (power_mW > sfp->max_power_mW) { 1651 /* Module power specification exceeds the allowed maximum. */ 1652 if (sfp->id.ext.sff8472_compliance == 1653 SFP_SFF8472_COMPLIANCE_NONE && 1654 !(sfp->id.ext.diagmon & SFP_DIAGMON_DDM)) { 1655 /* The module appears not to implement bus address 1656 * 0xa2, so assume that the module powers up in the 1657 * indicated mode. 1658 */ 1659 dev_err(sfp->dev, 1660 "Host does not support %u.%uW modules\n", 1661 power_mW / 1000, (power_mW / 100) % 10); 1662 return -EINVAL; 1663 } else { 1664 dev_warn(sfp->dev, 1665 "Host does not support %u.%uW modules, module left in power mode 1\n", 1666 power_mW / 1000, (power_mW / 100) % 10); 1667 return 0; 1668 } 1669 } 1670 1671 /* If the module requires a higher power mode, but also requires 1672 * an address change sequence, warn the user that the module may 1673 * not be functional. 1674 */ 1675 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE && power_mW > 1000) { 1676 dev_warn(sfp->dev, 1677 "Address Change Sequence not supported but module requires %u.%uW, module may not be functional\n", 1678 power_mW / 1000, (power_mW / 100) % 10); 1679 return 0; 1680 } 1681 1682 sfp->module_power_mW = power_mW; 1683 1684 return 0; 1685 } 1686 1687 static int sfp_sm_mod_hpower(struct sfp *sfp, bool enable) 1688 { 1689 u8 val; 1690 int err; 1691 1692 err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1693 if (err != sizeof(val)) { 1694 dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err); 1695 return -EAGAIN; 1696 } 1697 1698 /* DM7052 reports as a high power module, responds to reads (with 1699 * all bytes 0xff) at 0x51 but does not accept writes. In any case, 1700 * if the bit is already set, we're already in high power mode. 1701 */ 1702 if (!!(val & BIT(0)) == enable) 1703 return 0; 1704 1705 if (enable) 1706 val |= BIT(0); 1707 else 1708 val &= ~BIT(0); 1709 1710 err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1711 if (err != sizeof(val)) { 1712 dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err); 1713 return -EAGAIN; 1714 } 1715 1716 if (enable) 1717 dev_info(sfp->dev, "Module switched to %u.%uW power level\n", 1718 sfp->module_power_mW / 1000, 1719 (sfp->module_power_mW / 100) % 10); 1720 1721 return 0; 1722 } 1723 1724 /* GPON modules based on Realtek RTL8672 and RTL9601C chips (e.g. V-SOL 1725 * V2801F, CarlitoxxPro CPGOS03-0490, Ubiquiti U-Fiber Instant, ...) do 1726 * not support multibyte reads from the EEPROM. Each multi-byte read 1727 * operation returns just one byte of EEPROM followed by zeros. There is 1728 * no way to identify which modules are using Realtek RTL8672 and RTL9601C 1729 * chips. Moreover every OEM of V-SOL V2801F module puts its own vendor 1730 * name and vendor id into EEPROM, so there is even no way to detect if 1731 * module is V-SOL V2801F. Therefore check for those zeros in the read 1732 * data and then based on check switch to reading EEPROM to one byte 1733 * at a time. 1734 */ 1735 static bool sfp_id_needs_byte_io(struct sfp *sfp, void *buf, size_t len) 1736 { 1737 size_t i, block_size = sfp->i2c_block_size; 1738 1739 /* Already using byte IO */ 1740 if (block_size == 1) 1741 return false; 1742 1743 for (i = 1; i < len; i += block_size) { 1744 if (memchr_inv(buf + i, '\0', min(block_size - 1, len - i))) 1745 return false; 1746 } 1747 return true; 1748 } 1749 1750 static int sfp_cotsworks_fixup_check(struct sfp *sfp, struct sfp_eeprom_id *id) 1751 { 1752 u8 check; 1753 int err; 1754 1755 if (id->base.phys_id != SFF8024_ID_SFF_8472 || 1756 id->base.phys_ext_id != SFP_PHYS_EXT_ID_SFP || 1757 id->base.connector != SFF8024_CONNECTOR_LC) { 1758 dev_warn(sfp->dev, "Rewriting fiber module EEPROM with corrected values\n"); 1759 id->base.phys_id = SFF8024_ID_SFF_8472; 1760 id->base.phys_ext_id = SFP_PHYS_EXT_ID_SFP; 1761 id->base.connector = SFF8024_CONNECTOR_LC; 1762 err = sfp_write(sfp, false, SFP_PHYS_ID, &id->base, 3); 1763 if (err != 3) { 1764 dev_err(sfp->dev, "Failed to rewrite module EEPROM: %d\n", err); 1765 return err; 1766 } 1767 1768 /* Cotsworks modules have been found to require a delay between write operations. */ 1769 mdelay(50); 1770 1771 /* Update base structure checksum */ 1772 check = sfp_check(&id->base, sizeof(id->base) - 1); 1773 err = sfp_write(sfp, false, SFP_CC_BASE, &check, 1); 1774 if (err != 1) { 1775 dev_err(sfp->dev, "Failed to update base structure checksum in fiber module EEPROM: %d\n", err); 1776 return err; 1777 } 1778 } 1779 return 0; 1780 } 1781 1782 static int sfp_sm_mod_probe(struct sfp *sfp, bool report) 1783 { 1784 /* SFP module inserted - read I2C data */ 1785 struct sfp_eeprom_id id; 1786 bool cotsworks_sfbg; 1787 bool cotsworks; 1788 u8 check; 1789 int ret; 1790 1791 /* Some SFP modules and also some Linux I2C drivers do not like reads 1792 * longer than 16 bytes, so read the EEPROM in chunks of 16 bytes at 1793 * a time. 1794 */ 1795 sfp->i2c_block_size = 16; 1796 1797 ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base)); 1798 if (ret < 0) { 1799 if (report) 1800 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret); 1801 return -EAGAIN; 1802 } 1803 1804 if (ret != sizeof(id.base)) { 1805 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1806 return -EAGAIN; 1807 } 1808 1809 /* Some SFP modules (e.g. Nokia 3FE46541AA) lock up if read from 1810 * address 0x51 is just one byte at a time. Also SFF-8472 requires 1811 * that EEPROM supports atomic 16bit read operation for diagnostic 1812 * fields, so do not switch to one byte reading at a time unless it 1813 * is really required and we have no other option. 1814 */ 1815 if (sfp_id_needs_byte_io(sfp, &id.base, sizeof(id.base))) { 1816 dev_info(sfp->dev, 1817 "Detected broken RTL8672/RTL9601C emulated EEPROM\n"); 1818 dev_info(sfp->dev, 1819 "Switching to reading EEPROM to one byte at a time\n"); 1820 sfp->i2c_block_size = 1; 1821 1822 ret = sfp_read(sfp, false, 0, &id.base, sizeof(id.base)); 1823 if (ret < 0) { 1824 if (report) 1825 dev_err(sfp->dev, "failed to read EEPROM: %d\n", 1826 ret); 1827 return -EAGAIN; 1828 } 1829 1830 if (ret != sizeof(id.base)) { 1831 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1832 return -EAGAIN; 1833 } 1834 } 1835 1836 /* Cotsworks do not seem to update the checksums when they 1837 * do the final programming with the final module part number, 1838 * serial number and date code. 1839 */ 1840 cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS ", 16); 1841 cotsworks_sfbg = !memcmp(id.base.vendor_pn, "SFBG", 4); 1842 1843 /* Cotsworks SFF module EEPROM do not always have valid phys_id, 1844 * phys_ext_id, and connector bytes. Rewrite SFF EEPROM bytes if 1845 * Cotsworks PN matches and bytes are not correct. 1846 */ 1847 if (cotsworks && cotsworks_sfbg) { 1848 ret = sfp_cotsworks_fixup_check(sfp, &id); 1849 if (ret < 0) 1850 return ret; 1851 } 1852 1853 /* Validate the checksum over the base structure */ 1854 check = sfp_check(&id.base, sizeof(id.base) - 1); 1855 if (check != id.base.cc_base) { 1856 if (cotsworks) { 1857 dev_warn(sfp->dev, 1858 "EEPROM base structure checksum failure (0x%02x != 0x%02x)\n", 1859 check, id.base.cc_base); 1860 } else { 1861 dev_err(sfp->dev, 1862 "EEPROM base structure checksum failure: 0x%02x != 0x%02x\n", 1863 check, id.base.cc_base); 1864 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1865 16, 1, &id, sizeof(id), true); 1866 return -EINVAL; 1867 } 1868 } 1869 1870 ret = sfp_read(sfp, false, SFP_CC_BASE + 1, &id.ext, sizeof(id.ext)); 1871 if (ret < 0) { 1872 if (report) 1873 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret); 1874 return -EAGAIN; 1875 } 1876 1877 if (ret != sizeof(id.ext)) { 1878 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1879 return -EAGAIN; 1880 } 1881 1882 check = sfp_check(&id.ext, sizeof(id.ext) - 1); 1883 if (check != id.ext.cc_ext) { 1884 if (cotsworks) { 1885 dev_warn(sfp->dev, 1886 "EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n", 1887 check, id.ext.cc_ext); 1888 } else { 1889 dev_err(sfp->dev, 1890 "EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n", 1891 check, id.ext.cc_ext); 1892 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1893 16, 1, &id, sizeof(id), true); 1894 memset(&id.ext, 0, sizeof(id.ext)); 1895 } 1896 } 1897 1898 sfp->id = id; 1899 1900 dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n", 1901 (int)sizeof(id.base.vendor_name), id.base.vendor_name, 1902 (int)sizeof(id.base.vendor_pn), id.base.vendor_pn, 1903 (int)sizeof(id.base.vendor_rev), id.base.vendor_rev, 1904 (int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn, 1905 (int)sizeof(id.ext.datecode), id.ext.datecode); 1906 1907 /* Check whether we support this module */ 1908 if (!sfp->type->module_supported(&id)) { 1909 dev_err(sfp->dev, 1910 "module is not supported - phys id 0x%02x 0x%02x\n", 1911 sfp->id.base.phys_id, sfp->id.base.phys_ext_id); 1912 return -EINVAL; 1913 } 1914 1915 /* If the module requires address swap mode, warn about it */ 1916 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) 1917 dev_warn(sfp->dev, 1918 "module address swap to access page 0xA2 is not supported.\n"); 1919 1920 /* Parse the module power requirement */ 1921 ret = sfp_module_parse_power(sfp); 1922 if (ret < 0) 1923 return ret; 1924 1925 if (!memcmp(id.base.vendor_name, "ALCATELLUCENT ", 16) && 1926 !memcmp(id.base.vendor_pn, "3FE46541AA ", 16)) 1927 sfp->module_t_start_up = T_START_UP_BAD_GPON; 1928 else 1929 sfp->module_t_start_up = T_START_UP; 1930 1931 return 0; 1932 } 1933 1934 static void sfp_sm_mod_remove(struct sfp *sfp) 1935 { 1936 if (sfp->sm_mod_state > SFP_MOD_WAITDEV) 1937 sfp_module_remove(sfp->sfp_bus); 1938 1939 sfp_hwmon_remove(sfp); 1940 1941 memset(&sfp->id, 0, sizeof(sfp->id)); 1942 sfp->module_power_mW = 0; 1943 1944 dev_info(sfp->dev, "module removed\n"); 1945 } 1946 1947 /* This state machine tracks the upstream's state */ 1948 static void sfp_sm_device(struct sfp *sfp, unsigned int event) 1949 { 1950 switch (sfp->sm_dev_state) { 1951 default: 1952 if (event == SFP_E_DEV_ATTACH) 1953 sfp->sm_dev_state = SFP_DEV_DOWN; 1954 break; 1955 1956 case SFP_DEV_DOWN: 1957 if (event == SFP_E_DEV_DETACH) 1958 sfp->sm_dev_state = SFP_DEV_DETACHED; 1959 else if (event == SFP_E_DEV_UP) 1960 sfp->sm_dev_state = SFP_DEV_UP; 1961 break; 1962 1963 case SFP_DEV_UP: 1964 if (event == SFP_E_DEV_DETACH) 1965 sfp->sm_dev_state = SFP_DEV_DETACHED; 1966 else if (event == SFP_E_DEV_DOWN) 1967 sfp->sm_dev_state = SFP_DEV_DOWN; 1968 break; 1969 } 1970 } 1971 1972 /* This state machine tracks the insert/remove state of the module, probes 1973 * the on-board EEPROM, and sets up the power level. 1974 */ 1975 static void sfp_sm_module(struct sfp *sfp, unsigned int event) 1976 { 1977 int err; 1978 1979 /* Handle remove event globally, it resets this state machine */ 1980 if (event == SFP_E_REMOVE) { 1981 if (sfp->sm_mod_state > SFP_MOD_PROBE) 1982 sfp_sm_mod_remove(sfp); 1983 sfp_sm_mod_next(sfp, SFP_MOD_EMPTY, 0); 1984 return; 1985 } 1986 1987 /* Handle device detach globally */ 1988 if (sfp->sm_dev_state < SFP_DEV_DOWN && 1989 sfp->sm_mod_state > SFP_MOD_WAITDEV) { 1990 if (sfp->module_power_mW > 1000 && 1991 sfp->sm_mod_state > SFP_MOD_HPOWER) 1992 sfp_sm_mod_hpower(sfp, false); 1993 sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0); 1994 return; 1995 } 1996 1997 switch (sfp->sm_mod_state) { 1998 default: 1999 if (event == SFP_E_INSERT) { 2000 sfp_sm_mod_next(sfp, SFP_MOD_PROBE, T_SERIAL); 2001 sfp->sm_mod_tries_init = R_PROBE_RETRY_INIT; 2002 sfp->sm_mod_tries = R_PROBE_RETRY_SLOW; 2003 } 2004 break; 2005 2006 case SFP_MOD_PROBE: 2007 /* Wait for T_PROBE_INIT to time out */ 2008 if (event != SFP_E_TIMEOUT) 2009 break; 2010 2011 err = sfp_sm_mod_probe(sfp, sfp->sm_mod_tries == 1); 2012 if (err == -EAGAIN) { 2013 if (sfp->sm_mod_tries_init && 2014 --sfp->sm_mod_tries_init) { 2015 sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT); 2016 break; 2017 } else if (sfp->sm_mod_tries && --sfp->sm_mod_tries) { 2018 if (sfp->sm_mod_tries == R_PROBE_RETRY_SLOW - 1) 2019 dev_warn(sfp->dev, 2020 "please wait, module slow to respond\n"); 2021 sfp_sm_set_timer(sfp, T_PROBE_RETRY_SLOW); 2022 break; 2023 } 2024 } 2025 if (err < 0) { 2026 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2027 break; 2028 } 2029 2030 err = sfp_hwmon_insert(sfp); 2031 if (err) 2032 dev_warn(sfp->dev, "hwmon probe failed: %d\n", err); 2033 2034 sfp_sm_mod_next(sfp, SFP_MOD_WAITDEV, 0); 2035 fallthrough; 2036 case SFP_MOD_WAITDEV: 2037 /* Ensure that the device is attached before proceeding */ 2038 if (sfp->sm_dev_state < SFP_DEV_DOWN) 2039 break; 2040 2041 /* Report the module insertion to the upstream device */ 2042 err = sfp_module_insert(sfp->sfp_bus, &sfp->id); 2043 if (err < 0) { 2044 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2045 break; 2046 } 2047 2048 /* If this is a power level 1 module, we are done */ 2049 if (sfp->module_power_mW <= 1000) 2050 goto insert; 2051 2052 sfp_sm_mod_next(sfp, SFP_MOD_HPOWER, 0); 2053 fallthrough; 2054 case SFP_MOD_HPOWER: 2055 /* Enable high power mode */ 2056 err = sfp_sm_mod_hpower(sfp, true); 2057 if (err < 0) { 2058 if (err != -EAGAIN) { 2059 sfp_module_remove(sfp->sfp_bus); 2060 sfp_sm_mod_next(sfp, SFP_MOD_ERROR, 0); 2061 } else { 2062 sfp_sm_set_timer(sfp, T_PROBE_RETRY_INIT); 2063 } 2064 break; 2065 } 2066 2067 sfp_sm_mod_next(sfp, SFP_MOD_WAITPWR, T_HPOWER_LEVEL); 2068 break; 2069 2070 case SFP_MOD_WAITPWR: 2071 /* Wait for T_HPOWER_LEVEL to time out */ 2072 if (event != SFP_E_TIMEOUT) 2073 break; 2074 2075 insert: 2076 sfp_sm_mod_next(sfp, SFP_MOD_PRESENT, 0); 2077 break; 2078 2079 case SFP_MOD_PRESENT: 2080 case SFP_MOD_ERROR: 2081 break; 2082 } 2083 } 2084 2085 static void sfp_sm_main(struct sfp *sfp, unsigned int event) 2086 { 2087 unsigned long timeout; 2088 int ret; 2089 2090 /* Some events are global */ 2091 if (sfp->sm_state != SFP_S_DOWN && 2092 (sfp->sm_mod_state != SFP_MOD_PRESENT || 2093 sfp->sm_dev_state != SFP_DEV_UP)) { 2094 if (sfp->sm_state == SFP_S_LINK_UP && 2095 sfp->sm_dev_state == SFP_DEV_UP) 2096 sfp_sm_link_down(sfp); 2097 if (sfp->sm_state > SFP_S_INIT) 2098 sfp_module_stop(sfp->sfp_bus); 2099 if (sfp->mod_phy) 2100 sfp_sm_phy_detach(sfp); 2101 sfp_module_tx_disable(sfp); 2102 sfp_soft_stop_poll(sfp); 2103 sfp_sm_next(sfp, SFP_S_DOWN, 0); 2104 return; 2105 } 2106 2107 /* The main state machine */ 2108 switch (sfp->sm_state) { 2109 case SFP_S_DOWN: 2110 if (sfp->sm_mod_state != SFP_MOD_PRESENT || 2111 sfp->sm_dev_state != SFP_DEV_UP) 2112 break; 2113 2114 if (!(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) 2115 sfp_soft_start_poll(sfp); 2116 2117 sfp_module_tx_enable(sfp); 2118 2119 /* Initialise the fault clearance retries */ 2120 sfp->sm_fault_retries = N_FAULT_INIT; 2121 2122 /* We need to check the TX_FAULT state, which is not defined 2123 * while TX_DISABLE is asserted. The earliest we want to do 2124 * anything (such as probe for a PHY) is 50ms. 2125 */ 2126 sfp_sm_next(sfp, SFP_S_WAIT, T_WAIT); 2127 break; 2128 2129 case SFP_S_WAIT: 2130 if (event != SFP_E_TIMEOUT) 2131 break; 2132 2133 if (sfp->state & SFP_F_TX_FAULT) { 2134 /* Wait up to t_init (SFF-8472) or t_start_up (SFF-8431) 2135 * from the TX_DISABLE deassertion for the module to 2136 * initialise, which is indicated by TX_FAULT 2137 * deasserting. 2138 */ 2139 timeout = sfp->module_t_start_up; 2140 if (timeout > T_WAIT) 2141 timeout -= T_WAIT; 2142 else 2143 timeout = 1; 2144 2145 sfp_sm_next(sfp, SFP_S_INIT, timeout); 2146 } else { 2147 /* TX_FAULT is not asserted, assume the module has 2148 * finished initialising. 2149 */ 2150 goto init_done; 2151 } 2152 break; 2153 2154 case SFP_S_INIT: 2155 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { 2156 /* TX_FAULT is still asserted after t_init or 2157 * or t_start_up, so assume there is a fault. 2158 */ 2159 sfp_sm_fault(sfp, SFP_S_INIT_TX_FAULT, 2160 sfp->sm_fault_retries == N_FAULT_INIT); 2161 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { 2162 init_done: 2163 sfp->sm_phy_retries = R_PHY_RETRY; 2164 goto phy_probe; 2165 } 2166 break; 2167 2168 case SFP_S_INIT_PHY: 2169 if (event != SFP_E_TIMEOUT) 2170 break; 2171 phy_probe: 2172 /* TX_FAULT deasserted or we timed out with TX_FAULT 2173 * clear. Probe for the PHY and check the LOS state. 2174 */ 2175 ret = sfp_sm_probe_for_phy(sfp); 2176 if (ret == -ENODEV) { 2177 if (--sfp->sm_phy_retries) { 2178 sfp_sm_next(sfp, SFP_S_INIT_PHY, T_PHY_RETRY); 2179 break; 2180 } else { 2181 dev_info(sfp->dev, "no PHY detected\n"); 2182 } 2183 } else if (ret) { 2184 sfp_sm_next(sfp, SFP_S_FAIL, 0); 2185 break; 2186 } 2187 if (sfp_module_start(sfp->sfp_bus)) { 2188 sfp_sm_next(sfp, SFP_S_FAIL, 0); 2189 break; 2190 } 2191 sfp_sm_link_check_los(sfp); 2192 2193 /* Reset the fault retry count */ 2194 sfp->sm_fault_retries = N_FAULT; 2195 break; 2196 2197 case SFP_S_INIT_TX_FAULT: 2198 if (event == SFP_E_TIMEOUT) { 2199 sfp_module_tx_fault_reset(sfp); 2200 sfp_sm_next(sfp, SFP_S_INIT, sfp->module_t_start_up); 2201 } 2202 break; 2203 2204 case SFP_S_WAIT_LOS: 2205 if (event == SFP_E_TX_FAULT) 2206 sfp_sm_fault(sfp, SFP_S_TX_FAULT, true); 2207 else if (sfp_los_event_inactive(sfp, event)) 2208 sfp_sm_link_up(sfp); 2209 break; 2210 2211 case SFP_S_LINK_UP: 2212 if (event == SFP_E_TX_FAULT) { 2213 sfp_sm_link_down(sfp); 2214 sfp_sm_fault(sfp, SFP_S_TX_FAULT, true); 2215 } else if (sfp_los_event_active(sfp, event)) { 2216 sfp_sm_link_down(sfp); 2217 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); 2218 } 2219 break; 2220 2221 case SFP_S_TX_FAULT: 2222 if (event == SFP_E_TIMEOUT) { 2223 sfp_module_tx_fault_reset(sfp); 2224 sfp_sm_next(sfp, SFP_S_REINIT, sfp->module_t_start_up); 2225 } 2226 break; 2227 2228 case SFP_S_REINIT: 2229 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { 2230 sfp_sm_fault(sfp, SFP_S_TX_FAULT, false); 2231 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { 2232 dev_info(sfp->dev, "module transmit fault recovered\n"); 2233 sfp_sm_link_check_los(sfp); 2234 } 2235 break; 2236 2237 case SFP_S_TX_DISABLE: 2238 break; 2239 } 2240 } 2241 2242 static void sfp_sm_event(struct sfp *sfp, unsigned int event) 2243 { 2244 mutex_lock(&sfp->sm_mutex); 2245 2246 dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n", 2247 mod_state_to_str(sfp->sm_mod_state), 2248 dev_state_to_str(sfp->sm_dev_state), 2249 sm_state_to_str(sfp->sm_state), 2250 event_to_str(event)); 2251 2252 sfp_sm_device(sfp, event); 2253 sfp_sm_module(sfp, event); 2254 sfp_sm_main(sfp, event); 2255 2256 dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n", 2257 mod_state_to_str(sfp->sm_mod_state), 2258 dev_state_to_str(sfp->sm_dev_state), 2259 sm_state_to_str(sfp->sm_state)); 2260 2261 mutex_unlock(&sfp->sm_mutex); 2262 } 2263 2264 static void sfp_attach(struct sfp *sfp) 2265 { 2266 sfp_sm_event(sfp, SFP_E_DEV_ATTACH); 2267 } 2268 2269 static void sfp_detach(struct sfp *sfp) 2270 { 2271 sfp_sm_event(sfp, SFP_E_DEV_DETACH); 2272 } 2273 2274 static void sfp_start(struct sfp *sfp) 2275 { 2276 sfp_sm_event(sfp, SFP_E_DEV_UP); 2277 } 2278 2279 static void sfp_stop(struct sfp *sfp) 2280 { 2281 sfp_sm_event(sfp, SFP_E_DEV_DOWN); 2282 } 2283 2284 static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo) 2285 { 2286 /* locking... and check module is present */ 2287 2288 if (sfp->id.ext.sff8472_compliance && 2289 !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) { 2290 modinfo->type = ETH_MODULE_SFF_8472; 2291 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 2292 } else { 2293 modinfo->type = ETH_MODULE_SFF_8079; 2294 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; 2295 } 2296 return 0; 2297 } 2298 2299 static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee, 2300 u8 *data) 2301 { 2302 unsigned int first, last, len; 2303 int ret; 2304 2305 if (ee->len == 0) 2306 return -EINVAL; 2307 2308 first = ee->offset; 2309 last = ee->offset + ee->len; 2310 if (first < ETH_MODULE_SFF_8079_LEN) { 2311 len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN); 2312 len -= first; 2313 2314 ret = sfp_read(sfp, false, first, data, len); 2315 if (ret < 0) 2316 return ret; 2317 2318 first += len; 2319 data += len; 2320 } 2321 if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) { 2322 len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN); 2323 len -= first; 2324 first -= ETH_MODULE_SFF_8079_LEN; 2325 2326 ret = sfp_read(sfp, true, first, data, len); 2327 if (ret < 0) 2328 return ret; 2329 } 2330 return 0; 2331 } 2332 2333 static int sfp_module_eeprom_by_page(struct sfp *sfp, 2334 const struct ethtool_module_eeprom *page, 2335 struct netlink_ext_ack *extack) 2336 { 2337 if (page->bank) { 2338 NL_SET_ERR_MSG(extack, "Banks not supported"); 2339 return -EOPNOTSUPP; 2340 } 2341 2342 if (page->page) { 2343 NL_SET_ERR_MSG(extack, "Only page 0 supported"); 2344 return -EOPNOTSUPP; 2345 } 2346 2347 if (page->i2c_address != 0x50 && 2348 page->i2c_address != 0x51) { 2349 NL_SET_ERR_MSG(extack, "Only address 0x50 and 0x51 supported"); 2350 return -EOPNOTSUPP; 2351 } 2352 2353 return sfp_read(sfp, page->i2c_address == 0x51, page->offset, 2354 page->data, page->length); 2355 }; 2356 2357 static const struct sfp_socket_ops sfp_module_ops = { 2358 .attach = sfp_attach, 2359 .detach = sfp_detach, 2360 .start = sfp_start, 2361 .stop = sfp_stop, 2362 .module_info = sfp_module_info, 2363 .module_eeprom = sfp_module_eeprom, 2364 .module_eeprom_by_page = sfp_module_eeprom_by_page, 2365 }; 2366 2367 static void sfp_timeout(struct work_struct *work) 2368 { 2369 struct sfp *sfp = container_of(work, struct sfp, timeout.work); 2370 2371 rtnl_lock(); 2372 sfp_sm_event(sfp, SFP_E_TIMEOUT); 2373 rtnl_unlock(); 2374 } 2375 2376 static void sfp_check_state(struct sfp *sfp) 2377 { 2378 unsigned int state, i, changed; 2379 2380 mutex_lock(&sfp->st_mutex); 2381 state = sfp_get_state(sfp); 2382 changed = state ^ sfp->state; 2383 changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT; 2384 2385 for (i = 0; i < GPIO_MAX; i++) 2386 if (changed & BIT(i)) 2387 dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i], 2388 !!(sfp->state & BIT(i)), !!(state & BIT(i))); 2389 2390 state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT); 2391 sfp->state = state; 2392 2393 rtnl_lock(); 2394 if (changed & SFP_F_PRESENT) 2395 sfp_sm_event(sfp, state & SFP_F_PRESENT ? 2396 SFP_E_INSERT : SFP_E_REMOVE); 2397 2398 if (changed & SFP_F_TX_FAULT) 2399 sfp_sm_event(sfp, state & SFP_F_TX_FAULT ? 2400 SFP_E_TX_FAULT : SFP_E_TX_CLEAR); 2401 2402 if (changed & SFP_F_LOS) 2403 sfp_sm_event(sfp, state & SFP_F_LOS ? 2404 SFP_E_LOS_HIGH : SFP_E_LOS_LOW); 2405 rtnl_unlock(); 2406 mutex_unlock(&sfp->st_mutex); 2407 } 2408 2409 static irqreturn_t sfp_irq(int irq, void *data) 2410 { 2411 struct sfp *sfp = data; 2412 2413 sfp_check_state(sfp); 2414 2415 return IRQ_HANDLED; 2416 } 2417 2418 static void sfp_poll(struct work_struct *work) 2419 { 2420 struct sfp *sfp = container_of(work, struct sfp, poll.work); 2421 2422 sfp_check_state(sfp); 2423 2424 if (sfp->state_soft_mask & (SFP_F_LOS | SFP_F_TX_FAULT) || 2425 sfp->need_poll) 2426 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 2427 } 2428 2429 static struct sfp *sfp_alloc(struct device *dev) 2430 { 2431 struct sfp *sfp; 2432 2433 sfp = kzalloc(sizeof(*sfp), GFP_KERNEL); 2434 if (!sfp) 2435 return ERR_PTR(-ENOMEM); 2436 2437 sfp->dev = dev; 2438 2439 mutex_init(&sfp->sm_mutex); 2440 mutex_init(&sfp->st_mutex); 2441 INIT_DELAYED_WORK(&sfp->poll, sfp_poll); 2442 INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout); 2443 2444 sfp_hwmon_init(sfp); 2445 2446 return sfp; 2447 } 2448 2449 static void sfp_cleanup(void *data) 2450 { 2451 struct sfp *sfp = data; 2452 2453 sfp_hwmon_exit(sfp); 2454 2455 cancel_delayed_work_sync(&sfp->poll); 2456 cancel_delayed_work_sync(&sfp->timeout); 2457 if (sfp->i2c_mii) { 2458 mdiobus_unregister(sfp->i2c_mii); 2459 mdiobus_free(sfp->i2c_mii); 2460 } 2461 if (sfp->i2c) 2462 i2c_put_adapter(sfp->i2c); 2463 kfree(sfp); 2464 } 2465 2466 static int sfp_probe(struct platform_device *pdev) 2467 { 2468 const struct sff_data *sff; 2469 struct i2c_adapter *i2c; 2470 char *sfp_irq_name; 2471 struct sfp *sfp; 2472 int err, i; 2473 2474 sfp = sfp_alloc(&pdev->dev); 2475 if (IS_ERR(sfp)) 2476 return PTR_ERR(sfp); 2477 2478 platform_set_drvdata(pdev, sfp); 2479 2480 err = devm_add_action(sfp->dev, sfp_cleanup, sfp); 2481 if (err < 0) 2482 return err; 2483 2484 sff = sfp->type = &sfp_data; 2485 2486 if (pdev->dev.of_node) { 2487 struct device_node *node = pdev->dev.of_node; 2488 const struct of_device_id *id; 2489 struct device_node *np; 2490 2491 id = of_match_node(sfp_of_match, node); 2492 if (WARN_ON(!id)) 2493 return -EINVAL; 2494 2495 sff = sfp->type = id->data; 2496 2497 np = of_parse_phandle(node, "i2c-bus", 0); 2498 if (!np) { 2499 dev_err(sfp->dev, "missing 'i2c-bus' property\n"); 2500 return -ENODEV; 2501 } 2502 2503 i2c = of_find_i2c_adapter_by_node(np); 2504 of_node_put(np); 2505 } else if (has_acpi_companion(&pdev->dev)) { 2506 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 2507 struct fwnode_handle *fw = acpi_fwnode_handle(adev); 2508 struct fwnode_reference_args args; 2509 struct acpi_handle *acpi_handle; 2510 int ret; 2511 2512 ret = acpi_node_get_property_reference(fw, "i2c-bus", 0, &args); 2513 if (ret || !is_acpi_device_node(args.fwnode)) { 2514 dev_err(&pdev->dev, "missing 'i2c-bus' property\n"); 2515 return -ENODEV; 2516 } 2517 2518 acpi_handle = ACPI_HANDLE_FWNODE(args.fwnode); 2519 i2c = i2c_acpi_find_adapter_by_handle(acpi_handle); 2520 } else { 2521 return -EINVAL; 2522 } 2523 2524 if (!i2c) 2525 return -EPROBE_DEFER; 2526 2527 err = sfp_i2c_configure(sfp, i2c); 2528 if (err < 0) { 2529 i2c_put_adapter(i2c); 2530 return err; 2531 } 2532 2533 for (i = 0; i < GPIO_MAX; i++) 2534 if (sff->gpios & BIT(i)) { 2535 sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev, 2536 gpio_of_names[i], gpio_flags[i]); 2537 if (IS_ERR(sfp->gpio[i])) 2538 return PTR_ERR(sfp->gpio[i]); 2539 } 2540 2541 sfp->get_state = sfp_gpio_get_state; 2542 sfp->set_state = sfp_gpio_set_state; 2543 2544 /* Modules that have no detect signal are always present */ 2545 if (!(sfp->gpio[GPIO_MODDEF0])) 2546 sfp->get_state = sff_gpio_get_state; 2547 2548 device_property_read_u32(&pdev->dev, "maximum-power-milliwatt", 2549 &sfp->max_power_mW); 2550 if (!sfp->max_power_mW) 2551 sfp->max_power_mW = 1000; 2552 2553 dev_info(sfp->dev, "Host maximum power %u.%uW\n", 2554 sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10); 2555 2556 /* Get the initial state, and always signal TX disable, 2557 * since the network interface will not be up. 2558 */ 2559 sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE; 2560 2561 if (sfp->gpio[GPIO_RATE_SELECT] && 2562 gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT])) 2563 sfp->state |= SFP_F_RATE_SELECT; 2564 sfp_set_state(sfp, sfp->state); 2565 sfp_module_tx_disable(sfp); 2566 if (sfp->state & SFP_F_PRESENT) { 2567 rtnl_lock(); 2568 sfp_sm_event(sfp, SFP_E_INSERT); 2569 rtnl_unlock(); 2570 } 2571 2572 for (i = 0; i < GPIO_MAX; i++) { 2573 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) 2574 continue; 2575 2576 sfp->gpio_irq[i] = gpiod_to_irq(sfp->gpio[i]); 2577 if (sfp->gpio_irq[i] < 0) { 2578 sfp->gpio_irq[i] = 0; 2579 sfp->need_poll = true; 2580 continue; 2581 } 2582 2583 sfp_irq_name = devm_kasprintf(sfp->dev, GFP_KERNEL, 2584 "%s-%s", dev_name(sfp->dev), 2585 gpio_of_names[i]); 2586 2587 if (!sfp_irq_name) 2588 return -ENOMEM; 2589 2590 err = devm_request_threaded_irq(sfp->dev, sfp->gpio_irq[i], 2591 NULL, sfp_irq, 2592 IRQF_ONESHOT | 2593 IRQF_TRIGGER_RISING | 2594 IRQF_TRIGGER_FALLING, 2595 sfp_irq_name, sfp); 2596 if (err) { 2597 sfp->gpio_irq[i] = 0; 2598 sfp->need_poll = true; 2599 } 2600 } 2601 2602 if (sfp->need_poll) 2603 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 2604 2605 /* We could have an issue in cases no Tx disable pin is available or 2606 * wired as modules using a laser as their light source will continue to 2607 * be active when the fiber is removed. This could be a safety issue and 2608 * we should at least warn the user about that. 2609 */ 2610 if (!sfp->gpio[GPIO_TX_DISABLE]) 2611 dev_warn(sfp->dev, 2612 "No tx_disable pin: SFP modules will always be emitting.\n"); 2613 2614 sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops); 2615 if (!sfp->sfp_bus) 2616 return -ENOMEM; 2617 2618 sfp_debugfs_init(sfp); 2619 2620 return 0; 2621 } 2622 2623 static int sfp_remove(struct platform_device *pdev) 2624 { 2625 struct sfp *sfp = platform_get_drvdata(pdev); 2626 2627 sfp_debugfs_exit(sfp); 2628 sfp_unregister_socket(sfp->sfp_bus); 2629 2630 rtnl_lock(); 2631 sfp_sm_event(sfp, SFP_E_REMOVE); 2632 rtnl_unlock(); 2633 2634 return 0; 2635 } 2636 2637 static void sfp_shutdown(struct platform_device *pdev) 2638 { 2639 struct sfp *sfp = platform_get_drvdata(pdev); 2640 int i; 2641 2642 for (i = 0; i < GPIO_MAX; i++) { 2643 if (!sfp->gpio_irq[i]) 2644 continue; 2645 2646 devm_free_irq(sfp->dev, sfp->gpio_irq[i], sfp); 2647 } 2648 2649 cancel_delayed_work_sync(&sfp->poll); 2650 cancel_delayed_work_sync(&sfp->timeout); 2651 } 2652 2653 static struct platform_driver sfp_driver = { 2654 .probe = sfp_probe, 2655 .remove = sfp_remove, 2656 .shutdown = sfp_shutdown, 2657 .driver = { 2658 .name = "sfp", 2659 .of_match_table = sfp_of_match, 2660 }, 2661 }; 2662 2663 static int sfp_init(void) 2664 { 2665 poll_jiffies = msecs_to_jiffies(100); 2666 2667 return platform_driver_register(&sfp_driver); 2668 } 2669 module_init(sfp_init); 2670 2671 static void sfp_exit(void) 2672 { 2673 platform_driver_unregister(&sfp_driver); 2674 } 2675 module_exit(sfp_exit); 2676 2677 MODULE_ALIAS("platform:sfp"); 2678 MODULE_AUTHOR("Russell King"); 2679 MODULE_LICENSE("GPL v2"); 2680