Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'sound-6.2-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"Hopefully the last one for 6.2, a collection of the fixes that have
been gathered since the last pull.
All changes are small and trivial device-specific fixes"
* tag 'sound-6.2-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: hda/realtek: Add Positivo N14KP6-TG
ASoC: topology: Return -ENOMEM on memory allocation failure
ALSA: emux: Avoid potential array out-of-bound in snd_emux_xg_control()
ASoC: fsl_sai: fix getting version from VERID
ALSA: hda/realtek: fix mute/micmute LEDs don't work for a HP platform.
ALSA: hda/realtek: Add quirk for ASUS UM3402 using CS35L41
ASoC: codecs: es8326: Fix DTS properties reading
ASoC: tas5805m: add missing page switch.
ASoC: tas5805m: rework to avoid scheduling while atomic.
ALSA: hda/realtek: Enable mute/micmute LEDs on HP Elitebook, 645 G9
ASoC: SOF: amd: Fix for handling spurious interrupts from DSP
ALSA: hda/realtek: Fix the speaker output on Samsung Galaxy Book2 Pro 360
ALSA: pci: lx6464es: fix a debug loop
ASoC: rt715-sdca: fix clock stop prepare timeout issue
+136
-75
+9
sound/pci/hda/patch_realtek.c
+9
sound/pci/hda/patch_realtek.c
···
9423
9423
SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9424
9424
SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9425
9425
SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9426
+
SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9426
9427
SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9427
9428
SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9428
9429
SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
···
9434
9433
SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9435
9434
SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9436
9435
SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9436
+
SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9437
+
SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9438
+
SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9439
+
SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9440
+
SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9437
9441
SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9438
9442
SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
9439
9443
SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
···
9486
9480
SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
9487
9481
SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402", ALC245_FIXUP_CS35L41_SPI_2),
9488
9482
SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
9483
+
SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
9489
9484
SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
9490
9485
SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
9491
9486
SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
···
9530
9523
SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
9531
9524
SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
9532
9525
SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
9526
+
SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
9533
9527
SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
9534
9528
SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
9535
9529
SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
···
9709
9701
SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
9710
9702
SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
9711
9703
SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
9704
+
SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
9712
9705
SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
9713
9706
SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
9714
9707
SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
+5
-6
sound/pci/lx6464es/lx_core.c
+5
-6
sound/pci/lx6464es/lx_core.c
···
493
493
dev_dbg(chip->card->dev,
494
494
"CMD_08_ASK_BUFFERS: needed %d, freed %d\n",
495
495
*r_needed, *r_freed);
496
-
for (i = 0; i < MAX_STREAM_BUFFER; ++i) {
497
-
for (i = 0; i != chip->rmh.stat_len; ++i)
498
-
dev_dbg(chip->card->dev,
499
-
" stat[%d]: %x, %x\n", i,
500
-
chip->rmh.stat[i],
501
-
chip->rmh.stat[i] & MASK_DATA_SIZE);
496
+
for (i = 0; i < MAX_STREAM_BUFFER && i < chip->rmh.stat_len;
497
+
++i) {
498
+
dev_dbg(chip->card->dev, " stat[%d]: %x, %x\n", i,
499
+
chip->rmh.stat[i],
500
+
chip->rmh.stat[i] & MASK_DATA_SIZE);
502
501
}
503
502
}
504
503
+4
-2
sound/soc/codecs/es8326.c
+4
-2
sound/soc/codecs/es8326.c
···
729
729
}
730
730
dev_dbg(component->dev, "jack-pol %x", es8326->jack_pol);
731
731
732
-
ret = device_property_read_u8(component->dev, "everest,interrupt-src", &es8326->jack_pol);
732
+
ret = device_property_read_u8(component->dev, "everest,interrupt-src",
733
+
&es8326->interrupt_src);
733
734
if (ret != 0) {
734
735
dev_dbg(component->dev, "interrupt-src return %d", ret);
735
736
es8326->interrupt_src = ES8326_HP_DET_SRC_PIN9;
736
737
}
737
738
dev_dbg(component->dev, "interrupt-src %x", es8326->interrupt_src);
738
739
739
-
ret = device_property_read_u8(component->dev, "everest,interrupt-clk", &es8326->jack_pol);
740
+
ret = device_property_read_u8(component->dev, "everest,interrupt-clk",
741
+
&es8326->interrupt_clk);
740
742
if (ret != 0) {
741
743
dev_dbg(component->dev, "interrupt-clk return %d", ret);
742
744
es8326->interrupt_clk = 0x45;
+1
-1
sound/soc/codecs/rt715-sdca-sdw.c
+1
-1
sound/soc/codecs/rt715-sdca-sdw.c
+92
-43
sound/soc/codecs/tas5805m.c
+92
-43
sound/soc/codecs/tas5805m.c
···
154
154
#define TAS5805M_VOLUME_MIN 0
155
155
156
156
struct tas5805m_priv {
157
+
struct i2c_client *i2c;
157
158
struct regulator *pvdd;
158
159
struct gpio_desc *gpio_pdn_n;
159
160
···
166
165
int vol[2];
167
166
bool is_powered;
168
167
bool is_muted;
168
+
169
+
struct work_struct work;
170
+
struct mutex lock;
169
171
};
170
172
171
173
static void set_dsp_scale(struct regmap *rm, int offset, int vol)
···
185
181
regmap_bulk_write(rm, offset, v, ARRAY_SIZE(v));
186
182
}
187
183
188
-
static void tas5805m_refresh(struct snd_soc_component *component)
184
+
static void tas5805m_refresh(struct tas5805m_priv *tas5805m)
189
185
{
190
-
struct tas5805m_priv *tas5805m =
191
-
snd_soc_component_get_drvdata(component);
192
186
struct regmap *rm = tas5805m->regmap;
193
187
194
-
dev_dbg(component->dev, "refresh: is_muted=%d, vol=%d/%d\n",
188
+
dev_dbg(&tas5805m->i2c->dev, "refresh: is_muted=%d, vol=%d/%d\n",
195
189
tas5805m->is_muted, tas5805m->vol[0], tas5805m->vol[1]);
196
190
197
191
regmap_write(rm, REG_PAGE, 0x00);
···
202
200
*/
203
201
set_dsp_scale(rm, 0x24, tas5805m->vol[0]);
204
202
set_dsp_scale(rm, 0x28, tas5805m->vol[1]);
203
+
204
+
regmap_write(rm, REG_PAGE, 0x00);
205
+
regmap_write(rm, REG_BOOK, 0x00);
205
206
206
207
/* Set/clear digital soft-mute */
207
208
regmap_write(rm, REG_DEVICE_CTRL_2,
···
231
226
struct tas5805m_priv *tas5805m =
232
227
snd_soc_component_get_drvdata(component);
233
228
229
+
mutex_lock(&tas5805m->lock);
234
230
ucontrol->value.integer.value[0] = tas5805m->vol[0];
235
231
ucontrol->value.integer.value[1] = tas5805m->vol[1];
232
+
mutex_unlock(&tas5805m->lock);
233
+
236
234
return 0;
237
235
}
238
236
···
251
243
snd_soc_kcontrol_component(kcontrol);
252
244
struct tas5805m_priv *tas5805m =
253
245
snd_soc_component_get_drvdata(component);
246
+
int ret = 0;
254
247
255
248
if (!(volume_is_valid(ucontrol->value.integer.value[0]) &&
256
249
volume_is_valid(ucontrol->value.integer.value[1])))
257
250
return -EINVAL;
258
251
252
+
mutex_lock(&tas5805m->lock);
259
253
if (tas5805m->vol[0] != ucontrol->value.integer.value[0] ||
260
254
tas5805m->vol[1] != ucontrol->value.integer.value[1]) {
261
255
tas5805m->vol[0] = ucontrol->value.integer.value[0];
···
266
256
tas5805m->vol[0], tas5805m->vol[1],
267
257
tas5805m->is_powered);
268
258
if (tas5805m->is_powered)
269
-
tas5805m_refresh(component);
270
-
return 1;
259
+
tas5805m_refresh(tas5805m);
260
+
ret = 1;
271
261
}
262
+
mutex_unlock(&tas5805m->lock);
272
263
273
-
return 0;
264
+
return ret;
274
265
}
275
266
276
267
static const struct snd_kcontrol_new tas5805m_snd_controls[] = {
···
305
294
struct snd_soc_component *component = dai->component;
306
295
struct tas5805m_priv *tas5805m =
307
296
snd_soc_component_get_drvdata(component);
308
-
struct regmap *rm = tas5805m->regmap;
309
-
unsigned int chan, global1, global2;
310
297
311
298
switch (cmd) {
312
299
case SNDRV_PCM_TRIGGER_START:
313
300
case SNDRV_PCM_TRIGGER_RESUME:
314
301
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
315
-
dev_dbg(component->dev, "DSP startup\n");
316
-
317
-
/* We mustn't issue any I2C transactions until the I2S
318
-
* clock is stable. Furthermore, we must allow a 5ms
319
-
* delay after the first set of register writes to
320
-
* allow the DSP to boot before configuring it.
321
-
*/
322
-
usleep_range(5000, 10000);
323
-
send_cfg(rm, dsp_cfg_preboot,
324
-
ARRAY_SIZE(dsp_cfg_preboot));
325
-
usleep_range(5000, 15000);
326
-
send_cfg(rm, tas5805m->dsp_cfg_data,
327
-
tas5805m->dsp_cfg_len);
328
-
329
-
tas5805m->is_powered = true;
330
-
tas5805m_refresh(component);
302
+
dev_dbg(component->dev, "clock start\n");
303
+
schedule_work(&tas5805m->work);
331
304
break;
332
305
333
306
case SNDRV_PCM_TRIGGER_STOP:
334
307
case SNDRV_PCM_TRIGGER_SUSPEND:
335
308
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
336
-
dev_dbg(component->dev, "DSP shutdown\n");
337
-
338
-
tas5805m->is_powered = false;
339
-
340
-
regmap_write(rm, REG_PAGE, 0x00);
341
-
regmap_write(rm, REG_BOOK, 0x00);
342
-
343
-
regmap_read(rm, REG_CHAN_FAULT, &chan);
344
-
regmap_read(rm, REG_GLOBAL_FAULT1, &global1);
345
-
regmap_read(rm, REG_GLOBAL_FAULT2, &global2);
346
-
347
-
dev_dbg(component->dev,
348
-
"fault regs: CHAN=%02x, GLOBAL1=%02x, GLOBAL2=%02x\n",
349
-
chan, global1, global2);
350
-
351
-
regmap_write(rm, REG_DEVICE_CTRL_2, DCTRL2_MODE_HIZ);
352
309
break;
353
310
354
311
default:
355
312
return -EINVAL;
313
+
}
314
+
315
+
return 0;
316
+
}
317
+
318
+
static void do_work(struct work_struct *work)
319
+
{
320
+
struct tas5805m_priv *tas5805m =
321
+
container_of(work, struct tas5805m_priv, work);
322
+
struct regmap *rm = tas5805m->regmap;
323
+
324
+
dev_dbg(&tas5805m->i2c->dev, "DSP startup\n");
325
+
326
+
mutex_lock(&tas5805m->lock);
327
+
/* We mustn't issue any I2C transactions until the I2S
328
+
* clock is stable. Furthermore, we must allow a 5ms
329
+
* delay after the first set of register writes to
330
+
* allow the DSP to boot before configuring it.
331
+
*/
332
+
usleep_range(5000, 10000);
333
+
send_cfg(rm, dsp_cfg_preboot, ARRAY_SIZE(dsp_cfg_preboot));
334
+
usleep_range(5000, 15000);
335
+
send_cfg(rm, tas5805m->dsp_cfg_data, tas5805m->dsp_cfg_len);
336
+
337
+
tas5805m->is_powered = true;
338
+
tas5805m_refresh(tas5805m);
339
+
mutex_unlock(&tas5805m->lock);
340
+
}
341
+
342
+
static int tas5805m_dac_event(struct snd_soc_dapm_widget *w,
343
+
struct snd_kcontrol *kcontrol, int event)
344
+
{
345
+
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
346
+
struct tas5805m_priv *tas5805m =
347
+
snd_soc_component_get_drvdata(component);
348
+
struct regmap *rm = tas5805m->regmap;
349
+
350
+
if (event & SND_SOC_DAPM_PRE_PMD) {
351
+
unsigned int chan, global1, global2;
352
+
353
+
dev_dbg(component->dev, "DSP shutdown\n");
354
+
cancel_work_sync(&tas5805m->work);
355
+
356
+
mutex_lock(&tas5805m->lock);
357
+
if (tas5805m->is_powered) {
358
+
tas5805m->is_powered = false;
359
+
360
+
regmap_write(rm, REG_PAGE, 0x00);
361
+
regmap_write(rm, REG_BOOK, 0x00);
362
+
363
+
regmap_read(rm, REG_CHAN_FAULT, &chan);
364
+
regmap_read(rm, REG_GLOBAL_FAULT1, &global1);
365
+
regmap_read(rm, REG_GLOBAL_FAULT2, &global2);
366
+
367
+
dev_dbg(component->dev, "fault regs: CHAN=%02x, "
368
+
"GLOBAL1=%02x, GLOBAL2=%02x\n",
369
+
chan, global1, global2);
370
+
371
+
regmap_write(rm, REG_DEVICE_CTRL_2, DCTRL2_MODE_HIZ);
372
+
}
373
+
mutex_unlock(&tas5805m->lock);
356
374
}
357
375
358
376
return 0;
···
394
354
395
355
static const struct snd_soc_dapm_widget tas5805m_dapm_widgets[] = {
396
356
SND_SOC_DAPM_AIF_IN("DAC IN", "Playback", 0, SND_SOC_NOPM, 0, 0),
397
-
SND_SOC_DAPM_DAC("DAC", NULL, SND_SOC_NOPM, 0, 0),
357
+
SND_SOC_DAPM_DAC_E("DAC", NULL, SND_SOC_NOPM, 0, 0,
358
+
tas5805m_dac_event, SND_SOC_DAPM_PRE_PMD),
398
359
SND_SOC_DAPM_OUTPUT("OUT")
399
360
};
400
361
···
416
375
struct tas5805m_priv *tas5805m =
417
376
snd_soc_component_get_drvdata(component);
418
377
378
+
mutex_lock(&tas5805m->lock);
419
379
dev_dbg(component->dev, "set mute=%d (is_powered=%d)\n",
420
380
mute, tas5805m->is_powered);
381
+
421
382
tas5805m->is_muted = mute;
422
383
if (tas5805m->is_powered)
423
-
tas5805m_refresh(component);
384
+
tas5805m_refresh(tas5805m);
385
+
mutex_unlock(&tas5805m->lock);
424
386
425
387
return 0;
426
388
}
···
478
434
if (!tas5805m)
479
435
return -ENOMEM;
480
436
437
+
tas5805m->i2c = i2c;
481
438
tas5805m->pvdd = devm_regulator_get(dev, "pvdd");
482
439
if (IS_ERR(tas5805m->pvdd)) {
483
440
dev_err(dev, "failed to get pvdd supply: %ld\n",
···
552
507
gpiod_set_value(tas5805m->gpio_pdn_n, 1);
553
508
usleep_range(10000, 15000);
554
509
510
+
INIT_WORK(&tas5805m->work, do_work);
511
+
mutex_init(&tas5805m->lock);
512
+
555
513
/* Don't register through devm. We need to be able to unregister
556
514
* the component prior to deasserting PDN#
557
515
*/
···
575
527
struct device *dev = &i2c->dev;
576
528
struct tas5805m_priv *tas5805m = dev_get_drvdata(dev);
577
529
530
+
cancel_work_sync(&tas5805m->work);
578
531
snd_soc_unregister_component(dev);
579
532
gpiod_set_value(tas5805m->gpio_pdn_n, 0);
580
533
usleep_range(10000, 15000);
+1
sound/soc/fsl/fsl_sai.c
+1
sound/soc/fsl/fsl_sai.c
···
1141
1141
1142
1142
sai->verid.version = val &
1143
1143
(FSL_SAI_VERID_MAJOR_MASK | FSL_SAI_VERID_MINOR_MASK);
1144
+
sai->verid.version >>= FSL_SAI_VERID_MINOR_SHIFT;
1144
1145
sai->verid.feature = val & FSL_SAI_VERID_FEATURE_MASK;
1145
1146
1146
1147
ret = regmap_read(sai->regmap, FSL_SAI_PARAM, &val);
+6
-2
sound/soc/soc-topology.c
+6
-2
sound/soc/soc-topology.c
···
1401
1401
1402
1402
template.num_kcontrols = le32_to_cpu(w->num_kcontrols);
1403
1403
kc = devm_kcalloc(tplg->dev, le32_to_cpu(w->num_kcontrols), sizeof(*kc), GFP_KERNEL);
1404
-
if (!kc)
1404
+
if (!kc) {
1405
+
ret = -ENOMEM;
1405
1406
goto hdr_err;
1407
+
}
1406
1408
1407
1409
kcontrol_type = devm_kcalloc(tplg->dev, le32_to_cpu(w->num_kcontrols), sizeof(unsigned int),
1408
1410
GFP_KERNEL);
1409
-
if (!kcontrol_type)
1411
+
if (!kcontrol_type) {
1412
+
ret = -ENOMEM;
1410
1413
goto hdr_err;
1414
+
}
1411
1415
1412
1416
for (i = 0; i < le32_to_cpu(w->num_kcontrols); i++) {
1413
1417
control_hdr = (struct snd_soc_tplg_ctl_hdr *)tplg->pos;
+15
-21
sound/soc/sof/amd/acp.c
+15
-21
sound/soc/sof/amd/acp.c
···
318
318
{
319
319
struct snd_sof_dev *sdev = context;
320
320
const struct sof_amd_acp_desc *desc = get_chip_info(sdev->pdata);
321
-
unsigned int base = desc->dsp_intr_base;
322
321
unsigned int val, count = ACP_HW_SEM_RETRY_COUNT;
323
322
324
323
val = snd_sof_dsp_read(sdev, ACP_DSP_BAR, desc->ext_intr_stat);
···
327
328
return IRQ_HANDLED;
328
329
}
329
330
330
-
val = snd_sof_dsp_read(sdev, ACP_DSP_BAR, base + DSP_SW_INTR_STAT_OFFSET);
331
-
if (val & ACP_DSP_TO_HOST_IRQ) {
332
-
while (snd_sof_dsp_read(sdev, ACP_DSP_BAR, desc->hw_semaphore_offset)) {
333
-
/* Wait until acquired HW Semaphore lock or timeout */
334
-
count--;
335
-
if (!count) {
336
-
dev_err(sdev->dev, "%s: Failed to acquire HW lock\n", __func__);
337
-
return IRQ_NONE;
338
-
}
331
+
while (snd_sof_dsp_read(sdev, ACP_DSP_BAR, desc->hw_semaphore_offset)) {
332
+
/* Wait until acquired HW Semaphore lock or timeout */
333
+
count--;
334
+
if (!count) {
335
+
dev_err(sdev->dev, "%s: Failed to acquire HW lock\n", __func__);
336
+
return IRQ_NONE;
339
337
}
340
-
341
-
sof_ops(sdev)->irq_thread(irq, sdev);
342
-
val |= ACP_DSP_TO_HOST_IRQ;
343
-
snd_sof_dsp_write(sdev, ACP_DSP_BAR, base + DSP_SW_INTR_STAT_OFFSET, val);
344
-
345
-
/* Unlock or Release HW Semaphore */
346
-
snd_sof_dsp_write(sdev, ACP_DSP_BAR, desc->hw_semaphore_offset, 0x0);
347
-
348
-
return IRQ_HANDLED;
349
338
}
350
339
351
-
return IRQ_NONE;
340
+
sof_ops(sdev)->irq_thread(irq, sdev);
341
+
/* Unlock or Release HW Semaphore */
342
+
snd_sof_dsp_write(sdev, ACP_DSP_BAR, desc->hw_semaphore_offset, 0x0);
343
+
344
+
return IRQ_HANDLED;
352
345
};
353
346
354
347
static irqreturn_t acp_irq_handler(int irq, void *dev_id)
···
351
360
unsigned int val;
352
361
353
362
val = snd_sof_dsp_read(sdev, ACP_DSP_BAR, base + DSP_SW_INTR_STAT_OFFSET);
354
-
if (val)
363
+
if (val) {
364
+
val |= ACP_DSP_TO_HOST_IRQ;
365
+
snd_sof_dsp_write(sdev, ACP_DSP_BAR, base + DSP_SW_INTR_STAT_OFFSET, val);
355
366
return IRQ_WAKE_THREAD;
367
+
}
356
368
357
369
return IRQ_NONE;
358
370
}
+3
sound/synth/emux/emux_nrpn.c
+3
sound/synth/emux/emux_nrpn.c
···
349
349
snd_emux_xg_control(struct snd_emux_port *port, struct snd_midi_channel *chan,
350
350
int param)
351
351
{
352
+
if (param >= ARRAY_SIZE(chan->control))
353
+
return -EINVAL;
354
+
352
355
return send_converted_effect(xg_effects, ARRAY_SIZE(xg_effects),
353
356
port, chan, param,
354
357
chan->control[param],