[PATCH v9 00/14] iio: afe: add temperature rescaling support

[PATCH v9 00/14] iio: afe: add temperature rescaling support

[Liam Beguin]

Hi Jonathan, Peter,

Apologies for not getting back to you sooner. I got caught up on other
work and wasn't able to dedicate time to this earlier. Hopefully, this
time around, I'll be able to get this to the finish line :-)

I left out IIO_VAL_INT overflows for now, so that I can focus on getting
the rest of these changes pulled in, but I don't mind adding a patch for
that later on.

This series focuses on adding temperature rescaling support to the IIO
Analog Front End (AFE) driver.

The first few patches address minor bugs in IIO inkernel functions, and
prepare the AFE driver for the additional features.

The main changes to the AFE driver include an initial Kunit test suite,
support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
and temperature transducer sensors.

Thanks for your time,
Liam

Changes since v8:
- reword comment
- fix erroneous 64-bit division
- optimize and use 32-bit divisions when values are know to not overflow
- keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
  point
- add test cases
- use nano precision in test cases
- simplify offset calculation in rtd_props()

Changes since v7:
- drop gcd() logic in rescale_process_scale()
- use div_s64() instead of do_div() for signed 64-bit divisions
- combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
- switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
- rework test logic to allow for small relative error
- rename test variables to align error output messages

Changes since v6:
- rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
- combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
- add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
- force use of positive integers with gcd()
- reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
- fix duplicate symbol build error
- apply Reviewed-by

Changes since v5:
- add include/linux/iio/afe/rescale.h
- expose functions use to process scale and offset
- add basic iio-rescale kunit test cases
- fix integer overflow case
- improve precision for IIO_VAL_FRACTIONAL_LOG2

Changes since v4:
- only use gcd() when necessary in overflow mitigation
- fix INT_PLUS_{MICRO,NANO} support
- apply Reviewed-by
- fix temperature-transducer bindings

Changes since v3:
- drop unnecessary fallthrough statements
- drop redundant local variables in some calculations
- fix s64 divisions on 32bit platforms by using do_div
- add comment describing iio-rescaler offset calculation
- drop unnecessary MAINTAINERS entry

Changes since v2:
- don't break implicit offset truncations
- make a best effort to get a valid value for fractional types
- drop return value change in iio_convert_raw_to_processed_unlocked()
- don't rely on processed value for offset calculation
- add INT_PLUS_{MICRO,NANO} support in iio-rescale
- revert generic implementation in favor of temperature-sense-rtd and
  temperature-transducer
- add separate section to MAINTAINERS file

Changes since v1:
- rebase on latest iio `testing` branch
- also apply consumer scale on integer channel scale types
- don't break implicit truncation in processed channel offset
  calculation
- drop temperature AFE flavors in favor of a simpler generic
  implementation

Liam Beguin (14):
  iio: inkern: apply consumer scale on IIO_VAL_INT cases
  iio: inkern: apply consumer scale when no channel scale is available
  iio: inkern: make a best effort on offset calculation
  iio: afe: rescale: expose scale processing function
  iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
  iio: afe: rescale: add offset support
  iio: afe: rescale: use s64 for temporary scale calculations
  iio: afe: rescale: reduce risk of integer overflow
  iio: afe: rescale: fix accuracy for small fractional scales
  iio: test: add basic tests for the iio-rescale driver
  iio: afe: rescale: add RTD temperature sensor support
  iio: afe: rescale: add temperature transducers
  dt-bindings: iio: afe: add bindings for temperature-sense-rtd
  dt-bindings: iio: afe: add bindings for temperature transducers

 .../iio/afe/temperature-sense-rtd.yaml        | 101 +++
 .../iio/afe/temperature-transducer.yaml       | 114 +++
 drivers/iio/afe/iio-rescale.c                 | 271 ++++++-
 drivers/iio/inkern.c                          |  40 +-
 drivers/iio/test/Kconfig                      |  10 +
 drivers/iio/test/Makefile                     |   1 +
 drivers/iio/test/iio-test-rescale.c           | 705 ++++++++++++++++++
 include/linux/iio/afe/rescale.h               |  34 +
 8 files changed, 1232 insertions(+), 44 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml
 create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml
 create mode 100644 drivers/iio/test/iio-test-rescale.c
 create mode 100644 include/linux/iio/afe/rescale.h

Range-diff against v8:
 1:  42a7a1047edc =  1:  ae3cc93baee6 iio: inkern: apply consumer scale on IIO_VAL_INT cases
 2:  a1cd89fdad11 =  2:  06f66e7f7403 iio: inkern: apply consumer scale when no channel scale is available
 3:  ed0721fb6bd1 =  3:  2dbf6b3bbaeb iio: inkern: make a best effort on offset calculation
 4:  f8fb78bb1112 =  4:  b083cf307268 iio: afe: rescale: expose scale processing function
 5:  504b7a3f830b !  5:  a0bde29ecc8c iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
    @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
     +		else
     +			mult = 1000000LL;
     +		/*
    -+		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if *val OR
    -+		 * *val2 is negative the schan scale is negative
    ++		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if either *val
    ++		 * OR *val2 is negative the schan scale is negative, i.e.
    ++		 * *val = 1 and *val2 = -0.5 yields -1.5 not -0.5.
     +		 */
     +		neg = *val < 0 || *val2 < 0;
     +
 6:  c254e9ae813e =  6:  c3d0e6248033 iio: afe: rescale: add offset support
 7:  ee8814d6abe4 =  7:  2a81fa735103 iio: afe: rescale: use s64 for temporary scale calculations
 8:  62cdcfbc9836 =  8:  8315548d0fce iio: afe: rescale: reduce risk of integer overflow
 9:  88309a5136ee !  9:  223ed0569cd2 iio: afe: rescale: fix accuracy for small fractional scales
    @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
     +
     +		tmp = div_s64_rem(tmp, 1000000000LL, &rem);
      		*val = tmp;
    +-		return scale_type;
    ++
    ++		if (!rem)
    ++			return scale_type;
     +
    -+		/*
    -+		 * For small values, the approximation can be costly,
    -+		 * change scale type to maintain accuracy.
    -+		 *
    -+		 * 100 vs. 10000000 NANO caps the error to about 100 ppm.
    -+		 */
     +		if (scale_type == IIO_VAL_FRACTIONAL)
     +			tmp = *val2;
     +		else
     +			tmp = 1 << *val2;
     +
    -+		 if (abs(rem) > 10000000 && abs(*val / tmp) < 100) {
    -+			 *val = div_s64_rem(*val, tmp, &rem2);
    -+
    -+			 *val2 = div_s64(rem, tmp);
    -+			 if (rem2)
    -+				 *val2 += div_s64(rem2 * 1000000000LL, tmp);
    ++		rem2 = *val % (int)tmp;
    ++		*val = *val / (int)tmp;
     +
    -+			 return IIO_VAL_INT_PLUS_NANO;
    -+		 }
    ++		*val2 = rem / (int)tmp;
    ++		if (rem2)
    ++			*val2 += div_s64((s64)rem2 * 1000000000LL, tmp);
     +
    - 		return scale_type;
    ++		return IIO_VAL_INT_PLUS_NANO;
      	case IIO_VAL_INT_PLUS_NANO:
      	case IIO_VAL_INT_PLUS_MICRO:
    + 		if (scale_type == IIO_VAL_INT_PLUS_NANO)
10:  fb505a9f42f1 ! 10:  90044efdf8be iio: test: add basic tests for the iio-rescale driver
    @@ drivers/iio/test/Makefile
      # Keep in alphabetical order
     +obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) += iio-test-rescale.o ../afe/iio-rescale.o
      obj-$(CONFIG_IIO_TEST_FORMAT) += iio-test-format.o
    + CFLAGS_iio-test-format.o += $(DISABLE_STRUCTLEAK_PLUGIN)
     
      ## drivers/iio/test/iio-test-rescale.c (new) ##
     @@
    @@ drivers/iio/test/iio-test-rescale.c (new)
     +	 * Use cases with small scales involving divisions
     +	 */
     +	{
    ++		.name = "small IIO_VAL_FRACTIONAL, 261/509 scaled by 90/1373754273",
    ++		.numerator = 261,
    ++		.denominator = 509,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
    ++		.schan_val = 90,
    ++		.schan_val2 = 1373754273,
    ++		.expected = "0.000000033594",
    ++	},
    ++	{
    ++		.name = "small IIO_VAL_FRACTIONAL, 90/1373754273 scaled by 261/509",
    ++		.numerator = 90,
    ++		.denominator = 1373754273,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
    ++		.schan_val = 261,
    ++		.schan_val2 = 509,
    ++		.expected = "0.000000033594",
    ++	},
    ++	{
    ++		.name = "small IIO_VAL_FRACTIONAL, 760/1373754273 scaled by 427/2727",
    ++		.numerator = 760,
    ++		.denominator = 1373754273,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
    ++		.schan_val = 427,
    ++		.schan_val2 = 2727,
    ++		.expected = "0.000000086626",
    ++	},
    ++	{
    ++		.name = "small IIO_VAL_FRACTIONAL, 761/1373754273 scaled by 427/2727",
    ++		.numerator = 761,
    ++		.denominator = 1373754273,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
    ++		.schan_val = 427,
    ++		.schan_val2 = 2727,
    ++		.expected = "0.000000086740",
    ++	},
    ++	{
    ++		.name = "small IIO_VAL_FRACTIONAL, 5/32768 scaled by 3/10000",
    ++		.numerator = 5,
    ++		.denominator = 32768,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
    ++		.schan_val = 3,
    ++		.schan_val2 = 10000,
    ++		.expected = "0.0000000457763671875",
    ++	},
    ++	{
     +		.name = "small IIO_VAL_FRACTIONAL, 0 < scale < 1",
     +		.numerator = 6,
     +		.denominator = 6,
    @@ drivers/iio/test/iio-test-rescale.c (new)
     +		.expected = "-1.3333333333333333",
     +	},
     +	{
    ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 760/32768 scaled by 15/22",
    ++		.numerator = 760,
    ++		.denominator = 32768,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
    ++		.schan_val = 15,
    ++		.schan_val2 = 22,
    ++		.expected = "0.000000082946",
    ++	},
    ++	{
    ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 761/32768 scaled by 15/22",
    ++		.numerator = 761,
    ++		.denominator = 32768,
    ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
    ++		.schan_val = 15,
    ++		.schan_val2 = 22,
    ++		.expected = "0.000000083055",
    ++	},
    ++	{
     +		.name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 1",
     +		.numerator = 16,
     +		.denominator = 3,
    @@ drivers/iio/test/iio-test-rescale.c (new)
     +KUNIT_ARRAY_PARAM(iio_rescale_offset, offset_cases, case_to_desc);
     +
     +/**
    -+ * iio_str_to_micro() - Parse a fixed-point string to get an
    -+ *                      IIO_VAL_INT_PLUS_MICRO value
    ++ * iio_str_to_nano() - Parse a fixed-point string to get an
    ++ *                      IIO_VAL_INT_PLUS_NANO value
     + * @str: The string to parse
    -+ * @micro: The number as an integer
    ++ * @nano: The number as an integer
     + *
     + * Returns 0 on success, or a negative error code if the string cound not be
     + * parsed.
     + */
    -+static int iio_str_to_micro(const char *str, s64 *micro)
    ++static int iio_str_to_nano(const char *str, s64 *nano)
     +{
    -+	int fract_mult = 100000LL;
    ++	int fract_mult = 100000000LL;
     +	int tmp, tmp2;
     +	int ret = 0;
     +
    @@ drivers/iio/test/iio-test-rescale.c (new)
     +	if (tmp < 0)
     +		tmp2 *= -1;
     +
    -+	*micro = (s64)tmp * 10 * fract_mult + tmp2;
    ++	*nano = (s64)tmp * 10 * fract_mult + tmp2;
     +
     +	return ret;
     +}
     +
     +/**
    -+ * iio_test_relative_error_ppm() - Compute relative error (in ppm) between two
    -+ *                                 fixed-point strings
    ++ * iio_test_relative_error_ppm() - Compute relative error (in parts-per-million)
    ++ *                                 between two fixed-point strings
     + * @real_str: The real value as a string
     + * @exp_str: The expected value as a string
     + *
     + * Returns a negative error code if the strings cound not be parsed, or the
    -+ * relative error in ppm.
    ++ * relative error in parts-per-million.
     + */
     +static int iio_test_relative_error_ppm(const char *real_str, const char *exp_str)
     +{
     +	s64 real, exp, err;
     +	int ret;
     +
    -+	ret = iio_str_to_micro(real_str, &real);
    ++	ret = iio_str_to_nano(real_str, &real);
     +	if (ret < 0)
     +		return ret;
     +
    -+	ret = iio_str_to_micro(exp_str, &exp);
    ++	ret = iio_str_to_nano(exp_str, &exp);
     +	if (ret < 0)
     +		return ret;
     +
    ++	if (!exp) {
    ++		pr_err("Expected value is null, relative error is undefined\n");
    ++		return -EINVAL;
    ++	}
    ++
     +	err = 1000000 * abs(exp - real);
     +	err = div64_u64(err, abs(exp));
     +	return (int)err;
    @@ drivers/iio/test/iio-test-rescale.c (new)
     +	rel_ppm = iio_test_relative_error_ppm(buff, t->expected);
     +	KUNIT_EXPECT_GE_MSG(test, rel_ppm, 0, "failed to compute ppm\n");
     +
    -+	KUNIT_EXPECT_LT_MSG(test, rel_ppm, 500,
    ++	KUNIT_EXPECT_EQ_MSG(test, rel_ppm, 0,
     +			    "\t    real=%s"
     +			    "\texpected=%s\n",
     +			    buff, t->expected);
11:  050487186e14 = 11:  c4ed463e5fb0 iio: afe: rescale: add RTD temperature sensor support
12:  f36a44a5d898 ! 12:  ff2f0dc248a7 iio: afe: rescale: add temperature transducers
    @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
     +	s32 offset = 0;
     +	s32 sense = 1;
     +	s32 alpha;
    -+	s64 tmp;
     +	int ret;
     +
     +	device_property_read_u32(dev, "sense-offset-millicelsius", &offset);
    @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
     +	rescale->numerator = 1000000;
     +	rescale->denominator = alpha * sense;
     +
    -+	tmp = (s64)offset * (s64)alpha * (s64)sense;
    -+	rescale->offset = div_s64(tmp, (s32)1000000);
    ++	rescale->offset = div_s64((s64)offset * rescale->denominator,
    ++				  rescale->numerator);
     +
     +	return 0;
     +}
13:  63be647fd110 = 13:  84bc1f7d1ab5 dt-bindings: iio: afe: add bindings for temperature-sense-rtd
14:  c2f5c19dece3 = 14:  1b76cfb37e23 dt-bindings: iio: afe: add bindings for temperature transducers

base-commit: 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 01/14] iio: inkern: apply consumer scale on IIO_VAL_INT cases

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

When a consumer calls iio_read_channel_processed() and the channel has
an integer scale, the scale channel scale is applied and the processed
value is returned as expected.

On the other hand, if the consumer calls iio_convert_raw_to_processed()
the scaling factor requested by the consumer is not applied.

This for example causes the consumer to process mV when expecting uV.
Make sure to always apply the scaling factor requested by the consumer.

Fixes: 48e44ce0f881 ("iio:inkern: Add function to read the processed value")
Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/inkern.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index 0222885b334c..021e1397ffc5 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -616,7 +616,7 @@ static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
 
 	switch (scale_type) {
 	case IIO_VAL_INT:
-		*processed = raw64 * scale_val;
+		*processed = raw64 * scale_val * scale;
 		break;
 	case IIO_VAL_INT_PLUS_MICRO:
 		if (scale_val2 < 0)
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 02/14] iio: inkern: apply consumer scale when no channel scale is available

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

When a consumer calls iio_read_channel_processed() and no channel scale
is available, it's assumed that the scale is one and the raw value is
returned as expected.

On the other hand, if the consumer calls iio_convert_raw_to_processed()
the scaling factor requested by the consumer is not applied.

This for example causes the consumer to process mV when expecting uV.
Make sure to always apply the scaling factor requested by the consumer.

Fixes: adc8ec5ff183 ("iio: inkern: pass through raw values if no scaling")
Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/inkern.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index 021e1397ffc5..dbe13fad3cbb 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -607,10 +607,10 @@ static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
 					IIO_CHAN_INFO_SCALE);
 	if (scale_type < 0) {
 		/*
-		 * Just pass raw values as processed if no scaling is
-		 * available.
+		 * If no channel scaling is available apply consumer scale to
+		 * raw value and return.
 		 */
-		*processed = raw;
+		*processed = raw * scale;
 		return 0;
 	}
 
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 03/14] iio: inkern: make a best effort on offset calculation

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

iio_convert_raw_to_processed_unlocked() assumes the offset is an
integer. Make a best effort to get a valid offset value for fractional
cases without breaking implicit truncations.

Fixes: 48e44ce0f881 ("iio:inkern: Add function to read the processed value")
Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/inkern.c | 32 +++++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index dbe13fad3cbb..aff6d2d3447c 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -595,13 +595,35 @@ EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
 static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
 	int raw, int *processed, unsigned int scale)
 {
-	int scale_type, scale_val, scale_val2, offset;
+	int scale_type, scale_val, scale_val2;
+	int offset_type, offset_val, offset_val2;
 	s64 raw64 = raw;
-	int ret;
 
-	ret = iio_channel_read(chan, &offset, NULL, IIO_CHAN_INFO_OFFSET);
-	if (ret >= 0)
-		raw64 += offset;
+	offset_type = iio_channel_read(chan, &offset_val, &offset_val2,
+				       IIO_CHAN_INFO_OFFSET);
+	if (offset_type >= 0) {
+		switch (offset_type) {
+		case IIO_VAL_INT:
+			break;
+		case IIO_VAL_INT_PLUS_MICRO:
+		case IIO_VAL_INT_PLUS_NANO:
+			/*
+			 * Both IIO_VAL_INT_PLUS_MICRO and IIO_VAL_INT_PLUS_NANO
+			 * implicitely truncate the offset to it's integer form.
+			 */
+			break;
+		case IIO_VAL_FRACTIONAL:
+			offset_val /= offset_val2;
+			break;
+		case IIO_VAL_FRACTIONAL_LOG2:
+			offset_val /= (1 << offset_val2);
+			break;
+		default:
+			return -EINVAL;
+		}
+
+		raw64 += offset_val;
+	}
 
 	scale_type = iio_channel_read(chan, &scale_val, &scale_val2,
 					IIO_CHAN_INFO_SCALE);
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 04/14] iio: afe: rescale: expose scale processing function

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

In preparation for the addition of kunit tests, expose the logic
responsible for combining channel scales.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c   | 65 ++++++++++++++-------------------
 include/linux/iio/afe/rescale.h | 30 +++++++++++++++
 2 files changed, 58 insertions(+), 37 deletions(-)
 create mode 100644 include/linux/iio/afe/rescale.h

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index 774eb3044edd..d0669fd8eac5 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -11,35 +11,46 @@
 #include <linux/gcd.h>
 #include <linux/iio/consumer.h>
 #include <linux/iio/iio.h>
