Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-5.17-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"A collection of small patches, mostly for old and new regressions and
device-specific fixes.
- Regression fixes regarding ALSA core SG-buffer helpers
- Regression fix for Realtek HD-audio mutex deadlock
- Regression fix for USB-audio PM resume error
- More coverage of ASoC core control API notification fixes
- Old regression fixes for HD-audio probe mask
- Fixes for ASoC Realtek codec work handling
- Other device-specific quirks / fixes"
* tag 'sound-5.17-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (24 commits)
ASoC: intel: skylake: Set max DMA segment size
ASoC: SOF: hda: Set max DMA segment size
ALSA: hda: Set max DMA segment size
ALSA: hda/realtek: Fix deadlock by COEF mutex
ALSA: usb-audio: Don't abort resume upon errors
ALSA: hda: Fix missing codec probe on Shenker Dock 15
ALSA: hda: Fix regression on forced probe mask option
ALSA: hda/realtek: Add quirk for Legion Y9000X 2019
ALSA: usb-audio: revert to IMPLICIT_FB_FIXED_DEV for M-Audio FastTrack Ultra
ASoC: wm_adsp: Correct control read size when parsing compressed buffer
ASoC: qcom: Actually clear DMA interrupt register for HDMI
ALSA: memalloc: invalidate SG pages before sync
ALSA: memalloc: Fix dma_need_sync() checks
MAINTAINERS: update cros_ec_codec maintainers
ASoC: rt5682: do not block workqueue if card is unbound
ASoC: rt5668: do not block workqueue if card is unbound
ASoC: rt5682s: do not block workqueue if card is unbound
ASoC: tas2770: Insert post reset delay
ASoC: Revert "ASoC: mediatek: Check for error clk pointer"
ASoC: amd: acp: Set gpio_spkr_en to None for max speaker amplifer in machine driver
...
+118
-75
+1
Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml
+1
Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml
+1
MAINTAINERS
+1
MAINTAINERS
+4
-11
drivers/soc/mediatek/mtk-scpsys.c
+4
-11
drivers/soc/mediatek/mtk-scpsys.c
···
411
411
return ret;
412
412
}
413
413
414
-
static int init_clks(struct platform_device *pdev, struct clk **clk)
414
+
static void init_clks(struct platform_device *pdev, struct clk **clk)
415
415
{
416
416
int i;
417
417
418
-
for (i = CLK_NONE + 1; i < CLK_MAX; i++) {
418
+
for (i = CLK_NONE + 1; i < CLK_MAX; i++)
419
419
clk[i] = devm_clk_get(&pdev->dev, clk_names[i]);
420
-
if (IS_ERR(clk[i]))
421
-
return PTR_ERR(clk[i]);
422
-
}
423
-
424
-
return 0;
425
420
}
426
421
427
422
static struct scp *init_scp(struct platform_device *pdev,
···
426
431
{
427
432
struct genpd_onecell_data *pd_data;
428
433
struct resource *res;
429
-
int i, j, ret;
434
+
int i, j;
430
435
struct scp *scp;
431
436
struct clk *clk[CLK_MAX];
432
437
···
481
486
482
487
pd_data->num_domains = num;
483
488
484
-
ret = init_clks(pdev, clk);
485
-
if (ret)
486
-
return ERR_PTR(ret);
489
+
init_clks(pdev, clk);
487
490
488
491
for (i = 0; i < num; i++) {
489
492
struct scp_domain *scpd = &scp->domains[i];
+10
-5
sound/core/memalloc.c
+10
-5
sound/core/memalloc.c
···
511
511
DEFAULT_GFP, 0);
512
512
if (!sgt)
513
513
return NULL;
514
-
dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->dev.dir);
514
+
dmab->dev.need_sync = dma_need_sync(dmab->dev.dev,
515
+
sg_dma_address(sgt->sgl));
515
516
p = dma_vmap_noncontiguous(dmab->dev.dev, size, sgt);
516
517
if (p)
517
518
dmab->private_data = sgt;
···
541
540
if (mode == SNDRV_DMA_SYNC_CPU) {
542
541
if (dmab->dev.dir == DMA_TO_DEVICE)
543
542
return;
543
+
invalidate_kernel_vmap_range(dmab->area, dmab->bytes);
544
544
dma_sync_sgtable_for_cpu(dmab->dev.dev, dmab->private_data,
545
545
dmab->dev.dir);
546
-
invalidate_kernel_vmap_range(dmab->area, dmab->bytes);
547
546
} else {
548
547
if (dmab->dev.dir == DMA_FROM_DEVICE)
549
548
return;
···
672
671
*/
673
672
static void *snd_dma_noncoherent_alloc(struct snd_dma_buffer *dmab, size_t size)
674
673
{
675
-
dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->dev.dir);
676
-
return dma_alloc_noncoherent(dmab->dev.dev, size, &dmab->addr,
677
-
dmab->dev.dir, DEFAULT_GFP);
674
+
void *p;
675
+
676
+
p = dma_alloc_noncoherent(dmab->dev.dev, size, &dmab->addr,
677
+
dmab->dev.dir, DEFAULT_GFP);
678
+
if (p)
679
+
dmab->dev.need_sync = dma_need_sync(dmab->dev.dev, dmab->addr);
680
+
return p;
678
681
}
679
682
680
683
static void snd_dma_noncoherent_free(struct snd_dma_buffer *dmab)
+4
-2
sound/pci/hda/hda_intel.c
+4
-2
sound/pci/hda/hda_intel.c
···
1615
1615
/* forced codec slots */
1616
1616
SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
1617
1617
SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
1618
+
SND_PCI_QUIRK(0x1558, 0x0351, "Schenker Dock 15", 0x105),
1618
1619
/* WinFast VP200 H (Teradici) user reported broken communication */
1619
1620
SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
1620
1621
{}
···
1799
1798
1800
1799
assign_position_fix(chip, check_position_fix(chip, position_fix[dev]));
1801
1800
1802
-
check_probe_mask(chip, dev);
1803
-
1804
1801
if (single_cmd < 0) /* allow fallback to single_cmd at errors */
1805
1802
chip->fallback_to_single_cmd = 1;
1806
1803
else /* explicitly set to single_cmd or not */
···
1823
1824
dev_dbg(chip->card->dev, "Enable delay in RIRB handling\n");
1824
1825
chip->bus.core.needs_damn_long_delay = 1;
1825
1826
}
1827
+
1828
+
check_probe_mask(chip, dev);
1826
1829
1827
1830
err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1828
1831
if (err < 0) {
···
1941
1940
dma_bits = 32;
1942
1941
if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(dma_bits)))
1943
1942
dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32));
1943
+
dma_set_max_seg_size(&pci->dev, UINT_MAX);
1944
1944
1945
1945
/* read number of streams from GCAP register instead of using
1946
1946
* hardcoded value
+25
-15
sound/pci/hda/patch_realtek.c
+25
-15
sound/pci/hda/patch_realtek.c
···
138
138
* COEF access helper functions
139
139
*/
140
140
141
+
static void coef_mutex_lock(struct hda_codec *codec)
142
+
{
143
+
struct alc_spec *spec = codec->spec;
144
+
145
+
snd_hda_power_up_pm(codec);
146
+
mutex_lock(&spec->coef_mutex);
147
+
}
148
+
149
+
static void coef_mutex_unlock(struct hda_codec *codec)
150
+
{
151
+
struct alc_spec *spec = codec->spec;
152
+
153
+
mutex_unlock(&spec->coef_mutex);
154
+
snd_hda_power_down_pm(codec);
155
+
}
156
+
141
157
static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
142
158
unsigned int coef_idx)
143
159
{
···
167
151
static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
168
152
unsigned int coef_idx)
169
153
{
170
-
struct alc_spec *spec = codec->spec;
171
154
unsigned int val;
172
155
173
-
mutex_lock(&spec->coef_mutex);
156
+
coef_mutex_lock(codec);
174
157
val = __alc_read_coefex_idx(codec, nid, coef_idx);
175
-
mutex_unlock(&spec->coef_mutex);
158
+
coef_mutex_unlock(codec);
176
159
return val;
177
160
}
178
161
···
188
173
static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
189
174
unsigned int coef_idx, unsigned int coef_val)
190
175
{
191
-
struct alc_spec *spec = codec->spec;
192
-
193
-
mutex_lock(&spec->coef_mutex);
176
+
coef_mutex_lock(codec);
194
177
__alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
195
-
mutex_unlock(&spec->coef_mutex);
178
+
coef_mutex_unlock(codec);
196
179
}
197
180
198
181
#define alc_write_coef_idx(codec, coef_idx, coef_val) \
···
211
198
unsigned int coef_idx, unsigned int mask,
212
199
unsigned int bits_set)
213
200
{
214
-
struct alc_spec *spec = codec->spec;
215
-
216
-
mutex_lock(&spec->coef_mutex);
201
+
coef_mutex_lock(codec);
217
202
__alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
218
-
mutex_unlock(&spec->coef_mutex);
203
+
coef_mutex_unlock(codec);
219
204
}
220
205
221
206
#define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
···
246
235
static void alc_process_coef_fw(struct hda_codec *codec,
247
236
const struct coef_fw *fw)
248
237
{
249
-
struct alc_spec *spec = codec->spec;
250
-
251
-
mutex_lock(&spec->coef_mutex);
238
+
coef_mutex_lock(codec);
252
239
for (; fw->nid; fw++) {
253
240
if (fw->mask == (unsigned short)-1)
254
241
__alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
···
254
245
__alc_update_coefex_idx(codec, fw->nid, fw->idx,
255
246
fw->mask, fw->val);
256
247
}
257
-
mutex_unlock(&spec->coef_mutex);
248
+
coef_mutex_unlock(codec);
258
249
}
259
250
260
251
/*
···
9179
9170
SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
9180
9171
SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
9181
9172
SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9173
+
SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
9182
9174
SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
9183
9175
SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
9184
9176
SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
-1
sound/soc/amd/acp/acp-mach.h
-1
sound/soc/amd/acp/acp-mach.h
+2
-2
sound/soc/amd/acp/acp-sof-mach.c
+2
-2
sound/soc/amd/acp/acp-sof-mach.c
···
37
37
.hs_codec_id = RT5682,
38
38
.amp_codec_id = MAX98360A,
39
39
.dmic_codec_id = DMIC,
40
-
.gpio_spkr_en = EN_SPKR_GPIO_NK,
40
+
.gpio_spkr_en = EN_SPKR_GPIO_NONE,
41
41
};
42
42
43
43
static struct acp_card_drvdata sof_rt5682s_max_data = {
···
47
47
.hs_codec_id = RT5682S,
48
48
.amp_codec_id = MAX98360A,
49
49
.dmic_codec_id = DMIC,
50
-
.gpio_spkr_en = EN_SPKR_GPIO_NK,
50
+
.gpio_spkr_en = EN_SPKR_GPIO_NONE,
51
51
};
52
52
53
53
static const struct snd_kcontrol_new acp_controls[] = {
+7
-5
sound/soc/codecs/rt5668.c
+7
-5
sound/soc/codecs/rt5668.c
···
1022
1022
container_of(work, struct rt5668_priv, jack_detect_work.work);
1023
1023
int val, btn_type;
1024
1024
1025
-
while (!rt5668->component)
1026
-
usleep_range(10000, 15000);
1027
-
1028
-
while (!rt5668->component->card->instantiated)
1029
-
usleep_range(10000, 15000);
1025
+
if (!rt5668->component || !rt5668->component->card ||
1026
+
!rt5668->component->card->instantiated) {
1027
+
/* card not yet ready, try later */
1028
+
mod_delayed_work(system_power_efficient_wq,
1029
+
&rt5668->jack_detect_work, msecs_to_jiffies(15));
1030
+
return;
1031
+
}
1030
1032
1031
1033
mutex_lock(&rt5668->calibrate_mutex);
1032
1034
+7
-5
sound/soc/codecs/rt5682.c
+7
-5
sound/soc/codecs/rt5682.c
···
1092
1092
struct snd_soc_dapm_context *dapm;
1093
1093
int val, btn_type;
1094
1094
1095
-
while (!rt5682->component)
1096
-
usleep_range(10000, 15000);
1097
-
1098
-
while (!rt5682->component->card->instantiated)
1099
-
usleep_range(10000, 15000);
1095
+
if (!rt5682->component || !rt5682->component->card ||
1096
+
!rt5682->component->card->instantiated) {
1097
+
/* card not yet ready, try later */
1098
+
mod_delayed_work(system_power_efficient_wq,
1099
+
&rt5682->jack_detect_work, msecs_to_jiffies(15));
1100
+
return;
1101
+
}
1100
1102
1101
1103
dapm = snd_soc_component_get_dapm(rt5682->component);
1102
1104
+7
-5
sound/soc/codecs/rt5682s.c
+7
-5
sound/soc/codecs/rt5682s.c
···
824
824
container_of(work, struct rt5682s_priv, jack_detect_work.work);
825
825
int val, btn_type;
826
826
827
-
while (!rt5682s->component)
828
-
usleep_range(10000, 15000);
829
-
830
-
while (!rt5682s->component->card->instantiated)
831
-
usleep_range(10000, 15000);
827
+
if (!rt5682s->component || !rt5682s->component->card ||
828
+
!rt5682s->component->card->instantiated) {
829
+
/* card not yet ready, try later */
830
+
mod_delayed_work(system_power_efficient_wq,
831
+
&rt5682s->jack_detect_work, msecs_to_jiffies(15));
832
+
return;
833
+
}
832
834
833
835
mutex_lock(&rt5682s->jdet_mutex);
834
836
mutex_lock(&rt5682s->calibrate_mutex);
+6
-1
sound/soc/codecs/tas2770.c
+6
-1
sound/soc/codecs/tas2770.c
···
38
38
gpiod_set_value_cansleep(tas2770->reset_gpio, 0);
39
39
msleep(20);
40
40
gpiod_set_value_cansleep(tas2770->reset_gpio, 1);
41
+
usleep_range(1000, 2000);
41
42
}
42
43
43
44
snd_soc_component_write(tas2770->component, TAS2770_SW_RST,
44
45
TAS2770_RST);
46
+
usleep_range(1000, 2000);
45
47
}
46
48
47
49
static int tas2770_set_bias_level(struct snd_soc_component *component,
···
112
110
113
111
if (tas2770->sdz_gpio) {
114
112
gpiod_set_value_cansleep(tas2770->sdz_gpio, 1);
113
+
usleep_range(1000, 2000);
115
114
} else {
116
115
ret = snd_soc_component_update_bits(component, TAS2770_PWR_CTRL,
117
116
TAS2770_PWR_CTRL_MASK,
···
513
510
514
511
tas2770->component = component;
515
512
516
-
if (tas2770->sdz_gpio)
513
+
if (tas2770->sdz_gpio) {
517
514
gpiod_set_value_cansleep(tas2770->sdz_gpio, 1);
515
+
usleep_range(1000, 2000);
516
+
}
518
517
519
518
tas2770_reset(tas2770);
520
519
+2
-1
sound/soc/codecs/wm_adsp.c
+2
-1
sound/soc/codecs/wm_adsp.c
···
1441
1441
int ret, i;
1442
1442
1443
1443
for (i = 0; i < 5; ++i) {
1444
-
ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1, sizeof(coeff_v1));
1444
+
ret = cs_dsp_coeff_read_ctrl(cs_ctl, 0, &coeff_v1,
1445
+
min(cs_ctl->len, sizeof(coeff_v1)));
1445
1446
if (ret < 0)
1446
1447
return ret;
1447
1448
+1
sound/soc/intel/skylake/skl.c
+1
sound/soc/intel/skylake/skl.c
···
952
952
/* allow 64bit DMA address if supported by H/W */
953
953
if (dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(64)))
954
954
dma_set_mask_and_coherent(bus->dev, DMA_BIT_MASK(32));
955
+
dma_set_max_seg_size(bus->dev, UINT_MAX);
955
956
956
957
/* initialize streams */
957
958
snd_hdac_ext_stream_init_all
+4
-4
sound/soc/qcom/lpass-platform.c
+4
-4
sound/soc/qcom/lpass-platform.c
···
524
524
return -EINVAL;
525
525
}
526
526
527
-
ret = regmap_update_bits(map, reg_irqclr, val_irqclr, val_irqclr);
527
+
ret = regmap_write_bits(map, reg_irqclr, val_irqclr, val_irqclr);
528
528
if (ret) {
529
529
dev_err(soc_runtime->dev, "error writing to irqclear reg: %d\n", ret);
530
530
return ret;
···
665
665
return -EINVAL;
666
666
}
667
667
if (interrupts & LPAIF_IRQ_PER(chan)) {
668
-
rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_PER(chan) | val));
668
+
rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_PER(chan) | val));
669
669
if (rv) {
670
670
dev_err(soc_runtime->dev,
671
671
"error writing to irqclear reg: %d\n", rv);
···
676
676
}
677
677
678
678
if (interrupts & LPAIF_IRQ_XRUN(chan)) {
679
-
rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_XRUN(chan) | val));
679
+
rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_XRUN(chan) | val));
680
680
if (rv) {
681
681
dev_err(soc_runtime->dev,
682
682
"error writing to irqclear reg: %d\n", rv);
···
688
688
}
689
689
690
690
if (interrupts & LPAIF_IRQ_ERR(chan)) {
691
-
rv = regmap_update_bits(map, reg, mask, (LPAIF_IRQ_ERR(chan) | val));
691
+
rv = regmap_write_bits(map, reg, mask, (LPAIF_IRQ_ERR(chan) | val));
692
692
if (rv) {
693
693
dev_err(soc_runtime->dev,
694
694
"error writing to irqclear reg: %d\n", rv);
+31
-10
sound/soc/soc-ops.c
+31
-10
sound/soc/soc-ops.c
···
308
308
unsigned int sign_bit = mc->sign_bit;
309
309
unsigned int mask = (1 << fls(max)) - 1;
310
310
unsigned int invert = mc->invert;
311
-
int err;
311
+
int err, ret;
312
312
bool type_2r = false;
313
313
unsigned int val2 = 0;
314
314
unsigned int val, val_mask;
···
350
350
err = snd_soc_component_update_bits(component, reg, val_mask, val);
351
351
if (err < 0)
352
352
return err;
353
+
ret = err;
353
354
354
-
if (type_2r)
355
+
if (type_2r) {
355
356
err = snd_soc_component_update_bits(component, reg2, val_mask,
356
-
val2);
357
+
val2);
358
+
/* Don't discard any error code or drop change flag */
359
+
if (ret == 0 || err < 0) {
360
+
ret = err;
361
+
}
362
+
}
357
363
358
-
return err;
364
+
return ret;
359
365
}
360
366
EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
361
367
···
427
421
int min = mc->min;
428
422
unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
429
423
int err = 0;
424
+
int ret;
430
425
unsigned int val, val_mask;
431
426
432
427
if (ucontrol->value.integer.value[0] < 0)
···
444
437
err = snd_soc_component_update_bits(component, reg, val_mask, val);
445
438
if (err < 0)
446
439
return err;
440
+
ret = err;
447
441
448
442
if (snd_soc_volsw_is_stereo(mc)) {
449
443
unsigned int val2;
···
455
447
456
448
err = snd_soc_component_update_bits(component, reg2, val_mask,
457
449
val2);
450
+
451
+
/* Don't discard any error code or drop change flag */
452
+
if (ret == 0 || err < 0) {
453
+
ret = err;
454
+
}
458
455
}
459
456
return err;
460
457
}
···
519
506
unsigned int mask = (1 << fls(max)) - 1;
520
507
unsigned int invert = mc->invert;
521
508
unsigned int val, val_mask;
522
-
int ret;
509
+
int err, ret;
523
510
524
511
if (invert)
525
512
val = (max - ucontrol->value.integer.value[0]) & mask;
···
528
515
val_mask = mask << shift;
529
516
val = val << shift;
530
517
531
-
ret = snd_soc_component_update_bits(component, reg, val_mask, val);
532
-
if (ret < 0)
533
-
return ret;
518
+
err = snd_soc_component_update_bits(component, reg, val_mask, val);
519
+
if (err < 0)
520
+
return err;
521
+
ret = err;
534
522
535
523
if (snd_soc_volsw_is_stereo(mc)) {
536
524
if (invert)
···
541
527
val_mask = mask << shift;
542
528
val = val << shift;
543
529
544
-
ret = snd_soc_component_update_bits(component, rreg, val_mask,
530
+
err = snd_soc_component_update_bits(component, rreg, val_mask,
545
531
val);
532
+
/* Don't discard any error code or drop change flag */
533
+
if (ret == 0 || err < 0) {
534
+
ret = err;
535
+
}
546
536
}
547
537
548
538
return ret;
···
895
877
unsigned long mask = (1UL<<mc->nbits)-1;
896
878
long max = mc->max;
897
879
long val = ucontrol->value.integer.value[0];
880
+
int ret = 0;
898
881
unsigned int i;
899
882
900
883
if (val < mc->min || val > mc->max)
···
910
891
regmask, regval);
911
892
if (err < 0)
912
893
return err;
894
+
if (err > 0)
895
+
ret = err;
913
896
}
914
897
915
-
return 0;
898
+
return ret;
916
899
}
917
900
EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
918
901
+1
sound/soc/sof/intel/hda.c
+1
sound/soc/sof/intel/hda.c
+2
-2
sound/usb/implicit.c
+2
-2
sound/usb/implicit.c
···
47
47
static const struct snd_usb_implicit_fb_match playback_implicit_fb_quirks[] = {
48
48
/* Generic matching */
49
49
IMPLICIT_FB_GENERIC_DEV(0x0499, 0x1509), /* Steinberg UR22 */
50
-
IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2080), /* M-Audio FastTrack Ultra */
51
-
IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2081), /* M-Audio FastTrack Ultra */
52
50
IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2030), /* M-Audio Fast Track C400 */
53
51
IMPLICIT_FB_GENERIC_DEV(0x0763, 0x2031), /* M-Audio Fast Track C600 */
54
52
55
53
/* Fixed EP */
56
54
/* FIXME: check the availability of generic matching */
55
+
IMPLICIT_FB_FIXED_DEV(0x0763, 0x2080, 0x81, 2), /* M-Audio FastTrack Ultra */
56
+
IMPLICIT_FB_FIXED_DEV(0x0763, 0x2081, 0x81, 2), /* M-Audio FastTrack Ultra */
57
57
IMPLICIT_FB_FIXED_DEV(0x2466, 0x8010, 0x81, 2), /* Fractal Audio Axe-Fx III */
58
58
IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0001, 0x81, 2), /* Solid State Logic SSL2 */
59
59
IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0002, 0x81, 2), /* Solid State Logic SSL2+ */
+3
-6
sound/usb/mixer.c
+3
-6
sound/usb/mixer.c
···
3678
3678
err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
3679
3679
cval->cache_val[idx]);
3680
3680
if (err < 0)
3681
-
return err;
3681
+
break;
3682
3682
}
3683
3683
idx++;
3684
3684
}
3685
3685
} else {
3686
3686
/* master */
3687
-
if (cval->cached) {
3688
-
err = snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
3689
-
if (err < 0)
3690
-
return err;
3691
-
}
3687
+
if (cval->cached)
3688
+
snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
3692
3689
}
3693
3690
3694
3691
return 0;