lastdragon/linux-kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Resguardo inicial

Browse Source
This commit is contained in:
lastdragon
2026-09-06 12:53:21 -06:00
parent 662efe3c2a
commit ad2088d178
94853 changed files with 43200404 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
linux-7.2.3/drivers/iio/test/Kconfig
+54
View File
@@ -0,0 +1,54 @@
# SPDX-License-Identifier: GPL-2.0-only
#
# Industrial I/O subsystem unit tests configuration
#
# Keep in alphabetical order
config IIO_GTS_KUNIT_TEST
tristate "Test IIO gain-time-scale helpers" if !KUNIT_ALL_TESTS
depends on KUNIT
select IIO_GTS_HELPER
default KUNIT_ALL_TESTS
help
build unit tests for the IIO light sensor gain-time-scale helpers.
For more information on KUnit and unit tests in general, please refer
to the KUnit documentation in Documentation/dev-tools/kunit/.
If unsure, say N. Keep in alphabetical order
config IIO_RESCALE_KUNIT_TEST
tristate "Test IIO rescale conversion functions" if !KUNIT_ALL_TESTS
depends on KUNIT && IIO_RESCALE
default KUNIT_ALL_TESTS
help
Build unit tests for the iio-rescale code.
For more information on KUnit and unit tests in general, please refer
to the KUnit documentation in Documentation/dev-tools/kunit/.
If unsure, say N.
config IIO_FORMAT_KUNIT_TEST
tristate "Test IIO formatting functions" if !KUNIT_ALL_TESTS
depends on KUNIT
default KUNIT_ALL_TESTS
help
build unit tests for the IIO formatting functions.
For more information on KUnit and unit tests in general, please refer
to the KUnit documentation in Documentation/dev-tools/kunit/.
If unsure, say N.
config IIO_MULTIPLY_KUNIT_TEST
tristate "Test IIO multiply functions" if !KUNIT_ALL_TESTS
depends on KUNIT
default KUNIT_ALL_TESTS
help
build unit tests for the IIO multiply functions.
For more information on KUnit and unit tests in general, please refer
to the KUnit documentation in Documentation/dev-tools/kunit/.
If unsure, say N.
linux-7.2.3/drivers/iio/test/Makefile
+11
View File
@@ -0,0 +1,11 @@
# SPDX-License-Identifier: GPL-2.0
#
# Makefile for the industrial I/O unit tests.
#
# Keep in alphabetical order
obj-$(CONFIG_IIO_RESCALE_KUNIT_TEST) += iio-test-rescale.o
obj-$(CONFIG_IIO_FORMAT_KUNIT_TEST) += iio-test-format.o
obj-$(CONFIG_IIO_GTS_KUNIT_TEST) += iio-test-gts.o
obj-$(CONFIG_IIO_MULTIPLY_KUNIT_TEST) += iio-test-multiply.o
CFLAGS_iio-test-format.o += $(DISABLE_STRUCTLEAK_PLUGIN)
linux-7.2.3/drivers/iio/test/iio-test-format.c
+271
View File
@@ -0,0 +1,271 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Unit tests for IIO formatting functions
*
* Copyright (c) 2020 Lars-Peter Clausen <lars@metafoo.de>
*/
#include <kunit/test.h>
#include <linux/iio/iio.h>
#define IIO_TEST_FORMAT_EXPECT_EQ(_test, _buf, _ret, _val) do { \
KUNIT_EXPECT_EQ(_test, strlen(_buf), _ret); \
KUNIT_EXPECT_STREQ(_test, (_buf), (_val)); \
} while (0)
static void iio_test_iio_format_value_integer(struct kunit *test)
{
char *buf;
int val;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
val = 42;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "42\n");
val = -23;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-23\n");
val = 0;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");
val = INT_MAX;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "2147483647\n");
val = INT_MIN;
ret = iio_format_value(buf, IIO_VAL_INT, 1, &val);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-2147483648\n");
}
static void iio_test_iio_format_value_fixedpoint(struct kunit *test)
{
int values[2];
char *buf;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
/* positive >= 1 */
values[0] = 1;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000010 dB\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000000010\n");
/* positive < 1 */
values[0] = 0;
values[1] = 12;
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000012 dB\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000012\n");
/* negative <= -1 */
values[0] = -1;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000010 dB\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.000000010\n");
/* negative > -1 */
values[0] = 0;
values[1] = -123;
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO_DB, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000123 dB\n");
ret = iio_format_value(buf, IIO_VAL_INT_PLUS_NANO, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000123\n");
}
static void iio_test_iio_format_value_fractional(struct kunit *test)
{
int values[2];
char *buf;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
/* positive < 1 */
values[0] = 1;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.100000000\n");
/* positive >= 1 */
values[0] = 100;
values[1] = 3;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "33.333333333\n");
/* negative > -1 */
values[0] = -1;
values[1] = 1000000000;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.000000001\n");
/* negative <= -1 */
values[0] = -200;
values[1] = 3;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-66.666666666\n");
/* Zero */
values[0] = 0;
values[1] = -10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
}
static void iio_test_iio_format_value_fractional_log2(struct kunit *test)
{
int values[2];
char *buf;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
/* positive < 1 */
values[0] = 123;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.120117187\n");
/* positive >= 1 */
values[0] = 1234567;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1205.631835937\n");
/* negative > -1 */
values[0] = -123;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.120117187\n");
/* negative <= -1 */
values[0] = -1234567;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1205.631835937\n");
/* Zero */
values[0] = 0;
values[1] = 10;
ret = iio_format_value(buf, IIO_VAL_FRACTIONAL_LOG2, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000000000\n");
}
static void iio_test_iio_format_value_multiple(struct kunit *test)
{
int values[] = {1, -2, 3, -4, 5};
char *buf;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
ret = iio_format_value(buf, IIO_VAL_INT_MULTIPLE,
ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1 -2 3 -4 5 \n");
}
static void iio_test_iio_format_value_integer_64(struct kunit *test)
{
int values[2];
s64 value;
char *buf;
int ret;
buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
value = 24;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "24\n");
value = -24;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-24\n");
value = 0;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n");
value = UINT_MAX;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "4294967295\n");
value = -((s64)UINT_MAX);
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-4294967295\n");
value = LLONG_MAX;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036854775807\n");
value = LLONG_MIN;
values[0] = lower_32_bits(value);
values[1] = upper_32_bits(value);
ret = iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values);
IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036854775808\n");
}
static struct kunit_case iio_format_test_cases[] = {
KUNIT_CASE(iio_test_iio_format_value_integer),
KUNIT_CASE(iio_test_iio_format_value_fixedpoint),
KUNIT_CASE(iio_test_iio_format_value_fractional),
KUNIT_CASE(iio_test_iio_format_value_fractional_log2),
KUNIT_CASE(iio_test_iio_format_value_multiple),
KUNIT_CASE(iio_test_iio_format_value_integer_64),
{ }
};
static struct kunit_suite iio_format_test_suite = {
.name = "iio-format",
.test_cases = iio_format_test_cases,
};
kunit_test_suite(iio_format_test_suite);
MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("Test IIO formatting functions");
MODULE_LICENSE("GPL v2");
linux-7.2.3/drivers/iio/test/iio-test-gts.c
+515
View File
@@ -0,0 +1,515 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Unit tests for IIO light sensor gain-time-scale helpers
*
* Copyright (c) 2023 Matti Vaittinen <mazziesaccount@gmail.com>
*/
#include <kunit/device.h>
#include <kunit/test.h>
#include <linux/device.h>
#include <linux/iio/iio-gts-helper.h>
#include <linux/iio/types.h>
/*
* Please, read the "rant" from the top of the lib/test_linear_ranges.c if
* you see a line of helper code which is not being tested.
*
* Then, please look at the line which is not being tested. Is this line
* somehow unusually complex? If answer is "no", then chances are that the
* "development inertia" caused by adding a test exceeds the benefits.
*
* If yes, then adding a test is probably a good idea but please stop for a
* moment and consider the effort of changing all the tests when code gets
* refactored. Eventually it needs to be.
*/
#define TEST_TSEL_50 1
#define TEST_TSEL_X_MIN TEST_TSEL_50
#define TEST_TSEL_100 0
#define TEST_TSEL_200 2
#define TEST_TSEL_400 4
#define TEST_TSEL_X_MAX TEST_TSEL_400
#define TEST_GSEL_1 0x00
#define TEST_GSEL_X_MIN TEST_GSEL_1
#define TEST_GSEL_4 0x08
#define TEST_GSEL_16 0x0a
#define TEST_GSEL_32 0x0b
#define TEST_GSEL_64 0x0c
#define TEST_GSEL_256 0x18
#define TEST_GSEL_512 0x19
#define TEST_GSEL_1024 0x1a
#define TEST_GSEL_2048 0x1b
#define TEST_GSEL_4096 0x1c
#define TEST_GSEL_X_MAX TEST_GSEL_4096
#define TEST_SCALE_1X 64
#define TEST_SCALE_MIN_X TEST_SCALE_1X
#define TEST_SCALE_2X 32
#define TEST_SCALE_4X 16
#define TEST_SCALE_8X 8
#define TEST_SCALE_16X 4
#define TEST_SCALE_32X 2
#define TEST_SCALE_64X 1
#define TEST_SCALE_NANO_128X 500000000
#define TEST_SCALE_NANO_256X 250000000
#define TEST_SCALE_NANO_512X 125000000
#define TEST_SCALE_NANO_1024X 62500000
#define TEST_SCALE_NANO_2048X 31250000
#define TEST_SCALE_NANO_4096X 15625000
#define TEST_SCALE_NANO_4096X2 7812500
#define TEST_SCALE_NANO_4096X4 3906250
#define TEST_SCALE_NANO_4096X8 1953125
#define TEST_SCALE_NANO_MAX_X TEST_SCALE_NANO_4096X8
/*
* Can't have this allocated from stack because the kunit clean-up will
* happen only after the test function has already gone
*/
static struct iio_gts gts;
/* Keep the gain and time tables unsorted to test the sorting */
static const struct iio_gain_sel_pair gts_test_gains[] = {
GAIN_SCALE_GAIN(1, TEST_GSEL_1),
GAIN_SCALE_GAIN(4, TEST_GSEL_4),
GAIN_SCALE_GAIN(16, TEST_GSEL_16),
GAIN_SCALE_GAIN(32, TEST_GSEL_32),
GAIN_SCALE_GAIN(64, TEST_GSEL_64),
GAIN_SCALE_GAIN(256, TEST_GSEL_256),
GAIN_SCALE_GAIN(512, TEST_GSEL_512),
GAIN_SCALE_GAIN(1024, TEST_GSEL_1024),
GAIN_SCALE_GAIN(4096, TEST_GSEL_4096),
GAIN_SCALE_GAIN(2048, TEST_GSEL_2048),
#define HWGAIN_MAX 4096
};
static const struct iio_itime_sel_mul gts_test_itimes[] = {
GAIN_SCALE_ITIME_US(100 * 1000, TEST_TSEL_100, 2),
GAIN_SCALE_ITIME_US(400 * 1000, TEST_TSEL_400, 8),
GAIN_SCALE_ITIME_US(400 * 1000, TEST_TSEL_400, 8),
GAIN_SCALE_ITIME_US(50 * 1000, TEST_TSEL_50, 1),
GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
#define TIMEGAIN_MAX 8
};
#define TOTAL_GAIN_MAX (HWGAIN_MAX * TIMEGAIN_MAX)
#define IIO_GTS_TEST_DEV "iio-gts-test-dev"
static struct device *__test_init_iio_gain_scale(struct kunit *test,
struct iio_gts *gts, const struct iio_gain_sel_pair *g_table,
int num_g, const struct iio_itime_sel_mul *i_table, int num_i)
{
struct device *dev;
int ret;
dev = kunit_device_register(test, IIO_GTS_TEST_DEV);
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, dev);
if (IS_ERR_OR_NULL(dev))
return NULL;
ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, 0, g_table, num_g,
i_table, num_i, gts);
KUNIT_EXPECT_EQ(test, 0, ret);
if (ret)
return NULL;
return dev;
}
#define test_init_iio_gain_scale(test, gts) \
__test_init_iio_gain_scale(test, gts, gts_test_gains, \
ARRAY_SIZE(gts_test_gains), gts_test_itimes, \
ARRAY_SIZE(gts_test_itimes))
static void test_init_iio_gts_invalid(struct kunit *test)
{
struct device *dev;
int ret;
const struct iio_itime_sel_mul itimes_neg[] = {
GAIN_SCALE_ITIME_US(-10, TEST_TSEL_400, 8),
GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
};
const struct iio_gain_sel_pair gains_neg[] = {
GAIN_SCALE_GAIN(1, TEST_GSEL_1),
GAIN_SCALE_GAIN(2, TEST_GSEL_4),
GAIN_SCALE_GAIN(-2, TEST_GSEL_16),
};
/* 55555 * 38656 = 2147534080 => overflows 32bit int */
const struct iio_itime_sel_mul itimes_overflow[] = {
GAIN_SCALE_ITIME_US(400 * 1000, TEST_TSEL_400, 55555),
GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
};
const struct iio_gain_sel_pair gains_overflow[] = {
GAIN_SCALE_GAIN(1, TEST_GSEL_1),
GAIN_SCALE_GAIN(2, TEST_GSEL_4),
GAIN_SCALE_GAIN(38656, TEST_GSEL_16),
};
dev = kunit_device_register(test, IIO_GTS_TEST_DEV);
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, dev);
if (!dev)
return;
/* Ok gains, negative time */
ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, 0, gts_test_gains,
ARRAY_SIZE(gts_test_gains), itimes_neg,
ARRAY_SIZE(itimes_neg), &gts);
KUNIT_EXPECT_EQ(test, -EINVAL, ret);
/* Ok times, negative gain */
ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, 0, gains_neg,
ARRAY_SIZE(gains_neg), gts_test_itimes,
ARRAY_SIZE(gts_test_itimes), &gts);
KUNIT_EXPECT_EQ(test, -EINVAL, ret);
/* gain * time overflow int */
ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, 0, gains_overflow,
ARRAY_SIZE(gains_overflow), itimes_overflow,
ARRAY_SIZE(itimes_overflow), &gts);
KUNIT_EXPECT_EQ(test, -EOVERFLOW, ret);
}
static void test_iio_gts_find_gain_for_scale_using_time(struct kunit *test)
{
struct device *dev;
int ret, gain_sel;
dev = test_init_iio_gain_scale(test, &gts);
if (!dev)
return;
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_100,
TEST_SCALE_8X, 0, &gain_sel);
/*
* Meas time 100 => gain by time 2x
* TEST_SCALE_8X matches total gain 8x
* => required HWGAIN 4x
*/
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_GSEL_4, gain_sel);
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_200, 0,
TEST_SCALE_NANO_256X, &gain_sel);
/*
* Meas time 200 => gain by time 4x
* TEST_SCALE_256X matches total gain 256x
* => required HWGAIN 256/4 => 64x
*/
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_GSEL_64, gain_sel);
/* Min time, Min gain */
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_X_MIN,
TEST_SCALE_MIN_X, 0, &gain_sel);
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_GSEL_1, gain_sel);
/* Max time, Max gain */
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_X_MAX,
0, TEST_SCALE_NANO_MAX_X, &gain_sel);
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_GSEL_4096, gain_sel);
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_100, 0,
TEST_SCALE_NANO_256X, &gain_sel);
/*
* Meas time 100 => gain by time 2x
* TEST_SCALE_256X matches total gain 256x
* => required HWGAIN 256/2 => 128x (not in gain-table - unsupported)
*/
KUNIT_EXPECT_NE(test, 0, ret);
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_200, 0,
TEST_SCALE_NANO_MAX_X, &gain_sel);
/* We can't reach the max gain with integration time smaller than MAX */
KUNIT_EXPECT_NE(test, 0, ret);
ret = iio_gts_find_gain_sel_for_scale_using_time(&gts, TEST_TSEL_50, 0,
TEST_SCALE_NANO_MAX_X, &gain_sel);
/* We can't reach the max gain with integration time smaller than MAX */
KUNIT_EXPECT_NE(test, 0, ret);
}
static void test_iio_gts_find_new_gain_sel_by_old_gain_time(struct kunit *test)
{
struct device *dev;
int ret, old_gain, new_gain, old_time_sel, new_time_sel;
dev = test_init_iio_gain_scale(test, &gts);
if (!dev)
return;
old_gain = 32;
old_time_sel = TEST_TSEL_200;
new_time_sel = TEST_TSEL_400;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_EQ(test, 0, ret);
/*
* Doubling the integration time doubles the total gain - so old
* (hw)gain must be divided by two to compensate. => 32 / 2 => 16
*/
KUNIT_EXPECT_EQ(test, 16, new_gain);
old_gain = 4;
old_time_sel = TEST_TSEL_50;
new_time_sel = TEST_TSEL_200;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_EQ(test, 0, ret);
/*
* gain by time 1x => 4x - (hw)gain 4x => 1x
*/
KUNIT_EXPECT_EQ(test, 1, new_gain);
old_gain = 512;
old_time_sel = TEST_TSEL_400;
new_time_sel = TEST_TSEL_50;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_EQ(test, 0, ret);
/*
* gain by time 8x => 1x - (hw)gain 512x => 4096x)
*/
KUNIT_EXPECT_EQ(test, 4096, new_gain);
/* Unsupported gain 2x */
old_gain = 4;
old_time_sel = TEST_TSEL_200;
new_time_sel = TEST_TSEL_400;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_NE(test, 0, ret);
/* Too small gain */
old_gain = 4;
old_time_sel = TEST_TSEL_50;
new_time_sel = TEST_TSEL_400;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_NE(test, 0, ret);
/* Too big gain */
old_gain = 1024;
old_time_sel = TEST_TSEL_400;
new_time_sel = TEST_TSEL_50;
ret = iio_gts_find_new_gain_sel_by_old_gain_time(&gts, old_gain,
old_time_sel, new_time_sel, &new_gain);
KUNIT_EXPECT_NE(test, 0, ret);
}
static void test_iio_find_closest_gain_low(struct kunit *test)
{
struct device *dev;
bool in_range;
int ret;
const struct iio_gain_sel_pair gts_test_gains_gain_low[] = {
GAIN_SCALE_GAIN(4, TEST_GSEL_4),
GAIN_SCALE_GAIN(16, TEST_GSEL_16),
GAIN_SCALE_GAIN(32, TEST_GSEL_32),
};
dev = test_init_iio_gain_scale(test, &gts);
if (!dev)
return;
ret = iio_find_closest_gain_low(&gts, 2, &in_range);
KUNIT_EXPECT_EQ(test, 1, ret);
KUNIT_EXPECT_EQ(test, true, in_range);
ret = iio_find_closest_gain_low(&gts, 1, &in_range);
KUNIT_EXPECT_EQ(test, 1, ret);
KUNIT_EXPECT_EQ(test, true, in_range);
ret = iio_find_closest_gain_low(&gts, 4095, &in_range);
KUNIT_EXPECT_EQ(test, 2048, ret);
KUNIT_EXPECT_EQ(test, true, in_range);
ret = iio_find_closest_gain_low(&gts, 4097, &in_range);
KUNIT_EXPECT_EQ(test, 4096, ret);
KUNIT_EXPECT_EQ(test, false, in_range);
kunit_device_unregister(test, dev);
dev = __test_init_iio_gain_scale(test, &gts, gts_test_gains_gain_low,
ARRAY_SIZE(gts_test_gains_gain_low),
gts_test_itimes, ARRAY_SIZE(gts_test_itimes));
if (!dev)
return;
ret = iio_find_closest_gain_low(&gts, 3, &in_range);
KUNIT_EXPECT_EQ(test, -EINVAL, ret);
KUNIT_EXPECT_EQ(test, false, in_range);
}
static void test_iio_gts_total_gain_to_scale(struct kunit *test)
{
struct device *dev;
int ret, scale_int, scale_nano;
dev = test_init_iio_gain_scale(test, &gts);
if (!dev)
return;
ret = iio_gts_total_gain_to_scale(&gts, 1, &scale_int, &scale_nano);
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_SCALE_1X, scale_int);
KUNIT_EXPECT_EQ(test, 0, scale_nano);
ret = iio_gts_total_gain_to_scale(&gts, 1, &scale_int, &scale_nano);
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, TEST_SCALE_1X, scale_int);
KUNIT_EXPECT_EQ(test, 0, scale_nano);
ret = iio_gts_total_gain_to_scale(&gts, 4096 * 8, &scale_int,
&scale_nano);
KUNIT_EXPECT_EQ(test, 0, ret);
KUNIT_EXPECT_EQ(test, 0, scale_int);
KUNIT_EXPECT_EQ(test, TEST_SCALE_NANO_4096X8, scale_nano);
}
static void test_iio_gts_chk_times(struct kunit *test, const int *vals)
{
static const int expected[] = {0, 50000, 0, 100000, 0, 200000, 0, 400000};
int i;
for (i = 0; i < ARRAY_SIZE(expected); i++)
KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
}
static void test_iio_gts_chk_scales_all(struct kunit *test, struct iio_gts *gts,
const int *vals, int len)
{
static const int gains[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
1024, 2048, 4096, 4096 * 2, 4096 * 4,
4096 * 8};
int expected[ARRAY_SIZE(gains) * 2];
int i, ret;
int exp_len = ARRAY_SIZE(gains) * 2;
KUNIT_EXPECT_EQ(test, exp_len, len);
if (len != exp_len)
return;
for (i = 0; i < ARRAY_SIZE(gains); i++) {
ret = iio_gts_total_gain_to_scale(gts, gains[i],
&expected[2 * i],
&expected[2 * i + 1]);
KUNIT_EXPECT_EQ(test, 0, ret);
if (ret)
return;
}
for (i = 0; i < ARRAY_SIZE(expected); i++)
KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
}
static void test_iio_gts_chk_scales_t200(struct kunit *test, struct iio_gts *gts,
const int *vals, int len)
{
/* The gain caused by time 200 is 4x */
static const int gains[] = {
1 * 4,
4 * 4,
16 * 4,
32 * 4,
64 * 4,
256 * 4,
512 * 4,
1024 * 4,
2048 * 4,
4096 * 4
};
int expected[ARRAY_SIZE(gains) * 2];
int i, ret;
KUNIT_EXPECT_EQ(test, 2 * ARRAY_SIZE(gains), len);
if (len < 2 * ARRAY_SIZE(gains))
return;
for (i = 0; i < ARRAY_SIZE(gains); i++) {
ret = iio_gts_total_gain_to_scale(gts, gains[i],
&expected[2 * i],
&expected[2 * i + 1]);
KUNIT_EXPECT_EQ(test, 0, ret);
if (ret)
return;
}
for (i = 0; i < ARRAY_SIZE(expected); i++)
KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
}
static void test_iio_gts_avail_test(struct kunit *test)
{
struct device *dev;
int ret;
int type, len;
const int *vals;
dev = test_init_iio_gain_scale(test, &gts);
if (!dev)
return;
/* test table building for times and iio_gts_avail_times() */
ret = iio_gts_avail_times(&gts, &vals, &type, &len);
KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
if (ret)
return;
KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_MICRO, type);
KUNIT_EXPECT_EQ(test, 8, len);
if (len < 8)
return;
test_iio_gts_chk_times(test, vals);
/* Test table building for all scales and iio_gts_all_avail_scales() */
ret = iio_gts_all_avail_scales(&gts, &vals, &type, &len);
KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
if (ret)
return;
KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_NANO, type);
test_iio_gts_chk_scales_all(test, &gts, vals, len);
/*
* Test table building for scales/time and
* iio_gts_avail_scales_for_time()
*/
ret = iio_gts_avail_scales_for_time(&gts, 200000, &vals, &type, &len);
KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
if (ret)
return;
KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_NANO, type);
test_iio_gts_chk_scales_t200(test, &gts, vals, len);
}
static struct kunit_case iio_gts_test_cases[] = {
KUNIT_CASE(test_init_iio_gts_invalid),
KUNIT_CASE(test_iio_gts_find_gain_for_scale_using_time),
KUNIT_CASE(test_iio_gts_find_new_gain_sel_by_old_gain_time),
KUNIT_CASE(test_iio_find_closest_gain_low),
KUNIT_CASE(test_iio_gts_total_gain_to_scale),
KUNIT_CASE(test_iio_gts_avail_test),
{ }
};
static struct kunit_suite iio_gts_test_suite = {
.name = "iio-gain-time-scale",
.test_cases = iio_gts_test_cases,
};
kunit_test_suite(iio_gts_test_suite);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Matti Vaittinen <mazziesaccount@gmail.com>");
MODULE_DESCRIPTION("Test IIO light sensor gain-time-scale helpers");
MODULE_IMPORT_NS("IIO_GTS_HELPER");
linux-7.2.3/drivers/iio/test/iio-test-multiply.c
+212
View File
@@ -0,0 +1,212 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Unit tests for IIO multiply functions
*
* Copyright (c) 2025 Hans de Goede <hans@hansg.org>
* Based on iio-test-format.c which is:
* Copyright (c) 2020 Lars-Peter Clausen <lars@metafoo.de>
*/
#include <kunit/test.h>
#include <linux/iio/consumer.h>
#include <linux/math64.h>
#include <linux/types.h>
static void __iio_test_iio_multiply_value_integer(struct kunit *test, s64 multiplier)
{
int ret, result, val;
val = 42;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT, val, 0);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, multiplier * val);
val = -23;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT, val, 0);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, multiplier * val);
val = 0;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT, val, 0);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, multiplier * val);
}
static void iio_test_iio_multiply_value_integer(struct kunit *test)
{
__iio_test_iio_multiply_value_integer(test, 20);
__iio_test_iio_multiply_value_integer(test, -20);
}
static void __iio_test_iio_multiply_value_fixedpoint(struct kunit *test, s64 multiplier)
{
int ret, result, val, val2;
/* positive >= 1 (1.5) */
val = 1;
val2 = 500000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_MICRO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * 15, 10));
val = 1;
val2 = 500000000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_NANO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * 15, 10));
/* positive < 1 (0.5) */
val = 0;
val2 = 500000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_MICRO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * 5, 10));
val = 0;
val2 = 500000000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_NANO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * 5, 10));
/* negative <= -1 (-1.5) */
val = -1;
val2 = 500000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_MICRO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * -15, 10));
val = -1;
val2 = 500000000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_NANO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * -15, 10));
/* negative > -1 (-0.5) */
val = 0;
val2 = -500000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_MICRO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * -5, 10));
val = 0;
val2 = -500000000;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_INT_PLUS_NANO, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * -5, 10));
}
static void iio_test_iio_multiply_value_fixedpoint(struct kunit *test)
{
__iio_test_iio_multiply_value_fixedpoint(test, 20);
__iio_test_iio_multiply_value_fixedpoint(test, -20);
}
static void __iio_test_iio_multiply_value_fractional(struct kunit *test, s64 multiplier)
{
int ret, result, val, val2;
/* positive < 1 (1/10)*/
val = 1;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * val, val2));
/* positive >= 1 (100/3)*/
val = 100;
val2 = 3;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * val, val2));
/* negative > -1 (-1/10) */
val = -1;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * val, val2));
/* negative <= -1 (-200/3)*/
val = -200;
val2 = 3;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * val, val2));
/* Zero (0/-10) */
val = 0;
val2 = -10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, div_s64(multiplier * val, val2));
}
static void iio_test_iio_multiply_value_fractional(struct kunit *test)
{
__iio_test_iio_multiply_value_fractional(test, 20);
__iio_test_iio_multiply_value_fractional(test, -20);
}
static void __iio_test_iio_multiply_value_fractional_log2(struct kunit *test, s64 multiplier)
{
int ret, result, val, val2;
/* positive < 1 (123/1024) */
val = 123;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL_LOG2, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, (multiplier * val) >> val2);
/* positive >= 1 (1234567/1024) */
val = 1234567;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL_LOG2, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, (multiplier * val) >> val2);
/* negative > -1 (-123/1024) */
val = -123;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL_LOG2, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, (multiplier * val) >> val2);
/* negative <= -1 (-1234567/1024) */
val = -1234567;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL_LOG2, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, (multiplier * val) >> val2);
/* Zero (0/1024) */
val = 0;
val2 = 10;
ret = iio_multiply_value(&result, multiplier, IIO_VAL_FRACTIONAL_LOG2, val, val2);
KUNIT_EXPECT_EQ(test, ret, IIO_VAL_INT);
KUNIT_EXPECT_EQ(test, result, (multiplier * val) >> val2);
}
static void iio_test_iio_multiply_value_fractional_log2(struct kunit *test)
{
__iio_test_iio_multiply_value_fractional_log2(test, 20);
__iio_test_iio_multiply_value_fractional_log2(test, -20);
}
static struct kunit_case iio_multiply_test_cases[] = {
KUNIT_CASE(iio_test_iio_multiply_value_integer),
KUNIT_CASE(iio_test_iio_multiply_value_fixedpoint),
KUNIT_CASE(iio_test_iio_multiply_value_fractional),
KUNIT_CASE(iio_test_iio_multiply_value_fractional_log2),
{ }
};
static struct kunit_suite iio_multiply_test_suite = {
.name = "iio-multiply",
.test_cases = iio_multiply_test_cases,
};
kunit_test_suite(iio_multiply_test_suite);
MODULE_AUTHOR("Hans de Goede <hans@hansg.org>");
MODULE_DESCRIPTION("Test IIO multiply functions");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("IIO_UNIT_TEST");
linux-7.2.3/drivers/iio/test/iio-test-rescale.c
+719
View File
@@ -0,0 +1,719 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Kunit tests for IIO rescale conversions
*
* Copyright (c) 2021 Liam Beguin <liambeguin@gmail.com>
*/
#include <linux/gcd.h>
#include <linux/overflow.h>
#include <linux/iio/afe/rescale.h>
#include <linux/iio/iio.h>
#include <kunit/test.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;
};
static 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",
},
};
static 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 tmp, tmp2;
int ret = 0;
/*
* iio_str_to_fixpoint() uses 10^8 here instead of 10^9 as fract_mult is
* the multiplier for the first decimal place.
*/
ret = iio_str_to_fixpoint(str, 100000000, &tmp, &tmp2);
if (ret < 0)
return ret;
if (tmp < 0)
tmp2 *= -1;
*nano = (s64)tmp * 1000000000UL + 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 = 1000000UL * abs(exp - real);
return (int)div64_u64(err, abs(exp));
}
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;
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buff);
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;
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buff_off);
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);
MODULE_AUTHOR("Liam Beguin <liambeguin@gmail.com>");
MODULE_DESCRIPTION("Test IIO rescale conversion functions");
MODULE_LICENSE("GPL v2");
MODULE_IMPORT_NS("IIO_RESCALE");