michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests/drivers/aon_counter: make a ztest testcase

Browse source 
Reorganize the code tree so no forward declarations are needed
(basically, move main() to the bottom).

Retag as not build only so it can be run on Quark*

Convert to actually verify counter readouts are increasing /
decreasing over busy empty loops and the alarm is being called.

Change-Id: I746efe595b8d1ac4471dccc2e87f8b36f5cc8ebe
Signed-off-by: Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
This commit is contained in:
Inaky Perez-Gonzalez 2016-11-04 23:05:56 -07:00 • committed by Anas Nashif
commit 5b7bfdaf48
4 changed files with 86 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

1
tests/drivers/aon_counter/prj.conf
View file

@ -1,2 +1,3 @@
CONFIG_PRINTK=y
CONFIG_COUNTER=y
CONFIG_ZTEST=y

2
tests/drivers/aon_counter/src/Makefile
View file

@ -1 +1,3 @@
include $(ZEPHYR_BASE)/tests/Makefile.test
obj-y = main.o

158
tests/drivers/aon_counter/src/main.c
View file

@ -13,154 +13,160 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <zephyr.h>
#include <ztest.h>
#include <misc/printk.h>
#include <device.h>
#include <counter.h>
static void aonpt_example_callback(struct device *dev, void *user_data);
static void free_running_counter_example(void);
static void periodic_timer_example(void);
/*
* 0 if not called, != 0 is the value of the counter
*
* Note to avoid 0 being posted there because the counter reached 0,
* we'll add 1 if this is the case.
*/
static volatile uint32_t aonpt_example_callback_was_called;
void main(void)
static void aonpt_example_callback(struct device *dev, void *user_data)
{
/* test quark Always-on free running counter */
free_running_counter_example();
uint32_t counter;
/* test quark Always-on periodic timer */
periodic_timer_example();
printk("Periodic timer callback data %p\n", user_data);
counter = counter_read(dev);
printk("Periodic timer callback value %u\n", counter);
aonpt_example_callback_was_called = counter == 0 ? 1 : counter;
}
static void free_running_counter_example(void)
{
int r;
volatile uint32_t delay = 0;
uint32_t c_val = 0, i = 0;
uint32_t dummy_data = 30;
uint32_t counter_initial_value = 10000;
unsigned pt_loops = 20, i;
uint32_t c_vals[pt_loops + 1];
struct device *aon_counter_dev;
aon_counter_dev = device_get_binding("AON_COUNTER");
if (!aon_counter_dev) {
printk("Counter device not found\n");
return;
}
printk("Always-on free running counter example app\n");
if (counter_start(aon_counter_dev) != 0) {
printk("Counter device enabling fail!\n");
return;
}
aon_counter_dev = device_get_binding("AON_COUNTER");
assert_not_null(aon_counter_dev, "Counter device not found\n");
printk("Always-on counter started\n");
r = counter_start(aon_counter_dev);
assert_equal(r, 0, "Counter device enable didn't return 0\n");
/* The AON counter runs from the RTC clock at 32KHz (rather than
/*
* The AON counter runs from the RTC clock at 32KHz (rather than
* the system clock which is 32MHz) so we need to spin for a few cycles
* allow the register change to propagate.
*/
c_vals[0] = counter_read(aon_counter_dev);
for (delay = 5000; delay--;) {
}
c_vals[1] = counter_read(aon_counter_dev);
printk("Always-on counter before 5k empty loop %u / after %u\n",
c_vals[0], c_vals[1]);
assert_true(c_vals[1] > c_vals[0],
"Always-on counter failed to increase during 5k loop");
for (i = 0; i < 20; i++) {
c_vals[0] = counter_read(aon_counter_dev);
for (i = 1; i <= pt_loops; i++) { /* note the i + 1 */
for (delay = 500; delay--;) {
}
c_val = counter_read(aon_counter_dev);
printk("Always-on counter value: %d\n", c_val);
c_vals[i] = counter_read(aon_counter_dev);
printk("Always-on counter before 500 empty loop %u / after %u\n",
c_vals[i - 1], c_vals[i]);
assert_true(c_vals[i] > c_vals[i - 1],
"Always-on counter failed to increase "
"during 500 loop");
}
if (counter_set_alarm(aon_counter_dev, NULL, counter_initial_value,
(void *)&dummy_data) != 0) {
printk("Always-on counter does not support alarm!\n");
}
counter_stop(aon_counter_dev);
printk("Always-on counter stopped\n");
}
static void periodic_timer_example(void)
{
int r;
volatile uint32_t delay = 0;
uint32_t pt_val = 0, i = 0;
uint32_t i = 0;
uint32_t dummy_data = 30;
uint32_t timer_initial_value = 10000;
const unsigned pt_loops = 20;
uint32_t pt_val0, pt_vals[pt_loops + 1];
struct device *aon_periodic_timer_dev = NULL;
aon_periodic_timer_dev = device_get_binding("AON_TIMER");
if (!aon_periodic_timer_dev) {
printk("Timer device not found\n");
return;
}
printk("Periodic timer example app\n");
aon_periodic_timer_dev = device_get_binding("AON_TIMER");
assert_not_null(aon_periodic_timer_dev, "Timer device not found\n");
counter_start(aon_periodic_timer_dev);
printk("Periodic timer started\n");
/* The AON timer runs from the RTC clock at 32KHz (rather than
/*
* The AON timer runs from the RTC clock at 32KHz (rather than
* the system clock which is 32MHz) so we need to spin for a few cycles
* allow the register change to propagate.
*
* Note it counts down!
*/
pt_val0 = counter_read(aon_periodic_timer_dev);
for (delay = 5000; delay--;) {
}
for (i = 0; i < 20; i++) {
pt_vals[0] = counter_read(aon_periodic_timer_dev);
printk("Periodic timer value before 5k %u, after %u\n",
pt_val0, pt_vals[0]);
assert_true(pt_vals[0] < pt_val0,
"timer failed to decrease in 5k empty loop");
for (i = 1; i < pt_loops + 1; i++) { /* note the +1 */
for (delay = 500; delay--;) {
}
pt_val = counter_read(aon_periodic_timer_dev);
printk("Periodic timer value: %x\n", pt_val);
pt_vals[i] = counter_read(aon_periodic_timer_dev);
printk("Periodic timer value before 500 %u, after %u\n",
pt_vals[i - 1], pt_vals[i]);
assert_true(pt_vals[i] < pt_vals[i - 1],
"timer failed to decrease in 500 empty loop");
}
if (counter_set_alarm(aon_periodic_timer_dev, aonpt_example_callback,
timer_initial_value, (void *)&dummy_data)
!= 0) {
printk("Periodic Timer was not started yet\n");
return;
}
r = counter_set_alarm(aon_periodic_timer_dev, aonpt_example_callback,
timer_initial_value, (void *)&dummy_data);
assert_equal(r, 0, "Periodic Timer was not started yet\n");
printk("Periodic Timer alarm on\n");
/* long delay for the alarm and callback to happen */
for (delay = 5000000; delay--;) {
}
assert_not_equal(aonpt_example_callback_was_called, 0,
"alarm callback was not called");
printk("Alarm callback was called with counter %u\n",
aonpt_example_callback_was_called);
/* callback is turned off */
if (counter_set_alarm(aon_periodic_timer_dev, NULL,
timer_initial_value, (void *)&dummy_data)
!= 0) {
printk("Periodic timer was not started yet\n");
return;
}
r = counter_set_alarm(aon_periodic_timer_dev, NULL,
timer_initial_value, (void *)&dummy_data);
assert_equal(r, 0, "Periodic timer was not started yet\n");
printk("Periodic timer alarm off\n");
for (i = 0; i < 20; i++) {
pt_vals[0] = counter_read(aon_periodic_timer_dev);
for (i = 1; i < pt_loops + 1; i++) { /* note the +1 */
for (delay = 500; delay--;) {
}
pt_val = counter_read(aon_periodic_timer_dev);
printk("Periodic timer value: %x\n", pt_val);
pt_vals[i] = counter_read(aon_periodic_timer_dev);
printk("Periodic timer value before 500 %u, after %u\n",
pt_vals[i - 1], pt_vals[i]);
assert_true(pt_vals[i] < pt_vals[i - 1],
"timer failed to decrease in 500 empty loop");
}
counter_stop(aon_periodic_timer_dev);
printk("Periodic timer stopped\n");
}
static void aonpt_example_callback(struct device *dev, void *user_data)
void test_main(void)
{
printk("Periodic timer callback data %d\n", *((uint32_t *)user_data));
printk("Periodic timer callback value %d\n", counter_read(dev));
ztest_test_suite(
aon_counter_test,
ztest_unit_test(free_running_counter_example),
ztest_unit_test(periodic_timer_example));
ztest_run_test_suite(aon_counter_test);
}

3
tests/drivers/aon_counter/testcase.ini
View file

@ -1,4 +1,3 @@
[test]
tags = apps
build_only = true
platform_whitelist = quark_d2000_crb
platform_whitelist = quark_d2000_crb quark_se_c1000_devboard quark_se_c1000_ss_devboard arduino_101_sss arduino_101