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

Configure Feed

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

Merge tag 'sound-6.14-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull sound fixes from Takashi Iwai:
"A collection of fixes. The only slightly large change is for ASoC
Cirrus codec, but that's still in a normal range. All the rest are
small device-specific fixes and should be fairly safe to take"

* tag 'sound-6.14-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: hda/realtek: Fix microphone regression on ASUS N705UD
ALSA: hda/realtek: Fix wrong mic setup for ASUS VivoBook 15
ASoC: cs35l56: Prevent races when soft-resetting using SPI control
firmware: cs_dsp: Remove async regmap writes
ASoC: Intel: sof_sdw: warn both sdw and pch dmic are used
ASoC: SOF: Intel: don't check number of sdw links when set dmic_fixup
ASoC: dapm-graph: set fill colour of turned on nodes
ASoC: fsl: Rename stream name of SAI DAI driver
ASoC: es8328: fix route from DAC to output
ALSA: usb-audio: Re-add sample rate quirk for Pioneer DJM-900NXS2
ASoC: tas2764: Set the SDOUT polarity correctly
ASoC: tas2764: Fix power control mask
ALSA: usb-audio: Avoid dropping MIDI events at closing multiple ports
ASoC: tas2770: Fix volume scale

+162 -56
+6 -18
drivers/firmware/cirrus/cs_dsp.c
··· 1609 1609 goto out_fw; 1610 1610 } 1611 1611 1612 - ret = regmap_raw_write_async(regmap, reg, buf->buf, 1613 - le32_to_cpu(region->len)); 1612 + ret = regmap_raw_write(regmap, reg, buf->buf, 1613 + le32_to_cpu(region->len)); 1614 1614 if (ret != 0) { 1615 1615 cs_dsp_err(dsp, 1616 1616 "%s.%d: Failed to write %d bytes at %d in %s: %d\n", ··· 1625 1625 regions++; 1626 1626 } 1627 1627 1628 - ret = regmap_async_complete(regmap); 1629 - if (ret != 0) { 1630 - cs_dsp_err(dsp, "Failed to complete async write: %d\n", ret); 1631 - goto out_fw; 1632 - } 1633 - 1634 1628 if (pos > firmware->size) 1635 1629 cs_dsp_warn(dsp, "%s.%d: %zu bytes at end of file\n", 1636 1630 file, regions, pos - firmware->size); ··· 1632 1638 cs_dsp_debugfs_save_wmfwname(dsp, file); 1633 1639 1634 1640 out_fw: 1635 - regmap_async_complete(regmap); 1636 1641 cs_dsp_buf_free(&buf_list); 1637 1642 1638 1643 if (ret == -EOVERFLOW) ··· 2319 2326 cs_dsp_dbg(dsp, "%s.%d: Writing %d bytes at %x\n", 2320 2327 file, blocks, le32_to_cpu(blk->len), 2321 2328 reg); 2322 - ret = regmap_raw_write_async(regmap, reg, buf->buf, 2323 - le32_to_cpu(blk->len)); 2329 + ret = regmap_raw_write(regmap, reg, buf->buf, 2330 + le32_to_cpu(blk->len)); 2324 2331 if (ret != 0) { 2325 2332 cs_dsp_err(dsp, 2326 2333 "%s.%d: Failed to write to %x in %s: %d\n", ··· 2332 2339 blocks++; 2333 2340 } 2334 2341 2335 - ret = regmap_async_complete(regmap); 2336 - if (ret != 0) 2337 - cs_dsp_err(dsp, "Failed to complete async write: %d\n", ret); 2338 - 2339 2342 if (pos > firmware->size) 2340 2343 cs_dsp_warn(dsp, "%s.%d: %zu bytes at end of file\n", 2341 2344 file, blocks, pos - firmware->size); ··· 2339 2350 cs_dsp_debugfs_save_binname(dsp, file); 2340 2351 2341 2352 out_fw: 2342 - regmap_async_complete(regmap); 2343 2353 cs_dsp_buf_free(&buf_list); 2344 2354 2345 2355 if (ret == -EOVERFLOW) ··· 2549 2561 { 2550 2562 int ret; 2551 2563 2552 - ret = regmap_update_bits_async(dsp->regmap, dsp->base + ADSP2_CONTROL, 2553 - ADSP2_SYS_ENA, ADSP2_SYS_ENA); 2564 + ret = regmap_update_bits(dsp->regmap, dsp->base + ADSP2_CONTROL, 2565 + ADSP2_SYS_ENA, ADSP2_SYS_ENA); 2554 2566 if (ret != 0) 2555 2567 return ret; 2556 2568
+31
include/sound/cs35l56.h
··· 12 12 #include <linux/firmware/cirrus/cs_dsp.h> 13 13 #include <linux/regulator/consumer.h> 14 14 #include <linux/regmap.h> 15 + #include <linux/spi/spi.h> 15 16 #include <sound/cs-amp-lib.h> 16 17 17 18 #define CS35L56_DEVID 0x0000000 ··· 62 61 #define CS35L56_IRQ1_MASK_8 0x000E0AC 63 62 #define CS35L56_IRQ1_MASK_18 0x000E0D4 64 63 #define CS35L56_IRQ1_MASK_20 0x000E0DC 64 + #define CS35L56_DSP_MBOX_1_RAW 0x0011000 65 65 #define CS35L56_DSP_VIRTUAL1_MBOX_1 0x0011020 66 66 #define CS35L56_DSP_VIRTUAL1_MBOX_2 0x0011024 67 67 #define CS35L56_DSP_VIRTUAL1_MBOX_3 0x0011028 ··· 226 224 #define CS35L56_HALO_STATE_SHUTDOWN 1 227 225 #define CS35L56_HALO_STATE_BOOT_DONE 2 228 226 227 + #define CS35L56_MBOX_CMD_PING 0x0A000000 229 228 #define CS35L56_MBOX_CMD_AUDIO_PLAY 0x0B000001 230 229 #define CS35L56_MBOX_CMD_AUDIO_PAUSE 0x0B000002 231 230 #define CS35L56_MBOX_CMD_AUDIO_REINIT 0x0B000003 ··· 257 254 #define CS35L56_NUM_BULK_SUPPLIES 3 258 255 #define CS35L56_NUM_DSP_REGIONS 5 259 256 257 + /* Additional margin for SYSTEM_RESET to control port ready on SPI */ 258 + #define CS35L56_SPI_RESET_TO_PORT_READY_US (CS35L56_CONTROL_PORT_READY_US + 2500) 259 + 260 + struct cs35l56_spi_payload { 261 + __be32 addr; 262 + __be16 pad; 263 + __be32 value; 264 + } __packed; 265 + static_assert(sizeof(struct cs35l56_spi_payload) == 10); 266 + 260 267 struct cs35l56_base { 261 268 struct device *dev; 262 269 struct regmap *regmap; ··· 282 269 s8 cal_index; 283 270 struct cirrus_amp_cal_data cal_data; 284 271 struct gpio_desc *reset_gpio; 272 + struct cs35l56_spi_payload *spi_payload_buf; 285 273 }; 286 274 287 275 static inline bool cs35l56_is_otp_register(unsigned int reg) 288 276 { 289 277 return (reg >> 16) == 3; 278 + } 279 + 280 + static inline int cs35l56_init_config_for_spi(struct cs35l56_base *cs35l56, 281 + struct spi_device *spi) 282 + { 283 + cs35l56->spi_payload_buf = devm_kzalloc(&spi->dev, 284 + sizeof(*cs35l56->spi_payload_buf), 285 + GFP_KERNEL | GFP_DMA); 286 + if (!cs35l56->spi_payload_buf) 287 + return -ENOMEM; 288 + 289 + return 0; 290 + } 291 + 292 + static inline bool cs35l56_is_spi(struct cs35l56_base *cs35l56) 293 + { 294 + return IS_ENABLED(CONFIG_SPI_MASTER) && !!cs35l56->spi_payload_buf; 290 295 } 291 296 292 297 extern const struct regmap_config cs35l56_regmap_i2c;
+3
sound/pci/hda/cs35l56_hda_spi.c
··· 22 22 return -ENOMEM; 23 23 24 24 cs35l56->base.dev = &spi->dev; 25 + ret = cs35l56_init_config_for_spi(&cs35l56->base, spi); 26 + if (ret) 27 + return ret; 25 28 26 29 #ifdef CS35L56_WAKE_HOLD_TIME_US 27 30 cs35l56->base.can_hibernate = true;
+1 -1
sound/pci/hda/patch_realtek.c
··· 10623 10623 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC), 10624 10624 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 10625 10625 SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10626 + SND_PCI_QUIRK(0x1043, 0x1460, "Asus VivoBook 15", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 10626 10627 SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10627 10628 SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC), 10628 10629 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), ··· 10657 10656 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 10658 10657 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 10659 10658 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 10660 - SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), 10661 10659 SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2), 10662 10660 SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2), 10663 10661 SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
+80
sound/soc/codecs/cs35l56-shared.c
··· 10 10 #include <linux/gpio/consumer.h> 11 11 #include <linux/regmap.h> 12 12 #include <linux/regulator/consumer.h> 13 + #include <linux/spi/spi.h> 13 14 #include <linux/types.h> 14 15 #include <sound/cs-amp-lib.h> 15 16 ··· 304 303 } 305 304 EXPORT_SYMBOL_NS_GPL(cs35l56_wait_min_reset_pulse, "SND_SOC_CS35L56_SHARED"); 306 305 306 + static const struct { 307 + u32 addr; 308 + u32 value; 309 + } cs35l56_spi_system_reset_stages[] = { 310 + { .addr = CS35L56_DSP_VIRTUAL1_MBOX_1, .value = CS35L56_MBOX_CMD_SYSTEM_RESET }, 311 + /* The next write is necessary to delimit the soft reset */ 312 + { .addr = CS35L56_DSP_MBOX_1_RAW, .value = CS35L56_MBOX_CMD_PING }, 313 + }; 314 + 315 + static void cs35l56_spi_issue_bus_locked_reset(struct cs35l56_base *cs35l56_base, 316 + struct spi_device *spi) 317 + { 318 + struct cs35l56_spi_payload *buf = cs35l56_base->spi_payload_buf; 319 + struct spi_transfer t = { 320 + .tx_buf = buf, 321 + .len = sizeof(*buf), 322 + }; 323 + struct spi_message m; 324 + int i, ret; 325 + 326 + for (i = 0; i < ARRAY_SIZE(cs35l56_spi_system_reset_stages); i++) { 327 + buf->addr = cpu_to_be32(cs35l56_spi_system_reset_stages[i].addr); 328 + buf->value = cpu_to_be32(cs35l56_spi_system_reset_stages[i].value); 329 + spi_message_init_with_transfers(&m, &t, 1); 330 + ret = spi_sync_locked(spi, &m); 331 + if (ret) 332 + dev_warn(cs35l56_base->dev, "spi_sync failed: %d\n", ret); 333 + 334 + usleep_range(CS35L56_SPI_RESET_TO_PORT_READY_US, 335 + 2 * CS35L56_SPI_RESET_TO_PORT_READY_US); 336 + } 337 + } 338 + 339 + static void cs35l56_spi_system_reset(struct cs35l56_base *cs35l56_base) 340 + { 341 + struct spi_device *spi = to_spi_device(cs35l56_base->dev); 342 + unsigned int val; 343 + int read_ret, ret; 344 + 345 + /* 346 + * There must not be any other SPI bus activity while the amp is 347 + * soft-resetting. 348 + */ 349 + ret = spi_bus_lock(spi->controller); 350 + if (ret) { 351 + dev_warn(cs35l56_base->dev, "spi_bus_lock failed: %d\n", ret); 352 + return; 353 + } 354 + 355 + cs35l56_spi_issue_bus_locked_reset(cs35l56_base, spi); 356 + spi_bus_unlock(spi->controller); 357 + 358 + /* 359 + * Check firmware boot by testing for a response in MBOX_2. 360 + * HALO_STATE cannot be trusted yet because the reset sequence 361 + * can leave it with stale state. But MBOX is reset. 362 + * The regmap must remain in cache-only until the chip has 363 + * booted, so use a bypassed read. 364 + */ 365 + ret = read_poll_timeout(regmap_read_bypassed, read_ret, 366 + (val > 0) && (val < 0xffffffff), 367 + CS35L56_HALO_STATE_POLL_US, 368 + CS35L56_HALO_STATE_TIMEOUT_US, 369 + false, 370 + cs35l56_base->regmap, 371 + CS35L56_DSP_VIRTUAL1_MBOX_2, 372 + &val); 373 + if (ret) { 374 + dev_err(cs35l56_base->dev, "SPI reboot timed out(%d): MBOX2=%#x\n", 375 + read_ret, val); 376 + } 377 + } 378 + 307 379 static const struct reg_sequence cs35l56_system_reset_seq[] = { 308 380 REG_SEQ0(CS35L56_DSP1_HALO_STATE, 0), 309 381 REG_SEQ0(CS35L56_DSP_VIRTUAL1_MBOX_1, CS35L56_MBOX_CMD_SYSTEM_RESET), ··· 389 315 * accesses other than the controlled system reset sequence below. 390 316 */ 391 317 regcache_cache_only(cs35l56_base->regmap, true); 318 + 319 + if (cs35l56_is_spi(cs35l56_base)) { 320 + cs35l56_spi_system_reset(cs35l56_base); 321 + return; 322 + } 323 + 392 324 regmap_multi_reg_write_bypassed(cs35l56_base->regmap, 393 325 cs35l56_system_reset_seq, 394 326 ARRAY_SIZE(cs35l56_system_reset_seq));
+3
sound/soc/codecs/cs35l56-spi.c
··· 33 33 34 34 cs35l56->base.dev = &spi->dev; 35 35 cs35l56->base.can_hibernate = true; 36 + ret = cs35l56_init_config_for_spi(&cs35l56->base, spi); 37 + if (ret) 38 + return ret; 36 39 37 40 ret = cs35l56_common_probe(cs35l56); 38 41 if (ret != 0)
+4 -11
sound/soc/codecs/es8328.c
··· 233 233 234 234 /* Left Mixer */ 235 235 static const struct snd_kcontrol_new es8328_left_mixer_controls[] = { 236 - SOC_DAPM_SINGLE("Playback Switch", ES8328_DACCONTROL17, 7, 1, 0), 237 236 SOC_DAPM_SINGLE("Left Bypass Switch", ES8328_DACCONTROL17, 6, 1, 0), 238 237 SOC_DAPM_SINGLE("Right Playback Switch", ES8328_DACCONTROL18, 7, 1, 0), 239 238 SOC_DAPM_SINGLE("Right Bypass Switch", ES8328_DACCONTROL18, 6, 1, 0), ··· 242 243 static const struct snd_kcontrol_new es8328_right_mixer_controls[] = { 243 244 SOC_DAPM_SINGLE("Left Playback Switch", ES8328_DACCONTROL19, 7, 1, 0), 244 245 SOC_DAPM_SINGLE("Left Bypass Switch", ES8328_DACCONTROL19, 6, 1, 0), 245 - SOC_DAPM_SINGLE("Playback Switch", ES8328_DACCONTROL20, 7, 1, 0), 246 246 SOC_DAPM_SINGLE("Right Bypass Switch", ES8328_DACCONTROL20, 6, 1, 0), 247 247 }; 248 248 ··· 334 336 SND_SOC_DAPM_DAC("Left DAC", "Left Playback", ES8328_DACPOWER, 335 337 ES8328_DACPOWER_LDAC_OFF, 1), 336 338 337 - SND_SOC_DAPM_MIXER("Left Mixer", SND_SOC_NOPM, 0, 0, 339 + SND_SOC_DAPM_MIXER("Left Mixer", ES8328_DACCONTROL17, 7, 0, 338 340 &es8328_left_mixer_controls[0], 339 341 ARRAY_SIZE(es8328_left_mixer_controls)), 340 - SND_SOC_DAPM_MIXER("Right Mixer", SND_SOC_NOPM, 0, 0, 342 + SND_SOC_DAPM_MIXER("Right Mixer", ES8328_DACCONTROL20, 7, 0, 341 343 &es8328_right_mixer_controls[0], 342 344 ARRAY_SIZE(es8328_right_mixer_controls)), 343 345 ··· 416 418 { "Right Line Mux", "PGA", "Right PGA Mux" }, 417 419 { "Right Line Mux", "Differential", "Differential Mux" }, 418 420 419 - { "Left Out 1", NULL, "Left DAC" }, 420 - { "Right Out 1", NULL, "Right DAC" }, 421 - { "Left Out 2", NULL, "Left DAC" }, 422 - { "Right Out 2", NULL, "Right DAC" }, 423 - 424 - { "Left Mixer", "Playback Switch", "Left DAC" }, 421 + { "Left Mixer", NULL, "Left DAC" }, 425 422 { "Left Mixer", "Left Bypass Switch", "Left Line Mux" }, 426 423 { "Left Mixer", "Right Playback Switch", "Right DAC" }, 427 424 { "Left Mixer", "Right Bypass Switch", "Right Line Mux" }, 428 425 429 426 { "Right Mixer", "Left Playback Switch", "Left DAC" }, 430 427 { "Right Mixer", "Left Bypass Switch", "Left Line Mux" }, 431 - { "Right Mixer", "Playback Switch", "Right DAC" }, 428 + { "Right Mixer", NULL, "Right DAC" }, 432 429 { "Right Mixer", "Right Bypass Switch", "Right Line Mux" }, 433 430 434 431 { "DAC DIG", NULL, "DAC STM" },
+9 -1
sound/soc/codecs/tas2764.c
··· 365 365 { 366 366 struct snd_soc_component *component = dai->component; 367 367 struct tas2764_priv *tas2764 = snd_soc_component_get_drvdata(component); 368 - u8 tdm_rx_start_slot = 0, asi_cfg_0 = 0, asi_cfg_1 = 0; 368 + u8 tdm_rx_start_slot = 0, asi_cfg_0 = 0, asi_cfg_1 = 0, asi_cfg_4 = 0; 369 369 int ret; 370 370 371 371 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { ··· 374 374 fallthrough; 375 375 case SND_SOC_DAIFMT_NB_NF: 376 376 asi_cfg_1 = TAS2764_TDM_CFG1_RX_RISING; 377 + asi_cfg_4 = TAS2764_TDM_CFG4_TX_FALLING; 377 378 break; 378 379 case SND_SOC_DAIFMT_IB_IF: 379 380 asi_cfg_0 ^= TAS2764_TDM_CFG0_FRAME_START; 380 381 fallthrough; 381 382 case SND_SOC_DAIFMT_IB_NF: 382 383 asi_cfg_1 = TAS2764_TDM_CFG1_RX_FALLING; 384 + asi_cfg_4 = TAS2764_TDM_CFG4_TX_RISING; 383 385 break; 384 386 } 385 387 386 388 ret = snd_soc_component_update_bits(component, TAS2764_TDM_CFG1, 387 389 TAS2764_TDM_CFG1_RX_MASK, 388 390 asi_cfg_1); 391 + if (ret < 0) 392 + return ret; 393 + 394 + ret = snd_soc_component_update_bits(component, TAS2764_TDM_CFG4, 395 + TAS2764_TDM_CFG4_TX_MASK, 396 + asi_cfg_4); 389 397 if (ret < 0) 390 398 return ret; 391 399
+7 -1
sound/soc/codecs/tas2764.h
··· 25 25 26 26 /* Power Control */ 27 27 #define TAS2764_PWR_CTRL TAS2764_REG(0X0, 0x02) 28 - #define TAS2764_PWR_CTRL_MASK GENMASK(1, 0) 28 + #define TAS2764_PWR_CTRL_MASK GENMASK(2, 0) 29 29 #define TAS2764_PWR_CTRL_ACTIVE 0x0 30 30 #define TAS2764_PWR_CTRL_MUTE BIT(0) 31 31 #define TAS2764_PWR_CTRL_SHUTDOWN BIT(1) ··· 78 78 #define TAS2764_TDM_CFG3_RXS_MASK GENMASK(7, 4) 79 79 #define TAS2764_TDM_CFG3_RXS_SHIFT 0x4 80 80 #define TAS2764_TDM_CFG3_MASK GENMASK(3, 0) 81 + 82 + /* TDM Configuration Reg4 */ 83 + #define TAS2764_TDM_CFG4 TAS2764_REG(0X0, 0x0d) 84 + #define TAS2764_TDM_CFG4_TX_MASK BIT(0) 85 + #define TAS2764_TDM_CFG4_TX_RISING 0x0 86 + #define TAS2764_TDM_CFG4_TX_FALLING BIT(0) 81 87 82 88 /* TDM Configuration Reg5 */ 83 89 #define TAS2764_TDM_CFG5 TAS2764_REG(0X0, 0x0e)
+1 -1
sound/soc/codecs/tas2770.c
··· 506 506 } 507 507 508 508 static DECLARE_TLV_DB_SCALE(tas2770_digital_tlv, 1100, 50, 0); 509 - static DECLARE_TLV_DB_SCALE(tas2770_playback_volume, -12750, 50, 0); 509 + static DECLARE_TLV_DB_SCALE(tas2770_playback_volume, -10050, 50, 0); 510 510 511 511 static const struct snd_kcontrol_new tas2770_snd_controls[] = { 512 512 SOC_SINGLE_TLV("Speaker Playback Volume", TAS2770_PLAY_CFG_REG2,
+3 -3
sound/soc/fsl/fsl_sai.c
··· 994 994 { 995 995 .name = "sai-tx", 996 996 .playback = { 997 - .stream_name = "CPU-Playback", 997 + .stream_name = "SAI-Playback", 998 998 .channels_min = 1, 999 999 .channels_max = 32, 1000 - .rate_min = 8000, 1000 + .rate_min = 8000, 1001 1001 .rate_max = 2822400, 1002 1002 .rates = SNDRV_PCM_RATE_KNOT, 1003 1003 .formats = FSL_SAI_FORMATS, ··· 1007 1007 { 1008 1008 .name = "sai-rx", 1009 1009 .capture = { 1010 - .stream_name = "CPU-Capture", 1010 + .stream_name = "SAI-Capture", 1011 1011 .channels_min = 1, 1012 1012 .channels_max = 32, 1013 1013 .rate_min = 8000,
+2 -2
sound/soc/fsl/imx-audmix.c
··· 119 119 static const char *name[][3] = { 120 120 {"HiFi-AUDMIX-FE-0", "HiFi-AUDMIX-FE-1", "HiFi-AUDMIX-FE-2"}, 121 121 {"sai-tx", "sai-tx", "sai-rx"}, 122 - {"AUDMIX-Playback-0", "AUDMIX-Playback-1", "CPU-Capture"}, 123 - {"CPU-Playback", "CPU-Playback", "AUDMIX-Capture-0"}, 122 + {"AUDMIX-Playback-0", "AUDMIX-Playback-1", "SAI-Capture"}, 123 + {"SAI-Playback", "SAI-Playback", "AUDMIX-Capture-0"}, 124 124 }; 125 125 126 126 static int imx_audmix_probe(struct platform_device *pdev)
+7
sound/soc/intel/boards/sof_sdw.c
··· 803 803 int *be_id, struct snd_soc_codec_conf **codec_conf) 804 804 { 805 805 struct device *dev = card->dev; 806 + struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev); 806 807 struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card); 808 + struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 807 809 struct intel_mc_ctx *intel_ctx = (struct intel_mc_ctx *)ctx->private; 808 810 struct asoc_sdw_endpoint *sof_end; 809 811 int stream; ··· 902 900 903 901 codecs[j].name = sof_end->codec_name; 904 902 codecs[j].dai_name = sof_end->dai_info->dai_name; 903 + if (sof_end->dai_info->dai_type == SOC_SDW_DAI_TYPE_MIC && 904 + mach_params->dmic_num > 0) { 905 + dev_warn(dev, 906 + "Both SDW DMIC and PCH DMIC are present, if incorrect, please set kernel params snd_sof_intel_hda_generic dmic_num=0 to disable PCH DMIC\n"); 907 + } 905 908 j++; 906 909 } 907 910
+2 -16
sound/soc/sof/intel/hda.c
··· 1312 1312 /* report to machine driver if any DMICs are found */ 1313 1313 mach->mach_params.dmic_num = check_dmic_num(sdev); 1314 1314 1315 - if (sdw_mach_found) { 1316 - /* 1317 - * DMICs use up to 4 pins and are typically pin-muxed with SoundWire 1318 - * link 2 and 3, or link 1 and 2, thus we only try to enable dmics 1319 - * if all conditions are true: 1320 - * a) 2 or fewer links are used by SoundWire 1321 - * b) the NHLT table reports the presence of microphones 1322 - */ 1323 - if (hweight_long(mach->link_mask) <= 2) 1324 - dmic_fixup = true; 1325 - else 1326 - mach->mach_params.dmic_num = 0; 1327 - } else { 1328 - if (mach->tplg_quirk_mask & SND_SOC_ACPI_TPLG_INTEL_DMIC_NUMBER) 1329 - dmic_fixup = true; 1330 - } 1315 + if (sdw_mach_found || mach->tplg_quirk_mask & SND_SOC_ACPI_TPLG_INTEL_DMIC_NUMBER) 1316 + dmic_fixup = true; 1331 1317 1332 1318 if (tplg_fixup && 1333 1319 dmic_fixup &&
+1 -1
sound/usb/midi.c
··· 1145 1145 { 1146 1146 struct usbmidi_out_port *port = substream->runtime->private_data; 1147 1147 1148 - cancel_work_sync(&port->ep->work); 1148 + flush_work(&port->ep->work); 1149 1149 return substream_open(substream, 0, 0); 1150 1150 } 1151 1151
+1
sound/usb/quirks.c
··· 1868 1868 case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */ 1869 1869 subs->stream_offset_adj = 2; 1870 1870 break; 1871 + case USB_ID(0x2b73, 0x000a): /* Pioneer DJM-900NXS2 */ 1871 1872 case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */ 1872 1873 pioneer_djm_set_format_quirk(subs, 0x0082); 1873 1874 break;
+1 -1
tools/sound/dapm-graph
··· 10 10 11 11 STYLE_COMPONENT_ON="color=dodgerblue;style=bold" 12 12 STYLE_COMPONENT_OFF="color=gray40;style=filled;fillcolor=gray90" 13 - STYLE_NODE_ON="shape=box,style=bold,color=green4" 13 + STYLE_NODE_ON="shape=box,style=bold,color=green4,fillcolor=white" 14 14 STYLE_NODE_OFF="shape=box,style=filled,color=gray30,fillcolor=gray95" 15 15 16 16 # Print usage and exit