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

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

Pull sound fixes from Takashi Iwai:
"All small changes, mostly device-specific:

- A regression fix for PCM WC-page allocation on x86

- A regression fix for i915 audio component binding

- Fixes for (longstanding) beep handling bug

- Runtime PM fixes for Intel LPE HDMI audio

- A couple of pending FireWire fixes

- Usual HD-audio and USB-audio quirks, new Intel dspconf entries"

* tag 'sound-5.19-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: hda/realtek: Add quirk for Clevo NS50PU
ALSA: hda: Fix discovery of i915 graphics PCI device
ALSA: hda/via: Fix missing beep setup
ALSA: hda/conexant: Fix missing beep setup
ALSA: memalloc: Drop x86-specific hack for WC allocations
ALSA: hda/realtek: Add quirk for Clevo PD70PNT
ALSA: x86: intel_hdmi_audio: use pm_runtime_resume_and_get()
ALSA: x86: intel_hdmi_audio: enable pm_runtime and set autosuspend delay
ALSA: hda: intel-nhlt: remove use of __func__ in dev_dbg
ALSA: hda: intel-dspcfg: use SOF for UpExtreme and UpExtreme11 boards
firewire: convert sysfs sprintf/snprintf family to sysfs_emit
firewire: cdev: fix potential leak of kernel stack due to uninitialized value
ALSA: hda/realtek: Apply fixup for Lenovo Yoga Duet 7 properly
ALSA: hda/realtek - ALC897 headset MIC no sound
ALSA: usb-audio: US16x08: Move overflow check before array access
ALSA: hda/realtek: Add mute LED quirk for HP Omen laptop

Linus Torvalds ddfe8031 de5c208d