+#include <linux/iio/afe/rescale.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/property.h>
 
-struct rescale;
-
-struct rescale_cfg {
-	enum iio_chan_type type;
-	int (*props)(struct device *dev, struct rescale *rescale);
-};
+int rescale_process_scale(struct rescale *rescale, int scale_type,
+			  int *val, int *val2)
+{
+	unsigned long long tmp;
 
-struct rescale {
-	const struct rescale_cfg *cfg;
-	struct iio_channel *source;
-	struct iio_chan_spec chan;
-	struct iio_chan_spec_ext_info *ext_info;
-	bool chan_processed;
-	s32 numerator;
-	s32 denominator;
-};
+	switch (scale_type) {
+	case IIO_VAL_FRACTIONAL:
+		*val *= rescale->numerator;
+		*val2 *= rescale->denominator;
+		return scale_type;
+	case IIO_VAL_INT:
+		*val *= rescale->numerator;
+		if (rescale->denominator == 1)
+			return scale_type;
+		*val2 = rescale->denominator;
+		return IIO_VAL_FRACTIONAL;
+	case IIO_VAL_FRACTIONAL_LOG2:
+		tmp = *val * 1000000000LL;
+		do_div(tmp, rescale->denominator);
+		tmp *= rescale->numerator;
+		do_div(tmp, 1000000000LL);
+		*val = tmp;
+		return scale_type;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
 static int rescale_read_raw(struct iio_dev *indio_dev,
 			    struct iio_chan_spec const *chan,
 			    int *val, int *val2, long mask)
 {
 	struct rescale *rescale = iio_priv(indio_dev);
-	unsigned long long tmp;
 	int ret;
 
 	switch (mask) {
@@ -65,27 +76,7 @@ static int rescale_read_raw(struct iio_dev *indio_dev,
 		} else {
 			ret = iio_read_channel_scale(rescale->source, val, val2);
 		}
-		switch (ret) {
-		case IIO_VAL_FRACTIONAL:
-			*val *= rescale->numerator;
-			*val2 *= rescale->denominator;
-			return ret;
-		case IIO_VAL_INT:
-			*val *= rescale->numerator;
-			if (rescale->denominator == 1)
-				return ret;
-			*val2 = rescale->denominator;
-			return IIO_VAL_FRACTIONAL;
-		case IIO_VAL_FRACTIONAL_LOG2:
-			tmp = *val * 1000000000LL;
-			do_div(tmp, rescale->denominator);
-			tmp *= rescale->numerator;
-			do_div(tmp, 1000000000LL);
-			*val = tmp;
-			return ret;
-		default:
-			return -EOPNOTSUPP;
-		}
+		return rescale_process_scale(rescale, ret, val, val2);
 	default:
 		return -EINVAL;
 	}
diff --git a/include/linux/iio/afe/rescale.h b/include/linux/iio/afe/rescale.h
new file mode 100644
index 000000000000..14d4ee1227c6
--- /dev/null
+++ b/include/linux/iio/afe/rescale.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2021 Liam Beguin <liambeguin@gmail.com>
+ */
+
+#ifndef __IIO_RESCALE_H__
+#define __IIO_RESCALE_H__
+
+#include <linux/iio/iio.h>
+
+struct rescale;
+
+struct rescale_cfg {
+	enum iio_chan_type type;
+	int (*props)(struct device *dev, struct rescale *rescale);
+};
+
+struct rescale {
+	const struct rescale_cfg *cfg;
+	struct iio_channel *source;
+	struct iio_chan_spec chan;
+	struct iio_chan_spec_ext_info *ext_info;
+	bool chan_processed;
+	s32 numerator;
+	s32 denominator;
+};
+
+int rescale_process_scale(struct rescale *rescale, int scale_type,
+			  int *val, int *val2);
+#endif /* __IIO_RESCALE_H__ */
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 05/14] iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

Some ADCs use IIO_VAL_INT_PLUS_{NANO,MICRO} scale types.
Add support for these to allow using the iio-rescaler with them.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 36 +++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index d0669fd8eac5..2c25a6375f99 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -22,6 +22,9 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 			  int *val, int *val2)
 {
 	unsigned long long tmp;
+	s32 rem;
+	u32 mult;
+	u32 neg;
 
 	switch (scale_type) {
 	case IIO_VAL_FRACTIONAL:
@@ -40,6 +43,39 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 		tmp *= rescale->numerator;
 		do_div(tmp, 1000000000LL);
 		*val = tmp;
+		return scale_type;
+	case IIO_VAL_INT_PLUS_NANO:
+	case IIO_VAL_INT_PLUS_MICRO:
+		if (scale_type == IIO_VAL_INT_PLUS_NANO)
+			mult = 1000000000LL;
+		else
+			mult = 1000000LL;
+		/*
+		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if either *val
+		 * OR *val2 is negative the schan scale is negative, i.e.
+		 * *val = 1 and *val2 = -0.5 yields -1.5 not -0.5.
+		 */
+		neg = *val < 0 || *val2 < 0;
+
+		tmp = (s64)abs(*val) * abs(rescale->numerator);
+		*val = div_s64_rem(tmp, abs(rescale->denominator), &rem);
+
+		tmp = (s64)rem * mult + (s64)abs(*val2) * abs(rescale->numerator);
+		tmp = div_s64(tmp, abs(rescale->denominator));
+
+		*val += div_s64_rem(tmp, mult, val2);
+
+		/*
+		 * If only one of the rescaler elements or the schan scale is
+		 * negative, the combined scale is negative.
+		 */
+		if (neg ^ ((rescale->numerator < 0) ^ (rescale->denominator < 0))) {
+			if (*val)
+				*val = -*val;
+			else
+				*val2 = -*val2;
+		}
+
 		return scale_type;
 	default:
 		return -EOPNOTSUPP;
-- 
2.32.0.452.g940fe202adcb

Re: [PATCH v9 05/14] iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support

[Jonathan Cameron]

On Sun, 14 Nov 2021 22:43:25 -0500
Liam Beguin <liambeguin@gmail.com> wrote:

> From: Liam Beguin <lvb@xiphos.com>
> 
> Some ADCs use IIO_VAL_INT_PLUS_{NANO,MICRO} scale types.
> Add support for these to allow using the iio-rescaler with them.
> 
> Signed-off-by: Liam Beguin <lvb@xiphos.com>
> ---
>  drivers/iio/afe/iio-rescale.c | 36 +++++++++++++++++++++++++++++++++++
>  1 file changed, 36 insertions(+)
> 
> diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
> index d0669fd8eac5..2c25a6375f99 100644
> --- a/drivers/iio/afe/iio-rescale.c
> +++ b/drivers/iio/afe/iio-rescale.c
> @@ -22,6 +22,9 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
>  			  int *val, int *val2)
>  {
>  	unsigned long long tmp;
> +	s32 rem;
> +	u32 mult;
> +	u32 neg;
>  
>  	switch (scale_type) {
>  	case IIO_VAL_FRACTIONAL:
> @@ -40,6 +43,39 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
>  		tmp *= rescale->numerator;
>  		do_div(tmp, 1000000000LL);
>  		*val = tmp;
> +		return scale_type;
> +	case IIO_VAL_INT_PLUS_NANO:
> +	case IIO_VAL_INT_PLUS_MICRO:
> +		if (scale_type == IIO_VAL_INT_PLUS_NANO)
> +			mult = 1000000000LL;
> +		else
> +			mult = 1000000LL;

Trivial but perhaps you can use the multipliers defined in include/linux/units.h?
			mut = MICRO; etc.

I think that patch set crossed with the earlier versions of this one but given
it's now there I think it would slightly improve readability.


> +		/*
> +		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if either *val
> +		 * OR *val2 is negative the schan scale is negative, i.e.
> +		 * *val = 1 and *val2 = -0.5 yields -1.5 not -0.5.
> +		 */
> +		neg = *val < 0 || *val2 < 0;
> +
> +		tmp = (s64)abs(*val) * abs(rescale->numerator);
> +		*val = div_s64_rem(tmp, abs(rescale->denominator), &rem);
> +
> +		tmp = (s64)rem * mult + (s64)abs(*val2) * abs(rescale->numerator);
> +		tmp = div_s64(tmp, abs(rescale->denominator));
> +
> +		*val += div_s64_rem(tmp, mult, val2);
> +
> +		/*
> +		 * If only one of the rescaler elements or the schan scale is
> +		 * negative, the combined scale is negative.
> +		 */
> +		if (neg ^ ((rescale->numerator < 0) ^ (rescale->denominator < 0))) {
> +			if (*val)
> +				*val = -*val;
> +			else
> +				*val2 = -*val2;
> +		}
> +
>  		return scale_type;
>  	default:
>  		return -EOPNOTSUPP;

[PATCH v9 06/14] iio: afe: rescale: add offset support

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

This is a preparatory change required for the addition of temperature
sensing front ends.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c   | 80 +++++++++++++++++++++++++++++++++
 include/linux/iio/afe/rescale.h |  4 ++
 2 files changed, 84 insertions(+)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index 2c25a6375f99..da462e0910ff 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -82,11 +82,46 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 	}
 }
 
+int rescale_process_offset(struct rescale *rescale, int scale_type,
+			   int scale, int scale2, int schan_off,
+			   int *val, int *val2)
+{
+	s64 tmp, tmp2;
+
+	switch (scale_type) {
+	case IIO_VAL_FRACTIONAL:
+		tmp = (s64)rescale->offset * scale2;
+		*val = div_s64(tmp, scale) + schan_off;
+		return IIO_VAL_INT;
+	case IIO_VAL_INT:
+		*val = div_s64(rescale->offset, scale) + schan_off;
+		return IIO_VAL_INT;
+	case IIO_VAL_FRACTIONAL_LOG2:
+		tmp = (s64)rescale->offset * (1 << scale2);
+		*val = div_s64(tmp, scale) + schan_off;
+		return IIO_VAL_INT;
+	case IIO_VAL_INT_PLUS_NANO:
+		tmp = (s64)rescale->offset * 1000000000;
+		tmp2 = ((s64)scale * 1000000000L) + scale2;
+		*val = div64_s64(tmp, tmp2) + schan_off;
+		return IIO_VAL_INT;
+	case IIO_VAL_INT_PLUS_MICRO:
+		tmp = (s64)rescale->offset * 1000000L;
+		tmp2 = ((s64)scale * 1000000L) + scale2;
+		*val = div64_s64(tmp, tmp2) + schan_off;
+		return IIO_VAL_INT;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
 static int rescale_read_raw(struct iio_dev *indio_dev,
 			    struct iio_chan_spec const *chan,
 			    int *val, int *val2, long mask)
 {
 	struct rescale *rescale = iio_priv(indio_dev);
+	int scale, scale2;
+	int schan_off = 0;
 	int ret;
 
 	switch (mask) {
@@ -113,6 +148,47 @@ static int rescale_read_raw(struct iio_dev *indio_dev,
 			ret = iio_read_channel_scale(rescale->source, val, val2);
 		}
 		return rescale_process_scale(rescale, ret, val, val2);
+	case IIO_CHAN_INFO_OFFSET:
+		/*
+		 * Processed channels are scaled 1-to-1 and source offset is
+		 * already taken into account.
+		 *
+		 * In other cases, real world measurement are expressed as:
+		 *
+		 *	schan_scale * (raw + schan_offset)
+		 *
+		 * Given that the rescaler parameters are applied recursively:
+		 *
+		 *	rescaler_scale * (schan_scale * (raw + schan_offset) +
+		 *		rescaler_offset)
+		 *
+		 * Or,
+		 *
+		 *	(rescaler_scale * schan_scale) * (raw +
+		 *		(schan_offset +	rescaler_offset / schan_scale)
+		 *
+		 * Thus, reusing the original expression the parameters exposed
+		 * to userspace are:
+		 *
+		 *	scale = schan_scale * rescaler_scale
+		 *	offset = schan_offset + rescaler_offset / schan_scale
+		 */
+		if (rescale->chan_processed) {
+			*val = rescale->offset;
+			return IIO_VAL_INT;
+		}
+
+		if (iio_channel_has_info(rescale->source->channel,
+					 IIO_CHAN_INFO_OFFSET)) {
+			ret = iio_read_channel_offset(rescale->source,
+						      &schan_off, NULL);
+			if (ret != IIO_VAL_INT)
+				return ret < 0 ? ret : -EOPNOTSUPP;
+		}
+
+		ret = iio_read_channel_scale(rescale->source, &scale, &scale2);
+		return rescale_process_offset(rescale, ret, scale, scale2,
+					      schan_off, val, val2);
 	default:
 		return -EINVAL;
 	}
@@ -189,6 +265,9 @@ static int rescale_configure_channel(struct device *dev,
 	chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 		BIT(IIO_CHAN_INFO_SCALE);
 
+	if (rescale->offset)
+		chan->info_mask_separate |= BIT(IIO_CHAN_INFO_OFFSET);
+
 	/*
 	 * Using .read_avail() is fringe to begin with and makes no sense
 	 * whatsoever for processed channels, so we make sure that this cannot
@@ -353,6 +432,7 @@ static int rescale_probe(struct platform_device *pdev)
 	rescale->cfg = of_device_get_match_data(dev);
 	rescale->numerator = 1;
 	rescale->denominator = 1;
+	rescale->offset = 0;
 
 	ret = rescale->cfg->props(dev, rescale);
 	if (ret)
diff --git a/include/linux/iio/afe/rescale.h b/include/linux/iio/afe/rescale.h
index 14d4ee1227c6..b152ac487403 100644
--- a/include/linux/iio/afe/rescale.h
+++ b/include/linux/iio/afe/rescale.h
@@ -23,8 +23,12 @@ struct rescale {
 	bool chan_processed;
 	s32 numerator;
 	s32 denominator;
+	s32 offset;
 };
 
 int rescale_process_scale(struct rescale *rescale, int scale_type,
 			  int *val, int *val2);
+int rescale_process_offset(struct rescale *rescale, int scale_type,
+			   int scale, int scale2, int schan_off,
+			   int *val, int *val2);
 #endif /* __IIO_RESCALE_H__ */
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 07/14] iio: afe: rescale: use s64 for temporary scale calculations

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

All four scaling coefficients can take signed values.
Make tmp a signed 64-bit integer and switch to div_s64() to preserve
signs during 64-bit divisions.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index da462e0910ff..394f8b16b29c 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -21,7 +21,7 @@
 int rescale_process_scale(struct rescale *rescale, int scale_type,
 			  int *val, int *val2)
 {
-	unsigned long long tmp;
+	s64 tmp;
 	s32 rem;
 	u32 mult;
 	u32 neg;
@@ -38,10 +38,10 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 		*val2 = rescale->denominator;
 		return IIO_VAL_FRACTIONAL;
 	case IIO_VAL_FRACTIONAL_LOG2:
-		tmp = *val * 1000000000LL;
-		do_div(tmp, rescale->denominator);
+		tmp = (s64)*val * 1000000000LL;
+		tmp = div_s64(tmp, rescale->denominator);
 		tmp *= rescale->numerator;
-		do_div(tmp, 1000000000LL);
+		tmp = div_s64(tmp, 1000000000LL);
 		*val = tmp;
 		return scale_type;
 	case IIO_VAL_INT_PLUS_NANO:
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 08/14] iio: afe: rescale: reduce risk of integer overflow

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

Reduce the risk of integer overflow by doing the scale calculation on
a 64-bit integer. Since the rescaling is only performed on *val, reuse
the IIO_VAL_FRACTIONAL_LOG2 case.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index 394f8b16b29c..17036130d364 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -27,16 +27,13 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 	u32 neg;
 
 	switch (scale_type) {
-	case IIO_VAL_FRACTIONAL:
-		*val *= rescale->numerator;
-		*val2 *= rescale->denominator;
-		return scale_type;
 	case IIO_VAL_INT:
 		*val *= rescale->numerator;
 		if (rescale->denominator == 1)
 			return scale_type;
 		*val2 = rescale->denominator;
 		return IIO_VAL_FRACTIONAL;
+	case IIO_VAL_FRACTIONAL:
 	case IIO_VAL_FRACTIONAL_LOG2:
 		tmp = (s64)*val * 1000000000LL;
 		tmp = div_s64(tmp, rescale->denominator);
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 09/14] iio: afe: rescale: fix accuracy for small fractional scales

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

The approximation caused by integer divisions can be costly on smaller
scale values since the decimal part is significant compared to the
integer part. Switch to an IIO_VAL_INT_PLUS_NANO scale type in such
cases to maintain accuracy.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index 17036130d364..8a2f1c0ca5a3 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -22,7 +22,7 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 			  int *val, int *val2)
 {
 	s64 tmp;
-	s32 rem;
+	s32 rem, rem2;
 	u32 mult;
 	u32 neg;
 
@@ -38,9 +38,26 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
 		tmp = (s64)*val * 1000000000LL;
 		tmp = div_s64(tmp, rescale->denominator);
 		tmp *= rescale->numerator;
-		tmp = div_s64(tmp, 1000000000LL);
+
+		tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 		*val = tmp;
-		return scale_type;
+
+		if (!rem)
+			return scale_type;
+
+		if (scale_type == IIO_VAL_FRACTIONAL)
+			tmp = *val2;
+		else
+			tmp = 1 << *val2;
+
+		rem2 = *val % (int)tmp;
+		*val = *val / (int)tmp;
+
+		*val2 = rem / (int)tmp;
+		if (rem2)
+			*val2 += div_s64((s64)rem2 * 1000000000LL, tmp);
+
+		return IIO_VAL_INT_PLUS_NANO;
 	case IIO_VAL_INT_PLUS_NANO:
 	case IIO_VAL_INT_PLUS_MICRO:
 		if (scale_type == IIO_VAL_INT_PLUS_NANO)
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

The iio-rescale driver supports various combinations of scale types and
offsets. These can often result in large integer multiplications. Make
sure these calculations are done right by adding a set of kunit test
cases that build on top of iio-test-format.

To run these tests, add the following to .kunitconfig
	$ cat .kunitconfig
	CONFIG_IIO=y
	CONFIG_IIO_RESCALE_KUNIT_TEST=y
	CONFIG_KUNIT=y

Then run:
	$ ./tools/testing/kunit/kunit.py run --kunitconfig .kunitconfig

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/test/Kconfig            |  10 +
 drivers/iio/test/Makefile           |   1 +
 drivers/iio/test/iio-test-rescale.c | 705 ++++++++++++++++++++++++++++
 3 files changed, 716 insertions(+)
 create mode 100644 drivers/iio/test/iio-test-rescale.c

diff --git a/drivers/iio/test/Kconfig b/drivers/iio/test/Kconfig
index 679a7794af20..872ed4ed140a 100644
--- a/drivers/iio/test/Kconfig
+++ b/drivers/iio/test/Kconfig
@@ -4,6 +4,16 @@
 #
 
 # Keep in alphabetical order
+config IIO_RESCALE_KUNIT_TEST
+	bool "Test IIO rescale conversion functions"
+	depends on KUNIT && !IIO_RESCALE
+	default KUNIT_ALL_TESTS
+	help
+	  If you want to run tests on the iio-rescale code say Y here.
+
+	  This takes advantage of ARCH=um to run tests and should be used by
+	  developers to tests their changes to the rescaling logic.
+
 config IIO_TEST_FORMAT
         bool "Test IIO formatting functions"
         depends on KUNIT=y
diff --git a/drivers/iio/test/Makefile b/drivers/iio/test/Makefile
index 467519a2027e..f15ae0a6394f 100644
--- a/drivers/iio/test/Makefile
+++ b/drivers/iio/test/Makefile
@@ -4,5 +4,6 @@
 #
 
 # Keep in alphabetical order
+obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) += iio-test-rescale.o ../afe/iio-rescale.o
 obj-$(CONFIG_IIO_TEST_FORMAT) += iio-test-format.o
 CFLAGS_iio-test-format.o += $(DISABLE_STRUCTLEAK_PLUGIN)
diff --git a/drivers/iio/test/iio-test-rescale.c b/drivers/iio/test/iio-test-rescale.c
new file mode 100644
index 000000000000..526f87fa3514
--- /dev/null
+++ b/drivers/iio/test/iio-test-rescale.c
@@ -0,0 +1,705 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Kunit tests for IIO rescale conversions
+ *
+ * Copyright (c) 2021 Liam Beguin <liambeguin@gmail.com>
+ */
+
+#include <kunit/test.h>
+#include <linux/gcd.h>
+#include <linux/iio/afe/rescale.h>
+#include <linux/iio/iio.h>
+#include <linux/overflow.h>
+
+struct rescale_tc_data {
+	const char *name;
+
+	const s32 numerator;
+	const s32 denominator;
+	const s32 offset;
+
+	const int schan_val;
+	const int schan_val2;
+	const int schan_off;
+	const int schan_scale_type;
+
+	const char *expected;
+	const char *expected_off;
+};
+
+const struct rescale_tc_data scale_cases[] = {
+	/*
+	 * Typical use cases
+	 */
+	{
+		.name = "typical IIO_VAL_INT, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT,
+		.schan_val = 42,
+		.expected = "5210.918114143",
+	},
+	{
+		.name = "typical IIO_VAL_INT, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT,
+		.schan_val = 42,
+		.expected = "-5210.918114143",
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 42,
+		.schan_val2 = 20,
+		.expected = "260.545905707",
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 42,
+		.schan_val2 = 20,
+		.expected = "-260.545905707",
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL_LOG2, positive",
+		.numerator = 42,
+		.denominator = 53,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 4096,
+		.schan_val2 = 16,
+		.expected = "0.049528301",
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL_LOG2, negative",
+		.numerator = -42,
+		.denominator = 53,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 4096,
+		.schan_val2 = 16,
+		.expected = "-0.049528301",
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_NANO, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456,
+		.expected = "1240.710106203",
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_NANO, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456,
+		.expected = "-1240.710106203",
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_MICRO, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 1234,
+		.expected = "1240.84789",
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_MICRO, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 1234,
+		.expected = "-1240.84789",
+	},
+	/*
+	 * Use cases with small scales involving divisions
+	 */
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 261/509 scaled by 90/1373754273",
+		.numerator = 261,
+		.denominator = 509,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 90,
+		.schan_val2 = 1373754273,
+		.expected = "0.000000033594",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 90/1373754273 scaled by 261/509",
+		.numerator = 90,
+		.denominator = 1373754273,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 261,
+		.schan_val2 = 509,
+		.expected = "0.000000033594",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 760/1373754273 scaled by 427/2727",
+		.numerator = 760,
+		.denominator = 1373754273,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 427,
+		.schan_val2 = 2727,
+		.expected = "0.000000086626",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 761/1373754273 scaled by 427/2727",
+		.numerator = 761,
+		.denominator = 1373754273,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 427,
+		.schan_val2 = 2727,
+		.expected = "0.000000086740",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 5/32768 scaled by 3/10000",
+		.numerator = 5,
+		.denominator = 32768,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 3,
+		.schan_val2 = 10000,
+		.expected = "0.0000000457763671875",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 0 < scale < 1",
+		.numerator = 6,
+		.denominator = 6,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 1,
+		.schan_val2 = 3,
+		.expected = "0.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, -1 < scale < 0",
+		.numerator = -6,
+		.denominator = 6,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 1,
+		.schan_val2 = 3,
+		.expected = "-0.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, 0 < scale < 2",
+		.numerator = 8,
+		.denominator = 2,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 1,
+		.schan_val2 = 3,
+		.expected = "1.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL, -2 < scale < 0",
+		.numerator = -8,
+		.denominator = 2,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 1,
+		.schan_val2 = 3,
+		.expected = "-1.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, 760/32768 scaled by 15/22",
+		.numerator = 760,
+		.denominator = 32768,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 15,
+		.schan_val2 = 22,
+		.expected = "0.000000082946",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, 761/32768 scaled by 15/22",
+		.numerator = 761,
+		.denominator = 32768,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 15,
+		.schan_val2 = 22,
+		.expected = "0.000000083055",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 1",
+		.numerator = 16,
+		.denominator = 3,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 1,
+		.schan_val2 = 4,
+		.expected = "0.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, -1 < scale < 0",
+		.numerator = -16,
+		.denominator = 3,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 1,
+		.schan_val2 = 4,
+		.expected = "-0.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 2",
+		.numerator = 8,
+		.denominator = 3,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 1,
+		.schan_val2 = 1,
+		.expected = "1.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_FRACTIONAL_LOG2, -2 < scale < 0",
+		.numerator = -8,
+		.denominator = 3,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 1,
+		.schan_val2 = 1,
+		.expected = "-1.3333333333333333",
+	},
+	{
+		.name = "small IIO_VAL_INT_PLUS_MICRO, positive",
+		.numerator = 1,
+		.denominator = 2,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 5,
+		.schan_val2 = 1234,
+		.expected = "2.500617",
+	},
+	{
+		.name = "small IIO_VAL_INT_PLUS_MICRO, negative",
+		.numerator = -1,
+		.denominator = 2,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 5,
+		.schan_val2 = 1234,
+		.expected = "-2.500617",
+	},
+	/*
+	 * INT_PLUS_{MICRO,NANO} positive/negative corner cases
+	 */
+	{
+		.name = "negative IIO_VAL_INT_PLUS_NANO, negative schan",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = 123456,
+		.expected = "-1240.710106203",
+	},
+	{
+		.name = "negative IIO_VAL_INT_PLUS_NANO, both negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = 123456,
+		.expected = "1240.710106203",
+	},
+	{
+		.name = "negative IIO_VAL_INT_PLUS_NANO, 3 negative",
+		.numerator = -1000000,
+		.denominator = -8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = 123456,
+		.expected = "-1240.710106203",
+	},
+	{
+		.name = "negative IIO_VAL_INT_PLUS_NANO, 4 negative",
+		.numerator = -1000000,
+		.denominator = -8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = -123456,
+		.expected = "-1240.710106203",
+	},
+	{
+		.name = "negative IIO_VAL_INT_PLUS_NANO, negative, *val = 0",
+		.numerator = 1,
+		.denominator = -10,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 0,
+		.schan_val2 = 123456789,
+		.expected = "-0.012345678",
+	},
+	/*
+	 * INT_PLUS_{MICRO,NANO} decimal part overflow
+	 */
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_NANO, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.expected = "1256.01200856",
+	},
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_NANO, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.expected = "-1256.01200856",
+	},
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_NANO, negative schan",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = 123456789,
+		.expected = "-1256.01200856",
+	},
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, positive",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.expected = "16557.914267",
+	},
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, negative",
+		.numerator = -1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.expected = "-16557.914267",
+	},
+	{
+		.name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, negative schan",
+		.numerator = 1000000,
+		.denominator = 8060,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = -10,
+		.schan_val2 = 123456789,
+		.expected = "-16557.914267",
+	},
+	/*
+	 * 32-bit overflow conditions
+	 */
+	{
+		.name = "overflow IIO_VAL_FRACTIONAL, positive",
+		.numerator = 2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = S32_MAX,
+		.schan_val2 = 1,
+		.expected = "214748364.7",
+	},
+	{
+		.name = "overflow IIO_VAL_FRACTIONAL, negative",
+		.numerator = -2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = S32_MAX,
+		.schan_val2 = 1,
+		.expected = "-214748364.7",
+	},
+	{
+		.name = "overflow IIO_VAL_FRACTIONAL_LOG2, positive",
+		.numerator = S32_MAX,
+		.denominator = 4096,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 4096,
+		.schan_val2 = 16,
+		.expected = "32767.99998474121",
+	},
+	{
+		.name = "overflow IIO_VAL_FRACTIONAL_LOG2, negative",
+		.numerator = S32_MAX,
+		.denominator = 4096,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = -4096,
+		.schan_val2 = 16,
+		.expected = "-32767.99998474121",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_NANO, positive",
+		.numerator = 2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = S32_MAX,
+		.expected = "1.214748364",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_NANO, negative",
+		.numerator = -2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = S32_MAX,
+		.expected = "-1.214748364",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_NANO, negative schan",
+		.numerator = 2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = -10,
+		.schan_val2 = S32_MAX,
+		.expected = "-1.214748364",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_MICRO, positive",
+		.numerator = 2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = S32_MAX,
+		.expected = "215.748364",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_MICRO, negative",
+		.numerator = -2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = S32_MAX,
+		.expected = "-215.748364",
+	},
+	{
+		.name = "overflow IIO_VAL_INT_PLUS_MICRO, negative schan",
+		.numerator = 2,
+		.denominator = 20,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = -10,
+		.schan_val2 = S32_MAX,
+		.expected = "-215.748364",
+	},
+};
+
+const struct rescale_tc_data offset_cases[] = {
+	/*
+	 * Typical use cases
+	 */
+	{
+		.name = "typical IIO_VAL_INT, positive",
+		.offset = 1234,
+		.schan_scale_type = IIO_VAL_INT,
+		.schan_val = 123,
+		.schan_val2 = 0,
+		.schan_off = 14,
+		.expected_off = "24", /* 23.872 */
+	},
+	{
+		.name = "typical IIO_VAL_INT, negative",
+		.offset = -1234,
+		.schan_scale_type = IIO_VAL_INT,
+		.schan_val = 12,
+		.schan_val2 = 0,
+		.schan_off = 14,
+		.expected_off = "-88", /* -88.83333333333333 */
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL, positive",
+		.offset = 1234,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 12,
+		.schan_val2 = 34,
+		.schan_off = 14,
+		.expected_off = "3510", /* 3510.333333333333 */
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL, negative",
+		.offset = -1234,
+		.schan_scale_type = IIO_VAL_FRACTIONAL,
+		.schan_val = 12,
+		.schan_val2 = 34,
+		.schan_off = 14,
+		.expected_off = "-3482", /* -3482.333333333333 */
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL_LOG2, positive",
+		.offset = 1234,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 12,
+		.schan_val2 = 16,
+		.schan_off = 14,
+		.expected_off = "6739299", /* 6739299.333333333 */
+	},
+	{
+		.name = "typical IIO_VAL_FRACTIONAL_LOG2, negative",
+		.offset = -1234,
+		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
+		.schan_val = 12,
+		.schan_val2 = 16,
+		.schan_off = 14,
+		.expected_off = "-6739271", /* -6739271.333333333 */
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_NANO, positive",
+		.offset = 1234,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.schan_off = 14,
+		.expected_off = "135", /* 135.8951219647469 */
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_NANO, negative",
+		.offset = -1234,
+		.schan_scale_type = IIO_VAL_INT_PLUS_NANO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.schan_off = 14,
+		.expected_off = "-107", /* -107.89512196474689 */
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_MICRO, positive",
+		.offset = 1234,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.schan_off = 14,
+		.expected_off = "23", /* 23.246438560723952 */
+	},
+	{
+		.name = "typical IIO_VAL_INT_PLUS_MICRO, negative",
+		.offset = -12345,
+		.schan_scale_type = IIO_VAL_INT_PLUS_MICRO,
+		.schan_val = 10,
+		.schan_val2 = 123456789,
+		.schan_off = 14,
+		.expected_off = "-78", /* -78.50185091745313 */
+	},
+};
+
+static void case_to_desc(const struct rescale_tc_data *t, char *desc)
+{
+	strcpy(desc, t->name);
+}
+
+KUNIT_ARRAY_PARAM(iio_rescale_scale, scale_cases, case_to_desc);
+KUNIT_ARRAY_PARAM(iio_rescale_offset, offset_cases, case_to_desc);
+
+/**
+ * iio_str_to_nano() - Parse a fixed-point string to get an
+ *                      IIO_VAL_INT_PLUS_NANO value
+ * @str: The string to parse
+ * @nano: The number as an integer
+ *
+ * Returns 0 on success, or a negative error code if the string cound not be
+ * parsed.
+ */
+static int iio_str_to_nano(const char *str, s64 *nano)
+{
+	int fract_mult = 100000000LL;
+	int tmp, tmp2;
+	int ret = 0;
+
+	ret = iio_str_to_fixpoint(str, fract_mult, &tmp, &tmp2);
+	if (ret < 0)
+		return ret;
+
+	if (tmp < 0)
+		tmp2 *= -1;
+
+	*nano = (s64)tmp * 10 * fract_mult + tmp2;
+
+	return ret;
+}
+
+/**
+ * iio_test_relative_error_ppm() - Compute relative error (in parts-per-million)
+ *                                 between two fixed-point strings
+ * @real_str: The real value as a string
+ * @exp_str: The expected value as a string
+ *
+ * Returns a negative error code if the strings cound not be parsed, or the
+ * relative error in parts-per-million.
+ */
+static int iio_test_relative_error_ppm(const char *real_str, const char *exp_str)
+{
+	s64 real, exp, err;
+	int ret;
+
+	ret = iio_str_to_nano(real_str, &real);
+	if (ret < 0)
+		return ret;
+
+	ret = iio_str_to_nano(exp_str, &exp);
+	if (ret < 0)
+		return ret;
+
+	if (!exp) {
+		pr_err("Expected value is null, relative error is undefined\n");
+		return -EINVAL;
+	}
+
+	err = 1000000 * abs(exp - real);
+	err = div64_u64(err, abs(exp));
+	return (int)err;
+}
+
+static void iio_rescale_test_scale(struct kunit *test)
+{
+	struct rescale_tc_data *t = (struct rescale_tc_data *)test->param_value;
+	char *buff = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
+	struct rescale rescale;
+	int values[2];
+	int rel_ppm;
+	int ret;
+
+	rescale.numerator = t->numerator;
+	rescale.denominator = t->denominator;
+	rescale.offset = t->offset;
+	values[0] = t->schan_val;
+	values[1] = t->schan_val2;
+
+	ret = rescale_process_scale(&rescale, t->schan_scale_type,
+				    &values[0], &values[1]);
+
+	ret = iio_format_value(buff, ret, 2, values);
+	KUNIT_EXPECT_EQ(test, (int)strlen(buff), ret);
+
+	rel_ppm = iio_test_relative_error_ppm(buff, t->expected);
+	KUNIT_EXPECT_GE_MSG(test, rel_ppm, 0, "failed to compute ppm\n");
+
+	KUNIT_EXPECT_EQ_MSG(test, rel_ppm, 0,
+			    "\t    real=%s"
+			    "\texpected=%s\n",
+			    buff, t->expected);
+}
+
+static void iio_rescale_test_offset(struct kunit *test)
+{
+	struct rescale_tc_data *t = (struct rescale_tc_data *)test->param_value;
+	char *buff_off = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
+	struct rescale rescale;
+	int values[2];
+	int ret;
+
+	rescale.numerator = t->numerator;
+	rescale.denominator = t->denominator;
+	rescale.offset = t->offset;
+	values[0] = t->schan_val;
+	values[1] = t->schan_val2;
+
+	ret = rescale_process_offset(&rescale, t->schan_scale_type,
+				     t->schan_val, t->schan_val2, t->schan_off,
+				     &values[0], &values[1]);
+
+	ret = iio_format_value(buff_off, ret, 2, values);
+	KUNIT_EXPECT_EQ(test, (int)strlen(buff_off), ret);
+
+	KUNIT_EXPECT_STREQ(test, strim(buff_off), t->expected_off);
+}
+
+static struct kunit_case iio_rescale_test_cases[] = {
+	KUNIT_CASE_PARAM(iio_rescale_test_scale, iio_rescale_scale_gen_params),
+	KUNIT_CASE_PARAM(iio_rescale_test_offset, iio_rescale_offset_gen_params),
+	{}
+};
+
+static struct kunit_suite iio_rescale_test_suite = {
+	.name = "iio-rescale",
+	.test_cases = iio_rescale_test_cases,
+};
+kunit_test_suite(iio_rescale_test_suite);
-- 
2.32.0.452.g940fe202adcb

