| Message ID | 1531856893-27884-5-git-send-email-andrew@lunn.ch (mailing list archive) |
|---|---|
| State | Awaiting Upstream |
| Headers | show |
On Tue, Jul 17, 2018 at 09:48:13PM +0200, Andrew Lunn wrote: > SFP modules can contain a number of sensors. The EEPROM also contains > recommended alarm and critical values for each sensor, and indications > of if these have been exceeded. Export this information via > HWMON. Currently temperature, VCC, bias current, transmit power, and > possibly receiver power is supported. > > The sensors in the modules can either return calibrate or uncalibrated > values. Uncalibrated values need to be manipulated, using coefficients > provided in the SFP EEPROM. Uncalibrated receive power values require > floating point maths in order to calibrate them. Performing this in > the kernel is hard. So if the SFP module indicates it uses > uncalibrated values, RX power is not made available. > > With this hwmon device, it is possible to view the sensor values using > lm-sensors programs: > > in0: +3.29 V (crit min = +2.90 V, min = +3.00 V) > (max = +3.60 V, crit max = +3.70 V) > temp1: +33.0°C (low = -5.0°C, high = +80.0°C) > (crit low = -10.0°C, crit = +85.0°C) > power1: 1000.00 nW (max = 794.00 uW, min = 50.00 uW) ALARM (LCRIT) > (lcrit = 40.00 uW, crit = 1000.00 uW) > curr1: +0.00 A (crit min = +0.00 A, min = +0.00 A) ALARM (LCRIT, MIN) > (max = +0.01 A, crit max = +0.01 A) > > The scaling sensors performs on the bias current is not particularly > good. The raw values are more useful: > > curr1: > curr1_input: 0.000 > curr1_min: 0.002 > curr1_max: 0.010 > curr1_lcrit: 0.000 > curr1_crit: 0.011 > curr1_min_alarm: 1.000 > curr1_max_alarm: 0.000 > curr1_lcrit_alarm: 1.000 > curr1_crit_alarm: 0.000 > > In order to keep the I2C overhead to a minimum, the constant values, > such as limits and calibration coefficients are read once at module > insertion time. Thus only reading *_input and *_alarm properties > requires i2c read operations. > > Signed-off-by: Andrew Lunn <andrew@lunn.ch> Acked-by: Guenter Roeck <linux@roeck-us.net> > --- > RFC->V1 > Use __be16 when reading sensor > DIV_ROUND_CLOSEST() > Don't use devm_hwmon_* to fix lifetime issues > Replace invalid chars in hwmon name with _ > --- > drivers/net/phy/Kconfig | 1 + > drivers/net/phy/sfp.c | 727 ++++++++++++++++++++++++++++++++++++++++ > include/linux/sfp.h | 72 +++- > 3 files changed, 799 insertions(+), 1 deletion(-) > > diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig > index 7761536974bf..f31ae4faf4e5 100644 > --- a/drivers/net/phy/Kconfig > +++ b/drivers/net/phy/Kconfig > @@ -215,6 +215,7 @@ config SFP > tristate "SFP cage support" > depends on I2C > select MDIO_I2C > + imply HWMON > > config AMD_PHY > tristate "AMD PHYs" > diff --git a/drivers/net/phy/sfp.c b/drivers/net/phy/sfp.c > index c4c92db86dfa..5661226cf75b 100644 > --- a/drivers/net/phy/sfp.c > +++ b/drivers/net/phy/sfp.c > @@ -1,5 +1,7 @@ > +#include <linux/ctype.h> > #include <linux/delay.h> > #include <linux/gpio/consumer.h> > +#include <linux/hwmon.h> > #include <linux/i2c.h> > #include <linux/interrupt.h> > #include <linux/jiffies.h> > @@ -131,6 +133,12 @@ struct sfp { > unsigned int sm_retries; > > struct sfp_eeprom_id id; > +#if IS_ENABLED(CONFIG_HWMON) > + struct sfp_diag diag; > + struct device *hwmon_dev; > + char *hwmon_name; > +#endif > + > }; > > static bool sff_module_supported(const struct sfp_eeprom_id *id) > @@ -316,6 +324,719 @@ static unsigned int sfp_check(void *buf, size_t len) > return check; > } > > +/* hwmon */ > +#if IS_ENABLED(CONFIG_HWMON) > +static umode_t sfp_hwmon_is_visible(const void *data, > + enum hwmon_sensor_types type, > + u32 attr, int channel) > +{ > + const struct sfp *sfp = data; > + > + switch (type) { > + case hwmon_temp: > + switch (attr) { > + case hwmon_temp_input: > + case hwmon_temp_min_alarm: > + case hwmon_temp_max_alarm: > + case hwmon_temp_lcrit_alarm: > + case hwmon_temp_crit_alarm: > + case hwmon_temp_min: > + case hwmon_temp_max: > + case hwmon_temp_lcrit: > + case hwmon_temp_crit: > + return 0444; > + default: > + return 0; > + } > + case hwmon_in: > + switch (attr) { > + case hwmon_in_input: > + case hwmon_in_min_alarm: > + case hwmon_in_max_alarm: > + case hwmon_in_lcrit_alarm: > + case hwmon_in_crit_alarm: > + case hwmon_in_min: > + case hwmon_in_max: > + case hwmon_in_lcrit: > + case hwmon_in_crit: > + return 0444; > + default: > + return 0; > + } > + case hwmon_curr: > + switch (attr) { > + case hwmon_curr_input: > + case hwmon_curr_min_alarm: > + case hwmon_curr_max_alarm: > + case hwmon_curr_lcrit_alarm: > + case hwmon_curr_crit_alarm: > + case hwmon_curr_min: > + case hwmon_curr_max: > + case hwmon_curr_lcrit: > + case hwmon_curr_crit: > + return 0444; > + default: > + return 0; > + } > + case hwmon_power: > + /* External calibration of receive power requires > + * floating point arithmetic. Doing that in the kernel > + * is not easy, so just skip it. If the module does > + * not require external calibration, we can however > + * show receiver power, since FP is then not needed. > + */ > + if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL && > + channel == 1) > + return 0; > + switch (attr) { > + case hwmon_power_input: > + case hwmon_power_min_alarm: > + case hwmon_power_max_alarm: > + case hwmon_power_lcrit_alarm: > + case hwmon_power_crit_alarm: > + case hwmon_power_min: > + case hwmon_power_max: > + case hwmon_power_lcrit: > + case hwmon_power_crit: > + return 0444; > + default: > + return 0; > + } > + default: > + return 0; > + } > +} > + > +static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value) > +{ > + __be16 val; > + int err; > + > + err = sfp_read(sfp, true, reg, &val, sizeof(val)); > + if (err < 0) > + return err; > + > + *value = be16_to_cpu(val); > + > + return 0; > +} > + > +static void sfp_hwmon_to_rx_power(long *value) > +{ > + *value = DIV_ROUND_CLOSEST(*value, 100); > +} > + > +static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset, > + long *value) > +{ > + if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL) > + *value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset; > +} > + > +static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value) > +{ > + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope), > + be16_to_cpu(sfp->diag.cal_t_offset), value); > + > + if (*value >= 0x8000) > + *value -= 0x10000; > + > + *value = DIV_ROUND_CLOSEST(*value * 1000, 256); > +} > + > +static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value) > +{ > + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope), > + be16_to_cpu(sfp->diag.cal_v_offset), value); > + > + *value = DIV_ROUND_CLOSEST(*value, 10); > +} > + > +static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value) > +{ > + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope), > + be16_to_cpu(sfp->diag.cal_txi_offset), value); > + > + *value = DIV_ROUND_CLOSEST(*value, 500); > +} > + > +static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value) > +{ > + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope), > + be16_to_cpu(sfp->diag.cal_txpwr_offset), value); > + > + *value = DIV_ROUND_CLOSEST(*value, 10); > +} > + > +static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value) > +{ > + int err; > + > + err = sfp_hwmon_read_sensor(sfp, reg, value); > + if (err < 0) > + return err; > + > + sfp_hwmon_calibrate_temp(sfp, value); > + > + return 0; > +} > + > +static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value) > +{ > + int err; > + > + err = sfp_hwmon_read_sensor(sfp, reg, value); > + if (err < 0) > + return err; > + > + sfp_hwmon_calibrate_vcc(sfp, value); > + > + return 0; > +} > + > +static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value) > +{ > + int err; > + > + err = sfp_hwmon_read_sensor(sfp, reg, value); > + if (err < 0) > + return err; > + > + sfp_hwmon_calibrate_bias(sfp, value); > + > + return 0; > +} > + > +static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value) > +{ > + int err; > + > + err = sfp_hwmon_read_sensor(sfp, reg, value); > + if (err < 0) > + return err; > + > + sfp_hwmon_calibrate_tx_power(sfp, value); > + > + return 0; > +} > + > +static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value) > +{ > + int err; > + > + err = sfp_hwmon_read_sensor(sfp, reg, value); > + if (err < 0) > + return err; > + > + sfp_hwmon_to_rx_power(value); > + > + return 0; > +} > + > +static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value) > +{ > + u8 status; > + int err; > + > + switch (attr) { > + case hwmon_temp_input: > + return sfp_hwmon_read_temp(sfp, SFP_TEMP, value); > + > + case hwmon_temp_lcrit: > + *value = be16_to_cpu(sfp->diag.temp_low_alarm); > + sfp_hwmon_calibrate_temp(sfp, value); > + return 0; > + > + case hwmon_temp_min: > + *value = be16_to_cpu(sfp->diag.temp_low_warn); > + sfp_hwmon_calibrate_temp(sfp, value); > + return 0; > + case hwmon_temp_max: > + *value = be16_to_cpu(sfp->diag.temp_high_warn); > + sfp_hwmon_calibrate_temp(sfp, value); > + return 0; > + > + case hwmon_temp_crit: > + *value = be16_to_cpu(sfp->diag.temp_high_alarm); > + sfp_hwmon_calibrate_temp(sfp, value); > + return 0; > + > + case hwmon_temp_lcrit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TEMP_LOW); > + return 0; > + > + case hwmon_temp_min_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TEMP_LOW); > + return 0; > + > + case hwmon_temp_max_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TEMP_HIGH); > + return 0; > + > + case hwmon_temp_crit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TEMP_HIGH); > + return 0; > + default: > + return -EOPNOTSUPP; > + } > + > + return -EOPNOTSUPP; > +} > + > +static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value) > +{ > + u8 status; > + int err; > + > + switch (attr) { > + case hwmon_in_input: > + return sfp_hwmon_read_vcc(sfp, SFP_VCC, value); > + > + case hwmon_in_lcrit: > + *value = be16_to_cpu(sfp->diag.volt_low_alarm); > + sfp_hwmon_calibrate_vcc(sfp, value); > + return 0; > + > + case hwmon_in_min: > + *value = be16_to_cpu(sfp->diag.volt_low_warn); > + sfp_hwmon_calibrate_vcc(sfp, value); > + return 0; > + > + case hwmon_in_max: > + *value = be16_to_cpu(sfp->diag.volt_high_warn); > + sfp_hwmon_calibrate_vcc(sfp, value); > + return 0; > + > + case hwmon_in_crit: > + *value = be16_to_cpu(sfp->diag.volt_high_alarm); > + sfp_hwmon_calibrate_vcc(sfp, value); > + return 0; > + > + case hwmon_in_lcrit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_VCC_LOW); > + return 0; > + > + case hwmon_in_min_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_VCC_LOW); > + return 0; > + > + case hwmon_in_max_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_VCC_HIGH); > + return 0; > + > + case hwmon_in_crit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_VCC_HIGH); > + return 0; > + default: > + return -EOPNOTSUPP; > + } > + > + return -EOPNOTSUPP; > +} > + > +static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value) > +{ > + u8 status; > + int err; > + > + switch (attr) { > + case hwmon_curr_input: > + return sfp_hwmon_read_bias(sfp, SFP_TX_BIAS, value); > + > + case hwmon_curr_lcrit: > + *value = be16_to_cpu(sfp->diag.bias_low_alarm); > + sfp_hwmon_calibrate_bias(sfp, value); > + return 0; > + > + case hwmon_curr_min: > + *value = be16_to_cpu(sfp->diag.bias_low_warn); > + sfp_hwmon_calibrate_bias(sfp, value); > + return 0; > + > + case hwmon_curr_max: > + *value = be16_to_cpu(sfp->diag.bias_high_warn); > + sfp_hwmon_calibrate_bias(sfp, value); > + return 0; > + > + case hwmon_curr_crit: > + *value = be16_to_cpu(sfp->diag.bias_high_alarm); > + sfp_hwmon_calibrate_bias(sfp, value); > + return 0; > + > + case hwmon_curr_lcrit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TX_BIAS_LOW); > + return 0; > + > + case hwmon_curr_min_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TX_BIAS_LOW); > + return 0; > + > + case hwmon_curr_max_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TX_BIAS_HIGH); > + return 0; > + > + case hwmon_curr_crit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TX_BIAS_HIGH); > + return 0; > + default: > + return -EOPNOTSUPP; > + } > + > + return -EOPNOTSUPP; > +} > + > +static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value) > +{ > + u8 status; > + int err; > + > + switch (attr) { > + case hwmon_power_input: > + return sfp_hwmon_read_tx_power(sfp, SFP_TX_POWER, value); > + > + case hwmon_power_lcrit: > + *value = be16_to_cpu(sfp->diag.txpwr_low_alarm); > + sfp_hwmon_calibrate_tx_power(sfp, value); > + return 0; > + > + case hwmon_power_min: > + *value = be16_to_cpu(sfp->diag.txpwr_low_warn); > + sfp_hwmon_calibrate_tx_power(sfp, value); > + return 0; > + > + case hwmon_power_max: > + *value = be16_to_cpu(sfp->diag.txpwr_high_warn); > + sfp_hwmon_calibrate_tx_power(sfp, value); > + return 0; > + > + case hwmon_power_crit: > + *value = be16_to_cpu(sfp->diag.txpwr_high_alarm); > + sfp_hwmon_calibrate_tx_power(sfp, value); > + return 0; > + > + case hwmon_power_lcrit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TXPWR_LOW); > + return 0; > + > + case hwmon_power_min_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TXPWR_LOW); > + return 0; > + > + case hwmon_power_max_alarm: > + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN0_TXPWR_HIGH); > + return 0; > + > + case hwmon_power_crit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM0_TXPWR_HIGH); > + return 0; > + default: > + return -EOPNOTSUPP; > + } > + > + return -EOPNOTSUPP; > +} > + > +static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value) > +{ > + u8 status; > + int err; > + > + switch (attr) { > + case hwmon_power_input: > + return sfp_hwmon_read_rx_power(sfp, SFP_RX_POWER, value); > + > + case hwmon_power_lcrit: > + *value = be16_to_cpu(sfp->diag.rxpwr_low_alarm); > + sfp_hwmon_to_rx_power(value); > + return 0; > + > + case hwmon_power_min: > + *value = be16_to_cpu(sfp->diag.rxpwr_low_warn); > + sfp_hwmon_to_rx_power(value); > + return 0; > + > + case hwmon_power_max: > + *value = be16_to_cpu(sfp->diag.rxpwr_high_warn); > + sfp_hwmon_to_rx_power(value); > + return 0; > + > + case hwmon_power_crit: > + *value = be16_to_cpu(sfp->diag.rxpwr_high_alarm); > + sfp_hwmon_to_rx_power(value); > + return 0; > + > + case hwmon_power_lcrit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM1_RXPWR_LOW); > + return 0; > + > + case hwmon_power_min_alarm: > + err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN1_RXPWR_LOW); > + return 0; > + > + case hwmon_power_max_alarm: > + err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_WARN1_RXPWR_HIGH); > + return 0; > + > + case hwmon_power_crit_alarm: > + err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); > + if (err < 0) > + return err; > + > + *value = !!(status & SFP_ALARM1_RXPWR_HIGH); > + return 0; > + default: > + return -EOPNOTSUPP; > + } > + > + return -EOPNOTSUPP; > +} > + > +static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type, > + u32 attr, int channel, long *value) > +{ > + struct sfp *sfp = dev_get_drvdata(dev); > + > + switch (type) { > + case hwmon_temp: > + return sfp_hwmon_temp(sfp, attr, value); > + case hwmon_in: > + return sfp_hwmon_vcc(sfp, attr, value); > + case hwmon_curr: > + return sfp_hwmon_bias(sfp, attr, value); > + case hwmon_power: > + switch (channel) { > + case 0: > + return sfp_hwmon_tx_power(sfp, attr, value); > + case 1: > + return sfp_hwmon_rx_power(sfp, attr, value); > + default: > + return -EOPNOTSUPP; > + } > + default: > + return -EOPNOTSUPP; > + } > +} > + > +static const struct hwmon_ops sfp_hwmon_ops = { > + .is_visible = sfp_hwmon_is_visible, > + .read = sfp_hwmon_read, > +}; > + > +static u32 sfp_hwmon_chip_config[] = { > + HWMON_C_REGISTER_TZ, > + 0, > +}; > + > +static const struct hwmon_channel_info sfp_hwmon_chip = { > + .type = hwmon_chip, > + .config = sfp_hwmon_chip_config, > +}; > + > +static u32 sfp_hwmon_temp_config[] = { > + HWMON_T_INPUT | > + HWMON_T_MAX | HWMON_T_MIN | > + HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM | > + HWMON_T_CRIT | HWMON_T_LCRIT | > + HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM, > + 0, > +}; > + > +static const struct hwmon_channel_info sfp_hwmon_temp_channel_info = { > + .type = hwmon_temp, > + .config = sfp_hwmon_temp_config, > +}; > + > +static u32 sfp_hwmon_vcc_config[] = { > + HWMON_I_INPUT | > + HWMON_I_MAX | HWMON_I_MIN | > + HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM | > + HWMON_I_CRIT | HWMON_I_LCRIT | > + HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM, > + 0, > +}; > + > +static const struct hwmon_channel_info sfp_hwmon_vcc_channel_info = { > + .type = hwmon_in, > + .config = sfp_hwmon_vcc_config, > +}; > + > +static u32 sfp_hwmon_bias_config[] = { > + HWMON_C_INPUT | > + HWMON_C_MAX | HWMON_C_MIN | > + HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM | > + HWMON_C_CRIT | HWMON_C_LCRIT | > + HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM, > + 0, > +}; > + > +static const struct hwmon_channel_info sfp_hwmon_bias_channel_info = { > + .type = hwmon_curr, > + .config = sfp_hwmon_bias_config, > +}; > + > +static u32 sfp_hwmon_power_config[] = { > + /* Transmit power */ > + HWMON_P_INPUT | > + HWMON_P_MAX | HWMON_P_MIN | > + HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | > + HWMON_P_CRIT | HWMON_P_LCRIT | > + HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, > + /* Receive power */ > + HWMON_P_INPUT | > + HWMON_P_MAX | HWMON_P_MIN | > + HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | > + HWMON_P_CRIT | HWMON_P_LCRIT | > + HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, > + 0, > +}; > + > +static const struct hwmon_channel_info sfp_hwmon_power_channel_info = { > + .type = hwmon_power, > + .config = sfp_hwmon_power_config, > +}; > + > +static const struct hwmon_channel_info *sfp_hwmon_info[] = { > + &sfp_hwmon_chip, > + &sfp_hwmon_vcc_channel_info, > + &sfp_hwmon_temp_channel_info, > + &sfp_hwmon_bias_channel_info, > + &sfp_hwmon_power_channel_info, > + NULL, > +}; > + > +static const struct hwmon_chip_info sfp_hwmon_chip_info = { > + .ops = &sfp_hwmon_ops, > + .info = sfp_hwmon_info, > +}; > + > +static int sfp_hwmon_insert(struct sfp *sfp) > +{ > + int err, i; > + > + if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE) > + return 0; > + > + if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM)) > + return 0; > + > + if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) > + /* This driver in general does not support address > + * change. > + */ > + return 0; > + > + err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag)); > + if (err < 0) > + return err; > + > + sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL); > + if (!sfp->hwmon_name) > + return -ENODEV; > + > + for (i = 0; sfp->hwmon_name[i]; i++) > + if (hwmon_is_bad_char(sfp->hwmon_name[i])) > + sfp->hwmon_name[i] = '_'; > + > + sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev, > + sfp->hwmon_name, sfp, > + &sfp_hwmon_chip_info, > + NULL); > + > + return PTR_ERR_OR_ZERO(sfp->hwmon_dev); > +} > + > +static void sfp_hwmon_remove(struct sfp *sfp) > +{ > + hwmon_device_unregister(sfp->hwmon_dev); > + kfree(sfp->hwmon_name); > +} > +#else > +static int sfp_hwmon_insert(struct sfp *sfp) > +{ > + return 0; > +} > + > +static void sfp_hwmon_remove(struct sfp *sfp) > +{ > +} > +#endif > + > /* Helpers */ > static void sfp_module_tx_disable(struct sfp *sfp) > { > @@ -636,6 +1357,10 @@ static int sfp_sm_mod_probe(struct sfp *sfp) > dev_warn(sfp->dev, > "module address swap to access page 0xA2 is not supported.\n"); > > + ret = sfp_hwmon_insert(sfp); > + if (ret < 0) > + return ret; > + > ret = sfp_module_insert(sfp->sfp_bus, &sfp->id); > if (ret < 0) > return ret; > @@ -647,6 +1372,8 @@ static void sfp_sm_mod_remove(struct sfp *sfp) > { > sfp_module_remove(sfp->sfp_bus); > > + sfp_hwmon_remove(sfp); > + > if (sfp->mod_phy) > sfp_sm_phy_detach(sfp); > > diff --git a/include/linux/sfp.h b/include/linux/sfp.h > index ebce9e24906a..d37518e89db2 100644 > --- a/include/linux/sfp.h > +++ b/include/linux/sfp.h > @@ -231,6 +231,50 @@ struct sfp_eeprom_id { > struct sfp_eeprom_ext ext; > } __packed; > > +struct sfp_diag { > + __be16 temp_high_alarm; > + __be16 temp_low_alarm; > + __be16 temp_high_warn; > + __be16 temp_low_warn; > + __be16 volt_high_alarm; > + __be16 volt_low_alarm; > + __be16 volt_high_warn; > + __be16 volt_low_warn; > + __be16 bias_high_alarm; > + __be16 bias_low_alarm; > + __be16 bias_high_warn; > + __be16 bias_low_warn; > + __be16 txpwr_high_alarm; > + __be16 txpwr_low_alarm; > + __be16 txpwr_high_warn; > + __be16 txpwr_low_warn; > + __be16 rxpwr_high_alarm; > + __be16 rxpwr_low_alarm; > + __be16 rxpwr_high_warn; > + __be16 rxpwr_low_warn; > + __be16 laser_temp_high_alarm; > + __be16 laser_temp_low_alarm; > + __be16 laser_temp_high_warn; > + __be16 laser_temp_low_warn; > + __be16 tec_cur_high_alarm; > + __be16 tec_cur_low_alarm; > + __be16 tec_cur_high_warn; > + __be16 tec_cur_low_warn; > + __be32 cal_rxpwr4; > + __be32 cal_rxpwr3; > + __be32 cal_rxpwr2; > + __be32 cal_rxpwr1; > + __be32 cal_rxpwr0; > + __be16 cal_txi_slope; > + __be16 cal_txi_offset; > + __be16 cal_txpwr_slope; > + __be16 cal_txpwr_offset; > + __be16 cal_t_slope; > + __be16 cal_t_offset; > + __be16 cal_v_slope; > + __be16 cal_v_offset; > +} __packed; > + > /* SFP EEPROM registers */ > enum { > SFP_PHYS_ID = 0x00, > @@ -384,7 +428,33 @@ enum { > SFP_TEC_CUR = 0x6c, > > SFP_STATUS = 0x6e, > - SFP_ALARM = 0x70, > + SFP_ALARM0 = 0x70, > + SFP_ALARM0_TEMP_HIGH = BIT(7), > + SFP_ALARM0_TEMP_LOW = BIT(6), > + SFP_ALARM0_VCC_HIGH = BIT(5), > + SFP_ALARM0_VCC_LOW = BIT(4), > + SFP_ALARM0_TX_BIAS_HIGH = BIT(3), > + SFP_ALARM0_TX_BIAS_LOW = BIT(2), > + SFP_ALARM0_TXPWR_HIGH = BIT(1), > + SFP_ALARM0_TXPWR_LOW = BIT(0), > + > + SFP_ALARM1 = 0x71, > + SFP_ALARM1_RXPWR_HIGH = BIT(7), > + SFP_ALARM1_RXPWR_LOW = BIT(6), > + > + SFP_WARN0 = 0x74, > + SFP_WARN0_TEMP_HIGH = BIT(7), > + SFP_WARN0_TEMP_LOW = BIT(6), > + SFP_WARN0_VCC_HIGH = BIT(5), > + SFP_WARN0_VCC_LOW = BIT(4), > + SFP_WARN0_TX_BIAS_HIGH = BIT(3), > + SFP_WARN0_TX_BIAS_LOW = BIT(2), > + SFP_WARN0_TXPWR_HIGH = BIT(1), > + SFP_WARN0_TXPWR_LOW = BIT(0), > + > + SFP_WARN1 = 0x75, > + SFP_WARN1_RXPWR_HIGH = BIT(7), > + SFP_WARN1_RXPWR_LOW = BIT(6), > > SFP_EXT_STATUS = 0x76, > SFP_VSL = 0x78, > -- > 2.18.0 > -- To unsubscribe from this list: send the line "unsubscribe linux-hwmon" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/drivers/net/phy/Kconfig b/drivers/net/phy/Kconfig index 7761536974bf..f31ae4faf4e5 100644 --- a/drivers/net/phy/Kconfig +++ b/drivers/net/phy/Kconfig @@ -215,6 +215,7 @@ config SFP tristate "SFP cage support" depends on I2C select MDIO_I2C + imply HWMON config AMD_PHY tristate "AMD PHYs" diff --git a/drivers/net/phy/sfp.c b/drivers/net/phy/sfp.c index c4c92db86dfa..5661226cf75b 100644 --- a/drivers/net/phy/sfp.c +++ b/drivers/net/phy/sfp.c @@ -1,5 +1,7 @@ +#include <linux/ctype.h> #include <linux/delay.h> #include <linux/gpio/consumer.h> +#include <linux/hwmon.h> #include <linux/i2c.h> #include <linux/interrupt.h> #include <linux/jiffies.h> @@ -131,6 +133,12 @@ struct sfp { unsigned int sm_retries; struct sfp_eeprom_id id; +#if IS_ENABLED(CONFIG_HWMON) + struct sfp_diag diag; + struct device *hwmon_dev; + char *hwmon_name; +#endif + }; static bool sff_module_supported(const struct sfp_eeprom_id *id) @@ -316,6 +324,719 @@ static unsigned int sfp_check(void *buf, size_t len) return check; } +/* hwmon */ +#if IS_ENABLED(CONFIG_HWMON) +static umode_t sfp_hwmon_is_visible(const void *data, + enum hwmon_sensor_types type, + u32 attr, int channel) +{ + const struct sfp *sfp = data; + + switch (type) { + case hwmon_temp: + switch (attr) { + case hwmon_temp_input: + case hwmon_temp_min_alarm: + case hwmon_temp_max_alarm: + case hwmon_temp_lcrit_alarm: + case hwmon_temp_crit_alarm: + case hwmon_temp_min: + case hwmon_temp_max: + case hwmon_temp_lcrit: + case hwmon_temp_crit: + return 0444; + default: + return 0; + } + case hwmon_in: + switch (attr) { + case hwmon_in_input: + case hwmon_in_min_alarm: + case hwmon_in_max_alarm: + case hwmon_in_lcrit_alarm: + case hwmon_in_crit_alarm: + case hwmon_in_min: + case hwmon_in_max: + case hwmon_in_lcrit: + case hwmon_in_crit: + return 0444; + default: + return 0; + } + case hwmon_curr: + switch (attr) { + case hwmon_curr_input: + case hwmon_curr_min_alarm: + case hwmon_curr_max_alarm: + case hwmon_curr_lcrit_alarm: + case hwmon_curr_crit_alarm: + case hwmon_curr_min: + case hwmon_curr_max: + case hwmon_curr_lcrit: + case hwmon_curr_crit: + return 0444; + default: + return 0; + } + case hwmon_power: + /* External calibration of receive power requires + * floating point arithmetic. Doing that in the kernel + * is not easy, so just skip it. If the module does + * not require external calibration, we can however + * show receiver power, since FP is then not needed. + */ + if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL && + channel == 1) + return 0; + switch (attr) { + case hwmon_power_input: + case hwmon_power_min_alarm: + case hwmon_power_max_alarm: + case hwmon_power_lcrit_alarm: + case hwmon_power_crit_alarm: + case hwmon_power_min: + case hwmon_power_max: + case hwmon_power_lcrit: + case hwmon_power_crit: + return 0444; + default: + return 0; + } + default: + return 0; + } +} + +static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value) +{ + __be16 val; + int err; + + err = sfp_read(sfp, true, reg, &val, sizeof(val)); + if (err < 0) + return err; + + *value = be16_to_cpu(val); + + return 0; +} + +static void sfp_hwmon_to_rx_power(long *value) +{ + *value = DIV_ROUND_CLOSEST(*value, 100); +} + +static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset, + long *value) +{ + if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL) + *value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset; +} + +static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value) +{ + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope), + be16_to_cpu(sfp->diag.cal_t_offset), value); + + if (*value >= 0x8000) + *value -= 0x10000; + + *value = DIV_ROUND_CLOSEST(*value * 1000, 256); +} + +static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value) +{ + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope), + be16_to_cpu(sfp->diag.cal_v_offset), value); + + *value = DIV_ROUND_CLOSEST(*value, 10); +} + +static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value) +{ + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope), + be16_to_cpu(sfp->diag.cal_txi_offset), value); + + *value = DIV_ROUND_CLOSEST(*value, 500); +} + +static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value) +{ + sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope), + be16_to_cpu(sfp->diag.cal_txpwr_offset), value); + + *value = DIV_ROUND_CLOSEST(*value, 10); +} + +static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value) +{ + int err; + + err = sfp_hwmon_read_sensor(sfp, reg, value); + if (err < 0) + return err; + + sfp_hwmon_calibrate_temp(sfp, value); + + return 0; +} + +static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value) +{ + int err; + + err = sfp_hwmon_read_sensor(sfp, reg, value); + if (err < 0) + return err; + + sfp_hwmon_calibrate_vcc(sfp, value); + + return 0; +} + +static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value) +{ + int err; + + err = sfp_hwmon_read_sensor(sfp, reg, value); + if (err < 0) + return err; + + sfp_hwmon_calibrate_bias(sfp, value); + + return 0; +} + +static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value) +{ + int err; + + err = sfp_hwmon_read_sensor(sfp, reg, value); + if (err < 0) + return err; + + sfp_hwmon_calibrate_tx_power(sfp, value); + + return 0; +} + +static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value) +{ + int err; + + err = sfp_hwmon_read_sensor(sfp, reg, value); + if (err < 0) + return err; + + sfp_hwmon_to_rx_power(value); + + return 0; +} + +static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value) +{ + u8 status; + int err; + + switch (attr) { + case hwmon_temp_input: + return sfp_hwmon_read_temp(sfp, SFP_TEMP, value); + + case hwmon_temp_lcrit: + *value = be16_to_cpu(sfp->diag.temp_low_alarm); + sfp_hwmon_calibrate_temp(sfp, value); + return 0; + + case hwmon_temp_min: + *value = be16_to_cpu(sfp->diag.temp_low_warn); + sfp_hwmon_calibrate_temp(sfp, value); + return 0; + case hwmon_temp_max: + *value = be16_to_cpu(sfp->diag.temp_high_warn); + sfp_hwmon_calibrate_temp(sfp, value); + return 0; + + case hwmon_temp_crit: + *value = be16_to_cpu(sfp->diag.temp_high_alarm); + sfp_hwmon_calibrate_temp(sfp, value); + return 0; + + case hwmon_temp_lcrit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TEMP_LOW); + return 0; + + case hwmon_temp_min_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TEMP_LOW); + return 0; + + case hwmon_temp_max_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TEMP_HIGH); + return 0; + + case hwmon_temp_crit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TEMP_HIGH); + return 0; + default: + return -EOPNOTSUPP; + } + + return -EOPNOTSUPP; +} + +static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value) +{ + u8 status; + int err; + + switch (attr) { + case hwmon_in_input: + return sfp_hwmon_read_vcc(sfp, SFP_VCC, value); + + case hwmon_in_lcrit: + *value = be16_to_cpu(sfp->diag.volt_low_alarm); + sfp_hwmon_calibrate_vcc(sfp, value); + return 0; + + case hwmon_in_min: + *value = be16_to_cpu(sfp->diag.volt_low_warn); + sfp_hwmon_calibrate_vcc(sfp, value); + return 0; + + case hwmon_in_max: + *value = be16_to_cpu(sfp->diag.volt_high_warn); + sfp_hwmon_calibrate_vcc(sfp, value); + return 0; + + case hwmon_in_crit: + *value = be16_to_cpu(sfp->diag.volt_high_alarm); + sfp_hwmon_calibrate_vcc(sfp, value); + return 0; + + case hwmon_in_lcrit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_VCC_LOW); + return 0; + + case hwmon_in_min_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_VCC_LOW); + return 0; + + case hwmon_in_max_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_VCC_HIGH); + return 0; + + case hwmon_in_crit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_VCC_HIGH); + return 0; + default: + return -EOPNOTSUPP; + } + + return -EOPNOTSUPP; +} + +static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value) +{ + u8 status; + int err; + + switch (attr) { + case hwmon_curr_input: + return sfp_hwmon_read_bias(sfp, SFP_TX_BIAS, value); + + case hwmon_curr_lcrit: + *value = be16_to_cpu(sfp->diag.bias_low_alarm); + sfp_hwmon_calibrate_bias(sfp, value); + return 0; + + case hwmon_curr_min: + *value = be16_to_cpu(sfp->diag.bias_low_warn); + sfp_hwmon_calibrate_bias(sfp, value); + return 0; + + case hwmon_curr_max: + *value = be16_to_cpu(sfp->diag.bias_high_warn); + sfp_hwmon_calibrate_bias(sfp, value); + return 0; + + case hwmon_curr_crit: + *value = be16_to_cpu(sfp->diag.bias_high_alarm); + sfp_hwmon_calibrate_bias(sfp, value); + return 0; + + case hwmon_curr_lcrit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TX_BIAS_LOW); + return 0; + + case hwmon_curr_min_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TX_BIAS_LOW); + return 0; + + case hwmon_curr_max_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TX_BIAS_HIGH); + return 0; + + case hwmon_curr_crit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TX_BIAS_HIGH); + return 0; + default: + return -EOPNOTSUPP; + } + + return -EOPNOTSUPP; +} + +static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value) +{ + u8 status; + int err; + + switch (attr) { + case hwmon_power_input: + return sfp_hwmon_read_tx_power(sfp, SFP_TX_POWER, value); + + case hwmon_power_lcrit: + *value = be16_to_cpu(sfp->diag.txpwr_low_alarm); + sfp_hwmon_calibrate_tx_power(sfp, value); + return 0; + + case hwmon_power_min: + *value = be16_to_cpu(sfp->diag.txpwr_low_warn); + sfp_hwmon_calibrate_tx_power(sfp, value); + return 0; + + case hwmon_power_max: + *value = be16_to_cpu(sfp->diag.txpwr_high_warn); + sfp_hwmon_calibrate_tx_power(sfp, value); + return 0; + + case hwmon_power_crit: + *value = be16_to_cpu(sfp->diag.txpwr_high_alarm); + sfp_hwmon_calibrate_tx_power(sfp, value); + return 0; + + case hwmon_power_lcrit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TXPWR_LOW); + return 0; + + case hwmon_power_min_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TXPWR_LOW); + return 0; + + case hwmon_power_max_alarm: + err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN0_TXPWR_HIGH); + return 0; + + case hwmon_power_crit_alarm: + err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM0_TXPWR_HIGH); + return 0; + default: + return -EOPNOTSUPP; + } + + return -EOPNOTSUPP; +} + +static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value) +{ + u8 status; + int err; + + switch (attr) { + case hwmon_power_input: + return sfp_hwmon_read_rx_power(sfp, SFP_RX_POWER, value); + + case hwmon_power_lcrit: + *value = be16_to_cpu(sfp->diag.rxpwr_low_alarm); + sfp_hwmon_to_rx_power(value); + return 0; + + case hwmon_power_min: + *value = be16_to_cpu(sfp->diag.rxpwr_low_warn); + sfp_hwmon_to_rx_power(value); + return 0; + + case hwmon_power_max: + *value = be16_to_cpu(sfp->diag.rxpwr_high_warn); + sfp_hwmon_to_rx_power(value); + return 0; + + case hwmon_power_crit: + *value = be16_to_cpu(sfp->diag.rxpwr_high_alarm); + sfp_hwmon_to_rx_power(value); + return 0; + + case hwmon_power_lcrit_alarm: + err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM1_RXPWR_LOW); + return 0; + + case hwmon_power_min_alarm: + err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN1_RXPWR_LOW); + return 0; + + case hwmon_power_max_alarm: + err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_WARN1_RXPWR_HIGH); + return 0; + + case hwmon_power_crit_alarm: + err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status)); + if (err < 0) + return err; + + *value = !!(status & SFP_ALARM1_RXPWR_HIGH); + return 0; + default: + return -EOPNOTSUPP; + } + + return -EOPNOTSUPP; +} + +static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, long *value) +{ + struct sfp *sfp = dev_get_drvdata(dev); + + switch (type) { + case hwmon_temp: + return sfp_hwmon_temp(sfp, attr, value); + case hwmon_in: + return sfp_hwmon_vcc(sfp, attr, value); + case hwmon_curr: + return sfp_hwmon_bias(sfp, attr, value); + case hwmon_power: + switch (channel) { + case 0: + return sfp_hwmon_tx_power(sfp, attr, value); + case 1: + return sfp_hwmon_rx_power(sfp, attr, value); + default: + return -EOPNOTSUPP; + } + default: + return -EOPNOTSUPP; + } +} + +static const struct hwmon_ops sfp_hwmon_ops = { + .is_visible = sfp_hwmon_is_visible, + .read = sfp_hwmon_read, +}; + +static u32 sfp_hwmon_chip_config[] = { + HWMON_C_REGISTER_TZ, + 0, +}; + +static const struct hwmon_channel_info sfp_hwmon_chip = { + .type = hwmon_chip, + .config = sfp_hwmon_chip_config, +}; + +static u32 sfp_hwmon_temp_config[] = { + HWMON_T_INPUT | + HWMON_T_MAX | HWMON_T_MIN | + HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM | + HWMON_T_CRIT | HWMON_T_LCRIT | + HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM, + 0, +}; + +static const struct hwmon_channel_info sfp_hwmon_temp_channel_info = { + .type = hwmon_temp, + .config = sfp_hwmon_temp_config, +}; + +static u32 sfp_hwmon_vcc_config[] = { + HWMON_I_INPUT | + HWMON_I_MAX | HWMON_I_MIN | + HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM | + HWMON_I_CRIT | HWMON_I_LCRIT | + HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM, + 0, +}; + +static const struct hwmon_channel_info sfp_hwmon_vcc_channel_info = { + .type = hwmon_in, + .config = sfp_hwmon_vcc_config, +}; + +static u32 sfp_hwmon_bias_config[] = { + HWMON_C_INPUT | + HWMON_C_MAX | HWMON_C_MIN | + HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM | + HWMON_C_CRIT | HWMON_C_LCRIT | + HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM, + 0, +}; + +static const struct hwmon_channel_info sfp_hwmon_bias_channel_info = { + .type = hwmon_curr, + .config = sfp_hwmon_bias_config, +}; + +static u32 sfp_hwmon_power_config[] = { + /* Transmit power */ + HWMON_P_INPUT | + HWMON_P_MAX | HWMON_P_MIN | + HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | + HWMON_P_CRIT | HWMON_P_LCRIT | + HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, + /* Receive power */ + HWMON_P_INPUT | + HWMON_P_MAX | HWMON_P_MIN | + HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM | + HWMON_P_CRIT | HWMON_P_LCRIT | + HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM, + 0, +}; + +static const struct hwmon_channel_info sfp_hwmon_power_channel_info = { + .type = hwmon_power, + .config = sfp_hwmon_power_config, +}; + +static const struct hwmon_channel_info *sfp_hwmon_info[] = { + &sfp_hwmon_chip, + &sfp_hwmon_vcc_channel_info, + &sfp_hwmon_temp_channel_info, + &sfp_hwmon_bias_channel_info, + &sfp_hwmon_power_channel_info, + NULL, +}; + +static const struct hwmon_chip_info sfp_hwmon_chip_info = { + .ops = &sfp_hwmon_ops, + .info = sfp_hwmon_info, +}; + +static int sfp_hwmon_insert(struct sfp *sfp) +{ + int err, i; + + if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE) + return 0; + + if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM)) + return 0; + + if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) + /* This driver in general does not support address + * change. + */ + return 0; + + err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag)); + if (err < 0) + return err; + + sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL); + if (!sfp->hwmon_name) + return -ENODEV; + + for (i = 0; sfp->hwmon_name[i]; i++) + if (hwmon_is_bad_char(sfp->hwmon_name[i])) + sfp->hwmon_name[i] = '_'; + + sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev, + sfp->hwmon_name, sfp, + &sfp_hwmon_chip_info, + NULL); + + return PTR_ERR_OR_ZERO(sfp->hwmon_dev); +} + +static void sfp_hwmon_remove(struct sfp *sfp) +{ + hwmon_device_unregister(sfp->hwmon_dev); + kfree(sfp->hwmon_name); +} +#else +static int sfp_hwmon_insert(struct sfp *sfp) +{ + return 0; +} + +static void sfp_hwmon_remove(struct sfp *sfp) +{ +} +#endif + /* Helpers */ static void sfp_module_tx_disable(struct sfp *sfp) { @@ -636,6 +1357,10 @@ static int sfp_sm_mod_probe(struct sfp *sfp) dev_warn(sfp->dev, "module address swap to access page 0xA2 is not supported.\n"); + ret = sfp_hwmon_insert(sfp); + if (ret < 0) + return ret; + ret = sfp_module_insert(sfp->sfp_bus, &sfp->id); if (ret < 0) return ret; @@ -647,6 +1372,8 @@ static void sfp_sm_mod_remove(struct sfp *sfp) { sfp_module_remove(sfp->sfp_bus); + sfp_hwmon_remove(sfp); + if (sfp->mod_phy) sfp_sm_phy_detach(sfp); diff --git a/include/linux/sfp.h b/include/linux/sfp.h index ebce9e24906a..d37518e89db2 100644 --- a/include/linux/sfp.h +++ b/include/linux/sfp.h @@ -231,6 +231,50 @@ struct sfp_eeprom_id { struct sfp_eeprom_ext ext; } __packed; +struct sfp_diag { + __be16 temp_high_alarm; + __be16 temp_low_alarm; + __be16 temp_high_warn; + __be16 temp_low_warn; + __be16 volt_high_alarm; + __be16 volt_low_alarm; + __be16 volt_high_warn; + __be16 volt_low_warn; + __be16 bias_high_alarm; + __be16 bias_low_alarm; + __be16 bias_high_warn; + __be16 bias_low_warn; + __be16 txpwr_high_alarm; + __be16 txpwr_low_alarm; + __be16 txpwr_high_warn; + __be16 txpwr_low_warn; + __be16 rxpwr_high_alarm; + __be16 rxpwr_low_alarm; + __be16 rxpwr_high_warn; + __be16 rxpwr_low_warn; + __be16 laser_temp_high_alarm; + __be16 laser_temp_low_alarm; + __be16 laser_temp_high_warn; + __be16 laser_temp_low_warn; + __be16 tec_cur_high_alarm; + __be16 tec_cur_low_alarm; + __be16 tec_cur_high_warn; + __be16 tec_cur_low_warn; + __be32 cal_rxpwr4; + __be32 cal_rxpwr3; + __be32 cal_rxpwr2; + __be32 cal_rxpwr1; + __be32 cal_rxpwr0; + __be16 cal_txi_slope; + __be16 cal_txi_offset; + __be16 cal_txpwr_slope; + __be16 cal_txpwr_offset; + __be16 cal_t_slope; + __be16 cal_t_offset; + __be16 cal_v_slope; + __be16 cal_v_offset; +} __packed; + /* SFP EEPROM registers */ enum { SFP_PHYS_ID = 0x00, @@ -384,7 +428,33 @@ enum { SFP_TEC_CUR = 0x6c, SFP_STATUS = 0x6e, - SFP_ALARM = 0x70, + SFP_ALARM0 = 0x70, + SFP_ALARM0_TEMP_HIGH = BIT(7), + SFP_ALARM0_TEMP_LOW = BIT(6), + SFP_ALARM0_VCC_HIGH = BIT(5), + SFP_ALARM0_VCC_LOW = BIT(4), + SFP_ALARM0_TX_BIAS_HIGH = BIT(3), + SFP_ALARM0_TX_BIAS_LOW = BIT(2), + SFP_ALARM0_TXPWR_HIGH = BIT(1), + SFP_ALARM0_TXPWR_LOW = BIT(0), + + SFP_ALARM1 = 0x71, + SFP_ALARM1_RXPWR_HIGH = BIT(7), + SFP_ALARM1_RXPWR_LOW = BIT(6), + + SFP_WARN0 = 0x74, + SFP_WARN0_TEMP_HIGH = BIT(7), + SFP_WARN0_TEMP_LOW = BIT(6), + SFP_WARN0_VCC_HIGH = BIT(5), + SFP_WARN0_VCC_LOW = BIT(4), + SFP_WARN0_TX_BIAS_HIGH = BIT(3), + SFP_WARN0_TX_BIAS_LOW = BIT(2), + SFP_WARN0_TXPWR_HIGH = BIT(1), + SFP_WARN0_TXPWR_LOW = BIT(0), + + SFP_WARN1 = 0x75, + SFP_WARN1_RXPWR_HIGH = BIT(7), + SFP_WARN1_RXPWR_LOW = BIT(6), SFP_EXT_STATUS = 0x76, SFP_VSL = 0x78,
SFP modules can contain a number of sensors. The EEPROM also contains recommended alarm and critical values for each sensor, and indications of if these have been exceeded. Export this information via HWMON. Currently temperature, VCC, bias current, transmit power, and possibly receiver power is supported. The sensors in the modules can either return calibrate or uncalibrated values. Uncalibrated values need to be manipulated, using coefficients provided in the SFP EEPROM. Uncalibrated receive power values require floating point maths in order to calibrate them. Performing this in the kernel is hard. So if the SFP module indicates it uses uncalibrated values, RX power is not made available. With this hwmon device, it is possible to view the sensor values using lm-sensors programs: in0: +3.29 V (crit min = +2.90 V, min = +3.00 V) (max = +3.60 V, crit max = +3.70 V) temp1: +33.0°C (low = -5.0°C, high = +80.0°C) (crit low = -10.0°C, crit = +85.0°C) power1: 1000.00 nW (max = 794.00 uW, min = 50.00 uW) ALARM (LCRIT) (lcrit = 40.00 uW, crit = 1000.00 uW) curr1: +0.00 A (crit min = +0.00 A, min = +0.00 A) ALARM (LCRIT, MIN) (max = +0.01 A, crit max = +0.01 A) The scaling sensors performs on the bias current is not particularly good. The raw values are more useful: curr1: curr1_input: 0.000 curr1_min: 0.002 curr1_max: 0.010 curr1_lcrit: 0.000 curr1_crit: 0.011 curr1_min_alarm: 1.000 curr1_max_alarm: 0.000 curr1_lcrit_alarm: 1.000 curr1_crit_alarm: 0.000 In order to keep the I2C overhead to a minimum, the constant values, such as limits and calibration coefficients are read once at module insertion time. Thus only reading *_input and *_alarm properties requires i2c read operations. Signed-off-by: Andrew Lunn <andrew@lunn.ch> --- RFC->V1 Use __be16 when reading sensor DIV_ROUND_CLOSEST() Don't use devm_hwmon_* to fix lifetime issues Replace invalid chars in hwmon name with _ --- drivers/net/phy/Kconfig | 1 + drivers/net/phy/sfp.c | 727 ++++++++++++++++++++++++++++++++++++++++ include/linux/sfp.h | 72 +++- 3 files changed, 799 insertions(+), 1 deletion(-)