+90 -58
+1 -1
drivers/firewire/core-cdev.c
··· 1211 1211 struct fw_cdev_get_cycle_timer2 *a = &arg->get_cycle_timer2; 1212 1212 struct fw_card *card = client->device->card; 1213 1213 struct timespec64 ts = {0, 0}; 1214 - u32 cycle_time; 1214 + u32 cycle_time = 0; 1215 1215 int ret = 0; 1216 1216 1217 1217 local_irq_disable();
+2 -4
drivers/firewire/core-device.c
··· 372 372 struct fw_device *device = fw_device(dev->parent); 373 373 struct fw_unit *unit = fw_unit(dev); 374 374 375 - return snprintf(buf, PAGE_SIZE, "%d\n", 376 - (int)(unit->directory - device->config_rom)); 375 + return sysfs_emit(buf, "%td\n", unit->directory - device->config_rom); 377 376 } 378 377 379 378 static struct device_attribute fw_unit_attributes[] = { ··· 402 403 int ret; 403 404 404 405 down_read(&fw_device_rwsem); 405 - ret = snprintf(buf, PAGE_SIZE, "0x%08x%08x\n", 406 - device->config_rom[3], device->config_rom[4]); 406 + ret = sysfs_emit(buf, "0x%08x%08x\n", device->config_rom[3], device->config_rom[4]); 407 407 up_read(&fw_device_rwsem); 408 408 409 409 return ret;
+1 -22
sound/core/memalloc.c
··· 431 431 */ 432 432 static void *snd_dma_dev_alloc(struct snd_dma_buffer *dmab, size_t size) 433 433 { 434 - void *p; 435 - 436 - p = dma_alloc_coherent(dmab->dev.dev, size, &dmab->addr, DEFAULT_GFP); 437 - #ifdef CONFIG_X86 438 - if (p && dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC) 439 - set_memory_wc((unsigned long)p, PAGE_ALIGN(size) >> PAGE_SHIFT); 440 - #endif 441 - return p; 434 + return dma_alloc_coherent(dmab->dev.dev, size, &dmab->addr, DEFAULT_GFP); 442 435 } 443 436 444 437 static void snd_dma_dev_free(struct snd_dma_buffer *dmab) 445 438 { 446 - #ifdef CONFIG_X86 447 - if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC) 448 - set_memory_wb((unsigned long)dmab->area, 449 - PAGE_ALIGN(dmab->bytes) >> PAGE_SHIFT); 450 - #endif 451 439 dma_free_coherent(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr); 452 440 } 453 441 454 442 static int snd_dma_dev_mmap(struct snd_dma_buffer *dmab, 455 443 struct vm_area_struct *area) 456 444 { 457 - #ifdef CONFIG_X86 458 - if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC) 459 - area->vm_page_prot = pgprot_writecombine(area->vm_page_prot); 460 - #endif 461 445 return dma_mmap_coherent(dmab->dev.dev, area, 462 446 dmab->area, dmab->addr, dmab->bytes); 463 447 } ··· 455 471 /* 456 472 * Write-combined pages 457 473 */ 458 - #ifdef CONFIG_X86 459 - /* On x86, share the same ops as the standard dev ops */ 460 - #define snd_dma_wc_ops snd_dma_dev_ops 461 - #else /* CONFIG_X86 */ 462 474 static void *snd_dma_wc_alloc(struct snd_dma_buffer *dmab, size_t size) 463 475 { 464 476 return dma_alloc_wc(dmab->dev.dev, size, &dmab->addr, DEFAULT_GFP); ··· 477 497 .free = snd_dma_wc_free, 478 498 .mmap = snd_dma_wc_mmap, 479 499 }; 480 - #endif /* CONFIG_X86 */ 481 500 482 501 #ifdef CONFIG_SND_DMA_SGBUF 483 502 static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size);
+6 -9
sound/hda/hdac_i915.c
··· 119 119 /* check whether Intel graphics is present and reachable */ 120 120 static int i915_gfx_present(struct pci_dev *hdac_pci) 121 121 { 122 - unsigned int class = PCI_BASE_CLASS_DISPLAY << 16; 123 122 struct pci_dev *display_dev = NULL; 124 - bool match = false; 125 123 126 - do { 127 - display_dev = pci_get_class(class, display_dev); 128 - 129 - if (display_dev && display_dev->vendor == PCI_VENDOR_ID_INTEL && 124 + for_each_pci_dev(display_dev) { 125 + if (display_dev->vendor == PCI_VENDOR_ID_INTEL && 126 + (display_dev->class >> 16) == PCI_BASE_CLASS_DISPLAY && 130 127 connectivity_check(display_dev, hdac_pci)) { 131 128 pci_dev_put(display_dev); 132 - match = true; 129 + return true; 133 130 } 134 - } while (!match && display_dev); 131 + } 135 132 136 - return match; 133 + return false; 137 134 } 138 135 139 136 /**
+12
sound/hda/intel-dsp-config.c
··· 196 196 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 197 197 } 198 198 }, 199 + { 200 + .ident = "UP-WHL", 201 + .matches = { 202 + DMI_MATCH(DMI_SYS_VENDOR, "AAEON"), 203 + } 204 + }, 199 205 {} 200 206 } 201 207 }, ··· 362 356 .ident = "Google Chromebooks", 363 357 .matches = { 364 358 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 359 + } 360 + }, 361 + { 362 + .ident = "UPX-TGL", 363 + .matches = { 364 + DMI_MATCH(DMI_SYS_VENDOR, "AAEON"), 365 365 } 366 366 }, 367 367 {}
+8 -9
sound/hda/intel-nhlt.c
··· 55 55 56 56 /* find max number of channels based on format_configuration */ 57 57 if (fmt_configs->fmt_count) { 58 - dev_dbg(dev, "%s: found %d format definitions\n", 59 - __func__, fmt_configs->fmt_count); 58 + dev_dbg(dev, "found %d format definitions\n", 59 + fmt_configs->fmt_count); 60 60 61 61 for (i = 0; i < fmt_configs->fmt_count; i++) { 62 62 struct wav_fmt_ext *fmt_ext; ··· 66 66 if (fmt_ext->fmt.channels > max_ch) 67 67 max_ch = fmt_ext->fmt.channels; 68 68 } 69 - dev_dbg(dev, "%s: max channels found %d\n", __func__, max_ch); 69 + dev_dbg(dev, "max channels found %d\n", max_ch); 70 70 } else { 71 - dev_dbg(dev, "%s: No format information found\n", __func__); 71 + dev_dbg(dev, "No format information found\n"); 72 72 } 73 73 74 74 if (cfg->device_config.config_type != NHLT_CONFIG_TYPE_MIC_ARRAY) { ··· 95 95 } 96 96 97 97 if (dmic_geo > 0) { 98 - dev_dbg(dev, "%s: Array with %d dmics\n", __func__, dmic_geo); 98 + dev_dbg(dev, "Array with %d dmics\n", dmic_geo); 99 99 } 100 100 if (max_ch > dmic_geo) { 101 - dev_dbg(dev, "%s: max channels %d exceed dmic number %d\n", 102 - __func__, max_ch, dmic_geo); 101 + dev_dbg(dev, "max channels %d exceed dmic number %d\n", 102 + max_ch, dmic_geo); 103 103 } 104 104 } 105 105 } 106 106 107 - dev_dbg(dev, "%s: dmic number %d max_ch %d\n", 108 - __func__, dmic_geo, max_ch); 107 + dev_dbg(dev, "dmic number %d max_ch %d\n", dmic_geo, max_ch); 109 108 110 109 return dmic_geo; 111 110 }
+4 -3
sound/pci/hda/hda_auto_parser.c
··· 819 819 snd_hda_set_pin_ctl_cache(codec, cfg->nid, cfg->val); 820 820 } 821 821 822 - static void apply_fixup(struct hda_codec *codec, int id, int action, int depth) 822 + void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth) 823 823 { 824 824 const char *modelname = codec->fixup_name; 825 825 ··· 829 829 if (++depth > 10) 830 830 break; 831 831 if (fix->chained_before) 832 - apply_fixup(codec, fix->chain_id, action, depth + 1); 832 + __snd_hda_apply_fixup(codec, fix->chain_id, action, depth + 1); 833 833 834 834 switch (fix->type) { 835 835 case HDA_FIXUP_PINS: ··· 870 870 id = fix->chain_id; 871 871 } 872 872 } 873 + EXPORT_SYMBOL_GPL(__snd_hda_apply_fixup); 873 874 874 875 /** 875 876 * snd_hda_apply_fixup - Apply the fixup chain with the given action ··· 880 879 void snd_hda_apply_fixup(struct hda_codec *codec, int action) 881 880 { 882 881 if (codec->fixup_list) 883 - apply_fixup(codec, codec->fixup_id, action, 0); 882 + __snd_hda_apply_fixup(codec, codec->fixup_id, action, 0); 884 883 } 885 884 EXPORT_SYMBOL_GPL(snd_hda_apply_fixup); 886 885
+1
sound/pci/hda/hda_local.h
··· 348 348 void snd_hda_apply_pincfgs(struct hda_codec *codec, 349 349 const struct hda_pintbl *cfg); 350 350 void snd_hda_apply_fixup(struct hda_codec *codec, int action); 351 + void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth); 351 352 void snd_hda_pick_fixup(struct hda_codec *codec, 352 353 const struct hda_model_fixup *models, 353 354 const struct snd_pci_quirk *quirk,
+2 -2
sound/pci/hda/patch_conexant.c
··· 1079 1079 if (err < 0) 1080 1080 goto error; 1081 1081 1082 - err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg); 1082 + err = cx_auto_parse_beep(codec); 1083 1083 if (err < 0) 1084 1084 goto error; 1085 1085 1086 - err = cx_auto_parse_beep(codec); 1086 + err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg); 1087 1087 if (err < 0) 1088 1088 goto error; 1089 1089
+35 -1
sound/pci/hda/patch_realtek.c
··· 2634 2634 SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2635 2635 SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2636 2636 SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2637 + SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2637 2638 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2638 2639 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2639 2640 SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED), ··· 7005 7004 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, 7006 7005 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 7007 7006 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, 7007 + ALC298_FIXUP_LENOVO_C940_DUET7, 7008 7008 ALC287_FIXUP_13S_GEN2_SPEAKERS, 7009 7009 ALC256_FIXUP_SET_COEF_DEFAULTS, 7010 7010 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, ··· 7023 7021 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED, 7024 7022 ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE, 7025 7023 }; 7024 + 7025 + /* A special fixup for Lenovo C940 and Yoga Duet 7; 7026 + * both have the very same PCI SSID, and we need to apply different fixups 7027 + * depending on the codec ID 7028 + */ 7029 + static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec, 7030 + const struct hda_fixup *fix, 7031 + int action) 7032 + { 7033 + int id; 7034 + 7035 + if (codec->core.vendor_id == 0x10ec0298) 7036 + id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */ 7037 + else 7038 + id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */ 7039 + __snd_hda_apply_fixup(codec, id, action, 0); 7040 + } 7026 7041 7027 7042 static const struct hda_fixup alc269_fixups[] = { 7028 7043 [ALC269_FIXUP_GPIO2] = { ··· 8740 8721 .chained = true, 8741 8722 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8742 8723 }, 8724 + [ALC298_FIXUP_LENOVO_C940_DUET7] = { 8725 + .type = HDA_FIXUP_FUNC, 8726 + .v.func = alc298_fixup_lenovo_c940_duet7, 8727 + }, 8743 8728 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = { 8744 8729 .type = HDA_FIXUP_VERBS, 8745 8730 .v.verbs = (const struct hda_verb[]) { ··· 9045 9022 ALC285_FIXUP_HP_GPIO_AMP_INIT), 9046 9023 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation", 9047 9024 ALC285_FIXUP_HP_GPIO_AMP_INIT), 9025 + SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 9048 9026 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 9049 9027 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED), 9050 9028 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), ··· 9211 9187 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9212 9188 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9213 9189 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9190 + SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9214 9191 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9215 9192 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9216 9193 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), ··· 9298 9273 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 9299 9274 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9300 9275 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 9301 - SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME), 9276 + SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7), 9302 9277 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS), 9303 9278 SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9304 9279 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), ··· 10762 10737 ALC668_FIXUP_MIC_DET_COEF, 10763 10738 ALC897_FIXUP_LENOVO_HEADSET_MIC, 10764 10739 ALC897_FIXUP_HEADSET_MIC_PIN, 10740 + ALC897_FIXUP_HP_HSMIC_VERB, 10765 10741 }; 10766 10742 10767 10743 static const struct hda_fixup alc662_fixups[] = { ··· 11182 11156 .chained = true, 11183 11157 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC 11184 11158 }, 11159 + [ALC897_FIXUP_HP_HSMIC_VERB] = { 11160 + .type = HDA_FIXUP_PINS, 11161 + .v.pins = (const struct hda_pintbl[]) { 11162 + { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 11163 + { } 11164 + }, 11165 + }, 11185 11166 }; 11186 11167 11187 11168 static const struct snd_pci_quirk alc662_fixup_tbl[] = { ··· 11214 11181 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11215 11182 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11216 11183 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 11184 + SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 11217 11185 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2), 11218 11186 SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2), 11219 11187 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
+2 -2
sound/pci/hda/patch_via.c
··· 518 518 if (err < 0) 519 519 return err; 520 520 521 - err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg); 521 + err = auto_parse_beep(codec); 522 522 if (err < 0) 523 523 return err; 524 524 525 - err = auto_parse_beep(codec); 525 + err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg); 526 526 if (err < 0) 527 527 return err; 528 528
+3 -3
sound/usb/mixer_us16x08.c
··· 637 637 } 638 638 } else { 639 639 /* skip channels with no compressor active */ 640 - while (!store->comp_store->val[ 640 + while (store->comp_index <= SND_US16X08_MAX_CHANNELS 641 + && !store->comp_store->val[ 641 642 COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)] 642 - [store->comp_index - 1] 643 - && store->comp_index <= SND_US16X08_MAX_CHANNELS) { 643 + [store->comp_index - 1]) { 644 644 store->comp_index++; 645 645 } 646 646 ret = store->comp_index++;
+13 -2
sound/x86/intel_hdmi_audio.c
··· 33 33 #include <drm/intel_lpe_audio.h> 34 34 #include "intel_hdmi_audio.h" 35 35 36 + #define INTEL_HDMI_AUDIO_SUSPEND_DELAY_MS 5000 37 + 36 38 #define for_each_pipe(card_ctx, pipe) \ 37 39 for ((pipe) = 0; (pipe) < (card_ctx)->num_pipes; (pipe)++) 38 40 #define for_each_port(card_ctx, port) \ ··· 1068 1066 intelhaddata = snd_pcm_substream_chip(substream); 1069 1067 runtime = substream->runtime; 1070 1068 1071 - pm_runtime_get_sync(intelhaddata->dev); 1069 + retval = pm_runtime_resume_and_get(intelhaddata->dev); 1070 + if (retval < 0) 1071 + return retval; 1072 1072 1073 1073 /* set the runtime hw parameter with local snd_pcm_hardware struct */ 1074 1074 runtime->hw = had_pcm_hardware; ··· 1538 1534 container_of(work, struct snd_intelhad, hdmi_audio_wq); 1539 1535 struct intel_hdmi_lpe_audio_pdata *pdata = ctx->dev->platform_data; 1540 1536 struct intel_hdmi_lpe_audio_port_pdata *ppdata = &pdata->port[ctx->port]; 1537 + int ret; 1541 1538 1542 - pm_runtime_get_sync(ctx->dev); 1539 + ret = pm_runtime_resume_and_get(ctx->dev); 1540 + if (ret < 0) 1541 + return; 1542 + 1543 1543 mutex_lock(&ctx->mutex); 1544 1544 if (ppdata->pipe < 0) { 1545 1545 dev_dbg(ctx->dev, "%s: Event: HAD_NOTIFY_HOT_UNPLUG : port = %d\n", ··· 1810 1802 pdata->notify_audio_lpe = notify_audio_lpe; 1811 1803 spin_unlock_irq(&pdata->lpe_audio_slock); 1812 1804 1805 + pm_runtime_set_autosuspend_delay(&pdev->dev, INTEL_HDMI_AUDIO_SUSPEND_DELAY_MS); 1813 1806 pm_runtime_use_autosuspend(&pdev->dev); 1807 + pm_runtime_enable(&pdev->dev); 1814 1808 pm_runtime_mark_last_busy(&pdev->dev); 1809 + pm_runtime_idle(&pdev->dev); 1815 1810 1816 1811 dev_dbg(&pdev->dev, "%s: handle pending notification\n", __func__); 1817 1812 for_each_port(card_ctx, port) {