Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757137AbXKWPfG (ORCPT ); Fri, 23 Nov 2007 10:35:06 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1756062AbXKWPez (ORCPT ); Fri, 23 Nov 2007 10:34:55 -0500 Received: from nat-132.atmel.no ([80.232.32.132]:57926 "EHLO relay.atmel.no" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1756057AbXKWPey (ORCPT ); Fri, 23 Nov 2007 10:34:54 -0500 From: Haavard Skinnemoen To: Shannon Nelson Cc: Dan Williams , linux-kernel@vger.kernel.org, Olof Johansson , Sam Ravnborg , Haavard Skinnemoen Subject: [PATCH v2] dmaengine: Simple DMA memcpy test client Date: Fri, 23 Nov 2007 16:34:36 +0100 Message-Id: <1195832076-13022-1-git-send-email-hskinnemoen@atmel.com> X-Mailer: git-send-email 1.5.3.4 Sender: linux-kernel-owner@vger.kernel.org X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 10085 Lines: 373 This client tests DMA memcpy using various lengths and various offsets into the source and destination buffers. It will initialize both buffers with a know pattern and verify that the DMA engine copies the requested region and nothing more. Signed-off-by: Haavard Skinnemoen --- Changes since v1: * Remove extra dashes around "help" in Kconfig * Remove "default n" from Kconfig * Turn TEST_BUF_SIZE into a module parameter * Return DMA_NAK instead of DMA_DUP * Print unhandled events * Support testing specific channels and devices * Move to the end of the Makefile Big thanks to Sam Ravnborg and Shannon Nelson for feedback. I haven't added support for testing multiple channels at once, or for testing a single channel using multiple threads. It will be a rather big change, but I think it might be worth it since it will make the module much better at catching nasty race conditions in the DMA Engine driver. drivers/dma/Kconfig | 7 + drivers/dma/Makefile | 1 + drivers/dma/dmatest.c | 304 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 312 insertions(+), 0 deletions(-) create mode 100644 drivers/dma/dmatest.c diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig index 6a7d25f..3bb9f2c 100644 --- a/drivers/dma/Kconfig +++ b/drivers/dma/Kconfig @@ -49,4 +49,11 @@ config NET_DMA Since this is the main user of the DMA engine, it should be enabled; say Y here. +config DMATEST + tristate "DMA Test client" + depends on DMA_ENGINE + help + Simple DMA test client. Say N unless you're debugging a + DMA Device driver. + endif diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile index b152cd8..cecfb60 100644 --- a/drivers/dma/Makefile +++ b/drivers/dma/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_NET_DMA) += iovlock.o obj-$(CONFIG_INTEL_IOATDMA) += ioatdma.o ioatdma-objs := ioat.o ioat_dma.o ioat_dca.o obj-$(CONFIG_INTEL_IOP_ADMA) += iop-adma.o +obj-$(CONFIG_DMATEST) += dmatest.o diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c new file mode 100644 index 0000000..523ee93 --- /dev/null +++ b/drivers/dma/dmatest.c @@ -0,0 +1,304 @@ +/* + * DMA Engine test module + * + * Copyright (C) 2007 Atmel Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +static unsigned int test_buf_size = 16384; +module_param(test_buf_size, uint, S_IRUGO); +MODULE_PARM_DESC(test_buf_size, "Size of the memcpy test buffer"); + +static char test_channel[BUS_ID_SIZE]; +module_param_string(channel, test_channel, sizeof(test_channel), S_IRUGO); +MODULE_PARM_DESC(channel, "Bus ID of the channel to test (default: any)"); + +static char test_device[BUS_ID_SIZE]; +module_param_string(device, test_device, sizeof(test_device), S_IRUGO); +MODULE_PARM_DESC(device, "Bus ID of the DMA Engine to test (default: any)"); + +#define SRC_PATTERN 0x7c +#define SRC_PATTERN_OUTSIDE 0X8d +#define POISON_UNINIT 0x49 +#define POISON_OUTSIDE 0x37 + +struct dmatest { + spinlock_t lock; + struct dma_client client; + struct task_struct *thread; + struct dma_chan *chan; + wait_queue_head_t wq; + u8 *srcbuf; + u8 *dstbuf; +}; + +static inline struct dmatest *to_dmatest(struct dma_client *client) +{ + return container_of(client, struct dmatest, client); +} + +static bool dmatest_match_channel(struct dma_chan *chan) +{ + if (test_channel[0] == '\0') + return true; + return strcmp(chan->dev.bus_id, test_channel) == 0; +} + +static bool dmatest_match_device(struct dma_device *device) +{ + if (test_device[0] == '\0') + return true; + return strcmp(device->dev->bus_id, test_device) == 0; +} + +static enum dma_state_client +dmatest_event(struct dma_client *client, struct dma_chan *chan, + enum dma_state state) +{ + struct dmatest *test = to_dmatest(client); + enum dma_state_client ack = DMA_NAK; + + spin_lock(&test->lock); + switch (state) { + case DMA_RESOURCE_AVAILABLE: + if (test->chan) { + ack = DMA_NAK; + } else if (dmatest_match_channel(chan) + && dmatest_match_device(chan->device)) { + printk(KERN_INFO "dmatest: Got channel %s\n", + chan->dev.bus_id); + test->chan = chan; + wake_up_interruptible(&test->wq); + ack = DMA_ACK; + } else { + ack = DMA_DUP; + } + break; + + case DMA_RESOURCE_REMOVED: + if (test->chan == chan) { + printk(KERN_INFO "dmatest: Lost channel %s\n", + chan->dev.bus_id); + test->chan = NULL; + ack = DMA_ACK; + } + break; + + default: + printk(KERN_INFO "dmatest: Unhandled event %u (%s)\n", + state, chan->dev.bus_id); + break; + } + spin_unlock(&test->lock); + + return ack; +} + +static unsigned long dmatest_random(void) +{ + unsigned long buf; + + get_random_bytes(&buf, sizeof(buf)); + return buf; +} + +static unsigned int dmatest_verify(u8 *buf, unsigned int start, + unsigned int end, u8 expected) +{ + unsigned int i; + unsigned int error_count = 0; + + for (i = start; i < end; i++) { + if (buf[i] != expected) { + if (error_count < 32) + printk(KERN_ERR "dmatest: buf[0x%x] = %02x " + "(expected %02x)\n", + i, buf[i], expected); + error_count++; + } + } + + if (error_count > 32) + printk(KERN_ERR "dmatest: %u errors suppressed\n", + error_count - 32); + + return error_count; +} + +static int dmatest_func(void *data) +{ + struct dmatest *test = data; + struct dma_chan *chan; + bool should_stop = false; + unsigned int src_off, dst_off, len; + unsigned int error_count; + dma_cookie_t cookie; + enum dma_status status; + + dma_cap_set(DMA_MEMCPY, test->client.cap_mask); + dma_async_client_register(&test->client); + dma_async_client_chan_request(&test->client); + + for (;;) { + DEFINE_WAIT(chan_wait); + + pr_debug("dmatest: Waiting for a channel...\n"); + for (;;) { + spin_lock(&test->lock); + prepare_to_wait(&test->wq, &chan_wait, + TASK_UNINTERRUPTIBLE); + if (kthread_should_stop()) { + should_stop = true; + break; + } + + if (test->chan) { + chan = test->chan; + dma_chan_get(chan); + break; + } + spin_unlock(&test->lock); + + schedule(); + } + finish_wait(&test->wq, &chan_wait); + spin_unlock(&test->lock); + + if (should_stop) + break; + + pr_debug("dmatest: Got it!\n"); + + len = dmatest_random() % test_buf_size; + src_off = dmatest_random() % (test_buf_size - len); + dst_off = dmatest_random() % (test_buf_size - len); + + memset(test->srcbuf, SRC_PATTERN_OUTSIDE, src_off); + memset(test->srcbuf + src_off, SRC_PATTERN, len); + memset(test->srcbuf + src_off + len, SRC_PATTERN_OUTSIDE, + test_buf_size - (src_off + len)); + memset(test->dstbuf, POISON_OUTSIDE, dst_off); + memset(test->dstbuf + dst_off, POISON_UNINIT, len); + memset(test->dstbuf + dst_off + len, POISON_OUTSIDE, + test_buf_size - (dst_off + len)); + + cookie = dma_async_memcpy_buf_to_buf(chan, + test->dstbuf + dst_off, + test->srcbuf + src_off, + len); + if (dma_submit_error(cookie)) { + printk("dmatest: submit error: %d\n", cookie); + dma_chan_put(chan); + msleep(100); + continue; + } + dma_async_memcpy_issue_pending(chan); + + do { + msleep(1); + status = dma_async_memcpy_complete( + chan, cookie, NULL, NULL); + } while (status == DMA_IN_PROGRESS); + + dma_chan_put(chan); + + if (status == DMA_ERROR) { + printk("dmatest: error during copy\n"); + continue; + } + + error_count = 0; + + printk(KERN_INFO "dmatest: verifying source buffer...\n"); + error_count += dmatest_verify(test->srcbuf, 0, src_off, + SRC_PATTERN_OUTSIDE); + error_count += dmatest_verify(test->srcbuf, src_off, + src_off + len, SRC_PATTERN); + error_count += dmatest_verify(test->srcbuf, src_off + len, + test_buf_size, SRC_PATTERN_OUTSIDE); + + printk(KERN_INFO "dmatest: verifying dest buffer...\n"); + error_count += dmatest_verify(test->dstbuf, 0, dst_off, + POISON_OUTSIDE); + error_count += dmatest_verify(test->dstbuf, dst_off, + dst_off + len, SRC_PATTERN); + error_count += dmatest_verify(test->dstbuf, dst_off + len, + test_buf_size, POISON_OUTSIDE); + + if (error_count) + printk(KERN_ERR "dmatest: %u errors with " + "src_off=0x%x dst_off=0x%x len=0x%x\n", + error_count, src_off, dst_off, len); + else + printk(KERN_INFO "dmatest: No errors with " + "src_off=0x%x dst_off=0x%x len=0x%x\n", + src_off, dst_off, len); + } + + dma_async_client_unregister(&test->client); + + return 0; +} + +static struct dmatest dmatest_data = { + .client = { + .event_callback = dmatest_event, + }, + .wq = __WAIT_QUEUE_HEAD_INITIALIZER(dmatest_data.wq), +}; + +static int __init dmatest_init(void) +{ + struct dmatest *test = &dmatest_data; + int ret = -ENOMEM; + + spin_lock_init(&test->lock); + + test->srcbuf = kmalloc(test_buf_size, GFP_KERNEL); + if (!test->srcbuf) + goto err_srcbuf; + test->dstbuf = kmalloc(test_buf_size, GFP_KERNEL); + if (!test->dstbuf) + goto err_dstbuf; + + test->thread = kthread_run(dmatest_func, test, "kdmatestd"); + if (IS_ERR(test->thread)) { + ret = PTR_ERR(test->thread); + goto err_kthread; + } + + return 0; + +err_kthread: + kfree(test->dstbuf); +err_dstbuf: + kfree(test->srcbuf); +err_srcbuf: + return ret; +} +module_init(dmatest_init); + +static void __exit dmatest_exit(void) +{ + int ret; + + ret = kthread_stop(dmatest_data.thread); + printk("dmatest: Thread exited with status %d\n", ret); + kfree(dmatest_data.srcbuf); + kfree(dmatest_data.dstbuf); +} +module_exit(dmatest_exit); + +MODULE_AUTHOR("Haavard Skinnemoen "); +MODULE_LICENSE("GPL v2"); -- 1.5.3.4 - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/