Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ASoC: cs35l56: More support for new Dell laptops
Merge series from Richard Fitzgerald <rf@opensource.cirrus.com>:
Some new Dell models use spare pins on the amp as a binary integer
value to indicate the speaker type. The driver must use this to
select the correct firmware files for the hardware.
Patch #1 is the new support.
The other patches are for KUnit testing.
+1317
-4
+37
include/sound/cs35l56.h
+37
include/sound/cs35l56.h
···
9
9
#ifndef __CS35L56_H
10
10
#define __CS35L56_H
11
11
12
+
#include <linux/bits.h>
12
13
#include <linux/debugfs.h>
13
14
#include <linux/firmware/cirrus/cs_dsp.h>
14
15
#include <linux/regulator/consumer.h>
···
27
26
#define CS35L56_GLOBAL_ENABLES 0x0002014
28
27
#define CS35L56_BLOCK_ENABLES 0x0002018
29
28
#define CS35L56_BLOCK_ENABLES2 0x000201C
29
+
#define CS35L56_SYNC_GPIO1_CFG 0x0002410
30
+
#define CS35L56_ASP2_DIO_GPIO13_CFG 0x0002440
31
+
#define CS35L56_UPDATE_REGS 0x0002A0C
30
32
#define CS35L56_REFCLK_INPUT 0x0002C04
31
33
#define CS35L56_GLOBAL_SAMPLE_RATE 0x0002C0C
32
34
#define CS35L56_OTP_MEM_53 0x00300D4
···
69
65
#define CS35L56_IRQ1_MASK_8 0x000E0AC
70
66
#define CS35L56_IRQ1_MASK_18 0x000E0D4
71
67
#define CS35L56_IRQ1_MASK_20 0x000E0DC
68
+
#define CS35L56_GPIO_STATUS1 0x000F000
69
+
#define CS35L56_GPIO1_CTRL1 0x000F008
70
+
#define CS35L56_GPIO13_CTRL1 0x000F038
72
71
#define CS35L56_MIXER_NGATE_CH1_CFG 0x0010004
73
72
#define CS35L56_MIXER_NGATE_CH2_CFG 0x0010008
74
73
#define CS35L56_DSP_MBOX_1_RAW 0x0011000
···
137
130
#define CS35L56_MTLREVID_MASK 0x0000000F
138
131
#define CS35L56_REVID_B0 0x000000B0
139
132
133
+
/* PAD_INTF */
134
+
#define CS35L56_PAD_GPIO_PULL_MASK GENMASK(3, 2)
135
+
#define CS35L56_PAD_GPIO_IE BIT(0)
136
+
137
+
#define CS35L56_PAD_PULL_NONE 0
138
+
#define CS35L56_PAD_PULL_UP 1
139
+
#define CS35L56_PAD_PULL_DOWN 2
140
+
141
+
/* UPDATE_REGS */
142
+
#define CS35L56_UPDT_GPIO_PRES BIT(6)
143
+
140
144
/* ASP_ENABLES1 */
141
145
#define CS35L56_ASP_RX2_EN_SHIFT 17
142
146
#define CS35L56_ASP_RX1_EN_SHIFT 16
···
202
184
203
185
/* MIXER_NGATE_CHn_CFG */
204
186
#define CS35L56_AUX_NGATE_CHn_EN 0x00000001
187
+
188
+
/* GPIOn_CTRL1 */
189
+
#define CS35L56_GPIO_DIR_MASK BIT(31)
190
+
#define CS35L56_GPIO_FN_MASK GENMASK(2, 0)
191
+
192
+
#define CS35L56_GPIO_FN_GPIO 0x00000001
205
193
206
194
/* Mixer input sources */
207
195
#define CS35L56_INPUT_SRC_NONE 0x00
···
303
279
#define CS35L56_HALO_STATE_TIMEOUT_US 250000
304
280
#define CS35L56_RESET_PULSE_MIN_US 1100
305
281
#define CS35L56_WAKE_HOLD_TIME_US 1000
282
+
#define CS35L56_PAD_PULL_SETTLE_US 10
306
283
307
284
#define CS35L56_CALIBRATION_POLL_US (100 * USEC_PER_MSEC)
308
285
#define CS35L56_CALIBRATION_TIMEOUT_US (5 * USEC_PER_SEC)
···
313
288
314
289
#define CS35L56_NUM_BULK_SUPPLIES 3
315
290
#define CS35L56_NUM_DSP_REGIONS 5
291
+
292
+
#define CS35L56_MAX_GPIO 13
293
+
#define CS35L63_MAX_GPIO 9
316
294
317
295
/* Additional margin for SYSTEM_RESET to control port ready on SPI */
318
296
#define CS35L56_SPI_RESET_TO_PORT_READY_US (CS35L56_CONTROL_PORT_READY_US + 2500)
···
366
338
const struct cirrus_amp_cal_controls *calibration_controls;
367
339
struct dentry *debugfs;
368
340
u64 silicon_uid;
341
+
u8 onchip_spkid_gpios[5];
342
+
u8 num_onchip_spkid_gpios;
343
+
u8 onchip_spkid_pulls[5];
344
+
u8 num_onchip_spkid_pulls;
369
345
};
370
346
371
347
static inline bool cs35l56_is_otp_register(unsigned int reg)
···
445
413
void cs35l56_log_tuning(struct cs35l56_base *cs35l56_base, struct cs_dsp *cs_dsp);
446
414
int cs35l56_hw_init(struct cs35l56_base *cs35l56_base);
447
415
int cs35l56_get_speaker_id(struct cs35l56_base *cs35l56_base);
416
+
int cs35l56_check_and_save_onchip_spkid_gpios(struct cs35l56_base *cs35l56_base,
417
+
const u32 *gpios, int num_gpios,
418
+
const u32 *pulls, int num_pulls);
419
+
int cs35l56_configure_onchip_spkid_pads(struct cs35l56_base *cs35l56_base);
420
+
int cs35l56_read_onchip_spkid(struct cs35l56_base *cs35l56_base);
448
421
int cs35l56_get_bclk_freq_id(unsigned int freq);
449
422
void cs35l56_fill_supply_names(struct regulator_bulk_data *data);
450
423
+14
sound/soc/codecs/Kconfig
+14
sound/soc/codecs/Kconfig
···
936
936
help
937
937
This builds KUnit tests for the Cirrus Logic cs35l56
938
938
codec driver.
939
+
940
+
For more information on KUnit and unit tests in general,
941
+
please refer to the KUnit documentation in
942
+
Documentation/dev-tools/kunit/.
943
+
If in doubt, say "N".
944
+
945
+
config SND_SOC_CS35L56_SHARED_TEST
946
+
tristate "KUnit test for Cirrus Logic cs35l56-shared" if !KUNIT_ALL_TESTS
947
+
depends on SND_SOC_CS35L56_SHARED && KUNIT
948
+
default KUNIT_ALL_TESTS
949
+
help
950
+
This builds KUnit tests for the Cirrus Logic cs35l56-shared
951
+
module.
952
+
939
953
For more information on KUnit and unit tests in general,
940
954
please refer to the KUnit documentation in
941
955
Documentation/dev-tools/kunit/.
+2
sound/soc/codecs/Makefile
+2
sound/soc/codecs/Makefile
···
77
77
snd-soc-cs35l45-i2c-y := cs35l45-i2c.o
78
78
snd-soc-cs35l56-y := cs35l56.o
79
79
snd-soc-cs35l56-shared-y := cs35l56-shared.o
80
+
snd-soc-cs35l56-shared-test-y := cs35l56-shared-test.o
80
81
snd-soc-cs35l56-i2c-y := cs35l56-i2c.o
81
82
snd-soc-cs35l56-spi-y := cs35l56-spi.o
82
83
snd-soc-cs35l56-sdw-y := cs35l56-sdw.o
···
513
512
obj-$(CONFIG_SND_SOC_CS35L45_I2C) += snd-soc-cs35l45-i2c.o
514
513
obj-$(CONFIG_SND_SOC_CS35L56) += snd-soc-cs35l56.o
515
514
obj-$(CONFIG_SND_SOC_CS35L56_SHARED) += snd-soc-cs35l56-shared.o
515
+
obj-$(CONFIG_SND_SOC_CS35L56_SHARED_TEST) += snd-soc-cs35l56-shared-test.o
516
516
obj-$(CONFIG_SND_SOC_CS35L56_I2C) += snd-soc-cs35l56-i2c.o
517
517
obj-$(CONFIG_SND_SOC_CS35L56_SPI) += snd-soc-cs35l56-spi.o
518
518
obj-$(CONFIG_SND_SOC_CS35L56_SDW) += snd-soc-cs35l56-sdw.o
+273
sound/soc/codecs/cs35l56-test.c
+273
sound/soc/codecs/cs35l56-test.c
···
15
15
#include <linux/module.h>
16
16
#include <linux/overflow.h>
17
17
#include <linux/pci_ids.h>
18
+
#include <linux/property.h>
19
+
#include <linux/seq_buf.h>
18
20
#include <linux/soundwire/sdw.h>
19
21
#include <sound/cs35l56.h>
20
22
#include <sound/cs-amp-lib.h>
···
25
23
KUNIT_DEFINE_ACTION_WRAPPER(faux_device_destroy_wrapper, faux_device_destroy,
26
24
struct faux_device *)
27
25
26
+
KUNIT_DEFINE_ACTION_WRAPPER(software_node_unregister_node_group_wrapper,
27
+
software_node_unregister_node_group,
28
+
const struct software_node * const *)
29
+
30
+
KUNIT_DEFINE_ACTION_WRAPPER(software_node_unregister_wrapper,
31
+
software_node_unregister,
32
+
const struct software_node *)
33
+
34
+
KUNIT_DEFINE_ACTION_WRAPPER(device_remove_software_node_wrapper,
35
+
device_remove_software_node,
36
+
struct device *)
37
+
28
38
struct cs35l56_test_priv {
29
39
struct faux_device *amp_dev;
30
40
struct cs35l56_private *cs35l56_priv;
31
41
32
42
const char *ssidexv2;
43
+
44
+
bool read_onchip_spkid_called;
45
+
bool configure_onchip_spkid_pads_called;
33
46
};
34
47
35
48
struct cs35l56_test_param {
36
49
u8 type;
37
50
u8 rev;
51
+
52
+
s32 spkid_gpios[4];
53
+
s32 spkid_pulls[4];
54
+
};
55
+
56
+
static const struct software_node cs35l56_test_dev_sw_node =
57
+
SOFTWARE_NODE("SWD1", NULL, NULL);
58
+
59
+
static const struct software_node cs35l56_test_af01_sw_node =
60
+
SOFTWARE_NODE("AF01", NULL, &cs35l56_test_dev_sw_node);
61
+
62
+
static const struct software_node *cs35l56_test_dev_and_af01_node_group[] = {
63
+
&cs35l56_test_dev_sw_node,
64
+
&cs35l56_test_af01_sw_node,
65
+
NULL
38
66
};
39
67
40
68
static const char *cs35l56_test_devm_get_vendor_specific_variant_id_none(struct device *dev,
···
264
232
KUNIT_EXPECT_STREQ(test, cs35l56->fallback_fw_suffix, "l1u5");
265
233
}
266
234
235
+
/*
236
+
* Test that cs35l56_process_xu_properties() correctly parses the GPIO and
237
+
* pull values from properties into the arrays in struct cs35l56_base.
238
+
*
239
+
* This test creates the node tree:
240
+
*
241
+
* Node("SWD1") { // top-level device node
242
+
* Node("AF01") {
243
+
* Node("mipi-sdca-function-expansion-subproperties") {
244
+
* property: "01fa-spk-id-gpios-onchip"
245
+
* property: 01fa-spk-id-gpios-onchip-pull
246
+
* }
247
+
* }
248
+
* }
249
+
*
250
+
* Note that in ACPI "mipi-sdca-function-expansion-subproperties" is
251
+
* a special _DSD property that points to a Device(EXT0) node but behaves
252
+
* as an alias of the EXT0 node. The equivalent in software nodes is to
253
+
* create a Node named "mipi-sdca-function-expansion-subproperties" with
254
+
* the properties.
255
+
*
256
+
*/
257
+
static void cs35l56_test_parse_xu_onchip_spkid(struct kunit *test)
258
+
{
259
+
const struct cs35l56_test_param *param = test->param_value;
260
+
struct cs35l56_test_priv *priv = test->priv;
261
+
struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
262
+
struct software_node *ext0_node;
263
+
int num_gpios = 0;
264
+
int num_pulls = 0;
265
+
int i;
266
+
267
+
for (i = 0; i < ARRAY_SIZE(param->spkid_gpios); i++, num_gpios++) {
268
+
if (param->spkid_gpios[i] < 0)
269
+
break;
270
+
}
271
+
KUNIT_ASSERT_LE(test, num_gpios, ARRAY_SIZE(cs35l56->base.onchip_spkid_gpios));
272
+
273
+
for (i = 0; i < ARRAY_SIZE(param->spkid_pulls); i++, num_pulls++) {
274
+
if (param->spkid_pulls[i] < 0)
275
+
break;
276
+
}
277
+
KUNIT_ASSERT_LE(test, num_pulls, ARRAY_SIZE(cs35l56->base.onchip_spkid_pulls));
278
+
279
+
const struct property_entry ext0_props[] = {
280
+
PROPERTY_ENTRY_U32_ARRAY_LEN("01fa-spk-id-gpios-onchip",
281
+
param->spkid_gpios, num_gpios),
282
+
PROPERTY_ENTRY_U32_ARRAY_LEN("01fa-spk-id-gpios-onchip-pull",
283
+
param->spkid_pulls, num_pulls),
284
+
{ }
285
+
};
286
+
287
+
KUNIT_ASSERT_EQ(test,
288
+
software_node_register_node_group(cs35l56_test_dev_and_af01_node_group),
289
+
0);
290
+
KUNIT_ASSERT_EQ(test,
291
+
kunit_add_action_or_reset(test,
292
+
software_node_unregister_node_group_wrapper,
293
+
cs35l56_test_dev_and_af01_node_group),
294
+
0);
295
+
296
+
ext0_node = kunit_kzalloc(test, sizeof(*ext0_node), GFP_KERNEL);
297
+
KUNIT_ASSERT_NOT_NULL(test, ext0_node);
298
+
*ext0_node = SOFTWARE_NODE("mipi-sdca-function-expansion-subproperties",
299
+
ext0_props, &cs35l56_test_af01_sw_node);
300
+
301
+
KUNIT_ASSERT_EQ(test, software_node_register(ext0_node), 0);
302
+
KUNIT_ASSERT_EQ(test,
303
+
kunit_add_action_or_reset(test,
304
+
software_node_unregister_wrapper,
305
+
ext0_node),
306
+
0);
307
+
308
+
KUNIT_ASSERT_EQ(test,
309
+
device_add_software_node(cs35l56->base.dev, &cs35l56_test_dev_sw_node), 0);
310
+
KUNIT_ASSERT_EQ(test, 0,
311
+
kunit_add_action_or_reset(test,
312
+
device_remove_software_node_wrapper,
313
+
cs35l56->base.dev));
314
+
315
+
KUNIT_EXPECT_EQ(test, cs35l56_process_xu_properties(cs35l56), 0);
316
+
317
+
KUNIT_EXPECT_EQ(test, cs35l56->base.num_onchip_spkid_gpios, num_gpios);
318
+
KUNIT_EXPECT_EQ(test, cs35l56->base.num_onchip_spkid_pulls, num_pulls);
319
+
320
+
for (i = 0; i < ARRAY_SIZE(param->spkid_gpios); i++) {
321
+
if (param->spkid_gpios[i] < 0)
322
+
break;
323
+
324
+
/*
325
+
* cs35l56_process_xu_properties() stores the GPIO numbers
326
+
* zero-based, which is one less than the value in the property.
327
+
*/
328
+
KUNIT_EXPECT_EQ_MSG(test, cs35l56->base.onchip_spkid_gpios[i],
329
+
param->spkid_gpios[i] - 1,
330
+
"i=%d", i);
331
+
}
332
+
333
+
for (i = 0; i < ARRAY_SIZE(param->spkid_pulls); i++) {
334
+
if (param->spkid_pulls[i] < 0)
335
+
break;
336
+
337
+
KUNIT_EXPECT_EQ_MSG(test, cs35l56->base.onchip_spkid_pulls[i],
338
+
param->spkid_pulls[i], "i=%d", i);
339
+
}
340
+
}
341
+
342
+
static int cs35l56_test_dummy_read_onchip_spkid(struct cs35l56_base *cs35l56_base)
343
+
{
344
+
struct kunit *test = kunit_get_current_test();
345
+
struct cs35l56_test_priv *priv = test->priv;
346
+
347
+
priv->read_onchip_spkid_called = true;
348
+
349
+
return 4;
350
+
}
351
+
352
+
static int cs35l56_test_dummy_configure_onchip_spkid_pads(struct cs35l56_base *cs35l56_base)
353
+
{
354
+
struct kunit *test = kunit_get_current_test();
355
+
struct cs35l56_test_priv *priv = test->priv;
356
+
357
+
priv->configure_onchip_spkid_pads_called = true;
358
+
359
+
return 0;
360
+
}
361
+
362
+
static void cs35l56_test_set_fw_name_reads_onchip_spkid(struct kunit *test)
363
+
{
364
+
struct cs35l56_test_priv *priv = test->priv;
365
+
struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
366
+
367
+
/* Provide some on-chip GPIOs for spkid */
368
+
cs35l56->base.onchip_spkid_gpios[0] = 1;
369
+
cs35l56->base.num_onchip_spkid_gpios = 1;
370
+
371
+
cs35l56->speaker_id = -ENOENT;
372
+
373
+
kunit_activate_static_stub(test,
374
+
cs35l56_configure_onchip_spkid_pads,
375
+
cs35l56_test_dummy_configure_onchip_spkid_pads);
376
+
kunit_activate_static_stub(test,
377
+
cs35l56_read_onchip_spkid,
378
+
cs35l56_test_dummy_read_onchip_spkid);
379
+
380
+
priv->configure_onchip_spkid_pads_called = false;
381
+
priv->read_onchip_spkid_called = false;
382
+
KUNIT_EXPECT_EQ(test, cs35l56_set_fw_name(cs35l56->component), 0);
383
+
KUNIT_EXPECT_TRUE(test, priv->configure_onchip_spkid_pads_called);
384
+
KUNIT_EXPECT_TRUE(test, priv->read_onchip_spkid_called);
385
+
KUNIT_EXPECT_EQ(test, cs35l56->speaker_id,
386
+
cs35l56_test_dummy_read_onchip_spkid(&cs35l56->base));
387
+
}
388
+
389
+
static void cs35l56_test_set_fw_name_preserves_spkid_with_onchip_gpios(struct kunit *test)
390
+
{
391
+
struct cs35l56_test_priv *priv = test->priv;
392
+
struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
393
+
394
+
/* Provide some on-chip GPIOs for spkid */
395
+
cs35l56->base.onchip_spkid_gpios[0] = 1;
396
+
cs35l56->base.num_onchip_spkid_gpios = 1;
397
+
398
+
/* Simulate that the driver already got a spkid from somewhere */
399
+
cs35l56->speaker_id = 15;
400
+
401
+
KUNIT_EXPECT_EQ(test, cs35l56_set_fw_name(cs35l56->component), 0);
402
+
KUNIT_EXPECT_EQ(test, cs35l56->speaker_id, 15);
403
+
}
404
+
405
+
static void cs35l56_test_set_fw_name_preserves_spkid_without_onchip_gpios(struct kunit *test)
406
+
{
407
+
struct cs35l56_test_priv *priv = test->priv;
408
+
struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
409
+
410
+
cs35l56->base.num_onchip_spkid_gpios = 0;
411
+
412
+
/* Simulate that the driver already got a spkid from somewhere */
413
+
cs35l56->speaker_id = 15;
414
+
415
+
KUNIT_EXPECT_EQ(test, cs35l56_set_fw_name(cs35l56->component), 0);
416
+
KUNIT_EXPECT_EQ(test, cs35l56->speaker_id, 15);
417
+
}
418
+
267
419
static int cs35l56_test_case_init_common(struct kunit *test)
268
420
{
269
421
struct cs35l56_test_priv *priv;
···
479
263
cs35l56->component = kunit_kzalloc(test, sizeof(*cs35l56->component), GFP_KERNEL);
480
264
KUNIT_ASSERT_NOT_NULL(test, cs35l56->component);
481
265
cs35l56->component->dev = cs35l56->base.dev;
266
+
snd_soc_component_set_drvdata(cs35l56->component, cs35l56);
482
267
483
268
cs35l56->component->card = kunit_kzalloc(test, sizeof(*cs35l56->component->card),
484
269
GFP_KERNEL);
···
516
299
return 0;
517
300
}
518
301
302
+
static void cs35l56_test_gpio_param_desc(const struct cs35l56_test_param *param, char *desc)
303
+
{
304
+
DECLARE_SEQ_BUF(gpios, 1 + (2 * ARRAY_SIZE(param->spkid_gpios)));
305
+
DECLARE_SEQ_BUF(pulls, 1 + (2 * ARRAY_SIZE(param->spkid_pulls)));
306
+
int i;
307
+
308
+
for (i = 0; i < ARRAY_SIZE(param->spkid_gpios); i++) {
309
+
if (param->spkid_gpios[i] < 0)
310
+
break;
311
+
312
+
seq_buf_printf(&gpios, "%s%d", (i == 0) ? "" : ",", param->spkid_gpios[i]);
313
+
}
314
+
315
+
for (i = 0; i < ARRAY_SIZE(param->spkid_pulls); i++) {
316
+
if (param->spkid_pulls[i] < 0)
317
+
break;
318
+
319
+
seq_buf_printf(&pulls, "%s%d", (i == 0) ? "" : ",", param->spkid_pulls[i]);
320
+
}
321
+
322
+
snprintf(desc, KUNIT_PARAM_DESC_SIZE, "gpios:{%s} pulls:{%s}",
323
+
seq_buf_str(&gpios), seq_buf_str(&pulls));
324
+
}
325
+
326
+
static const struct cs35l56_test_param cs35l56_test_onchip_spkid_cases[] = {
327
+
{ .spkid_gpios = { 1, -1 }, .spkid_pulls = { 1, -1 }, },
328
+
{ .spkid_gpios = { 1, -1 }, .spkid_pulls = { 2, -1 }, },
329
+
330
+
{ .spkid_gpios = { 7, -1 }, .spkid_pulls = { 1, -1 }, },
331
+
{ .spkid_gpios = { 7, -1 }, .spkid_pulls = { 2, -1 }, },
332
+
333
+
{ .spkid_gpios = { 1, 7, -1 }, .spkid_pulls = { 1, 1, -1 }, },
334
+
{ .spkid_gpios = { 1, 7, -1 }, .spkid_pulls = { 2, 2, -1 }, },
335
+
336
+
{ .spkid_gpios = { 7, 1, -1 }, .spkid_pulls = { 1, 1, -1 }, },
337
+
{ .spkid_gpios = { 7, 1, -1 }, .spkid_pulls = { 2, 2, -1 }, },
338
+
339
+
{ .spkid_gpios = { 3, 7, 1, -1 }, .spkid_pulls = { 1, 1, 1, -1 }, },
340
+
{ .spkid_gpios = { 3, 7, 1, -1 }, .spkid_pulls = { 2, 2, 2, -1 }, },
341
+
};
342
+
KUNIT_ARRAY_PARAM(cs35l56_test_onchip_spkid,
343
+
cs35l56_test_onchip_spkid_cases,
344
+
cs35l56_test_gpio_param_desc);
345
+
519
346
static void cs35l56_test_type_rev_param_desc(const struct cs35l56_test_param *param,
520
347
char *desc)
521
348
{
···
592
331
cs35l56_test_type_rev_ex_b0_gen_params),
593
332
KUNIT_CASE(cs35l56_test_l56_b0_ssidexv2_ignored_suffix_sdw),
594
333
334
+
KUNIT_CASE_PARAM(cs35l56_test_parse_xu_onchip_spkid,
335
+
cs35l56_test_onchip_spkid_gen_params),
336
+
337
+
KUNIT_CASE(cs35l56_test_set_fw_name_reads_onchip_spkid),
338
+
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_with_onchip_gpios),
339
+
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_without_onchip_gpios),
340
+
595
341
{ } /* terminator */
596
342
};
597
343
···
606
338
KUNIT_CASE_PARAM(cs35l56_test_suffix_i2cspi, cs35l56_test_type_rev_all_gen_params),
607
339
KUNIT_CASE_PARAM(cs35l56_test_ssidexv2_suffix_i2cspi,
608
340
cs35l56_test_type_rev_all_gen_params),
341
+
342
+
KUNIT_CASE(cs35l56_test_set_fw_name_reads_onchip_spkid),
343
+
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_with_onchip_gpios),
344
+
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_without_onchip_gpios),
609
345
610
346
{ } /* terminator */
611
347
};
···
632
360
);
633
361
634
362
MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
363
+
MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
635
364
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
636
365
MODULE_DESCRIPTION("KUnit test for Cirrus Logic cs35l56 codec driver");
637
366
MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
+137
-4
sound/soc/codecs/cs35l56.c
+137
-4
sound/soc/codecs/cs35l56.c
···
1179
1179
}
1180
1180
EXPORT_SYMBOL_IF_KUNIT(cs35l56_set_fw_suffix);
1181
1181
1182
-
static int cs35l56_component_probe(struct snd_soc_component *component)
1182
+
VISIBLE_IF_KUNIT int cs35l56_set_fw_name(struct snd_soc_component *component)
1183
1183
{
1184
-
struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
1185
1184
struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
1186
-
struct dentry *debugfs_root = component->debugfs_root;
1187
1185
unsigned short vendor, device;
1188
1186
int ret;
1189
1187
1190
-
BUILD_BUG_ON(ARRAY_SIZE(cs35l56_tx_input_texts) != ARRAY_SIZE(cs35l56_tx_input_values));
1188
+
if ((cs35l56->speaker_id < 0) && cs35l56->base.num_onchip_spkid_gpios) {
1189
+
PM_RUNTIME_ACQUIRE(cs35l56->base.dev, pm);
1190
+
ret = PM_RUNTIME_ACQUIRE_ERR(&pm);
1191
+
if (ret)
1192
+
return ret;
1193
+
1194
+
ret = cs35l56_configure_onchip_spkid_pads(&cs35l56->base);
1195
+
if (ret)
1196
+
return ret;
1197
+
1198
+
ret = cs35l56_read_onchip_spkid(&cs35l56->base);
1199
+
if (ret < 0)
1200
+
return ret;
1201
+
1202
+
cs35l56->speaker_id = ret;
1203
+
}
1191
1204
1192
1205
if (!cs35l56->dsp.system_name &&
1193
1206
(snd_soc_card_get_pci_ssid(component->card, &vendor, &device) == 0)) {
···
1221
1208
return -ENOMEM;
1222
1209
}
1223
1210
1211
+
return 0;
1212
+
}
1213
+
EXPORT_SYMBOL_IF_KUNIT(cs35l56_set_fw_name);
1214
+
1215
+
static int cs35l56_component_probe(struct snd_soc_component *component)
1216
+
{
1217
+
struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
1218
+
struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
1219
+
struct dentry *debugfs_root = component->debugfs_root;
1220
+
int ret;
1221
+
1222
+
BUILD_BUG_ON(ARRAY_SIZE(cs35l56_tx_input_texts) != ARRAY_SIZE(cs35l56_tx_input_values));
1223
+
1224
1224
if (!wait_for_completion_timeout(&cs35l56->init_completion,
1225
1225
msecs_to_jiffies(5000))) {
1226
1226
dev_err(cs35l56->base.dev, "%s: init_completion timed out\n", __func__);
···
1245
1219
return -ENOMEM;
1246
1220
1247
1221
cs35l56->component = component;
1222
+
ret = cs35l56_set_fw_name(component);
1223
+
if (ret)
1224
+
return ret;
1225
+
1248
1226
ret = cs35l56_set_fw_suffix(cs35l56);
1249
1227
if (ret)
1250
1228
return ret;
···
1562
1532
return 0;
1563
1533
}
1564
1534
1535
+
static int cs35l56_read_fwnode_u32_array(struct device *dev,
1536
+
struct fwnode_handle *parent_node,
1537
+
const char *prop_name,
1538
+
int max_count,
1539
+
u32 *dest)
1540
+
{
1541
+
int count, ret;
1542
+
1543
+
count = fwnode_property_count_u32(parent_node, prop_name);
1544
+
if ((count == 0) || (count == -EINVAL) || (count == -ENODATA)) {
1545
+
dev_dbg(dev, "%s not found in %s\n", prop_name, fwnode_get_name(parent_node));
1546
+
return 0;
1547
+
}
1548
+
1549
+
if (count < 0) {
1550
+
dev_err(dev, "Get %s error:%d\n", prop_name, count);
1551
+
return count;
1552
+
}
1553
+
1554
+
if (count > max_count) {
1555
+
dev_err(dev, "%s too many entries (%d)\n", prop_name, count);
1556
+
return -EOVERFLOW;
1557
+
}
1558
+
1559
+
ret = fwnode_property_read_u32_array(parent_node, prop_name, dest, count);
1560
+
if (ret) {
1561
+
dev_err(dev, "Error reading %s: %d\n", prop_name, ret);
1562
+
return ret;
1563
+
}
1564
+
1565
+
return count;
1566
+
}
1567
+
1568
+
static int cs35l56_process_xu_onchip_speaker_id(struct cs35l56_private *cs35l56,
1569
+
struct fwnode_handle *ext_node)
1570
+
{
1571
+
static const char * const gpio_name = "01fa-spk-id-gpios-onchip";
1572
+
static const char * const pull_name = "01fa-spk-id-gpios-onchip-pull";
1573
+
u32 gpios[5], pulls[5];
1574
+
int num_gpios, num_pulls;
1575
+
int ret;
1576
+
1577
+
static_assert(ARRAY_SIZE(gpios) == ARRAY_SIZE(cs35l56->base.onchip_spkid_gpios));
1578
+
static_assert(ARRAY_SIZE(pulls) == ARRAY_SIZE(cs35l56->base.onchip_spkid_pulls));
1579
+
1580
+
num_gpios = cs35l56_read_fwnode_u32_array(cs35l56->base.dev, ext_node, gpio_name,
1581
+
ARRAY_SIZE(gpios), gpios);
1582
+
if (num_gpios < 1)
1583
+
return num_gpios;
1584
+
1585
+
num_pulls = cs35l56_read_fwnode_u32_array(cs35l56->base.dev, ext_node, pull_name,
1586
+
ARRAY_SIZE(pulls), pulls);
1587
+
if (num_pulls < 0)
1588
+
return num_pulls;
1589
+
1590
+
if (num_pulls != num_gpios) {
1591
+
dev_warn(cs35l56->base.dev, "%s count(%d) != %s count(%d)\n",
1592
+
pull_name, num_pulls, gpio_name, num_gpios);
1593
+
}
1594
+
1595
+
ret = cs35l56_check_and_save_onchip_spkid_gpios(&cs35l56->base,
1596
+
gpios, num_gpios,
1597
+
pulls, num_pulls);
1598
+
if (ret) {
1599
+
return dev_err_probe(cs35l56->base.dev, ret, "Error in %s/%s\n",
1600
+
gpio_name, pull_name);
1601
+
}
1602
+
1603
+
return 0;
1604
+
}
1605
+
1606
+
VISIBLE_IF_KUNIT int cs35l56_process_xu_properties(struct cs35l56_private *cs35l56)
1607
+
{
1608
+
struct fwnode_handle *ext_node = NULL;
1609
+
struct fwnode_handle *link;
1610
+
int ret;
1611
+
1612
+
if (!cs35l56->sdw_peripheral)
1613
+
return 0;
1614
+
1615
+
fwnode_for_each_child_node(dev_fwnode(cs35l56->base.dev), link) {
1616
+
ext_node = fwnode_get_named_child_node(link,
1617
+
"mipi-sdca-function-expansion-subproperties");
1618
+
if (ext_node) {
1619
+
fwnode_handle_put(link);
1620
+
break;
1621
+
}
1622
+
}
1623
+
1624
+
if (!ext_node)
1625
+
return 0;
1626
+
1627
+
ret = cs35l56_process_xu_onchip_speaker_id(cs35l56, ext_node);
1628
+
fwnode_handle_put(ext_node);
1629
+
1630
+
return ret;
1631
+
}
1632
+
EXPORT_SYMBOL_IF_KUNIT(cs35l56_process_xu_properties);
1633
+
1565
1634
static int cs35l56_get_firmware_uid(struct cs35l56_private *cs35l56)
1566
1635
{
1567
1636
struct device *dev = cs35l56->base.dev;
···
1839
1710
1840
1711
ret = cs35l56_get_firmware_uid(cs35l56);
1841
1712
if (ret != 0)
1713
+
goto err;
1714
+
1715
+
ret = cs35l56_process_xu_properties(cs35l56);
1716
+
if (ret)
1842
1717
goto err;
1843
1718
1844
1719
ret = cs35l56_dsp_init(cs35l56);
+2
sound/soc/codecs/cs35l56.h
+2
sound/soc/codecs/cs35l56.h
···
76
76
77
77
#if IS_ENABLED(CONFIG_KUNIT)
78
78
int cs35l56_set_fw_suffix(struct cs35l56_private *cs35l56);
79
+
int cs35l56_set_fw_name(struct snd_soc_component *component);
80
+
int cs35l56_process_xu_properties(struct cs35l56_private *cs35l56);
79
81
#endif
80
82
81
83
#endif /* ifndef CS35L56_H */