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