tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

firmware: cs_dsp: Simplify suppressing log messages during KUnit testing

Rework the way that kernel log messages are rate-limited or suppressed
while running the cs_dsp KUnit tests.

Under normal conditions cs_dsp doesn't produce an unreasonable number of
log messages, and state changes are relatively infrequent. But the KUnit
tests run through a very large number of test cases, especially error
cases, and this produces an unusually large amount of log output from
cs_dsp.

The original fix for this in commit 10db9f6899dd ("firmware: cs_dsp:
rate-limit log messages in KUnit builds") was effective but not pretty.
It involved different definitions of the log macros for KUnit and
not-KUnit builds, and exported variables for the KUnit tests to disable
log messages. I would have preferred to turn the log macros into real
functions that can contain a KUNIT_STATIC_STUB_REDIRECT(), but the
dev_xxx() macros don't have a version that take va_args, so they can't
be wrapped by a function.

This patch enables the use of a KUNIT_STATIC_STUB_REDIRECT() instead
of exported variables, and avoids the need for different definitions of
the debug macros in KUnit and not-KUnit builds.

- A new function cs_dsp_can_emit_message() returns true if the
messages can be emitted to the kernel log. In a normal not-KUnit build
this function collapses to simply returning true. In KUnit builds it
will rate-limit output, and this uses a single static rate limiter so
it limits the overall rate across all cs_dsp log messages. The KUnit
test can redirect it to change the suppression behavior.

- The cs_dsp debug message macros are changed to only call the dev_xxx()
if cs_dsp_can_emit_message() returns true. These are still macros so
there is no problem wrapping the dev_xxx(). For a normal not-KUnit
build cs_dsp_can_emit_message() always returns true so these macros
simplify down to being identical to calling dev_xxx() directly.

- The KUnit tests that cause a lot of cs_dsp messages now redirect
cs_dsp_can_emit_message() to a local function. This returns false
to suppress cs_dsp messages, unless DEBUG is defined for that test.

I have checked that for a x86_64 production (non-KUnit) build the
disassembled cs_dsp.o is identical to what was generated from the
original code. So the complier is correctly simplifying the
cs_dsp_can_emit_message() and macros down to only the call to dev_xxx().

Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Link: https://patch.msgid.link/20260310130343.1791951-1-rf@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Richard Fitzgerald and committed by
Mark Brown 9be71d46 207fd1f4

+79 -81
+36 -32
drivers/firmware/cirrus/cs_dsp.c
··· 9 9 * Cirrus Logic International Semiconductor Ltd. 10 10 */ 11 11 12 + #include <kunit/static_stub.h> 12 13 #include <kunit/visibility.h> 13 14 #include <linux/cleanup.h> 14 15 #include <linux/ctype.h> ··· 19 18 #include <linux/minmax.h> 20 19 #include <linux/module.h> 21 20 #include <linux/moduleparam.h> 21 + #include <linux/ratelimit.h> 22 22 #include <linux/seq_file.h> 23 23 #include <linux/slab.h> 24 24 #include <linux/vmalloc.h> ··· 32 30 /* 33 31 * When the KUnit test is running the error-case tests will cause a lot 34 32 * of messages. Rate-limit to prevent overflowing the kernel log buffer 35 - * during KUnit test runs. 33 + * during KUnit test runs and allow the test to redirect this function. 34 + * In normal (not KUnit) builds this collapses to only return true. 36 35 */ 37 - #if IS_ENABLED(CONFIG_FW_CS_DSP_KUNIT_TEST) 38 - bool cs_dsp_suppress_err_messages; 39 - EXPORT_SYMBOL_IF_KUNIT(cs_dsp_suppress_err_messages); 36 + VISIBLE_IF_KUNIT bool cs_dsp_can_emit_message(void) 37 + { 38 + KUNIT_STATIC_STUB_REDIRECT(cs_dsp_can_emit_message); 40 39 41 - bool cs_dsp_suppress_warn_messages; 42 - EXPORT_SYMBOL_IF_KUNIT(cs_dsp_suppress_warn_messages); 40 + if (IS_ENABLED(CONFIG_FW_CS_DSP_KUNIT_TEST)) { 41 + static DEFINE_RATELIMIT_STATE(_rs, 42 + DEFAULT_RATELIMIT_INTERVAL, 43 + DEFAULT_RATELIMIT_BURST); 44 + return __ratelimit(&_rs); 45 + } 43 46 44 - bool cs_dsp_suppress_info_messages; 45 - EXPORT_SYMBOL_IF_KUNIT(cs_dsp_suppress_info_messages); 47 + return true; 48 + } 49 + EXPORT_SYMBOL_IF_KUNIT(cs_dsp_can_emit_message); 46 50 47 - #define cs_dsp_err(_dsp, fmt, ...) \ 48 - do { \ 49 - if (!cs_dsp_suppress_err_messages) \ 50 - dev_err_ratelimited(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 51 + #define cs_dsp_err(_dsp, fmt, ...) \ 52 + do { \ 53 + if (cs_dsp_can_emit_message()) \ 54 + dev_err(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 51 55 } while (false) 52 - #define cs_dsp_warn(_dsp, fmt, ...) \ 53 - do { \ 54 - if (!cs_dsp_suppress_warn_messages) \ 55 - dev_warn_ratelimited(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 56 + 57 + #define cs_dsp_warn(_dsp, fmt, ...) \ 58 + do { \ 59 + if (cs_dsp_can_emit_message()) \ 60 + dev_warn(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 56 61 } while (false) 57 - #define cs_dsp_info(_dsp, fmt, ...) \ 58 - do { \ 59 - if (!cs_dsp_suppress_info_messages) \ 60 - dev_info_ratelimited(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 62 + 63 + #define cs_dsp_info(_dsp, fmt, ...) \ 64 + do { \ 65 + if (cs_dsp_can_emit_message()) \ 66 + dev_info(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 61 67 } while (false) 62 - #define cs_dsp_dbg(_dsp, fmt, ...) \ 63 - dev_dbg_ratelimited(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__) 64 - #else 65 - #define cs_dsp_err(_dsp, fmt, ...) \ 66 - dev_err(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__) 67 - #define cs_dsp_warn(_dsp, fmt, ...) \ 68 - dev_warn(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__) 69 - #define cs_dsp_info(_dsp, fmt, ...) \ 70 - dev_info(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__) 71 - #define cs_dsp_dbg(_dsp, fmt, ...) \ 72 - dev_dbg(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__) 73 - #endif 68 + 69 + #define cs_dsp_dbg(_dsp, fmt, ...) \ 70 + do { \ 71 + if (cs_dsp_can_emit_message()) \ 72 + dev_dbg(_dsp->dev, "%s: " fmt, _dsp->name, ##__VA_ARGS__); \ 73 + } while (false) 74 74 75 75 #define ADSP1_CONTROL_1 0x00 76 76 #define ADSP1_CONTROL_2 0x02
+1 -3
drivers/firmware/cirrus/cs_dsp.h
··· 10 10 #define FW_CS_DSP_H 11 11 12 12 #if IS_ENABLED(CONFIG_KUNIT) 13 - extern bool cs_dsp_suppress_err_messages; 14 - extern bool cs_dsp_suppress_warn_messages; 15 - extern bool cs_dsp_suppress_info_messages; 13 + bool cs_dsp_can_emit_message(void); 16 14 #endif 17 15 18 16 #endif /* ifndef FW_CS_DSP_H */
+12 -9
drivers/firmware/cirrus/test/cs_dsp_test_bin.c
··· 7 7 8 8 #include <kunit/device.h> 9 9 #include <kunit/resource.h> 10 + #include <kunit/static_stub.h> 10 11 #include <kunit/test.h> 11 12 #include <linux/build_bug.h> 12 13 #include <linux/firmware/cirrus/cs_dsp.h> ··· 2156 2155 KUNIT_EXPECT_EQ(test, reg_val, payload_data); 2157 2156 } 2158 2157 2158 + static bool cs_dsp_bin_test_can_emit_message_hook(void) 2159 + { 2160 + #if defined(DEBUG) 2161 + return true; 2162 + #else 2163 + return false; 2164 + #endif 2165 + } 2166 + 2159 2167 static int cs_dsp_bin_test_common_init(struct kunit *test, struct cs_dsp *dsp, 2160 2168 int wmdr_ver) 2161 2169 { ··· 2249 2239 * The large number of test cases will cause an unusually large amount 2250 2240 * of dev_info() messages from cs_dsp, so suppress these. 2251 2241 */ 2252 - cs_dsp_suppress_info_messages = true; 2242 + kunit_activate_static_stub(test, cs_dsp_can_emit_message, 2243 + cs_dsp_bin_test_can_emit_message_hook); 2253 2244 2254 2245 return 0; 2255 - } 2256 - 2257 - static void cs_dsp_bin_test_exit(struct kunit *test) 2258 - { 2259 - cs_dsp_suppress_info_messages = false; 2260 2246 } 2261 2247 2262 2248 static int cs_dsp_bin_test_halo_init_common(struct kunit *test, int wmdr_ver) ··· 2839 2833 static struct kunit_suite cs_dsp_bin_test_halo = { 2840 2834 .name = "cs_dsp_bin_halo", 2841 2835 .init = cs_dsp_bin_test_halo_init, 2842 - .exit = cs_dsp_bin_test_exit, 2843 2836 .test_cases = cs_dsp_bin_test_cases_halo, 2844 2837 .attr.speed = KUNIT_SPEED_SLOW, 2845 2838 }; ··· 2853 2848 static struct kunit_suite cs_dsp_bin_test_adsp2_32bit = { 2854 2849 .name = "cs_dsp_bin_adsp2_32bit", 2855 2850 .init = cs_dsp_bin_test_adsp2_32bit_init, 2856 - .exit = cs_dsp_bin_test_exit, 2857 2851 .test_cases = cs_dsp_bin_test_cases_adsp2, 2858 2852 .attr.speed = KUNIT_SPEED_SLOW, 2859 2853 }; ··· 2860 2856 static struct kunit_suite cs_dsp_bin_test_adsp2_16bit = { 2861 2857 .name = "cs_dsp_bin_adsp2_16bit", 2862 2858 .init = cs_dsp_bin_test_adsp2_16bit_init, 2863 - .exit = cs_dsp_bin_test_exit, 2864 2859 .test_cases = cs_dsp_bin_test_cases_adsp2, 2865 2860 .attr.speed = KUNIT_SPEED_SLOW, 2866 2861 };
+9 -10
drivers/firmware/cirrus/test/cs_dsp_test_bin_error.c
··· 8 8 9 9 #include <kunit/device.h> 10 10 #include <kunit/resource.h> 11 + #include <kunit/static_stub.h> 11 12 #include <kunit/test.h> 12 13 #include <linux/build_bug.h> 13 14 #include <linux/firmware/cirrus/cs_dsp.h> ··· 381 380 0); 382 381 } 383 382 384 - static void cs_dsp_bin_err_test_exit(struct kunit *test) 383 + static bool cs_dsp_bin_err_test_can_emit_message_hook(void) 385 384 { 386 - cs_dsp_suppress_err_messages = false; 387 - cs_dsp_suppress_warn_messages = false; 388 - cs_dsp_suppress_info_messages = false; 385 + #if defined(DEBUG) 386 + return true; 387 + #else 388 + return false; 389 + #endif 389 390 } 390 391 391 392 static int cs_dsp_bin_err_test_common_init(struct kunit *test, struct cs_dsp *dsp, ··· 485 482 * Testing error conditions can produce a lot of log output 486 483 * from cs_dsp error messages, so suppress messages. 487 484 */ 488 - cs_dsp_suppress_err_messages = true; 489 - cs_dsp_suppress_warn_messages = true; 490 - cs_dsp_suppress_info_messages = true; 485 + kunit_activate_static_stub(test, cs_dsp_can_emit_message, 486 + cs_dsp_bin_err_test_can_emit_message_hook); 491 487 492 488 return 0; 493 489 } ··· 586 584 static struct kunit_suite cs_dsp_bin_err_test_halo = { 587 585 .name = "cs_dsp_bin_err_halo", 588 586 .init = cs_dsp_bin_err_test_halo_init, 589 - .exit = cs_dsp_bin_err_test_exit, 590 587 .test_cases = cs_dsp_bin_err_test_cases, 591 588 .attr.speed = KUNIT_SPEED_SLOW, 592 589 }; ··· 593 592 static struct kunit_suite cs_dsp_bin_err_test_adsp2_32bit = { 594 593 .name = "cs_dsp_bin_err_adsp2_32bit", 595 594 .init = cs_dsp_bin_err_test_adsp2_32bit_init, 596 - .exit = cs_dsp_bin_err_test_exit, 597 595 .test_cases = cs_dsp_bin_err_test_cases, 598 596 .attr.speed = KUNIT_SPEED_SLOW, 599 597 }; ··· 600 600 static struct kunit_suite cs_dsp_bin_err_test_adsp2_16bit = { 601 601 .name = "cs_dsp_bin_err_adsp2_16bit", 602 602 .init = cs_dsp_bin_err_test_adsp2_16bit_init, 603 - .exit = cs_dsp_bin_err_test_exit, 604 603 .test_cases = cs_dsp_bin_err_test_cases, 605 604 .attr.speed = KUNIT_SPEED_SLOW, 606 605 };
+12 -13
drivers/firmware/cirrus/test/cs_dsp_test_wmfw.c
··· 8 8 9 9 #include <kunit/device.h> 10 10 #include <kunit/resource.h> 11 + #include <kunit/static_stub.h> 11 12 #include <kunit/test.h> 12 13 #include <linux/build_bug.h> 13 14 #include <linux/firmware/cirrus/cs_dsp.h> ··· 1776 1775 KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes); 1777 1776 } 1778 1777 1778 + static bool cs_dsp_wmfw_test_can_emit_message_hook(void) 1779 + { 1780 + #if defined(DEBUG) 1781 + return true; 1782 + #else 1783 + return false; 1784 + #endif 1785 + } 1786 + 1779 1787 static int cs_dsp_wmfw_test_common_init(struct kunit *test, struct cs_dsp *dsp, 1780 1788 int wmfw_version) 1781 1789 { ··· 1873 1863 * The large number of test cases will cause an unusually large amount 1874 1864 * of dev_info() messages from cs_dsp, so suppress these. 1875 1865 */ 1876 - cs_dsp_suppress_info_messages = true; 1866 + kunit_activate_static_stub(test, cs_dsp_can_emit_message, 1867 + cs_dsp_wmfw_test_can_emit_message_hook); 1877 1868 1878 1869 return 0; 1879 - } 1880 - 1881 - static void cs_dsp_wmfw_test_exit(struct kunit *test) 1882 - { 1883 - cs_dsp_suppress_info_messages = false; 1884 1870 } 1885 1871 1886 1872 static int cs_dsp_wmfw_test_halo_init(struct kunit *test) ··· 2186 2180 static struct kunit_suite cs_dsp_wmfw_test_halo = { 2187 2181 .name = "cs_dsp_wmfwV3_halo", 2188 2182 .init = cs_dsp_wmfw_test_halo_init, 2189 - .exit = cs_dsp_wmfw_test_exit, 2190 2183 .test_cases = cs_dsp_wmfw_test_cases_halo, 2191 2184 .attr.speed = KUNIT_SPEED_SLOW, 2192 2185 }; ··· 2193 2188 static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw0 = { 2194 2189 .name = "cs_dsp_wmfwV0_adsp2_32bit", 2195 2190 .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw0_init, 2196 - .exit = cs_dsp_wmfw_test_exit, 2197 2191 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2198 2192 .attr.speed = KUNIT_SPEED_SLOW, 2199 2193 }; ··· 2200 2196 static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw1 = { 2201 2197 .name = "cs_dsp_wmfwV1_adsp2_32bit", 2202 2198 .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw1_init, 2203 - .exit = cs_dsp_wmfw_test_exit, 2204 2199 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2205 2200 .attr.speed = KUNIT_SPEED_SLOW, 2206 2201 }; ··· 2207 2204 static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw2 = { 2208 2205 .name = "cs_dsp_wmfwV2_adsp2_32bit", 2209 2206 .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw2_init, 2210 - .exit = cs_dsp_wmfw_test_exit, 2211 2207 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2212 2208 .attr.speed = KUNIT_SPEED_SLOW, 2213 2209 }; ··· 2214 2212 static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw0 = { 2215 2213 .name = "cs_dsp_wmfwV0_adsp2_16bit", 2216 2214 .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw0_init, 2217 - .exit = cs_dsp_wmfw_test_exit, 2218 2215 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2219 2216 .attr.speed = KUNIT_SPEED_SLOW, 2220 2217 }; ··· 2221 2220 static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw1 = { 2222 2221 .name = "cs_dsp_wmfwV1_adsp2_16bit", 2223 2222 .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw1_init, 2224 - .exit = cs_dsp_wmfw_test_exit, 2225 2223 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2226 2224 .attr.speed = KUNIT_SPEED_SLOW, 2227 2225 }; ··· 2228 2228 static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw2 = { 2229 2229 .name = "cs_dsp_wmfwV2_adsp2_16bit", 2230 2230 .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw2_init, 2231 - .exit = cs_dsp_wmfw_test_exit, 2232 2231 .test_cases = cs_dsp_wmfw_test_cases_adsp2, 2233 2232 .attr.speed = KUNIT_SPEED_SLOW, 2234 2233 };
+9 -14
drivers/firmware/cirrus/test/cs_dsp_test_wmfw_error.c
··· 8 8 9 9 #include <kunit/device.h> 10 10 #include <kunit/resource.h> 11 + #include <kunit/static_stub.h> 11 12 #include <kunit/test.h> 12 13 #include <linux/build_bug.h> 13 14 #include <linux/firmware/cirrus/cs_dsp.h> ··· 990 989 -EOVERFLOW); 991 990 } 992 991 993 - static void cs_dsp_wmfw_err_test_exit(struct kunit *test) 992 + static bool cs_dsp_wmfw_err_test_can_emit_message_hook(void) 994 993 { 995 - cs_dsp_suppress_err_messages = false; 996 - cs_dsp_suppress_warn_messages = false; 997 - cs_dsp_suppress_info_messages = false; 994 + #if defined(DEBUG) 995 + return true; 996 + #else 997 + return false; 998 + #endif 998 999 } 999 1000 1000 1001 static int cs_dsp_wmfw_err_test_common_init(struct kunit *test, struct cs_dsp *dsp, ··· 1083 1080 * Testing error conditions can produce a lot of log output 1084 1081 * from cs_dsp error messages, so suppress messages. 1085 1082 */ 1086 - cs_dsp_suppress_err_messages = true; 1087 - cs_dsp_suppress_warn_messages = true; 1088 - cs_dsp_suppress_info_messages = true; 1083 + kunit_activate_static_stub(test, cs_dsp_can_emit_message, 1084 + cs_dsp_wmfw_err_test_can_emit_message_hook); 1089 1085 1090 1086 return 0; 1091 1087 } ··· 1306 1304 static struct kunit_suite cs_dsp_wmfw_err_test_halo = { 1307 1305 .name = "cs_dsp_wmfwV3_err_halo", 1308 1306 .init = cs_dsp_wmfw_err_test_halo_init, 1309 - .exit = cs_dsp_wmfw_err_test_exit, 1310 1307 .test_cases = cs_dsp_wmfw_err_test_cases_v3, 1311 1308 .attr.speed = KUNIT_SPEED_SLOW, 1312 1309 }; ··· 1313 1312 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0 = { 1314 1313 .name = "cs_dsp_wmfwV0_err_adsp2_32bit", 1315 1314 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0_init, 1316 - .exit = cs_dsp_wmfw_err_test_exit, 1317 1315 .test_cases = cs_dsp_wmfw_err_test_cases_v0, 1318 1316 .attr.speed = KUNIT_SPEED_SLOW, 1319 1317 }; ··· 1320 1320 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1 = { 1321 1321 .name = "cs_dsp_wmfwV1_err_adsp2_32bit", 1322 1322 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1_init, 1323 - .exit = cs_dsp_wmfw_err_test_exit, 1324 1323 .test_cases = cs_dsp_wmfw_err_test_cases_v1, 1325 1324 .attr.speed = KUNIT_SPEED_SLOW, 1326 1325 }; ··· 1327 1328 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2 = { 1328 1329 .name = "cs_dsp_wmfwV2_err_adsp2_32bit", 1329 1330 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2_init, 1330 - .exit = cs_dsp_wmfw_err_test_exit, 1331 1331 .test_cases = cs_dsp_wmfw_err_test_cases_v2, 1332 1332 .attr.speed = KUNIT_SPEED_SLOW, 1333 1333 }; ··· 1334 1336 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0 = { 1335 1337 .name = "cs_dsp_wmfwV0_err_adsp2_16bit", 1336 1338 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0_init, 1337 - .exit = cs_dsp_wmfw_err_test_exit, 1338 1339 .test_cases = cs_dsp_wmfw_err_test_cases_v0, 1339 1340 .attr.speed = KUNIT_SPEED_SLOW, 1340 1341 }; ··· 1341 1344 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1 = { 1342 1345 .name = "cs_dsp_wmfwV1_err_adsp2_16bit", 1343 1346 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1_init, 1344 - .exit = cs_dsp_wmfw_err_test_exit, 1345 1347 .test_cases = cs_dsp_wmfw_err_test_cases_v1, 1346 1348 .attr.speed = KUNIT_SPEED_SLOW, 1347 1349 }; ··· 1348 1352 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2 = { 1349 1353 .name = "cs_dsp_wmfwV2_err_adsp2_16bit", 1350 1354 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2_init, 1351 - .exit = cs_dsp_wmfw_err_test_exit, 1352 1355 .test_cases = cs_dsp_wmfw_err_test_cases_v2, 1353 1356 .attr.speed = KUNIT_SPEED_SLOW, 1354 1357 };