Re: [PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[kernel test robot]

[-- Attachment #1: Type: text/plain, Size: 9920 bytes --]

Hi Liam,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1]

url:    https://github.com/0day-ci/linux/commits/Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
base:   2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
config: nds32-randconfig-r003-20211115 (attached as .config)
compiler: nds32le-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
        git checkout bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
        # save the attached .config to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=nds32 SHELL=/bin/bash

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All errors (new ones prefixed by >>):

   nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_offset':
>> iio-test-rescale.c:(.text+0x16): undefined reference to `kunit_kmalloc_array'
>> nds32le-linux-ld: iio-test-rescale.c:(.text+0x1a): undefined reference to `kunit_kmalloc_array'
>> nds32le-linux-ld: iio-test-rescale.c:(.text+0x80): undefined reference to `kunit_binary_assert_format'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x84): undefined reference to `kunit_binary_assert_format'
>> nds32le-linux-ld: iio-test-rescale.c:(.text+0xe0): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0xe4): undefined reference to `kunit_do_assertion'
>> nds32le-linux-ld: iio-test-rescale.c:(.text+0x104): undefined reference to `kunit_binary_str_assert_format'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x108): undefined reference to `kunit_binary_str_assert_format'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x158): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x15c): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_scale':
   iio-test-rescale.c:(.text+0x236): undefined reference to `kunit_kmalloc_array'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x23a): undefined reference to `kunit_kmalloc_array'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x2d8): undefined reference to `kunit_binary_assert_format'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x2dc): undefined reference to `kunit_binary_assert_format'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x30a): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x30e): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x476): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x47a): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: iio-test-rescale.c:(.text+0x4d8): undefined reference to `kunit_do_assertion'
   nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o:iio-test-rescale.c:(.text+0x4dc): more undefined references to `kunit_do_assertion' follow
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend':
   (.text+0x330): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: (.text+0x334): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_resume_worker':
   drm_fb_helper.c:(.text+0x35c): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x360): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_unregister_fbi':
   (.text+0x3c4): undefined reference to `unregister_framebuffer'
   nds32le-linux-ld: (.text+0x3c8): undefined reference to `unregister_framebuffer'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_fini':
   (.text+0x424): undefined reference to `fb_dealloc_cmap'
   nds32le-linux-ld: (.text+0x428): undefined reference to `fb_dealloc_cmap'
   nds32le-linux-ld: (.text+0x432): undefined reference to `framebuffer_release'
   nds32le-linux-ld: (.text+0x436): undefined reference to `framebuffer_release'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_read':
   (.text+0x4fc): undefined reference to `fb_sys_read'
   nds32le-linux-ld: (.text+0x500): undefined reference to `fb_sys_read'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_alloc_fbi':
   (.text+0xec2): undefined reference to `framebuffer_alloc'
   nds32le-linux-ld: (.text+0xec6): undefined reference to `framebuffer_alloc'
   nds32le-linux-ld: (.text+0xede): undefined reference to `fb_alloc_cmap'
   nds32le-linux-ld: (.text+0xee2): undefined reference to `fb_alloc_cmap'
   nds32le-linux-ld: (.text+0xf08): undefined reference to `fb_dealloc_cmap'
   nds32le-linux-ld: (.text+0xf0c): undefined reference to `fb_dealloc_cmap'
   nds32le-linux-ld: (.text+0xf2e): undefined reference to `framebuffer_release'
   nds32le-linux-ld: (.text+0xf32): undefined reference to `framebuffer_release'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_generic_probe':
   drm_fb_helper.c:(.text+0x102a): undefined reference to `fb_deferred_io_init'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x102e): undefined reference to `fb_deferred_io_init'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `__drm_fb_helper_initial_config_and_unlock':
   drm_fb_helper.c:(.text+0x1118): undefined reference to `register_framebuffer'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x111c): undefined reference to `register_framebuffer'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend_unlocked':
   (.text+0x1680): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: (.text+0x1684): undefined reference to `fb_set_suspend'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_write':
   (.text+0x1b96): undefined reference to `fb_sys_write'
   nds32le-linux-ld: (.text+0x1b9a): undefined reference to `fb_sys_write'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_fillrect':
   (.text+0x1bdc): undefined reference to `sys_fillrect'
   nds32le-linux-ld: (.text+0x1be0): undefined reference to `sys_fillrect'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_copyarea':
   (.text+0x1c0c): undefined reference to `sys_copyarea'
   nds32le-linux-ld: (.text+0x1c10): undefined reference to `sys_copyarea'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_imageblit':
   (.text+0x1c3c): undefined reference to `sys_imageblit'
   nds32le-linux-ld: (.text+0x1c40): undefined reference to `sys_imageblit'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_fillrect':
   (.text+0x1c6c): undefined reference to `cfb_fillrect'
   nds32le-linux-ld: (.text+0x1c70): undefined reference to `cfb_fillrect'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_copyarea':
   (.text+0x1c9c): undefined reference to `cfb_copyarea'
   nds32le-linux-ld: (.text+0x1ca0): undefined reference to `cfb_copyarea'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_imageblit':
   (.text+0x1ccc): undefined reference to `cfb_imageblit'
   nds32le-linux-ld: (.text+0x1cd0): undefined reference to `cfb_imageblit'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_copyarea':
   drm_fb_helper.c:(.text+0x1f3e): undefined reference to `cfb_copyarea'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f42): undefined reference to `cfb_copyarea'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f4e): undefined reference to `sys_copyarea'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f52): undefined reference to `sys_copyarea'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_fillrect':
   drm_fb_helper.c:(.text+0x1f8e): undefined reference to `cfb_fillrect'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f92): undefined reference to `cfb_fillrect'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f9e): undefined reference to `sys_fillrect'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fa2): undefined reference to `sys_fillrect'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_imageblit':
   drm_fb_helper.c:(.text+0x1fde): undefined reference to `cfb_imageblit'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fe2): undefined reference to `cfb_imageblit'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fee): undefined reference to `sys_imageblit'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x1ff2): undefined reference to `sys_imageblit'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_cleanup':
   drm_fb_helper.c:(.text+0x2040): undefined reference to `fb_deferred_io_cleanup'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x2044): undefined reference to `fb_deferred_io_cleanup'
   nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_client_unregister':
   drm_fb_helper.c:(.text+0x20dc): undefined reference to `unregister_framebuffer'
   nds32le-linux-ld: drm_fb_helper.c:(.text+0x20e0): undefined reference to `unregister_framebuffer'

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 34904 bytes --]

