hwmon: (nct7802) buggy VSEN1/2/3 alarm
Hi Guenter,
According to the NCT7802Y datasheet, the REG_VOLTAGE_LIMIT_LSB definition is wrong and leads to wrong threshold registers used. It should be :
static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = {
{ 0x46, 0x00, 0x40, 0x42, 0x44 },
{ 0x45, 0x00, 0x3f, 0x41, 0x43 },
};With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
Best regards
Gilles BULOZ
Senior software(/hardware) engineer | R&D
Kontron Modular Computers S.A.S.
Guenter Roeck
maintainerQuoted 10 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Good catch. Care to send a patch ?
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Guenter
Quoted 12 lines · Guenter Roeck
Quoted 10 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache would be better. I suggest this :
- have a cached value for each status register, by default at 0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial line and output is slower) and to deal with possible latencies, but not too long...
Quoted 4 lines
Guenter
.
Guenter Roeck
maintainerQuoted 13 lines · Gilles Buloz
Quoted 12 lines · Guenter Roeck
Quoted 10 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
Quoted 9 lines
Quoted 3 lines
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 2 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial line and output is slower) and to deal with possible latencies, but not too long...
The timeout would be determined by the chip's conversion rate (register 0x26), or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 14 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
Quoted 9 lines
Quoted 3 lines
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.
Quoted 7 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 2 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial line and output is slower) and to deal with possible latencies, but not too long...
The timeout would be determined by the chip's conversion rate (register
0x26),
As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 7 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
.
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others. For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15 -2
@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */
@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,
@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }
Quoted 54 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 7 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 2 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial line and output is slower) and to deal with possible latencies, but not too long...
The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 7 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
.
Guenter Roeck
maintainerQuoted 7 lines · Gilles Buloz
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others. For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.
Yes, that is the expected behavior.
Guenter
Quoted 103 lines
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }Quoted 54 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 7 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 2 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial line and output is slower) and to deal with possible latencies, but not too long...
The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 7 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
.
OK, so to have "ALARM" reported as long as we are outside limits, I did not find another method than checking against limits by software, but still clear the related status register to have a working interrupt.
The patch below is working for voltages.
If you're OK, I can extend it to the temperatures and fans
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +32 -6
@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
@@ -377,6 +377,32 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret; + unsigned int val; + + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0) + return min; + max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + /* also clear related status register to have functional interrupt */ + ret = regmap_read(data->regmap, sattr->index, &val); + if (ret < 0) + return ret; + + return sprintf(buf, "%u\n", (volt < min) || (volt > max)); +} + static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) {
@@ -714,7 +740,7 @@ 0, 1); static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 0, 2); -static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); +static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_in_alarm, NULL, 0, 0x1e); static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 3);
@@ -725,7 +751,7 @@ 2, 1); static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 2, 2); -static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); +static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_in_alarm, NULL, 2, 0x1e); static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 0);
@@ -734,7 +760,7 @@ 3, 1); static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 3, 2); -static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); +static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_in_alarm, NULL, 3, 0x1e); static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 1);
@@ -743,7 +769,7 @@ 4, 1); static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 4, 2); -static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); +static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_in_alarm, NULL, 4, 0x1e); static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 2);
Quoted 121 lines · Guenter Roeck
Quoted 8 lines · Gilles Buloz
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others.
For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.Yes, that is the expected behavior.
Guenter
Quoted 95 lines
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }Quoted 47 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 8 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 3 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial
line and output is slower) and to deal with possible latencies, but not too long...The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 9 lines
Quoted 8 lines
Quoted 7 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
..
Guenter Roeck
maintainerQuoted 35 lines · Gilles Buloz
OK, so to have "ALARM" reported as long as we are outside limits, I did not find another method than checking against limits by software, but still clear the related status register to have a working interrupt.
The patch below is working for voltages.
If you're OK, I can extend it to the temperatures and fansnct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -377,6 +377,32 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret; + unsigned int val; + + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0)
nct7802.c 2019-11-26 17:27:56.000000000 +0100 line 402
Quoted 10 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +10
-0+ return min; + max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + /* also clear related status register to have functional interrupt */ + ret = regmap_read(data->regmap, sattr->index, &val); + if (ret < 0) + return ret; +
According to the datasheet, the status register bits should be set while voltages are out of range. Are you sure that this is not the case ?
The next question is how the status registers behave. If the bits are set whenever voltages cross a limit, we could use that knowledge and compare voltages against limits only after a status register bit was set. Something like
if (status register bit is set) {
alarm = (voltage is out of range);
cache alarm;
}
print alarm;Thanks,
Guenter
Quoted 165 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +7
-4+ return sprintf(buf, "%u\n", (volt < min) || (volt > max)); +} + static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) {@@ -714,7 +740,7 @@ 0, 1); static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 0, 2); -static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); +static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_in_alarm, NULL, 0, 0x1e); static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 3);@@ -725,7 +751,7 @@ 2, 1); static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 2, 2); -static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); +static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_in_alarm, NULL, 2, 0x1e); static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 0);@@ -734,7 +760,7 @@ 3, 1); static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 3, 2); -static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); +static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_in_alarm, NULL, 3, 0x1e); static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 1);@@ -743,7 +769,7 @@ 4, 1); static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 4, 2); -static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); +static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_in_alarm, NULL, 4, 0x1e); static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 2);Quoted 121 lines · Guenter Roeck
Quoted 8 lines · Gilles Buloz
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others.
For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.Yes, that is the expected behavior.
Guenter
Quoted 95 lines
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }Quoted 47 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 8 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 3 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial
line and output is slower) and to deal with possible latencies, but not too long...The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 9 lines
Quoted 8 lines
Quoted 7 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Guenter
..
Quoted 40 lines · Guenter Roeck
Quoted 39 lines · Gilles Buloz
OK, so to have "ALARM" reported as long as we are outside limits, I did not find another method than checking against limits by software, but still clear the related status register to have a working interrupt.
The patch below is working for voltages.
If you're OK, I can extend it to the temperatures and fansnct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +19
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -377,6 +377,32 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret; + unsigned int val; + + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0) + return min; + max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max;
Quoted 8 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 line 402
Quoted 6 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +6
-0+ + /* also clear related status register to have functional interrupt */ + ret = regmap_read(data->regmap, sattr->index, &val); + if (ret < 0) + return ret; +According to the datasheet, the status register bits should be set while voltages are out of range. Are you sure that this is not the case ?
Yes you are right, except for Voltages for which we only have the "SMI Voltage status" @1E to get a status, and as this is an SMI status register it does not work as simple non-SMI status registers.
So the good nexs is that there's nothing to fix for temperatures and fans because the driver is only using the non-SMI status registers for them, and they have their bits set as long as we are out of range (not cleared by read).
Quoted 4 lines
The next question is how the status registers behave. If the bits are set whenever voltages cross a limit, we could use that knowledge and compare voltages against limits only after a status register bit was set. Something like
Quoted 8 lines
if (status register bit is set) { alarm = (voltage is out of range); cache alarm; } print alarm;Thanks,
Guenter
Good idea, I'm going to work on it and make sure there's no risk to miss a transition and then have a staled status.
Quoted 163 lines
Quoted 156 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +7
-4+ return sprintf(buf, "%u\n", (volt < min) || (volt > max)); +} + static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) {@@ -714,7 +740,7 @@ 0, 1); static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 0, 2); -static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); +static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_in_alarm, NULL, 0, 0x1e); static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 3);@@ -725,7 +751,7 @@ 2, 1); static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 2, 2); -static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); +static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_in_alarm, NULL, 2, 0x1e); static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 0);@@ -734,7 +760,7 @@ 3, 1); static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 3, 2); -static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); +static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_in_alarm, NULL, 3, 0x1e); static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 1);@@ -743,7 +769,7 @@ 4, 1); static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 4, 2); -static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); +static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_in_alarm, NULL, 4, 0x1e); static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 2);Quoted 112 lines · Guenter Roeck
Quoted 8 lines · Gilles Buloz
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others.
For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.Yes, that is the expected behavior.
Guenter
Quoted 99 lines
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }Quoted 51 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 8 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 3 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial
line and output is slower) and to deal with possible latencies, but not too long...The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 4 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Quoted 5 lines
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Guenter
..
.
According to your suggestions, I've made and tested this patch that works :
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +57 -6
@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
@@ -67,6 +67,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 in_status_cache; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,
@@ -377,6 +378,56 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret, i; + unsigned int val; + + /* + * The SMI Voltage statys register is the only register giving a status + * for volatges. A bit is set for each input crossing a threshold, in + * both direction, but the "inside" or "outside" limits info is not + * available. Also this register is cleared on read. + * To deal with this we use a status cache with one validity bit and + * one status bit for each input. Validity is cleared at startup and + * each time the register reports a change, and the status is processed + * by software based on current value and limits. + */ + ret = regmap_read(data->regmap, 0x1E, &val); /* SMI Voltage status */ + if (ret < 0) + return ret; + + /* if status of an input has changed, invalidate its cached status */ + for (i=0; i<=3; i++) + if (val & (1 << i)) + data->in_status_cache &= ~(0x10 << i); + + /* if cached status for requested input is invalid, update it */ + if (!(data->in_status_cache & (0x10 << sattr->index))) { + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0) + return min; + max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + if ((volt < min) || (volt > max)) + data->in_status_cache |= (1 << sattr->index); + else + data->in_status_cache &= ~(1 << sattr->index); + + data->in_status_cache |= 0x10 << sattr->index; + } + + return sprintf(buf, "%u\n", !!(data->in_status_cache & (1 << sattr->index))); +} + static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) {
@@ -714,7 +765,7 @@ 0, 1); static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 0, 2); -static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); +static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_in_alarm, NULL, 0, 3); static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 3);
@@ -725,7 +776,7 @@ 2, 1); static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 2, 2); -static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); +static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_in_alarm, NULL, 2, 0); static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 0);
@@ -734,7 +785,7 @@ 3, 1); static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 3, 2); -static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); +static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_in_alarm, NULL, 3, 1); static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 1);
@@ -743,7 +794,7 @@ 4, 1); static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 4, 2); -static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); +static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_in_alarm, NULL, 4, 2); static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 2);
Quoted 225 lines · Guenter Roeck
Quoted 35 lines · Gilles Buloz
OK, so to have "ALARM" reported as long as we are outside limits, I did not find another method than checking against limits by software, but still clear the related status register to have a working interrupt.
The patch below is working for voltages.
If you're OK, I can extend it to the temperatures and fansnct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -377,6 +377,32 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret; + unsigned int val; + + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0)nct7802.c 2019-11-26 17:27:56.000000000 +0100 line 402
Quoted 10 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +10
-0+ return min; + max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + /* also clear related status register to have functional interrupt */ + ret = regmap_read(data->regmap, sattr->index, &val); + if (ret < 0) + return ret; +According to the datasheet, the status register bits should be set while voltages are out of range. Are you sure that this is not the case ?
The next question is how the status registers behave. If the bits are set whenever voltages cross a limit, we could use that knowledge and compare voltages against limits only after a status register bit was set. Something like
if (status register bit is set) { alarm = (voltage is out of range); cache alarm; } print alarm;Thanks,
GuenterQuoted 156 lines
nct7802.c 2019-11-26 17:27:56.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +7
-4+ return sprintf(buf, "%u\n", (volt < min) || (volt > max)); +} + static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) {@@ -714,7 +740,7 @@ 0, 1); static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_in, store_in, 0, 2); -static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 3); +static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_in_alarm, NULL, 0, 0x1e); static SENSOR_DEVICE_ATTR_2(in0_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 3);@@ -725,7 +751,7 @@ 2, 1); static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_in, store_in, 2, 2); -static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 0); +static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_in_alarm, NULL, 2, 0x1e); static SENSOR_DEVICE_ATTR_2(in2_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 0);@@ -734,7 +760,7 @@ 3, 1); static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_in, store_in, 3, 2); -static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 1); +static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_in_alarm, NULL, 3, 0x1e); static SENSOR_DEVICE_ATTR_2(in3_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 1);@@ -743,7 +769,7 @@ 4, 1); static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_in, store_in, 4, 2); -static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_alarm, NULL, 0x1e, 2); +static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_in_alarm, NULL, 4, 0x1e); static SENSOR_DEVICE_ATTR_2(in4_beep, S_IRUGO | S_IWUSR, show_beep, store_beep, 0x5a, 2);Quoted 112 lines · Guenter Roeck
Quoted 8 lines · Gilles Buloz
I have a functional patch (see below), but before going further (split and cleanup), I would like to have your opinion on how the NCT7802Y handles the thresholds status.
Except for temperatures and in "comparator interrupt mode", the status bits are NOT set after each ADC conversion, but only once when crossing a threshold. So an alarm for a threshold is reported only to the first process reading the status and not to the others.
For instance if you run "sensors" you only get "ALARM" once the nothing until the threshold is crossed again in the other direction. Maybe the expected behaviour would be to display "ALARM" as long as we are outside the thresholds, not only once.Yes, that is the expected behavior.
Guenter
Quoted 99 lines
nct7802.c 2019-11-25 23:22:00.905387154 +0100 renamed from nct7802.c.orig 2019-11-25 22:17:04.845718422 +0100 +15
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -60,6 +60,9 @@ #define REG_CHIP_ID 0xfe #define REG_VERSION_ID 0xff +#define REG_CACHE_START 0x17 +#define REG_CACHE_END 0x20 + /* * Data structures and manipulation thereof */@@ -67,6 +70,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 reg_cache[REG_CACHE_END - REG_CACHE_START + 1]; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -467,6 +471,15 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, if (ret < 0) return ret; + /* + * For registers cleared on read, use a cache to keep all bits + * that are set until they are returned to the caller + */ + if ((sattr->nr >= REG_CACHE_START) && (sattr->nr <= REG_CACHE_END)) { + val |= data->reg_cache[sattr->nr - REG_CACHE_START]; + data->reg_cache[sattr->nr - REG_CACHE_START] = val & ~(1 << bit); + } + return sprintf(buf, "%u\n", !!(val & (1 << bit))); }Quoted 51 lines · Gilles BULOZ
Quoted 15 lines · Guenter Roeck
Quoted 14 lines · Gilles Buloz
Quoted 13 lines · Guenter Roeck
Quoted 12 lines · Gilles Buloz
Hi Guenter,
According to the NCT7802Y datasheet, the
REG_VOLTAGE_LIMIT_LSBdefinition is wrong and leads to wrong threshold registers used. It
should be :static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { { 0x46, 0x00, 0x40, 0x42, 0x44 }, { 0x45, 0x00, 0x3f, 0x41, 0x43 }, };With this definition, the right bit is set in "Voltage SMI Status Register @0x1e" for each threshold reached (using i2cget to check)
Quoted 4 lines
Quoted 2 lines
Quoted 1 line
Good catch. Care to send a patch ?
As a fix for this is only useful with a fix for the problem below, maybe a single patch for both would be better.
Not really. Those are two separate issues. The reported and selected limits are wrong, period. This will require two patches.
OK
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
But I'm unable to get any "ALARM" reported by the command "sensors" for VSEN1/2/3 = in2,in3,in4 because status for in0 is read before (unless I set "ignore in0" in sensors file). The problem is that status bits in "Voltage SMI Status Register @0x1e" are cleared when reading, and a read is done for each inX processed, so only the first inX has a chance to get its alarm bit set. For this problem I don't see how to fix this easily; just to let you know ...
One possible fix would be to cache each alarm register and to clear the cache either after reading it (bitwise) or after a timeout. The latter is probably better to avoid stale information.
Quoted 7 lines
As we have status registers cleared at byte level and we want them to be cleared at bit level when each bit is read, I think a cache
would be better. I suggest this :
- have a cached value for each status register, by default at0x00
- when reading a register to get a bit, "OR" its byte value with its cached value, then use its cached value for processing.
- then clear the bit that has been processed from the cached value.Quoted 8 lines
Both methods I suggested would have to involve a cache. The question is when to clear the cache - either clear a bit after reporting it, or clear it after a timeout.
Quoted 3 lines
I think a timeout would not be obvious to set : at least the time for sensors to read all info (including when terminal is a serial
line and output is slower) and to deal with possible latencies, but not too long...The timeout would be determined by the chip's conversion rate (register
0x26),As I understand, the status must be kept in cache between the first read of status register @1E for in0 (clearing all status bits), and the last read for in4. This duration depends on the "sensors" execution time and I'can see any link with the conversion rate here.
Quoted 4 lines
or, for simplicity, just be set to one second. I don't immediately see why that would be difficult to implement. Not that it matters much, really; I would accept patches with and without timeout.
Quoted 5 lines
Quoted 5 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Guenter
..
.
Guenter Roeck
maintainerQuoted 30 lines · Gilles Buloz
According to your suggestions, I've made and tested this patch that works :
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +6
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -67,6 +67,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 in_status_cache; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -377,6 +378,56 @@ return err ? : count; } +static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 393
Quoted 10 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +10
-0+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret, i; + unsigned int val; + + /* + * The SMI Voltage statys register is the only register giving a status + * for volatges. A bit is set for each input crossing a threshold, in + * both direction, but the "inside" or "outside" limits info is not + * available. Also this register is cleared on read.
Might add a note that this is form experiment, and not explicitly spelled out in the datasheet.
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 399
Quoted 6 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +6
-0+ * To deal with this we use a status cache with one validity bit and + * one status bit for each input. Validity is cleared at startup and + * each time the register reports a change, and the status is processed + * by software based on current value and limits. + */ + ret = regmap_read(data->regmap, 0x1E, &val); /* SMI Voltage status */
We are using lowercase for hex numbers elsewhere in this driver, so please use lowercase here as well.
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 404
Quoted 5 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +5
-0+ if (ret < 0) + return ret; + + /* if status of an input has changed, invalidate its cached status */ + for (i=0; i<=3; i++)
Spaces before and after assignments, please.
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 415
Quoted 11 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +11
-0+ if (val & (1 << i)) + data->in_status_cache &= ~(0x10 << i); + + /* if cached status for requested input is invalid, update it */ + if (!(data->in_status_cache & (0x10 << sattr->index))) { + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0) + return min;
Do we need to check min ? The register description suggests "over limit". No idea though what the min limits are for in that case. Might be worth running some checks to understand this better (if you did not do that already).
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 420
Quoted 5 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +5
-0+ max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + if ((volt < min) || (volt > max))
Unnecessary inner ( )
Guenter
Please find the inlined patches according to your feedback. I've also fixed some typos and added a mutex_lock/unlock in in_alarm_show(). See also my replies to your questions in the previous mail below
From b663ac0dda5968ce7b43a55576639b5b28b2ebbb Mon Sep 17 00:00:00 2001
From: Gilles Buloz <[email protected]>
Date: Wed, 27 Nov 2019 18:09:34 +0100
Subject: [PATCH 1/2] hwmon: (nct7802) Fix voltage limits written to wrong
registers
in0 thresholds are written to the in2 thresholds registers in2 thresholds to in3 thresholds
in3 thresholds to in4 thresholds
in4 thresholds to in0 thresholds
--- drivers/hwmon/nct7802.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/hwmon/nct7802.c +2 -2
@@ -23,8 +23,8 @@static const u8 REG_VOLTAGE [5 ] = {0x09 ,0x0a ,0x0c ,0x0d ,0x0e };static const u8 REG_VOLTAGE_LIMIT_LSB [2 ][5 ] = { - {0x40 ,0x00 ,0x42 ,0x44 ,0x46 }, - {0x3f ,0x00 ,0x41 ,0x43 ,0x45 }, + {0x46 ,0x00 ,0x40 ,0x42 ,0x44 }, + {0x45 ,0x00 ,0x3f ,0x41 ,0x43 }, };static const u8 REG_VOLTAGE_LIMIT_MSB [5 ] = {0x48 ,0x00 ,0x47 ,0x47 ,0x48 };
Signature · 30 lines
2.17.1 From 24ac3207f7cfd0411aa47b0c48b5c657bc0daa48 Mon Sep 17 00:00:00 2001 From: Gilles Buloz <[email protected]> Date: Wed, 27 Nov 2019 19:20:41 +0100 Subject: [PATCH 2/2] hwmon: (nct7802) Fix non-working alarm on voltages No alarm is reported by /sys/.../inX_alarm In detail: The SMI Voltage status register is the only register giving a status for voltages, but it does not work like the non-SMI status registers used for temperatures and fans. A bit is set for each input crossing a threshold, in both direction, but the "inside" or "outside" limits info is not available. Also this register is cleared on read. Note : this is not explicitly spelled out in the datasheet, but from experiment. As a result if an input is crossing a threshold (min or max in any direction), the alarm is reported only once even if the input is still outside limits. Also if the alarm for another input is read before the one of this input, no alarm is reported at all. Signed-off-by: Gilles Buloz <[email protected]> --- drivers/hwmon/nct7802.c | 71 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 67 insertions(+), 4 deletions(-)
drivers/hwmon/nct7802.c +67 -4
111 lines not on this page · raw message
Signature · 1 line
2.17.1
Quoted 28 lines · Guenter Roeck
Quoted 27 lines · Gilles Buloz
According to your suggestions, I've made and tested this patch that works :
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +3
-2@@ -32,8 +32,8 @@ static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e }; static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = { - { 0x40, 0x00, 0x42, 0x44, 0x46 }, - { 0x3f, 0x00, 0x41, 0x43, 0x45 }, + { 0x46, 0x00, 0x40, 0x42, 0x44 }, + { 0x45, 0x00, 0x3f, 0x41, 0x43 }, }; static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };@@ -67,6 +67,7 @@ struct nct7802_data { struct regmap *regmap; struct mutex access_lock; /* for multi-byte read and write operations */ + u8 in_status_cache; }; static ssize_t show_temp_type(struct device *dev, struct device_attribute *attr,@@ -377,6 +378,56 @@ return err ? : count; }
Quoted 16 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 393
Quoted 13 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +13
-0+static ssize_t show_in_alarm(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); + struct nct7802_data *data = dev_get_drvdata(dev); + int volt, min, max, ret, i; + unsigned int val; + + /* + * The SMI Voltage statys register is the only register giving a status + * for volatges. A bit is set for each input crossing a threshold, in + * both direction, but the "inside" or "outside" limits info is not + * available. Also this register is cleared on read.Might add a note that this is form experiment, and not explicitly spelled out in the datasheet.
done
Quoted 10 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 399
Quoted 7 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +6
-0+ * To deal with this we use a status cache with one validity bit and + * one status bit for each input. Validity is cleared at startup and + * each time the register reports a change, and the status is processed + * by software based on current value and limits. + */ + ret = regmap_read(data->regmap, 0x1E, &val); /* SMI Voltage status */We are using lowercase for hex numbers elsewhere in this driver, so please use lowercase here as well.
done
Quoted 8 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 404
Quoted 6 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +5
-0+ if (ret < 0) + return ret; + + /* if status of an input has changed, invalidate its cached status */ + for (i=0; i<=3; i++)Spaces before and after assignments, please.
done (checkpatch already told that to me :-) )
Quoted 13 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 415
Quoted 12 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +11
-0+ if (val & (1 << i)) + data->in_status_cache &= ~(0x10 << i); + + /* if cached status for requested input is invalid, update it */ + if (!(data->in_status_cache & (0x10 << sattr->index))) { + volt = nct7802_read_voltage(data, sattr->nr, 0); + if (volt < 0) + return volt; + min = nct7802_read_voltage(data, sattr->nr, 1); + if (min < 0) + return min;
Quoted 1 line
Do we need to check min ? The register description suggests "over limit".
Yes I know, but my experiments show that the bits in SMI Voltage status register are also set when crossing the "min" threshold. I think that's why the datasheet does not show any register for "under limit".
Quoted 1 line
No idea though what the min limits are for in that case. Might be worth
Yes, it's usefull to know a system is powered from a voltage near the minimum because the risk of going under is increased and we must warn the user about that. Any small glitch under the min may lead to unexpected system reset.
Quoted 2 lines
running some checks to understand this better (if you did not do that already).
Sure I did that : I changed all voltage thresholds successively to have min above value or max below value in sensors.conf, then ran "sensors -s" to update the thresholds, then ran "sensors" several times to make sure ALARM is displayed. Then switched them back to normal values one by one to make sure ALARM is no more displayed. I also tried to load the driver with voltages already outside limits to make sure ALARM is reported.
I did this on kernel 4.17.19 because I had no hardware running 5.4, but did that by backporting my patch that is for the latest kernel to make sure this patch is correct.
Quoted 8 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 line 420
Quoted 6 lines
nct7802.c 2019-11-27 15:15:51.000000000 +0100 renamed from nct7802.c.orig 2019-11-26 10:37:08.753693088 +0100 +5
-0+ max = nct7802_read_voltage(data, sattr->nr, 2); + if (max < 0) + return max; + + if ((volt < min) || (volt > max))Unnecessary inner ( )
done
Quoted 4 lines
Guenter
.
Guenter Roeck
maintainerQuoted 3 lines · Gilles Buloz
Please find the inlined patches according to your feedback. I've also fixed some typos and added a mutex_lock/unlock in
in_alarm_show(). See also my replies to your questions in the previous mail below
Please don't send final patches inline, nor as reply to previous e-mails. Doing this violates Documentation/process/submitting-patches.rst. Besides, I use patchwork for my workflow, patchwork gets confused by it, and the patches don't show up there.
On top of that, the patches are whitespace damaged (tabs replaced with spaces) and would not apply, even if I tried.
Guenter