From 15b8a8ea1a87313f1b46ea878c65942fd52147ed Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Mon, 4 Mar 2013 11:09:29 +0200 Subject: [PATCH] dmatest: split test parameters to separate structure Better to keep test parameters separate from internal variables. Signed-off-by: Andy Shevchenko Acked-by: Viresh Kumar Signed-off-by: Vinod Koul --- drivers/dma/dmatest.c | 109 ++++++++++++++++++++++++------------------ 1 file changed, 62 insertions(+), 47 deletions(-) diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c index 475a21ad6657..c6e5d8331c66 100644 --- a/drivers/dma/dmatest.c +++ b/drivers/dma/dmatest.c @@ -97,7 +97,7 @@ struct dmatest_chan { }; /** - * struct dmatest_info - test information. + * struct dmatest_params - test parameters. * @buf_size: size of the memcpy test buffer * @channel: bus ID of the channel to test * @device: bus ID of the DMA Engine to test @@ -108,8 +108,7 @@ struct dmatest_chan { * @pq_sources: number of p+q source buffers * @timeout: transfer timeout in msec, -1 for infinite timeout */ -struct dmatest_info { - /* Test parameters */ +struct dmatest_params { unsigned int buf_size; char channel[20]; char device[20]; @@ -119,6 +118,15 @@ struct dmatest_info { unsigned int xor_sources; unsigned int pq_sources; int timeout; +}; + +/** + * struct dmatest_info - test information. + * @params: test parameters + */ +struct dmatest_info { + /* Test parameters */ + struct dmatest_params params; /* Internal state */ struct list_head channels; @@ -127,20 +135,20 @@ struct dmatest_info { static struct dmatest_info test_info; -static bool dmatest_match_channel(struct dmatest_info *info, +static bool dmatest_match_channel(struct dmatest_params *params, struct dma_chan *chan) { - if (info->channel[0] == '\0') + if (params->channel[0] == '\0') return true; - return strcmp(dma_chan_name(chan), info->channel) == 0; + return strcmp(dma_chan_name(chan), params->channel) == 0; } -static bool dmatest_match_device(struct dmatest_info *info, +static bool dmatest_match_device(struct dmatest_params *params, struct dma_device *device) { - if (info->device[0] == '\0') + if (params->device[0] == '\0') return true; - return strcmp(dev_name(device->dev), info->device) == 0; + return strcmp(dev_name(device->dev), params->device) == 0; } static unsigned long dmatest_random(void) @@ -300,6 +308,7 @@ static int dmatest_func(void *data) struct dmatest_thread *thread = data; struct dmatest_done done = { .wait = &done_wait }; struct dmatest_info *info; + struct dmatest_params *params; struct dma_chan *chan; struct dma_device *dev; const char *thread_name; @@ -323,20 +332,21 @@ static int dmatest_func(void *data) smp_rmb(); info = thread->info; + params = &info->params; chan = thread->chan; dev = chan->device; if (thread->type == DMA_MEMCPY) src_cnt = dst_cnt = 1; else if (thread->type == DMA_XOR) { /* force odd to ensure dst = src */ - src_cnt = min_odd(info->xor_sources | 1, dev->max_xor); + src_cnt = min_odd(params->xor_sources | 1, dev->max_xor); dst_cnt = 1; } else if (thread->type == DMA_PQ) { /* force odd to ensure dst = src */ - src_cnt = min_odd(info->pq_sources | 1, dma_maxpq(dev, 0)); + src_cnt = min_odd(params->pq_sources | 1, dma_maxpq(dev, 0)); dst_cnt = 2; - pq_coefs = kmalloc(info->pq_sources+1, GFP_KERNEL); + pq_coefs = kmalloc(params->pq_sources+1, GFP_KERNEL); if (!pq_coefs) goto err_thread_type; @@ -349,7 +359,7 @@ static int dmatest_func(void *data) if (!thread->srcs) goto err_srcs; for (i = 0; i < src_cnt; i++) { - thread->srcs[i] = kmalloc(info->buf_size, GFP_KERNEL); + thread->srcs[i] = kmalloc(params->buf_size, GFP_KERNEL); if (!thread->srcs[i]) goto err_srcbuf; } @@ -359,7 +369,7 @@ static int dmatest_func(void *data) if (!thread->dsts) goto err_dsts; for (i = 0; i < dst_cnt; i++) { - thread->dsts[i] = kmalloc(info->buf_size, GFP_KERNEL); + thread->dsts[i] = kmalloc(params->buf_size, GFP_KERNEL); if (!thread->dsts[i]) goto err_dstbuf; } @@ -375,7 +385,7 @@ static int dmatest_func(void *data) | DMA_COMPL_SKIP_DEST_UNMAP | DMA_COMPL_SRC_UNMAP_SINGLE; while (!kthread_should_stop() - && !(info->iterations && total_tests >= info->iterations)) { + && !(params->iterations && total_tests >= params->iterations)) { struct dma_async_tx_descriptor *tx = NULL; dma_addr_t dma_srcs[src_cnt]; dma_addr_t dma_dsts[dst_cnt]; @@ -391,24 +401,24 @@ static int dmatest_func(void *data) else if (thread->type == DMA_PQ) align = dev->pq_align; - if (1 << align > info->buf_size) { + if (1 << align > params->buf_size) { pr_err("%u-byte buffer too small for %d-byte alignment\n", - info->buf_size, 1 << align); + params->buf_size, 1 << align); break; } - len = dmatest_random() % info->buf_size + 1; + len = dmatest_random() % params->buf_size + 1; len = (len >> align) << align; if (!len) len = 1 << align; - src_off = dmatest_random() % (info->buf_size - len + 1); - dst_off = dmatest_random() % (info->buf_size - len + 1); + src_off = dmatest_random() % (params->buf_size - len + 1); + dst_off = dmatest_random() % (params->buf_size - len + 1); src_off = (src_off >> align) << align; dst_off = (dst_off >> align) << align; - dmatest_init_srcs(thread->srcs, src_off, len, info->buf_size); - dmatest_init_dsts(thread->dsts, dst_off, len, info->buf_size); + dmatest_init_srcs(thread->srcs, src_off, len, params->buf_size); + dmatest_init_dsts(thread->dsts, dst_off, len, params->buf_size); for (i = 0; i < src_cnt; i++) { u8 *buf = thread->srcs[i] + src_off; @@ -429,16 +439,17 @@ static int dmatest_func(void *data) /* map with DMA_BIDIRECTIONAL to force writeback/invalidate */ for (i = 0; i < dst_cnt; i++) { dma_dsts[i] = dma_map_single(dev->dev, thread->dsts[i], - info->buf_size, + params->buf_size, DMA_BIDIRECTIONAL); ret = dma_mapping_error(dev->dev, dma_dsts[i]); if (ret) { unmap_src(dev->dev, dma_srcs, len, src_cnt); - unmap_dst(dev->dev, dma_dsts, info->buf_size, i); + unmap_dst(dev->dev, dma_dsts, params->buf_size, + i); pr_warn("%s: #%u: mapping error %d with " "dst_off=0x%x len=0x%x\n", thread_name, total_tests - 1, ret, - dst_off, info->buf_size); + dst_off, params->buf_size); failed_tests++; continue; } @@ -466,7 +477,8 @@ static int dmatest_func(void *data) if (!tx) { unmap_src(dev->dev, dma_srcs, len, src_cnt); - unmap_dst(dev->dev, dma_dsts, info->buf_size, dst_cnt); + unmap_dst(dev->dev, dma_dsts, params->buf_size, + dst_cnt); pr_warning("%s: #%u: prep error with src_off=0x%x " "dst_off=0x%x len=0x%x\n", thread_name, total_tests - 1, @@ -494,7 +506,7 @@ static int dmatest_func(void *data) wait_event_freezable_timeout(done_wait, done.done || kthread_should_stop(), - msecs_to_jiffies(info->timeout)); + msecs_to_jiffies(params->timeout)); status = dma_async_is_tx_complete(chan, cookie, NULL, NULL); @@ -521,7 +533,7 @@ static int dmatest_func(void *data) } /* Unmap by myself (see DMA_COMPL_SKIP_DEST_UNMAP above) */ - unmap_dst(dev->dev, dma_dsts, info->buf_size, dst_cnt); + unmap_dst(dev->dev, dma_dsts, params->buf_size, dst_cnt); error_count = 0; @@ -532,7 +544,7 @@ static int dmatest_func(void *data) src_off + len, src_off, PATTERN_SRC | PATTERN_COPY, true); error_count += dmatest_verify(thread->srcs, src_off + len, - info->buf_size, src_off + len, + params->buf_size, src_off + len, PATTERN_SRC, true); pr_debug("%s: verifying dest buffer...\n", @@ -543,7 +555,7 @@ static int dmatest_func(void *data) dst_off + len, src_off, PATTERN_SRC | PATTERN_COPY, false); error_count += dmatest_verify(thread->dsts, dst_off + len, - info->buf_size, dst_off + len, + params->buf_size, dst_off + len, PATTERN_DST, false); if (error_count) { @@ -580,7 +592,7 @@ err_thread_type: if (ret) dmaengine_terminate_all(chan); - if (info->iterations > 0) + if (params->iterations > 0) while (!kthread_should_stop()) { DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wait_dmatest_exit); interruptible_sleep_on(&wait_dmatest_exit); @@ -612,6 +624,7 @@ static void dmatest_cleanup_channel(struct dmatest_chan *dtc) static int dmatest_add_threads(struct dmatest_info *info, struct dmatest_chan *dtc, enum dma_transaction_type type) { + struct dmatest_params *params = &info->params; struct dmatest_thread *thread; struct dma_chan *chan = dtc->chan; char *op; @@ -626,7 +639,7 @@ static int dmatest_add_threads(struct dmatest_info *info, else return -EINVAL; - for (i = 0; i < info->threads_per_chan; i++) { + for (i = 0; i < params->threads_per_chan; i++) { thread = kzalloc(sizeof(struct dmatest_thread), GFP_KERNEL); if (!thread) { pr_warning("dmatest: No memory for %s-%s%u\n", @@ -696,10 +709,10 @@ static int dmatest_add_channel(struct dmatest_info *info, static bool filter(struct dma_chan *chan, void *param) { - struct dmatest_info *info = param; + struct dmatest_params *params = param; - if (!dmatest_match_channel(info, chan) || - !dmatest_match_device(info, chan->device)) + if (!dmatest_match_channel(params, chan) || + !dmatest_match_device(params, chan->device)) return false; else return true; @@ -709,12 +722,13 @@ static int run_threaded_test(struct dmatest_info *info) { dma_cap_mask_t mask; struct dma_chan *chan; + struct dmatest_params *params = &info->params; int err = 0; dma_cap_zero(mask); dma_cap_set(DMA_MEMCPY, mask); for (;;) { - chan = dma_request_channel(mask, filter, info); + chan = dma_request_channel(mask, filter, params); if (chan) { err = dmatest_add_channel(info, chan); if (err) { @@ -723,8 +737,8 @@ static int run_threaded_test(struct dmatest_info *info) } } else break; /* no more channels available */ - if (info->max_channels && - info->nr_channels >= info->max_channels) + if (params->max_channels && + info->nr_channels >= params->max_channels) break; /* we have all we need */ } return err; @@ -749,21 +763,22 @@ static void stop_threaded_test(struct dmatest_info *info) static int __init dmatest_init(void) { struct dmatest_info *info = &test_info; + struct dmatest_params *params = &info->params; memset(info, 0, sizeof(*info)); INIT_LIST_HEAD(&info->channels); /* Set default parameters */ - info->buf_size = test_buf_size; - strlcpy(info->channel, test_channel, sizeof(info->channel)); - strlcpy(info->device, test_device, sizeof(info->device)); - info->threads_per_chan = threads_per_chan; - info->max_channels = max_channels; - info->iterations = iterations; - info->xor_sources = xor_sources; - info->pq_sources = pq_sources; - info->timeout = timeout; + params->buf_size = test_buf_size; + strlcpy(params->channel, test_channel, sizeof(params->channel)); + strlcpy(params->device, test_device, sizeof(params->device)); + params->threads_per_chan = threads_per_chan; + params->max_channels = max_channels; + params->iterations = iterations; + params->xor_sources = xor_sources; + params->pq_sources = pq_sources; + params->timeout = timeout; return run_threaded_test(info); } -- 2.20.1