mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
123 lines
3.1 KiB
C
123 lines
3.1 KiB
C
/*
|
|
* Copyright (C) 2021 Otto-von-Guericke Universität Magdeburg
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU Lesser
|
|
* General Public License v2.1. See the file LICENSE in the top level
|
|
* directory for more details.
|
|
*/
|
|
|
|
/**
|
|
* @ingroup tests
|
|
* @{
|
|
*
|
|
* @file
|
|
* @brief Test application for the PIO peripheral driver
|
|
*
|
|
* @author Fabian Hüßler <fabian.huessler@ovgu.de>
|
|
*
|
|
* @}
|
|
*/
|
|
|
|
#include <stddef.h>
|
|
#include "shell.h"
|
|
#include "periph_conf.h"
|
|
#include "periph/pio.h"
|
|
#include "pio/pio.h"
|
|
#define ENABLE_DEBUG 0
|
|
#include "debug.h"
|
|
|
|
#if ENABLE_DEBUG
|
|
#define DEBUG_TEST_FAILED(msg, ...) \
|
|
DEBUG("[Test PIO] %s failed at %d: " msg "\n", __func__, __LINE__, __VA_ARGS__);
|
|
#else
|
|
#define DEBUG_TEST_FAILED(msg, ...)
|
|
#endif
|
|
|
|
static int _test_pio_alloc_and_free(pio_t pio)
|
|
{
|
|
int error = 1;
|
|
pio_program_t pro;
|
|
for (int i = 0; i < PIO_INSTR_NUMOF; i++) {
|
|
pro = (pio_program_t){.location = PIO_PROGRAM_NOT_LOADED, .instr_numof = 1};
|
|
if (pio_alloc_program(pio, &pro)) {
|
|
DEBUG_TEST_FAILED("Could not allocate program at %d", i);
|
|
goto CLEAN;
|
|
}
|
|
}
|
|
if (!pio_alloc_program(pio, &pro)) {
|
|
DEBUG_TEST_FAILED("Program impossibly allocated");
|
|
goto CLEAN;
|
|
}
|
|
pio_free_program(pio, &pro);
|
|
pro.location = PIO_PROGRAM_NOT_LOADED;
|
|
if (pio_alloc_program(pio, &pro)) {
|
|
DEBUG_TEST_FAILED("Program could not be allocated after free");
|
|
goto CLEAN;
|
|
}
|
|
error = 0;
|
|
CLEAN:
|
|
for (int i = 0; i < PIO_INSTR_NUMOF; i++) {
|
|
pro = (pio_program_t){.location = i, .instr_numof = 1};
|
|
pio_free_program(pio, &pro);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int _test_pio_sm_lock_unlock(pio_t pio)
|
|
{
|
|
int error = 1;
|
|
pio_sm_t sm;
|
|
for (pio_sm_t i = 0; i < PIO_SM_NUMOF; i++) {
|
|
if ((sm = pio_sm_lock(pio)) < 0) {
|
|
DEBUG_TEST_FAILED("Could not lock state machine %d", i);
|
|
goto CLEAN;
|
|
}
|
|
}
|
|
if (pio_sm_lock(pio) >= 0) {
|
|
DEBUG_TEST_FAILED("State machine impossibly locked");
|
|
goto CLEAN;
|
|
}
|
|
pio_sm_unlock(pio, sm);
|
|
if (sm != pio_sm_lock(pio)) {
|
|
DEBUG_TEST_FAILED("State machine could not be locked after unlock");
|
|
goto CLEAN;
|
|
}
|
|
error = 0;
|
|
CLEAN:
|
|
for (pio_sm_t i = 0; i < PIO_SM_NUMOF; i++) {
|
|
pio_sm_unlock(pio, i);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int _test_pio_sm_program_any(void)
|
|
{
|
|
int error = 1;
|
|
pio_t pio;
|
|
pio_sm_t sm;
|
|
pio_program_t pro = {.location = PIO_PROGRAM_NOT_LOADED, .instr_numof = PIO_INSTR_NUMOF};
|
|
if (pio_alloc_program_sm_lock_any(&pio, &sm, &pro)) {
|
|
DEBUG_TEST_FAILED("Could not allocate program for any state machine");
|
|
goto CLEAN;
|
|
}
|
|
error = 0;
|
|
CLEAN:
|
|
pio_sm_unlock(pio, sm);
|
|
pio_free_program(pio, &pro);
|
|
return error;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
int error = 0;
|
|
|
|
for (pio_t pio = 0; pio < PIO_NUMOF; pio++) {
|
|
error = _test_pio_alloc_and_free(pio) ? 1 : error;
|
|
error = _test_pio_sm_lock_unlock(pio) ? 1 : error;
|
|
}
|
|
error = _test_pio_sm_program_any() ? 1 : error;
|
|
|
|
puts(error ? "TEST FAILED!" : "TEST SUCCEEDED!");
|
|
return 0;
|
|
}
|