Nikita Shubin <nikita.shu...@maquefel.me> writes:
> From: Nikita Shubin <n.shu...@yadro.com>
>
> Signed-off-by: Nikita Shubin <n.shu...@yadro.com>
> ---
> tests/qtest/meson.build | 1 +
> tests/qtest/stm32-dma-test.c | 415 +++++++++++++++++++++++++++++++++++
> 2 files changed, 416 insertions(+)
> create mode 100644 tests/qtest/stm32-dma-test.c
>
> diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build
> index 5a8c1f102c..6c45692f9d 100644
> --- a/tests/qtest/meson.build
> +++ b/tests/qtest/meson.build
> @@ -240,6 +240,7 @@ qtests_arm = \
> (config_all_devices.has_key('CONFIG_TPM_TIS_I2C') ? ['tpm-tis-i2c-test'] :
> []) + \
> (config_all_devices.has_key('CONFIG_VEXPRESS') ? ['test-arm-mptimer'] :
> []) + \
> (config_all_devices.has_key('CONFIG_MICROBIT') ? ['microbit-test'] : []) +
> \
> + (config_all_devices.has_key('CONFIG_STM32F100_SOC') ? ['stm32-dma-test'] :
> []) + \
> (config_all_devices.has_key('CONFIG_STM32L4X5_SOC') ? qtests_stm32l4x5 :
> []) + \
> (config_all_devices.has_key('CONFIG_FSI_APB2OPB_ASPEED') ?
> ['aspeed_fsi-test'] : []) + \
> (config_all_devices.has_key('CONFIG_STM32L4X5_SOC') and
> diff --git a/tests/qtest/stm32-dma-test.c b/tests/qtest/stm32-dma-test.c
> new file mode 100644
> index 0000000000..74b81fa434
> --- /dev/null
> +++ b/tests/qtest/stm32-dma-test.c
> @@ -0,0 +1,415 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * QTest testcase for STM32 DMA engine.
> + *
> + * This includes STM32F1xxxx, STM32F2xxxx and GD32F30x
> + *
> + * Author: 2025 Nikita Shubin <n.shu...@yadro.com>
> + */
> +
> +#include "qemu/osdep.h"
> +#include "qemu/bitops.h"
> +#include "libqtest-single.h"
> +#include "libqos/libqos.h"
> +
> +/* Offsets in stm32vldiscovery platform: */
> +#define DMA_BASE 0x40020000
> +#define SRAM_BASE 0x20000000
> +
> +/* Global interrupt flag */
> +#define DMA_ISR_GIF BIT(0)
> +/* Full transfer finish */
> +#define DMA_ISR_TCIF BIT(1)
> +/* Half transfer finish */
> +#define DMA_ISR_HTIF BIT(2)
> +/* Transfer error */
> +#define DMA_ISR_TEIF BIT(3)
> +
> +/* Used register/fields definitions */
> +#define DMA_CCR(idx) (0x08 + 0x14 * idx)
> +#define DMA_CNDTR(idx) (0x0C + 0x14 * idx)
> +#define DMA_CPAR(idx) (0x10 + 0x14 * idx)
> +#define DMA_CMAR(idx) (0x14 + 0x14 * idx)
> +
> +#define DMA_MAX_CHAN 7
> +
> +/* Register offsets for a dma chan0 within a dma block. */
> +#define DMA_CHAN(_idx, _irq) \
> + { \
> + .ccr = DMA_CCR(_idx), \
> + .cndrt = DMA_CNDTR(_idx), \
> + .cpar = DMA_CPAR(_idx), \
> + .cmar = DMA_CMAR(_idx), \
> + .irq_line = _irq,\
> + }
> +
> +typedef struct DMAChan {
> + uint32_t ccr;
> + uint32_t cndrt;
> + uint32_t cpar;
> + uint32_t cmar;
> + uint8_t irq_line;
> +} DMAChan;
> +
> +const DMAChan dma_chans[] = {
> + DMA_CHAN(0, 11),
> + DMA_CHAN(1, 12),
> + DMA_CHAN(2, 12),
> + DMA_CHAN(3, 13),
> + DMA_CHAN(4, 14),
> + DMA_CHAN(5, 16),
> + DMA_CHAN(6, 17),
> +};
> +
> +/* Register offsets for a dma within a dma block. */
> +typedef struct DMA {
> + uint32_t base_addr;
> + uint32_t isr;
> + uint32_t ofcr;
> +} DMA;
> +
> +const DMA dma = {
> + .base_addr = DMA_BASE,
> + .isr = 0x00,
> + .ofcr = 0x04,
> +};
> +
> +typedef struct TestData {
> + QTestState *qts;
> + const DMA *dma;
> + const DMAChan *chans;
> +} TestData;
> +
> +#define NVIC_ISER 0xE000E100
> +#define NVIC_ISPR 0xE000E200
> +#define NVIC_ICPR 0xE000E280
> +
> +static void enable_nvic_irq(unsigned int n)
> +{
> + writel(NVIC_ISER, 1 << n);
> +}
> +
> +static void unpend_nvic_irq(unsigned int n)
> +{
> + writel(NVIC_ICPR, 1 << n);
> +}
> +
> +static bool check_nvic_pending(unsigned int n)
> +{
> + return readl(NVIC_ISPR) & (1 << n);
> +}
> +
> +static uint32_t dma_read(const TestData *td, uint32_t offset)
> +{
> + return qtest_readl(td->qts, td->dma->base_addr + offset);
> +}
> +
> +static void dma_write(const TestData *td, uint32_t offset, uint32_t value)
> +{
> + qtest_writel(td->qts, td->dma->base_addr + offset, value);
> +}
> +
> +static void dma_write_ofcr(const TestData *td, uint32_t value)
> +{
> + return dma_write(td, td->dma->ofcr, value);
> +}
> +
> +static uint32_t dma_read_isr(const TestData *td)
> +{
> + return dma_read(td, td->dma->isr);
> +}
> +
> +static void dma_write_ccr(const TestData *td, uint8_t idx, uint32_t value)
> +{
> + dma_write(td, td->chans[idx].ccr, value);
> +}
> +
> +static uint32_t dma_read_ccr(const TestData *td, uint8_t idx)
> +{
> + return dma_read(td, td->chans[idx].ccr);
> +}
> +
> +static void dma_write_cndrt(const TestData *td, uint8_t idx, uint32_t value)
> +{
> + dma_write(td, td->chans[idx].cndrt, value);
> +}
> +
> +static void dma_write_cpar(const TestData *td, uint8_t idx, uint32_t value)
> +{
> + dma_write(td, td->chans[idx].cpar, value);
> +}
> +
> +static void dma_write_cmar(const TestData *td, uint8_t idx, uint32_t value)
> +{
> + dma_write(td, td->chans[idx].cmar, value);
> +}
> +
> +static void test_m2m(gconstpointer test_data)
> +{
> + const TestData *td = test_data;
> + QTestState *s = td->qts;
> + const uint32_t patt_len = 0xff;
> + char *pattern_check = g_malloc(patt_len);
> + char *pattern = g_malloc(patt_len);
These^ two should be g_autofree.
> + uint8_t idx = 0;
> + uint32_t val;
> +
> + enable_nvic_irq(td->chans[idx].irq_line);
> + qtest_irq_intercept_in(global_qtest, "/machine/soc/dma[0]");
> +
> + /* write addr */
> + dma_write_cpar(td, idx, SRAM_BASE);
> + dma_write_cmar(td, idx, SRAM_BASE + patt_len);
> +
> + /* enable increment and M2M */
> + val = dma_read_ccr(td, idx);
> + val |= BIT(1); /* TCIE */
> + val |= BIT(6); /* PINC */
> + val |= BIT(7); /* MINC */
> + val |= BIT(14); /* M2M */
> + dma_write_ccr(td, idx, val);
> +
> + generate_pattern(pattern, patt_len, patt_len);
> + qtest_memwrite(s, SRAM_BASE, pattern, patt_len);
> +
> + dma_write_cndrt(td, idx, patt_len);
> +
> + val |= BIT(0); /* enable channel */
> + dma_write_ccr(td, idx, val);
> +
> + qtest_memread(s, SRAM_BASE + patt_len, pattern_check, patt_len);
> +
> + g_assert(memcmp(pattern, pattern_check, patt_len) == 0);
> +
> + g_assert_true(check_nvic_pending(td->chans[idx].irq_line));
> +}
> +
> +typedef struct width_pattern {
> + uint32_t src;
> + uint8_t swidth;
> + uint32_t dst;
> + uint8_t dwidth;
> +} width_pattern;
> +
> +static void test_width(gconstpointer test_data)
> +{
> + const width_pattern patterns[] = {
> + { 0xb0, 1, 0xb0, 1 },
> + { 0xb0, 1, 0x00b0, 2 },
> + { 0xb0, 1, 0x000000b0, 4 },
> + { 0xb1b0, 2, 0xb0, 1 },
> + { 0xb1b0, 2, 0xb1b0, 2 },
> + { 0xb1b0, 2, 0x0000b1b0, 4 },
> + { 0xb3b2b1b0, 4, 0xb0, 1 },
> + { 0xb3b2b1b0, 4, 0xb1b0, 2 },
> + { 0xb3b2b1b0, 4, 0xb3b2b1b0, 4 },
> + };
> +
> + const TestData *td = test_data;
> + QTestState *s = td->qts;
> + const uint32_t patt = 0xffffffff;
> + const uint32_t patt_len = 4;
> + uint32_t dst;
> + uint8_t idx = 0;
> + uint32_t val;
> +
> + qmp("{'execute':'system_reset' }");
These calls to qmp() all leak the response dict. You need to catch the
return value and unref.
QDict *response;
response = qmp("{'execute':'system_reset' }");
qobject_unref(response);
> +
> + /* write addr */
> + dma_write_cpar(td, idx, SRAM_BASE);
> + dma_write_cmar(td, idx, SRAM_BASE + patt_len);
> +
> + /* enable increment and M2M */
> + val = dma_read_ccr(td, idx);
> + val |= BIT(6); /* PINC */
> + val |= BIT(7); /* MINC */
> + val |= BIT(14); /* M2M */
> + dma_write_ccr(td, idx, val);
> +
> + for (int i = 0; i < ARRAY_SIZE(patterns); i++) {
> + /* fill destination and source with pattern */
> + qtest_memwrite(s, SRAM_BASE, &patt, patt_len);
> + qtest_memwrite(s, SRAM_BASE + patt_len, &patt, patt_len);
> +
> + qtest_memwrite(s, SRAM_BASE, &patterns[i].src, patterns[i].swidth);
> +
> + dma_write_cndrt(td, idx, 1);
> + val |= BIT(0); /* enable channel */
> + val = deposit32(val, 8, 2, patterns[i].swidth >> 1);
> + val = deposit32(val, 10, 2, patterns[i].dwidth >> 1);
> + dma_write_ccr(td, idx, val);
> +
> + qtest_memread(s, SRAM_BASE + patt_len, &dst, patterns[i].dwidth);
> +
> + g_assert(memcmp(&dst, &patterns[i].dst, patterns[i].dwidth) == 0);
> +
> + /* disable chan */
> + val &= ~BIT(0);
> + dma_write_ccr(td, idx, val);
> + }
> +}
> +
> +static void dma_set_irq(unsigned int idx, int num, int level)
> +{
> + g_autofree char *name = g_strdup_printf("/machine/soc/dma[%u]",
> + idx);
> + qtest_set_irq_in(global_qtest, name, NULL, num, level);
> +}
> +
> +static void test_triggers(gconstpointer test_data)
> +{
> + const TestData *td = test_data;
> + QTestState *s = td->qts;
> + const uint32_t patt = 0xffffffff;
> + const uint32_t patt_len = 4;
> + uint32_t dst;
> + uint32_t val;
> +
> + qmp("{'execute':'system_reset' }");
> +
> + for (int i = 0; i < ARRAY_SIZE(dma_chans); i++) {
> + qtest_memset(s, SRAM_BASE, 0, patt_len * 2);
> + qtest_memwrite(s, SRAM_BASE, &patt, patt_len);
> +
> + /* write addr */
> + dma_write_cpar(td, i, SRAM_BASE);
> + dma_write_cmar(td, i, SRAM_BASE + patt_len);
> +
> + val = dma_read_ccr(td, i);
> +
> + dma_write_cndrt(td, i, 1);
> + val |= BIT(0); /* enable channel */
> + val = deposit32(val, 8, 2, patt_len >> 1);
> + val = deposit32(val, 10, 2, patt_len >> 1);
> + dma_write_ccr(td, i, val);
> +
> + dma_set_irq(0, i, 1);
> +
> + qtest_memread(s, SRAM_BASE + patt_len, &dst, patt_len);
> +
> + g_assert(memcmp(&dst, &patt, patt_len) == 0);
> +
> + /* disable chan */
> + val &= ~BIT(0);
> + dma_write_ccr(td, i, val);
> + }
> +}
> +
> +static void test_interrupts(gconstpointer test_data)
> +{
> + const TestData *td = test_data;
> + const uint32_t patt_len = 1024;
> + uint8_t idx = 0;
> + uint32_t val;
> +
> + qmp("{'execute':'system_reset' }");
> +
> + enable_nvic_irq(td->chans[idx].irq_line);
> +
> + /* write addr */
> + dma_write_cpar(td, idx, SRAM_BASE);
> + dma_write_cmar(td, idx, SRAM_BASE + patt_len);
> +
> + /* write counter */
> + dma_write_cndrt(td, idx, 2);
> +
> + /* enable increment and M2M */
> + val = dma_read_ccr(td, idx);
> + val |= BIT(0); /* EN */
> + val |= BIT(1); /* TCIE */
> + val |= BIT(2); /* HTIE */
> + val |= BIT(3); /* TEIE */
> + val |= BIT(6); /* PINC */
> + val |= BIT(7); /* MINC */
> + dma_write_ccr(td, idx, val);
> +
> + /* Half-transfer */
> + dma_set_irq(0, idx, 1);
> + g_assert_true(check_nvic_pending(td->chans[idx].irq_line));
> + val = dma_read_isr(td);
> +
> + g_assert_true(val & DMA_ISR_GIF);
> + g_assert_true(val & DMA_ISR_HTIF);
> + unpend_nvic_irq(td->chans[idx].irq_line);
> +
> + dma_write_ofcr(td, 0xffffffff);
> + val = dma_read_isr(td);
> + g_assert_false(val & DMA_ISR_GIF);
> + g_assert_false(val & DMA_ISR_HTIF);
> +
> + /* Full-transfer */
> + dma_set_irq(0, idx, 1);
> + g_assert_true(check_nvic_pending(td->chans[idx].irq_line));
> + val = dma_read_isr(td);
> +
> + g_assert_true(val & DMA_ISR_GIF);
> + g_assert_true(val & DMA_ISR_HTIF);
> + g_assert_true(val & DMA_ISR_TCIF);
> + unpend_nvic_irq(td->chans[idx].irq_line);
> +
> + dma_write_ofcr(td, 0xffffffff);
> + val = dma_read_isr(td);
> + g_assert_false(val & DMA_ISR_GIF);
> + g_assert_false(val & DMA_ISR_HTIF);
> + g_assert_false(val & DMA_ISR_TCIF);
> +
> + /* Error-on-transfer */
> + val = dma_read_ccr(td, idx);
> + val &= ~BIT(0);
> + dma_write_ccr(td, idx, val);
> +
> + dma_write_cndrt(td, idx, 1);
> + dma_write_cpar(td, idx, 0xffffffff);
> +
> + val |= BIT(0);
> + dma_write_ccr(td, idx, val);
> +
> + dma_set_irq(0, idx, 1);
> + g_assert_true(check_nvic_pending(td->chans[idx].irq_line));
> + val = dma_read_isr(td);
> +
> + g_assert_true(val & DMA_ISR_GIF);
> + g_assert_true(val & DMA_ISR_TEIF);
> + unpend_nvic_irq(td->chans[idx].irq_line);
> +
> + dma_write_ofcr(td, 0xffffffff);
> + val = dma_read_isr(td);
> + g_assert_false(val & DMA_ISR_GIF);
> + g_assert_false(val & DMA_ISR_TEIF);
> +}
> +
> +static void stm32_add_test(const char *name, const TestData *td,
> + GTestDataFunc fn)
> +{
> + g_autofree char *full_name = g_strdup_printf(
> + "stm32_dma/%s", name);
> + qtest_add_data_func(full_name, td, fn);
> +}
> +
> +/* Convenience macro for adding a test with a predictable function name. */
> +#define add_test(name, td) stm32_add_test(#name, td, test_##name)
> +
> +int main(int argc, char **argv)
> +{
> + TestData testdata;
> + QTestState *s;
> + int ret;
> +
> + g_test_init(&argc, &argv, NULL);
> + s = qtest_start("-machine stm32vldiscovery");
> + g_test_set_nonfatal_assertions();
> +
> + TestData *td = &testdata;
> + td->qts = s;
> + td->dma = &dma;
> + td->chans = dma_chans;
> + add_test(m2m, td);
> + add_test(width, td);
> + add_test(triggers, td);
> + add_test(interrupts, td);
> +
> + ret = g_test_run();
> + qtest_end();
> +
> + return ret;
> +}
