#include <kunit/device.h>
#include <kunit/test.h>
#include <linux/dma-mapping.h>
#include <linux/limits.h>
#include <linux/spi/spi.h>
#include "../internals.h"
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
#define SPI_DMA_TEST_LEN 256
#define SPI_DMA_TEST_XFERS 2
struct spi_dma_test_ctx {
struct spi_controller *ctlr;
struct spi_device *spi;
struct device *dma_dev;
struct device *stale_dma_dev;
struct spi_transfer xfer[SPI_DMA_TEST_XFERS];
struct spi_message msg;
void *buf[SPI_DMA_TEST_XFERS * 2];
};
static bool spi_dma_test_can_dma(struct spi_controller *ctlr,
struct spi_device *spi,
struct spi_transfer *xfer)
{
return true;
}
static struct spi_dma_test_ctx *spi_dma_test_ctx_new(struct kunit *test)
{
struct spi_dma_test_ctx *ctx;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
ctx->dma_dev = kunit_device_register(test, "spi-dma-error-path");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->dma_dev);
ctx->stale_dma_dev =
kunit_device_register(test, "spi-dma-stale-device");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->stale_dma_dev);
KUNIT_ASSERT_EQ(test, 0,
dma_coerce_mask_and_coherent(ctx->dma_dev,
DMA_BIT_MASK(64)));
KUNIT_ASSERT_EQ(test, 0,
dma_coerce_mask_and_coherent(ctx->stale_dma_dev,
DMA_BIT_MASK(64)));
ctx->ctlr = kunit_kzalloc(test, sizeof(*ctx->ctlr), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->ctlr);
ctx->spi = kunit_kzalloc(test, sizeof(*ctx->spi), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->spi);
ctx->ctlr->can_dma = spi_dma_test_can_dma;
ctx->ctlr->dma_map_dev = ctx->dma_dev;
ctx->ctlr->max_dma_len = INT_MAX;
ctx->spi->controller = ctx->ctlr;
spi_message_init(&ctx->msg);
ctx->msg.spi = ctx->spi;
return ctx;
}
static void *spi_dma_test_buf(struct kunit *test, struct spi_dma_test_ctx *ctx,
unsigned int slot)
{
KUNIT_ASSERT_LT(test, slot, ARRAY_SIZE(ctx->buf));
ctx->buf[slot] = kunit_kzalloc(test, SPI_DMA_TEST_LEN, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->buf[slot]);
return ctx->buf[slot];
}
static void spi_dma_test_pin_stale_dma_devs(struct spi_dma_test_ctx *ctx)
{
ctx->ctlr->cur_tx_dma_dev = ctx->stale_dma_dev;
ctx->ctlr->cur_rx_dma_dev = ctx->stale_dma_dev;
}
static void spi_dma_test_assert_dma_devs_published(struct kunit *test,
struct spi_dma_test_ctx *ctx)
{
KUNIT_ASSERT_PTR_EQ(test, ctx->ctlr->cur_tx_dma_dev, ctx->dma_dev);
KUNIT_ASSERT_PTR_EQ(test, ctx->ctlr->cur_rx_dma_dev, ctx->dma_dev);
}
static void spi_dma_test_assert_nothing_mapped(struct kunit *test,
struct spi_dma_test_ctx *ctx,
unsigned int nr_xfers)
{
unsigned int i;
for (i = 0; i < nr_xfers; i++) {
KUNIT_ASSERT_FALSE_MSG(test, ctx->xfer[i].tx_sg_mapped,
"xfer[%u] still claims a TX mapping after __spi_map_msg() failed",
i);
KUNIT_ASSERT_FALSE_MSG(test, ctx->xfer[i].rx_sg_mapped,
"xfer[%u] still claims an RX mapping after __spi_map_msg() failed",
i);
KUNIT_EXPECT_NULL(test, ctx->xfer[i].tx_sg.sgl);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].tx_sg.orig_nents, 0U);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].tx_sg.nents, 0U);
KUNIT_EXPECT_NULL(test, ctx->xfer[i].rx_sg.sgl);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].rx_sg.orig_nents, 0U);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].rx_sg.nents, 0U);
}
}
static void spi_dma_later_tx_fail_rolls_back_earlier(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
ctx->xfer[1].tx_buf = spi_dma_test_buf(test, ctx, 2);
ctx->xfer[1].rx_buf = NULL;
ctx->xfer[1].len = 0;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
spi_message_add_tail(&ctx->xfer[1], &ctx->msg);
spi_dma_test_pin_stale_dma_devs(ctx);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, -EINVAL);
spi_dma_test_assert_dma_devs_published(test, ctx);
spi_dma_test_assert_nothing_mapped(test, ctx, SPI_DMA_TEST_XFERS);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
}
static void spi_dma_later_rx_fail_rolls_back_earlier(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
ctx->xfer[1].tx_buf = NULL;
ctx->xfer[1].rx_buf = spi_dma_test_buf(test, ctx, 2);
ctx->xfer[1].len = 0;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
spi_message_add_tail(&ctx->xfer[1], &ctx->msg);
spi_dma_test_pin_stale_dma_devs(ctx);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, -EINVAL);
spi_dma_test_assert_dma_devs_published(test, ctx);
spi_dma_test_assert_nothing_mapped(test, ctx, SPI_DMA_TEST_XFERS);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
}
static void spi_dma_map_success_publishes_dma_devs(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_EXPECT_TRUE(test, ctx->xfer[0].tx_sg_mapped);
KUNIT_EXPECT_TRUE(test, ctx->xfer[0].rx_sg_mapped);
KUNIT_EXPECT_PTR_EQ(test, ctx->ctlr->cur_tx_dma_dev, ctx->dma_dev);
KUNIT_EXPECT_PTR_EQ(test, ctx->ctlr->cur_rx_dma_dev, ctx->dma_dev);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
KUNIT_EXPECT_FALSE(test, ctx->xfer[0].tx_sg_mapped);
KUNIT_EXPECT_FALSE(test, ctx->xfer[0].rx_sg_mapped);
KUNIT_EXPECT_NULL(test, ctx->xfer[0].tx_sg.sgl);
KUNIT_EXPECT_NULL(test, ctx->xfer[0].rx_sg.sgl);
}
static void spi_dma_map_nothing_is_success(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = NULL;
ctx->xfer[0].rx_buf = NULL;
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_EXPECT_EQ(test, ret, 0);
spi_dma_test_assert_nothing_mapped(test, ctx, 1);
}
static struct kunit_case spi_dma_error_path_cases[] = {
KUNIT_CASE(spi_dma_later_tx_fail_rolls_back_earlier),
KUNIT_CASE(spi_dma_later_rx_fail_rolls_back_earlier),
KUNIT_CASE(spi_dma_map_success_publishes_dma_devs),
KUNIT_CASE(spi_dma_map_nothing_is_success),
{}
};
static struct kunit_suite spi_dma_error_path_suite = {
.name = "spi_dma",
.test_cases = spi_dma_error_path_cases,
};
kunit_test_suite(spi_dma_error_path_suite);
MODULE_DESCRIPTION("KUnit tests for SPI core DMA mapping");
MODULE_LICENSE("GPL"