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