1 /*
2 * SPDX-FileCopyrightText: Copyright (c) 2025 Jilay Sandeep Pandya
3 * SPDX-FileCopyrightText: Copyright (c) 2023 Carl Zeiss Meditec AG
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/devicetree.h>
8 #include <zephyr/drivers/emul_sensor.h>
9 #include <zephyr/drivers/emul.h>
10 #include <zephyr/drivers/i2c_emul.h>
11 #include <zephyr/drivers/sensor.h>
12 #include <zephyr/drivers/sensor/adltc2990.h>
13 #include <zephyr/fff.h>
14 #include <zephyr/ztest.h>
15
16 #include "adltc2990_emul.h"
17 #include "adltc2990_reg.h"
18 #include "adltc2990_internal.h"
19
20 #include <zephyr/logging/log.h>
21
22 DEFINE_FFF_GLOBALS;
23
24 DECLARE_FAKE_VALUE_FUNC(int, fake_mock_i2c_transfer, uint8_t, int, int);
25
26 DEFINE_FAKE_VALUE_FUNC(int, fake_mock_i2c_transfer, uint8_t, int, int);
27
28 static int mock_i2c_transfer_fail_reg_number = -1;
29
adltc2990_i2c_is_touching_reg_delegate(uint8_t start_reg,int num_msgs,int reg)30 static int adltc2990_i2c_is_touching_reg_delegate(uint8_t start_reg, int num_msgs, int reg)
31 {
32
33 if (start_reg == reg) {
34 return -EIO;
35 }
36
37 return 0;
38 }
39
mock_i2c_transfer_delegate(const struct emul * target,struct i2c_msg * msgs,int num_msgs,int addr)40 static int mock_i2c_transfer_delegate(const struct emul *target, struct i2c_msg *msgs, int num_msgs,
41 int addr)
42 {
43 ARG_UNUSED(target);
44 ARG_UNUSED(addr);
45
46 uint8_t start_reg = msgs[0].buf[0];
47
48 fake_mock_i2c_transfer_fake.return_val =
49 fake_mock_i2c_transfer(start_reg, num_msgs, mock_i2c_transfer_fail_reg_number);
50 if (fake_mock_i2c_transfer_fake.return_val == -EIO) {
51 return -EIO;
52 }
53 return -ENOSYS;
54 }
55
reset_mock_i2c_transfer_fake(void)56 static void reset_mock_i2c_transfer_fake(void)
57 {
58 mock_i2c_transfer_fail_reg_number = -1;
59 fake_mock_i2c_transfer_reset();
60 fake_mock_i2c_transfer_fake.custom_fake = adltc2990_i2c_is_touching_reg_delegate;
61 }
62
63 /* Colllection of common assertion macros */
64 #define CHECK_SINGLE_ENDED_VOLTAGE(sensor_val, index, pin_voltage, r1, r2) \
65 zassert_ok(sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE)); \
66 zassert_ok(sensor_channel_get(fixture->dev, SENSOR_CHAN_VOLTAGE, sensor_val)); \
67 zassert_between_inclusive( \
68 sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000, \
69 (pin_voltage - 0.01f) * ((r1 + r2) / (float)r2), \
70 (pin_voltage + 0.01f) * ((r1 + r2) / (float)r2), \
71 "%f Out of Range [%f,%f] input %f, [%dmΩ, %dmΩ] " \
72 "\nCheck if the sensor node is configured correctly", \
73 (double)(sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000), \
74 (double)((pin_voltage - 0.01f) * ((r1 + r2) / (float)r2)), \
75 (double)((pin_voltage + 0.01f) * ((r1 + r2) / (float)r2)), (double)pin_voltage, \
76 r1, r2);
77
78 #define CHECK_CURRENT(sensor_val, index, pin_voltage, r_microohms) \
79 zassert_ok(sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_CURRENT)); \
80 zassert_ok(sensor_channel_get(fixture->dev, SENSOR_CHAN_CURRENT, sensor_val)); \
81 zassert_between_inclusive( \
82 sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000, \
83 (pin_voltage - 0.01f) * ADLTC2990_MICROOHM_CONVERSION_FACTOR / r_microohms, \
84 (pin_voltage + 0.01f) * ADLTC2990_MICROOHM_CONVERSION_FACTOR / r_microohms, \
85 "%f Out of Range [%f,%f] input %f, current-resistor: %dµΩ\nCheck if the sensor " \
86 "node is configured correctly", \
87 (double)(sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000), \
88 (double)((pin_voltage - 0.001f) * ADLTC2990_MICROOHM_CONVERSION_FACTOR / \
89 r_microohms), \
90 (double)((pin_voltage + 0.001f) * ADLTC2990_MICROOHM_CONVERSION_FACTOR / \
91 r_microohms), \
92 (double)pin_voltage, r_microohms);
93
94 #define CHECK_TEMPERATURE(sensor_val, index, expected_temperature, temperature_type) \
95 zassert_ok(sensor_sample_fetch_chan(fixture->dev, temperature_type)); \
96 zassert_ok(sensor_channel_get(fixture->dev, temperature_type, sensor_val)); \
97 zassert_equal(expected_temperature, \
98 sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000, \
99 "expected %f, got %f", (double)expected_temperature, \
100 (double)(sensor_val[index].val1 + (float)sensor_val[index].val2 / 1000000));
101
102 /*** TEST-SUITE: ADLTC2990 Measurement Mode 0 0***/
103
104 struct adltc2990_0_0_fixture {
105 const struct device *dev;
106 const struct emul *target;
107 };
108
adltc2990_0_0_setup(void)109 static void *adltc2990_0_0_setup(void)
110 {
111 static struct adltc2990_0_0_fixture fixture = {
112 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_0_0)),
113 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_0_0)),
114 };
115
116 zassert_not_null(fixture.dev);
117 zassert_not_null(fixture.target);
118 return &fixture;
119 }
120
adltc2990_0_0_before(void * f)121 static void adltc2990_0_0_before(void *f)
122 {
123 struct adltc2990_0_0_fixture *fixture = f;
124
125 adltc2990_emul_reset(fixture->target);
126 }
127
128 ZTEST_SUITE(adltc2990_0_0, NULL, adltc2990_0_0_setup, adltc2990_0_0_before, NULL, NULL);
129
ZTEST_F(adltc2990_0_0,test_measure_mode_internal_temperature_only)130 ZTEST_F(adltc2990_0_0, test_measure_mode_internal_temperature_only)
131 {
132 struct sensor_value value[1];
133
134 zassert_equal(-ENOTSUP, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_MAGN_X));
135 zassert_equal(-ENOTSUP, sensor_channel_get(fixture->dev, SENSOR_CHAN_MAGN_Z, value));
136 zassert_equal(-EINVAL, sensor_channel_get(fixture->dev, SENSOR_CHAN_CURRENT, value));
137 zassert_equal(-EINVAL, sensor_channel_get(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP, value));
138 }
139
140 /*** TEST-SUITE: ADLTC2990 Measurement Mode 4 3***/
141
142 struct adltc2990_4_3_fixture {
143 const struct device *dev;
144 const struct emul *target;
145 };
146
adltc2990_4_3_setup(void)147 static void *adltc2990_4_3_setup(void)
148 {
149 static struct adltc2990_4_3_fixture fixture = {
150 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_4_3)),
151 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_4_3)),
152 };
153
154 zassert_not_null(fixture.dev);
155 zassert_not_null(fixture.target);
156 return &fixture;
157 }
158
adltc2990_4_3_before(void * f)159 static void adltc2990_4_3_before(void *f)
160 {
161 struct adltc2990_4_3_fixture *fixture = f;
162
163 adltc2990_emul_reset(fixture->target);
164 }
165
166 ZTEST_SUITE(adltc2990_4_3, NULL, adltc2990_4_3_setup, adltc2990_4_3_before, NULL, NULL);
167
ZTEST_F(adltc2990_4_3,test_mock_i2c_error)168 ZTEST_F(adltc2990_4_3, test_mock_i2c_error)
169 {
170 struct i2c_emul_api mock_bus_api;
171
172 fixture->target->bus.i2c->mock_api = &mock_bus_api;
173 mock_bus_api.transfer = mock_i2c_transfer_delegate;
174
175 reset_mock_i2c_transfer_fake();
176
177 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_STATUS;
178 bool is_busy;
179
180 zassert_equal(-EIO, adltc2990_is_busy(fixture->dev, &is_busy), "I2C Error not detected");
181 zassert_equal(1, fake_mock_i2c_transfer_fake.call_count);
182
183 reset_mock_i2c_transfer_fake();
184
185 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_TRIGGER;
186 adltc2990_trigger_measurement(fixture->dev, ADLTC2990_REPEATED_ACQUISITION);
187 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
188
189 reset_mock_i2c_transfer_fake();
190
191 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_CONTROL;
192 adltc2990_trigger_measurement(fixture->dev, ADLTC2990_SINGLE_SHOT_ACQUISITION);
193 zassert_equal(ADLTC2990_REG_CONTROL, fake_mock_i2c_transfer_fake.arg0_val);
194 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
195
196 reset_mock_i2c_transfer_fake();
197
198 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_VCC_LSB;
199 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
200 zassert_equal(ADLTC2990_REG_VCC_LSB, fake_mock_i2c_transfer_fake.arg0_val);
201
202 reset_mock_i2c_transfer_fake();
203
204 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V1_MSB;
205 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP));
206 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
207
208 reset_mock_i2c_transfer_fake();
209
210 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V3_MSB;
211 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_CURRENT));
212 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
213
214 reset_mock_i2c_transfer_fake();
215
216 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_INTERNAL_TEMP_MSB;
217 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_DIE_TEMP));
218 zassert_equal(1, fake_mock_i2c_transfer_fake.call_count);
219
220 reset_mock_i2c_transfer_fake();
221
222 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V1_MSB;
223 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP));
224 zassert_equal(1, fake_mock_i2c_transfer_fake.call_count);
225 }
226
ZTEST_F(adltc2990_4_3,test_available_channels)227 ZTEST_F(adltc2990_4_3, test_available_channels)
228 {
229 struct sensor_value value[3];
230
231 zassert_equal(0, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
232 zassert_equal(0, sensor_channel_get(fixture->dev, SENSOR_CHAN_VOLTAGE, value));
233 zassert_equal(0, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP));
234 zassert_equal(0, sensor_channel_get(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP, value));
235 zassert_equal(0, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_CURRENT));
236 zassert_equal(0, sensor_channel_get(fixture->dev, SENSOR_CHAN_CURRENT, value));
237 }
238
239 /*** TEST-SUITE: ADLTC2990 Measurement Mode 1 3***/
240
241 struct adltc2990_1_3_fixture {
242 const struct device *dev;
243 const struct emul *target;
244 };
245
adltc2990_1_3_setup(void)246 static void *adltc2990_1_3_setup(void)
247 {
248 static struct adltc2990_1_3_fixture fixture = {
249 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_1_3)),
250 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_1_3)),
251 };
252
253 zassert_not_null(fixture.dev);
254 zassert_not_null(fixture.target);
255 return &fixture;
256 }
257
adltc2990_1_3_before(void * f)258 static void adltc2990_1_3_before(void *f)
259 {
260 struct adltc2990_1_3_fixture *fixture = f;
261
262 uint8_t ctrl_reg_value;
263
264 adltc2990_emul_get_reg(fixture->target, ADLTC2990_REG_CONTROL, &ctrl_reg_value);
265
266 adltc2990_emul_reset(fixture->target);
267
268 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_CONTROL, &ctrl_reg_value);
269 }
270
271 ZTEST_SUITE(adltc2990_1_3, NULL, adltc2990_1_3_setup, adltc2990_1_3_before, NULL, NULL);
272
ZTEST_F(adltc2990_1_3,test_acq_format)273 ZTEST_F(adltc2990_1_3, test_acq_format)
274 {
275 uint8_t ctrl_register_value;
276
277 adltc2990_trigger_measurement(fixture->dev, ADLTC2990_SINGLE_SHOT_ACQUISITION);
278 adltc2990_emul_get_reg(fixture->target, ADLTC2990_REG_CONTROL, &ctrl_register_value);
279 zassert_equal(ADLTC2990_SINGLE_SHOT_ACQUISITION,
280 ADLTC2990_ACQUISITION_BIT_VAL(ctrl_register_value),
281 "Repeated Acquisition not set");
282
283 adltc2990_trigger_measurement(fixture->dev, ADLTC2990_REPEATED_ACQUISITION);
284 adltc2990_emul_get_reg(fixture->target, ADLTC2990_REG_CONTROL, &ctrl_register_value);
285 zassert_equal(ADLTC2990_REPEATED_ACQUISITION,
286 ADLTC2990_ACQUISITION_BIT_VAL(ctrl_register_value),
287 "Single Shot Acquisition not set");
288 }
289
ZTEST_F(adltc2990_1_3,test_die_temperature)290 ZTEST_F(adltc2990_1_3, test_die_temperature)
291 {
292 /* The following values are taken from datasheet and should translate to 125°c */
293 uint8_t msb = 0b00000111, lsb = 0b11010000;
294
295 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_MSB, &msb);
296 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_LSB, &lsb);
297
298 struct sensor_value temp_value[1];
299
300 CHECK_TEMPERATURE(temp_value, 0, 125.00f, SENSOR_CHAN_DIE_TEMP);
301
302 /*0b00011101 0b10000000 –40.0000*/
303 msb = 0b00011101;
304 lsb = 0b10000000;
305
306 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_MSB, &msb);
307 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_LSB, &lsb);
308
309 CHECK_TEMPERATURE(temp_value, 0, -40.00f, SENSOR_CHAN_DIE_TEMP);
310 }
311
ZTEST_F(adltc2990_1_3,test_ambient_temperature)312 ZTEST_F(adltc2990_1_3, test_ambient_temperature)
313 {
314 /* 0b00000001 0b10010001 +25.0625 */
315 uint8_t msb = 0b00000001, lsb = 0b10010001;
316 struct sensor_value temp_ambient[1];
317
318 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_MSB, &msb);
319 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_LSB, &lsb);
320
321 CHECK_TEMPERATURE(temp_ambient, 0, 25.06250f, SENSOR_CHAN_AMBIENT_TEMP);
322 }
323
ZTEST_F(adltc2990_1_3,test_current)324 ZTEST_F(adltc2990_1_3, test_current)
325 {
326 /* 0b00111100 0b01011000 +0.300 */
327 uint8_t msb_reg_value = 0b00111100, lsb_reg_value = 0b01011000;
328
329 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb_reg_value);
330 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb_reg_value);
331
332 struct sensor_value current_values[1];
333 const struct adltc2990_config *dev_config = fixture->target->dev->config;
334
335 CHECK_CURRENT(current_values, 0, 0.3f, dev_config->pins_v1_v2.pins_current_resistor);
336
337 /* 0b00100000 0b00000000 +0.159 */
338 msb_reg_value = 0b00100000, lsb_reg_value = 0b00000000;
339 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb_reg_value);
340 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb_reg_value);
341 CHECK_CURRENT(current_values, 0, 0.159f, dev_config->pins_v1_v2.pins_current_resistor);
342 }
343
ZTEST_F(adltc2990_1_3,test_V1_MINUS_V2_VCC)344 ZTEST_F(adltc2990_1_3, test_V1_MINUS_V2_VCC)
345 {
346 uint8_t msb = 0b01100000, lsb = 0b00000000;
347
348 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb);
349 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb);
350
351 msb = 0b00000010;
352 lsb = 0b10001111;
353 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_VCC_MSB, &msb);
354 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_VCC_LSB, &lsb);
355
356 zassert_ok(sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
357
358 struct sensor_value voltage_values[2];
359
360 zassert_ok(sensor_channel_get(fixture->dev, SENSOR_CHAN_VOLTAGE, voltage_values));
361
362 float test_value = voltage_values[0].val1 + (float)voltage_values[0].val2 / 1000000;
363
364 zassert_between_inclusive(test_value, -0.16f, -0.159f, "Out of Range [-0.16,-0.159]%.6f",
365 (double)test_value);
366
367 test_value = voltage_values[1].val1 + (float)voltage_values[1].val2 / 1000000;
368 zassert_between_inclusive(test_value, 2.69f, 2.7f, "Out of Range [2.69, 2.7]%.6f",
369 (double)test_value);
370 }
371
372 /*** TEST-SUITE: ADLTC2990 Measurement Mode 5 3***/
373
374 struct adltc2990_5_3_fixture {
375 const struct device *dev;
376 const struct emul *target;
377 };
378
adltc2990_5_3_setup(void)379 static void *adltc2990_5_3_setup(void)
380 {
381 static struct adltc2990_5_3_fixture fixture = {
382 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_5_3)),
383 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_5_3)),
384 };
385
386 zassert_not_null(fixture.dev);
387 zassert_not_null(fixture.target);
388 return &fixture;
389 }
390
adltc2990_5_3_before(void * f)391 static void adltc2990_5_3_before(void *f)
392 {
393 struct adltc2990_5_3_fixture *fixture = f;
394
395 adltc2990_emul_reset(fixture->target);
396 }
397
398 ZTEST_SUITE(adltc2990_5_3, NULL, adltc2990_5_3_setup, adltc2990_5_3_before, NULL, NULL);
399
ZTEST_F(adltc2990_5_3,test_mock_i2c_error)400 ZTEST_F(adltc2990_5_3, test_mock_i2c_error)
401 {
402 struct i2c_emul_api mock_bus_api;
403
404 fixture->target->bus.i2c->mock_api = &mock_bus_api;
405 mock_bus_api.transfer = mock_i2c_transfer_delegate;
406
407 reset_mock_i2c_transfer_fake();
408
409 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V3_MSB;
410 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP));
411 zassert_equal(3, fake_mock_i2c_transfer_fake.call_count);
412 }
413
ZTEST_F(adltc2990_5_3,test_ambient_temperature)414 ZTEST_F(adltc2990_5_3, test_ambient_temperature)
415 {
416 /*Kelvin 0b00010001 0b00010010 273.1250*/
417 uint8_t msb = 0b00010001, lsb = 0b00010010;
418
419 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb);
420 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb);
421
422 struct sensor_value temp_value[2];
423
424 CHECK_TEMPERATURE(temp_value, 0, 273.1250f, SENSOR_CHAN_AMBIENT_TEMP);
425
426 /*Kelvin 0b00001110 0b10010010 233.125*/
427 msb = 0b00001110;
428 lsb = 0b10010010;
429 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_MSB, &msb);
430 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_LSB, &lsb);
431 CHECK_TEMPERATURE(temp_value, 1, 233.1250f, SENSOR_CHAN_AMBIENT_TEMP);
432 }
433
ZTEST_F(adltc2990_5_3,test_die_temperature)434 ZTEST_F(adltc2990_5_3, test_die_temperature)
435 {
436 /*0b00011000 0b11100010 398.1250*/
437 uint8_t msb = 0b00011000, lsb = 0b11100010;
438
439 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_MSB, &msb);
440 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_LSB, &lsb);
441
442 struct sensor_value temp_value[1];
443
444 CHECK_TEMPERATURE(temp_value, 0, 398.1250f, SENSOR_CHAN_DIE_TEMP);
445 }
446
447 /*** TEST-SUITE: ADLTC2990 Measurement Mode 7 3***/
448
449 struct adltc2990_6_3_fixture {
450 const struct device *dev;
451 const struct emul *target;
452 };
453
adltc2990_6_3_setup(void)454 static void *adltc2990_6_3_setup(void)
455 {
456 static struct adltc2990_6_3_fixture fixture = {
457 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_6_3)),
458 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_6_3)),
459 };
460
461 zassert_not_null(fixture.dev);
462 zassert_not_null(fixture.target);
463 return &fixture;
464 }
465
adltc2990_6_3_before(void * f)466 static void adltc2990_6_3_before(void *f)
467 {
468 struct adltc2990_6_3_fixture *fixture = f;
469
470 adltc2990_emul_reset(fixture->target);
471 }
472
473 ZTEST_SUITE(adltc2990_6_3, NULL, adltc2990_6_3_setup, adltc2990_6_3_before, NULL, NULL);
474
ZTEST_F(adltc2990_6_3,test_mock_i2c_error)475 ZTEST_F(adltc2990_6_3, test_mock_i2c_error)
476 {
477 struct i2c_emul_api mock_bus_api;
478
479 fixture->target->bus.i2c->mock_api = &mock_bus_api;
480 mock_bus_api.transfer = mock_i2c_transfer_delegate;
481
482 reset_mock_i2c_transfer_fake();
483
484 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_VCC_LSB;
485 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
486 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
487 zassert_equal(2, fake_mock_i2c_transfer_fake.call_count);
488
489 reset_mock_i2c_transfer_fake();
490
491 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V1_MSB;
492 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
493 zassert_equal(3, fake_mock_i2c_transfer_fake.call_count);
494
495 reset_mock_i2c_transfer_fake();
496
497 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V3_MSB;
498 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
499 zassert_equal(5, fake_mock_i2c_transfer_fake.call_count);
500
501 reset_mock_i2c_transfer_fake();
502
503 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V1_LSB;
504 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_CURRENT));
505 zassert_equal(2, fake_mock_i2c_transfer_fake.call_count);
506 }
507
ZTEST_F(adltc2990_6_3,test_current)508 ZTEST_F(adltc2990_6_3, test_current)
509 {
510 /* 0b00111100 0b01011000 +0.300 */
511 uint8_t msb_reg_value = 0b00111100, lsb_reg_value = 0b01011000;
512
513 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb_reg_value);
514 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb_reg_value);
515
516 struct sensor_value current_values[2];
517 const struct adltc2990_config *dev_config = fixture->target->dev->config;
518
519 CHECK_CURRENT(current_values, 0, 0.3f, dev_config->pins_v1_v2.pins_current_resistor);
520
521 /* 0b00100000 0b00000000 +0.159 */
522 msb_reg_value = 0b00100000, lsb_reg_value = 0b00000000;
523 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_MSB, &msb_reg_value);
524 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_LSB, &lsb_reg_value);
525 CHECK_CURRENT(current_values, 1, 0.159f, dev_config->pins_v3_v4.pins_current_resistor);
526 }
527
528 /*** TEST-SUITE: ADLTC2990 Measurement Mode 7 3***/
529 struct adltc2990_7_3_fixture {
530 const struct device *dev;
531 const struct emul *target;
532 };
533
adltc2990_7_3_setup(void)534 static void *adltc2990_7_3_setup(void)
535 {
536 static struct adltc2990_7_3_fixture fixture = {
537 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_7_3)),
538 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_7_3)),
539 };
540
541 zassert_not_null(fixture.dev);
542 zassert_not_null(fixture.target);
543 return &fixture;
544 }
545
adltc2990_7_3_before(void * f)546 static void adltc2990_7_3_before(void *f)
547 {
548 struct adltc2990_7_3_fixture *fixture = f;
549
550 adltc2990_emul_reset(fixture->target);
551 }
552
553 ZTEST_SUITE(adltc2990_7_3, NULL, adltc2990_7_3_setup, adltc2990_7_3_before, NULL, NULL);
554
ZTEST_F(adltc2990_7_3,test_mock_i2c_error)555 ZTEST_F(adltc2990_7_3, test_mock_i2c_error)
556 {
557 struct i2c_emul_api mock_bus_api;
558
559 fixture->target->bus.i2c->mock_api = &mock_bus_api;
560 mock_bus_api.transfer = mock_i2c_transfer_delegate;
561
562 reset_mock_i2c_transfer_fake();
563
564 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_VCC_LSB;
565 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
566 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
567 zassert_equal(2, fake_mock_i2c_transfer_fake.call_count);
568
569 reset_mock_i2c_transfer_fake();
570
571 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V1_MSB;
572 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
573 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
574 zassert_equal(3, fake_mock_i2c_transfer_fake.call_count);
575
576 reset_mock_i2c_transfer_fake();
577
578 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V2_MSB;
579 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
580 zassert_equal(-EIO, fake_mock_i2c_transfer_fake.return_val);
581 zassert_equal(5, fake_mock_i2c_transfer_fake.call_count);
582
583 reset_mock_i2c_transfer_fake();
584
585 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V3_MSB;
586 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
587 zassert_equal(7, fake_mock_i2c_transfer_fake.call_count);
588
589 reset_mock_i2c_transfer_fake();
590
591 mock_i2c_transfer_fail_reg_number = ADLTC2990_REG_V4_MSB;
592 zassert_equal(-EIO, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_VOLTAGE));
593 zassert_equal(9, fake_mock_i2c_transfer_fake.call_count);
594 }
595
ZTEST_F(adltc2990_7_3,test_available_channels)596 ZTEST_F(adltc2990_7_3, test_available_channels)
597 {
598 zassert_equal(-EINVAL, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_AMBIENT_TEMP));
599 zassert_equal(-EINVAL, sensor_sample_fetch_chan(fixture->dev, SENSOR_CHAN_CURRENT));
600 }
601
ZTEST_F(adltc2990_7_3,test_is_device_busy)602 ZTEST_F(adltc2990_7_3, test_is_device_busy)
603 {
604 uint8_t is_busy = BIT(0);
605 bool result;
606
607 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_STATUS, &is_busy);
608 adltc2990_is_busy(fixture->dev, &result);
609 zassert_equal(1, result, "expected 1, got %d", result);
610
611 is_busy = 0;
612 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_STATUS, &is_busy);
613 adltc2990_is_busy(fixture->dev, &result);
614 zassert_equal(0, result, "expected 0, got %d", result);
615 }
616
ZTEST_F(adltc2990_7_3,test_die_temperature)617 ZTEST_F(adltc2990_7_3, test_die_temperature)
618 {
619 /* The following values are taken from datasheet and should translate to 398.1250K */
620
621 uint8_t msb = 0b00011000, lsb = 0b11100010;
622
623 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_MSB, &msb);
624 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_INTERNAL_TEMP_LSB, &lsb);
625
626 struct sensor_value *die_temp_value_null = (struct sensor_value *)NULL;
627
628 zassert_equal(-EINVAL,
629 sensor_channel_get(fixture->dev, SENSOR_CHAN_ALL, die_temp_value_null));
630
631 struct sensor_value die_temp_value[1];
632
633 CHECK_TEMPERATURE(die_temp_value, 0, 398.1250f, SENSOR_CHAN_DIE_TEMP);
634 }
635
ZTEST_F(adltc2990_7_3,test_V1_V2_V3_V4_VCC)636 ZTEST_F(adltc2990_7_3, test_V1_V2_V3_V4_VCC)
637 {
638 /* 0b00111111 0b11111111 >5 */
639 uint8_t msb_reg_value = 0b00111111, lsb_reg_value = 0b11111111;
640
641 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_MSB, &msb_reg_value);
642 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V1_LSB, &lsb_reg_value);
643
644 /* 0b00101100 0b11001101 3.500 */
645 msb_reg_value = 0b00101100;
646 lsb_reg_value = 0b11001101;
647 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V2_MSB, &msb_reg_value);
648 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V2_LSB, &lsb_reg_value);
649
650 /* 0b00011111 0b11111111 2.500 */
651 msb_reg_value = 0b00011111;
652 lsb_reg_value = 0b11111111;
653 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_MSB, &msb_reg_value);
654 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V3_LSB, &lsb_reg_value);
655
656 /* 0b01111100 0b00101001 –0.300 */
657 msb_reg_value = 0b01111100;
658 lsb_reg_value = 0b00101001;
659 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V4_MSB, &msb_reg_value);
660 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_V4_LSB, &lsb_reg_value);
661
662 /* VCC = 6V */
663 msb_reg_value = 0b00101100;
664 lsb_reg_value = 0b11001101;
665 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_VCC_MSB, &msb_reg_value);
666 adltc2990_emul_set_reg(fixture->target, ADLTC2990_REG_VCC_LSB, &lsb_reg_value);
667
668 struct sensor_value voltage_values[5];
669
670 const struct adltc2990_config *dev_config = fixture->dev->config;
671
672 CHECK_SINGLE_ENDED_VOLTAGE(voltage_values, 0, 5.0f,
673 dev_config->pins_v1_v2.voltage_divider_resistors.v1_r1_r2[0],
674 dev_config->pins_v1_v2.voltage_divider_resistors.v1_r1_r2[1]);
675
676 CHECK_SINGLE_ENDED_VOLTAGE(voltage_values, 1, 3.5f,
677 dev_config->pins_v1_v2.voltage_divider_resistors.v2_r1_r2[0],
678 dev_config->pins_v1_v2.voltage_divider_resistors.v2_r1_r2[1]);
679
680 CHECK_SINGLE_ENDED_VOLTAGE(voltage_values, 2, 2.5f,
681 dev_config->pins_v3_v4.voltage_divider_resistors.v3_r1_r2[0],
682 dev_config->pins_v3_v4.voltage_divider_resistors.v3_r1_r2[1]);
683
684 CHECK_SINGLE_ENDED_VOLTAGE(voltage_values, 3, -0.3f,
685 dev_config->pins_v3_v4.voltage_divider_resistors.v4_r1_r2[0],
686 dev_config->pins_v3_v4.voltage_divider_resistors.v4_r1_r2[1]);
687
688 double test_value = voltage_values[4].val1 + (double)voltage_values[4].val2 / 1000000;
689
690 zassert_between_inclusive(test_value, 6.0, 6.1, "Out of Range [6.0,6.1] %.6f",
691 (double)test_value);
692
693 zassert_equal(6, voltage_values[4].val1);
694 }
695
696 /*** TEST-SUITE: ADLTC2990 Measurement Mode Incorrect***/
697 struct adltc2990_incorrect_fixture {
698 const struct device *dev;
699 const struct emul *target;
700 };
701
adltc2990_incorrect_setup(void)702 static void *adltc2990_incorrect_setup(void)
703 {
704 static struct adltc2990_incorrect_fixture fixture = {
705 .dev = DEVICE_DT_GET(DT_NODELABEL(adltc2990_incorrect)),
706 .target = EMUL_DT_GET(DT_NODELABEL(adltc2990_incorrect)),
707 };
708
709 zassert_not_null(fixture.dev);
710 zassert_not_null(fixture.target);
711 return &fixture;
712 }
713
adltc2990_incorrect_before(void * f)714 static void adltc2990_incorrect_before(void *f)
715 {
716 struct adltc2990_incorrect_fixture *fixture = f;
717
718 adltc2990_emul_reset(fixture->target);
719 }
720
721 ZTEST_SUITE(adltc2990_incorrect, NULL, adltc2990_incorrect_setup, adltc2990_incorrect_before, NULL,
722 NULL);
723
ZTEST_F(adltc2990_incorrect,test_current_cannot_be_measured)724 ZTEST_F(adltc2990_incorrect, test_current_cannot_be_measured)
725 {
726 struct sensor_value current[1];
727
728 zassert_equal(-EINVAL, sensor_channel_get(fixture->dev, SENSOR_CHAN_CURRENT, current));
729 }
730
