1// SPDX-License-Identifier: GPL-2.0-only
2/* Unit tests for IIO light sensor gain-time-scale helpers
3 *
4 * Copyright (c) 2023 Matti Vaittinen <mazziesaccount@gmail.com>
5 */
6
7#include <kunit/device.h>
8#include <kunit/test.h>
9#include <linux/device.h>
10#include <linux/iio/iio-gts-helper.h>
11#include <linux/iio/types.h>
12
13/*
14 * Please, read the "rant" from the top of the lib/test_linear_ranges.c if
15 * you see a line of helper code which is not being tested.
16 *
17 * Then, please look at the line which is not being tested. Is this line
18 * somehow unusually complex? If answer is "no", then chances are that the
19 * "development inertia" caused by adding a test exceeds the benefits.
20 *
21 * If yes, then adding a test is probably a good idea but please stop for a
22 * moment and consider the effort of changing all the tests when code gets
23 * refactored. Eventually it neeeds to be.
24 */
25
26#define TEST_TSEL_50 1
27#define TEST_TSEL_X_MIN TEST_TSEL_50
28#define TEST_TSEL_100 0
29#define TEST_TSEL_200 2
30#define TEST_TSEL_400 4
31#define TEST_TSEL_X_MAX TEST_TSEL_400
32
33#define TEST_GSEL_1 0x00
34#define TEST_GSEL_X_MIN TEST_GSEL_1
35#define TEST_GSEL_4 0x08
36#define TEST_GSEL_16 0x0a
37#define TEST_GSEL_32 0x0b
38#define TEST_GSEL_64 0x0c
39#define TEST_GSEL_256 0x18
40#define TEST_GSEL_512 0x19
41#define TEST_GSEL_1024 0x1a
42#define TEST_GSEL_2048 0x1b
43#define TEST_GSEL_4096 0x1c
44#define TEST_GSEL_X_MAX TEST_GSEL_4096
45
46#define TEST_SCALE_1X 64
47#define TEST_SCALE_MIN_X TEST_SCALE_1X
48#define TEST_SCALE_2X 32
49#define TEST_SCALE_4X 16
50#define TEST_SCALE_8X 8
51#define TEST_SCALE_16X 4
52#define TEST_SCALE_32X 2
53#define TEST_SCALE_64X 1
54
55#define TEST_SCALE_NANO_128X 500000000
56#define TEST_SCALE_NANO_256X 250000000
57#define TEST_SCALE_NANO_512X 125000000
58#define TEST_SCALE_NANO_1024X 62500000
59#define TEST_SCALE_NANO_2048X 31250000
60#define TEST_SCALE_NANO_4096X 15625000
61#define TEST_SCALE_NANO_4096X2 7812500
62#define TEST_SCALE_NANO_4096X4 3906250
63#define TEST_SCALE_NANO_4096X8 1953125
64
65#define TEST_SCALE_NANO_MAX_X TEST_SCALE_NANO_4096X8
66
67/*
68 * Can't have this allocated from stack because the kunit clean-up will
69 * happen only after the test function has already gone
70 */
71static struct iio_gts gts;
72
73static const struct iio_gain_sel_pair gts_test_gains[] = {
74 GAIN_SCALE_GAIN(1, TEST_GSEL_1),
75 GAIN_SCALE_GAIN(4, TEST_GSEL_4),
76 GAIN_SCALE_GAIN(16, TEST_GSEL_16),
77 GAIN_SCALE_GAIN(32, TEST_GSEL_32),
78 GAIN_SCALE_GAIN(64, TEST_GSEL_64),
79 GAIN_SCALE_GAIN(256, TEST_GSEL_256),
80 GAIN_SCALE_GAIN(512, TEST_GSEL_512),
81 GAIN_SCALE_GAIN(1024, TEST_GSEL_1024),
82 GAIN_SCALE_GAIN(2048, TEST_GSEL_2048),
83 GAIN_SCALE_GAIN(4096, TEST_GSEL_4096),
84#define HWGAIN_MAX 4096
85};
86
87static const struct iio_itime_sel_mul gts_test_itimes[] = {
88 GAIN_SCALE_ITIME_US(400 * 1000, TEST_TSEL_400, 8),
89 GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
90 GAIN_SCALE_ITIME_US(100 * 1000, TEST_TSEL_100, 2),
91 GAIN_SCALE_ITIME_US(50 * 1000, TEST_TSEL_50, 1),
92#define TIMEGAIN_MAX 8
93};
94#define TOTAL_GAIN_MAX (HWGAIN_MAX * TIMEGAIN_MAX)
95#define IIO_GTS_TEST_DEV "iio-gts-test-dev"
96
97static struct device *__test_init_iio_gain_scale(struct kunit *test,
98 struct iio_gts *gts, const struct iio_gain_sel_pair *g_table,
99 int num_g, const struct iio_itime_sel_mul *i_table, int num_i)
100{
101 struct device *dev;
102 int ret;
103
104 dev = kunit_device_register(test, IIO_GTS_TEST_DEV);
105
106 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, dev);
107 if (IS_ERR_OR_NULL(ptr: dev))
108 return NULL;
109
110 ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, max_scale_nano: 0, gain_tbl: g_table, num_gain: num_g,
111 tim_tbl: i_table, num_times: num_i, gts);
112 KUNIT_EXPECT_EQ(test, 0, ret);
113 if (ret)
114 return NULL;
115
116 return dev;
117}
118
119#define test_init_iio_gain_scale(test, gts) \
120 __test_init_iio_gain_scale(test, gts, gts_test_gains, \
121 ARRAY_SIZE(gts_test_gains), gts_test_itimes, \
122 ARRAY_SIZE(gts_test_itimes))
123
124static void test_init_iio_gts_invalid(struct kunit *test)
125{
126 struct device *dev;
127 int ret;
128 const struct iio_itime_sel_mul itimes_neg[] = {
129 GAIN_SCALE_ITIME_US(-10, TEST_TSEL_400, 8),
130 GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
131 };
132 const struct iio_gain_sel_pair gains_neg[] = {
133 GAIN_SCALE_GAIN(1, TEST_GSEL_1),
134 GAIN_SCALE_GAIN(2, TEST_GSEL_4),
135 GAIN_SCALE_GAIN(-2, TEST_GSEL_16),
136 };
137 /* 55555 * 38656 = 2147534080 => overflows 32bit int */
138 const struct iio_itime_sel_mul itimes_overflow[] = {
139 GAIN_SCALE_ITIME_US(400 * 1000, TEST_TSEL_400, 55555),
140 GAIN_SCALE_ITIME_US(200 * 1000, TEST_TSEL_200, 4),
141 };
142 const struct iio_gain_sel_pair gains_overflow[] = {
143 GAIN_SCALE_GAIN(1, TEST_GSEL_1),
144 GAIN_SCALE_GAIN(2, TEST_GSEL_4),
145 GAIN_SCALE_GAIN(38656, TEST_GSEL_16),
146 };
147
148 dev = kunit_device_register(test, IIO_GTS_TEST_DEV);
149 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, dev);
150 if (!dev)
151 return;
152
153 /* Ok gains, negative time */
154 ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, max_scale_nano: 0, gain_tbl: gts_test_gains,
155 ARRAY_SIZE(gts_test_gains), tim_tbl: itimes_neg,
156 ARRAY_SIZE(itimes_neg), gts: &gts);
157 KUNIT_EXPECT_EQ(test, -EINVAL, ret);
158
159 /* Ok times, negative gain */
160 ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, max_scale_nano: 0, gain_tbl: gains_neg,
161 ARRAY_SIZE(gains_neg), tim_tbl: gts_test_itimes,
162 ARRAY_SIZE(gts_test_itimes), gts: &gts);
163 KUNIT_EXPECT_EQ(test, -EINVAL, ret);
164
165 /* gain * time overflow int */
166 ret = devm_iio_init_iio_gts(dev, TEST_SCALE_1X, max_scale_nano: 0, gain_tbl: gains_overflow,
167 ARRAY_SIZE(gains_overflow), tim_tbl: itimes_overflow,
168 ARRAY_SIZE(itimes_overflow), gts: &gts);
169 KUNIT_EXPECT_EQ(test, -EOVERFLOW, ret);
170}
171
172static void test_iio_gts_find_gain_for_scale_using_time(struct kunit *test)
173{
174 struct device *dev;
175 int ret, gain_sel;
176
177 dev = test_init_iio_gain_scale(test, &gts);
178 if (!dev)
179 return;
180
181 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_100,
182 TEST_SCALE_8X, scale_nano: 0, gain_sel: &gain_sel);
183 /*
184 * Meas time 100 => gain by time 2x
185 * TEST_SCALE_8X matches total gain 8x
186 * => required HWGAIN 4x
187 */
188 KUNIT_EXPECT_EQ(test, 0, ret);
189 KUNIT_EXPECT_EQ(test, TEST_GSEL_4, gain_sel);
190
191 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_200, scale_int: 0,
192 TEST_SCALE_NANO_256X, gain_sel: &gain_sel);
193 /*
194 * Meas time 200 => gain by time 4x
195 * TEST_SCALE_256X matches total gain 256x
196 * => required HWGAIN 256/4 => 64x
197 */
198 KUNIT_EXPECT_EQ(test, 0, ret);
199 KUNIT_EXPECT_EQ(test, TEST_GSEL_64, gain_sel);
200
201 /* Min time, Min gain */
202 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_X_MIN,
203 TEST_SCALE_MIN_X, scale_nano: 0, gain_sel: &gain_sel);
204 KUNIT_EXPECT_EQ(test, 0, ret);
205 KUNIT_EXPECT_EQ(test, TEST_GSEL_1, gain_sel);
206
207 /* Max time, Max gain */
208 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_X_MAX,
209 scale_int: 0, TEST_SCALE_NANO_MAX_X, gain_sel: &gain_sel);
210 KUNIT_EXPECT_EQ(test, 0, ret);
211 KUNIT_EXPECT_EQ(test, TEST_GSEL_4096, gain_sel);
212
213 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_100, scale_int: 0,
214 TEST_SCALE_NANO_256X, gain_sel: &gain_sel);
215 /*
216 * Meas time 100 => gain by time 2x
217 * TEST_SCALE_256X matches total gain 256x
218 * => required HWGAIN 256/2 => 128x (not in gain-table - unsupported)
219 */
220 KUNIT_EXPECT_NE(test, 0, ret);
221
222 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_200, scale_int: 0,
223 TEST_SCALE_NANO_MAX_X, gain_sel: &gain_sel);
224 /* We can't reach the max gain with integration time smaller than MAX */
225 KUNIT_EXPECT_NE(test, 0, ret);
226
227 ret = iio_gts_find_gain_sel_for_scale_using_time(gts: &gts, TEST_TSEL_50, scale_int: 0,
228 TEST_SCALE_NANO_MAX_X, gain_sel: &gain_sel);
229 /* We can't reach the max gain with integration time smaller than MAX */
230 KUNIT_EXPECT_NE(test, 0, ret);
231}
232
233static void test_iio_gts_find_new_gain_sel_by_old_gain_time(struct kunit *test)
234{
235 struct device *dev;
236 int ret, old_gain, new_gain, old_time_sel, new_time_sel;
237
238 dev = test_init_iio_gain_scale(test, &gts);
239 if (!dev)
240 return;
241
242 old_gain = 32;
243 old_time_sel = TEST_TSEL_200;
244 new_time_sel = TEST_TSEL_400;
245
246 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
247 old_time_sel, new_time_sel, new_gain: &new_gain);
248 KUNIT_EXPECT_EQ(test, 0, ret);
249 /*
250 * Doubling the integration time doubles the total gain - so old
251 * (hw)gain must be divided by two to compensate. => 32 / 2 => 16
252 */
253 KUNIT_EXPECT_EQ(test, 16, new_gain);
254
255 old_gain = 4;
256 old_time_sel = TEST_TSEL_50;
257 new_time_sel = TEST_TSEL_200;
258 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
259 old_time_sel, new_time_sel, new_gain: &new_gain);
260 KUNIT_EXPECT_EQ(test, 0, ret);
261 /*
262 * gain by time 1x => 4x - (hw)gain 4x => 1x
263 */
264 KUNIT_EXPECT_EQ(test, 1, new_gain);
265
266 old_gain = 512;
267 old_time_sel = TEST_TSEL_400;
268 new_time_sel = TEST_TSEL_50;
269 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
270 old_time_sel, new_time_sel, new_gain: &new_gain);
271 KUNIT_EXPECT_EQ(test, 0, ret);
272 /*
273 * gain by time 8x => 1x - (hw)gain 512x => 4096x)
274 */
275 KUNIT_EXPECT_EQ(test, 4096, new_gain);
276
277 /* Unsupported gain 2x */
278 old_gain = 4;
279 old_time_sel = TEST_TSEL_200;
280 new_time_sel = TEST_TSEL_400;
281 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
282 old_time_sel, new_time_sel, new_gain: &new_gain);
283 KUNIT_EXPECT_NE(test, 0, ret);
284
285 /* Too small gain */
286 old_gain = 4;
287 old_time_sel = TEST_TSEL_50;
288 new_time_sel = TEST_TSEL_400;
289 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
290 old_time_sel, new_time_sel, new_gain: &new_gain);
291 KUNIT_EXPECT_NE(test, 0, ret);
292
293 /* Too big gain */
294 old_gain = 1024;
295 old_time_sel = TEST_TSEL_400;
296 new_time_sel = TEST_TSEL_50;
297 ret = iio_gts_find_new_gain_sel_by_old_gain_time(gts: &gts, old_gain,
298 old_time_sel, new_time_sel, new_gain: &new_gain);
299 KUNIT_EXPECT_NE(test, 0, ret);
300
301}
302
303static void test_iio_find_closest_gain_low(struct kunit *test)
304{
305 struct device *dev;
306 bool in_range;
307 int ret;
308
309 const struct iio_gain_sel_pair gts_test_gains_gain_low[] = {
310 GAIN_SCALE_GAIN(4, TEST_GSEL_4),
311 GAIN_SCALE_GAIN(16, TEST_GSEL_16),
312 GAIN_SCALE_GAIN(32, TEST_GSEL_32),
313 };
314
315 dev = test_init_iio_gain_scale(test, &gts);
316 if (!dev)
317 return;
318
319 ret = iio_find_closest_gain_low(gts: &gts, gain: 2, in_range: &in_range);
320 KUNIT_EXPECT_EQ(test, 1, ret);
321 KUNIT_EXPECT_EQ(test, true, in_range);
322
323 ret = iio_find_closest_gain_low(gts: &gts, gain: 1, in_range: &in_range);
324 KUNIT_EXPECT_EQ(test, 1, ret);
325 KUNIT_EXPECT_EQ(test, true, in_range);
326
327 ret = iio_find_closest_gain_low(gts: &gts, gain: 4095, in_range: &in_range);
328 KUNIT_EXPECT_EQ(test, 2048, ret);
329 KUNIT_EXPECT_EQ(test, true, in_range);
330
331 ret = iio_find_closest_gain_low(gts: &gts, gain: 4097, in_range: &in_range);
332 KUNIT_EXPECT_EQ(test, 4096, ret);
333 KUNIT_EXPECT_EQ(test, false, in_range);
334
335 kunit_device_unregister(test, dev);
336
337 dev = __test_init_iio_gain_scale(test, gts: &gts, g_table: gts_test_gains_gain_low,
338 ARRAY_SIZE(gts_test_gains_gain_low),
339 i_table: gts_test_itimes, ARRAY_SIZE(gts_test_itimes));
340 if (!dev)
341 return;
342
343 ret = iio_find_closest_gain_low(gts: &gts, gain: 3, in_range: &in_range);
344 KUNIT_EXPECT_EQ(test, -EINVAL, ret);
345 KUNIT_EXPECT_EQ(test, false, in_range);
346}
347
348static void test_iio_gts_total_gain_to_scale(struct kunit *test)
349{
350 struct device *dev;
351 int ret, scale_int, scale_nano;
352
353 dev = test_init_iio_gain_scale(test, &gts);
354 if (!dev)
355 return;
356
357 ret = iio_gts_total_gain_to_scale(gts: &gts, total_gain: 1, scale_int: &scale_int, scale_nano: &scale_nano);
358 KUNIT_EXPECT_EQ(test, 0, ret);
359 KUNIT_EXPECT_EQ(test, TEST_SCALE_1X, scale_int);
360 KUNIT_EXPECT_EQ(test, 0, scale_nano);
361
362 ret = iio_gts_total_gain_to_scale(gts: &gts, total_gain: 1, scale_int: &scale_int, scale_nano: &scale_nano);
363 KUNIT_EXPECT_EQ(test, 0, ret);
364 KUNIT_EXPECT_EQ(test, TEST_SCALE_1X, scale_int);
365 KUNIT_EXPECT_EQ(test, 0, scale_nano);
366
367 ret = iio_gts_total_gain_to_scale(gts: &gts, total_gain: 4096 * 8, scale_int: &scale_int,
368 scale_nano: &scale_nano);
369 KUNIT_EXPECT_EQ(test, 0, ret);
370 KUNIT_EXPECT_EQ(test, 0, scale_int);
371 KUNIT_EXPECT_EQ(test, TEST_SCALE_NANO_4096X8, scale_nano);
372}
373
374static void test_iio_gts_chk_times(struct kunit *test, const int *vals)
375{
376 static const int expected[] = {0, 50000, 0, 100000, 0, 200000, 0, 400000};
377 int i;
378
379 for (i = 0; i < ARRAY_SIZE(expected); i++)
380 KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
381}
382
383static void test_iio_gts_chk_scales_all(struct kunit *test, struct iio_gts *gts,
384 const int *vals, int len)
385{
386 static const int gains[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
387 1024, 2048, 4096, 4096 * 2, 4096 * 4,
388 4096 * 8};
389 int expected[ARRAY_SIZE(gains) * 2];
390 int i, ret;
391 int exp_len = ARRAY_SIZE(gains) * 2;
392
393 KUNIT_EXPECT_EQ(test, exp_len, len);
394 if (len != exp_len)
395 return;
396
397 for (i = 0; i < ARRAY_SIZE(gains); i++) {
398 ret = iio_gts_total_gain_to_scale(gts, total_gain: gains[i],
399 scale_int: &expected[2 * i],
400 scale_nano: &expected[2 * i + 1]);
401 KUNIT_EXPECT_EQ(test, 0, ret);
402 if (ret)
403 return;
404 }
405
406 for (i = 0; i < ARRAY_SIZE(expected); i++)
407 KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
408}
409
410static void test_iio_gts_chk_scales_t200(struct kunit *test, struct iio_gts *gts,
411 const int *vals, int len)
412{
413 /* The gain caused by time 200 is 4x */
414 static const int gains[] = {
415 1 * 4,
416 4 * 4,
417 16 * 4,
418 32 * 4,
419 64 * 4,
420 256 * 4,
421 512 * 4,
422 1024 * 4,
423 2048 * 4,
424 4096 * 4
425 };
426 int expected[ARRAY_SIZE(gains) * 2];
427 int i, ret;
428
429 KUNIT_EXPECT_EQ(test, 2 * ARRAY_SIZE(gains), len);
430 if (len < 2 * ARRAY_SIZE(gains))
431 return;
432
433 for (i = 0; i < ARRAY_SIZE(gains); i++) {
434 ret = iio_gts_total_gain_to_scale(gts, total_gain: gains[i],
435 scale_int: &expected[2 * i],
436 scale_nano: &expected[2 * i + 1]);
437 KUNIT_EXPECT_EQ(test, 0, ret);
438 if (ret)
439 return;
440 }
441
442 for (i = 0; i < ARRAY_SIZE(expected); i++)
443 KUNIT_EXPECT_EQ(test, expected[i], vals[i]);
444}
445
446static void test_iio_gts_avail_test(struct kunit *test)
447{
448 struct device *dev;
449 int ret;
450 int type, len;
451 const int *vals;
452
453 dev = test_init_iio_gain_scale(test, &gts);
454 if (!dev)
455 return;
456
457 /* test table building for times and iio_gts_avail_times() */
458 ret = iio_gts_avail_times(gts: &gts, vals: &vals, type: &type, length: &len);
459 KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
460 if (ret)
461 return;
462
463 KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_MICRO, type);
464 KUNIT_EXPECT_EQ(test, 8, len);
465 if (len < 8)
466 return;
467
468 test_iio_gts_chk_times(test, vals);
469
470 /* Test table building for all scales and iio_gts_all_avail_scales() */
471 ret = iio_gts_all_avail_scales(gts: &gts, vals: &vals, type: &type, length: &len);
472 KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
473 if (ret)
474 return;
475
476 KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_NANO, type);
477
478 test_iio_gts_chk_scales_all(test, gts: &gts, vals, len);
479
480 /*
481 * Test table building for scales/time and
482 * iio_gts_avail_scales_for_time()
483 */
484 ret = iio_gts_avail_scales_for_time(gts: &gts, time: 200000, vals: &vals, type: &type, length: &len);
485 KUNIT_EXPECT_EQ(test, IIO_AVAIL_LIST, ret);
486 if (ret)
487 return;
488
489 KUNIT_EXPECT_EQ(test, IIO_VAL_INT_PLUS_NANO, type);
490 test_iio_gts_chk_scales_t200(test, gts: &gts, vals, len);
491}
492
493static struct kunit_case iio_gts_test_cases[] = {
494 KUNIT_CASE(test_init_iio_gts_invalid),
495 KUNIT_CASE(test_iio_gts_find_gain_for_scale_using_time),
496 KUNIT_CASE(test_iio_gts_find_new_gain_sel_by_old_gain_time),
497 KUNIT_CASE(test_iio_find_closest_gain_low),
498 KUNIT_CASE(test_iio_gts_total_gain_to_scale),
499 KUNIT_CASE(test_iio_gts_avail_test),
500 {}
501};
502
503static struct kunit_suite iio_gts_test_suite = {
504 .name = "iio-gain-time-scale",
505 .test_cases = iio_gts_test_cases,
506};
507
508kunit_test_suite(iio_gts_test_suite);
509
510MODULE_LICENSE("GPL");
511MODULE_AUTHOR("Matti Vaittinen <mazziesaccount@gmail.com>");
512MODULE_DESCRIPTION("Test IIO light sensor gain-time-scale helpers");
513MODULE_IMPORT_NS(IIO_GTS_HELPER);
514

source code of linux/drivers/iio/test/iio-test-gts.c