1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/acpi.h> 3 #include <linux/ctype.h> 4 #include <linux/delay.h> 5 #include <linux/gpio/consumer.h> 6 #include <linux/hwmon.h> 7 #include <linux/i2c.h> 8 #include <linux/interrupt.h> 9 #include <linux/jiffies.h> 10 #include <linux/module.h> 11 #include <linux/mutex.h> 12 #include <linux/of.h> 13 #include <linux/phy.h> 14 #include <linux/platform_device.h> 15 #include <linux/rtnetlink.h> 16 #include <linux/slab.h> 17 #include <linux/workqueue.h> 18 19 #include "mdio-i2c.h" 20 #include "sfp.h" 21 #include "swphy.h" 22 23 enum { 24 GPIO_MODDEF0, 25 GPIO_LOS, 26 GPIO_TX_FAULT, 27 GPIO_TX_DISABLE, 28 GPIO_RATE_SELECT, 29 GPIO_MAX, 30 31 SFP_F_PRESENT = BIT(GPIO_MODDEF0), 32 SFP_F_LOS = BIT(GPIO_LOS), 33 SFP_F_TX_FAULT = BIT(GPIO_TX_FAULT), 34 SFP_F_TX_DISABLE = BIT(GPIO_TX_DISABLE), 35 SFP_F_RATE_SELECT = BIT(GPIO_RATE_SELECT), 36 37 SFP_E_INSERT = 0, 38 SFP_E_REMOVE, 39 SFP_E_DEV_DOWN, 40 SFP_E_DEV_UP, 41 SFP_E_TX_FAULT, 42 SFP_E_TX_CLEAR, 43 SFP_E_LOS_HIGH, 44 SFP_E_LOS_LOW, 45 SFP_E_TIMEOUT, 46 47 SFP_MOD_EMPTY = 0, 48 SFP_MOD_PROBE, 49 SFP_MOD_HPOWER, 50 SFP_MOD_PRESENT, 51 SFP_MOD_ERROR, 52 53 SFP_DEV_DOWN = 0, 54 SFP_DEV_UP, 55 56 SFP_S_DOWN = 0, 57 SFP_S_INIT, 58 SFP_S_WAIT_LOS, 59 SFP_S_LINK_UP, 60 SFP_S_TX_FAULT, 61 SFP_S_REINIT, 62 SFP_S_TX_DISABLE, 63 }; 64 65 static const char * const mod_state_strings[] = { 66 [SFP_MOD_EMPTY] = "empty", 67 [SFP_MOD_PROBE] = "probe", 68 [SFP_MOD_HPOWER] = "hpower", 69 [SFP_MOD_PRESENT] = "present", 70 [SFP_MOD_ERROR] = "error", 71 }; 72 73 static const char *mod_state_to_str(unsigned short mod_state) 74 { 75 if (mod_state >= ARRAY_SIZE(mod_state_strings)) 76 return "Unknown module state"; 77 return mod_state_strings[mod_state]; 78 } 79 80 static const char * const dev_state_strings[] = { 81 [SFP_DEV_DOWN] = "down", 82 [SFP_DEV_UP] = "up", 83 }; 84 85 static const char *dev_state_to_str(unsigned short dev_state) 86 { 87 if (dev_state >= ARRAY_SIZE(dev_state_strings)) 88 return "Unknown device state"; 89 return dev_state_strings[dev_state]; 90 } 91 92 static const char * const event_strings[] = { 93 [SFP_E_INSERT] = "insert", 94 [SFP_E_REMOVE] = "remove", 95 [SFP_E_DEV_DOWN] = "dev_down", 96 [SFP_E_DEV_UP] = "dev_up", 97 [SFP_E_TX_FAULT] = "tx_fault", 98 [SFP_E_TX_CLEAR] = "tx_clear", 99 [SFP_E_LOS_HIGH] = "los_high", 100 [SFP_E_LOS_LOW] = "los_low", 101 [SFP_E_TIMEOUT] = "timeout", 102 }; 103 104 static const char *event_to_str(unsigned short event) 105 { 106 if (event >= ARRAY_SIZE(event_strings)) 107 return "Unknown event"; 108 return event_strings[event]; 109 } 110 111 static const char * const sm_state_strings[] = { 112 [SFP_S_DOWN] = "down", 113 [SFP_S_INIT] = "init", 114 [SFP_S_WAIT_LOS] = "wait_los", 115 [SFP_S_LINK_UP] = "link_up", 116 [SFP_S_TX_FAULT] = "tx_fault", 117 [SFP_S_REINIT] = "reinit", 118 [SFP_S_TX_DISABLE] = "rx_disable", 119 }; 120 121 static const char *sm_state_to_str(unsigned short sm_state) 122 { 123 if (sm_state >= ARRAY_SIZE(sm_state_strings)) 124 return "Unknown state"; 125 return sm_state_strings[sm_state]; 126 } 127 128 static const char *gpio_of_names[] = { 129 "mod-def0", 130 "los", 131 "tx-fault", 132 "tx-disable", 133 "rate-select0", 134 }; 135 136 static const enum gpiod_flags gpio_flags[] = { 137 GPIOD_IN, 138 GPIOD_IN, 139 GPIOD_IN, 140 GPIOD_ASIS, 141 GPIOD_ASIS, 142 }; 143 144 #define T_INIT_JIFFIES msecs_to_jiffies(300) 145 #define T_RESET_US 10 146 #define T_FAULT_RECOVER msecs_to_jiffies(1000) 147 148 /* SFP module presence detection is poor: the three MOD DEF signals are 149 * the same length on the PCB, which means it's possible for MOD DEF 0 to 150 * connect before the I2C bus on MOD DEF 1/2. 151 * 152 * The SFP MSA specifies 300ms as t_init (the time taken for TX_FAULT to 153 * be deasserted) but makes no mention of the earliest time before we can 154 * access the I2C EEPROM. However, Avago modules require 300ms. 155 */ 156 #define T_PROBE_INIT msecs_to_jiffies(300) 157 #define T_HPOWER_LEVEL msecs_to_jiffies(300) 158 #define T_PROBE_RETRY msecs_to_jiffies(100) 159 160 /* SFP modules appear to always have their PHY configured for bus address 161 * 0x56 (which with mdio-i2c, translates to a PHY address of 22). 162 */ 163 #define SFP_PHY_ADDR 22 164 165 /* Give this long for the PHY to reset. */ 166 #define T_PHY_RESET_MS 50 167 168 struct sff_data { 169 unsigned int gpios; 170 bool (*module_supported)(const struct sfp_eeprom_id *id); 171 }; 172 173 struct sfp { 174 struct device *dev; 175 struct i2c_adapter *i2c; 176 struct mii_bus *i2c_mii; 177 struct sfp_bus *sfp_bus; 178 struct phy_device *mod_phy; 179 const struct sff_data *type; 180 u32 max_power_mW; 181 182 unsigned int (*get_state)(struct sfp *); 183 void (*set_state)(struct sfp *, unsigned int); 184 int (*read)(struct sfp *, bool, u8, void *, size_t); 185 int (*write)(struct sfp *, bool, u8, void *, size_t); 186 187 struct gpio_desc *gpio[GPIO_MAX]; 188 189 bool attached; 190 unsigned int state; 191 struct delayed_work poll; 192 struct delayed_work timeout; 193 struct mutex sm_mutex; 194 unsigned char sm_mod_state; 195 unsigned char sm_dev_state; 196 unsigned short sm_state; 197 unsigned int sm_retries; 198 199 struct sfp_eeprom_id id; 200 #if IS_ENABLED(CONFIG_HWMON) 201 struct sfp_diag diag; 202 struct device *hwmon_dev; 203 char *hwmon_name; 204 #endif 205 206 }; 207 208 static bool sff_module_supported(const struct sfp_eeprom_id *id) 209 { 210 return id->base.phys_id == SFP_PHYS_ID_SFF && 211 id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP; 212 } 213 214 static const struct sff_data sff_data = { 215 .gpios = SFP_F_LOS | SFP_F_TX_FAULT | SFP_F_TX_DISABLE, 216 .module_supported = sff_module_supported, 217 }; 218 219 static bool sfp_module_supported(const struct sfp_eeprom_id *id) 220 { 221 return id->base.phys_id == SFP_PHYS_ID_SFP && 222 id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP; 223 } 224 225 static const struct sff_data sfp_data = { 226 .gpios = SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT | 227 SFP_F_TX_DISABLE | SFP_F_RATE_SELECT, 228 .module_supported = sfp_module_supported, 229 }; 230 231 static const struct of_device_id sfp_of_match[] = { 232 { .compatible = "sff,sff", .data = &sff_data, }, 233 { .compatible = "sff,sfp", .data = &sfp_data, }, 234 { }, 235 }; 236 MODULE_DEVICE_TABLE(of, sfp_of_match); 237 238 static unsigned long poll_jiffies; 239 240 static unsigned int sfp_gpio_get_state(struct sfp *sfp) 241 { 242 unsigned int i, state, v; 243 244 for (i = state = 0; i < GPIO_MAX; i++) { 245 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) 246 continue; 247 248 v = gpiod_get_value_cansleep(sfp->gpio[i]); 249 if (v) 250 state |= BIT(i); 251 } 252 253 return state; 254 } 255 256 static unsigned int sff_gpio_get_state(struct sfp *sfp) 257 { 258 return sfp_gpio_get_state(sfp) | SFP_F_PRESENT; 259 } 260 261 static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state) 262 { 263 if (state & SFP_F_PRESENT) { 264 /* If the module is present, drive the signals */ 265 if (sfp->gpio[GPIO_TX_DISABLE]) 266 gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE], 267 state & SFP_F_TX_DISABLE); 268 if (state & SFP_F_RATE_SELECT) 269 gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT], 270 state & SFP_F_RATE_SELECT); 271 } else { 272 /* Otherwise, let them float to the pull-ups */ 273 if (sfp->gpio[GPIO_TX_DISABLE]) 274 gpiod_direction_input(sfp->gpio[GPIO_TX_DISABLE]); 275 if (state & SFP_F_RATE_SELECT) 276 gpiod_direction_input(sfp->gpio[GPIO_RATE_SELECT]); 277 } 278 } 279 280 static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 dev_addr, void *buf, 281 size_t len) 282 { 283 struct i2c_msg msgs[2]; 284 u8 bus_addr = a2 ? 0x51 : 0x50; 285 size_t this_len; 286 int ret; 287 288 msgs[0].addr = bus_addr; 289 msgs[0].flags = 0; 290 msgs[0].len = 1; 291 msgs[0].buf = &dev_addr; 292 msgs[1].addr = bus_addr; 293 msgs[1].flags = I2C_M_RD; 294 msgs[1].len = len; 295 msgs[1].buf = buf; 296 297 while (len) { 298 this_len = len; 299 if (this_len > 16) 300 this_len = 16; 301 302 msgs[1].len = this_len; 303 304 ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs)); 305 if (ret < 0) 306 return ret; 307 308 if (ret != ARRAY_SIZE(msgs)) 309 break; 310 311 msgs[1].buf += this_len; 312 dev_addr += this_len; 313 len -= this_len; 314 } 315 316 return msgs[1].buf - (u8 *)buf; 317 } 318 319 static int sfp_i2c_write(struct sfp *sfp, bool a2, u8 dev_addr, void *buf, 320 size_t len) 321 { 322 struct i2c_msg msgs[1]; 323 u8 bus_addr = a2 ? 0x51 : 0x50; 324 int ret; 325 326 msgs[0].addr = bus_addr; 327 msgs[0].flags = 0; 328 msgs[0].len = 1 + len; 329 msgs[0].buf = kmalloc(1 + len, GFP_KERNEL); 330 if (!msgs[0].buf) 331 return -ENOMEM; 332 333 msgs[0].buf[0] = dev_addr; 334 memcpy(&msgs[0].buf[1], buf, len); 335 336 ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs)); 337 338 kfree(msgs[0].buf); 339 340 if (ret < 0) 341 return ret; 342 343 return ret == ARRAY_SIZE(msgs) ? len : 0; 344 } 345 346 static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c) 347 { 348 struct mii_bus *i2c_mii; 349 int ret; 350 351 if (!i2c_check_functionality(i2c, I2C_FUNC_I2C)) 352 return -EINVAL; 353 354 sfp->i2c = i2c; 355 sfp->read = sfp_i2c_read; 356 sfp->write = sfp_i2c_write; 357 358 i2c_mii = mdio_i2c_alloc(sfp->dev, i2c); 359 if (IS_ERR(i2c_mii)) 360 return PTR_ERR(i2c_mii); 361 362 i2c_mii->name = "SFP I2C Bus"; 363 i2c_mii->phy_mask = ~0; 364 365 ret = mdiobus_register(i2c_mii); 366 if (ret < 0) { 367 mdiobus_free(i2c_mii); 368 return ret; 369 } 370 371 sfp->i2c_mii = i2c_mii; 372 373 return 0; 374 } 375 376 /* Interface */ 377 static unsigned int sfp_get_state(struct sfp *sfp) 378 { 379 return sfp->get_state(sfp); 380 } 381 382 static void sfp_set_state(struct sfp *sfp, unsigned int state) 383 { 384 sfp->set_state(sfp, state); 385 } 386 387 static int sfp_read(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len) 388 { 389 return sfp->read(sfp, a2, addr, buf, len); 390 } 391 392 static int sfp_write(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len) 393 { 394 return sfp->write(sfp, a2, addr, buf, len); 395 } 396 397 static unsigned int sfp_check(void *buf, size_t len) 398 { 399 u8 *p, check; 400 401 for (p = buf, check = 0; len; p++, len--) 402 check += *p; 403 404 return check; 405 } 406 407 /* hwmon */ 408 #if IS_ENABLED(CONFIG_HWMON) 409 static umode_t sfp_hwmon_is_visible(const void *data, 410 enum hwmon_sensor_types type, 411 u32 attr, int channel) 412 { 413 const struct sfp *sfp = data; 414 415 switch (type) { 416 case hwmon_temp: 417 switch (attr) { 418 case hwmon_temp_min_alarm: 419 case hwmon_temp_max_alarm: 420 case hwmon_temp_lcrit_alarm: 421 case hwmon_temp_crit_alarm: 422 case hwmon_temp_min: 423 case hwmon_temp_max: 424 case hwmon_temp_lcrit: 425 case hwmon_temp_crit: 426 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN)) 427 return 0; 428 /* fall through */ 429 case hwmon_temp_input: 430 return 0444; 431 default: 432 return 0; 433 } 434 case hwmon_in: 435 switch (attr) { 436 case hwmon_in_min_alarm: 437 case hwmon_in_max_alarm: 438 case hwmon_in_lcrit_alarm: 439 case hwmon_in_crit_alarm: 440 case hwmon_in_min: 441 case hwmon_in_max: 442 case hwmon_in_lcrit: 443 case hwmon_in_crit: 444 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN)) 445 return 0; 446 /* fall through */ 447 case hwmon_in_input: 448 return 0444; 449 default: 450 return 0; 451 } 452 case hwmon_curr: 453 switch (attr) { 454 case hwmon_curr_min_alarm: 455 case hwmon_curr_max_alarm: 456 case hwmon_curr_lcrit_alarm: 457 case hwmon_curr_crit_alarm: 458 case hwmon_curr_min: 459 case hwmon_curr_max: 460 case hwmon_curr_lcrit: 461 case hwmon_curr_crit: 462 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN)) 463 return 0; 464 /* fall through */ 465 case hwmon_curr_input: 466 return 0444; 467 default: 468 return 0; 469 } 470 case hwmon_power: 471 /* External calibration of receive power requires 472 * floating point arithmetic. Doing that in the kernel 473 * is not easy, so just skip it. If the module does 474 * not require external calibration, we can however 475 * show receiver power, since FP is then not needed. 476 */ 477 if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL && 478 channel == 1) 479 return 0; 480 switch (attr) { 481 case hwmon_power_min_alarm: 482 case hwmon_power_max_alarm: 483 case hwmon_power_lcrit_alarm: 484 case hwmon_power_crit_alarm: 485 case hwmon_power_min: 486 case hwmon_power_max: 487 case hwmon_power_lcrit: 488 case hwmon_power_crit: 489 if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN)) 490 return 0; 491 /* fall through */ 492 case hwmon_power_input: 493 return 0444; 494 default: 495 return 0; 496 } 497 default: 498 return 0; 499 } 500 } 501 502 static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value) 503 { 504 __be16 val; 505 int err; 506 507 err = sfp_read(sfp, true, reg, &val, sizeof(val)); 508 if (err < 0) 509 return err; 510 511 *value = be16_to_cpu(val); 512 513 return 0; 514 } 515 516 static void sfp_hwmon_to_rx_power(long *value) 517 { 518 *value = DIV_ROUND_CLOSEST(*value, 100); 519 } 520 521 static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset, 522 long *value) 523 { 524 if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL) 525 *value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset; 526 } 527 528 static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value) 529 { 530 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope), 531 be16_to_cpu(sfp->diag.cal_t_offset), value); 532 533 if (*value >= 0x8000) 534 *value -= 0x10000; 535 536 *value = DIV_ROUND_CLOSEST(*value * 1000, 256); 537 } 538 539 static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value) 540 { 541 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope), 542 be16_to_cpu(sfp->diag.cal_v_offset), value); 543 544 *value = DIV_ROUND_CLOSEST(*value, 10); 545 } 546 547 static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value) 548 { 549 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope), 550 be16_to_cpu(sfp->diag.cal_txi_offset), value); 551 552 *value = DIV_ROUND_CLOSEST(*value, 500); 553 } 554 555 static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value) 556 { 557 sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope), 558 be16_to_cpu(sfp->diag.cal_txpwr_offset), value); 559 560 *value = DIV_ROUND_CLOSEST(*value, 10); 561 } 562 563 static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value) 564 { 565 int err; 566 567 err = sfp_hwmon_read_sensor(sfp, reg, value); 568 if (err < 0) 569 return err; 570 571 sfp_hwmon_calibrate_temp(sfp, value); 572 573 return 0; 574 } 575 576 static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value) 577 { 578 int err; 579 580 err = sfp_hwmon_read_sensor(sfp, reg, value); 581 if (err < 0) 582 return err; 583 584 sfp_hwmon_calibrate_vcc(sfp, value); 585 586 return 0; 587 } 588 589 static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value) 590 { 591 int err; 592 593 err = sfp_hwmon_read_sensor(sfp, reg, value); 594 if (err < 0) 595 return err; 596 597 sfp_hwmon_calibrate_bias(sfp, value); 598 599 return 0; 600 } 601 602 static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value) 603 { 604 int err; 605 606 err = sfp_hwmon_read_sensor(sfp, reg, value); 607 if (err < 0) 608 return err; 609 610 sfp_hwmon_calibrate_tx_power(sfp, value); 611 612 return 0; 613 } 614 615 static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value) 616 { 617 int err; 618 619 err = sfp_hwmon_read_sensor(sfp, reg, value); 620 if (err < 0) 621 return err; 622 623 sfp_hwmon_to_rx_power(value); 624 625 return 0; 626 } 627 628 static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value) 629 { 630 u8 status; 631 int err; 632 633 switch (attr) { 634 case hwmon_temp_input: 635 return sfp_hwmon_read_temp(sfp, SFP_TEMP, value); 636 637 case hwmon_temp_lcrit: 638 *value = be16_to_cpu(sfp->diag.temp_low_alarm); 639 sfp_hwmon_calibrate_temp(sfp, value); 640 return 0; 641 642 case hwmon_temp_min: 643 *value = be16_to_cpu(sfp->diag.temp_low_warn); 644 sfp_hwmon_calibrate_temp(sfp, value); 645 return 0; 646 case hwmon_temp_max: 647 *value = be16_to_cpu(sfp->diag.temp_high_warn); 648 sfp_hwmon_calibrate_temp(sfp, value); 649 return 0; 650 651 case hwmon_temp_crit: 652 *value = be16_to_cpu(sfp->diag.temp_high_alarm); 653 sfp_hwmon_calibrate_temp(sfp, value); 654 return 0; 655 656 case hwmon_temp_lcrit_alarm: 657 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 658 if (err < 0) 659 return err; 660 661 *value = !!(status & SFP_ALARM0_TEMP_LOW); 662 return 0; 663 664 case hwmon_temp_min_alarm: 665 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 666 if (err < 0) 667 return err; 668 669 *value = !!(status & SFP_WARN0_TEMP_LOW); 670 return 0; 671 672 case hwmon_temp_max_alarm: 673 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 674 if (err < 0) 675 return err; 676 677 *value = !!(status & SFP_WARN0_TEMP_HIGH); 678 return 0; 679 680 case hwmon_temp_crit_alarm: 681 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 682 if (err < 0) 683 return err; 684 685 *value = !!(status & SFP_ALARM0_TEMP_HIGH); 686 return 0; 687 default: 688 return -EOPNOTSUPP; 689 } 690 691 return -EOPNOTSUPP; 692 } 693 694 static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value) 695 { 696 u8 status; 697 int err; 698 699 switch (attr) { 700 case hwmon_in_input: 701 return sfp_hwmon_read_vcc(sfp, SFP_VCC, value); 702 703 case hwmon_in_lcrit: 704 *value = be16_to_cpu(sfp->diag.volt_low_alarm); 705 sfp_hwmon_calibrate_vcc(sfp, value); 706 return 0; 707 708 case hwmon_in_min: 709 *value = be16_to_cpu(sfp->diag.volt_low_warn); 710 sfp_hwmon_calibrate_vcc(sfp, value); 711 return 0; 712 713 case hwmon_in_max: 714 *value = be16_to_cpu(sfp->diag.volt_high_warn); 715 sfp_hwmon_calibrate_vcc(sfp, value); 716 return 0; 717 718 case hwmon_in_crit: 719 *value = be16_to_cpu(sfp->diag.volt_high_alarm); 720 sfp_hwmon_calibrate_vcc(sfp, value); 721 return 0; 722 723 case hwmon_in_lcrit_alarm: 724 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 725 if (err < 0) 726 return err; 727 728 *value = !!(status & SFP_ALARM0_VCC_LOW); 729 return 0; 730 731 case hwmon_in_min_alarm: 732 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 733 if (err < 0) 734 return err; 735 736 *value = !!(status & SFP_WARN0_VCC_LOW); 737 return 0; 738 739 case hwmon_in_max_alarm: 740 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 741 if (err < 0) 742 return err; 743 744 *value = !!(status & SFP_WARN0_VCC_HIGH); 745 return 0; 746 747 case hwmon_in_crit_alarm: 748 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 749 if (err < 0) 750 return err; 751 752 *value = !!(status & SFP_ALARM0_VCC_HIGH); 753 return 0; 754 default: 755 return -EOPNOTSUPP; 756 } 757 758 return -EOPNOTSUPP; 759 } 760 761 static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value) 762 { 763 u8 status; 764 int err; 765 766 switch (attr) { 767 case hwmon_curr_input: 768 return sfp_hwmon_read_bias(sfp, SFP_TX_BIAS, value); 769 770 case hwmon_curr_lcrit: 771 *value = be16_to_cpu(sfp->diag.bias_low_alarm); 772 sfp_hwmon_calibrate_bias(sfp, value); 773 return 0; 774 775 case hwmon_curr_min: 776 *value = be16_to_cpu(sfp->diag.bias_low_warn); 777 sfp_hwmon_calibrate_bias(sfp, value); 778 return 0; 779 780 case hwmon_curr_max: 781 *value = be16_to_cpu(sfp->diag.bias_high_warn); 782 sfp_hwmon_calibrate_bias(sfp, value); 783 return 0; 784 785 case hwmon_curr_crit: 786 *value = be16_to_cpu(sfp->diag.bias_high_alarm); 787 sfp_hwmon_calibrate_bias(sfp, value); 788 return 0; 789 790 case hwmon_curr_lcrit_alarm: 791 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 792 if (err < 0) 793 return err; 794 795 *value = !!(status & SFP_ALARM0_TX_BIAS_LOW); 796 return 0; 797 798 case hwmon_curr_min_alarm: 799 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 800 if (err < 0) 801 return err; 802 803 *value = !!(status & SFP_WARN0_TX_BIAS_LOW); 804 return 0; 805 806 case hwmon_curr_max_alarm: 807 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 808 if (err < 0) 809 return err; 810 811 *value = !!(status & SFP_WARN0_TX_BIAS_HIGH); 812 return 0; 813 814 case hwmon_curr_crit_alarm: 815 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 816 if (err < 0) 817 return err; 818 819 *value = !!(status & SFP_ALARM0_TX_BIAS_HIGH); 820 return 0; 821 default: 822 return -EOPNOTSUPP; 823 } 824 825 return -EOPNOTSUPP; 826 } 827 828 static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value) 829 { 830 u8 status; 831 int err; 832 833 switch (attr) { 834 case hwmon_power_input: 835 return sfp_hwmon_read_tx_power(sfp, SFP_TX_POWER, value); 836 837 case hwmon_power_lcrit: 838 *value = be16_to_cpu(sfp->diag.txpwr_low_alarm); 839 sfp_hwmon_calibrate_tx_power(sfp, value); 840 return 0; 841 842 case hwmon_power_min: 843 *value = be16_to_cpu(sfp->diag.txpwr_low_warn); 844 sfp_hwmon_calibrate_tx_power(sfp, value); 845 return 0; 846 847 case hwmon_power_max: 848 *value = be16_to_cpu(sfp->diag.txpwr_high_warn); 849 sfp_hwmon_calibrate_tx_power(sfp, value); 850 return 0; 851 852 case hwmon_power_crit: 853 *value = be16_to_cpu(sfp->diag.txpwr_high_alarm); 854 sfp_hwmon_calibrate_tx_power(sfp, value); 855 return 0; 856 857 case hwmon_power_lcrit_alarm: 858 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 859 if (err < 0) 860 return err; 861 862 *value = !!(status & SFP_ALARM0_TXPWR_LOW); 863 return 0; 864 865 case hwmon_power_min_alarm: 866 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 867 if (err < 0) 868 return err; 869 870 *value = !!(status & SFP_WARN0_TXPWR_LOW); 871 return 0; 872 873 case hwmon_power_max_alarm: 874 err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); 875 if (err < 0) 876 return err; 877 878 *value = !!(status & SFP_WARN0_TXPWR_HIGH); 879 return 0; 880 881 case hwmon_power_crit_alarm: 882 err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); 883 if (err < 0) 884 return err; 885 886 *value = !!(status & SFP_ALARM0_TXPWR_HIGH); 887 return 0; 888 default: 889 return -EOPNOTSUPP; 890 } 891 892 return -EOPNOTSUPP; 893 } 894 895 static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value) 896 { 897 u8 status; 898 int err; 899 900 switch (attr) { 901 case hwmon_power_input: 902 return sfp_hwmon_read_rx_power(sfp, SFP_RX_POWER, value); 903 904 case hwmon_power_lcrit: 905 *value = be16_to_cpu(sfp->diag.rxpwr_low_alarm); 906 sfp_hwmon_to_rx_power(value); 907 return 0; 908 909 case hwmon_power_min: 910 *value = be16_to_cpu(sfp->diag.rxpwr_low_warn); 911 sfp_hwmon_to_rx_power(value); 912 return 0; 913 914 case hwmon_power_max: 915 *value = be16_to_cpu(sfp->diag.rxpwr_high_warn); 916 sfp_hwmon_to_rx_power(value); 917 return 0; 918 919 case hwmon_power_crit: 920 *value = be16_to_cpu(sfp->diag.rxpwr_high_alarm); 921 sfp_hwmon_to_rx_power(value); 922 return 0; 923 924 case hwmon_power_lcrit_alarm: 925 err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); 926 if (err < 0) 927 return err; 928 929 *value = !!(status & SFP_ALARM1_RXPWR_LOW); 930 return 0; 931 932 case hwmon_power_min_alarm: 933 err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); 934 if (err < 0) 935 return err; 936 937 *value = !!(status & SFP_WARN1_RXPWR_LOW); 938 return 0; 939 940 case hwmon_power_max_alarm: 941 err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); 942 if (err < 0) 943 return err; 944 945 *value = !!(status & SFP_WARN1_RXPWR_HIGH); 946 return 0; 947 948 case hwmon_power_crit_alarm: 949 err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); 950 if (err < 0) 951 return err; 952 953 *value = !!(status & SFP_ALARM1_RXPWR_HIGH); 954 return 0; 955 default: 956 return -EOPNOTSUPP; 957 } 958 959 return -EOPNOTSUPP; 960 } 961 962 static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 963 u32 attr, int channel, long *value) 964 { 965 struct sfp *sfp = dev_get_drvdata(dev); 966 967 switch (type) { 968 case hwmon_temp: 969 return sfp_hwmon_temp(sfp, attr, value); 970 case hwmon_in: 971 return sfp_hwmon_vcc(sfp, attr, value); 972 case hwmon_curr: 973 return sfp_hwmon_bias(sfp, attr, value); 974 case hwmon_power: 975 switch (channel) { 976 case 0: 977 return sfp_hwmon_tx_power(sfp, attr, value); 978 case 1: 979 return sfp_hwmon_rx_power(sfp, attr, value); 980 default: 981 return -EOPNOTSUPP; 982 } 983 default: 984 return -EOPNOTSUPP; 985 } 986 } 987 988 static const struct hwmon_ops sfp_hwmon_ops = { 989 .is_visible = sfp_hwmon_is_visible, 990 .read = sfp_hwmon_read, 991 }; 992 993 static u32 sfp_hwmon_chip_config[] = { 994 HWMON_C_REGISTER_TZ, 995 0, 996 }; 997 998 static const struct hwmon_channel_info sfp_hwmon_chip = { 999 .type = hwmon_chip, 1000 .config = sfp_hwmon_chip_config, 1001 }; 1002 1003 static u32 sfp_hwmon_temp_config[] = { 1004 HWMON_T_INPUT | 1005 HWMON_T_MAX | HWMON_T_MIN | 1006 HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM | 1007 HWMON_T_CRIT | HWMON_T_LCRIT | 1008 HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM, 1009 0, 1010 }; 1011 1012 static const struct hwmon_channel_info sfp_hwmon_temp_channel_info = { 1013 .type = hwmon_temp, 1014 .config = sfp_hwmon_temp_config, 1015 }; 1016 1017 static u32 sfp_hwmon_vcc_config[] = { 1018 HWMON_I_INPUT | 1019 HWMON_I_MAX | HWMON_I_MIN | 1020 HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM | 1021 HWMON_I_CRIT | HWMON_I_LCRIT | 1022 HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM, 1023 0, 1024 }; 1025 1026 static const struct hwmon_channel_info sfp_hwmon_vcc_channel_info = { 1027 .type = hwmon_in, 1028 .config = sfp_hwmon_vcc_config, 1029 }; 1030 1031 static u32 sfp_hwmon_bias_config[] = { 1032 HWMON_C_INPUT | 1033 HWMON_C_MAX | HWMON_C_MIN | 1034 HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM | 1035 HWMON_C_CRIT | HWMON_C_LCRIT | 1036 HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM, 1037 0, 1038 }; 1039 1040 static const struct hwmon_channel_info sfp_hwmon_bias_channel_info = { 1041 .type = hwmon_curr, 1042 .config = sfp_hwmon_bias_config, 1043 }; 1044 1045 static u32 sfp_hwmon_power_config[] = { 1046 /* Transmit power */ 1047 HWMON_P_INPUT | 1048 HWMON_P_MAX | HWMON_P_MIN | 1049 HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | 1050 HWMON_P_CRIT | HWMON_P_LCRIT | 1051 HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, 1052 /* Receive power */ 1053 HWMON_P_INPUT | 1054 HWMON_P_MAX | HWMON_P_MIN | 1055 HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | 1056 HWMON_P_CRIT | HWMON_P_LCRIT | 1057 HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, 1058 0, 1059 }; 1060 1061 static const struct hwmon_channel_info sfp_hwmon_power_channel_info = { 1062 .type = hwmon_power, 1063 .config = sfp_hwmon_power_config, 1064 }; 1065 1066 static const struct hwmon_channel_info *sfp_hwmon_info[] = { 1067 &sfp_hwmon_chip, 1068 &sfp_hwmon_vcc_channel_info, 1069 &sfp_hwmon_temp_channel_info, 1070 &sfp_hwmon_bias_channel_info, 1071 &sfp_hwmon_power_channel_info, 1072 NULL, 1073 }; 1074 1075 static const struct hwmon_chip_info sfp_hwmon_chip_info = { 1076 .ops = &sfp_hwmon_ops, 1077 .info = sfp_hwmon_info, 1078 }; 1079 1080 static int sfp_hwmon_insert(struct sfp *sfp) 1081 { 1082 int err, i; 1083 1084 if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE) 1085 return 0; 1086 1087 if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM)) 1088 return 0; 1089 1090 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) 1091 /* This driver in general does not support address 1092 * change. 1093 */ 1094 return 0; 1095 1096 err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag)); 1097 if (err < 0) 1098 return err; 1099 1100 sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL); 1101 if (!sfp->hwmon_name) 1102 return -ENODEV; 1103 1104 for (i = 0; sfp->hwmon_name[i]; i++) 1105 if (hwmon_is_bad_char(sfp->hwmon_name[i])) 1106 sfp->hwmon_name[i] = '_'; 1107 1108 sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev, 1109 sfp->hwmon_name, sfp, 1110 &sfp_hwmon_chip_info, 1111 NULL); 1112 1113 return PTR_ERR_OR_ZERO(sfp->hwmon_dev); 1114 } 1115 1116 static void sfp_hwmon_remove(struct sfp *sfp) 1117 { 1118 if (!IS_ERR_OR_NULL(sfp->hwmon_dev)) { 1119 hwmon_device_unregister(sfp->hwmon_dev); 1120 sfp->hwmon_dev = NULL; 1121 kfree(sfp->hwmon_name); 1122 } 1123 } 1124 #else 1125 static int sfp_hwmon_insert(struct sfp *sfp) 1126 { 1127 return 0; 1128 } 1129 1130 static void sfp_hwmon_remove(struct sfp *sfp) 1131 { 1132 } 1133 #endif 1134 1135 /* Helpers */ 1136 static void sfp_module_tx_disable(struct sfp *sfp) 1137 { 1138 dev_dbg(sfp->dev, "tx disable %u -> %u\n", 1139 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1); 1140 sfp->state |= SFP_F_TX_DISABLE; 1141 sfp_set_state(sfp, sfp->state); 1142 } 1143 1144 static void sfp_module_tx_enable(struct sfp *sfp) 1145 { 1146 dev_dbg(sfp->dev, "tx disable %u -> %u\n", 1147 sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0); 1148 sfp->state &= ~SFP_F_TX_DISABLE; 1149 sfp_set_state(sfp, sfp->state); 1150 } 1151 1152 static void sfp_module_tx_fault_reset(struct sfp *sfp) 1153 { 1154 unsigned int state = sfp->state; 1155 1156 if (state & SFP_F_TX_DISABLE) 1157 return; 1158 1159 sfp_set_state(sfp, state | SFP_F_TX_DISABLE); 1160 1161 udelay(T_RESET_US); 1162 1163 sfp_set_state(sfp, state); 1164 } 1165 1166 /* SFP state machine */ 1167 static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout) 1168 { 1169 if (timeout) 1170 mod_delayed_work(system_power_efficient_wq, &sfp->timeout, 1171 timeout); 1172 else 1173 cancel_delayed_work(&sfp->timeout); 1174 } 1175 1176 static void sfp_sm_next(struct sfp *sfp, unsigned int state, 1177 unsigned int timeout) 1178 { 1179 sfp->sm_state = state; 1180 sfp_sm_set_timer(sfp, timeout); 1181 } 1182 1183 static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state, 1184 unsigned int timeout) 1185 { 1186 sfp->sm_mod_state = state; 1187 sfp_sm_set_timer(sfp, timeout); 1188 } 1189 1190 static void sfp_sm_phy_detach(struct sfp *sfp) 1191 { 1192 phy_stop(sfp->mod_phy); 1193 sfp_remove_phy(sfp->sfp_bus); 1194 phy_device_remove(sfp->mod_phy); 1195 phy_device_free(sfp->mod_phy); 1196 sfp->mod_phy = NULL; 1197 } 1198 1199 static void sfp_sm_probe_phy(struct sfp *sfp) 1200 { 1201 struct phy_device *phy; 1202 int err; 1203 1204 msleep(T_PHY_RESET_MS); 1205 1206 phy = mdiobus_scan(sfp->i2c_mii, SFP_PHY_ADDR); 1207 if (phy == ERR_PTR(-ENODEV)) { 1208 dev_info(sfp->dev, "no PHY detected\n"); 1209 return; 1210 } 1211 if (IS_ERR(phy)) { 1212 dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy)); 1213 return; 1214 } 1215 1216 err = sfp_add_phy(sfp->sfp_bus, phy); 1217 if (err) { 1218 phy_device_remove(phy); 1219 phy_device_free(phy); 1220 dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err); 1221 return; 1222 } 1223 1224 sfp->mod_phy = phy; 1225 phy_start(phy); 1226 } 1227 1228 static void sfp_sm_link_up(struct sfp *sfp) 1229 { 1230 sfp_link_up(sfp->sfp_bus); 1231 sfp_sm_next(sfp, SFP_S_LINK_UP, 0); 1232 } 1233 1234 static void sfp_sm_link_down(struct sfp *sfp) 1235 { 1236 sfp_link_down(sfp->sfp_bus); 1237 } 1238 1239 static void sfp_sm_link_check_los(struct sfp *sfp) 1240 { 1241 unsigned int los = sfp->state & SFP_F_LOS; 1242 1243 /* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL 1244 * are set, we assume that no LOS signal is available. 1245 */ 1246 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED)) 1247 los ^= SFP_F_LOS; 1248 else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL))) 1249 los = 0; 1250 1251 if (los) 1252 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); 1253 else 1254 sfp_sm_link_up(sfp); 1255 } 1256 1257 static bool sfp_los_event_active(struct sfp *sfp, unsigned int event) 1258 { 1259 return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) && 1260 event == SFP_E_LOS_LOW) || 1261 (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) && 1262 event == SFP_E_LOS_HIGH); 1263 } 1264 1265 static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event) 1266 { 1267 return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) && 1268 event == SFP_E_LOS_HIGH) || 1269 (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) && 1270 event == SFP_E_LOS_LOW); 1271 } 1272 1273 static void sfp_sm_fault(struct sfp *sfp, bool warn) 1274 { 1275 if (sfp->sm_retries && !--sfp->sm_retries) { 1276 dev_err(sfp->dev, 1277 "module persistently indicates fault, disabling\n"); 1278 sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0); 1279 } else { 1280 if (warn) 1281 dev_err(sfp->dev, "module transmit fault indicated\n"); 1282 1283 sfp_sm_next(sfp, SFP_S_TX_FAULT, T_FAULT_RECOVER); 1284 } 1285 } 1286 1287 static void sfp_sm_mod_init(struct sfp *sfp) 1288 { 1289 sfp_module_tx_enable(sfp); 1290 1291 /* Wait t_init before indicating that the link is up, provided the 1292 * current state indicates no TX_FAULT. If TX_FAULT clears before 1293 * this time, that's fine too. 1294 */ 1295 sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES); 1296 sfp->sm_retries = 5; 1297 1298 /* Setting the serdes link mode is guesswork: there's no 1299 * field in the EEPROM which indicates what mode should 1300 * be used. 1301 * 1302 * If it's a gigabit-only fiber module, it probably does 1303 * not have a PHY, so switch to 802.3z negotiation mode. 1304 * Otherwise, switch to SGMII mode (which is required to 1305 * support non-gigabit speeds) and probe for a PHY. 1306 */ 1307 if (sfp->id.base.e1000_base_t || 1308 sfp->id.base.e100_base_lx || 1309 sfp->id.base.e100_base_fx) 1310 sfp_sm_probe_phy(sfp); 1311 } 1312 1313 static int sfp_sm_mod_hpower(struct sfp *sfp) 1314 { 1315 u32 power; 1316 u8 val; 1317 int err; 1318 1319 power = 1000; 1320 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL)) 1321 power = 1500; 1322 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL)) 1323 power = 2000; 1324 1325 if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE && 1326 (sfp->id.ext.diagmon & (SFP_DIAGMON_DDM | SFP_DIAGMON_ADDRMODE)) != 1327 SFP_DIAGMON_DDM) { 1328 /* The module appears not to implement bus address 0xa2, 1329 * or requires an address change sequence, so assume that 1330 * the module powers up in the indicated power mode. 1331 */ 1332 if (power > sfp->max_power_mW) { 1333 dev_err(sfp->dev, 1334 "Host does not support %u.%uW modules\n", 1335 power / 1000, (power / 100) % 10); 1336 return -EINVAL; 1337 } 1338 return 0; 1339 } 1340 1341 if (power > sfp->max_power_mW) { 1342 dev_warn(sfp->dev, 1343 "Host does not support %u.%uW modules, module left in power mode 1\n", 1344 power / 1000, (power / 100) % 10); 1345 return 0; 1346 } 1347 1348 if (power <= 1000) 1349 return 0; 1350 1351 err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1352 if (err != sizeof(val)) { 1353 dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err); 1354 err = -EAGAIN; 1355 goto err; 1356 } 1357 1358 val |= BIT(0); 1359 1360 err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val)); 1361 if (err != sizeof(val)) { 1362 dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err); 1363 err = -EAGAIN; 1364 goto err; 1365 } 1366 1367 dev_info(sfp->dev, "Module switched to %u.%uW power level\n", 1368 power / 1000, (power / 100) % 10); 1369 return T_HPOWER_LEVEL; 1370 1371 err: 1372 return err; 1373 } 1374 1375 static int sfp_sm_mod_probe(struct sfp *sfp) 1376 { 1377 /* SFP module inserted - read I2C data */ 1378 struct sfp_eeprom_id id; 1379 bool cotsworks; 1380 u8 check; 1381 int ret; 1382 1383 ret = sfp_read(sfp, false, 0, &id, sizeof(id)); 1384 if (ret < 0) { 1385 dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret); 1386 return -EAGAIN; 1387 } 1388 1389 if (ret != sizeof(id)) { 1390 dev_err(sfp->dev, "EEPROM short read: %d\n", ret); 1391 return -EAGAIN; 1392 } 1393 1394 /* Cotsworks do not seem to update the checksums when they 1395 * do the final programming with the final module part number, 1396 * serial number and date code. 1397 */ 1398 cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS ", 16); 1399 1400 /* Validate the checksum over the base structure */ 1401 check = sfp_check(&id.base, sizeof(id.base) - 1); 1402 if (check != id.base.cc_base) { 1403 if (cotsworks) { 1404 dev_warn(sfp->dev, 1405 "EEPROM base structure checksum failure (0x%02x != 0x%02x)\n", 1406 check, id.base.cc_base); 1407 } else { 1408 dev_err(sfp->dev, 1409 "EEPROM base structure checksum failure: 0x%02x != 0x%02x\n", 1410 check, id.base.cc_base); 1411 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1412 16, 1, &id, sizeof(id), true); 1413 return -EINVAL; 1414 } 1415 } 1416 1417 check = sfp_check(&id.ext, sizeof(id.ext) - 1); 1418 if (check != id.ext.cc_ext) { 1419 if (cotsworks) { 1420 dev_warn(sfp->dev, 1421 "EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n", 1422 check, id.ext.cc_ext); 1423 } else { 1424 dev_err(sfp->dev, 1425 "EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n", 1426 check, id.ext.cc_ext); 1427 print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, 1428 16, 1, &id, sizeof(id), true); 1429 memset(&id.ext, 0, sizeof(id.ext)); 1430 } 1431 } 1432 1433 sfp->id = id; 1434 1435 dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n", 1436 (int)sizeof(id.base.vendor_name), id.base.vendor_name, 1437 (int)sizeof(id.base.vendor_pn), id.base.vendor_pn, 1438 (int)sizeof(id.base.vendor_rev), id.base.vendor_rev, 1439 (int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn, 1440 (int)sizeof(id.ext.datecode), id.ext.datecode); 1441 1442 /* Check whether we support this module */ 1443 if (!sfp->type->module_supported(&sfp->id)) { 1444 dev_err(sfp->dev, 1445 "module is not supported - phys id 0x%02x 0x%02x\n", 1446 sfp->id.base.phys_id, sfp->id.base.phys_ext_id); 1447 return -EINVAL; 1448 } 1449 1450 /* If the module requires address swap mode, warn about it */ 1451 if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) 1452 dev_warn(sfp->dev, 1453 "module address swap to access page 0xA2 is not supported.\n"); 1454 1455 ret = sfp_hwmon_insert(sfp); 1456 if (ret < 0) 1457 return ret; 1458 1459 ret = sfp_module_insert(sfp->sfp_bus, &sfp->id); 1460 if (ret < 0) 1461 return ret; 1462 1463 return sfp_sm_mod_hpower(sfp); 1464 } 1465 1466 static void sfp_sm_mod_remove(struct sfp *sfp) 1467 { 1468 sfp_module_remove(sfp->sfp_bus); 1469 1470 sfp_hwmon_remove(sfp); 1471 1472 if (sfp->mod_phy) 1473 sfp_sm_phy_detach(sfp); 1474 1475 sfp_module_tx_disable(sfp); 1476 1477 memset(&sfp->id, 0, sizeof(sfp->id)); 1478 1479 dev_info(sfp->dev, "module removed\n"); 1480 } 1481 1482 static void sfp_sm_event(struct sfp *sfp, unsigned int event) 1483 { 1484 mutex_lock(&sfp->sm_mutex); 1485 1486 dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n", 1487 mod_state_to_str(sfp->sm_mod_state), 1488 dev_state_to_str(sfp->sm_dev_state), 1489 sm_state_to_str(sfp->sm_state), 1490 event_to_str(event)); 1491 1492 /* This state machine tracks the insert/remove state of 1493 * the module, and handles probing the on-board EEPROM. 1494 */ 1495 switch (sfp->sm_mod_state) { 1496 default: 1497 if (event == SFP_E_INSERT && sfp->attached) { 1498 sfp_module_tx_disable(sfp); 1499 sfp_sm_ins_next(sfp, SFP_MOD_PROBE, T_PROBE_INIT); 1500 } 1501 break; 1502 1503 case SFP_MOD_PROBE: 1504 if (event == SFP_E_REMOVE) { 1505 sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0); 1506 } else if (event == SFP_E_TIMEOUT) { 1507 int val = sfp_sm_mod_probe(sfp); 1508 1509 if (val == 0) 1510 sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0); 1511 else if (val > 0) 1512 sfp_sm_ins_next(sfp, SFP_MOD_HPOWER, val); 1513 else if (val != -EAGAIN) 1514 sfp_sm_ins_next(sfp, SFP_MOD_ERROR, 0); 1515 else 1516 sfp_sm_set_timer(sfp, T_PROBE_RETRY); 1517 } 1518 break; 1519 1520 case SFP_MOD_HPOWER: 1521 if (event == SFP_E_TIMEOUT) { 1522 sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0); 1523 break; 1524 } 1525 /* fallthrough */ 1526 case SFP_MOD_PRESENT: 1527 case SFP_MOD_ERROR: 1528 if (event == SFP_E_REMOVE) { 1529 sfp_sm_mod_remove(sfp); 1530 sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0); 1531 } 1532 break; 1533 } 1534 1535 /* This state machine tracks the netdev up/down state */ 1536 switch (sfp->sm_dev_state) { 1537 default: 1538 if (event == SFP_E_DEV_UP) 1539 sfp->sm_dev_state = SFP_DEV_UP; 1540 break; 1541 1542 case SFP_DEV_UP: 1543 if (event == SFP_E_DEV_DOWN) { 1544 /* If the module has a PHY, avoid raising TX disable 1545 * as this resets the PHY. Otherwise, raise it to 1546 * turn the laser off. 1547 */ 1548 if (!sfp->mod_phy) 1549 sfp_module_tx_disable(sfp); 1550 sfp->sm_dev_state = SFP_DEV_DOWN; 1551 } 1552 break; 1553 } 1554 1555 /* Some events are global */ 1556 if (sfp->sm_state != SFP_S_DOWN && 1557 (sfp->sm_mod_state != SFP_MOD_PRESENT || 1558 sfp->sm_dev_state != SFP_DEV_UP)) { 1559 if (sfp->sm_state == SFP_S_LINK_UP && 1560 sfp->sm_dev_state == SFP_DEV_UP) 1561 sfp_sm_link_down(sfp); 1562 if (sfp->mod_phy) 1563 sfp_sm_phy_detach(sfp); 1564 sfp_sm_next(sfp, SFP_S_DOWN, 0); 1565 mutex_unlock(&sfp->sm_mutex); 1566 return; 1567 } 1568 1569 /* The main state machine */ 1570 switch (sfp->sm_state) { 1571 case SFP_S_DOWN: 1572 if (sfp->sm_mod_state == SFP_MOD_PRESENT && 1573 sfp->sm_dev_state == SFP_DEV_UP) 1574 sfp_sm_mod_init(sfp); 1575 break; 1576 1577 case SFP_S_INIT: 1578 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) 1579 sfp_sm_fault(sfp, true); 1580 else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) 1581 sfp_sm_link_check_los(sfp); 1582 break; 1583 1584 case SFP_S_WAIT_LOS: 1585 if (event == SFP_E_TX_FAULT) 1586 sfp_sm_fault(sfp, true); 1587 else if (sfp_los_event_inactive(sfp, event)) 1588 sfp_sm_link_up(sfp); 1589 break; 1590 1591 case SFP_S_LINK_UP: 1592 if (event == SFP_E_TX_FAULT) { 1593 sfp_sm_link_down(sfp); 1594 sfp_sm_fault(sfp, true); 1595 } else if (sfp_los_event_active(sfp, event)) { 1596 sfp_sm_link_down(sfp); 1597 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); 1598 } 1599 break; 1600 1601 case SFP_S_TX_FAULT: 1602 if (event == SFP_E_TIMEOUT) { 1603 sfp_module_tx_fault_reset(sfp); 1604 sfp_sm_next(sfp, SFP_S_REINIT, T_INIT_JIFFIES); 1605 } 1606 break; 1607 1608 case SFP_S_REINIT: 1609 if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { 1610 sfp_sm_fault(sfp, false); 1611 } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { 1612 dev_info(sfp->dev, "module transmit fault recovered\n"); 1613 sfp_sm_link_check_los(sfp); 1614 } 1615 break; 1616 1617 case SFP_S_TX_DISABLE: 1618 break; 1619 } 1620 1621 dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n", 1622 mod_state_to_str(sfp->sm_mod_state), 1623 dev_state_to_str(sfp->sm_dev_state), 1624 sm_state_to_str(sfp->sm_state)); 1625 1626 mutex_unlock(&sfp->sm_mutex); 1627 } 1628 1629 static void sfp_attach(struct sfp *sfp) 1630 { 1631 sfp->attached = true; 1632 if (sfp->state & SFP_F_PRESENT) 1633 sfp_sm_event(sfp, SFP_E_INSERT); 1634 } 1635 1636 static void sfp_detach(struct sfp *sfp) 1637 { 1638 sfp->attached = false; 1639 sfp_sm_event(sfp, SFP_E_REMOVE); 1640 } 1641 1642 static void sfp_start(struct sfp *sfp) 1643 { 1644 sfp_sm_event(sfp, SFP_E_DEV_UP); 1645 } 1646 1647 static void sfp_stop(struct sfp *sfp) 1648 { 1649 sfp_sm_event(sfp, SFP_E_DEV_DOWN); 1650 } 1651 1652 static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo) 1653 { 1654 /* locking... and check module is present */ 1655 1656 if (sfp->id.ext.sff8472_compliance && 1657 !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) { 1658 modinfo->type = ETH_MODULE_SFF_8472; 1659 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 1660 } else { 1661 modinfo->type = ETH_MODULE_SFF_8079; 1662 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; 1663 } 1664 return 0; 1665 } 1666 1667 static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee, 1668 u8 *data) 1669 { 1670 unsigned int first, last, len; 1671 int ret; 1672 1673 if (ee->len == 0) 1674 return -EINVAL; 1675 1676 first = ee->offset; 1677 last = ee->offset + ee->len; 1678 if (first < ETH_MODULE_SFF_8079_LEN) { 1679 len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN); 1680 len -= first; 1681 1682 ret = sfp_read(sfp, false, first, data, len); 1683 if (ret < 0) 1684 return ret; 1685 1686 first += len; 1687 data += len; 1688 } 1689 if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) { 1690 len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN); 1691 len -= first; 1692 first -= ETH_MODULE_SFF_8079_LEN; 1693 1694 ret = sfp_read(sfp, true, first, data, len); 1695 if (ret < 0) 1696 return ret; 1697 } 1698 return 0; 1699 } 1700 1701 static const struct sfp_socket_ops sfp_module_ops = { 1702 .attach = sfp_attach, 1703 .detach = sfp_detach, 1704 .start = sfp_start, 1705 .stop = sfp_stop, 1706 .module_info = sfp_module_info, 1707 .module_eeprom = sfp_module_eeprom, 1708 }; 1709 1710 static void sfp_timeout(struct work_struct *work) 1711 { 1712 struct sfp *sfp = container_of(work, struct sfp, timeout.work); 1713 1714 rtnl_lock(); 1715 sfp_sm_event(sfp, SFP_E_TIMEOUT); 1716 rtnl_unlock(); 1717 } 1718 1719 static void sfp_check_state(struct sfp *sfp) 1720 { 1721 unsigned int state, i, changed; 1722 1723 state = sfp_get_state(sfp); 1724 changed = state ^ sfp->state; 1725 changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT; 1726 1727 for (i = 0; i < GPIO_MAX; i++) 1728 if (changed & BIT(i)) 1729 dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i], 1730 !!(sfp->state & BIT(i)), !!(state & BIT(i))); 1731 1732 state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT); 1733 sfp->state = state; 1734 1735 rtnl_lock(); 1736 if (changed & SFP_F_PRESENT) 1737 sfp_sm_event(sfp, state & SFP_F_PRESENT ? 1738 SFP_E_INSERT : SFP_E_REMOVE); 1739 1740 if (changed & SFP_F_TX_FAULT) 1741 sfp_sm_event(sfp, state & SFP_F_TX_FAULT ? 1742 SFP_E_TX_FAULT : SFP_E_TX_CLEAR); 1743 1744 if (changed & SFP_F_LOS) 1745 sfp_sm_event(sfp, state & SFP_F_LOS ? 1746 SFP_E_LOS_HIGH : SFP_E_LOS_LOW); 1747 rtnl_unlock(); 1748 } 1749 1750 static irqreturn_t sfp_irq(int irq, void *data) 1751 { 1752 struct sfp *sfp = data; 1753 1754 sfp_check_state(sfp); 1755 1756 return IRQ_HANDLED; 1757 } 1758 1759 static void sfp_poll(struct work_struct *work) 1760 { 1761 struct sfp *sfp = container_of(work, struct sfp, poll.work); 1762 1763 sfp_check_state(sfp); 1764 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 1765 } 1766 1767 static struct sfp *sfp_alloc(struct device *dev) 1768 { 1769 struct sfp *sfp; 1770 1771 sfp = kzalloc(sizeof(*sfp), GFP_KERNEL); 1772 if (!sfp) 1773 return ERR_PTR(-ENOMEM); 1774 1775 sfp->dev = dev; 1776 1777 mutex_init(&sfp->sm_mutex); 1778 INIT_DELAYED_WORK(&sfp->poll, sfp_poll); 1779 INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout); 1780 1781 return sfp; 1782 } 1783 1784 static void sfp_cleanup(void *data) 1785 { 1786 struct sfp *sfp = data; 1787 1788 cancel_delayed_work_sync(&sfp->poll); 1789 cancel_delayed_work_sync(&sfp->timeout); 1790 if (sfp->i2c_mii) { 1791 mdiobus_unregister(sfp->i2c_mii); 1792 mdiobus_free(sfp->i2c_mii); 1793 } 1794 if (sfp->i2c) 1795 i2c_put_adapter(sfp->i2c); 1796 kfree(sfp); 1797 } 1798 1799 static int sfp_probe(struct platform_device *pdev) 1800 { 1801 const struct sff_data *sff; 1802 struct i2c_adapter *i2c; 1803 struct sfp *sfp; 1804 bool poll = false; 1805 int irq, err, i; 1806 1807 sfp = sfp_alloc(&pdev->dev); 1808 if (IS_ERR(sfp)) 1809 return PTR_ERR(sfp); 1810 1811 platform_set_drvdata(pdev, sfp); 1812 1813 err = devm_add_action(sfp->dev, sfp_cleanup, sfp); 1814 if (err < 0) 1815 return err; 1816 1817 sff = sfp->type = &sfp_data; 1818 1819 if (pdev->dev.of_node) { 1820 struct device_node *node = pdev->dev.of_node; 1821 const struct of_device_id *id; 1822 struct device_node *np; 1823 1824 id = of_match_node(sfp_of_match, node); 1825 if (WARN_ON(!id)) 1826 return -EINVAL; 1827 1828 sff = sfp->type = id->data; 1829 1830 np = of_parse_phandle(node, "i2c-bus", 0); 1831 if (!np) { 1832 dev_err(sfp->dev, "missing 'i2c-bus' property\n"); 1833 return -ENODEV; 1834 } 1835 1836 i2c = of_find_i2c_adapter_by_node(np); 1837 of_node_put(np); 1838 } else if (has_acpi_companion(&pdev->dev)) { 1839 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 1840 struct fwnode_handle *fw = acpi_fwnode_handle(adev); 1841 struct fwnode_reference_args args; 1842 struct acpi_handle *acpi_handle; 1843 int ret; 1844 1845 ret = acpi_node_get_property_reference(fw, "i2c-bus", 0, &args); 1846 if (ACPI_FAILURE(ret) || !is_acpi_device_node(args.fwnode)) { 1847 dev_err(&pdev->dev, "missing 'i2c-bus' property\n"); 1848 return -ENODEV; 1849 } 1850 1851 acpi_handle = ACPI_HANDLE_FWNODE(args.fwnode); 1852 i2c = i2c_acpi_find_adapter_by_handle(acpi_handle); 1853 } else { 1854 return -EINVAL; 1855 } 1856 1857 if (!i2c) 1858 return -EPROBE_DEFER; 1859 1860 err = sfp_i2c_configure(sfp, i2c); 1861 if (err < 0) { 1862 i2c_put_adapter(i2c); 1863 return err; 1864 } 1865 1866 for (i = 0; i < GPIO_MAX; i++) 1867 if (sff->gpios & BIT(i)) { 1868 sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev, 1869 gpio_of_names[i], gpio_flags[i]); 1870 if (IS_ERR(sfp->gpio[i])) 1871 return PTR_ERR(sfp->gpio[i]); 1872 } 1873 1874 sfp->get_state = sfp_gpio_get_state; 1875 sfp->set_state = sfp_gpio_set_state; 1876 1877 /* Modules that have no detect signal are always present */ 1878 if (!(sfp->gpio[GPIO_MODDEF0])) 1879 sfp->get_state = sff_gpio_get_state; 1880 1881 device_property_read_u32(&pdev->dev, "maximum-power-milliwatt", 1882 &sfp->max_power_mW); 1883 if (!sfp->max_power_mW) 1884 sfp->max_power_mW = 1000; 1885 1886 dev_info(sfp->dev, "Host maximum power %u.%uW\n", 1887 sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10); 1888 1889 /* Get the initial state, and always signal TX disable, 1890 * since the network interface will not be up. 1891 */ 1892 sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE; 1893 1894 if (sfp->gpio[GPIO_RATE_SELECT] && 1895 gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT])) 1896 sfp->state |= SFP_F_RATE_SELECT; 1897 sfp_set_state(sfp, sfp->state); 1898 sfp_module_tx_disable(sfp); 1899 1900 for (i = 0; i < GPIO_MAX; i++) { 1901 if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) 1902 continue; 1903 1904 irq = gpiod_to_irq(sfp->gpio[i]); 1905 if (!irq) { 1906 poll = true; 1907 continue; 1908 } 1909 1910 err = devm_request_threaded_irq(sfp->dev, irq, NULL, sfp_irq, 1911 IRQF_ONESHOT | 1912 IRQF_TRIGGER_RISING | 1913 IRQF_TRIGGER_FALLING, 1914 dev_name(sfp->dev), sfp); 1915 if (err) 1916 poll = true; 1917 } 1918 1919 if (poll) 1920 mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); 1921 1922 /* We could have an issue in cases no Tx disable pin is available or 1923 * wired as modules using a laser as their light source will continue to 1924 * be active when the fiber is removed. This could be a safety issue and 1925 * we should at least warn the user about that. 1926 */ 1927 if (!sfp->gpio[GPIO_TX_DISABLE]) 1928 dev_warn(sfp->dev, 1929 "No tx_disable pin: SFP modules will always be emitting.\n"); 1930 1931 sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops); 1932 if (!sfp->sfp_bus) 1933 return -ENOMEM; 1934 1935 return 0; 1936 } 1937 1938 static int sfp_remove(struct platform_device *pdev) 1939 { 1940 struct sfp *sfp = platform_get_drvdata(pdev); 1941 1942 sfp_unregister_socket(sfp->sfp_bus); 1943 1944 return 0; 1945 } 1946 1947 static struct platform_driver sfp_driver = { 1948 .probe = sfp_probe, 1949 .remove = sfp_remove, 1950 .driver = { 1951 .name = "sfp", 1952 .of_match_table = sfp_of_match, 1953 }, 1954 }; 1955 1956 static int sfp_init(void) 1957 { 1958 poll_jiffies = msecs_to_jiffies(100); 1959 1960 return platform_driver_register(&sfp_driver); 1961 } 1962 module_init(sfp_init); 1963 1964 static void sfp_exit(void) 1965 { 1966 platform_driver_unregister(&sfp_driver); 1967 } 1968 module_exit(sfp_exit); 1969 1970 MODULE_ALIAS("platform:sfp"); 1971 MODULE_AUTHOR("Russell King"); 1972 MODULE_LICENSE("GPL v2"); 1973