Re: [PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[Jonathan Cameron]

On Wed, 17 Nov 2021 23:03:24 +0800
kernel test robot <lkp@intel.com> wrote:

> Hi Liam,
> 
> Thank you for the patch! Yet something to improve:
> 
> [auto build test ERROR on 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1]
> 
> url:    https://github.com/0day-ci/linux/commits/Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
> base:   2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
> config: nds32-randconfig-r003-20211115 (attached as .config)
> compiler: nds32le-linux-gcc (GCC) 11.2.0
> reproduce (this is a W=1 build):
>         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>         chmod +x ~/bin/make.cross
>         # https://github.com/0day-ci/linux/commit/bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
>         git remote add linux-review https://github.com/0day-ci/linux
>         git fetch --no-tags linux-review Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
>         git checkout bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
>         # save the attached .config to linux build tree
>         mkdir build_dir
>         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=nds32 SHELL=/bin/bash
> 
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kernel test robot <lkp@intel.com>
> 

This one has me stumped.  The new tests have a depends on KUNIT and that should result in these
functions being built.
 
Anyone know what might have caused these?

Jonathan


> All errors (new ones prefixed by >>):
> 
>    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_offset':
> >> iio-test-rescale.c:(.text+0x16): undefined reference to `kunit_kmalloc_array'
> >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x1a): undefined reference to `kunit_kmalloc_array'
> >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x80): undefined reference to `kunit_binary_assert_format'  
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x84): undefined reference to `kunit_binary_assert_format'
> >> nds32le-linux-ld: iio-test-rescale.c:(.text+0xe0): undefined reference to `kunit_do_assertion'  
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0xe4): undefined reference to `kunit_do_assertion'
> >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x104): undefined reference to `kunit_binary_str_assert_format'  
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x108): undefined reference to `kunit_binary_str_assert_format'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x158): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x15c): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_scale':
>    iio-test-rescale.c:(.text+0x236): undefined reference to `kunit_kmalloc_array'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x23a): undefined reference to `kunit_kmalloc_array'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x2d8): undefined reference to `kunit_binary_assert_format'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x2dc): undefined reference to `kunit_binary_assert_format'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x30a): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x30e): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x476): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x47a): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: iio-test-rescale.c:(.text+0x4d8): undefined reference to `kunit_do_assertion'
>    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o:iio-test-rescale.c:(.text+0x4dc): more undefined references to `kunit_do_assertion' follow
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend':
>    (.text+0x330): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: (.text+0x334): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_resume_worker':
>    drm_fb_helper.c:(.text+0x35c): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x360): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_unregister_fbi':
>    (.text+0x3c4): undefined reference to `unregister_framebuffer'
>    nds32le-linux-ld: (.text+0x3c8): undefined reference to `unregister_framebuffer'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_fini':
>    (.text+0x424): undefined reference to `fb_dealloc_cmap'
>    nds32le-linux-ld: (.text+0x428): undefined reference to `fb_dealloc_cmap'
>    nds32le-linux-ld: (.text+0x432): undefined reference to `framebuffer_release'
>    nds32le-linux-ld: (.text+0x436): undefined reference to `framebuffer_release'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_read':
>    (.text+0x4fc): undefined reference to `fb_sys_read'
>    nds32le-linux-ld: (.text+0x500): undefined reference to `fb_sys_read'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_alloc_fbi':
>    (.text+0xec2): undefined reference to `framebuffer_alloc'
>    nds32le-linux-ld: (.text+0xec6): undefined reference to `framebuffer_alloc'
>    nds32le-linux-ld: (.text+0xede): undefined reference to `fb_alloc_cmap'
>    nds32le-linux-ld: (.text+0xee2): undefined reference to `fb_alloc_cmap'
>    nds32le-linux-ld: (.text+0xf08): undefined reference to `fb_dealloc_cmap'
>    nds32le-linux-ld: (.text+0xf0c): undefined reference to `fb_dealloc_cmap'
>    nds32le-linux-ld: (.text+0xf2e): undefined reference to `framebuffer_release'
>    nds32le-linux-ld: (.text+0xf32): undefined reference to `framebuffer_release'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_generic_probe':
>    drm_fb_helper.c:(.text+0x102a): undefined reference to `fb_deferred_io_init'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x102e): undefined reference to `fb_deferred_io_init'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `__drm_fb_helper_initial_config_and_unlock':
>    drm_fb_helper.c:(.text+0x1118): undefined reference to `register_framebuffer'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x111c): undefined reference to `register_framebuffer'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend_unlocked':
>    (.text+0x1680): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: (.text+0x1684): undefined reference to `fb_set_suspend'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_write':
>    (.text+0x1b96): undefined reference to `fb_sys_write'
>    nds32le-linux-ld: (.text+0x1b9a): undefined reference to `fb_sys_write'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_fillrect':
>    (.text+0x1bdc): undefined reference to `sys_fillrect'
>    nds32le-linux-ld: (.text+0x1be0): undefined reference to `sys_fillrect'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_copyarea':
>    (.text+0x1c0c): undefined reference to `sys_copyarea'
>    nds32le-linux-ld: (.text+0x1c10): undefined reference to `sys_copyarea'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_imageblit':
>    (.text+0x1c3c): undefined reference to `sys_imageblit'
>    nds32le-linux-ld: (.text+0x1c40): undefined reference to `sys_imageblit'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_fillrect':
>    (.text+0x1c6c): undefined reference to `cfb_fillrect'
>    nds32le-linux-ld: (.text+0x1c70): undefined reference to `cfb_fillrect'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_copyarea':
>    (.text+0x1c9c): undefined reference to `cfb_copyarea'
>    nds32le-linux-ld: (.text+0x1ca0): undefined reference to `cfb_copyarea'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_imageblit':
>    (.text+0x1ccc): undefined reference to `cfb_imageblit'
>    nds32le-linux-ld: (.text+0x1cd0): undefined reference to `cfb_imageblit'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_copyarea':
>    drm_fb_helper.c:(.text+0x1f3e): undefined reference to `cfb_copyarea'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f42): undefined reference to `cfb_copyarea'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f4e): undefined reference to `sys_copyarea'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f52): undefined reference to `sys_copyarea'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_fillrect':
>    drm_fb_helper.c:(.text+0x1f8e): undefined reference to `cfb_fillrect'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f92): undefined reference to `cfb_fillrect'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f9e): undefined reference to `sys_fillrect'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fa2): undefined reference to `sys_fillrect'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_imageblit':
>    drm_fb_helper.c:(.text+0x1fde): undefined reference to `cfb_imageblit'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fe2): undefined reference to `cfb_imageblit'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fee): undefined reference to `sys_imageblit'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1ff2): undefined reference to `sys_imageblit'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_cleanup':
>    drm_fb_helper.c:(.text+0x2040): undefined reference to `fb_deferred_io_cleanup'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x2044): undefined reference to `fb_deferred_io_cleanup'
>    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_client_unregister':
>    drm_fb_helper.c:(.text+0x20dc): undefined reference to `unregister_framebuffer'
>    nds32le-linux-ld: drm_fb_helper.c:(.text+0x20e0): undefined reference to `unregister_framebuffer'
> 
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

Re: [PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[Peter Rosin]

On 2021-11-21 12:19, Jonathan Cameron wrote:
> On Wed, 17 Nov 2021 23:03:24 +0800
> kernel test robot <lkp@intel.com> wrote:
> 
>> Hi Liam,
>>
>> Thank you for the patch! Yet something to improve:
>>
>> [auto build test ERROR on 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1]
>>
>> url:    https://github.com/0day-ci/linux/commits/Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
>> base:   2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
>> config: nds32-randconfig-r003-20211115 (attached as .config)
>> compiler: nds32le-linux-gcc (GCC) 11.2.0
>> reproduce (this is a W=1 build):
>>         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
>>         chmod +x ~/bin/make.cross
>>         # https://github.com/0day-ci/linux/commit/bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
>>         git remote add linux-review https://github.com/0day-ci/linux
>>         git fetch --no-tags linux-review Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
>>         git checkout bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
>>         # save the attached .config to linux build tree
>>         mkdir build_dir
>>         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=nds32 SHELL=/bin/bash
>>
>> If you fix the issue, kindly add following tag as appropriate
>> Reported-by: kernel test robot <lkp@intel.com>
>>
> 
> This one has me stumped.  The new tests have a depends on KUNIT and that should result in these
> functions being built.
>  
> Anyone know what might have caused these?

I didn't grok that either. My best guess is that the arch in question
(nds32) has some other config thingy that makes kunit build in some
weird way (or maybe not at all). But that's just a very wild guess
indeed.

I'll try to get to reviewing this new version, but I'm swamped at $-job
at the moment...

Cheers,
Peter

Re: [PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[Liam Beguin]

On Sun, Nov 21, 2021 at 11:19:58AM +0000, Jonathan Cameron wrote:
> On Wed, 17 Nov 2021 23:03:24 +0800
> kernel test robot <lkp@intel.com> wrote:
> 
> > Hi Liam,
> > 
> > Thank you for the patch! Yet something to improve:
> > 
> > [auto build test ERROR on 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1]
> > 
> > url:    https://github.com/0day-ci/linux/commits/Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
> > base:   2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
> > config: nds32-randconfig-r003-20211115 (attached as .config)
> > compiler: nds32le-linux-gcc (GCC) 11.2.0
> > reproduce (this is a W=1 build):
> >         wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
> >         chmod +x ~/bin/make.cross
> >         # https://github.com/0day-ci/linux/commit/bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
> >         git remote add linux-review https://github.com/0day-ci/linux
> >         git fetch --no-tags linux-review Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
> >         git checkout bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
> >         # save the attached .config to linux build tree
> >         mkdir build_dir
> >         COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=nds32 SHELL=/bin/bash
> > 
> > If you fix the issue, kindly add following tag as appropriate
> > Reported-by: kernel test robot <lkp@intel.com>
> > 
> 
> This one has me stumped.  The new tests have a depends on KUNIT and that should result in these
> functions being built.
>  

I only took a quick look at this, but was quite puzzled too.
I'll try to find more time to investigate.

Cheers,
Liam

> Anyone know what might have caused these?
> 
> Jonathan
> 
> 
> > All errors (new ones prefixed by >>):
> > 
> >    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_offset':
> > >> iio-test-rescale.c:(.text+0x16): undefined reference to `kunit_kmalloc_array'
> > >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x1a): undefined reference to `kunit_kmalloc_array'
> > >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x80): undefined reference to `kunit_binary_assert_format'  
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x84): undefined reference to `kunit_binary_assert_format'
> > >> nds32le-linux-ld: iio-test-rescale.c:(.text+0xe0): undefined reference to `kunit_do_assertion'  
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0xe4): undefined reference to `kunit_do_assertion'
> > >> nds32le-linux-ld: iio-test-rescale.c:(.text+0x104): undefined reference to `kunit_binary_str_assert_format'  
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x108): undefined reference to `kunit_binary_str_assert_format'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x158): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x15c): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_scale':
> >    iio-test-rescale.c:(.text+0x236): undefined reference to `kunit_kmalloc_array'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x23a): undefined reference to `kunit_kmalloc_array'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x2d8): undefined reference to `kunit_binary_assert_format'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x2dc): undefined reference to `kunit_binary_assert_format'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x30a): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x30e): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x476): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x47a): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: iio-test-rescale.c:(.text+0x4d8): undefined reference to `kunit_do_assertion'
> >    nds32le-linux-ld: drivers/iio/test/iio-test-rescale.o:iio-test-rescale.c:(.text+0x4dc): more undefined references to `kunit_do_assertion' follow
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend':
> >    (.text+0x330): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: (.text+0x334): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_resume_worker':
> >    drm_fb_helper.c:(.text+0x35c): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x360): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_unregister_fbi':
> >    (.text+0x3c4): undefined reference to `unregister_framebuffer'
> >    nds32le-linux-ld: (.text+0x3c8): undefined reference to `unregister_framebuffer'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_fini':
> >    (.text+0x424): undefined reference to `fb_dealloc_cmap'
> >    nds32le-linux-ld: (.text+0x428): undefined reference to `fb_dealloc_cmap'
> >    nds32le-linux-ld: (.text+0x432): undefined reference to `framebuffer_release'
> >    nds32le-linux-ld: (.text+0x436): undefined reference to `framebuffer_release'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_read':
> >    (.text+0x4fc): undefined reference to `fb_sys_read'
> >    nds32le-linux-ld: (.text+0x500): undefined reference to `fb_sys_read'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_alloc_fbi':
> >    (.text+0xec2): undefined reference to `framebuffer_alloc'
> >    nds32le-linux-ld: (.text+0xec6): undefined reference to `framebuffer_alloc'
> >    nds32le-linux-ld: (.text+0xede): undefined reference to `fb_alloc_cmap'
> >    nds32le-linux-ld: (.text+0xee2): undefined reference to `fb_alloc_cmap'
> >    nds32le-linux-ld: (.text+0xf08): undefined reference to `fb_dealloc_cmap'
> >    nds32le-linux-ld: (.text+0xf0c): undefined reference to `fb_dealloc_cmap'
> >    nds32le-linux-ld: (.text+0xf2e): undefined reference to `framebuffer_release'
> >    nds32le-linux-ld: (.text+0xf32): undefined reference to `framebuffer_release'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_generic_probe':
> >    drm_fb_helper.c:(.text+0x102a): undefined reference to `fb_deferred_io_init'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x102e): undefined reference to `fb_deferred_io_init'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `__drm_fb_helper_initial_config_and_unlock':
> >    drm_fb_helper.c:(.text+0x1118): undefined reference to `register_framebuffer'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x111c): undefined reference to `register_framebuffer'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend_unlocked':
> >    (.text+0x1680): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: (.text+0x1684): undefined reference to `fb_set_suspend'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_write':
> >    (.text+0x1b96): undefined reference to `fb_sys_write'
> >    nds32le-linux-ld: (.text+0x1b9a): undefined reference to `fb_sys_write'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_fillrect':
> >    (.text+0x1bdc): undefined reference to `sys_fillrect'
> >    nds32le-linux-ld: (.text+0x1be0): undefined reference to `sys_fillrect'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_copyarea':
> >    (.text+0x1c0c): undefined reference to `sys_copyarea'
> >    nds32le-linux-ld: (.text+0x1c10): undefined reference to `sys_copyarea'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_imageblit':
> >    (.text+0x1c3c): undefined reference to `sys_imageblit'
> >    nds32le-linux-ld: (.text+0x1c40): undefined reference to `sys_imageblit'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_fillrect':
> >    (.text+0x1c6c): undefined reference to `cfb_fillrect'
> >    nds32le-linux-ld: (.text+0x1c70): undefined reference to `cfb_fillrect'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_copyarea':
> >    (.text+0x1c9c): undefined reference to `cfb_copyarea'
> >    nds32le-linux-ld: (.text+0x1ca0): undefined reference to `cfb_copyarea'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_imageblit':
> >    (.text+0x1ccc): undefined reference to `cfb_imageblit'
> >    nds32le-linux-ld: (.text+0x1cd0): undefined reference to `cfb_imageblit'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_copyarea':
> >    drm_fb_helper.c:(.text+0x1f3e): undefined reference to `cfb_copyarea'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f42): undefined reference to `cfb_copyarea'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f4e): undefined reference to `sys_copyarea'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f52): undefined reference to `sys_copyarea'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_fillrect':
> >    drm_fb_helper.c:(.text+0x1f8e): undefined reference to `cfb_fillrect'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f92): undefined reference to `cfb_fillrect'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1f9e): undefined reference to `sys_fillrect'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fa2): undefined reference to `sys_fillrect'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_imageblit':
> >    drm_fb_helper.c:(.text+0x1fde): undefined reference to `cfb_imageblit'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fe2): undefined reference to `cfb_imageblit'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1fee): undefined reference to `sys_imageblit'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x1ff2): undefined reference to `sys_imageblit'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_cleanup':
> >    drm_fb_helper.c:(.text+0x2040): undefined reference to `fb_deferred_io_cleanup'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x2044): undefined reference to `fb_deferred_io_cleanup'
> >    nds32le-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_client_unregister':
> >    drm_fb_helper.c:(.text+0x20dc): undefined reference to `unregister_framebuffer'
> >    nds32le-linux-ld: drm_fb_helper.c:(.text+0x20e0): undefined reference to `unregister_framebuffer'
> > 
> > ---
> > 0-DAY CI Kernel Test Service, Intel Corporation
> > https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
> 

