diff --git a/CODEOWNERS b/CODEOWNERS index 203fe1fa15e1c..08a4999027213 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -755,6 +755,7 @@ scripts/build/gen_image_info.py @tejlmand /subsys/debug/gdbstub.c @ceolin /subsys/dfu/ @de-nordic @nordicjm /subsys/disk/ @jfischer-no +/subsys/dsp/ @yperess /subsys/tracing/ @nashif /subsys/debug/asan_hacks.c @aescolar @daor-oti /subsys/demand_paging/ @dcpleung @nashif diff --git a/MAINTAINERS.yml b/MAINTAINERS.yml index d3594feaef340..484f6728ce01e 100644 --- a/MAINTAINERS.yml +++ b/MAINTAINERS.yml @@ -324,6 +324,17 @@ CMSIS API layer: - "area: CMSIS API Layer" - "area: Portability" +DSP subsystem: + status: maintained + maintainers: + - stephanosio + - yperess + files: + - subsys/dsp/ + - tests/subsys/dsp/ + labels: + - "area: DSP" + CMSIS-DSP integration: status: maintained maintainers: diff --git a/doc/develop/api/overview.rst b/doc/develop/api/overview.rst index a7836c388a466..b6f686ee6c5ce 100644 --- a/doc/develop/api/overview.rst +++ b/doc/develop/api/overview.rst @@ -316,3 +316,7 @@ between major releases are available in the :ref:`zephyr_release_notes`. * - :ref:`watchdog_api` - Stable - 1.0 + + * - :ref:`zdsp_api` + - Experimental + - 3.3 diff --git a/doc/services/dsp/index.rst b/doc/services/dsp/index.rst new file mode 100644 index 0000000000000..6ce6acf384da7 --- /dev/null +++ b/doc/services/dsp/index.rst @@ -0,0 +1,61 @@ +.. _zdsp_api: + +Digital Signal Processing (DSP) +############################### + +.. contents:: + :local: + :depth: 2 + +The DSP API provides an architecture agnostic way for signal processing. +Currently, the API will work on any architecture but will likely not be +optimized. The status of the various architectures can be found below: + ++--------------+-------------+ +| Architecture | Status | ++--------------+-------------+ +| ARC | Unoptimized | +| ARM | Optimized | +| ARM64 | Optimized | +| MIPS | Unoptimized | +| NIOS2 | Unoptimized | +| POSIX | Unoptimized | +| RISCV | Unoptimized | +| RISCV64 | Unoptimized | +| SPARC | Unoptimized | +| X86 | Unoptimized | +| XTENSA | Unoptimized | ++--------------+-------------+ + +Using zDSP +********** + +zDSP provides various backend options which are selected automatically for the +application. By default, including the CMSIS module will enable all +architectures to use the zDSP APIs. This can be done by setting:: + + CONFIG_CMSIS_DSP=y + +If your application requires some additional customization, it's possible to +enable :kconfig:option:`CONFIG_DSP_BACKEND_CUSTOM` which means that the +application is responsible for providing the implementation of the zDSP +library. + +Optimizing for your architecture +******************************** + +If your architecture is showing as ``Unoptimized``, it's possible to add a new +zDSP backend to better support it. To do that, a new Kconfig option should be +added to `subsys/dsp/Kconfig`_ along with the required dependencies and the +``default`` set for ``DSP_BACKEND`` Kconfig choice. + +Next, the implementation should be added at ``subsys/dsp//`` and +linked in at `subsys/dsp/CMakeLists.txt`_. + +API Reference +************* + +.. doxygengroup:: math_dsp + +.. _subsys/dsp/Kconfig: https://github.com/zephyrproject-rtos/zephyr/blob/main/subsys/dsp/Kconfig +.. _subsys/dsp/CMakeLists.txt: https://github.com/zephyrproject-rtos/zephyr/blob/main/subsys/dsp/CMakeLists.txt diff --git a/doc/services/index.rst b/doc/services/index.rst index 61c1695ac47c6..675edf935d590 100644 --- a/doc/services/index.rst +++ b/doc/services/index.rst @@ -10,6 +10,7 @@ OS Services crypto/index debugging/index.rst device_mgmt/index + dsp/index.rst file_system/index.rst formatted_output.rst ipc/index.rst diff --git a/doc/zephyr.doxyfile.in b/doc/zephyr.doxyfile.in index 79e3c2bf91175..600d8ac81b91e 100644 --- a/doc/zephyr.doxyfile.in +++ b/doc/zephyr.doxyfile.in @@ -2316,6 +2316,7 @@ PREDEFINED = __DOXYGEN__ \ CONFIG_ERRNO \ CONFIG_FLASH_JESD216_API \ CONFIG_FLASH_PAGE_LAYOUT \ + CONFIG_FP16 \ CONFIG_FPU \ CONFIG_FPU_SHARING \ CONFIG_GDBSTUB \ diff --git a/include/zephyr/dsp/basicmath.h b/include/zephyr/dsp/basicmath.h new file mode 100644 index 0000000000000..0128b3c727d12 --- /dev/null +++ b/include/zephyr/dsp/basicmath.h @@ -0,0 +1,920 @@ +/* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @file zephyr/dsp/basicmath.h + * + * @brief Public APIs for DSP basicmath + */ + +#ifndef INCLUDE_ZEPHYR_DSP_BASICMATH_H_ +#define INCLUDE_ZEPHYR_DSP_BASICMATH_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @ingroup math_dsp + * @defgroup math_dsp_basic Basic Math Functions + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_mult Vector Multiplication + * + * Element-by-element multiplication of two vectors. + * 
+ *     dst[n] = src_a[n] * src_b[n],   0 <= n < block_size.
+ *
+ * There are separate functions for floating-point, Q7, Q15, and Q31 data types. + * @{ + */ + +/** + * @brief Q7 vector multiplication. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q7 range [0x80 0x7F] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_mult_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, + uint32_t block_size); + +/** + * @brief Q15 vector multiplication. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_mult_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size); + +/** + * @brief Q31 vector multiplication. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_mult_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size); + +/** + * @brief Floating-point vector multiplication. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_mult_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_add Vector Addition + * + * Element-by-element addition of two vectors. + * 
+ *     dst[n] = src_a[n] + src_b[n],   0 <= n < block_size.
+ *
+ * There are separate functions for floating-point, Q7, Q15, and Q31 data types. + * @{ + */ + +/** + * @brief Floating-point vector addition. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_add_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size); + +/** + * @brief Q7 vector addition. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q7 range [0x80 0x7F] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_add_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, + uint32_t block_size); + +/** + * @brief Q15 vector addition. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_add_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size); + +/** + * @brief Q31 vector addition. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_add_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_sub Vector Subtraction + * + * Element-by-element subtraction of two vectors. + * 
+ *     dst[n] = src_a[n] - src_b[n],   0 <= n < block_size.
+ *
+ * There are separate functions for floating-point, Q7, Q15, and Q31 data types. + * @{ + */ + +/** + * @brief Floating-point vector subtraction. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_sub_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size); + +/** + * @brief Q7 vector subtraction. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_sub_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, + uint32_t block_size); + +/** + * @brief Q15 vector subtraction. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_sub_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size); + +/** + * @brief Q31 vector subtraction. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_sub_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_scale Vector Scale + * + * Multiply a vector by a scalar value. For floating-point data, the algorithm used is: + * 
+ *     dst[n] = src[n] * scale,   0 <= n < block_size.
+ *
+ * + * In the fixed-point Q7, Q15, and Q31 functions, scale is represented by a fractional + * multiplication scale_fract and an arithmetic shift shift. The shift + * allows the gain of the scaling operation to exceed 1.0. The algorithm used with fixed-point data + * is: + * 
+ *     dst[n] = (src[n] * scale_fract) << shift,   0 <= n < block_size.
+ *
+ * + * The overall scale factor applied to the fixed-point data is + * 
+ *     scale = scale_fract * 2^shift.
+ *
+ * The functions support in-place computation allowing the source and destination pointers to + * reference the same memory buffer. + * @{ + */ + +/** + * @brief Multiplies a floating-point vector by a scalar. + * @param[in] src points to the input vector + * @param[in] scale scale factor to be applied + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_scale_f32(const float32_t *src, float32_t scale, float32_t *dst, + uint32_t block_size); + +/** + * @brief Multiplies a Q7 vector by a scalar. + * + * @par Scaling and Overflow Behavior + * The input data *src and scale_fract are in 1.7 format. + * These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to + * 1.7 format. + * + * @param[in] src points to the input vector + * @param[in] scale_fract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_scale_q7(const q7_t *src, q7_t scale_fract, int8_t shift, q7_t *dst, + uint32_t block_size); + +/** + * @brief Multiplies a Q15 vector by a scalar. + * + * @par Scaling and Overflow Behavior + * The input data *src and scale_fract are in 1.15 format. + * These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to + * 1.15 format. + * + * @param[in] src points to the input vector + * @param[in] scale_fract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_scale_q15(const q15_t *src, q15_t scale_fract, int8_t shift, q15_t *dst, + uint32_t block_size); + +/** + * @brief Multiplies a Q31 vector by a scalar. + * + * @par Scaling and Overflow Behavior + * The input data *src and scale_fract are in 1.31 format. + * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to + * 1.31 format. + * + * @param[in] src points to the input vector + * @param[in] scale_fract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_scale_q31(const q31_t *src, q31_t scale_fract, int8_t shift, q31_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_abs Vector Absolute Value + * + * Computes the absolute value of a vector on an element-by-element basis. + * 
+ *     dst[n] = abs(src[n]),   0 <= n < block_size.
+ *
+ * The functions support in-place computation allowing the source and destination pointers to + * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and + * Q31 data types. + * @{ + */ + +/** + * @brief Floating-point vector absolute value. + * @param[in] src points to the input buffer + * @param[out] dst points to the output buffer + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_abs_f32(const float32_t *src, float32_t *dst, uint32_t block_size); + +/** + * @brief Q7 vector absolute value. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F. + * + * @param[in] src points to the input buffer + * @param[out] dst points to the output buffer + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_abs_q7(const q7_t *src, q7_t *dst, uint32_t block_size); + +/** + * @brief Q15 vector absolute value. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF. + * + * @param[in] src points to the input buffer + * @param[out] dst points to the output buffer + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_abs_q15(const q15_t *src, q15_t *dst, uint32_t block_size); + +/** + * @brief Q31 vector absolute value. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value + * 0x7FFFFFFF. + * + * @param[in] src points to the input buffer + * @param[out] dst points to the output buffer + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_abs_q31(const q31_t *src, q31_t *dst, uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_dot Vector Dot Product + * + * Computes the dot product of two vectors. The vectors are multiplied element-by-element and then + * summed. + * 
+ *     sum = src_a[0]*src_b[0] + src_a[1]*src_b[1] + ... + src_a[block_size-1]*src_b[block_size-1]
+ *
+ * There are separate functions for floating-point, Q7, Q15, and Q31 data types. + * @{ + */ + +/** + * @brief Dot product of floating-point vectors. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[in] block_size number of samples in each vector + * @param[out] result output result returned here + */ +DSP_FUNC_SCOPE void zdsp_dot_prod_f32(const float32_t *src_a, const float32_t *src_b, + uint32_t block_size, float32_t *result); + +/** + * @brief Dot product of Q7 vectors. + * + * @par Scaling and Overflow Behavior + * The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these results are added to + * an accumulator in 18.14 format. Nonsaturating additions are used and there is no danger of wrap + * around as long as the vectors are less than 2^18 elements long. The return result is in 18.14 + * format. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[in] block_size number of samples in each vector + * @param[out] result output result returned here + */ +DSP_FUNC_SCOPE void zdsp_dot_prod_q7(const q7_t *src_a, const q7_t *src_b, uint32_t block_size, + q31_t *result); + +/** + * @brief Dot product of Q15 vectors. + * + * @par Scaling and Overflow Behavior + * The intermediate multiplications are in 1.15 x 1.15 = 2.30 format and these results are added + * to a 64-bit accumulator in 34.30 format. Nonsaturating additions are used and given that there + * are 33 guard bits in the accumulator there is no risk of overflow. The return result is in + * 34.30 format. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[in] block_size number of samples in each vector + * @param[out] result output result returned here + */ +DSP_FUNC_SCOPE void zdsp_dot_prod_q15(const q15_t *src_a, const q15_t *src_b, uint32_t block_size, + q63_t *result); + +/** + * @brief Dot product of Q31 vectors. + * + * @par Scaling and Overflow Behavior + * The intermediate multiplications are in 1.31 x 1.31 = 2.62 format and these are truncated to + * 2.48 format by discarding the lower 14 bits. The 2.48 result is then added without saturation + * to a 64-bit accumulator in 16.48 format. There are 15 guard bits in the accumulator and there + * is no risk of overflow as long as the length of the vectors is less than 2^16 elements. The + * return result is in 16.48 format. + * + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[in] block_size number of samples in each vector + * @param[out] result output result returned here + */ +DSP_FUNC_SCOPE void zdsp_dot_prod_q31(const q31_t *src_a, const q31_t *src_b, uint32_t block_size, + q63_t *result); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_shift Vector Shift + * + * Shifts the elements of a fixed-point vector by a specified number of bits. + * There are separate functions for Q7, Q15, and Q31 data types. The underlying algorithm used is: + * 
+ *     dst[n] = src[n] << shift,   0 <= n < block_size.
+ *
+ * If shift is positive then the elements of the vector are shifted to the left. + * If shift is negative then the elements of the vector are shifted to the right. + * + * The functions support in-place computation allowing the source and destination pointers to + * reference the same memory buffer. + * @{ + */ + +/** + * @brief Shifts the elements of a Q7 vector a specified number of bits. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q7 range [0x80 0x7F] are saturated. + * + * @param[in] src points to the input vector + * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value + * shifts right. + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_shift_q7(const q7_t *src, int8_t shift_bits, q7_t *dst, + uint32_t block_size); + +/** + * @brief Shifts the elements of a Q15 vector a specified number of bits. + * + * @pre Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated. + * + * @param[in] src points to the input vector + * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value + * shifts right. + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_shift_q15(const q15_t *src, int8_t shift_bits, q15_t *dst, + uint32_t block_size); + +/** + * @brief Shifts the elements of a Q31 vector a specified number of bits. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated. + * + * @param[in] src points to the input vector + * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value + * shifts right. + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_shift_q31(const q31_t *src, int8_t shift_bits, q31_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_offset Vector Offset + * + * Adds a constant offset to each element of a vector. + * 
+ *     dst[n] = src[n] + offset,   0 <= n < block_size.
+ *
+ * The functions support in-place computation allowing the source and destination pointers to + * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and + * Q31 data types. + * + * @{ + */ + +/** + * @brief Adds a constant offset to a floating-point vector. + * @param[in] src points to the input vector + * @param[in] offset is the offset to be added + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_offset_f32(const float32_t *src, float32_t offset, float32_t *dst, + uint32_t block_size); + +/** + * @brief Adds a constant offset to a Q7 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q7 range [0x80 0x7F] are saturated. + * + * @param[in] src points to the input vector + * @param[in] offset is the offset to be added + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_offset_q7(const q7_t *src, q7_t offset, q7_t *dst, uint32_t block_size); + +/** + * @brief Adds a constant offset to a Q15 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated. + * + * @param[in] src points to the input vector + * @param[in] offset is the offset to be added + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_offset_q15(const q15_t *src, q15_t offset, q15_t *dst, + uint32_t block_size); + +/** + * @brief Adds a constant offset to a Q31 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated. + * + * @param[in] src points to the input vector + * @param[in] offset is the offset to be added + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_offset_q31(const q31_t *src, q31_t offset, q31_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_negate Vector Negate + * + * Negates the elements of a vector. + * 
+ *     dst[n] = -src[n],   0 <= n < block_size.
+ *
+ * The functions support in-place computation allowing the source and destination pointers to + * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and + * Q31 data types. + * + * @{ + */ + +/** + * @brief Negates the elements of a floating-point vector. + * @param[in] src points to the input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_negate_f32(const float32_t *src, float32_t *dst, uint32_t block_size); + +/** + * @brief Negates the elements of a Q7 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q7 value -1 (0x80) is saturated to the maximum allowable positive value 0x7F. + * + * @param[in] src points to the input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_negate_q7(const q7_t *src, q7_t *dst, uint32_t block_size); + +/** + * @brief Negates the elements of a Q15 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q15 value -1 (0x8000) is saturated to the maximum allowable positive value 0x7FFF. + * + * @param[in] src points to the input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_negate_q15(const q15_t *src, q15_t *dst, uint32_t block_size); + +/** + * @brief Negates the elements of a Q31 vector. + * + * @par Scaling and Overflow Behavior + * The function uses saturating arithmetic. + * The Q31 value -1 (0x80000000) is saturated to the maximum allowable positive value 0x7FFFFFFF. + * + * @param[in] src points to the input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_negate_q31(const q31_t *src, q31_t *dst, uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_and Vector bitwise AND + * + * Compute the logical bitwise AND. + * + * There are separate functions for uint32_t, uint16_t, and uint7_t data types. + * @{ + */ + +/** + * @brief Compute the logical bitwise AND of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_and_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise AND of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_and_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise AND of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_and_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_or Vector bitwise OR + * + * Compute the logical bitwise OR. + * + * There are separate functions for uint32_t, uint16_t, and uint7_t data types. + * @{ + */ + +/** + * @brief Compute the logical bitwise OR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_or_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise OR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_or_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise OR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_or_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_not Vector bitwise NOT + * + * Compute the logical bitwise NOT. + * + * There are separate functions for uint32_t, uint16_t, and uint7_t data types. + * @{ + */ + +/** + * @brief Compute the logical bitwise NOT of a fixed-point vector. + * @param[in] src points to input vector + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_not_u8(const uint8_t *src, uint8_t *dst, uint32_t block_size); + +/** + * @brief Compute the logical bitwise NOT of a fixed-point vector. + * @param[in] src points to input vector + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_not_u16(const uint16_t *src, uint16_t *dst, uint32_t block_size); + +/** + * @brief Compute the logical bitwise NOT of a fixed-point vector. + * @param[in] src points to input vector + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_not_u32(const uint32_t *src, uint32_t *dst, uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_xor Vector bitwise XOR + * + * Compute the logical bitwise XOR. + * + * There are separate functions for uint32_t, uint16_t, and uint7_t data types. + * @{ + */ + +/** + * @brief Compute the logical bitwise XOR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_xor_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise XOR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_xor_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size); + +/** + * @brief Compute the logical bitwise XOR of two fixed-point vectors. + * @param[in] src_a points to input vector A + * @param[in] src_b points to input vector B + * @param[out] dst points to output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_xor_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size); + +/** + * @} + */ + +/** + * @ingroup math_dsp_basic + * @addtogroup math_dsp_basic_clip Vector Clipping + * + * Element-by-element clipping of a value. + * + * The value is constrained between 2 bounds. + * + * There are separate functions for floating-point, Q7, Q15, and Q31 data types. + * @{ + */ + +/** + * @brief Elementwise floating-point clipping + * @param[in] src points to input values + * @param[out] dst points to output clipped values + * @param[in] low lower bound + * @param[in] high higher bound + * @param[in] num_samples number of samples to clip + */ +DSP_FUNC_SCOPE void zdsp_clip_f32(const float32_t *src, float32_t *dst, float32_t low, + float32_t high, uint32_t num_samples); + +/** + * @brief Elementwise fixed-point clipping + * @param[in] src points to input values + * @param[out] dst points to output clipped values + * @param[in] low lower bound + * @param[in] high higher bound + * @param[in] num_samples number of samples to clip + */ +DSP_FUNC_SCOPE void zdsp_clip_q31(const q31_t *src, q31_t *dst, q31_t low, q31_t high, + uint32_t num_samples); + +/** + * @brief Elementwise fixed-point clipping + * @param[in] src points to input values + * @param[out] dst points to output clipped values + * @param[in] low lower bound + * @param[in] high higher bound + * @param[in] num_samples number of samples to clip + */ +DSP_FUNC_SCOPE void zdsp_clip_q15(const q15_t *src, q15_t *dst, q15_t low, q15_t high, + uint32_t num_samples); + +/** + * @brief Elementwise fixed-point clipping + * @param[in] src points to input values + * @param[out] dst points to output clipped values + * @param[in] low lower bound + * @param[in] high higher bound + * @param[in] num_samples number of samples to clip + */ +DSP_FUNC_SCOPE void zdsp_clip_q7(const q7_t *src, q7_t *dst, q7_t low, q7_t high, + uint32_t num_samples); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#ifdef CONFIG_FP16 +#include +#endif /* CONFIG_FP16 */ + +#endif /* INCLUDE_ZEPHYR_DSP_BASICMATH_H_ */ diff --git a/include/zephyr/dsp/basicmath_f16.h b/include/zephyr/dsp/basicmath_f16.h new file mode 100644 index 0000000000000..23239e9a65980 --- /dev/null +++ b/include/zephyr/dsp/basicmath_f16.h @@ -0,0 +1,124 @@ +/* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @file zephyr/dsp/basicmath_f16.h + * + * @brief Public APIs for DSP basicmath for 16 bit floating point + */ + +#ifndef INCLUDE_ZEPHYR_DSP_BASICMATH_F16_H_ +#define INCLUDE_ZEPHYR_DSP_BASICMATH_F16_H_ + +#ifndef CONFIG_FP16 +#error "Cannot use float16 DSP functionality without CONFIG_FP16 enabled" +#endif /* CONFIG_FP16 */ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @ingroup math_dsp_basic_mult + * @brief Floating-point vector multiplication. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_mult_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size); + +/** + * @ingroup math_dsp_basic_add + * @brief Floating-point vector addition. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_add_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size); + +/** + * @ingroup math_dsp_basic_sub + * @brief Floating-point vector subtraction. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_sub_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size); + +/** + * @ingroup math_dsp_basic_scale + * @brief Multiplies a floating-point vector by a scalar. + * @param[in] src points to the input vector + * @param[in] scale scale factor to be applied + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_scale_f16(const float16_t *src, float16_t scale, float16_t *dst, + uint32_t block_size); + +/** + * @ingroup math_dsp_basic_abs + * @brief Floating-point vector absolute value. + * @param[in] src points to the input buffer + * @param[out] dst points to the output buffer + * @param[in] block_size number of samples in each vector + */ +DSP_FUNC_SCOPE void zdsp_abs_f16(const float16_t *src, float16_t *dst, uint32_t block_size); + +/** + * @ingroup math_dsp_basic_dot + * @brief Dot product of floating-point vectors. + * @param[in] src_a points to the first input vector + * @param[in] src_b points to the second input vector + * @param[in] block_size number of samples in each vector + * @param[out] result output result returned here + */ +DSP_FUNC_SCOPE void zdsp_dot_prod_f16(const float16_t *src_a, const float16_t *src_b, + uint32_t block_size, float16_t *result); + +/** + * @ingroup math_dsp_basic_offset + * @brief Adds a constant offset to a floating-point vector. + * @param[in] src points to the input vector + * @param[in] offset is the offset to be added + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_offset_f16(const float16_t *src, float16_t offset, float16_t *dst, + uint32_t block_size); + +/** + * @ingroup math_dsp_basic_negate + * @brief Negates the elements of a floating-point vector. + * @param[in] src points to the input vector + * @param[out] dst points to the output vector + * @param[in] block_size number of samples in the vector + */ +DSP_FUNC_SCOPE void zdsp_negate_f16(const float16_t *src, float16_t *dst, uint32_t block_size); + +/** + * @ingroup math_dsp_basic_clip + * @brief Elementwise floating-point clipping + * @param[in] src points to input values + * @param[out] dst points to output clipped values + * @param[in] low lower bound + * @param[in] high higher bound + * @param[in] num_samples number of samples to clip + */ +DSP_FUNC_SCOPE void zdsp_clip_f16(const float16_t *src, float16_t *dst, float16_t low, + float16_t high, uint32_t num_samples); + +#ifdef __cplusplus +} +#endif + +#endif /* INCLUDE_ZEPHYR_DSP_BASICMATH_F16_H_ */ diff --git a/include/zephyr/dsp/dsp.h b/include/zephyr/dsp/dsp.h new file mode 100644 index 0000000000000..09c757216b13a --- /dev/null +++ b/include/zephyr/dsp/dsp.h @@ -0,0 +1,31 @@ +/* Copyright (c) 2022 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @file zephyr/dsp/dsp.h + * + * @brief Public APIs for Digital Signal Processing (DSP) math. + */ + +#ifndef INCLUDE_ZEPHYR_DSP_DSP_H_ +#define INCLUDE_ZEPHYR_DSP_DSP_H_ + +#ifdef CONFIG_DSP_BACKEND_HAS_STATIC +#define DSP_FUNC_SCOPE static +#else +#define DSP_FUNC_SCOPE +#endif + +/** + * @brief DSP Interface + * @defgroup math_dsp DSP Interface + */ + +#include + +#include + +#include "zdsp_backend.h" + +#endif /* INCLUDE_ZEPHYR_DSP_DSP_H_ */ diff --git a/include/zephyr/dsp/types.h b/include/zephyr/dsp/types.h new file mode 100644 index 0000000000000..52ce2ab20372c --- /dev/null +++ b/include/zephyr/dsp/types.h @@ -0,0 +1,71 @@ +/* Copyright (c) 2022 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef INCLUDE_ZEPHYR_DSP_TYPES_H_ +#define INCLUDE_ZEPHYR_DSP_TYPES_H_ + +#include + +/** + * @addtogroup math_dsp + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @typedef q7_t + * @brief 8-bit fractional data type in 1.7 format. + */ +typedef int8_t q7_t; + +/** + * @typedef q15_t + * @brief 16-bit fractional data type in 1.15 format. + */ +typedef int16_t q15_t; + +/** + * @typedef q31_t + * @brief 32-bit fractional data type in 1.31 format. + */ +typedef int32_t q31_t; + +/** + * @typedef q63_t + * @brief 64-bit fractional data type in 1.63 format. + */ +typedef int64_t q63_t; + +/** + * @typedef float16_t + * @brief 16-bit floating point type definition. + */ +#if defined(CONFIG_FP16) +typedef __fp16 float16_t; +#endif /* CONFIG_FP16 */ + +/** + * @typedef float32_t + * @brief 32-bit floating-point type definition. + */ +typedef float float32_t; + +/** + * @typedef float64_t + * @brief 64-bit floating-point type definition. + */ +typedef double float64_t; + +#ifdef __cplusplus +} +#endif + +/** + * @} + */ + +#endif /* INCLUDE_ZEPHYR_DSP_TYPES_H_ */ diff --git a/modules/Kconfig.cmsis b/modules/Kconfig.cmsis index 19ab657e668f5..c14870c1429a2 100644 --- a/modules/Kconfig.cmsis +++ b/modules/Kconfig.cmsis @@ -22,7 +22,7 @@ endif menuconfig CMSIS_DSP bool "CMSIS-DSP Library Support" - depends on (CPU_CORTEX && NEWLIB_LIBC) || ARCH_POSIX + depends on NEWLIB_LIBC || ARCH_POSIX if CMSIS_DSP source "modules/Kconfig.cmsis_dsp" diff --git a/modules/Kconfig.cmsis_dsp b/modules/Kconfig.cmsis_dsp index 86704b392abbf..6b5f936ccc3e0 100644 --- a/modules/Kconfig.cmsis_dsp +++ b/modules/Kconfig.cmsis_dsp @@ -29,6 +29,7 @@ config CMSIS_DSP_BASICMATH config CMSIS_DSP_COMPLEXMATH bool "Complex Math Functions" imply CMSIS_DSP_FASTMATH + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Complex Math Functions, which support the following operations: @@ -42,6 +43,7 @@ config CMSIS_DSP_COMPLEXMATH config CMSIS_DSP_CONTROLLER bool "Controller Functions" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Controller Functions, which support the following operations: @@ -61,6 +63,7 @@ config CMSIS_DSP_FASTMATH bool "Fast Math Functions" select CMSIS_DSP_TABLES imply CMSIS_DSP_TABLES_ALL_FAST + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Fast Math Functions, which support the following operations: @@ -74,6 +77,7 @@ config CMSIS_DSP_FILTERING bool "Filtering Functions" imply CMSIS_DSP_FASTMATH imply CMSIS_DSP_SUPPORT + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Filtering Functions, which support the following operations: @@ -99,6 +103,7 @@ config CMSIS_DSP_FILTERING config CMSIS_DSP_INTERPOLATION bool "Interpolation Functions" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Interpolation Functions, which support the following operations: @@ -109,6 +114,7 @@ config CMSIS_DSP_INTERPOLATION config CMSIS_DSP_MATRIX bool "Matrix Functions" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Matrix Functions, which support the following operations: @@ -127,6 +133,7 @@ config CMSIS_DSP_MATRIX config CMSIS_DSP_QUATERNIONMATH bool "Quaternion Math Functions" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Quaternion Math Functions, which support the following operations: @@ -142,6 +149,7 @@ config CMSIS_DSP_STATISTICS bool "Statistics Functions" imply CMSIS_DSP_BASICMATH imply CMSIS_DSP_FASTMATH + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Statistics Functions, which support the following operations: @@ -161,6 +169,7 @@ config CMSIS_DSP_STATISTICS config CMSIS_DSP_SUPPORT bool "Support Functions" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Support Functions, which support the following operations: @@ -180,6 +189,7 @@ config CMSIS_DSP_TRANSFORM bool "Transform Functions" select CMSIS_DSP_TABLES imply CMSIS_DSP_TABLES_ALL_FFT + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Transform Functions, which support the following transformations: @@ -191,6 +201,7 @@ config CMSIS_DSP_TRANSFORM config CMSIS_DSP_SVM bool "Support Vector Machine Functions" select CMSIS_DSP_TABLES + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Support Vector Machine Functions, which support the following algorithms: @@ -203,6 +214,7 @@ config CMSIS_DSP_SVM config CMSIS_DSP_BAYES bool "Bayesian Estimators" imply CMSIS_DSP_STATISTICS + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Bayesian Estimator Functions, which implements the naive gaussian Bayes estimator. @@ -210,6 +222,7 @@ config CMSIS_DSP_BAYES config CMSIS_DSP_DISTANCE bool "Distance Functions" imply CMSIS_DSP_STATISTICS + depends on CPU_CORTEX || ARCH_POSIX help This option enables the Distance Functions, which support the following distance computation algorithms: @@ -238,6 +251,7 @@ config CMSIS_DSP_DISTANCE menuconfig CMSIS_DSP_TABLES bool "Look-up Tables" + depends on CPU_CORTEX || ARCH_POSIX help This option enables the static look-up tables used by the DSP functions to compute results. diff --git a/subsys/CMakeLists.txt b/subsys/CMakeLists.txt index a7f385cc545f7..44d1f82eab887 100644 --- a/subsys/CMakeLists.txt +++ b/subsys/CMakeLists.txt @@ -19,6 +19,7 @@ add_subdirectory(random) add_subdirectory(storage) add_subdirectory_ifdef(CONFIG_SETTINGS settings) add_subdirectory(fb) +add_subdirectory(dsp) add_subdirectory(portability) add_subdirectory(pm) add_subdirectory(stats) diff --git a/subsys/Kconfig b/subsys/Kconfig index a37bd623d58bb..d34b5acee449e 100644 --- a/subsys/Kconfig +++ b/subsys/Kconfig @@ -32,6 +32,8 @@ source "subsys/logging/Kconfig" source "subsys/lorawan/Kconfig" +source "subsys/dsp/Kconfig" + source "subsys/mgmt/Kconfig" source "subsys/modbus/Kconfig" diff --git a/subsys/dsp/CMakeLists.txt b/subsys/dsp/CMakeLists.txt new file mode 100644 index 0000000000000..a8ebd0ca92162 --- /dev/null +++ b/subsys/dsp/CMakeLists.txt @@ -0,0 +1,8 @@ +# Copyright (c) 2022 Google LLC +# SPDX-License-Identifier: Apache-2.0 + +zephyr_library_named(zdsp) + +add_subdirectory_ifdef(CONFIG_DSP_BACKEND_CMSIS cmsis) + +zephyr_link_libraries(zdsp) diff --git a/subsys/dsp/Kconfig b/subsys/dsp/Kconfig new file mode 100644 index 0000000000000..e053d9f6a38db --- /dev/null +++ b/subsys/dsp/Kconfig @@ -0,0 +1,26 @@ +# Copyright (c) 2022 Google LLC +# SPDX-License-Identifier: Apache-2.0 + +config DSP_BACKEND_HAS_STATIC + bool + +choice DSP_BACKEND + prompt "DSP library backend selection" + default DSP_BACKEND_CMSIS if CMSIS_DSP + default DSP_BACKEND_CUSTOM + +config DSP_BACKEND_CMSIS + bool "Use the CMSIS-DSP library as the math backend" + depends on CMSIS_DSP + select DSP_BACKEND_HAS_STATIC + help + Implement the various zephyr DSP functions using the CMSIS-DSP library. This feature + requires the CMSIS module to be selected. + +config DSP_BACKEND_CUSTOM + bool "Do not use any Zephyr backends for DSP" + help + Rely on the application to provide a custom DSP backend. The implementation should be + added to the 'zdsp' build target by the application or one of its modules. + +endchoice diff --git a/subsys/dsp/cmsis/CMakeLists.txt b/subsys/dsp/cmsis/CMakeLists.txt new file mode 100644 index 0000000000000..c2b1bc0e6f278 --- /dev/null +++ b/subsys/dsp/cmsis/CMakeLists.txt @@ -0,0 +1,4 @@ +# Copyright (c) 2022 Google LLC +# SPDX-License-Identifier: Apache-2.0 + +target_include_directories(zdsp PUBLIC public) diff --git a/subsys/dsp/cmsis/public/zdsp_backend.h b/subsys/dsp/cmsis/public/zdsp_backend.h new file mode 100644 index 0000000000000..39a9d6d4abefd --- /dev/null +++ b/subsys/dsp/cmsis/public/zdsp_backend.h @@ -0,0 +1,280 @@ +/* Copyright (c) 2022 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef SUBSYS_MATH_CMSIS_BACKEND_PUBLIC_ZDSP_BACKEND_DSP_H_ +#define SUBSYS_MATH_CMSIS_BACKEND_PUBLIC_ZDSP_BACKEND_DSP_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* This include MUST be done before arm_math.h so we can let the arch specific + * logic set up the right #define values for arm_math.h + */ +#include + +#include + +static inline void zdsp_mult_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, + uint32_t block_size) +{ + arm_mult_q7(src_a, src_b, dst, block_size); +} +static inline void zdsp_mult_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size) +{ + arm_mult_q15(src_a, src_b, dst, block_size); +} +static inline void zdsp_mult_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size) +{ + arm_mult_q31(src_a, src_b, dst, block_size); +} +static inline void zdsp_mult_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size) +{ + arm_mult_f32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_add_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, uint32_t block_size) +{ + arm_add_q7(src_a, src_b, dst, block_size); +} +static inline void zdsp_add_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size) +{ + arm_add_q15(src_a, src_b, dst, block_size); +} +static inline void zdsp_add_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size) +{ + arm_add_q31(src_a, src_b, dst, block_size); +} +static inline void zdsp_add_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size) +{ + arm_add_f32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_sub_q7(const q7_t *src_a, const q7_t *src_b, q7_t *dst, uint32_t block_size) +{ + arm_sub_q7(src_a, src_b, dst, block_size); +} +static inline void zdsp_sub_q15(const q15_t *src_a, const q15_t *src_b, q15_t *dst, + uint32_t block_size) +{ + arm_sub_q15(src_a, src_b, dst, block_size); +} +static inline void zdsp_sub_q31(const q31_t *src_a, const q31_t *src_b, q31_t *dst, + uint32_t block_size) +{ + arm_sub_q31(src_a, src_b, dst, block_size); +} +static inline void zdsp_sub_f32(const float32_t *src_a, const float32_t *src_b, float32_t *dst, + uint32_t block_size) +{ + arm_sub_f32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_scale_q7(const q7_t *src, q7_t scale_fract, int8_t shift, q7_t *dst, + uint32_t block_size) +{ + arm_scale_q7(src, scale_fract, shift, dst, block_size); +} +static inline void zdsp_scale_q15(const q15_t *src, q15_t scale_fract, int8_t shift, q15_t *dst, + uint32_t block_size) +{ + arm_scale_q15(src, scale_fract, shift, dst, block_size); +} +static inline void zdsp_scale_q31(const q31_t *src, q31_t scale_fract, int8_t shift, q31_t *dst, + uint32_t block_size) +{ + arm_scale_q31(src, scale_fract, shift, dst, block_size); +} + +static inline void zdsp_scale_f32(const float32_t *src, float32_t scale, float32_t *dst, + uint32_t block_size) +{ + arm_scale_f32(src, scale, dst, block_size); +} + +static inline void zdsp_abs_q7(const q7_t *src, q7_t *dst, uint32_t block_size) +{ + arm_abs_q7(src, dst, block_size); +} +static inline void zdsp_abs_q15(const q15_t *src, q15_t *dst, uint32_t block_size) +{ + arm_abs_q15(src, dst, block_size); +} +static inline void zdsp_abs_q31(const q31_t *src, q31_t *dst, uint32_t block_size) +{ + arm_abs_q31(src, dst, block_size); +} +static inline void zdsp_abs_f32(const float32_t *src, float32_t *dst, uint32_t block_size) +{ + arm_abs_f32(src, dst, block_size); +} + +static inline void zdsp_negate_q7(const q7_t *src, q7_t *dst, uint32_t block_size) +{ + arm_negate_q7(src, dst, block_size); +} +static inline void zdsp_negate_q15(const q15_t *src, q15_t *dst, uint32_t block_size) +{ + arm_negate_q15(src, dst, block_size); +} +static inline void zdsp_negate_q31(const q31_t *src, q31_t *dst, uint32_t block_size) +{ + arm_negate_q31(src, dst, block_size); +} +static inline void zdsp_negate_f32(const float32_t *src, float32_t *dst, uint32_t block_size) +{ + arm_negate_f32(src, dst, block_size); +} + +static inline void zdsp_dot_prod_q7(const q7_t *src_a, const q7_t *src_b, uint32_t block_size, + q31_t *dst) +{ + arm_dot_prod_q7(src_a, src_b, block_size, dst); +} +static inline void zdsp_dot_prod_q15(const q15_t *src_a, const q15_t *src_b, uint32_t block_size, + q63_t *dst) +{ + arm_dot_prod_q15(src_a, src_b, block_size, dst); +} +static inline void zdsp_dot_prod_q31(const q31_t *src_a, const q31_t *src_b, uint32_t block_size, + q63_t *dst) +{ + arm_dot_prod_q31(src_a, src_b, block_size, dst); +} +static inline void zdsp_dot_prod_f32(const float32_t *src_a, const float32_t *src_b, + uint32_t block_size, float32_t *dst) +{ + arm_dot_prod_f32(src_a, src_b, block_size, dst); +} + +static inline void zdsp_shift_q7(const q7_t *src, int8_t shift_bits, q7_t *dst, uint32_t block_size) +{ + arm_shift_q7(src, shift_bits, dst, block_size); +} +static inline void zdsp_shift_q15(const q15_t *src, int8_t shift_bits, q15_t *dst, + uint32_t block_size) +{ + arm_shift_q15(src, shift_bits, dst, block_size); +} +static inline void zdsp_shift_q31(const q31_t *src, int8_t shift_bits, q31_t *dst, + uint32_t block_size) +{ + arm_shift_q31(src, shift_bits, dst, block_size); +} + +static inline void zdsp_offset_q7(const q7_t *src, q7_t offset, q7_t *dst, uint32_t block_size) +{ + arm_offset_q7(src, offset, dst, block_size); +} +static inline void zdsp_offset_q15(const q15_t *src, q15_t offset, q15_t *dst, uint32_t block_size) +{ + arm_offset_q15(src, offset, dst, block_size); +} +static inline void zdsp_offset_q31(const q31_t *src, q31_t offset, q31_t *dst, uint32_t block_size) +{ + arm_offset_q31(src, offset, dst, block_size); +} +static inline void zdsp_offset_f32(const float32_t *src, float32_t offset, float32_t *dst, + uint32_t block_size) +{ + arm_offset_f32(src, offset, dst, block_size); +} + +static inline void zdsp_clip_q7(const q7_t *src, q7_t *dst, q7_t low, q7_t high, + uint32_t num_samples) +{ + arm_clip_q7(src, dst, low, high, num_samples); +} +static inline void zdsp_clip_q15(const q15_t *src, q15_t *dst, q15_t low, q15_t high, + uint32_t num_samples) +{ + arm_clip_q15(src, dst, low, high, num_samples); +} +static inline void zdsp_clip_q31(const q31_t *src, q31_t *dst, q31_t low, q31_t high, + uint32_t num_samples) +{ + arm_clip_q31(src, dst, low, high, num_samples); +} +static inline void zdsp_clip_f32(const float32_t *src, float32_t *dst, float32_t low, + float32_t high, uint32_t num_samples) +{ + arm_clip_f32(src, dst, low, high, num_samples); +} + +static inline void zdsp_and_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size) +{ + arm_and_u8(src_a, src_b, dst, block_size); +} +static inline void zdsp_and_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size) +{ + arm_and_u16(src_a, src_b, dst, block_size); +} +static inline void zdsp_and_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size) +{ + arm_and_u32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_or_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size) +{ + arm_or_u8(src_a, src_b, dst, block_size); +} +static inline void zdsp_or_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size) +{ + arm_or_u16(src_a, src_b, dst, block_size); +} +static inline void zdsp_or_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size) +{ + arm_or_u32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_xor_u8(const uint8_t *src_a, const uint8_t *src_b, uint8_t *dst, + uint32_t block_size) +{ + arm_xor_u8(src_a, src_b, dst, block_size); +} +static inline void zdsp_xor_u16(const uint16_t *src_a, const uint16_t *src_b, uint16_t *dst, + uint32_t block_size) +{ + arm_xor_u16(src_a, src_b, dst, block_size); +} +static inline void zdsp_xor_u32(const uint32_t *src_a, const uint32_t *src_b, uint32_t *dst, + uint32_t block_size) +{ + arm_xor_u32(src_a, src_b, dst, block_size); +} + +static inline void zdsp_not_u8(const uint8_t *src, uint8_t *dst, uint32_t block_size) +{ + arm_not_u8(src, dst, block_size); +} +static inline void zdsp_not_u16(const uint16_t *src, uint16_t *dst, uint32_t block_size) +{ + arm_not_u16(src, dst, block_size); +} +static inline void zdsp_not_u32(const uint32_t *src, uint32_t *dst, uint32_t block_size) +{ + arm_not_u32(src, dst, block_size); +} + +#ifdef __cplusplus +} +#endif + +#ifdef CONFIG_FP16 +#include "zdsp_backend_f16.h" +#endif /* COIFNG_FP16 */ + +#endif /* SUBSYS_MATH_CMSIS_BACKEND_PUBLIC_ZDSP_BACKEND_DSP_H_ */ diff --git a/subsys/dsp/cmsis/public/zdsp_backend_f16.h b/subsys/dsp/cmsis/public/zdsp_backend_f16.h new file mode 100644 index 0000000000000..1bc6364edd092 --- /dev/null +++ b/subsys/dsp/cmsis/public/zdsp_backend_f16.h @@ -0,0 +1,75 @@ +/* Copyright (c) 2022 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef SUBSYS_DSP_CMSIS_PUBLIC_ZDSP_BACKEND_F16_H_ +#define SUBSYS_DSP_CMSIS_PUBLIC_ZDSP_BACKEND_F16_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* This include MUST be done before arm_math.h so we can let the arch specific + * logic set up the right #define values for arm_math.h + */ +#include + +#include + +static inline void zdsp_mult_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size) +{ + arm_mult_f16(src_a, src_b, dst, block_size); +} + +static inline void zdsp_add_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size) +{ + arm_add_f16(src_a, src_b, dst, block_size); +} + +static inline void zdsp_sub_f16(const float16_t *src_a, const float16_t *src_b, float16_t *dst, + uint32_t block_size) +{ + arm_sub_f16(src_a, src_b, dst, block_size); +} + +static inline void zdsp_scale_f16(const float16_t *src, float16_t scale, float16_t *dst, + uint32_t block_size) +{ + arm_scale_f16(src, scale, dst, block_size); +} + +static inline void zdsp_abs_f16(const float16_t *src, float16_t *dst, uint32_t block_size) +{ + arm_abs_f16(src, dst, block_size); +} + +static inline void zdsp_dot_prod_f16(const float16_t *src_a, const float16_t *src_b, + uint32_t block_size, float16_t *result) +{ + arm_dot_prod_f16(src_a, src_b, block_size, result); +} + +static inline void zdsp_offset_f16(const float16_t *src, float16_t offset, float16_t *dst, + uint32_t block_size) +{ + arm_offset_f16(src, offset, dst, block_size); +} + +static inline void zdsp_negate_f16(const float16_t *src, float16_t *dst, uint32_t block_size) +{ + arm_negate_f16(src, dst, block_size); +} + +static inline void zdsp_clip_f16(const float16_t *src, float16_t *dst, float16_t low, + float16_t high, uint32_t num_samples) +{ + arm_clip_f16(src, dst, low, high, num_samples); +} + +#ifdef __cplusplus +} +#endif + +#endif /* SUBSYS_DSP_CMSIS_PUBLIC_ZDSP_BACKEND_F16_H_ */ diff --git a/tests/lib/cmsis_dsp/basicmath/testcase.yaml b/tests/lib/cmsis_dsp/basicmath/testcase.yaml deleted file mode 100644 index 49166351b8a15..0000000000000 --- a/tests/lib/cmsis_dsp/basicmath/testcase.yaml +++ /dev/null @@ -1,21 +0,0 @@ -tests: - libraries.cmsis_dsp.basicmath: - filter: ((CONFIG_CPU_AARCH32_CORTEX_R or CONFIG_CPU_CORTEX_M) and TOOLCHAIN_HAS_NEWLIB == 1) or CONFIG_ARCH_POSIX - integration_platforms: - - frdm_k64f - - sam_e70_xplained - - mps2_an521 - - native_posix - tags: cmsis_dsp - min_flash: 128 - min_ram: 64 - libraries.cmsis_dsp.basicmath.fpu: - filter: ((CONFIG_CPU_AARCH32_CORTEX_R or CONFIG_CPU_CORTEX_M) and CONFIG_CPU_HAS_FPU and TOOLCHAIN_HAS_NEWLIB == 1) or CONFIG_ARCH_POSIX - integration_platforms: - - mps2_an521_remote - - mps3_an547 - tags: cmsis_dsp fpu - extra_configs: - - CONFIG_FPU=y - min_flash: 128 - min_ram: 64 diff --git a/tests/lib/cmsis_dsp/basicmath/CMakeLists.txt b/tests/subsys/dsp/basicmath/CMakeLists.txt similarity index 64% rename from tests/lib/cmsis_dsp/basicmath/CMakeLists.txt rename to tests/subsys/dsp/basicmath/CMakeLists.txt index 48754f7a8ead6..22ec493cdfd83 100644 --- a/tests/lib/cmsis_dsp/basicmath/CMakeLists.txt +++ b/tests/subsys/dsp/basicmath/CMakeLists.txt @@ -11,4 +11,6 @@ target_sources(app PRIVATE src/f32.c ) -target_sources_ifdef(CONFIG_CMSIS_DSP_FLOAT16 app PRIVATE src/f16.c) +target_sources_ifdef(CONFIG_FP16 app PRIVATE src/f16.c) + +target_include_directories(app PRIVATE ${ZEPHYR_BASE}/tests/lib/cmsis_dsp) diff --git a/tests/lib/cmsis_dsp/basicmath/prj.conf b/tests/subsys/dsp/basicmath/prj.conf similarity index 79% rename from tests/lib/cmsis_dsp/basicmath/prj.conf rename to tests/subsys/dsp/basicmath/prj.conf index ad76c3a269a2a..4511e31f3aa33 100644 --- a/tests/lib/cmsis_dsp/basicmath/prj.conf +++ b/tests/subsys/dsp/basicmath/prj.conf @@ -3,3 +3,4 @@ CONFIG_ZTEST_NEW_API=y CONFIG_NEWLIB_LIBC=y CONFIG_CMSIS_DSP=y CONFIG_CMSIS_DSP_BASICMATH=y +CONFIG_DSP_BACKEND_CMSIS=y diff --git a/tests/lib/cmsis_dsp/basicmath/src/f16.c b/tests/subsys/dsp/basicmath/src/f16.c similarity index 60% rename from tests/lib/cmsis_dsp/basicmath/src/f16.c rename to tests/subsys/dsp/basicmath/src/f16.c index bfd79cb3f0dcf..891f57e018a68 100644 --- a/tests/lib/cmsis_dsp/basicmath/src/f16.c +++ b/tests/subsys/dsp/basicmath/src/f16.c @@ -5,11 +5,11 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include #include #include -#include -#include "../../common/test_common.h" +#include "common/test_common.h" #include "f16.pat" @@ -17,7 +17,7 @@ #define SNR_DOTPROD_THRESH ((float32_t)40) #define REL_ERROR_THRESH (4.0e-2) -static void test_arm_add_f16( +static void test_zdsp_add_f16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -28,7 +28,7 @@ static void test_arm_add_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_add_f16((float16_t *)input1, (float16_t *)input2, output, length); + zdsp_add_f16((float16_t *)input1, (float16_t *)input2, output, length); /* Validate output */ zassert_true( @@ -45,13 +45,13 @@ static void test_arm_add_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_add_f16, 7, in_com1, in_com2, ref_add, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_add_f16, 16, in_com1, in_com2, ref_add, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_add_f16, 23, in_com1, in_com2, ref_add, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_add_f16, long, in_com1, in_com2, ref_add, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, 7, in_com1, in_com2, ref_add, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, 16, in_com1, in_com2, ref_add, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, 23, in_com1, in_com2, ref_add, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_add_f16, long, in_com1, in_com2, ref_add, ARRAY_SIZE(in_com1)); -static void test_arm_sub_f16( +static void test_zdsp_sub_f16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -62,7 +62,7 @@ static void test_arm_sub_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_sub_f16((float16_t *)input1, (float16_t *)input2, output, length); + zdsp_sub_f16((float16_t *)input1, (float16_t *)input2, output, length); /* Validate output */ zassert_true( @@ -79,13 +79,13 @@ static void test_arm_sub_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_sub_f16, 7, in_com1, in_com2, ref_sub, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_sub_f16, 16, in_com1, in_com2, ref_sub, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_sub_f16, 23, in_com1, in_com2, ref_sub, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_sub_f16, long, in_com1, in_com2, ref_sub, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, 7, in_com1, in_com2, ref_sub, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, 16, in_com1, in_com2, ref_sub, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, 23, in_com1, in_com2, ref_sub, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_sub_f16, long, in_com1, in_com2, ref_sub, ARRAY_SIZE(in_com1)); -static void test_arm_mult_f16( +static void test_zdsp_mult_f16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -96,7 +96,7 @@ static void test_arm_mult_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_mult_f16((float16_t *)input1, (float16_t *)input2, output, length); + zdsp_mult_f16((float16_t *)input1, (float16_t *)input2, output, length); /* Validate output */ zassert_true( @@ -113,13 +113,13 @@ static void test_arm_mult_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_mult_f16, 7, in_com1, in_com2, ref_mult, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_mult_f16, 16, in_com1, in_com2, ref_mult, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_mult_f16, 23, in_com1, in_com2, ref_mult, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_mult_f16, long, in_com1, in_com2, ref_mult, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, 7, in_com1, in_com2, ref_mult, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, 16, in_com1, in_com2, ref_mult, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, 23, in_com1, in_com2, ref_mult, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_mult_f16, long, in_com1, in_com2, ref_mult, ARRAY_SIZE(in_com1)); -static void test_arm_negate_f16( +static void test_zdsp_negate_f16( const uint16_t *input1, const uint16_t *ref, size_t length) { float16_t *output; @@ -129,7 +129,7 @@ static void test_arm_negate_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_negate_f16((float16_t *)input1, output, length); + zdsp_negate_f16((float16_t *)input1, output, length); /* Validate output */ zassert_true( @@ -146,13 +146,13 @@ static void test_arm_negate_f16( free(output); } -DEFINE_TEST_VARIANT3(basic_math_f16, arm_negate_f16, 7, in_com1, ref_negate, 7); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_negate_f16, 16, in_com1, ref_negate, 16); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_negate_f16, 23, in_com1, ref_negate, 23); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_negate_f16, long, in_com1, ref_negate, +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, 7, in_com1, ref_negate, 7); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, 16, in_com1, ref_negate, 16); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, 23, in_com1, ref_negate, 23); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_negate_f16, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); -static void test_arm_offset_f16( +static void test_zdsp_offset_f16( const uint16_t *input1, float16_t scalar, const uint16_t *ref, size_t length) { @@ -163,7 +163,7 @@ static void test_arm_offset_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_offset_f16((float16_t *)input1, scalar, output, length); + zdsp_offset_f16((float16_t *)input1, scalar, output, length); /* Validate output */ zassert_true( @@ -180,13 +180,13 @@ static void test_arm_offset_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_offset_f16, 0p5_7, in_com1, 0.5f, ref_offset, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_offset_f16, 0p5_16, in_com1, 0.5f, ref_offset, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_offset_f16, 0p5_23, in_com1, 0.5f, ref_offset, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_offset_f16, long, in_com1, 0.5f, ref_offset, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, 0p5_7, in_com1, 0.5f, ref_offset, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, 0p5_16, in_com1, 0.5f, ref_offset, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, 0p5_23, in_com1, 0.5f, ref_offset, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_offset_f16, long, in_com1, 0.5f, ref_offset, ARRAY_SIZE(in_com1)); -static void test_arm_scale_f16( +static void test_zdsp_scale_f16( const uint16_t *input1, float16_t scalar, const uint16_t *ref, size_t length) { @@ -197,7 +197,7 @@ static void test_arm_scale_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_scale_f16((float16_t *)input1, scalar, output, length); + zdsp_scale_f16((float16_t *)input1, scalar, output, length); /* Validate output */ zassert_true( @@ -214,13 +214,13 @@ static void test_arm_scale_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_scale_f16, 0p5_7, in_com1, 0.5f, ref_scale, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_scale_f16, 0p5_16, in_com1, 0.5f, ref_scale, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_scale_f16, 0p5_23, in_com1, 0.5f, ref_scale, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_scale_f16, long, in_com1, 0.5f, ref_scale, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, 0p5_7, in_com1, 0.5f, ref_scale, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, 0p5_16, in_com1, 0.5f, ref_scale, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, 0p5_23, in_com1, 0.5f, ref_scale, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_scale_f16, long, in_com1, 0.5f, ref_scale, ARRAY_SIZE(in_com1)); -static void test_arm_dot_prod_f16( +static void test_zdsp_dot_prod_f16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -231,7 +231,7 @@ static void test_arm_dot_prod_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_dot_prod_f16( + zdsp_dot_prod_f16( (float16_t *)input1, (float16_t *)input2, length, &output[0]); /* Validate output */ @@ -249,13 +249,13 @@ static void test_arm_dot_prod_f16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f16, arm_dot_prod_f16, 7, in_com1, in_com2, ref_dot_prod_3, 7); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_dot_prod_f16, 16, in_com1, in_com2, ref_dot_prod_4, 16); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_dot_prod_f16, 23, in_com1, in_com2, ref_dot_prod_4n1, 23); -DEFINE_TEST_VARIANT4(basic_math_f16, arm_dot_prod_f16, long, in_com1, in_com2, ref_dot_prod_long, +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_dot_prod_f16, 7, in_com1, in_com2, ref_dot_prod_3, 7); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_dot_prod_f16, 16, in_com1, in_com2, ref_dot_prod_4, 16); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_dot_prod_f16, 23, in_com1, in_com2, ref_dot_prod_4n1, 23); +DEFINE_TEST_VARIANT4(basic_math_f16, zdsp_dot_prod_f16, long, in_com1, in_com2, ref_dot_prod_long, ARRAY_SIZE(in_com1)); -static void test_arm_abs_f16( +static void test_zdsp_abs_f16( const uint16_t *input1, const uint16_t *ref, size_t length) { float16_t *output; @@ -265,7 +265,7 @@ static void test_arm_abs_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_abs_f16((float16_t *)input1, output, length); + zdsp_abs_f16((float16_t *)input1, output, length); /* Validate output */ zassert_true( @@ -282,12 +282,12 @@ static void test_arm_abs_f16( free(output); } -DEFINE_TEST_VARIANT3(basic_math_f16, arm_abs_f16, 7, in_com1, ref_abs, 7); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_abs_f16, 16, in_com1, ref_abs, 16); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_abs_f16, 23, in_com1, ref_abs, 23); -DEFINE_TEST_VARIANT3(basic_math_f16, arm_abs_f16, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, 7, in_com1, ref_abs, 7); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, 16, in_com1, ref_abs, 16); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, 23, in_com1, ref_abs, 23); +DEFINE_TEST_VARIANT3(basic_math_f16, zdsp_abs_f16, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); -static void test_arm_clip_f16( +static void test_zdsp_clip_f16( const uint16_t *input, const uint16_t *ref, float16_t min, float16_t max, size_t length) { float16_t *output; @@ -297,7 +297,7 @@ static void test_arm_clip_f16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_clip_f16((float16_t *)input, output, min, max, length); + zdsp_clip_f16((float16_t *)input, output, min, max, length); /* Validate output */ zassert_true( @@ -314,11 +314,11 @@ static void test_arm_clip_f16( free(output); } -DEFINE_TEST_VARIANT5(basic_math_f16, arm_clip_f16, m0p5_m0p1, in_clip, ref_clip1, +DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16, m0p5_m0p1, in_clip, ref_clip1, -0.5f, -0.1f, ARRAY_SIZE(ref_clip1)); -DEFINE_TEST_VARIANT5(basic_math_f16, arm_clip_f16, m0p5_0p5, in_clip, ref_clip2, +DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16, m0p5_0p5, in_clip, ref_clip2, -0.5f, 0.5f, ARRAY_SIZE(ref_clip2)); -DEFINE_TEST_VARIANT5(basic_math_f16, arm_clip_f16, 0p1_0p5, in_clip, ref_clip3, +DEFINE_TEST_VARIANT5(basic_math_f16, zdsp_clip_f16, 0p1_0p5, in_clip, ref_clip3, 0.1f, 0.5f, ARRAY_SIZE(ref_clip3)); ZTEST_SUITE(basic_math_f16, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/lib/cmsis_dsp/basicmath/src/f16.pat b/tests/subsys/dsp/basicmath/src/f16.pat similarity index 100% rename from tests/lib/cmsis_dsp/basicmath/src/f16.pat rename to tests/subsys/dsp/basicmath/src/f16.pat diff --git a/tests/lib/cmsis_dsp/basicmath/src/f32.c b/tests/subsys/dsp/basicmath/src/f32.c similarity index 60% rename from tests/lib/cmsis_dsp/basicmath/src/f32.c rename to tests/subsys/dsp/basicmath/src/f32.c index b8f27223f3efb..05b3d22200b5d 100644 --- a/tests/lib/cmsis_dsp/basicmath/src/f32.c +++ b/tests/subsys/dsp/basicmath/src/f32.c @@ -5,18 +5,18 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include #include #include -#include -#include "../../common/test_common.h" +#include "common/test_common.h" #include "f32.pat" #define SNR_ERROR_THRESH ((float32_t)120) #define REL_ERROR_THRESH (5.0e-5) -static void test_arm_add_f32( +static void test_zdsp_add_f32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { @@ -27,7 +27,7 @@ static void test_arm_add_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_add_f32((float32_t *)input1, (float32_t *)input2, output, length); + zdsp_add_f32((float32_t *)input1, (float32_t *)input2, output, length); /* Validate output */ zassert_true( @@ -44,13 +44,13 @@ static void test_arm_add_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_add_f32, 3, in_com1, in_com2, ref_add, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_add_f32, 8, in_com1, in_com2, ref_add, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_add_f32, 11, in_com1, in_com2, ref_add, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_add_f32, long, in_com1, in_com2, ref_add, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, 3, in_com1, in_com2, ref_add, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, 8, in_com1, in_com2, ref_add, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, 11, in_com1, in_com2, ref_add, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_add_f32, long, in_com1, in_com2, ref_add, ARRAY_SIZE(in_com1)); -static void test_arm_sub_f32( +static void test_zdsp_sub_f32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { @@ -61,7 +61,7 @@ static void test_arm_sub_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_sub_f32((float32_t *)input1, (float32_t *)input2, output, length); + zdsp_sub_f32((float32_t *)input1, (float32_t *)input2, output, length); /* Validate output */ zassert_true( @@ -78,13 +78,13 @@ static void test_arm_sub_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_sub_f32, 3, in_com1, in_com2, ref_sub, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_sub_f32, 8, in_com1, in_com2, ref_sub, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_sub_f32, 11, in_com1, in_com2, ref_sub, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_sub_f32, long, in_com1, in_com2, ref_sub, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, 3, in_com1, in_com2, ref_sub, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, 8, in_com1, in_com2, ref_sub, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, 11, in_com1, in_com2, ref_sub, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_sub_f32, long, in_com1, in_com2, ref_sub, ARRAY_SIZE(in_com1)); -static void test_arm_mult_f32( +static void test_zdsp_mult_f32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { @@ -95,7 +95,7 @@ static void test_arm_mult_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_mult_f32((float32_t *)input1, (float32_t *)input2, output, length); + zdsp_mult_f32((float32_t *)input1, (float32_t *)input2, output, length); /* Validate output */ zassert_true( @@ -112,13 +112,13 @@ static void test_arm_mult_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_mult_f32, 3, in_com1, in_com2, ref_mult, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_mult_f32, 8, in_com1, in_com2, ref_mult, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_mult_f32, 11, in_com1, in_com2, ref_mult, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_mult_f32, long, in_com1, in_com2, ref_mult, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, 3, in_com1, in_com2, ref_mult, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, 8, in_com1, in_com2, ref_mult, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, 11, in_com1, in_com2, ref_mult, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_mult_f32, long, in_com1, in_com2, ref_mult, ARRAY_SIZE(in_com1)); -static void test_arm_negate_f32( +static void test_zdsp_negate_f32( const uint32_t *input1, const uint32_t *ref, size_t length) { float32_t *output; @@ -128,7 +128,7 @@ static void test_arm_negate_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_negate_f32((float32_t *)input1, output, length); + zdsp_negate_f32((float32_t *)input1, output, length); /* Validate output */ zassert_true( @@ -145,13 +145,13 @@ static void test_arm_negate_f32( free(output); } -DEFINE_TEST_VARIANT3(basic_math_f32, arm_negate_f32, 3, in_com1, ref_negate, 3); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_negate_f32, 8, in_com1, ref_negate, 8); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_negate_f32, 11, in_com1, ref_negate, 11); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_negate_f32, long, in_com1, ref_negate, +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, 3, in_com1, ref_negate, 3); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, 8, in_com1, ref_negate, 8); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, 11, in_com1, ref_negate, 11); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_negate_f32, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); -static void test_arm_offset_f32( +static void test_zdsp_offset_f32( const uint32_t *input1, float32_t scalar, const uint32_t *ref, size_t length) { @@ -162,7 +162,7 @@ static void test_arm_offset_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_offset_f32((float32_t *)input1, scalar, output, length); + zdsp_offset_f32((float32_t *)input1, scalar, output, length); /* Validate output */ zassert_true( @@ -179,13 +179,13 @@ static void test_arm_offset_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_offset_f32, 0p5_3, in_com1, 0.5f, ref_offset, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_offset_f32, 0p5_8, in_com1, 0.5f, ref_offset, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_offset_f32, 0p5_11, in_com1, 0.5f, ref_offset, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_offset_f32, long, in_com1, 0.5f, ref_offset, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, 0p5_3, in_com1, 0.5f, ref_offset, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, 0p5_8, in_com1, 0.5f, ref_offset, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, 0p5_11, in_com1, 0.5f, ref_offset, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_offset_f32, long, in_com1, 0.5f, ref_offset, ARRAY_SIZE(in_com1)); -static void test_arm_scale_f32( +static void test_zdsp_scale_f32( const uint32_t *input1, float32_t scalar, const uint32_t *ref, size_t length) { @@ -196,7 +196,7 @@ static void test_arm_scale_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_scale_f32((float32_t *)input1, scalar, output, length); + zdsp_scale_f32((float32_t *)input1, scalar, output, length); /* Validate output */ zassert_true( @@ -213,13 +213,13 @@ static void test_arm_scale_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_scale_f32, 0p5_3, in_com1, 0.5f, ref_scale, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_scale_f32, 0p5_8, in_com1, 0.5f, ref_scale, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_scale_f32, 0p5_11, in_com1, 0.5f, ref_scale, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_scale_f32, long, in_com1, 0.5f, ref_scale, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, 0p5_3, in_com1, 0.5f, ref_scale, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, 0p5_8, in_com1, 0.5f, ref_scale, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, 0p5_11, in_com1, 0.5f, ref_scale, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_scale_f32, long, in_com1, 0.5f, ref_scale, ARRAY_SIZE(in_com1)); -static void test_arm_dot_prod_f32( +static void test_zdsp_dot_prod_f32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { @@ -230,7 +230,7 @@ static void test_arm_dot_prod_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_dot_prod_f32( + zdsp_dot_prod_f32( (float32_t *)input1, (float32_t *)input2, length, &output[0]); /* Validate output */ @@ -248,13 +248,13 @@ static void test_arm_dot_prod_f32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_f32, arm_dot_prod_f32, 3, in_com1, in_com2, ref_dot_prod_3, 3); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_dot_prod_f32, 8, in_com1, in_com2, ref_dot_prod_4, 8); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_dot_prod_f32, 11, in_com1, in_com2, ref_dot_prod_4n1, 11); -DEFINE_TEST_VARIANT4(basic_math_f32, arm_dot_prod_f32, long, in_com1, in_com2, ref_dot_prod_long, +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_dot_prod_f32, 3, in_com1, in_com2, ref_dot_prod_3, 3); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_dot_prod_f32, 8, in_com1, in_com2, ref_dot_prod_4, 8); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_dot_prod_f32, 11, in_com1, in_com2, ref_dot_prod_4n1, 11); +DEFINE_TEST_VARIANT4(basic_math_f32, zdsp_dot_prod_f32, long, in_com1, in_com2, ref_dot_prod_long, ARRAY_SIZE(in_com1)); -static void test_arm_abs_f32( +static void test_zdsp_abs_f32( const uint32_t *input1, const uint32_t *ref, size_t length) { float32_t *output; @@ -264,7 +264,7 @@ static void test_arm_abs_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_abs_f32((float32_t *)input1, output, length); + zdsp_abs_f32((float32_t *)input1, output, length); /* Validate output */ zassert_true( @@ -281,12 +281,12 @@ static void test_arm_abs_f32( free(output); } -DEFINE_TEST_VARIANT3(basic_math_f32, arm_abs_f32, 3, in_com1, ref_abs, 3); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_abs_f32, 8, in_com1, ref_abs, 8); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_abs_f32, 11, in_com1, ref_abs, 11); -DEFINE_TEST_VARIANT3(basic_math_f32, arm_abs_f32, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, 3, in_com1, ref_abs, 3); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, 8, in_com1, ref_abs, 8); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, 11, in_com1, ref_abs, 11); +DEFINE_TEST_VARIANT3(basic_math_f32, zdsp_abs_f32, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); -static void test_arm_clip_f32( +static void test_zdsp_clip_f32( const uint32_t *input, const uint32_t *ref, float32_t min, float32_t max, size_t length) { float32_t *output; @@ -296,7 +296,7 @@ static void test_arm_clip_f32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_clip_f32((float32_t *)input, output, min, max, length); + zdsp_clip_f32((float32_t *)input, output, min, max, length); /* Validate output */ zassert_true( @@ -313,11 +313,11 @@ static void test_arm_clip_f32( free(output); } -DEFINE_TEST_VARIANT5(basic_math_f32, arm_clip_f32, m0p5_m0p1, in_clip, ref_clip1, +DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32, m0p5_m0p1, in_clip, ref_clip1, -0.5f, -0.1f, ARRAY_SIZE(ref_clip1)); -DEFINE_TEST_VARIANT5(basic_math_f32, arm_clip_f32, m0p5_0p5, in_clip, ref_clip2, +DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32, m0p5_0p5, in_clip, ref_clip2, -0.5f, 0.5f, ARRAY_SIZE(ref_clip2)); -DEFINE_TEST_VARIANT5(basic_math_f32, arm_clip_f32, 0p1_0p5, in_clip, ref_clip3, +DEFINE_TEST_VARIANT5(basic_math_f32, zdsp_clip_f32, 0p1_0p5, in_clip, ref_clip3, 0.1f, 0.5f, ARRAY_SIZE(ref_clip3)); ZTEST_SUITE(basic_math_f32, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/lib/cmsis_dsp/basicmath/src/f32.pat b/tests/subsys/dsp/basicmath/src/f32.pat similarity index 100% rename from tests/lib/cmsis_dsp/basicmath/src/f32.pat rename to tests/subsys/dsp/basicmath/src/f32.pat diff --git a/tests/lib/cmsis_dsp/basicmath/src/q15.c b/tests/subsys/dsp/basicmath/src/q15.c similarity index 54% rename from tests/lib/cmsis_dsp/basicmath/src/q15.c rename to tests/subsys/dsp/basicmath/src/q15.c index 9c7938152ae7c..3e2b979136ca7 100644 --- a/tests/lib/cmsis_dsp/basicmath/src/q15.c +++ b/tests/subsys/dsp/basicmath/src/q15.c @@ -5,11 +5,11 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include #include #include -#include -#include "../../common/test_common.h" +#include "common/test_common.h" #include "q15.pat" @@ -18,7 +18,7 @@ #define ABS_ERROR_THRESH_Q15 ((q15_t)2) #define ABS_ERROR_THRESH_Q63 ((q63_t)(1 << 17)) -static void test_arm_add_q15( +static void test_zdsp_add_q15( const q15_t *input1, const q15_t *input2, const q15_t *ref, size_t length) { @@ -29,7 +29,7 @@ static void test_arm_add_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_add_q15(input1, input2, output, length); + zdsp_add_q15(input1, input2, output, length); /* Validate output */ zassert_true( @@ -44,15 +44,17 @@ static void test_arm_add_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, 7, in_com1, in_com2, ref_add, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, 16, in_com1, in_com2, ref_add, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, 23, in_com1, in_com2, ref_add, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, possat, in_maxpos, in_maxpos, ref_add_possat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, negsat, in_maxneg, in_maxneg, ref_add_negsat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_add_q15, long, in_com1, in_com2, ref_add, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, 7, in_com1, in_com2, ref_add, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, 16, in_com1, in_com2, ref_add, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, 23, in_com1, in_com2, ref_add, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, possat, in_maxpos, in_maxpos, ref_add_possat, + 17); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, negsat, in_maxneg, in_maxneg, ref_add_negsat, + 17); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_add_q15, long, in_com1, in_com2, ref_add, ARRAY_SIZE(in_com1)); -static void test_arm_sub_q15( +static void test_zdsp_sub_q15( const q15_t *input1, const q15_t *input2, const q15_t *ref, size_t length) { @@ -63,7 +65,7 @@ static void test_arm_sub_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_sub_q15(input1, input2, output, length); + zdsp_sub_q15(input1, input2, output, length); /* Validate output */ zassert_true( @@ -78,15 +80,17 @@ static void test_arm_sub_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, 7, in_com1, in_com2, ref_sub, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, 16, in_com1, in_com2, ref_sub, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, 23, in_com1, in_com2, ref_sub, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, possat, in_maxpos, in_maxneg, ref_sub_possat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, negsat, in_maxneg, in_maxpos, ref_sub_negsat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_sub_q15, long, in_com1, in_com2, ref_sub, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, 7, in_com1, in_com2, ref_sub, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, 16, in_com1, in_com2, ref_sub, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, 23, in_com1, in_com2, ref_sub, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, possat, in_maxpos, in_maxneg, ref_sub_possat, + 17); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, negsat, in_maxneg, in_maxpos, ref_sub_negsat, + 17); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_sub_q15, long, in_com1, in_com2, ref_sub, ARRAY_SIZE(in_com1)); -static void test_arm_mult_q15( +static void test_zdsp_mult_q15( const q15_t *input1, const q15_t *input2, const q15_t *ref, size_t length) { @@ -97,7 +101,7 @@ static void test_arm_mult_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_mult_q15(input1, input2, output, length); + zdsp_mult_q15(input1, input2, output, length); /* Validate output */ zassert_true( @@ -112,15 +116,15 @@ static void test_arm_mult_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_mult_q15, 7, in_com1, in_com2, ref_mult, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_mult_q15, 16, in_com1, in_com2, ref_mult, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_mult_q15, 23, in_com1, in_com2, ref_mult, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_mult_q15, possat, in_maxneg2, in_maxneg2, ref_mult_possat, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_mult_q15, 7, in_com1, in_com2, ref_mult, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_mult_q15, 16, in_com1, in_com2, ref_mult, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_mult_q15, 23, in_com1, in_com2, ref_mult, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_mult_q15, possat, in_maxneg2, in_maxneg2, ref_mult_possat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_mult_q15, long, in_com1, in_com2, ref_mult, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_mult_q15, long, in_com1, in_com2, ref_mult, ARRAY_SIZE(in_com1)); -static void test_arm_negate_q15( +static void test_zdsp_negate_q15( const q15_t *input1, const q15_t *ref, size_t length) { q15_t *output; @@ -130,7 +134,7 @@ static void test_arm_negate_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_negate_q15(input1, output, length); + zdsp_negate_q15(input1, output, length); /* Validate output */ zassert_true( @@ -145,14 +149,14 @@ static void test_arm_negate_q15( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q15, arm_negate_q15, 7, in_com1, ref_negate, 7); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_negate_q15, 16, in_com1, ref_negate, 16); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_negate_q15, 23, in_com1, ref_negate, 23); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_negate_q15, possat, in_maxneg2, ref_negate_possat, 17); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_negate_q15, long, in_com1, ref_negate, +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_negate_q15, 7, in_com1, ref_negate, 7); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_negate_q15, 16, in_com1, ref_negate, 16); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_negate_q15, 23, in_com1, ref_negate, 23); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_negate_q15, possat, in_maxneg2, ref_negate_possat, 17); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_negate_q15, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); -static void test_arm_offset_q15( +static void test_zdsp_offset_q15( const q15_t *input1, q15_t scalar, const q15_t *ref, size_t length) { q15_t *output; @@ -162,7 +166,7 @@ static void test_arm_offset_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_offset_q15(input1, scalar, output, length); + zdsp_offset_q15(input1, scalar, output, length); /* Validate output */ zassert_true( @@ -177,17 +181,17 @@ static void test_arm_offset_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, 0p5_7, in_com1, 0x4000, ref_offset, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, 0p5_16, in_com1, 0x4000, ref_offset, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, 0p5_23, in_com1, 0x4000, ref_offset, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, possat, in_maxpos, 0x7333, ref_offset_possat, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, 0p5_7, in_com1, 0x4000, ref_offset, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, 0p5_16, in_com1, 0x4000, ref_offset, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, 0p5_23, in_com1, 0x4000, ref_offset, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, possat, in_maxpos, 0x7333, ref_offset_possat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, negsat, in_maxneg, 0x8ccd, ref_offset_negsat, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, negsat, in_maxneg, 0x8ccd, ref_offset_negsat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_offset_q15, long, in_com1, 0x4000, ref_offset, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_offset_q15, long, in_com1, 0x4000, ref_offset, ARRAY_SIZE(in_com1)); -static void test_arm_scale_q15( +static void test_zdsp_scale_q15( const q15_t *input1, q15_t scalar, const q15_t *ref, size_t length) { q15_t *output; @@ -197,7 +201,7 @@ static void test_arm_scale_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_scale_q15(input1, scalar, 0, output, length); + zdsp_scale_q15(input1, scalar, 0, output, length); /* Validate output */ zassert_true( @@ -212,15 +216,15 @@ static void test_arm_scale_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_scale_q15, 0p5_7, in_com1, 0x4000, ref_scale, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_scale_q15, 0p5_16, in_com1, 0x4000, ref_scale, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_scale_q15, 0p5_23, in_com1, 0x4000, ref_scale, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_scale_q15, possat, in_maxneg2, 0x8000, ref_scale_possat, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_scale_q15, 0p5_7, in_com1, 0x4000, ref_scale, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_scale_q15, 0p5_16, in_com1, 0x4000, ref_scale, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_scale_q15, 0p5_23, in_com1, 0x4000, ref_scale, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_scale_q15, possat, in_maxneg2, 0x8000, ref_scale_possat, 17); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_scale_q15, long, in_com1, 0x4000, ref_scale, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_scale_q15, long, in_com1, 0x4000, ref_scale, ARRAY_SIZE(in_com1)); -static void test_arm_dot_prod_q15( +static void test_zdsp_dot_prod_q15( const q15_t *input1, const q15_t *input2, const q63_t *ref, size_t length) { @@ -231,7 +235,7 @@ static void test_arm_dot_prod_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_dot_prod_q15(input1, input2, length, &output[0]); + zdsp_dot_prod_q15(input1, input2, length, &output[0]); /* Validate output */ zassert_true( @@ -246,13 +250,13 @@ static void test_arm_dot_prod_q15( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_dot_prod_q15, 7, in_com1, in_com2, ref_dot_prod_3, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_dot_prod_q15, 16, in_com1, in_com2, ref_dot_prod_4, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_dot_prod_q15, 23, in_com1, in_com2, ref_dot_prod_4n1, 23); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_dot_prod_q15, long, in_com1, in_com2, ref_dot_prod_long, +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_dot_prod_q15, 7, in_com1, in_com2, ref_dot_prod_3, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_dot_prod_q15, 16, in_com1, in_com2, ref_dot_prod_4, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_dot_prod_q15, 23, in_com1, in_com2, ref_dot_prod_4n1, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_dot_prod_q15, long, in_com1, in_com2, ref_dot_prod_long, ARRAY_SIZE(in_com1)); -static void test_arm_abs_q15( +static void test_zdsp_abs_q15( const q15_t *input1, const q15_t *ref, size_t length) { q15_t *output; @@ -262,7 +266,7 @@ static void test_arm_abs_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_abs_q15(input1, output, length); + zdsp_abs_q15(input1, output, length); /* Validate output */ zassert_true( @@ -277,12 +281,12 @@ static void test_arm_abs_q15( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q15, arm_abs_q15, 7, in_com1, ref_abs, 7); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_abs_q15, 16, in_com1, ref_abs, 16); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_abs_q15, 23, in_com1, ref_abs, 23); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_abs_q15, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_abs_q15, 7, in_com1, ref_abs, 7); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_abs_q15, 16, in_com1, ref_abs, 16); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_abs_q15, 23, in_com1, ref_abs, 23); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_abs_q15, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); -static void test_arm_shift_q15( +static void test_zdsp_shift_q15( const q15_t *input1, const q15_t *ref, size_t length) { q15_t *output; @@ -292,7 +296,7 @@ static void test_arm_shift_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_shift_q15(input1, 1, output, length); + zdsp_shift_q15(input1, 1, output, length); /* Validate output */ zassert_true( @@ -307,11 +311,11 @@ static void test_arm_shift_q15( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q15, arm_shift_q15, rand, in_rand, ref_shift, 17); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_shift_q15, possat, in_maxpos, ref_shift_possat, 17); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_shift_q15, negsat, in_maxneg, ref_shift_negsat, 17); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_shift_q15, rand, in_rand, ref_shift, 17); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_shift_q15, possat, in_maxpos, ref_shift_possat, 17); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_shift_q15, negsat, in_maxneg, ref_shift_negsat, 17); -static void test_arm_and_u16( +static void test_zdsp_and_u16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -322,7 +326,7 @@ static void test_arm_and_u16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_and_u16(input1, input2, output, length); + zdsp_and_u16(input1, input2, output, length); /* Validate output */ zassert_true( @@ -333,11 +337,11 @@ static void test_arm_and_u16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_and_u16, 7, in_bitwise1, in_bitwise2, ref_and, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_and_u16, 16, in_bitwise1, in_bitwise2, ref_and, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_and_u16, 23, in_bitwise1, in_bitwise2, ref_and, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_and_u16, 7, in_bitwise1, in_bitwise2, ref_and, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_and_u16, 16, in_bitwise1, in_bitwise2, ref_and, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_and_u16, 23, in_bitwise1, in_bitwise2, ref_and, 23); -static void test_arm_or_u16( +static void test_zdsp_or_u16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -348,7 +352,7 @@ static void test_arm_or_u16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_or_u16(input1, input2, output, length); + zdsp_or_u16(input1, input2, output, length); /* Validate output */ zassert_true( @@ -359,11 +363,11 @@ static void test_arm_or_u16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_or_u16, 7, in_bitwise1, in_bitwise2, ref_or, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_or_u16, 16, in_bitwise1, in_bitwise2, ref_or, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_or_u16, 23, in_bitwise1, in_bitwise2, ref_or, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_or_u16, 7, in_bitwise1, in_bitwise2, ref_or, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_or_u16, 16, in_bitwise1, in_bitwise2, ref_or, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_or_u16, 23, in_bitwise1, in_bitwise2, ref_or, 23); -static void test_arm_not_u16( +static void test_zdsp_not_u16( const uint16_t *input1, const uint16_t *ref, size_t length) { uint16_t *output; @@ -373,7 +377,7 @@ static void test_arm_not_u16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_not_u16(input1, output, length); + zdsp_not_u16(input1, output, length); /* Validate output */ zassert_true( @@ -384,11 +388,11 @@ static void test_arm_not_u16( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q15, arm_not_u16, 7, in_bitwise1, ref_not, 7); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_not_u16, 16, in_bitwise1, ref_not, 16); -DEFINE_TEST_VARIANT3(basic_math_q15, arm_not_u16, 23, in_bitwise1, ref_not, 23); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_not_u16, 7, in_bitwise1, ref_not, 7); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_not_u16, 16, in_bitwise1, ref_not, 16); +DEFINE_TEST_VARIANT3(basic_math_q15, zdsp_not_u16, 23, in_bitwise1, ref_not, 23); -static void test_arm_xor_u16( +static void test_zdsp_xor_u16( const uint16_t *input1, const uint16_t *input2, const uint16_t *ref, size_t length) { @@ -399,7 +403,7 @@ static void test_arm_xor_u16( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_xor_u16(input1, input2, output, length); + zdsp_xor_u16(input1, input2, output, length); /* Validate output */ zassert_true( @@ -410,11 +414,11 @@ static void test_arm_xor_u16( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q15, arm_xor_u16, 7, in_bitwise1, in_bitwise2, ref_xor, 7); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_xor_u16, 16, in_bitwise1, in_bitwise2, ref_xor, 16); -DEFINE_TEST_VARIANT4(basic_math_q15, arm_xor_u16, 23, in_bitwise1, in_bitwise2, ref_xor, 23); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_xor_u16, 7, in_bitwise1, in_bitwise2, ref_xor, 7); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_xor_u16, 16, in_bitwise1, in_bitwise2, ref_xor, 16); +DEFINE_TEST_VARIANT4(basic_math_q15, zdsp_xor_u16, 23, in_bitwise1, in_bitwise2, ref_xor, 23); -static void test_arm_clip_q15( +static void test_zdsp_clip_q15( const q15_t *input, const q15_t *ref, q15_t min, q15_t max, size_t length) { q15_t *output; @@ -424,7 +428,7 @@ static void test_arm_clip_q15( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_clip_q15(input, output, min, max, length); + zdsp_clip_q15(input, output, min, max, length); /* Validate output */ zassert_true( @@ -435,11 +439,11 @@ static void test_arm_clip_q15( free(output); } -DEFINE_TEST_VARIANT5(basic_math_q15, arm_clip_q15, c000_f333, in_clip, ref_clip1, +DEFINE_TEST_VARIANT5(basic_math_q15, zdsp_clip_q15, c000_f333, in_clip, ref_clip1, 0xc000, 0xf333, ARRAY_SIZE(ref_clip1)); -DEFINE_TEST_VARIANT5(basic_math_q15, arm_clip_q15, c000_4000, in_clip, ref_clip2, +DEFINE_TEST_VARIANT5(basic_math_q15, zdsp_clip_q15, c000_4000, in_clip, ref_clip2, 0xc000, 0x4000, ARRAY_SIZE(ref_clip2)); -DEFINE_TEST_VARIANT5(basic_math_q15, arm_clip_q15, 0ccd_4000, in_clip, ref_clip3, +DEFINE_TEST_VARIANT5(basic_math_q15, zdsp_clip_q15, 0ccd_4000, in_clip, ref_clip3, 0x0ccd, 0x4000, ARRAY_SIZE(ref_clip3)); ZTEST_SUITE(basic_math_q15, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/lib/cmsis_dsp/basicmath/src/q15.pat b/tests/subsys/dsp/basicmath/src/q15.pat similarity index 100% rename from tests/lib/cmsis_dsp/basicmath/src/q15.pat rename to tests/subsys/dsp/basicmath/src/q15.pat diff --git a/tests/lib/cmsis_dsp/basicmath/src/q31.c b/tests/subsys/dsp/basicmath/src/q31.c similarity index 54% rename from tests/lib/cmsis_dsp/basicmath/src/q31.c rename to tests/subsys/dsp/basicmath/src/q31.c index dd0ff26c5c04f..7027d8c194cf1 100644 --- a/tests/lib/cmsis_dsp/basicmath/src/q31.c +++ b/tests/subsys/dsp/basicmath/src/q31.c @@ -5,11 +5,11 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include #include #include -#include -#include "../../common/test_common.h" +#include "common/test_common.h" #include "q31.pat" @@ -17,7 +17,7 @@ #define ABS_ERROR_THRESH_Q31 ((q31_t)4) #define ABS_ERROR_THRESH_Q63 ((q63_t)(1 << 17)) -static void test_arm_add_q31( +static void test_zdsp_add_q31( const q31_t *input1, const q31_t *input2, const q31_t *ref, size_t length) { q31_t *output; @@ -27,7 +27,7 @@ static void test_arm_add_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_add_q31(input1, input2, output, length); + zdsp_add_q31(input1, input2, output, length); /* Validate output */ zassert_true( @@ -42,15 +42,15 @@ static void test_arm_add_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, 3, in_com1, in_com2, ref_add, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, 8, in_com1, in_com2, ref_add, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, 11, in_com1, in_com2, ref_add, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, possat, in_maxpos, in_maxpos, ref_add_possat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, negsat, in_maxneg, in_maxneg, ref_add_negsat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_add_q31, long, in_com1, in_com2, ref_add, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, 3, in_com1, in_com2, ref_add, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, 8, in_com1, in_com2, ref_add, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, 11, in_com1, in_com2, ref_add, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, possat, in_maxpos, in_maxpos, ref_add_possat, 9); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, negsat, in_maxneg, in_maxneg, ref_add_negsat, 9); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_add_q31, long, in_com1, in_com2, ref_add, ARRAY_SIZE(in_com1)); -static void test_arm_sub_q31( +static void test_zdsp_sub_q31( const q31_t *input1, const q31_t *input2, const q31_t *ref, size_t length) { q31_t *output; @@ -60,7 +60,7 @@ static void test_arm_sub_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_sub_q31(input1, input2, output, length); + zdsp_sub_q31(input1, input2, output, length); /* Validate output */ zassert_true( @@ -75,15 +75,15 @@ static void test_arm_sub_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, 3, in_com1, in_com2, ref_sub, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, 8, in_com1, in_com2, ref_sub, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, 11, in_com1, in_com2, ref_sub, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, possat, in_maxpos, in_maxneg, ref_sub_possat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, negsat, in_maxneg, in_maxpos, ref_sub_negsat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_sub_q31, long, in_com1, in_com2, ref_sub, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, 3, in_com1, in_com2, ref_sub, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, 8, in_com1, in_com2, ref_sub, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, 11, in_com1, in_com2, ref_sub, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, possat, in_maxpos, in_maxneg, ref_sub_possat, 9); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, negsat, in_maxneg, in_maxpos, ref_sub_negsat, 9); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_sub_q31, long, in_com1, in_com2, ref_sub, ARRAY_SIZE(in_com1)); -static void test_arm_mult_q31( +static void test_zdsp_mult_q31( const q31_t *input1, const q31_t *input2, const q31_t *ref, size_t length) { q31_t *output; @@ -93,7 +93,7 @@ static void test_arm_mult_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_mult_q31(input1, input2, output, length); + zdsp_mult_q31(input1, input2, output, length); /* Validate output */ zassert_true( @@ -108,15 +108,15 @@ static void test_arm_mult_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_mult_q31, 3, in_com1, in_com2, ref_mult, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_mult_q31, 8, in_com1, in_com2, ref_mult, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_mult_q31, 11, in_com1, in_com2, ref_mult, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_mult_q31, possat, in_maxneg2, in_maxneg2, ref_mult_possat, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_mult_q31, 3, in_com1, in_com2, ref_mult, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_mult_q31, 8, in_com1, in_com2, ref_mult, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_mult_q31, 11, in_com1, in_com2, ref_mult, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_mult_q31, possat, in_maxneg2, in_maxneg2, ref_mult_possat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_mult_q31, long, in_com1, in_com2, ref_mult, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_mult_q31, long, in_com1, in_com2, ref_mult, ARRAY_SIZE(in_com1)); -static void test_arm_negate_q31( +static void test_zdsp_negate_q31( const q31_t *input1, const q31_t *ref, size_t length) { q31_t *output; @@ -126,7 +126,7 @@ static void test_arm_negate_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_negate_q31(input1, output, length); + zdsp_negate_q31(input1, output, length); /* Validate output */ zassert_true( @@ -141,14 +141,14 @@ static void test_arm_negate_q31( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q31, arm_negate_q31, 3, in_com1, ref_negate, 3); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_negate_q31, 8, in_com1, ref_negate, 8); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_negate_q31, 11, in_com1, ref_negate, 11); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_negate_q31, possat, in_maxneg2, ref_negate_possat, 9); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_negate_q31, long, in_com1, ref_negate, +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_negate_q31, 3, in_com1, ref_negate, 3); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_negate_q31, 8, in_com1, ref_negate, 8); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_negate_q31, 11, in_com1, ref_negate, 11); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_negate_q31, possat, in_maxneg2, ref_negate_possat, 9); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_negate_q31, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); -static void test_arm_offset_q31( +static void test_zdsp_offset_q31( const q31_t *input1, q31_t scalar, const q31_t *ref, size_t length) { q31_t *output; @@ -158,7 +158,7 @@ static void test_arm_offset_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_offset_q31(input1, scalar, output, length); + zdsp_offset_q31(input1, scalar, output, length); /* Validate output */ zassert_true( @@ -173,17 +173,17 @@ static void test_arm_offset_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, 0p5_3, in_com1, 0x40000000, ref_offset, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, 0p5_8, in_com1, 0x40000000, ref_offset, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, 0p5_11, in_com1, 0x40000000, ref_offset, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, possat, in_maxpos, 0x73333333, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, 0p5_3, in_com1, 0x40000000, ref_offset, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, 0p5_8, in_com1, 0x40000000, ref_offset, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, 0p5_11, in_com1, 0x40000000, ref_offset, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, possat, in_maxpos, 0x73333333, ref_offset_possat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, negsat, in_maxneg, 0x8ccccccd, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, negsat, in_maxneg, 0x8ccccccd, ref_offset_negsat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_offset_q31, long, in_com1, 0x40000000, ref_offset, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_offset_q31, long, in_com1, 0x40000000, ref_offset, ARRAY_SIZE(in_com1)); -static void test_arm_scale_q31( +static void test_zdsp_scale_q31( const q31_t *input1, q31_t scalar, const q31_t *ref, size_t length) { q31_t *output; @@ -193,7 +193,7 @@ static void test_arm_scale_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_scale_q31(input1, scalar, 0, output, length); + zdsp_scale_q31(input1, scalar, 0, output, length); /* Validate output */ zassert_true( @@ -208,15 +208,15 @@ static void test_arm_scale_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_scale_q31, 0p5_3, in_com1, 0x40000000, ref_scale, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_scale_q31, 0p5_8, in_com1, 0x40000000, ref_scale, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_scale_q31, 0p5_11, in_com1, 0x40000000, ref_scale, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_scale_q31, possat, in_maxneg2, 0x80000000, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_scale_q31, 0p5_3, in_com1, 0x40000000, ref_scale, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_scale_q31, 0p5_8, in_com1, 0x40000000, ref_scale, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_scale_q31, 0p5_11, in_com1, 0x40000000, ref_scale, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_scale_q31, possat, in_maxneg2, 0x80000000, ref_scale_possat, 9); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_scale_q31, long, in_com1, 0x40000000, ref_scale, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_scale_q31, long, in_com1, 0x40000000, ref_scale, ARRAY_SIZE(in_com1)); -static void test_arm_dot_prod_q31( +static void test_zdsp_dot_prod_q31( const q31_t *input1, const q31_t *input2, const q63_t *ref, size_t length) { q63_t *output; @@ -226,7 +226,7 @@ static void test_arm_dot_prod_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_dot_prod_q31(input1, input2, length, &output[0]); + zdsp_dot_prod_q31(input1, input2, length, &output[0]); /* Validate output */ zassert_true( @@ -241,13 +241,13 @@ static void test_arm_dot_prod_q31( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_dot_prod_q31, 3, in_com1, in_com2, ref_dot_prod_3, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_dot_prod_q31, 8, in_com1, in_com2, ref_dot_prod_4, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_dot_prod_q31, 11, in_com1, in_com2, ref_dot_prod_4n1, 11); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_dot_prod_q31, long, in_com1, in_com2, ref_dot_prod_long, +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_dot_prod_q31, 3, in_com1, in_com2, ref_dot_prod_3, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_dot_prod_q31, 8, in_com1, in_com2, ref_dot_prod_4, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_dot_prod_q31, 11, in_com1, in_com2, ref_dot_prod_4n1, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_dot_prod_q31, long, in_com1, in_com2, ref_dot_prod_long, ARRAY_SIZE(in_com1)); -static void test_arm_abs_q31( +static void test_zdsp_abs_q31( const q31_t *input1, const q31_t *ref, size_t length) { q31_t *output; @@ -257,7 +257,7 @@ static void test_arm_abs_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_abs_q31(input1, output, length); + zdsp_abs_q31(input1, output, length); /* Validate output */ zassert_true( @@ -272,12 +272,12 @@ static void test_arm_abs_q31( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q31, arm_abs_q31, 3, in_com1, ref_abs, 3); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_abs_q31, 8, in_com1, ref_abs, 8); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_abs_q31, 11, in_com1, ref_abs, 11); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_abs_q31, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_abs_q31, 3, in_com1, ref_abs, 3); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_abs_q31, 8, in_com1, ref_abs, 8); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_abs_q31, 11, in_com1, ref_abs, 11); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_abs_q31, long, in_com1, ref_abs, ARRAY_SIZE(in_com1)); -static void test_arm_shift_q31( +static void test_zdsp_shift_q31( const q31_t *input1, const q31_t *ref, size_t length) { q31_t *output; @@ -287,7 +287,7 @@ static void test_arm_shift_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_shift_q31(input1, 1, output, length); + zdsp_shift_q31(input1, 1, output, length); /* Validate output */ zassert_true( @@ -302,11 +302,11 @@ static void test_arm_shift_q31( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q31, arm_shift_q31, rand, in_rand, ref_shift, 9); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_shift_q31, possat, in_maxpos, ref_shift_possat, 9); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_shift_q31, negsat, in_maxneg, ref_shift_negsat, 9); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_shift_q31, rand, in_rand, ref_shift, 9); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_shift_q31, possat, in_maxpos, ref_shift_possat, 9); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_shift_q31, negsat, in_maxneg, ref_shift_negsat, 9); -static void test_arm_and_u32( +static void test_zdsp_and_u32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { uint32_t *output; @@ -316,7 +316,7 @@ static void test_arm_and_u32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_and_u32(input1, input2, output, length); + zdsp_and_u32(input1, input2, output, length); /* Validate output */ zassert_true( @@ -327,11 +327,11 @@ static void test_arm_and_u32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_and_u32, 3, in_bitwise1, in_bitwise2, ref_and, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_and_u32, 8, in_bitwise1, in_bitwise2, ref_and, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_and_u32, 11, in_bitwise1, in_bitwise2, ref_and, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_and_u32, 3, in_bitwise1, in_bitwise2, ref_and, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_and_u32, 8, in_bitwise1, in_bitwise2, ref_and, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_and_u32, 11, in_bitwise1, in_bitwise2, ref_and, 11); -static void test_arm_or_u32( +static void test_zdsp_or_u32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { uint32_t *output; @@ -341,7 +341,7 @@ static void test_arm_or_u32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_or_u32(input1, input2, output, length); + zdsp_or_u32(input1, input2, output, length); /* Validate output */ zassert_true( @@ -352,11 +352,11 @@ static void test_arm_or_u32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_or_u32, 3, in_bitwise1, in_bitwise2, ref_or, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_or_u32, 8, in_bitwise1, in_bitwise2, ref_or, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_or_u32, 11, in_bitwise1, in_bitwise2, ref_or, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_or_u32, 3, in_bitwise1, in_bitwise2, ref_or, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_or_u32, 8, in_bitwise1, in_bitwise2, ref_or, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_or_u32, 11, in_bitwise1, in_bitwise2, ref_or, 11); -static void test_arm_not_u32( +static void test_zdsp_not_u32( const uint32_t *input1, const uint32_t *ref, size_t length) { uint32_t *output; @@ -366,7 +366,7 @@ static void test_arm_not_u32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_not_u32(input1, output, length); + zdsp_not_u32(input1, output, length); /* Validate output */ zassert_true( @@ -377,11 +377,11 @@ static void test_arm_not_u32( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q31, arm_not_u32, 3, in_bitwise1, ref_not, 3); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_not_u32, 8, in_bitwise1, ref_not, 8); -DEFINE_TEST_VARIANT3(basic_math_q31, arm_not_u32, 11, in_bitwise1, ref_not, 11); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_not_u32, 3, in_bitwise1, ref_not, 3); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_not_u32, 8, in_bitwise1, ref_not, 8); +DEFINE_TEST_VARIANT3(basic_math_q31, zdsp_not_u32, 11, in_bitwise1, ref_not, 11); -static void test_arm_xor_u32( +static void test_zdsp_xor_u32( const uint32_t *input1, const uint32_t *input2, const uint32_t *ref, size_t length) { uint32_t *output; @@ -391,7 +391,7 @@ static void test_arm_xor_u32( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_xor_u32(input1, input2, output, length); + zdsp_xor_u32(input1, input2, output, length); /* Validate output */ zassert_true( @@ -402,11 +402,11 @@ static void test_arm_xor_u32( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q31, arm_xor_u32, 3, in_bitwise1, in_bitwise2, ref_xor, 3); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_xor_u32, 8, in_bitwise1, in_bitwise2, ref_xor, 8); -DEFINE_TEST_VARIANT4(basic_math_q31, arm_xor_u32, 11, in_bitwise1, in_bitwise2, ref_xor, 11); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_xor_u32, 3, in_bitwise1, in_bitwise2, ref_xor, 3); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_xor_u32, 8, in_bitwise1, in_bitwise2, ref_xor, 8); +DEFINE_TEST_VARIANT4(basic_math_q31, zdsp_xor_u32, 11, in_bitwise1, in_bitwise2, ref_xor, 11); -static void test_arm_clip_q31( +static void test_zdsp_clip_q31( const q31_t *input, const q31_t *ref, q31_t min, q31_t max, size_t length) { q31_t *output; @@ -416,7 +416,7 @@ static void test_arm_clip_q31( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_clip_q31(input, output, min, max, length); + zdsp_clip_q31(input, output, min, max, length); /* Validate output */ zassert_true( @@ -427,11 +427,11 @@ static void test_arm_clip_q31( free(output); } -DEFINE_TEST_VARIANT5(basic_math_q31, arm_clip_q31, c0000000_f3333333, in_clip, ref_clip1, +DEFINE_TEST_VARIANT5(basic_math_q31, zdsp_clip_q31, c0000000_f3333333, in_clip, ref_clip1, 0xc0000000, 0xf3333333, ARRAY_SIZE(ref_clip1)); -DEFINE_TEST_VARIANT5(basic_math_q31, arm_clip_q31, c0000000_40000000, in_clip, ref_clip2, +DEFINE_TEST_VARIANT5(basic_math_q31, zdsp_clip_q31, c0000000_40000000, in_clip, ref_clip2, 0xc0000000, 0x40000000, ARRAY_SIZE(ref_clip2)); -DEFINE_TEST_VARIANT5(basic_math_q31, arm_clip_q31, 0ccccccd_40000000, in_clip, ref_clip3, +DEFINE_TEST_VARIANT5(basic_math_q31, zdsp_clip_q31, 0ccccccd_40000000, in_clip, ref_clip3, 0x0ccccccd, 0x40000000, ARRAY_SIZE(ref_clip3)); ZTEST_SUITE(basic_math_q31, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/lib/cmsis_dsp/basicmath/src/q31.pat b/tests/subsys/dsp/basicmath/src/q31.pat similarity index 100% rename from tests/lib/cmsis_dsp/basicmath/src/q31.pat rename to tests/subsys/dsp/basicmath/src/q31.pat diff --git a/tests/lib/cmsis_dsp/basicmath/src/q7.c b/tests/subsys/dsp/basicmath/src/q7.c similarity index 54% rename from tests/lib/cmsis_dsp/basicmath/src/q7.c rename to tests/subsys/dsp/basicmath/src/q7.c index cb9628fc3b358..1193903810838 100644 --- a/tests/lib/cmsis_dsp/basicmath/src/q7.c +++ b/tests/subsys/dsp/basicmath/src/q7.c @@ -5,11 +5,11 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include #include #include -#include -#include "../../common/test_common.h" +#include "common/test_common.h" #include "q7.pat" @@ -17,7 +17,7 @@ #define ABS_ERROR_THRESH_Q7 ((q7_t)2) #define ABS_ERROR_THRESH_Q31 ((q31_t)(1 << 15)) -static void test_arm_add_q7( +static void test_zdsp_add_q7( const q7_t *input1, const q7_t *input2, const q7_t *ref, size_t length) { q7_t *output; @@ -27,7 +27,7 @@ static void test_arm_add_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_add_q7(input1, input2, output, length); + zdsp_add_q7(input1, input2, output, length); /* Validate output */ zassert_true( @@ -42,15 +42,15 @@ static void test_arm_add_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, 15, in_com1, in_com2, ref_add, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, 32, in_com1, in_com2, ref_add, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, 47, in_com1, in_com2, ref_add, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, possat, in_maxpos, in_maxpos, ref_add_possat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, negsat, in_maxneg, in_maxneg, ref_add_negsat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_add_q7, long, in_com1, in_com2, ref_add, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, 15, in_com1, in_com2, ref_add, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, 32, in_com1, in_com2, ref_add, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, 47, in_com1, in_com2, ref_add, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, possat, in_maxpos, in_maxpos, ref_add_possat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, negsat, in_maxneg, in_maxneg, ref_add_negsat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_add_q7, long, in_com1, in_com2, ref_add, ARRAY_SIZE(in_com1)); -static void test_arm_sub_q7( +static void test_zdsp_sub_q7( const q7_t *input1, const q7_t *input2, const q7_t *ref, size_t length) { q7_t *output; @@ -60,7 +60,7 @@ static void test_arm_sub_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_sub_q7(input1, input2, output, length); + zdsp_sub_q7(input1, input2, output, length); /* Validate output */ zassert_true( @@ -75,15 +75,15 @@ static void test_arm_sub_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, 15, in_com1, in_com2, ref_sub, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, 32, in_com1, in_com2, ref_sub, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, 47, in_com1, in_com2, ref_sub, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, possat, in_maxpos, in_maxneg, ref_sub_possat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, negsat, in_maxneg, in_maxpos, ref_sub_negsat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_sub_q7, long, in_com1, in_com2, ref_sub, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, 15, in_com1, in_com2, ref_sub, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, 32, in_com1, in_com2, ref_sub, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, 47, in_com1, in_com2, ref_sub, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, possat, in_maxpos, in_maxneg, ref_sub_possat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, negsat, in_maxneg, in_maxpos, ref_sub_negsat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_sub_q7, long, in_com1, in_com2, ref_sub, ARRAY_SIZE(in_com1)); -static void test_arm_mult_q7( +static void test_zdsp_mult_q7( const q7_t *input1, const q7_t *input2, const q7_t *ref, size_t length) { q7_t *output; @@ -93,7 +93,7 @@ static void test_arm_mult_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_mult_q7(input1, input2, output, length); + zdsp_mult_q7(input1, input2, output, length); /* Validate output */ zassert_true( @@ -108,15 +108,15 @@ static void test_arm_mult_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_mult_q7, 15, in_com1, in_com2, ref_mult, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_mult_q7, 32, in_com1, in_com2, ref_mult, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_mult_q7, 47, in_com1, in_com2, ref_mult, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_mult_q7, possat, in_maxneg2, in_maxneg2, ref_mult_possat, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_mult_q7, 15, in_com1, in_com2, ref_mult, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_mult_q7, 32, in_com1, in_com2, ref_mult, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_mult_q7, 47, in_com1, in_com2, ref_mult, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_mult_q7, possat, in_maxneg2, in_maxneg2, ref_mult_possat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_mult_q7, long, in_com1, in_com2, ref_mult, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_mult_q7, long, in_com1, in_com2, ref_mult, ARRAY_SIZE(in_com1)); -static void test_arm_negate_q7( +static void test_zdsp_negate_q7( const q7_t *input1, const q7_t *ref, size_t length) { q7_t *output; @@ -126,7 +126,7 @@ static void test_arm_negate_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_negate_q7(input1, output, length); + zdsp_negate_q7(input1, output, length); /* Validate output */ zassert_true( @@ -141,13 +141,13 @@ static void test_arm_negate_q7( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q7, arm_negate_q7, 15, in_com1, ref_negate, 15); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_negate_q7, 32, in_com1, ref_negate, 32); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_negate_q7, 47, in_com1, ref_negate, 47); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_negate_q7, possat, in_maxneg2, ref_negate_possat, 33); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_negate_q7, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_negate_q7, 15, in_com1, ref_negate, 15); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_negate_q7, 32, in_com1, ref_negate, 32); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_negate_q7, 47, in_com1, ref_negate, 47); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_negate_q7, possat, in_maxneg2, ref_negate_possat, 33); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_negate_q7, long, in_com1, ref_negate, ARRAY_SIZE(in_com1)); -static void test_arm_offset_q7( +static void test_zdsp_offset_q7( const q7_t *input1, q7_t scalar, const q7_t *ref, size_t length) { q7_t *output; @@ -157,7 +157,7 @@ static void test_arm_offset_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_offset_q7(input1, scalar, output, length); + zdsp_offset_q7(input1, scalar, output, length); /* Validate output */ zassert_true( @@ -172,15 +172,15 @@ static void test_arm_offset_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, 0p5_15, in_com1, 0x40, ref_offset, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, 0p5_32, in_com1, 0x40, ref_offset, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, 0p5_47, in_com1, 0x40, ref_offset, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, possat, in_maxpos, 0x73, ref_offset_possat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, negsat, in_maxneg, 0x8d, ref_offset_negsat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_offset_q7, long, in_com1, 0x40, ref_offset, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, 0p5_15, in_com1, 0x40, ref_offset, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, 0p5_32, in_com1, 0x40, ref_offset, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, 0p5_47, in_com1, 0x40, ref_offset, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, possat, in_maxpos, 0x73, ref_offset_possat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, negsat, in_maxneg, 0x8d, ref_offset_negsat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_offset_q7, long, in_com1, 0x40, ref_offset, ARRAY_SIZE(in_com1)); -static void test_arm_scale_q7( +static void test_zdsp_scale_q7( const q7_t *input1, q7_t scalar, const q7_t *ref, size_t length) { q7_t *output; @@ -190,7 +190,7 @@ static void test_arm_scale_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_scale_q7(input1, scalar, 0, output, length); + zdsp_scale_q7(input1, scalar, 0, output, length); /* Validate output */ zassert_true( @@ -205,14 +205,14 @@ static void test_arm_scale_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_scale_q7, 0p5_15, in_com1, 0x40, ref_scale, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_scale_q7, 0p5_32, in_com1, 0x40, ref_scale, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_scale_q7, 0p5_47, in_com1, 0x40, ref_scale, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_scale_q7, possat, in_maxneg2, 0x80, ref_scale_possat, 33); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_scale_q7, long, in_com1, 0x40, ref_scale, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_scale_q7, 0p5_15, in_com1, 0x40, ref_scale, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_scale_q7, 0p5_32, in_com1, 0x40, ref_scale, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_scale_q7, 0p5_47, in_com1, 0x40, ref_scale, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_scale_q7, possat, in_maxneg2, 0x80, ref_scale_possat, 33); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_scale_q7, long, in_com1, 0x40, ref_scale, ARRAY_SIZE(in_com1)); -static void test_arm_dot_prod_q7( +static void test_zdsp_dot_prod_q7( const q7_t *input1, const q7_t *input2, const q31_t *ref, size_t length) { @@ -223,7 +223,7 @@ static void test_arm_dot_prod_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_dot_prod_q7(input1, input2, length, &output[0]); + zdsp_dot_prod_q7(input1, input2, length, &output[0]); /* Validate output */ zassert_true( @@ -238,13 +238,13 @@ static void test_arm_dot_prod_q7( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_dot_prod_q7, 15, in_com1, in_com2, ref_dot_prod_3, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_dot_prod_q7, 32, in_com1, in_com2, ref_dot_prod_4, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_dot_prod_q7, 47, in_com1, in_com2, ref_dot_prod_4n1, 47); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_dot_prod_q7, long, in_com1, in_com2, ref_dot_prod_long, +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_dot_prod_q7, 15, in_com1, in_com2, ref_dot_prod_3, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_dot_prod_q7, 32, in_com1, in_com2, ref_dot_prod_4, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_dot_prod_q7, 47, in_com1, in_com2, ref_dot_prod_4n1, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_dot_prod_q7, long, in_com1, in_com2, ref_dot_prod_long, ARRAY_SIZE(in_com1)); -static void test_arm_abs_q7( +static void test_zdsp_abs_q7( const q7_t *input1, const q7_t *ref, size_t length) { q7_t *output; @@ -254,7 +254,7 @@ static void test_arm_abs_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_abs_q7(input1, output, length); + zdsp_abs_q7(input1, output, length); /* Validate output */ zassert_true( @@ -269,12 +269,12 @@ static void test_arm_abs_q7( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q7, arm_abs_q7, 15, in_com1, ref_abs, 15); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_abs_q7, 32, in_com1, ref_abs, 32); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_abs_q7, 47, in_com1, ref_abs, 47); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_abs_q7, long, in_com1, ref_abs, ARRAY_SIZE(ref_abs)); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_abs_q7, 15, in_com1, ref_abs, 15); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_abs_q7, 32, in_com1, ref_abs, 32); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_abs_q7, 47, in_com1, ref_abs, 47); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_abs_q7, long, in_com1, ref_abs, ARRAY_SIZE(ref_abs)); -static void test_arm_shift_q7( +static void test_zdsp_shift_q7( const q7_t *input1, const q7_t *ref, size_t length) { q7_t *output; @@ -284,7 +284,7 @@ static void test_arm_shift_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_shift_q7(input1, 1, output, length); + zdsp_shift_q7(input1, 1, output, length); /* Validate output */ zassert_true( @@ -299,11 +299,11 @@ static void test_arm_shift_q7( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q7, arm_shift_q7, rand, in_rand, ref_shift, 33); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_shift_q7, possat, in_maxpos, ref_shift_possat, 33); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_shift_q7, negsat, in_maxneg, ref_shift_negsat, 33); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_shift_q7, rand, in_rand, ref_shift, 33); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_shift_q7, possat, in_maxpos, ref_shift_possat, 33); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_shift_q7, negsat, in_maxneg, ref_shift_negsat, 33); -static void test_arm_and_u8( +static void test_zdsp_and_u8( const uint8_t *input1, const uint8_t *input2, const uint8_t *ref, size_t length) { uint8_t *output; @@ -313,7 +313,7 @@ static void test_arm_and_u8( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_and_u8(input1, input2, output, length); + zdsp_and_u8(input1, input2, output, length); /* Validate output */ zassert_true( @@ -324,11 +324,11 @@ static void test_arm_and_u8( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_and_u8, 15, in_bitwise1, in_bitwise2, ref_and, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_and_u8, 32, in_bitwise1, in_bitwise2, ref_and, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_and_u8, 47, in_bitwise1, in_bitwise2, ref_and, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_and_u8, 15, in_bitwise1, in_bitwise2, ref_and, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_and_u8, 32, in_bitwise1, in_bitwise2, ref_and, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_and_u8, 47, in_bitwise1, in_bitwise2, ref_and, 47); -static void test_arm_or_u8( +static void test_zdsp_or_u8( const uint8_t *input1, const uint8_t *input2, const uint8_t *ref, size_t length) { uint8_t *output; @@ -338,7 +338,7 @@ static void test_arm_or_u8( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_or_u8(input1, input2, output, length); + zdsp_or_u8(input1, input2, output, length); /* Validate output */ zassert_true( @@ -349,11 +349,11 @@ static void test_arm_or_u8( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_or_u8, 15, in_bitwise1, in_bitwise2, ref_or, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_or_u8, 32, in_bitwise1, in_bitwise2, ref_or, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_or_u8, 47, in_bitwise1, in_bitwise2, ref_or, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_or_u8, 15, in_bitwise1, in_bitwise2, ref_or, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_or_u8, 32, in_bitwise1, in_bitwise2, ref_or, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_or_u8, 47, in_bitwise1, in_bitwise2, ref_or, 47); -static void test_arm_not_u8( +static void test_zdsp_not_u8( const uint8_t *input1, const uint8_t *ref, size_t length) { uint8_t *output; @@ -363,7 +363,7 @@ static void test_arm_not_u8( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_not_u8(input1, output, length); + zdsp_not_u8(input1, output, length); /* Validate output */ zassert_true( @@ -374,11 +374,11 @@ static void test_arm_not_u8( free(output); } -DEFINE_TEST_VARIANT3(basic_math_q7, arm_not_u8, 15, in_bitwise1, ref_not, 15); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_not_u8, 32, in_bitwise1, ref_not, 32); -DEFINE_TEST_VARIANT3(basic_math_q7, arm_not_u8, 47, in_bitwise1, ref_not, 47); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_not_u8, 15, in_bitwise1, ref_not, 15); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_not_u8, 32, in_bitwise1, ref_not, 32); +DEFINE_TEST_VARIANT3(basic_math_q7, zdsp_not_u8, 47, in_bitwise1, ref_not, 47); -static void test_arm_xor_u8( +static void test_zdsp_xor_u8( const uint8_t *input1, const uint8_t *input2, const uint8_t *ref, size_t length) { uint8_t *output; @@ -388,7 +388,7 @@ static void test_arm_xor_u8( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_xor_u8(input1, input2, output, length); + zdsp_xor_u8(input1, input2, output, length); /* Validate output */ zassert_true( @@ -399,11 +399,11 @@ static void test_arm_xor_u8( free(output); } -DEFINE_TEST_VARIANT4(basic_math_q7, arm_xor_u8, 15, in_bitwise1, in_bitwise2, ref_xor, 15); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_xor_u8, 32, in_bitwise1, in_bitwise2, ref_xor, 32); -DEFINE_TEST_VARIANT4(basic_math_q7, arm_xor_u8, 47, in_bitwise1, in_bitwise2, ref_xor, 47); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_xor_u8, 15, in_bitwise1, in_bitwise2, ref_xor, 15); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_xor_u8, 32, in_bitwise1, in_bitwise2, ref_xor, 32); +DEFINE_TEST_VARIANT4(basic_math_q7, zdsp_xor_u8, 47, in_bitwise1, in_bitwise2, ref_xor, 47); -static void test_arm_clip_q7( +static void test_zdsp_clip_q7( const q7_t *input, const q7_t *ref, q7_t min, q7_t max, size_t length) { q7_t *output; @@ -413,7 +413,7 @@ static void test_arm_clip_q7( zassert_not_null(output, ASSERT_MSG_BUFFER_ALLOC_FAILED); /* Run test function */ - arm_clip_q7(input, output, min, max, length); + zdsp_clip_q7(input, output, min, max, length); /* Validate output */ zassert_true( @@ -424,11 +424,11 @@ static void test_arm_clip_q7( free(output); } -DEFINE_TEST_VARIANT5(basic_math_q7, arm_clip_q7, c0_f3, in_clip, ref_clip1, 0xc0, 0xf3, +DEFINE_TEST_VARIANT5(basic_math_q7, zdsp_clip_q7, c0_f3, in_clip, ref_clip1, 0xc0, 0xf3, ARRAY_SIZE(ref_clip1)); -DEFINE_TEST_VARIANT5(basic_math_q7, arm_clip_q7, c0_40, in_clip, ref_clip2, 0xc0, 0x40, +DEFINE_TEST_VARIANT5(basic_math_q7, zdsp_clip_q7, c0_40, in_clip, ref_clip2, 0xc0, 0x40, ARRAY_SIZE(ref_clip2)); -DEFINE_TEST_VARIANT5(basic_math_q7, arm_clip_q7, 0d_40, in_clip, ref_clip3, 0x0d, 0x40, +DEFINE_TEST_VARIANT5(basic_math_q7, zdsp_clip_q7, 0d_40, in_clip, ref_clip3, 0x0d, 0x40, ARRAY_SIZE(ref_clip3)); ZTEST_SUITE(basic_math_q7, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/lib/cmsis_dsp/basicmath/src/q7.pat b/tests/subsys/dsp/basicmath/src/q7.pat similarity index 100% rename from tests/lib/cmsis_dsp/basicmath/src/q7.pat rename to tests/subsys/dsp/basicmath/src/q7.pat diff --git a/tests/subsys/dsp/basicmath/testcase.yaml b/tests/subsys/dsp/basicmath/testcase.yaml new file mode 100644 index 0000000000000..b0cd202d3ffdc --- /dev/null +++ b/tests/subsys/dsp/basicmath/testcase.yaml @@ -0,0 +1,21 @@ +tests: + zdsp.basicmath: + filter: TOOLCHAIN_HAS_NEWLIB == 1 or CONFIG_ARCH_POSIX + integration_platforms: + - frdm_k64f + - sam_e70_xplained + - mps2_an521 + - native_posix + tags: zdsp + min_flash: 128 + min_ram: 64 + zdsp.basicmath.fpu: + filter: (CONFIG_CPU_HAS_FPU and TOOLCHAIN_HAS_NEWLIB == 1) or CONFIG_ARCH_POSIX + integration_platforms: + - mps2_an521_remote + - mps3_an547 + tags: zdsp fpu + extra_configs: + - CONFIG_FPU=y + min_flash: 128 + min_ram: 64 diff --git a/west.yml b/west.yml index 5771dfc089293..938ddd4238d43 100644 --- a/west.yml +++ b/west.yml @@ -32,7 +32,7 @@ manifest: revision: fe0ab36e0fa7453a4c9b97bedac89709f45cf965 path: modules/lib/chre - name: cmsis - revision: 093de61c2a7d12dc9253daf8692f61f793a9254a + revision: 74981bf893e8b10931464b9945e2143d99a3f0a3 path: modules/hal/cmsis groups: - hal