Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-6.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"A pile of fixes that have been gathered since the previous pull. Most
of changes are device-specific, and nothing looks too scary.
- A memory leak fix in ALSA sequencer code in 6.5-rc
- Many fixes for ASoC Qualcomm CODEC drivers, covering SoundWire
probe problems
- A series of ASoC AMD fixes
- A few fixes and cleanups of selftest stuff
- HD-audio codec fixes and quirks for Clevo, HP, Lenovo, Dell"
* tag 'sound-6.5-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (52 commits)
ALSA: hda/realtek: Add support for DELL Oasis 13/14/16 laptops
ALSA: hda/realtek: Fix generic fixup definition for cs35l41 amp
ALSA: hda/realtek: Enable Mute LED on HP Laptop 15s-eq2xxx
selftests: ALSA: Add test-pcmtest-driver to .gitignore
ALSA: hda/realtek: Add quirk for Clevo NS70AU
ASoC: fsl_sai: Disable bit clock with transmitter
ALSA: seq: Fix memory leak at error path in snd_seq_create_port()
ASoC: SOF: ipc3-dtrace: uninitialized data in dfsentry_trace_filter_write()
ASoC: cs42l51: fix driver to properly autoload with automatic module loading
MAINTAINERS: Redo addition of ssm3515 to APPLE SOUND
ASoC: rt5640: Fix the issue of speaker noise
ALSA: hda/realtek - remove 3k pull low procedure
selftests: ALSA: Fix fclose on an already fclosed file pointer
ALSA: pcmtest: Don't use static storage to track per device data
ALSA: pcmtest: Convert to platform remove callback returning void
ASoC: dt-bindings: audio-graph-card2: Drop incomplete example
ASoC: dt-bindings: Update maintainer email id
ASoC: amd: ps: Fix extraneous error messages
ASoC: fsl_sai: Revert "ASoC: fsl_sai: Enable MCTL_MCLK_EN bit for master mode"
ASoC: codecs: SND_SOC_WCD934X should select REGMAP_IRQ
...
+342
-156
+1
-19
Documentation/devicetree/bindings/sound/audio-graph-card2.yaml
+1
-19
Documentation/devicetree/bindings/sound/audio-graph-card2.yaml
···
39
39
40
40
additionalProperties: false
41
41
42
-
examples:
43
-
- |
44
-
sound {
45
-
compatible = "audio-graph-card2";
46
-
47
-
links = <&cpu_port>;
48
-
};
49
-
50
-
cpu {
51
-
compatible = "cpu-driver";
52
-
53
-
cpu_port: port { cpu_ep: endpoint { remote-endpoint = <&codec_ep>; }; };
54
-
};
55
-
56
-
codec {
57
-
compatible = "codec-driver";
58
-
59
-
port { codec_ep: endpoint { remote-endpoint = <&cpu_ep>; }; };
60
-
};
42
+
...
+1
-1
Documentation/devicetree/bindings/sound/google,sc7180-trogdor.yaml
+1
-1
Documentation/devicetree/bindings/sound/google,sc7180-trogdor.yaml
+1
-1
Documentation/devicetree/bindings/sound/qcom,lpass-cpu.yaml
+1
-1
Documentation/devicetree/bindings/sound/qcom,lpass-cpu.yaml
+2
MAINTAINERS
+2
MAINTAINERS
···
1865
1865
L: asahi@lists.linux.dev
1866
1866
L: alsa-devel@alsa-project.org (moderated for non-subscribers)
1867
1867
S: Maintained
1868
+
F: Documentation/devicetree/bindings/sound/adi,ssm3515.yaml
1868
1869
F: Documentation/devicetree/bindings/sound/apple,*
1869
1870
F: sound/soc/apple/*
1870
1871
F: sound/soc/codecs/cs42l83-i2c.c
1872
+
F: sound/soc/codecs/ssm3515.c
1871
1873
1872
1874
ARM/APPLE MACHINE SUPPORT
1873
1875
M: Hector Martin <marcan@marcan.st>
+1
sound/core/seq/seq_ports.c
+1
sound/core/seq/seq_ports.c
+7
-5
sound/drivers/pcmtest.c
+7
-5
sound/drivers/pcmtest.c
···
110
110
struct timer_list timer_instance;
111
111
};
112
112
113
-
static struct pcmtst *pcmtst;
114
-
115
113
static struct snd_pcm_hardware snd_pcmtst_hw = {
116
114
.info = (SNDRV_PCM_INFO_INTERLEAVED |
117
115
SNDRV_PCM_INFO_BLOCK_TRANSFER |
···
550
552
static int pcmtst_probe(struct platform_device *pdev)
551
553
{
552
554
struct snd_card *card;
555
+
struct pcmtst *pcmtst;
553
556
int err;
554
557
555
558
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
···
572
573
if (err < 0)
573
574
return err;
574
575
576
+
platform_set_drvdata(pdev, pcmtst);
577
+
575
578
return 0;
576
579
}
577
580
578
-
static int pdev_remove(struct platform_device *dev)
581
+
static void pdev_remove(struct platform_device *pdev)
579
582
{
583
+
struct pcmtst *pcmtst = platform_get_drvdata(pdev);
584
+
580
585
snd_pcmtst_free(pcmtst);
581
-
return 0;
582
586
}
583
587
584
588
static struct platform_device pcmtst_pdev = {
···
591
589
592
590
static struct platform_driver pcmtst_pdrv = {
593
591
.probe = pcmtst_probe,
594
-
.remove = pdev_remove,
592
+
.remove_new = pdev_remove,
595
593
.driver = {
596
594
.name = "pcmtest",
597
595
},
+50
-12
sound/pci/hda/patch_realtek.c
+50
-12
sound/pci/hda/patch_realtek.c
···
122
122
unsigned int ultra_low_power:1;
123
123
unsigned int has_hs_key:1;
124
124
unsigned int no_internal_mic_pin:1;
125
+
unsigned int en_3kpull_low:1;
125
126
126
127
/* for PLL fix */
127
128
hda_nid_t pll_nid;
···
3623
3622
if (!hp_pin)
3624
3623
hp_pin = 0x21;
3625
3624
3625
+
alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3626
3626
hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3627
3627
3628
3628
if (hp_pin_sense)
···
3640
3638
/* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3641
3639
* when booting with headset plugged. So skip setting it for the codec alc257
3642
3640
*/
3643
-
if (codec->core.vendor_id != 0x10ec0236 &&
3644
-
codec->core.vendor_id != 0x10ec0257)
3641
+
if (spec->en_3kpull_low)
3645
3642
alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3646
3643
3647
3644
if (!spec->no_shutup_pins)
···
4620
4619
spec->mute_led_coef.mask = 1 << 5;
4621
4620
spec->mute_led_coef.on = 0;
4622
4621
spec->mute_led_coef.off = 1 << 5;
4622
+
snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4623
+
}
4624
+
}
4625
+
4626
+
static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4627
+
const struct hda_fixup *fix, int action)
4628
+
{
4629
+
struct alc_spec *spec = codec->spec;
4630
+
4631
+
if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4632
+
spec->mute_led_polarity = 0;
4633
+
spec->mute_led_coef.idx = 0x07;
4634
+
spec->mute_led_coef.mask = 1;
4635
+
spec->mute_led_coef.on = 1;
4636
+
spec->mute_led_coef.off = 0;
4623
4637
snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4624
4638
}
4625
4639
}
···
7159
7143
ALC285_FIXUP_HP_GPIO_LED,
7160
7144
ALC285_FIXUP_HP_MUTE_LED,
7161
7145
ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7146
+
ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7162
7147
ALC236_FIXUP_HP_GPIO_LED,
7163
7148
ALC236_FIXUP_HP_MUTE_LED,
7164
7149
ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
···
7230
7213
ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7231
7214
ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7232
7215
ALC236_FIXUP_DELL_DUAL_CODECS,
7216
+
ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7233
7217
};
7234
7218
7235
7219
/* A special fixup for Lenovo C940 and Yoga Duet 7;
···
8650
8632
.type = HDA_FIXUP_FUNC,
8651
8633
.v.func = alc285_fixup_hp_spectre_x360_mute_led,
8652
8634
},
8635
+
[ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8636
+
.type = HDA_FIXUP_FUNC,
8637
+
.v.func = alc236_fixup_hp_mute_led_coefbit2,
8638
+
},
8653
8639
[ALC236_FIXUP_HP_GPIO_LED] = {
8654
8640
.type = HDA_FIXUP_FUNC,
8655
8641
.v.func = alc236_fixup_hp_gpio_led,
···
9167
9145
[ALC287_FIXUP_CS35L41_I2C_2] = {
9168
9146
.type = HDA_FIXUP_FUNC,
9169
9147
.v.func = cs35l41_fixup_i2c_two,
9170
-
.chained = true,
9171
-
.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9172
9148
},
9173
9149
[ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9174
9150
.type = HDA_FIXUP_FUNC,
···
9303
9283
.chained = true,
9304
9284
.chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9305
9285
},
9286
+
[ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9287
+
.type = HDA_FIXUP_FUNC,
9288
+
.v.func = cs35l41_fixup_i2c_two,
9289
+
.chained = true,
9290
+
.chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9291
+
},
9306
9292
};
9307
9293
9308
9294
static const struct snd_pci_quirk alc269_fixup_tbl[] = {
···
9419
9393
SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9420
9394
SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9421
9395
SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9396
+
SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC245_FIXUP_CS35L41_SPI_2),
9397
+
SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC245_FIXUP_CS35L41_SPI_2),
9398
+
SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC245_FIXUP_CS35L41_SPI_2),
9399
+
SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC287_FIXUP_CS35L41_I2C_2),
9400
+
SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC287_FIXUP_CS35L41_I2C_2),
9401
+
SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC287_FIXUP_CS35L41_I2C_2),
9402
+
SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC287_FIXUP_CS35L41_I2C_2),
9403
+
SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis MLK 14 RPL-P", ALC287_FIXUP_CS35L41_I2C_2),
9422
9404
SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9423
9405
SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9424
9406
SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
···
9550
9516
SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9551
9517
SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9552
9518
SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9519
+
SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9553
9520
SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9554
9521
SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9555
9522
SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
···
9762
9727
SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9763
9728
SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9764
9729
SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9730
+
SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9765
9731
SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9766
9732
SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9767
9733
SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
···
9846
9810
SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
9847
9811
SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
9848
9812
SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
9849
-
SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9850
-
SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9851
-
SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9852
-
SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2),
9853
-
SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2),
9854
-
SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_CS35L41_I2C_2),
9855
-
SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2),
9856
-
SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2),
9813
+
SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9814
+
SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9815
+
SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9816
+
SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9817
+
SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9818
+
SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9819
+
SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9820
+
SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI),
9857
9821
SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
9858
9822
SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
9859
9823
SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
···
10718
10682
spec->shutup = alc256_shutup;
10719
10683
spec->init_hook = alc256_init;
10720
10684
spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
10685
+
if (codec->bus->pci->vendor == PCI_VENDOR_ID_AMD)
10686
+
spec->en_3kpull_low = true;
10721
10687
break;
10722
10688
case 0x10ec0257:
10723
10689
spec->codec_variant = ALC269_TYPE_ALC257;
+4
-3
sound/soc/amd/acp/amd.h
+4
-3
sound/soc/amd/acp/amd.h
···
173
173
174
174
static inline u64 acp_get_byte_count(struct acp_dev_data *adata, int dai_id, int direction)
175
175
{
176
-
u64 byte_count, low = 0, high = 0;
176
+
u64 byte_count = 0, low = 0, high = 0;
177
177
178
178
if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
179
179
switch (dai_id) {
···
191
191
break;
192
192
default:
193
193
dev_err(adata->dev, "Invalid dai id %x\n", dai_id);
194
-
return -EINVAL;
194
+
goto POINTER_RETURN_BYTES;
195
195
}
196
196
} else {
197
197
switch (dai_id) {
···
213
213
break;
214
214
default:
215
215
dev_err(adata->dev, "Invalid dai id %x\n", dai_id);
216
-
return -EINVAL;
216
+
goto POINTER_RETURN_BYTES;
217
217
}
218
218
}
219
219
/* Get 64 bit value from two 32 bit registers */
220
220
byte_count = (high << 32) | low;
221
221
222
+
POINTER_RETURN_BYTES:
222
223
return byte_count;
223
224
}
224
225
+21
-1
sound/soc/amd/ps/acp63.h
+21
-1
sound/soc/amd/ps/acp63.h
···
116
116
#define ACP63_SDW0_DMA_MAX_STREAMS 6
117
117
#define ACP63_SDW1_DMA_MAX_STREAMS 2
118
118
#define ACP_P1_AUDIO_TX_THRESHOLD 6
119
+
120
+
/*
121
+
* Below entries describes SDW0 instance DMA stream id and DMA irq bit mapping
122
+
* in ACP_EXTENAL_INTR_CNTL register.
123
+
* Stream id IRQ Bit
124
+
* 0 (SDW0_AUDIO0_TX) 28
125
+
* 1 (SDW0_AUDIO1_TX) 26
126
+
* 2 (SDW0_AUDIO2_TX) 24
127
+
* 3 (SDW0_AUDIO0_RX) 27
128
+
* 4 (SDW0_AUDIO1_RX) 25
129
+
* 5 (SDW0_AUDIO2_RX) 23
130
+
*/
119
131
#define SDW0_DMA_TX_IRQ_MASK(i) (ACP_AUDIO0_TX_THRESHOLD - (2 * (i)))
120
-
#define SDW0_DMA_RX_IRQ_MASK(i) (ACP_AUDIO0_RX_THRESHOLD - (2 * (i)))
132
+
#define SDW0_DMA_RX_IRQ_MASK(i) (ACP_AUDIO0_RX_THRESHOLD - (2 * ((i) - 3)))
133
+
134
+
/*
135
+
* Below entries describes SDW1 instance DMA stream id and DMA irq bit mapping
136
+
* in ACP_EXTENAL_INTR_CNTL1 register.
137
+
* Stream id IRQ Bit
138
+
* 0 (SDW1_AUDIO1_TX) 6
139
+
* 1 (SDW1_AUDIO1_RX) 5
140
+
*/
121
141
#define SDW1_DMA_IRQ_MASK(i) (ACP_P1_AUDIO_TX_THRESHOLD - (i))
122
142
123
143
#define ACP_DELAY_US 5
+2
-2
sound/soc/amd/ps/pci-ps.c
+2
-2
sound/soc/amd/ps/pci-ps.c
···
257
257
&sdw_manager_bitmap, 1);
258
258
259
259
if (ret) {
260
-
dev_err(dev, "Failed to read mipi-sdw-manager-list: %d\n", ret);
260
+
dev_dbg(dev, "Failed to read mipi-sdw-manager-list: %d\n", ret);
261
261
return -EINVAL;
262
262
}
263
263
count = hweight32(sdw_manager_bitmap);
···
641
641
ret = get_acp63_device_config(val, pci, adata);
642
642
/* ACP PCI driver probe should be continued even PDM or SoundWire Devices are not found */
643
643
if (ret) {
644
-
dev_err(&pci->dev, "get acp device config failed:%d\n", ret);
644
+
dev_dbg(&pci->dev, "get acp device config failed:%d\n", ret);
645
645
goto skip_pdev_creation;
646
646
}
647
647
ret = create_acp63_platform_devs(pci, adata, addr);
+14
-2
sound/soc/amd/ps/ps-sdw-dma.c
+14
-2
sound/soc/amd/ps/ps-sdw-dma.c
···
30
30
ACP_AUDIO2_TX_LINEARPOSITIONCNTR_LOW, ACP_AUDIO2_TX_LINEARPOSITIONCNTR_HIGH},
31
31
{ACP_AUDIO0_RX_DMA_SIZE, ACP_AUDIO0_RX_FIFOADDR, ACP_AUDIO0_RX_FIFOSIZE,
32
32
ACP_AUDIO0_RX_RINGBUFSIZE, ACP_AUDIO0_RX_RINGBUFADDR, ACP_AUDIO0_RX_INTR_WATERMARK_SIZE,
33
-
ACP_AUDIO0_TX_LINEARPOSITIONCNTR_LOW, ACP_AUDIO0_TX_LINEARPOSITIONCNTR_HIGH},
33
+
ACP_AUDIO0_RX_LINEARPOSITIONCNTR_LOW, ACP_AUDIO0_RX_LINEARPOSITIONCNTR_HIGH},
34
34
{ACP_AUDIO1_RX_DMA_SIZE, ACP_AUDIO1_RX_FIFOADDR, ACP_AUDIO1_RX_FIFOSIZE,
35
35
ACP_AUDIO1_RX_RINGBUFSIZE, ACP_AUDIO1_RX_RINGBUFADDR, ACP_AUDIO1_RX_INTR_WATERMARK_SIZE,
36
36
ACP_AUDIO1_RX_LINEARPOSITIONCNTR_LOW, ACP_AUDIO1_RX_LINEARPOSITIONCNTR_HIGH},
···
39
39
ACP_AUDIO2_RX_LINEARPOSITIONCNTR_LOW, ACP_AUDIO2_RX_LINEARPOSITIONCNTR_HIGH}
40
40
};
41
41
42
+
/*
43
+
* SDW1 instance supports one TX stream and one RX stream.
44
+
* For TX/RX streams DMA registers programming for SDW1 instance, it uses ACP_P1_AUDIO1 register
45
+
* set as per hardware register documentation
46
+
*/
42
47
static struct sdw_dma_ring_buf_reg sdw1_dma_ring_buf_reg[ACP63_SDW1_DMA_MAX_STREAMS] = {
43
48
{ACP_P1_AUDIO1_TX_DMA_SIZE, ACP_P1_AUDIO1_TX_FIFOADDR, ACP_P1_AUDIO1_TX_FIFOSIZE,
44
49
ACP_P1_AUDIO1_TX_RINGBUFSIZE, ACP_P1_AUDIO1_TX_RINGBUFADDR,
···
64
59
ACP_SW0_AUDIO2_RX_EN,
65
60
};
66
61
62
+
/*
63
+
* SDW1 instance supports one TX stream and one RX stream.
64
+
* For TX/RX streams DMA enable register programming for SDW1 instance,
65
+
* it uses ACP_SW1_AUDIO1_TX_EN and ACP_SW1_AUDIO1_RX_EN registers
66
+
* as per hardware register documentation.
67
+
*/
67
68
static u32 sdw1_dma_enable_reg[ACP63_SDW1_DMA_MAX_STREAMS] = {
68
69
ACP_SW1_AUDIO1_TX_EN,
69
70
ACP_SW1_AUDIO1_RX_EN,
···
318
307
pos_high_reg = sdw1_dma_ring_buf_reg[stream->stream_id].pos_high_reg;
319
308
break;
320
309
default:
321
-
return -EINVAL;
310
+
goto POINTER_RETURN_BYTES;
322
311
}
323
312
if (pos_low_reg) {
324
313
byte_count.bcount.high = readl(acp_base + pos_high_reg);
325
314
byte_count.bcount.low = readl(acp_base + pos_low_reg);
326
315
}
316
+
POINTER_RETURN_BYTES:
327
317
return byte_count.bytescount;
328
318
}
329
319
+2
sound/soc/codecs/Kconfig
+2
sound/soc/codecs/Kconfig
···
715
715
716
716
config SND_SOC_CS35L45
717
717
tristate
718
+
select REGMAP_IRQ
718
719
719
720
config SND_SOC_CS35L45_SPI
720
721
tristate "Cirrus Logic CS35L45 CODEC (SPI)"
···
1943
1942
tristate "WCD9340/WCD9341 Codec"
1944
1943
depends on COMMON_CLK
1945
1944
depends on SLIMBUS
1945
+
select REGMAP_IRQ
1946
1946
select REGMAP_SLIMBUS
1947
1947
select SND_SOC_WCD_MBHC
1948
1948
depends on MFD_WCD934X || COMPILE_TEST
+6
sound/soc/codecs/cs42l51-i2c.c
+6
sound/soc/codecs/cs42l51-i2c.c
···
19
19
};
20
20
MODULE_DEVICE_TABLE(i2c, cs42l51_i2c_id);
21
21
22
+
const struct of_device_id cs42l51_of_match[] = {
23
+
{ .compatible = "cirrus,cs42l51", },
24
+
{ }
25
+
};
26
+
MODULE_DEVICE_TABLE(of, cs42l51_of_match);
27
+
22
28
static int cs42l51_i2c_probe(struct i2c_client *i2c)
23
29
{
24
30
struct regmap_config config;
-7
sound/soc/codecs/cs42l51.c
-7
sound/soc/codecs/cs42l51.c
···
823
823
}
824
824
EXPORT_SYMBOL_GPL(cs42l51_resume);
825
825
826
-
const struct of_device_id cs42l51_of_match[] = {
827
-
{ .compatible = "cirrus,cs42l51", },
828
-
{ }
829
-
};
830
-
MODULE_DEVICE_TABLE(of, cs42l51_of_match);
831
-
EXPORT_SYMBOL_GPL(cs42l51_of_match);
832
-
833
826
MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
834
827
MODULE_DESCRIPTION("Cirrus Logic CS42L51 ALSA SoC Codec Driver");
835
828
MODULE_LICENSE("GPL");
-1
sound/soc/codecs/cs42l51.h
-1
sound/soc/codecs/cs42l51.h
···
16
16
void cs42l51_remove(struct device *dev);
17
17
int __maybe_unused cs42l51_suspend(struct device *dev);
18
18
int __maybe_unused cs42l51_resume(struct device *dev);
19
-
extern const struct of_device_id cs42l51_of_match[];
20
19
21
20
#define CS42L51_CHIP_ID 0x1B
22
21
#define CS42L51_CHIP_REV_A 0x00
+7
-6
sound/soc/codecs/rt5640.c
+7
-6
sound/soc/codecs/rt5640.c
···
53
53
{RT5640_PR_BASE + 0x3d, 0x3600},
54
54
{RT5640_PR_BASE + 0x12, 0x0aa8},
55
55
{RT5640_PR_BASE + 0x14, 0x0aaa},
56
-
{RT5640_PR_BASE + 0x20, 0x6110},
57
56
{RT5640_PR_BASE + 0x21, 0xe0e0},
58
57
{RT5640_PR_BASE + 0x23, 0x1804},
59
58
};
···
2566
2567
if (jack_data && jack_data->use_platform_clock)
2567
2568
rt5640->use_platform_clock = jack_data->use_platform_clock;
2568
2569
2569
-
ret = request_irq(rt5640->irq, rt5640_irq,
2570
-
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
2571
-
"rt5640", rt5640);
2570
+
ret = devm_request_threaded_irq(component->dev, rt5640->irq,
2571
+
NULL, rt5640_irq,
2572
+
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
2573
+
"rt5640", rt5640);
2572
2574
if (ret) {
2573
2575
dev_warn(component->dev, "Failed to reguest IRQ %d: %d\n", rt5640->irq, ret);
2574
2576
rt5640_disable_jack_detect(component);
···
2622
2622
2623
2623
rt5640->jack = jack;
2624
2624
2625
-
ret = request_irq(rt5640->irq, rt5640_irq,
2626
-
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "rt5640", rt5640);
2625
+
ret = devm_request_threaded_irq(component->dev, rt5640->irq,
2626
+
NULL, rt5640_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2627
+
"rt5640", rt5640);
2627
2628
if (ret) {
2628
2629
dev_warn(component->dev, "Failed to reguest IRQ %d: %d\n", rt5640->irq, ret);
2629
2630
rt5640->irq = -ENXIO;
+5
-1
sound/soc/codecs/rt5645.c
+5
-1
sound/soc/codecs/rt5645.c
···
3950
3950
* read and power On.
3951
3951
*/
3952
3952
msleep(TIME_TO_POWER_MS);
3953
-
regmap_read(regmap, RT5645_VENDOR_ID2, &val);
3953
+
ret = regmap_read(regmap, RT5645_VENDOR_ID2, &val);
3954
+
if (ret < 0) {
3955
+
dev_err(&i2c->dev, "Failed to read: 0x%02X\n, ret = %d", RT5645_VENDOR_ID2, ret);
3956
+
goto err_enable;
3957
+
}
3954
3958
3955
3959
switch (val) {
3956
3960
case RT5645_DEVICE_ID:
+41
-16
sound/soc/codecs/wcd-mbhc-v2.c
+41
-16
sound/soc/codecs/wcd-mbhc-v2.c
···
1454
1454
return ERR_PTR(-EINVAL);
1455
1455
}
1456
1456
1457
-
mbhc = devm_kzalloc(dev, sizeof(*mbhc), GFP_KERNEL);
1457
+
mbhc = kzalloc(sizeof(*mbhc), GFP_KERNEL);
1458
1458
if (!mbhc)
1459
1459
return ERR_PTR(-ENOMEM);
1460
1460
···
1474
1474
1475
1475
INIT_WORK(&mbhc->correct_plug_swch, wcd_correct_swch_plug);
1476
1476
1477
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->mbhc_sw_intr, NULL,
1477
+
ret = request_threaded_irq(mbhc->intr_ids->mbhc_sw_intr, NULL,
1478
1478
wcd_mbhc_mech_plug_detect_irq,
1479
1479
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1480
1480
"mbhc sw intr", mbhc);
1481
1481
if (ret)
1482
-
goto err;
1482
+
goto err_free_mbhc;
1483
1483
1484
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->mbhc_btn_press_intr, NULL,
1484
+
ret = request_threaded_irq(mbhc->intr_ids->mbhc_btn_press_intr, NULL,
1485
1485
wcd_mbhc_btn_press_handler,
1486
1486
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1487
1487
"Button Press detect", mbhc);
1488
1488
if (ret)
1489
-
goto err;
1489
+
goto err_free_sw_intr;
1490
1490
1491
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->mbhc_btn_release_intr, NULL,
1491
+
ret = request_threaded_irq(mbhc->intr_ids->mbhc_btn_release_intr, NULL,
1492
1492
wcd_mbhc_btn_release_handler,
1493
1493
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1494
1494
"Button Release detect", mbhc);
1495
1495
if (ret)
1496
-
goto err;
1496
+
goto err_free_btn_press_intr;
1497
1497
1498
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->mbhc_hs_ins_intr, NULL,
1498
+
ret = request_threaded_irq(mbhc->intr_ids->mbhc_hs_ins_intr, NULL,
1499
1499
wcd_mbhc_adc_hs_ins_irq,
1500
1500
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1501
1501
"Elect Insert", mbhc);
1502
1502
if (ret)
1503
-
goto err;
1503
+
goto err_free_btn_release_intr;
1504
1504
1505
1505
disable_irq_nosync(mbhc->intr_ids->mbhc_hs_ins_intr);
1506
1506
1507
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->mbhc_hs_rem_intr, NULL,
1507
+
ret = request_threaded_irq(mbhc->intr_ids->mbhc_hs_rem_intr, NULL,
1508
1508
wcd_mbhc_adc_hs_rem_irq,
1509
1509
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1510
1510
"Elect Remove", mbhc);
1511
1511
if (ret)
1512
-
goto err;
1512
+
goto err_free_hs_ins_intr;
1513
1513
1514
1514
disable_irq_nosync(mbhc->intr_ids->mbhc_hs_rem_intr);
1515
1515
1516
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->hph_left_ocp, NULL,
1516
+
ret = request_threaded_irq(mbhc->intr_ids->hph_left_ocp, NULL,
1517
1517
wcd_mbhc_hphl_ocp_irq,
1518
1518
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1519
1519
"HPH_L OCP detect", mbhc);
1520
1520
if (ret)
1521
-
goto err;
1521
+
goto err_free_hs_rem_intr;
1522
1522
1523
-
ret = devm_request_threaded_irq(dev, mbhc->intr_ids->hph_right_ocp, NULL,
1523
+
ret = request_threaded_irq(mbhc->intr_ids->hph_right_ocp, NULL,
1524
1524
wcd_mbhc_hphr_ocp_irq,
1525
1525
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
1526
1526
"HPH_R OCP detect", mbhc);
1527
1527
if (ret)
1528
-
goto err;
1528
+
goto err_free_hph_left_ocp;
1529
1529
1530
1530
return mbhc;
1531
-
err:
1531
+
1532
+
err_free_hph_left_ocp:
1533
+
free_irq(mbhc->intr_ids->hph_left_ocp, mbhc);
1534
+
err_free_hs_rem_intr:
1535
+
free_irq(mbhc->intr_ids->mbhc_hs_rem_intr, mbhc);
1536
+
err_free_hs_ins_intr:
1537
+
free_irq(mbhc->intr_ids->mbhc_hs_ins_intr, mbhc);
1538
+
err_free_btn_release_intr:
1539
+
free_irq(mbhc->intr_ids->mbhc_btn_release_intr, mbhc);
1540
+
err_free_btn_press_intr:
1541
+
free_irq(mbhc->intr_ids->mbhc_btn_press_intr, mbhc);
1542
+
err_free_sw_intr:
1543
+
free_irq(mbhc->intr_ids->mbhc_sw_intr, mbhc);
1544
+
err_free_mbhc:
1545
+
kfree(mbhc);
1546
+
1532
1547
dev_err(dev, "Failed to request mbhc interrupts %d\n", ret);
1533
1548
1534
1549
return ERR_PTR(ret);
···
1552
1537
1553
1538
void wcd_mbhc_deinit(struct wcd_mbhc *mbhc)
1554
1539
{
1540
+
free_irq(mbhc->intr_ids->hph_right_ocp, mbhc);
1541
+
free_irq(mbhc->intr_ids->hph_left_ocp, mbhc);
1542
+
free_irq(mbhc->intr_ids->mbhc_hs_rem_intr, mbhc);
1543
+
free_irq(mbhc->intr_ids->mbhc_hs_ins_intr, mbhc);
1544
+
free_irq(mbhc->intr_ids->mbhc_btn_release_intr, mbhc);
1545
+
free_irq(mbhc->intr_ids->mbhc_btn_press_intr, mbhc);
1546
+
free_irq(mbhc->intr_ids->mbhc_sw_intr, mbhc);
1547
+
1555
1548
mutex_lock(&mbhc->lock);
1556
1549
wcd_cancel_hs_detect_plug(mbhc, &mbhc->correct_plug_swch);
1557
1550
mutex_unlock(&mbhc->lock);
1551
+
1552
+
kfree(mbhc);
1558
1553
}
1559
1554
EXPORT_SYMBOL(wcd_mbhc_deinit);
1560
1555
+16
-4
sound/soc/codecs/wcd934x.c
+16
-4
sound/soc/codecs/wcd934x.c
···
2642
2642
return rc;
2643
2643
}
2644
2644
2645
-
static inline void wcd934x_mbhc_get_result_params(struct wcd934x_codec *wcd934x,
2645
+
static void wcd934x_mbhc_get_result_params(struct wcd934x_codec *wcd934x,
2646
2646
s16 *d1_a, u16 noff,
2647
2647
int32_t *zdet)
2648
2648
{
···
2683
2683
else if (x1 < minCode_param[noff])
2684
2684
*zdet = WCD934X_ZDET_FLOATING_IMPEDANCE;
2685
2685
2686
-
dev_info(wcd934x->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%d(milliOhm)\n",
2686
+
dev_dbg(wcd934x->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%di (milliohm)\n",
2687
2687
__func__, d1, c1, x1, *zdet);
2688
2688
ramp_down:
2689
2689
i = 0;
···
2740
2740
*zr = zdet;
2741
2741
}
2742
2742
2743
-
static inline void wcd934x_wcd_mbhc_qfuse_cal(struct snd_soc_component *component,
2744
-
int32_t *z_val, int flag_l_r)
2743
+
static void wcd934x_wcd_mbhc_qfuse_cal(struct snd_soc_component *component,
2744
+
int32_t *z_val, int flag_l_r)
2745
2745
{
2746
2746
s16 q1;
2747
2747
int q1_cal;
···
3044
3044
3045
3045
return 0;
3046
3046
}
3047
+
3048
+
static void wcd934x_mbhc_deinit(struct snd_soc_component *component)
3049
+
{
3050
+
struct wcd934x_codec *wcd = snd_soc_component_get_drvdata(component);
3051
+
3052
+
if (!wcd->mbhc)
3053
+
return;
3054
+
3055
+
wcd_mbhc_deinit(wcd->mbhc);
3056
+
}
3057
+
3047
3058
static int wcd934x_comp_probe(struct snd_soc_component *component)
3048
3059
{
3049
3060
struct wcd934x_codec *wcd = dev_get_drvdata(component->dev);
···
3088
3077
{
3089
3078
struct wcd934x_codec *wcd = dev_get_drvdata(comp->dev);
3090
3079
3080
+
wcd934x_mbhc_deinit(comp);
3091
3081
wcd_clsh_ctrl_free(wcd->clsh_ctrl);
3092
3082
}
3093
3083
+81
-18
sound/soc/codecs/wcd938x.c
+81
-18
sound/soc/codecs/wcd938x.c
···
210
210
};
211
211
212
212
static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(ear_pa_gain, 600, -1800);
213
-
static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(line_gain, 600, -3000);
213
+
static const DECLARE_TLV_DB_SCALE(line_gain, -3000, 150, -3000);
214
214
static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(analog_gain, 0, 3000);
215
215
216
216
struct wcd938x_mbhc_zdet_param {
···
2124
2124
return wcd938x_mbhc_micb_adjust_voltage(component, micb_mv, MIC_BIAS_2);
2125
2125
}
2126
2126
2127
-
static inline void wcd938x_mbhc_get_result_params(struct wcd938x_priv *wcd938x,
2127
+
static void wcd938x_mbhc_get_result_params(struct snd_soc_component *component,
2128
2128
s16 *d1_a, u16 noff,
2129
2129
int32_t *zdet)
2130
2130
{
2131
+
struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
2131
2132
int i;
2132
2133
int val, val1;
2133
2134
s16 c1;
···
2155
2154
usleep_range(5000, 5050);
2156
2155
2157
2156
if (!c1 || !x1) {
2158
-
pr_err("%s: Impedance detect ramp error, c1=%d, x1=0x%x\n",
2159
-
__func__, c1, x1);
2157
+
dev_err(component->dev, "Impedance detect ramp error, c1=%d, x1=0x%x\n",
2158
+
c1, x1);
2160
2159
goto ramp_down;
2161
2160
}
2162
2161
d1 = d1_a[c1];
···
2166
2165
else if (x1 < minCode_param[noff])
2167
2166
*zdet = WCD938X_ZDET_FLOATING_IMPEDANCE;
2168
2167
2169
-
pr_err("%s: d1=%d, c1=%d, x1=0x%x, z_val=%d(milliOhm)\n",
2168
+
dev_dbg(component->dev, "%s: d1=%d, c1=%d, x1=0x%x, z_val=%d (milliohm)\n",
2170
2169
__func__, d1, c1, x1, *zdet);
2171
2170
ramp_down:
2172
2171
i = 0;
···
2211
2210
WCD938X_ANA_MBHC_ZDET, 0x80, 0x80);
2212
2211
dev_dbg(component->dev, "%s: ramp for HPH_L, noff = %d\n",
2213
2212
__func__, zdet_param->noff);
2214
-
wcd938x_mbhc_get_result_params(wcd938x, d1_a, zdet_param->noff, &zdet);
2213
+
wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2215
2214
regmap_update_bits(wcd938x->regmap,
2216
2215
WCD938X_ANA_MBHC_ZDET, 0x80, 0x00);
2217
2216
···
2225
2224
WCD938X_ANA_MBHC_ZDET, 0x40, 0x40);
2226
2225
dev_dbg(component->dev, "%s: ramp for HPH_R, noff = %d\n",
2227
2226
__func__, zdet_param->noff);
2228
-
wcd938x_mbhc_get_result_params(wcd938x, d1_a, zdet_param->noff, &zdet);
2227
+
wcd938x_mbhc_get_result_params(component, d1_a, zdet_param->noff, &zdet);
2229
2228
regmap_update_bits(wcd938x->regmap,
2230
2229
WCD938X_ANA_MBHC_ZDET, 0x40, 0x00);
2231
2230
2232
2231
*zr = zdet;
2233
2232
}
2234
2233
2235
-
static inline void wcd938x_wcd_mbhc_qfuse_cal(struct snd_soc_component *component,
2236
-
int32_t *z_val, int flag_l_r)
2234
+
static void wcd938x_wcd_mbhc_qfuse_cal(struct snd_soc_component *component,
2235
+
int32_t *z_val, int flag_l_r)
2237
2236
{
2238
2237
s16 q1;
2239
2238
int q1_cal;
···
2626
2625
WCD938X_IRQ_HPHR_OCP_INT);
2627
2626
2628
2627
wcd938x->wcd_mbhc = wcd_mbhc_init(component, &mbhc_cb, intr_ids, wcd_mbhc_fields, true);
2628
+
if (IS_ERR(wcd938x->wcd_mbhc))
2629
+
return PTR_ERR(wcd938x->wcd_mbhc);
2629
2630
2630
2631
snd_soc_add_component_controls(component, impedance_detect_controls,
2631
2632
ARRAY_SIZE(impedance_detect_controls));
···
2636
2633
2637
2634
return 0;
2638
2635
}
2636
+
2637
+
static void wcd938x_mbhc_deinit(struct snd_soc_component *component)
2638
+
{
2639
+
struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
2640
+
2641
+
wcd_mbhc_deinit(wcd938x->wcd_mbhc);
2642
+
}
2643
+
2639
2644
/* END MBHC */
2640
2645
2641
2646
static const struct snd_kcontrol_new wcd938x_snd_controls[] = {
···
2663
2652
wcd938x_get_swr_port, wcd938x_set_swr_port),
2664
2653
SOC_SINGLE_EXT("DSD_R Switch", WCD938X_DSD_R, 0, 1, 0,
2665
2654
wcd938x_get_swr_port, wcd938x_set_swr_port),
2666
-
SOC_SINGLE_TLV("HPHL Volume", WCD938X_HPH_L_EN, 0, 0x18, 0, line_gain),
2667
-
SOC_SINGLE_TLV("HPHR Volume", WCD938X_HPH_R_EN, 0, 0x18, 0, line_gain),
2655
+
SOC_SINGLE_TLV("HPHL Volume", WCD938X_HPH_L_EN, 0, 0x18, 1, line_gain),
2656
+
SOC_SINGLE_TLV("HPHR Volume", WCD938X_HPH_R_EN, 0, 0x18, 1, line_gain),
2668
2657
WCD938X_EAR_PA_GAIN_TLV("EAR_PA Volume", WCD938X_ANA_EAR_COMPANDER_CTL,
2669
2658
2, 0x10, 0, ear_pa_gain),
2670
2659
SOC_SINGLE_EXT("ADC1 Switch", WCD938X_ADC1, 1, 1, 0,
···
3091
3080
static int wcd938x_soc_codec_probe(struct snd_soc_component *component)
3092
3081
{
3093
3082
struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
3083
+
struct sdw_slave *tx_sdw_dev = wcd938x->tx_sdw_dev;
3094
3084
struct device *dev = component->dev;
3085
+
unsigned long time_left;
3095
3086
int ret, i;
3096
3087
3088
+
time_left = wait_for_completion_timeout(&tx_sdw_dev->initialization_complete,
3089
+
msecs_to_jiffies(2000));
3090
+
if (!time_left) {
3091
+
dev_err(dev, "soundwire device init timeout\n");
3092
+
return -ETIMEDOUT;
3093
+
}
3094
+
3097
3095
snd_soc_component_init_regmap(component, wcd938x->regmap);
3096
+
3097
+
ret = pm_runtime_resume_and_get(dev);
3098
+
if (ret < 0)
3099
+
return ret;
3098
3100
3099
3101
wcd938x->variant = snd_soc_component_read_field(component,
3100
3102
WCD938X_DIGITAL_EFUSE_REG_0,
3101
3103
WCD938X_ID_MASK);
3102
3104
3103
3105
wcd938x->clsh_info = wcd_clsh_ctrl_alloc(component, WCD938X);
3106
+
if (IS_ERR(wcd938x->clsh_info)) {
3107
+
pm_runtime_put(dev);
3108
+
return PTR_ERR(wcd938x->clsh_info);
3109
+
}
3104
3110
3105
3111
wcd938x_io_init(wcd938x);
3106
3112
/* Set all interrupts as edge triggered */
···
3125
3097
regmap_write(wcd938x->regmap,
3126
3098
(WCD938X_DIGITAL_INTR_LEVEL_0 + i), 0);
3127
3099
}
3100
+
3101
+
pm_runtime_put(dev);
3128
3102
3129
3103
wcd938x->hphr_pdm_wd_int = regmap_irq_get_virq(wcd938x->irq_chip,
3130
3104
WCD938X_IRQ_HPHR_PDM_WD_INT);
···
3139
3109
ret = request_threaded_irq(wcd938x->hphr_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3140
3110
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
3141
3111
"HPHR PDM WD INT", wcd938x);
3142
-
if (ret)
3112
+
if (ret) {
3143
3113
dev_err(dev, "Failed to request HPHR WD interrupt (%d)\n", ret);
3114
+
goto err_free_clsh_ctrl;
3115
+
}
3144
3116
3145
3117
ret = request_threaded_irq(wcd938x->hphl_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3146
3118
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
3147
3119
"HPHL PDM WD INT", wcd938x);
3148
-
if (ret)
3120
+
if (ret) {
3149
3121
dev_err(dev, "Failed to request HPHL WD interrupt (%d)\n", ret);
3122
+
goto err_free_hphr_pdm_wd_int;
3123
+
}
3150
3124
3151
3125
ret = request_threaded_irq(wcd938x->aux_pdm_wd_int, NULL, wcd938x_wd_handle_irq,
3152
3126
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
3153
3127
"AUX PDM WD INT", wcd938x);
3154
-
if (ret)
3128
+
if (ret) {
3155
3129
dev_err(dev, "Failed to request Aux WD interrupt (%d)\n", ret);
3130
+
goto err_free_hphl_pdm_wd_int;
3131
+
}
3156
3132
3157
3133
/* Disable watchdog interrupt for HPH and AUX */
3158
3134
disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
···
3173
3137
dev_err(component->dev,
3174
3138
"%s: Failed to add snd ctrls for variant: %d\n",
3175
3139
__func__, wcd938x->variant);
3176
-
goto err;
3140
+
goto err_free_aux_pdm_wd_int;
3177
3141
}
3178
3142
break;
3179
3143
case WCD9385:
···
3183
3147
dev_err(component->dev,
3184
3148
"%s: Failed to add snd ctrls for variant: %d\n",
3185
3149
__func__, wcd938x->variant);
3186
-
goto err;
3150
+
goto err_free_aux_pdm_wd_int;
3187
3151
}
3188
3152
break;
3189
3153
default:
···
3191
3155
}
3192
3156
3193
3157
ret = wcd938x_mbhc_init(component);
3194
-
if (ret)
3158
+
if (ret) {
3195
3159
dev_err(component->dev, "mbhc initialization failed\n");
3196
-
err:
3160
+
goto err_free_aux_pdm_wd_int;
3161
+
}
3162
+
3163
+
return 0;
3164
+
3165
+
err_free_aux_pdm_wd_int:
3166
+
free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3167
+
err_free_hphl_pdm_wd_int:
3168
+
free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3169
+
err_free_hphr_pdm_wd_int:
3170
+
free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3171
+
err_free_clsh_ctrl:
3172
+
wcd_clsh_ctrl_free(wcd938x->clsh_info);
3173
+
3197
3174
return ret;
3175
+
}
3176
+
3177
+
static void wcd938x_soc_codec_remove(struct snd_soc_component *component)
3178
+
{
3179
+
struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
3180
+
3181
+
wcd938x_mbhc_deinit(component);
3182
+
3183
+
free_irq(wcd938x->aux_pdm_wd_int, wcd938x);
3184
+
free_irq(wcd938x->hphl_pdm_wd_int, wcd938x);
3185
+
free_irq(wcd938x->hphr_pdm_wd_int, wcd938x);
3186
+
3187
+
wcd_clsh_ctrl_free(wcd938x->clsh_info);
3198
3188
}
3199
3189
3200
3190
static int wcd938x_codec_set_jack(struct snd_soc_component *comp,
···
3239
3177
static const struct snd_soc_component_driver soc_codec_dev_wcd938x = {
3240
3178
.name = "wcd938x_codec",
3241
3179
.probe = wcd938x_soc_codec_probe,
3180
+
.remove = wcd938x_soc_codec_remove,
3242
3181
.controls = wcd938x_snd_controls,
3243
3182
.num_controls = ARRAY_SIZE(wcd938x_snd_controls),
3244
3183
.dapm_widgets = wcd938x_dapm_widgets,
+1
-7
sound/soc/fsl/fsl_sai.c
+1
-7
sound/soc/fsl/fsl_sai.c
···
507
507
savediv / 2 - 1);
508
508
}
509
509
510
-
if (sai->soc_data->max_register >= FSL_SAI_MCTL) {
511
-
/* SAI is in master mode at this point, so enable MCLK */
512
-
regmap_update_bits(sai->regmap, FSL_SAI_MCTL,
513
-
FSL_SAI_MCTL_MCLK_EN, FSL_SAI_MCTL_MCLK_EN);
514
-
}
515
-
516
510
return 0;
517
511
}
518
512
···
713
719
u32 xcsr, count = 100;
714
720
715
721
regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx, ofs),
716
-
FSL_SAI_CSR_TERE, 0);
722
+
FSL_SAI_CSR_TERE | FSL_SAI_CSR_BCE, 0);
717
723
718
724
/* TERE will remain set till the end of current frame */
719
725
do {
+1
sound/soc/fsl/fsl_sai.h
+1
sound/soc/fsl/fsl_sai.h
+1
-1
sound/soc/qcom/qdsp6/q6afe-dai.c
+1
-1
sound/soc/qcom/qdsp6/q6afe-dai.c
···
476
476
477
477
static const struct snd_soc_dapm_route q6afe_dapm_routes[] = {
478
478
{"HDMI Playback", NULL, "HDMI_RX"},
479
-
{"Display Port Playback", NULL, "DISPLAY_PORT_RX"},
479
+
{"DISPLAY_PORT_RX_0 Playback", NULL, "DISPLAY_PORT_RX"},
480
480
{"Slimbus Playback", NULL, "SLIMBUS_0_RX"},
481
481
{"Slimbus1 Playback", NULL, "SLIMBUS_1_RX"},
482
482
{"Slimbus2 Playback", NULL, "SLIMBUS_2_RX"},
+1
sound/soc/qcom/qdsp6/q6apm-dai.c
+1
sound/soc/qcom/qdsp6/q6apm-dai.c
+6
-1
sound/soc/qcom/qdsp6/q6apm.c
+6
-1
sound/soc/qcom/qdsp6/q6apm.c
···
511
511
512
512
switch (hdr->opcode) {
513
513
case DATA_CMD_RSP_WR_SH_MEM_EP_DATA_BUFFER_DONE_V2:
514
+
if (!graph->ar_graph)
515
+
break;
514
516
client_event = APM_CLIENT_EVENT_DATA_WRITE_DONE;
515
517
mutex_lock(&graph->lock);
516
518
token = hdr->token & APM_WRITE_TOKEN_MASK;
···
546
544
wake_up(&graph->cmd_wait);
547
545
break;
548
546
case DATA_CMD_RSP_RD_SH_MEM_EP_DATA_BUFFER_V2:
547
+
if (!graph->ar_graph)
548
+
break;
549
549
client_event = APM_CLIENT_EVENT_DATA_READ_DONE;
550
550
mutex_lock(&graph->lock);
551
551
rd_done = data->payload;
···
653
649
{
654
650
struct audioreach_graph *ar_graph = graph->ar_graph;
655
651
656
-
gpr_free_port(graph->port);
652
+
graph->ar_graph = NULL;
657
653
kref_put(&ar_graph->refcount, q6apm_put_audioreach_graph);
654
+
gpr_free_port(graph->port);
658
655
kfree(graph);
659
656
660
657
return 0;
+2
-2
sound/soc/qcom/qdsp6/topology.c
+2
-2
sound/soc/qcom/qdsp6/topology.c
···
1277
1277
1278
1278
ret = snd_soc_tplg_component_load(component, &audioreach_tplg_ops, fw);
1279
1279
if (ret < 0) {
1280
-
dev_err(dev, "tplg component load failed%d\n", ret);
1281
-
ret = -EINVAL;
1280
+
if (ret != -EPROBE_DEFER)
1281
+
dev_err(dev, "tplg component load failed: %d\n", ret);
1282
1282
}
1283
1283
1284
1284
release_firmware(fw);
+4
-2
sound/soc/soc-core.c
+4
-2
sound/soc/soc-core.c
···
1988
1988
/* probe all components used by DAI links on this card */
1989
1989
ret = soc_probe_link_components(card);
1990
1990
if (ret < 0) {
1991
-
dev_err(card->dev,
1992
-
"ASoC: failed to instantiate card %d\n", ret);
1991
+
if (ret != -EPROBE_DEFER) {
1992
+
dev_err(card->dev,
1993
+
"ASoC: failed to instantiate card %d\n", ret);
1994
+
}
1993
1995
goto probe_end;
1994
1996
}
1995
1997
+7
-3
sound/soc/soc-topology.c
+7
-3
sound/soc/soc-topology.c
···
1732
1732
1733
1733
ret = snd_soc_add_pcm_runtimes(tplg->comp->card, link, 1);
1734
1734
if (ret < 0) {
1735
-
dev_err(tplg->dev, "ASoC: adding FE link failed\n");
1735
+
if (ret != -EPROBE_DEFER)
1736
+
dev_err(tplg->dev, "ASoC: adding FE link failed\n");
1736
1737
goto err;
1737
1738
}
1738
1739
···
2493
2492
/* load the header object */
2494
2493
ret = soc_tplg_load_header(tplg, hdr);
2495
2494
if (ret < 0) {
2496
-
dev_err(tplg->dev,
2497
-
"ASoC: topology: could not load header: %d\n", ret);
2495
+
if (ret != -EPROBE_DEFER) {
2496
+
dev_err(tplg->dev,
2497
+
"ASoC: topology: could not load header: %d\n",
2498
+
ret);
2499
+
}
2498
2500
return ret;
2499
2501
}
2500
2502
+7
-3
sound/soc/sof/amd/acp.c
+7
-3
sound/soc/sof/amd/acp.c
···
217
217
unsigned int image_length)
218
218
{
219
219
struct snd_sof_dev *sdev = adata->dev;
220
+
const struct sof_amd_acp_desc *desc = get_chip_info(sdev->pdata);
220
221
unsigned int tx_count, fw_qualifier, val;
221
222
int ret;
222
223
···
252
251
return ret;
253
252
}
254
253
255
-
ret = psp_send_cmd(adata, MBOX_ACP_SHA_DMA_COMMAND);
256
-
if (ret)
257
-
return ret;
254
+
/* psp_send_cmd only required for renoir platform (rev - 3) */
255
+
if (desc->rev == 3) {
256
+
ret = psp_send_cmd(adata, MBOX_ACP_SHA_DMA_COMMAND);
257
+
if (ret)
258
+
return ret;
259
+
}
258
260
259
261
ret = snd_sof_dsp_read_poll_timeout(sdev, ACP_DSP_BAR, ACP_SHA_DSP_FW_QUALIFIER,
260
262
fw_qualifier, fw_qualifier & DSP_FW_RUN_ENABLE,
+4
-5
sound/soc/sof/ipc3-dtrace.c
+4
-5
sound/soc/sof/ipc3-dtrace.c
···
186
186
struct snd_sof_dfsentry *dfse = file->private_data;
187
187
struct sof_ipc_trace_filter_elem *elems = NULL;
188
188
struct snd_sof_dev *sdev = dfse->sdev;
189
-
loff_t pos = 0;
190
189
int num_elems;
191
190
char *string;
192
191
int ret;
···
200
201
if (!string)
201
202
return -ENOMEM;
202
203
203
-
/* assert null termination */
204
-
string[count] = 0;
205
-
ret = simple_write_to_buffer(string, count, &pos, from, count);
206
-
if (ret < 0)
204
+
if (copy_from_user(string, from, count)) {
205
+
ret = -EFAULT;
207
206
goto error;
207
+
}
208
+
string[count] = '\0';
208
209
209
210
ret = trace_filter_parse(sdev, string, &num_elems, &elems);
210
211
if (ret < 0)
+22
-12
sound/soc/tegra/tegra210_adx.c
+22
-12
sound/soc/tegra/tegra210_adx.c
···
2
2
//
3
3
// tegra210_adx.c - Tegra210 ADX driver
4
4
//
5
-
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
5
+
// Copyright (c) 2021-2023 NVIDIA CORPORATION. All rights reserved.
6
6
7
7
#include <linux/clk.h>
8
8
#include <linux/device.h>
···
175
175
mc = (struct soc_mixer_control *)kcontrol->private_value;
176
176
enabled = adx->byte_mask[mc->reg / 32] & (1 << (mc->reg % 32));
177
177
178
+
/*
179
+
* TODO: Simplify this logic to just return from bytes_map[]
180
+
*
181
+
* Presently below is required since bytes_map[] is
182
+
* tightly packed and cannot store the control value of 256.
183
+
* Byte mask state is used to know if 256 needs to be returned.
184
+
* Note that for control value of 256, the put() call stores 0
185
+
* in the bytes_map[] and disables the corresponding bit in
186
+
* byte_mask[].
187
+
*/
178
188
if (enabled)
179
189
ucontrol->value.integer.value[0] = bytes_map[mc->reg];
180
190
else
181
-
ucontrol->value.integer.value[0] = 0;
191
+
ucontrol->value.integer.value[0] = 256;
182
192
183
193
return 0;
184
194
}
···
202
192
int value = ucontrol->value.integer.value[0];
203
193
struct soc_mixer_control *mc =
204
194
(struct soc_mixer_control *)kcontrol->private_value;
195
+
unsigned int mask_val = adx->byte_mask[mc->reg / 32];
205
196
206
-
if (value == bytes_map[mc->reg])
197
+
if (value >= 0 && value <= 255)
198
+
mask_val |= (1 << (mc->reg % 32));
199
+
else
200
+
mask_val &= ~(1 << (mc->reg % 32));
201
+
202
+
if (mask_val == adx->byte_mask[mc->reg / 32])
207
203
return 0;
208
204
209
-
if (value >= 0 && value <= 255) {
210
-
/* update byte map and enable slot */
211
-
bytes_map[mc->reg] = value;
212
-
adx->byte_mask[mc->reg / 32] |= (1 << (mc->reg % 32));
213
-
} else {
214
-
/* reset byte map and disable slot */
215
-
bytes_map[mc->reg] = 0;
216
-
adx->byte_mask[mc->reg / 32] &= ~(1 << (mc->reg % 32));
217
-
}
205
+
/* Update byte map and slot */
206
+
bytes_map[mc->reg] = value % 256;
207
+
adx->byte_mask[mc->reg / 32] = mask_val;
218
208
219
209
return 1;
220
210
}
+22
-18
sound/soc/tegra/tegra210_amx.c
+22
-18
sound/soc/tegra/tegra210_amx.c
···
2
2
//
3
3
// tegra210_amx.c - Tegra210 AMX driver
4
4
//
5
-
// Copyright (c) 2021 NVIDIA CORPORATION. All rights reserved.
5
+
// Copyright (c) 2021-2023 NVIDIA CORPORATION. All rights reserved.
6
6
7
7
#include <linux/clk.h>
8
8
#include <linux/device.h>
···
203
203
else
204
204
enabled = amx->byte_mask[0] & (1 << reg);
205
205
206
+
/*
207
+
* TODO: Simplify this logic to just return from bytes_map[]
208
+
*
209
+
* Presently below is required since bytes_map[] is
210
+
* tightly packed and cannot store the control value of 256.
211
+
* Byte mask state is used to know if 256 needs to be returned.
212
+
* Note that for control value of 256, the put() call stores 0
213
+
* in the bytes_map[] and disables the corresponding bit in
214
+
* byte_mask[].
215
+
*/
206
216
if (enabled)
207
217
ucontrol->value.integer.value[0] = bytes_map[reg];
208
218
else
209
-
ucontrol->value.integer.value[0] = 0;
219
+
ucontrol->value.integer.value[0] = 256;
210
220
211
221
return 0;
212
222
}
···
231
221
unsigned char *bytes_map = (unsigned char *)&amx->map;
232
222
int reg = mc->reg;
233
223
int value = ucontrol->value.integer.value[0];
224
+
unsigned int mask_val = amx->byte_mask[reg / 32];
234
225
235
-
if (value == bytes_map[reg])
226
+
if (value >= 0 && value <= 255)
227
+
mask_val |= (1 << (reg % 32));
228
+
else
229
+
mask_val &= ~(1 << (reg % 32));
230
+
231
+
if (mask_val == amx->byte_mask[reg / 32])
236
232
return 0;
237
233
238
-
if (value >= 0 && value <= 255) {
239
-
/* Update byte map and enable slot */
240
-
bytes_map[reg] = value;
241
-
if (reg > 31)
242
-
amx->byte_mask[1] |= (1 << (reg - 32));
243
-
else
244
-
amx->byte_mask[0] |= (1 << reg);
245
-
} else {
246
-
/* Reset byte map and disable slot */
247
-
bytes_map[reg] = 0;
248
-
if (reg > 31)
249
-
amx->byte_mask[1] &= ~(1 << (reg - 32));
250
-
else
251
-
amx->byte_mask[0] &= ~(1 << reg);
252
-
}
234
+
/* Update byte map and slot */
235
+
bytes_map[reg] = value % 256;
236
+
amx->byte_mask[reg / 32] = mask_val;
253
237
254
238
return 1;
255
239
}
+1
-3
tools/testing/selftests/alsa/test-pcmtest-driver.c
+1
-3
tools/testing/selftests/alsa/test-pcmtest-driver.c