Re: [PATCH v9 10/14] iio: test: add basic tests for the iio-rescale driver

[kernel test robot]

Hi Liam,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1]

url:    https://github.com/0day-ci/linux/commits/Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
base:   2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
config: openrisc-randconfig-c003-20211115 (https://download.01.org/0day-ci/archive/20211125/202111250238.lNOwhSKW-lkp@intel.com/config)
compiler: or1k-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Liam-Beguin/iio-afe-add-temperature-rescaling-support/20211115-114729
        git checkout bef63a2e36c2ceccc6f5954ab7e7cbb178c08fd8
        # save the config file to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=openrisc SHELL=/bin/bash

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All errors (new ones prefixed by >>):

   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend':
   (.text+0x46c): undefined reference to `fb_set_suspend'
   (.text+0x46c): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_set_suspend'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_resume_worker':
   drm_fb_helper.c:(.text+0x4d8): undefined reference to `fb_set_suspend'
   drm_fb_helper.c:(.text+0x4d8): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_set_suspend'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_unregister_fbi':
   (.text+0x76c): undefined reference to `unregister_framebuffer'
   (.text+0x76c): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `unregister_framebuffer'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_fini':
   (.text+0x878): undefined reference to `framebuffer_release'
   (.text+0x878): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `framebuffer_release'
   or1k-linux-ld: (.text+0x9f0): undefined reference to `fb_dealloc_cmap'
   (.text+0x9f0): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_dealloc_cmap'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_read':
   (.text+0xa40): undefined reference to `fb_sys_read'
   (.text+0xa40): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_sys_read'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_alloc_fbi':
   (.text+0x25e8): undefined reference to `framebuffer_alloc'
   (.text+0x25e8): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `framebuffer_alloc'
   or1k-linux-ld: (.text+0x2620): undefined reference to `fb_alloc_cmap'
   (.text+0x2620): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_alloc_cmap'
   or1k-linux-ld: (.text+0x2648): undefined reference to `framebuffer_release'
   (.text+0x2648): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `framebuffer_release'
   or1k-linux-ld: (.text+0x2788): undefined reference to `fb_dealloc_cmap'
   (.text+0x2788): relocation truncated to fit: R_OR1K_INSN_REL_26 against undefined symbol `fb_dealloc_cmap'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `__drm_fb_helper_initial_config_and_unlock':
   drm_fb_helper.c:(.text+0x2854): undefined reference to `register_framebuffer'
   drm_fb_helper.c:(.text+0x2854): additional relocation overflows omitted from the output
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_set_suspend_unlocked':
   (.text+0x37a8): undefined reference to `fb_set_suspend'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_generic_probe':
   drm_fb_helper.c:(.text+0x45c4): undefined reference to `fb_deferred_io_init'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_imageblit':
   (.text+0x4bd4): undefined reference to `cfb_imageblit'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_copyarea':
   (.text+0x4c54): undefined reference to `cfb_copyarea'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_cfb_fillrect':
   (.text+0x4cd4): undefined reference to `cfb_fillrect'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_imageblit':
   (.text+0x4d54): undefined reference to `sys_imageblit'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_copyarea':
   (.text+0x4dd4): undefined reference to `sys_copyarea'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_fillrect':
   (.text+0x4e54): undefined reference to `sys_fillrect'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fb_helper_sys_write':
   (.text+0x4ecc): undefined reference to `fb_sys_write'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_fillrect':
   drm_fb_helper.c:(.text+0x5108): undefined reference to `cfb_fillrect'
   or1k-linux-ld: drm_fb_helper.c:(.text+0x5148): undefined reference to `sys_fillrect'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_imageblit':
   drm_fb_helper.c:(.text+0x51c8): undefined reference to `cfb_imageblit'
   or1k-linux-ld: drm_fb_helper.c:(.text+0x5208): undefined reference to `sys_imageblit'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_fb_copyarea':
   drm_fb_helper.c:(.text+0x5288): undefined reference to `cfb_copyarea'
   or1k-linux-ld: drm_fb_helper.c:(.text+0x52c8): undefined reference to `sys_copyarea'
   or1k-linux-ld: drivers/gpu/drm/drm_fb_helper.o: in function `drm_fbdev_cleanup':
   drm_fb_helper.c:(.text+0x5570): undefined reference to `fb_deferred_io_cleanup'
   or1k-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_offset':
   iio-test-rescale.c:(.text+0x34): undefined reference to `kunit_kmalloc_array'
>> or1k-linux-ld: iio-test-rescale.c:(.text+0xc4): undefined reference to `kunit_binary_assert_format'
   or1k-linux-ld: iio-test-rescale.c:(.text+0xc8): undefined reference to `kunit_binary_assert_format'
>> or1k-linux-ld: iio-test-rescale.c:(.text+0x12c): undefined reference to `kunit_do_assertion'
>> or1k-linux-ld: iio-test-rescale.c:(.text+0x148): undefined reference to `kunit_binary_str_assert_format'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x14c): undefined reference to `kunit_binary_str_assert_format'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x1b0): undefined reference to `kunit_do_assertion'
   or1k-linux-ld: drivers/iio/test/iio-test-rescale.o: in function `iio_rescale_test_scale':
   iio-test-rescale.c:(.text+0x380): undefined reference to `kunit_kmalloc_array'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x420): undefined reference to `kunit_binary_assert_format'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x440): undefined reference to `kunit_binary_assert_format'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x470): undefined reference to `kunit_do_assertion'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x6bc): undefined reference to `kunit_do_assertion'
   or1k-linux-ld: iio-test-rescale.c:(.text+0x730): undefined reference to `kunit_do_assertion'

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[PATCH v9 11/14] iio: afe: rescale: add RTD temperature sensor support

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

An RTD (Resistance Temperature Detector) is a kind of temperature
sensor used to get a linear voltage to temperature reading within a
give range (usually 0 to 100 degrees Celsius). Common types of RTDs
include PT100, PT500, and PT1000.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 48 +++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index 8a2f1c0ca5a3..ea162ba2a674 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -381,10 +381,52 @@ static int rescale_voltage_divider_props(struct device *dev,
 	return 0;
 }
 
+static int rescale_temp_sense_rtd_props(struct device *dev,
+					struct rescale *rescale)
+{
+	u32 factor;
+	u32 alpha;
+	u32 iexc;
+	u32 tmp;
+	int ret;
+	u32 r0;
+
+	ret = device_property_read_u32(dev, "excitation-current-microamp",
+				       &iexc);
+	if (ret) {
+		dev_err(dev, "failed to read excitation-current-microamp: %d\n",
+			ret);
+		return ret;
+	}
+
+	ret = device_property_read_u32(dev, "alpha-ppm-per-celsius", &alpha);
+	if (ret) {
+		dev_err(dev, "failed to read alpha-ppm-per-celsius: %d\n",
+			ret);
+		return ret;
+	}
+
+	ret = device_property_read_u32(dev, "r-naught-ohms", &r0);
+	if (ret) {
+		dev_err(dev, "failed to read r-naught-ohms: %d\n", ret);
+		return ret;
+	}
+
+	tmp = r0 * iexc * alpha / 1000000;
+	factor = gcd(tmp, 1000000);
+	rescale->numerator = 1000000 / factor;
+	rescale->denominator = tmp / factor;
+
+	rescale->offset = -1 * ((r0 * iexc) / 1000);
+
+	return 0;
+}
+
 enum rescale_variant {
 	CURRENT_SENSE_AMPLIFIER,
 	CURRENT_SENSE_SHUNT,
 	VOLTAGE_DIVIDER,
+	TEMP_SENSE_RTD,
 };
 
 static const struct rescale_cfg rescale_cfg[] = {
@@ -400,6 +442,10 @@ static const struct rescale_cfg rescale_cfg[] = {
 		.type = IIO_VOLTAGE,
 		.props = rescale_voltage_divider_props,
 	},
+	[TEMP_SENSE_RTD] = {
+		.type = IIO_TEMP,
+		.props = rescale_temp_sense_rtd_props,
+	},
 };
 
 static const struct of_device_id rescale_match[] = {
@@ -409,6 +455,8 @@ static const struct of_device_id rescale_match[] = {
 	  .data = &rescale_cfg[CURRENT_SENSE_SHUNT], },
 	{ .compatible = "voltage-divider",
 	  .data = &rescale_cfg[VOLTAGE_DIVIDER], },
+	{ .compatible = "temperature-sense-rtd",
+	  .data = &rescale_cfg[TEMP_SENSE_RTD], },
 	{ /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, rescale_match);
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 12/14] iio: afe: rescale: add temperature transducers

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

A temperature transducer is a device that converts a thermal quantity
into any other physical quantity. This patch add support for temperature
to voltage (like the LTC2997) and temperature to current (like the
AD590) linear transducers.
In both cases these are assumed to be connected to a voltage ADC.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
---
 drivers/iio/afe/iio-rescale.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/drivers/iio/afe/iio-rescale.c b/drivers/iio/afe/iio-rescale.c
index ea162ba2a674..6bdcf6e139c7 100644
--- a/drivers/iio/afe/iio-rescale.c
+++ b/drivers/iio/afe/iio-rescale.c
@@ -422,11 +422,37 @@ static int rescale_temp_sense_rtd_props(struct device *dev,
 	return 0;
 }
 
+static int rescale_temp_transducer_props(struct device *dev,
+					 struct rescale *rescale)
+{
+	s32 offset = 0;
+	s32 sense = 1;
+	s32 alpha;
+	int ret;
+
+	device_property_read_u32(dev, "sense-offset-millicelsius", &offset);
+	device_property_read_u32(dev, "sense-resistor-ohms", &sense);
+	ret = device_property_read_u32(dev, "alpha-ppm-per-celsius", &alpha);
+	if (ret) {
+		dev_err(dev, "failed to read alpha-ppm-per-celsius: %d\n", ret);
+		return ret;
+	}
+
+	rescale->numerator = 1000000;
+	rescale->denominator = alpha * sense;
+
+	rescale->offset = div_s64((s64)offset * rescale->denominator,
+				  rescale->numerator);
+
+	return 0;
+}
+
 enum rescale_variant {
 	CURRENT_SENSE_AMPLIFIER,
 	CURRENT_SENSE_SHUNT,
 	VOLTAGE_DIVIDER,
 	TEMP_SENSE_RTD,
+	TEMP_TRANSDUCER,
 };
 
 static const struct rescale_cfg rescale_cfg[] = {
@@ -446,6 +472,10 @@ static const struct rescale_cfg rescale_cfg[] = {
 		.type = IIO_TEMP,
 		.props = rescale_temp_sense_rtd_props,
 	},
+	[TEMP_TRANSDUCER] = {
+		.type = IIO_TEMP,
+		.props = rescale_temp_transducer_props,
+	},
 };
 
 static const struct of_device_id rescale_match[] = {
@@ -457,6 +487,8 @@ static const struct of_device_id rescale_match[] = {
 	  .data = &rescale_cfg[VOLTAGE_DIVIDER], },
 	{ .compatible = "temperature-sense-rtd",
 	  .data = &rescale_cfg[TEMP_SENSE_RTD], },
+	{ .compatible = "temperature-transducer",
+	  .data = &rescale_cfg[TEMP_TRANSDUCER], },
 	{ /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, rescale_match);
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 13/14] dt-bindings: iio: afe: add bindings for temperature-sense-rtd

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

An ADC is often used to measure other quantities indirectly. This
binding describe one case, the measurement of a temperature through the
voltage across an RTD resistor such as a PT1000.

Signed-off-by: Liam Beguin <lvb@xiphos.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---
 .../iio/afe/temperature-sense-rtd.yaml        | 101 ++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml

diff --git a/Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml b/Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml
new file mode 100644
index 000000000000..336ce96371db
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/iio/afe/temperature-sense-rtd.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Temperature Sense RTD
+
+maintainers:
+  - Liam Beguin <liambeguin@gmail.com>
+
+description: |
+  RTDs (Resistance Temperature Detectors) are a kind of temperature sensors
+  used to get a linear voltage to temperature reading within a give range
+  (usually 0 to 100 degrees Celsius).
+
+  When an io-channel measures the output voltage across an RTD such as a
+  PT1000, the interesting measurement is almost always the corresponding
+  temperature, not the voltage output. This binding describes such a circuit.
+
+  The general transfer function here is (using SI units)
+
+    V = R(T) * iexc
+    R(T) = r0 * (1 + alpha * T)
+    T = 1 / (alpha * r0 * iexc) * (V - r0 * iexc)
+
+  The following circuit matches what's in the examples section.
+
+           5V0
+          -----
+            |
+        +---+----+
+        |  R 5k  |
+        +---+----+
+            |
+            V 1mA
+            |
+            +---- Vout
+            |
+        +---+----+
+        | PT1000 |
+        +---+----+
+            |
+          -----
+           GND
+
+properties:
+  compatible:
+    const: temperature-sense-rtd
+
+  io-channels:
+    maxItems: 1
+    description: |
+      Channel node of a voltage io-channel.
+
+  '#io-channel-cells':
+    const: 0
+
+  excitation-current-microamp:
+    description: The current fed through the RTD sensor.
+
+  alpha-ppm-per-celsius:
+    description: |
+      alpha can also be expressed in micro-ohms per ohm Celsius. It's a linear
+      approximation of the resistance versus temperature relationship
+      between 0 and 100 degrees Celsius.
+
+      alpha = (R_100 - R_0) / (100 * R_0)
+
+      Where, R_100 is the resistance of the sensor at 100 degrees Celsius, and
+      R_0 (or r-naught-ohms) is the resistance of the sensor at 0 degrees
+      Celsius.
+
+      Pure platinum has an alpha of 3925. Industry standards such as IEC60751
+      and ASTM E-1137 specify an alpha of 3850.
+
+  r-naught-ohms:
+    description: |
+      Resistance of the sensor at 0 degrees Celsius.
+      Common values are 100 for PT100, 500 for PT500, and 1000 for PT1000
+
+additionalProperties: false
+required:
+  - compatible
+  - io-channels
+  - excitation-current-microamp
+  - alpha-ppm-per-celsius
+  - r-naught-ohms
+
+examples:
+  - |
+    pt1000_1: temperature-sensor0 {
+        compatible = "temperature-sense-rtd";
+        #io-channel-cells = <0>;
+        io-channels = <&temp_adc1 0>;
+
+        excitation-current-microamp = <1000>; /* i = U/R = 5 / 5000 */
+        alpha-ppm-per-celsius = <3908>;
+        r-naught-ohms = <1000>;
+    };
+...
-- 
2.32.0.452.g940fe202adcb

[PATCH v9 14/14] dt-bindings: iio: afe: add bindings for temperature transducers

[Liam Beguin]

From: Liam Beguin <lvb@xiphos.com>

An ADC is often used to measure other quantities indirectly.
This binding describe one case, the measurement of a temperature
through a temperature transducer (either voltage or current).

Signed-off-by: Liam Beguin <lvb@xiphos.com>
Reviewed-by: Rob Herring <robh@kernel.org>
---
 .../iio/afe/temperature-transducer.yaml       | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml

diff --git a/Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml b/Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml
new file mode 100644
index 000000000000..cfbf5350db27
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml
@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/iio/afe/temperature-transducer.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Temperature Transducer
+
+maintainers:
+  - Liam Beguin <liambeguin@gmail.com>
+
+description: |
+  A temperature transducer is a device that converts a thermal quantity
+  into any other physical quantity. This binding applies to temperature to
+  voltage (like the LTC2997), and temperature to current (like the AD590)
+  linear transducers.
+  In both cases these are assumed to be connected to a voltage ADC.
+
+  When an io-channel measures the output voltage of a temperature analog front
+  end such as a temperature transducer, the interesting measurement is almost
+  always the corresponding temperature, not the voltage output. This binding
+  describes such a circuit.
+
+  The general transfer function here is (using SI units)
+    V(T) = Rsense * Isense(T)
+    T = (Isense(T) / alpha) + offset
+    T = 1 / (Rsense * alpha) * (V + offset * Rsense * alpha)
+
+  When using a temperature to voltage transducer, Rsense is set to 1.
+
+  The following circuits show a temperature to current and a temperature to
+  voltage transducer that can be used with this binding.
+
+           VCC
+          -----
+            |
+        +---+---+
+        | AD590 |                               VCC
+        +---+---+                              -----
+            |                                    |
+            V proportional to T             +----+----+
+            |                          D+ --+         |
+            +---- Vout                      | LTC2997 +--- Vout
+            |                          D- --+         |
+        +---+----+                          +---------+
+        | Rsense |                               |
+        +---+----+                             -----
+            |                                   GND
+          -----
+           GND
+
+properties:
+  compatible:
+    const: temperature-transducer
+
+  io-channels:
+    maxItems: 1
+    description: |
+      Channel node of a voltage io-channel.
+
+  '#io-channel-cells':
+    const: 0
+
+  sense-offset-millicelsius:
+    description: |
+      Temperature offset.
+      This offset is commonly used to convert from Kelvins to degrees Celsius.
+      In that case, sense-offset-millicelsius would be set to <(-273150)>.
+    default: 0
+
+  sense-resistor-ohms:
+    description: |
+      The sense resistor.
+      By default sense-resistor-ohms cancels out the resistor making the
+      circuit behave like a temperature transducer.
+    default: 1
+
+  alpha-ppm-per-celsius:
+    description: |
+      Sometimes referred to as output gain, slope, or temperature coefficient.
+
+      alpha is expressed in parts per million which can be micro-amps per
+      degrees Celsius or micro-volts per degrees Celsius. The is the main
+      characteristic of a temperature transducer and should be stated in the
+      datasheet.
+
+additionalProperties: false
+
+required:
+  - compatible
+  - io-channels
+  - alpha-ppm-per-celsius
+
+examples:
+  - |
+    ad950: temperature-sensor-0 {
+        compatible = "temperature-transducer";
+        #io-channel-cells = <0>;
+        io-channels = <&temp_adc 3>;
+
+        sense-offset-millicelsius = <(-273150)>; /* Kelvin to degrees Celsius */
+        sense-resistor-ohms = <8060>;
+        alpha-ppm-per-celsius = <1>; /* 1 uA/K */
+    };
+  - |
+    znq_tmp: temperature-sensor-1 {
+        compatible = "temperature-transducer";
+        #io-channel-cells = <0>;
+        io-channels = <&temp_adc 2>;
+
+        sense-offset-millicelsius = <(-273150)>; /* Kelvin to degrees Celsius */
+        alpha-ppm-per-celsius = <4000>; /* 4 mV/K */
+    };
+...
-- 
2.32.0.452.g940fe202adcb

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Jonathan Cameron]

On Sun, 14 Nov 2021 22:43:20 -0500
Liam Beguin <liambeguin@gmail.com> wrote:

> Hi Jonathan, Peter,
> 
> Apologies for not getting back to you sooner. I got caught up on other
> work and wasn't able to dedicate time to this earlier. Hopefully, this
> time around, I'll be able to get this to the finish line :-)
> 
> I left out IIO_VAL_INT overflows for now, so that I can focus on getting
> the rest of these changes pulled in, but I don't mind adding a patch for
> that later on.
> 
> This series focuses on adding temperature rescaling support to the IIO
> Analog Front End (AFE) driver.
> 
> The first few patches address minor bugs in IIO inkernel functions, and
> prepare the AFE driver for the additional features.
> 
> The main changes to the AFE driver include an initial Kunit test suite,
> support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
> and temperature transducer sensors.
> 
> Thanks for your time,
> Liam

Hi Liam,

I'm fine with these.  The comment about using the MICRO etc defines can
be handled as as trivial follow up patch. Hopefully someone else can
figure out the 0-day build issue as I didn't managed to.

However, I've long ago lost track of the various precision discussions
you and Peter were having so would like Peter's input before taking these.

Thanks again for your persistence with this,

Jonathan

> 
> Changes since v8:
> - reword comment
> - fix erroneous 64-bit division
> - optimize and use 32-bit divisions when values are know to not overflow
> - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
>   point
> - add test cases
> - use nano precision in test cases
> - simplify offset calculation in rtd_props()
> 
> Changes since v7:
> - drop gcd() logic in rescale_process_scale()
> - use div_s64() instead of do_div() for signed 64-bit divisions
> - combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
> - switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
> - rework test logic to allow for small relative error
> - rename test variables to align error output messages
> 
> Changes since v6:
> - rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
> - combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
> - add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
> - force use of positive integers with gcd()
> - reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
> - fix duplicate symbol build error
> - apply Reviewed-by
> 
> Changes since v5:
> - add include/linux/iio/afe/rescale.h
> - expose functions use to process scale and offset
> - add basic iio-rescale kunit test cases
> - fix integer overflow case
> - improve precision for IIO_VAL_FRACTIONAL_LOG2
> 
> Changes since v4:
> - only use gcd() when necessary in overflow mitigation
> - fix INT_PLUS_{MICRO,NANO} support
> - apply Reviewed-by
> - fix temperature-transducer bindings
> 
> Changes since v3:
> - drop unnecessary fallthrough statements
> - drop redundant local variables in some calculations
> - fix s64 divisions on 32bit platforms by using do_div
> - add comment describing iio-rescaler offset calculation
> - drop unnecessary MAINTAINERS entry
> 
> Changes since v2:
> - don't break implicit offset truncations
> - make a best effort to get a valid value for fractional types
> - drop return value change in iio_convert_raw_to_processed_unlocked()
> - don't rely on processed value for offset calculation
> - add INT_PLUS_{MICRO,NANO} support in iio-rescale
> - revert generic implementation in favor of temperature-sense-rtd and
>   temperature-transducer
> - add separate section to MAINTAINERS file
> 
> Changes since v1:
> - rebase on latest iio `testing` branch
> - also apply consumer scale on integer channel scale types
> - don't break implicit truncation in processed channel offset
>   calculation
> - drop temperature AFE flavors in favor of a simpler generic
>   implementation
> 
> Liam Beguin (14):
>   iio: inkern: apply consumer scale on IIO_VAL_INT cases
>   iio: inkern: apply consumer scale when no channel scale is available
>   iio: inkern: make a best effort on offset calculation
>   iio: afe: rescale: expose scale processing function
>   iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
>   iio: afe: rescale: add offset support
>   iio: afe: rescale: use s64 for temporary scale calculations
>   iio: afe: rescale: reduce risk of integer overflow
>   iio: afe: rescale: fix accuracy for small fractional scales
>   iio: test: add basic tests for the iio-rescale driver
>   iio: afe: rescale: add RTD temperature sensor support
>   iio: afe: rescale: add temperature transducers
>   dt-bindings: iio: afe: add bindings for temperature-sense-rtd
>   dt-bindings: iio: afe: add bindings for temperature transducers
> 
>  .../iio/afe/temperature-sense-rtd.yaml        | 101 +++
>  .../iio/afe/temperature-transducer.yaml       | 114 +++
>  drivers/iio/afe/iio-rescale.c                 | 271 ++++++-
>  drivers/iio/inkern.c                          |  40 +-
>  drivers/iio/test/Kconfig                      |  10 +
>  drivers/iio/test/Makefile                     |   1 +
>  drivers/iio/test/iio-test-rescale.c           | 705 ++++++++++++++++++
>  include/linux/iio/afe/rescale.h               |  34 +
>  8 files changed, 1232 insertions(+), 44 deletions(-)
>  create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml
>  create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml
>  create mode 100644 drivers/iio/test/iio-test-rescale.c
>  create mode 100644 include/linux/iio/afe/rescale.h
> 
> Range-diff against v8:
>  1:  42a7a1047edc =  1:  ae3cc93baee6 iio: inkern: apply consumer scale on IIO_VAL_INT cases
>  2:  a1cd89fdad11 =  2:  06f66e7f7403 iio: inkern: apply consumer scale when no channel scale is available
>  3:  ed0721fb6bd1 =  3:  2dbf6b3bbaeb iio: inkern: make a best effort on offset calculation
>  4:  f8fb78bb1112 =  4:  b083cf307268 iio: afe: rescale: expose scale processing function
>  5:  504b7a3f830b !  5:  a0bde29ecc8c iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
>     @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
>      +		else
>      +			mult = 1000000LL;
>      +		/*
>     -+		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if *val OR
>     -+		 * *val2 is negative the schan scale is negative
>     ++		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if either *val
>     ++		 * OR *val2 is negative the schan scale is negative, i.e.
>     ++		 * *val = 1 and *val2 = -0.5 yields -1.5 not -0.5.
>      +		 */
>      +		neg = *val < 0 || *val2 < 0;
>      +
>  6:  c254e9ae813e =  6:  c3d0e6248033 iio: afe: rescale: add offset support
>  7:  ee8814d6abe4 =  7:  2a81fa735103 iio: afe: rescale: use s64 for temporary scale calculations
>  8:  62cdcfbc9836 =  8:  8315548d0fce iio: afe: rescale: reduce risk of integer overflow
>  9:  88309a5136ee !  9:  223ed0569cd2 iio: afe: rescale: fix accuracy for small fractional scales
>     @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
>      +
>      +		tmp = div_s64_rem(tmp, 1000000000LL, &rem);
>       		*val = tmp;
>     +-		return scale_type;
>     ++
>     ++		if (!rem)
>     ++			return scale_type;
>      +
>     -+		/*
>     -+		 * For small values, the approximation can be costly,
>     -+		 * change scale type to maintain accuracy.
>     -+		 *
>     -+		 * 100 vs. 10000000 NANO caps the error to about 100 ppm.
>     -+		 */
>      +		if (scale_type == IIO_VAL_FRACTIONAL)
>      +			tmp = *val2;
>      +		else
>      +			tmp = 1 << *val2;
>      +
>     -+		 if (abs(rem) > 10000000 && abs(*val / tmp) < 100) {
>     -+			 *val = div_s64_rem(*val, tmp, &rem2);
>     -+
>     -+			 *val2 = div_s64(rem, tmp);
>     -+			 if (rem2)
>     -+				 *val2 += div_s64(rem2 * 1000000000LL, tmp);
>     ++		rem2 = *val % (int)tmp;
>     ++		*val = *val / (int)tmp;
>      +
>     -+			 return IIO_VAL_INT_PLUS_NANO;
>     -+		 }
>     ++		*val2 = rem / (int)tmp;
>     ++		if (rem2)
>     ++			*val2 += div_s64((s64)rem2 * 1000000000LL, tmp);
>      +
>     - 		return scale_type;
>     ++		return IIO_VAL_INT_PLUS_NANO;
>       	case IIO_VAL_INT_PLUS_NANO:
>       	case IIO_VAL_INT_PLUS_MICRO:
>     + 		if (scale_type == IIO_VAL_INT_PLUS_NANO)
> 10:  fb505a9f42f1 ! 10:  90044efdf8be iio: test: add basic tests for the iio-rescale driver
>     @@ drivers/iio/test/Makefile
>       # Keep in alphabetical order
>      +obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) += iio-test-rescale.o ../afe/iio-rescale.o
>       obj-$(CONFIG_IIO_TEST_FORMAT) += iio-test-format.o
>     + CFLAGS_iio-test-format.o += $(DISABLE_STRUCTLEAK_PLUGIN)
>      
>       ## drivers/iio/test/iio-test-rescale.c (new) ##
>      @@
>     @@ drivers/iio/test/iio-test-rescale.c (new)
>      +	 * Use cases with small scales involving divisions
>      +	 */
>      +	{
>     ++		.name = "small IIO_VAL_FRACTIONAL, 261/509 scaled by 90/1373754273",
>     ++		.numerator = 261,
>     ++		.denominator = 509,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
>     ++		.schan_val = 90,
>     ++		.schan_val2 = 1373754273,
>     ++		.expected = "0.000000033594",
>     ++	},
>     ++	{
>     ++		.name = "small IIO_VAL_FRACTIONAL, 90/1373754273 scaled by 261/509",
>     ++		.numerator = 90,
>     ++		.denominator = 1373754273,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
>     ++		.schan_val = 261,
>     ++		.schan_val2 = 509,
>     ++		.expected = "0.000000033594",
>     ++	},
>     ++	{
>     ++		.name = "small IIO_VAL_FRACTIONAL, 760/1373754273 scaled by 427/2727",
>     ++		.numerator = 760,
>     ++		.denominator = 1373754273,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
>     ++		.schan_val = 427,
>     ++		.schan_val2 = 2727,
>     ++		.expected = "0.000000086626",
>     ++	},
>     ++	{
>     ++		.name = "small IIO_VAL_FRACTIONAL, 761/1373754273 scaled by 427/2727",
>     ++		.numerator = 761,
>     ++		.denominator = 1373754273,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
>     ++		.schan_val = 427,
>     ++		.schan_val2 = 2727,
>     ++		.expected = "0.000000086740",
>     ++	},
>     ++	{
>     ++		.name = "small IIO_VAL_FRACTIONAL, 5/32768 scaled by 3/10000",
>     ++		.numerator = 5,
>     ++		.denominator = 32768,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
>     ++		.schan_val = 3,
>     ++		.schan_val2 = 10000,
>     ++		.expected = "0.0000000457763671875",
>     ++	},
>     ++	{
>      +		.name = "small IIO_VAL_FRACTIONAL, 0 < scale < 1",
>      +		.numerator = 6,
>      +		.denominator = 6,
>     @@ drivers/iio/test/iio-test-rescale.c (new)
>      +		.expected = "-1.3333333333333333",
>      +	},
>      +	{
>     ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 760/32768 scaled by 15/22",
>     ++		.numerator = 760,
>     ++		.denominator = 32768,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
>     ++		.schan_val = 15,
>     ++		.schan_val2 = 22,
>     ++		.expected = "0.000000082946",
>     ++	},
>     ++	{
>     ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 761/32768 scaled by 15/22",
>     ++		.numerator = 761,
>     ++		.denominator = 32768,
>     ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
>     ++		.schan_val = 15,
>     ++		.schan_val2 = 22,
>     ++		.expected = "0.000000083055",
>     ++	},
>     ++	{
>      +		.name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 1",
>      +		.numerator = 16,
>      +		.denominator = 3,
>     @@ drivers/iio/test/iio-test-rescale.c (new)
>      +KUNIT_ARRAY_PARAM(iio_rescale_offset, offset_cases, case_to_desc);
>      +
>      +/**
>     -+ * iio_str_to_micro() - Parse a fixed-point string to get an
>     -+ *                      IIO_VAL_INT_PLUS_MICRO value
>     ++ * iio_str_to_nano() - Parse a fixed-point string to get an
>     ++ *                      IIO_VAL_INT_PLUS_NANO value
>      + * @str: The string to parse
>     -+ * @micro: The number as an integer
>     ++ * @nano: The number as an integer
>      + *
>      + * Returns 0 on success, or a negative error code if the string cound not be
>      + * parsed.
>      + */
>     -+static int iio_str_to_micro(const char *str, s64 *micro)
>     ++static int iio_str_to_nano(const char *str, s64 *nano)
>      +{
>     -+	int fract_mult = 100000LL;
>     ++	int fract_mult = 100000000LL;
>      +	int tmp, tmp2;
>      +	int ret = 0;
>      +
>     @@ drivers/iio/test/iio-test-rescale.c (new)
>      +	if (tmp < 0)
>      +		tmp2 *= -1;
>      +
>     -+	*micro = (s64)tmp * 10 * fract_mult + tmp2;
>     ++	*nano = (s64)tmp * 10 * fract_mult + tmp2;
>      +
>      +	return ret;
>      +}
>      +
>      +/**
>     -+ * iio_test_relative_error_ppm() - Compute relative error (in ppm) between two
>     -+ *                                 fixed-point strings
>     ++ * iio_test_relative_error_ppm() - Compute relative error (in parts-per-million)
>     ++ *                                 between two fixed-point strings
>      + * @real_str: The real value as a string
>      + * @exp_str: The expected value as a string
>      + *
>      + * Returns a negative error code if the strings cound not be parsed, or the
>     -+ * relative error in ppm.
>     ++ * relative error in parts-per-million.
>      + */
>      +static int iio_test_relative_error_ppm(const char *real_str, const char *exp_str)
>      +{
>      +	s64 real, exp, err;
>      +	int ret;
>      +
>     -+	ret = iio_str_to_micro(real_str, &real);
>     ++	ret = iio_str_to_nano(real_str, &real);
>      +	if (ret < 0)
>      +		return ret;
>      +
>     -+	ret = iio_str_to_micro(exp_str, &exp);
>     ++	ret = iio_str_to_nano(exp_str, &exp);
>      +	if (ret < 0)
>      +		return ret;
>      +
>     ++	if (!exp) {
>     ++		pr_err("Expected value is null, relative error is undefined\n");
>     ++		return -EINVAL;
>     ++	}
>     ++
>      +	err = 1000000 * abs(exp - real);
>      +	err = div64_u64(err, abs(exp));
>      +	return (int)err;
>     @@ drivers/iio/test/iio-test-rescale.c (new)
>      +	rel_ppm = iio_test_relative_error_ppm(buff, t->expected);
>      +	KUNIT_EXPECT_GE_MSG(test, rel_ppm, 0, "failed to compute ppm\n");
>      +
>     -+	KUNIT_EXPECT_LT_MSG(test, rel_ppm, 500,
>     ++	KUNIT_EXPECT_EQ_MSG(test, rel_ppm, 0,
>      +			    "\t    real=%s"
>      +			    "\texpected=%s\n",
>      +			    buff, t->expected);
> 11:  050487186e14 = 11:  c4ed463e5fb0 iio: afe: rescale: add RTD temperature sensor support
> 12:  f36a44a5d898 ! 12:  ff2f0dc248a7 iio: afe: rescale: add temperature transducers
>     @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
>      +	s32 offset = 0;
>      +	s32 sense = 1;
>      +	s32 alpha;
>     -+	s64 tmp;
>      +	int ret;
>      +
>      +	device_property_read_u32(dev, "sense-offset-millicelsius", &offset);
>     @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
>      +	rescale->numerator = 1000000;
>      +	rescale->denominator = alpha * sense;
>      +
>     -+	tmp = (s64)offset * (s64)alpha * (s64)sense;
>     -+	rescale->offset = div_s64(tmp, (s32)1000000);
>     ++	rescale->offset = div_s64((s64)offset * rescale->denominator,
>     ++				  rescale->numerator);
>      +
>      +	return 0;
>      +}
> 13:  63be647fd110 = 13:  84bc1f7d1ab5 dt-bindings: iio: afe: add bindings for temperature-sense-rtd
> 14:  c2f5c19dece3 = 14:  1b76cfb37e23 dt-bindings: iio: afe: add bindings for temperature transducers
> 
> base-commit: 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Liam Beguin]

On Sun, Nov 21, 2021 at 11:25:56AM +0000, Jonathan Cameron wrote:
> On Sun, 14 Nov 2021 22:43:20 -0500
> Liam Beguin <liambeguin@gmail.com> wrote:
> 
> > Hi Jonathan, Peter,
> > 
> > Apologies for not getting back to you sooner. I got caught up on other
> > work and wasn't able to dedicate time to this earlier. Hopefully, this
> > time around, I'll be able to get this to the finish line :-)
> > 
> > I left out IIO_VAL_INT overflows for now, so that I can focus on getting
> > the rest of these changes pulled in, but I don't mind adding a patch for
> > that later on.
> > 
> > This series focuses on adding temperature rescaling support to the IIO
> > Analog Front End (AFE) driver.
> > 
> > The first few patches address minor bugs in IIO inkernel functions, and
> > prepare the AFE driver for the additional features.
> > 
> > The main changes to the AFE driver include an initial Kunit test suite,
> > support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
> > and temperature transducer sensors.
> > 
> > Thanks for your time,
> > Liam
> 
> Hi Liam,

Hi Jonathan,

> I'm fine with these.  The comment about using the MICRO etc defines can
> be handled as as trivial follow up patch. Hopefully someone else can
> figure out the 0-day build issue as I didn't managed to.

I'll prepare the MICRO, NANO changes if we have a v10, otherwise I'll
send them as a follow up patch as you suggest.

I'll also try to find more time to dig more into that 0-day build issue.

> However, I've long ago lost track of the various precision discussions
> you and Peter were having so would like Peter's input before taking these.

That's my fault, apologies for letting this sit for so long.

> Thanks again for your persistence with this,

No worries, thanks for your patience :)

Cheers,
Liam

> 
> Jonathan
> 
> > 
> > Changes since v8:
> > - reword comment
> > - fix erroneous 64-bit division
> > - optimize and use 32-bit divisions when values are know to not overflow
> > - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
> >   point
> > - add test cases
> > - use nano precision in test cases
> > - simplify offset calculation in rtd_props()
> > 
> > Changes since v7:
> > - drop gcd() logic in rescale_process_scale()
> > - use div_s64() instead of do_div() for signed 64-bit divisions
> > - combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
> > - switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
> > - rework test logic to allow for small relative error
> > - rename test variables to align error output messages
> > 
> > Changes since v6:
> > - rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
> > - combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
> > - add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
> > - force use of positive integers with gcd()
> > - reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
> > - fix duplicate symbol build error
> > - apply Reviewed-by
> > 
> > Changes since v5:
> > - add include/linux/iio/afe/rescale.h
> > - expose functions use to process scale and offset
> > - add basic iio-rescale kunit test cases
> > - fix integer overflow case
> > - improve precision for IIO_VAL_FRACTIONAL_LOG2
> > 
> > Changes since v4:
> > - only use gcd() when necessary in overflow mitigation
> > - fix INT_PLUS_{MICRO,NANO} support
> > - apply Reviewed-by
> > - fix temperature-transducer bindings
> > 
> > Changes since v3:
> > - drop unnecessary fallthrough statements
> > - drop redundant local variables in some calculations
> > - fix s64 divisions on 32bit platforms by using do_div
> > - add comment describing iio-rescaler offset calculation
> > - drop unnecessary MAINTAINERS entry
> > 
> > Changes since v2:
> > - don't break implicit offset truncations
> > - make a best effort to get a valid value for fractional types
> > - drop return value change in iio_convert_raw_to_processed_unlocked()
> > - don't rely on processed value for offset calculation
> > - add INT_PLUS_{MICRO,NANO} support in iio-rescale
> > - revert generic implementation in favor of temperature-sense-rtd and
> >   temperature-transducer
> > - add separate section to MAINTAINERS file
> > 
> > Changes since v1:
> > - rebase on latest iio `testing` branch
> > - also apply consumer scale on integer channel scale types
> > - don't break implicit truncation in processed channel offset
> >   calculation
> > - drop temperature AFE flavors in favor of a simpler generic
> >   implementation
> > 
> > Liam Beguin (14):
> >   iio: inkern: apply consumer scale on IIO_VAL_INT cases
> >   iio: inkern: apply consumer scale when no channel scale is available
> >   iio: inkern: make a best effort on offset calculation
> >   iio: afe: rescale: expose scale processing function
> >   iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
> >   iio: afe: rescale: add offset support
> >   iio: afe: rescale: use s64 for temporary scale calculations
> >   iio: afe: rescale: reduce risk of integer overflow
> >   iio: afe: rescale: fix accuracy for small fractional scales
> >   iio: test: add basic tests for the iio-rescale driver
> >   iio: afe: rescale: add RTD temperature sensor support
> >   iio: afe: rescale: add temperature transducers
> >   dt-bindings: iio: afe: add bindings for temperature-sense-rtd
> >   dt-bindings: iio: afe: add bindings for temperature transducers
> > 
> >  .../iio/afe/temperature-sense-rtd.yaml        | 101 +++
> >  .../iio/afe/temperature-transducer.yaml       | 114 +++
> >  drivers/iio/afe/iio-rescale.c                 | 271 ++++++-
> >  drivers/iio/inkern.c                          |  40 +-
> >  drivers/iio/test/Kconfig                      |  10 +
> >  drivers/iio/test/Makefile                     |   1 +
> >  drivers/iio/test/iio-test-rescale.c           | 705 ++++++++++++++++++
> >  include/linux/iio/afe/rescale.h               |  34 +
> >  8 files changed, 1232 insertions(+), 44 deletions(-)
> >  create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-sense-rtd.yaml
> >  create mode 100644 Documentation/devicetree/bindings/iio/afe/temperature-transducer.yaml
> >  create mode 100644 drivers/iio/test/iio-test-rescale.c
> >  create mode 100644 include/linux/iio/afe/rescale.h
> > 
> > Range-diff against v8:
> >  1:  42a7a1047edc =  1:  ae3cc93baee6 iio: inkern: apply consumer scale on IIO_VAL_INT cases
> >  2:  a1cd89fdad11 =  2:  06f66e7f7403 iio: inkern: apply consumer scale when no channel scale is available
> >  3:  ed0721fb6bd1 =  3:  2dbf6b3bbaeb iio: inkern: make a best effort on offset calculation
> >  4:  f8fb78bb1112 =  4:  b083cf307268 iio: afe: rescale: expose scale processing function
> >  5:  504b7a3f830b !  5:  a0bde29ecc8c iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
> >     @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
> >      +		else
> >      +			mult = 1000000LL;
> >      +		/*
> >     -+		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if *val OR
> >     -+		 * *val2 is negative the schan scale is negative
> >     ++		 * For IIO_VAL_INT_PLUS_{MICRO,NANO} scale types if either *val
> >     ++		 * OR *val2 is negative the schan scale is negative, i.e.
> >     ++		 * *val = 1 and *val2 = -0.5 yields -1.5 not -0.5.
> >      +		 */
> >      +		neg = *val < 0 || *val2 < 0;
> >      +
> >  6:  c254e9ae813e =  6:  c3d0e6248033 iio: afe: rescale: add offset support
> >  7:  ee8814d6abe4 =  7:  2a81fa735103 iio: afe: rescale: use s64 for temporary scale calculations
> >  8:  62cdcfbc9836 =  8:  8315548d0fce iio: afe: rescale: reduce risk of integer overflow
> >  9:  88309a5136ee !  9:  223ed0569cd2 iio: afe: rescale: fix accuracy for small fractional scales
> >     @@ drivers/iio/afe/iio-rescale.c: int rescale_process_scale(struct rescale *rescale
> >      +
> >      +		tmp = div_s64_rem(tmp, 1000000000LL, &rem);
> >       		*val = tmp;
> >     +-		return scale_type;
> >     ++
> >     ++		if (!rem)
> >     ++			return scale_type;
> >      +
> >     -+		/*
> >     -+		 * For small values, the approximation can be costly,
> >     -+		 * change scale type to maintain accuracy.
> >     -+		 *
> >     -+		 * 100 vs. 10000000 NANO caps the error to about 100 ppm.
> >     -+		 */
> >      +		if (scale_type == IIO_VAL_FRACTIONAL)
> >      +			tmp = *val2;
> >      +		else
> >      +			tmp = 1 << *val2;
> >      +
> >     -+		 if (abs(rem) > 10000000 && abs(*val / tmp) < 100) {
> >     -+			 *val = div_s64_rem(*val, tmp, &rem2);
> >     -+
> >     -+			 *val2 = div_s64(rem, tmp);
> >     -+			 if (rem2)
> >     -+				 *val2 += div_s64(rem2 * 1000000000LL, tmp);
> >     ++		rem2 = *val % (int)tmp;
> >     ++		*val = *val / (int)tmp;
> >      +
> >     -+			 return IIO_VAL_INT_PLUS_NANO;
> >     -+		 }
> >     ++		*val2 = rem / (int)tmp;
> >     ++		if (rem2)
> >     ++			*val2 += div_s64((s64)rem2 * 1000000000LL, tmp);
> >      +
> >     - 		return scale_type;
> >     ++		return IIO_VAL_INT_PLUS_NANO;
> >       	case IIO_VAL_INT_PLUS_NANO:
> >       	case IIO_VAL_INT_PLUS_MICRO:
> >     + 		if (scale_type == IIO_VAL_INT_PLUS_NANO)
> > 10:  fb505a9f42f1 ! 10:  90044efdf8be iio: test: add basic tests for the iio-rescale driver
> >     @@ drivers/iio/test/Makefile
> >       # Keep in alphabetical order
> >      +obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) += iio-test-rescale.o ../afe/iio-rescale.o
> >       obj-$(CONFIG_IIO_TEST_FORMAT) += iio-test-format.o
> >     + CFLAGS_iio-test-format.o += $(DISABLE_STRUCTLEAK_PLUGIN)
> >      
> >       ## drivers/iio/test/iio-test-rescale.c (new) ##
> >      @@
> >     @@ drivers/iio/test/iio-test-rescale.c (new)
> >      +	 * Use cases with small scales involving divisions
> >      +	 */
> >      +	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL, 261/509 scaled by 90/1373754273",
> >     ++		.numerator = 261,
> >     ++		.denominator = 509,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
> >     ++		.schan_val = 90,
> >     ++		.schan_val2 = 1373754273,
> >     ++		.expected = "0.000000033594",
> >     ++	},
> >     ++	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL, 90/1373754273 scaled by 261/509",
> >     ++		.numerator = 90,
> >     ++		.denominator = 1373754273,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
> >     ++		.schan_val = 261,
> >     ++		.schan_val2 = 509,
> >     ++		.expected = "0.000000033594",
> >     ++	},
> >     ++	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL, 760/1373754273 scaled by 427/2727",
> >     ++		.numerator = 760,
> >     ++		.denominator = 1373754273,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
> >     ++		.schan_val = 427,
> >     ++		.schan_val2 = 2727,
> >     ++		.expected = "0.000000086626",
> >     ++	},
> >     ++	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL, 761/1373754273 scaled by 427/2727",
> >     ++		.numerator = 761,
> >     ++		.denominator = 1373754273,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
> >     ++		.schan_val = 427,
> >     ++		.schan_val2 = 2727,
> >     ++		.expected = "0.000000086740",
> >     ++	},
> >     ++	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL, 5/32768 scaled by 3/10000",
> >     ++		.numerator = 5,
> >     ++		.denominator = 32768,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL,
> >     ++		.schan_val = 3,
> >     ++		.schan_val2 = 10000,
> >     ++		.expected = "0.0000000457763671875",
> >     ++	},
> >     ++	{
> >      +		.name = "small IIO_VAL_FRACTIONAL, 0 < scale < 1",
> >      +		.numerator = 6,
> >      +		.denominator = 6,
> >     @@ drivers/iio/test/iio-test-rescale.c (new)
> >      +		.expected = "-1.3333333333333333",
> >      +	},
> >      +	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 760/32768 scaled by 15/22",
> >     ++		.numerator = 760,
> >     ++		.denominator = 32768,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
> >     ++		.schan_val = 15,
> >     ++		.schan_val2 = 22,
> >     ++		.expected = "0.000000082946",
> >     ++	},
> >     ++	{
> >     ++		.name = "small IIO_VAL_FRACTIONAL_LOG2, 761/32768 scaled by 15/22",
> >     ++		.numerator = 761,
> >     ++		.denominator = 32768,
> >     ++		.schan_scale_type = IIO_VAL_FRACTIONAL_LOG2,
> >     ++		.schan_val = 15,
> >     ++		.schan_val2 = 22,
> >     ++		.expected = "0.000000083055",
> >     ++	},
> >     ++	{
> >      +		.name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 1",
> >      +		.numerator = 16,
> >      +		.denominator = 3,
> >     @@ drivers/iio/test/iio-test-rescale.c (new)
> >      +KUNIT_ARRAY_PARAM(iio_rescale_offset, offset_cases, case_to_desc);
> >      +
> >      +/**
> >     -+ * iio_str_to_micro() - Parse a fixed-point string to get an
> >     -+ *                      IIO_VAL_INT_PLUS_MICRO value
> >     ++ * iio_str_to_nano() - Parse a fixed-point string to get an
> >     ++ *                      IIO_VAL_INT_PLUS_NANO value
> >      + * @str: The string to parse
> >     -+ * @micro: The number as an integer
> >     ++ * @nano: The number as an integer
> >      + *
> >      + * Returns 0 on success, or a negative error code if the string cound not be
> >      + * parsed.
> >      + */
> >     -+static int iio_str_to_micro(const char *str, s64 *micro)
> >     ++static int iio_str_to_nano(const char *str, s64 *nano)
> >      +{
> >     -+	int fract_mult = 100000LL;
> >     ++	int fract_mult = 100000000LL;
> >      +	int tmp, tmp2;
> >      +	int ret = 0;
> >      +
> >     @@ drivers/iio/test/iio-test-rescale.c (new)
> >      +	if (tmp < 0)
> >      +		tmp2 *= -1;
> >      +
> >     -+	*micro = (s64)tmp * 10 * fract_mult + tmp2;
> >     ++	*nano = (s64)tmp * 10 * fract_mult + tmp2;
> >      +
> >      +	return ret;
> >      +}
> >      +
> >      +/**
> >     -+ * iio_test_relative_error_ppm() - Compute relative error (in ppm) between two
> >     -+ *                                 fixed-point strings
> >     ++ * iio_test_relative_error_ppm() - Compute relative error (in parts-per-million)
> >     ++ *                                 between two fixed-point strings
> >      + * @real_str: The real value as a string
> >      + * @exp_str: The expected value as a string
> >      + *
> >      + * Returns a negative error code if the strings cound not be parsed, or the
> >     -+ * relative error in ppm.
> >     ++ * relative error in parts-per-million.
> >      + */
> >      +static int iio_test_relative_error_ppm(const char *real_str, const char *exp_str)
> >      +{
> >      +	s64 real, exp, err;
> >      +	int ret;
> >      +
> >     -+	ret = iio_str_to_micro(real_str, &real);
> >     ++	ret = iio_str_to_nano(real_str, &real);
> >      +	if (ret < 0)
> >      +		return ret;
> >      +
> >     -+	ret = iio_str_to_micro(exp_str, &exp);
> >     ++	ret = iio_str_to_nano(exp_str, &exp);
> >      +	if (ret < 0)
> >      +		return ret;
> >      +
> >     ++	if (!exp) {
> >     ++		pr_err("Expected value is null, relative error is undefined\n");
> >     ++		return -EINVAL;
> >     ++	}
> >     ++
> >      +	err = 1000000 * abs(exp - real);
> >      +	err = div64_u64(err, abs(exp));
> >      +	return (int)err;
> >     @@ drivers/iio/test/iio-test-rescale.c (new)
> >      +	rel_ppm = iio_test_relative_error_ppm(buff, t->expected);
> >      +	KUNIT_EXPECT_GE_MSG(test, rel_ppm, 0, "failed to compute ppm\n");
> >      +
> >     -+	KUNIT_EXPECT_LT_MSG(test, rel_ppm, 500,
> >     ++	KUNIT_EXPECT_EQ_MSG(test, rel_ppm, 0,
> >      +			    "\t    real=%s"
> >      +			    "\texpected=%s\n",
> >      +			    buff, t->expected);
> > 11:  050487186e14 = 11:  c4ed463e5fb0 iio: afe: rescale: add RTD temperature sensor support
> > 12:  f36a44a5d898 ! 12:  ff2f0dc248a7 iio: afe: rescale: add temperature transducers
> >     @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
> >      +	s32 offset = 0;
> >      +	s32 sense = 1;
> >      +	s32 alpha;
> >     -+	s64 tmp;
> >      +	int ret;
> >      +
> >      +	device_property_read_u32(dev, "sense-offset-millicelsius", &offset);
> >     @@ drivers/iio/afe/iio-rescale.c: static int rescale_temp_sense_rtd_props(struct de
> >      +	rescale->numerator = 1000000;
> >      +	rescale->denominator = alpha * sense;
> >      +
> >     -+	tmp = (s64)offset * (s64)alpha * (s64)sense;
> >     -+	rescale->offset = div_s64(tmp, (s32)1000000);
> >     ++	rescale->offset = div_s64((s64)offset * rescale->denominator,
> >     ++				  rescale->numerator);
> >      +
> >      +	return 0;
> >      +}
> > 13:  63be647fd110 = 13:  84bc1f7d1ab5 dt-bindings: iio: afe: add bindings for temperature-sense-rtd
> > 14:  c2f5c19dece3 = 14:  1b76cfb37e23 dt-bindings: iio: afe: add bindings for temperature transducers
> > 
> > base-commit: 2b6bff0b122785f09cfbdc34b1aa9edceea6e4c1
> 

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Peter Rosin]

Hi Liam!

On 2021-11-15 04:43, Liam Beguin wrote:
> Hi Jonathan, Peter,
> 
> Apologies for not getting back to you sooner. I got caught up on other
> work and wasn't able to dedicate time to this earlier. Hopefully, this
> time around, I'll be able to get this to the finish line :-)
> 
> I left out IIO_VAL_INT overflows for now, so that I can focus on getting
> the rest of these changes pulled in, but I don't mind adding a patch for
> that later on.
> 
> This series focuses on adding temperature rescaling support to the IIO
> Analog Front End (AFE) driver.
> 
> The first few patches address minor bugs in IIO inkernel functions, and
> prepare the AFE driver for the additional features.
> 
> The main changes to the AFE driver include an initial Kunit test suite,
> support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
> and temperature transducer sensors.
> 
> Thanks for your time,

And thanks for yours!

> Liam
> 
> Changes since v8:
> - reword comment
> - fix erroneous 64-bit division
> - optimize and use 32-bit divisions when values are know to not overflow
> - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
>   point

This is not what is going on. Patch 9/14 will convert all fractional
scales to fixed point. But I would really like if you in the "reduce
risk of integer overflow" patch (8/14) would hold true to the above
and keep the fractional scale when possible and only fall back to
the less precise fractional-log case if any of the multiplications
needed for an exact fractional scale causes overflow.

The v8 discussion concluded that this was a valid approach, right?

I know you also said that the core exposes the scale with nano
precision in sysfs anyway, but that is not true for in-kernel
consumers. They have an easier time reading the "real" scale value
compared to going via the string representation of fixed point
returned from iio_format_value. At least the rescaler itself does so,
which means that chaining rescalers might suffer needless accuracy
degradation.

So, please add the overflow fallback thingy right away, it would make
me feel much better.

> - add test cases
> - use nano precision in test cases
> - simplify offset calculation in rtd_props()
> 
> Changes since v7:
> - drop gcd() logic in rescale_process_scale()
> - use div_s64() instead of do_div() for signed 64-bit divisions
> - combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
> - switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
> - rework test logic to allow for small relative error
> - rename test variables to align error output messages
> 
> Changes since v6:
> - rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
> - combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
> - add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
> - force use of positive integers with gcd()
> - reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
> - fix duplicate symbol build error
> - apply Reviewed-by
> 
> Changes since v5:
> - add include/linux/iio/afe/rescale.h
> - expose functions use to process scale and offset
> - add basic iio-rescale kunit test cases
> - fix integer overflow case
> - improve precision for IIO_VAL_FRACTIONAL_LOG2
> 
> Changes since v4:
> - only use gcd() when necessary in overflow mitigation
> - fix INT_PLUS_{MICRO,NANO} support
> - apply Reviewed-by
> - fix temperature-transducer bindings
> 
> Changes since v3:
> - drop unnecessary fallthrough statements
> - drop redundant local variables in some calculations
> - fix s64 divisions on 32bit platforms by using do_div
> - add comment describing iio-rescaler offset calculation
> - drop unnecessary MAINTAINERS entry
> 
> Changes since v2:
> - don't break implicit offset truncations
> - make a best effort to get a valid value for fractional types
> - drop return value change in iio_convert_raw_to_processed_unlocked()
> - don't rely on processed value for offset calculation
> - add INT_PLUS_{MICRO,NANO} support in iio-rescale
> - revert generic implementation in favor of temperature-sense-rtd and
>   temperature-transducer
> - add separate section to MAINTAINERS file
> 
> Changes since v1:
> - rebase on latest iio `testing` branch
> - also apply consumer scale on integer channel scale types
> - don't break implicit truncation in processed channel offset
>   calculation
> - drop temperature AFE flavors in favor of a simpler generic
>   implementation
> 
> Liam Beguin (14):
>   iio: inkern: apply consumer scale on IIO_VAL_INT cases
>   iio: inkern: apply consumer scale when no channel scale is available
>   iio: inkern: make a best effort on offset calculation
>   iio: afe: rescale: expose scale processing function
>   iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
>   iio: afe: rescale: add offset support
>   iio: afe: rescale: use s64 for temporary scale calculations
>   iio: afe: rescale: reduce risk of integer overflow
>   iio: afe: rescale: fix accuracy for small fractional scales

Can you please swap the order of these two patches? (i.e. "reduce
risk..." and "fix accuracy...")

Basically, I think the accuracy of the IIO_VAL_FRACTIONAL_LOG2
case should be improved before the IIO_VAL_FRACTIONAL case is
joined with it. I.e. swap the order of 8/14 and 9/14 (or almost,
you need to also move the addition of the
scale_type == IIO_VAL_FRACTIONAL condition to the other patch in
order for it to make sense).

That's all I'm finding. But then again, I don't know what to do
about the 0day report on 10/14. It does say that it's a W=1
build, maybe we need not worry about it?

Cheers,
Peter

>   iio: test: add basic tests for the iio-rescale driver
>   iio: afe: rescale: add RTD temperature sensor support
>   iio: afe: rescale: add temperature transducers
>   dt-bindings: iio: afe: add bindings for temperature-sense-rtd
>   dt-bindings: iio: afe: add bindings for temperature transducers

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Jonathan Cameron]

On Mon, 22 Nov 2021 01:53:44 +0100
Peter Rosin <peda@axentia.se> wrote:

> Hi Liam!
> 
> On 2021-11-15 04:43, Liam Beguin wrote:
> > Hi Jonathan, Peter,
> > 
> > Apologies for not getting back to you sooner. I got caught up on other
> > work and wasn't able to dedicate time to this earlier. Hopefully, this
> > time around, I'll be able to get this to the finish line :-)
> > 
> > I left out IIO_VAL_INT overflows for now, so that I can focus on getting
> > the rest of these changes pulled in, but I don't mind adding a patch for
> > that later on.
> > 
> > This series focuses on adding temperature rescaling support to the IIO
> > Analog Front End (AFE) driver.
> > 
> > The first few patches address minor bugs in IIO inkernel functions, and
> > prepare the AFE driver for the additional features.
> > 
> > The main changes to the AFE driver include an initial Kunit test suite,
> > support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
> > and temperature transducer sensors.
> > 
> > Thanks for your time,  
> 
> And thanks for yours!
> 
> > Liam
> > 
> > Changes since v8:
> > - reword comment
> > - fix erroneous 64-bit division
> > - optimize and use 32-bit divisions when values are know to not overflow
> > - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
> >   point  
> 
> This is not what is going on. Patch 9/14 will convert all fractional
> scales to fixed point. But I would really like if you in the "reduce
> risk of integer overflow" patch (8/14) would hold true to the above
> and keep the fractional scale when possible and only fall back to
> the less precise fractional-log case if any of the multiplications
> needed for an exact fractional scale causes overflow.
> 
> The v8 discussion concluded that this was a valid approach, right?
> 
> I know you also said that the core exposes the scale with nano
> precision in sysfs anyway, but that is not true for in-kernel
> consumers. They have an easier time reading the "real" scale value
> compared to going via the string representation of fixed point
> returned from iio_format_value. At least the rescaler itself does so,
> which means that chaining rescalers might suffer needless accuracy
> degradation.
> 
> So, please add the overflow fallback thingy right away, it would make
> me feel much better.
> 
> > - add test cases
> > - use nano precision in test cases
> > - simplify offset calculation in rtd_props()
> > 
> > Changes since v7:
> > - drop gcd() logic in rescale_process_scale()
> > - use div_s64() instead of do_div() for signed 64-bit divisions
> > - combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
> > - switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
> > - rework test logic to allow for small relative error
> > - rename test variables to align error output messages
> > 
> > Changes since v6:
> > - rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
> > - combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
> > - add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
> > - force use of positive integers with gcd()
> > - reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
> > - fix duplicate symbol build error
> > - apply Reviewed-by
> > 
> > Changes since v5:
> > - add include/linux/iio/afe/rescale.h
> > - expose functions use to process scale and offset
> > - add basic iio-rescale kunit test cases
> > - fix integer overflow case
> > - improve precision for IIO_VAL_FRACTIONAL_LOG2
> > 
> > Changes since v4:
> > - only use gcd() when necessary in overflow mitigation
> > - fix INT_PLUS_{MICRO,NANO} support
> > - apply Reviewed-by
> > - fix temperature-transducer bindings
> > 
> > Changes since v3:
> > - drop unnecessary fallthrough statements
> > - drop redundant local variables in some calculations
> > - fix s64 divisions on 32bit platforms by using do_div
> > - add comment describing iio-rescaler offset calculation
> > - drop unnecessary MAINTAINERS entry
> > 
> > Changes since v2:
> > - don't break implicit offset truncations
> > - make a best effort to get a valid value for fractional types
> > - drop return value change in iio_convert_raw_to_processed_unlocked()
> > - don't rely on processed value for offset calculation
> > - add INT_PLUS_{MICRO,NANO} support in iio-rescale
> > - revert generic implementation in favor of temperature-sense-rtd and
> >   temperature-transducer
> > - add separate section to MAINTAINERS file
> > 
> > Changes since v1:
> > - rebase on latest iio `testing` branch
> > - also apply consumer scale on integer channel scale types
> > - don't break implicit truncation in processed channel offset
> >   calculation
> > - drop temperature AFE flavors in favor of a simpler generic
> >   implementation
> > 
> > Liam Beguin (14):
> >   iio: inkern: apply consumer scale on IIO_VAL_INT cases
> >   iio: inkern: apply consumer scale when no channel scale is available
> >   iio: inkern: make a best effort on offset calculation
> >   iio: afe: rescale: expose scale processing function
> >   iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
> >   iio: afe: rescale: add offset support
> >   iio: afe: rescale: use s64 for temporary scale calculations
> >   iio: afe: rescale: reduce risk of integer overflow
> >   iio: afe: rescale: fix accuracy for small fractional scales  
> 
> Can you please swap the order of these two patches? (i.e. "reduce
> risk..." and "fix accuracy...")
> 
> Basically, I think the accuracy of the IIO_VAL_FRACTIONAL_LOG2
> case should be improved before the IIO_VAL_FRACTIONAL case is
> joined with it. I.e. swap the order of 8/14 and 9/14 (or almost,
> you need to also move the addition of the
> scale_type == IIO_VAL_FRACTIONAL condition to the other patch in
> order for it to make sense).
> 
> That's all I'm finding. But then again, I don't know what to do
> about the 0day report on 10/14. It does say that it's a W=1
> build, maybe we need not worry about it?

W=1 won't affect that undefined symbols error.

I'd be cynical and assume it's a random issue, post a v10 perhaps
with a note in the cover letter on this.

Jonathan
> 
> Cheers,
> Peter
> 
> >   iio: test: add basic tests for the iio-rescale driver
> >   iio: afe: rescale: add RTD temperature sensor support
> >   iio: afe: rescale: add temperature transducers
> >   dt-bindings: iio: afe: add bindings for temperature-sense-rtd
> >   dt-bindings: iio: afe: add bindings for temperature transducers  
> 

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Liam Beguin]

Hi Peter,

On Mon, Nov 22, 2021 at 01:53:44AM +0100, Peter Rosin wrote:
> Hi Liam!
> 
> On 2021-11-15 04:43, Liam Beguin wrote:
> > Hi Jonathan, Peter,
> > 
> > Apologies for not getting back to you sooner. I got caught up on other
> > work and wasn't able to dedicate time to this earlier. Hopefully, this
> > time around, I'll be able to get this to the finish line :-)
> > 
> > I left out IIO_VAL_INT overflows for now, so that I can focus on getting
> > the rest of these changes pulled in, but I don't mind adding a patch for
> > that later on.
> > 
> > This series focuses on adding temperature rescaling support to the IIO
> > Analog Front End (AFE) driver.
> > 
> > The first few patches address minor bugs in IIO inkernel functions, and
> > prepare the AFE driver for the additional features.
> > 
> > The main changes to the AFE driver include an initial Kunit test suite,
> > support for IIO_VAL_INT_PLUS_{NANO,MICRO} scales, and support for RTDs
> > and temperature transducer sensors.
> > 
> > Thanks for your time,
> 
> And thanks for yours!
> 
> > Liam
> > 
> > Changes since v8:
> > - reword comment
> > - fix erroneous 64-bit division
> > - optimize and use 32-bit divisions when values are know to not overflow
> > - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
> >   point
> 
> This is not what is going on. Patch 9/14 will convert all fractional
> scales to fixed point. But I would really like if you in the "reduce
> risk of integer overflow" patch (8/14) would hold true to the above
> and keep the fractional scale when possible and only fall back to
> the less precise fractional-log case if any of the multiplications
> needed for an exact fractional scale causes overflow.

Thanks for looking at these patches again.

> The v8 discussion concluded that this was a valid approach, right?

Yes, I remember you saying that you'd be more comfortable keeping the
IIO_VAL_FRACTIONAL.

> I know you also said that the core exposes the scale with nano
> precision in sysfs anyway, but that is not true for in-kernel
> consumers. They have an easier time reading the "real" scale value
> compared to going via the string representation of fixed point
> returned from iio_format_value. At least the rescaler itself does so,
> which means that chaining rescalers might suffer needless accuracy
> degradation.

Agreed, that makes total sense.

If I'm not mistaken, the first condition in the case, if (!rem), will
return IIO_VAL_FRACTIONAL if the division is exact, keeping all the
precision. No?

> So, please add the overflow fallback thingy right away, it would make
> me feel much better.
> 
> > - add test cases
> > - use nano precision in test cases
> > - simplify offset calculation in rtd_props()
> > 
> > Changes since v7:
> > - drop gcd() logic in rescale_process_scale()
> > - use div_s64() instead of do_div() for signed 64-bit divisions
> > - combine IIO_VAL_FRACTIONAL and IIO_VAL_FRACTIONAL_LOG2 scale cases
> > - switch to INT_PLUS_NANO when accuracy is lost with FRACTIONAL scales
> > - rework test logic to allow for small relative error
> > - rename test variables to align error output messages
> > 
> > Changes since v6:
> > - rework IIO_VAL_INT_PLUS_{NANO,MICRO} based on Peter's suggestion
> > - combine IIO_VAL_INT_PLUS_{NANO,MICRO} cases
> > - add test cases for negative IIO_VAL_INT_PLUS_{NANO,MICRO} corner cases
> > - force use of positive integers with gcd()
> > - reduce risk of integer overflow in IIO_VAL_FRACTIONAL_LOG2
> > - fix duplicate symbol build error
> > - apply Reviewed-by
> > 
> > Changes since v5:
> > - add include/linux/iio/afe/rescale.h
> > - expose functions use to process scale and offset
> > - add basic iio-rescale kunit test cases
> > - fix integer overflow case
> > - improve precision for IIO_VAL_FRACTIONAL_LOG2
> > 
> > Changes since v4:
> > - only use gcd() when necessary in overflow mitigation
> > - fix INT_PLUS_{MICRO,NANO} support
> > - apply Reviewed-by
> > - fix temperature-transducer bindings
> > 
> > Changes since v3:
> > - drop unnecessary fallthrough statements
> > - drop redundant local variables in some calculations
> > - fix s64 divisions on 32bit platforms by using do_div
> > - add comment describing iio-rescaler offset calculation
> > - drop unnecessary MAINTAINERS entry
> > 
> > Changes since v2:
> > - don't break implicit offset truncations
> > - make a best effort to get a valid value for fractional types
> > - drop return value change in iio_convert_raw_to_processed_unlocked()
> > - don't rely on processed value for offset calculation
> > - add INT_PLUS_{MICRO,NANO} support in iio-rescale
> > - revert generic implementation in favor of temperature-sense-rtd and
> >   temperature-transducer
> > - add separate section to MAINTAINERS file
> > 
> > Changes since v1:
> > - rebase on latest iio `testing` branch
> > - also apply consumer scale on integer channel scale types
> > - don't break implicit truncation in processed channel offset
> >   calculation
> > - drop temperature AFE flavors in favor of a simpler generic
> >   implementation
> > 
> > Liam Beguin (14):
> >   iio: inkern: apply consumer scale on IIO_VAL_INT cases
> >   iio: inkern: apply consumer scale when no channel scale is available
> >   iio: inkern: make a best effort on offset calculation
> >   iio: afe: rescale: expose scale processing function
> >   iio: afe: rescale: add INT_PLUS_{MICRO,NANO} support
> >   iio: afe: rescale: add offset support
> >   iio: afe: rescale: use s64 for temporary scale calculations
> >   iio: afe: rescale: reduce risk of integer overflow
> >   iio: afe: rescale: fix accuracy for small fractional scales
> 
> Can you please swap the order of these two patches? (i.e. "reduce
> risk..." and "fix accuracy...")
> 
> Basically, I think the accuracy of the IIO_VAL_FRACTIONAL_LOG2
> case should be improved before the IIO_VAL_FRACTIONAL case is
> joined with it. I.e. swap the order of 8/14 and 9/14 (or almost,
> you need to also move the addition of the
> scale_type == IIO_VAL_FRACTIONAL condition to the other patch in
> order for it to make sense).

Makes sense! I'll swap the order of these commits.

> That's all I'm finding. But then again, I don't know what to do
> about the 0day report on 10/14. It does say that it's a W=1
> build, maybe we need not worry about it?

I didn't have a chance to look into that more, but will now.

Cheers,
Liam

> Cheers,
> Peter
> 
> >   iio: test: add basic tests for the iio-rescale driver
> >   iio: afe: rescale: add RTD temperature sensor support
> >   iio: afe: rescale: add temperature transducers
> >   dt-bindings: iio: afe: add bindings for temperature-sense-rtd
> >   dt-bindings: iio: afe: add bindings for temperature transducers
> 

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Peter Rosin]

Hi!

On 2021-11-27 21:27, Liam Beguin wrote:
> Hi Peter,
> 
> On Mon, Nov 22, 2021 at 01:53:44AM +0100, Peter Rosin wrote:
>> Hi Liam!
>>
>> On 2021-11-15 04:43, Liam Beguin wrote:
>>> Hi Jonathan, Peter,

snip

>>> - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
>>>   point
>>
>> This is not what is going on. Patch 9/14 will convert all fractional
>> scales to fixed point. But I would really like if you in the "reduce
>> risk of integer overflow" patch (8/14) would hold true to the above
>> and keep the fractional scale when possible and only fall back to
>> the less precise fractional-log case if any of the multiplications
>> needed for an exact fractional scale causes overflow.
> 
> Thanks for looking at these patches again.
> 
>> The v8 discussion concluded that this was a valid approach, right?
> 
> Yes, I remember you saying that you'd be more comfortable keeping the
> IIO_VAL_FRACTIONAL.
> 
>> I know you also said that the core exposes the scale with nano
>> precision in sysfs anyway, but that is not true for in-kernel
>> consumers. They have an easier time reading the "real" scale value
>> compared to going via the string representation of fixed point
>> returned from iio_format_value. At least the rescaler itself does so,
>> which means that chaining rescalers might suffer needless accuracy
>> degradation.
> 
> Agreed, that makes total sense.
> 
> If I'm not mistaken, the first condition in the case, if (!rem), will
> return IIO_VAL_FRACTIONAL if the division is exact, keeping all the
> precision. No?

Only if the resulting scale fits in nine decimals. That's never the
case if you have primes other than 2 and 5 in the denominator (after
eliminating gcd of course). Which mean that if you chain one rescaler
doing 1/3 and one doing 3/1, you would get a combined scale of
0.999999999 instead of 3/3 if we take the approach of these patches.

So, what I'm after is that - for IIO_VAL_FRACTIONAL - not take the
multiply-by-1e9 code path /unless/ the existing fractional approach
overflows in either numerator or denominator (or both).

Side note: The same could be done for IIO_VAL_INT when the numerator
overflows (since the denominator cannot overflow), but I guess that
can be done later.

Cheers,
Peter

Re: [PATCH v9 00/14] iio: afe: add temperature rescaling support

[Liam Beguin]

Hi Peter,

On Sun, Nov 28, 2021 at 10:17:50AM +0100, Peter Rosin wrote:
> Hi!
> 
> On 2021-11-27 21:27, Liam Beguin wrote:
> > Hi Peter,
> > 
> > On Mon, Nov 22, 2021 at 01:53:44AM +0100, Peter Rosin wrote:
> >> Hi Liam!
> >>
> >> On 2021-11-15 04:43, Liam Beguin wrote:
> >>> Hi Jonathan, Peter,
> 
> snip
> 
> >>> - keep IIO_VAL_FRACTIONAL scale when possible, if not default to fixed
> >>>   point
> >>
> >> This is not what is going on. Patch 9/14 will convert all fractional
> >> scales to fixed point. But I would really like if you in the "reduce
> >> risk of integer overflow" patch (8/14) would hold true to the above
> >> and keep the fractional scale when possible and only fall back to
> >> the less precise fractional-log case if any of the multiplications
> >> needed for an exact fractional scale causes overflow.
> > 
> > Thanks for looking at these patches again.
> > 
> >> The v8 discussion concluded that this was a valid approach, right?
> > 
> > Yes, I remember you saying that you'd be more comfortable keeping the
> > IIO_VAL_FRACTIONAL.
> > 
> >> I know you also said that the core exposes the scale with nano
> >> precision in sysfs anyway, but that is not true for in-kernel
> >> consumers. They have an easier time reading the "real" scale value
> >> compared to going via the string representation of fixed point
> >> returned from iio_format_value. At least the rescaler itself does so,
> >> which means that chaining rescalers might suffer needless accuracy
> >> degradation.
> > 
> > Agreed, that makes total sense.
> > 
> > If I'm not mistaken, the first condition in the case, if (!rem), will
> > return IIO_VAL_FRACTIONAL if the division is exact, keeping all the
> > precision. No?
> 
> Only if the resulting scale fits in nine decimals. That's never the
> case if you have primes other than 2 and 5 in the denominator (after
> eliminating gcd of course). Which mean that if you chain one rescaler
> doing 1/3 and one doing 3/1, you would get a combined scale of
> 0.999999999 instead of 3/3 if we take the approach of these patches.
> 
> So, what I'm after is that - for IIO_VAL_FRACTIONAL - not take the
> multiply-by-1e9 code path /unless/ the existing fractional approach
> overflows in either numerator or denominator (or both).

Understood, I'll update based on this.

> Side note: The same could be done for IIO_VAL_INT when the numerator
> overflows (since the denominator cannot overflow), but I guess that
> can be done later.

Agreed, I don't mind working on this later but I'd like to focus on
getting the current changes in first.

Thanks,
Liam

> Cheers,
> Peter