From 361deb7243d275ba8ce6e27db7727fce6fd39f3e Mon Sep 17 00:00:00 2001 From: Alexandru Ardelean Date: Tue, 12 Feb 2019 17:11:37 +0200 Subject: dmaengine: dmatest: wrap src & dst data into a struct This change wraps the data for the source & destination buffers into a `struct dmatest_data`. The rename patterns are: * src_cnt -> src->cnt * dst_cnt -> dst->cnt * src_off -> src->off * dst_off -> dst->off * thread->srcs -> src->aligned * thread->usrcs -> src->raw * thread->dsts -> dst->aligned * thread->udsts -> dst->raw The intent is to make a function that moves duplicate parts of the code into common alloc & free functions, which will unclutter the `dmatest_func()` function. Signed-off-by: Alexandru Ardelean Signed-off-by: Vinod Koul --- drivers/dma/dmatest.c | 195 ++++++++++++++++++++++++++------------------------ 1 file changed, 101 insertions(+), 94 deletions(-) (limited to 'drivers/dma/dmatest.c') diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c index 2eea4ef72915..ea1f885e70f4 100644 --- a/drivers/dma/dmatest.c +++ b/drivers/dma/dmatest.c @@ -200,15 +200,20 @@ struct dmatest_done { wait_queue_head_t *wait; }; +struct dmatest_data { + u8 **raw; + u8 **aligned; + unsigned int cnt; + unsigned int off; +}; + struct dmatest_thread { struct list_head node; struct dmatest_info *info; struct task_struct *task; struct dma_chan *chan; - u8 **srcs; - u8 **usrcs; - u8 **dsts; - u8 **udsts; + struct dmatest_data src; + struct dmatest_data dst; enum dma_transaction_type type; wait_queue_head_t done_wait; struct dmatest_done test_done; @@ -511,8 +516,8 @@ static int dmatest_func(void *data) enum dma_ctrl_flags flags; u8 *pq_coefs = NULL; int ret; - int src_cnt; - int dst_cnt; + struct dmatest_data *src; + struct dmatest_data *dst; int i; ktime_t ktime, start, diff; ktime_t filltime = 0; @@ -535,25 +540,27 @@ static int dmatest_func(void *data) params = &info->params; chan = thread->chan; dev = chan->device; + src = &thread->src; + dst = &thread->dst; if (thread->type == DMA_MEMCPY) { align = params->alignment < 0 ? dev->copy_align : params->alignment; - src_cnt = dst_cnt = 1; + src->cnt = dst->cnt = 1; } else if (thread->type == DMA_MEMSET) { align = params->alignment < 0 ? dev->fill_align : params->alignment; - src_cnt = dst_cnt = 1; + src->cnt = dst->cnt = 1; is_memset = true; } else if (thread->type == DMA_XOR) { /* force odd to ensure dst = src */ - src_cnt = min_odd(params->xor_sources | 1, dev->max_xor); - dst_cnt = 1; + src->cnt = min_odd(params->xor_sources | 1, dev->max_xor); + dst->cnt = 1; align = params->alignment < 0 ? dev->xor_align : params->alignment; } else if (thread->type == DMA_PQ) { /* force odd to ensure dst = src */ - src_cnt = min_odd(params->pq_sources | 1, dma_maxpq(dev, 0)); - dst_cnt = 2; + src->cnt = min_odd(params->pq_sources | 1, dma_maxpq(dev, 0)); + dst->cnt = 2; align = params->alignment < 0 ? dev->pq_align : params->alignment; @@ -561,15 +568,15 @@ static int dmatest_func(void *data) if (!pq_coefs) goto err_thread_type; - for (i = 0; i < src_cnt; i++) + for (i = 0; i < src->cnt; i++) pq_coefs[i] = 1; } else goto err_thread_type; /* Check if buffer count fits into map count variable (u8) */ - if ((src_cnt + dst_cnt) >= 255) { + if ((src->cnt + dst->cnt) >= 255) { pr_err("too many buffers (%d of 255 supported)\n", - src_cnt + dst_cnt); + src->cnt + dst->cnt); goto err_free_coefs; } @@ -579,57 +586,57 @@ static int dmatest_func(void *data) goto err_free_coefs; } - thread->srcs = kcalloc(src_cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!thread->srcs) + src->aligned = kcalloc(src->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!src->aligned) goto err_free_coefs; - thread->usrcs = kcalloc(src_cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!thread->usrcs) + src->raw = kcalloc(src->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!src->raw) goto err_usrcs; - for (i = 0; i < src_cnt; i++) { - thread->usrcs[i] = kmalloc(params->buf_size + align, + for (i = 0; i < src->cnt; i++) { + src->raw[i] = kmalloc(params->buf_size + align, GFP_KERNEL); - if (!thread->usrcs[i]) + if (!src->raw[i]) goto err_srcbuf; /* align srcs to alignment restriction */ if (align) - thread->srcs[i] = PTR_ALIGN(thread->usrcs[i], align); + src->aligned[i] = PTR_ALIGN(src->raw[i], align); else - thread->srcs[i] = thread->usrcs[i]; + src->aligned[i] = src->raw[i]; } - thread->srcs[i] = NULL; + src->aligned[i] = NULL; - thread->dsts = kcalloc(dst_cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!thread->dsts) + dst->aligned = kcalloc(dst->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!dst->aligned) goto err_dsts; - thread->udsts = kcalloc(dst_cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!thread->udsts) + dst->raw = kcalloc(dst->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!dst->raw) goto err_udsts; - for (i = 0; i < dst_cnt; i++) { - thread->udsts[i] = kmalloc(params->buf_size + align, + for (i = 0; i < dst->cnt; i++) { + dst->raw[i] = kmalloc(params->buf_size + align, GFP_KERNEL); - if (!thread->udsts[i]) + if (!dst->raw[i]) goto err_dstbuf; /* align dsts to alignment restriction */ if (align) - thread->dsts[i] = PTR_ALIGN(thread->udsts[i], align); + dst->aligned[i] = PTR_ALIGN(dst->raw[i], align); else - thread->dsts[i] = thread->udsts[i]; + dst->aligned[i] = dst->raw[i]; } - thread->dsts[i] = NULL; + dst->aligned[i] = NULL; set_user_nice(current, 10); - srcs = kcalloc(src_cnt, sizeof(dma_addr_t), GFP_KERNEL); + srcs = kcalloc(src->cnt, sizeof(dma_addr_t), GFP_KERNEL); if (!srcs) goto err_dstbuf; - dma_pq = kcalloc(dst_cnt, sizeof(dma_addr_t), GFP_KERNEL); + dma_pq = kcalloc(dst->cnt, sizeof(dma_addr_t), GFP_KERNEL); if (!dma_pq) goto err_srcs_array; @@ -644,7 +651,7 @@ static int dmatest_func(void *data) struct dma_async_tx_descriptor *tx = NULL; struct dmaengine_unmap_data *um; dma_addr_t *dsts; - unsigned int src_off, dst_off, len; + unsigned int len; total_tests++; @@ -670,59 +677,59 @@ static int dmatest_func(void *data) total_len += len; if (params->norandom) { - src_off = 0; - dst_off = 0; + src->off = 0; + dst->off = 0; } else { - src_off = dmatest_random() % (params->buf_size - len + 1); - dst_off = dmatest_random() % (params->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; + src->off = (src->off >> align) << align; + dst->off = (dst->off >> align) << align; } if (!params->noverify) { start = ktime_get(); - dmatest_init_srcs(thread->srcs, src_off, len, + dmatest_init_srcs(src->aligned, src->off, len, params->buf_size, is_memset); - dmatest_init_dsts(thread->dsts, dst_off, len, + dmatest_init_dsts(dst->aligned, dst->off, len, params->buf_size, is_memset); diff = ktime_sub(ktime_get(), start); filltime = ktime_add(filltime, diff); } - um = dmaengine_get_unmap_data(dev->dev, src_cnt + dst_cnt, + um = dmaengine_get_unmap_data(dev->dev, src->cnt + dst->cnt, GFP_KERNEL); if (!um) { failed_tests++; result("unmap data NULL", total_tests, - src_off, dst_off, len, ret); + src->off, dst->off, len, ret); continue; } um->len = params->buf_size; - for (i = 0; i < src_cnt; i++) { - void *buf = thread->srcs[i]; + for (i = 0; i < src->cnt; i++) { + void *buf = src->aligned[i]; struct page *pg = virt_to_page(buf); unsigned long pg_off = offset_in_page(buf); um->addr[i] = dma_map_page(dev->dev, pg, pg_off, um->len, DMA_TO_DEVICE); - srcs[i] = um->addr[i] + src_off; + srcs[i] = um->addr[i] + src->off; ret = dma_mapping_error(dev->dev, um->addr[i]); if (ret) { dmaengine_unmap_put(um); result("src mapping error", total_tests, - src_off, dst_off, len, ret); + src->off, dst->off, len, ret); failed_tests++; continue; } um->to_cnt++; } /* map with DMA_BIDIRECTIONAL to force writeback/invalidate */ - dsts = &um->addr[src_cnt]; - for (i = 0; i < dst_cnt; i++) { - void *buf = thread->dsts[i]; + dsts = &um->addr[src->cnt]; + for (i = 0; i < dst->cnt; i++) { + void *buf = dst->aligned[i]; struct page *pg = virt_to_page(buf); unsigned long pg_off = offset_in_page(buf); @@ -732,7 +739,7 @@ static int dmatest_func(void *data) if (ret) { dmaengine_unmap_put(um); result("dst mapping error", total_tests, - src_off, dst_off, len, ret); + src->off, dst->off, len, ret); failed_tests++; continue; } @@ -741,30 +748,30 @@ static int dmatest_func(void *data) if (thread->type == DMA_MEMCPY) tx = dev->device_prep_dma_memcpy(chan, - dsts[0] + dst_off, + dsts[0] + dst->off, srcs[0], len, flags); else if (thread->type == DMA_MEMSET) tx = dev->device_prep_dma_memset(chan, - dsts[0] + dst_off, - *(thread->srcs[0] + src_off), + dsts[0] + dst->off, + *(src->aligned[0] + src->off), len, flags); else if (thread->type == DMA_XOR) tx = dev->device_prep_dma_xor(chan, - dsts[0] + dst_off, - srcs, src_cnt, + dsts[0] + dst->off, + srcs, src->cnt, len, flags); else if (thread->type == DMA_PQ) { - for (i = 0; i < dst_cnt; i++) - dma_pq[i] = dsts[i] + dst_off; + for (i = 0; i < dst->cnt; i++) + dma_pq[i] = dsts[i] + dst->off; tx = dev->device_prep_dma_pq(chan, dma_pq, srcs, - src_cnt, pq_coefs, + src->cnt, pq_coefs, len, flags); } if (!tx) { dmaengine_unmap_put(um); - result("prep error", total_tests, src_off, - dst_off, len, ret); + result("prep error", total_tests, src->off, + dst->off, len, ret); msleep(100); failed_tests++; continue; @@ -777,8 +784,8 @@ static int dmatest_func(void *data) if (dma_submit_error(cookie)) { dmaengine_unmap_put(um); - result("submit error", total_tests, src_off, - dst_off, len, ret); + result("submit error", total_tests, src->off, + dst->off, len, ret); msleep(100); failed_tests++; continue; @@ -793,58 +800,58 @@ static int dmatest_func(void *data) dmaengine_unmap_put(um); if (!done->done) { - result("test timed out", total_tests, src_off, dst_off, + result("test timed out", total_tests, src->off, dst->off, len, 0); failed_tests++; continue; } else if (status != DMA_COMPLETE) { result(status == DMA_ERROR ? "completion error status" : - "completion busy status", total_tests, src_off, - dst_off, len, ret); + "completion busy status", total_tests, src->off, + dst->off, len, ret); failed_tests++; continue; } if (params->noverify) { - verbose_result("test passed", total_tests, src_off, - dst_off, len, 0); + verbose_result("test passed", total_tests, src->off, + dst->off, len, 0); continue; } start = ktime_get(); pr_debug("%s: verifying source buffer...\n", current->comm); - error_count = dmatest_verify(thread->srcs, 0, src_off, + error_count = dmatest_verify(src->aligned, 0, src->off, 0, PATTERN_SRC, true, is_memset); - error_count += dmatest_verify(thread->srcs, src_off, - src_off + len, src_off, + error_count += dmatest_verify(src->aligned, src->off, + src->off + len, src->off, PATTERN_SRC | PATTERN_COPY, true, is_memset); - error_count += dmatest_verify(thread->srcs, src_off + len, - params->buf_size, src_off + len, + error_count += dmatest_verify(src->aligned, src->off + len, + params->buf_size, src->off + len, PATTERN_SRC, true, is_memset); pr_debug("%s: verifying dest buffer...\n", current->comm); - error_count += dmatest_verify(thread->dsts, 0, dst_off, + error_count += dmatest_verify(dst->aligned, 0, dst->off, 0, PATTERN_DST, false, is_memset); - error_count += dmatest_verify(thread->dsts, dst_off, - dst_off + len, src_off, + error_count += dmatest_verify(dst->aligned, dst->off, + dst->off + len, src->off, PATTERN_SRC | PATTERN_COPY, false, is_memset); - error_count += dmatest_verify(thread->dsts, dst_off + len, - params->buf_size, dst_off + len, + error_count += dmatest_verify(dst->aligned, dst->off + len, + params->buf_size, dst->off + len, PATTERN_DST, false, is_memset); diff = ktime_sub(ktime_get(), start); comparetime = ktime_add(comparetime, diff); if (error_count) { - result("data error", total_tests, src_off, dst_off, + result("data error", total_tests, src->off, dst->off, len, error_count); failed_tests++; } else { - verbose_result("test passed", total_tests, src_off, - dst_off, len, 0); + verbose_result("test passed", total_tests, src->off, + dst->off, len, 0); } } ktime = ktime_sub(ktime_get(), ktime); @@ -857,18 +864,18 @@ static int dmatest_func(void *data) err_srcs_array: kfree(srcs); err_dstbuf: - for (i = 0; thread->udsts[i]; i++) - kfree(thread->udsts[i]); - kfree(thread->udsts); + for (i = 0; dst->raw[i]; i++) + kfree(dst->raw[i]); + kfree(dst->raw); err_udsts: - kfree(thread->dsts); + kfree(dst->aligned); err_dsts: err_srcbuf: - for (i = 0; thread->usrcs[i]; i++) - kfree(thread->usrcs[i]); - kfree(thread->usrcs); + for (i = 0; src->raw[i]; i++) + kfree(src->raw[i]); + kfree(src->raw); err_usrcs: - kfree(thread->srcs); + kfree(src->aligned); err_free_coefs: kfree(pq_coefs); err_thread_type: -- cgit v1.2.3 From 41d00bb7a60fadbae76e1826bd27a320e18c769f Mon Sep 17 00:00:00 2001 From: Alexandru Ardelean Date: Tue, 12 Feb 2019 17:11:38 +0200 Subject: dmaengine: dmatest: add short-hand `buf_size` var in dmatest_func() This is just a cosmetic change, since this variable gets used quite a bit inside the dmatest_func() routine. Signed-off-by: Alexandru Ardelean Signed-off-by: Vinod Koul --- drivers/dma/dmatest.c | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) (limited to 'drivers/dma/dmatest.c') diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c index ea1f885e70f4..3b148c2647f8 100644 --- a/drivers/dma/dmatest.c +++ b/drivers/dma/dmatest.c @@ -516,6 +516,7 @@ static int dmatest_func(void *data) enum dma_ctrl_flags flags; u8 *pq_coefs = NULL; int ret; + unsigned int buf_size; struct dmatest_data *src; struct dmatest_data *dst; int i; @@ -580,9 +581,10 @@ static int dmatest_func(void *data) goto err_free_coefs; } - if (1 << align > params->buf_size) { + buf_size = params->buf_size; + if (1 << align > buf_size) { pr_err("%u-byte buffer too small for %d-byte alignment\n", - params->buf_size, 1 << align); + buf_size, 1 << align); goto err_free_coefs; } @@ -595,7 +597,7 @@ static int dmatest_func(void *data) goto err_usrcs; for (i = 0; i < src->cnt; i++) { - src->raw[i] = kmalloc(params->buf_size + align, + src->raw[i] = kmalloc(buf_size + align, GFP_KERNEL); if (!src->raw[i]) goto err_srcbuf; @@ -617,7 +619,7 @@ static int dmatest_func(void *data) goto err_udsts; for (i = 0; i < dst->cnt; i++) { - dst->raw[i] = kmalloc(params->buf_size + align, + dst->raw[i] = kmalloc(buf_size + align, GFP_KERNEL); if (!dst->raw[i]) goto err_dstbuf; @@ -656,16 +658,16 @@ static int dmatest_func(void *data) total_tests++; if (params->transfer_size) { - if (params->transfer_size >= params->buf_size) { + if (params->transfer_size >= buf_size) { pr_err("%u-byte transfer size must be lower than %u-buffer size\n", - params->transfer_size, params->buf_size); + params->transfer_size, buf_size); break; } len = params->transfer_size; } else if (params->norandom) { - len = params->buf_size; + len = buf_size; } else { - len = dmatest_random() % params->buf_size + 1; + len = dmatest_random() % buf_size + 1; } /* Do not alter transfer size explicitly defined by user */ @@ -680,8 +682,8 @@ static int dmatest_func(void *data) src->off = 0; dst->off = 0; } else { - src->off = dmatest_random() % (params->buf_size - len + 1); - dst->off = dmatest_random() % (params->buf_size - len + 1); + src->off = dmatest_random() % (buf_size - len + 1); + dst->off = dmatest_random() % (buf_size - len + 1); src->off = (src->off >> align) << align; dst->off = (dst->off >> align) << align; @@ -690,9 +692,9 @@ static int dmatest_func(void *data) if (!params->noverify) { start = ktime_get(); dmatest_init_srcs(src->aligned, src->off, len, - params->buf_size, is_memset); + buf_size, is_memset); dmatest_init_dsts(dst->aligned, dst->off, len, - params->buf_size, is_memset); + buf_size, is_memset); diff = ktime_sub(ktime_get(), start); filltime = ktime_add(filltime, diff); @@ -707,7 +709,7 @@ static int dmatest_func(void *data) continue; } - um->len = params->buf_size; + um->len = buf_size; for (i = 0; i < src->cnt; i++) { void *buf = src->aligned[i]; struct page *pg = virt_to_page(buf); @@ -827,7 +829,7 @@ static int dmatest_func(void *data) src->off + len, src->off, PATTERN_SRC | PATTERN_COPY, true, is_memset); error_count += dmatest_verify(src->aligned, src->off + len, - params->buf_size, src->off + len, + buf_size, src->off + len, PATTERN_SRC, true, is_memset); pr_debug("%s: verifying dest buffer...\n", current->comm); @@ -839,7 +841,7 @@ static int dmatest_func(void *data) PATTERN_SRC | PATTERN_COPY, false, is_memset); error_count += dmatest_verify(dst->aligned, dst->off + len, - params->buf_size, dst->off + len, + buf_size, dst->off + len, PATTERN_DST, false, is_memset); diff = ktime_sub(ktime_get(), start); -- cgit v1.2.3 From 3b6679f91e6f7772b7bfa3417b637f09e5998357 Mon Sep 17 00:00:00 2001 From: Alexandru Ardelean Date: Tue, 12 Feb 2019 17:11:39 +0200 Subject: dmaengine: dmatest: move test data alloc & free into functions This patch starts to take advantage of the `dmatest_data` struct by moving the common allocation & free-ing bits into functions. Signed-off-by: Alexandru Ardelean Signed-off-by: Vinod Koul --- drivers/dma/dmatest.c | 110 +++++++++++++++++++++++++------------------------- 1 file changed, 55 insertions(+), 55 deletions(-) (limited to 'drivers/dma/dmatest.c') diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c index 3b148c2647f8..50221d467d86 100644 --- a/drivers/dma/dmatest.c +++ b/drivers/dma/dmatest.c @@ -486,6 +486,53 @@ static unsigned long long dmatest_KBs(s64 runtime, unsigned long long len) return FIXPT_TO_INT(dmatest_persec(runtime, len >> 10)); } +static void __dmatest_free_test_data(struct dmatest_data *d, unsigned int cnt) +{ + unsigned int i; + + for (i = 0; i < cnt; i++) + kfree(d->raw[i]); + + kfree(d->aligned); + kfree(d->raw); +} + +static void dmatest_free_test_data(struct dmatest_data *d) +{ + __dmatest_free_test_data(d, d->cnt); +} + +static int dmatest_alloc_test_data(struct dmatest_data *d, + unsigned int buf_size, u8 align) +{ + unsigned int i = 0; + + d->raw = kcalloc(d->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!d->raw) + return -ENOMEM; + + d->aligned = kcalloc(d->cnt + 1, sizeof(u8 *), GFP_KERNEL); + if (!d->aligned) + goto err; + + for (i = 0; i < d->cnt; i++) { + d->raw[i] = kmalloc(buf_size + align, GFP_KERNEL); + if (!d->raw[i]) + goto err; + + /* align to alignment restriction */ + if (align) + d->aligned[i] = PTR_ALIGN(d->raw[i], align); + else + d->aligned[i] = d->raw[i]; + } + + return 0; +err: + __dmatest_free_test_data(d, i); + return -ENOMEM; +} + /* * This function repeatedly tests DMA transfers of various lengths and * offsets for a given operation type until it is told to exit by @@ -588,55 +635,17 @@ static int dmatest_func(void *data) goto err_free_coefs; } - src->aligned = kcalloc(src->cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!src->aligned) + if (dmatest_alloc_test_data(src, buf_size, align) < 0) goto err_free_coefs; - src->raw = kcalloc(src->cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!src->raw) - goto err_usrcs; - - for (i = 0; i < src->cnt; i++) { - src->raw[i] = kmalloc(buf_size + align, - GFP_KERNEL); - if (!src->raw[i]) - goto err_srcbuf; - - /* align srcs to alignment restriction */ - if (align) - src->aligned[i] = PTR_ALIGN(src->raw[i], align); - else - src->aligned[i] = src->raw[i]; - } - src->aligned[i] = NULL; - - dst->aligned = kcalloc(dst->cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!dst->aligned) - goto err_dsts; - - dst->raw = kcalloc(dst->cnt + 1, sizeof(u8 *), GFP_KERNEL); - if (!dst->raw) - goto err_udsts; - - for (i = 0; i < dst->cnt; i++) { - dst->raw[i] = kmalloc(buf_size + align, - GFP_KERNEL); - if (!dst->raw[i]) - goto err_dstbuf; - - /* align dsts to alignment restriction */ - if (align) - dst->aligned[i] = PTR_ALIGN(dst->raw[i], align); - else - dst->aligned[i] = dst->raw[i]; - } - dst->aligned[i] = NULL; + if (dmatest_alloc_test_data(dst, buf_size, align) < 0) + goto err_src; set_user_nice(current, 10); srcs = kcalloc(src->cnt, sizeof(dma_addr_t), GFP_KERNEL); if (!srcs) - goto err_dstbuf; + goto err_dst; dma_pq = kcalloc(dst->cnt, sizeof(dma_addr_t), GFP_KERNEL); if (!dma_pq) @@ -865,19 +874,10 @@ static int dmatest_func(void *data) kfree(dma_pq); err_srcs_array: kfree(srcs); -err_dstbuf: - for (i = 0; dst->raw[i]; i++) - kfree(dst->raw[i]); - kfree(dst->raw); -err_udsts: - kfree(dst->aligned); -err_dsts: -err_srcbuf: - for (i = 0; src->raw[i]; i++) - kfree(src->raw[i]); - kfree(src->raw); -err_usrcs: - kfree(src->aligned); +err_dst: + dmatest_free_test_data(dst); +err_src: + dmatest_free_test_data(src); err_free_coefs: kfree(pq_coefs); err_thread_type: -- cgit v1.2.3