1 /*
2 * QTests for Nuvoton NPCM7xx ADCModules.
3 *
4 * Copyright 2020 Google LLC
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 */
16
17 #include "qemu/osdep.h"
18 #include "qemu/bitops.h"
19 #include "qemu/timer.h"
20 #include "libqtest.h"
21 #include "qapi/qmp/qdict.h"
22
23 #define REF_HZ (25000000)
24
25 #define CON_OFFSET 0x0
26 #define DATA_OFFSET 0x4
27
28 #define NUM_INPUTS 8
29 #define DEFAULT_IREF 2000000
30 #define CONV_CYCLES 20
31 #define RESET_CYCLES 10
32 #define R0_INPUT 500000
33 #define R1_INPUT 1500000
34 #define MAX_RESULT 1023
35
36 #define DEFAULT_CLKDIV 5
37
38 #define FUSE_ARRAY_BA 0xf018a000
39 #define FCTL_OFFSET 0x14
40 #define FST_OFFSET 0x0
41 #define FADDR_OFFSET 0x4
42 #define FDATA_OFFSET 0x8
43 #define ADC_CALIB_ADDR 24
44 #define FUSE_READ 0x2
45
46 /* Register field definitions. */
47 #define CON_MUX(rv) ((rv) << 24)
48 #define CON_INT_EN BIT(21)
49 #define CON_REFSEL BIT(19)
50 #define CON_INT BIT(18)
51 #define CON_EN BIT(17)
52 #define CON_RST BIT(16)
53 #define CON_CONV BIT(13)
54 #define CON_DIV(rv) extract32(rv, 1, 8)
55
56 #define FST_RDST BIT(1)
57 #define FDATA_MASK 0xff
58
59 #define MAX_ERROR 10000
60 #define MIN_CALIB_INPUT 100000
61 #define MAX_CALIB_INPUT 1800000
62
63 static const uint32_t input_list[] = {
64 100000,
65 500000,
66 1000000,
67 1500000,
68 1800000,
69 2000000,
70 };
71
72 static const uint32_t vref_list[] = {
73 2000000,
74 2200000,
75 2500000,
76 };
77
78 static const uint32_t iref_list[] = {
79 1800000,
80 1900000,
81 2000000,
82 2100000,
83 2200000,
84 };
85
86 static const uint32_t div_list[] = {0, 1, 3, 7, 15};
87
88 typedef struct ADC {
89 int irq;
90 uint64_t base_addr;
91 } ADC;
92
93 ADC adc_defs = {
94 .irq = 0,
95 .base_addr = 0xf000c000
96 };
97
adc_read_con(QTestState * qts,const ADC * adc)98 static uint32_t adc_read_con(QTestState *qts, const ADC *adc)
99 {
100 return qtest_readl(qts, adc->base_addr + CON_OFFSET);
101 }
102
adc_write_con(QTestState * qts,const ADC * adc,uint32_t value)103 static void adc_write_con(QTestState *qts, const ADC *adc, uint32_t value)
104 {
105 qtest_writel(qts, adc->base_addr + CON_OFFSET, value);
106 }
107
adc_read_data(QTestState * qts,const ADC * adc)108 static uint32_t adc_read_data(QTestState *qts, const ADC *adc)
109 {
110 return qtest_readl(qts, adc->base_addr + DATA_OFFSET);
111 }
112
adc_calibrate(uint32_t measured,uint32_t * rv)113 static uint32_t adc_calibrate(uint32_t measured, uint32_t *rv)
114 {
115 return R0_INPUT + (R1_INPUT - R0_INPUT) * (int32_t)(measured - rv[0])
116 / (int32_t)(rv[1] - rv[0]);
117 }
118
adc_qom_set(QTestState * qts,const ADC * adc,const char * name,uint32_t value)119 static void adc_qom_set(QTestState *qts, const ADC *adc,
120 const char *name, uint32_t value)
121 {
122 QDict *response;
123 const char *path = "/machine/soc/adc";
124
125 g_test_message("Setting properties %s of %s with value %u",
126 name, path, value);
127 response = qtest_qmp(qts, "{ 'execute': 'qom-set',"
128 " 'arguments': { 'path': %s, 'property': %s, 'value': %u}}",
129 path, name, value);
130 /* The qom set message returns successfully. */
131 g_assert_true(qdict_haskey(response, "return"));
132 qobject_unref(response);
133 }
134
adc_write_input(QTestState * qts,const ADC * adc,uint32_t index,uint32_t value)135 static void adc_write_input(QTestState *qts, const ADC *adc,
136 uint32_t index, uint32_t value)
137 {
138 char name[100];
139
140 sprintf(name, "adci[%u]", index);
141 adc_qom_set(qts, adc, name, value);
142 }
143
adc_write_vref(QTestState * qts,const ADC * adc,uint32_t value)144 static void adc_write_vref(QTestState *qts, const ADC *adc, uint32_t value)
145 {
146 adc_qom_set(qts, adc, "vref", value);
147 }
148
adc_calculate_output(uint32_t input,uint32_t ref)149 static uint32_t adc_calculate_output(uint32_t input, uint32_t ref)
150 {
151 uint32_t output;
152
153 g_assert_cmpuint(input, <=, ref);
154 output = (input * (MAX_RESULT + 1)) / ref;
155 if (output > MAX_RESULT) {
156 output = MAX_RESULT;
157 }
158
159 return output;
160 }
161
adc_prescaler(QTestState * qts,const ADC * adc)162 static uint32_t adc_prescaler(QTestState *qts, const ADC *adc)
163 {
164 uint32_t div = extract32(adc_read_con(qts, adc), 1, 8);
165
166 return 2 * (div + 1);
167 }
168
adc_calculate_steps(uint32_t cycles,uint32_t prescale,uint32_t clkdiv)169 static int64_t adc_calculate_steps(uint32_t cycles, uint32_t prescale,
170 uint32_t clkdiv)
171 {
172 return (NANOSECONDS_PER_SECOND / (REF_HZ >> clkdiv)) * cycles * prescale;
173 }
174
adc_wait_conv_finished(QTestState * qts,const ADC * adc,uint32_t clkdiv)175 static void adc_wait_conv_finished(QTestState *qts, const ADC *adc,
176 uint32_t clkdiv)
177 {
178 uint32_t prescaler = adc_prescaler(qts, adc);
179
180 /*
181 * ADC should takes roughly 20 cycles to convert one sample. So we assert it
182 * should take 10~30 cycles here.
183 */
184 qtest_clock_step(qts, adc_calculate_steps(CONV_CYCLES / 2, prescaler,
185 clkdiv));
186 /* ADC is still converting. */
187 g_assert_true(adc_read_con(qts, adc) & CON_CONV);
188 qtest_clock_step(qts, adc_calculate_steps(CONV_CYCLES, prescaler, clkdiv));
189 /* ADC has finished conversion. */
190 g_assert_false(adc_read_con(qts, adc) & CON_CONV);
191 }
192
193 /* Check ADC can be reset to default value. */
test_init(gconstpointer adc_p)194 static void test_init(gconstpointer adc_p)
195 {
196 const ADC *adc = adc_p;
197
198 QTestState *qts = qtest_init("-machine quanta-gsj");
199 adc_write_con(qts, adc, CON_REFSEL | CON_INT);
200 g_assert_cmphex(adc_read_con(qts, adc), ==, CON_REFSEL);
201 qtest_quit(qts);
202 }
203
204 /* Check ADC can convert from an internal reference. */
test_convert_internal(gconstpointer adc_p)205 static void test_convert_internal(gconstpointer adc_p)
206 {
207 const ADC *adc = adc_p;
208 uint32_t index, input, output, expected_output;
209 QTestState *qts = qtest_init("-machine quanta-gsj");
210 qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic");
211
212 for (index = 0; index < NUM_INPUTS; ++index) {
213 for (size_t i = 0; i < ARRAY_SIZE(input_list); ++i) {
214 input = input_list[i];
215 expected_output = adc_calculate_output(input, DEFAULT_IREF);
216
217 adc_write_input(qts, adc, index, input);
218 adc_write_con(qts, adc, CON_MUX(index) | CON_REFSEL | CON_INT |
219 CON_EN | CON_CONV);
220 adc_wait_conv_finished(qts, adc, DEFAULT_CLKDIV);
221 g_assert_cmphex(adc_read_con(qts, adc), ==, CON_MUX(index) |
222 CON_REFSEL | CON_EN);
223 g_assert_false(qtest_get_irq(qts, adc->irq));
224 output = adc_read_data(qts, adc);
225 g_assert_cmpuint(output, ==, expected_output);
226 }
227 }
228
229 qtest_quit(qts);
230 }
231
232 /* Check ADC can convert from an external reference. */
test_convert_external(gconstpointer adc_p)233 static void test_convert_external(gconstpointer adc_p)
234 {
235 const ADC *adc = adc_p;
236 uint32_t index, input, vref, output, expected_output;
237 QTestState *qts = qtest_init("-machine quanta-gsj");
238 qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic");
239
240 for (index = 0; index < NUM_INPUTS; ++index) {
241 for (size_t i = 0; i < ARRAY_SIZE(input_list); ++i) {
242 for (size_t j = 0; j < ARRAY_SIZE(vref_list); ++j) {
243 input = input_list[i];
244 vref = vref_list[j];
245 expected_output = adc_calculate_output(input, vref);
246
247 adc_write_input(qts, adc, index, input);
248 adc_write_vref(qts, adc, vref);
249 adc_write_con(qts, adc, CON_MUX(index) | CON_INT | CON_EN |
250 CON_CONV);
251 adc_wait_conv_finished(qts, adc, DEFAULT_CLKDIV);
252 g_assert_cmphex(adc_read_con(qts, adc), ==,
253 CON_MUX(index) | CON_EN);
254 g_assert_false(qtest_get_irq(qts, adc->irq));
255 output = adc_read_data(qts, adc);
256 g_assert_cmpuint(output, ==, expected_output);
257 }
258 }
259 }
260
261 qtest_quit(qts);
262 }
263
264 /* Check ADC interrupt files if and only if CON_INT_EN is set. */
test_interrupt(gconstpointer adc_p)265 static void test_interrupt(gconstpointer adc_p)
266 {
267 const ADC *adc = adc_p;
268 uint32_t index, input, output, expected_output;
269 QTestState *qts = qtest_init("-machine quanta-gsj");
270
271 index = 1;
272 input = input_list[1];
273 expected_output = adc_calculate_output(input, DEFAULT_IREF);
274
275 qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic");
276 adc_write_input(qts, adc, index, input);
277 g_assert_false(qtest_get_irq(qts, adc->irq));
278 adc_write_con(qts, adc, CON_MUX(index) | CON_INT_EN | CON_REFSEL | CON_INT
279 | CON_EN | CON_CONV);
280 adc_wait_conv_finished(qts, adc, DEFAULT_CLKDIV);
281 g_assert_cmphex(adc_read_con(qts, adc), ==, CON_MUX(index) | CON_INT_EN
282 | CON_REFSEL | CON_INT | CON_EN);
283 g_assert_true(qtest_get_irq(qts, adc->irq));
284 output = adc_read_data(qts, adc);
285 g_assert_cmpuint(output, ==, expected_output);
286
287 qtest_quit(qts);
288 }
289
290 /* Check ADC is reset after setting ADC_RST for 10 ADC cycles. */
test_reset(gconstpointer adc_p)291 static void test_reset(gconstpointer adc_p)
292 {
293 const ADC *adc = adc_p;
294 QTestState *qts = qtest_init("-machine quanta-gsj");
295
296 for (size_t i = 0; i < ARRAY_SIZE(div_list); ++i) {
297 uint32_t div = div_list[i];
298
299 adc_write_con(qts, adc, CON_INT | CON_EN | CON_RST | CON_DIV(div));
300 qtest_clock_step(qts, adc_calculate_steps(RESET_CYCLES,
301 adc_prescaler(qts, adc), DEFAULT_CLKDIV));
302 g_assert_false(adc_read_con(qts, adc) & CON_EN);
303 }
304 qtest_quit(qts);
305 }
306
307 /* Check ADC Calibration works as desired. */
test_calibrate(gconstpointer adc_p)308 static void test_calibrate(gconstpointer adc_p)
309 {
310 int i, j;
311 const ADC *adc = adc_p;
312
313 for (j = 0; j < ARRAY_SIZE(iref_list); ++j) {
314 uint32_t iref = iref_list[j];
315 uint32_t expected_rv[] = {
316 adc_calculate_output(R0_INPUT, iref),
317 adc_calculate_output(R1_INPUT, iref),
318 };
319 char buf[100];
320 QTestState *qts;
321
322 sprintf(buf, "-machine quanta-gsj -global npcm7xx-adc.iref=%u", iref);
323 qts = qtest_init(buf);
324
325 /* Check the converted value is correct using the calibration value. */
326 for (i = 0; i < ARRAY_SIZE(input_list); ++i) {
327 uint32_t input;
328 uint32_t output;
329 uint32_t expected_output;
330 uint32_t calibrated_voltage;
331 uint32_t index = 0;
332
333 input = input_list[i];
334 /* Calibration only works for input range 0.1V ~ 1.8V. */
335 if (input < MIN_CALIB_INPUT || input > MAX_CALIB_INPUT) {
336 continue;
337 }
338 expected_output = adc_calculate_output(input, iref);
339
340 adc_write_input(qts, adc, index, input);
341 adc_write_con(qts, adc, CON_MUX(index) | CON_REFSEL | CON_INT |
342 CON_EN | CON_CONV);
343 adc_wait_conv_finished(qts, adc, DEFAULT_CLKDIV);
344 g_assert_cmphex(adc_read_con(qts, adc), ==,
345 CON_REFSEL | CON_MUX(index) | CON_EN);
346 output = adc_read_data(qts, adc);
347 g_assert_cmpuint(output, ==, expected_output);
348
349 calibrated_voltage = adc_calibrate(output, expected_rv);
350 g_assert_cmpuint(calibrated_voltage, >, input - MAX_ERROR);
351 g_assert_cmpuint(calibrated_voltage, <, input + MAX_ERROR);
352 }
353
354 qtest_quit(qts);
355 }
356 }
357
adc_add_test(const char * name,const ADC * wd,GTestDataFunc fn)358 static void adc_add_test(const char *name, const ADC* wd,
359 GTestDataFunc fn)
360 {
361 g_autofree char *full_name = g_strdup_printf("npcm7xx_adc/%s", name);
362 qtest_add_data_func(full_name, wd, fn);
363 }
364 #define add_test(name, td) adc_add_test(#name, td, test_##name)
365
main(int argc,char ** argv)366 int main(int argc, char **argv)
367 {
368 g_test_init(&argc, &argv, NULL);
369
370 add_test(init, &adc_defs);
371 add_test(convert_internal, &adc_defs);
372 add_test(convert_external, &adc_defs);
373 add_test(interrupt, &adc_defs);
374 add_test(reset, &adc_defs);
375 add_test(calibrate, &adc_defs);
376
377 return g_test_run();
378 }
379