xref: /openbmc/qemu/tests/qtest/test-arm-mptimer.c (revision af531756) 
1 /*
2  * QTest testcase for the ARM MPTimer
3  *
4  * Copyright (c) 2016 Dmitry Osipenko <digetx@gmail.com>
5  *
6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
7  * See the COPYING file in the top-level directory.
8  */
9 
10 #include "qemu/osdep.h"
11 #include "qemu/timer.h"
12 #include "libqtest-single.h"
13 
14 #define TIMER_BLOCK_SCALE(s)    ((((s) & 0xff) + 1) * 10)
15 
16 #define TIMER_BLOCK_STEP(scaler, steps_nb) \
17     clock_step(TIMER_BLOCK_SCALE(scaler) * (int64_t)(steps_nb) + 1)
18 
19 #define TIMER_BASE_PHYS 0x1e000600
20 
21 #define TIMER_LOAD      0x00
22 #define TIMER_COUNTER   0x04
23 #define TIMER_CONTROL   0x08
24 #define TIMER_INTSTAT   0x0C
25 
26 #define TIMER_CONTROL_ENABLE        (1 << 0)
27 #define TIMER_CONTROL_PERIODIC      (1 << 1)
28 #define TIMER_CONTROL_IT_ENABLE     (1 << 2)
29 #define TIMER_CONTROL_PRESCALER(p)  (((p) & 0xff) << 8)
30 
31 #define PERIODIC     1
32 #define ONESHOT      0
33 #define NOSCALE      0
34 
35 static int nonscaled = NOSCALE;
36 static int scaled = 122;
37 
38 static void timer_load(uint32_t load)
39 {
40     writel(TIMER_BASE_PHYS + TIMER_LOAD, load);
41 }
42 
43 static void timer_start(int periodic, uint32_t scale)
44 {
45     uint32_t ctl = TIMER_CONTROL_ENABLE | TIMER_CONTROL_PRESCALER(scale);
46 
47     if (periodic) {
48         ctl |= TIMER_CONTROL_PERIODIC;
49     }
50 
51     writel(TIMER_BASE_PHYS + TIMER_CONTROL, ctl);
52 }
53 
54 static void timer_stop(void)
55 {
56     writel(TIMER_BASE_PHYS + TIMER_CONTROL, 0);
57 }
58 
59 static void timer_int_clr(void)
60 {
61     writel(TIMER_BASE_PHYS + TIMER_INTSTAT, 1);
62 }
63 
64 static void timer_reset(void)
65 {
66     timer_stop();
67     timer_load(0);
68     timer_int_clr();
69 }
70 
71 static uint32_t timer_get_and_clr_int_sts(void)
72 {
73     uint32_t int_sts = readl(TIMER_BASE_PHYS + TIMER_INTSTAT);
74 
75     if (int_sts) {
76         timer_int_clr();
77     }
78 
79     return int_sts;
80 }
81 
82 static uint32_t timer_counter(void)
83 {
84     return readl(TIMER_BASE_PHYS + TIMER_COUNTER);
85 }
86 
87 static void timer_set_counter(uint32_t value)
88 {
89     writel(TIMER_BASE_PHYS + TIMER_COUNTER, value);
90 }
91 
92 static void test_timer_oneshot(gconstpointer arg)
93 {
94     int scaler = *((int *) arg);
95 
96     timer_reset();
97     timer_load(9999999);
98     timer_start(ONESHOT, scaler);
99 
100     TIMER_BLOCK_STEP(scaler, 9999);
101 
102     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
103     g_assert_cmpuint(timer_counter(), ==, 9990000);
104 
105     TIMER_BLOCK_STEP(scaler, 9990000);
106 
107     g_assert_cmpuint(timer_counter(), ==, 0);
108     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
109 
110     TIMER_BLOCK_STEP(scaler, 9990000);
111 
112     g_assert_cmpuint(timer_counter(), ==, 0);
113     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
114 }
115 
116 static void test_timer_pause(gconstpointer arg)
117 {
118     int scaler = *((int *) arg);
119 
120     timer_reset();
121     timer_load(999999999);
122     timer_start(ONESHOT, scaler);
123 
124     TIMER_BLOCK_STEP(scaler, 999);
125 
126     g_assert_cmpuint(timer_counter(), ==, 999999000);
127     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
128 
129     TIMER_BLOCK_STEP(scaler, 9000);
130 
131     g_assert_cmpuint(timer_counter(), ==, 999990000);
132     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
133 
134     timer_stop();
135 
136     g_assert_cmpuint(timer_counter(), ==, 999990000);
137     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
138 
139     TIMER_BLOCK_STEP(scaler, 90000);
140 
141     g_assert_cmpuint(timer_counter(), ==, 999990000);
142     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
143 
144     timer_start(ONESHOT, scaler);
145 
146     TIMER_BLOCK_STEP(scaler, 999990000);
147 
148     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
149     g_assert_cmpuint(timer_counter(), ==, 0);
150 
151     TIMER_BLOCK_STEP(scaler, 999990000);
152 
153     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
154     g_assert_cmpuint(timer_counter(), ==, 0);
155 }
156 
157 static void test_timer_reload(gconstpointer arg)
158 {
159     int scaler = *((int *) arg);
160 
161     timer_reset();
162     timer_load(UINT32_MAX);
163     timer_start(ONESHOT, scaler);
164 
165     TIMER_BLOCK_STEP(scaler, 90000);
166 
167     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 90000);
168     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
169 
170     timer_load(UINT32_MAX);
171 
172     TIMER_BLOCK_STEP(scaler, 90000);
173 
174     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 90000);
175     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
176 }
177 
178 static void test_timer_periodic(gconstpointer arg)
179 {
180     int scaler = *((int *) arg);
181     int repeat = 10;
182 
183     timer_reset();
184     timer_load(100);
185     timer_start(PERIODIC, scaler);
186 
187     while (repeat--) {
188         clock_step(TIMER_BLOCK_SCALE(scaler) * (101 + repeat) + 1);
189 
190         g_assert_cmpuint(timer_counter(), ==, 100 - repeat);
191         g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
192 
193         clock_step(TIMER_BLOCK_SCALE(scaler) * (101 - repeat) - 1);
194     }
195 }
196 
197 static void test_timer_oneshot_to_periodic(gconstpointer arg)
198 {
199     int scaler = *((int *) arg);
200 
201     timer_reset();
202     timer_load(10000);
203     timer_start(ONESHOT, scaler);
204 
205     TIMER_BLOCK_STEP(scaler, 1000);
206 
207     g_assert_cmpuint(timer_counter(), ==, 9000);
208     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
209 
210     timer_start(PERIODIC, scaler);
211 
212     TIMER_BLOCK_STEP(scaler, 14001);
213 
214     g_assert_cmpuint(timer_counter(), ==, 5000);
215     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
216 }
217 
218 static void test_timer_periodic_to_oneshot(gconstpointer arg)
219 {
220     int scaler = *((int *) arg);
221 
222     timer_reset();
223     timer_load(99999999);
224     timer_start(PERIODIC, scaler);
225 
226     TIMER_BLOCK_STEP(scaler, 999);
227 
228     g_assert_cmpuint(timer_counter(), ==, 99999000);
229     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
230 
231     timer_start(ONESHOT, scaler);
232 
233     TIMER_BLOCK_STEP(scaler, 99999009);
234 
235     g_assert_cmpuint(timer_counter(), ==, 0);
236     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
237 }
238 
239 static void test_timer_prescaler(void)
240 {
241     timer_reset();
242     timer_load(9999999);
243     timer_start(ONESHOT, NOSCALE);
244 
245     TIMER_BLOCK_STEP(NOSCALE, 9999998);
246 
247     g_assert_cmpuint(timer_counter(), ==, 1);
248     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
249 
250     TIMER_BLOCK_STEP(NOSCALE, 1);
251 
252     g_assert_cmpuint(timer_counter(), ==, 0);
253     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
254 
255     timer_reset();
256     timer_load(9999999);
257     timer_start(ONESHOT, 0xAB);
258 
259     TIMER_BLOCK_STEP(0xAB, 9999998);
260 
261     g_assert_cmpuint(timer_counter(), ==, 1);
262     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
263 
264     TIMER_BLOCK_STEP(0xAB, 1);
265 
266     g_assert_cmpuint(timer_counter(), ==, 0);
267     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
268 }
269 
270 static void test_timer_prescaler_on_the_fly(void)
271 {
272     timer_reset();
273     timer_load(9999999);
274     timer_start(ONESHOT, NOSCALE);
275 
276     TIMER_BLOCK_STEP(NOSCALE, 999);
277 
278     g_assert_cmpuint(timer_counter(), ==, 9999000);
279     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
280 
281     timer_start(ONESHOT, 0xAB);
282 
283     TIMER_BLOCK_STEP(0xAB, 9000);
284 
285     g_assert_cmpuint(timer_counter(), ==, 9990000);
286     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
287 }
288 
289 static void test_timer_set_oneshot_counter_to_0(gconstpointer arg)
290 {
291     int scaler = *((int *) arg);
292 
293     timer_reset();
294     timer_load(UINT32_MAX);
295     timer_start(ONESHOT, scaler);
296 
297     TIMER_BLOCK_STEP(scaler, 1);
298 
299     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 1);
300     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
301 
302     timer_set_counter(0);
303 
304     TIMER_BLOCK_STEP(scaler, 10);
305 
306     g_assert_cmpuint(timer_counter(), ==, 0);
307     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
308 }
309 
310 static void test_timer_set_periodic_counter_to_0(gconstpointer arg)
311 {
312     int scaler = *((int *) arg);
313 
314     timer_reset();
315     timer_load(UINT32_MAX);
316     timer_start(PERIODIC, scaler);
317 
318     TIMER_BLOCK_STEP(scaler, 1);
319 
320     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 1);
321     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
322 
323     timer_set_counter(0);
324 
325     TIMER_BLOCK_STEP(scaler, 1);
326 
327     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - (scaler ? 0 : 1));
328     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
329 
330     timer_reset();
331     timer_set_counter(UINT32_MAX);
332     timer_start(PERIODIC, scaler);
333 
334     TIMER_BLOCK_STEP(scaler, 1);
335 
336     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 1);
337     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
338 
339     timer_set_counter(0);
340 
341     TIMER_BLOCK_STEP(scaler, 1);
342 
343     g_assert_cmpuint(timer_counter(), ==, 0);
344     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
345 }
346 
347 static void test_timer_noload_oneshot(gconstpointer arg)
348 {
349     int scaler = *((int *) arg);
350 
351     timer_reset();
352     timer_start(ONESHOT, scaler);
353 
354     TIMER_BLOCK_STEP(scaler, 1);
355 
356     g_assert_cmpuint(timer_counter(), ==, 0);
357     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
358 
359     TIMER_BLOCK_STEP(scaler, 1);
360 
361     g_assert_cmpuint(timer_counter(), ==, 0);
362     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
363 }
364 
365 static void test_timer_noload_periodic(gconstpointer arg)
366 {
367     int scaler = *((int *) arg);
368 
369     timer_reset();
370     timer_start(PERIODIC, scaler);
371 
372     TIMER_BLOCK_STEP(scaler, 1);
373 
374     g_assert_cmpuint(timer_counter(), ==, 0);
375     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
376 
377     TIMER_BLOCK_STEP(scaler, 1);
378 
379     g_assert_cmpuint(timer_counter(), ==, 0);
380     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
381 }
382 
383 static void test_timer_zero_load_oneshot(gconstpointer arg)
384 {
385     int scaler = *((int *) arg);
386 
387     timer_reset();
388     timer_start(ONESHOT, scaler);
389 
390     TIMER_BLOCK_STEP(scaler, 1);
391 
392     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
393     g_assert_cmpuint(timer_counter(), ==, 0);
394 
395     timer_load(0);
396 
397     TIMER_BLOCK_STEP(scaler, 1);
398 
399     g_assert_cmpuint(timer_counter(), ==, 0);
400     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
401 
402     TIMER_BLOCK_STEP(scaler, 1);
403 
404     g_assert_cmpuint(timer_counter(), ==, 0);
405     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
406 }
407 
408 static void test_timer_zero_load_periodic(gconstpointer arg)
409 {
410     int scaler = *((int *) arg);
411 
412     timer_reset();
413     timer_start(PERIODIC, scaler);
414 
415     TIMER_BLOCK_STEP(scaler, 1);
416 
417     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
418     g_assert_cmpuint(timer_counter(), ==, 0);
419 
420     timer_load(0);
421 
422     TIMER_BLOCK_STEP(scaler, 1);
423 
424     g_assert_cmpuint(timer_counter(), ==, 0);
425     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
426 
427     TIMER_BLOCK_STEP(scaler, 1);
428 
429     g_assert_cmpuint(timer_counter(), ==, 0);
430     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
431 }
432 
433 static void test_timer_zero_load_oneshot_to_nonzero(gconstpointer arg)
434 {
435     int scaler = *((int *) arg);
436 
437     timer_reset();
438     timer_start(ONESHOT, scaler);
439 
440     TIMER_BLOCK_STEP(scaler, 1);
441 
442     g_assert_cmpuint(timer_counter(), ==, 0);
443     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
444 
445     timer_load(0);
446 
447     TIMER_BLOCK_STEP(scaler, 1);
448 
449     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
450     g_assert_cmpuint(timer_counter(), ==, 0);
451 
452     timer_load(999);
453 
454     TIMER_BLOCK_STEP(scaler, 1001);
455 
456     g_assert_cmpuint(timer_counter(), ==, 0);
457     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
458 }
459 
460 static void test_timer_zero_load_periodic_to_nonzero(gconstpointer arg)
461 {
462     int scaler = *((int *) arg);
463     int i;
464 
465     timer_reset();
466     timer_start(PERIODIC, scaler);
467 
468     TIMER_BLOCK_STEP(scaler, 1);
469 
470     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
471     g_assert_cmpuint(timer_counter(), ==, 0);
472 
473     timer_load(0);
474 
475     TIMER_BLOCK_STEP(scaler, 1);
476 
477     g_assert_cmpuint(timer_counter(), ==, 0);
478     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
479 
480     timer_load(1999999);
481 
482     for (i = 1; i < 10; i++) {
483         TIMER_BLOCK_STEP(scaler, 2000001);
484 
485         g_assert_cmpuint(timer_counter(), ==, 1999999 - i);
486         g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
487         g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
488     }
489 }
490 
491 static void test_timer_nonzero_load_oneshot_to_zero(gconstpointer arg)
492 {
493     int scaler = *((int *) arg);
494 
495     timer_reset();
496     timer_start(ONESHOT, scaler);
497 
498     TIMER_BLOCK_STEP(scaler, 1);
499 
500     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
501     g_assert_cmpuint(timer_counter(), ==, 0);
502 
503     timer_load(UINT32_MAX);
504     timer_load(0);
505 
506     TIMER_BLOCK_STEP(scaler, 100);
507 
508     g_assert_cmpuint(timer_counter(), ==, 0);
509     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
510 }
511 
512 static void test_timer_nonzero_load_periodic_to_zero(gconstpointer arg)
513 {
514     int scaler = *((int *) arg);
515 
516     timer_reset();
517     timer_start(PERIODIC, scaler);
518 
519     TIMER_BLOCK_STEP(scaler, 1);
520 
521     g_assert_cmpuint(timer_counter(), ==, 0);
522     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
523 
524     timer_load(UINT32_MAX);
525     timer_load(0);
526 
527     TIMER_BLOCK_STEP(scaler, 100);
528 
529     g_assert_cmpuint(timer_counter(), ==, 0);
530     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
531 }
532 
533 static void test_timer_set_periodic_counter_on_the_fly(gconstpointer arg)
534 {
535     int scaler = *((int *) arg);
536 
537     timer_reset();
538     timer_load(UINT32_MAX / 2);
539     timer_start(PERIODIC, scaler);
540 
541     TIMER_BLOCK_STEP(scaler, 100);
542 
543     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX / 2 - 100);
544     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
545 
546     timer_set_counter(UINT32_MAX);
547 
548     TIMER_BLOCK_STEP(scaler, 100);
549 
550     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 100);
551     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
552 }
553 
554 static void test_timer_enable_and_set_counter(gconstpointer arg)
555 {
556     int scaler = *((int *) arg);
557 
558     timer_reset();
559     timer_start(ONESHOT, scaler);
560 
561     TIMER_BLOCK_STEP(scaler, 1);
562 
563     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
564 
565     timer_set_counter(UINT32_MAX);
566 
567     TIMER_BLOCK_STEP(scaler, 100);
568 
569     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 100);
570     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
571 }
572 
573 static void test_timer_set_counter_and_enable(gconstpointer arg)
574 {
575     int scaler = *((int *) arg);
576 
577     timer_reset();
578     timer_set_counter(UINT32_MAX);
579     timer_start(ONESHOT, scaler);
580 
581     TIMER_BLOCK_STEP(scaler, 100);
582 
583     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 100);
584     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
585 }
586 
587 static void test_timer_set_counter_disabled(void)
588 {
589     timer_reset();
590     timer_set_counter(999999999);
591 
592     TIMER_BLOCK_STEP(NOSCALE, 100);
593 
594     g_assert_cmpuint(timer_counter(), ==, 999999999);
595     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
596 }
597 
598 static void test_timer_load_disabled(void)
599 {
600     timer_reset();
601     timer_load(999999999);
602 
603     TIMER_BLOCK_STEP(NOSCALE, 100);
604 
605     g_assert_cmpuint(timer_counter(), ==, 999999999);
606     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
607 }
608 
609 static void test_timer_oneshot_with_counter_0_on_start(gconstpointer arg)
610 {
611     int scaler = *((int *) arg);
612 
613     timer_reset();
614     timer_load(999);
615     timer_set_counter(0);
616     timer_start(ONESHOT, scaler);
617 
618     TIMER_BLOCK_STEP(scaler, 100);
619 
620     g_assert_cmpuint(timer_counter(), ==, 0);
621     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
622 
623     TIMER_BLOCK_STEP(scaler, 100);
624 
625     g_assert_cmpuint(timer_counter(), ==, 0);
626     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
627 }
628 
629 static void test_timer_periodic_with_counter_0_on_start(gconstpointer arg)
630 {
631     int scaler = *((int *) arg);
632     int i;
633 
634     timer_reset();
635     timer_load(UINT32_MAX);
636     timer_set_counter(0);
637 
638     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
639     g_assert_cmpuint(timer_counter(), ==, 0);
640 
641     timer_start(PERIODIC, scaler);
642 
643     TIMER_BLOCK_STEP(scaler, 100);
644 
645     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
646     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX + (scaler ? 1 : 0) - 100);
647 
648     TIMER_BLOCK_STEP(scaler, 100);
649 
650     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX + (scaler ? 1 : 0) - 200);
651     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
652 
653     timer_reset();
654     timer_load(1999999);
655     timer_set_counter(0);
656 
657     g_assert_cmpuint(timer_counter(), ==, 0);
658     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
659 
660     TIMER_BLOCK_STEP(scaler, 1);
661 
662     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
663 
664     timer_start(PERIODIC, scaler);
665 
666     TIMER_BLOCK_STEP(scaler, 1);
667 
668     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
669 
670     for (i = 2 - (!!scaler ? 1 : 0); i < 10; i++) {
671         TIMER_BLOCK_STEP(scaler, 2000001);
672 
673         g_assert_cmpuint(timer_counter(), ==, 1999999 - i);
674         g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
675         g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
676     }
677 }
678 
679 static void test_periodic_counter(gconstpointer arg)
680 {
681     const int test_load = 10;
682     int scaler = *((int *) arg);
683     int test_val;
684 
685     timer_reset();
686     timer_load(test_load);
687     timer_start(PERIODIC, scaler);
688 
689     clock_step(1);
690 
691     for (test_val = 0; test_val <= test_load; test_val++) {
692         clock_step(TIMER_BLOCK_SCALE(scaler) * test_load);
693         g_assert_cmpint(timer_counter(), ==, test_val);
694     }
695 }
696 
697 static void test_timer_set_counter_periodic_with_zero_load(gconstpointer arg)
698 {
699     int scaler = *((int *) arg);
700 
701     timer_reset();
702     timer_start(PERIODIC, scaler);
703     timer_load(0);
704 
705     TIMER_BLOCK_STEP(scaler, 1);
706 
707     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
708 
709     TIMER_BLOCK_STEP(scaler, 1);
710 
711     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
712 
713     timer_set_counter(999);
714 
715     TIMER_BLOCK_STEP(scaler, 999);
716 
717     g_assert_cmpuint(timer_counter(), ==, 0);
718     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
719 
720     TIMER_BLOCK_STEP(scaler, 1);
721 
722     g_assert_cmpuint(timer_counter(), ==, 0);
723     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
724 }
725 
726 static void test_timer_set_oneshot_load_to_0(gconstpointer arg)
727 {
728     int scaler = *((int *) arg);
729 
730     timer_reset();
731     timer_load(UINT32_MAX);
732     timer_start(ONESHOT, scaler);
733 
734     TIMER_BLOCK_STEP(scaler, 100);
735 
736     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 100);
737     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
738 
739     timer_load(0);
740 
741     TIMER_BLOCK_STEP(scaler, 100);
742 
743     g_assert_cmpuint(timer_counter(), ==, 0);
744     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
745 
746     TIMER_BLOCK_STEP(scaler, 100);
747 
748     g_assert_cmpuint(timer_counter(), ==, 0);
749     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
750 }
751 
752 static void test_timer_set_periodic_load_to_0(gconstpointer arg)
753 {
754     int scaler = *((int *) arg);
755 
756     timer_reset();
757     timer_load(UINT32_MAX);
758     timer_start(PERIODIC, scaler);
759 
760     TIMER_BLOCK_STEP(scaler, 100);
761 
762     g_assert_cmpuint(timer_counter(), ==, UINT32_MAX - 100);
763     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
764 
765     timer_load(0);
766 
767     TIMER_BLOCK_STEP(scaler, 100);
768 
769     g_assert_cmpuint(timer_counter(), ==, 0);
770     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
771 
772     TIMER_BLOCK_STEP(scaler, 100);
773 
774     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
775     g_assert_cmpuint(timer_counter(), ==, 0);
776 }
777 
778 static void test_deferred_trigger(void)
779 {
780     int mode = ONESHOT;
781 
782 again:
783     timer_reset();
784     timer_start(mode, 255);
785 
786     clock_step(100);
787 
788     g_assert_cmpuint(timer_counter(), ==, 0);
789 
790     TIMER_BLOCK_STEP(255, 1);
791 
792     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
793 
794     timer_reset();
795     timer_load(2);
796     timer_start(mode, 255);
797 
798     clock_step(100);
799 
800     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
801 
802     TIMER_BLOCK_STEP(255, 1);
803 
804     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
805 
806     TIMER_BLOCK_STEP(255, 1);
807 
808     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
809 
810     timer_reset();
811     timer_load(UINT32_MAX);
812     timer_start(mode, 255);
813 
814     clock_step(100);
815 
816     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
817 
818     timer_set_counter(0);
819 
820     clock_step(100);
821 
822     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
823 
824     TIMER_BLOCK_STEP(255, 1);
825 
826     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
827 
828     timer_reset();
829     timer_load(UINT32_MAX);
830     timer_start(mode, 255);
831 
832     clock_step(100);
833 
834     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
835 
836     timer_load(0);
837 
838     clock_step(100);
839 
840     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
841 
842     TIMER_BLOCK_STEP(255, 1);
843 
844     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
845 
846     if (mode == ONESHOT) {
847         mode = PERIODIC;
848         goto again;
849     }
850 }
851 
852 static void test_timer_zero_load_mode_switch(gconstpointer arg)
853 {
854     int scaler = *((int *) arg);
855 
856     timer_reset();
857     timer_load(0);
858     timer_start(PERIODIC, scaler);
859 
860     TIMER_BLOCK_STEP(scaler, 1);
861 
862     g_assert_cmpuint(timer_counter(), ==, 0);
863     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
864 
865     TIMER_BLOCK_STEP(scaler, 1);
866 
867     timer_start(ONESHOT, scaler);
868 
869     TIMER_BLOCK_STEP(scaler, 1);
870 
871     g_assert_cmpuint(timer_counter(), ==, 0);
872     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
873 
874     TIMER_BLOCK_STEP(scaler, 1);
875 
876     g_assert_cmpuint(timer_counter(), ==, 0);
877     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
878 
879     TIMER_BLOCK_STEP(scaler, 1);
880 
881     timer_start(PERIODIC, scaler);
882 
883     TIMER_BLOCK_STEP(scaler, 1);
884 
885     g_assert_cmpuint(timer_counter(), ==, 0);
886     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, !!scaler);
887 }
888 
889 static void test_timer_zero_load_prescaled_periodic_to_nonscaled_oneshot(void)
890 {
891     timer_reset();
892     timer_load(0);
893     timer_start(PERIODIC, 255);
894 
895     TIMER_BLOCK_STEP(255, 1);
896 
897     g_assert_cmpuint(timer_counter(), ==, 0);
898     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
899     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
900 
901     TIMER_BLOCK_STEP(255, 1);
902 
903     g_assert_cmpuint(timer_counter(), ==, 0);
904     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
905     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
906 
907     TIMER_BLOCK_STEP(255, 1);
908 
909     timer_start(ONESHOT, NOSCALE);
910 
911     TIMER_BLOCK_STEP(NOSCALE, 1);
912 
913     g_assert_cmpuint(timer_counter(), ==, 0);
914     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
915     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
916 
917     TIMER_BLOCK_STEP(NOSCALE, 1);
918 
919     g_assert_cmpuint(timer_counter(), ==, 0);
920     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
921 }
922 
923 static void test_timer_zero_load_prescaled_oneshot_to_nonscaled_periodic(void)
924 {
925     timer_reset();
926     timer_load(0);
927     timer_start(ONESHOT, 255);
928 
929     TIMER_BLOCK_STEP(255, 1);
930 
931     g_assert_cmpuint(timer_counter(), ==, 0);
932     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
933     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
934 
935     timer_start(PERIODIC, NOSCALE);
936 
937     TIMER_BLOCK_STEP(NOSCALE, 1);
938 
939     g_assert_cmpuint(timer_counter(), ==, 0);
940     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
941 }
942 
943 static void test_timer_zero_load_nonscaled_oneshot_to_prescaled_periodic(void)
944 {
945     timer_reset();
946     timer_load(0);
947     timer_start(ONESHOT, NOSCALE);
948 
949     TIMER_BLOCK_STEP(NOSCALE, 1);
950 
951     g_assert_cmpuint(timer_counter(), ==, 0);
952     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
953 
954     timer_start(PERIODIC, 255);
955 
956     TIMER_BLOCK_STEP(255, 1);
957 
958     g_assert_cmpuint(timer_counter(), ==, 0);
959     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
960     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
961 
962     TIMER_BLOCK_STEP(255, 1);
963 
964     g_assert_cmpuint(timer_counter(), ==, 0);
965     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
966     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
967 }
968 
969 static void test_timer_zero_load_nonscaled_periodic_to_prescaled_oneshot(void)
970 {
971     timer_reset();
972     timer_load(0);
973     timer_start(PERIODIC, NOSCALE);
974 
975     TIMER_BLOCK_STEP(NOSCALE, 1);
976 
977     g_assert_cmpuint(timer_counter(), ==, 0);
978     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
979 
980     timer_start(ONESHOT, 255);
981 
982     TIMER_BLOCK_STEP(255, 1);
983 
984     g_assert_cmpuint(timer_counter(), ==, 0);
985     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 1);
986     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
987 
988     TIMER_BLOCK_STEP(255, 1);
989 
990     g_assert_cmpuint(timer_counter(), ==, 0);
991     g_assert_cmpuint(timer_get_and_clr_int_sts(), ==, 0);
992 }
993 
994 /*
995  * Add a qtest test that comes in two versions: one with
996  * a timer scaler setting, and one with the timer nonscaled.
997  */
998 static void add_scaler_test(const char *str, bool scale,
999                             void (*fn)(const void *))
1000 {
1001     char *name;
1002     int *scaler = scale ? &scaled : &nonscaled;
1003 
1004     name = g_strdup_printf("%s=%d", str, *scaler);
1005     qtest_add_data_func(name, scaler, fn);
1006     g_free(name);
1007 }
1008 
1009 int main(int argc, char **argv)
1010 {
1011     int ret;
1012     int scale;
1013 
1014     g_test_init(&argc, &argv, NULL);
1015 
1016     qtest_add_func("mptimer/deferred_trigger", test_deferred_trigger);
1017     qtest_add_func("mptimer/load_disabled", test_timer_load_disabled);
1018     qtest_add_func("mptimer/set_counter_disabled", test_timer_set_counter_disabled);
1019     qtest_add_func("mptimer/zero_load_prescaled_periodic_to_nonscaled_oneshot",
1020                    test_timer_zero_load_prescaled_periodic_to_nonscaled_oneshot);
1021     qtest_add_func("mptimer/zero_load_prescaled_oneshot_to_nonscaled_periodic",
1022                    test_timer_zero_load_prescaled_oneshot_to_nonscaled_periodic);
1023     qtest_add_func("mptimer/zero_load_nonscaled_oneshot_to_prescaled_periodic",
1024                    test_timer_zero_load_nonscaled_oneshot_to_prescaled_periodic);
1025     qtest_add_func("mptimer/zero_load_nonscaled_periodic_to_prescaled_oneshot",
1026                    test_timer_zero_load_nonscaled_periodic_to_prescaled_oneshot);
1027     qtest_add_func("mptimer/prescaler", test_timer_prescaler);
1028     qtest_add_func("mptimer/prescaler_on_the_fly", test_timer_prescaler_on_the_fly);
1029 
1030     for (scale = 0; scale < 2; scale++) {
1031         add_scaler_test("mptimer/oneshot scaler",
1032                         scale, test_timer_oneshot);
1033         add_scaler_test("mptimer/pause scaler",
1034                         scale, test_timer_pause);
1035         add_scaler_test("mptimer/reload scaler",
1036                         scale, test_timer_reload);
1037         add_scaler_test("mptimer/periodic scaler",
1038                         scale, test_timer_periodic);
1039         add_scaler_test("mptimer/oneshot_to_periodic scaler",
1040                         scale, test_timer_oneshot_to_periodic);
1041         add_scaler_test("mptimer/periodic_to_oneshot scaler",
1042                         scale, test_timer_periodic_to_oneshot);
1043         add_scaler_test("mptimer/set_oneshot_counter_to_0 scaler",
1044                         scale, test_timer_set_oneshot_counter_to_0);
1045         add_scaler_test("mptimer/set_periodic_counter_to_0 scaler",
1046                         scale, test_timer_set_periodic_counter_to_0);
1047         add_scaler_test("mptimer/noload_oneshot scaler",
1048                         scale, test_timer_noload_oneshot);
1049         add_scaler_test("mptimer/noload_periodic scaler",
1050                         scale, test_timer_noload_periodic);
1051         add_scaler_test("mptimer/zero_load_oneshot scaler",
1052                         scale, test_timer_zero_load_oneshot);
1053         add_scaler_test("mptimer/zero_load_periodic scaler",
1054                         scale, test_timer_zero_load_periodic);
1055         add_scaler_test("mptimer/zero_load_oneshot_to_nonzero scaler",
1056                         scale, test_timer_zero_load_oneshot_to_nonzero);
1057         add_scaler_test("mptimer/zero_load_periodic_to_nonzero scaler",
1058                         scale, test_timer_zero_load_periodic_to_nonzero);
1059         add_scaler_test("mptimer/nonzero_load_oneshot_to_zero scaler",
1060                         scale, test_timer_nonzero_load_oneshot_to_zero);
1061         add_scaler_test("mptimer/nonzero_load_periodic_to_zero scaler",
1062                         scale, test_timer_nonzero_load_periodic_to_zero);
1063         add_scaler_test("mptimer/set_periodic_counter_on_the_fly scaler",
1064                         scale, test_timer_set_periodic_counter_on_the_fly);
1065         add_scaler_test("mptimer/enable_and_set_counter scaler",
1066                         scale, test_timer_enable_and_set_counter);
1067         add_scaler_test("mptimer/set_counter_and_enable scaler",
1068                         scale, test_timer_set_counter_and_enable);
1069         add_scaler_test("mptimer/oneshot_with_counter_0_on_start scaler",
1070                         scale, test_timer_oneshot_with_counter_0_on_start);
1071         add_scaler_test("mptimer/periodic_with_counter_0_on_start scaler",
1072                         scale, test_timer_periodic_with_counter_0_on_start);
1073         add_scaler_test("mptimer/periodic_counter scaler",
1074                         scale, test_periodic_counter);
1075         add_scaler_test("mptimer/set_counter_periodic_with_zero_load scaler",
1076                         scale, test_timer_set_counter_periodic_with_zero_load);
1077         add_scaler_test("mptimer/set_oneshot_load_to_0 scaler",
1078                         scale, test_timer_set_oneshot_load_to_0);
1079         add_scaler_test("mptimer/set_periodic_load_to_0 scaler",
1080                         scale, test_timer_set_periodic_load_to_0);
1081         add_scaler_test("mptimer/zero_load_mode_switch scaler",
1082                         scale, test_timer_zero_load_mode_switch);
1083     }
1084 
1085     qtest_start("-machine vexpress-a9");
1086     ret = g_test_run();
1087     qtest_end();
1088 
1089     return ret;
1090 }
1091