1 /*
2 * Copyright (c) 2022 Nordic Semiconductor ASA
3 * SPDX-License-Identifier: Apache-2.0
4 */
5
6 #include <zephyr/drivers/regulator.h>
7 #include <zephyr/drivers/regulator/fake.h>
8 #include <zephyr/ztest.h>
9
10 DEFINE_FFF_GLOBALS;
11
12 static const struct device *const parent = DEVICE_DT_GET(DT_NODELABEL(regulator));
13 /* REG0: no Devicetree properties */
14 static const struct device *const reg0 = DEVICE_DT_GET(DT_NODELABEL(reg0));
15 /* REG1: regulator-always-on */
16 static const struct device *const reg1 = DEVICE_DT_GET(DT_NODELABEL(reg1));
17 /* REG2: regulator-boot-on */
18 static const struct device *const reg2 = DEVICE_DT_GET(DT_NODELABEL(reg2));
19 /* REG3: regulator-max/min-microvolt/microamp, regulator-allowed-modes */
20 static const struct device *const reg3 = DEVICE_DT_GET(DT_NODELABEL(reg3));
21 /* REG4: regulator-boot-off */
22 static const struct device *const reg4 = DEVICE_DT_GET(DT_NODELABEL(reg4));
23 /* REG5: regulator-boot-off and is_enabled */
24 static const struct device *const reg5 = DEVICE_DT_GET(DT_NODELABEL(reg5));
25
26 static DEVICE_API(regulator, dummy_regulator_api);
27 static DEVICE_API(regulator_parent, dummy_regulator_parent_api);
28
29 DEVICE_DEFINE(dummy_regulator, "dummy_regulator", NULL, NULL, NULL, NULL, POST_KERNEL,
30 CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &dummy_regulator_api);
31 DEVICE_DEFINE(dummy_regulator_parent, "dummy_regulator_parent", NULL, NULL, NULL, NULL, POST_KERNEL,
32 CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &dummy_regulator_parent_api);
33
34 /* Dummy regulator: empty API */
35 static const struct device *const dummy_reg = DEVICE_GET(dummy_regulator);
36 /* Dummy parent regulator: empty API */
37 static const struct device *const dummy_parent = DEVICE_GET(dummy_regulator_parent);
38
ZTEST(regulator_api,test_parent_dvs_state_set_not_implemented)39 ZTEST(regulator_api, test_parent_dvs_state_set_not_implemented)
40 {
41 int ret = regulator_parent_dvs_state_set(dummy_parent, 0);
42
43 zassert_equal(ret, -ENOSYS);
44 }
45
ZTEST(regulator_api,test_parent_dvs_state_set_ok)46 ZTEST(regulator_api, test_parent_dvs_state_set_ok)
47 {
48 RESET_FAKE(regulator_parent_fake_dvs_state_set);
49
50 regulator_parent_fake_dvs_state_set_fake.return_val = 0;
51
52 zassert_equal(regulator_parent_dvs_state_set(parent, 0U), 0);
53 zassert_equal(regulator_parent_fake_dvs_state_set_fake.arg0_val, parent);
54 zassert_equal(regulator_parent_fake_dvs_state_set_fake.arg1_val, 0U);
55 zassert_equal(regulator_parent_fake_dvs_state_set_fake.call_count, 1U);
56 }
57
ZTEST(regulator_api,test_parent_dvs_state_set_fail)58 ZTEST(regulator_api, test_parent_dvs_state_set_fail)
59 {
60 RESET_FAKE(regulator_parent_fake_dvs_state_set);
61
62 regulator_parent_fake_dvs_state_set_fake.return_val = -ENOTSUP;
63
64 zassert_equal(regulator_parent_dvs_state_set(parent, 0U), -ENOTSUP);
65 zassert_equal(regulator_parent_fake_dvs_state_set_fake.arg0_val, parent);
66 zassert_equal(regulator_parent_fake_dvs_state_set_fake.arg1_val, 0U);
67 zassert_equal(regulator_parent_fake_dvs_state_set_fake.call_count, 1U);
68 }
69
ZTEST(regulator_api,test_parent_ship_mode_not_implemented)70 ZTEST(regulator_api, test_parent_ship_mode_not_implemented)
71 {
72 int ret = regulator_parent_ship_mode(dummy_parent);
73
74 zassert_equal(ret, -ENOSYS);
75 }
76
ZTEST(regulator_api,test_parent_ship_mode_ok)77 ZTEST(regulator_api, test_parent_ship_mode_ok)
78 {
79 RESET_FAKE(regulator_parent_fake_ship_mode);
80
81 regulator_parent_fake_ship_mode_fake.return_val = 0;
82
83 zassert_equal(regulator_parent_ship_mode(parent), 0);
84 zassert_equal(regulator_parent_fake_ship_mode_fake.arg0_val, parent);
85 zassert_equal(regulator_parent_fake_ship_mode_fake.call_count, 1U);
86 }
87
ZTEST(regulator_api,test_parent_ship_mode_fail)88 ZTEST(regulator_api, test_parent_ship_mode_fail)
89 {
90 RESET_FAKE(regulator_parent_fake_ship_mode);
91
92 regulator_parent_fake_ship_mode_fake.return_val = -ENOTSUP;
93
94 zassert_equal(regulator_parent_ship_mode(parent), -ENOTSUP);
95 zassert_equal(regulator_parent_fake_ship_mode_fake.arg0_val, parent);
96 zassert_equal(regulator_parent_fake_ship_mode_fake.call_count, 1U);
97 }
98
ZTEST(regulator_api,test_common_config)99 ZTEST(regulator_api, test_common_config)
100 {
101 const struct regulator_common_config *config;
102
103 /* reg0: all defaults */
104 config = reg0->config;
105 zassert_equal(config->min_uv, INT32_MIN);
106 zassert_equal(config->max_uv, INT32_MAX);
107 zassert_equal(config->min_ua, INT32_MIN);
108 zassert_equal(config->max_ua, INT32_MAX);
109 zassert_equal(config->allowed_modes_cnt, 0U);
110 zassert_equal(config->initial_mode, REGULATOR_INITIAL_MODE_UNKNOWN);
111 zassert_equal(REGULATOR_ACTIVE_DISCHARGE_GET_BITS(config->flags),
112 REGULATOR_ACTIVE_DISCHARGE_DEFAULT);
113
114 /* reg1: regulator-always-on */
115 config = reg1->config;
116 zassert_equal(config->flags & REGULATOR_ALWAYS_ON, REGULATOR_ALWAYS_ON);
117
118 /* reg2: regulator-boot-on */
119 config = reg2->config;
120 zassert_equal(config->flags & REGULATOR_BOOT_ON, REGULATOR_BOOT_ON);
121
122 /* reg3: regulator-min/max-microvolt/microamp */
123 config = reg3->config;
124 zassert_equal(config->min_uv, 100);
125 zassert_equal(config->max_uv, 200);
126 zassert_equal(config->min_ua, 100);
127 zassert_equal(config->max_ua, 200);
128 zassert_equal(config->allowed_modes[0], 1U);
129 zassert_equal(config->allowed_modes[1], 10U);
130 zassert_equal(config->allowed_modes_cnt, 2U);
131 zassert_equal(REGULATOR_ACTIVE_DISCHARGE_GET_BITS(config->flags), 1U);
132
133 /* reg4: regulator-boot-off */
134 config = reg4->config;
135 zassert_equal(config->flags & REGULATOR_BOOT_OFF, REGULATOR_BOOT_OFF);
136 }
137
ZTEST(regulator_api,test_common_is_init_enabled)138 ZTEST(regulator_api, test_common_is_init_enabled)
139 {
140 zassert_false(regulator_common_is_init_enabled(reg0));
141 zassert_true(regulator_common_is_init_enabled(reg1));
142 zassert_true(regulator_common_is_init_enabled(reg2));
143 zassert_false(regulator_common_is_init_enabled(reg3));
144 zassert_false(regulator_common_is_init_enabled(reg4));
145 zassert_false(regulator_common_is_init_enabled(reg5));
146 }
147
ZTEST(regulator_api,test_enable_disable)148 ZTEST(regulator_api, test_enable_disable)
149 {
150 RESET_FAKE(regulator_fake_enable);
151 RESET_FAKE(regulator_fake_disable);
152
153 /* REG1 already enabled, not enabled again */
154 zassert_equal(regulator_enable(reg1), 0);
155 zassert_equal(regulator_fake_enable_fake.call_count, 0U);
156
157 /* REG1: can't be disabled */
158 zassert_equal(regulator_disable(reg1), 0);
159 zassert_equal(regulator_fake_disable_fake.call_count, 0U);
160
161 /* REG2: can be disabled */
162 zassert_equal(regulator_disable(reg2), 0);
163 zassert_equal(regulator_fake_disable_fake.arg0_val, reg2);
164 zassert_equal(regulator_fake_disable_fake.call_count, 1U);
165
166 /* REG2: enable again */
167 zassert_equal(regulator_enable(reg2), 0);
168 zassert_equal(regulator_fake_enable_fake.arg0_val, reg2);
169 zassert_equal(regulator_fake_enable_fake.call_count, 1U);
170
171 /* REG0: enable */
172 zassert_equal(regulator_enable(reg0), 0);
173 zassert_equal(regulator_fake_enable_fake.arg0_val, reg0);
174 zassert_equal(regulator_fake_enable_fake.call_count, 2U);
175
176 /* REG0: disable */
177 zassert_equal(regulator_disable(reg0), 0);
178 zassert_equal(regulator_fake_disable_fake.arg0_val, reg0);
179 zassert_equal(regulator_fake_disable_fake.call_count, 2U);
180
181 /* REG5: disabled at boot, can be enabled again */
182 zassert_equal(regulator_enable(reg5), 0);
183 zassert_equal(regulator_fake_enable_fake.call_count, 3U);
184
185 /* REG5: disable */
186 zassert_equal(regulator_disable(reg5), 0);
187 zassert_equal(regulator_fake_disable_fake.call_count, 3U);
188 }
189
ZTEST(regulator_api,test_count_voltages_not_implemented)190 ZTEST(regulator_api, test_count_voltages_not_implemented)
191 {
192 unsigned int count = regulator_count_voltages(dummy_reg);
193
194 zassert_equal(count, 0U);
195 }
196
ZTEST(regulator_api,test_count_voltages)197 ZTEST(regulator_api, test_count_voltages)
198 {
199 RESET_FAKE(regulator_fake_count_voltages);
200
201 regulator_fake_count_voltages_fake.return_val = 10U;
202
203 zassert_equal(regulator_count_voltages(reg0), 10U);
204 zassert_equal(regulator_fake_count_voltages_fake.arg0_val, reg0);
205 zassert_equal(regulator_fake_count_voltages_fake.call_count, 1U);
206 }
207
ZTEST(regulator_api,test_list_voltage_not_implemented)208 ZTEST(regulator_api, test_list_voltage_not_implemented)
209 {
210 int ret = regulator_list_voltage(dummy_reg, 0, NULL);
211
212 zassert_equal(ret, -EINVAL);
213 }
214
list_voltage_ok(const struct device * dev,unsigned int idx,int32_t * volt_uv)215 static int list_voltage_ok(const struct device *dev, unsigned int idx, int32_t *volt_uv)
216 {
217 ARG_UNUSED(dev);
218 ARG_UNUSED(idx);
219
220 *volt_uv = 100;
221
222 return 0;
223 }
224
ZTEST(regulator_api,test_list_voltage_valid)225 ZTEST(regulator_api, test_list_voltage_valid)
226 {
227 int32_t volt_uv;
228
229 RESET_FAKE(regulator_fake_list_voltage);
230
231 regulator_fake_list_voltage_fake.custom_fake = list_voltage_ok;
232
233 zassert_equal(regulator_list_voltage(reg0, 0, &volt_uv), 0);
234 zassert_equal(volt_uv, 100);
235 zassert_equal(regulator_fake_list_voltage_fake.call_count, 1U);
236 zassert_equal(regulator_fake_list_voltage_fake.arg0_val, reg0);
237 zassert_equal(regulator_fake_list_voltage_fake.arg1_val, 0);
238 zassert_equal(regulator_fake_list_voltage_fake.arg2_val, &volt_uv);
239 }
240
list_voltage_invalid(const struct device * dev,unsigned int idx,int32_t * volt_uv)241 static int list_voltage_invalid(const struct device *dev, unsigned int idx, int32_t *volt_uv)
242 {
243 ARG_UNUSED(dev);
244 ARG_UNUSED(idx);
245 ARG_UNUSED(volt_uv);
246
247 return -EINVAL;
248 }
249
ZTEST(regulator_api,test_list_voltage_invalid)250 ZTEST(regulator_api, test_list_voltage_invalid)
251 {
252 RESET_FAKE(regulator_fake_list_voltage);
253
254 regulator_fake_list_voltage_fake.custom_fake = list_voltage_invalid;
255
256 zassert_equal(regulator_list_voltage(reg0, 0, NULL), -EINVAL);
257 zassert_equal(regulator_fake_list_voltage_fake.call_count, 1U);
258 zassert_equal(regulator_fake_list_voltage_fake.arg0_val, reg0);
259 zassert_equal(regulator_fake_list_voltage_fake.arg1_val, 0);
260 zassert_equal(regulator_fake_list_voltage_fake.arg2_val, NULL);
261 }
262
list_voltage(const struct device * dev,unsigned int idx,int32_t * volt_uv)263 static int list_voltage(const struct device *dev, unsigned int idx, int32_t *volt_uv)
264 {
265 ARG_UNUSED(dev);
266
267 switch (idx) {
268 case 0U:
269 *volt_uv = 100;
270 break;
271 case 1U:
272 *volt_uv = 200;
273 break;
274 case 2U:
275 *volt_uv = 300;
276 break;
277 case 3U:
278 *volt_uv = 400;
279 break;
280 default:
281 return -EINVAL;
282 }
283
284 return 0;
285 }
286
ZTEST(regulator_api,test_is_supported_voltage)287 ZTEST(regulator_api, test_is_supported_voltage)
288 {
289 RESET_FAKE(regulator_fake_count_voltages);
290 RESET_FAKE(regulator_fake_list_voltage);
291
292 regulator_fake_count_voltages_fake.return_val = 4U;
293 regulator_fake_list_voltage_fake.custom_fake = list_voltage;
294
295 zassert_false(regulator_is_supported_voltage(reg0, 0, 50));
296 zassert_true(regulator_is_supported_voltage(reg0, 50, 100));
297 zassert_true(regulator_is_supported_voltage(reg0, 100, 200));
298 zassert_true(regulator_is_supported_voltage(reg0, 150, 200));
299 zassert_true(regulator_is_supported_voltage(reg0, 200, 300));
300 zassert_true(regulator_is_supported_voltage(reg0, 300, 400));
301 zassert_true(regulator_is_supported_voltage(reg0, 400, 500));
302 zassert_false(regulator_is_supported_voltage(reg0, 500, 600));
303
304 zassert_not_equal(regulator_fake_count_voltages_fake.call_count, 0U);
305 zassert_not_equal(regulator_fake_list_voltage_fake.call_count, 0U);
306 }
307
ZTEST(regulator_api,test_is_supported_voltage_dt_limit)308 ZTEST(regulator_api, test_is_supported_voltage_dt_limit)
309 {
310 RESET_FAKE(regulator_fake_count_voltages);
311 RESET_FAKE(regulator_fake_list_voltage);
312
313 regulator_fake_count_voltages_fake.return_val = 4U;
314 regulator_fake_list_voltage_fake.custom_fake = list_voltage;
315
316 zassert_false(regulator_is_supported_voltage(reg3, 0, 50));
317 zassert_true(regulator_is_supported_voltage(reg3, 50, 100));
318 zassert_true(regulator_is_supported_voltage(reg3, 100, 200));
319 zassert_true(regulator_is_supported_voltage(reg3, 150, 200));
320 zassert_true(regulator_is_supported_voltage(reg3, 200, 300));
321 zassert_false(regulator_is_supported_voltage(reg3, 300, 400));
322 zassert_false(regulator_is_supported_voltage(reg3, 400, 500));
323 zassert_false(regulator_is_supported_voltage(reg3, 500, 600));
324
325 zassert_not_equal(regulator_fake_count_voltages_fake.call_count, 0U);
326 zassert_not_equal(regulator_fake_list_voltage_fake.call_count, 0U);
327 }
328
ZTEST(regulator_api,test_set_voltage_not_implemented)329 ZTEST(regulator_api, test_set_voltage_not_implemented)
330 {
331 int ret = regulator_set_voltage(dummy_reg, 0, 0);
332
333 zassert_equal(ret, -ENOSYS);
334 }
335
ZTEST(regulator_api,test_set_voltage_ok)336 ZTEST(regulator_api, test_set_voltage_ok)
337 {
338 RESET_FAKE(regulator_fake_set_voltage);
339
340 regulator_fake_set_voltage_fake.return_val = 0;
341
342 zassert_equal(regulator_set_voltage(reg0, 0, 0), 0);
343 zassert_equal(regulator_fake_set_voltage_fake.arg0_val, reg0);
344 zassert_equal(regulator_fake_set_voltage_fake.arg1_val, 0);
345 zassert_equal(regulator_fake_set_voltage_fake.arg2_val, 0);
346 zassert_equal(regulator_fake_set_voltage_fake.call_count, 1U);
347 }
348
ZTEST(regulator_api,test_set_voltage_fail)349 ZTEST(regulator_api, test_set_voltage_fail)
350 {
351 RESET_FAKE(regulator_fake_set_voltage);
352
353 regulator_fake_set_voltage_fake.return_val = -EINVAL;
354
355 zassert_equal(regulator_set_voltage(reg0, 0, 0), -EINVAL);
356 zassert_equal(regulator_fake_set_voltage_fake.arg0_val, reg0);
357 zassert_equal(regulator_fake_set_voltage_fake.arg1_val, 0);
358 zassert_equal(regulator_fake_set_voltage_fake.arg2_val, 0);
359 zassert_equal(regulator_fake_set_voltage_fake.call_count, 1U);
360 }
361
ZTEST(regulator_api,test_set_voltage_dt_limit)362 ZTEST(regulator_api, test_set_voltage_dt_limit)
363 {
364 RESET_FAKE(regulator_fake_set_voltage);
365
366 regulator_fake_set_voltage_fake.return_val = 0;
367
368 zassert_equal(regulator_set_voltage(reg3, 300, 400), -EINVAL);
369 zassert_equal(regulator_fake_set_voltage_fake.call_count, 0U);
370 }
371
ZTEST(regulator_api,test_get_voltage_not_implemented)372 ZTEST(regulator_api, test_get_voltage_not_implemented)
373 {
374 int ret = regulator_get_voltage(dummy_reg, NULL);
375
376 zassert_equal(ret, -ENOSYS);
377 }
378
get_voltage_ok(const struct device * dev,int32_t * volt_uv)379 static int get_voltage_ok(const struct device *dev, int32_t *volt_uv)
380 {
381 ARG_UNUSED(dev);
382
383 *volt_uv = 100;
384
385 return 0;
386 }
387
ZTEST(regulator_api,test_get_voltage_ok)388 ZTEST(regulator_api, test_get_voltage_ok)
389 {
390 int32_t volt_uv;
391
392 RESET_FAKE(regulator_fake_get_voltage);
393
394 regulator_fake_get_voltage_fake.custom_fake = get_voltage_ok;
395
396 zassert_equal(regulator_get_voltage(reg0, &volt_uv), 0);
397 zassert_equal(volt_uv, 100);
398 zassert_equal(regulator_fake_get_voltage_fake.call_count, 1U);
399 zassert_equal(regulator_fake_get_voltage_fake.arg0_val, reg0);
400 zassert_equal(regulator_fake_get_voltage_fake.arg1_val, &volt_uv);
401 }
402
get_voltage_fail(const struct device * dev,int32_t * volt_uv)403 static int get_voltage_fail(const struct device *dev, int32_t *volt_uv)
404 {
405 ARG_UNUSED(dev);
406 ARG_UNUSED(volt_uv);
407
408 return -EIO;
409 }
410
ZTEST(regulator_api,test_get_voltage_error)411 ZTEST(regulator_api, test_get_voltage_error)
412 {
413 RESET_FAKE(regulator_fake_get_voltage);
414
415 regulator_fake_get_voltage_fake.custom_fake = get_voltage_fail;
416
417 zassert_equal(regulator_get_voltage(reg0, NULL), -EIO);
418 zassert_equal(regulator_fake_get_voltage_fake.call_count, 1U);
419 zassert_equal(regulator_fake_get_voltage_fake.arg0_val, reg0);
420 zassert_equal(regulator_fake_get_voltage_fake.arg1_val, NULL);
421 }
422
ZTEST(regulator_api,test_count_current_limits_not_implemented)423 ZTEST(regulator_api, test_count_current_limits_not_implemented)
424 {
425 unsigned int ret = regulator_count_current_limits(dummy_reg);
426
427 zassert_equal(ret, 0);
428 }
429
ZTEST(regulator_api,test_count_current_limits_ok)430 ZTEST(regulator_api, test_count_current_limits_ok)
431 {
432 RESET_FAKE(regulator_fake_count_current_limits);
433
434 regulator_fake_count_current_limits_fake.return_val = 10;
435
436 zassert_equal(regulator_count_current_limits(reg0), 10U);
437 zassert_equal(regulator_fake_count_current_limits_fake.arg0_val, reg0);
438 zassert_equal(regulator_fake_count_current_limits_fake.call_count, 1U);
439 }
440
ZTEST(regulator_api,test_count_current_limits_fail)441 ZTEST(regulator_api, test_count_current_limits_fail)
442 {
443 RESET_FAKE(regulator_fake_count_current_limits);
444
445 regulator_fake_count_current_limits_fake.return_val = -EINVAL;
446
447 zassert_equal(regulator_count_current_limits(reg0), -EINVAL);
448 zassert_equal(regulator_fake_count_current_limits_fake.arg0_val, reg0);
449 zassert_equal(regulator_fake_count_current_limits_fake.call_count, 1U);
450 }
451
ZTEST(regulator_api,test_list_current_limit_not_implemented)452 ZTEST(regulator_api, test_list_current_limit_not_implemented)
453 {
454 zassert_equal(regulator_list_current_limit(dummy_reg, 0, NULL), -EINVAL);
455 }
456
list_current_limit_ok(const struct device * dev,unsigned int idx,int32_t * curr_ua)457 static int list_current_limit_ok(const struct device *dev, unsigned int idx, int32_t *curr_ua)
458 {
459 ARG_UNUSED(dev);
460 ARG_UNUSED(idx);
461
462 *curr_ua = 100;
463
464 return 0;
465 }
466
ZTEST(regulator_api,test_list_current_limit_ok)467 ZTEST(regulator_api, test_list_current_limit_ok)
468 {
469 RESET_FAKE(regulator_fake_list_current_limit);
470
471 int32_t curr_ua;
472
473 regulator_fake_list_current_limit_fake.custom_fake = list_current_limit_ok;
474
475 zassert_equal(regulator_list_current_limit(reg0, 1, &curr_ua), 0);
476 zassert_equal(curr_ua, 100);
477 zassert_equal(regulator_fake_list_current_limit_fake.arg0_val, reg0);
478 zassert_equal(regulator_fake_list_current_limit_fake.arg1_val, 1U);
479 zassert_equal(regulator_fake_list_current_limit_fake.arg2_val, &curr_ua);
480 zassert_equal(regulator_fake_list_current_limit_fake.call_count, 1U);
481 }
482
ZTEST(regulator_api,test_list_current_limit_fail)483 ZTEST(regulator_api, test_list_current_limit_fail)
484 {
485 RESET_FAKE(regulator_fake_list_current_limit);
486
487 int32_t curr_ua;
488
489 regulator_fake_list_current_limit_fake.return_val = -EIO;
490
491 zassert_equal(regulator_list_current_limit(reg0, 1, &curr_ua), -EIO);
492 zassert_equal(regulator_fake_list_current_limit_fake.arg0_val, reg0);
493 zassert_equal(regulator_fake_list_current_limit_fake.arg1_val, 1U);
494 zassert_equal(regulator_fake_list_current_limit_fake.arg2_val, &curr_ua);
495 zassert_equal(regulator_fake_list_current_limit_fake.call_count, 1U);
496 }
497
ZTEST(regulator_api,test_set_current_limit_not_implemented)498 ZTEST(regulator_api, test_set_current_limit_not_implemented)
499 {
500 int ret = regulator_set_current_limit(dummy_reg, 0, 0);
501
502 zassert_equal(ret, -ENOSYS);
503 }
504
ZTEST(regulator_api,test_set_current_limit_ok)505 ZTEST(regulator_api, test_set_current_limit_ok)
506 {
507 RESET_FAKE(regulator_fake_set_current_limit);
508
509 regulator_fake_set_current_limit_fake.return_val = 0;
510
511 zassert_equal(regulator_set_current_limit(reg0, 0, 0), 0);
512 zassert_equal(regulator_fake_set_current_limit_fake.arg0_val, reg0);
513 zassert_equal(regulator_fake_set_current_limit_fake.arg1_val, 0);
514 zassert_equal(regulator_fake_set_current_limit_fake.arg2_val, 0);
515 zassert_equal(regulator_fake_set_current_limit_fake.call_count, 1U);
516 }
517
ZTEST(regulator_api,test_set_current_limit_fail)518 ZTEST(regulator_api, test_set_current_limit_fail)
519 {
520 RESET_FAKE(regulator_fake_set_current_limit);
521
522 regulator_fake_set_current_limit_fake.return_val = -EINVAL;
523
524 zassert_equal(regulator_set_current_limit(reg0, 0, 0), -EINVAL);
525 zassert_equal(regulator_fake_set_current_limit_fake.arg0_val, reg0);
526 zassert_equal(regulator_fake_set_current_limit_fake.arg1_val, 0);
527 zassert_equal(regulator_fake_set_current_limit_fake.arg2_val, 0);
528 zassert_equal(regulator_fake_set_current_limit_fake.call_count, 1U);
529 }
530
ZTEST(regulator_api,test_set_current_limit_dt_limit)531 ZTEST(regulator_api, test_set_current_limit_dt_limit)
532 {
533 RESET_FAKE(regulator_fake_set_current_limit);
534
535 regulator_fake_set_current_limit_fake.return_val = 0;
536
537 zassert_equal(regulator_set_current_limit(reg3, 300, 400), -EINVAL);
538 zassert_equal(regulator_fake_set_current_limit_fake.call_count, 0U);
539 }
540
ZTEST(regulator_api,test_get_current_limit_not_implemented)541 ZTEST(regulator_api, test_get_current_limit_not_implemented)
542 {
543 int ret = regulator_get_current_limit(dummy_reg, NULL);
544
545 zassert_equal(ret, -ENOSYS);
546 }
547
get_current_limit_ok(const struct device * dev,int32_t * curr_ua)548 static int get_current_limit_ok(const struct device *dev, int32_t *curr_ua)
549 {
550 ARG_UNUSED(dev);
551
552 *curr_ua = 100;
553
554 return 0;
555 }
556
ZTEST(regulator_api,test_get_current_limit_ok)557 ZTEST(regulator_api, test_get_current_limit_ok)
558 {
559 int32_t curr_ua;
560
561 RESET_FAKE(regulator_fake_get_current_limit);
562
563 regulator_fake_get_current_limit_fake.custom_fake = get_current_limit_ok;
564
565 zassert_equal(regulator_get_current_limit(reg0, &curr_ua), 0);
566 zassert_equal(curr_ua, 100);
567 zassert_equal(regulator_fake_get_current_limit_fake.call_count, 1U);
568 zassert_equal(regulator_fake_get_current_limit_fake.arg0_val, reg0);
569 zassert_equal(regulator_fake_get_current_limit_fake.arg1_val, &curr_ua);
570 }
571
get_current_limit_fail(const struct device * dev,int32_t * curr_ua)572 static int get_current_limit_fail(const struct device *dev, int32_t *curr_ua)
573 {
574 ARG_UNUSED(dev);
575 ARG_UNUSED(curr_ua);
576
577 return -EIO;
578 }
579
ZTEST(regulator_api,test_get_current_limit_error)580 ZTEST(regulator_api, test_get_current_limit_error)
581 {
582 RESET_FAKE(regulator_fake_get_current_limit);
583
584 regulator_fake_get_current_limit_fake.custom_fake = get_current_limit_fail;
585
586 zassert_equal(regulator_get_current_limit(reg0, NULL), -EIO);
587 zassert_equal(regulator_fake_get_current_limit_fake.call_count, 1U);
588 zassert_equal(regulator_fake_get_current_limit_fake.arg0_val, reg0);
589 zassert_equal(regulator_fake_get_current_limit_fake.arg1_val, NULL);
590 }
591
ZTEST(regulator_api,test_set_mode_not_implemented)592 ZTEST(regulator_api, test_set_mode_not_implemented)
593 {
594 int ret = regulator_set_mode(dummy_reg, 0);
595
596 zassert_equal(ret, -ENOSYS);
597 }
598
ZTEST(regulator_api,test_set_mode_ok)599 ZTEST(regulator_api, test_set_mode_ok)
600 {
601 RESET_FAKE(regulator_fake_set_mode);
602
603 regulator_fake_set_mode_fake.return_val = 0;
604
605 zassert_equal(regulator_set_mode(reg0, 0), 0);
606 zassert_equal(regulator_set_mode(reg0, 1), 0);
607 zassert_equal(regulator_set_mode(reg0, 10), 0);
608 zassert_equal(regulator_fake_set_mode_fake.call_count, 3U);
609 }
610
ZTEST(regulator_api,test_set_mode_fail)611 ZTEST(regulator_api, test_set_mode_fail)
612 {
613 RESET_FAKE(regulator_fake_set_mode);
614
615 regulator_fake_set_mode_fake.return_val = -ENOTSUP;
616
617 zassert_equal(regulator_set_mode(reg0, 0), -ENOTSUP);
618 zassert_equal(regulator_fake_set_mode_fake.arg0_val, reg0);
619 zassert_equal(regulator_fake_set_mode_fake.arg1_val, 0);
620 zassert_equal(regulator_fake_set_mode_fake.call_count, 1U);
621 }
622
ZTEST(regulator_api,test_set_mode_dt_limit)623 ZTEST(regulator_api, test_set_mode_dt_limit)
624 {
625 RESET_FAKE(regulator_fake_set_mode);
626
627 regulator_fake_set_mode_fake.return_val = 0;
628
629 zassert_equal(regulator_set_mode(reg3, 0), -ENOTSUP);
630 zassert_equal(regulator_set_mode(reg3, 1), 0);
631 zassert_equal(regulator_set_mode(reg3, 10), 0);
632 zassert_equal(regulator_fake_set_mode_fake.call_count, 2U);
633 }
634
ZTEST(regulator_api,test_get_mode_not_implemented)635 ZTEST(regulator_api, test_get_mode_not_implemented)
636 {
637 int ret = regulator_get_mode(dummy_reg, NULL);
638
639 zassert_equal(ret, -ENOSYS);
640 }
641
ZTEST(regulator_api,test_set_active_discharge_not_implemented)642 ZTEST(regulator_api, test_set_active_discharge_not_implemented)
643 {
644 int ret = regulator_set_active_discharge(dummy_reg, false);
645
646 zassert_equal(ret, -ENOSYS);
647 }
648
get_active_discharge_ok(const struct device * dev,bool * active_discharge)649 static int get_active_discharge_ok(const struct device *dev, bool *active_discharge)
650 {
651 ARG_UNUSED(dev);
652
653 *active_discharge = true;
654
655 return 0;
656 }
657
ZTEST(regulator_api,test_get_active_discharge_ok)658 ZTEST(regulator_api, test_get_active_discharge_ok)
659 {
660 bool active_discharge;
661
662 RESET_FAKE(regulator_fake_get_active_discharge);
663
664 regulator_fake_get_active_discharge_fake.custom_fake = get_active_discharge_ok;
665
666 zassert_equal(regulator_get_active_discharge(reg0, &active_discharge), false);
667 zassert_equal(active_discharge, true);
668 zassert_equal(regulator_fake_get_active_discharge_fake.call_count, 1U);
669 zassert_equal(regulator_fake_get_active_discharge_fake.arg0_val, reg0);
670 zassert_equal(regulator_fake_get_active_discharge_fake.arg1_val, &active_discharge);
671 }
672
ZTEST(regulator_api,test_get_active_discharge_not_implemented)673 ZTEST(regulator_api, test_get_active_discharge_not_implemented)
674 {
675 int ret = regulator_get_active_discharge(dummy_reg, NULL);
676
677 zassert_equal(ret, -ENOSYS);
678 }
679
get_mode_ok(const struct device * dev,regulator_mode_t * mode)680 static int get_mode_ok(const struct device *dev, regulator_mode_t *mode)
681 {
682 ARG_UNUSED(dev);
683
684 *mode = 10U;
685
686 return 0;
687 }
688
ZTEST(regulator_api,test_get_mode_ok)689 ZTEST(regulator_api, test_get_mode_ok)
690 {
691 regulator_mode_t mode;
692
693 RESET_FAKE(regulator_fake_get_mode);
694
695 regulator_fake_get_mode_fake.custom_fake = get_mode_ok;
696
697 zassert_equal(regulator_get_mode(reg0, &mode), 0U);
698 zassert_equal(mode, 10U);
699 zassert_equal(regulator_fake_get_mode_fake.call_count, 1U);
700 zassert_equal(regulator_fake_get_mode_fake.arg0_val, reg0);
701 zassert_equal(regulator_fake_get_mode_fake.arg1_val, &mode);
702 }
703
get_mode_fail(const struct device * dev,regulator_mode_t * mode)704 static int get_mode_fail(const struct device *dev, regulator_mode_t *mode)
705 {
706 ARG_UNUSED(dev);
707 ARG_UNUSED(mode);
708
709 return -EIO;
710 }
711
ZTEST(regulator_api,test_get_mode_error)712 ZTEST(regulator_api, test_get_mode_error)
713 {
714 RESET_FAKE(regulator_fake_get_mode);
715
716 regulator_fake_get_mode_fake.custom_fake = get_mode_fail;
717
718 zassert_equal(regulator_get_mode(reg0, NULL), -EIO);
719 zassert_equal(regulator_fake_get_mode_fake.call_count, 1U);
720 zassert_equal(regulator_fake_get_mode_fake.arg0_val, reg0);
721 zassert_equal(regulator_fake_get_mode_fake.arg1_val, NULL);
722 }
723
ZTEST(regulator_api,test_get_error_flags_not_implemented)724 ZTEST(regulator_api, test_get_error_flags_not_implemented)
725 {
726 int ret = regulator_get_error_flags(dummy_reg, NULL);
727
728 zassert_equal(ret, -ENOSYS);
729 }
730
get_error_flags_ok(const struct device * dev,regulator_error_flags_t * flags)731 static int get_error_flags_ok(const struct device *dev, regulator_error_flags_t *flags)
732 {
733 ARG_UNUSED(dev);
734
735 *flags = REGULATOR_ERROR_OVER_CURRENT;
736
737 return 0;
738 }
739
ZTEST(regulator_api,test_get_error_flags_ok)740 ZTEST(regulator_api, test_get_error_flags_ok)
741 {
742 regulator_error_flags_t flags;
743
744 RESET_FAKE(regulator_fake_get_error_flags);
745
746 regulator_fake_get_error_flags_fake.custom_fake = get_error_flags_ok;
747
748 zassert_equal(regulator_get_error_flags(reg0, &flags), 0);
749 zassert_equal(flags, REGULATOR_ERROR_OVER_CURRENT);
750 zassert_equal(regulator_fake_get_error_flags_fake.call_count, 1U);
751 zassert_equal(regulator_fake_get_error_flags_fake.arg0_val, reg0);
752 zassert_equal(regulator_fake_get_error_flags_fake.arg1_val, &flags);
753 }
754
get_error_flags_fail(const struct device * dev,regulator_error_flags_t * flags)755 static int get_error_flags_fail(const struct device *dev, regulator_error_flags_t *flags)
756 {
757 ARG_UNUSED(dev);
758 ARG_UNUSED(flags);
759
760 return -EIO;
761 }
762
ZTEST(regulator_api,test_get_max_voltage)763 ZTEST(regulator_api, test_get_max_voltage)
764 {
765 int32_t max_uv = 0;
766 int err = 0;
767
768 err = regulator_common_get_max_voltage(reg0, &max_uv);
769 zassert_equal(err, -ENOENT);
770
771 err = regulator_common_get_max_voltage(reg3, &max_uv);
772 zassert_equal(err, 0);
773 zassert_equal(max_uv, 200);
774 }
775
ZTEST(regulator_api,test_get_min_voltage)776 ZTEST(regulator_api, test_get_min_voltage)
777 {
778 int32_t min_uv = 0;
779 int err = 0;
780
781 err = regulator_common_get_min_voltage(reg0, &min_uv);
782 zassert_equal(err, -ENOENT);
783
784 err = regulator_common_get_min_voltage(reg3, &min_uv);
785 zassert_equal(err, 0);
786 zassert_equal(min_uv, 100);
787 }
788
ZTEST(regulator_api,test_get_error_flags_error)789 ZTEST(regulator_api, test_get_error_flags_error)
790 {
791 RESET_FAKE(regulator_fake_get_error_flags);
792
793 regulator_fake_get_error_flags_fake.custom_fake = get_error_flags_fail;
794
795 zassert_equal(regulator_get_error_flags(reg0, NULL), -EIO);
796 zassert_equal(regulator_fake_get_error_flags_fake.call_count, 1U);
797 zassert_equal(regulator_fake_get_error_flags_fake.arg0_val, reg0);
798 zassert_equal(regulator_fake_get_error_flags_fake.arg1_val, NULL);
799 }
800
setup(void)801 void *setup(void)
802 {
803 zassert_true(device_is_ready(parent));
804 zassert_true(device_is_ready(reg0));
805 zassert_true(device_is_ready(reg1));
806 zassert_true(device_is_ready(reg2));
807 zassert_true(device_is_ready(reg3));
808 zassert_true(device_is_ready(reg4));
809 zassert_true(device_is_ready(reg5));
810
811 /* REG1, REG2 initialized at init time (always-on/boot-on) */
812 zassert_equal(regulator_fake_enable_fake.call_count, 2U);
813 zassert_true(regulator_is_enabled(reg1));
814 zassert_true(regulator_is_enabled(reg2));
815
816 /* REG3 mode set at init time (initial-mode) */
817 zassert_equal(regulator_fake_set_mode_fake.call_count, 1U);
818
819 /* REG4 already disabled at init time (boot-off) */
820 zassert_false(regulator_is_enabled(reg4));
821
822 /* REG5 explicitly disabled at init time (boot-off) */
823 zassert_equal(regulator_fake_disable_fake.call_count, 1U);
824 zassert_false(regulator_is_enabled(reg5));
825
826 return NULL;
827 }
828
829 ZTEST_SUITE(regulator_api, NULL, setup, NULL, NULL, NULL);
830
