aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci
diff options
context:
space:
mode:
authorTakashi Iwai <tiwai@suse.de>2015-04-13 04:23:18 -0400
committerTakashi Iwai <tiwai@suse.de>2015-04-13 04:23:18 -0400
commit9a4f35865ffcb2f4603375eadabe0d475fab1a0f (patch)
tree1465ac717deee029d3a9c1f7235ba85be57feefa /sound/pci
parenteef0342cf32689f77d78ee3302999e5caaa6a8f3 (diff)
parentc30cf8cbe55413cd643a0bdd3442d75950caa918 (diff)
Merge branch 'for-next' into for-linus
Diffstat (limited to 'sound/pci')
-rw-r--r--sound/pci/ac97/ac97_codec.c4
-rw-r--r--sound/pci/ac97/ac97_patch.c27
-rw-r--r--sound/pci/ad1889.c2
-rw-r--r--sound/pci/asihpi/asihpi.c2
-rw-r--r--sound/pci/atiixp.c2
-rw-r--r--sound/pci/azt3328.c7
-rw-r--r--sound/pci/cmipci.c2
-rw-r--r--sound/pci/cs5535audio/cs5535audio.c2
-rw-r--r--sound/pci/echoaudio/echoaudio.c16
-rw-r--r--sound/pci/emu10k1/emu10k1_main.c25
-rw-r--r--sound/pci/emu10k1/emu10k1_synth.c35
-rw-r--r--sound/pci/emu10k1/emumixer.c118
-rw-r--r--sound/pci/hda/Kconfig1
-rw-r--r--sound/pci/hda/Makefile3
-rw-r--r--sound/pci/hda/hda_auto_parser.c33
-rw-r--r--sound/pci/hda/hda_beep.c37
-rw-r--r--sound/pci/hda/hda_beep.h1
-rw-r--r--sound/pci/hda/hda_bind.c273
-rw-r--r--sound/pci/hda/hda_codec.c2289
-rw-r--r--sound/pci/hda/hda_codec.h288
-rw-r--r--sound/pci/hda/hda_controller.c269
-rw-r--r--sound/pci/hda/hda_controller.h397
-rw-r--r--sound/pci/hda/hda_generic.c599
-rw-r--r--sound/pci/hda/hda_generic.h9
-rw-r--r--sound/pci/hda/hda_hwdep.c5
-rw-r--r--sound/pci/hda/hda_i915.c2
-rw-r--r--sound/pci/hda/hda_intel.c99
-rw-r--r--sound/pci/hda/hda_intel.h2
-rw-r--r--sound/pci/hda/hda_jack.c8
-rw-r--r--sound/pci/hda/hda_local.h123
-rw-r--r--sound/pci/hda/hda_priv.h406
-rw-r--r--sound/pci/hda/hda_proc.c76
-rw-r--r--sound/pci/hda/hda_sysfs.c62
-rw-r--r--sound/pci/hda/hda_tegra.c50
-rw-r--r--sound/pci/hda/hda_trace.h143
-rw-r--r--sound/pci/hda/local.h39
-rw-r--r--sound/pci/hda/patch_analog.c34
-rw-r--r--sound/pci/hda/patch_ca0110.c16
-rw-r--r--sound/pci/hda/patch_ca0132.c68
-rw-r--r--sound/pci/hda/patch_cirrus.c16
-rw-r--r--sound/pci/hda/patch_cmedia.c16
-rw-r--r--sound/pci/hda/patch_conexant.c41
-rw-r--r--sound/pci/hda/patch_hdmi.c99
-rw-r--r--sound/pci/hda/patch_realtek.c293
-rw-r--r--sound/pci/hda/patch_si3054.c37
-rw-r--r--sound/pci/hda/patch_sigmatel.c138
-rw-r--r--sound/pci/hda/patch_via.c778
-rw-r--r--sound/pci/hda/thinkpad_helper.c2
-rw-r--r--sound/pci/ice1712/wtm.c172
-rw-r--r--sound/pci/intel8x0.c2
-rw-r--r--sound/pci/rme9652/hdspm.c141
-rw-r--r--sound/pci/via82xx.c2
52 files changed, 2887 insertions, 4424 deletions
diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index 5ee2f17c287c..82259ca61e64 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -177,6 +177,7 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = {
177{ 0x54524123, 0xffffffff, "TR28602", NULL, NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)] 177{ 0x54524123, 0xffffffff, "TR28602", NULL, NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
178{ 0x54584e03, 0xffffffff, "TLV320AIC27", NULL, NULL }, 178{ 0x54584e03, 0xffffffff, "TLV320AIC27", NULL, NULL },
179{ 0x54584e20, 0xffffffff, "TLC320AD9xC", NULL, NULL }, 179{ 0x54584e20, 0xffffffff, "TLC320AD9xC", NULL, NULL },
180{ 0x56494120, 0xfffffff0, "VIA1613", patch_vt1613, NULL },
180{ 0x56494161, 0xffffffff, "VIA1612A", NULL, NULL }, // modified ICE1232 with S/PDIF 181{ 0x56494161, 0xffffffff, "VIA1612A", NULL, NULL }, // modified ICE1232 with S/PDIF
181{ 0x56494170, 0xffffffff, "VIA1617A", patch_vt1617a, NULL }, // modified VT1616 with S/PDIF 182{ 0x56494170, 0xffffffff, "VIA1617A", patch_vt1617a, NULL }, // modified VT1616 with S/PDIF
182{ 0x56494182, 0xffffffff, "VIA1618", patch_vt1618, NULL }, 183{ 0x56494182, 0xffffffff, "VIA1618", patch_vt1618, NULL },
@@ -2901,7 +2902,8 @@ static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr)
2901 * Return: Zero if successful, or a negative error code on failure. 2902 * Return: Zero if successful, or a negative error code on failure.
2902 */ 2903 */
2903 2904
2904int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, const char *override) 2905int snd_ac97_tune_hardware(struct snd_ac97 *ac97,
2906 const struct ac97_quirk *quirk, const char *override)
2905{ 2907{
2906 int result; 2908 int result;
2907 2909
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
index ceaac1c41906..f4234edb878c 100644
--- a/sound/pci/ac97/ac97_patch.c
+++ b/sound/pci/ac97/ac97_patch.c
@@ -3352,6 +3352,33 @@ static int patch_cm9780(struct snd_ac97 *ac97)
3352} 3352}
3353 3353
3354/* 3354/*
3355 * VIA VT1613 codec
3356 */
3357static const struct snd_kcontrol_new snd_ac97_controls_vt1613[] = {
3358AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0),
3359};
3360
3361static int patch_vt1613_specific(struct snd_ac97 *ac97)
3362{
3363 return patch_build_controls(ac97, &snd_ac97_controls_vt1613[0],
3364 ARRAY_SIZE(snd_ac97_controls_vt1613));
3365};
3366
3367static const struct snd_ac97_build_ops patch_vt1613_ops = {
3368 .build_specific = patch_vt1613_specific
3369};
3370
3371static int patch_vt1613(struct snd_ac97 *ac97)
3372{
3373 ac97->build_ops = &patch_vt1613_ops;
3374
3375 ac97->flags |= AC97_HAS_NO_VIDEO;
3376 ac97->caps |= AC97_BC_HEADPHONE;
3377
3378 return 0;
3379}
3380
3381/*
3355 * VIA VT1616 codec 3382 * VIA VT1616 codec
3356 */ 3383 */
3357static const struct snd_kcontrol_new snd_ac97_controls_vt1616[] = { 3384static const struct snd_kcontrol_new snd_ac97_controls_vt1616[] = {
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 850a8c984c25..66ddd981d1d5 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -747,7 +747,7 @@ snd_ad1889_proc_init(struct snd_ad1889 *chip)
747 snd_info_set_text_ops(entry, chip, snd_ad1889_proc_read); 747 snd_info_set_text_ops(entry, chip, snd_ad1889_proc_read);
748} 748}
749 749
750static struct ac97_quirk ac97_quirks[] = { 750static const struct ac97_quirk ac97_quirks[] = {
751 { 751 {
752 .subvendor = 0x11d4, /* AD */ 752 .subvendor = 0x11d4, /* AD */
753 .subdevice = 0x1889, /* AD1889 */ 753 .subdevice = 0x1889, /* AD1889 */
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index e5cd7be85355..1039eccbb895 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -2376,7 +2376,7 @@ static int snd_asihpi_cmode_add(struct snd_card_asihpi *asihpi,
2376/*------------------------------------------------------------ 2376/*------------------------------------------------------------
2377 Sampleclock source controls 2377 Sampleclock source controls
2378 ------------------------------------------------------------*/ 2378 ------------------------------------------------------------*/
2379static const char const *sampleclock_sources[] = { 2379static const char * const sampleclock_sources[] = {
2380 "N/A", "Local PLL", "Digital Sync", "Word External", "Word Header", 2380 "N/A", "Local PLL", "Digital Sync", "Word External", "Word Header",
2381 "SMPTE", "Digital1", "Auto", "Network", "Invalid", 2381 "SMPTE", "Digital1", "Auto", "Network", "Invalid",
2382 "Prev Module", "BLU-Link", 2382 "Prev Module", "BLU-Link",
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index d5f15c9bbeda..42a20c806b39 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -1390,7 +1390,7 @@ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
1390 * ac97 mixer section 1390 * ac97 mixer section
1391 */ 1391 */
1392 1392
1393static struct ac97_quirk ac97_quirks[] = { 1393static const struct ac97_quirk ac97_quirks[] = {
1394 { 1394 {
1395 .subvendor = 0x103c, 1395 .subvendor = 0x103c,
1396 .subdevice = 0x006b, 1396 .subdevice = 0x006b,
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index a40a2b4c8fd7..33b2a0af1b59 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -1385,8 +1385,8 @@ snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
1385 .running) 1385 .running)
1386 && (!chip->codecs[peer_codecs[codec_type].other2] 1386 && (!chip->codecs[peer_codecs[codec_type].other2]
1387 .running)); 1387 .running));
1388 } 1388 }
1389 if (call_function) 1389 if (call_function)
1390 snd_azf3328_ctrl_enable_codecs(chip, enable); 1390 snd_azf3328_ctrl_enable_codecs(chip, enable);
1391 1391
1392 /* ...and adjust clock, too 1392 /* ...and adjust clock, too
@@ -2126,7 +2126,8 @@ static struct snd_pcm_ops snd_azf3328_i2s_out_ops = {
2126static int 2126static int
2127snd_azf3328_pcm(struct snd_azf3328 *chip) 2127snd_azf3328_pcm(struct snd_azf3328 *chip)
2128{ 2128{
2129enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */ 2129 /* pcm devices */
2130 enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS };
2130 2131
2131 struct snd_pcm *pcm; 2132 struct snd_pcm *pcm;
2132 int err; 2133 int err;
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 1d0f2cad2f5a..6cf464d9043d 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -2062,7 +2062,7 @@ static int snd_cmipci_get_volume(struct snd_kcontrol *kcontrol,
2062 val = (snd_cmipci_mixer_read(cm, reg.right_reg) >> reg.right_shift) & reg.mask; 2062 val = (snd_cmipci_mixer_read(cm, reg.right_reg) >> reg.right_shift) & reg.mask;
2063 if (reg.invert) 2063 if (reg.invert)
2064 val = reg.mask - val; 2064 val = reg.mask - val;
2065 ucontrol->value.integer.value[1] = val; 2065 ucontrol->value.integer.value[1] = val;
2066 } 2066 }
2067 spin_unlock_irq(&cm->reg_lock); 2067 spin_unlock_irq(&cm->reg_lock);
2068 return 0; 2068 return 0;
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 802c33f1cc59..963b912550d4 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -43,7 +43,7 @@ static char *ac97_quirk;
43module_param(ac97_quirk, charp, 0444); 43module_param(ac97_quirk, charp, 0444);
44MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds."); 44MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");
45 45
46static struct ac97_quirk ac97_quirks[] = { 46static const struct ac97_quirk ac97_quirks[] = {
47#if 0 /* Not yet confirmed if all 5536 boards are HP only */ 47#if 0 /* Not yet confirmed if all 5536 boards are HP only */
48 { 48 {
49 .subvendor = PCI_VENDOR_ID_AMD, 49 .subvendor = PCI_VENDOR_ID_AMD,
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index a962de03ebb6..862db9a0b041 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -1283,12 +1283,14 @@ static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1283static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol, 1283static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1284 struct snd_ctl_elem_value *ucontrol) 1284 struct snd_ctl_elem_value *ucontrol)
1285{ 1285{
1286 struct echoaudio *chip; 1286 struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1287 unsigned int out = ucontrol->id.index / num_busses_in(chip);
1288 unsigned int in = ucontrol->id.index % num_busses_in(chip);
1287 1289
1288 chip = snd_kcontrol_chip(kcontrol); 1290 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1289 ucontrol->value.integer.value[0] = 1291 return -EINVAL;
1290 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)] 1292
1291 [ucontrol->id.index % num_busses_in(chip)]; 1293 ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
1292 return 0; 1294 return 0;
1293} 1295}
1294 1296
@@ -1297,12 +1299,14 @@ static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1297{ 1299{
1298 struct echoaudio *chip; 1300 struct echoaudio *chip;
1299 int changed, gain; 1301 int changed, gain;
1300 short out, in; 1302 unsigned int out, in;
1301 1303
1302 changed = 0; 1304 changed = 0;
1303 chip = snd_kcontrol_chip(kcontrol); 1305 chip = snd_kcontrol_chip(kcontrol);
1304 out = ucontrol->id.index / num_busses_in(chip); 1306 out = ucontrol->id.index / num_busses_in(chip);
1305 in = ucontrol->id.index % num_busses_in(chip); 1307 in = ucontrol->id.index % num_busses_in(chip);
1308 if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1309 return -EINVAL;
1306 gain = ucontrol->value.integer.value[0]; 1310 gain = ucontrol->value.integer.value[0];
1307 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT) 1311 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1308 return -EINVAL; 1312 return -EINVAL;
diff --git a/sound/pci/emu10k1/emu10k1_main.c b/sound/pci/emu10k1/emu10k1_main.c
index b4458a630a7c..54079f5d5673 100644
--- a/sound/pci/emu10k1/emu10k1_main.c
+++ b/sound/pci/emu10k1/emu10k1_main.c
@@ -707,6 +707,7 @@ static int emu1010_firmware_thread(void *data)
707{ 707{
708 struct snd_emu10k1 *emu = data; 708 struct snd_emu10k1 *emu = data;
709 u32 tmp, tmp2, reg; 709 u32 tmp, tmp2, reg;
710 u32 last_reg = 0;
710 int err; 711 int err;
711 712
712 for (;;) { 713 for (;;) {
@@ -782,7 +783,15 @@ static int emu1010_firmware_thread(void *data)
782 msleep(10); 783 msleep(10);
783 /* Unmute all. Default is muted after a firmware load */ 784 /* Unmute all. Default is muted after a firmware load */
784 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE); 785 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE);
786 } else if (!reg && last_reg) {
787 /* Audio Dock removed */
788 dev_info(emu->card->dev,
789 "emu1010: Audio Dock detached\n");
790 /* Unmute all */
791 snd_emu1010_fpga_write(emu, EMU_HANA_UNMUTE, EMU_UNMUTE);
785 } 792 }
793
794 last_reg = reg;
786 } 795 }
787 dev_info(emu->card->dev, "emu1010: firmware thread stopping\n"); 796 dev_info(emu->card->dev, "emu1010: firmware thread stopping\n");
788 return 0; 797 return 0;
@@ -1325,6 +1334,22 @@ static int snd_emu10k1_dev_free(struct snd_device *device)
1325} 1334}
1326 1335
1327static struct snd_emu_chip_details emu_chip_details[] = { 1336static struct snd_emu_chip_details emu_chip_details[] = {
1337 /* Audigy 5/Rx SB1550 */
1338 /* Tested by michael@gernoth.net 28 Mar 2015 */
1339 /* DSP: CA10300-IAT LF
1340 * DAC: Cirrus Logic CS4382-KQZ
1341 * ADC: Philips 1361T
1342 * AC97: Sigmatel STAC9750
1343 * CA0151: None
1344 */
1345 {.vendor = 0x1102, .device = 0x0008, .subsystem = 0x10241102,
1346 .driver = "Audigy2", .name = "SB Audigy 5/Rx [SB1550]",
1347 .id = "Audigy2",
1348 .emu10k2_chip = 1,
1349 .ca0108_chip = 1,
1350 .spk71 = 1,
1351 .adc_1361t = 1, /* 24 bit capture instead of 16bit */
1352 .ac97_chip = 1},
1328 /* Audigy4 (Not PRO) SB0610 */ 1353 /* Audigy4 (Not PRO) SB0610 */
1329 /* Tested by James@superbug.co.uk 4th April 2006 */ 1354 /* Tested by James@superbug.co.uk 4th April 2006 */
1330 /* A_IOCFG bits 1355 /* A_IOCFG bits
diff --git a/sound/pci/emu10k1/emu10k1_synth.c b/sound/pci/emu10k1/emu10k1_synth.c
index 4c41c903a840..5457d5613f6b 100644
--- a/sound/pci/emu10k1/emu10k1_synth.c
+++ b/sound/pci/emu10k1/emu10k1_synth.c
@@ -29,8 +29,9 @@ MODULE_LICENSE("GPL");
29/* 29/*
30 * create a new hardware dependent device for Emu10k1 30 * create a new hardware dependent device for Emu10k1
31 */ 31 */
32static int snd_emu10k1_synth_new_device(struct snd_seq_device *dev) 32static int snd_emu10k1_synth_probe(struct device *_dev)
33{ 33{
34 struct snd_seq_device *dev = to_seq_dev(_dev);
34 struct snd_emux *emux; 35 struct snd_emux *emux;
35 struct snd_emu10k1 *hw; 36 struct snd_emu10k1 *hw;
36 struct snd_emu10k1_synth_arg *arg; 37 struct snd_emu10k1_synth_arg *arg;
@@ -79,8 +80,9 @@ static int snd_emu10k1_synth_new_device(struct snd_seq_device *dev)
79 return 0; 80 return 0;
80} 81}
81 82
82static int snd_emu10k1_synth_delete_device(struct snd_seq_device *dev) 83static int snd_emu10k1_synth_remove(struct device *_dev)
83{ 84{
85 struct snd_seq_device *dev = to_seq_dev(_dev);
84 struct snd_emux *emux; 86 struct snd_emux *emux;
85 struct snd_emu10k1 *hw; 87 struct snd_emu10k1 *hw;
86 unsigned long flags; 88 unsigned long flags;
@@ -104,21 +106,14 @@ static int snd_emu10k1_synth_delete_device(struct snd_seq_device *dev)
104 * INIT part 106 * INIT part
105 */ 107 */
106 108
107static int __init alsa_emu10k1_synth_init(void) 109static struct snd_seq_driver emu10k1_synth_driver = {
108{ 110 .driver = {
109 111 .name = KBUILD_MODNAME,
110 static struct snd_seq_dev_ops ops = { 112 .probe = snd_emu10k1_synth_probe,
111 snd_emu10k1_synth_new_device, 113 .remove = snd_emu10k1_synth_remove,
112 snd_emu10k1_synth_delete_device, 114 },
113 }; 115 .id = SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
114 return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH, &ops, 116 .argsize = sizeof(struct snd_emu10k1_synth_arg),
115 sizeof(struct snd_emu10k1_synth_arg)); 117};
116} 118
117 119module_snd_seq_driver(emu10k1_synth_driver);
118static void __exit alsa_emu10k1_synth_exit(void)
119{
120 snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH);
121}
122
123module_init(alsa_emu10k1_synth_init)
124module_exit(alsa_emu10k1_synth_exit)
diff --git a/sound/pci/emu10k1/emumixer.c b/sound/pci/emu10k1/emumixer.c
index 1de33025669a..55e57166256e 100644
--- a/sound/pci/emu10k1/emumixer.c
+++ b/sound/pci/emu10k1/emumixer.c
@@ -806,6 +806,108 @@ static struct snd_kcontrol_new snd_emu1010_internal_clock =
806 .put = snd_emu1010_internal_clock_put 806 .put = snd_emu1010_internal_clock_put
807}; 807};
808 808
809static int snd_emu1010_optical_out_info(struct snd_kcontrol *kcontrol,
810 struct snd_ctl_elem_info *uinfo)
811{
812 static const char * const texts[2] = {
813 "SPDIF", "ADAT"
814 };
815
816 return snd_ctl_enum_info(uinfo, 1, 2, texts);
817}
818
819static int snd_emu1010_optical_out_get(struct snd_kcontrol *kcontrol,
820 struct snd_ctl_elem_value *ucontrol)
821{
822 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
823
824 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_out;
825 return 0;
826}
827
828static int snd_emu1010_optical_out_put(struct snd_kcontrol *kcontrol,
829 struct snd_ctl_elem_value *ucontrol)
830{
831 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
832 unsigned int val;
833 u32 tmp;
834 int change = 0;
835
836 val = ucontrol->value.enumerated.item[0];
837 /* Limit: uinfo->value.enumerated.items = 2; */
838 if (val >= 2)
839 return -EINVAL;
840 change = (emu->emu1010.optical_out != val);
841 if (change) {
842 emu->emu1010.optical_out = val;
843 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : 0) |
844 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : 0);
845 snd_emu1010_fpga_write(emu, EMU_HANA_OPTICAL_TYPE, tmp);
846 }
847 return change;
848}
849
850static struct snd_kcontrol_new snd_emu1010_optical_out = {
851 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
852 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
853 .name = "Optical Output Mode",
854 .count = 1,
855 .info = snd_emu1010_optical_out_info,
856 .get = snd_emu1010_optical_out_get,
857 .put = snd_emu1010_optical_out_put
858};
859
860static int snd_emu1010_optical_in_info(struct snd_kcontrol *kcontrol,
861 struct snd_ctl_elem_info *uinfo)
862{
863 static const char * const texts[2] = {
864 "SPDIF", "ADAT"
865 };
866
867 return snd_ctl_enum_info(uinfo, 1, 2, texts);
868}
869
870static int snd_emu1010_optical_in_get(struct snd_kcontrol *kcontrol,
871 struct snd_ctl_elem_value *ucontrol)
872{
873 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
874
875 ucontrol->value.enumerated.item[0] = emu->emu1010.optical_in;
876 return 0;
877}
878
879static int snd_emu1010_optical_in_put(struct snd_kcontrol *kcontrol,
880 struct snd_ctl_elem_value *ucontrol)
881{
882 struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
883 unsigned int val;
884 u32 tmp;
885 int change = 0;
886
887 val = ucontrol->value.enumerated.item[0];
888 /* Limit: uinfo->value.enumerated.items = 2; */
889 if (val >= 2)
890 return -EINVAL;
891 change = (emu->emu1010.optical_in != val);
892 if (change) {
893 emu->emu1010.optical_in = val;
894 tmp = (emu->emu1010.optical_in ? EMU_HANA_OPTICAL_IN_ADAT : 0) |
895 (emu->emu1010.optical_out ? EMU_HANA_OPTICAL_OUT_ADAT : 0);
896 snd_emu1010_fpga_write(emu, EMU_HANA_OPTICAL_TYPE, tmp);
897 }
898 return change;
899}
900
901static struct snd_kcontrol_new snd_emu1010_optical_in = {
902 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
903 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
904 .name = "Optical Input Mode",
905 .count = 1,
906 .info = snd_emu1010_optical_in_info,
907 .get = snd_emu1010_optical_in_get,
908 .put = snd_emu1010_optical_in_put
909};
910
809static int snd_audigy_i2c_capture_source_info(struct snd_kcontrol *kcontrol, 911static int snd_audigy_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
810 struct snd_ctl_elem_info *uinfo) 912 struct snd_ctl_elem_info *uinfo)
811{ 913{
@@ -2051,6 +2153,14 @@ int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
2051 snd_ctl_new1(&snd_emu1010_internal_clock, emu)); 2153 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2052 if (err < 0) 2154 if (err < 0)
2053 return err; 2155 return err;
2156 err = snd_ctl_add(card,
2157 snd_ctl_new1(&snd_emu1010_optical_out, emu));
2158 if (err < 0)
2159 return err;
2160 err = snd_ctl_add(card,
2161 snd_ctl_new1(&snd_emu1010_optical_in, emu));
2162 if (err < 0)
2163 return err;
2054 2164
2055 } else if (emu->card_capabilities->emu_model) { 2165 } else if (emu->card_capabilities->emu_model) {
2056 /* all other e-mu cards for now */ 2166 /* all other e-mu cards for now */
@@ -2086,6 +2196,14 @@ int snd_emu10k1_mixer(struct snd_emu10k1 *emu,
2086 snd_ctl_new1(&snd_emu1010_internal_clock, emu)); 2196 snd_ctl_new1(&snd_emu1010_internal_clock, emu));
2087 if (err < 0) 2197 if (err < 0)
2088 return err; 2198 return err;
2199 err = snd_ctl_add(card,
2200 snd_ctl_new1(&snd_emu1010_optical_out, emu));
2201 if (err < 0)
2202 return err;
2203 err = snd_ctl_add(card,
2204 snd_ctl_new1(&snd_emu1010_optical_in, emu));
2205 if (err < 0)
2206 return err;
2089 } 2207 }
2090 2208
2091 if ( emu->card_capabilities->i2c_adc) { 2209 if ( emu->card_capabilities->i2c_adc) {
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index 7f0f2c5a4e97..a5ed1c181784 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -5,6 +5,7 @@ config SND_HDA
5 select SND_PCM 5 select SND_PCM
6 select SND_VMASTER 6 select SND_VMASTER
7 select SND_KCTL_JACK 7 select SND_KCTL_JACK
8 select SND_HDA_CORE
8 9
9config SND_HDA_INTEL 10config SND_HDA_INTEL
10 tristate "HD Audio PCI" 11 tristate "HD Audio PCI"
diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
index 194f30935e77..af78fb33a4fd 100644
--- a/sound/pci/hda/Makefile
+++ b/sound/pci/hda/Makefile
@@ -4,13 +4,12 @@ snd-hda-tegra-objs := hda_tegra.o
4# for haswell power well 4# for haswell power well
5snd-hda-intel-$(CONFIG_SND_HDA_I915) += hda_i915.o 5snd-hda-intel-$(CONFIG_SND_HDA_I915) += hda_i915.o
6 6
7snd-hda-codec-y := hda_codec.o hda_jack.o hda_auto_parser.o hda_sysfs.o 7snd-hda-codec-y := hda_bind.o hda_codec.o hda_jack.o hda_auto_parser.o hda_sysfs.o
8snd-hda-codec-$(CONFIG_PROC_FS) += hda_proc.o 8snd-hda-codec-$(CONFIG_PROC_FS) += hda_proc.o
9snd-hda-codec-$(CONFIG_SND_HDA_HWDEP) += hda_hwdep.o 9snd-hda-codec-$(CONFIG_SND_HDA_HWDEP) += hda_hwdep.o
10snd-hda-codec-$(CONFIG_SND_HDA_INPUT_BEEP) += hda_beep.o 10snd-hda-codec-$(CONFIG_SND_HDA_INPUT_BEEP) += hda_beep.o
11 11
12# for trace-points 12# for trace-points
13CFLAGS_hda_codec.o := -I$(src)
14CFLAGS_hda_controller.o := -I$(src) 13CFLAGS_hda_controller.o := -I$(src)
15 14
16snd-hda-codec-generic-objs := hda_generic.o 15snd-hda-codec-generic-objs := hda_generic.o
diff --git a/sound/pci/hda/hda_auto_parser.c b/sound/pci/hda/hda_auto_parser.c
index 3f8706bb3d16..03b7399bb7f0 100644
--- a/sound/pci/hda/hda_auto_parser.c
+++ b/sound/pci/hda/hda_auto_parser.c
@@ -172,7 +172,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
172 const hda_nid_t *ignore_nids, 172 const hda_nid_t *ignore_nids,
173 unsigned int cond_flags) 173 unsigned int cond_flags)
174{ 174{
175 hda_nid_t nid, end_nid; 175 hda_nid_t nid;
176 short seq, assoc_line_out; 176 short seq, assoc_line_out;
177 struct auto_out_pin line_out[ARRAY_SIZE(cfg->line_out_pins)]; 177 struct auto_out_pin line_out[ARRAY_SIZE(cfg->line_out_pins)];
178 struct auto_out_pin speaker_out[ARRAY_SIZE(cfg->speaker_pins)]; 178 struct auto_out_pin speaker_out[ARRAY_SIZE(cfg->speaker_pins)];
@@ -189,8 +189,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
189 memset(hp_out, 0, sizeof(hp_out)); 189 memset(hp_out, 0, sizeof(hp_out));
190 assoc_line_out = 0; 190 assoc_line_out = 0;
191 191
192 end_nid = codec->start_nid + codec->num_nodes; 192 for_each_hda_codec_node(nid, codec) {
193 for (nid = codec->start_nid; nid < end_nid; nid++) {
194 unsigned int wid_caps = get_wcaps(codec, nid); 193 unsigned int wid_caps = get_wcaps(codec, nid);
195 unsigned int wid_type = get_wcaps_type(wid_caps); 194 unsigned int wid_type = get_wcaps_type(wid_caps);
196 unsigned int def_conf; 195 unsigned int def_conf;
@@ -410,7 +409,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
410 * debug prints of the parsed results 409 * debug prints of the parsed results
411 */ 410 */
412 codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n", 411 codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
413 codec->chip_name, cfg->line_outs, cfg->line_out_pins[0], 412 codec->core.chip_name, cfg->line_outs, cfg->line_out_pins[0],
414 cfg->line_out_pins[1], cfg->line_out_pins[2], 413 cfg->line_out_pins[1], cfg->line_out_pins[2],
415 cfg->line_out_pins[3], cfg->line_out_pins[4], 414 cfg->line_out_pins[3], cfg->line_out_pins[4],
416 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" : 415 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
@@ -836,33 +835,33 @@ static void apply_fixup(struct hda_codec *codec, int id, int action, int depth)
836 if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins) 835 if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins)
837 break; 836 break;
838 codec_dbg(codec, "%s: Apply pincfg for %s\n", 837 codec_dbg(codec, "%s: Apply pincfg for %s\n",
839 codec->chip_name, modelname); 838 codec->core.chip_name, modelname);
840 snd_hda_apply_pincfgs(codec, fix->v.pins); 839 snd_hda_apply_pincfgs(codec, fix->v.pins);
841 break; 840 break;
842 case HDA_FIXUP_VERBS: 841 case HDA_FIXUP_VERBS:
843 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs) 842 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs)
844 break; 843 break;
845 codec_dbg(codec, "%s: Apply fix-verbs for %s\n", 844 codec_dbg(codec, "%s: Apply fix-verbs for %s\n",
846 codec->chip_name, modelname); 845 codec->core.chip_name, modelname);
847 snd_hda_add_verbs(codec, fix->v.verbs); 846 snd_hda_add_verbs(codec, fix->v.verbs);
848 break; 847 break;
849 case HDA_FIXUP_FUNC: 848 case HDA_FIXUP_FUNC:
850 if (!fix->v.func) 849 if (!fix->v.func)
851 break; 850 break;
852 codec_dbg(codec, "%s: Apply fix-func for %s\n", 851 codec_dbg(codec, "%s: Apply fix-func for %s\n",
853 codec->chip_name, modelname); 852 codec->core.chip_name, modelname);
854 fix->v.func(codec, fix, action); 853 fix->v.func(codec, fix, action);
855 break; 854 break;
856 case HDA_FIXUP_PINCTLS: 855 case HDA_FIXUP_PINCTLS:
857 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins) 856 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins)
858 break; 857 break;
859 codec_dbg(codec, "%s: Apply pinctl for %s\n", 858 codec_dbg(codec, "%s: Apply pinctl for %s\n",
860 codec->chip_name, modelname); 859 codec->core.chip_name, modelname);
861 set_pin_targets(codec, fix->v.pins); 860 set_pin_targets(codec, fix->v.pins);
862 break; 861 break;
863 default: 862 default:
864 codec_err(codec, "%s: Invalid fixup type %d\n", 863 codec_err(codec, "%s: Invalid fixup type %d\n",
865 codec->chip_name, fix->type); 864 codec->core.chip_name, fix->type);
866 break; 865 break;
867 } 866 }
868 if (!fix->chained || fix->chained_before) 867 if (!fix->chained || fix->chained_before)
@@ -912,16 +911,16 @@ void snd_hda_pick_pin_fixup(struct hda_codec *codec,
912 return; 911 return;
913 912
914 for (pq = pin_quirk; pq->subvendor; pq++) { 913 for (pq = pin_quirk; pq->subvendor; pq++) {
915 if ((codec->subsystem_id & 0xffff0000) != (pq->subvendor << 16)) 914 if ((codec->core.subsystem_id & 0xffff0000) != (pq->subvendor << 16))
916 continue; 915 continue;
917 if (codec->vendor_id != pq->codec) 916 if (codec->core.vendor_id != pq->codec)
918 continue; 917 continue;
919 if (pin_config_match(codec, pq->pins)) { 918 if (pin_config_match(codec, pq->pins)) {
920 codec->fixup_id = pq->value; 919 codec->fixup_id = pq->value;
921#ifdef CONFIG_SND_DEBUG_VERBOSE 920#ifdef CONFIG_SND_DEBUG_VERBOSE
922 codec->fixup_name = pq->name; 921 codec->fixup_name = pq->name;
923 codec_dbg(codec, "%s: picked fixup %s (pin match)\n", 922 codec_dbg(codec, "%s: picked fixup %s (pin match)\n",
924 codec->chip_name, codec->fixup_name); 923 codec->core.chip_name, codec->fixup_name);
925#endif 924#endif
926 codec->fixup_list = fixlist; 925 codec->fixup_list = fixlist;
927 return; 926 return;
@@ -963,7 +962,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
963 codec->fixup_name = NULL; 962 codec->fixup_name = NULL;
964 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP; 963 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
965 codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n", 964 codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
966 codec->chip_name); 965 codec->core.chip_name);
967 return; 966 return;
968 } 967 }
969 968
@@ -974,7 +973,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
974 codec->fixup_name = models->name; 973 codec->fixup_name = models->name;
975 codec->fixup_list = fixlist; 974 codec->fixup_list = fixlist;
976 codec_dbg(codec, "%s: picked fixup %s (model specified)\n", 975 codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
977 codec->chip_name, codec->fixup_name); 976 codec->core.chip_name, codec->fixup_name);
978 return; 977 return;
979 } 978 }
980 models++; 979 models++;
@@ -987,7 +986,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
987#ifdef CONFIG_SND_DEBUG_VERBOSE 986#ifdef CONFIG_SND_DEBUG_VERBOSE
988 name = q->name; 987 name = q->name;
989 codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n", 988 codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
990 codec->chip_name, name, q->subdevice_mask ? "" : " - vendor generic"); 989 codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
991#endif 990#endif
992 } 991 }
993 } 992 }
@@ -996,12 +995,12 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
996 unsigned int vendorid = 995 unsigned int vendorid =
997 q->subdevice | (q->subvendor << 16); 996 q->subdevice | (q->subvendor << 16);
998 unsigned int mask = 0xffff0000 | q->subdevice_mask; 997 unsigned int mask = 0xffff0000 | q->subdevice_mask;
999 if ((codec->subsystem_id & mask) == (vendorid & mask)) { 998 if ((codec->core.subsystem_id & mask) == (vendorid & mask)) {
1000 id = q->value; 999 id = q->value;
1001#ifdef CONFIG_SND_DEBUG_VERBOSE 1000#ifdef CONFIG_SND_DEBUG_VERBOSE
1002 name = q->name; 1001 name = q->name;
1003 codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n", 1002 codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
1004 codec->chip_name, name); 1003 codec->core.chip_name, name);
1005#endif 1004#endif
1006 break; 1005 break;
1007 } 1006 }
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 1e7de08e77cb..3364dc0fdeab 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -33,30 +33,36 @@ enum {
33 DIGBEEP_HZ_MAX = 12000000, /* 12 KHz */ 33 DIGBEEP_HZ_MAX = 12000000, /* 12 KHz */
34}; 34};
35 35
36static void snd_hda_generate_beep(struct work_struct *work) 36/* generate or stop tone */
37static void generate_tone(struct hda_beep *beep, int tone)
37{ 38{
38 struct hda_beep *beep =
39 container_of(work, struct hda_beep, beep_work);
40 struct hda_codec *codec = beep->codec; 39 struct hda_codec *codec = beep->codec;
41 int tone;
42 40
43 if (!beep->enabled)
44 return;
45
46 tone = beep->tone;
47 if (tone && !beep->playing) { 41 if (tone && !beep->playing) {
48 snd_hda_power_up(codec); 42 snd_hda_power_up(codec);
43 if (beep->power_hook)
44 beep->power_hook(beep, true);
49 beep->playing = 1; 45 beep->playing = 1;
50 } 46 }
51 /* generate tone */
52 snd_hda_codec_write(codec, beep->nid, 0, 47 snd_hda_codec_write(codec, beep->nid, 0,
53 AC_VERB_SET_BEEP_CONTROL, tone); 48 AC_VERB_SET_BEEP_CONTROL, tone);
54 if (!tone && beep->playing) { 49 if (!tone && beep->playing) {
55 beep->playing = 0; 50 beep->playing = 0;
51 if (beep->power_hook)
52 beep->power_hook(beep, false);
56 snd_hda_power_down(codec); 53 snd_hda_power_down(codec);
57 } 54 }
58} 55}
59 56
57static void snd_hda_generate_beep(struct work_struct *work)
58{
59 struct hda_beep *beep =
60 container_of(work, struct hda_beep, beep_work);
61
62 if (beep->enabled)
63 generate_tone(beep, beep->tone);
64}
65
60/* (non-standard) Linear beep tone calculation for IDT/STAC codecs 66/* (non-standard) Linear beep tone calculation for IDT/STAC codecs
61 * 67 *
62 * The tone frequency of beep generator on IDT/STAC codecs is 68 * The tone frequency of beep generator on IDT/STAC codecs is
@@ -130,10 +136,7 @@ static void turn_off_beep(struct hda_beep *beep)
130 cancel_work_sync(&beep->beep_work); 136 cancel_work_sync(&beep->beep_work);
131 if (beep->playing) { 137 if (beep->playing) {
132 /* turn off beep */ 138 /* turn off beep */
133 snd_hda_codec_write(beep->codec, beep->nid, 0, 139 generate_tone(beep, 0);
134 AC_VERB_SET_BEEP_CONTROL, 0);
135 beep->playing = 0;
136 snd_hda_power_down(beep->codec);
137 } 140 }
138} 141}
139 142
@@ -160,15 +163,15 @@ static int snd_hda_do_attach(struct hda_beep *beep)
160 input_dev->name = "HDA Digital PCBeep"; 163 input_dev->name = "HDA Digital PCBeep";
161 input_dev->phys = beep->phys; 164 input_dev->phys = beep->phys;
162 input_dev->id.bustype = BUS_PCI; 165 input_dev->id.bustype = BUS_PCI;
166 input_dev->dev.parent = &codec->card->card_dev;
163 167
164 input_dev->id.vendor = codec->vendor_id >> 16; 168 input_dev->id.vendor = codec->core.vendor_id >> 16;
165 input_dev->id.product = codec->vendor_id & 0xffff; 169 input_dev->id.product = codec->core.vendor_id & 0xffff;
166 input_dev->id.version = 0x01; 170 input_dev->id.version = 0x01;
167 171
168 input_dev->evbit[0] = BIT_MASK(EV_SND); 172 input_dev->evbit[0] = BIT_MASK(EV_SND);
169 input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE); 173 input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
170 input_dev->event = snd_hda_beep_event; 174 input_dev->event = snd_hda_beep_event;
171 input_dev->dev.parent = &codec->dev;
172 input_set_drvdata(input_dev, beep); 175 input_set_drvdata(input_dev, beep);
173 176
174 beep->dev = input_dev; 177 beep->dev = input_dev;
@@ -224,7 +227,7 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
224 if (beep == NULL) 227 if (beep == NULL)
225 return -ENOMEM; 228 return -ENOMEM;
226 snprintf(beep->phys, sizeof(beep->phys), 229 snprintf(beep->phys, sizeof(beep->phys),
227 "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr); 230 "card%d/codec#%d/beep0", codec->card->number, codec->addr);
228 /* enable linear scale */ 231 /* enable linear scale */
229 snd_hda_codec_write_cache(codec, nid, 0, 232 snd_hda_codec_write_cache(codec, nid, 0,
230 AC_VERB_SET_DIGI_CONVERT_2, 0x01); 233 AC_VERB_SET_DIGI_CONVERT_2, 0x01);
diff --git a/sound/pci/hda/hda_beep.h b/sound/pci/hda/hda_beep.h
index a63b5e077332..46524ff7e79e 100644
--- a/sound/pci/hda/hda_beep.h
+++ b/sound/pci/hda/hda_beep.h
@@ -40,6 +40,7 @@ struct hda_beep {
40 unsigned int playing:1; 40 unsigned int playing:1;
41 struct work_struct beep_work; /* scheduled task for beep event */ 41 struct work_struct beep_work; /* scheduled task for beep event */
42 struct mutex mutex; 42 struct mutex mutex;
43 void (*power_hook)(struct hda_beep *beep, bool on);
43}; 44};
44 45
45#ifdef CONFIG_SND_HDA_INPUT_BEEP 46#ifdef CONFIG_SND_HDA_INPUT_BEEP
diff --git a/sound/pci/hda/hda_bind.c b/sound/pci/hda/hda_bind.c
new file mode 100644
index 000000000000..00aa31c5f08e
--- /dev/null
+++ b/sound/pci/hda/hda_bind.c
@@ -0,0 +1,273 @@
1/*
2 * HD-audio codec driver binding
3 * Copyright (c) Takashi Iwai <tiwai@suse.de>
4 */
5
6#include <linux/init.h>
7#include <linux/slab.h>
8#include <linux/mutex.h>
9#include <linux/module.h>
10#include <linux/export.h>
11#include <linux/pm.h>
12#include <linux/pm_runtime.h>
13#include <sound/core.h>
14#include "hda_codec.h"
15#include "hda_local.h"
16
17/*
18 * find a matching codec preset
19 */
20static int hda_codec_match(struct hdac_device *dev, struct hdac_driver *drv)
21{
22 struct hda_codec *codec = container_of(dev, struct hda_codec, core);
23 struct hda_codec_driver *driver =
24 container_of(drv, struct hda_codec_driver, core);
25 const struct hda_codec_preset *preset;
26 /* check probe_id instead of vendor_id if set */
27 u32 id = codec->probe_id ? codec->probe_id : codec->core.vendor_id;
28
29 for (preset = driver->preset; preset->id; preset++) {
30 u32 mask = preset->mask;
31
32 if (preset->afg && preset->afg != codec->core.afg)
33 continue;
34 if (preset->mfg && preset->mfg != codec->core.mfg)
35 continue;
36 if (!mask)
37 mask = ~0;
38 if (preset->id == (id & mask) &&
39 (!preset->rev || preset->rev == codec->core.revision_id)) {
40 codec->preset = preset;
41 return 1;
42 }
43 }
44 return 0;
45}
46
47/* process an unsolicited event */
48static void hda_codec_unsol_event(struct hdac_device *dev, unsigned int ev)
49{
50 struct hda_codec *codec = container_of(dev, struct hda_codec, core);
51
52 if (codec->patch_ops.unsol_event)
53 codec->patch_ops.unsol_event(codec, ev);
54}
55
56/* reset the codec name from the preset */
57static int codec_refresh_name(struct hda_codec *codec, const char *name)
58{
59 if (name) {
60 kfree(codec->core.chip_name);
61 codec->core.chip_name = kstrdup(name, GFP_KERNEL);
62 }
63 return codec->core.chip_name ? 0 : -ENOMEM;
64}
65
66static int hda_codec_driver_probe(struct device *dev)
67{
68 struct hda_codec *codec = dev_to_hda_codec(dev);
69 struct module *owner = dev->driver->owner;
70 int err;
71
72 if (WARN_ON(!codec->preset))
73 return -EINVAL;
74
75 err = codec_refresh_name(codec, codec->preset->name);
76 if (err < 0)
77 goto error;
78 err = snd_hdac_regmap_init(&codec->core);
79 if (err < 0)
80 goto error;
81
82 if (!try_module_get(owner)) {
83 err = -EINVAL;
84 goto error;
85 }
86
87 err = codec->preset->patch(codec);
88 if (err < 0)
89 goto error_module;
90
91 err = snd_hda_codec_build_pcms(codec);
92 if (err < 0)
93 goto error_module;
94 err = snd_hda_codec_build_controls(codec);
95 if (err < 0)
96 goto error_module;
97 if (codec->card->registered) {
98 err = snd_card_register(codec->card);
99 if (err < 0)
100 goto error_module;
101 snd_hda_codec_register(codec);
102 }
103
104 codec->core.lazy_cache = true;
105 return 0;
106
107 error_module:
108 module_put(owner);
109
110 error:
111 snd_hda_codec_cleanup_for_unbind(codec);
112 return err;
113}
114
115static int hda_codec_driver_remove(struct device *dev)
116{
117 struct hda_codec *codec = dev_to_hda_codec(dev);
118
119 if (codec->patch_ops.free)
120 codec->patch_ops.free(codec);
121 snd_hda_codec_cleanup_for_unbind(codec);
122 module_put(dev->driver->owner);
123 return 0;
124}
125
126static void hda_codec_driver_shutdown(struct device *dev)
127{
128 struct hda_codec *codec = dev_to_hda_codec(dev);
129
130 if (!pm_runtime_suspended(dev) && codec->patch_ops.reboot_notify)
131 codec->patch_ops.reboot_notify(codec);
132}
133
134int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name,
135 struct module *owner)
136{
137 drv->core.driver.name = name;
138 drv->core.driver.owner = owner;
139 drv->core.driver.bus = &snd_hda_bus_type;
140 drv->core.driver.probe = hda_codec_driver_probe;
141 drv->core.driver.remove = hda_codec_driver_remove;
142 drv->core.driver.shutdown = hda_codec_driver_shutdown;
143 drv->core.driver.pm = &hda_codec_driver_pm;
144 drv->core.type = HDA_DEV_LEGACY;
145 drv->core.match = hda_codec_match;
146 drv->core.unsol_event = hda_codec_unsol_event;
147 return driver_register(&drv->core.driver);
148}
149EXPORT_SYMBOL_GPL(__hda_codec_driver_register);
150
151void hda_codec_driver_unregister(struct hda_codec_driver *drv)
152{
153 driver_unregister(&drv->core.driver);
154}
155EXPORT_SYMBOL_GPL(hda_codec_driver_unregister);
156
157static inline bool codec_probed(struct hda_codec *codec)
158{
159 return device_attach(hda_codec_dev(codec)) > 0 && codec->preset;
160}
161
162/* try to auto-load and bind the codec module */
163static void codec_bind_module(struct hda_codec *codec)
164{
165#ifdef MODULE
166 request_module("snd-hda-codec-id:%08x", codec->core.vendor_id);
167 if (codec_probed(codec))
168 return;
169 request_module("snd-hda-codec-id:%04x*",
170 (codec->core.vendor_id >> 16) & 0xffff);
171 if (codec_probed(codec))
172 return;
173#endif
174}
175
176#if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
177/* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
178static bool is_likely_hdmi_codec(struct hda_codec *codec)
179{
180 hda_nid_t nid;
181
182 for_each_hda_codec_node(nid, codec) {
183 unsigned int wcaps = get_wcaps(codec, nid);
184 switch (get_wcaps_type(wcaps)) {
185 case AC_WID_AUD_IN:
186 return false; /* HDMI parser supports only HDMI out */
187 case AC_WID_AUD_OUT:
188 if (!(wcaps & AC_WCAP_DIGITAL))
189 return false;
190 break;
191 }
192 }
193 return true;
194}
195#else
196/* no HDMI codec parser support */
197#define is_likely_hdmi_codec(codec) false
198#endif /* CONFIG_SND_HDA_CODEC_HDMI */
199
200static int codec_bind_generic(struct hda_codec *codec)
201{
202 if (codec->probe_id)
203 return -ENODEV;
204
205 if (is_likely_hdmi_codec(codec)) {
206 codec->probe_id = HDA_CODEC_ID_GENERIC_HDMI;
207#if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
208 request_module("snd-hda-codec-hdmi");
209#endif
210 if (codec_probed(codec))
211 return 0;
212 }
213
214 codec->probe_id = HDA_CODEC_ID_GENERIC;
215#if IS_MODULE(CONFIG_SND_HDA_GENERIC)
216 request_module("snd-hda-codec-generic");
217#endif
218 if (codec_probed(codec))
219 return 0;
220 return -ENODEV;
221}
222
223#if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
224#define is_generic_config(codec) \
225 (codec->modelname && !strcmp(codec->modelname, "generic"))
226#else
227#define is_generic_config(codec) 0
228#endif
229
230/**
231 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
232 * @codec: the HDA codec
233 *
234 * Start parsing of the given codec tree and (re-)initialize the whole
235 * patch instance.
236 *
237 * Returns 0 if successful or a negative error code.
238 */
239int snd_hda_codec_configure(struct hda_codec *codec)
240{
241 int err;
242
243 if (is_generic_config(codec))
244 codec->probe_id = HDA_CODEC_ID_GENERIC;
245 else
246 codec->probe_id = 0;
247
248 err = snd_hdac_device_register(&codec->core);
249 if (err < 0)
250 return err;
251
252 if (!codec->preset)
253 codec_bind_module(codec);
254 if (!codec->preset) {
255 err = codec_bind_generic(codec);
256 if (err < 0) {
257 codec_err(codec, "Unable to bind the codec\n");
258 goto error;
259 }
260 }
261
262 /* audio codec should override the mixer name */
263 if (codec->core.afg || !*codec->card->mixername)
264 snprintf(codec->card->mixername,
265 sizeof(codec->card->mixername), "%s %s",
266 codec->core.vendor_name, codec->core.chip_name);
267 return 0;
268
269 error:
270 snd_hdac_device_unregister(&codec->core);
271 return err;
272}
273EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 2fe86d2e1b09..e70a7fb393dd 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -26,6 +26,8 @@
26#include <linux/mutex.h> 26#include <linux/mutex.h>
27#include <linux/module.h> 27#include <linux/module.h>
28#include <linux/async.h> 28#include <linux/async.h>
29#include <linux/pm.h>
30#include <linux/pm_runtime.h>
29#include <sound/core.h> 31#include <sound/core.h>
30#include "hda_codec.h" 32#include "hda_codec.h"
31#include <sound/asoundef.h> 33#include <sound/asoundef.h>
@@ -37,97 +39,20 @@
37#include "hda_jack.h" 39#include "hda_jack.h"
38#include <sound/hda_hwdep.h> 40#include <sound/hda_hwdep.h>
39 41
40#define CREATE_TRACE_POINTS
41#include "hda_trace.h"
42
43/*
44 * vendor / preset table
45 */
46
47struct hda_vendor_id {
48 unsigned int id;
49 const char *name;
50};
51
52/* codec vendor labels */
53static struct hda_vendor_id hda_vendor_ids[] = {
54 { 0x1002, "ATI" },
55 { 0x1013, "Cirrus Logic" },
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
58 { 0x10de, "Nvidia" },
59 { 0x10ec, "Realtek" },
60 { 0x1102, "Creative" },
61 { 0x1106, "VIA" },
62 { 0x111d, "IDT" },
63 { 0x11c1, "LSI" },
64 { 0x11d4, "Analog Devices" },
65 { 0x13f6, "C-Media" },
66 { 0x14f1, "Conexant" },
67 { 0x17e8, "Chrontel" },
68 { 0x1854, "LG" },
69 { 0x1aec, "Wolfson Microelectronics" },
70 { 0x1af4, "QEMU" },
71 { 0x434d, "C-Media" },
72 { 0x8086, "Intel" },
73 { 0x8384, "SigmaTel" },
74 {} /* terminator */
75};
76
77static DEFINE_MUTEX(preset_mutex);
78static LIST_HEAD(hda_preset_tables);
79
80/**
81 * snd_hda_add_codec_preset - Add a codec preset to the chain
82 * @preset: codec preset table to add
83 */
84int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
85{
86 mutex_lock(&preset_mutex);
87 list_add_tail(&preset->list, &hda_preset_tables);
88 mutex_unlock(&preset_mutex);
89 return 0;
90}
91EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
92
93/**
94 * snd_hda_delete_codec_preset - Delete a codec preset from the chain
95 * @preset: codec preset table to delete
96 */
97int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
98{
99 mutex_lock(&preset_mutex);
100 list_del(&preset->list);
101 mutex_unlock(&preset_mutex);
102 return 0;
103}
104EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
105
106#ifdef CONFIG_PM 42#ifdef CONFIG_PM
107#define codec_in_pm(codec) ((codec)->in_pm) 43#define codec_in_pm(codec) atomic_read(&(codec)->core.in_pm)
108static void hda_power_work(struct work_struct *work); 44#define hda_codec_is_power_on(codec) \
109static void hda_keep_power_on(struct hda_codec *codec); 45 (!pm_runtime_suspended(hda_codec_dev(codec)))
110#define hda_codec_is_power_on(codec) ((codec)->power_on)
111
112static void hda_call_pm_notify(struct hda_codec *codec, bool power_up)
113{
114 struct hda_bus *bus = codec->bus;
115
116 if ((power_up && codec->pm_up_notified) ||
117 (!power_up && !codec->pm_up_notified))
118 return;
119 if (bus->ops.pm_notify)
120 bus->ops.pm_notify(bus, power_up);
121 codec->pm_up_notified = power_up;
122}
123
124#else 46#else
125#define codec_in_pm(codec) 0 47#define codec_in_pm(codec) 0
126static inline void hda_keep_power_on(struct hda_codec *codec) {}
127#define hda_codec_is_power_on(codec) 1 48#define hda_codec_is_power_on(codec) 1
128#define hda_call_pm_notify(codec, state) {}
129#endif 49#endif
130 50
51#define codec_has_epss(codec) \
52 ((codec)->core.power_caps & AC_PWRST_EPSS)
53#define codec_has_clkstop(codec) \
54 ((codec)->core.power_caps & AC_PWRST_CLKSTOP)
55
131/** 56/**
132 * snd_hda_get_jack_location - Give a location string of the jack 57 * snd_hda_get_jack_location - Give a location string of the jack
133 * @cfg: pin default config value 58 * @cfg: pin default config value
@@ -199,67 +124,32 @@ const char *snd_hda_get_jack_type(u32 cfg)
199EXPORT_SYMBOL_GPL(snd_hda_get_jack_type); 124EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
200 125
201/* 126/*
202 * Compose a 32bit command word to be sent to the HD-audio controller 127 * Send and receive a verb - passed to exec_verb override for hdac_device
203 */
204static inline unsigned int
205make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int flags,
206 unsigned int verb, unsigned int parm)
207{
208 u32 val;
209
210 if ((codec->addr & ~0xf) || (nid & ~0x7f) ||
211 (verb & ~0xfff) || (parm & ~0xffff)) {
212 codec_err(codec, "hda-codec: out of range cmd %x:%x:%x:%x\n",
213 codec->addr, nid, verb, parm);
214 return ~0;
215 }
216
217 val = (u32)codec->addr << 28;
218 val |= (u32)nid << 20;
219 val |= verb << 8;
220 val |= parm;
221 return val;
222}
223
224/*
225 * Send and receive a verb
226 */ 128 */
227static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd, 129static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
228 int flags, unsigned int *res) 130 unsigned int flags, unsigned int *res)
229{ 131{
132 struct hda_codec *codec = container_of(dev, struct hda_codec, core);
230 struct hda_bus *bus = codec->bus; 133 struct hda_bus *bus = codec->bus;
231 int err; 134 int err;
232 135
233 if (cmd == ~0) 136 if (cmd == ~0)
234 return -1; 137 return -1;
235 138
236 if (res)
237 *res = -1;
238 again: 139 again:
239 snd_hda_power_up(codec); 140 snd_hda_power_up_pm(codec);
240 mutex_lock(&bus->cmd_mutex); 141 mutex_lock(&bus->core.cmd_mutex);
241 if (flags & HDA_RW_NO_RESPONSE_FALLBACK) 142 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
242 bus->no_response_fallback = 1; 143 bus->no_response_fallback = 1;
243 for (;;) { 144 err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
244 trace_hda_send_cmd(codec, cmd); 145 cmd, res);
245 err = bus->ops.command(bus, cmd);
246 if (err != -EAGAIN)
247 break;
248 /* process pending verbs */
249 bus->ops.get_response(bus, codec->addr);
250 }
251 if (!err && res) {
252 *res = bus->ops.get_response(bus, codec->addr);
253 trace_hda_get_response(codec, *res);
254 }
255 bus->no_response_fallback = 0; 146 bus->no_response_fallback = 0;
256 mutex_unlock(&bus->cmd_mutex); 147 mutex_unlock(&bus->core.cmd_mutex);
257 snd_hda_power_down(codec); 148 snd_hda_power_down_pm(codec);
258 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) { 149 if (!codec_in_pm(codec) && res && err < 0 && bus->rirb_error) {
259 if (bus->response_reset) { 150 if (bus->response_reset) {
260 codec_dbg(codec, 151 codec_dbg(codec,
261 "resetting BUS due to fatal communication error\n"); 152 "resetting BUS due to fatal communication error\n");
262 trace_hda_bus_reset(bus);
263 bus->ops.bus_reset(bus); 153 bus->ops.bus_reset(bus);
264 } 154 }
265 goto again; 155 goto again;
@@ -286,9 +176,9 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
286 int flags, 176 int flags,
287 unsigned int verb, unsigned int parm) 177 unsigned int verb, unsigned int parm)
288{ 178{
289 unsigned cmd = make_codec_cmd(codec, nid, flags, verb, parm); 179 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
290 unsigned int res; 180 unsigned int res;
291 if (codec_exec_verb(codec, cmd, flags, &res)) 181 if (snd_hdac_exec_verb(&codec->core, cmd, flags, &res))
292 return -1; 182 return -1;
293 return res; 183 return res;
294} 184}
@@ -309,10 +199,8 @@ EXPORT_SYMBOL_GPL(snd_hda_codec_read);
309int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags, 199int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
310 unsigned int verb, unsigned int parm) 200 unsigned int verb, unsigned int parm)
311{ 201{
312 unsigned int cmd = make_codec_cmd(codec, nid, flags, verb, parm); 202 unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
313 unsigned int res; 203 return snd_hdac_exec_verb(&codec->core, cmd, flags, NULL);
314 return codec_exec_verb(codec, cmd, flags,
315 codec->bus->sync_write ? &res : NULL);
316} 204}
317EXPORT_SYMBOL_GPL(snd_hda_codec_write); 205EXPORT_SYMBOL_GPL(snd_hda_codec_write);
318 206
@@ -331,30 +219,6 @@ void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
331} 219}
332EXPORT_SYMBOL_GPL(snd_hda_sequence_write); 220EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
333 221
334/**
335 * snd_hda_get_sub_nodes - get the range of sub nodes
336 * @codec: the HDA codec
337 * @nid: NID to parse
338 * @start_id: the pointer to store the start NID
339 *
340 * Parse the NID and store the start NID of its sub-nodes.
341 * Returns the number of sub-nodes.
342 */
343int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
344 hda_nid_t *start_id)
345{
346 unsigned int parm;
347
348 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
349 if (parm == -1) {
350 *start_id = 0;
351 return 0;
352 }
353 *start_id = (parm >> 16) & 0x7fff;
354 return (int)(parm & 0x7fff);
355}
356EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
357
358/* connection list element */ 222/* connection list element */
359struct hda_conn_list { 223struct hda_conn_list {
360 struct list_head list; 224 struct list_head list;
@@ -495,128 +359,6 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
495} 359}
496EXPORT_SYMBOL_GPL(snd_hda_get_connections); 360EXPORT_SYMBOL_GPL(snd_hda_get_connections);
497 361
498/* return CONNLIST_LEN parameter of the given widget */
499static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
500{
501 unsigned int wcaps = get_wcaps(codec, nid);
502 unsigned int parm;
503
504 if (!(wcaps & AC_WCAP_CONN_LIST) &&
505 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
506 return 0;
507
508 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
509 if (parm == -1)
510 parm = 0;
511 return parm;
512}
513
514int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
515{
516 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
517}
518
519/**
520 * snd_hda_get_raw_connections - copy connection list without cache
521 * @codec: the HDA codec
522 * @nid: NID to parse
523 * @conn_list: connection list array
524 * @max_conns: max. number of connections to store
525 *
526 * Like snd_hda_get_connections(), copy the connection list but without
527 * checking through the connection-list cache.
528 * Currently called only from hda_proc.c, so not exported.
529 */
530int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
531 hda_nid_t *conn_list, int max_conns)
532{
533 unsigned int parm;
534 int i, conn_len, conns;
535 unsigned int shift, num_elems, mask;
536 hda_nid_t prev_nid;
537 int null_count = 0;
538
539 parm = get_num_conns(codec, nid);
540 if (!parm)
541 return 0;
542
543 if (parm & AC_CLIST_LONG) {
544 /* long form */
545 shift = 16;
546 num_elems = 2;
547 } else {
548 /* short form */
549 shift = 8;
550 num_elems = 4;
551 }
552 conn_len = parm & AC_CLIST_LENGTH;
553 mask = (1 << (shift-1)) - 1;
554
555 if (!conn_len)
556 return 0; /* no connection */
557
558 if (conn_len == 1) {
559 /* single connection */
560 parm = snd_hda_codec_read(codec, nid, 0,
561 AC_VERB_GET_CONNECT_LIST, 0);
562 if (parm == -1 && codec->bus->rirb_error)
563 return -EIO;
564 if (conn_list)
565 conn_list[0] = parm & mask;
566 return 1;
567 }
568
569 /* multi connection */
570 conns = 0;
571 prev_nid = 0;
572 for (i = 0; i < conn_len; i++) {
573 int range_val;
574 hda_nid_t val, n;
575
576 if (i % num_elems == 0) {
577 parm = snd_hda_codec_read(codec, nid, 0,
578 AC_VERB_GET_CONNECT_LIST, i);
579 if (parm == -1 && codec->bus->rirb_error)
580 return -EIO;
581 }
582 range_val = !!(parm & (1 << (shift-1))); /* ranges */
583 val = parm & mask;
584 if (val == 0 && null_count++) { /* no second chance */
585 codec_dbg(codec,
586 "invalid CONNECT_LIST verb %x[%i]:%x\n",
587 nid, i, parm);
588 return 0;
589 }
590 parm >>= shift;
591 if (range_val) {
592 /* ranges between the previous and this one */
593 if (!prev_nid || prev_nid >= val) {
594 codec_warn(codec,
595 "invalid dep_range_val %x:%x\n",
596 prev_nid, val);
597 continue;
598 }
599 for (n = prev_nid + 1; n <= val; n++) {
600 if (conn_list) {
601 if (conns >= max_conns)
602 return -ENOSPC;
603 conn_list[conns] = n;
604 }
605 conns++;
606 }
607 } else {
608 if (conn_list) {
609 if (conns >= max_conns)
610 return -ENOSPC;
611 conn_list[conns] = val;
612 }
613 conns++;
614 }
615 prev_nid = val;
616 }
617 return conns;
618}
619
620/** 362/**
621 * snd_hda_override_conn_list - add/modify the connection-list to cache 363 * snd_hda_override_conn_list - add/modify the connection-list to cache
622 * @codec: the HDA codec 364 * @codec: the HDA codec
@@ -741,90 +483,6 @@ int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
741 return devices; 483 return devices;
742} 484}
743 485
744/**
745 * snd_hda_queue_unsol_event - add an unsolicited event to queue
746 * @bus: the BUS
747 * @res: unsolicited event (lower 32bit of RIRB entry)
748 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
749 *
750 * Adds the given event to the queue. The events are processed in
751 * the workqueue asynchronously. Call this function in the interrupt
752 * hanlder when RIRB receives an unsolicited event.
753 *
754 * Returns 0 if successful, or a negative error code.
755 */
756int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
757{
758 struct hda_bus_unsolicited *unsol;
759 unsigned int wp;
760
761 if (!bus || !bus->workq)
762 return 0;
763
764 trace_hda_unsol_event(bus, res, res_ex);
765 unsol = bus->unsol;
766 if (!unsol)
767 return 0;
768
769 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
770 unsol->wp = wp;
771
772 wp <<= 1;
773 unsol->queue[wp] = res;
774 unsol->queue[wp + 1] = res_ex;
775
776 queue_work(bus->workq, &unsol->work);
777
778 return 0;
779}
780EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
781
782/*
783 * process queued unsolicited events
784 */
785static void process_unsol_events(struct work_struct *work)
786{
787 struct hda_bus_unsolicited *unsol =
788 container_of(work, struct hda_bus_unsolicited, work);
789 struct hda_bus *bus = unsol->bus;
790 struct hda_codec *codec;
791 unsigned int rp, caddr, res;
792
793 while (unsol->rp != unsol->wp) {
794 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
795 unsol->rp = rp;
796 rp <<= 1;
797 res = unsol->queue[rp];
798 caddr = unsol->queue[rp + 1];
799 if (!(caddr & (1 << 4))) /* no unsolicited event? */
800 continue;
801 codec = bus->caddr_tbl[caddr & 0x0f];
802 if (codec && codec->patch_ops.unsol_event)
803 codec->patch_ops.unsol_event(codec, res);
804 }
805}
806
807/*
808 * initialize unsolicited queue
809 */
810static int init_unsol_queue(struct hda_bus *bus)
811{
812 struct hda_bus_unsolicited *unsol;
813
814 if (bus->unsol) /* already initialized */
815 return 0;
816
817 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
818 if (!unsol) {
819 dev_err(bus->card->dev, "can't allocate unsolicited queue\n");
820 return -ENOMEM;
821 }
822 INIT_WORK(&unsol->work, process_unsol_events);
823 unsol->bus = bus;
824 bus->unsol = unsol;
825 return 0;
826}
827
828/* 486/*
829 * destructor 487 * destructor
830 */ 488 */
@@ -832,16 +490,9 @@ static void snd_hda_bus_free(struct hda_bus *bus)
832{ 490{
833 if (!bus) 491 if (!bus)
834 return; 492 return;
835
836 WARN_ON(!list_empty(&bus->codec_list));
837 if (bus->workq)
838 flush_workqueue(bus->workq);
839 kfree(bus->unsol);
840 if (bus->ops.private_free) 493 if (bus->ops.private_free)
841 bus->ops.private_free(bus); 494 bus->ops.private_free(bus);
842 if (bus->workq) 495 snd_hdac_bus_exit(&bus->core);
843 destroy_workqueue(bus->workq);
844
845 kfree(bus); 496 kfree(bus);
846} 497}
847 498
@@ -858,17 +509,35 @@ static int snd_hda_bus_dev_disconnect(struct snd_device *device)
858 return 0; 509 return 0;
859} 510}
860 511
512/* hdac_bus_ops translations */
513static int _hda_bus_command(struct hdac_bus *_bus, unsigned int cmd)
514{
515 struct hda_bus *bus = container_of(_bus, struct hda_bus, core);
516 return bus->ops.command(bus, cmd);
517}
518
519static int _hda_bus_get_response(struct hdac_bus *_bus, unsigned int addr,
520 unsigned int *res)
521{
522 struct hda_bus *bus = container_of(_bus, struct hda_bus, core);
523 *res = bus->ops.get_response(bus, addr);
524 return bus->rirb_error ? -EIO : 0;
525}
526
527static const struct hdac_bus_ops bus_ops = {
528 .command = _hda_bus_command,
529 .get_response = _hda_bus_get_response,
530};
531
861/** 532/**
862 * snd_hda_bus_new - create a HDA bus 533 * snd_hda_bus_new - create a HDA bus
863 * @card: the card entry 534 * @card: the card entry
864 * @temp: the template for hda_bus information
865 * @busp: the pointer to store the created bus instance 535 * @busp: the pointer to store the created bus instance
866 * 536 *
867 * Returns 0 if successful, or a negative error code. 537 * Returns 0 if successful, or a negative error code.
868 */ 538 */
869int snd_hda_bus_new(struct snd_card *card, 539int snd_hda_bus_new(struct snd_card *card,
870 const struct hda_bus_template *temp, 540 struct hda_bus **busp)
871 struct hda_bus **busp)
872{ 541{
873 struct hda_bus *bus; 542 struct hda_bus *bus;
874 int err; 543 int err;
@@ -877,40 +546,21 @@ int snd_hda_bus_new(struct snd_card *card,
877 .dev_free = snd_hda_bus_dev_free, 546 .dev_free = snd_hda_bus_dev_free,
878 }; 547 };
879 548
880 if (snd_BUG_ON(!temp))
881 return -EINVAL;
882 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
883 return -EINVAL;
884
885 if (busp) 549 if (busp)
886 *busp = NULL; 550 *busp = NULL;
887 551
888 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 552 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
889 if (bus == NULL) { 553 if (!bus)
890 dev_err(card->dev, "can't allocate struct hda_bus\n");
891 return -ENOMEM; 554 return -ENOMEM;
555
556 err = snd_hdac_bus_init(&bus->core, card->dev, &bus_ops);
557 if (err < 0) {
558 kfree(bus);
559 return err;
892 } 560 }
893 561
894 bus->card = card; 562 bus->card = card;
895 bus->private_data = temp->private_data;
896 bus->pci = temp->pci;
897 bus->modelname = temp->modelname;
898 bus->power_save = temp->power_save;
899 bus->ops = temp->ops;
900
901 mutex_init(&bus->cmd_mutex);
902 mutex_init(&bus->prepare_mutex); 563 mutex_init(&bus->prepare_mutex);
903 INIT_LIST_HEAD(&bus->codec_list);
904
905 snprintf(bus->workq_name, sizeof(bus->workq_name),
906 "hd-audio%d", card->number);
907 bus->workq = create_singlethread_workqueue(bus->workq_name);
908 if (!bus->workq) {
909 dev_err(card->dev, "cannot create workqueue %s\n",
910 bus->workq_name);
911 kfree(bus);
912 return -ENOMEM;
913 }
914 564
915 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops); 565 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
916 if (err < 0) { 566 if (err < 0) {
@@ -923,140 +573,6 @@ int snd_hda_bus_new(struct snd_card *card,
923} 573}
924EXPORT_SYMBOL_GPL(snd_hda_bus_new); 574EXPORT_SYMBOL_GPL(snd_hda_bus_new);
925 575
926#if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
927#define is_generic_config(codec) \
928 (codec->modelname && !strcmp(codec->modelname, "generic"))
929#else
930#define is_generic_config(codec) 0
931#endif
932
933#ifdef MODULE
934#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
935#else
936#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
937#endif
938
939/*
940 * find a matching codec preset
941 */
942static const struct hda_codec_preset *
943find_codec_preset(struct hda_codec *codec)
944{
945 struct hda_codec_preset_list *tbl;
946 const struct hda_codec_preset *preset;
947 unsigned int mod_requested = 0;
948
949 again:
950 mutex_lock(&preset_mutex);
951 list_for_each_entry(tbl, &hda_preset_tables, list) {
952 if (!try_module_get(tbl->owner)) {
953 codec_err(codec, "cannot module_get\n");
954 continue;
955 }
956 for (preset = tbl->preset; preset->id; preset++) {
957 u32 mask = preset->mask;
958 if (preset->afg && preset->afg != codec->afg)
959 continue;
960 if (preset->mfg && preset->mfg != codec->mfg)
961 continue;
962 if (!mask)
963 mask = ~0;
964 if (preset->id == (codec->vendor_id & mask) &&
965 (!preset->rev ||
966 preset->rev == codec->revision_id)) {
967 mutex_unlock(&preset_mutex);
968 codec->owner = tbl->owner;
969 return preset;
970 }
971 }
972 module_put(tbl->owner);
973 }
974 mutex_unlock(&preset_mutex);
975
976 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
977 if (!mod_requested)
978 request_module("snd-hda-codec-id:%08x",
979 codec->vendor_id);
980 else
981 request_module("snd-hda-codec-id:%04x*",
982 (codec->vendor_id >> 16) & 0xffff);
983 mod_requested++;
984 goto again;
985 }
986 return NULL;
987}
988
989/*
990 * get_codec_name - store the codec name
991 */
992static int get_codec_name(struct hda_codec *codec)
993{
994 const struct hda_vendor_id *c;
995 const char *vendor = NULL;
996 u16 vendor_id = codec->vendor_id >> 16;
997 char tmp[16];
998
999 if (codec->vendor_name)
1000 goto get_chip_name;
1001
1002 for (c = hda_vendor_ids; c->id; c++) {
1003 if (c->id == vendor_id) {
1004 vendor = c->name;
1005 break;
1006 }
1007 }
1008 if (!vendor) {
1009 sprintf(tmp, "Generic %04x", vendor_id);
1010 vendor = tmp;
1011 }
1012 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
1013 if (!codec->vendor_name)
1014 return -ENOMEM;
1015
1016 get_chip_name:
1017 if (codec->chip_name)
1018 return 0;
1019
1020 if (codec->preset && codec->preset->name)
1021 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
1022 else {
1023 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
1024 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
1025 }
1026 if (!codec->chip_name)
1027 return -ENOMEM;
1028 return 0;
1029}
1030
1031/*
1032 * look for an AFG and MFG nodes
1033 */
1034static void setup_fg_nodes(struct hda_codec *codec)
1035{
1036 int i, total_nodes, function_id;
1037 hda_nid_t nid;
1038
1039 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
1040 for (i = 0; i < total_nodes; i++, nid++) {
1041 function_id = snd_hda_param_read(codec, nid,
1042 AC_PAR_FUNCTION_TYPE);
1043 switch (function_id & 0xff) {
1044 case AC_GRP_AUDIO_FUNCTION:
1045 codec->afg = nid;
1046 codec->afg_function_id = function_id & 0xff;
1047 codec->afg_unsol = (function_id >> 8) & 1;
1048 break;
1049 case AC_GRP_MODEM_FUNCTION:
1050 codec->mfg = nid;
1051 codec->mfg_function_id = function_id & 0xff;
1052 codec->mfg_unsol = (function_id >> 8) & 1;
1053 break;
1054 default:
1055 break;
1056 }
1057 }
1058}
1059
1060/* 576/*
1061 * read widget caps for each widget and store in cache 577 * read widget caps for each widget and store in cache
1062 */ 578 */
@@ -1065,25 +581,22 @@ static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1065 int i; 581 int i;
1066 hda_nid_t nid; 582 hda_nid_t nid;
1067 583
1068 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node, 584 codec->wcaps = kmalloc(codec->core.num_nodes * 4, GFP_KERNEL);
1069 &codec->start_nid);
1070 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1071 if (!codec->wcaps) 585 if (!codec->wcaps)
1072 return -ENOMEM; 586 return -ENOMEM;
1073 nid = codec->start_nid; 587 nid = codec->core.start_nid;
1074 for (i = 0; i < codec->num_nodes; i++, nid++) 588 for (i = 0; i < codec->core.num_nodes; i++, nid++)
1075 codec->wcaps[i] = snd_hda_param_read(codec, nid, 589 codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
1076 AC_PAR_AUDIO_WIDGET_CAP); 590 nid, AC_PAR_AUDIO_WIDGET_CAP);
1077 return 0; 591 return 0;
1078} 592}
1079 593
1080/* read all pin default configurations and save codec->init_pins */ 594/* read all pin default configurations and save codec->init_pins */
1081static int read_pin_defaults(struct hda_codec *codec) 595static int read_pin_defaults(struct hda_codec *codec)
1082{ 596{
1083 int i; 597 hda_nid_t nid;
1084 hda_nid_t nid = codec->start_nid;
1085 598
1086 for (i = 0; i < codec->num_nodes; i++, nid++) { 599 for_each_hda_codec_node(nid, codec) {
1087 struct hda_pincfg *pin; 600 struct hda_pincfg *pin;
1088 unsigned int wcaps = get_wcaps(codec, nid); 601 unsigned int wcaps = get_wcaps(codec, nid);
1089 unsigned int wid_type = get_wcaps_type(wcaps); 602 unsigned int wid_type = get_wcaps_type(wcaps);
@@ -1290,14 +803,10 @@ static void hda_jackpoll_work(struct work_struct *work)
1290 if (!codec->jackpoll_interval) 803 if (!codec->jackpoll_interval)
1291 return; 804 return;
1292 805
1293 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work, 806 schedule_delayed_work(&codec->jackpoll_work,
1294 codec->jackpoll_interval); 807 codec->jackpoll_interval);
1295} 808}
1296 809
1297static void init_hda_cache(struct hda_cache_rec *cache,
1298 unsigned int record_size);
1299static void free_hda_cache(struct hda_cache_rec *cache);
1300
1301/* release all pincfg lists */ 810/* release all pincfg lists */
1302static void free_init_pincfgs(struct hda_codec *codec) 811static void free_init_pincfgs(struct hda_codec *codec)
1303{ 812{
@@ -1339,70 +848,117 @@ get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1339} 848}
1340 849
1341/* 850/*
1342 * Dynamic symbol binding for the codec parsers 851 * PCM device
1343 */ 852 */
853static void release_pcm(struct kref *kref)
854{
855 struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
856
857 if (pcm->pcm)
858 snd_device_free(pcm->codec->card, pcm->pcm);
859 clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
860 kfree(pcm->name);
861 kfree(pcm);
862}
1344 863
1345#define load_parser(codec, sym) \ 864void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
1346 ((codec)->parser = (int (*)(struct hda_codec *))symbol_request(sym)) 865{
866 kref_put(&pcm->kref, release_pcm);
867}
868EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
1347 869
1348static void unload_parser(struct hda_codec *codec) 870struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
871 const char *fmt, ...)
1349{ 872{
1350 if (codec->parser) 873 struct hda_pcm *pcm;
1351 symbol_put_addr(codec->parser); 874 va_list args;
1352 codec->parser = NULL; 875
876 va_start(args, fmt);
877 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
878 if (!pcm)
879 return NULL;
880
881 pcm->codec = codec;
882 kref_init(&pcm->kref);
883 pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
884 if (!pcm->name) {
885 kfree(pcm);
886 return NULL;
887 }
888
889 list_add_tail(&pcm->list, &codec->pcm_list_head);
890 return pcm;
1353} 891}
892EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
1354 893
1355/* 894/*
1356 * codec destructor 895 * codec destructor
1357 */ 896 */
1358static void snd_hda_codec_free(struct hda_codec *codec) 897static void codec_release_pcms(struct hda_codec *codec)
1359{ 898{
1360 if (!codec) 899 struct hda_pcm *pcm, *n;
1361 return; 900
901 list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
902 list_del_init(&pcm->list);
903 if (pcm->pcm)
904 snd_device_disconnect(codec->card, pcm->pcm);
905 snd_hda_codec_pcm_put(pcm);
906 }
907}
908
909void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
910{
911 if (codec->registered) {
912 /* pm_runtime_put() is called in snd_hdac_device_exit() */
913 pm_runtime_get_noresume(hda_codec_dev(codec));
914 pm_runtime_disable(hda_codec_dev(codec));
915 codec->registered = 0;
916 }
917
1362 cancel_delayed_work_sync(&codec->jackpoll_work); 918 cancel_delayed_work_sync(&codec->jackpoll_work);
919 if (!codec->in_freeing)
920 snd_hda_ctls_clear(codec);
921 codec_release_pcms(codec);
922 snd_hda_detach_beep_device(codec);
923 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1363 snd_hda_jack_tbl_clear(codec); 924 snd_hda_jack_tbl_clear(codec);
1364 free_init_pincfgs(codec); 925 codec->proc_widget_hook = NULL;
1365#ifdef CONFIG_PM 926 codec->spec = NULL;
1366 cancel_delayed_work(&codec->power_work); 927
1367 flush_workqueue(codec->bus->workq); 928 /* free only driver_pins so that init_pins + user_pins are restored */
1368#endif 929 snd_array_free(&codec->driver_pins);
1369 list_del(&codec->list);
1370 snd_array_free(&codec->mixers);
1371 snd_array_free(&codec->nids);
1372 snd_array_free(&codec->cvt_setups); 930 snd_array_free(&codec->cvt_setups);
1373 snd_array_free(&codec->spdif_out); 931 snd_array_free(&codec->spdif_out);
932 snd_array_free(&codec->verbs);
933 codec->preset = NULL;
934 codec->slave_dig_outs = NULL;
935 codec->spdif_status_reset = 0;
936 snd_array_free(&codec->mixers);
937 snd_array_free(&codec->nids);
1374 remove_conn_list(codec); 938 remove_conn_list(codec);
1375 codec->bus->caddr_tbl[codec->addr] = NULL; 939 snd_hdac_regmap_exit(&codec->core);
1376 if (codec->patch_ops.free)
1377 codec->patch_ops.free(codec);
1378 hda_call_pm_notify(codec, false); /* cancel leftover refcounts */
1379 snd_hda_sysfs_clear(codec);
1380 unload_parser(codec);
1381 module_put(codec->owner);
1382 free_hda_cache(&codec->amp_cache);
1383 free_hda_cache(&codec->cmd_cache);
1384 kfree(codec->vendor_name);
1385 kfree(codec->chip_name);
1386 kfree(codec->modelname);
1387 kfree(codec->wcaps);
1388 codec->bus->num_codecs--;
1389 put_device(&codec->dev);
1390} 940}
1391 941
1392static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1393 hda_nid_t fg, unsigned int power_state);
1394
1395static unsigned int hda_set_power_state(struct hda_codec *codec, 942static unsigned int hda_set_power_state(struct hda_codec *codec,
1396 unsigned int power_state); 943 unsigned int power_state);
1397 944
1398static int snd_hda_codec_dev_register(struct snd_device *device) 945/* also called from hda_bind.c */
946void snd_hda_codec_register(struct hda_codec *codec)
1399{ 947{
1400 struct hda_codec *codec = device->device_data; 948 if (codec->registered)
1401 int err = device_add(&codec->dev); 949 return;
950 if (device_is_registered(hda_codec_dev(codec))) {
951 snd_hda_register_beep_device(codec);
952 pm_runtime_enable(hda_codec_dev(codec));
953 /* it was powered up in snd_hda_codec_new(), now all done */
954 snd_hda_power_down(codec);
955 codec->registered = 1;
956 }
957}
1402 958
1403 if (err < 0) 959static int snd_hda_codec_dev_register(struct snd_device *device)
1404 return err; 960{
1405 snd_hda_register_beep_device(codec); 961 snd_hda_codec_register(device->device_data);
1406 return 0; 962 return 0;
1407} 963}
1408 964
@@ -1411,20 +967,29 @@ static int snd_hda_codec_dev_disconnect(struct snd_device *device)
1411 struct hda_codec *codec = device->device_data; 967 struct hda_codec *codec = device->device_data;
1412 968
1413 snd_hda_detach_beep_device(codec); 969 snd_hda_detach_beep_device(codec);
1414 device_del(&codec->dev);
1415 return 0; 970 return 0;
1416} 971}
1417 972
1418static int snd_hda_codec_dev_free(struct snd_device *device) 973static int snd_hda_codec_dev_free(struct snd_device *device)
1419{ 974{
1420 snd_hda_codec_free(device->device_data); 975 struct hda_codec *codec = device->device_data;
976
977 codec->in_freeing = 1;
978 snd_hdac_device_unregister(&codec->core);
979 put_device(hda_codec_dev(codec));
1421 return 0; 980 return 0;
1422} 981}
1423 982
1424/* just free the container */
1425static void snd_hda_codec_dev_release(struct device *dev) 983static void snd_hda_codec_dev_release(struct device *dev)
1426{ 984{
1427 kfree(container_of(dev, struct hda_codec, dev)); 985 struct hda_codec *codec = dev_to_hda_codec(dev);
986
987 free_init_pincfgs(codec);
988 snd_hdac_device_exit(&codec->core);
989 snd_hda_sysfs_clear(codec);
990 kfree(codec->modelname);
991 kfree(codec->wcaps);
992 kfree(codec);
1428} 993}
1429 994
1430/** 995/**
@@ -1435,9 +1000,8 @@ static void snd_hda_codec_dev_release(struct device *dev)
1435 * 1000 *
1436 * Returns 0 if successful, or a negative error code. 1001 * Returns 0 if successful, or a negative error code.
1437 */ 1002 */
1438int snd_hda_codec_new(struct hda_bus *bus, 1003int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
1439 unsigned int codec_addr, 1004 unsigned int codec_addr, struct hda_codec **codecp)
1440 struct hda_codec **codecp)
1441{ 1005{
1442 struct hda_codec *codec; 1006 struct hda_codec *codec;
1443 char component[31]; 1007 char component[31];
@@ -1454,35 +1018,27 @@ int snd_hda_codec_new(struct hda_bus *bus,
1454 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS)) 1018 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1455 return -EINVAL; 1019 return -EINVAL;
1456 1020
1457 if (bus->caddr_tbl[codec_addr]) {
1458 dev_err(bus->card->dev,
1459 "address 0x%x is already occupied\n",
1460 codec_addr);
1461 return -EBUSY;
1462 }
1463
1464 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 1021 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1465 if (codec == NULL) { 1022 if (!codec)
1466 dev_err(bus->card->dev, "can't allocate struct hda_codec\n");
1467 return -ENOMEM; 1023 return -ENOMEM;
1024
1025 sprintf(component, "hdaudioC%dD%d", card->number, codec_addr);
1026 err = snd_hdac_device_init(&codec->core, &bus->core, component,
1027 codec_addr);
1028 if (err < 0) {
1029 kfree(codec);
1030 return err;
1468 } 1031 }
1469 1032
1470 device_initialize(&codec->dev); 1033 codec->core.dev.release = snd_hda_codec_dev_release;
1471 codec->dev.parent = &bus->card->card_dev; 1034 codec->core.type = HDA_DEV_LEGACY;
1472 codec->dev.class = sound_class; 1035 codec->core.exec_verb = codec_exec_verb;
1473 codec->dev.release = snd_hda_codec_dev_release;
1474 codec->dev.groups = snd_hda_dev_attr_groups;
1475 dev_set_name(&codec->dev, "hdaudioC%dD%d", bus->card->number,
1476 codec_addr);
1477 dev_set_drvdata(&codec->dev, codec); /* for sysfs */
1478 1036
1479 codec->bus = bus; 1037 codec->bus = bus;
1038 codec->card = card;
1480 codec->addr = codec_addr; 1039 codec->addr = codec_addr;
1481 mutex_init(&codec->spdif_mutex); 1040 mutex_init(&codec->spdif_mutex);
1482 mutex_init(&codec->control_mutex); 1041 mutex_init(&codec->control_mutex);
1483 mutex_init(&codec->hash_mutex);
1484 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1485 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1486 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32); 1042 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1487 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32); 1043 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1488 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); 1044 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
@@ -1492,19 +1048,14 @@ int snd_hda_codec_new(struct hda_bus *bus,
1492 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16); 1048 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1493 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8); 1049 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1494 INIT_LIST_HEAD(&codec->conn_list); 1050 INIT_LIST_HEAD(&codec->conn_list);
1051 INIT_LIST_HEAD(&codec->pcm_list_head);
1495 1052
1496 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work); 1053 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1497 codec->depop_delay = -1; 1054 codec->depop_delay = -1;
1498 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 1055 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
1499 1056
1500#ifdef CONFIG_PM 1057#ifdef CONFIG_PM
1501 spin_lock_init(&codec->power_lock); 1058 codec->power_jiffies = jiffies;
1502 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1503 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1504 * the caller has to power down appropriatley after initialization
1505 * phase.
1506 */
1507 hda_keep_power_on(codec);
1508#endif 1059#endif
1509 1060
1510 snd_hda_sysfs_init(codec); 1061 snd_hda_sysfs_init(codec);
@@ -1517,59 +1068,14 @@ int snd_hda_codec_new(struct hda_bus *bus,
1517 } 1068 }
1518 } 1069 }
1519 1070
1520 list_add_tail(&codec->list, &bus->codec_list); 1071 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1521 bus->num_codecs++;
1522
1523 bus->caddr_tbl[codec_addr] = codec;
1524
1525 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1526 AC_PAR_VENDOR_ID);
1527 if (codec->vendor_id == -1)
1528 /* read again, hopefully the access method was corrected
1529 * in the last read...
1530 */
1531 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1532 AC_PAR_VENDOR_ID);
1533 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1534 AC_PAR_SUBSYSTEM_ID);
1535 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1536 AC_PAR_REV_ID);
1537
1538 setup_fg_nodes(codec);
1539 if (!codec->afg && !codec->mfg) {
1540 dev_err(bus->card->dev, "no AFG or MFG node found\n");
1541 err = -ENODEV;
1542 goto error;
1543 }
1544
1545 fg = codec->afg ? codec->afg : codec->mfg;
1546 err = read_widget_caps(codec, fg); 1072 err = read_widget_caps(codec, fg);
1547 if (err < 0) { 1073 if (err < 0)
1548 dev_err(bus->card->dev, "cannot malloc\n");
1549 goto error; 1074 goto error;
1550 }
1551 err = read_pin_defaults(codec); 1075 err = read_pin_defaults(codec);
1552 if (err < 0) 1076 if (err < 0)
1553 goto error; 1077 goto error;
1554 1078
1555 if (!codec->subsystem_id) {
1556 codec->subsystem_id =
1557 snd_hda_codec_read(codec, fg, 0,
1558 AC_VERB_GET_SUBSYSTEM_ID, 0);
1559 }
1560
1561#ifdef CONFIG_PM
1562 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1563 AC_PWRST_CLKSTOP);
1564#endif
1565 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1566 AC_PWRST_EPSS);
1567#ifdef CONFIG_PM
1568 if (!codec->d3_stop_clk || !codec->epss)
1569 bus->power_keep_link_on = 1;
1570#endif
1571
1572
1573 /* power-up all before initialization */ 1079 /* power-up all before initialization */
1574 hda_set_power_state(codec, AC_PWRST_D0); 1080 hda_set_power_state(codec, AC_PWRST_D0);
1575 1081
@@ -1577,11 +1083,11 @@ int snd_hda_codec_new(struct hda_bus *bus,
1577 1083
1578 snd_hda_create_hwdep(codec); 1084 snd_hda_create_hwdep(codec);
1579 1085
1580 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id, 1086 sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
1581 codec->subsystem_id, codec->revision_id); 1087 codec->core.subsystem_id, codec->core.revision_id);
1582 snd_component_add(codec->bus->card, component); 1088 snd_component_add(card, component);
1583 1089
1584 err = snd_device_new(bus->card, SNDRV_DEV_CODEC, codec, &dev_ops); 1090 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
1585 if (err < 0) 1091 if (err < 0)
1586 goto error; 1092 goto error;
1587 1093
@@ -1590,7 +1096,7 @@ int snd_hda_codec_new(struct hda_bus *bus,
1590 return 0; 1096 return 0;
1591 1097
1592 error: 1098 error:
1593 snd_hda_codec_free(codec); 1099 put_device(hda_codec_dev(codec));
1594 return err; 1100 return err;
1595} 1101}
1596EXPORT_SYMBOL_GPL(snd_hda_codec_new); 1102EXPORT_SYMBOL_GPL(snd_hda_codec_new);
@@ -1607,16 +1113,18 @@ int snd_hda_codec_update_widgets(struct hda_codec *codec)
1607 hda_nid_t fg; 1113 hda_nid_t fg;
1608 int err; 1114 int err;
1609 1115
1116 err = snd_hdac_refresh_widgets(&codec->core);
1117 if (err < 0)
1118 return err;
1119
1610 /* Assume the function group node does not change, 1120 /* Assume the function group node does not change,
1611 * only the widget nodes may change. 1121 * only the widget nodes may change.
1612 */ 1122 */
1613 kfree(codec->wcaps); 1123 kfree(codec->wcaps);
1614 fg = codec->afg ? codec->afg : codec->mfg; 1124 fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
1615 err = read_widget_caps(codec, fg); 1125 err = read_widget_caps(codec, fg);
1616 if (err < 0) { 1126 if (err < 0)
1617 codec_err(codec, "cannot malloc\n");
1618 return err; 1127 return err;
1619 }
1620 1128
1621 snd_array_free(&codec->init_pins); 1129 snd_array_free(&codec->init_pins);
1622 err = read_pin_defaults(codec); 1130 err = read_pin_defaults(codec);
@@ -1625,98 +1133,6 @@ int snd_hda_codec_update_widgets(struct hda_codec *codec)
1625} 1133}
1626EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets); 1134EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1627 1135
1628
1629#if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
1630/* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
1631static bool is_likely_hdmi_codec(struct hda_codec *codec)
1632{
1633 hda_nid_t nid = codec->start_nid;
1634 int i;
1635
1636 for (i = 0; i < codec->num_nodes; i++, nid++) {
1637 unsigned int wcaps = get_wcaps(codec, nid);
1638 switch (get_wcaps_type(wcaps)) {
1639 case AC_WID_AUD_IN:
1640 return false; /* HDMI parser supports only HDMI out */
1641 case AC_WID_AUD_OUT:
1642 if (!(wcaps & AC_WCAP_DIGITAL))
1643 return false;
1644 break;
1645 }
1646 }
1647 return true;
1648}
1649#else
1650/* no HDMI codec parser support */
1651#define is_likely_hdmi_codec(codec) false
1652#endif /* CONFIG_SND_HDA_CODEC_HDMI */
1653
1654/**
1655 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1656 * @codec: the HDA codec
1657 *
1658 * Start parsing of the given codec tree and (re-)initialize the whole
1659 * patch instance.
1660 *
1661 * Returns 0 if successful or a negative error code.
1662 */
1663int snd_hda_codec_configure(struct hda_codec *codec)
1664{
1665 int (*patch)(struct hda_codec *) = NULL;
1666 int err;
1667
1668 codec->preset = find_codec_preset(codec);
1669 if (!codec->vendor_name || !codec->chip_name) {
1670 err = get_codec_name(codec);
1671 if (err < 0)
1672 return err;
1673 }
1674
1675 if (!is_generic_config(codec) && codec->preset)
1676 patch = codec->preset->patch;
1677 if (!patch) {
1678 unload_parser(codec); /* to be sure */
1679 if (is_likely_hdmi_codec(codec)) {
1680#if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
1681 patch = load_parser(codec, snd_hda_parse_hdmi_codec);
1682#elif IS_BUILTIN(CONFIG_SND_HDA_CODEC_HDMI)
1683 patch = snd_hda_parse_hdmi_codec;
1684#endif
1685 }
1686 if (!patch) {
1687#if IS_MODULE(CONFIG_SND_HDA_GENERIC)
1688 patch = load_parser(codec, snd_hda_parse_generic_codec);
1689#elif IS_BUILTIN(CONFIG_SND_HDA_GENERIC)
1690 patch = snd_hda_parse_generic_codec;
1691#endif
1692 }
1693 if (!patch) {
1694 codec_err(codec, "No codec parser is available\n");
1695 return -ENODEV;
1696 }
1697 }
1698
1699 err = patch(codec);
1700 if (err < 0) {
1701 unload_parser(codec);
1702 return err;
1703 }
1704
1705 if (codec->patch_ops.unsol_event) {
1706 err = init_unsol_queue(codec->bus);
1707 if (err < 0)
1708 return err;
1709 }
1710
1711 /* audio codec should override the mixer name */
1712 if (codec->afg || !*codec->bus->card->mixername)
1713 snprintf(codec->bus->card->mixername,
1714 sizeof(codec->bus->card->mixername),
1715 "%s %s", codec->vendor_name, codec->chip_name);
1716 return 0;
1717}
1718EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
1719
1720/* update the stream-id if changed */ 1136/* update the stream-id if changed */
1721static void update_pcm_stream_id(struct hda_codec *codec, 1137static void update_pcm_stream_id(struct hda_codec *codec,
1722 struct hda_cvt_setup *p, hda_nid_t nid, 1138 struct hda_cvt_setup *p, hda_nid_t nid,
@@ -1782,6 +1198,8 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1782 if (!p) 1198 if (!p)
1783 return; 1199 return;
1784 1200
1201 if (codec->patch_ops.stream_pm)
1202 codec->patch_ops.stream_pm(codec, nid, true);
1785 if (codec->pcm_format_first) 1203 if (codec->pcm_format_first)
1786 update_pcm_format(codec, p, nid, format); 1204 update_pcm_format(codec, p, nid, format);
1787 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id); 1205 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
@@ -1793,7 +1211,7 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1793 1211
1794 /* make other inactive cvts with the same stream-tag dirty */ 1212 /* make other inactive cvts with the same stream-tag dirty */
1795 type = get_wcaps_type(get_wcaps(codec, nid)); 1213 type = get_wcaps_type(get_wcaps(codec, nid));
1796 list_for_each_entry(c, &codec->bus->codec_list, list) { 1214 list_for_each_codec(c, codec->bus) {
1797 for (i = 0; i < c->cvt_setups.used; i++) { 1215 for (i = 0; i < c->cvt_setups.used; i++) {
1798 p = snd_array_elem(&c->cvt_setups, i); 1216 p = snd_array_elem(&c->cvt_setups, i);
1799 if (!p->active && p->stream_tag == stream_tag && 1217 if (!p->active && p->stream_tag == stream_tag &&
@@ -1850,6 +1268,8 @@ static void really_cleanup_stream(struct hda_codec *codec,
1850); 1268);
1851 memset(q, 0, sizeof(*q)); 1269 memset(q, 0, sizeof(*q));
1852 q->nid = nid; 1270 q->nid = nid;
1271 if (codec->patch_ops.stream_pm)
1272 codec->patch_ops.stream_pm(codec, nid, false);
1853} 1273}
1854 1274
1855/* clean up the all conflicting obsolete streams */ 1275/* clean up the all conflicting obsolete streams */
@@ -1858,7 +1278,7 @@ static void purify_inactive_streams(struct hda_codec *codec)
1858 struct hda_codec *c; 1278 struct hda_codec *c;
1859 int i; 1279 int i;
1860 1280
1861 list_for_each_entry(c, &codec->bus->codec_list, list) { 1281 list_for_each_codec(c, codec->bus) {
1862 for (i = 0; i < c->cvt_setups.used; i++) { 1282 for (i = 0; i < c->cvt_setups.used; i++) {
1863 struct hda_cvt_setup *p; 1283 struct hda_cvt_setup *p;
1864 p = snd_array_elem(&c->cvt_setups, i); 1284 p = snd_array_elem(&c->cvt_setups, i);
@@ -1886,127 +1306,6 @@ static void hda_cleanup_all_streams(struct hda_codec *codec)
1886 * amp access functions 1306 * amp access functions
1887 */ 1307 */
1888 1308
1889/* FIXME: more better hash key? */
1890#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1891#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1892#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1893#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1894#define INFO_AMP_CAPS (1<<0)
1895#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1896
1897/* initialize the hash table */
1898static void init_hda_cache(struct hda_cache_rec *cache,
1899 unsigned int record_size)
1900{
1901 memset(cache, 0, sizeof(*cache));
1902 memset(cache->hash, 0xff, sizeof(cache->hash));
1903 snd_array_init(&cache->buf, record_size, 64);
1904}
1905
1906static void free_hda_cache(struct hda_cache_rec *cache)
1907{
1908 snd_array_free(&cache->buf);
1909}
1910
1911/* query the hash. allocate an entry if not found. */
1912static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1913{
1914 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1915 u16 cur = cache->hash[idx];
1916 struct hda_cache_head *info;
1917
1918 while (cur != 0xffff) {
1919 info = snd_array_elem(&cache->buf, cur);
1920 if (info->key == key)
1921 return info;
1922 cur = info->next;
1923 }
1924 return NULL;
1925}
1926
1927/* query the hash. allocate an entry if not found. */
1928static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1929 u32 key)
1930{
1931 struct hda_cache_head *info = get_hash(cache, key);
1932 if (!info) {
1933 u16 idx, cur;
1934 /* add a new hash entry */
1935 info = snd_array_new(&cache->buf);
1936 if (!info)
1937 return NULL;
1938 cur = snd_array_index(&cache->buf, info);
1939 info->key = key;
1940 info->val = 0;
1941 info->dirty = 0;
1942 idx = key % (u16)ARRAY_SIZE(cache->hash);
1943 info->next = cache->hash[idx];
1944 cache->hash[idx] = cur;
1945 }
1946 return info;
1947}
1948
1949/* query and allocate an amp hash entry */
1950static inline struct hda_amp_info *
1951get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1952{
1953 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1954}
1955
1956/* overwrite the value with the key in the caps hash */
1957static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1958{
1959 struct hda_amp_info *info;
1960
1961 mutex_lock(&codec->hash_mutex);
1962 info = get_alloc_amp_hash(codec, key);
1963 if (!info) {
1964 mutex_unlock(&codec->hash_mutex);
1965 return -EINVAL;
1966 }
1967 info->amp_caps = val;
1968 info->head.val |= INFO_AMP_CAPS;
1969 mutex_unlock(&codec->hash_mutex);
1970 return 0;
1971}
1972
1973/* query the value from the caps hash; if not found, fetch the current
1974 * value from the given function and store in the hash
1975 */
1976static unsigned int
1977query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1978 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1979{
1980 struct hda_amp_info *info;
1981 unsigned int val;
1982
1983 mutex_lock(&codec->hash_mutex);
1984 info = get_alloc_amp_hash(codec, key);
1985 if (!info) {
1986 mutex_unlock(&codec->hash_mutex);
1987 return 0;
1988 }
1989 if (!(info->head.val & INFO_AMP_CAPS)) {
1990 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1991 val = func(codec, nid, dir);
1992 write_caps_hash(codec, key, val);
1993 } else {
1994 val = info->amp_caps;
1995 mutex_unlock(&codec->hash_mutex);
1996 }
1997 return val;
1998}
1999
2000static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
2001 int direction)
2002{
2003 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
2004 nid = codec->afg;
2005 return snd_hda_param_read(codec, nid,
2006 direction == HDA_OUTPUT ?
2007 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
2008}
2009
2010/** 1309/**
2011 * query_amp_caps - query AMP capabilities 1310 * query_amp_caps - query AMP capabilities
2012 * @codec: the HD-auio codec 1311 * @codec: the HD-auio codec
@@ -2021,9 +1320,11 @@ static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
2021 */ 1320 */
2022u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) 1321u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
2023{ 1322{
2024 return query_caps_hash(codec, nid, direction, 1323 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
2025 HDA_HASH_KEY(nid, direction, 0), 1324 nid = codec->core.afg;
2026 read_amp_cap); 1325 return snd_hda_param_read(codec, nid,
1326 direction == HDA_OUTPUT ?
1327 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
2027} 1328}
2028EXPORT_SYMBOL_GPL(query_amp_caps); 1329EXPORT_SYMBOL_GPL(query_amp_caps);
2029 1330
@@ -2064,183 +1365,14 @@ EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
2064int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 1365int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
2065 unsigned int caps) 1366 unsigned int caps)
2066{ 1367{
2067 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps); 1368 unsigned int parm;
2068}
2069EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
2070
2071static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
2072 int dir)
2073{
2074 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2075}
2076
2077/**
2078 * snd_hda_query_pin_caps - Query PIN capabilities
2079 * @codec: the HD-auio codec
2080 * @nid: the NID to query
2081 *
2082 * Query PIN capabilities for the given widget.
2083 * Returns the obtained capability bits.
2084 *
2085 * When cap bits have been already read, this doesn't read again but
2086 * returns the cached value.
2087 */
2088u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
2089{
2090 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
2091 read_pin_cap);
2092}
2093EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
2094
2095/**
2096 * snd_hda_override_pin_caps - Override the pin capabilities
2097 * @codec: the CODEC
2098 * @nid: the NID to override
2099 * @caps: the capability bits to set
2100 *
2101 * Override the cached PIN capabilitiy bits value by the given one.
2102 *
2103 * Returns zero if successful or a negative error code.
2104 */
2105int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
2106 unsigned int caps)
2107{
2108 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
2109}
2110EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
2111
2112/* read or sync the hash value with the current value;
2113 * call within hash_mutex
2114 */
2115static struct hda_amp_info *
2116update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
2117 int direction, int index, bool init_only)
2118{
2119 struct hda_amp_info *info;
2120 unsigned int parm, val = 0;
2121 bool val_read = false;
2122
2123 retry:
2124 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
2125 if (!info)
2126 return NULL;
2127 if (!(info->head.val & INFO_AMP_VOL(ch))) {
2128 if (!val_read) {
2129 mutex_unlock(&codec->hash_mutex);
2130 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
2131 parm |= direction == HDA_OUTPUT ?
2132 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
2133 parm |= index;
2134 val = snd_hda_codec_read(codec, nid, 0,
2135 AC_VERB_GET_AMP_GAIN_MUTE, parm);
2136 val &= 0xff;
2137 val_read = true;
2138 mutex_lock(&codec->hash_mutex);
2139 goto retry;
2140 }
2141 info->vol[ch] = val;
2142 info->head.val |= INFO_AMP_VOL(ch);
2143 } else if (init_only)
2144 return NULL;
2145 return info;
2146}
2147
2148/*
2149 * write the current volume in info to the h/w
2150 */
2151static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
2152 hda_nid_t nid, int ch, int direction, int index,
2153 int val)
2154{
2155 u32 parm;
2156
2157 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
2158 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
2159 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2160 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
2161 (amp_caps & AC_AMPCAP_MIN_MUTE))
2162 ; /* set the zero value as a fake mute */
2163 else
2164 parm |= val;
2165 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
2166}
2167
2168/**
2169 * snd_hda_codec_amp_read - Read AMP value
2170 * @codec: HD-audio codec
2171 * @nid: NID to read the AMP value
2172 * @ch: channel (left=0 or right=1)
2173 * @direction: #HDA_INPUT or #HDA_OUTPUT
2174 * @index: the index value (only for input direction)
2175 *
2176 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
2177 */
2178int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2179 int direction, int index)
2180{
2181 struct hda_amp_info *info;
2182 unsigned int val = 0;
2183
2184 mutex_lock(&codec->hash_mutex);
2185 info = update_amp_hash(codec, nid, ch, direction, index, false);
2186 if (info)
2187 val = info->vol[ch];
2188 mutex_unlock(&codec->hash_mutex);
2189 return val;
2190}
2191EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
2192
2193static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2194 int direction, int idx, int mask, int val,
2195 bool init_only)
2196{
2197 struct hda_amp_info *info;
2198 unsigned int caps;
2199 unsigned int cache_only;
2200
2201 if (snd_BUG_ON(mask & ~0xff))
2202 mask &= 0xff;
2203 val &= mask;
2204
2205 mutex_lock(&codec->hash_mutex);
2206 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
2207 if (!info) {
2208 mutex_unlock(&codec->hash_mutex);
2209 return 0;
2210 }
2211 val |= info->vol[ch] & ~mask;
2212 if (info->vol[ch] == val) {
2213 mutex_unlock(&codec->hash_mutex);
2214 return 0;
2215 }
2216 info->vol[ch] = val;
2217 cache_only = info->head.dirty = codec->cached_write;
2218 caps = info->amp_caps;
2219 mutex_unlock(&codec->hash_mutex);
2220 if (!cache_only)
2221 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2222 return 1;
2223}
2224 1369
2225/** 1370 snd_hda_override_wcaps(codec, nid,
2226 * snd_hda_codec_amp_update - update the AMP value 1371 get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
2227 * @codec: HD-audio codec 1372 parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
2228 * @nid: NID to read the AMP value 1373 return snd_hdac_override_parm(&codec->core, nid, parm, caps);
2229 * @ch: channel (left=0 or right=1)
2230 * @direction: #HDA_INPUT or #HDA_OUTPUT
2231 * @idx: the index value (only for input direction)
2232 * @mask: bit mask to set
2233 * @val: the bits value to set
2234 *
2235 * Update the AMP value with a bit mask.
2236 * Returns 0 if the value is unchanged, 1 if changed.
2237 */
2238int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2239 int direction, int idx, int mask, int val)
2240{
2241 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2242} 1374}
2243EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update); 1375EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
2244 1376
2245/** 1377/**
2246 * snd_hda_codec_amp_stereo - update the AMP stereo values 1378 * snd_hda_codec_amp_stereo - update the AMP stereo values
@@ -2285,7 +1417,16 @@ EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
2285int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch, 1417int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2286 int dir, int idx, int mask, int val) 1418 int dir, int idx, int mask, int val)
2287{ 1419{
2288 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true); 1420 int orig;
1421
1422 if (!codec->core.regmap)
1423 return -EINVAL;
1424 regcache_cache_only(codec->core.regmap, true);
1425 orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1426 regcache_cache_only(codec->core.regmap, false);
1427 if (orig >= 0)
1428 return 0;
1429 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val);
2289} 1430}
2290EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init); 1431EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
2291 1432
@@ -2314,49 +1455,6 @@ int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2314} 1455}
2315EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo); 1456EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
2316 1457
2317/**
2318 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2319 * @codec: HD-audio codec
2320 *
2321 * Resume the all amp commands from the cache.
2322 */
2323void snd_hda_codec_resume_amp(struct hda_codec *codec)
2324{
2325 int i;
2326
2327 mutex_lock(&codec->hash_mutex);
2328 codec->cached_write = 0;
2329 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2330 struct hda_amp_info *buffer;
2331 u32 key;
2332 hda_nid_t nid;
2333 unsigned int idx, dir, ch;
2334 struct hda_amp_info info;
2335
2336 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2337 if (!buffer->head.dirty)
2338 continue;
2339 buffer->head.dirty = 0;
2340 info = *buffer;
2341 key = info.head.key;
2342 if (!key)
2343 continue;
2344 nid = key & 0xff;
2345 idx = (key >> 16) & 0xff;
2346 dir = (key >> 24) & 0xff;
2347 for (ch = 0; ch < 2; ch++) {
2348 if (!(info.head.val & INFO_AMP_VOL(ch)))
2349 continue;
2350 mutex_unlock(&codec->hash_mutex);
2351 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2352 info.vol[ch]);
2353 mutex_lock(&codec->hash_mutex);
2354 }
2355 }
2356 mutex_unlock(&codec->hash_mutex);
2357}
2358EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
2359
2360static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir, 1458static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2361 unsigned int ofs) 1459 unsigned int ofs)
2362{ 1460{
@@ -2478,14 +1576,12 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2478 long *valp = ucontrol->value.integer.value; 1576 long *valp = ucontrol->value.integer.value;
2479 int change = 0; 1577 int change = 0;
2480 1578
2481 snd_hda_power_up(codec);
2482 if (chs & 1) { 1579 if (chs & 1) {
2483 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp); 1580 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2484 valp++; 1581 valp++;
2485 } 1582 }
2486 if (chs & 2) 1583 if (chs & 2)
2487 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp); 1584 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2488 snd_hda_power_down(codec);
2489 return change; 1585 return change;
2490} 1586}
2491EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put); 1587EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
@@ -2572,7 +1668,7 @@ find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2572 if (snd_BUG_ON(strlen(name) >= sizeof(id.name))) 1668 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2573 return NULL; 1669 return NULL;
2574 strcpy(id.name, name); 1670 strcpy(id.name, name);
2575 return snd_ctl_find_id(codec->bus->card, &id); 1671 return snd_ctl_find_id(codec->card, &id);
2576} 1672}
2577 1673
2578/** 1674/**
@@ -2636,7 +1732,7 @@ int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2636 nid = kctl->id.subdevice & 0xffff; 1732 nid = kctl->id.subdevice & 0xffff;
2637 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG)) 1733 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2638 kctl->id.subdevice = 0; 1734 kctl->id.subdevice = 0;
2639 err = snd_ctl_add(codec->bus->card, kctl); 1735 err = snd_ctl_add(codec->card, kctl);
2640 if (err < 0) 1736 if (err < 0)
2641 return err; 1737 return err;
2642 item = snd_array_new(&codec->mixers); 1738 item = snd_array_new(&codec->mixers);
@@ -2689,7 +1785,7 @@ void snd_hda_ctls_clear(struct hda_codec *codec)
2689 int i; 1785 int i;
2690 struct hda_nid_item *items = codec->mixers.list; 1786 struct hda_nid_item *items = codec->mixers.list;
2691 for (i = 0; i < codec->mixers.used; i++) 1787 for (i = 0; i < codec->mixers.used; i++)
2692 snd_ctl_remove(codec->bus->card, items[i].kctl); 1788 snd_ctl_remove(codec->card, items[i].kctl);
2693 snd_array_free(&codec->mixers); 1789 snd_array_free(&codec->mixers);
2694 snd_array_free(&codec->nids); 1790 snd_array_free(&codec->nids);
2695} 1791}
@@ -2712,10 +1808,9 @@ int snd_hda_lock_devices(struct hda_bus *bus)
2712 if (!list_empty(&card->ctl_files)) 1808 if (!list_empty(&card->ctl_files))
2713 goto err_clear; 1809 goto err_clear;
2714 1810
2715 list_for_each_entry(codec, &bus->codec_list, list) { 1811 list_for_each_codec(codec, bus) {
2716 int pcm; 1812 struct hda_pcm *cpcm;
2717 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 1813 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
2718 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2719 if (!cpcm->pcm) 1814 if (!cpcm->pcm)
2720 continue; 1815 continue;
2721 if (cpcm->pcm->streams[0].substream_opened || 1816 if (cpcm->pcm->streams[0].substream_opened ||
@@ -2742,7 +1837,6 @@ void snd_hda_unlock_devices(struct hda_bus *bus)
2742{ 1837{
2743 struct snd_card *card = bus->card; 1838 struct snd_card *card = bus->card;
2744 1839
2745 card = bus->card;
2746 spin_lock(&card->files_lock); 1840 spin_lock(&card->files_lock);
2747 card->shutdown = 0; 1841 card->shutdown = 0;
2748 spin_unlock(&card->files_lock); 1842 spin_unlock(&card->files_lock);
@@ -2762,51 +1856,12 @@ EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
2762int snd_hda_codec_reset(struct hda_codec *codec) 1856int snd_hda_codec_reset(struct hda_codec *codec)
2763{ 1857{
2764 struct hda_bus *bus = codec->bus; 1858 struct hda_bus *bus = codec->bus;
2765 struct snd_card *card = bus->card;
2766 int i;
2767 1859
2768 if (snd_hda_lock_devices(bus) < 0) 1860 if (snd_hda_lock_devices(bus) < 0)
2769 return -EBUSY; 1861 return -EBUSY;
2770 1862
2771 /* OK, let it free */ 1863 /* OK, let it free */
2772 cancel_delayed_work_sync(&codec->jackpoll_work); 1864 snd_hdac_device_unregister(&codec->core);
2773#ifdef CONFIG_PM
2774 cancel_delayed_work_sync(&codec->power_work);
2775 flush_workqueue(bus->workq);
2776#endif
2777 snd_hda_ctls_clear(codec);
2778 /* release PCMs */
2779 for (i = 0; i < codec->num_pcms; i++) {
2780 if (codec->pcm_info[i].pcm) {
2781 snd_device_free(card, codec->pcm_info[i].pcm);
2782 clear_bit(codec->pcm_info[i].device,
2783 bus->pcm_dev_bits);
2784 }
2785 }
2786 snd_hda_detach_beep_device(codec);
2787 if (codec->patch_ops.free)
2788 codec->patch_ops.free(codec);
2789 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2790 snd_hda_jack_tbl_clear(codec);
2791 codec->proc_widget_hook = NULL;
2792 codec->spec = NULL;
2793 free_hda_cache(&codec->amp_cache);
2794 free_hda_cache(&codec->cmd_cache);
2795 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2796 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2797 /* free only driver_pins so that init_pins + user_pins are restored */
2798 snd_array_free(&codec->driver_pins);
2799 snd_array_free(&codec->cvt_setups);
2800 snd_array_free(&codec->spdif_out);
2801 snd_array_free(&codec->verbs);
2802 codec->num_pcms = 0;
2803 codec->pcm_info = NULL;
2804 codec->preset = NULL;
2805 codec->slave_dig_outs = NULL;
2806 codec->spdif_status_reset = 0;
2807 unload_parser(codec);
2808 module_put(codec->owner);
2809 codec->owner = NULL;
2810 1865
2811 /* allow device access again */ 1866 /* allow device access again */
2812 snd_hda_unlock_devices(bus); 1867 snd_hda_unlock_devices(bus);
@@ -3153,7 +2208,6 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
3153 long *valp = ucontrol->value.integer.value; 2208 long *valp = ucontrol->value.integer.value;
3154 int change = 0; 2209 int change = 0;
3155 2210
3156 snd_hda_power_up(codec);
3157 if (chs & 1) { 2211 if (chs & 1) {
3158 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 2212 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
3159 HDA_AMP_MUTE, 2213 HDA_AMP_MUTE,
@@ -3165,7 +2219,6 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
3165 HDA_AMP_MUTE, 2219 HDA_AMP_MUTE,
3166 *valp ? 0 : HDA_AMP_MUTE); 2220 *valp ? 0 : HDA_AMP_MUTE);
3167 hda_call_check_power_status(codec, nid); 2221 hda_call_check_power_status(codec, nid);
3168 snd_hda_power_down(codec);
3169 return change; 2222 return change;
3170} 2223}
3171EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put); 2224EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
@@ -3466,25 +2519,35 @@ static unsigned int convert_to_spdif_status(unsigned short val)
3466 2519
3467/* set digital convert verbs both for the given NID and its slaves */ 2520/* set digital convert verbs both for the given NID and its slaves */
3468static void set_dig_out(struct hda_codec *codec, hda_nid_t nid, 2521static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3469 int verb, int val) 2522 int mask, int val)
3470{ 2523{
3471 const hda_nid_t *d; 2524 const hda_nid_t *d;
3472 2525
3473 snd_hda_codec_write_cache(codec, nid, 0, verb, val); 2526 snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
2527 mask, val);
3474 d = codec->slave_dig_outs; 2528 d = codec->slave_dig_outs;
3475 if (!d) 2529 if (!d)
3476 return; 2530 return;
3477 for (; *d; d++) 2531 for (; *d; d++)
3478 snd_hda_codec_write_cache(codec, *d, 0, verb, val); 2532 snd_hdac_regmap_update(&codec->core, nid,
2533 AC_VERB_SET_DIGI_CONVERT_1, mask, val);
3479} 2534}
3480 2535
3481static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid, 2536static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3482 int dig1, int dig2) 2537 int dig1, int dig2)
3483{ 2538{
3484 if (dig1 != -1) 2539 unsigned int mask = 0;
3485 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1); 2540 unsigned int val = 0;
3486 if (dig2 != -1) 2541
3487 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2); 2542 if (dig1 != -1) {
2543 mask |= 0xff;
2544 val = dig1;
2545 }
2546 if (dig2 != -1) {
2547 mask |= 0xff00;
2548 val |= dig2 << 8;
2549 }
2550 set_dig_out(codec, nid, mask, val);
3488} 2551}
3489 2552
3490static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, 2553static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
@@ -3617,6 +2680,7 @@ int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3617 struct snd_kcontrol *kctl; 2680 struct snd_kcontrol *kctl;
3618 struct snd_kcontrol_new *dig_mix; 2681 struct snd_kcontrol_new *dig_mix;
3619 int idx = 0; 2682 int idx = 0;
2683 int val = 0;
3620 const int spdif_index = 16; 2684 const int spdif_index = 16;
3621 struct hda_spdif_out *spdif; 2685 struct hda_spdif_out *spdif;
3622 struct hda_bus *bus = codec->bus; 2686 struct hda_bus *bus = codec->bus;
@@ -3657,8 +2721,9 @@ int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3657 return err; 2721 return err;
3658 } 2722 }
3659 spdif->nid = cvt_nid; 2723 spdif->nid = cvt_nid;
3660 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0, 2724 snd_hdac_regmap_read(&codec->core, cvt_nid,
3661 AC_VERB_GET_DIGI_CONVERT_1, 0); 2725 AC_VERB_GET_DIGI_CONVERT_1, &val);
2726 spdif->ctls = val;
3662 spdif->status = convert_to_spdif_status(spdif->ctls); 2727 spdif->status = convert_to_spdif_status(spdif->ctls);
3663 return 0; 2728 return 0;
3664} 2729}
@@ -3802,8 +2867,8 @@ static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3802 change = codec->spdif_in_enable != val; 2867 change = codec->spdif_in_enable != val;
3803 if (change) { 2868 if (change) {
3804 codec->spdif_in_enable = val; 2869 codec->spdif_in_enable = val;
3805 snd_hda_codec_write_cache(codec, nid, 0, 2870 snd_hdac_regmap_write(&codec->core, nid,
3806 AC_VERB_SET_DIGI_CONVERT_1, val); 2871 AC_VERB_SET_DIGI_CONVERT_1, val);
3807 } 2872 }
3808 mutex_unlock(&codec->spdif_mutex); 2873 mutex_unlock(&codec->spdif_mutex);
3809 return change; 2874 return change;
@@ -3814,10 +2879,11 @@ static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3814{ 2879{
3815 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2880 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3816 hda_nid_t nid = kcontrol->private_value; 2881 hda_nid_t nid = kcontrol->private_value;
3817 unsigned short val; 2882 unsigned int val;
3818 unsigned int sbits; 2883 unsigned int sbits;
3819 2884
3820 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0); 2885 snd_hdac_regmap_read(&codec->core, nid,
2886 AC_VERB_GET_DIGI_CONVERT_1, &val);
3821 sbits = convert_to_spdif_status(val); 2887 sbits = convert_to_spdif_status(val);
3822 ucontrol->value.iec958.status[0] = sbits; 2888 ucontrol->value.iec958.status[0] = sbits;
3823 ucontrol->value.iec958.status[1] = sbits >> 8; 2889 ucontrol->value.iec958.status[1] = sbits >> 8;
@@ -3883,153 +2949,6 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3883} 2949}
3884EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls); 2950EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
3885 2951
3886/*
3887 * command cache
3888 */
3889
3890/* build a 31bit cache key with the widget id and the command parameter */
3891#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3892#define get_cmd_cache_nid(key) ((key) & 0xff)
3893#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3894
3895/**
3896 * snd_hda_codec_write_cache - send a single command with caching
3897 * @codec: the HDA codec
3898 * @nid: NID to send the command
3899 * @flags: optional bit flags
3900 * @verb: the verb to send
3901 * @parm: the parameter for the verb
3902 *
3903 * Send a single command without waiting for response.
3904 *
3905 * Returns 0 if successful, or a negative error code.
3906 */
3907int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3908 int flags, unsigned int verb, unsigned int parm)
3909{
3910 int err;
3911 struct hda_cache_head *c;
3912 u32 key;
3913 unsigned int cache_only;
3914
3915 cache_only = codec->cached_write;
3916 if (!cache_only) {
3917 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
3918 if (err < 0)
3919 return err;
3920 }
3921
3922 /* parm may contain the verb stuff for get/set amp */
3923 verb = verb | (parm >> 8);
3924 parm &= 0xff;
3925 key = build_cmd_cache_key(nid, verb);
3926 mutex_lock(&codec->bus->cmd_mutex);
3927 c = get_alloc_hash(&codec->cmd_cache, key);
3928 if (c) {
3929 c->val = parm;
3930 c->dirty = cache_only;
3931 }
3932 mutex_unlock(&codec->bus->cmd_mutex);
3933 return 0;
3934}
3935EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
3936
3937/**
3938 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3939 * @codec: the HDA codec
3940 * @nid: NID to send the command
3941 * @flags: optional bit flags
3942 * @verb: the verb to send
3943 * @parm: the parameter for the verb
3944 *
3945 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3946 * command if the parameter is already identical with the cached value.
3947 * If not, it sends the command and refreshes the cache.
3948 *
3949 * Returns 0 if successful, or a negative error code.
3950 */
3951int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3952 int flags, unsigned int verb, unsigned int parm)
3953{
3954 struct hda_cache_head *c;
3955 u32 key;
3956
3957 /* parm may contain the verb stuff for get/set amp */
3958 verb = verb | (parm >> 8);
3959 parm &= 0xff;
3960 key = build_cmd_cache_key(nid, verb);
3961 mutex_lock(&codec->bus->cmd_mutex);
3962 c = get_hash(&codec->cmd_cache, key);
3963 if (c && c->val == parm) {
3964 mutex_unlock(&codec->bus->cmd_mutex);
3965 return 0;
3966 }
3967 mutex_unlock(&codec->bus->cmd_mutex);
3968 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
3969}
3970EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
3971
3972/**
3973 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3974 * @codec: HD-audio codec
3975 *
3976 * Execute all verbs recorded in the command caches to resume.
3977 */
3978void snd_hda_codec_resume_cache(struct hda_codec *codec)
3979{
3980 int i;
3981
3982 mutex_lock(&codec->hash_mutex);
3983 codec->cached_write = 0;
3984 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3985 struct hda_cache_head *buffer;
3986 u32 key;
3987
3988 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3989 key = buffer->key;
3990 if (!key)
3991 continue;
3992 if (!buffer->dirty)
3993 continue;
3994 buffer->dirty = 0;
3995 mutex_unlock(&codec->hash_mutex);
3996 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3997 get_cmd_cache_cmd(key), buffer->val);
3998 mutex_lock(&codec->hash_mutex);
3999 }
4000 mutex_unlock(&codec->hash_mutex);
4001}
4002EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
4003
4004/**
4005 * snd_hda_sequence_write_cache - sequence writes with caching
4006 * @codec: the HDA codec
4007 * @seq: VERB array to send
4008 *
4009 * Send the commands sequentially from the given array.
4010 * Thte commands are recorded on cache for power-save and resume.
4011 * The array must be terminated with NID=0.
4012 */
4013void snd_hda_sequence_write_cache(struct hda_codec *codec,
4014 const struct hda_verb *seq)
4015{
4016 for (; seq->nid; seq++)
4017 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
4018 seq->param);
4019}
4020EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
4021
4022/**
4023 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
4024 * @codec: HD-audio codec
4025 */
4026void snd_hda_codec_flush_cache(struct hda_codec *codec)
4027{
4028 snd_hda_codec_resume_amp(codec);
4029 snd_hda_codec_resume_cache(codec);
4030}
4031EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
4032
4033/** 2952/**
4034 * snd_hda_codec_set_power_to_all - Set the power state to all widgets 2953 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
4035 * @codec: the HDA codec 2954 * @codec: the HDA codec
@@ -4043,10 +2962,9 @@ EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
4043void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg, 2962void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
4044 unsigned int power_state) 2963 unsigned int power_state)
4045{ 2964{
4046 hda_nid_t nid = codec->start_nid; 2965 hda_nid_t nid;
4047 int i;
4048 2966
4049 for (i = 0; i < codec->num_nodes; i++, nid++) { 2967 for_each_hda_codec_node(nid, codec) {
4050 unsigned int wcaps = get_wcaps(codec, nid); 2968 unsigned int wcaps = get_wcaps(codec, nid);
4051 unsigned int state = power_state; 2969 unsigned int state = power_state;
4052 if (!(wcaps & AC_WCAP_POWER)) 2970 if (!(wcaps & AC_WCAP_POWER))
@@ -4063,22 +2981,6 @@ void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
4063EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all); 2981EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
4064 2982
4065/* 2983/*
4066 * supported power states check
4067 */
4068static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
4069 unsigned int power_state)
4070{
4071 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
4072
4073 if (sup == -1)
4074 return false;
4075 if (sup & power_state)
4076 return true;
4077 else
4078 return false;
4079}
4080
4081/*
4082 * wait until the state is reached, returns the current state 2984 * wait until the state is reached, returns the current state
4083 */ 2985 */
4084static unsigned int hda_sync_power_state(struct hda_codec *codec, 2986static unsigned int hda_sync_power_state(struct hda_codec *codec,
@@ -4117,7 +3019,7 @@ unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
4117 hda_nid_t nid, 3019 hda_nid_t nid,
4118 unsigned int power_state) 3020 unsigned int power_state)
4119{ 3021{
4120 if (nid == codec->afg || nid == codec->mfg) 3022 if (nid == codec->core.afg || nid == codec->core.mfg)
4121 return power_state; 3023 return power_state;
4122 if (power_state == AC_PWRST_D3 && 3024 if (power_state == AC_PWRST_D3 &&
4123 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN && 3025 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
@@ -4137,7 +3039,7 @@ EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
4137static unsigned int hda_set_power_state(struct hda_codec *codec, 3039static unsigned int hda_set_power_state(struct hda_codec *codec,
4138 unsigned int power_state) 3040 unsigned int power_state)
4139{ 3041{
4140 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg; 3042 hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
4141 int count; 3043 int count;
4142 unsigned int state; 3044 unsigned int state;
4143 int flags = 0; 3045 int flags = 0;
@@ -4145,7 +3047,7 @@ static unsigned int hda_set_power_state(struct hda_codec *codec,
4145 /* this delay seems necessary to avoid click noise at power-down */ 3047 /* this delay seems necessary to avoid click noise at power-down */
4146 if (power_state == AC_PWRST_D3) { 3048 if (power_state == AC_PWRST_D3) {
4147 if (codec->depop_delay < 0) 3049 if (codec->depop_delay < 0)
4148 msleep(codec->epss ? 10 : 100); 3050 msleep(codec_has_epss(codec) ? 10 : 100);
4149 else if (codec->depop_delay > 0) 3051 else if (codec->depop_delay > 0)
4150 msleep(codec->depop_delay); 3052 msleep(codec->depop_delay);
4151 flags = HDA_RW_NO_RESPONSE_FALLBACK; 3053 flags = HDA_RW_NO_RESPONSE_FALLBACK;
@@ -4179,14 +3081,13 @@ static unsigned int hda_set_power_state(struct hda_codec *codec,
4179 */ 3081 */
4180static void sync_power_up_states(struct hda_codec *codec) 3082static void sync_power_up_states(struct hda_codec *codec)
4181{ 3083{
4182 hda_nid_t nid = codec->start_nid; 3084 hda_nid_t nid;
4183 int i;
4184 3085
4185 /* don't care if no filter is used */ 3086 /* don't care if no filter is used */
4186 if (!codec->power_filter) 3087 if (!codec->power_filter)
4187 return; 3088 return;
4188 3089
4189 for (i = 0; i < codec->num_nodes; i++, nid++) { 3090 for_each_hda_codec_node(nid, codec) {
4190 unsigned int wcaps = get_wcaps(codec, nid); 3091 unsigned int wcaps = get_wcaps(codec, nid);
4191 unsigned int target; 3092 unsigned int target;
4192 if (!(wcaps & AC_WCAP_POWER)) 3093 if (!(wcaps & AC_WCAP_POWER))
@@ -4212,63 +3113,54 @@ static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
4212#endif 3113#endif
4213 3114
4214#ifdef CONFIG_PM 3115#ifdef CONFIG_PM
3116/* update the power on/off account with the current jiffies */
3117static void update_power_acct(struct hda_codec *codec, bool on)
3118{
3119 unsigned long delta = jiffies - codec->power_jiffies;
3120
3121 if (on)
3122 codec->power_on_acct += delta;
3123 else
3124 codec->power_off_acct += delta;
3125 codec->power_jiffies += delta;
3126}
3127
3128void snd_hda_update_power_acct(struct hda_codec *codec)
3129{
3130 update_power_acct(codec, hda_codec_is_power_on(codec));
3131}
3132
4215/* 3133/*
4216 * call suspend and power-down; used both from PM and power-save 3134 * call suspend and power-down; used both from PM and power-save
4217 * this function returns the power state in the end 3135 * this function returns the power state in the end
4218 */ 3136 */
4219static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq) 3137static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
4220{ 3138{
4221 unsigned int state; 3139 unsigned int state;
4222 3140
4223 codec->in_pm = 1; 3141 atomic_inc(&codec->core.in_pm);
4224 3142
4225 if (codec->patch_ops.suspend) 3143 if (codec->patch_ops.suspend)
4226 codec->patch_ops.suspend(codec); 3144 codec->patch_ops.suspend(codec);
4227 hda_cleanup_all_streams(codec); 3145 hda_cleanup_all_streams(codec);
4228 state = hda_set_power_state(codec, AC_PWRST_D3); 3146 state = hda_set_power_state(codec, AC_PWRST_D3);
4229 /* Cancel delayed work if we aren't currently running from it. */ 3147 update_power_acct(codec, true);
4230 if (!in_wq) 3148 atomic_dec(&codec->core.in_pm);
4231 cancel_delayed_work_sync(&codec->power_work);
4232 spin_lock(&codec->power_lock);
4233 snd_hda_update_power_acct(codec);
4234 trace_hda_power_down(codec);
4235 codec->power_on = 0;
4236 codec->power_transition = 0;
4237 codec->power_jiffies = jiffies;
4238 spin_unlock(&codec->power_lock);
4239 codec->in_pm = 0;
4240 return state; 3149 return state;
4241} 3150}
4242 3151
4243/* mark all entries of cmd and amp caches dirty */
4244static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
4245{
4246 int i;
4247 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
4248 struct hda_cache_head *cmd;
4249 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
4250 cmd->dirty = 1;
4251 }
4252 for (i = 0; i < codec->amp_cache.buf.used; i++) {
4253 struct hda_amp_info *amp;
4254 amp = snd_array_elem(&codec->amp_cache.buf, i);
4255 amp->head.dirty = 1;
4256 }
4257}
4258
4259/* 3152/*
4260 * kick up codec; used both from PM and power-save 3153 * kick up codec; used both from PM and power-save
4261 */ 3154 */
4262static void hda_call_codec_resume(struct hda_codec *codec) 3155static void hda_call_codec_resume(struct hda_codec *codec)
4263{ 3156{
4264 codec->in_pm = 1; 3157 atomic_inc(&codec->core.in_pm);
4265 3158
4266 hda_mark_cmd_cache_dirty(codec); 3159 if (codec->core.regmap)
3160 regcache_mark_dirty(codec->core.regmap);
3161
3162 codec->power_jiffies = jiffies;
4267 3163
4268 /* set as if powered on for avoiding re-entering the resume
4269 * in the resume / power-save sequence
4270 */
4271 hda_keep_power_on(codec);
4272 hda_set_power_state(codec, AC_PWRST_D0); 3164 hda_set_power_state(codec, AC_PWRST_D0);
4273 restore_shutup_pins(codec); 3165 restore_shutup_pins(codec);
4274 hda_exec_init_verbs(codec); 3166 hda_exec_init_verbs(codec);
@@ -4278,72 +3170,71 @@ static void hda_call_codec_resume(struct hda_codec *codec)
4278 else { 3170 else {
4279 if (codec->patch_ops.init) 3171 if (codec->patch_ops.init)
4280 codec->patch_ops.init(codec); 3172 codec->patch_ops.init(codec);
4281 snd_hda_codec_resume_amp(codec); 3173 if (codec->core.regmap)
4282 snd_hda_codec_resume_cache(codec); 3174 regcache_sync(codec->core.regmap);
4283 } 3175 }
4284 3176
4285 if (codec->jackpoll_interval) 3177 if (codec->jackpoll_interval)
4286 hda_jackpoll_work(&codec->jackpoll_work.work); 3178 hda_jackpoll_work(&codec->jackpoll_work.work);
4287 else 3179 else
4288 snd_hda_jack_report_sync(codec); 3180 snd_hda_jack_report_sync(codec);
4289 3181 atomic_dec(&codec->core.in_pm);
4290 codec->in_pm = 0;
4291 snd_hda_power_down(codec); /* flag down before returning */
4292} 3182}
4293#endif /* CONFIG_PM */
4294 3183
3184static int hda_codec_runtime_suspend(struct device *dev)
3185{
3186 struct hda_codec *codec = dev_to_hda_codec(dev);
3187 struct hda_pcm *pcm;
3188 unsigned int state;
4295 3189
4296/** 3190 cancel_delayed_work_sync(&codec->jackpoll_work);
4297 * snd_hda_build_controls - build mixer controls 3191 list_for_each_entry(pcm, &codec->pcm_list_head, list)
4298 * @bus: the BUS 3192 snd_pcm_suspend_all(pcm->pcm);
4299 * 3193 state = hda_call_codec_suspend(codec);
4300 * Creates mixer controls for each codec included in the bus. 3194 if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
4301 * 3195 (state & AC_PWRST_CLK_STOP_OK))
4302 * Returns 0 if successful, otherwise a negative error code. 3196 snd_hdac_codec_link_down(&codec->core);
4303 */ 3197 return 0;
4304int snd_hda_build_controls(struct hda_bus *bus) 3198}
3199
3200static int hda_codec_runtime_resume(struct device *dev)
4305{ 3201{
4306 struct hda_codec *codec; 3202 struct hda_codec *codec = dev_to_hda_codec(dev);
4307 3203
4308 list_for_each_entry(codec, &bus->codec_list, list) { 3204 snd_hdac_codec_link_up(&codec->core);
4309 int err = snd_hda_codec_build_controls(codec); 3205 hda_call_codec_resume(codec);
4310 if (err < 0) { 3206 pm_runtime_mark_last_busy(dev);
4311 codec_err(codec,
4312 "cannot build controls for #%d (error %d)\n",
4313 codec->addr, err);
4314 err = snd_hda_codec_reset(codec);
4315 if (err < 0) {
4316 codec_err(codec,
4317 "cannot revert codec\n");
4318 return err;
4319 }
4320 }
4321 }
4322 return 0; 3207 return 0;
4323} 3208}
4324EXPORT_SYMBOL_GPL(snd_hda_build_controls); 3209#endif /* CONFIG_PM */
3210
3211/* referred in hda_bind.c */
3212const struct dev_pm_ops hda_codec_driver_pm = {
3213 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3214 pm_runtime_force_resume)
3215 SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
3216 NULL)
3217};
4325 3218
4326/* 3219/*
4327 * add standard channel maps if not specified 3220 * add standard channel maps if not specified
4328 */ 3221 */
4329static int add_std_chmaps(struct hda_codec *codec) 3222static int add_std_chmaps(struct hda_codec *codec)
4330{ 3223{
4331 int i, str, err; 3224 struct hda_pcm *pcm;
3225 int str, err;
4332 3226
4333 for (i = 0; i < codec->num_pcms; i++) { 3227 list_for_each_entry(pcm, &codec->pcm_list_head, list) {
4334 for (str = 0; str < 2; str++) { 3228 for (str = 0; str < 2; str++) {
4335 struct snd_pcm *pcm = codec->pcm_info[i].pcm; 3229 struct hda_pcm_stream *hinfo = &pcm->stream[str];
4336 struct hda_pcm_stream *hinfo =
4337 &codec->pcm_info[i].stream[str];
4338 struct snd_pcm_chmap *chmap; 3230 struct snd_pcm_chmap *chmap;
4339 const struct snd_pcm_chmap_elem *elem; 3231 const struct snd_pcm_chmap_elem *elem;
4340 3232
4341 if (codec->pcm_info[i].own_chmap) 3233 if (!pcm || pcm->own_chmap ||
4342 continue; 3234 !hinfo->substreams)
4343 if (!pcm || !hinfo->substreams)
4344 continue; 3235 continue;
4345 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps; 3236 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4346 err = snd_pcm_add_chmap_ctls(pcm, str, elem, 3237 err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
4347 hinfo->channels_max, 3238 hinfo->channels_max,
4348 0, &chmap); 3239 0, &chmap);
4349 if (err < 0) 3240 if (err < 0)
@@ -4499,43 +3390,29 @@ unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
4499} 3390}
4500EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format); 3391EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
4501 3392
4502static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid, 3393static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4503 int dir)
4504{ 3394{
4505 unsigned int val = 0; 3395 unsigned int val = 0;
4506 if (nid != codec->afg && 3396 if (nid != codec->core.afg &&
4507 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) 3397 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4508 val = snd_hda_param_read(codec, nid, AC_PAR_PCM); 3398 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4509 if (!val || val == -1) 3399 if (!val || val == -1)
4510 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM); 3400 val = snd_hda_param_read(codec, codec->core.afg, AC_PAR_PCM);
4511 if (!val || val == -1) 3401 if (!val || val == -1)
4512 return 0; 3402 return 0;
4513 return val; 3403 return val;
4514} 3404}
4515 3405
4516static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid) 3406static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4517{
4518 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4519 get_pcm_param);
4520}
4521
4522static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4523 int dir)
4524{ 3407{
4525 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 3408 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4526 if (!streams || streams == -1) 3409 if (!streams || streams == -1)
4527 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM); 3410 streams = snd_hda_param_read(codec, codec->core.afg, AC_PAR_STREAM);
4528 if (!streams || streams == -1) 3411 if (!streams || streams == -1)
4529 return 0; 3412 return 0;
4530 return streams; 3413 return streams;
4531} 3414}
4532 3415
4533static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4534{
4535 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4536 get_stream_param);
4537}
4538
4539/** 3416/**
4540 * snd_hda_query_supported_pcm - query the supported PCM rates and formats 3417 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4541 * @codec: the HDA codec 3418 * @codec: the HDA codec
@@ -4792,7 +3669,11 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
4792{ 3669{
4793 int ret; 3670 int ret;
4794 mutex_lock(&codec->bus->prepare_mutex); 3671 mutex_lock(&codec->bus->prepare_mutex);
4795 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream); 3672 if (hinfo->ops.prepare)
3673 ret = hinfo->ops.prepare(hinfo, codec, stream, format,
3674 substream);
3675 else
3676 ret = -ENODEV;
4796 if (ret >= 0) 3677 if (ret >= 0)
4797 purify_inactive_streams(codec); 3678 purify_inactive_streams(codec);
4798 mutex_unlock(&codec->bus->prepare_mutex); 3679 mutex_unlock(&codec->bus->prepare_mutex);
@@ -4813,7 +3694,8 @@ void snd_hda_codec_cleanup(struct hda_codec *codec,
4813 struct snd_pcm_substream *substream) 3694 struct snd_pcm_substream *substream)
4814{ 3695{
4815 mutex_lock(&codec->bus->prepare_mutex); 3696 mutex_lock(&codec->bus->prepare_mutex);
4816 hinfo->ops.cleanup(hinfo, codec, substream); 3697 if (hinfo->ops.cleanup)
3698 hinfo->ops.cleanup(hinfo, codec, substream);
4817 mutex_unlock(&codec->bus->prepare_mutex); 3699 mutex_unlock(&codec->bus->prepare_mutex);
4818} 3700}
4819EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup); 3701EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
@@ -4871,112 +3753,84 @@ static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
4871 return -EAGAIN; 3753 return -EAGAIN;
4872} 3754}
4873 3755
4874/* 3756/* call build_pcms ops of the given codec and set up the default parameters */
4875 * attach a new PCM stream 3757int snd_hda_codec_parse_pcms(struct hda_codec *codec)
4876 */
4877static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4878{ 3758{
4879 struct hda_bus *bus = codec->bus; 3759 struct hda_pcm *cpcm;
4880 struct hda_pcm_stream *info; 3760 int err;
4881 int stream, err;
4882 3761
4883 if (snd_BUG_ON(!pcm->name)) 3762 if (!list_empty(&codec->pcm_list_head))
4884 return -EINVAL; 3763 return 0; /* already parsed */
4885 for (stream = 0; stream < 2; stream++) { 3764
4886 info = &pcm->stream[stream]; 3765 if (!codec->patch_ops.build_pcms)
4887 if (info->substreams) { 3766 return 0;
3767
3768 err = codec->patch_ops.build_pcms(codec);
3769 if (err < 0) {
3770 codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
3771 codec->core.addr, err);
3772 return err;
3773 }
3774
3775 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3776 int stream;
3777
3778 for (stream = 0; stream < 2; stream++) {
3779 struct hda_pcm_stream *info = &cpcm->stream[stream];
3780
3781 if (!info->substreams)
3782 continue;
4888 err = set_pcm_default_values(codec, info); 3783 err = set_pcm_default_values(codec, info);
4889 if (err < 0) 3784 if (err < 0) {
3785 codec_warn(codec,
3786 "fail to setup default for PCM %s\n",
3787 cpcm->name);
4890 return err; 3788 return err;
3789 }
4891 } 3790 }
4892 } 3791 }
4893 return bus->ops.attach_pcm(bus, codec, pcm); 3792
3793 return 0;
4894} 3794}
4895 3795
4896/* assign all PCMs of the given codec */ 3796/* assign all PCMs of the given codec */
4897int snd_hda_codec_build_pcms(struct hda_codec *codec) 3797int snd_hda_codec_build_pcms(struct hda_codec *codec)
4898{ 3798{
4899 unsigned int pcm; 3799 struct hda_bus *bus = codec->bus;
4900 int err; 3800 struct hda_pcm *cpcm;
3801 int dev, err;
4901 3802
4902 if (!codec->num_pcms) { 3803 if (snd_BUG_ON(!bus->ops.attach_pcm))
4903 if (!codec->patch_ops.build_pcms) 3804 return -EINVAL;
4904 return 0; 3805
4905 err = codec->patch_ops.build_pcms(codec); 3806 err = snd_hda_codec_parse_pcms(codec);
4906 if (err < 0) { 3807 if (err < 0) {
4907 codec_err(codec, 3808 snd_hda_codec_reset(codec);
4908 "cannot build PCMs for #%d (error %d)\n", 3809 return err;
4909 codec->addr, err);
4910 err = snd_hda_codec_reset(codec);
4911 if (err < 0) {
4912 codec_err(codec,
4913 "cannot revert codec\n");
4914 return err;
4915 }
4916 }
4917 } 3810 }
4918 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4919 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4920 int dev;
4921 3811
3812 /* attach a new PCM streams */
3813 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
3814 if (cpcm->pcm)
3815 continue; /* already attached */
4922 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams) 3816 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4923 continue; /* no substreams assigned */ 3817 continue; /* no substreams assigned */
4924 3818
4925 if (!cpcm->pcm) { 3819 dev = get_empty_pcm_device(bus, cpcm->pcm_type);
4926 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type); 3820 if (dev < 0)
4927 if (dev < 0) 3821 continue; /* no fatal error */
4928 continue; /* no fatal error */ 3822 cpcm->device = dev;
4929 cpcm->device = dev; 3823 err = bus->ops.attach_pcm(bus, codec, cpcm);
4930 err = snd_hda_attach_pcm(codec, cpcm); 3824 if (err < 0) {
4931 if (err < 0) { 3825 codec_err(codec,
4932 codec_err(codec, 3826 "cannot attach PCM stream %d for codec #%d\n",
4933 "cannot attach PCM stream %d for codec #%d\n", 3827 dev, codec->core.addr);
4934 dev, codec->addr); 3828 continue; /* no fatal error */
4935 continue; /* no fatal error */
4936 }
4937 } 3829 }
4938 } 3830 }
4939 return 0;
4940}
4941 3831
4942/**
4943 * snd_hda_build_pcms - build PCM information
4944 * @bus: the BUS
4945 *
4946 * Create PCM information for each codec included in the bus.
4947 *
4948 * The build_pcms codec patch is requested to set up codec->num_pcms and
4949 * codec->pcm_info properly. The array is referred by the top-level driver
4950 * to create its PCM instances.
4951 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4952 * callback.
4953 *
4954 * At least, substreams, channels_min and channels_max must be filled for
4955 * each stream. substreams = 0 indicates that the stream doesn't exist.
4956 * When rates and/or formats are zero, the supported values are queried
4957 * from the given nid. The nid is used also by the default ops.prepare
4958 * and ops.cleanup callbacks.
4959 *
4960 * The driver needs to call ops.open in its open callback. Similarly,
4961 * ops.close is supposed to be called in the close callback.
4962 * ops.prepare should be called in the prepare or hw_params callback
4963 * with the proper parameters for set up.
4964 * ops.cleanup should be called in hw_free for clean up of streams.
4965 *
4966 * This function returns 0 if successful, or a negative error code.
4967 */
4968int snd_hda_build_pcms(struct hda_bus *bus)
4969{
4970 struct hda_codec *codec;
4971
4972 list_for_each_entry(codec, &bus->codec_list, list) {
4973 int err = snd_hda_codec_build_pcms(codec);
4974 if (err < 0)
4975 return err;
4976 }
4977 return 0; 3832 return 0;
4978} 3833}
4979EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
4980 3834
4981/** 3835/**
4982 * snd_hda_add_new_ctls - create controls from the array 3836 * snd_hda_add_new_ctls - create controls from the array
@@ -5013,8 +3867,8 @@ int snd_hda_add_new_ctls(struct hda_codec *codec,
5013 * the codec addr; if it still fails (or it's the 3867 * the codec addr; if it still fails (or it's the
5014 * primary codec), then try another control index 3868 * primary codec), then try another control index
5015 */ 3869 */
5016 if (!addr && codec->addr) 3870 if (!addr && codec->core.addr)
5017 addr = codec->addr; 3871 addr = codec->core.addr;
5018 else if (!idx && !knew->index) { 3872 else if (!idx && !knew->index) {
5019 idx = find_empty_mixer_ctl_idx(codec, 3873 idx = find_empty_mixer_ctl_idx(codec,
5020 knew->name, 0); 3874 knew->name, 0);
@@ -5029,127 +3883,37 @@ int snd_hda_add_new_ctls(struct hda_codec *codec,
5029EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls); 3883EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
5030 3884
5031#ifdef CONFIG_PM 3885#ifdef CONFIG_PM
5032static void hda_power_work(struct work_struct *work) 3886static void codec_set_power_save(struct hda_codec *codec, int delay)
5033{
5034 struct hda_codec *codec =
5035 container_of(work, struct hda_codec, power_work.work);
5036 struct hda_bus *bus = codec->bus;
5037 unsigned int state;
5038
5039 spin_lock(&codec->power_lock);
5040 if (codec->power_transition > 0) { /* during power-up sequence? */
5041 spin_unlock(&codec->power_lock);
5042 return;
5043 }
5044 if (!codec->power_on || codec->power_count) {
5045 codec->power_transition = 0;
5046 spin_unlock(&codec->power_lock);
5047 return;
5048 }
5049 spin_unlock(&codec->power_lock);
5050
5051 state = hda_call_codec_suspend(codec, true);
5052 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK))
5053 hda_call_pm_notify(codec, false);
5054}
5055
5056static void hda_keep_power_on(struct hda_codec *codec)
5057{
5058 spin_lock(&codec->power_lock);
5059 codec->power_count++;
5060 codec->power_on = 1;
5061 codec->power_jiffies = jiffies;
5062 spin_unlock(&codec->power_lock);
5063 hda_call_pm_notify(codec, true);
5064}
5065
5066/* update the power on/off account with the current jiffies */
5067void snd_hda_update_power_acct(struct hda_codec *codec)
5068{
5069 unsigned long delta = jiffies - codec->power_jiffies;
5070 if (codec->power_on)
5071 codec->power_on_acct += delta;
5072 else
5073 codec->power_off_acct += delta;
5074 codec->power_jiffies += delta;
5075}
5076
5077/* Transition to powered up, if wait_power_down then wait for a pending
5078 * transition to D3 to complete. A pending D3 transition is indicated
5079 * with power_transition == -1. */
5080/* call this with codec->power_lock held! */
5081static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
5082{
5083 /* Return if power_on or transitioning to power_on, unless currently
5084 * powering down. */
5085 if ((codec->power_on || codec->power_transition > 0) &&
5086 !(wait_power_down && codec->power_transition < 0))
5087 return;
5088 spin_unlock(&codec->power_lock);
5089
5090 cancel_delayed_work_sync(&codec->power_work);
5091
5092 spin_lock(&codec->power_lock);
5093 /* If the power down delayed work was cancelled above before starting,
5094 * then there is no need to go through power up here.
5095 */
5096 if (codec->power_on) {
5097 if (codec->power_transition < 0)
5098 codec->power_transition = 0;
5099 return;
5100 }
5101
5102 trace_hda_power_up(codec);
5103 snd_hda_update_power_acct(codec);
5104 codec->power_on = 1;
5105 codec->power_jiffies = jiffies;
5106 codec->power_transition = 1; /* avoid reentrance */
5107 spin_unlock(&codec->power_lock);
5108
5109 hda_call_codec_resume(codec);
5110
5111 spin_lock(&codec->power_lock);
5112 codec->power_transition = 0;
5113}
5114
5115#define power_save(codec) \
5116 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
5117
5118/* Transition to powered down */
5119static void __snd_hda_power_down(struct hda_codec *codec)
5120{ 3887{
5121 if (!codec->power_on || codec->power_count || codec->power_transition) 3888 struct device *dev = hda_codec_dev(codec);
5122 return;
5123 3889
5124 if (power_save(codec)) { 3890 if (delay > 0) {
5125 codec->power_transition = -1; /* avoid reentrance */ 3891 pm_runtime_set_autosuspend_delay(dev, delay);
5126 queue_delayed_work(codec->bus->workq, &codec->power_work, 3892 pm_runtime_use_autosuspend(dev);
5127 msecs_to_jiffies(power_save(codec) * 1000)); 3893 pm_runtime_allow(dev);
3894 if (!pm_runtime_suspended(dev))
3895 pm_runtime_mark_last_busy(dev);
3896 } else {
3897 pm_runtime_dont_use_autosuspend(dev);
3898 pm_runtime_forbid(dev);
5128 } 3899 }
5129} 3900}
5130 3901
5131/** 3902/**
5132 * snd_hda_power_save - Power-up/down/sync the codec 3903 * snd_hda_set_power_save - reprogram autosuspend for the given delay
5133 * @codec: HD-audio codec 3904 * @bus: HD-audio bus
5134 * @delta: the counter delta to change 3905 * @delay: autosuspend delay in msec, 0 = off
5135 * @d3wait: sync for D3 transition complete
5136 * 3906 *
5137 * Change the power-up counter via @delta, and power up or down the hardware 3907 * Synchronize the runtime PM autosuspend state from the power_save option.
5138 * appropriately. For the power-down, queue to the delayed action.
5139 * Passing zero to @delta means to synchronize the power state.
5140 */ 3908 */
5141void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait) 3909void snd_hda_set_power_save(struct hda_bus *bus, int delay)
5142{ 3910{
5143 spin_lock(&codec->power_lock); 3911 struct hda_codec *c;
5144 codec->power_count += delta; 3912
5145 trace_hda_power_count(codec); 3913 list_for_each_codec(c, bus)
5146 if (delta > 0) 3914 codec_set_power_save(c, delay);
5147 __snd_hda_power_up(codec, d3wait);
5148 else
5149 __snd_hda_power_down(codec);
5150 spin_unlock(&codec->power_lock);
5151} 3915}
5152EXPORT_SYMBOL_GPL(snd_hda_power_save); 3916EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
5153 3917
5154/** 3918/**
5155 * snd_hda_check_amp_list_power - Check the amp list and update the power 3919 * snd_hda_check_amp_list_power - Check the amp list and update the power
@@ -5187,7 +3951,7 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec,
5187 if (!(v & HDA_AMP_MUTE) && v > 0) { 3951 if (!(v & HDA_AMP_MUTE) && v > 0) {
5188 if (!check->power_on) { 3952 if (!check->power_on) {
5189 check->power_on = 1; 3953 check->power_on = 1;
5190 snd_hda_power_up(codec); 3954 snd_hda_power_up_pm(codec);
5191 } 3955 }
5192 return 1; 3956 return 1;
5193 } 3957 }
@@ -5195,7 +3959,7 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec,
5195 } 3959 }
5196 if (check->power_on) { 3960 if (check->power_on) {
5197 check->power_on = 0; 3961 check->power_on = 0;
5198 snd_hda_power_down(codec); 3962 snd_hda_power_down_pm(codec);
5199 } 3963 }
5200 return 0; 3964 return 0;
5201} 3965}
@@ -5203,88 +3967,6 @@ EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
5203#endif 3967#endif
5204 3968
5205/* 3969/*
5206 * Channel mode helper
5207 */
5208
5209/**
5210 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5211 * @codec: the HDA codec
5212 * @uinfo: pointer to get/store the data
5213 * @chmode: channel mode array
5214 * @num_chmodes: channel mode array size
5215 */
5216int snd_hda_ch_mode_info(struct hda_codec *codec,
5217 struct snd_ctl_elem_info *uinfo,
5218 const struct hda_channel_mode *chmode,
5219 int num_chmodes)
5220{
5221 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5222 uinfo->count = 1;
5223 uinfo->value.enumerated.items = num_chmodes;
5224 if (uinfo->value.enumerated.item >= num_chmodes)
5225 uinfo->value.enumerated.item = num_chmodes - 1;
5226 sprintf(uinfo->value.enumerated.name, "%dch",
5227 chmode[uinfo->value.enumerated.item].channels);
5228 return 0;
5229}
5230EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
5231
5232/**
5233 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5234 * @codec: the HDA codec
5235 * @ucontrol: pointer to get/store the data
5236 * @chmode: channel mode array
5237 * @num_chmodes: channel mode array size
5238 * @max_channels: max number of channels
5239 */
5240int snd_hda_ch_mode_get(struct hda_codec *codec,
5241 struct snd_ctl_elem_value *ucontrol,
5242 const struct hda_channel_mode *chmode,
5243 int num_chmodes,
5244 int max_channels)
5245{
5246 int i;
5247
5248 for (i = 0; i < num_chmodes; i++) {
5249 if (max_channels == chmode[i].channels) {
5250 ucontrol->value.enumerated.item[0] = i;
5251 break;
5252 }
5253 }
5254 return 0;
5255}
5256EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
5257
5258/**
5259 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5260 * @codec: the HDA codec
5261 * @ucontrol: pointer to get/store the data
5262 * @chmode: channel mode array
5263 * @num_chmodes: channel mode array size
5264 * @max_channelsp: pointer to store the max channels
5265 */
5266int snd_hda_ch_mode_put(struct hda_codec *codec,
5267 struct snd_ctl_elem_value *ucontrol,
5268 const struct hda_channel_mode *chmode,
5269 int num_chmodes,
5270 int *max_channelsp)
5271{
5272 unsigned int mode;
5273
5274 mode = ucontrol->value.enumerated.item[0];
5275 if (mode >= num_chmodes)
5276 return -EINVAL;
5277 if (*max_channelsp == chmode[mode].channels)
5278 return 0;
5279 /* change the current channel setting */
5280 *max_channelsp = chmode[mode].channels;
5281 if (chmode[mode].sequence)
5282 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5283 return 1;
5284}
5285EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
5286
5287/*
5288 * input MUX helper 3970 * input MUX helper
5289 */ 3971 */
5290 3972
@@ -5418,24 +4100,6 @@ static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5418} 4100}
5419 4101
5420/** 4102/**
5421 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5422 * @bus: HD-audio bus
5423 */
5424void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5425{
5426 struct hda_codec *codec;
5427
5428 if (!bus)
5429 return;
5430 list_for_each_entry(codec, &bus->codec_list, list) {
5431 if (hda_codec_is_power_on(codec) &&
5432 codec->patch_ops.reboot_notify)
5433 codec->patch_ops.reboot_notify(codec);
5434 }
5435}
5436EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
5437
5438/**
5439 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode 4103 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5440 * @codec: the HDA codec 4104 * @codec: the HDA codec
5441 * @mout: hda_multi_out object 4105 * @mout: hda_multi_out object
@@ -5825,123 +4489,26 @@ int snd_hda_add_imux_item(struct hda_codec *codec,
5825} 4489}
5826EXPORT_SYMBOL_GPL(snd_hda_add_imux_item); 4490EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
5827 4491
5828
5829#ifdef CONFIG_PM
5830/*
5831 * power management
5832 */
5833
5834
5835static void hda_async_suspend(void *data, async_cookie_t cookie)
5836{
5837 hda_call_codec_suspend(data, false);
5838}
5839
5840static void hda_async_resume(void *data, async_cookie_t cookie)
5841{
5842 hda_call_codec_resume(data);
5843}
5844
5845/** 4492/**
5846 * snd_hda_suspend - suspend the codecs 4493 * snd_hda_bus_reset - Reset the bus
5847 * @bus: the HDA bus 4494 * @bus: HD-audio bus
5848 *
5849 * Returns 0 if successful.
5850 */ 4495 */
5851int snd_hda_suspend(struct hda_bus *bus) 4496void snd_hda_bus_reset(struct hda_bus *bus)
5852{ 4497{
5853 struct hda_codec *codec; 4498 struct hda_codec *codec;
5854 ASYNC_DOMAIN_EXCLUSIVE(domain);
5855 4499
5856 list_for_each_entry(codec, &bus->codec_list, list) { 4500 list_for_each_codec(codec, bus) {
4501 /* FIXME: maybe a better way needed for forced reset */
5857 cancel_delayed_work_sync(&codec->jackpoll_work); 4502 cancel_delayed_work_sync(&codec->jackpoll_work);
4503#ifdef CONFIG_PM
5858 if (hda_codec_is_power_on(codec)) { 4504 if (hda_codec_is_power_on(codec)) {
5859 if (bus->num_codecs > 1) 4505 hda_call_codec_suspend(codec);
5860 async_schedule_domain(hda_async_suspend, codec,
5861 &domain);
5862 else
5863 hda_call_codec_suspend(codec, false);
5864 }
5865 }
5866
5867 if (bus->num_codecs > 1)
5868 async_synchronize_full_domain(&domain);
5869
5870 return 0;
5871}
5872EXPORT_SYMBOL_GPL(snd_hda_suspend);
5873
5874/**
5875 * snd_hda_resume - resume the codecs
5876 * @bus: the HDA bus
5877 *
5878 * Returns 0 if successful.
5879 */
5880int snd_hda_resume(struct hda_bus *bus)
5881{
5882 struct hda_codec *codec;
5883 ASYNC_DOMAIN_EXCLUSIVE(domain);
5884
5885 list_for_each_entry(codec, &bus->codec_list, list) {
5886 if (bus->num_codecs > 1)
5887 async_schedule_domain(hda_async_resume, codec, &domain);
5888 else
5889 hda_call_codec_resume(codec); 4506 hda_call_codec_resume(codec);
4507 }
4508#endif
5890 } 4509 }
5891
5892 if (bus->num_codecs > 1)
5893 async_synchronize_full_domain(&domain);
5894
5895 return 0;
5896}
5897EXPORT_SYMBOL_GPL(snd_hda_resume);
5898#endif /* CONFIG_PM */
5899
5900/*
5901 * generic arrays
5902 */
5903
5904/**
5905 * snd_array_new - get a new element from the given array
5906 * @array: the array object
5907 *
5908 * Get a new element from the given array. If it exceeds the
5909 * pre-allocated array size, re-allocate the array.
5910 *
5911 * Returns NULL if allocation failed.
5912 */
5913void *snd_array_new(struct snd_array *array)
5914{
5915 if (snd_BUG_ON(!array->elem_size))
5916 return NULL;
5917 if (array->used >= array->alloced) {
5918 int num = array->alloced + array->alloc_align;
5919 int size = (num + 1) * array->elem_size;
5920 void *nlist;
5921 if (snd_BUG_ON(num >= 4096))
5922 return NULL;
5923 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
5924 if (!nlist)
5925 return NULL;
5926 array->list = nlist;
5927 array->alloced = num;
5928 }
5929 return snd_array_elem(array, array->used++);
5930}
5931EXPORT_SYMBOL_GPL(snd_array_new);
5932
5933/**
5934 * snd_array_free - free the given array elements
5935 * @array: the array object
5936 */
5937void snd_array_free(struct snd_array *array)
5938{
5939 kfree(array->list);
5940 array->used = 0;
5941 array->alloced = 0;
5942 array->list = NULL;
5943} 4510}
5944EXPORT_SYMBOL_GPL(snd_array_free); 4511EXPORT_SYMBOL_GPL(snd_hda_bus_reset);
5945 4512
5946/** 4513/**
5947 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer 4514 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 9c8820f21f94..9075ac28dc4b 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -21,41 +21,14 @@
21#ifndef __SOUND_HDA_CODEC_H 21#ifndef __SOUND_HDA_CODEC_H
22#define __SOUND_HDA_CODEC_H 22#define __SOUND_HDA_CODEC_H
23 23
24#include <linux/kref.h>
24#include <sound/info.h> 25#include <sound/info.h>
25#include <sound/control.h> 26#include <sound/control.h>
26#include <sound/pcm.h> 27#include <sound/pcm.h>
27#include <sound/hwdep.h> 28#include <sound/hwdep.h>
29#include <sound/hdaudio.h>
28#include <sound/hda_verbs.h> 30#include <sound/hda_verbs.h>
29 31#include <sound/hda_regmap.h>
30/*
31 * generic arrays
32 */
33struct snd_array {
34 unsigned int used;
35 unsigned int alloced;
36 unsigned int elem_size;
37 unsigned int alloc_align;
38 void *list;
39};
40
41void *snd_array_new(struct snd_array *array);
42void snd_array_free(struct snd_array *array);
43static inline void snd_array_init(struct snd_array *array, unsigned int size,
44 unsigned int align)
45{
46 array->elem_size = size;
47 array->alloc_align = align;
48}
49
50static inline void *snd_array_elem(struct snd_array *array, unsigned int idx)
51{
52 return array->list + idx * array->elem_size;
53}
54
55static inline unsigned int snd_array_index(struct snd_array *array, void *ptr)
56{
57 return (unsigned long)(ptr - array->list) / array->elem_size;
58}
59 32
60/* 33/*
61 * Structures 34 * Structures
@@ -66,10 +39,6 @@ struct hda_beep;
66struct hda_codec; 39struct hda_codec;
67struct hda_pcm; 40struct hda_pcm;
68struct hda_pcm_stream; 41struct hda_pcm_stream;
69struct hda_bus_unsolicited;
70
71/* NID type */
72typedef u16 hda_nid_t;
73 42
74/* bus operators */ 43/* bus operators */
75struct hda_bus_ops { 44struct hda_bus_ops {
@@ -84,10 +53,6 @@ struct hda_bus_ops {
84 struct hda_pcm *pcm); 53 struct hda_pcm *pcm);
85 /* reset bus for retry verb */ 54 /* reset bus for retry verb */
86 void (*bus_reset)(struct hda_bus *bus); 55 void (*bus_reset)(struct hda_bus *bus);
87#ifdef CONFIG_PM
88 /* notify power-up/down from codec to controller */
89 void (*pm_notify)(struct hda_bus *bus, bool power_up);
90#endif
91#ifdef CONFIG_SND_HDA_DSP_LOADER 56#ifdef CONFIG_SND_HDA_DSP_LOADER
92 /* prepare DSP transfer */ 57 /* prepare DSP transfer */
93 int (*load_dsp_prepare)(struct hda_bus *bus, unsigned int format, 58 int (*load_dsp_prepare)(struct hda_bus *bus, unsigned int format,
@@ -101,15 +66,6 @@ struct hda_bus_ops {
101#endif 66#endif
102}; 67};
103 68
104/* template to pass to the bus constructor */
105struct hda_bus_template {
106 void *private_data;
107 struct pci_dev *pci;
108 const char *modelname;
109 int *power_save;
110 struct hda_bus_ops ops;
111};
112
113/* 69/*
114 * codec bus 70 * codec bus
115 * 71 *
@@ -117,42 +73,28 @@ struct hda_bus_template {
117 * A hda_bus contains several codecs in the list codec_list. 73 * A hda_bus contains several codecs in the list codec_list.
118 */ 74 */
119struct hda_bus { 75struct hda_bus {
76 struct hdac_bus core;
77
120 struct snd_card *card; 78 struct snd_card *card;
121 79
122 /* copied from template */
123 void *private_data; 80 void *private_data;
124 struct pci_dev *pci; 81 struct pci_dev *pci;
125 const char *modelname; 82 const char *modelname;
126 int *power_save;
127 struct hda_bus_ops ops; 83 struct hda_bus_ops ops;
128 84
129 /* codec linked list */
130 struct list_head codec_list;
131 unsigned int num_codecs;
132 /* link caddr -> codec */
133 struct hda_codec *caddr_tbl[HDA_MAX_CODEC_ADDRESS + 1];
134
135 struct mutex cmd_mutex;
136 struct mutex prepare_mutex; 85 struct mutex prepare_mutex;
137 86
138 /* unsolicited event queue */
139 struct hda_bus_unsolicited *unsol;
140 char workq_name[16];
141 struct workqueue_struct *workq; /* common workqueue for codecs */
142
143 /* assigned PCMs */ 87 /* assigned PCMs */
144 DECLARE_BITMAP(pcm_dev_bits, SNDRV_PCM_DEVICES); 88 DECLARE_BITMAP(pcm_dev_bits, SNDRV_PCM_DEVICES);
145 89
146 /* misc op flags */ 90 /* misc op flags */
147 unsigned int needs_damn_long_delay :1; 91 unsigned int needs_damn_long_delay :1;
148 unsigned int allow_bus_reset:1; /* allow bus reset at fatal error */ 92 unsigned int allow_bus_reset:1; /* allow bus reset at fatal error */
149 unsigned int sync_write:1; /* sync after verb write */
150 /* status for codec/controller */ 93 /* status for codec/controller */
151 unsigned int shutdown :1; /* being unloaded */ 94 unsigned int shutdown :1; /* being unloaded */
152 unsigned int rirb_error:1; /* error in codec communication */ 95 unsigned int rirb_error:1; /* error in codec communication */
153 unsigned int response_reset:1; /* controller was reset */ 96 unsigned int response_reset:1; /* controller was reset */
154 unsigned int in_reset:1; /* during reset operation */ 97 unsigned int in_reset:1; /* during reset operation */
155 unsigned int power_keep_link_on:1; /* don't power off HDA link */
156 unsigned int no_response_fallback:1; /* don't fallback at RIRB error */ 98 unsigned int no_response_fallback:1; /* don't fallback at RIRB error */
157 99
158 int primary_dig_out_type; /* primary digital out PCM type */ 100 int primary_dig_out_type; /* primary digital out PCM type */
@@ -175,15 +117,22 @@ struct hda_codec_preset {
175 int (*patch)(struct hda_codec *codec); 117 int (*patch)(struct hda_codec *codec);
176}; 118};
177 119
178struct hda_codec_preset_list { 120#define HDA_CODEC_ID_GENERIC_HDMI 0x00000101
121#define HDA_CODEC_ID_GENERIC 0x00000201
122
123struct hda_codec_driver {
124 struct hdac_driver core;
179 const struct hda_codec_preset *preset; 125 const struct hda_codec_preset *preset;
180 struct module *owner;
181 struct list_head list;
182}; 126};
183 127
184/* initial hook */ 128int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name,
185int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset); 129 struct module *owner);
186int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset); 130#define hda_codec_driver_register(drv) \
131 __hda_codec_driver_register(drv, KBUILD_MODNAME, THIS_MODULE)
132void hda_codec_driver_unregister(struct hda_codec_driver *drv);
133#define module_hda_codec_driver(drv) \
134 module_driver(drv, hda_codec_driver_register, \
135 hda_codec_driver_unregister)
187 136
188/* ops set by the preset patch */ 137/* ops set by the preset patch */
189struct hda_codec_ops { 138struct hda_codec_ops {
@@ -200,25 +149,7 @@ struct hda_codec_ops {
200 int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid); 149 int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid);
201#endif 150#endif
202 void (*reboot_notify)(struct hda_codec *codec); 151 void (*reboot_notify)(struct hda_codec *codec);
203}; 152 void (*stream_pm)(struct hda_codec *codec, hda_nid_t nid, bool on);
204
205/* record for amp information cache */
206struct hda_cache_head {
207 u32 key:31; /* hash key */
208 u32 dirty:1;
209 u16 val; /* assigned value */
210 u16 next;
211};
212
213struct hda_amp_info {
214 struct hda_cache_head head;
215 u32 amp_caps; /* amp capabilities */
216 u16 vol[2]; /* current volume & mute */
217};
218
219struct hda_cache_rec {
220 u16 hash[64]; /* hash table for index */
221 struct snd_array buf; /* record entries */
222}; 153};
223 154
224/* PCM callbacks */ 155/* PCM callbacks */
@@ -267,41 +198,29 @@ struct hda_pcm {
267 int device; /* device number to assign */ 198 int device; /* device number to assign */
268 struct snd_pcm *pcm; /* assigned PCM instance */ 199 struct snd_pcm *pcm; /* assigned PCM instance */
269 bool own_chmap; /* codec driver provides own channel maps */ 200 bool own_chmap; /* codec driver provides own channel maps */
201 /* private: */
202 struct hda_codec *codec;
203 struct kref kref;
204 struct list_head list;
270}; 205};
271 206
272/* codec information */ 207/* codec information */
273struct hda_codec { 208struct hda_codec {
274 struct device dev; 209 struct hdac_device core;
275 struct hda_bus *bus; 210 struct hda_bus *bus;
211 struct snd_card *card;
276 unsigned int addr; /* codec addr*/ 212 unsigned int addr; /* codec addr*/
277 struct list_head list; /* list point */ 213 u32 probe_id; /* overridden id for probing */
278
279 hda_nid_t afg; /* AFG node id */
280 hda_nid_t mfg; /* MFG node id */
281
282 /* ids */
283 u8 afg_function_id;
284 u8 mfg_function_id;
285 u8 afg_unsol;
286 u8 mfg_unsol;
287 u32 vendor_id;
288 u32 subsystem_id;
289 u32 revision_id;
290 214
291 /* detected preset */ 215 /* detected preset */
292 const struct hda_codec_preset *preset; 216 const struct hda_codec_preset *preset;
293 struct module *owner;
294 int (*parser)(struct hda_codec *codec);
295 const char *vendor_name; /* codec vendor name */
296 const char *chip_name; /* codec chip name */
297 const char *modelname; /* model name for preset */ 217 const char *modelname; /* model name for preset */
298 218
299 /* set by patch */ 219 /* set by patch */
300 struct hda_codec_ops patch_ops; 220 struct hda_codec_ops patch_ops;
301 221
302 /* PCM to create, set by patch_ops.build_pcms callback */ 222 /* PCM to create, set by patch_ops.build_pcms callback */
303 unsigned int num_pcms; 223 struct list_head pcm_list_head;
304 struct hda_pcm *pcm_info;
305 224
306 /* codec specific info */ 225 /* codec specific info */
307 void *spec; 226 void *spec;
@@ -311,21 +230,15 @@ struct hda_codec {
311 unsigned int beep_mode; 230 unsigned int beep_mode;
312 231
313 /* widget capabilities cache */ 232 /* widget capabilities cache */
314 unsigned int num_nodes;
315 hda_nid_t start_nid;
316 u32 *wcaps; 233 u32 *wcaps;
317 234
318 struct snd_array mixers; /* list of assigned mixer elements */ 235 struct snd_array mixers; /* list of assigned mixer elements */
319 struct snd_array nids; /* list of mapped mixer elements */ 236 struct snd_array nids; /* list of mapped mixer elements */
320 237
321 struct hda_cache_rec amp_cache; /* cache for amp access */
322 struct hda_cache_rec cmd_cache; /* cache for other commands */
323
324 struct list_head conn_list; /* linked-list of connection-list */ 238 struct list_head conn_list; /* linked-list of connection-list */
325 239
326 struct mutex spdif_mutex; 240 struct mutex spdif_mutex;
327 struct mutex control_mutex; 241 struct mutex control_mutex;
328 struct mutex hash_mutex;
329 struct snd_array spdif_out; 242 struct snd_array spdif_out;
330 unsigned int spdif_in_enable; /* SPDIF input enable? */ 243 unsigned int spdif_in_enable; /* SPDIF input enable? */
331 const hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */ 244 const hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
@@ -345,6 +258,8 @@ struct hda_codec {
345#endif 258#endif
346 259
347 /* misc flags */ 260 /* misc flags */
261 unsigned int in_freeing:1; /* being released */
262 unsigned int registered:1; /* codec was registered */
348 unsigned int spdif_status_reset :1; /* needs to toggle SPDIF for each 263 unsigned int spdif_status_reset :1; /* needs to toggle SPDIF for each
349 * status change 264 * status change
350 * (e.g. Realtek codecs) 265 * (e.g. Realtek codecs)
@@ -362,22 +277,14 @@ struct hda_codec {
362 unsigned int inv_eapd:1; /* broken h/w: inverted EAPD control */ 277 unsigned int inv_eapd:1; /* broken h/w: inverted EAPD control */
363 unsigned int inv_jack_detect:1; /* broken h/w: inverted detection bit */ 278 unsigned int inv_jack_detect:1; /* broken h/w: inverted detection bit */
364 unsigned int pcm_format_first:1; /* PCM format must be set first */ 279 unsigned int pcm_format_first:1; /* PCM format must be set first */
365 unsigned int epss:1; /* supporting EPSS? */
366 unsigned int cached_write:1; /* write only to caches */ 280 unsigned int cached_write:1; /* write only to caches */
367 unsigned int dp_mst:1; /* support DP1.2 Multi-stream transport */ 281 unsigned int dp_mst:1; /* support DP1.2 Multi-stream transport */
368 unsigned int dump_coef:1; /* dump processing coefs in codec proc file */ 282 unsigned int dump_coef:1; /* dump processing coefs in codec proc file */
283 unsigned int power_save_node:1; /* advanced PM for each widget */
369#ifdef CONFIG_PM 284#ifdef CONFIG_PM
370 unsigned int power_on :1; /* current (global) power-state */
371 unsigned int d3_stop_clk:1; /* support D3 operation without BCLK */
372 unsigned int pm_up_notified:1; /* PM notified to controller */
373 unsigned int in_pm:1; /* suspend/resume being performed */
374 int power_transition; /* power-state in transition */
375 int power_count; /* current (global) power refcount */
376 struct delayed_work power_work; /* delayed task for powerdown */
377 unsigned long power_on_acct; 285 unsigned long power_on_acct;
378 unsigned long power_off_acct; 286 unsigned long power_off_acct;
379 unsigned long power_jiffies; 287 unsigned long power_jiffies;
380 spinlock_t power_lock;
381#endif 288#endif
382 289
383 /* filter the requested power state per nid */ 290 /* filter the requested power state per nid */
@@ -409,10 +316,11 @@ struct hda_codec {
409 struct snd_array verbs; 316 struct snd_array verbs;
410}; 317};
411 318
412/* direction */ 319#define dev_to_hda_codec(_dev) container_of(_dev, struct hda_codec, core.dev)
413enum { 320#define hda_codec_dev(_dev) (&(_dev)->core.dev)
414 HDA_INPUT, HDA_OUTPUT 321
415}; 322#define list_for_each_codec(c, bus) \
323 list_for_each_entry(c, &(bus)->core.codec_list, core.list)
416 324
417/* snd_hda_codec_read/write optional flags */ 325/* snd_hda_codec_read/write optional flags */
418#define HDA_RW_NO_RESPONSE_FALLBACK (1 << 0) 326#define HDA_RW_NO_RESPONSE_FALLBACK (1 << 0)
@@ -420,10 +328,9 @@ enum {
420/* 328/*
421 * constructors 329 * constructors
422 */ 330 */
423int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, 331int snd_hda_bus_new(struct snd_card *card, struct hda_bus **busp);
424 struct hda_bus **busp); 332int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
425int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, 333 unsigned int codec_addr, struct hda_codec **codecp);
426 struct hda_codec **codecp);
427int snd_hda_codec_configure(struct hda_codec *codec); 334int snd_hda_codec_configure(struct hda_codec *codec);
428int snd_hda_codec_update_widgets(struct hda_codec *codec); 335int snd_hda_codec_update_widgets(struct hda_codec *codec);
429 336
@@ -436,9 +343,9 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
436int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags, 343int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
437 unsigned int verb, unsigned int parm); 344 unsigned int verb, unsigned int parm);
438#define snd_hda_param_read(codec, nid, param) \ 345#define snd_hda_param_read(codec, nid, param) \
439 snd_hda_codec_read(codec, nid, 0, AC_VERB_PARAMETERS, param) 346 snd_hdac_read_parm(&(codec)->core, nid, param)
440int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, 347#define snd_hda_get_sub_nodes(codec, nid, start_nid) \
441 hda_nid_t *start_id); 348 snd_hdac_get_sub_nodes(&(codec)->core, nid, start_nid)
442int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, 349int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
443 hda_nid_t *conn_list, int max_conns); 350 hda_nid_t *conn_list, int max_conns);
444static inline int 351static inline int
@@ -446,9 +353,12 @@ snd_hda_get_num_conns(struct hda_codec *codec, hda_nid_t nid)
446{ 353{
447 return snd_hda_get_connections(codec, nid, NULL, 0); 354 return snd_hda_get_connections(codec, nid, NULL, 0);
448} 355}
449int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid); 356
450int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid, 357#define snd_hda_get_raw_connections(codec, nid, list, max_conns) \
451 hda_nid_t *conn_list, int max_conns); 358 snd_hdac_get_connections(&(codec)->core, nid, list, max_conns)
359#define snd_hda_get_num_raw_conns(codec, nid) \
360 snd_hdac_get_connections(&(codec)->core, nid, NULL, 0);
361
452int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid, 362int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
453 const hda_nid_t **listp); 363 const hda_nid_t **listp);
454int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums, 364int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums,
@@ -470,18 +380,22 @@ void snd_hda_sequence_write(struct hda_codec *codec,
470 const struct hda_verb *seq); 380 const struct hda_verb *seq);
471 381
472/* unsolicited event */ 382/* unsolicited event */
473int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex); 383static inline void
384snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
385{
386 snd_hdac_bus_queue_event(&bus->core, res, res_ex);
387}
474 388
475/* cached write */ 389/* cached write */
476int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid, 390static inline int
477 int flags, unsigned int verb, unsigned int parm); 391snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
478void snd_hda_sequence_write_cache(struct hda_codec *codec, 392 int flags, unsigned int verb, unsigned int parm)
479 const struct hda_verb *seq); 393{
480int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid, 394 return snd_hdac_regmap_write(&codec->core, nid, verb, parm);
481 int flags, unsigned int verb, unsigned int parm); 395}
482void snd_hda_codec_resume_cache(struct hda_codec *codec); 396
483/* both for cmd & amp caches */ 397#define snd_hda_codec_update_cache(codec, nid, flags, verb, parm) \
484void snd_hda_codec_flush_cache(struct hda_codec *codec); 398 snd_hda_codec_write_cache(codec, nid, flags, verb, parm)
485 399
486/* the struct for codec->pin_configs */ 400/* the struct for codec->pin_configs */
487struct hda_pincfg { 401struct hda_pincfg {
@@ -512,15 +426,24 @@ void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid);
512/* 426/*
513 * Mixer 427 * Mixer
514 */ 428 */
515int snd_hda_build_controls(struct hda_bus *bus);
516int snd_hda_codec_build_controls(struct hda_codec *codec); 429int snd_hda_codec_build_controls(struct hda_codec *codec);
517 430
518/* 431/*
519 * PCM 432 * PCM
520 */ 433 */
521int snd_hda_build_pcms(struct hda_bus *bus); 434int snd_hda_codec_parse_pcms(struct hda_codec *codec);
522int snd_hda_codec_build_pcms(struct hda_codec *codec); 435int snd_hda_codec_build_pcms(struct hda_codec *codec);
523 436
437__printf(2, 3)
438struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
439 const char *fmt, ...);
440
441static inline void snd_hda_codec_pcm_get(struct hda_pcm *pcm)
442{
443 kref_get(&pcm->kref);
444}
445void snd_hda_codec_pcm_put(struct hda_pcm *pcm);
446
524int snd_hda_codec_prepare(struct hda_codec *codec, 447int snd_hda_codec_prepare(struct hda_codec *codec,
525 struct hda_pcm_stream *hinfo, 448 struct hda_pcm_stream *hinfo,
526 unsigned int stream, 449 unsigned int stream,
@@ -552,20 +475,17 @@ extern const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[];
552 * Misc 475 * Misc
553 */ 476 */
554void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen); 477void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen);
555void snd_hda_bus_reboot_notify(struct hda_bus *bus);
556void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg, 478void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
557 unsigned int power_state); 479 unsigned int power_state);
558 480
559int snd_hda_lock_devices(struct hda_bus *bus); 481int snd_hda_lock_devices(struct hda_bus *bus);
560void snd_hda_unlock_devices(struct hda_bus *bus); 482void snd_hda_unlock_devices(struct hda_bus *bus);
483void snd_hda_bus_reset(struct hda_bus *bus);
561 484
562/* 485/*
563 * power management 486 * power management
564 */ 487 */
565#ifdef CONFIG_PM 488extern const struct dev_pm_ops hda_codec_driver_pm;
566int snd_hda_suspend(struct hda_bus *bus);
567int snd_hda_resume(struct hda_bus *bus);
568#endif
569 489
570static inline 490static inline
571int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid) 491int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid)
@@ -587,65 +507,17 @@ const char *snd_hda_get_jack_location(u32 cfg);
587/* 507/*
588 * power saving 508 * power saving
589 */ 509 */
510#define snd_hda_power_up(codec) snd_hdac_power_up(&(codec)->core)
511#define snd_hda_power_up_pm(codec) snd_hdac_power_up_pm(&(codec)->core)
512#define snd_hda_power_down(codec) snd_hdac_power_down(&(codec)->core)
513#define snd_hda_power_down_pm(codec) snd_hdac_power_down_pm(&(codec)->core)
590#ifdef CONFIG_PM 514#ifdef CONFIG_PM
591void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait); 515void snd_hda_set_power_save(struct hda_bus *bus, int delay);
592void snd_hda_update_power_acct(struct hda_codec *codec); 516void snd_hda_update_power_acct(struct hda_codec *codec);
593#else 517#else
594static inline void snd_hda_power_save(struct hda_codec *codec, int delta, 518static inline void snd_hda_set_power_save(struct hda_bus *bus, int delay) {}
595 bool d3wait) {}
596#endif 519#endif
597 520
598/**
599 * snd_hda_power_up - Power-up the codec
600 * @codec: HD-audio codec
601 *
602 * Increment the power-up counter and power up the hardware really when
603 * not turned on yet.
604 */
605static inline void snd_hda_power_up(struct hda_codec *codec)
606{
607 snd_hda_power_save(codec, 1, false);
608}
609
610/**
611 * snd_hda_power_up_d3wait - Power-up the codec after waiting for any pending
612 * D3 transition to complete. This differs from snd_hda_power_up() when
613 * power_transition == -1. snd_hda_power_up sees this case as a nop,
614 * snd_hda_power_up_d3wait waits for the D3 transition to complete then powers
615 * back up.
616 * @codec: HD-audio codec
617 *
618 * Cancel any power down operation hapenning on the work queue, then power up.
619 */
620static inline void snd_hda_power_up_d3wait(struct hda_codec *codec)
621{
622 snd_hda_power_save(codec, 1, true);
623}
624
625/**
626 * snd_hda_power_down - Power-down the codec
627 * @codec: HD-audio codec
628 *
629 * Decrement the power-up counter and schedules the power-off work if
630 * the counter rearches to zero.
631 */
632static inline void snd_hda_power_down(struct hda_codec *codec)
633{
634 snd_hda_power_save(codec, -1, false);
635}
636
637/**
638 * snd_hda_power_sync - Synchronize the power-save status
639 * @codec: HD-audio codec
640 *
641 * Synchronize the actual power state with the power account;
642 * called when power_save parameter is changed
643 */
644static inline void snd_hda_power_sync(struct hda_codec *codec)
645{
646 snd_hda_power_save(codec, 0, false);
647}
648
649#ifdef CONFIG_SND_HDA_PATCH_LOADER 521#ifdef CONFIG_SND_HDA_PATCH_LOADER
650/* 522/*
651 * patch firmware 523 * patch firmware
diff --git a/sound/pci/hda/hda_controller.c b/sound/pci/hda/hda_controller.c
index 17c2637d842c..26ce990592a0 100644
--- a/sound/pci/hda/hda_controller.c
+++ b/sound/pci/hda/hda_controller.c
@@ -27,10 +27,8 @@
27#include <linux/module.h> 27#include <linux/module.h>
28#include <linux/pm_runtime.h> 28#include <linux/pm_runtime.h>
29#include <linux/slab.h> 29#include <linux/slab.h>
30#include <linux/reboot.h>
31#include <sound/core.h> 30#include <sound/core.h>
32#include <sound/initval.h> 31#include <sound/initval.h>
33#include "hda_priv.h"
34#include "hda_controller.h" 32#include "hda_controller.h"
35 33
36#define CREATE_TRACE_POINTS 34#define CREATE_TRACE_POINTS
@@ -259,11 +257,18 @@ static void azx_timecounter_init(struct snd_pcm_substream *substream,
259 tc->cycle_last = last; 257 tc->cycle_last = last;
260} 258}
261 259
260static inline struct hda_pcm_stream *
261to_hda_pcm_stream(struct snd_pcm_substream *substream)
262{
263 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
264 return &apcm->info->stream[substream->stream];
265}
266
262static u64 azx_adjust_codec_delay(struct snd_pcm_substream *substream, 267static u64 azx_adjust_codec_delay(struct snd_pcm_substream *substream,
263 u64 nsec) 268 u64 nsec)
264{ 269{
265 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 270 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
266 struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; 271 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
267 u64 codec_frames, codec_nsecs; 272 u64 codec_frames, codec_nsecs;
268 273
269 if (!hinfo->ops.get_delay) 274 if (!hinfo->ops.get_delay)
@@ -399,7 +404,7 @@ static int azx_setup_periods(struct azx *chip,
399static int azx_pcm_close(struct snd_pcm_substream *substream) 404static int azx_pcm_close(struct snd_pcm_substream *substream)
400{ 405{
401 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 406 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
402 struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; 407 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
403 struct azx *chip = apcm->chip; 408 struct azx *chip = apcm->chip;
404 struct azx_dev *azx_dev = get_azx_dev(substream); 409 struct azx_dev *azx_dev = get_azx_dev(substream);
405 unsigned long flags; 410 unsigned long flags;
@@ -410,9 +415,11 @@ static int azx_pcm_close(struct snd_pcm_substream *substream)
410 azx_dev->running = 0; 415 azx_dev->running = 0;
411 spin_unlock_irqrestore(&chip->reg_lock, flags); 416 spin_unlock_irqrestore(&chip->reg_lock, flags);
412 azx_release_device(azx_dev); 417 azx_release_device(azx_dev);
413 hinfo->ops.close(hinfo, apcm->codec, substream); 418 if (hinfo->ops.close)
419 hinfo->ops.close(hinfo, apcm->codec, substream);
414 snd_hda_power_down(apcm->codec); 420 snd_hda_power_down(apcm->codec);
415 mutex_unlock(&chip->open_mutex); 421 mutex_unlock(&chip->open_mutex);
422 snd_hda_codec_pcm_put(apcm->info);
416 return 0; 423 return 0;
417} 424}
418 425
@@ -441,7 +448,7 @@ static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
441 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 448 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
442 struct azx_dev *azx_dev = get_azx_dev(substream); 449 struct azx_dev *azx_dev = get_azx_dev(substream);
443 struct azx *chip = apcm->chip; 450 struct azx *chip = apcm->chip;
444 struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; 451 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
445 int err; 452 int err;
446 453
447 /* reset BDL address */ 454 /* reset BDL address */
@@ -468,7 +475,7 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
468 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 475 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
469 struct azx *chip = apcm->chip; 476 struct azx *chip = apcm->chip;
470 struct azx_dev *azx_dev = get_azx_dev(substream); 477 struct azx_dev *azx_dev = get_azx_dev(substream);
471 struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; 478 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
472 struct snd_pcm_runtime *runtime = substream->runtime; 479 struct snd_pcm_runtime *runtime = substream->runtime;
473 unsigned int bufsize, period_bytes, format_val, stream_tag; 480 unsigned int bufsize, period_bytes, format_val, stream_tag;
474 int err; 481 int err;
@@ -708,7 +715,7 @@ unsigned int azx_get_position(struct azx *chip,
708 715
709 if (substream->runtime) { 716 if (substream->runtime) {
710 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 717 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
711 struct hda_pcm_stream *hinfo = apcm->hinfo[stream]; 718 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
712 719
713 if (chip->get_delay[stream]) 720 if (chip->get_delay[stream])
714 delay += chip->get_delay[stream](chip, azx_dev, pos); 721 delay += chip->get_delay[stream](chip, azx_dev, pos);
@@ -732,17 +739,32 @@ static snd_pcm_uframes_t azx_pcm_pointer(struct snd_pcm_substream *substream)
732 azx_get_position(chip, azx_dev)); 739 azx_get_position(chip, azx_dev));
733} 740}
734 741
735static int azx_get_wallclock_tstamp(struct snd_pcm_substream *substream, 742static int azx_get_time_info(struct snd_pcm_substream *substream,
736 struct timespec *ts) 743 struct timespec *system_ts, struct timespec *audio_ts,
744 struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
745 struct snd_pcm_audio_tstamp_report *audio_tstamp_report)
737{ 746{
738 struct azx_dev *azx_dev = get_azx_dev(substream); 747 struct azx_dev *azx_dev = get_azx_dev(substream);
739 u64 nsec; 748 u64 nsec;
740 749
741 nsec = timecounter_read(&azx_dev->azx_tc); 750 if ((substream->runtime->hw.info & SNDRV_PCM_INFO_HAS_LINK_ATIME) &&
742 nsec = div_u64(nsec, 3); /* can be optimized */ 751 (audio_tstamp_config->type_requested == SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK)) {
743 nsec = azx_adjust_codec_delay(substream, nsec); 752
753 snd_pcm_gettime(substream->runtime, system_ts);
744 754
745 *ts = ns_to_timespec(nsec); 755 nsec = timecounter_read(&azx_dev->azx_tc);
756 nsec = div_u64(nsec, 3); /* can be optimized */
757 if (audio_tstamp_config->report_delay)
758 nsec = azx_adjust_codec_delay(substream, nsec);
759
760 *audio_ts = ns_to_timespec(nsec);
761
762 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK;
763 audio_tstamp_report->accuracy_report = 1; /* rest of structure is valid */
764 audio_tstamp_report->accuracy = 42; /* 24 MHz WallClock == 42ns resolution */
765
766 } else
767 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
746 768
747 return 0; 769 return 0;
748} 770}
@@ -756,7 +778,8 @@ static struct snd_pcm_hardware azx_pcm_hw = {
756 /* SNDRV_PCM_INFO_RESUME |*/ 778 /* SNDRV_PCM_INFO_RESUME |*/
757 SNDRV_PCM_INFO_PAUSE | 779 SNDRV_PCM_INFO_PAUSE |
758 SNDRV_PCM_INFO_SYNC_START | 780 SNDRV_PCM_INFO_SYNC_START |
759 SNDRV_PCM_INFO_HAS_WALL_CLOCK | 781 SNDRV_PCM_INFO_HAS_WALL_CLOCK | /* legacy */
782 SNDRV_PCM_INFO_HAS_LINK_ATIME |
760 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP), 783 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP),
761 .formats = SNDRV_PCM_FMTBIT_S16_LE, 784 .formats = SNDRV_PCM_FMTBIT_S16_LE,
762 .rates = SNDRV_PCM_RATE_48000, 785 .rates = SNDRV_PCM_RATE_48000,
@@ -775,7 +798,7 @@ static struct snd_pcm_hardware azx_pcm_hw = {
775static int azx_pcm_open(struct snd_pcm_substream *substream) 798static int azx_pcm_open(struct snd_pcm_substream *substream)
776{ 799{
777 struct azx_pcm *apcm = snd_pcm_substream_chip(substream); 800 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
778 struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; 801 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
779 struct azx *chip = apcm->chip; 802 struct azx *chip = apcm->chip;
780 struct azx_dev *azx_dev; 803 struct azx_dev *azx_dev;
781 struct snd_pcm_runtime *runtime = substream->runtime; 804 struct snd_pcm_runtime *runtime = substream->runtime;
@@ -783,11 +806,12 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
783 int err; 806 int err;
784 int buff_step; 807 int buff_step;
785 808
809 snd_hda_codec_pcm_get(apcm->info);
786 mutex_lock(&chip->open_mutex); 810 mutex_lock(&chip->open_mutex);
787 azx_dev = azx_assign_device(chip, substream); 811 azx_dev = azx_assign_device(chip, substream);
788 if (azx_dev == NULL) { 812 if (azx_dev == NULL) {
789 mutex_unlock(&chip->open_mutex); 813 err = -EBUSY;
790 return -EBUSY; 814 goto unlock;
791 } 815 }
792 runtime->hw = azx_pcm_hw; 816 runtime->hw = azx_pcm_hw;
793 runtime->hw.channels_min = hinfo->channels_min; 817 runtime->hw.channels_min = hinfo->channels_min;
@@ -821,13 +845,14 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
821 buff_step); 845 buff_step);
822 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 846 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
823 buff_step); 847 buff_step);
824 snd_hda_power_up_d3wait(apcm->codec); 848 snd_hda_power_up(apcm->codec);
825 err = hinfo->ops.open(hinfo, apcm->codec, substream); 849 if (hinfo->ops.open)
850 err = hinfo->ops.open(hinfo, apcm->codec, substream);
851 else
852 err = -ENODEV;
826 if (err < 0) { 853 if (err < 0) {
827 azx_release_device(azx_dev); 854 azx_release_device(azx_dev);
828 snd_hda_power_down(apcm->codec); 855 goto powerdown;
829 mutex_unlock(&chip->open_mutex);
830 return err;
831 } 856 }
832 snd_pcm_limit_hw_rates(runtime); 857 snd_pcm_limit_hw_rates(runtime);
833 /* sanity check */ 858 /* sanity check */
@@ -836,16 +861,18 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
836 snd_BUG_ON(!runtime->hw.formats) || 861 snd_BUG_ON(!runtime->hw.formats) ||
837 snd_BUG_ON(!runtime->hw.rates)) { 862 snd_BUG_ON(!runtime->hw.rates)) {
838 azx_release_device(azx_dev); 863 azx_release_device(azx_dev);
839 hinfo->ops.close(hinfo, apcm->codec, substream); 864 if (hinfo->ops.close)
840 snd_hda_power_down(apcm->codec); 865 hinfo->ops.close(hinfo, apcm->codec, substream);
841 mutex_unlock(&chip->open_mutex); 866 err = -EINVAL;
842 return -EINVAL; 867 goto powerdown;
843 } 868 }
844 869
845 /* disable WALLCLOCK timestamps for capture streams 870 /* disable LINK_ATIME timestamps for capture streams
846 until we figure out how to handle digital inputs */ 871 until we figure out how to handle digital inputs */
847 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) 872 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
848 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_WALL_CLOCK; 873 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_WALL_CLOCK; /* legacy */
874 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_LINK_ATIME;
875 }
849 876
850 spin_lock_irqsave(&chip->reg_lock, flags); 877 spin_lock_irqsave(&chip->reg_lock, flags);
851 azx_dev->substream = substream; 878 azx_dev->substream = substream;
@@ -856,6 +883,13 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
856 snd_pcm_set_sync(substream); 883 snd_pcm_set_sync(substream);
857 mutex_unlock(&chip->open_mutex); 884 mutex_unlock(&chip->open_mutex);
858 return 0; 885 return 0;
886
887 powerdown:
888 snd_hda_power_down(apcm->codec);
889 unlock:
890 mutex_unlock(&chip->open_mutex);
891 snd_hda_codec_pcm_put(apcm->info);
892 return err;
859} 893}
860 894
861static int azx_pcm_mmap(struct snd_pcm_substream *substream, 895static int azx_pcm_mmap(struct snd_pcm_substream *substream,
@@ -877,7 +911,7 @@ static struct snd_pcm_ops azx_pcm_ops = {
877 .prepare = azx_pcm_prepare, 911 .prepare = azx_pcm_prepare,
878 .trigger = azx_pcm_trigger, 912 .trigger = azx_pcm_trigger,
879 .pointer = azx_pcm_pointer, 913 .pointer = azx_pcm_pointer,
880 .wall_clock = azx_get_wallclock_tstamp, 914 .get_time_info = azx_get_time_info,
881 .mmap = azx_pcm_mmap, 915 .mmap = azx_pcm_mmap,
882 .page = snd_pcm_sgbuf_ops_page, 916 .page = snd_pcm_sgbuf_ops_page,
883}; 917};
@@ -887,6 +921,7 @@ static void azx_pcm_free(struct snd_pcm *pcm)
887 struct azx_pcm *apcm = pcm->private_data; 921 struct azx_pcm *apcm = pcm->private_data;
888 if (apcm) { 922 if (apcm) {
889 list_del(&apcm->list); 923 list_del(&apcm->list);
924 apcm->info->pcm = NULL;
890 kfree(apcm); 925 kfree(apcm);
891 } 926 }
892} 927}
@@ -923,6 +958,7 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
923 apcm->chip = chip; 958 apcm->chip = chip;
924 apcm->pcm = pcm; 959 apcm->pcm = pcm;
925 apcm->codec = codec; 960 apcm->codec = codec;
961 apcm->info = cpcm;
926 pcm->private_data = apcm; 962 pcm->private_data = apcm;
927 pcm->private_free = azx_pcm_free; 963 pcm->private_free = azx_pcm_free;
928 if (cpcm->pcm_type == HDA_PCM_TYPE_MODEM) 964 if (cpcm->pcm_type == HDA_PCM_TYPE_MODEM)
@@ -930,7 +966,6 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
930 list_add_tail(&apcm->list, &chip->pcm_list); 966 list_add_tail(&apcm->list, &chip->pcm_list);
931 cpcm->pcm = pcm; 967 cpcm->pcm = pcm;
932 for (s = 0; s < 2; s++) { 968 for (s = 0; s < 2; s++) {
933 apcm->hinfo[s] = &cpcm->stream[s];
934 if (cpcm->stream[s].substreams) 969 if (cpcm->stream[s].substreams)
935 snd_pcm_set_ops(pcm, s, &azx_pcm_ops); 970 snd_pcm_set_ops(pcm, s, &azx_pcm_ops);
936 } 971 }
@@ -941,9 +976,6 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
941 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, 976 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
942 chip->card->dev, 977 chip->card->dev,
943 size, MAX_PREALLOC_SIZE); 978 size, MAX_PREALLOC_SIZE);
944 /* link to codec */
945 for (s = 0; s < 2; s++)
946 pcm->streams[s].dev.parent = &codec->dev;
947 return 0; 979 return 0;
948} 980}
949 981
@@ -952,14 +984,9 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
952 */ 984 */
953static int azx_alloc_cmd_io(struct azx *chip) 985static int azx_alloc_cmd_io(struct azx *chip)
954{ 986{
955 int err;
956
957 /* single page (at least 4096 bytes) must suffice for both ringbuffes */ 987 /* single page (at least 4096 bytes) must suffice for both ringbuffes */
958 err = chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV, 988 return chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV,
959 PAGE_SIZE, &chip->rb); 989 PAGE_SIZE, &chip->rb);
960 if (err < 0)
961 dev_err(chip->card->dev, "cannot allocate CORB/RIRB\n");
962 return err;
963} 990}
964 991
965static void azx_init_cmd_io(struct azx *chip) 992static void azx_init_cmd_io(struct azx *chip)
@@ -1445,7 +1472,6 @@ static void azx_load_dsp_cleanup(struct hda_bus *bus,
1445int azx_alloc_stream_pages(struct azx *chip) 1472int azx_alloc_stream_pages(struct azx *chip)
1446{ 1473{
1447 int i, err; 1474 int i, err;
1448 struct snd_card *card = chip->card;
1449 1475
1450 for (i = 0; i < chip->num_streams; i++) { 1476 for (i = 0; i < chip->num_streams; i++) {
1451 dsp_lock_init(&chip->azx_dev[i]); 1477 dsp_lock_init(&chip->azx_dev[i]);
@@ -1453,18 +1479,14 @@ int azx_alloc_stream_pages(struct azx *chip)
1453 err = chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV, 1479 err = chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV,
1454 BDL_SIZE, 1480 BDL_SIZE,
1455 &chip->azx_dev[i].bdl); 1481 &chip->azx_dev[i].bdl);
1456 if (err < 0) { 1482 if (err < 0)
1457 dev_err(card->dev, "cannot allocate BDL\n");
1458 return -ENOMEM; 1483 return -ENOMEM;
1459 }
1460 } 1484 }
1461 /* allocate memory for the position buffer */ 1485 /* allocate memory for the position buffer */
1462 err = chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV, 1486 err = chip->ops->dma_alloc_pages(chip, SNDRV_DMA_TYPE_DEV,
1463 chip->num_streams * 8, &chip->posbuf); 1487 chip->num_streams * 8, &chip->posbuf);
1464 if (err < 0) { 1488 if (err < 0)
1465 dev_err(card->dev, "cannot allocate posbuf\n");
1466 return -ENOMEM; 1489 return -ENOMEM;
1467 }
1468 1490
1469 /* allocate CORB/RIRB */ 1491 /* allocate CORB/RIRB */
1470 err = azx_alloc_cmd_io(chip); 1492 err = azx_alloc_cmd_io(chip);
@@ -1676,7 +1698,7 @@ irqreturn_t azx_interrupt(int irq, void *dev_id)
1676 int i; 1698 int i;
1677 1699
1678#ifdef CONFIG_PM 1700#ifdef CONFIG_PM
1679 if (chip->driver_caps & AZX_DCAPS_PM_RUNTIME) 1701 if (azx_has_pm_runtime(chip))
1680 if (!pm_runtime_active(chip->card->dev)) 1702 if (!pm_runtime_active(chip->card->dev))
1681 return IRQ_NONE; 1703 return IRQ_NONE;
1682#endif 1704#endif
@@ -1742,12 +1764,12 @@ static int probe_codec(struct azx *chip, int addr)
1742 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID; 1764 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
1743 unsigned int res; 1765 unsigned int res;
1744 1766
1745 mutex_lock(&chip->bus->cmd_mutex); 1767 mutex_lock(&chip->bus->core.cmd_mutex);
1746 chip->probing = 1; 1768 chip->probing = 1;
1747 azx_send_cmd(chip->bus, cmd); 1769 azx_send_cmd(chip->bus, cmd);
1748 res = azx_get_response(chip->bus, addr); 1770 res = azx_get_response(chip->bus, addr);
1749 chip->probing = 0; 1771 chip->probing = 0;
1750 mutex_unlock(&chip->bus->cmd_mutex); 1772 mutex_unlock(&chip->bus->core.cmd_mutex);
1751 if (res == -1) 1773 if (res == -1)
1752 return -EIO; 1774 return -EIO;
1753 dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr); 1775 dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr);
@@ -1761,34 +1783,11 @@ static void azx_bus_reset(struct hda_bus *bus)
1761 bus->in_reset = 1; 1783 bus->in_reset = 1;
1762 azx_stop_chip(chip); 1784 azx_stop_chip(chip);
1763 azx_init_chip(chip, true); 1785 azx_init_chip(chip, true);
1764#ifdef CONFIG_PM 1786 if (chip->initialized)
1765 if (chip->initialized) { 1787 snd_hda_bus_reset(chip->bus);
1766 struct azx_pcm *p;
1767 list_for_each_entry(p, &chip->pcm_list, list)
1768 snd_pcm_suspend_all(p->pcm);
1769 snd_hda_suspend(chip->bus);
1770 snd_hda_resume(chip->bus);
1771 }
1772#endif
1773 bus->in_reset = 0; 1788 bus->in_reset = 0;
1774} 1789}
1775 1790
1776#ifdef CONFIG_PM
1777/* power-up/down the controller */
1778static void azx_power_notify(struct hda_bus *bus, bool power_up)
1779{
1780 struct azx *chip = bus->private_data;
1781
1782 if (!(chip->driver_caps & AZX_DCAPS_PM_RUNTIME))
1783 return;
1784
1785 if (power_up)
1786 pm_runtime_get_sync(chip->card->dev);
1787 else
1788 pm_runtime_put_sync(chip->card->dev);
1789}
1790#endif
1791
1792static int get_jackpoll_interval(struct azx *chip) 1791static int get_jackpoll_interval(struct azx *chip)
1793{ 1792{
1794 int i; 1793 int i;
@@ -1810,41 +1809,59 @@ static int get_jackpoll_interval(struct azx *chip)
1810 return j; 1809 return j;
1811} 1810}
1812 1811
1813/* Codec initialization */ 1812static struct hda_bus_ops bus_ops = {
1814int azx_codec_create(struct azx *chip, const char *model, 1813 .command = azx_send_cmd,
1815 unsigned int max_slots, 1814 .get_response = azx_get_response,
1816 int *power_save_to) 1815 .attach_pcm = azx_attach_pcm_stream,
1817{ 1816 .bus_reset = azx_bus_reset,
1818 struct hda_bus_template bus_temp;
1819 int c, codecs, err;
1820
1821 memset(&bus_temp, 0, sizeof(bus_temp));
1822 bus_temp.private_data = chip;
1823 bus_temp.modelname = model;
1824 bus_temp.pci = chip->pci;
1825 bus_temp.ops.command = azx_send_cmd;
1826 bus_temp.ops.get_response = azx_get_response;
1827 bus_temp.ops.attach_pcm = azx_attach_pcm_stream;
1828 bus_temp.ops.bus_reset = azx_bus_reset;
1829#ifdef CONFIG_PM
1830 bus_temp.power_save = power_save_to;
1831 bus_temp.ops.pm_notify = azx_power_notify;
1832#endif
1833#ifdef CONFIG_SND_HDA_DSP_LOADER 1817#ifdef CONFIG_SND_HDA_DSP_LOADER
1834 bus_temp.ops.load_dsp_prepare = azx_load_dsp_prepare; 1818 .load_dsp_prepare = azx_load_dsp_prepare,
1835 bus_temp.ops.load_dsp_trigger = azx_load_dsp_trigger; 1819 .load_dsp_trigger = azx_load_dsp_trigger,
1836 bus_temp.ops.load_dsp_cleanup = azx_load_dsp_cleanup; 1820 .load_dsp_cleanup = azx_load_dsp_cleanup,
1837#endif 1821#endif
1822};
1823
1824/* HD-audio bus initialization */
1825int azx_bus_create(struct azx *chip, const char *model)
1826{
1827 struct hda_bus *bus;
1828 int err;
1838 1829
1839 err = snd_hda_bus_new(chip->card, &bus_temp, &chip->bus); 1830 err = snd_hda_bus_new(chip->card, &bus);
1840 if (err < 0) 1831 if (err < 0)
1841 return err; 1832 return err;
1842 1833
1834 chip->bus = bus;
1835 bus->private_data = chip;
1836 bus->pci = chip->pci;
1837 bus->modelname = model;
1838 bus->ops = bus_ops;
1839
1843 if (chip->driver_caps & AZX_DCAPS_RIRB_DELAY) { 1840 if (chip->driver_caps & AZX_DCAPS_RIRB_DELAY) {
1844 dev_dbg(chip->card->dev, "Enable delay in RIRB handling\n"); 1841 dev_dbg(chip->card->dev, "Enable delay in RIRB handling\n");
1845 chip->bus->needs_damn_long_delay = 1; 1842 bus->needs_damn_long_delay = 1;
1843 }
1844
1845 /* AMD chipsets often cause the communication stalls upon certain
1846 * sequence like the pin-detection. It seems that forcing the synced
1847 * access works around the stall. Grrr...
1848 */
1849 if (chip->driver_caps & AZX_DCAPS_SYNC_WRITE) {
1850 dev_dbg(chip->card->dev, "Enable sync_write for stable communication\n");
1851 bus->core.sync_write = 1;
1852 bus->allow_bus_reset = 1;
1846 } 1853 }
1847 1854
1855 return 0;
1856}
1857EXPORT_SYMBOL_GPL(azx_bus_create);
1858
1859/* Probe codecs */
1860int azx_probe_codecs(struct azx *chip, unsigned int max_slots)
1861{
1862 struct hda_bus *bus = chip->bus;
1863 int c, codecs, err;
1864
1848 codecs = 0; 1865 codecs = 0;
1849 if (!max_slots) 1866 if (!max_slots)
1850 max_slots = AZX_DEFAULT_CODECS; 1867 max_slots = AZX_DEFAULT_CODECS;
@@ -1872,21 +1889,11 @@ int azx_codec_create(struct azx *chip, const char *model,
1872 } 1889 }
1873 } 1890 }
1874 1891
1875 /* AMD chipsets often cause the communication stalls upon certain
1876 * sequence like the pin-detection. It seems that forcing the synced
1877 * access works around the stall. Grrr...
1878 */
1879 if (chip->driver_caps & AZX_DCAPS_SYNC_WRITE) {
1880 dev_dbg(chip->card->dev, "Enable sync_write for stable communication\n");
1881 chip->bus->sync_write = 1;
1882 chip->bus->allow_bus_reset = 1;
1883 }
1884
1885 /* Then create codec instances */ 1892 /* Then create codec instances */
1886 for (c = 0; c < max_slots; c++) { 1893 for (c = 0; c < max_slots; c++) {
1887 if ((chip->codec_mask & (1 << c)) & chip->codec_probe_mask) { 1894 if ((chip->codec_mask & (1 << c)) & chip->codec_probe_mask) {
1888 struct hda_codec *codec; 1895 struct hda_codec *codec;
1889 err = snd_hda_codec_new(chip->bus, c, &codec); 1896 err = snd_hda_codec_new(bus, bus->card, c, &codec);
1890 if (err < 0) 1897 if (err < 0)
1891 continue; 1898 continue;
1892 codec->jackpoll_interval = get_jackpoll_interval(chip); 1899 codec->jackpoll_interval = get_jackpoll_interval(chip);
@@ -1900,26 +1907,19 @@ int azx_codec_create(struct azx *chip, const char *model,
1900 } 1907 }
1901 return 0; 1908 return 0;
1902} 1909}
1903EXPORT_SYMBOL_GPL(azx_codec_create); 1910EXPORT_SYMBOL_GPL(azx_probe_codecs);
1904 1911
1905/* configure each codec instance */ 1912/* configure each codec instance */
1906int azx_codec_configure(struct azx *chip) 1913int azx_codec_configure(struct azx *chip)
1907{ 1914{
1908 struct hda_codec *codec; 1915 struct hda_codec *codec;
1909 list_for_each_entry(codec, &chip->bus->codec_list, list) { 1916 list_for_each_codec(codec, chip->bus) {
1910 snd_hda_codec_configure(codec); 1917 snd_hda_codec_configure(codec);
1911 } 1918 }
1912 return 0; 1919 return 0;
1913} 1920}
1914EXPORT_SYMBOL_GPL(azx_codec_configure); 1921EXPORT_SYMBOL_GPL(azx_codec_configure);
1915 1922
1916/* mixer creation - all stuff is implemented in hda module */
1917int azx_mixer_create(struct azx *chip)
1918{
1919 return snd_hda_build_controls(chip->bus);
1920}
1921EXPORT_SYMBOL_GPL(azx_mixer_create);
1922
1923 1923
1924static bool is_input_stream(struct azx *chip, unsigned char index) 1924static bool is_input_stream(struct azx *chip, unsigned char index)
1925{ 1925{
@@ -1966,30 +1966,5 @@ int azx_init_stream(struct azx *chip)
1966} 1966}
1967EXPORT_SYMBOL_GPL(azx_init_stream); 1967EXPORT_SYMBOL_GPL(azx_init_stream);
1968 1968
1969/*
1970 * reboot notifier for hang-up problem at power-down
1971 */
1972static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf)
1973{
1974 struct azx *chip = container_of(nb, struct azx, reboot_notifier);
1975 snd_hda_bus_reboot_notify(chip->bus);
1976 azx_stop_chip(chip);
1977 return NOTIFY_OK;
1978}
1979
1980void azx_notifier_register(struct azx *chip)
1981{
1982 chip->reboot_notifier.notifier_call = azx_halt;
1983 register_reboot_notifier(&chip->reboot_notifier);
1984}
1985EXPORT_SYMBOL_GPL(azx_notifier_register);
1986
1987void azx_notifier_unregister(struct azx *chip)
1988{
1989 if (chip->reboot_notifier.notifier_call)
1990 unregister_reboot_notifier(&chip->reboot_notifier);
1991}
1992EXPORT_SYMBOL_GPL(azx_notifier_unregister);
1993
1994MODULE_LICENSE("GPL"); 1969MODULE_LICENSE("GPL");
1995MODULE_DESCRIPTION("Common HDA driver functions"); 1970MODULE_DESCRIPTION("Common HDA driver functions");
diff --git a/sound/pci/hda/hda_controller.h b/sound/pci/hda/hda_controller.h
index c90d10fd4d8f..be1b7ded8d82 100644
--- a/sound/pci/hda/hda_controller.h
+++ b/sound/pci/hda/hda_controller.h
@@ -15,10 +15,396 @@
15#ifndef __SOUND_HDA_CONTROLLER_H 15#ifndef __SOUND_HDA_CONTROLLER_H
16#define __SOUND_HDA_CONTROLLER_H 16#define __SOUND_HDA_CONTROLLER_H
17 17
18#include <linux/timecounter.h>
19#include <linux/interrupt.h>
18#include <sound/core.h> 20#include <sound/core.h>
21#include <sound/pcm.h>
19#include <sound/initval.h> 22#include <sound/initval.h>
20#include "hda_codec.h" 23#include "hda_codec.h"
21#include "hda_priv.h" 24
25/*
26 * registers
27 */
28#define AZX_REG_GCAP 0x00
29#define AZX_GCAP_64OK (1 << 0) /* 64bit address support */
30#define AZX_GCAP_NSDO (3 << 1) /* # of serial data out signals */
31#define AZX_GCAP_BSS (31 << 3) /* # of bidirectional streams */
32#define AZX_GCAP_ISS (15 << 8) /* # of input streams */
33#define AZX_GCAP_OSS (15 << 12) /* # of output streams */
34#define AZX_REG_VMIN 0x02
35#define AZX_REG_VMAJ 0x03
36#define AZX_REG_OUTPAY 0x04
37#define AZX_REG_INPAY 0x06
38#define AZX_REG_GCTL 0x08
39#define AZX_GCTL_RESET (1 << 0) /* controller reset */
40#define AZX_GCTL_FCNTRL (1 << 1) /* flush control */
41#define AZX_GCTL_UNSOL (1 << 8) /* accept unsol. response enable */
42#define AZX_REG_WAKEEN 0x0c
43#define AZX_REG_STATESTS 0x0e
44#define AZX_REG_GSTS 0x10
45#define AZX_GSTS_FSTS (1 << 1) /* flush status */
46#define AZX_REG_INTCTL 0x20
47#define AZX_REG_INTSTS 0x24
48#define AZX_REG_WALLCLK 0x30 /* 24Mhz source */
49#define AZX_REG_OLD_SSYNC 0x34 /* SSYNC for old ICH */
50#define AZX_REG_SSYNC 0x38
51#define AZX_REG_CORBLBASE 0x40
52#define AZX_REG_CORBUBASE 0x44
53#define AZX_REG_CORBWP 0x48
54#define AZX_REG_CORBRP 0x4a
55#define AZX_CORBRP_RST (1 << 15) /* read pointer reset */
56#define AZX_REG_CORBCTL 0x4c
57#define AZX_CORBCTL_RUN (1 << 1) /* enable DMA */
58#define AZX_CORBCTL_CMEIE (1 << 0) /* enable memory error irq */
59#define AZX_REG_CORBSTS 0x4d
60#define AZX_CORBSTS_CMEI (1 << 0) /* memory error indication */
61#define AZX_REG_CORBSIZE 0x4e
62
63#define AZX_REG_RIRBLBASE 0x50
64#define AZX_REG_RIRBUBASE 0x54
65#define AZX_REG_RIRBWP 0x58
66#define AZX_RIRBWP_RST (1 << 15) /* write pointer reset */
67#define AZX_REG_RINTCNT 0x5a
68#define AZX_REG_RIRBCTL 0x5c
69#define AZX_RBCTL_IRQ_EN (1 << 0) /* enable IRQ */
70#define AZX_RBCTL_DMA_EN (1 << 1) /* enable DMA */
71#define AZX_RBCTL_OVERRUN_EN (1 << 2) /* enable overrun irq */
72#define AZX_REG_RIRBSTS 0x5d
73#define AZX_RBSTS_IRQ (1 << 0) /* response irq */
74#define AZX_RBSTS_OVERRUN (1 << 2) /* overrun irq */
75#define AZX_REG_RIRBSIZE 0x5e
76
77#define AZX_REG_IC 0x60
78#define AZX_REG_IR 0x64
79#define AZX_REG_IRS 0x68
80#define AZX_IRS_VALID (1<<1)
81#define AZX_IRS_BUSY (1<<0)
82
83#define AZX_REG_DPLBASE 0x70
84#define AZX_REG_DPUBASE 0x74
85#define AZX_DPLBASE_ENABLE 0x1 /* Enable position buffer */
86
87/* SD offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
88enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
89
90/* stream register offsets from stream base */
91#define AZX_REG_SD_CTL 0x00
92#define AZX_REG_SD_STS 0x03
93#define AZX_REG_SD_LPIB 0x04
94#define AZX_REG_SD_CBL 0x08
95#define AZX_REG_SD_LVI 0x0c
96#define AZX_REG_SD_FIFOW 0x0e
97#define AZX_REG_SD_FIFOSIZE 0x10
98#define AZX_REG_SD_FORMAT 0x12
99#define AZX_REG_SD_BDLPL 0x18
100#define AZX_REG_SD_BDLPU 0x1c
101
102/* PCI space */
103#define AZX_PCIREG_TCSEL 0x44
104
105/*
106 * other constants
107 */
108
109/* max number of fragments - we may use more if allocating more pages for BDL */
110#define BDL_SIZE 4096
111#define AZX_MAX_BDL_ENTRIES (BDL_SIZE / 16)
112#define AZX_MAX_FRAG 32
113/* max buffer size - no h/w limit, you can increase as you like */
114#define AZX_MAX_BUF_SIZE (1024*1024*1024)
115
116/* RIRB int mask: overrun[2], response[0] */
117#define RIRB_INT_RESPONSE 0x01
118#define RIRB_INT_OVERRUN 0x04
119#define RIRB_INT_MASK 0x05
120
121/* STATESTS int mask: S3,SD2,SD1,SD0 */
122#define AZX_MAX_CODECS 8
123#define AZX_DEFAULT_CODECS 4
124#define STATESTS_INT_MASK ((1 << AZX_MAX_CODECS) - 1)
125
126/* SD_CTL bits */
127#define SD_CTL_STREAM_RESET 0x01 /* stream reset bit */
128#define SD_CTL_DMA_START 0x02 /* stream DMA start bit */
129#define SD_CTL_STRIPE (3 << 16) /* stripe control */
130#define SD_CTL_TRAFFIC_PRIO (1 << 18) /* traffic priority */
131#define SD_CTL_DIR (1 << 19) /* bi-directional stream */
132#define SD_CTL_STREAM_TAG_MASK (0xf << 20)
133#define SD_CTL_STREAM_TAG_SHIFT 20
134
135/* SD_CTL and SD_STS */
136#define SD_INT_DESC_ERR 0x10 /* descriptor error interrupt */
137#define SD_INT_FIFO_ERR 0x08 /* FIFO error interrupt */
138#define SD_INT_COMPLETE 0x04 /* completion interrupt */
139#define SD_INT_MASK (SD_INT_DESC_ERR|SD_INT_FIFO_ERR|\
140 SD_INT_COMPLETE)
141
142/* SD_STS */
143#define SD_STS_FIFO_READY 0x20 /* FIFO ready */
144
145/* INTCTL and INTSTS */
146#define AZX_INT_ALL_STREAM 0xff /* all stream interrupts */
147#define AZX_INT_CTRL_EN 0x40000000 /* controller interrupt enable bit */
148#define AZX_INT_GLOBAL_EN 0x80000000 /* global interrupt enable bit */
149
150/* below are so far hardcoded - should read registers in future */
151#define AZX_MAX_CORB_ENTRIES 256
152#define AZX_MAX_RIRB_ENTRIES 256
153
154/* driver quirks (capabilities) */
155/* bits 0-7 are used for indicating driver type */
156#define AZX_DCAPS_NO_TCSEL (1 << 8) /* No Intel TCSEL bit */
157#define AZX_DCAPS_NO_MSI (1 << 9) /* No MSI support */
158#define AZX_DCAPS_SNOOP_MASK (3 << 10) /* snoop type mask */
159#define AZX_DCAPS_SNOOP_OFF (1 << 12) /* snoop default off */
160#define AZX_DCAPS_RIRB_DELAY (1 << 13) /* Long delay in read loop */
161#define AZX_DCAPS_RIRB_PRE_DELAY (1 << 14) /* Put a delay before read */
162#define AZX_DCAPS_CTX_WORKAROUND (1 << 15) /* X-Fi workaround */
163#define AZX_DCAPS_POSFIX_LPIB (1 << 16) /* Use LPIB as default */
164#define AZX_DCAPS_POSFIX_VIA (1 << 17) /* Use VIACOMBO as default */
165#define AZX_DCAPS_NO_64BIT (1 << 18) /* No 64bit address */
166#define AZX_DCAPS_SYNC_WRITE (1 << 19) /* sync each cmd write */
167#define AZX_DCAPS_OLD_SSYNC (1 << 20) /* Old SSYNC reg for ICH */
168#define AZX_DCAPS_NO_ALIGN_BUFSIZE (1 << 21) /* no buffer size alignment */
169/* 22 unused */
170#define AZX_DCAPS_4K_BDLE_BOUNDARY (1 << 23) /* BDLE in 4k boundary */
171#define AZX_DCAPS_REVERSE_ASSIGN (1 << 24) /* Assign devices in reverse order */
172#define AZX_DCAPS_COUNT_LPIB_DELAY (1 << 25) /* Take LPIB as delay */
173#define AZX_DCAPS_PM_RUNTIME (1 << 26) /* runtime PM support */
174#define AZX_DCAPS_I915_POWERWELL (1 << 27) /* HSW i915 powerwell support */
175#define AZX_DCAPS_CORBRP_SELF_CLEAR (1 << 28) /* CORBRP clears itself after reset */
176#define AZX_DCAPS_NO_MSI64 (1 << 29) /* Stick to 32-bit MSIs */
177#define AZX_DCAPS_SEPARATE_STREAM_TAG (1 << 30) /* capture and playback use separate stream tag */
178
179enum {
180 AZX_SNOOP_TYPE_NONE,
181 AZX_SNOOP_TYPE_SCH,
182 AZX_SNOOP_TYPE_ATI,
183 AZX_SNOOP_TYPE_NVIDIA,
184};
185
186/* HD Audio class code */
187#define PCI_CLASS_MULTIMEDIA_HD_AUDIO 0x0403
188
189struct azx_dev {
190 struct snd_dma_buffer bdl; /* BDL buffer */
191 u32 *posbuf; /* position buffer pointer */
192
193 unsigned int bufsize; /* size of the play buffer in bytes */
194 unsigned int period_bytes; /* size of the period in bytes */
195 unsigned int frags; /* number for period in the play buffer */
196 unsigned int fifo_size; /* FIFO size */
197 unsigned long start_wallclk; /* start + minimum wallclk */
198 unsigned long period_wallclk; /* wallclk for period */
199
200 void __iomem *sd_addr; /* stream descriptor pointer */
201
202 u32 sd_int_sta_mask; /* stream int status mask */
203
204 /* pcm support */
205 struct snd_pcm_substream *substream; /* assigned substream,
206 * set in PCM open
207 */
208 unsigned int format_val; /* format value to be set in the
209 * controller and the codec
210 */
211 unsigned char stream_tag; /* assigned stream */
212 unsigned char index; /* stream index */
213 int assigned_key; /* last device# key assigned to */
214
215 unsigned int opened:1;
216 unsigned int running:1;
217 unsigned int irq_pending:1;
218 unsigned int prepared:1;
219 unsigned int locked:1;
220 /*
221 * For VIA:
222 * A flag to ensure DMA position is 0
223 * when link position is not greater than FIFO size
224 */
225 unsigned int insufficient:1;
226 unsigned int wc_marked:1;
227 unsigned int no_period_wakeup:1;
228
229 struct timecounter azx_tc;
230 struct cyclecounter azx_cc;
231
232 int delay_negative_threshold;
233
234#ifdef CONFIG_SND_HDA_DSP_LOADER
235 /* Allows dsp load to have sole access to the playback stream. */
236 struct mutex dsp_mutex;
237#endif
238};
239
240/* CORB/RIRB */
241struct azx_rb {
242 u32 *buf; /* CORB/RIRB buffer
243 * Each CORB entry is 4byte, RIRB is 8byte
244 */
245 dma_addr_t addr; /* physical address of CORB/RIRB buffer */
246 /* for RIRB */
247 unsigned short rp, wp; /* read/write pointers */
248 int cmds[AZX_MAX_CODECS]; /* number of pending requests */
249 u32 res[AZX_MAX_CODECS]; /* last read value */
250};
251
252struct azx;
253
254/* Functions to read/write to hda registers. */
255struct hda_controller_ops {
256 /* Register Access */
257 void (*reg_writel)(u32 value, u32 __iomem *addr);
258 u32 (*reg_readl)(u32 __iomem *addr);
259 void (*reg_writew)(u16 value, u16 __iomem *addr);
260 u16 (*reg_readw)(u16 __iomem *addr);
261 void (*reg_writeb)(u8 value, u8 __iomem *addr);
262 u8 (*reg_readb)(u8 __iomem *addr);
263 /* Disable msi if supported, PCI only */
264 int (*disable_msi_reset_irq)(struct azx *);
265 /* Allocation ops */
266 int (*dma_alloc_pages)(struct azx *chip,
267 int type,
268 size_t size,
269 struct snd_dma_buffer *buf);
270 void (*dma_free_pages)(struct azx *chip, struct snd_dma_buffer *buf);
271 int (*substream_alloc_pages)(struct azx *chip,
272 struct snd_pcm_substream *substream,
273 size_t size);
274 int (*substream_free_pages)(struct azx *chip,
275 struct snd_pcm_substream *substream);
276 void (*pcm_mmap_prepare)(struct snd_pcm_substream *substream,
277 struct vm_area_struct *area);
278 /* Check if current position is acceptable */
279 int (*position_check)(struct azx *chip, struct azx_dev *azx_dev);
280};
281
282struct azx_pcm {
283 struct azx *chip;
284 struct snd_pcm *pcm;
285 struct hda_codec *codec;
286 struct hda_pcm *info;
287 struct list_head list;
288};
289
290typedef unsigned int (*azx_get_pos_callback_t)(struct azx *, struct azx_dev *);
291typedef int (*azx_get_delay_callback_t)(struct azx *, struct azx_dev *, unsigned int pos);
292
293struct azx {
294 struct snd_card *card;
295 struct pci_dev *pci;
296 int dev_index;
297
298 /* chip type specific */
299 int driver_type;
300 unsigned int driver_caps;
301 int playback_streams;
302 int playback_index_offset;
303 int capture_streams;
304 int capture_index_offset;
305 int num_streams;
306 const int *jackpoll_ms; /* per-card jack poll interval */
307
308 /* Register interaction. */
309 const struct hda_controller_ops *ops;
310
311 /* position adjustment callbacks */
312 azx_get_pos_callback_t get_position[2];
313 azx_get_delay_callback_t get_delay[2];
314
315 /* pci resources */
316 unsigned long addr;
317 void __iomem *remap_addr;
318 int irq;
319
320 /* locks */
321 spinlock_t reg_lock;
322 struct mutex open_mutex; /* Prevents concurrent open/close operations */
323
324 /* streams (x num_streams) */
325 struct azx_dev *azx_dev;
326
327 /* PCM */
328 struct list_head pcm_list; /* azx_pcm list */
329
330 /* HD codec */
331 unsigned short codec_mask;
332 int codec_probe_mask; /* copied from probe_mask option */
333 struct hda_bus *bus;
334 unsigned int beep_mode;
335
336 /* CORB/RIRB */
337 struct azx_rb corb;
338 struct azx_rb rirb;
339
340 /* CORB/RIRB and position buffers */
341 struct snd_dma_buffer rb;
342 struct snd_dma_buffer posbuf;
343
344#ifdef CONFIG_SND_HDA_PATCH_LOADER
345 const struct firmware *fw;
346#endif
347
348 /* flags */
349 const int *bdl_pos_adj;
350 int poll_count;
351 unsigned int running:1;
352 unsigned int initialized:1;
353 unsigned int single_cmd:1;
354 unsigned int polling_mode:1;
355 unsigned int msi:1;
356 unsigned int probing:1; /* codec probing phase */
357 unsigned int snoop:1;
358 unsigned int align_buffer_size:1;
359 unsigned int region_requested:1;
360 unsigned int disabled:1; /* disabled by VGA-switcher */
361
362 /* for debugging */
363 unsigned int last_cmd[AZX_MAX_CODECS];
364
365#ifdef CONFIG_SND_HDA_DSP_LOADER
366 struct azx_dev saved_azx_dev;
367#endif
368};
369
370#ifdef CONFIG_X86
371#define azx_snoop(chip) ((chip)->snoop)
372#else
373#define azx_snoop(chip) true
374#endif
375
376/*
377 * macros for easy use
378 */
379
380#define azx_writel(chip, reg, value) \
381 ((chip)->ops->reg_writel(value, (chip)->remap_addr + AZX_REG_##reg))
382#define azx_readl(chip, reg) \
383 ((chip)->ops->reg_readl((chip)->remap_addr + AZX_REG_##reg))
384#define azx_writew(chip, reg, value) \
385 ((chip)->ops->reg_writew(value, (chip)->remap_addr + AZX_REG_##reg))
386#define azx_readw(chip, reg) \
387 ((chip)->ops->reg_readw((chip)->remap_addr + AZX_REG_##reg))
388#define azx_writeb(chip, reg, value) \
389 ((chip)->ops->reg_writeb(value, (chip)->remap_addr + AZX_REG_##reg))
390#define azx_readb(chip, reg) \
391 ((chip)->ops->reg_readb((chip)->remap_addr + AZX_REG_##reg))
392
393#define azx_sd_writel(chip, dev, reg, value) \
394 ((chip)->ops->reg_writel(value, (dev)->sd_addr + AZX_REG_##reg))
395#define azx_sd_readl(chip, dev, reg) \
396 ((chip)->ops->reg_readl((dev)->sd_addr + AZX_REG_##reg))
397#define azx_sd_writew(chip, dev, reg, value) \
398 ((chip)->ops->reg_writew(value, (dev)->sd_addr + AZX_REG_##reg))
399#define azx_sd_readw(chip, dev, reg) \
400 ((chip)->ops->reg_readw((dev)->sd_addr + AZX_REG_##reg))
401#define azx_sd_writeb(chip, dev, reg, value) \
402 ((chip)->ops->reg_writeb(value, (dev)->sd_addr + AZX_REG_##reg))
403#define azx_sd_readb(chip, dev, reg) \
404 ((chip)->ops->reg_readb((dev)->sd_addr + AZX_REG_##reg))
405
406#define azx_has_pm_runtime(chip) \
407 (!AZX_DCAPS_PM_RUNTIME || ((chip)->driver_caps & AZX_DCAPS_PM_RUNTIME))
22 408
23/* PCM setup */ 409/* PCM setup */
24static inline struct azx_dev *get_azx_dev(struct snd_pcm_substream *substream) 410static inline struct azx_dev *get_azx_dev(struct snd_pcm_substream *substream)
@@ -43,14 +429,9 @@ void azx_enter_link_reset(struct azx *chip);
43irqreturn_t azx_interrupt(int irq, void *dev_id); 429irqreturn_t azx_interrupt(int irq, void *dev_id);
44 430
45/* Codec interface */ 431/* Codec interface */
46int azx_codec_create(struct azx *chip, const char *model, 432int azx_bus_create(struct azx *chip, const char *model);
47 unsigned int max_slots, 433int azx_probe_codecs(struct azx *chip, unsigned int max_slots);
48 int *power_save_to);
49int azx_codec_configure(struct azx *chip); 434int azx_codec_configure(struct azx *chip);
50int azx_mixer_create(struct azx *chip);
51int azx_init_stream(struct azx *chip); 435int azx_init_stream(struct azx *chip);
52 436
53void azx_notifier_register(struct azx *chip);
54void azx_notifier_unregister(struct azx *chip);
55
56#endif /* __SOUND_HDA_CONTROLLER_H */ 437#endif /* __SOUND_HDA_CONTROLLER_H */
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c
index 8ec5289f8e05..3d2597b7037b 100644
--- a/sound/pci/hda/hda_generic.c
+++ b/sound/pci/hda/hda_generic.c
@@ -140,6 +140,9 @@ static void parse_user_hints(struct hda_codec *codec)
140 val = snd_hda_get_bool_hint(codec, "single_adc_amp"); 140 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
141 if (val >= 0) 141 if (val >= 0)
142 codec->single_adc_amp = !!val; 142 codec->single_adc_amp = !!val;
143 val = snd_hda_get_bool_hint(codec, "power_save_node");
144 if (val >= 0)
145 codec->power_save_node = !!val;
143 146
144 val = snd_hda_get_bool_hint(codec, "auto_mute"); 147 val = snd_hda_get_bool_hint(codec, "auto_mute");
145 if (val >= 0) 148 if (val >= 0)
@@ -648,12 +651,24 @@ static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
648 unsigned int dir, unsigned int idx) 651 unsigned int dir, unsigned int idx)
649{ 652{
650 struct hda_gen_spec *spec = codec->spec; 653 struct hda_gen_spec *spec = codec->spec;
654 int type = get_wcaps_type(get_wcaps(codec, nid));
651 int i, n; 655 int i, n;
652 656
657 if (nid == codec->core.afg)
658 return true;
659
653 for (n = 0; n < spec->paths.used; n++) { 660 for (n = 0; n < spec->paths.used; n++) {
654 struct nid_path *path = snd_array_elem(&spec->paths, n); 661 struct nid_path *path = snd_array_elem(&spec->paths, n);
655 if (!path->active) 662 if (!path->active)
656 continue; 663 continue;
664 if (codec->power_save_node) {
665 if (!path->stream_enabled)
666 continue;
667 /* ignore unplugged paths except for DAC/ADC */
668 if (!(path->pin_enabled || path->pin_fixed) &&
669 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
670 continue;
671 }
657 for (i = 0; i < path->depth; i++) { 672 for (i = 0; i < path->depth; i++) {
658 if (path->path[i] == nid) { 673 if (path->path[i] == nid) {
659 if (dir == HDA_OUTPUT || path->idx[i] == idx) 674 if (dir == HDA_OUTPUT || path->idx[i] == idx)
@@ -807,6 +822,44 @@ static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
807 } 822 }
808} 823}
809 824
825/* sync power of each widget in the the given path */
826static hda_nid_t path_power_update(struct hda_codec *codec,
827 struct nid_path *path,
828 bool allow_powerdown)
829{
830 hda_nid_t nid, changed = 0;
831 int i, state;
832
833 for (i = 0; i < path->depth; i++) {
834 nid = path->path[i];
835 if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
836 continue;
837 if (nid == codec->core.afg)
838 continue;
839 if (!allow_powerdown || is_active_nid_for_any(codec, nid))
840 state = AC_PWRST_D0;
841 else
842 state = AC_PWRST_D3;
843 if (!snd_hda_check_power_state(codec, nid, state)) {
844 snd_hda_codec_write(codec, nid, 0,
845 AC_VERB_SET_POWER_STATE, state);
846 changed = nid;
847 if (state == AC_PWRST_D0)
848 snd_hdac_regmap_sync_node(&codec->core, nid);
849 }
850 }
851 return changed;
852}
853
854/* do sync with the last power state change */
855static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
856{
857 if (nid) {
858 msleep(10);
859 snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
860 }
861}
862
810/** 863/**
811 * snd_hda_activate_path - activate or deactivate the given path 864 * snd_hda_activate_path - activate or deactivate the given path
812 * @codec: the HDA codec 865 * @codec: the HDA codec
@@ -825,15 +878,13 @@ void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
825 if (!enable) 878 if (!enable)
826 path->active = false; 879 path->active = false;
827 880
881 /* make sure the widget is powered up */
882 if (enable && (spec->power_down_unused || codec->power_save_node))
883 path_power_update(codec, path, codec->power_save_node);
884
828 for (i = path->depth - 1; i >= 0; i--) { 885 for (i = path->depth - 1; i >= 0; i--) {
829 hda_nid_t nid = path->path[i]; 886 hda_nid_t nid = path->path[i];
830 if (enable && spec->power_down_unused) { 887
831 /* make sure the widget is powered up */
832 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0))
833 snd_hda_codec_write(codec, nid, 0,
834 AC_VERB_SET_POWER_STATE,
835 AC_PWRST_D0);
836 }
837 if (enable && path->multi[i]) 888 if (enable && path->multi[i])
838 snd_hda_codec_update_cache(codec, nid, 0, 889 snd_hda_codec_update_cache(codec, nid, 0,
839 AC_VERB_SET_CONNECT_SEL, 890 AC_VERB_SET_CONNECT_SEL,
@@ -853,28 +904,10 @@ EXPORT_SYMBOL_GPL(snd_hda_activate_path);
853static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path) 904static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
854{ 905{
855 struct hda_gen_spec *spec = codec->spec; 906 struct hda_gen_spec *spec = codec->spec;
856 bool changed = false;
857 int i;
858 907
859 if (!spec->power_down_unused || path->active) 908 if (!(spec->power_down_unused || codec->power_save_node) || path->active)
860 return; 909 return;
861 910 sync_power_state_change(codec, path_power_update(codec, path, true));
862 for (i = 0; i < path->depth; i++) {
863 hda_nid_t nid = path->path[i];
864 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D3) &&
865 !is_active_nid_for_any(codec, nid)) {
866 snd_hda_codec_write(codec, nid, 0,
867 AC_VERB_SET_POWER_STATE,
868 AC_PWRST_D3);
869 changed = true;
870 }
871 }
872
873 if (changed) {
874 msleep(10);
875 snd_hda_codec_read(codec, path->path[0], 0,
876 AC_VERB_GET_POWER_STATE, 0);
877 }
878} 911}
879 912
880/* turn on/off EAPD on the given pin */ 913/* turn on/off EAPD on the given pin */
@@ -1574,6 +1607,7 @@ static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1574 return 0; 1607 return 0;
1575 /* print_nid_path(codec, "output-aamix", path); */ 1608 /* print_nid_path(codec, "output-aamix", path); */
1576 path->active = false; /* unused as default */ 1609 path->active = false; /* unused as default */
1610 path->pin_fixed = true; /* static route */
1577 return snd_hda_get_path_idx(codec, path); 1611 return snd_hda_get_path_idx(codec, path);
1578} 1612}
1579 1613
@@ -1863,12 +1897,11 @@ static void debug_show_configs(struct hda_codec *codec,
1863static void fill_all_dac_nids(struct hda_codec *codec) 1897static void fill_all_dac_nids(struct hda_codec *codec)
1864{ 1898{
1865 struct hda_gen_spec *spec = codec->spec; 1899 struct hda_gen_spec *spec = codec->spec;
1866 int i; 1900 hda_nid_t nid;
1867 hda_nid_t nid = codec->start_nid;
1868 1901
1869 spec->num_all_dacs = 0; 1902 spec->num_all_dacs = 0;
1870 memset(spec->all_dacs, 0, sizeof(spec->all_dacs)); 1903 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1871 for (i = 0; i < codec->num_nodes; i++, nid++) { 1904 for_each_hda_codec_node(nid, codec) {
1872 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT) 1905 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1873 continue; 1906 continue;
1874 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) { 1907 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
@@ -2998,6 +3031,7 @@ static int new_analog_input(struct hda_codec *codec, int input_idx,
2998 } 3031 }
2999 3032
3000 path->active = true; 3033 path->active = true;
3034 path->stream_enabled = true; /* no DAC/ADC involved */
3001 err = add_loopback_list(spec, mix_nid, idx); 3035 err = add_loopback_list(spec, mix_nid, idx);
3002 if (err < 0) 3036 if (err < 0)
3003 return err; 3037 return err;
@@ -3009,6 +3043,8 @@ static int new_analog_input(struct hda_codec *codec, int input_idx,
3009 if (path) { 3043 if (path) {
3010 print_nid_path(codec, "loopback-merge", path); 3044 print_nid_path(codec, "loopback-merge", path);
3011 path->active = true; 3045 path->active = true;
3046 path->pin_fixed = true; /* static route */
3047 path->stream_enabled = true; /* no DAC/ADC involved */
3012 spec->loopback_merge_path = 3048 spec->loopback_merge_path =
3013 snd_hda_get_path_idx(codec, path); 3049 snd_hda_get_path_idx(codec, path);
3014 } 3050 }
@@ -3030,10 +3066,9 @@ static int fill_adc_nids(struct hda_codec *codec)
3030 hda_nid_t nid; 3066 hda_nid_t nid;
3031 hda_nid_t *adc_nids = spec->adc_nids; 3067 hda_nid_t *adc_nids = spec->adc_nids;
3032 int max_nums = ARRAY_SIZE(spec->adc_nids); 3068 int max_nums = ARRAY_SIZE(spec->adc_nids);
3033 int i, nums = 0; 3069 int nums = 0;
3034 3070
3035 nid = codec->start_nid; 3071 for_each_hda_codec_node(nid, codec) {
3036 for (i = 0; i < codec->num_nodes; i++, nid++) {
3037 unsigned int caps = get_wcaps(codec, nid); 3072 unsigned int caps = get_wcaps(codec, nid);
3038 int type = get_wcaps_type(caps); 3073 int type = get_wcaps_type(caps);
3039 3074
@@ -3346,11 +3381,6 @@ static int cap_put_caller(struct snd_kcontrol *kcontrol,
3346 imux = &spec->input_mux; 3381 imux = &spec->input_mux;
3347 adc_idx = kcontrol->id.index; 3382 adc_idx = kcontrol->id.index;
3348 mutex_lock(&codec->control_mutex); 3383 mutex_lock(&codec->control_mutex);
3349 /* we use the cache-only update at first since multiple input paths
3350 * may shared the same amp; by updating only caches, the redundant
3351 * writes to hardware can be reduced.
3352 */
3353 codec->cached_write = 1;
3354 for (i = 0; i < imux->num_items; i++) { 3384 for (i = 0; i < imux->num_items; i++) {
3355 path = get_input_path(codec, adc_idx, i); 3385 path = get_input_path(codec, adc_idx, i);
3356 if (!path || !path->ctls[type]) 3386 if (!path || !path->ctls[type])
@@ -3358,12 +3388,9 @@ static int cap_put_caller(struct snd_kcontrol *kcontrol,
3358 kcontrol->private_value = path->ctls[type]; 3388 kcontrol->private_value = path->ctls[type];
3359 err = func(kcontrol, ucontrol); 3389 err = func(kcontrol, ucontrol);
3360 if (err < 0) 3390 if (err < 0)
3361 goto error; 3391 break;
3362 } 3392 }
3363 error:
3364 codec->cached_write = 0;
3365 mutex_unlock(&codec->control_mutex); 3393 mutex_unlock(&codec->control_mutex);
3366 snd_hda_codec_flush_cache(codec); /* flush the updates */
3367 if (err >= 0 && spec->cap_sync_hook) 3394 if (err >= 0 && spec->cap_sync_hook)
3368 spec->cap_sync_hook(codec, kcontrol, ucontrol); 3395 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3369 return err; 3396 return err;
@@ -3810,6 +3837,7 @@ static void parse_digital(struct hda_codec *codec)
3810 continue; 3837 continue;
3811 print_nid_path(codec, "digout", path); 3838 print_nid_path(codec, "digout", path);
3812 path->active = true; 3839 path->active = true;
3840 path->pin_fixed = true; /* no jack detection */
3813 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path); 3841 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
3814 set_pin_target(codec, pin, PIN_OUT, false); 3842 set_pin_target(codec, pin, PIN_OUT, false);
3815 if (!nums) { 3843 if (!nums) {
@@ -3826,8 +3854,7 @@ static void parse_digital(struct hda_codec *codec)
3826 3854
3827 if (spec->autocfg.dig_in_pin) { 3855 if (spec->autocfg.dig_in_pin) {
3828 pin = spec->autocfg.dig_in_pin; 3856 pin = spec->autocfg.dig_in_pin;
3829 dig_nid = codec->start_nid; 3857 for_each_hda_codec_node(dig_nid, codec) {
3830 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3831 unsigned int wcaps = get_wcaps(codec, dig_nid); 3858 unsigned int wcaps = get_wcaps(codec, dig_nid);
3832 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 3859 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3833 continue; 3860 continue;
@@ -3837,6 +3864,7 @@ static void parse_digital(struct hda_codec *codec)
3837 if (path) { 3864 if (path) {
3838 print_nid_path(codec, "digin", path); 3865 print_nid_path(codec, "digin", path);
3839 path->active = true; 3866 path->active = true;
3867 path->pin_fixed = true; /* no jack */
3840 spec->dig_in_nid = dig_nid; 3868 spec->dig_in_nid = dig_nid;
3841 spec->digin_path = snd_hda_get_path_idx(codec, path); 3869 spec->digin_path = snd_hda_get_path_idx(codec, path);
3842 set_pin_target(codec, pin, PIN_IN, false); 3870 set_pin_target(codec, pin, PIN_IN, false);
@@ -3896,6 +3924,238 @@ static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3896 return 1; 3924 return 1;
3897} 3925}
3898 3926
3927/* power up/down widgets in the all paths that match with the given NID
3928 * as terminals (either start- or endpoint)
3929 *
3930 * returns the last changed NID, or zero if unchanged.
3931 */
3932static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
3933 int pin_state, int stream_state)
3934{
3935 struct hda_gen_spec *spec = codec->spec;
3936 hda_nid_t last, changed = 0;
3937 struct nid_path *path;
3938 int n;
3939
3940 for (n = 0; n < spec->paths.used; n++) {
3941 path = snd_array_elem(&spec->paths, n);
3942 if (path->path[0] == nid ||
3943 path->path[path->depth - 1] == nid) {
3944 bool pin_old = path->pin_enabled;
3945 bool stream_old = path->stream_enabled;
3946
3947 if (pin_state >= 0)
3948 path->pin_enabled = pin_state;
3949 if (stream_state >= 0)
3950 path->stream_enabled = stream_state;
3951 if ((!path->pin_fixed && path->pin_enabled != pin_old)
3952 || path->stream_enabled != stream_old) {
3953 last = path_power_update(codec, path, true);
3954 if (last)
3955 changed = last;
3956 }
3957 }
3958 }
3959 return changed;
3960}
3961
3962/* check the jack status for power control */
3963static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
3964{
3965 if (!is_jack_detectable(codec, pin))
3966 return true;
3967 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
3968}
3969
3970/* power up/down the paths of the given pin according to the jack state;
3971 * power = 0/1 : only power up/down if it matches with the jack state,
3972 * < 0 : force power up/down to follow the jack sate
3973 *
3974 * returns the last changed NID, or zero if unchanged.
3975 */
3976static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
3977 int power)
3978{
3979 bool on;
3980
3981 if (!codec->power_save_node)
3982 return 0;
3983
3984 on = detect_pin_state(codec, pin);
3985
3986 if (power >= 0 && on != power)
3987 return 0;
3988 return set_path_power(codec, pin, on, -1);
3989}
3990
3991static void pin_power_callback(struct hda_codec *codec,
3992 struct hda_jack_callback *jack,
3993 bool on)
3994{
3995 if (jack && jack->tbl->nid)
3996 sync_power_state_change(codec,
3997 set_pin_power_jack(codec, jack->tbl->nid, on));
3998}
3999
4000/* callback only doing power up -- called at first */
4001static void pin_power_up_callback(struct hda_codec *codec,
4002 struct hda_jack_callback *jack)
4003{
4004 pin_power_callback(codec, jack, true);
4005}
4006
4007/* callback only doing power down -- called at last */
4008static void pin_power_down_callback(struct hda_codec *codec,
4009 struct hda_jack_callback *jack)
4010{
4011 pin_power_callback(codec, jack, false);
4012}
4013
4014/* set up the power up/down callbacks */
4015static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4016 const hda_nid_t *pins, bool on)
4017{
4018 int i;
4019 hda_jack_callback_fn cb =
4020 on ? pin_power_up_callback : pin_power_down_callback;
4021
4022 for (i = 0; i < num_pins && pins[i]; i++) {
4023 if (is_jack_detectable(codec, pins[i]))
4024 snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4025 else
4026 set_path_power(codec, pins[i], true, -1);
4027 }
4028}
4029
4030/* enabled power callback to each available I/O pin with jack detections;
4031 * the digital I/O pins are excluded because of the unreliable detectsion
4032 */
4033static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4034{
4035 struct hda_gen_spec *spec = codec->spec;
4036 struct auto_pin_cfg *cfg = &spec->autocfg;
4037 int i;
4038
4039 if (!codec->power_save_node)
4040 return;
4041 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4042 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4043 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4044 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4045 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4046 for (i = 0; i < cfg->num_inputs; i++)
4047 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4048}
4049
4050/* sync path power up/down with the jack states of given pins */
4051static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4052 const hda_nid_t *pins)
4053{
4054 int i;
4055
4056 for (i = 0; i < num_pins && pins[i]; i++)
4057 if (is_jack_detectable(codec, pins[i]))
4058 set_pin_power_jack(codec, pins[i], -1);
4059}
4060
4061/* sync path power up/down with pins; called at init and resume */
4062static void sync_all_pin_power_ctls(struct hda_codec *codec)
4063{
4064 struct hda_gen_spec *spec = codec->spec;
4065 struct auto_pin_cfg *cfg = &spec->autocfg;
4066 int i;
4067
4068 if (!codec->power_save_node)
4069 return;
4070 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4071 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4072 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4073 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4074 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4075 for (i = 0; i < cfg->num_inputs; i++)
4076 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4077}
4078
4079/* add fake paths if not present yet */
4080static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4081 int num_pins, const hda_nid_t *pins)
4082{
4083 struct hda_gen_spec *spec = codec->spec;
4084 struct nid_path *path;
4085 int i;
4086
4087 for (i = 0; i < num_pins; i++) {
4088 if (!pins[i])
4089 break;
4090 if (get_nid_path(codec, nid, pins[i], 0))
4091 continue;
4092 path = snd_array_new(&spec->paths);
4093 if (!path)
4094 return -ENOMEM;
4095 memset(path, 0, sizeof(*path));
4096 path->depth = 2;
4097 path->path[0] = nid;
4098 path->path[1] = pins[i];
4099 path->active = true;
4100 }
4101 return 0;
4102}
4103
4104/* create fake paths to all outputs from beep */
4105static int add_fake_beep_paths(struct hda_codec *codec)
4106{
4107 struct hda_gen_spec *spec = codec->spec;
4108 struct auto_pin_cfg *cfg = &spec->autocfg;
4109 hda_nid_t nid = spec->beep_nid;
4110 int err;
4111
4112 if (!codec->power_save_node || !nid)
4113 return 0;
4114 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4115 if (err < 0)
4116 return err;
4117 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4118 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4119 if (err < 0)
4120 return err;
4121 }
4122 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4123 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4124 cfg->speaker_pins);
4125 if (err < 0)
4126 return err;
4127 }
4128 return 0;
4129}
4130
4131/* power up/down beep widget and its output paths */
4132static void beep_power_hook(struct hda_beep *beep, bool on)
4133{
4134 set_path_power(beep->codec, beep->nid, -1, on);
4135}
4136
4137/**
4138 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4139 * @codec: the HDA codec
4140 * @pin: NID of pin to fix
4141 */
4142int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4143{
4144 struct hda_gen_spec *spec = codec->spec;
4145 struct nid_path *path;
4146
4147 path = snd_array_new(&spec->paths);
4148 if (!path)
4149 return -ENOMEM;
4150 memset(path, 0, sizeof(*path));
4151 path->depth = 1;
4152 path->path[0] = pin;
4153 path->active = true;
4154 path->pin_fixed = true;
4155 path->stream_enabled = true;
4156 return 0;
4157}
4158EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
3899 4159
3900/* 4160/*
3901 * Jack detections for HP auto-mute and mic-switch 4161 * Jack detections for HP auto-mute and mic-switch
@@ -3933,6 +4193,10 @@ static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3933 if (!nid) 4193 if (!nid)
3934 break; 4194 break;
3935 4195
4196 oldval = snd_hda_codec_get_pin_target(codec, nid);
4197 if (oldval & PIN_IN)
4198 continue; /* no mute for inputs */
4199
3936 if (spec->auto_mute_via_amp) { 4200 if (spec->auto_mute_via_amp) {
3937 struct nid_path *path; 4201 struct nid_path *path;
3938 hda_nid_t mute_nid; 4202 hda_nid_t mute_nid;
@@ -3947,29 +4211,32 @@ static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3947 spec->mute_bits |= (1ULL << mute_nid); 4211 spec->mute_bits |= (1ULL << mute_nid);
3948 else 4212 else
3949 spec->mute_bits &= ~(1ULL << mute_nid); 4213 spec->mute_bits &= ~(1ULL << mute_nid);
3950 set_pin_eapd(codec, nid, !mute);
3951 continue; 4214 continue;
4215 } else {
4216 /* don't reset VREF value in case it's controlling
4217 * the amp (see alc861_fixup_asus_amp_vref_0f())
4218 */
4219 if (spec->keep_vref_in_automute)
4220 val = oldval & ~PIN_HP;
4221 else
4222 val = 0;
4223 if (!mute)
4224 val |= oldval;
4225 /* here we call update_pin_ctl() so that the pinctl is
4226 * changed without changing the pinctl target value;
4227 * the original target value will be still referred at
4228 * the init / resume again
4229 */
4230 update_pin_ctl(codec, nid, val);
3952 } 4231 }
3953 4232
3954 oldval = snd_hda_codec_get_pin_target(codec, nid);
3955 if (oldval & PIN_IN)
3956 continue; /* no mute for inputs */
3957 /* don't reset VREF value in case it's controlling
3958 * the amp (see alc861_fixup_asus_amp_vref_0f())
3959 */
3960 if (spec->keep_vref_in_automute)
3961 val = oldval & ~PIN_HP;
3962 else
3963 val = 0;
3964 if (!mute)
3965 val |= oldval;
3966 /* here we call update_pin_ctl() so that the pinctl is changed
3967 * without changing the pinctl target value;
3968 * the original target value will be still referred at the
3969 * init / resume again
3970 */
3971 update_pin_ctl(codec, nid, val);
3972 set_pin_eapd(codec, nid, !mute); 4233 set_pin_eapd(codec, nid, !mute);
4234 if (codec->power_save_node) {
4235 bool on = !mute;
4236 if (on)
4237 on = detect_pin_state(codec, nid);
4238 set_path_power(codec, nid, on, -1);
4239 }
3973 } 4240 }
3974} 4241}
3975 4242
@@ -4436,7 +4703,11 @@ unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4436 hda_nid_t nid, 4703 hda_nid_t nid,
4437 unsigned int power_state) 4704 unsigned int power_state)
4438{ 4705{
4439 if (power_state != AC_PWRST_D0 || nid == codec->afg) 4706 struct hda_gen_spec *spec = codec->spec;
4707
4708 if (!spec->power_down_unused && !codec->power_save_node)
4709 return power_state;
4710 if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4440 return power_state; 4711 return power_state;
4441 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER) 4712 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4442 return power_state; 4713 return power_state;
@@ -4466,6 +4737,21 @@ static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4466} 4737}
4467 4738
4468/** 4739/**
4740 * snd_hda_gen_stream_pm - Stream power management callback
4741 * @codec: the HDA codec
4742 * @nid: audio widget
4743 * @on: power on/off flag
4744 *
4745 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag.
4746 */
4747void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4748{
4749 if (codec->power_save_node)
4750 set_path_power(codec, nid, -1, on);
4751}
4752EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4753
4754/**
4469 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and 4755 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4470 * set up the hda_gen_spec 4756 * set up the hda_gen_spec
4471 * @codec: the HDA codec 4757 * @codec: the HDA codec
@@ -4549,6 +4835,9 @@ int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4549 if (err < 0) 4835 if (err < 0)
4550 return err; 4836 return err;
4551 4837
4838 /* add power-down pin callbacks at first */
4839 add_all_pin_power_ctls(codec, false);
4840
4552 spec->const_channel_count = spec->ext_channel_count; 4841 spec->const_channel_count = spec->ext_channel_count;
4553 /* check the multiple speaker and headphone pins */ 4842 /* check the multiple speaker and headphone pins */
4554 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 4843 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
@@ -4618,6 +4907,9 @@ int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4618 } 4907 }
4619 } 4908 }
4620 4909
4910 /* add power-up pin callbacks at last */
4911 add_all_pin_power_ctls(codec, true);
4912
4621 /* mute all aamix input initially */ 4913 /* mute all aamix input initially */
4622 if (spec->mixer_nid) 4914 if (spec->mixer_nid)
4623 mute_all_mixer_nid(codec, spec->mixer_nid); 4915 mute_all_mixer_nid(codec, spec->mixer_nid);
@@ -4625,13 +4917,20 @@ int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4625 dig_only: 4917 dig_only:
4626 parse_digital(codec); 4918 parse_digital(codec);
4627 4919
4628 if (spec->power_down_unused) 4920 if (spec->power_down_unused || codec->power_save_node)
4629 codec->power_filter = snd_hda_gen_path_power_filter; 4921 if (!codec->power_filter)
4922 codec->power_filter = snd_hda_gen_path_power_filter;
4630 4923
4631 if (!spec->no_analog && spec->beep_nid) { 4924 if (!spec->no_analog && spec->beep_nid) {
4632 err = snd_hda_attach_beep_device(codec, spec->beep_nid); 4925 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
4633 if (err < 0) 4926 if (err < 0)
4634 return err; 4927 return err;
4928 if (codec->beep && codec->power_save_node) {
4929 err = add_fake_beep_paths(codec);
4930 if (err < 0)
4931 return err;
4932 codec->beep->power_hook = beep_power_hook;
4933 }
4635 } 4934 }
4636 4935
4637 return 1; 4936 return 1;
@@ -4675,7 +4974,7 @@ int snd_hda_gen_build_controls(struct hda_codec *codec)
4675 err = snd_hda_create_dig_out_ctls(codec, 4974 err = snd_hda_create_dig_out_ctls(codec,
4676 spec->multiout.dig_out_nid, 4975 spec->multiout.dig_out_nid,
4677 spec->multiout.dig_out_nid, 4976 spec->multiout.dig_out_nid,
4678 spec->pcm_rec[1].pcm_type); 4977 spec->pcm_rec[1]->pcm_type);
4679 if (err < 0) 4978 if (err < 0)
4680 return err; 4979 return err;
4681 if (!spec->no_analog) { 4980 if (!spec->no_analog) {
@@ -5137,6 +5436,33 @@ static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5137 strlcat(str, sfx, len); 5436 strlcat(str, sfx, len);
5138} 5437}
5139 5438
5439/* copy PCM stream info from @default_str, and override non-NULL entries
5440 * from @spec_str and @nid
5441 */
5442static void setup_pcm_stream(struct hda_pcm_stream *str,
5443 const struct hda_pcm_stream *default_str,
5444 const struct hda_pcm_stream *spec_str,
5445 hda_nid_t nid)
5446{
5447 *str = *default_str;
5448 if (nid)
5449 str->nid = nid;
5450 if (spec_str) {
5451 if (spec_str->substreams)
5452 str->substreams = spec_str->substreams;
5453 if (spec_str->channels_min)
5454 str->channels_min = spec_str->channels_min;
5455 if (spec_str->channels_max)
5456 str->channels_max = spec_str->channels_max;
5457 if (spec_str->rates)
5458 str->rates = spec_str->rates;
5459 if (spec_str->formats)
5460 str->formats = spec_str->formats;
5461 if (spec_str->maxbps)
5462 str->maxbps = spec_str->maxbps;
5463 }
5464}
5465
5140/** 5466/**
5141 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results 5467 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5142 * @codec: the HDA codec 5468 * @codec: the HDA codec
@@ -5146,27 +5472,25 @@ static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5146int snd_hda_gen_build_pcms(struct hda_codec *codec) 5472int snd_hda_gen_build_pcms(struct hda_codec *codec)
5147{ 5473{
5148 struct hda_gen_spec *spec = codec->spec; 5474 struct hda_gen_spec *spec = codec->spec;
5149 struct hda_pcm *info = spec->pcm_rec; 5475 struct hda_pcm *info;
5150 const struct hda_pcm_stream *p;
5151 bool have_multi_adcs; 5476 bool have_multi_adcs;
5152 5477
5153 codec->num_pcms = 1;
5154 codec->pcm_info = info;
5155
5156 if (spec->no_analog) 5478 if (spec->no_analog)
5157 goto skip_analog; 5479 goto skip_analog;
5158 5480
5159 fill_pcm_stream_name(spec->stream_name_analog, 5481 fill_pcm_stream_name(spec->stream_name_analog,
5160 sizeof(spec->stream_name_analog), 5482 sizeof(spec->stream_name_analog),
5161 " Analog", codec->chip_name); 5483 " Analog", codec->core.chip_name);
5162 info->name = spec->stream_name_analog; 5484 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5485 if (!info)
5486 return -ENOMEM;
5487 spec->pcm_rec[0] = info;
5163 5488
5164 if (spec->multiout.num_dacs > 0) { 5489 if (spec->multiout.num_dacs > 0) {
5165 p = spec->stream_analog_playback; 5490 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5166 if (!p) 5491 &pcm_analog_playback,
5167 p = &pcm_analog_playback; 5492 spec->stream_analog_playback,
5168 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 5493 spec->multiout.dac_nids[0]);
5169 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
5170 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 5494 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5171 spec->multiout.max_channels; 5495 spec->multiout.max_channels;
5172 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT && 5496 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
@@ -5175,15 +5499,11 @@ int snd_hda_gen_build_pcms(struct hda_codec *codec)
5175 snd_pcm_2_1_chmaps; 5499 snd_pcm_2_1_chmaps;
5176 } 5500 }
5177 if (spec->num_adc_nids) { 5501 if (spec->num_adc_nids) {
5178 p = spec->stream_analog_capture; 5502 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5179 if (!p) { 5503 (spec->dyn_adc_switch ?
5180 if (spec->dyn_adc_switch) 5504 &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5181 p = &dyn_adc_pcm_analog_capture; 5505 spec->stream_analog_capture,
5182 else 5506 spec->adc_nids[0]);
5183 p = &pcm_analog_capture;
5184 }
5185 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5186 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
5187 } 5507 }
5188 5508
5189 skip_analog: 5509 skip_analog:
@@ -5191,29 +5511,27 @@ int snd_hda_gen_build_pcms(struct hda_codec *codec)
5191 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 5511 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5192 fill_pcm_stream_name(spec->stream_name_digital, 5512 fill_pcm_stream_name(spec->stream_name_digital,
5193 sizeof(spec->stream_name_digital), 5513 sizeof(spec->stream_name_digital),
5194 " Digital", codec->chip_name); 5514 " Digital", codec->core.chip_name);
5195 codec->num_pcms = 2; 5515 info = snd_hda_codec_pcm_new(codec, "%s",
5516 spec->stream_name_digital);
5517 if (!info)
5518 return -ENOMEM;
5196 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 5519 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
5197 info = spec->pcm_rec + 1; 5520 spec->pcm_rec[1] = info;
5198 info->name = spec->stream_name_digital;
5199 if (spec->dig_out_type) 5521 if (spec->dig_out_type)
5200 info->pcm_type = spec->dig_out_type; 5522 info->pcm_type = spec->dig_out_type;
5201 else 5523 else
5202 info->pcm_type = HDA_PCM_TYPE_SPDIF; 5524 info->pcm_type = HDA_PCM_TYPE_SPDIF;
5203 if (spec->multiout.dig_out_nid) { 5525 if (spec->multiout.dig_out_nid)
5204 p = spec->stream_digital_playback; 5526 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5205 if (!p) 5527 &pcm_digital_playback,
5206 p = &pcm_digital_playback; 5528 spec->stream_digital_playback,
5207 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 5529 spec->multiout.dig_out_nid);
5208 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 5530 if (spec->dig_in_nid)
5209 } 5531 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5210 if (spec->dig_in_nid) { 5532 &pcm_digital_capture,
5211 p = spec->stream_digital_capture; 5533 spec->stream_digital_capture,
5212 if (!p) 5534 spec->dig_in_nid);
5213 p = &pcm_digital_capture;
5214 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5215 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
5216 }
5217 } 5535 }
5218 5536
5219 if (spec->no_analog) 5537 if (spec->no_analog)
@@ -5228,35 +5546,30 @@ int snd_hda_gen_build_pcms(struct hda_codec *codec)
5228 if (spec->alt_dac_nid || have_multi_adcs) { 5546 if (spec->alt_dac_nid || have_multi_adcs) {
5229 fill_pcm_stream_name(spec->stream_name_alt_analog, 5547 fill_pcm_stream_name(spec->stream_name_alt_analog,
5230 sizeof(spec->stream_name_alt_analog), 5548 sizeof(spec->stream_name_alt_analog),
5231 " Alt Analog", codec->chip_name); 5549 " Alt Analog", codec->core.chip_name);
5232 codec->num_pcms = 3; 5550 info = snd_hda_codec_pcm_new(codec, "%s",
5233 info = spec->pcm_rec + 2; 5551 spec->stream_name_alt_analog);
5234 info->name = spec->stream_name_alt_analog; 5552 if (!info)
5235 if (spec->alt_dac_nid) { 5553 return -ENOMEM;
5236 p = spec->stream_analog_alt_playback; 5554 spec->pcm_rec[2] = info;
5237 if (!p) 5555 if (spec->alt_dac_nid)
5238 p = &pcm_analog_alt_playback; 5556 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5239 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 5557 &pcm_analog_alt_playback,
5240 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 5558 spec->stream_analog_alt_playback,
5241 spec->alt_dac_nid; 5559 spec->alt_dac_nid);
5242 } else { 5560 else
5243 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 5561 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5244 pcm_null_stream; 5562 &pcm_null_stream, NULL, 0);
5245 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
5246 }
5247 if (have_multi_adcs) { 5563 if (have_multi_adcs) {
5248 p = spec->stream_analog_alt_capture; 5564 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5249 if (!p) 5565 &pcm_analog_alt_capture,
5250 p = &pcm_analog_alt_capture; 5566 spec->stream_analog_alt_capture,
5251 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 5567 spec->adc_nids[1]);
5252 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
5253 spec->adc_nids[1];
5254 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 5568 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5255 spec->num_adc_nids - 1; 5569 spec->num_adc_nids - 1;
5256 } else { 5570 } else {
5257 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 5571 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5258 pcm_null_stream; 5572 &pcm_null_stream, NULL, 0);
5259 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
5260 } 5573 }
5261 } 5574 }
5262 5575
@@ -5452,8 +5765,6 @@ int snd_hda_gen_init(struct hda_codec *codec)
5452 5765
5453 snd_hda_apply_verbs(codec); 5766 snd_hda_apply_verbs(codec);
5454 5767
5455 codec->cached_write = 1;
5456
5457 init_multi_out(codec); 5768 init_multi_out(codec);
5458 init_extra_out(codec); 5769 init_extra_out(codec);
5459 init_multi_io(codec); 5770 init_multi_io(codec);
@@ -5464,10 +5775,12 @@ int snd_hda_gen_init(struct hda_codec *codec)
5464 5775
5465 clear_unsol_on_unused_pins(codec); 5776 clear_unsol_on_unused_pins(codec);
5466 5777
5778 sync_all_pin_power_ctls(codec);
5779
5467 /* call init functions of standard auto-mute helpers */ 5780 /* call init functions of standard auto-mute helpers */
5468 update_automute_all(codec); 5781 update_automute_all(codec);
5469 5782
5470 snd_hda_codec_flush_cache(codec); 5783 regcache_sync(codec->core.regmap);
5471 5784
5472 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook) 5785 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5473 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 5786 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
@@ -5524,13 +5837,11 @@ static const struct hda_codec_ops generic_patch_ops = {
5524#endif 5837#endif
5525}; 5838};
5526 5839
5527/** 5840/*
5528 * snd_hda_parse_generic_codec - Generic codec parser 5841 * snd_hda_parse_generic_codec - Generic codec parser
5529 * @codec: the HDA codec 5842 * @codec: the HDA codec
5530 *
5531 * This should be called from the HDA codec core.
5532 */ 5843 */
5533int snd_hda_parse_generic_codec(struct hda_codec *codec) 5844static int snd_hda_parse_generic_codec(struct hda_codec *codec)
5534{ 5845{
5535 struct hda_gen_spec *spec; 5846 struct hda_gen_spec *spec;
5536 int err; 5847 int err;
@@ -5556,7 +5867,17 @@ error:
5556 snd_hda_gen_free(codec); 5867 snd_hda_gen_free(codec);
5557 return err; 5868 return err;
5558} 5869}
5559EXPORT_SYMBOL_GPL(snd_hda_parse_generic_codec); 5870
5871static const struct hda_codec_preset snd_hda_preset_generic[] = {
5872 { .id = HDA_CODEC_ID_GENERIC, .patch = snd_hda_parse_generic_codec },
5873 {} /* terminator */
5874};
5875
5876static struct hda_codec_driver generic_driver = {
5877 .preset = snd_hda_preset_generic,
5878};
5879
5880module_hda_codec_driver(generic_driver);
5560 5881
5561MODULE_LICENSE("GPL"); 5882MODULE_LICENSE("GPL");
5562MODULE_DESCRIPTION("Generic HD-audio codec parser"); 5883MODULE_DESCRIPTION("Generic HD-audio codec parser");
diff --git a/sound/pci/hda/hda_generic.h b/sound/pci/hda/hda_generic.h
index 3d852660443a..56e4139b9032 100644
--- a/sound/pci/hda/hda_generic.h
+++ b/sound/pci/hda/hda_generic.h
@@ -46,7 +46,10 @@ struct nid_path {
46 unsigned char idx[MAX_NID_PATH_DEPTH]; 46 unsigned char idx[MAX_NID_PATH_DEPTH];
47 unsigned char multi[MAX_NID_PATH_DEPTH]; 47 unsigned char multi[MAX_NID_PATH_DEPTH];
48 unsigned int ctls[NID_PATH_NUM_CTLS]; /* NID_PATH_XXX_CTL */ 48 unsigned int ctls[NID_PATH_NUM_CTLS]; /* NID_PATH_XXX_CTL */
49 bool active; 49 bool active:1; /* activated by driver */
50 bool pin_enabled:1; /* pins are enabled */
51 bool pin_fixed:1; /* path with fixed pin */
52 bool stream_enabled:1; /* stream is active */
50}; 53};
51 54
52/* mic/line-in auto switching entry */ 55/* mic/line-in auto switching entry */
@@ -144,7 +147,7 @@ struct hda_gen_spec {
144 int const_channel_count; /* channel count for all */ 147 int const_channel_count; /* channel count for all */
145 148
146 /* PCM information */ 149 /* PCM information */
147 struct hda_pcm pcm_rec[3]; /* used in build_pcms() */ 150 struct hda_pcm *pcm_rec[3]; /* used in build_pcms() */
148 151
149 /* dynamic controls, init_verbs and input_mux */ 152 /* dynamic controls, init_verbs and input_mux */
150 struct auto_pin_cfg autocfg; 153 struct auto_pin_cfg autocfg;
@@ -340,5 +343,7 @@ int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid);
340unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec, 343unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
341 hda_nid_t nid, 344 hda_nid_t nid,
342 unsigned int power_state); 345 unsigned int power_state);
346void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on);
347int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin);
343 348
344#endif /* __SOUND_HDA_GENERIC_H */ 349#endif /* __SOUND_HDA_GENERIC_H */
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index 11b5a42b4ec8..57df06e76968 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -101,7 +101,7 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
101 int err; 101 int err;
102 102
103 sprintf(hwname, "HDA Codec %d", codec->addr); 103 sprintf(hwname, "HDA Codec %d", codec->addr);
104 err = snd_hwdep_new(codec->bus->card, hwname, codec->addr, &hwdep); 104 err = snd_hwdep_new(codec->card, hwname, codec->addr, &hwdep);
105 if (err < 0) 105 if (err < 0)
106 return err; 106 return err;
107 codec->hwdep = hwdep; 107 codec->hwdep = hwdep;
@@ -116,9 +116,6 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
116 hwdep->ops.ioctl_compat = hda_hwdep_ioctl_compat; 116 hwdep->ops.ioctl_compat = hda_hwdep_ioctl_compat;
117#endif 117#endif
118 118
119 /* link to codec */
120 hwdep->dev.parent = &codec->dev;
121
122 /* for sysfs */ 119 /* for sysfs */
123 hwdep->dev.groups = snd_hda_dev_attr_groups; 120 hwdep->dev.groups = snd_hda_dev_attr_groups;
124 dev_set_drvdata(&hwdep->dev, codec); 121 dev_set_drvdata(&hwdep->dev, codec);
diff --git a/sound/pci/hda/hda_i915.c b/sound/pci/hda/hda_i915.c
index 714894527e06..52a85d87c23c 100644
--- a/sound/pci/hda/hda_i915.c
+++ b/sound/pci/hda/hda_i915.c
@@ -22,7 +22,7 @@
22#include <linux/component.h> 22#include <linux/component.h>
23#include <drm/i915_component.h> 23#include <drm/i915_component.h>
24#include <sound/core.h> 24#include <sound/core.h>
25#include "hda_priv.h" 25#include "hda_controller.h"
26#include "hda_intel.h" 26#include "hda_intel.h"
27 27
28/* Intel HSW/BDW display HDA controller Extended Mode registers. 28/* Intel HSW/BDW display HDA controller Extended Mode registers.
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index a8a1e14272a1..e1c210515581 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -62,7 +62,6 @@
62#include <linux/firmware.h> 62#include <linux/firmware.h>
63#include "hda_codec.h" 63#include "hda_codec.h"
64#include "hda_controller.h" 64#include "hda_controller.h"
65#include "hda_priv.h"
66#include "hda_intel.h" 65#include "hda_intel.h"
67 66
68/* position fix mode */ 67/* position fix mode */
@@ -174,7 +173,6 @@ static struct kernel_param_ops param_ops_xint = {
174#define param_check_xint param_check_int 173#define param_check_xint param_check_int
175 174
176static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT; 175static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
177static int *power_save_addr = &power_save;
178module_param(power_save, xint, 0644); 176module_param(power_save, xint, 0644);
179MODULE_PARM_DESC(power_save, "Automatic power-saving timeout " 177MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
180 "(in second, 0 = disable)."); 178 "(in second, 0 = disable).");
@@ -187,7 +185,7 @@ static bool power_save_controller = 1;
187module_param(power_save_controller, bool, 0644); 185module_param(power_save_controller, bool, 0644);
188MODULE_PARM_DESC(power_save_controller, "Reset controller in power save mode."); 186MODULE_PARM_DESC(power_save_controller, "Reset controller in power save mode.");
189#else 187#else
190static int *power_save_addr; 188#define power_save 0
191#endif /* CONFIG_PM */ 189#endif /* CONFIG_PM */
192 190
193static int align_buffer_size = -1; 191static int align_buffer_size = -1;
@@ -299,8 +297,12 @@ enum {
299 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_POWERWELL |\ 297 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_POWERWELL |\
300 AZX_DCAPS_SNOOP_TYPE(SCH)) 298 AZX_DCAPS_SNOOP_TYPE(SCH))
301 299
300#define AZX_DCAPS_INTEL_BRASWELL \
301 (AZX_DCAPS_INTEL_PCH | AZX_DCAPS_I915_POWERWELL)
302
302#define AZX_DCAPS_INTEL_SKYLAKE \ 303#define AZX_DCAPS_INTEL_SKYLAKE \
303 (AZX_DCAPS_INTEL_PCH | AZX_DCAPS_SEPARATE_STREAM_TAG) 304 (AZX_DCAPS_INTEL_PCH | AZX_DCAPS_SEPARATE_STREAM_TAG |\
305 AZX_DCAPS_I915_POWERWELL)
304 306
305/* quirks for ATI SB / AMD Hudson */ 307/* quirks for ATI SB / AMD Hudson */
306#define AZX_DCAPS_PRESET_ATI_SB \ 308#define AZX_DCAPS_PRESET_ATI_SB \
@@ -530,10 +532,10 @@ static int azx_position_check(struct azx *chip, struct azx_dev *azx_dev)
530 if (ok == 1) { 532 if (ok == 1) {
531 azx_dev->irq_pending = 0; 533 azx_dev->irq_pending = 0;
532 return ok; 534 return ok;
533 } else if (ok == 0 && chip->bus && chip->bus->workq) { 535 } else if (ok == 0) {
534 /* bogus IRQ, process it later */ 536 /* bogus IRQ, process it later */
535 azx_dev->irq_pending = 1; 537 azx_dev->irq_pending = 1;
536 queue_work(chip->bus->workq, &hda->irq_pending_work); 538 schedule_work(&hda->irq_pending_work);
537 } 539 }
538 return 0; 540 return 0;
539} 541}
@@ -741,7 +743,6 @@ static int param_set_xint(const char *val, const struct kernel_param *kp)
741{ 743{
742 struct hda_intel *hda; 744 struct hda_intel *hda;
743 struct azx *chip; 745 struct azx *chip;
744 struct hda_codec *c;
745 int prev = power_save; 746 int prev = power_save;
746 int ret = param_set_int(val, kp); 747 int ret = param_set_int(val, kp);
747 748
@@ -753,8 +754,7 @@ static int param_set_xint(const char *val, const struct kernel_param *kp)
753 chip = &hda->chip; 754 chip = &hda->chip;
754 if (!chip->bus || chip->disabled) 755 if (!chip->bus || chip->disabled)
755 continue; 756 continue;
756 list_for_each_entry(c, &chip->bus->codec_list, list) 757 snd_hda_set_power_save(chip->bus, power_save * 1000);
757 snd_hda_power_sync(c);
758 } 758 }
759 mutex_unlock(&card_list_lock); 759 mutex_unlock(&card_list_lock);
760 return 0; 760 return 0;
@@ -773,7 +773,6 @@ static int azx_suspend(struct device *dev)
773 struct snd_card *card = dev_get_drvdata(dev); 773 struct snd_card *card = dev_get_drvdata(dev);
774 struct azx *chip; 774 struct azx *chip;
775 struct hda_intel *hda; 775 struct hda_intel *hda;
776 struct azx_pcm *p;
777 776
778 if (!card) 777 if (!card)
779 return 0; 778 return 0;
@@ -785,10 +784,6 @@ static int azx_suspend(struct device *dev)
785 784
786 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 785 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
787 azx_clear_irq_pending(chip); 786 azx_clear_irq_pending(chip);
788 list_for_each_entry(p, &chip->pcm_list, list)
789 snd_pcm_suspend_all(p->pcm);
790 if (chip->initialized)
791 snd_hda_suspend(chip->bus);
792 azx_stop_chip(chip); 787 azx_stop_chip(chip);
793 azx_enter_link_reset(chip); 788 azx_enter_link_reset(chip);
794 if (chip->irq >= 0) { 789 if (chip->irq >= 0) {
@@ -831,7 +826,6 @@ static int azx_resume(struct device *dev)
831 826
832 azx_init_chip(chip, true); 827 azx_init_chip(chip, true);
833 828
834 snd_hda_resume(chip->bus);
835 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 829 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
836 return 0; 830 return 0;
837} 831}
@@ -852,7 +846,7 @@ static int azx_runtime_suspend(struct device *dev)
852 if (chip->disabled || hda->init_failed) 846 if (chip->disabled || hda->init_failed)
853 return 0; 847 return 0;
854 848
855 if (!(chip->driver_caps & AZX_DCAPS_PM_RUNTIME)) 849 if (!azx_has_pm_runtime(chip))
856 return 0; 850 return 0;
857 851
858 /* enable controller wake up event */ 852 /* enable controller wake up event */
@@ -885,7 +879,7 @@ static int azx_runtime_resume(struct device *dev)
885 if (chip->disabled || hda->init_failed) 879 if (chip->disabled || hda->init_failed)
886 return 0; 880 return 0;
887 881
888 if (!(chip->driver_caps & AZX_DCAPS_PM_RUNTIME)) 882 if (!azx_has_pm_runtime(chip))
889 return 0; 883 return 0;
890 884
891 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) { 885 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
@@ -901,10 +895,10 @@ static int azx_runtime_resume(struct device *dev)
901 895
902 bus = chip->bus; 896 bus = chip->bus;
903 if (status && bus) { 897 if (status && bus) {
904 list_for_each_entry(codec, &bus->codec_list, list) 898 list_for_each_codec(codec, bus)
905 if (status & (1 << codec->addr)) 899 if (status & (1 << codec->addr))
906 queue_delayed_work(codec->bus->workq, 900 schedule_delayed_work(&codec->jackpoll_work,
907 &codec->jackpoll_work, codec->jackpoll_interval); 901 codec->jackpoll_interval);
908 } 902 }
909 903
910 /* disable controller Wake Up event*/ 904 /* disable controller Wake Up event*/
@@ -928,8 +922,8 @@ static int azx_runtime_idle(struct device *dev)
928 if (chip->disabled || hda->init_failed) 922 if (chip->disabled || hda->init_failed)
929 return 0; 923 return 0;
930 924
931 if (!power_save_controller || 925 if (!power_save_controller || !azx_has_pm_runtime(chip) ||
932 !(chip->driver_caps & AZX_DCAPS_PM_RUNTIME)) 926 chip->bus->core.codec_powered)
933 return -EBUSY; 927 return -EBUSY;
934 928
935 return 0; 929 return 0;
@@ -1071,14 +1065,11 @@ static int azx_free(struct azx *chip)
1071 struct hda_intel *hda = container_of(chip, struct hda_intel, chip); 1065 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
1072 int i; 1066 int i;
1073 1067
1074 if ((chip->driver_caps & AZX_DCAPS_PM_RUNTIME) 1068 if (azx_has_pm_runtime(chip) && chip->running)
1075 && chip->running)
1076 pm_runtime_get_noresume(&pci->dev); 1069 pm_runtime_get_noresume(&pci->dev);
1077 1070
1078 azx_del_card_list(chip); 1071 azx_del_card_list(chip);
1079 1072
1080 azx_notifier_unregister(chip);
1081
1082 hda->init_failed = 1; /* to be sure */ 1073 hda->init_failed = 1; /* to be sure */
1083 complete_all(&hda->probe_wait); 1074 complete_all(&hda->probe_wait);
1084 1075
@@ -1394,7 +1385,6 @@ static int azx_create(struct snd_card *card, struct pci_dev *pci,
1394 1385
1395 hda = kzalloc(sizeof(*hda), GFP_KERNEL); 1386 hda = kzalloc(sizeof(*hda), GFP_KERNEL);
1396 if (!hda) { 1387 if (!hda) {
1397 dev_err(card->dev, "Cannot allocate hda\n");
1398 pci_disable_device(pci); 1388 pci_disable_device(pci);
1399 return -ENOMEM; 1389 return -ENOMEM;
1400 } 1390 }
@@ -1575,10 +1565,8 @@ static int azx_first_init(struct azx *chip)
1575 chip->num_streams = chip->playback_streams + chip->capture_streams; 1565 chip->num_streams = chip->playback_streams + chip->capture_streams;
1576 chip->azx_dev = kcalloc(chip->num_streams, sizeof(*chip->azx_dev), 1566 chip->azx_dev = kcalloc(chip->num_streams, sizeof(*chip->azx_dev),
1577 GFP_KERNEL); 1567 GFP_KERNEL);
1578 if (!chip->azx_dev) { 1568 if (!chip->azx_dev)
1579 dev_err(card->dev, "cannot malloc azx_dev\n");
1580 return -ENOMEM; 1569 return -ENOMEM;
1581 }
1582 1570
1583 err = azx_alloc_stream_pages(chip); 1571 err = azx_alloc_stream_pages(chip);
1584 if (err < 0) 1572 if (err < 0)
@@ -1615,19 +1603,6 @@ static int azx_first_init(struct azx *chip)
1615 return 0; 1603 return 0;
1616} 1604}
1617 1605
1618static void power_down_all_codecs(struct azx *chip)
1619{
1620#ifdef CONFIG_PM
1621 /* The codecs were powered up in snd_hda_codec_new().
1622 * Now all initialization done, so turn them down if possible
1623 */
1624 struct hda_codec *codec;
1625 list_for_each_entry(codec, &chip->bus->codec_list, list) {
1626 snd_hda_power_down(codec);
1627 }
1628#endif
1629}
1630
1631#ifdef CONFIG_SND_HDA_PATCH_LOADER 1606#ifdef CONFIG_SND_HDA_PATCH_LOADER
1632/* callback from request_firmware_nowait() */ 1607/* callback from request_firmware_nowait() */
1633static void azx_firmware_cb(const struct firmware *fw, void *context) 1608static void azx_firmware_cb(const struct firmware *fw, void *context)
@@ -1896,12 +1871,14 @@ static int azx_probe_continue(struct azx *chip)
1896#endif 1871#endif
1897 1872
1898 /* create codec instances */ 1873 /* create codec instances */
1899 err = azx_codec_create(chip, model[dev], 1874 err = azx_bus_create(chip, model[dev]);
1900 azx_max_codecs[chip->driver_type], 1875 if (err < 0)
1901 power_save_addr); 1876 goto out_free;
1902 1877
1878 err = azx_probe_codecs(chip, azx_max_codecs[chip->driver_type]);
1903 if (err < 0) 1879 if (err < 0)
1904 goto out_free; 1880 goto out_free;
1881
1905#ifdef CONFIG_SND_HDA_PATCH_LOADER 1882#ifdef CONFIG_SND_HDA_PATCH_LOADER
1906 if (chip->fw) { 1883 if (chip->fw) {
1907 err = snd_hda_load_patch(chip->bus, chip->fw->size, 1884 err = snd_hda_load_patch(chip->bus, chip->fw->size,
@@ -1920,25 +1897,14 @@ static int azx_probe_continue(struct azx *chip)
1920 goto out_free; 1897 goto out_free;
1921 } 1898 }
1922 1899
1923 /* create PCM streams */
1924 err = snd_hda_build_pcms(chip->bus);
1925 if (err < 0)
1926 goto out_free;
1927
1928 /* create mixer controls */
1929 err = azx_mixer_create(chip);
1930 if (err < 0)
1931 goto out_free;
1932
1933 err = snd_card_register(chip->card); 1900 err = snd_card_register(chip->card);
1934 if (err < 0) 1901 if (err < 0)
1935 goto out_free; 1902 goto out_free;
1936 1903
1937 chip->running = 1; 1904 chip->running = 1;
1938 power_down_all_codecs(chip);
1939 azx_notifier_register(chip);
1940 azx_add_card_list(chip); 1905 azx_add_card_list(chip);
1941 if ((chip->driver_caps & AZX_DCAPS_PM_RUNTIME) || hda->use_vga_switcheroo) 1906 snd_hda_set_power_save(chip->bus, power_save * 1000);
1907 if (azx_has_pm_runtime(chip) || hda->use_vga_switcheroo)
1942 pm_runtime_put_noidle(&pci->dev); 1908 pm_runtime_put_noidle(&pci->dev);
1943 1909
1944out_free: 1910out_free:
@@ -1956,6 +1922,18 @@ static void azx_remove(struct pci_dev *pci)
1956 snd_card_free(card); 1922 snd_card_free(card);
1957} 1923}
1958 1924
1925static void azx_shutdown(struct pci_dev *pci)
1926{
1927 struct snd_card *card = pci_get_drvdata(pci);
1928 struct azx *chip;
1929
1930 if (!card)
1931 return;
1932 chip = card->private_data;
1933 if (chip && chip->running)
1934 azx_stop_chip(chip);
1935}
1936
1959/* PCI IDs */ 1937/* PCI IDs */
1960static const struct pci_device_id azx_ids[] = { 1938static const struct pci_device_id azx_ids[] = {
1961 /* CPT */ 1939 /* CPT */
@@ -2017,7 +1995,7 @@ static const struct pci_device_id azx_ids[] = {
2017 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM }, 1995 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
2018 /* Braswell */ 1996 /* Braswell */
2019 { PCI_DEVICE(0x8086, 0x2284), 1997 { PCI_DEVICE(0x8086, 0x2284),
2020 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH }, 1998 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_BRASWELL },
2021 /* ICH6 */ 1999 /* ICH6 */
2022 { PCI_DEVICE(0x8086, 0x2668), 2000 { PCI_DEVICE(0x8086, 0x2668),
2023 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH }, 2001 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
@@ -2178,6 +2156,7 @@ static struct pci_driver azx_driver = {
2178 .id_table = azx_ids, 2156 .id_table = azx_ids,
2179 .probe = azx_probe, 2157 .probe = azx_probe,
2180 .remove = azx_remove, 2158 .remove = azx_remove,
2159 .shutdown = azx_shutdown,
2181 .driver = { 2160 .driver = {
2182 .pm = AZX_PM_OPS, 2161 .pm = AZX_PM_OPS,
2183 }, 2162 },
diff --git a/sound/pci/hda/hda_intel.h b/sound/pci/hda/hda_intel.h
index 348611835476..d5231f7216a7 100644
--- a/sound/pci/hda/hda_intel.h
+++ b/sound/pci/hda/hda_intel.h
@@ -17,7 +17,7 @@
17#define __SOUND_HDA_INTEL_H 17#define __SOUND_HDA_INTEL_H
18 18
19#include <drm/i915_component.h> 19#include <drm/i915_component.h>
20#include "hda_priv.h" 20#include "hda_controller.h"
21 21
22struct hda_intel { 22struct hda_intel {
23 struct azx chip; 23 struct azx chip;
diff --git a/sound/pci/hda/hda_jack.c b/sound/pci/hda/hda_jack.c
index e664307617bd..d7cfe7b8c32b 100644
--- a/sound/pci/hda/hda_jack.c
+++ b/sound/pci/hda/hda_jack.c
@@ -135,7 +135,7 @@ void snd_hda_jack_tbl_clear(struct hda_codec *codec)
135#ifdef CONFIG_SND_HDA_INPUT_JACK 135#ifdef CONFIG_SND_HDA_INPUT_JACK
136 /* free jack instances manually when clearing/reconfiguring */ 136 /* free jack instances manually when clearing/reconfiguring */
137 if (!codec->bus->shutdown && jack->jack) 137 if (!codec->bus->shutdown && jack->jack)
138 snd_device_free(codec->bus->card, jack->jack); 138 snd_device_free(codec->card, jack->jack);
139#endif 139#endif
140 for (cb = jack->callback; cb; cb = next) { 140 for (cb = jack->callback; cb; cb = next) {
141 next = cb->next; 141 next = cb->next;
@@ -340,7 +340,7 @@ void snd_hda_jack_report_sync(struct hda_codec *codec)
340 if (!jack->kctl || jack->block_report) 340 if (!jack->kctl || jack->block_report)
341 continue; 341 continue;
342 state = get_jack_plug_state(jack->pin_sense); 342 state = get_jack_plug_state(jack->pin_sense);
343 snd_kctl_jack_report(codec->bus->card, jack->kctl, state); 343 snd_kctl_jack_report(codec->card, jack->kctl, state);
344#ifdef CONFIG_SND_HDA_INPUT_JACK 344#ifdef CONFIG_SND_HDA_INPUT_JACK
345 if (jack->jack) 345 if (jack->jack)
346 snd_jack_report(jack->jack, 346 snd_jack_report(jack->jack,
@@ -412,11 +412,11 @@ static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
412 jack->phantom_jack = !!phantom_jack; 412 jack->phantom_jack = !!phantom_jack;
413 413
414 state = snd_hda_jack_detect(codec, nid); 414 state = snd_hda_jack_detect(codec, nid);
415 snd_kctl_jack_report(codec->bus->card, kctl, state); 415 snd_kctl_jack_report(codec->card, kctl, state);
416#ifdef CONFIG_SND_HDA_INPUT_JACK 416#ifdef CONFIG_SND_HDA_INPUT_JACK
417 if (!phantom_jack) { 417 if (!phantom_jack) {
418 jack->type = get_input_jack_type(codec, nid); 418 jack->type = get_input_jack_type(codec, nid);
419 err = snd_jack_new(codec->bus->card, name, jack->type, 419 err = snd_jack_new(codec->card, name, jack->type,
420 &jack->jack); 420 &jack->jack);
421 if (err < 0) 421 if (err < 0)
422 return err; 422 return err;
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 62658f2f8c9f..3b567f42296b 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -127,18 +127,16 @@ int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
127 struct snd_ctl_elem_value *ucontrol); 127 struct snd_ctl_elem_value *ucontrol);
128#endif 128#endif
129/* lowlevel accessor with caching; use carefully */ 129/* lowlevel accessor with caching; use carefully */
130int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, 130#define snd_hda_codec_amp_read(codec, nid, ch, dir, idx) \
131 int direction, int index); 131 snd_hdac_regmap_get_amp(&(codec)->core, nid, ch, dir, idx)
132int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, 132#define snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val) \
133 int direction, int idx, int mask, int val); 133 snd_hdac_regmap_update_amp(&(codec)->core, nid, ch, dir, idx, mask, val)
134int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, 134int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
135 int dir, int idx, int mask, int val); 135 int dir, int idx, int mask, int val);
136int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch, 136int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
137 int direction, int idx, int mask, int val); 137 int direction, int idx, int mask, int val);
138int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid, 138int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
139 int dir, int idx, int mask, int val); 139 int dir, int idx, int mask, int val);
140void snd_hda_codec_resume_amp(struct hda_codec *codec);
141
142void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, 140void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
143 unsigned int *tlv); 141 unsigned int *tlv);
144struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, 142struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
@@ -150,6 +148,8 @@ int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
150#define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \ 148#define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \
151 __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL) 149 __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL)
152int snd_hda_codec_reset(struct hda_codec *codec); 150int snd_hda_codec_reset(struct hda_codec *codec);
151void snd_hda_codec_register(struct hda_codec *codec);
152void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec);
153 153
154enum { 154enum {
155 HDA_VMUTE_OFF, 155 HDA_VMUTE_OFF,
@@ -273,29 +273,6 @@ int snd_hda_add_imux_item(struct hda_codec *codec,
273 int index, int *type_index_ret); 273 int index, int *type_index_ret);
274 274
275/* 275/*
276 * Channel mode helper
277 */
278struct hda_channel_mode {
279 int channels;
280 const struct hda_verb *sequence;
281};
282
283int snd_hda_ch_mode_info(struct hda_codec *codec,
284 struct snd_ctl_elem_info *uinfo,
285 const struct hda_channel_mode *chmode,
286 int num_chmodes);
287int snd_hda_ch_mode_get(struct hda_codec *codec,
288 struct snd_ctl_elem_value *ucontrol,
289 const struct hda_channel_mode *chmode,
290 int num_chmodes,
291 int max_channels);
292int snd_hda_ch_mode_put(struct hda_codec *codec,
293 struct snd_ctl_elem_value *ucontrol,
294 const struct hda_channel_mode *chmode,
295 int num_chmodes,
296 int *max_channelsp);
297
298/*
299 * Multi-channel / digital-out PCM helper 276 * Multi-channel / digital-out PCM helper
300 */ 277 */
301 278
@@ -351,12 +328,6 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
351 struct hda_multi_out *mout); 328 struct hda_multi_out *mout);
352 329
353/* 330/*
354 * generic codec parser
355 */
356int snd_hda_parse_generic_codec(struct hda_codec *codec);
357int snd_hda_parse_hdmi_codec(struct hda_codec *codec);
358
359/*
360 * generic proc interface 331 * generic proc interface
361 */ 332 */
362#ifdef CONFIG_PROC_FS 333#ifdef CONFIG_PROC_FS
@@ -466,23 +437,6 @@ void snd_hda_pick_pin_fixup(struct hda_codec *codec,
466 const struct snd_hda_pin_quirk *pin_quirk, 437 const struct snd_hda_pin_quirk *pin_quirk,
467 const struct hda_fixup *fixlist); 438 const struct hda_fixup *fixlist);
468 439
469
470/*
471 * unsolicited event handler
472 */
473
474#define HDA_UNSOL_QUEUE_SIZE 64
475
476struct hda_bus_unsolicited {
477 /* ring buffer */
478 u32 queue[HDA_UNSOL_QUEUE_SIZE * 2];
479 unsigned int rp, wp;
480
481 /* workqueue */
482 struct work_struct work;
483 struct hda_bus *bus;
484};
485
486/* helper macros to retrieve pin default-config values */ 440/* helper macros to retrieve pin default-config values */
487#define get_defcfg_connect(cfg) \ 441#define get_defcfg_connect(cfg) \
488 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT) 442 ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT)
@@ -560,15 +514,18 @@ int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid);
560int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, 514int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
561 unsigned int val); 515 unsigned int val);
562 516
517#define for_each_hda_codec_node(nid, codec) \
518 for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)
519
563/* 520/*
564 * get widget capabilities 521 * get widget capabilities
565 */ 522 */
566static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) 523static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid)
567{ 524{
568 if (nid < codec->start_nid || 525 if (nid < codec->core.start_nid ||
569 nid >= codec->start_nid + codec->num_nodes) 526 nid >= codec->core.start_nid + codec->core.num_nodes)
570 return 0; 527 return 0;
571 return codec->wcaps[nid - codec->start_nid]; 528 return codec->wcaps[nid - codec->core.start_nid];
572} 529}
573 530
574/* get the widget type from widget capability bits */ 531/* get the widget type from widget capability bits */
@@ -592,17 +549,49 @@ static inline unsigned int get_wcaps_channels(u32 wcaps)
592static inline void snd_hda_override_wcaps(struct hda_codec *codec, 549static inline void snd_hda_override_wcaps(struct hda_codec *codec,
593 hda_nid_t nid, u32 val) 550 hda_nid_t nid, u32 val)
594{ 551{
595 if (nid >= codec->start_nid && 552 if (nid >= codec->core.start_nid &&
596 nid < codec->start_nid + codec->num_nodes) 553 nid < codec->core.start_nid + codec->core.num_nodes)
597 codec->wcaps[nid - codec->start_nid] = val; 554 codec->wcaps[nid - codec->core.start_nid] = val;
598} 555}
599 556
600u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); 557u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
601int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 558int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
602 unsigned int caps); 559 unsigned int caps);
603u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); 560/**
604int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid, 561 * snd_hda_query_pin_caps - Query PIN capabilities
605 unsigned int caps); 562 * @codec: the HD-auio codec
563 * @nid: the NID to query
564 *
565 * Query PIN capabilities for the given widget.
566 * Returns the obtained capability bits.
567 *
568 * When cap bits have been already read, this doesn't read again but
569 * returns the cached value.
570 */
571static inline u32
572snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
573{
574 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
575
576}
577
578/**
579 * snd_hda_override_pin_caps - Override the pin capabilities
580 * @codec: the CODEC
581 * @nid: the NID to override
582 * @caps: the capability bits to set
583 *
584 * Override the cached PIN capabilitiy bits value by the given one.
585 *
586 * Returns zero if successful or a negative error code.
587 */
588static inline int
589snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
590 unsigned int caps)
591{
592 return snd_hdac_override_parm(&codec->core, nid, AC_PAR_PIN_CAP, caps);
593}
594
606bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 595bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
607 int dir, unsigned int bits); 596 int dir, unsigned int bits);
608 597
@@ -800,9 +789,13 @@ void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
800 789
801/* 790/*
802 */ 791 */
803#define codec_err(codec, fmt, args...) dev_err(&(codec)->dev, fmt, ##args) 792#define codec_err(codec, fmt, args...) \
804#define codec_warn(codec, fmt, args...) dev_warn(&(codec)->dev, fmt, ##args) 793 dev_err(hda_codec_dev(codec), fmt, ##args)
805#define codec_info(codec, fmt, args...) dev_info(&(codec)->dev, fmt, ##args) 794#define codec_warn(codec, fmt, args...) \
806#define codec_dbg(codec, fmt, args...) dev_dbg(&(codec)->dev, fmt, ##args) 795 dev_warn(hda_codec_dev(codec), fmt, ##args)
796#define codec_info(codec, fmt, args...) \
797 dev_info(hda_codec_dev(codec), fmt, ##args)
798#define codec_dbg(codec, fmt, args...) \
799 dev_dbg(hda_codec_dev(codec), fmt, ##args)
807 800
808#endif /* __SOUND_HDA_LOCAL_H */ 801#endif /* __SOUND_HDA_LOCAL_H */
diff --git a/sound/pci/hda/hda_priv.h b/sound/pci/hda/hda_priv.h
deleted file mode 100644
index daf458299753..000000000000
--- a/sound/pci/hda/hda_priv.h
+++ /dev/null
@@ -1,406 +0,0 @@
1/*
2 * Common defines for the alsa driver code base for HD Audio.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the Free
6 * Software Foundation; either version 2 of the License, or (at your option)
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15#ifndef __SOUND_HDA_PRIV_H
16#define __SOUND_HDA_PRIV_H
17
18#include <linux/timecounter.h>
19#include <sound/core.h>
20#include <sound/pcm.h>
21
22/*
23 * registers
24 */
25#define AZX_REG_GCAP 0x00
26#define AZX_GCAP_64OK (1 << 0) /* 64bit address support */
27#define AZX_GCAP_NSDO (3 << 1) /* # of serial data out signals */
28#define AZX_GCAP_BSS (31 << 3) /* # of bidirectional streams */
29#define AZX_GCAP_ISS (15 << 8) /* # of input streams */
30#define AZX_GCAP_OSS (15 << 12) /* # of output streams */
31#define AZX_REG_VMIN 0x02
32#define AZX_REG_VMAJ 0x03
33#define AZX_REG_OUTPAY 0x04
34#define AZX_REG_INPAY 0x06
35#define AZX_REG_GCTL 0x08
36#define AZX_GCTL_RESET (1 << 0) /* controller reset */
37#define AZX_GCTL_FCNTRL (1 << 1) /* flush control */
38#define AZX_GCTL_UNSOL (1 << 8) /* accept unsol. response enable */
39#define AZX_REG_WAKEEN 0x0c
40#define AZX_REG_STATESTS 0x0e
41#define AZX_REG_GSTS 0x10
42#define AZX_GSTS_FSTS (1 << 1) /* flush status */
43#define AZX_REG_INTCTL 0x20
44#define AZX_REG_INTSTS 0x24
45#define AZX_REG_WALLCLK 0x30 /* 24Mhz source */
46#define AZX_REG_OLD_SSYNC 0x34 /* SSYNC for old ICH */
47#define AZX_REG_SSYNC 0x38
48#define AZX_REG_CORBLBASE 0x40
49#define AZX_REG_CORBUBASE 0x44
50#define AZX_REG_CORBWP 0x48
51#define AZX_REG_CORBRP 0x4a
52#define AZX_CORBRP_RST (1 << 15) /* read pointer reset */
53#define AZX_REG_CORBCTL 0x4c
54#define AZX_CORBCTL_RUN (1 << 1) /* enable DMA */
55#define AZX_CORBCTL_CMEIE (1 << 0) /* enable memory error irq */
56#define AZX_REG_CORBSTS 0x4d
57#define AZX_CORBSTS_CMEI (1 << 0) /* memory error indication */
58#define AZX_REG_CORBSIZE 0x4e
59
60#define AZX_REG_RIRBLBASE 0x50
61#define AZX_REG_RIRBUBASE 0x54
62#define AZX_REG_RIRBWP 0x58
63#define AZX_RIRBWP_RST (1 << 15) /* write pointer reset */
64#define AZX_REG_RINTCNT 0x5a
65#define AZX_REG_RIRBCTL 0x5c
66#define AZX_RBCTL_IRQ_EN (1 << 0) /* enable IRQ */
67#define AZX_RBCTL_DMA_EN (1 << 1) /* enable DMA */
68#define AZX_RBCTL_OVERRUN_EN (1 << 2) /* enable overrun irq */
69#define AZX_REG_RIRBSTS 0x5d
70#define AZX_RBSTS_IRQ (1 << 0) /* response irq */
71#define AZX_RBSTS_OVERRUN (1 << 2) /* overrun irq */
72#define AZX_REG_RIRBSIZE 0x5e
73
74#define AZX_REG_IC 0x60
75#define AZX_REG_IR 0x64
76#define AZX_REG_IRS 0x68
77#define AZX_IRS_VALID (1<<1)
78#define AZX_IRS_BUSY (1<<0)
79
80#define AZX_REG_DPLBASE 0x70
81#define AZX_REG_DPUBASE 0x74
82#define AZX_DPLBASE_ENABLE 0x1 /* Enable position buffer */
83
84/* SD offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
85enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
86
87/* stream register offsets from stream base */
88#define AZX_REG_SD_CTL 0x00
89#define AZX_REG_SD_STS 0x03
90#define AZX_REG_SD_LPIB 0x04
91#define AZX_REG_SD_CBL 0x08
92#define AZX_REG_SD_LVI 0x0c
93#define AZX_REG_SD_FIFOW 0x0e
94#define AZX_REG_SD_FIFOSIZE 0x10
95#define AZX_REG_SD_FORMAT 0x12
96#define AZX_REG_SD_BDLPL 0x18
97#define AZX_REG_SD_BDLPU 0x1c
98
99/* PCI space */
100#define AZX_PCIREG_TCSEL 0x44
101
102/*
103 * other constants
104 */
105
106/* max number of fragments - we may use more if allocating more pages for BDL */
107#define BDL_SIZE 4096
108#define AZX_MAX_BDL_ENTRIES (BDL_SIZE / 16)
109#define AZX_MAX_FRAG 32
110/* max buffer size - no h/w limit, you can increase as you like */
111#define AZX_MAX_BUF_SIZE (1024*1024*1024)
112
113/* RIRB int mask: overrun[2], response[0] */
114#define RIRB_INT_RESPONSE 0x01
115#define RIRB_INT_OVERRUN 0x04
116#define RIRB_INT_MASK 0x05
117
118/* STATESTS int mask: S3,SD2,SD1,SD0 */
119#define AZX_MAX_CODECS 8
120#define AZX_DEFAULT_CODECS 4
121#define STATESTS_INT_MASK ((1 << AZX_MAX_CODECS) - 1)
122
123/* SD_CTL bits */
124#define SD_CTL_STREAM_RESET 0x01 /* stream reset bit */
125#define SD_CTL_DMA_START 0x02 /* stream DMA start bit */
126#define SD_CTL_STRIPE (3 << 16) /* stripe control */
127#define SD_CTL_TRAFFIC_PRIO (1 << 18) /* traffic priority */
128#define SD_CTL_DIR (1 << 19) /* bi-directional stream */
129#define SD_CTL_STREAM_TAG_MASK (0xf << 20)
130#define SD_CTL_STREAM_TAG_SHIFT 20
131
132/* SD_CTL and SD_STS */
133#define SD_INT_DESC_ERR 0x10 /* descriptor error interrupt */
134#define SD_INT_FIFO_ERR 0x08 /* FIFO error interrupt */
135#define SD_INT_COMPLETE 0x04 /* completion interrupt */
136#define SD_INT_MASK (SD_INT_DESC_ERR|SD_INT_FIFO_ERR|\
137 SD_INT_COMPLETE)
138
139/* SD_STS */
140#define SD_STS_FIFO_READY 0x20 /* FIFO ready */
141
142/* INTCTL and INTSTS */
143#define AZX_INT_ALL_STREAM 0xff /* all stream interrupts */
144#define AZX_INT_CTRL_EN 0x40000000 /* controller interrupt enable bit */
145#define AZX_INT_GLOBAL_EN 0x80000000 /* global interrupt enable bit */
146
147/* below are so far hardcoded - should read registers in future */
148#define AZX_MAX_CORB_ENTRIES 256
149#define AZX_MAX_RIRB_ENTRIES 256
150
151/* driver quirks (capabilities) */
152/* bits 0-7 are used for indicating driver type */
153#define AZX_DCAPS_NO_TCSEL (1 << 8) /* No Intel TCSEL bit */
154#define AZX_DCAPS_NO_MSI (1 << 9) /* No MSI support */
155#define AZX_DCAPS_SNOOP_MASK (3 << 10) /* snoop type mask */
156#define AZX_DCAPS_SNOOP_OFF (1 << 12) /* snoop default off */
157#define AZX_DCAPS_RIRB_DELAY (1 << 13) /* Long delay in read loop */
158#define AZX_DCAPS_RIRB_PRE_DELAY (1 << 14) /* Put a delay before read */
159#define AZX_DCAPS_CTX_WORKAROUND (1 << 15) /* X-Fi workaround */
160#define AZX_DCAPS_POSFIX_LPIB (1 << 16) /* Use LPIB as default */
161#define AZX_DCAPS_POSFIX_VIA (1 << 17) /* Use VIACOMBO as default */
162#define AZX_DCAPS_NO_64BIT (1 << 18) /* No 64bit address */
163#define AZX_DCAPS_SYNC_WRITE (1 << 19) /* sync each cmd write */
164#define AZX_DCAPS_OLD_SSYNC (1 << 20) /* Old SSYNC reg for ICH */
165#define AZX_DCAPS_NO_ALIGN_BUFSIZE (1 << 21) /* no buffer size alignment */
166/* 22 unused */
167#define AZX_DCAPS_4K_BDLE_BOUNDARY (1 << 23) /* BDLE in 4k boundary */
168#define AZX_DCAPS_REVERSE_ASSIGN (1 << 24) /* Assign devices in reverse order */
169#define AZX_DCAPS_COUNT_LPIB_DELAY (1 << 25) /* Take LPIB as delay */
170#define AZX_DCAPS_PM_RUNTIME (1 << 26) /* runtime PM support */
171#define AZX_DCAPS_I915_POWERWELL (1 << 27) /* HSW i915 powerwell support */
172#define AZX_DCAPS_CORBRP_SELF_CLEAR (1 << 28) /* CORBRP clears itself after reset */
173#define AZX_DCAPS_NO_MSI64 (1 << 29) /* Stick to 32-bit MSIs */
174#define AZX_DCAPS_SEPARATE_STREAM_TAG (1 << 30) /* capture and playback use separate stream tag */
175
176enum {
177 AZX_SNOOP_TYPE_NONE ,
178 AZX_SNOOP_TYPE_SCH,
179 AZX_SNOOP_TYPE_ATI,
180 AZX_SNOOP_TYPE_NVIDIA,
181};
182
183/* HD Audio class code */
184#define PCI_CLASS_MULTIMEDIA_HD_AUDIO 0x0403
185
186struct azx_dev {
187 struct snd_dma_buffer bdl; /* BDL buffer */
188 u32 *posbuf; /* position buffer pointer */
189
190 unsigned int bufsize; /* size of the play buffer in bytes */
191 unsigned int period_bytes; /* size of the period in bytes */
192 unsigned int frags; /* number for period in the play buffer */
193 unsigned int fifo_size; /* FIFO size */
194 unsigned long start_wallclk; /* start + minimum wallclk */
195 unsigned long period_wallclk; /* wallclk for period */
196
197 void __iomem *sd_addr; /* stream descriptor pointer */
198
199 u32 sd_int_sta_mask; /* stream int status mask */
200
201 /* pcm support */
202 struct snd_pcm_substream *substream; /* assigned substream,
203 * set in PCM open
204 */
205 unsigned int format_val; /* format value to be set in the
206 * controller and the codec
207 */
208 unsigned char stream_tag; /* assigned stream */
209 unsigned char index; /* stream index */
210 int assigned_key; /* last device# key assigned to */
211
212 unsigned int opened:1;
213 unsigned int running:1;
214 unsigned int irq_pending:1;
215 unsigned int prepared:1;
216 unsigned int locked:1;
217 /*
218 * For VIA:
219 * A flag to ensure DMA position is 0
220 * when link position is not greater than FIFO size
221 */
222 unsigned int insufficient:1;
223 unsigned int wc_marked:1;
224 unsigned int no_period_wakeup:1;
225
226 struct timecounter azx_tc;
227 struct cyclecounter azx_cc;
228
229 int delay_negative_threshold;
230
231#ifdef CONFIG_SND_HDA_DSP_LOADER
232 /* Allows dsp load to have sole access to the playback stream. */
233 struct mutex dsp_mutex;
234#endif
235};
236
237/* CORB/RIRB */
238struct azx_rb {
239 u32 *buf; /* CORB/RIRB buffer
240 * Each CORB entry is 4byte, RIRB is 8byte
241 */
242 dma_addr_t addr; /* physical address of CORB/RIRB buffer */
243 /* for RIRB */
244 unsigned short rp, wp; /* read/write pointers */
245 int cmds[AZX_MAX_CODECS]; /* number of pending requests */
246 u32 res[AZX_MAX_CODECS]; /* last read value */
247};
248
249struct azx;
250
251/* Functions to read/write to hda registers. */
252struct hda_controller_ops {
253 /* Register Access */
254 void (*reg_writel)(u32 value, u32 __iomem *addr);
255 u32 (*reg_readl)(u32 __iomem *addr);
256 void (*reg_writew)(u16 value, u16 __iomem *addr);
257 u16 (*reg_readw)(u16 __iomem *addr);
258 void (*reg_writeb)(u8 value, u8 __iomem *addr);
259 u8 (*reg_readb)(u8 __iomem *addr);
260 /* Disable msi if supported, PCI only */
261 int (*disable_msi_reset_irq)(struct azx *);
262 /* Allocation ops */
263 int (*dma_alloc_pages)(struct azx *chip,
264 int type,
265 size_t size,
266 struct snd_dma_buffer *buf);
267 void (*dma_free_pages)(struct azx *chip, struct snd_dma_buffer *buf);
268 int (*substream_alloc_pages)(struct azx *chip,
269 struct snd_pcm_substream *substream,
270 size_t size);
271 int (*substream_free_pages)(struct azx *chip,
272 struct snd_pcm_substream *substream);
273 void (*pcm_mmap_prepare)(struct snd_pcm_substream *substream,
274 struct vm_area_struct *area);
275 /* Check if current position is acceptable */
276 int (*position_check)(struct azx *chip, struct azx_dev *azx_dev);
277};
278
279struct azx_pcm {
280 struct azx *chip;
281 struct snd_pcm *pcm;
282 struct hda_codec *codec;
283 struct hda_pcm_stream *hinfo[2];
284 struct list_head list;
285};
286
287typedef unsigned int (*azx_get_pos_callback_t)(struct azx *, struct azx_dev *);
288typedef int (*azx_get_delay_callback_t)(struct azx *, struct azx_dev *, unsigned int pos);
289
290struct azx {
291 struct snd_card *card;
292 struct pci_dev *pci;
293 int dev_index;
294
295 /* chip type specific */
296 int driver_type;
297 unsigned int driver_caps;
298 int playback_streams;
299 int playback_index_offset;
300 int capture_streams;
301 int capture_index_offset;
302 int num_streams;
303 const int *jackpoll_ms; /* per-card jack poll interval */
304
305 /* Register interaction. */
306 const struct hda_controller_ops *ops;
307
308 /* position adjustment callbacks */
309 azx_get_pos_callback_t get_position[2];
310 azx_get_delay_callback_t get_delay[2];
311
312 /* pci resources */
313 unsigned long addr;
314 void __iomem *remap_addr;
315 int irq;
316
317 /* locks */
318 spinlock_t reg_lock;
319 struct mutex open_mutex; /* Prevents concurrent open/close operations */
320
321 /* streams (x num_streams) */
322 struct azx_dev *azx_dev;
323
324 /* PCM */
325 struct list_head pcm_list; /* azx_pcm list */
326
327 /* HD codec */
328 unsigned short codec_mask;
329 int codec_probe_mask; /* copied from probe_mask option */
330 struct hda_bus *bus;
331 unsigned int beep_mode;
332
333 /* CORB/RIRB */
334 struct azx_rb corb;
335 struct azx_rb rirb;
336
337 /* CORB/RIRB and position buffers */
338 struct snd_dma_buffer rb;
339 struct snd_dma_buffer posbuf;
340
341#ifdef CONFIG_SND_HDA_PATCH_LOADER
342 const struct firmware *fw;
343#endif
344
345 /* flags */
346 const int *bdl_pos_adj;
347 int poll_count;
348 unsigned int running:1;
349 unsigned int initialized:1;
350 unsigned int single_cmd:1;
351 unsigned int polling_mode:1;
352 unsigned int msi:1;
353 unsigned int probing:1; /* codec probing phase */
354 unsigned int snoop:1;
355 unsigned int align_buffer_size:1;
356 unsigned int region_requested:1;
357 unsigned int disabled:1; /* disabled by VGA-switcher */
358
359 /* for debugging */
360 unsigned int last_cmd[AZX_MAX_CODECS];
361
362 /* reboot notifier (for mysterious hangup problem at power-down) */
363 struct notifier_block reboot_notifier;
364
365#ifdef CONFIG_SND_HDA_DSP_LOADER
366 struct azx_dev saved_azx_dev;
367#endif
368};
369
370#ifdef CONFIG_X86
371#define azx_snoop(chip) ((chip)->snoop)
372#else
373#define azx_snoop(chip) true
374#endif
375
376/*
377 * macros for easy use
378 */
379
380#define azx_writel(chip, reg, value) \
381 ((chip)->ops->reg_writel(value, (chip)->remap_addr + AZX_REG_##reg))
382#define azx_readl(chip, reg) \
383 ((chip)->ops->reg_readl((chip)->remap_addr + AZX_REG_##reg))
384#define azx_writew(chip, reg, value) \
385 ((chip)->ops->reg_writew(value, (chip)->remap_addr + AZX_REG_##reg))
386#define azx_readw(chip, reg) \
387 ((chip)->ops->reg_readw((chip)->remap_addr + AZX_REG_##reg))
388#define azx_writeb(chip, reg, value) \
389 ((chip)->ops->reg_writeb(value, (chip)->remap_addr + AZX_REG_##reg))
390#define azx_readb(chip, reg) \
391 ((chip)->ops->reg_readb((chip)->remap_addr + AZX_REG_##reg))
392
393#define azx_sd_writel(chip, dev, reg, value) \
394 ((chip)->ops->reg_writel(value, (dev)->sd_addr + AZX_REG_##reg))
395#define azx_sd_readl(chip, dev, reg) \
396 ((chip)->ops->reg_readl((dev)->sd_addr + AZX_REG_##reg))
397#define azx_sd_writew(chip, dev, reg, value) \
398 ((chip)->ops->reg_writew(value, (dev)->sd_addr + AZX_REG_##reg))
399#define azx_sd_readw(chip, dev, reg) \
400 ((chip)->ops->reg_readw((dev)->sd_addr + AZX_REG_##reg))
401#define azx_sd_writeb(chip, dev, reg, value) \
402 ((chip)->ops->reg_writeb(value, (dev)->sd_addr + AZX_REG_##reg))
403#define azx_sd_readb(chip, dev, reg) \
404 ((chip)->ops->reg_readb((dev)->sd_addr + AZX_REG_##reg))
405
406#endif /* __SOUND_HDA_PRIV_H */
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index 05e19f78b4cb..ee6230767c64 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -32,6 +32,10 @@ static int dump_coef = -1;
32module_param(dump_coef, int, 0644); 32module_param(dump_coef, int, 0644);
33MODULE_PARM_DESC(dump_coef, "Dump processing coefficients in codec proc file (-1=auto, 0=disable, 1=enable)"); 33MODULE_PARM_DESC(dump_coef, "Dump processing coefficients in codec proc file (-1=auto, 0=disable, 1=enable)");
34 34
35/* always use noncached version */
36#define param_read(codec, nid, parm) \
37 snd_hdac_read_parm_uncached(&(codec)->core, nid, parm)
38
35static char *bits_names(unsigned int bits, char *names[], int size) 39static char *bits_names(unsigned int bits, char *names[], int size)
36{ 40{
37 int i, n; 41 int i, n;
@@ -99,10 +103,10 @@ static void print_nid_array(struct snd_info_buffer *buffer,
99static void print_nid_pcms(struct snd_info_buffer *buffer, 103static void print_nid_pcms(struct snd_info_buffer *buffer,
100 struct hda_codec *codec, hda_nid_t nid) 104 struct hda_codec *codec, hda_nid_t nid)
101{ 105{
102 int pcm, type; 106 int type;
103 struct hda_pcm *cpcm; 107 struct hda_pcm *cpcm;
104 for (pcm = 0; pcm < codec->num_pcms; pcm++) { 108
105 cpcm = &codec->pcm_info[pcm]; 109 list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
106 for (type = 0; type < 2; type++) { 110 for (type = 0; type < 2; type++) {
107 if (cpcm->stream[type].nid != nid || cpcm->pcm == NULL) 111 if (cpcm->stream[type].nid != nid || cpcm->pcm == NULL)
108 continue; 112 continue;
@@ -119,9 +123,8 @@ static void print_amp_caps(struct snd_info_buffer *buffer,
119 struct hda_codec *codec, hda_nid_t nid, int dir) 123 struct hda_codec *codec, hda_nid_t nid, int dir)
120{ 124{
121 unsigned int caps; 125 unsigned int caps;
122 caps = snd_hda_param_read(codec, nid, 126 caps = param_read(codec, nid, dir == HDA_OUTPUT ?
123 dir == HDA_OUTPUT ? 127 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
124 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
125 if (caps == -1 || caps == 0) { 128 if (caps == -1 || caps == 0) {
126 snd_iprintf(buffer, "N/A\n"); 129 snd_iprintf(buffer, "N/A\n");
127 return; 130 return;
@@ -225,8 +228,8 @@ static void print_pcm_formats(struct snd_info_buffer *buffer,
225static void print_pcm_caps(struct snd_info_buffer *buffer, 228static void print_pcm_caps(struct snd_info_buffer *buffer,
226 struct hda_codec *codec, hda_nid_t nid) 229 struct hda_codec *codec, hda_nid_t nid)
227{ 230{
228 unsigned int pcm = snd_hda_param_read(codec, nid, AC_PAR_PCM); 231 unsigned int pcm = param_read(codec, nid, AC_PAR_PCM);
229 unsigned int stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM); 232 unsigned int stream = param_read(codec, nid, AC_PAR_STREAM);
230 if (pcm == -1 || stream == -1) { 233 if (pcm == -1 || stream == -1) {
231 snd_iprintf(buffer, "N/A\n"); 234 snd_iprintf(buffer, "N/A\n");
232 return; 235 return;
@@ -273,7 +276,7 @@ static void print_pin_caps(struct snd_info_buffer *buffer,
273 static char *jack_conns[4] = { "Jack", "N/A", "Fixed", "Both" }; 276 static char *jack_conns[4] = { "Jack", "N/A", "Fixed", "Both" };
274 unsigned int caps, val; 277 unsigned int caps, val;
275 278
276 caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 279 caps = param_read(codec, nid, AC_PAR_PIN_CAP);
277 snd_iprintf(buffer, " Pincap 0x%08x:", caps); 280 snd_iprintf(buffer, " Pincap 0x%08x:", caps);
278 if (caps & AC_PINCAP_IN) 281 if (caps & AC_PINCAP_IN)
279 snd_iprintf(buffer, " IN"); 282 snd_iprintf(buffer, " IN");
@@ -289,7 +292,7 @@ static void print_pin_caps(struct snd_info_buffer *buffer,
289 snd_iprintf(buffer, " Balanced"); 292 snd_iprintf(buffer, " Balanced");
290 if (caps & AC_PINCAP_HDMI) { 293 if (caps & AC_PINCAP_HDMI) {
291 /* Realtek uses this bit as a different meaning */ 294 /* Realtek uses this bit as a different meaning */
292 if ((codec->vendor_id >> 16) == 0x10ec) 295 if ((codec->core.vendor_id >> 16) == 0x10ec)
293 snd_iprintf(buffer, " R/L"); 296 snd_iprintf(buffer, " R/L");
294 else { 297 else {
295 if (caps & AC_PINCAP_HBR) 298 if (caps & AC_PINCAP_HBR)
@@ -401,8 +404,7 @@ static void print_pin_ctls(struct snd_info_buffer *buffer,
401static void print_vol_knob(struct snd_info_buffer *buffer, 404static void print_vol_knob(struct snd_info_buffer *buffer,
402 struct hda_codec *codec, hda_nid_t nid) 405 struct hda_codec *codec, hda_nid_t nid)
403{ 406{
404 unsigned int cap = snd_hda_param_read(codec, nid, 407 unsigned int cap = param_read(codec, nid, AC_PAR_VOL_KNB_CAP);
405 AC_PAR_VOL_KNB_CAP);
406 snd_iprintf(buffer, " Volume-Knob: delta=%d, steps=%d, ", 408 snd_iprintf(buffer, " Volume-Knob: delta=%d, steps=%d, ",
407 (cap >> 7) & 1, cap & 0x7f); 409 (cap >> 7) & 1, cap & 0x7f);
408 cap = snd_hda_codec_read(codec, nid, 0, 410 cap = snd_hda_codec_read(codec, nid, 0,
@@ -487,7 +489,7 @@ static void print_power_state(struct snd_info_buffer *buffer,
487 [ilog2(AC_PWRST_EPSS)] = "EPSS", 489 [ilog2(AC_PWRST_EPSS)] = "EPSS",
488 }; 490 };
489 491
490 int sup = snd_hda_param_read(codec, nid, AC_PAR_POWER_STATE); 492 int sup = param_read(codec, nid, AC_PAR_POWER_STATE);
491 int pwr = snd_hda_codec_read(codec, nid, 0, 493 int pwr = snd_hda_codec_read(codec, nid, 0,
492 AC_VERB_GET_POWER_STATE, 0); 494 AC_VERB_GET_POWER_STATE, 0);
493 if (sup != -1) 495 if (sup != -1)
@@ -531,8 +533,7 @@ static void print_proc_caps(struct snd_info_buffer *buffer,
531 struct hda_codec *codec, hda_nid_t nid) 533 struct hda_codec *codec, hda_nid_t nid)
532{ 534{
533 unsigned int i, ncoeff, oldindex; 535 unsigned int i, ncoeff, oldindex;
534 unsigned int proc_caps = snd_hda_param_read(codec, nid, 536 unsigned int proc_caps = param_read(codec, nid, AC_PAR_PROC_CAP);
535 AC_PAR_PROC_CAP);
536 ncoeff = (proc_caps & AC_PCAP_NUM_COEF) >> AC_PCAP_NUM_COEF_SHIFT; 537 ncoeff = (proc_caps & AC_PCAP_NUM_COEF) >> AC_PCAP_NUM_COEF_SHIFT;
537 snd_iprintf(buffer, " Processing caps: benign=%d, ncoeff=%d\n", 538 snd_iprintf(buffer, " Processing caps: benign=%d, ncoeff=%d\n",
538 proc_caps & AC_PCAP_BENIGN, ncoeff); 539 proc_caps & AC_PCAP_BENIGN, ncoeff);
@@ -597,7 +598,7 @@ static void print_gpio(struct snd_info_buffer *buffer,
597 struct hda_codec *codec, hda_nid_t nid) 598 struct hda_codec *codec, hda_nid_t nid)
598{ 599{
599 unsigned int gpio = 600 unsigned int gpio =
600 snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP); 601 param_read(codec, codec->core.afg, AC_PAR_GPIO_CAP);
601 unsigned int enable, direction, wake, unsol, sticky, data; 602 unsigned int enable, direction, wake, unsol, sticky, data;
602 int i, max; 603 int i, max;
603 snd_iprintf(buffer, "GPIO: io=%d, o=%d, i=%d, " 604 snd_iprintf(buffer, "GPIO: io=%d, o=%d, i=%d, "
@@ -667,13 +668,9 @@ static void print_device_list(struct snd_info_buffer *buffer,
667 } 668 }
668} 669}
669 670
670static void print_codec_info(struct snd_info_entry *entry, 671static void print_codec_core_info(struct hdac_device *codec,
671 struct snd_info_buffer *buffer) 672 struct snd_info_buffer *buffer)
672{ 673{
673 struct hda_codec *codec = entry->private_data;
674 hda_nid_t nid;
675 int i, nodes;
676
677 snd_iprintf(buffer, "Codec: "); 674 snd_iprintf(buffer, "Codec: ");
678 if (codec->vendor_name && codec->chip_name) 675 if (codec->vendor_name && codec->chip_name)
679 snd_iprintf(buffer, "%s %s\n", 676 snd_iprintf(buffer, "%s %s\n",
@@ -695,34 +692,43 @@ static void print_codec_info(struct snd_info_entry *entry,
695 snd_iprintf(buffer, "Modem Function Group: 0x%x\n", codec->mfg); 692 snd_iprintf(buffer, "Modem Function Group: 0x%x\n", codec->mfg);
696 else 693 else
697 snd_iprintf(buffer, "No Modem Function Group found\n"); 694 snd_iprintf(buffer, "No Modem Function Group found\n");
695}
696
697static void print_codec_info(struct snd_info_entry *entry,
698 struct snd_info_buffer *buffer)
699{
700 struct hda_codec *codec = entry->private_data;
701 hda_nid_t nid, fg;
702 int i, nodes;
698 703
699 if (! codec->afg) 704 print_codec_core_info(&codec->core, buffer);
705 fg = codec->core.afg;
706 if (!fg)
700 return; 707 return;
701 snd_hda_power_up(codec); 708 snd_hda_power_up(codec);
702 snd_iprintf(buffer, "Default PCM:\n"); 709 snd_iprintf(buffer, "Default PCM:\n");
703 print_pcm_caps(buffer, codec, codec->afg); 710 print_pcm_caps(buffer, codec, fg);
704 snd_iprintf(buffer, "Default Amp-In caps: "); 711 snd_iprintf(buffer, "Default Amp-In caps: ");
705 print_amp_caps(buffer, codec, codec->afg, HDA_INPUT); 712 print_amp_caps(buffer, codec, fg, HDA_INPUT);
706 snd_iprintf(buffer, "Default Amp-Out caps: "); 713 snd_iprintf(buffer, "Default Amp-Out caps: ");
707 print_amp_caps(buffer, codec, codec->afg, HDA_OUTPUT); 714 print_amp_caps(buffer, codec, fg, HDA_OUTPUT);
708 snd_iprintf(buffer, "State of AFG node 0x%02x:\n", codec->afg); 715 snd_iprintf(buffer, "State of AFG node 0x%02x:\n", fg);
709 print_power_state(buffer, codec, codec->afg); 716 print_power_state(buffer, codec, fg);
710 717
711 nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid); 718 nodes = snd_hda_get_sub_nodes(codec, fg, &nid);
712 if (! nid || nodes < 0) { 719 if (! nid || nodes < 0) {
713 snd_iprintf(buffer, "Invalid AFG subtree\n"); 720 snd_iprintf(buffer, "Invalid AFG subtree\n");
714 snd_hda_power_down(codec); 721 snd_hda_power_down(codec);
715 return; 722 return;
716 } 723 }
717 724
718 print_gpio(buffer, codec, codec->afg); 725 print_gpio(buffer, codec, fg);
719 if (codec->proc_widget_hook) 726 if (codec->proc_widget_hook)
720 codec->proc_widget_hook(buffer, codec, codec->afg); 727 codec->proc_widget_hook(buffer, codec, fg);
721 728
722 for (i = 0; i < nodes; i++, nid++) { 729 for (i = 0; i < nodes; i++, nid++) {
723 unsigned int wid_caps = 730 unsigned int wid_caps =
724 snd_hda_param_read(codec, nid, 731 param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP);
725 AC_PAR_AUDIO_WIDGET_CAP);
726 unsigned int wid_type = get_wcaps_type(wid_caps); 732 unsigned int wid_type = get_wcaps_type(wid_caps);
727 hda_nid_t *conn = NULL; 733 hda_nid_t *conn = NULL;
728 int conn_len = 0; 734 int conn_len = 0;
@@ -860,8 +866,8 @@ int snd_hda_codec_proc_new(struct hda_codec *codec)
860 struct snd_info_entry *entry; 866 struct snd_info_entry *entry;
861 int err; 867 int err;
862 868
863 snprintf(name, sizeof(name), "codec#%d", codec->addr); 869 snprintf(name, sizeof(name), "codec#%d", codec->core.addr);
864 err = snd_card_proc_new(codec->bus->card, name, &entry); 870 err = snd_card_proc_new(codec->card, name, &entry);
865 if (err < 0) 871 if (err < 0)
866 return err; 872 return err;
867 873
diff --git a/sound/pci/hda/hda_sysfs.c b/sound/pci/hda/hda_sysfs.c
index ccc962a1699f..a6e3d9b511ab 100644
--- a/sound/pci/hda/hda_sysfs.c
+++ b/sound/pci/hda/hda_sysfs.c
@@ -48,33 +48,33 @@ static DEVICE_ATTR_RO(power_on_acct);
48static DEVICE_ATTR_RO(power_off_acct); 48static DEVICE_ATTR_RO(power_off_acct);
49#endif /* CONFIG_PM */ 49#endif /* CONFIG_PM */
50 50
51#define CODEC_INFO_SHOW(type) \ 51#define CODEC_INFO_SHOW(type, field) \
52static ssize_t type##_show(struct device *dev, \ 52static ssize_t type##_show(struct device *dev, \
53 struct device_attribute *attr, \ 53 struct device_attribute *attr, \
54 char *buf) \ 54 char *buf) \
55{ \ 55{ \
56 struct hda_codec *codec = dev_get_drvdata(dev); \ 56 struct hda_codec *codec = dev_get_drvdata(dev); \
57 return sprintf(buf, "0x%x\n", codec->type); \ 57 return sprintf(buf, "0x%x\n", codec->field); \
58} 58}
59 59
60#define CODEC_INFO_STR_SHOW(type) \ 60#define CODEC_INFO_STR_SHOW(type, field) \
61static ssize_t type##_show(struct device *dev, \ 61static ssize_t type##_show(struct device *dev, \
62 struct device_attribute *attr, \ 62 struct device_attribute *attr, \
63 char *buf) \ 63 char *buf) \
64{ \ 64{ \
65 struct hda_codec *codec = dev_get_drvdata(dev); \ 65 struct hda_codec *codec = dev_get_drvdata(dev); \
66 return sprintf(buf, "%s\n", \ 66 return sprintf(buf, "%s\n", \
67 codec->type ? codec->type : ""); \ 67 codec->field ? codec->field : ""); \
68} 68}
69 69
70CODEC_INFO_SHOW(vendor_id); 70CODEC_INFO_SHOW(vendor_id, core.vendor_id);
71CODEC_INFO_SHOW(subsystem_id); 71CODEC_INFO_SHOW(subsystem_id, core.subsystem_id);
72CODEC_INFO_SHOW(revision_id); 72CODEC_INFO_SHOW(revision_id, core.revision_id);
73CODEC_INFO_SHOW(afg); 73CODEC_INFO_SHOW(afg, core.afg);
74CODEC_INFO_SHOW(mfg); 74CODEC_INFO_SHOW(mfg, core.mfg);
75CODEC_INFO_STR_SHOW(vendor_name); 75CODEC_INFO_STR_SHOW(vendor_name, core.vendor_name);
76CODEC_INFO_STR_SHOW(chip_name); 76CODEC_INFO_STR_SHOW(chip_name, core.chip_name);
77CODEC_INFO_STR_SHOW(modelname); 77CODEC_INFO_STR_SHOW(modelname, modelname);
78 78
79static ssize_t pin_configs_show(struct hda_codec *codec, 79static ssize_t pin_configs_show(struct hda_codec *codec,
80 struct snd_array *list, 80 struct snd_array *list,
@@ -149,7 +149,7 @@ static int reconfig_codec(struct hda_codec *codec)
149 err = snd_hda_codec_build_controls(codec); 149 err = snd_hda_codec_build_controls(codec);
150 if (err < 0) 150 if (err < 0)
151 goto error; 151 goto error;
152 err = snd_card_register(codec->bus->card); 152 err = snd_card_register(codec->card);
153 error: 153 error:
154 snd_hda_power_down(codec); 154 snd_hda_power_down(codec);
155 return err; 155 return err;
@@ -170,7 +170,7 @@ static char *kstrndup_noeol(const char *src, size_t len)
170 return s; 170 return s;
171} 171}
172 172
173#define CODEC_INFO_STORE(type) \ 173#define CODEC_INFO_STORE(type, field) \
174static ssize_t type##_store(struct device *dev, \ 174static ssize_t type##_store(struct device *dev, \
175 struct device_attribute *attr, \ 175 struct device_attribute *attr, \
176 const char *buf, size_t count) \ 176 const char *buf, size_t count) \
@@ -180,11 +180,11 @@ static ssize_t type##_store(struct device *dev, \
180 int err = kstrtoul(buf, 0, &val); \ 180 int err = kstrtoul(buf, 0, &val); \
181 if (err < 0) \ 181 if (err < 0) \
182 return err; \ 182 return err; \
183 codec->type = val; \ 183 codec->field = val; \
184 return count; \ 184 return count; \
185} 185}
186 186
187#define CODEC_INFO_STR_STORE(type) \ 187#define CODEC_INFO_STR_STORE(type, field) \
188static ssize_t type##_store(struct device *dev, \ 188static ssize_t type##_store(struct device *dev, \
189 struct device_attribute *attr, \ 189 struct device_attribute *attr, \
190 const char *buf, size_t count) \ 190 const char *buf, size_t count) \
@@ -193,17 +193,17 @@ static ssize_t type##_store(struct device *dev, \
193 char *s = kstrndup_noeol(buf, 64); \ 193 char *s = kstrndup_noeol(buf, 64); \
194 if (!s) \ 194 if (!s) \
195 return -ENOMEM; \ 195 return -ENOMEM; \
196 kfree(codec->type); \ 196 kfree(codec->field); \
197 codec->type = s; \ 197 codec->field = s; \
198 return count; \ 198 return count; \
199} 199}
200 200
201CODEC_INFO_STORE(vendor_id); 201CODEC_INFO_STORE(vendor_id, core.vendor_id);
202CODEC_INFO_STORE(subsystem_id); 202CODEC_INFO_STORE(subsystem_id, core.subsystem_id);
203CODEC_INFO_STORE(revision_id); 203CODEC_INFO_STORE(revision_id, core.revision_id);
204CODEC_INFO_STR_STORE(vendor_name); 204CODEC_INFO_STR_STORE(vendor_name, core.vendor_name);
205CODEC_INFO_STR_STORE(chip_name); 205CODEC_INFO_STR_STORE(chip_name, core.chip_name);
206CODEC_INFO_STR_STORE(modelname); 206CODEC_INFO_STR_STORE(modelname, modelname);
207 207
208#define CODEC_ACTION_STORE(type) \ 208#define CODEC_ACTION_STORE(type) \
209static ssize_t type##_store(struct device *dev, \ 209static ssize_t type##_store(struct device *dev, \
@@ -552,10 +552,10 @@ static void parse_codec_mode(char *buf, struct hda_bus *bus,
552 552
553 *codecp = NULL; 553 *codecp = NULL;
554 if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) { 554 if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) {
555 list_for_each_entry(codec, &bus->codec_list, list) { 555 list_for_each_codec(codec, bus) {
556 if ((vendorid <= 0 || codec->vendor_id == vendorid) && 556 if ((vendorid <= 0 || codec->core.vendor_id == vendorid) &&
557 (subid <= 0 || codec->subsystem_id == subid) && 557 (subid <= 0 || codec->core.subsystem_id == subid) &&
558 codec->addr == caddr) { 558 codec->core.addr == caddr) {
559 *codecp = codec; 559 *codecp = codec;
560 break; 560 break;
561 } 561 }
@@ -595,8 +595,8 @@ static void parse_model_mode(char *buf, struct hda_bus *bus,
595static void parse_chip_name_mode(char *buf, struct hda_bus *bus, 595static void parse_chip_name_mode(char *buf, struct hda_bus *bus,
596 struct hda_codec **codecp) 596 struct hda_codec **codecp)
597{ 597{
598 kfree((*codecp)->chip_name); 598 kfree((*codecp)->core.chip_name);
599 (*codecp)->chip_name = kstrdup(buf, GFP_KERNEL); 599 (*codecp)->core.chip_name = kstrdup(buf, GFP_KERNEL);
600} 600}
601 601
602#define DEFINE_PARSE_ID_MODE(name) \ 602#define DEFINE_PARSE_ID_MODE(name) \
@@ -605,7 +605,7 @@ static void parse_##name##_mode(char *buf, struct hda_bus *bus, \
605{ \ 605{ \
606 unsigned long val; \ 606 unsigned long val; \
607 if (!kstrtoul(buf, 0, &val)) \ 607 if (!kstrtoul(buf, 0, &val)) \
608 (*codecp)->name = val; \ 608 (*codecp)->core.name = val; \
609} 609}
610 610
611DEFINE_PARSE_ID_MODE(vendor_id); 611DEFINE_PARSE_ID_MODE(vendor_id);
diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c
index 375e94f4cf52..2e4fd5c56d3b 100644
--- a/sound/pci/hda/hda_tegra.c
+++ b/sound/pci/hda/hda_tegra.c
@@ -37,7 +37,6 @@
37 37
38#include "hda_codec.h" 38#include "hda_codec.h"
39#include "hda_controller.h" 39#include "hda_controller.h"
40#include "hda_priv.h"
41 40
42/* Defines for Nvidia Tegra HDA support */ 41/* Defines for Nvidia Tegra HDA support */
43#define HDA_BAR0 0x8000 42#define HDA_BAR0 0x8000
@@ -82,7 +81,7 @@ module_param(power_save, bint, 0644);
82MODULE_PARM_DESC(power_save, 81MODULE_PARM_DESC(power_save,
83 "Automatic power-saving timeout (in seconds, 0 = disable)."); 82 "Automatic power-saving timeout (in seconds, 0 = disable).");
84#else 83#else
85static int power_save = 0; 84#define power_save 0
86#endif 85#endif
87 86
88/* 87/*
@@ -250,14 +249,9 @@ static int hda_tegra_suspend(struct device *dev)
250{ 249{
251 struct snd_card *card = dev_get_drvdata(dev); 250 struct snd_card *card = dev_get_drvdata(dev);
252 struct azx *chip = card->private_data; 251 struct azx *chip = card->private_data;
253 struct azx_pcm *p;
254 struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip); 252 struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip);
255 253
256 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 254 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
257 list_for_each_entry(p, &chip->pcm_list, list)
258 snd_pcm_suspend_all(p->pcm);
259 if (chip->initialized)
260 snd_hda_suspend(chip->bus);
261 255
262 azx_stop_chip(chip); 256 azx_stop_chip(chip);
263 azx_enter_link_reset(chip); 257 azx_enter_link_reset(chip);
@@ -278,7 +272,6 @@ static int hda_tegra_resume(struct device *dev)
278 272
279 azx_init_chip(chip, 1); 273 azx_init_chip(chip, 1);
280 274
281 snd_hda_resume(chip->bus);
282 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 275 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
283 276
284 return 0; 277 return 0;
@@ -297,8 +290,6 @@ static int hda_tegra_dev_free(struct snd_device *device)
297 int i; 290 int i;
298 struct azx *chip = device->device_data; 291 struct azx *chip = device->device_data;
299 292
300 azx_notifier_unregister(chip);
301
302 if (chip->initialized) { 293 if (chip->initialized) {
303 for (i = 0; i < chip->num_streams; i++) 294 for (i = 0; i < chip->num_streams; i++)
304 azx_stream_stop(chip, &chip->azx_dev[i]); 295 azx_stream_stop(chip, &chip->azx_dev[i]);
@@ -344,17 +335,6 @@ static int hda_tegra_init_chip(struct azx *chip, struct platform_device *pdev)
344 return 0; 335 return 0;
345} 336}
346 337
347/*
348 * The codecs were powered up in snd_hda_codec_new().
349 * Now all initialization done, so turn them down if possible
350 */
351static void power_down_all_codecs(struct azx *chip)
352{
353 struct hda_codec *codec;
354 list_for_each_entry(codec, &chip->bus->codec_list, list)
355 snd_hda_power_down(codec);
356}
357
358static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev) 338static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev)
359{ 339{
360 struct snd_card *card = chip->card; 340 struct snd_card *card = chip->card;
@@ -503,21 +483,15 @@ static int hda_tegra_probe(struct platform_device *pdev)
503 goto out_free; 483 goto out_free;
504 484
505 /* create codec instances */ 485 /* create codec instances */
506 err = azx_codec_create(chip, NULL, 0, &power_save); 486 err = azx_bus_create(chip, NULL);
507 if (err < 0) 487 if (err < 0)
508 goto out_free; 488 goto out_free;
509 489
510 err = azx_codec_configure(chip); 490 err = azx_probe_codecs(chip, 0);
511 if (err < 0) 491 if (err < 0)
512 goto out_free; 492 goto out_free;
513 493
514 /* create PCM streams */ 494 err = azx_codec_configure(chip);
515 err = snd_hda_build_pcms(chip->bus);
516 if (err < 0)
517 goto out_free;
518
519 /* create mixer controls */
520 err = azx_mixer_create(chip);
521 if (err < 0) 495 if (err < 0)
522 goto out_free; 496 goto out_free;
523 497
@@ -526,8 +500,7 @@ static int hda_tegra_probe(struct platform_device *pdev)
526 goto out_free; 500 goto out_free;
527 501
528 chip->running = 1; 502 chip->running = 1;
529 power_down_all_codecs(chip); 503 snd_hda_set_power_save(chip->bus, power_save * 1000);
530 azx_notifier_register(chip);
531 504
532 return 0; 505 return 0;
533 506
@@ -541,6 +514,18 @@ static int hda_tegra_remove(struct platform_device *pdev)
541 return snd_card_free(dev_get_drvdata(&pdev->dev)); 514 return snd_card_free(dev_get_drvdata(&pdev->dev));
542} 515}
543 516
517static void hda_tegra_shutdown(struct platform_device *pdev)
518{
519 struct snd_card *card = dev_get_drvdata(&pdev->dev);
520 struct azx *chip;
521
522 if (!card)
523 return;
524 chip = card->private_data;
525 if (chip && chip->running)
526 azx_stop_chip(chip);
527}
528
544static struct platform_driver tegra_platform_hda = { 529static struct platform_driver tegra_platform_hda = {
545 .driver = { 530 .driver = {
546 .name = "tegra-hda", 531 .name = "tegra-hda",
@@ -549,6 +534,7 @@ static struct platform_driver tegra_platform_hda = {
549 }, 534 },
550 .probe = hda_tegra_probe, 535 .probe = hda_tegra_probe,
551 .remove = hda_tegra_remove, 536 .remove = hda_tegra_remove,
537 .shutdown = hda_tegra_shutdown,
552}; 538};
553module_platform_driver(tegra_platform_hda); 539module_platform_driver(tegra_platform_hda);
554 540
diff --git a/sound/pci/hda/hda_trace.h b/sound/pci/hda/hda_trace.h
deleted file mode 100644
index 3a1c63161eb1..000000000000
--- a/sound/pci/hda/hda_trace.h
+++ /dev/null
@@ -1,143 +0,0 @@
1#undef TRACE_SYSTEM
2#define TRACE_SYSTEM hda
3#define TRACE_INCLUDE_FILE hda_trace
4
5#if !defined(_TRACE_HDA_H) || defined(TRACE_HEADER_MULTI_READ)
6#define _TRACE_HDA_H
7
8#include <linux/tracepoint.h>
9
10struct hda_bus;
11struct hda_codec;
12
13DECLARE_EVENT_CLASS(hda_cmd,
14
15 TP_PROTO(struct hda_codec *codec, unsigned int val),
16
17 TP_ARGS(codec, val),
18
19 TP_STRUCT__entry(
20 __field( unsigned int, card )
21 __field( unsigned int, addr )
22 __field( unsigned int, val )
23 ),
24
25 TP_fast_assign(
26 __entry->card = (codec)->bus->card->number;
27 __entry->addr = (codec)->addr;
28 __entry->val = (val);
29 ),
30
31 TP_printk("[%d:%d] val=%x", __entry->card, __entry->addr, __entry->val)
32);
33
34DEFINE_EVENT(hda_cmd, hda_send_cmd,
35 TP_PROTO(struct hda_codec *codec, unsigned int val),
36 TP_ARGS(codec, val)
37);
38
39DEFINE_EVENT(hda_cmd, hda_get_response,
40 TP_PROTO(struct hda_codec *codec, unsigned int val),
41 TP_ARGS(codec, val)
42);
43
44TRACE_EVENT(hda_bus_reset,
45
46 TP_PROTO(struct hda_bus *bus),
47
48 TP_ARGS(bus),
49
50 TP_STRUCT__entry(
51 __field( unsigned int, card )
52 ),
53
54 TP_fast_assign(
55 __entry->card = (bus)->card->number;
56 ),
57
58 TP_printk("[%d]", __entry->card)
59);
60
61#ifdef CONFIG_PM
62DECLARE_EVENT_CLASS(hda_power,
63
64 TP_PROTO(struct hda_codec *codec),
65
66 TP_ARGS(codec),
67
68 TP_STRUCT__entry(
69 __field( unsigned int, card )
70 __field( unsigned int, addr )
71 ),
72
73 TP_fast_assign(
74 __entry->card = (codec)->bus->card->number;
75 __entry->addr = (codec)->addr;
76 ),
77
78 TP_printk("[%d:%d]", __entry->card, __entry->addr)
79);
80
81DEFINE_EVENT(hda_power, hda_power_down,
82 TP_PROTO(struct hda_codec *codec),
83 TP_ARGS(codec)
84);
85
86DEFINE_EVENT(hda_power, hda_power_up,
87 TP_PROTO(struct hda_codec *codec),
88 TP_ARGS(codec)
89);
90
91TRACE_EVENT(hda_power_count,
92 TP_PROTO(struct hda_codec *codec),
93 TP_ARGS(codec),
94 TP_STRUCT__entry(
95 __field( unsigned int, card )
96 __field( unsigned int, addr )
97 __field( int, power_count )
98 __field( int, power_on )
99 __field( int, power_transition )
100 ),
101
102 TP_fast_assign(
103 __entry->card = (codec)->bus->card->number;
104 __entry->addr = (codec)->addr;
105 __entry->power_count = (codec)->power_count;
106 __entry->power_on = (codec)->power_on;
107 __entry->power_transition = (codec)->power_transition;
108 ),
109
110 TP_printk("[%d:%d] power_count=%d, power_on=%d, power_transition=%d",
111 __entry->card, __entry->addr, __entry->power_count,
112 __entry->power_on, __entry->power_transition)
113);
114#endif /* CONFIG_PM */
115
116TRACE_EVENT(hda_unsol_event,
117
118 TP_PROTO(struct hda_bus *bus, u32 res, u32 res_ex),
119
120 TP_ARGS(bus, res, res_ex),
121
122 TP_STRUCT__entry(
123 __field( unsigned int, card )
124 __field( u32, res )
125 __field( u32, res_ex )
126 ),
127
128 TP_fast_assign(
129 __entry->card = (bus)->card->number;
130 __entry->res = res;
131 __entry->res_ex = res_ex;
132 ),
133
134 TP_printk("[%d] res=%x, res_ex=%x", __entry->card,
135 __entry->res, __entry->res_ex)
136);
137
138#endif /* _TRACE_HDA_H */
139
140/* This part must be outside protection */
141#undef TRACE_INCLUDE_PATH
142#define TRACE_INCLUDE_PATH .
143#include <trace/define_trace.h>
diff --git a/sound/pci/hda/local.h b/sound/pci/hda/local.h
new file mode 100644
index 000000000000..28cb7f98982e
--- /dev/null
+++ b/sound/pci/hda/local.h
@@ -0,0 +1,39 @@
1/*
2 */
3
4#ifndef __HDAC_LOCAL_H
5#define __HDAC_LOCAL_H
6
7int hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm);
8
9#define get_wcaps(codec, nid) \
10 hdac_read_parm(codec, nid, AC_PAR_AUDIO_WIDGET_CAP)
11/* get the widget type from widget capability bits */
12static inline int get_wcaps_type(unsigned int wcaps)
13{
14 if (!wcaps)
15 return -1; /* invalid type */
16 return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
17}
18
19#define get_pin_caps(codec, nid) \
20 hdac_read_parm(codec, nid, AC_PAR_PIN_CAP)
21
22static inline
23unsigned int get_pin_cfg(struct hdac_device *codec, hda_nid_t nid)
24{
25 unsigned int val;
26
27 if (snd_hdac_read(codec, nid, AC_VERB_GET_CONFIG_DEFAULT, 0, &val))
28 return -1;
29 return val;
30}
31
32#define get_amp_caps(codec, nid, dir) \
33 hdac_read_parm(codec, nid, (dir) == HDA_OUTPUT ? \
34 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP)
35
36#define get_power_caps(codec, nid) \
37 hdac_read_parm(codec, nid, AC_PAR_POWER_STATE)
38
39#endif /* __HDAC_LOCAL_H */
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index d285904cdb64..231f89029779 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -99,7 +99,7 @@ static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
99static void ad198x_power_eapd(struct hda_codec *codec) 99static void ad198x_power_eapd(struct hda_codec *codec)
100{ 100{
101 /* We currently only handle front, HP */ 101 /* We currently only handle front, HP */
102 switch (codec->vendor_id) { 102 switch (codec->core.vendor_id) {
103 case 0x11d41882: 103 case 0x11d41882:
104 case 0x11d4882a: 104 case 0x11d4882a:
105 case 0x11d41884: 105 case 0x11d41884:
@@ -777,7 +777,6 @@ static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
777 return 0; 777 return 0;
778 778
779 mutex_lock(&codec->control_mutex); 779 mutex_lock(&codec->control_mutex);
780 codec->cached_write = 1;
781 path = snd_hda_get_path_from_idx(codec, 780 path = snd_hda_get_path_from_idx(codec,
782 spec->smux_paths[spec->cur_smux]); 781 spec->smux_paths[spec->cur_smux]);
783 if (path) 782 if (path)
@@ -786,9 +785,7 @@ static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
786 if (path) 785 if (path)
787 snd_hda_activate_path(codec, path, true, true); 786 snd_hda_activate_path(codec, path, true, true);
788 spec->cur_smux = val; 787 spec->cur_smux = val;
789 codec->cached_write = 0;
790 mutex_unlock(&codec->control_mutex); 788 mutex_unlock(&codec->control_mutex);
791 snd_hda_codec_flush_cache(codec); /* flush the updates */
792 return 1; 789 return 1;
793} 790}
794 791
@@ -1004,18 +1001,17 @@ static void ad1884_fixup_hp_eapd(struct hda_codec *codec,
1004 const struct hda_fixup *fix, int action) 1001 const struct hda_fixup *fix, int action)
1005{ 1002{
1006 struct ad198x_spec *spec = codec->spec; 1003 struct ad198x_spec *spec = codec->spec;
1007 static const struct hda_verb gpio_init_verbs[] = {
1008 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1009 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1010 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1011 {},
1012 };
1013 1004
1014 switch (action) { 1005 switch (action) {
1015 case HDA_FIXUP_ACT_PRE_PROBE: 1006 case HDA_FIXUP_ACT_PRE_PROBE:
1016 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook; 1007 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook;
1017 spec->gen.own_eapd_ctl = 1; 1008 spec->gen.own_eapd_ctl = 1;
1018 snd_hda_sequence_write_cache(codec, gpio_init_verbs); 1009 snd_hda_codec_write_cache(codec, 0x01, 0,
1010 AC_VERB_SET_GPIO_MASK, 0x02);
1011 snd_hda_codec_write_cache(codec, 0x01, 0,
1012 AC_VERB_SET_GPIO_DIRECTION, 0x02);
1013 snd_hda_codec_write_cache(codec, 0x01, 0,
1014 AC_VERB_SET_GPIO_DATA, 0x02);
1019 break; 1015 break;
1020 case HDA_FIXUP_ACT_PROBE: 1016 case HDA_FIXUP_ACT_PROBE:
1021 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 1017 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
@@ -1194,20 +1190,8 @@ MODULE_ALIAS("snd-hda-codec-id:11d4*");
1194MODULE_LICENSE("GPL"); 1190MODULE_LICENSE("GPL");
1195MODULE_DESCRIPTION("Analog Devices HD-audio codec"); 1191MODULE_DESCRIPTION("Analog Devices HD-audio codec");
1196 1192
1197static struct hda_codec_preset_list analog_list = { 1193static struct hda_codec_driver analog_driver = {
1198 .preset = snd_hda_preset_analog, 1194 .preset = snd_hda_preset_analog,
1199 .owner = THIS_MODULE,
1200}; 1195};
1201 1196
1202static int __init patch_analog_init(void) 1197module_hda_codec_driver(analog_driver);
1203{
1204 return snd_hda_add_codec_preset(&analog_list);
1205}
1206
1207static void __exit patch_analog_exit(void)
1208{
1209 snd_hda_delete_codec_preset(&analog_list);
1210}
1211
1212module_init(patch_analog_init)
1213module_exit(patch_analog_exit)
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c
index 5e65999e0d8e..447302695195 100644
--- a/sound/pci/hda/patch_ca0110.c
+++ b/sound/pci/hda/patch_ca0110.c
@@ -98,20 +98,8 @@ MODULE_ALIAS("snd-hda-codec-id:1102000d");
98MODULE_LICENSE("GPL"); 98MODULE_LICENSE("GPL");
99MODULE_DESCRIPTION("Creative CA0110-IBG HD-audio codec"); 99MODULE_DESCRIPTION("Creative CA0110-IBG HD-audio codec");
100 100
101static struct hda_codec_preset_list ca0110_list = { 101static struct hda_codec_driver ca0110_driver = {
102 .preset = snd_hda_preset_ca0110, 102 .preset = snd_hda_preset_ca0110,
103 .owner = THIS_MODULE,
104}; 103};
105 104
106static int __init patch_ca0110_init(void) 105module_hda_codec_driver(ca0110_driver);
107{
108 return snd_hda_add_codec_preset(&ca0110_list);
109}
110
111static void __exit patch_ca0110_exit(void)
112{
113 snd_hda_delete_codec_preset(&ca0110_list);
114}
115
116module_init(patch_ca0110_init)
117module_exit(patch_ca0110_exit)
diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c
index e0383eea9880..4a4e7b282e4f 100644
--- a/sound/pci/hda/patch_ca0132.c
+++ b/sound/pci/hda/patch_ca0132.c
@@ -719,7 +719,6 @@ struct ca0132_spec {
719 unsigned int num_inputs; 719 unsigned int num_inputs;
720 hda_nid_t shared_mic_nid; 720 hda_nid_t shared_mic_nid;
721 hda_nid_t shared_out_nid; 721 hda_nid_t shared_out_nid;
722 struct hda_pcm pcm_rec[5]; /* PCM information */
723 722
724 /* chip access */ 723 /* chip access */
725 struct mutex chipio_mutex; /* chip access mutex */ 724 struct mutex chipio_mutex; /* chip access mutex */
@@ -3132,7 +3131,7 @@ static int ca0132_select_out(struct hda_codec *codec)
3132 3131
3133 codec_dbg(codec, "ca0132_select_out\n"); 3132 codec_dbg(codec, "ca0132_select_out\n");
3134 3133
3135 snd_hda_power_up(codec); 3134 snd_hda_power_up_pm(codec);
3136 3135
3137 auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID]; 3136 auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
3138 3137
@@ -3216,7 +3215,7 @@ static int ca0132_select_out(struct hda_codec *codec)
3216 } 3215 }
3217 3216
3218exit: 3217exit:
3219 snd_hda_power_down(codec); 3218 snd_hda_power_down_pm(codec);
3220 3219
3221 return err < 0 ? err : 0; 3220 return err < 0 ? err : 0;
3222} 3221}
@@ -3294,7 +3293,7 @@ static int ca0132_select_mic(struct hda_codec *codec)
3294 3293
3295 codec_dbg(codec, "ca0132_select_mic\n"); 3294 codec_dbg(codec, "ca0132_select_mic\n");
3296 3295
3297 snd_hda_power_up(codec); 3296 snd_hda_power_up_pm(codec);
3298 3297
3299 auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID]; 3298 auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];
3300 3299
@@ -3327,7 +3326,7 @@ static int ca0132_select_mic(struct hda_codec *codec)
3327 ca0132_effects_set(codec, VOICE_FOCUS, 0); 3326 ca0132_effects_set(codec, VOICE_FOCUS, 0);
3328 } 3327 }
3329 3328
3330 snd_hda_power_down(codec); 3329 snd_hda_power_down_pm(codec);
3331 3330
3332 return 0; 3331 return 0;
3333} 3332}
@@ -4036,12 +4035,11 @@ static struct hda_pcm_stream ca0132_pcm_digital_capture = {
4036static int ca0132_build_pcms(struct hda_codec *codec) 4035static int ca0132_build_pcms(struct hda_codec *codec)
4037{ 4036{
4038 struct ca0132_spec *spec = codec->spec; 4037 struct ca0132_spec *spec = codec->spec;
4039 struct hda_pcm *info = spec->pcm_rec; 4038 struct hda_pcm *info;
4040
4041 codec->pcm_info = info;
4042 codec->num_pcms = 0;
4043 4039
4044 info->name = "CA0132 Analog"; 4040 info = snd_hda_codec_pcm_new(codec, "CA0132 Analog");
4041 if (!info)
4042 return -ENOMEM;
4045 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback; 4043 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback;
4046 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0]; 4044 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0];
4047 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 4045 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
@@ -4049,27 +4047,27 @@ static int ca0132_build_pcms(struct hda_codec *codec)
4049 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4047 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4050 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4048 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4051 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0]; 4049 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
4052 codec->num_pcms++;
4053 4050
4054 info++; 4051 info = snd_hda_codec_pcm_new(codec, "CA0132 Analog Mic-In2");
4055 info->name = "CA0132 Analog Mic-In2"; 4052 if (!info)
4053 return -ENOMEM;
4056 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4054 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4057 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4055 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4058 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1]; 4056 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1];
4059 codec->num_pcms++;
4060 4057
4061 info++; 4058 info = snd_hda_codec_pcm_new(codec, "CA0132 What U Hear");
4062 info->name = "CA0132 What U Hear"; 4059 if (!info)
4060 return -ENOMEM;
4063 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4061 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4064 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4062 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4065 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[2]; 4063 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[2];
4066 codec->num_pcms++;
4067 4064
4068 if (!spec->dig_out && !spec->dig_in) 4065 if (!spec->dig_out && !spec->dig_in)
4069 return 0; 4066 return 0;
4070 4067
4071 info++; 4068 info = snd_hda_codec_pcm_new(codec, "CA0132 Digital");
4072 info->name = "CA0132 Digital"; 4069 if (!info)
4070 return -ENOMEM;
4073 info->pcm_type = HDA_PCM_TYPE_SPDIF; 4071 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4074 if (spec->dig_out) { 4072 if (spec->dig_out) {
4075 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 4073 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
@@ -4081,7 +4079,6 @@ static int ca0132_build_pcms(struct hda_codec *codec)
4081 ca0132_pcm_digital_capture; 4079 ca0132_pcm_digital_capture;
4082 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in; 4080 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
4083 } 4081 }
4084 codec->num_pcms++;
4085 4082
4086 return 0; 4083 return 0;
4087} 4084}
@@ -4246,13 +4243,9 @@ static void ca0132_refresh_widget_caps(struct hda_codec *codec)
4246{ 4243{
4247 struct ca0132_spec *spec = codec->spec; 4244 struct ca0132_spec *spec = codec->spec;
4248 int i; 4245 int i;
4249 hda_nid_t nid;
4250 4246
4251 codec_dbg(codec, "ca0132_refresh_widget_caps.\n"); 4247 codec_dbg(codec, "ca0132_refresh_widget_caps.\n");
4252 nid = codec->start_nid; 4248 snd_hda_codec_update_widgets(codec);
4253 for (i = 0; i < codec->num_nodes; i++, nid++)
4254 codec->wcaps[i] = snd_hda_param_read(codec, nid,
4255 AC_PAR_AUDIO_WIDGET_CAP);
4256 4249
4257 for (i = 0; i < spec->multiout.num_dacs; i++) 4250 for (i = 0; i < spec->multiout.num_dacs; i++)
4258 refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT); 4251 refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT);
@@ -4352,7 +4345,7 @@ static bool ca0132_download_dsp_images(struct hda_codec *codec)
4352 const struct dsp_image_seg *dsp_os_image; 4345 const struct dsp_image_seg *dsp_os_image;
4353 const struct firmware *fw_entry; 4346 const struct firmware *fw_entry;
4354 4347
4355 if (request_firmware(&fw_entry, EFX_FILE, codec->bus->card->dev) != 0) 4348 if (request_firmware(&fw_entry, EFX_FILE, codec->card->dev) != 0)
4356 return false; 4349 return false;
4357 4350
4358 dsp_os_image = (struct dsp_image_seg *)(fw_entry->data); 4351 dsp_os_image = (struct dsp_image_seg *)(fw_entry->data);
@@ -4413,8 +4406,7 @@ static void hp_callback(struct hda_codec *codec, struct hda_jack_callback *cb)
4413 * state machine run. 4406 * state machine run.
4414 */ 4407 */
4415 cancel_delayed_work_sync(&spec->unsol_hp_work); 4408 cancel_delayed_work_sync(&spec->unsol_hp_work);
4416 queue_delayed_work(codec->bus->workq, &spec->unsol_hp_work, 4409 schedule_delayed_work(&spec->unsol_hp_work, msecs_to_jiffies(500));
4417 msecs_to_jiffies(500));
4418 cb->tbl->block_report = 1; 4410 cb->tbl->block_report = 1;
4419} 4411}
4420 4412
@@ -4554,7 +4546,7 @@ static int ca0132_init(struct hda_codec *codec)
4554 spec->dsp_state = DSP_DOWNLOAD_INIT; 4546 spec->dsp_state = DSP_DOWNLOAD_INIT;
4555 spec->curr_chip_addx = INVALID_CHIP_ADDRESS; 4547 spec->curr_chip_addx = INVALID_CHIP_ADDRESS;
4556 4548
4557 snd_hda_power_up(codec); 4549 snd_hda_power_up_pm(codec);
4558 4550
4559 ca0132_init_unsol(codec); 4551 ca0132_init_unsol(codec);
4560 4552
@@ -4585,7 +4577,7 @@ static int ca0132_init(struct hda_codec *codec)
4585 4577
4586 snd_hda_jack_report_sync(codec); 4578 snd_hda_jack_report_sync(codec);
4587 4579
4588 snd_hda_power_down(codec); 4580 snd_hda_power_down_pm(codec);
4589 4581
4590 return 0; 4582 return 0;
4591} 4583}
@@ -4702,20 +4694,8 @@ MODULE_ALIAS("snd-hda-codec-id:11020011");
4702MODULE_LICENSE("GPL"); 4694MODULE_LICENSE("GPL");
4703MODULE_DESCRIPTION("Creative Sound Core3D codec"); 4695MODULE_DESCRIPTION("Creative Sound Core3D codec");
4704 4696
4705static struct hda_codec_preset_list ca0132_list = { 4697static struct hda_codec_driver ca0132_driver = {
4706 .preset = snd_hda_preset_ca0132, 4698 .preset = snd_hda_preset_ca0132,
4707 .owner = THIS_MODULE,
4708}; 4699};
4709 4700
4710static int __init patch_ca0132_init(void) 4701module_hda_codec_driver(ca0132_driver);
4711{
4712 return snd_hda_add_codec_preset(&ca0132_list);
4713}
4714
4715static void __exit patch_ca0132_exit(void)
4716{
4717 snd_hda_delete_codec_preset(&ca0132_list);
4718}
4719
4720module_init(patch_ca0132_init)
4721module_exit(patch_ca0132_exit)
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index dd2b3d92071f..50e9dd675579 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -1221,20 +1221,8 @@ MODULE_ALIAS("snd-hda-codec-id:10134213");
1221MODULE_LICENSE("GPL"); 1221MODULE_LICENSE("GPL");
1222MODULE_DESCRIPTION("Cirrus Logic HD-audio codec"); 1222MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
1223 1223
1224static struct hda_codec_preset_list cirrus_list = { 1224static struct hda_codec_driver cirrus_driver = {
1225 .preset = snd_hda_preset_cirrus, 1225 .preset = snd_hda_preset_cirrus,
1226 .owner = THIS_MODULE,
1227}; 1226};
1228 1227
1229static int __init patch_cirrus_init(void) 1228module_hda_codec_driver(cirrus_driver);
1230{
1231 return snd_hda_add_codec_preset(&cirrus_list);
1232}
1233
1234static void __exit patch_cirrus_exit(void)
1235{
1236 snd_hda_delete_codec_preset(&cirrus_list);
1237}
1238
1239module_init(patch_cirrus_init)
1240module_exit(patch_cirrus_exit)
diff --git a/sound/pci/hda/patch_cmedia.c b/sound/pci/hda/patch_cmedia.c
index c895a8f21192..617d9012e78a 100644
--- a/sound/pci/hda/patch_cmedia.c
+++ b/sound/pci/hda/patch_cmedia.c
@@ -137,20 +137,8 @@ MODULE_ALIAS("snd-hda-codec-id:434d4980");
137MODULE_LICENSE("GPL"); 137MODULE_LICENSE("GPL");
138MODULE_DESCRIPTION("C-Media HD-audio codec"); 138MODULE_DESCRIPTION("C-Media HD-audio codec");
139 139
140static struct hda_codec_preset_list cmedia_list = { 140static struct hda_codec_driver cmedia_driver = {
141 .preset = snd_hda_preset_cmedia, 141 .preset = snd_hda_preset_cmedia,
142 .owner = THIS_MODULE,
143}; 142};
144 143
145static int __init patch_cmedia_init(void) 144module_hda_codec_driver(cmedia_driver);
146{
147 return snd_hda_add_codec_preset(&cmedia_list);
148}
149
150static void __exit patch_cmedia_exit(void)
151{
152 snd_hda_delete_codec_preset(&cmedia_list);
153}
154
155module_init(patch_cmedia_init)
156module_exit(patch_cmedia_exit)
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index da67ea8645a6..f8f0dfbef149 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -103,10 +103,9 @@ static int add_beep_ctls(struct hda_codec *codec)
103static void cx_auto_parse_beep(struct hda_codec *codec) 103static void cx_auto_parse_beep(struct hda_codec *codec)
104{ 104{
105 struct conexant_spec *spec = codec->spec; 105 struct conexant_spec *spec = codec->spec;
106 hda_nid_t nid, end_nid; 106 hda_nid_t nid;
107 107
108 end_nid = codec->start_nid + codec->num_nodes; 108 for_each_hda_codec_node(nid, codec)
109 for (nid = codec->start_nid; nid < end_nid; nid++)
110 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) { 109 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) {
111 set_beep_amp(spec, nid, 0, HDA_OUTPUT); 110 set_beep_amp(spec, nid, 0, HDA_OUTPUT);
112 break; 111 break;
@@ -120,10 +119,9 @@ static void cx_auto_parse_beep(struct hda_codec *codec)
120static void cx_auto_parse_eapd(struct hda_codec *codec) 119static void cx_auto_parse_eapd(struct hda_codec *codec)
121{ 120{
122 struct conexant_spec *spec = codec->spec; 121 struct conexant_spec *spec = codec->spec;
123 hda_nid_t nid, end_nid; 122 hda_nid_t nid;
124 123
125 end_nid = codec->start_nid + codec->num_nodes; 124 for_each_hda_codec_node(nid, codec) {
126 for (nid = codec->start_nid; nid < end_nid; nid++) {
127 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 125 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
128 continue; 126 continue;
129 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) 127 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD))
@@ -304,6 +302,7 @@ static void cxt_fixup_headphone_mic(struct hda_codec *codec,
304 switch (action) { 302 switch (action) {
305 case HDA_FIXUP_ACT_PRE_PROBE: 303 case HDA_FIXUP_ACT_PRE_PROBE:
306 spec->parse_flags |= HDA_PINCFG_HEADPHONE_MIC; 304 spec->parse_flags |= HDA_PINCFG_HEADPHONE_MIC;
305 snd_hdac_regmap_add_vendor_verb(&codec->core, 0x410);
307 break; 306 break;
308 case HDA_FIXUP_ACT_PROBE: 307 case HDA_FIXUP_ACT_PROBE:
309 spec->gen.cap_sync_hook = cxt_update_headset_mode_hook; 308 spec->gen.cap_sync_hook = cxt_update_headset_mode_hook;
@@ -411,15 +410,11 @@ static void olpc_xo_automic(struct hda_codec *codec,
411 struct hda_jack_callback *jack) 410 struct hda_jack_callback *jack)
412{ 411{
413 struct conexant_spec *spec = codec->spec; 412 struct conexant_spec *spec = codec->spec;
414 int saved_cached_write = codec->cached_write;
415 413
416 codec->cached_write = 1;
417 /* in DC mode, we don't handle automic */ 414 /* in DC mode, we don't handle automic */
418 if (!spec->dc_enable) 415 if (!spec->dc_enable)
419 snd_hda_gen_mic_autoswitch(codec, jack); 416 snd_hda_gen_mic_autoswitch(codec, jack);
420 olpc_xo_update_mic_pins(codec); 417 olpc_xo_update_mic_pins(codec);
421 snd_hda_codec_flush_cache(codec);
422 codec->cached_write = saved_cached_write;
423 if (spec->dc_enable) 418 if (spec->dc_enable)
424 olpc_xo_update_mic_boost(codec); 419 olpc_xo_update_mic_boost(codec);
425} 420}
@@ -848,7 +843,7 @@ static int patch_conexant_auto(struct hda_codec *codec)
848 struct conexant_spec *spec; 843 struct conexant_spec *spec;
849 int err; 844 int err;
850 845
851 codec_info(codec, "%s: BIOS auto-probing.\n", codec->chip_name); 846 codec_info(codec, "%s: BIOS auto-probing.\n", codec->core.chip_name);
852 847
853 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 848 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
854 if (!spec) 849 if (!spec)
@@ -862,7 +857,7 @@ static int patch_conexant_auto(struct hda_codec *codec)
862 if (spec->dynamic_eapd) 857 if (spec->dynamic_eapd)
863 spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook; 858 spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook;
864 859
865 switch (codec->vendor_id) { 860 switch (codec->core.vendor_id) {
866 case 0x14f15045: 861 case 0x14f15045:
867 codec->single_adc_amp = 1; 862 codec->single_adc_amp = 1;
868 spec->gen.mixer_nid = 0x17; 863 spec->gen.mixer_nid = 0x17;
@@ -896,7 +891,7 @@ static int patch_conexant_auto(struct hda_codec *codec)
896 * others may use EAPD really as an amp switch, so it might be 891 * others may use EAPD really as an amp switch, so it might be
897 * not good to expose it blindly. 892 * not good to expose it blindly.
898 */ 893 */
899 switch (codec->subsystem_id >> 16) { 894 switch (codec->core.subsystem_id >> 16) {
900 case 0x103c: 895 case 0x103c:
901 spec->gen.vmaster_mute_enum = 1; 896 spec->gen.vmaster_mute_enum = 1;
902 break; 897 break;
@@ -919,10 +914,10 @@ static int patch_conexant_auto(struct hda_codec *codec)
919 * which falls into the single-cmd mode. 914 * which falls into the single-cmd mode.
920 * Better to make reset, then. 915 * Better to make reset, then.
921 */ 916 */
922 if (!codec->bus->sync_write) { 917 if (!codec->bus->core.sync_write) {
923 codec_info(codec, 918 codec_info(codec,
924 "Enable sync_write for stable communication\n"); 919 "Enable sync_write for stable communication\n");
925 codec->bus->sync_write = 1; 920 codec->bus->core.sync_write = 1;
926 codec->bus->allow_bus_reset = 1; 921 codec->bus->allow_bus_reset = 1;
927 } 922 }
928 923
@@ -1018,20 +1013,8 @@ MODULE_ALIAS("snd-hda-codec-id:14f151d7");
1018MODULE_LICENSE("GPL"); 1013MODULE_LICENSE("GPL");
1019MODULE_DESCRIPTION("Conexant HD-audio codec"); 1014MODULE_DESCRIPTION("Conexant HD-audio codec");
1020 1015
1021static struct hda_codec_preset_list conexant_list = { 1016static struct hda_codec_driver conexant_driver = {
1022 .preset = snd_hda_preset_conexant, 1017 .preset = snd_hda_preset_conexant,
1023 .owner = THIS_MODULE,
1024}; 1018};
1025 1019
1026static int __init patch_conexant_init(void) 1020module_hda_codec_driver(conexant_driver);
1027{
1028 return snd_hda_add_codec_preset(&conexant_list);
1029}
1030
1031static void __exit patch_conexant_exit(void)
1032{
1033 snd_hda_delete_codec_preset(&conexant_list);
1034}
1035
1036module_init(patch_conexant_init)
1037module_exit(patch_conexant_exit)
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index b422e406a9cb..5f44f60a6389 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -45,14 +45,14 @@ static bool static_hdmi_pcm;
45module_param(static_hdmi_pcm, bool, 0644); 45module_param(static_hdmi_pcm, bool, 0644);
46MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info"); 46MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info");
47 47
48#define is_haswell(codec) ((codec)->vendor_id == 0x80862807) 48#define is_haswell(codec) ((codec)->core.vendor_id == 0x80862807)
49#define is_broadwell(codec) ((codec)->vendor_id == 0x80862808) 49#define is_broadwell(codec) ((codec)->core.vendor_id == 0x80862808)
50#define is_skylake(codec) ((codec)->vendor_id == 0x80862809) 50#define is_skylake(codec) ((codec)->core.vendor_id == 0x80862809)
51#define is_haswell_plus(codec) (is_haswell(codec) || is_broadwell(codec) \ 51#define is_haswell_plus(codec) (is_haswell(codec) || is_broadwell(codec) \
52 || is_skylake(codec)) 52 || is_skylake(codec))
53 53
54#define is_valleyview(codec) ((codec)->vendor_id == 0x80862882) 54#define is_valleyview(codec) ((codec)->core.vendor_id == 0x80862882)
55#define is_cherryview(codec) ((codec)->vendor_id == 0x80862883) 55#define is_cherryview(codec) ((codec)->core.vendor_id == 0x80862883)
56#define is_valleyview_plus(codec) (is_valleyview(codec) || is_cherryview(codec)) 56#define is_valleyview_plus(codec) (is_valleyview(codec) || is_cherryview(codec))
57 57
58struct hdmi_spec_per_cvt { 58struct hdmi_spec_per_cvt {
@@ -86,7 +86,6 @@ struct hdmi_spec_per_pin {
86 bool non_pcm; 86 bool non_pcm;
87 bool chmap_set; /* channel-map override by ALSA API? */ 87 bool chmap_set; /* channel-map override by ALSA API? */
88 unsigned char chmap[8]; /* ALSA API channel-map */ 88 unsigned char chmap[8]; /* ALSA API channel-map */
89 char pcm_name[8]; /* filled in build_pcm callbacks */
90#ifdef CONFIG_PROC_FS 89#ifdef CONFIG_PROC_FS
91 struct snd_info_entry *proc_entry; 90 struct snd_info_entry *proc_entry;
92#endif 91#endif
@@ -132,7 +131,7 @@ struct hdmi_spec {
132 131
133 int num_pins; 132 int num_pins;
134 struct snd_array pins; /* struct hdmi_spec_per_pin */ 133 struct snd_array pins; /* struct hdmi_spec_per_pin */
135 struct snd_array pcm_rec; /* struct hda_pcm */ 134 struct hda_pcm *pcm_rec[16];
136 unsigned int channels_max; /* max over all cvts */ 135 unsigned int channels_max; /* max over all cvts */
137 136
138 struct hdmi_eld temp_eld; 137 struct hdmi_eld temp_eld;
@@ -355,8 +354,7 @@ static struct cea_channel_speaker_allocation channel_allocations[] = {
355 ((struct hdmi_spec_per_pin *)snd_array_elem(&spec->pins, idx)) 354 ((struct hdmi_spec_per_pin *)snd_array_elem(&spec->pins, idx))
356#define get_cvt(spec, idx) \ 355#define get_cvt(spec, idx) \
357 ((struct hdmi_spec_per_cvt *)snd_array_elem(&spec->cvts, idx)) 356 ((struct hdmi_spec_per_cvt *)snd_array_elem(&spec->cvts, idx))
358#define get_pcm_rec(spec, idx) \ 357#define get_pcm_rec(spec, idx) ((spec)->pcm_rec[idx])
359 ((struct hda_pcm *)snd_array_elem(&spec->pcm_rec, idx))
360 358
361static int pin_nid_to_pin_index(struct hda_codec *codec, hda_nid_t pin_nid) 359static int pin_nid_to_pin_index(struct hda_codec *codec, hda_nid_t pin_nid)
362{ 360{
@@ -579,7 +577,7 @@ static int eld_proc_new(struct hdmi_spec_per_pin *per_pin, int index)
579 int err; 577 int err;
580 578
581 snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index); 579 snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
582 err = snd_card_proc_new(codec->bus->card, name, &entry); 580 err = snd_card_proc_new(codec->card, name, &entry);
583 if (err < 0) 581 if (err < 0)
584 return err; 582 return err;
585 583
@@ -594,7 +592,7 @@ static int eld_proc_new(struct hdmi_spec_per_pin *per_pin, int index)
594static void eld_proc_free(struct hdmi_spec_per_pin *per_pin) 592static void eld_proc_free(struct hdmi_spec_per_pin *per_pin)
595{ 593{
596 if (!per_pin->codec->bus->shutdown && per_pin->proc_entry) { 594 if (!per_pin->codec->bus->shutdown && per_pin->proc_entry) {
597 snd_device_free(per_pin->codec->bus->card, per_pin->proc_entry); 595 snd_device_free(per_pin->codec->card, per_pin->proc_entry);
598 per_pin->proc_entry = NULL; 596 per_pin->proc_entry = NULL;
599 } 597 }
600} 598}
@@ -1393,13 +1391,12 @@ static void intel_not_share_assigned_cvt(struct hda_codec *codec,
1393 hda_nid_t pin_nid, int mux_idx) 1391 hda_nid_t pin_nid, int mux_idx)
1394{ 1392{
1395 struct hdmi_spec *spec = codec->spec; 1393 struct hdmi_spec *spec = codec->spec;
1396 hda_nid_t nid, end_nid; 1394 hda_nid_t nid;
1397 int cvt_idx, curr; 1395 int cvt_idx, curr;
1398 struct hdmi_spec_per_cvt *per_cvt; 1396 struct hdmi_spec_per_cvt *per_cvt;
1399 1397
1400 /* configure all pins, including "no physical connection" ones */ 1398 /* configure all pins, including "no physical connection" ones */
1401 end_nid = codec->start_nid + codec->num_nodes; 1399 for_each_hda_codec_node(nid, codec) {
1402 for (nid = codec->start_nid; nid < end_nid; nid++) {
1403 unsigned int wid_caps = get_wcaps(codec, nid); 1400 unsigned int wid_caps = get_wcaps(codec, nid);
1404 unsigned int wid_type = get_wcaps_type(wid_caps); 1401 unsigned int wid_type = get_wcaps_type(wid_caps);
1405 1402
@@ -1548,7 +1545,7 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
1548 bool eld_changed = false; 1545 bool eld_changed = false;
1549 bool ret; 1546 bool ret;
1550 1547
1551 snd_hda_power_up(codec); 1548 snd_hda_power_up_pm(codec);
1552 present = snd_hda_pin_sense(codec, pin_nid); 1549 present = snd_hda_pin_sense(codec, pin_nid);
1553 1550
1554 mutex_lock(&per_pin->lock); 1551 mutex_lock(&per_pin->lock);
@@ -1578,9 +1575,8 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
1578 update_eld = true; 1575 update_eld = true;
1579 } 1576 }
1580 else if (repoll) { 1577 else if (repoll) {
1581 queue_delayed_work(codec->bus->workq, 1578 schedule_delayed_work(&per_pin->work,
1582 &per_pin->work, 1579 msecs_to_jiffies(300));
1583 msecs_to_jiffies(300));
1584 goto unlock; 1580 goto unlock;
1585 } 1581 }
1586 } 1582 }
@@ -1624,7 +1620,7 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
1624 } 1620 }
1625 1621
1626 if (eld_changed) 1622 if (eld_changed)
1627 snd_ctl_notify(codec->bus->card, 1623 snd_ctl_notify(codec->card,
1628 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 1624 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
1629 &per_pin->eld_ctl->id); 1625 &per_pin->eld_ctl->id);
1630 unlock: 1626 unlock:
@@ -1635,7 +1631,7 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
1635 jack->block_report = !ret; 1631 jack->block_report = !ret;
1636 1632
1637 mutex_unlock(&per_pin->lock); 1633 mutex_unlock(&per_pin->lock);
1638 snd_hda_power_down(codec); 1634 snd_hda_power_down_pm(codec);
1639 return ret; 1635 return ret;
1640} 1636}
1641 1637
@@ -1731,7 +1727,7 @@ static int hdmi_parse_codec(struct hda_codec *codec)
1731 hda_nid_t nid; 1727 hda_nid_t nid;
1732 int i, nodes; 1728 int i, nodes;
1733 1729
1734 nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid); 1730 nodes = snd_hda_get_sub_nodes(codec, codec->core.afg, &nid);
1735 if (!nid || nodes < 0) { 1731 if (!nid || nodes < 0) {
1736 codec_warn(codec, "HDMI: failed to get afg sub nodes\n"); 1732 codec_warn(codec, "HDMI: failed to get afg sub nodes\n");
1737 return -EINVAL; 1733 return -EINVAL;
@@ -2056,11 +2052,10 @@ static int generic_hdmi_build_pcms(struct hda_codec *codec)
2056 struct hdmi_spec_per_pin *per_pin; 2052 struct hdmi_spec_per_pin *per_pin;
2057 2053
2058 per_pin = get_pin(spec, pin_idx); 2054 per_pin = get_pin(spec, pin_idx);
2059 sprintf(per_pin->pcm_name, "HDMI %d", pin_idx); 2055 info = snd_hda_codec_pcm_new(codec, "HDMI %d", pin_idx);
2060 info = snd_array_new(&spec->pcm_rec);
2061 if (!info) 2056 if (!info)
2062 return -ENOMEM; 2057 return -ENOMEM;
2063 info->name = per_pin->pcm_name; 2058 spec->pcm_rec[pin_idx] = info;
2064 info->pcm_type = HDA_PCM_TYPE_HDMI; 2059 info->pcm_type = HDA_PCM_TYPE_HDMI;
2065 info->own_chmap = true; 2060 info->own_chmap = true;
2066 2061
@@ -2070,9 +2065,6 @@ static int generic_hdmi_build_pcms(struct hda_codec *codec)
2070 /* other pstr fields are set in open */ 2065 /* other pstr fields are set in open */
2071 } 2066 }
2072 2067
2073 codec->num_pcms = spec->num_pins;
2074 codec->pcm_info = spec->pcm_rec.list;
2075
2076 return 0; 2068 return 0;
2077} 2069}
2078 2070
@@ -2125,13 +2117,15 @@ static int generic_hdmi_build_controls(struct hda_codec *codec)
2125 2117
2126 /* add channel maps */ 2118 /* add channel maps */
2127 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) { 2119 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2120 struct hda_pcm *pcm;
2128 struct snd_pcm_chmap *chmap; 2121 struct snd_pcm_chmap *chmap;
2129 struct snd_kcontrol *kctl; 2122 struct snd_kcontrol *kctl;
2130 int i; 2123 int i;
2131 2124
2132 if (!codec->pcm_info[pin_idx].pcm) 2125 pcm = spec->pcm_rec[pin_idx];
2126 if (!pcm || !pcm->pcm)
2133 break; 2127 break;
2134 err = snd_pcm_add_chmap_ctls(codec->pcm_info[pin_idx].pcm, 2128 err = snd_pcm_add_chmap_ctls(pcm->pcm,
2135 SNDRV_PCM_STREAM_PLAYBACK, 2129 SNDRV_PCM_STREAM_PLAYBACK,
2136 NULL, 0, pin_idx, &chmap); 2130 NULL, 0, pin_idx, &chmap);
2137 if (err < 0) 2131 if (err < 0)
@@ -2186,14 +2180,12 @@ static void hdmi_array_init(struct hdmi_spec *spec, int nums)
2186{ 2180{
2187 snd_array_init(&spec->pins, sizeof(struct hdmi_spec_per_pin), nums); 2181 snd_array_init(&spec->pins, sizeof(struct hdmi_spec_per_pin), nums);
2188 snd_array_init(&spec->cvts, sizeof(struct hdmi_spec_per_cvt), nums); 2182 snd_array_init(&spec->cvts, sizeof(struct hdmi_spec_per_cvt), nums);
2189 snd_array_init(&spec->pcm_rec, sizeof(struct hda_pcm), nums);
2190} 2183}
2191 2184
2192static void hdmi_array_free(struct hdmi_spec *spec) 2185static void hdmi_array_free(struct hdmi_spec *spec)
2193{ 2186{
2194 snd_array_free(&spec->pins); 2187 snd_array_free(&spec->pins);
2195 snd_array_free(&spec->cvts); 2188 snd_array_free(&spec->cvts);
2196 snd_array_free(&spec->pcm_rec);
2197} 2189}
2198 2190
2199static void generic_hdmi_free(struct hda_codec *codec) 2191static void generic_hdmi_free(struct hda_codec *codec)
@@ -2204,11 +2196,10 @@ static void generic_hdmi_free(struct hda_codec *codec)
2204 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) { 2196 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2205 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx); 2197 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
2206 2198
2207 cancel_delayed_work(&per_pin->work); 2199 cancel_delayed_work_sync(&per_pin->work);
2208 eld_proc_free(per_pin); 2200 eld_proc_free(per_pin);
2209 } 2201 }
2210 2202
2211 flush_workqueue(codec->bus->workq);
2212 hdmi_array_free(spec); 2203 hdmi_array_free(spec);
2213 kfree(spec); 2204 kfree(spec);
2214} 2205}
@@ -2220,8 +2211,7 @@ static int generic_hdmi_resume(struct hda_codec *codec)
2220 int pin_idx; 2211 int pin_idx;
2221 2212
2222 codec->patch_ops.init(codec); 2213 codec->patch_ops.init(codec);
2223 snd_hda_codec_resume_amp(codec); 2214 regcache_sync(codec->core.regmap);
2224 snd_hda_codec_resume_cache(codec);
2225 2215
2226 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) { 2216 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2227 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx); 2217 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
@@ -2308,6 +2298,7 @@ static void intel_haswell_fixup_enable_dp12(struct hda_codec *codec)
2308 2298
2309 /* enable DP1.2 mode */ 2299 /* enable DP1.2 mode */
2310 vendor_param |= INTEL_EN_DP12; 2300 vendor_param |= INTEL_EN_DP12;
2301 snd_hdac_regmap_add_vendor_verb(&codec->core, INTEL_SET_VENDOR_VERB);
2311 snd_hda_codec_write_cache(codec, INTEL_VENDOR_NID, 0, 2302 snd_hda_codec_write_cache(codec, INTEL_VENDOR_NID, 0,
2312 INTEL_SET_VENDOR_VERB, vendor_param); 2303 INTEL_SET_VENDOR_VERB, vendor_param);
2313} 2304}
@@ -2381,11 +2372,10 @@ static int simple_playback_build_pcms(struct hda_codec *codec)
2381 chans = get_wcaps(codec, per_cvt->cvt_nid); 2372 chans = get_wcaps(codec, per_cvt->cvt_nid);
2382 chans = get_wcaps_channels(chans); 2373 chans = get_wcaps_channels(chans);
2383 2374
2384 info = snd_array_new(&spec->pcm_rec); 2375 info = snd_hda_codec_pcm_new(codec, "HDMI 0");
2385 if (!info) 2376 if (!info)
2386 return -ENOMEM; 2377 return -ENOMEM;
2387 info->name = get_pin(spec, 0)->pcm_name; 2378 spec->pcm_rec[0] = info;
2388 sprintf(info->name, "HDMI 0");
2389 info->pcm_type = HDA_PCM_TYPE_HDMI; 2379 info->pcm_type = HDA_PCM_TYPE_HDMI;
2390 pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK]; 2380 pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
2391 *pstr = spec->pcm_playback; 2381 *pstr = spec->pcm_playback;
@@ -2393,9 +2383,6 @@ static int simple_playback_build_pcms(struct hda_codec *codec)
2393 if (pstr->channels_max <= 2 && chans && chans <= 16) 2383 if (pstr->channels_max <= 2 && chans && chans <= 16)
2394 pstr->channels_max = chans; 2384 pstr->channels_max = chans;
2395 2385
2396 codec->num_pcms = 1;
2397 codec->pcm_info = info;
2398
2399 return 0; 2386 return 0;
2400} 2387}
2401 2388
@@ -2940,7 +2927,8 @@ static int patch_nvhdmi(struct hda_codec *codec)
2940 */ 2927 */
2941 2928
2942#define is_amdhdmi_rev3_or_later(codec) \ 2929#define is_amdhdmi_rev3_or_later(codec) \
2943 ((codec)->vendor_id == 0x1002aa01 && ((codec)->revision_id & 0xff00) >= 0x0300) 2930 ((codec)->core.vendor_id == 0x1002aa01 && \
2931 ((codec)->core.revision_id & 0xff00) >= 0x0300)
2944#define has_amd_full_remap_support(codec) is_amdhdmi_rev3_or_later(codec) 2932#define has_amd_full_remap_support(codec) is_amdhdmi_rev3_or_later(codec)
2945 2933
2946/* ATI/AMD specific HDA pin verbs, see the AMD HDA Verbs specification */ 2934/* ATI/AMD specific HDA pin verbs, see the AMD HDA Verbs specification */
@@ -3301,15 +3289,6 @@ static int patch_via_hdmi(struct hda_codec *codec)
3301} 3289}
3302 3290
3303/* 3291/*
3304 * called from hda_codec.c for generic HDMI support
3305 */
3306int snd_hda_parse_hdmi_codec(struct hda_codec *codec)
3307{
3308 return patch_generic_hdmi(codec);
3309}
3310EXPORT_SYMBOL_GPL(snd_hda_parse_hdmi_codec);
3311
3312/*
3313 * patch entries 3292 * patch entries
3314 */ 3293 */
3315static const struct hda_codec_preset snd_hda_preset_hdmi[] = { 3294static const struct hda_codec_preset snd_hda_preset_hdmi[] = {
@@ -3373,6 +3352,8 @@ static const struct hda_codec_preset snd_hda_preset_hdmi[] = {
3373{ .id = 0x80862882, .name = "Valleyview2 HDMI", .patch = patch_generic_hdmi }, 3352{ .id = 0x80862882, .name = "Valleyview2 HDMI", .patch = patch_generic_hdmi },
3374{ .id = 0x80862883, .name = "Braswell HDMI", .patch = patch_generic_hdmi }, 3353{ .id = 0x80862883, .name = "Braswell HDMI", .patch = patch_generic_hdmi },
3375{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_generic_hdmi }, 3354{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_generic_hdmi },
3355/* special ID for generic HDMI */
3356{ .id = HDA_CODEC_ID_GENERIC_HDMI, .patch = patch_generic_hdmi },
3376{} /* terminator */ 3357{} /* terminator */
3377}; 3358};
3378 3359
@@ -3442,20 +3423,8 @@ MODULE_ALIAS("snd-hda-codec-intelhdmi");
3442MODULE_ALIAS("snd-hda-codec-nvhdmi"); 3423MODULE_ALIAS("snd-hda-codec-nvhdmi");
3443MODULE_ALIAS("snd-hda-codec-atihdmi"); 3424MODULE_ALIAS("snd-hda-codec-atihdmi");
3444 3425
3445static struct hda_codec_preset_list intel_list = { 3426static struct hda_codec_driver hdmi_driver = {
3446 .preset = snd_hda_preset_hdmi, 3427 .preset = snd_hda_preset_hdmi,
3447 .owner = THIS_MODULE,
3448}; 3428};
3449 3429
3450static int __init patch_hdmi_init(void) 3430module_hda_codec_driver(hdmi_driver);
3451{
3452 return snd_hda_add_codec_preset(&intel_list);
3453}
3454
3455static void __exit patch_hdmi_exit(void)
3456{
3457 snd_hda_delete_codec_preset(&intel_list);
3458}
3459
3460module_init(patch_hdmi_init)
3461module_exit(patch_hdmi_exit)
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 3ad85c762400..b26a7189fb3a 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -299,7 +299,7 @@ static void alc_fill_eapd_coef(struct hda_codec *codec)
299 299
300 coef = alc_get_coef0(codec); 300 coef = alc_get_coef0(codec);
301 301
302 switch (codec->vendor_id) { 302 switch (codec->core.vendor_id) {
303 case 0x10ec0262: 303 case 0x10ec0262:
304 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 304 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
305 break; 305 break;
@@ -432,7 +432,7 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
432 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 432 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
433 break; 433 break;
434 case ALC_INIT_DEFAULT: 434 case ALC_INIT_DEFAULT:
435 switch (codec->vendor_id) { 435 switch (codec->core.vendor_id) {
436 case 0x10ec0260: 436 case 0x10ec0260:
437 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 437 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
438 break; 438 break;
@@ -498,18 +498,18 @@ static int alc_auto_parse_customize_define(struct hda_codec *codec)
498 498
499 if (!codec->bus->pci) 499 if (!codec->bus->pci)
500 return -1; 500 return -1;
501 ass = codec->subsystem_id & 0xffff; 501 ass = codec->core.subsystem_id & 0xffff;
502 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 502 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
503 goto do_sku; 503 goto do_sku;
504 504
505 nid = 0x1d; 505 nid = 0x1d;
506 if (codec->vendor_id == 0x10ec0260) 506 if (codec->core.vendor_id == 0x10ec0260)
507 nid = 0x17; 507 nid = 0x17;
508 ass = snd_hda_codec_get_pincfg(codec, nid); 508 ass = snd_hda_codec_get_pincfg(codec, nid);
509 509
510 if (!(ass & 1)) { 510 if (!(ass & 1)) {
511 codec_info(codec, "%s: SKU not ready 0x%08x\n", 511 codec_info(codec, "%s: SKU not ready 0x%08x\n",
512 codec->chip_name, ass); 512 codec->core.chip_name, ass);
513 return -1; 513 return -1;
514 } 514 }
515 515
@@ -585,7 +585,7 @@ static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
585 goto do_sku; 585 goto do_sku;
586 } 586 }
587 587
588 ass = codec->subsystem_id & 0xffff; 588 ass = codec->core.subsystem_id & 0xffff;
589 if (codec->bus->pci && 589 if (codec->bus->pci &&
590 ass != codec->bus->pci->subsystem_device && (ass & 1)) 590 ass != codec->bus->pci->subsystem_device && (ass & 1))
591 goto do_sku; 591 goto do_sku;
@@ -600,7 +600,7 @@ static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
600 * 0 : override 600 * 0 : override
601 */ 601 */
602 nid = 0x1d; 602 nid = 0x1d;
603 if (codec->vendor_id == 0x10ec0260) 603 if (codec->core.vendor_id == 0x10ec0260)
604 nid = 0x17; 604 nid = 0x17;
605 ass = snd_hda_codec_get_pincfg(codec, nid); 605 ass = snd_hda_codec_get_pincfg(codec, nid);
606 codec_dbg(codec, 606 codec_dbg(codec,
@@ -621,7 +621,7 @@ static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
621 return 0; 621 return 0;
622do_sku: 622do_sku:
623 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 623 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
624 ass & 0xffff, codec->vendor_id); 624 ass & 0xffff, codec->core.vendor_id);
625 /* 625 /*
626 * 0 : override 626 * 0 : override
627 * 1 : Swap Jack 627 * 1 : Swap Jack
@@ -799,8 +799,7 @@ static int alc_resume(struct hda_codec *codec)
799 if (!spec->no_depop_delay) 799 if (!spec->no_depop_delay)
800 msleep(150); /* to avoid pop noise */ 800 msleep(150); /* to avoid pop noise */
801 codec->patch_ops.init(codec); 801 codec->patch_ops.init(codec);
802 snd_hda_codec_resume_amp(codec); 802 regcache_sync(codec->core.regmap);
803 snd_hda_codec_resume_cache(codec);
804 hda_call_check_power_status(codec, 0x01); 803 hda_call_check_power_status(codec, 0x01);
805 return 0; 804 return 0;
806} 805}
@@ -826,9 +825,9 @@ static const struct hda_codec_ops alc_patch_ops = {
826/* replace the codec chip_name with the given string */ 825/* replace the codec chip_name with the given string */
827static int alc_codec_rename(struct hda_codec *codec, const char *name) 826static int alc_codec_rename(struct hda_codec *codec, const char *name)
828{ 827{
829 kfree(codec->chip_name); 828 kfree(codec->core.chip_name);
830 codec->chip_name = kstrdup(name, GFP_KERNEL); 829 codec->core.chip_name = kstrdup(name, GFP_KERNEL);
831 if (!codec->chip_name) { 830 if (!codec->core.chip_name) {
832 alc_free(codec); 831 alc_free(codec);
833 return -ENOMEM; 832 return -ENOMEM;
834 } 833 }
@@ -904,7 +903,7 @@ static int alc_codec_rename_from_preset(struct hda_codec *codec)
904 const struct alc_codec_rename_pci_table *q; 903 const struct alc_codec_rename_pci_table *q;
905 904
906 for (p = rename_tbl; p->vendor_id; p++) { 905 for (p = rename_tbl; p->vendor_id; p++) {
907 if (p->vendor_id != codec->vendor_id) 906 if (p->vendor_id != codec->core.vendor_id)
908 continue; 907 continue;
909 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 908 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
910 return alc_codec_rename(codec, p->name); 909 return alc_codec_rename(codec, p->name);
@@ -913,7 +912,7 @@ static int alc_codec_rename_from_preset(struct hda_codec *codec)
913 if (!codec->bus->pci) 912 if (!codec->bus->pci)
914 return 0; 913 return 0;
915 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 914 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
916 if (q->codec_vendor_id != codec->vendor_id) 915 if (q->codec_vendor_id != codec->core.vendor_id)
917 continue; 916 continue;
918 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 917 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
919 continue; 918 continue;
@@ -1785,7 +1784,7 @@ static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1785{ 1784{
1786 unsigned int gpiostate, gpiomask, gpiodir; 1785 unsigned int gpiostate, gpiomask, gpiodir;
1787 1786
1788 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 1787 gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1789 AC_VERB_GET_GPIO_DATA, 0); 1788 AC_VERB_GET_GPIO_DATA, 0);
1790 1789
1791 if (!muted) 1790 if (!muted)
@@ -1793,23 +1792,23 @@ static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1793 else 1792 else
1794 gpiostate &= ~(1 << pin); 1793 gpiostate &= ~(1 << pin);
1795 1794
1796 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 1795 gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1797 AC_VERB_GET_GPIO_MASK, 0); 1796 AC_VERB_GET_GPIO_MASK, 0);
1798 gpiomask |= (1 << pin); 1797 gpiomask |= (1 << pin);
1799 1798
1800 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 1799 gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1801 AC_VERB_GET_GPIO_DIRECTION, 0); 1800 AC_VERB_GET_GPIO_DIRECTION, 0);
1802 gpiodir |= (1 << pin); 1801 gpiodir |= (1 << pin);
1803 1802
1804 1803
1805 snd_hda_codec_write(codec, codec->afg, 0, 1804 snd_hda_codec_write(codec, codec->core.afg, 0,
1806 AC_VERB_SET_GPIO_MASK, gpiomask); 1805 AC_VERB_SET_GPIO_MASK, gpiomask);
1807 snd_hda_codec_write(codec, codec->afg, 0, 1806 snd_hda_codec_write(codec, codec->core.afg, 0,
1808 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 1807 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1809 1808
1810 msleep(1); 1809 msleep(1);
1811 1810
1812 snd_hda_codec_write(codec, codec->afg, 0, 1811 snd_hda_codec_write(codec, codec->core.afg, 0,
1813 AC_VERB_SET_GPIO_DATA, gpiostate); 1812 AC_VERB_SET_GPIO_DATA, gpiostate);
1814} 1813}
1815 1814
@@ -2269,7 +2268,7 @@ static int patch_alc882(struct hda_codec *codec)
2269 2268
2270 spec = codec->spec; 2269 spec = codec->spec;
2271 2270
2272 switch (codec->vendor_id) { 2271 switch (codec->core.vendor_id) {
2273 case 0x10ec0882: 2272 case 0x10ec0882:
2274 case 0x10ec0885: 2273 case 0x10ec0885:
2275 case 0x10ec0900: 2274 case 0x10ec0900:
@@ -2602,53 +2601,12 @@ static int patch_alc268(struct hda_codec *codec)
2602 * ALC269 2601 * ALC269
2603 */ 2602 */
2604 2603
2605static int playback_pcm_open(struct hda_pcm_stream *hinfo,
2606 struct hda_codec *codec,
2607 struct snd_pcm_substream *substream)
2608{
2609 struct hda_gen_spec *spec = codec->spec;
2610 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2611 hinfo);
2612}
2613
2614static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2615 struct hda_codec *codec,
2616 unsigned int stream_tag,
2617 unsigned int format,
2618 struct snd_pcm_substream *substream)
2619{
2620 struct hda_gen_spec *spec = codec->spec;
2621 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2622 stream_tag, format, substream);
2623}
2624
2625static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2626 struct hda_codec *codec,
2627 struct snd_pcm_substream *substream)
2628{
2629 struct hda_gen_spec *spec = codec->spec;
2630 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2631}
2632
2633static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 2604static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2634 .substreams = 1,
2635 .channels_min = 2,
2636 .channels_max = 8,
2637 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2605 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2638 /* NID is set in alc_build_pcms */
2639 .ops = {
2640 .open = playback_pcm_open,
2641 .prepare = playback_pcm_prepare,
2642 .cleanup = playback_pcm_cleanup
2643 },
2644}; 2606};
2645 2607
2646static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 2608static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2647 .substreams = 1,
2648 .channels_min = 2,
2649 .channels_max = 2,
2650 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2609 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2651 /* NID is set in alc_build_pcms */
2652}; 2610};
2653 2611
2654/* different alc269-variants */ 2612/* different alc269-variants */
@@ -3101,8 +3059,7 @@ static int alc269_resume(struct hda_codec *codec)
3101 msleep(200); 3059 msleep(200);
3102 } 3060 }
3103 3061
3104 snd_hda_codec_resume_amp(codec); 3062 regcache_sync(codec->core.regmap);
3105 snd_hda_codec_resume_cache(codec);
3106 hda_call_check_power_status(codec, 0x01); 3063 hda_call_check_power_status(codec, 0x01);
3107 3064
3108 /* on some machine, the BIOS will clear the codec gpio data when enter 3065 /* on some machine, the BIOS will clear the codec gpio data when enter
@@ -3110,7 +3067,7 @@ static int alc269_resume(struct hda_codec *codec)
3110 * in the driver. 3067 * in the driver.
3111 */ 3068 */
3112 if (spec->gpio_led) 3069 if (spec->gpio_led)
3113 snd_hda_codec_write(codec, codec->afg, 0, AC_VERB_SET_GPIO_DATA, 3070 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3114 spec->gpio_led); 3071 spec->gpio_led);
3115 3072
3116 if (spec->has_alc5505_dsp) 3073 if (spec->has_alc5505_dsp)
@@ -3155,8 +3112,8 @@ static void alc271_fixup_dmic(struct hda_codec *codec,
3155 }; 3112 };
3156 unsigned int cfg; 3113 unsigned int cfg;
3157 3114
3158 if (strcmp(codec->chip_name, "ALC271X") && 3115 if (strcmp(codec->core.chip_name, "ALC271X") &&
3159 strcmp(codec->chip_name, "ALC269VB")) 3116 strcmp(codec->core.chip_name, "ALC269VB"))
3160 return; 3117 return;
3161 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 3118 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3162 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 3119 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
@@ -3266,7 +3223,7 @@ static unsigned int led_power_filter(struct hda_codec *codec,
3266 snd_hda_set_pin_ctl(codec, nid, 3223 snd_hda_set_pin_ctl(codec, nid,
3267 snd_hda_codec_get_pin_target(codec, nid)); 3224 snd_hda_codec_get_pin_target(codec, nid));
3268 3225
3269 return AC_PWRST_D0; 3226 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3270} 3227}
3271 3228
3272static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 3229static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
@@ -3522,9 +3479,9 @@ static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
3522 } 3479 }
3523 3480
3524 snd_hda_add_verbs(codec, gpio_init); 3481 snd_hda_add_verbs(codec, gpio_init);
3525 snd_hda_codec_write_cache(codec, codec->afg, 0, 3482 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3526 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 3483 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3527 snd_hda_jack_detect_enable_callback(codec, codec->afg, 3484 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3528 gpio2_mic_hotkey_event); 3485 gpio2_mic_hotkey_event);
3529 3486
3530 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3487 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
@@ -3585,6 +3542,14 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec)
3585 WRITE_COEF(0x32, 0x42a3), 3542 WRITE_COEF(0x32, 0x42a3),
3586 {} 3543 {}
3587 }; 3544 };
3545 static struct coef_fw coef0288[] = {
3546 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3547 UPDATE_COEF(0x50, 0x2000, 0x2000),
3548 UPDATE_COEF(0x56, 0x0006, 0x0006),
3549 UPDATE_COEF(0x66, 0x0008, 0),
3550 UPDATE_COEF(0x67, 0x2000, 0),
3551 {}
3552 };
3588 static struct coef_fw coef0292[] = { 3553 static struct coef_fw coef0292[] = {
3589 WRITE_COEF(0x76, 0x000e), 3554 WRITE_COEF(0x76, 0x000e),
3590 WRITE_COEF(0x6c, 0x2400), 3555 WRITE_COEF(0x6c, 0x2400),
@@ -3607,7 +3572,7 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec)
3607 {} 3572 {}
3608 }; 3573 };
3609 3574
3610 switch (codec->vendor_id) { 3575 switch (codec->core.vendor_id) {
3611 case 0x10ec0255: 3576 case 0x10ec0255:
3612 case 0x10ec0256: 3577 case 0x10ec0256:
3613 alc_process_coef_fw(codec, coef0255); 3578 alc_process_coef_fw(codec, coef0255);
@@ -3616,6 +3581,10 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec)
3616 case 0x10ec0283: 3581 case 0x10ec0283:
3617 alc_process_coef_fw(codec, coef0233); 3582 alc_process_coef_fw(codec, coef0233);
3618 break; 3583 break;
3584 case 0x10ec0286:
3585 case 0x10ec0288:
3586 alc_process_coef_fw(codec, coef0288);
3587 break;
3619 case 0x10ec0292: 3588 case 0x10ec0292:
3620 alc_process_coef_fw(codec, coef0292); 3589 alc_process_coef_fw(codec, coef0292);
3621 break; 3590 break;
@@ -3645,6 +3614,14 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3645 WRITE_COEF(0x26, 0x008c), 3614 WRITE_COEF(0x26, 0x008c),
3646 {} 3615 {}
3647 }; 3616 };
3617 static struct coef_fw coef0288[] = {
3618 UPDATE_COEF(0x50, 0x2000, 0),
3619 UPDATE_COEF(0x56, 0x0006, 0),
3620 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3621 UPDATE_COEF(0x66, 0x0008, 0x0008),
3622 UPDATE_COEF(0x67, 0x2000, 0x2000),
3623 {}
3624 };
3648 static struct coef_fw coef0292[] = { 3625 static struct coef_fw coef0292[] = {
3649 WRITE_COEF(0x19, 0xa208), 3626 WRITE_COEF(0x19, 0xa208),
3650 WRITE_COEF(0x2e, 0xacf0), 3627 WRITE_COEF(0x2e, 0xacf0),
@@ -3663,7 +3640,7 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3663 {} 3640 {}
3664 }; 3641 };
3665 3642
3666 switch (codec->vendor_id) { 3643 switch (codec->core.vendor_id) {
3667 case 0x10ec0255: 3644 case 0x10ec0255:
3668 case 0x10ec0256: 3645 case 0x10ec0256:
3669 alc_write_coef_idx(codec, 0x45, 0xc489); 3646 alc_write_coef_idx(codec, 0x45, 0xc489);
@@ -3678,6 +3655,13 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3678 alc_process_coef_fw(codec, coef0233); 3655 alc_process_coef_fw(codec, coef0233);
3679 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3656 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3680 break; 3657 break;
3658 case 0x10ec0286:
3659 case 0x10ec0288:
3660 alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
3661 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3662 alc_process_coef_fw(codec, coef0288);
3663 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3664 break;
3681 case 0x10ec0292: 3665 case 0x10ec0292:
3682 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3666 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3683 alc_process_coef_fw(codec, coef0292); 3667 alc_process_coef_fw(codec, coef0292);
@@ -3713,6 +3697,14 @@ static void alc_headset_mode_default(struct hda_codec *codec)
3713 WRITE_COEF(0x32, 0x4ea3), 3697 WRITE_COEF(0x32, 0x4ea3),
3714 {} 3698 {}
3715 }; 3699 };
3700 static struct coef_fw coef0288[] = {
3701 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
3702 UPDATE_COEF(0x50, 0x2000, 0x2000),
3703 UPDATE_COEF(0x56, 0x0006, 0x0006),
3704 UPDATE_COEF(0x66, 0x0008, 0),
3705 UPDATE_COEF(0x67, 0x2000, 0),
3706 {}
3707 };
3716 static struct coef_fw coef0292[] = { 3708 static struct coef_fw coef0292[] = {
3717 WRITE_COEF(0x76, 0x000e), 3709 WRITE_COEF(0x76, 0x000e),
3718 WRITE_COEF(0x6c, 0x2400), 3710 WRITE_COEF(0x6c, 0x2400),
@@ -3733,7 +3725,7 @@ static void alc_headset_mode_default(struct hda_codec *codec)
3733 {} 3725 {}
3734 }; 3726 };
3735 3727
3736 switch (codec->vendor_id) { 3728 switch (codec->core.vendor_id) {
3737 case 0x10ec0255: 3729 case 0x10ec0255:
3738 case 0x10ec0256: 3730 case 0x10ec0256:
3739 alc_process_coef_fw(codec, coef0255); 3731 alc_process_coef_fw(codec, coef0255);
@@ -3742,6 +3734,11 @@ static void alc_headset_mode_default(struct hda_codec *codec)
3742 case 0x10ec0283: 3734 case 0x10ec0283:
3743 alc_process_coef_fw(codec, coef0233); 3735 alc_process_coef_fw(codec, coef0233);
3744 break; 3736 break;
3737 case 0x10ec0286:
3738 case 0x10ec0288:
3739 alc_process_coef_fw(codec, coef0288);
3740 break;
3741 break;
3745 case 0x10ec0292: 3742 case 0x10ec0292:
3746 alc_process_coef_fw(codec, coef0292); 3743 alc_process_coef_fw(codec, coef0292);
3747 break; 3744 break;
@@ -3770,6 +3767,13 @@ static void alc_headset_mode_ctia(struct hda_codec *codec)
3770 WRITE_COEF(0x32, 0x4ea3), 3767 WRITE_COEF(0x32, 0x4ea3),
3771 {} 3768 {}
3772 }; 3769 };
3770 static struct coef_fw coef0288[] = {
3771 UPDATE_COEF(0x50, 0x2000, 0x2000),
3772 UPDATE_COEF(0x56, 0x0006, 0x0006),
3773 UPDATE_COEF(0x66, 0x0008, 0),
3774 UPDATE_COEF(0x67, 0x2000, 0),
3775 {}
3776 };
3773 static struct coef_fw coef0292[] = { 3777 static struct coef_fw coef0292[] = {
3774 WRITE_COEF(0x6b, 0xd429), 3778 WRITE_COEF(0x6b, 0xd429),
3775 WRITE_COEF(0x76, 0x0008), 3779 WRITE_COEF(0x76, 0x0008),
@@ -3788,7 +3792,7 @@ static void alc_headset_mode_ctia(struct hda_codec *codec)
3788 {} 3792 {}
3789 }; 3793 };
3790 3794
3791 switch (codec->vendor_id) { 3795 switch (codec->core.vendor_id) {
3792 case 0x10ec0255: 3796 case 0x10ec0255:
3793 case 0x10ec0256: 3797 case 0x10ec0256:
3794 alc_process_coef_fw(codec, coef0255); 3798 alc_process_coef_fw(codec, coef0255);
@@ -3797,6 +3801,12 @@ static void alc_headset_mode_ctia(struct hda_codec *codec)
3797 case 0x10ec0283: 3801 case 0x10ec0283:
3798 alc_process_coef_fw(codec, coef0233); 3802 alc_process_coef_fw(codec, coef0233);
3799 break; 3803 break;
3804 case 0x10ec0286:
3805 case 0x10ec0288:
3806 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
3807 msleep(300);
3808 alc_process_coef_fw(codec, coef0288);
3809 break;
3800 case 0x10ec0292: 3810 case 0x10ec0292:
3801 alc_process_coef_fw(codec, coef0292); 3811 alc_process_coef_fw(codec, coef0292);
3802 break; 3812 break;
@@ -3825,6 +3835,13 @@ static void alc_headset_mode_omtp(struct hda_codec *codec)
3825 WRITE_COEF(0x32, 0x4ea3), 3835 WRITE_COEF(0x32, 0x4ea3),
3826 {} 3836 {}
3827 }; 3837 };
3838 static struct coef_fw coef0288[] = {
3839 UPDATE_COEF(0x50, 0x2000, 0x2000),
3840 UPDATE_COEF(0x56, 0x0006, 0x0006),
3841 UPDATE_COEF(0x66, 0x0008, 0),
3842 UPDATE_COEF(0x67, 0x2000, 0),
3843 {}
3844 };
3828 static struct coef_fw coef0292[] = { 3845 static struct coef_fw coef0292[] = {
3829 WRITE_COEF(0x6b, 0xe429), 3846 WRITE_COEF(0x6b, 0xe429),
3830 WRITE_COEF(0x76, 0x0008), 3847 WRITE_COEF(0x76, 0x0008),
@@ -3843,7 +3860,7 @@ static void alc_headset_mode_omtp(struct hda_codec *codec)
3843 {} 3860 {}
3844 }; 3861 };
3845 3862
3846 switch (codec->vendor_id) { 3863 switch (codec->core.vendor_id) {
3847 case 0x10ec0255: 3864 case 0x10ec0255:
3848 case 0x10ec0256: 3865 case 0x10ec0256:
3849 alc_process_coef_fw(codec, coef0255); 3866 alc_process_coef_fw(codec, coef0255);
@@ -3852,6 +3869,12 @@ static void alc_headset_mode_omtp(struct hda_codec *codec)
3852 case 0x10ec0283: 3869 case 0x10ec0283:
3853 alc_process_coef_fw(codec, coef0233); 3870 alc_process_coef_fw(codec, coef0233);
3854 break; 3871 break;
3872 case 0x10ec0286:
3873 case 0x10ec0288:
3874 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
3875 msleep(300);
3876 alc_process_coef_fw(codec, coef0288);
3877 break;
3855 case 0x10ec0292: 3878 case 0x10ec0292:
3856 alc_process_coef_fw(codec, coef0292); 3879 alc_process_coef_fw(codec, coef0292);
3857 break; 3880 break;
@@ -3876,6 +3899,10 @@ static void alc_determine_headset_type(struct hda_codec *codec)
3876 conteol) */ 3899 conteol) */
3877 {} 3900 {}
3878 }; 3901 };
3902 static struct coef_fw coef0288[] = {
3903 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
3904 {}
3905 };
3879 static struct coef_fw coef0293[] = { 3906 static struct coef_fw coef0293[] = {
3880 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 3907 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
3881 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 3908 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
@@ -3889,7 +3916,7 @@ static void alc_determine_headset_type(struct hda_codec *codec)
3889 {} 3916 {}
3890 }; 3917 };
3891 3918
3892 switch (codec->vendor_id) { 3919 switch (codec->core.vendor_id) {
3893 case 0x10ec0255: 3920 case 0x10ec0255:
3894 case 0x10ec0256: 3921 case 0x10ec0256:
3895 alc_process_coef_fw(codec, coef0255); 3922 alc_process_coef_fw(codec, coef0255);
@@ -3904,6 +3931,13 @@ static void alc_determine_headset_type(struct hda_codec *codec)
3904 val = alc_read_coef_idx(codec, 0x46); 3931 val = alc_read_coef_idx(codec, 0x46);
3905 is_ctia = (val & 0x0070) == 0x0070; 3932 is_ctia = (val & 0x0070) == 0x0070;
3906 break; 3933 break;
3934 case 0x10ec0286:
3935 case 0x10ec0288:
3936 alc_process_coef_fw(codec, coef0288);
3937 msleep(350);
3938 val = alc_read_coef_idx(codec, 0x50);
3939 is_ctia = (val & 0x0070) == 0x0070;
3940 break;
3907 case 0x10ec0292: 3941 case 0x10ec0292:
3908 alc_write_coef_idx(codec, 0x6b, 0xd429); 3942 alc_write_coef_idx(codec, 0x6b, 0xd429);
3909 msleep(300); 3943 msleep(300);
@@ -4087,6 +4121,29 @@ static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4087 alc_fixup_headset_mode(codec, fix, action); 4121 alc_fixup_headset_mode(codec, fix, action);
4088} 4122}
4089 4123
4124static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4125 struct hda_jack_callback *jack)
4126{
4127 struct alc_spec *spec = codec->spec;
4128 int present;
4129
4130 alc_update_headset_jack_cb(codec, jack);
4131 /* Headset Mic enable or disable, only for Dell Dino */
4132 present = spec->gen.hp_jack_present ? 0x40 : 0;
4133 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4134 present);
4135}
4136
4137static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4138 const struct hda_fixup *fix, int action)
4139{
4140 alc_fixup_headset_mode(codec, fix, action);
4141 if (action == HDA_FIXUP_ACT_PROBE) {
4142 struct alc_spec *spec = codec->spec;
4143 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4144 }
4145}
4146
4090static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 4147static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4091 const struct hda_fixup *fix, int action) 4148 const struct hda_fixup *fix, int action)
4092{ 4149{
@@ -4127,9 +4184,9 @@ static unsigned int alc_power_filter_xps13(struct hda_codec *codec,
4127 4184
4128 /* Avoid pop noises when headphones are plugged in */ 4185 /* Avoid pop noises when headphones are plugged in */
4129 if (spec->gen.hp_jack_present) 4186 if (spec->gen.hp_jack_present)
4130 if (nid == codec->afg || nid == 0x02 || nid == 0x15) 4187 if (nid == codec->core.afg || nid == 0x02 || nid == 0x15)
4131 return AC_PWRST_D0; 4188 return AC_PWRST_D0;
4132 return power_state; 4189 return snd_hda_gen_path_power_filter(codec, nid, power_state);
4133} 4190}
4134 4191
4135static void alc_fixup_dell_xps13(struct hda_codec *codec, 4192static void alc_fixup_dell_xps13(struct hda_codec *codec,
@@ -4427,6 +4484,9 @@ enum {
4427 ALC286_FIXUP_HP_GPIO_LED, 4484 ALC286_FIXUP_HP_GPIO_LED,
4428 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 4485 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
4429 ALC280_FIXUP_HP_DOCK_PINS, 4486 ALC280_FIXUP_HP_DOCK_PINS,
4487 ALC288_FIXUP_DELL_HEADSET_MODE,
4488 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
4489 ALC288_FIXUP_DELL_XPS_13_GPIO6,
4430}; 4490};
4431 4491
4432static const struct hda_fixup alc269_fixups[] = { 4492static const struct hda_fixup alc269_fixups[] = {
@@ -4922,6 +4982,33 @@ static const struct hda_fixup alc269_fixups[] = {
4922 .chained = true, 4982 .chained = true,
4923 .chain_id = ALC280_FIXUP_HP_GPIO4 4983 .chain_id = ALC280_FIXUP_HP_GPIO4
4924 }, 4984 },
4985 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
4986 .type = HDA_FIXUP_FUNC,
4987 .v.func = alc_fixup_headset_mode_dell_alc288,
4988 .chained = true,
4989 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
4990 },
4991 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4992 .type = HDA_FIXUP_PINS,
4993 .v.pins = (const struct hda_pintbl[]) {
4994 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4995 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4996 { }
4997 },
4998 .chained = true,
4999 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
5000 },
5001 [ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
5002 .type = HDA_FIXUP_VERBS,
5003 .v.verbs = (const struct hda_verb[]) {
5004 {0x01, AC_VERB_SET_GPIO_MASK, 0x40},
5005 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
5006 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5007 { }
5008 },
5009 .chained = true,
5010 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
5011 },
4925}; 5012};
4926 5013
4927static const struct snd_pci_quirk alc269_fixup_tbl[] = { 5014static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -5150,6 +5237,13 @@ static const struct hda_model_fixup alc269_fixup_models[] = {
5150 {0x1b, 0x411111f0}, \ 5237 {0x1b, 0x411111f0}, \
5151 {0x1e, 0x411111f0} 5238 {0x1e, 0x411111f0}
5152 5239
5240#define ALC288_STANDARD_PINS \
5241 {0x17, 0x411111f0}, \
5242 {0x18, 0x411111f0}, \
5243 {0x19, 0x411111f0}, \
5244 {0x1a, 0x411111f0}, \
5245 {0x1e, 0x411111f0}
5246
5153#define ALC290_STANDARD_PINS \ 5247#define ALC290_STANDARD_PINS \
5154 {0x12, 0x99a30130}, \ 5248 {0x12, 0x99a30130}, \
5155 {0x13, 0x40000000}, \ 5249 {0x13, 0x40000000}, \
@@ -5345,6 +5439,13 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
5345 {0x19, 0x03a11020}, 5439 {0x19, 0x03a11020},
5346 {0x1d, 0x40e00001}, 5440 {0x1d, 0x40e00001},
5347 {0x21, 0x0321101f}), 5441 {0x21, 0x0321101f}),
5442 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
5443 ALC288_STANDARD_PINS,
5444 {0x12, 0x90a60120},
5445 {0x13, 0x40000000},
5446 {0x14, 0x90170110},
5447 {0x1d, 0x4076832d},
5448 {0x21, 0x0321101f}),
5348 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5449 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5349 ALC290_STANDARD_PINS, 5450 ALC290_STANDARD_PINS,
5350 {0x14, 0x411111f0}, 5451 {0x14, 0x411111f0},
@@ -5485,6 +5586,7 @@ static int patch_alc269(struct hda_codec *codec)
5485 5586
5486 spec = codec->spec; 5587 spec = codec->spec;
5487 spec->gen.shared_mic_vref_pin = 0x18; 5588 spec->gen.shared_mic_vref_pin = 0x18;
5589 codec->power_save_node = 1;
5488 5590
5489 snd_hda_pick_fixup(codec, alc269_fixup_models, 5591 snd_hda_pick_fixup(codec, alc269_fixup_models,
5490 alc269_fixup_tbl, alc269_fixups); 5592 alc269_fixup_tbl, alc269_fixups);
@@ -5498,7 +5600,7 @@ static int patch_alc269(struct hda_codec *codec)
5498 if (has_cdefine_beep(codec)) 5600 if (has_cdefine_beep(codec))
5499 spec->gen.beep_nid = 0x01; 5601 spec->gen.beep_nid = 0x01;
5500 5602
5501 switch (codec->vendor_id) { 5603 switch (codec->core.vendor_id) {
5502 case 0x10ec0269: 5604 case 0x10ec0269:
5503 spec->codec_variant = ALC269_TYPE_ALC269VA; 5605 spec->codec_variant = ALC269_TYPE_ALC269VA;
5504 switch (alc_get_coef0(codec) & 0x00f0) { 5606 switch (alc_get_coef0(codec) & 0x00f0) {
@@ -5581,6 +5683,7 @@ static int patch_alc269(struct hda_codec *codec)
5581 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 5683 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5582 5684
5583 codec->patch_ops = alc_patch_ops; 5685 codec->patch_ops = alc_patch_ops;
5686 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5584#ifdef CONFIG_PM 5687#ifdef CONFIG_PM
5585 codec->patch_ops.suspend = alc269_suspend; 5688 codec->patch_ops.suspend = alc269_suspend;
5586 codec->patch_ops.resume = alc269_resume; 5689 codec->patch_ops.resume = alc269_resume;
@@ -5842,9 +5945,9 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
5842 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5945 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5843 const hda_nid_t *ssids; 5946 const hda_nid_t *ssids;
5844 5947
5845 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 || 5948 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
5846 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 || 5949 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
5847 codec->vendor_id == 0x10ec0671) 5950 codec->core.vendor_id == 0x10ec0671)
5848 ssids = alc663_ssids; 5951 ssids = alc663_ssids;
5849 else 5952 else
5850 ssids = alc662_ssids; 5953 ssids = alc662_ssids;
@@ -5879,7 +5982,7 @@ static void alc_fixup_bass_chmap(struct hda_codec *codec,
5879{ 5982{
5880 if (action == HDA_FIXUP_ACT_BUILD) { 5983 if (action == HDA_FIXUP_ACT_BUILD) {
5881 struct alc_spec *spec = codec->spec; 5984 struct alc_spec *spec = codec->spec;
5882 spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps; 5985 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
5883 } 5986 }
5884} 5987}
5885 5988
@@ -5889,7 +5992,7 @@ static unsigned int gpio_led_power_filter(struct hda_codec *codec,
5889 unsigned int power_state) 5992 unsigned int power_state)
5890{ 5993{
5891 struct alc_spec *spec = codec->spec; 5994 struct alc_spec *spec = codec->spec;
5892 if (nid == codec->afg && power_state == AC_PWRST_D3 && spec->gpio_led) 5995 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
5893 return AC_PWRST_D0; 5996 return AC_PWRST_D0;
5894 return power_state; 5997 return power_state;
5895} 5998}
@@ -6387,7 +6490,7 @@ static int patch_alc662(struct hda_codec *codec)
6387 6490
6388 alc_fix_pll_init(codec, 0x20, 0x04, 15); 6491 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6389 6492
6390 switch (codec->vendor_id) { 6493 switch (codec->core.vendor_id) {
6391 case 0x10ec0668: 6494 case 0x10ec0668:
6392 spec->init_hook = alc668_restore_default_value; 6495 spec->init_hook = alc668_restore_default_value;
6393 break; 6496 break;
@@ -6417,7 +6520,7 @@ static int patch_alc662(struct hda_codec *codec)
6417 goto error; 6520 goto error;
6418 6521
6419 if (!spec->gen.no_analog && spec->gen.beep_nid) { 6522 if (!spec->gen.no_analog && spec->gen.beep_nid) {
6420 switch (codec->vendor_id) { 6523 switch (codec->core.vendor_id) {
6421 case 0x10ec0662: 6524 case 0x10ec0662:
6422 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 6525 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6423 break; 6526 break;
@@ -6550,20 +6653,8 @@ MODULE_ALIAS("snd-hda-codec-id:10ec*");
6550MODULE_LICENSE("GPL"); 6653MODULE_LICENSE("GPL");
6551MODULE_DESCRIPTION("Realtek HD-audio codec"); 6654MODULE_DESCRIPTION("Realtek HD-audio codec");
6552 6655
6553static struct hda_codec_preset_list realtek_list = { 6656static struct hda_codec_driver realtek_driver = {
6554 .preset = snd_hda_preset_realtek, 6657 .preset = snd_hda_preset_realtek,
6555 .owner = THIS_MODULE,
6556}; 6658};
6557 6659
6558static int __init patch_realtek_init(void) 6660module_hda_codec_driver(realtek_driver);
6559{
6560 return snd_hda_add_codec_preset(&realtek_list);
6561}
6562
6563static void __exit patch_realtek_exit(void)
6564{
6565 snd_hda_delete_codec_preset(&realtek_list);
6566}
6567
6568module_init(patch_realtek_init)
6569module_exit(patch_realtek_exit)
diff --git a/sound/pci/hda/patch_si3054.c b/sound/pci/hda/patch_si3054.c
index 3208ad69583e..5104bebb2286 100644
--- a/sound/pci/hda/patch_si3054.c
+++ b/sound/pci/hda/patch_si3054.c
@@ -83,7 +83,6 @@
83 83
84struct si3054_spec { 84struct si3054_spec {
85 unsigned international; 85 unsigned international;
86 struct hda_pcm pcm;
87}; 86};
88 87
89 88
@@ -199,15 +198,15 @@ static const struct hda_pcm_stream si3054_pcm = {
199 198
200static int si3054_build_pcms(struct hda_codec *codec) 199static int si3054_build_pcms(struct hda_codec *codec)
201{ 200{
202 struct si3054_spec *spec = codec->spec; 201 struct hda_pcm *info;
203 struct hda_pcm *info = &spec->pcm; 202
204 codec->num_pcms = 1; 203 info = snd_hda_codec_pcm_new(codec, "Si3054 Modem");
205 codec->pcm_info = info; 204 if (!info)
206 info->name = "Si3054 Modem"; 205 return -ENOMEM;
207 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = si3054_pcm; 206 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = si3054_pcm;
208 info->stream[SNDRV_PCM_STREAM_CAPTURE] = si3054_pcm; 207 info->stream[SNDRV_PCM_STREAM_CAPTURE] = si3054_pcm;
209 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = codec->mfg; 208 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = codec->core.mfg;
210 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = codec->mfg; 209 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = codec->core.mfg;
211 info->pcm_type = HDA_PCM_TYPE_MODEM; 210 info->pcm_type = HDA_PCM_TYPE_MODEM;
212 return 0; 211 return 0;
213} 212}
@@ -223,8 +222,12 @@ static int si3054_init(struct hda_codec *codec)
223 unsigned wait_count; 222 unsigned wait_count;
224 u16 val; 223 u16 val;
225 224
225 if (snd_hdac_regmap_add_vendor_verb(&codec->core,
226 SI3054_VERB_WRITE_NODE))
227 return -ENOMEM;
228
226 snd_hda_codec_write(codec, AC_NODE_ROOT, 0, AC_VERB_SET_CODEC_RESET, 0); 229 snd_hda_codec_write(codec, AC_NODE_ROOT, 0, AC_VERB_SET_CODEC_RESET, 0);
227 snd_hda_codec_write(codec, codec->mfg, 0, AC_VERB_SET_STREAM_FORMAT, 0); 230 snd_hda_codec_write(codec, codec->core.mfg, 0, AC_VERB_SET_STREAM_FORMAT, 0);
228 SET_REG(codec, SI3054_LINE_RATE, 9600); 231 SET_REG(codec, SI3054_LINE_RATE, 9600);
229 SET_REG(codec, SI3054_LINE_LEVEL, SI3054_DTAG_MASK|SI3054_ATAG_MASK); 232 SET_REG(codec, SI3054_LINE_LEVEL, SI3054_DTAG_MASK|SI3054_ATAG_MASK);
230 SET_REG(codec, SI3054_EXTENDED_MID, 0); 233 SET_REG(codec, SI3054_EXTENDED_MID, 0);
@@ -319,20 +322,8 @@ MODULE_ALIAS("snd-hda-codec-id:18540018");
319MODULE_LICENSE("GPL"); 322MODULE_LICENSE("GPL");
320MODULE_DESCRIPTION("Si3054 HD-audio modem codec"); 323MODULE_DESCRIPTION("Si3054 HD-audio modem codec");
321 324
322static struct hda_codec_preset_list si3054_list = { 325static struct hda_codec_driver si3054_driver = {
323 .preset = snd_hda_preset_si3054, 326 .preset = snd_hda_preset_si3054,
324 .owner = THIS_MODULE,
325}; 327};
326 328
327static int __init patch_si3054_init(void) 329module_hda_codec_driver(si3054_driver);
328{
329 return snd_hda_add_codec_preset(&si3054_list);
330}
331
332static void __exit patch_si3054_exit(void)
333{
334 snd_hda_delete_codec_preset(&si3054_list);
335}
336
337module_init(patch_si3054_init)
338module_exit(patch_si3054_exit)
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 87eff3173ce9..43c99ce4a520 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -299,32 +299,33 @@ static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
299 unsigned int dir_mask, unsigned int data) 299 unsigned int dir_mask, unsigned int data)
300{ 300{
301 unsigned int gpiostate, gpiomask, gpiodir; 301 unsigned int gpiostate, gpiomask, gpiodir;
302 hda_nid_t fg = codec->core.afg;
302 303
303 codec_dbg(codec, "%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data); 304 codec_dbg(codec, "%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
304 305
305 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 306 gpiostate = snd_hda_codec_read(codec, fg, 0,
306 AC_VERB_GET_GPIO_DATA, 0); 307 AC_VERB_GET_GPIO_DATA, 0);
307 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask); 308 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
308 309
309 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 310 gpiomask = snd_hda_codec_read(codec, fg, 0,
310 AC_VERB_GET_GPIO_MASK, 0); 311 AC_VERB_GET_GPIO_MASK, 0);
311 gpiomask |= mask; 312 gpiomask |= mask;
312 313
313 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 314 gpiodir = snd_hda_codec_read(codec, fg, 0,
314 AC_VERB_GET_GPIO_DIRECTION, 0); 315 AC_VERB_GET_GPIO_DIRECTION, 0);
315 gpiodir |= dir_mask; 316 gpiodir |= dir_mask;
316 317
317 /* Configure GPIOx as CMOS */ 318 /* Configure GPIOx as CMOS */
318 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0); 319 snd_hda_codec_write(codec, fg, 0, 0x7e7, 0);
319 320
320 snd_hda_codec_write(codec, codec->afg, 0, 321 snd_hda_codec_write(codec, fg, 0,
321 AC_VERB_SET_GPIO_MASK, gpiomask); 322 AC_VERB_SET_GPIO_MASK, gpiomask);
322 snd_hda_codec_read(codec, codec->afg, 0, 323 snd_hda_codec_read(codec, fg, 0,
323 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */ 324 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
324 325
325 msleep(1); 326 msleep(1);
326 327
327 snd_hda_codec_read(codec, codec->afg, 0, 328 snd_hda_codec_read(codec, fg, 0,
328 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */ 329 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
329} 330}
330 331
@@ -387,7 +388,7 @@ static unsigned int stac_vref_led_power_filter(struct hda_codec *codec,
387 hda_nid_t nid, 388 hda_nid_t nid,
388 unsigned int power_state) 389 unsigned int power_state)
389{ 390{
390 if (nid == codec->afg && power_state == AC_PWRST_D3) 391 if (nid == codec->core.afg && power_state == AC_PWRST_D3)
391 return AC_PWRST_D1; 392 return AC_PWRST_D1;
392 return snd_hda_gen_path_power_filter(codec, nid, power_state); 393 return snd_hda_gen_path_power_filter(codec, nid, power_state);
393} 394}
@@ -432,7 +433,7 @@ static void stac_update_outputs(struct hda_codec *codec)
432 433
433 if (spec->gpio_mute) 434 if (spec->gpio_mute)
434 spec->gen.master_mute = 435 spec->gen.master_mute =
435 !(snd_hda_codec_read(codec, codec->afg, 0, 436 !(snd_hda_codec_read(codec, codec->core.afg, 0,
436 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute); 437 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
437 438
438 snd_hda_gen_update_outputs(codec); 439 snd_hda_gen_update_outputs(codec);
@@ -476,7 +477,7 @@ static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
476 if (val != spec->power_map_bits) { 477 if (val != spec->power_map_bits) {
477 spec->power_map_bits = val; 478 spec->power_map_bits = val;
478 if (do_write) 479 if (do_write)
479 snd_hda_codec_write(codec, codec->afg, 0, 480 snd_hda_codec_write(codec, codec->core.afg, 0,
480 AC_VERB_IDT_SET_POWER_MAP, val); 481 AC_VERB_IDT_SET_POWER_MAP, val);
481 } 482 }
482} 483}
@@ -508,7 +509,8 @@ static void jack_update_power(struct hda_codec *codec,
508 false); 509 false);
509 } 510 }
510 511
511 snd_hda_codec_write(codec, codec->afg, 0, AC_VERB_IDT_SET_POWER_MAP, 512 snd_hda_codec_write(codec, codec->core.afg, 0,
513 AC_VERB_IDT_SET_POWER_MAP,
512 spec->power_map_bits); 514 spec->power_map_bits);
513} 515}
514 516
@@ -517,10 +519,10 @@ static void stac_vref_event(struct hda_codec *codec,
517{ 519{
518 unsigned int data; 520 unsigned int data;
519 521
520 data = snd_hda_codec_read(codec, codec->afg, 0, 522 data = snd_hda_codec_read(codec, codec->core.afg, 0,
521 AC_VERB_GET_GPIO_DATA, 0); 523 AC_VERB_GET_GPIO_DATA, 0);
522 /* toggle VREF state based on GPIOx status */ 524 /* toggle VREF state based on GPIOx status */
523 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0, 525 snd_hda_codec_write(codec, codec->core.afg, 0, 0x7e0,
524 !!(data & (1 << event->private_data))); 526 !!(data & (1 << event->private_data)));
525} 527}
526 528
@@ -622,7 +624,7 @@ static int stac_aloopback_put(struct snd_kcontrol *kcontrol,
622 /* Only return the bits defined by the shift value of the 624 /* Only return the bits defined by the shift value of the
623 * first two bytes of the mask 625 * first two bytes of the mask
624 */ 626 */
625 dac_mode = snd_hda_codec_read(codec, codec->afg, 0, 627 dac_mode = snd_hda_codec_read(codec, codec->core.afg, 0,
626 kcontrol->private_value & 0xFFFF, 0x0); 628 kcontrol->private_value & 0xFFFF, 0x0);
627 dac_mode >>= spec->aloopback_shift; 629 dac_mode >>= spec->aloopback_shift;
628 630
@@ -634,7 +636,7 @@ static int stac_aloopback_put(struct snd_kcontrol *kcontrol,
634 dac_mode &= ~idx_val; 636 dac_mode &= ~idx_val;
635 } 637 }
636 638
637 snd_hda_codec_write_cache(codec, codec->afg, 0, 639 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
638 kcontrol->private_value >> 16, dac_mode); 640 kcontrol->private_value >> 16, dac_mode);
639 641
640 return 1; 642 return 1;
@@ -658,11 +660,11 @@ static int stac_aloopback_put(struct snd_kcontrol *kcontrol,
658/* check whether it's a HP laptop with a docking port */ 660/* check whether it's a HP laptop with a docking port */
659static bool hp_bnb2011_with_dock(struct hda_codec *codec) 661static bool hp_bnb2011_with_dock(struct hda_codec *codec)
660{ 662{
661 if (codec->vendor_id != 0x111d7605 && 663 if (codec->core.vendor_id != 0x111d7605 &&
662 codec->vendor_id != 0x111d76d1) 664 codec->core.vendor_id != 0x111d76d1)
663 return false; 665 return false;
664 666
665 switch (codec->subsystem_id) { 667 switch (codec->core.subsystem_id) {
666 case 0x103c1618: 668 case 0x103c1618:
667 case 0x103c1619: 669 case 0x103c1619:
668 case 0x103c161a: 670 case 0x103c161a:
@@ -733,7 +735,7 @@ static void set_hp_led_gpio(struct hda_codec *codec)
733 if (spec->gpio_led) 735 if (spec->gpio_led)
734 return; 736 return;
735 737
736 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP); 738 gpio = snd_hda_param_read(codec, codec->core.afg, AC_PAR_GPIO_CAP);
737 gpio &= AC_GPIO_IO_COUNT; 739 gpio &= AC_GPIO_IO_COUNT;
738 if (gpio > 3) 740 if (gpio > 3)
739 spec->gpio_led = 0x08; /* GPIO 3 */ 741 spec->gpio_led = 0x08; /* GPIO 3 */
@@ -777,7 +779,7 @@ static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
777 &spec->gpio_led_polarity, 779 &spec->gpio_led_polarity,
778 &spec->gpio_led) == 2) { 780 &spec->gpio_led) == 2) {
779 unsigned int max_gpio; 781 unsigned int max_gpio;
780 max_gpio = snd_hda_param_read(codec, codec->afg, 782 max_gpio = snd_hda_param_read(codec, codec->core.afg,
781 AC_PAR_GPIO_CAP); 783 AC_PAR_GPIO_CAP);
782 max_gpio &= AC_GPIO_IO_COUNT; 784 max_gpio &= AC_GPIO_IO_COUNT;
783 if (spec->gpio_led < max_gpio) 785 if (spec->gpio_led < max_gpio)
@@ -807,7 +809,7 @@ static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
807 * we statically set the GPIO - if not a B-series system 809 * we statically set the GPIO - if not a B-series system
808 * and default polarity is provided 810 * and default polarity is provided
809 */ 811 */
810 if (!hp_blike_system(codec->subsystem_id) && 812 if (!hp_blike_system(codec->core.subsystem_id) &&
811 (default_polarity == 0 || default_polarity == 1)) { 813 (default_polarity == 0 || default_polarity == 1)) {
812 set_hp_led_gpio(codec); 814 set_hp_led_gpio(codec);
813 spec->gpio_led_polarity = default_polarity; 815 spec->gpio_led_polarity = default_polarity;
@@ -1048,12 +1050,9 @@ static const struct hda_verb stac92hd71bxx_core_init[] = {
1048 {} 1050 {}
1049}; 1051};
1050 1052
1051static const struct hda_verb stac92hd71bxx_unmute_core_init[] = { 1053static const hda_nid_t stac92hd71bxx_unmute_nids[] = {
1052 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */ 1054 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
1053 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1055 0x0f, 0x0a, 0x0d, 0
1054 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1055 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1056 {}
1057}; 1056};
1058 1057
1059static const struct hda_verb stac925x_core_init[] = { 1058static const struct hda_verb stac925x_core_init[] = {
@@ -2132,8 +2131,10 @@ static void stac92hd83xxx_fixup_hp_mic_led(struct hda_codec *codec,
2132 2131
2133 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2132 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2134 spec->mic_mute_led_gpio = 0x08; /* GPIO3 */ 2133 spec->mic_mute_led_gpio = 0x08; /* GPIO3 */
2134#ifdef CONFIG_PM
2135 /* resetting controller clears GPIO, so we need to keep on */ 2135 /* resetting controller clears GPIO, so we need to keep on */
2136 codec->bus->power_keep_link_on = 1; 2136 codec->core.power_caps &= ~AC_PWRST_CLKSTOP;
2137#endif
2137 } 2138 }
2138} 2139}
2139 2140
@@ -3029,9 +3030,9 @@ static void stac92hd71bxx_fixup_hp_m4(struct hda_codec *codec,
3029 return; 3030 return;
3030 3031
3031 /* Enable VREF power saving on GPIO1 detect */ 3032 /* Enable VREF power saving on GPIO1 detect */
3032 snd_hda_codec_write_cache(codec, codec->afg, 0, 3033 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3033 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02); 3034 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
3034 jack = snd_hda_jack_detect_enable_callback(codec, codec->afg, 3035 jack = snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3035 stac_vref_event); 3036 stac_vref_event);
3036 if (!IS_ERR(jack)) 3037 if (!IS_ERR(jack))
3037 jack->private_data = 0x02; 3038 jack->private_data = 0x02;
@@ -3091,7 +3092,7 @@ static void stac92hd71bxx_fixup_hp(struct hda_codec *codec,
3091 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3092 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3092 return; 3093 return;
3093 3094
3094 if (hp_blike_system(codec->subsystem_id)) { 3095 if (hp_blike_system(codec->core.subsystem_id)) {
3095 unsigned int pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f); 3096 unsigned int pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
3096 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT || 3097 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
3097 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER || 3098 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
@@ -3790,7 +3791,7 @@ static void stac927x_fixup_dell_dmic(struct hda_codec *codec,
3790 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3791 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3791 return; 3792 return;
3792 3793
3793 if (codec->subsystem_id != 0x1028022f) { 3794 if (codec->core.subsystem_id != 0x1028022f) {
3794 /* GPIO2 High = Enable EAPD */ 3795 /* GPIO2 High = Enable EAPD */
3795 spec->eapd_mask = spec->gpio_mask = 0x04; 3796 spec->eapd_mask = spec->gpio_mask = 0x04;
3796 spec->gpio_dir = spec->gpio_data = 0x04; 3797 spec->gpio_dir = spec->gpio_data = 0x04;
@@ -4051,9 +4052,9 @@ static void stac9205_fixup_dell_m43(struct hda_codec *codec,
4051 snd_hda_apply_pincfgs(codec, dell_9205_m43_pin_configs); 4052 snd_hda_apply_pincfgs(codec, dell_9205_m43_pin_configs);
4052 4053
4053 /* Enable unsol response for GPIO4/Dock HP connection */ 4054 /* Enable unsol response for GPIO4/Dock HP connection */
4054 snd_hda_codec_write_cache(codec, codec->afg, 0, 4055 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4055 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10); 4056 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
4056 jack = snd_hda_jack_detect_enable_callback(codec, codec->afg, 4057 jack = snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4057 stac_vref_event); 4058 stac_vref_event);
4058 if (!IS_ERR(jack)) 4059 if (!IS_ERR(jack))
4059 jack->private_data = 0x01; 4060 jack->private_data = 0x01;
@@ -4223,6 +4224,12 @@ static int stac_parse_auto_config(struct hda_codec *codec)
4223 if (err < 0) 4224 if (err < 0)
4224 return err; 4225 return err;
4225 4226
4227 if (spec->vref_mute_led_nid) {
4228 err = snd_hda_gen_fix_pin_power(codec, spec->vref_mute_led_nid);
4229 if (err < 0)
4230 return err;
4231 }
4232
4226 /* setup analog beep controls */ 4233 /* setup analog beep controls */
4227 if (spec->anabeep_nid > 0) { 4234 if (spec->anabeep_nid > 0) {
4228 err = stac_auto_create_beep_ctls(codec, 4235 err = stac_auto_create_beep_ctls(codec,
@@ -4259,6 +4266,10 @@ static int stac_parse_auto_config(struct hda_codec *codec)
4259 4266
4260 if (spec->aloopback_ctl && 4267 if (spec->aloopback_ctl &&
4261 snd_hda_get_bool_hint(codec, "loopback") == 1) { 4268 snd_hda_get_bool_hint(codec, "loopback") == 1) {
4269 unsigned int wr_verb =
4270 spec->aloopback_ctl->private_value >> 16;
4271 if (snd_hdac_regmap_add_vendor_verb(&codec->core, wr_verb))
4272 return -ENOMEM;
4262 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, spec->aloopback_ctl)) 4273 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, spec->aloopback_ctl))
4263 return -ENOMEM; 4274 return -ENOMEM;
4264 } 4275 }
@@ -4294,7 +4305,7 @@ static int stac_init(struct hda_codec *codec)
4294 4305
4295 /* sync the power-map */ 4306 /* sync the power-map */
4296 if (spec->num_pwrs) 4307 if (spec->num_pwrs)
4297 snd_hda_codec_write(codec, codec->afg, 0, 4308 snd_hda_codec_write(codec, codec->core.afg, 0,
4298 AC_VERB_IDT_SET_POWER_MAP, 4309 AC_VERB_IDT_SET_POWER_MAP,
4299 spec->power_map_bits); 4310 spec->power_map_bits);
4300 4311
@@ -4330,7 +4341,7 @@ static void stac_shutup(struct hda_codec *codec)
4330static void stac92hd_proc_hook(struct snd_info_buffer *buffer, 4341static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4331 struct hda_codec *codec, hda_nid_t nid) 4342 struct hda_codec *codec, hda_nid_t nid)
4332{ 4343{
4333 if (nid == codec->afg) 4344 if (nid == codec->core.afg)
4334 snd_iprintf(buffer, "Power-Map: 0x%02x\n", 4345 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4335 snd_hda_codec_read(codec, nid, 0, 4346 snd_hda_codec_read(codec, nid, 0,
4336 AC_VERB_IDT_GET_POWER_MAP, 0)); 4347 AC_VERB_IDT_GET_POWER_MAP, 0));
@@ -4341,7 +4352,7 @@ static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4341 unsigned int verb) 4352 unsigned int verb)
4342{ 4353{
4343 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n", 4354 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4344 snd_hda_codec_read(codec, codec->afg, 0, verb, 0)); 4355 snd_hda_codec_read(codec, codec->core.afg, 0, verb, 0));
4345} 4356}
4346 4357
4347/* stac92hd71bxx, stac92hd73xx */ 4358/* stac92hd71bxx, stac92hd73xx */
@@ -4349,21 +4360,21 @@ static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4349 struct hda_codec *codec, hda_nid_t nid) 4360 struct hda_codec *codec, hda_nid_t nid)
4350{ 4361{
4351 stac92hd_proc_hook(buffer, codec, nid); 4362 stac92hd_proc_hook(buffer, codec, nid);
4352 if (nid == codec->afg) 4363 if (nid == codec->core.afg)
4353 analog_loop_proc_hook(buffer, codec, 0xfa0); 4364 analog_loop_proc_hook(buffer, codec, 0xfa0);
4354} 4365}
4355 4366
4356static void stac9205_proc_hook(struct snd_info_buffer *buffer, 4367static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4357 struct hda_codec *codec, hda_nid_t nid) 4368 struct hda_codec *codec, hda_nid_t nid)
4358{ 4369{
4359 if (nid == codec->afg) 4370 if (nid == codec->core.afg)
4360 analog_loop_proc_hook(buffer, codec, 0xfe0); 4371 analog_loop_proc_hook(buffer, codec, 0xfe0);
4361} 4372}
4362 4373
4363static void stac927x_proc_hook(struct snd_info_buffer *buffer, 4374static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4364 struct hda_codec *codec, hda_nid_t nid) 4375 struct hda_codec *codec, hda_nid_t nid)
4365{ 4376{
4366 if (nid == codec->afg) 4377 if (nid == codec->core.afg)
4367 analog_loop_proc_hook(buffer, codec, 0xfeb); 4378 analog_loop_proc_hook(buffer, codec, 0xfeb);
4368} 4379}
4369#else 4380#else
@@ -4392,6 +4403,7 @@ static const struct hda_codec_ops stac_patch_ops = {
4392#ifdef CONFIG_PM 4403#ifdef CONFIG_PM
4393 .suspend = stac_suspend, 4404 .suspend = stac_suspend,
4394#endif 4405#endif
4406 .stream_pm = snd_hda_gen_stream_pm,
4395 .reboot_notify = stac_shutup, 4407 .reboot_notify = stac_shutup,
4396}; 4408};
4397 4409
@@ -4485,6 +4497,7 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
4485 return err; 4497 return err;
4486 4498
4487 spec = codec->spec; 4499 spec = codec->spec;
4500 codec->power_save_node = 1;
4488 spec->linear_tone_beep = 0; 4501 spec->linear_tone_beep = 0;
4489 spec->gen.mixer_nid = 0x1d; 4502 spec->gen.mixer_nid = 0x1d;
4490 spec->have_spdif_mux = 1; 4503 spec->have_spdif_mux = 1;
@@ -4587,9 +4600,11 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
4587 if (err < 0) 4600 if (err < 0)
4588 return err; 4601 return err;
4589 4602
4590 codec->epss = 0; /* longer delay needed for D3 */ 4603 /* longer delay needed for D3 */
4604 codec->core.power_caps &= ~AC_PWRST_EPSS;
4591 4605
4592 spec = codec->spec; 4606 spec = codec->spec;
4607 codec->power_save_node = 1;
4593 spec->linear_tone_beep = 0; 4608 spec->linear_tone_beep = 0;
4594 spec->gen.own_eapd_ctl = 1; 4609 spec->gen.own_eapd_ctl = 1;
4595 spec->gen.power_down_unused = 1; 4610 spec->gen.power_down_unused = 1;
@@ -4636,9 +4651,11 @@ static int patch_stac92hd95(struct hda_codec *codec)
4636 if (err < 0) 4651 if (err < 0)
4637 return err; 4652 return err;
4638 4653
4639 codec->epss = 0; /* longer delay needed for D3 */ 4654 /* longer delay needed for D3 */
4655 codec->core.power_caps &= ~AC_PWRST_EPSS;
4640 4656
4641 spec = codec->spec; 4657 spec = codec->spec;
4658 codec->power_save_node = 1;
4642 spec->linear_tone_beep = 0; 4659 spec->linear_tone_beep = 0;
4643 spec->gen.own_eapd_ctl = 1; 4660 spec->gen.own_eapd_ctl = 1;
4644 spec->gen.power_down_unused = 1; 4661 spec->gen.power_down_unused = 1;
@@ -4672,7 +4689,7 @@ static int patch_stac92hd95(struct hda_codec *codec)
4672static int patch_stac92hd71bxx(struct hda_codec *codec) 4689static int patch_stac92hd71bxx(struct hda_codec *codec)
4673{ 4690{
4674 struct sigmatel_spec *spec; 4691 struct sigmatel_spec *spec;
4675 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init; 4692 const hda_nid_t *unmute_nids = stac92hd71bxx_unmute_nids;
4676 int err; 4693 int err;
4677 4694
4678 err = alloc_stac_spec(codec); 4695 err = alloc_stac_spec(codec);
@@ -4680,6 +4697,7 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
4680 return err; 4697 return err;
4681 4698
4682 spec = codec->spec; 4699 spec = codec->spec;
4700 codec->power_save_node = 1;
4683 spec->linear_tone_beep = 0; 4701 spec->linear_tone_beep = 0;
4684 spec->gen.own_eapd_ctl = 1; 4702 spec->gen.own_eapd_ctl = 1;
4685 spec->gen.power_down_unused = 1; 4703 spec->gen.power_down_unused = 1;
@@ -4693,23 +4711,23 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
4693 spec->gpio_dir = 0x01; 4711 spec->gpio_dir = 0x01;
4694 spec->gpio_data = 0x01; 4712 spec->gpio_data = 0x01;
4695 4713
4696 switch (codec->vendor_id) { 4714 switch (codec->core.vendor_id) {
4697 case 0x111d76b6: /* 4 Port without Analog Mixer */ 4715 case 0x111d76b6: /* 4 Port without Analog Mixer */
4698 case 0x111d76b7: 4716 case 0x111d76b7:
4699 unmute_init++; 4717 unmute_nids++;
4700 break; 4718 break;
4701 case 0x111d7608: /* 5 Port with Analog Mixer */ 4719 case 0x111d7608: /* 5 Port with Analog Mixer */
4702 if ((codec->revision_id & 0xf) == 0 || 4720 if ((codec->core.revision_id & 0xf) == 0 ||
4703 (codec->revision_id & 0xf) == 1) 4721 (codec->core.revision_id & 0xf) == 1)
4704 spec->stream_delay = 40; /* 40 milliseconds */ 4722 spec->stream_delay = 40; /* 40 milliseconds */
4705 4723
4706 /* disable VSW */ 4724 /* disable VSW */
4707 unmute_init++; 4725 unmute_nids++;
4708 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); 4726 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
4709 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); 4727 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
4710 break; 4728 break;
4711 case 0x111d7603: /* 6 Port with Analog Mixer */ 4729 case 0x111d7603: /* 6 Port with Analog Mixer */
4712 if ((codec->revision_id & 0xf) == 1) 4730 if ((codec->core.revision_id & 0xf) == 1)
4713 spec->stream_delay = 40; /* 40 milliseconds */ 4731 spec->stream_delay = 40; /* 40 milliseconds */
4714 4732
4715 break; 4733 break;
@@ -4718,8 +4736,12 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
4718 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB) 4736 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB)
4719 snd_hda_add_verbs(codec, stac92hd71bxx_core_init); 4737 snd_hda_add_verbs(codec, stac92hd71bxx_core_init);
4720 4738
4721 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) 4739 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) {
4722 snd_hda_sequence_write_cache(codec, unmute_init); 4740 const hda_nid_t *p;
4741 for (p = unmute_nids; *p; p++)
4742 snd_hda_codec_amp_init_stereo(codec, *p, HDA_INPUT, 0,
4743 0xff, 0x00);
4744 }
4723 4745
4724 spec->aloopback_ctl = &stac92hd71bxx_loopback; 4746 spec->aloopback_ctl = &stac92hd71bxx_loopback;
4725 spec->aloopback_mask = 0x50; 4747 spec->aloopback_mask = 0x50;
@@ -5091,20 +5113,8 @@ MODULE_ALIAS("snd-hda-codec-id:111d*");
5091MODULE_LICENSE("GPL"); 5113MODULE_LICENSE("GPL");
5092MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec"); 5114MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5093 5115
5094static struct hda_codec_preset_list sigmatel_list = { 5116static struct hda_codec_driver sigmatel_driver = {
5095 .preset = snd_hda_preset_sigmatel, 5117 .preset = snd_hda_preset_sigmatel,
5096 .owner = THIS_MODULE,
5097}; 5118};
5098 5119
5099static int __init patch_sigmatel_init(void) 5120module_hda_codec_driver(sigmatel_driver);
5100{
5101 return snd_hda_add_codec_preset(&sigmatel_list);
5102}
5103
5104static void __exit patch_sigmatel_exit(void)
5105{
5106 snd_hda_delete_codec_preset(&sigmatel_list);
5107}
5108
5109module_init(patch_sigmatel_init)
5110module_exit(patch_sigmatel_exit)
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 3de6d3d779c9..31a95cca015d 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -99,7 +99,6 @@ struct via_spec {
99 99
100 /* HP mode source */ 100 /* HP mode source */
101 unsigned int dmic_enabled; 101 unsigned int dmic_enabled;
102 unsigned int no_pin_power_ctl;
103 enum VIA_HDA_CODEC codec_type; 102 enum VIA_HDA_CODEC codec_type;
104 103
105 /* analog low-power control */ 104 /* analog low-power control */
@@ -109,8 +108,7 @@ struct via_spec {
109 int hp_work_active; 108 int hp_work_active;
110 int vt1708_jack_detect; 109 int vt1708_jack_detect;
111 110
112 void (*set_widgets_power_state)(struct hda_codec *codec); 111 unsigned int beep_amp;
113 unsigned int dac_stream_tag[4];
114}; 112};
115 113
116static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec); 114static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
@@ -133,17 +131,18 @@ static struct via_spec *via_new_spec(struct hda_codec *codec)
133 /* VT1708BCE & VT1708S are almost same */ 131 /* VT1708BCE & VT1708S are almost same */
134 if (spec->codec_type == VT1708BCE) 132 if (spec->codec_type == VT1708BCE)
135 spec->codec_type = VT1708S; 133 spec->codec_type = VT1708S;
136 spec->no_pin_power_ctl = 1;
137 spec->gen.indep_hp = 1; 134 spec->gen.indep_hp = 1;
138 spec->gen.keep_eapd_on = 1; 135 spec->gen.keep_eapd_on = 1;
139 spec->gen.pcm_playback_hook = via_playback_pcm_hook; 136 spec->gen.pcm_playback_hook = via_playback_pcm_hook;
140 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO; 137 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
138 codec->power_save_node = 1;
139 spec->gen.power_down_unused = 1;
141 return spec; 140 return spec;
142} 141}
143 142
144static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec) 143static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
145{ 144{
146 u32 vendor_id = codec->vendor_id; 145 u32 vendor_id = codec->core.vendor_id;
147 u16 ven_id = vendor_id >> 16; 146 u16 ven_id = vendor_id >> 16;
148 u16 dev_id = vendor_id & 0xffff; 147 u16 dev_id = vendor_id & 0xffff;
149 enum VIA_HDA_CODEC codec_type; 148 enum VIA_HDA_CODEC codec_type;
@@ -222,98 +221,13 @@ static void vt1708_update_hp_work(struct hda_codec *codec)
222 if (!spec->hp_work_active) { 221 if (!spec->hp_work_active) {
223 codec->jackpoll_interval = msecs_to_jiffies(100); 222 codec->jackpoll_interval = msecs_to_jiffies(100);
224 snd_hda_codec_write(codec, 0x1, 0, 0xf81, 0); 223 snd_hda_codec_write(codec, 0x1, 0, 0xf81, 0);
225 queue_delayed_work(codec->bus->workq, 224 schedule_delayed_work(&codec->jackpoll_work, 0);
226 &codec->jackpoll_work, 0);
227 spec->hp_work_active = true; 225 spec->hp_work_active = true;
228 } 226 }
229 } else if (!hp_detect_with_aa(codec)) 227 } else if (!hp_detect_with_aa(codec))
230 vt1708_stop_hp_work(codec); 228 vt1708_stop_hp_work(codec);
231} 229}
232 230
233static void set_widgets_power_state(struct hda_codec *codec)
234{
235#if 0 /* FIXME: the assumed connections don't match always with the
236 * actual routes by the generic parser, so better to disable
237 * the control for safety.
238 */
239 struct via_spec *spec = codec->spec;
240 if (spec->set_widgets_power_state)
241 spec->set_widgets_power_state(codec);
242#endif
243}
244
245static void update_power_state(struct hda_codec *codec, hda_nid_t nid,
246 unsigned int parm)
247{
248 if (snd_hda_check_power_state(codec, nid, parm))
249 return;
250 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
251}
252
253static void update_conv_power_state(struct hda_codec *codec, hda_nid_t nid,
254 unsigned int parm, unsigned int index)
255{
256 struct via_spec *spec = codec->spec;
257 unsigned int format;
258
259 if (snd_hda_check_power_state(codec, nid, parm))
260 return;
261 format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
262 if (format && (spec->dac_stream_tag[index] != format))
263 spec->dac_stream_tag[index] = format;
264
265 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
266 if (parm == AC_PWRST_D0) {
267 format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
268 if (!format && (spec->dac_stream_tag[index] != format))
269 snd_hda_codec_write(codec, nid, 0,
270 AC_VERB_SET_CHANNEL_STREAMID,
271 spec->dac_stream_tag[index]);
272 }
273}
274
275static bool smart51_enabled(struct hda_codec *codec)
276{
277 struct via_spec *spec = codec->spec;
278 return spec->gen.ext_channel_count > 2;
279}
280
281static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
282{
283 struct via_spec *spec = codec->spec;
284 int i;
285
286 for (i = 0; i < spec->gen.multi_ios; i++)
287 if (spec->gen.multi_io[i].pin == pin)
288 return true;
289 return false;
290}
291
292static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
293 unsigned int *affected_parm)
294{
295 unsigned parm;
296 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
297 unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
298 >> AC_DEFCFG_MISC_SHIFT
299 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
300 struct via_spec *spec = codec->spec;
301 unsigned present = 0;
302
303 no_presence |= spec->no_pin_power_ctl;
304 if (!no_presence)
305 present = snd_hda_jack_detect(codec, nid);
306 if ((smart51_enabled(codec) && is_smart51_pins(codec, nid))
307 || ((no_presence || present)
308 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
309 *affected_parm = AC_PWRST_D0; /* if it's connected */
310 parm = AC_PWRST_D0;
311 } else
312 parm = AC_PWRST_D3;
313
314 update_power_state(codec, nid, parm);
315}
316
317static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol, 231static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
318 struct snd_ctl_elem_info *uinfo) 232 struct snd_ctl_elem_info *uinfo)
319{ 233{
@@ -324,8 +238,7 @@ static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
324 struct snd_ctl_elem_value *ucontrol) 238 struct snd_ctl_elem_value *ucontrol)
325{ 239{
326 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 240 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
327 struct via_spec *spec = codec->spec; 241 ucontrol->value.enumerated.item[0] = codec->power_save_node;
328 ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
329 return 0; 242 return 0;
330} 243}
331 244
@@ -334,12 +247,12 @@ static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
334{ 247{
335 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 248 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
336 struct via_spec *spec = codec->spec; 249 struct via_spec *spec = codec->spec;
337 unsigned int val = !ucontrol->value.enumerated.item[0]; 250 bool val = !!ucontrol->value.enumerated.item[0];
338 251
339 if (val == spec->no_pin_power_ctl) 252 if (val == codec->power_save_node)
340 return 0; 253 return 0;
341 spec->no_pin_power_ctl = val; 254 codec->power_save_node = val;
342 set_widgets_power_state(codec); 255 spec->gen.power_down_unused = val;
343 analog_low_current_mode(codec); 256 analog_low_current_mode(codec);
344 return 1; 257 return 1;
345} 258}
@@ -355,6 +268,59 @@ static const struct snd_kcontrol_new via_pin_power_ctl_enum[] = {
355 {} /* terminator */ 268 {} /* terminator */
356}; 269};
357 270
271#ifdef CONFIG_SND_HDA_INPUT_BEEP
272static inline void set_beep_amp(struct via_spec *spec, hda_nid_t nid,
273 int idx, int dir)
274{
275 spec->gen.beep_nid = nid;
276 spec->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir);
277}
278
279/* additional beep mixers; the actual parameters are overwritten at build */
280static const struct snd_kcontrol_new cxt_beep_mixer[] = {
281 HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
282 HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
283 { } /* end */
284};
285
286/* create beep controls if needed */
287static int add_beep_ctls(struct hda_codec *codec)
288{
289 struct via_spec *spec = codec->spec;
290 int err;
291
292 if (spec->beep_amp) {
293 const struct snd_kcontrol_new *knew;
294 for (knew = cxt_beep_mixer; knew->name; knew++) {
295 struct snd_kcontrol *kctl;
296 kctl = snd_ctl_new1(knew, codec);
297 if (!kctl)
298 return -ENOMEM;
299 kctl->private_value = spec->beep_amp;
300 err = snd_hda_ctl_add(codec, 0, kctl);
301 if (err < 0)
302 return err;
303 }
304 }
305 return 0;
306}
307
308static void auto_parse_beep(struct hda_codec *codec)
309{
310 struct via_spec *spec = codec->spec;
311 hda_nid_t nid;
312
313 for_each_hda_codec_node(nid, codec)
314 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) {
315 set_beep_amp(spec, nid, 0, HDA_OUTPUT);
316 break;
317 }
318}
319#else
320#define set_beep_amp(spec, nid, idx, dir) /* NOP */
321#define add_beep_ctls(codec) 0
322#define auto_parse_beep(codec)
323#endif
358 324
359/* check AA path's mute status */ 325/* check AA path's mute status */
360static bool is_aa_path_mute(struct hda_codec *codec) 326static bool is_aa_path_mute(struct hda_codec *codec)
@@ -384,7 +350,7 @@ static void __analog_low_current_mode(struct hda_codec *codec, bool force)
384 bool enable; 350 bool enable;
385 unsigned int verb, parm; 351 unsigned int verb, parm;
386 352
387 if (spec->no_pin_power_ctl) 353 if (!codec->power_save_node)
388 enable = false; 354 enable = false;
389 else 355 else
390 enable = is_aa_path_mute(codec) && !spec->gen.active_streams; 356 enable = is_aa_path_mute(codec) && !spec->gen.active_streams;
@@ -424,7 +390,7 @@ static void __analog_low_current_mode(struct hda_codec *codec, bool force)
424 return; /* other codecs are not supported */ 390 return; /* other codecs are not supported */
425 } 391 }
426 /* send verb */ 392 /* send verb */
427 snd_hda_codec_write(codec, codec->afg, 0, verb, parm); 393 snd_hda_codec_write(codec, codec->core.afg, 0, verb, parm);
428} 394}
429 395
430static void analog_low_current_mode(struct hda_codec *codec) 396static void analog_low_current_mode(struct hda_codec *codec)
@@ -441,8 +407,11 @@ static int via_build_controls(struct hda_codec *codec)
441 if (err < 0) 407 if (err < 0)
442 return err; 408 return err;
443 409
444 if (spec->set_widgets_power_state) 410 err = add_beep_ctls(codec);
445 spec->mixers[spec->num_mixers++] = via_pin_power_ctl_enum; 411 if (err < 0)
412 return err;
413
414 spec->mixers[spec->num_mixers++] = via_pin_power_ctl_enum;
446 415
447 for (i = 0; i < spec->num_mixers; i++) { 416 for (i = 0; i < spec->num_mixers; i++) {
448 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 417 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
@@ -486,7 +455,6 @@ static int via_suspend(struct hda_codec *codec)
486static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) 455static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
487{ 456{
488 struct via_spec *spec = codec->spec; 457 struct via_spec *spec = codec->spec;
489 set_widgets_power_state(codec);
490 analog_low_current_mode(codec); 458 analog_low_current_mode(codec);
491 vt1708_update_hp_work(codec); 459 vt1708_update_hp_work(codec);
492 return snd_hda_check_amp_list_power(codec, &spec->gen.loopback, nid); 460 return snd_hda_check_amp_list_power(codec, &spec->gen.loopback, nid);
@@ -504,6 +472,7 @@ static const struct hda_codec_ops via_patch_ops = {
504 .init = via_init, 472 .init = via_init,
505 .free = via_free, 473 .free = via_free,
506 .unsol_event = snd_hda_jack_unsol_event, 474 .unsol_event = snd_hda_jack_unsol_event,
475 .stream_pm = snd_hda_gen_stream_pm,
507#ifdef CONFIG_PM 476#ifdef CONFIG_PM
508 .suspend = via_suspend, 477 .suspend = via_suspend,
509 .check_power_status = via_check_power_status, 478 .check_power_status = via_check_power_status,
@@ -574,34 +543,6 @@ static const struct snd_kcontrol_new vt1708_jack_detect_ctl[] = {
574 {} /* terminator */ 543 {} /* terminator */
575}; 544};
576 545
577static void via_jack_powerstate_event(struct hda_codec *codec,
578 struct hda_jack_callback *tbl)
579{
580 set_widgets_power_state(codec);
581}
582
583static void via_set_jack_unsol_events(struct hda_codec *codec)
584{
585 struct via_spec *spec = codec->spec;
586 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
587 hda_nid_t pin;
588 int i;
589
590 for (i = 0; i < cfg->line_outs; i++) {
591 pin = cfg->line_out_pins[i];
592 if (pin && is_jack_detectable(codec, pin))
593 snd_hda_jack_detect_enable_callback(codec, pin,
594 via_jack_powerstate_event);
595 }
596
597 for (i = 0; i < cfg->num_inputs; i++) {
598 pin = cfg->line_out_pins[i];
599 if (pin && is_jack_detectable(codec, pin))
600 snd_hda_jack_detect_enable_callback(codec, pin,
601 via_jack_powerstate_event);
602 }
603}
604
605static const struct badness_table via_main_out_badness = { 546static const struct badness_table via_main_out_badness = {
606 .no_primary_dac = 0x10000, 547 .no_primary_dac = 0x10000,
607 .no_dac = 0x4000, 548 .no_dac = 0x4000,
@@ -631,11 +572,15 @@ static int via_parse_auto_config(struct hda_codec *codec)
631 if (err < 0) 572 if (err < 0)
632 return err; 573 return err;
633 574
575 auto_parse_beep(codec);
576
634 err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg); 577 err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
635 if (err < 0) 578 if (err < 0)
636 return err; 579 return err;
637 580
638 via_set_jack_unsol_events(codec); 581 /* disable widget PM at start for compatibility */
582 codec->power_save_node = 0;
583 spec->gen.power_down_unused = 0;
639 return 0; 584 return 0;
640} 585}
641 586
@@ -648,7 +593,6 @@ static int via_init(struct hda_codec *codec)
648 snd_hda_sequence_write(codec, spec->init_verbs[i]); 593 snd_hda_sequence_write(codec, spec->init_verbs[i]);
649 594
650 /* init power states */ 595 /* init power states */
651 set_widgets_power_state(codec);
652 __analog_low_current_mode(codec, true); 596 __analog_low_current_mode(codec, true);
653 597
654 snd_hda_gen_init(codec); 598 snd_hda_gen_init(codec);
@@ -676,15 +620,17 @@ static int vt1708_build_pcms(struct hda_codec *codec)
676 int i, err; 620 int i, err;
677 621
678 err = snd_hda_gen_build_pcms(codec); 622 err = snd_hda_gen_build_pcms(codec);
679 if (err < 0 || codec->vendor_id != 0x11061708) 623 if (err < 0 || codec->core.vendor_id != 0x11061708)
680 return err; 624 return err;
681 625
682 /* We got noisy outputs on the right channel on VT1708 when 626 /* We got noisy outputs on the right channel on VT1708 when
683 * 24bit samples are used. Until any workaround is found, 627 * 24bit samples are used. Until any workaround is found,
684 * disable the 24bit format, so far. 628 * disable the 24bit format, so far.
685 */ 629 */
686 for (i = 0; i < codec->num_pcms; i++) { 630 for (i = 0; i < ARRAY_SIZE(spec->gen.pcm_rec); i++) {
687 struct hda_pcm *info = &spec->gen.pcm_rec[i]; 631 struct hda_pcm *info = spec->gen.pcm_rec[i];
632 if (!info)
633 continue;
688 if (!info->stream[SNDRV_PCM_STREAM_PLAYBACK].substreams || 634 if (!info->stream[SNDRV_PCM_STREAM_PLAYBACK].substreams ||
689 info->pcm_type != HDA_PCM_TYPE_AUDIO) 635 info->pcm_type != HDA_PCM_TYPE_AUDIO)
690 continue; 636 continue;
@@ -766,78 +712,6 @@ static int patch_vt1709(struct hda_codec *codec)
766 return 0; 712 return 0;
767} 713}
768 714
769static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
770{
771 struct via_spec *spec = codec->spec;
772 int imux_is_smixer;
773 unsigned int parm;
774 int is_8ch = 0;
775 if ((spec->codec_type != VT1708B_4CH) &&
776 (codec->vendor_id != 0x11064397))
777 is_8ch = 1;
778
779 /* SW0 (17h) = stereo mixer */
780 imux_is_smixer =
781 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
782 == ((spec->codec_type == VT1708S) ? 5 : 0));
783 /* inputs */
784 /* PW 1/2/5 (1ah/1bh/1eh) */
785 parm = AC_PWRST_D3;
786 set_pin_power_state(codec, 0x1a, &parm);
787 set_pin_power_state(codec, 0x1b, &parm);
788 set_pin_power_state(codec, 0x1e, &parm);
789 if (imux_is_smixer)
790 parm = AC_PWRST_D0;
791 /* SW0 (17h), AIW 0/1 (13h/14h) */
792 update_power_state(codec, 0x17, parm);
793 update_power_state(codec, 0x13, parm);
794 update_power_state(codec, 0x14, parm);
795
796 /* outputs */
797 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
798 parm = AC_PWRST_D3;
799 set_pin_power_state(codec, 0x19, &parm);
800 if (smart51_enabled(codec))
801 set_pin_power_state(codec, 0x1b, &parm);
802 update_power_state(codec, 0x18, parm);
803 update_power_state(codec, 0x11, parm);
804
805 /* PW6 (22h), SW2 (26h), AOW2 (24h) */
806 if (is_8ch) {
807 parm = AC_PWRST_D3;
808 set_pin_power_state(codec, 0x22, &parm);
809 if (smart51_enabled(codec))
810 set_pin_power_state(codec, 0x1a, &parm);
811 update_power_state(codec, 0x26, parm);
812 update_power_state(codec, 0x24, parm);
813 } else if (codec->vendor_id == 0x11064397) {
814 /* PW7(23h), SW2(27h), AOW2(25h) */
815 parm = AC_PWRST_D3;
816 set_pin_power_state(codec, 0x23, &parm);
817 if (smart51_enabled(codec))
818 set_pin_power_state(codec, 0x1a, &parm);
819 update_power_state(codec, 0x27, parm);
820 update_power_state(codec, 0x25, parm);
821 }
822
823 /* PW 3/4/7 (1ch/1dh/23h) */
824 parm = AC_PWRST_D3;
825 /* force to D0 for internal Speaker */
826 set_pin_power_state(codec, 0x1c, &parm);
827 set_pin_power_state(codec, 0x1d, &parm);
828 if (is_8ch)
829 set_pin_power_state(codec, 0x23, &parm);
830
831 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
832 update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm);
833 update_power_state(codec, 0x10, parm);
834 if (is_8ch) {
835 update_power_state(codec, 0x25, parm);
836 update_power_state(codec, 0x27, parm);
837 } else if (codec->vendor_id == 0x11064397 && spec->gen.indep_hp_enabled)
838 update_power_state(codec, 0x25, parm);
839}
840
841static int patch_vt1708S(struct hda_codec *codec); 715static int patch_vt1708S(struct hda_codec *codec);
842static int patch_vt1708B(struct hda_codec *codec) 716static int patch_vt1708B(struct hda_codec *codec)
843{ 717{
@@ -862,9 +736,6 @@ static int patch_vt1708B(struct hda_codec *codec)
862 } 736 }
863 737
864 codec->patch_ops = via_patch_ops; 738 codec->patch_ops = via_patch_ops;
865
866 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
867
868 return 0; 739 return 0;
869} 740}
870 741
@@ -905,19 +776,19 @@ static int patch_vt1708S(struct hda_codec *codec)
905 776
906 /* correct names for VT1708BCE */ 777 /* correct names for VT1708BCE */
907 if (get_codec_type(codec) == VT1708BCE) { 778 if (get_codec_type(codec) == VT1708BCE) {
908 kfree(codec->chip_name); 779 kfree(codec->core.chip_name);
909 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL); 780 codec->core.chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
910 snprintf(codec->bus->card->mixername, 781 snprintf(codec->card->mixername,
911 sizeof(codec->bus->card->mixername), 782 sizeof(codec->card->mixername),
912 "%s %s", codec->vendor_name, codec->chip_name); 783 "%s %s", codec->core.vendor_name, codec->core.chip_name);
913 } 784 }
914 /* correct names for VT1705 */ 785 /* correct names for VT1705 */
915 if (codec->vendor_id == 0x11064397) { 786 if (codec->core.vendor_id == 0x11064397) {
916 kfree(codec->chip_name); 787 kfree(codec->core.chip_name);
917 codec->chip_name = kstrdup("VT1705", GFP_KERNEL); 788 codec->core.chip_name = kstrdup("VT1705", GFP_KERNEL);
918 snprintf(codec->bus->card->mixername, 789 snprintf(codec->card->mixername,
919 sizeof(codec->bus->card->mixername), 790 sizeof(codec->card->mixername),
920 "%s %s", codec->vendor_name, codec->chip_name); 791 "%s %s", codec->core.vendor_name, codec->core.chip_name);
921 } 792 }
922 793
923 /* automatic parse from the BIOS config */ 794 /* automatic parse from the BIOS config */
@@ -930,8 +801,6 @@ static int patch_vt1708S(struct hda_codec *codec)
930 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs; 801 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
931 802
932 codec->patch_ops = via_patch_ops; 803 codec->patch_ops = via_patch_ops;
933
934 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
935 return 0; 804 return 0;
936} 805}
937 806
@@ -945,36 +814,6 @@ static const struct hda_verb vt1702_init_verbs[] = {
945 { } 814 { }
946}; 815};
947 816
948static void set_widgets_power_state_vt1702(struct hda_codec *codec)
949{
950 int imux_is_smixer =
951 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
952 unsigned int parm;
953 /* inputs */
954 /* PW 1/2/5 (14h/15h/18h) */
955 parm = AC_PWRST_D3;
956 set_pin_power_state(codec, 0x14, &parm);
957 set_pin_power_state(codec, 0x15, &parm);
958 set_pin_power_state(codec, 0x18, &parm);
959 if (imux_is_smixer)
960 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
961 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
962 update_power_state(codec, 0x13, parm);
963 update_power_state(codec, 0x12, parm);
964 update_power_state(codec, 0x1f, parm);
965 update_power_state(codec, 0x20, parm);
966
967 /* outputs */
968 /* PW 3/4 (16h/17h) */
969 parm = AC_PWRST_D3;
970 set_pin_power_state(codec, 0x17, &parm);
971 set_pin_power_state(codec, 0x16, &parm);
972 /* MW0 (1ah), AOW 0/1 (10h/1dh) */
973 update_power_state(codec, 0x1a, imux_is_smixer ? AC_PWRST_D0 : parm);
974 update_power_state(codec, 0x10, parm);
975 update_power_state(codec, 0x1d, parm);
976}
977
978static int patch_vt1702(struct hda_codec *codec) 817static int patch_vt1702(struct hda_codec *codec)
979{ 818{
980 struct via_spec *spec; 819 struct via_spec *spec;
@@ -1004,8 +843,6 @@ static int patch_vt1702(struct hda_codec *codec)
1004 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs; 843 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
1005 844
1006 codec->patch_ops = via_patch_ops; 845 codec->patch_ops = via_patch_ops;
1007
1008 spec->set_widgets_power_state = set_widgets_power_state_vt1702;
1009 return 0; 846 return 0;
1010} 847}
1011 848
@@ -1020,71 +857,6 @@ static const struct hda_verb vt1718S_init_verbs[] = {
1020 { } 857 { }
1021}; 858};
1022 859
1023static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
1024{
1025 struct via_spec *spec = codec->spec;
1026 int imux_is_smixer;
1027 unsigned int parm, parm2;
1028 /* MUX6 (1eh) = stereo mixer */
1029 imux_is_smixer =
1030 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
1031 /* inputs */
1032 /* PW 5/6/7 (29h/2ah/2bh) */
1033 parm = AC_PWRST_D3;
1034 set_pin_power_state(codec, 0x29, &parm);
1035 set_pin_power_state(codec, 0x2a, &parm);
1036 set_pin_power_state(codec, 0x2b, &parm);
1037 if (imux_is_smixer)
1038 parm = AC_PWRST_D0;
1039 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
1040 update_power_state(codec, 0x1e, parm);
1041 update_power_state(codec, 0x1f, parm);
1042 update_power_state(codec, 0x10, parm);
1043 update_power_state(codec, 0x11, parm);
1044
1045 /* outputs */
1046 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
1047 parm = AC_PWRST_D3;
1048 set_pin_power_state(codec, 0x27, &parm);
1049 update_power_state(codec, 0x1a, parm);
1050 parm2 = parm; /* for pin 0x0b */
1051
1052 /* PW2 (26h), AOW2 (ah) */
1053 parm = AC_PWRST_D3;
1054 set_pin_power_state(codec, 0x26, &parm);
1055 if (smart51_enabled(codec))
1056 set_pin_power_state(codec, 0x2b, &parm);
1057 update_power_state(codec, 0xa, parm);
1058
1059 /* PW0 (24h), AOW0 (8h) */
1060 parm = AC_PWRST_D3;
1061 set_pin_power_state(codec, 0x24, &parm);
1062 if (!spec->gen.indep_hp_enabled) /* check for redirected HP */
1063 set_pin_power_state(codec, 0x28, &parm);
1064 update_power_state(codec, 0x8, parm);
1065 if (!spec->gen.indep_hp_enabled && parm2 != AC_PWRST_D3)
1066 parm = parm2;
1067 update_power_state(codec, 0xb, parm);
1068 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
1069 update_power_state(codec, 0x21, imux_is_smixer ? AC_PWRST_D0 : parm);
1070
1071 /* PW1 (25h), AOW1 (9h) */
1072 parm = AC_PWRST_D3;
1073 set_pin_power_state(codec, 0x25, &parm);
1074 if (smart51_enabled(codec))
1075 set_pin_power_state(codec, 0x2a, &parm);
1076 update_power_state(codec, 0x9, parm);
1077
1078 if (spec->gen.indep_hp_enabled) {
1079 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
1080 parm = AC_PWRST_D3;
1081 set_pin_power_state(codec, 0x28, &parm);
1082 update_power_state(codec, 0x1b, parm);
1083 update_power_state(codec, 0x34, parm);
1084 update_power_state(codec, 0xc, parm);
1085 }
1086}
1087
1088/* Add a connection to the primary DAC from AA-mixer for some codecs 860/* Add a connection to the primary DAC from AA-mixer for some codecs
1089 * This isn't listed from the raw info, but the chip has a secret connection. 861 * This isn't listed from the raw info, but the chip has a secret connection.
1090 */ 862 */
@@ -1105,8 +877,7 @@ static int add_secret_dac_path(struct hda_codec *codec)
1105 } 877 }
1106 878
1107 /* find the primary DAC and add to the connection list */ 879 /* find the primary DAC and add to the connection list */
1108 nid = codec->start_nid; 880 for_each_hda_codec_node(nid, codec) {
1109 for (i = 0; i < codec->num_nodes; i++, nid++) {
1110 unsigned int caps = get_wcaps(codec, nid); 881 unsigned int caps = get_wcaps(codec, nid);
1111 if (get_wcaps_type(caps) == AC_WID_AUD_OUT && 882 if (get_wcaps_type(caps) == AC_WID_AUD_OUT &&
1112 !(caps & AC_WCAP_DIGITAL)) { 883 !(caps & AC_WCAP_DIGITAL)) {
@@ -1145,9 +916,6 @@ static int patch_vt1718S(struct hda_codec *codec)
1145 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs; 916 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
1146 917
1147 codec->patch_ops = via_patch_ops; 918 codec->patch_ops = via_patch_ops;
1148
1149 spec->set_widgets_power_state = set_widgets_power_state_vt1718S;
1150
1151 return 0; 919 return 0;
1152} 920}
1153 921
@@ -1187,7 +955,6 @@ static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
1187 snd_hda_codec_write(codec, 0x26, 0, 955 snd_hda_codec_write(codec, 0x26, 0,
1188 AC_VERB_SET_CONNECT_SEL, index); 956 AC_VERB_SET_CONNECT_SEL, index);
1189 spec->dmic_enabled = index; 957 spec->dmic_enabled = index;
1190 set_widgets_power_state(codec);
1191 return 1; 958 return 1;
1192} 959}
1193 960
@@ -1222,95 +989,6 @@ static const struct hda_verb vt1716S_init_verbs[] = {
1222 { } 989 { }
1223}; 990};
1224 991
1225static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
1226{
1227 struct via_spec *spec = codec->spec;
1228 int imux_is_smixer;
1229 unsigned int parm;
1230 unsigned int mono_out, present;
1231 /* SW0 (17h) = stereo mixer */
1232 imux_is_smixer =
1233 (snd_hda_codec_read(codec, 0x17, 0,
1234 AC_VERB_GET_CONNECT_SEL, 0x00) == 5);
1235 /* inputs */
1236 /* PW 1/2/5 (1ah/1bh/1eh) */
1237 parm = AC_PWRST_D3;
1238 set_pin_power_state(codec, 0x1a, &parm);
1239 set_pin_power_state(codec, 0x1b, &parm);
1240 set_pin_power_state(codec, 0x1e, &parm);
1241 if (imux_is_smixer)
1242 parm = AC_PWRST_D0;
1243 /* SW0 (17h), AIW0(13h) */
1244 update_power_state(codec, 0x17, parm);
1245 update_power_state(codec, 0x13, parm);
1246
1247 parm = AC_PWRST_D3;
1248 set_pin_power_state(codec, 0x1e, &parm);
1249 /* PW11 (22h) */
1250 if (spec->dmic_enabled)
1251 set_pin_power_state(codec, 0x22, &parm);
1252 else
1253 update_power_state(codec, 0x22, AC_PWRST_D3);
1254
1255 /* SW2(26h), AIW1(14h) */
1256 update_power_state(codec, 0x26, parm);
1257 update_power_state(codec, 0x14, parm);
1258
1259 /* outputs */
1260 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
1261 parm = AC_PWRST_D3;
1262 set_pin_power_state(codec, 0x19, &parm);
1263 /* Smart 5.1 PW2(1bh) */
1264 if (smart51_enabled(codec))
1265 set_pin_power_state(codec, 0x1b, &parm);
1266 update_power_state(codec, 0x18, parm);
1267 update_power_state(codec, 0x11, parm);
1268
1269 /* PW7 (23h), SW3 (27h), AOW3 (25h) */
1270 parm = AC_PWRST_D3;
1271 set_pin_power_state(codec, 0x23, &parm);
1272 /* Smart 5.1 PW1(1ah) */
1273 if (smart51_enabled(codec))
1274 set_pin_power_state(codec, 0x1a, &parm);
1275 update_power_state(codec, 0x27, parm);
1276
1277 /* Smart 5.1 PW5(1eh) */
1278 if (smart51_enabled(codec))
1279 set_pin_power_state(codec, 0x1e, &parm);
1280 update_power_state(codec, 0x25, parm);
1281
1282 /* Mono out */
1283 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
1284 present = snd_hda_jack_detect(codec, 0x1c);
1285
1286 if (present)
1287 mono_out = 0;
1288 else {
1289 present = snd_hda_jack_detect(codec, 0x1d);
1290 if (!spec->gen.indep_hp_enabled && present)
1291 mono_out = 0;
1292 else
1293 mono_out = 1;
1294 }
1295 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
1296 update_power_state(codec, 0x28, parm);
1297 update_power_state(codec, 0x29, parm);
1298 update_power_state(codec, 0x2a, parm);
1299
1300 /* PW 3/4 (1ch/1dh) */
1301 parm = AC_PWRST_D3;
1302 set_pin_power_state(codec, 0x1c, &parm);
1303 set_pin_power_state(codec, 0x1d, &parm);
1304 /* HP Independent Mode, power on AOW3 */
1305 if (spec->gen.indep_hp_enabled)
1306 update_power_state(codec, 0x25, parm);
1307
1308 /* force to D0 for internal Speaker */
1309 /* MW0 (16h), AOW0 (10h) */
1310 update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm);
1311 update_power_state(codec, 0x10, mono_out ? AC_PWRST_D0 : parm);
1312}
1313
1314static int patch_vt1716S(struct hda_codec *codec) 992static int patch_vt1716S(struct hda_codec *codec)
1315{ 993{
1316 struct via_spec *spec; 994 struct via_spec *spec;
@@ -1338,8 +1016,6 @@ static int patch_vt1716S(struct hda_codec *codec)
1338 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer; 1016 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
1339 1017
1340 codec->patch_ops = via_patch_ops; 1018 codec->patch_ops = via_patch_ops;
1341
1342 spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
1343 return 0; 1019 return 0;
1344} 1020}
1345 1021
@@ -1365,98 +1041,6 @@ static const struct hda_verb vt1802_init_verbs[] = {
1365 { } 1041 { }
1366}; 1042};
1367 1043
1368static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
1369{
1370 struct via_spec *spec = codec->spec;
1371 int imux_is_smixer;
1372 unsigned int parm;
1373 unsigned int present;
1374 /* MUX9 (1eh) = stereo mixer */
1375 imux_is_smixer =
1376 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
1377 /* inputs */
1378 /* PW 5/6/7 (29h/2ah/2bh) */
1379 parm = AC_PWRST_D3;
1380 set_pin_power_state(codec, 0x29, &parm);
1381 set_pin_power_state(codec, 0x2a, &parm);
1382 set_pin_power_state(codec, 0x2b, &parm);
1383 parm = AC_PWRST_D0;
1384 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
1385 update_power_state(codec, 0x1e, parm);
1386 update_power_state(codec, 0x1f, parm);
1387 update_power_state(codec, 0x10, parm);
1388 update_power_state(codec, 0x11, parm);
1389
1390 /* outputs */
1391 /* AOW0 (8h)*/
1392 update_power_state(codec, 0x8, parm);
1393
1394 if (spec->codec_type == VT1802) {
1395 /* PW4 (28h), MW4 (18h), MUX4(38h) */
1396 parm = AC_PWRST_D3;
1397 set_pin_power_state(codec, 0x28, &parm);
1398 update_power_state(codec, 0x18, parm);
1399 update_power_state(codec, 0x38, parm);
1400 } else {
1401 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
1402 parm = AC_PWRST_D3;
1403 set_pin_power_state(codec, 0x26, &parm);
1404 update_power_state(codec, 0x1c, parm);
1405 update_power_state(codec, 0x37, parm);
1406 }
1407
1408 if (spec->codec_type == VT1802) {
1409 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
1410 parm = AC_PWRST_D3;
1411 set_pin_power_state(codec, 0x25, &parm);
1412 update_power_state(codec, 0x15, parm);
1413 update_power_state(codec, 0x35, parm);
1414 } else {
1415 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
1416 parm = AC_PWRST_D3;
1417 set_pin_power_state(codec, 0x25, &parm);
1418 update_power_state(codec, 0x19, parm);
1419 update_power_state(codec, 0x35, parm);
1420 }
1421
1422 if (spec->gen.indep_hp_enabled)
1423 update_power_state(codec, 0x9, AC_PWRST_D0);
1424
1425 /* Class-D */
1426 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
1427 present = snd_hda_jack_detect(codec, 0x25);
1428
1429 parm = AC_PWRST_D3;
1430 set_pin_power_state(codec, 0x24, &parm);
1431 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
1432 if (spec->codec_type == VT1802)
1433 update_power_state(codec, 0x14, parm);
1434 else
1435 update_power_state(codec, 0x18, parm);
1436 update_power_state(codec, 0x34, parm);
1437
1438 /* Mono Out */
1439 present = snd_hda_jack_detect(codec, 0x26);
1440
1441 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
1442 if (spec->codec_type == VT1802) {
1443 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
1444 update_power_state(codec, 0x33, parm);
1445 update_power_state(codec, 0x1c, parm);
1446 update_power_state(codec, 0x3c, parm);
1447 } else {
1448 /* PW15 (31h), MW8(17h), MUX8(3bh) */
1449 update_power_state(codec, 0x31, parm);
1450 update_power_state(codec, 0x17, parm);
1451 update_power_state(codec, 0x3b, parm);
1452 }
1453 /* MW9 (21h) */
1454 if (imux_is_smixer || !is_aa_path_mute(codec))
1455 update_power_state(codec, 0x21, AC_PWRST_D0);
1456 else
1457 update_power_state(codec, 0x21, AC_PWRST_D3);
1458}
1459
1460/* 1044/*
1461 * pin fix-up 1045 * pin fix-up
1462 */ 1046 */
@@ -1540,8 +1124,6 @@ static int patch_vt2002P(struct hda_codec *codec)
1540 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs; 1124 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
1541 1125
1542 codec->patch_ops = via_patch_ops; 1126 codec->patch_ops = via_patch_ops;
1543
1544 spec->set_widgets_power_state = set_widgets_power_state_vt2002P;
1545 return 0; 1127 return 0;
1546} 1128}
1547 1129
@@ -1555,81 +1137,6 @@ static const struct hda_verb vt1812_init_verbs[] = {
1555 { } 1137 { }
1556}; 1138};
1557 1139
1558static void set_widgets_power_state_vt1812(struct hda_codec *codec)
1559{
1560 struct via_spec *spec = codec->spec;
1561 unsigned int parm;
1562 unsigned int present;
1563 /* inputs */
1564 /* PW 5/6/7 (29h/2ah/2bh) */
1565 parm = AC_PWRST_D3;
1566 set_pin_power_state(codec, 0x29, &parm);
1567 set_pin_power_state(codec, 0x2a, &parm);
1568 set_pin_power_state(codec, 0x2b, &parm);
1569 parm = AC_PWRST_D0;
1570 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
1571 update_power_state(codec, 0x1e, parm);
1572 update_power_state(codec, 0x1f, parm);
1573 update_power_state(codec, 0x10, parm);
1574 update_power_state(codec, 0x11, parm);
1575
1576 /* outputs */
1577 /* AOW0 (8h)*/
1578 update_power_state(codec, 0x8, AC_PWRST_D0);
1579
1580 /* PW4 (28h), MW4 (18h), MUX4(38h) */
1581 parm = AC_PWRST_D3;
1582 set_pin_power_state(codec, 0x28, &parm);
1583 update_power_state(codec, 0x18, parm);
1584 update_power_state(codec, 0x38, parm);
1585
1586 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
1587 parm = AC_PWRST_D3;
1588 set_pin_power_state(codec, 0x25, &parm);
1589 update_power_state(codec, 0x15, parm);
1590 update_power_state(codec, 0x35, parm);
1591 if (spec->gen.indep_hp_enabled)
1592 update_power_state(codec, 0x9, AC_PWRST_D0);
1593
1594 /* Internal Speaker */
1595 /* PW0 (24h), MW0(14h), MUX0(34h) */
1596 present = snd_hda_jack_detect(codec, 0x25);
1597
1598 parm = AC_PWRST_D3;
1599 set_pin_power_state(codec, 0x24, &parm);
1600 if (present) {
1601 update_power_state(codec, 0x14, AC_PWRST_D3);
1602 update_power_state(codec, 0x34, AC_PWRST_D3);
1603 } else {
1604 update_power_state(codec, 0x14, AC_PWRST_D0);
1605 update_power_state(codec, 0x34, AC_PWRST_D0);
1606 }
1607
1608
1609 /* Mono Out */
1610 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
1611 present = snd_hda_jack_detect(codec, 0x28);
1612
1613 parm = AC_PWRST_D3;
1614 set_pin_power_state(codec, 0x31, &parm);
1615 if (present) {
1616 update_power_state(codec, 0x1c, AC_PWRST_D3);
1617 update_power_state(codec, 0x3c, AC_PWRST_D3);
1618 update_power_state(codec, 0x3e, AC_PWRST_D3);
1619 } else {
1620 update_power_state(codec, 0x1c, AC_PWRST_D0);
1621 update_power_state(codec, 0x3c, AC_PWRST_D0);
1622 update_power_state(codec, 0x3e, AC_PWRST_D0);
1623 }
1624
1625 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
1626 parm = AC_PWRST_D3;
1627 set_pin_power_state(codec, 0x33, &parm);
1628 update_power_state(codec, 0x1d, parm);
1629 update_power_state(codec, 0x3d, parm);
1630
1631}
1632
1633/* patch for vt1812 */ 1140/* patch for vt1812 */
1634static int patch_vt1812(struct hda_codec *codec) 1141static int patch_vt1812(struct hda_codec *codec)
1635{ 1142{
@@ -1656,8 +1163,6 @@ static int patch_vt1812(struct hda_codec *codec)
1656 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs; 1163 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs;
1657 1164
1658 codec->patch_ops = via_patch_ops; 1165 codec->patch_ops = via_patch_ops;
1659
1660 spec->set_widgets_power_state = set_widgets_power_state_vt1812;
1661 return 0; 1166 return 0;
1662} 1167}
1663 1168
@@ -1673,84 +1178,6 @@ static const struct hda_verb vt3476_init_verbs[] = {
1673 { } 1178 { }
1674}; 1179};
1675 1180
1676static void set_widgets_power_state_vt3476(struct hda_codec *codec)
1677{
1678 struct via_spec *spec = codec->spec;
1679 int imux_is_smixer;
1680 unsigned int parm, parm2;
1681 /* MUX10 (1eh) = stereo mixer */
1682 imux_is_smixer =
1683 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 4;
1684 /* inputs */
1685 /* PW 5/6/7 (29h/2ah/2bh) */
1686 parm = AC_PWRST_D3;
1687 set_pin_power_state(codec, 0x29, &parm);
1688 set_pin_power_state(codec, 0x2a, &parm);
1689 set_pin_power_state(codec, 0x2b, &parm);
1690 if (imux_is_smixer)
1691 parm = AC_PWRST_D0;
1692 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
1693 update_power_state(codec, 0x1e, parm);
1694 update_power_state(codec, 0x1f, parm);
1695 update_power_state(codec, 0x10, parm);
1696 update_power_state(codec, 0x11, parm);
1697
1698 /* outputs */
1699 /* PW3 (27h), MW3(37h), AOW3 (bh) */
1700 if (spec->codec_type == VT1705CF) {
1701 parm = AC_PWRST_D3;
1702 update_power_state(codec, 0x27, parm);
1703 update_power_state(codec, 0x37, parm);
1704 } else {
1705 parm = AC_PWRST_D3;
1706 set_pin_power_state(codec, 0x27, &parm);
1707 update_power_state(codec, 0x37, parm);
1708 }
1709
1710 /* PW2 (26h), MW2(36h), AOW2 (ah) */
1711 parm = AC_PWRST_D3;
1712 set_pin_power_state(codec, 0x26, &parm);
1713 update_power_state(codec, 0x36, parm);
1714 if (smart51_enabled(codec)) {
1715 /* PW7(2bh), MW7(3bh), MUX7(1Bh) */
1716 set_pin_power_state(codec, 0x2b, &parm);
1717 update_power_state(codec, 0x3b, parm);
1718 update_power_state(codec, 0x1b, parm);
1719 }
1720 update_conv_power_state(codec, 0xa, parm, 2);
1721
1722 /* PW1 (25h), MW1(35h), AOW1 (9h) */
1723 parm = AC_PWRST_D3;
1724 set_pin_power_state(codec, 0x25, &parm);
1725 update_power_state(codec, 0x35, parm);
1726 if (smart51_enabled(codec)) {
1727 /* PW6(2ah), MW6(3ah), MUX6(1ah) */
1728 set_pin_power_state(codec, 0x2a, &parm);
1729 update_power_state(codec, 0x3a, parm);
1730 update_power_state(codec, 0x1a, parm);
1731 }
1732 update_conv_power_state(codec, 0x9, parm, 1);
1733
1734 /* PW4 (28h), MW4 (38h), MUX4(18h), AOW3(bh)/AOW0(8h) */
1735 parm = AC_PWRST_D3;
1736 set_pin_power_state(codec, 0x28, &parm);
1737 update_power_state(codec, 0x38, parm);
1738 update_power_state(codec, 0x18, parm);
1739 if (spec->gen.indep_hp_enabled)
1740 update_conv_power_state(codec, 0xb, parm, 3);
1741 parm2 = parm; /* for pin 0x0b */
1742
1743 /* PW0 (24h), MW0(34h), MW9(3fh), AOW0 (8h) */
1744 parm = AC_PWRST_D3;
1745 set_pin_power_state(codec, 0x24, &parm);
1746 update_power_state(codec, 0x34, parm);
1747 if (!spec->gen.indep_hp_enabled && parm2 != AC_PWRST_D3)
1748 parm = parm2;
1749 update_conv_power_state(codec, 0x8, parm, 0);
1750 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
1751 update_power_state(codec, 0x3f, imux_is_smixer ? AC_PWRST_D0 : parm);
1752}
1753
1754static int patch_vt3476(struct hda_codec *codec) 1181static int patch_vt3476(struct hda_codec *codec)
1755{ 1182{
1756 struct via_spec *spec; 1183 struct via_spec *spec;
@@ -1774,9 +1201,6 @@ static int patch_vt3476(struct hda_codec *codec)
1774 spec->init_verbs[spec->num_iverbs++] = vt3476_init_verbs; 1201 spec->init_verbs[spec->num_iverbs++] = vt3476_init_verbs;
1775 1202
1776 codec->patch_ops = via_patch_ops; 1203 codec->patch_ops = via_patch_ops;
1777
1778 spec->set_widgets_power_state = set_widgets_power_state_vt3476;
1779
1780 return 0; 1204 return 0;
1781} 1205}
1782 1206
@@ -1884,23 +1308,11 @@ static const struct hda_codec_preset snd_hda_preset_via[] = {
1884 1308
1885MODULE_ALIAS("snd-hda-codec-id:1106*"); 1309MODULE_ALIAS("snd-hda-codec-id:1106*");
1886 1310
1887static struct hda_codec_preset_list via_list = { 1311static struct hda_codec_driver via_driver = {
1888 .preset = snd_hda_preset_via, 1312 .preset = snd_hda_preset_via,
1889 .owner = THIS_MODULE,
1890}; 1313};
1891 1314
1892MODULE_LICENSE("GPL"); 1315MODULE_LICENSE("GPL");
1893MODULE_DESCRIPTION("VIA HD-audio codec"); 1316MODULE_DESCRIPTION("VIA HD-audio codec");
1894 1317
1895static int __init patch_via_init(void) 1318module_hda_codec_driver(via_driver);
1896{
1897 return snd_hda_add_codec_preset(&via_list);
1898}
1899
1900static void __exit patch_via_exit(void)
1901{
1902 snd_hda_delete_codec_preset(&via_list);
1903}
1904
1905module_init(patch_via_init)
1906module_exit(patch_via_exit)
diff --git a/sound/pci/hda/thinkpad_helper.c b/sound/pci/hda/thinkpad_helper.c
index 6ba0b5517c40..0a4ad5feb82e 100644
--- a/sound/pci/hda/thinkpad_helper.c
+++ b/sound/pci/hda/thinkpad_helper.c
@@ -21,7 +21,7 @@ static acpi_status acpi_check_cb(acpi_handle handle, u32 lvl, void *context,
21static bool is_thinkpad(struct hda_codec *codec) 21static bool is_thinkpad(struct hda_codec *codec)
22{ 22{
23 bool found = false; 23 bool found = false;
24 if (codec->subsystem_id >> 16 != 0x17aa) 24 if (codec->core.subsystem_id >> 16 != 0x17aa)
25 return false; 25 return false;
26 if (ACPI_SUCCESS(acpi_get_devices("LEN0068", acpi_check_cb, &found, NULL)) && found) 26 if (ACPI_SUCCESS(acpi_get_devices("LEN0068", acpi_check_cb, &found, NULL)) && found)
27 return true; 27 return true;
diff --git a/sound/pci/ice1712/wtm.c b/sound/pci/ice1712/wtm.c
index bcf30a387b87..9906119e0954 100644
--- a/sound/pci/ice1712/wtm.c
+++ b/sound/pci/ice1712/wtm.c
@@ -29,12 +29,19 @@
29#include <linux/interrupt.h> 29#include <linux/interrupt.h>
30#include <linux/init.h> 30#include <linux/init.h>
31#include <sound/core.h> 31#include <sound/core.h>
32#include <sound/tlv.h>
33#include <linux/slab.h>
32 34
33#include "ice1712.h" 35#include "ice1712.h"
34#include "envy24ht.h" 36#include "envy24ht.h"
35#include "wtm.h" 37#include "wtm.h"
36#include "stac946x.h" 38#include "stac946x.h"
37 39
40struct wtm_spec {
41 /* rate change needs atomic mute/unmute of all dacs*/
42 struct mutex mute_mutex;
43};
44
38 45
39/* 46/*
40 * 2*ADC 6*DAC no1 ringbuffer r/w on i2c bus 47 * 2*ADC 6*DAC no1 ringbuffer r/w on i2c bus
@@ -68,15 +75,65 @@ static inline unsigned char stac9460_2_get(struct snd_ice1712 *ice, int reg)
68/* 75/*
69 * DAC mute control 76 * DAC mute control
70 */ 77 */
78static void stac9460_dac_mute_all(struct snd_ice1712 *ice, unsigned char mute,
79 unsigned short int *change_mask)
80{
81 unsigned char new, old;
82 int id, idx, change;
83
84 /*stac9460 1*/
85 for (id = 0; id < 7; id++) {
86 if (*change_mask & (0x01 << id)) {
87 if (id == 0)
88 idx = STAC946X_MASTER_VOLUME;
89 else
90 idx = STAC946X_LF_VOLUME - 1 + id;
91 old = stac9460_get(ice, idx);
92 new = (~mute << 7 & 0x80) | (old & ~0x80);
93 change = (new != old);
94 if (change) {
95 stac9460_put(ice, idx, new);
96 *change_mask = *change_mask | (0x01 << id);
97 } else {
98 *change_mask = *change_mask & ~(0x01 << id);
99 }
100 }
101 }
102
103 /*stac9460 2*/
104 for (id = 0; id < 3; id++) {
105 if (*change_mask & (0x01 << (id + 7))) {
106 if (id == 0)
107 idx = STAC946X_MASTER_VOLUME;
108 else
109 idx = STAC946X_LF_VOLUME - 1 + id;
110 old = stac9460_2_get(ice, idx);
111 new = (~mute << 7 & 0x80) | (old & ~0x80);
112 change = (new != old);
113 if (change) {
114 stac9460_2_put(ice, idx, new);
115 *change_mask = *change_mask | (0x01 << id);
116 } else {
117 *change_mask = *change_mask & ~(0x01 << id);
118 }
119 }
120 }
121}
122
123
124
71#define stac9460_dac_mute_info snd_ctl_boolean_mono_info 125#define stac9460_dac_mute_info snd_ctl_boolean_mono_info
72 126
73static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, 127static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol,
74 struct snd_ctl_elem_value *ucontrol) 128 struct snd_ctl_elem_value *ucontrol)
75{ 129{
76 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); 130 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
131 struct wtm_spec *spec = ice->spec;
77 unsigned char val; 132 unsigned char val;
78 int idx, id; 133 int idx, id;
79 134
135 mutex_lock(&spec->mute_mutex);
136
80 if (kcontrol->private_value) { 137 if (kcontrol->private_value) {
81 idx = STAC946X_MASTER_VOLUME; 138 idx = STAC946X_MASTER_VOLUME;
82 id = 0; 139 id = 0;
@@ -89,6 +146,8 @@ static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol,
89 else 146 else
90 val = stac9460_2_get(ice, idx - 6); 147 val = stac9460_2_get(ice, idx - 6);
91 ucontrol->value.integer.value[0] = (~val >> 7) & 0x1; 148 ucontrol->value.integer.value[0] = (~val >> 7) & 0x1;
149
150 mutex_unlock(&spec->mute_mutex);
92 return 0; 151 return 0;
93} 152}
94 153
@@ -338,8 +397,14 @@ static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol,
338/* 397/*
339 * MIC / LINE switch fonction 398 * MIC / LINE switch fonction
340 */ 399 */
400static int stac9460_mic_sw_info(struct snd_kcontrol *kcontrol,
401 struct snd_ctl_elem_info *uinfo)
402{
403 static const char * const texts[2] = { "Line In", "Mic" };
404
405 return snd_ctl_enum_info(uinfo, 1, 2, texts);
406}
341 407
342#define stac9460_mic_sw_info snd_ctl_boolean_mono_info
343 408
344static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol, 409static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
345 struct snd_ctl_elem_value *ucontrol) 410 struct snd_ctl_elem_value *ucontrol)
@@ -353,7 +418,7 @@ static int stac9460_mic_sw_get(struct snd_kcontrol *kcontrol,
353 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); 418 val = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
354 else 419 else
355 val = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); 420 val = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE);
356 ucontrol->value.integer.value[0] = ~val>>7 & 0x1; 421 ucontrol->value.enumerated.item[0] = (val >> 7) & 0x1;
357 return 0; 422 return 0;
358} 423}
359 424
@@ -369,7 +434,7 @@ static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
369 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE); 434 old = stac9460_get(ice, STAC946X_GENERAL_PURPOSE);
370 else 435 else
371 old = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE); 436 old = stac9460_2_get(ice, STAC946X_GENERAL_PURPOSE);
372 new = (~ucontrol->value.integer.value[0] << 7 & 0x80) | (old & ~0x80); 437 new = (ucontrol->value.enumerated.item[0] << 7 & 0x80) | (old & ~0x80);
373 change = (new != old); 438 change = (new != old);
374 if (change) { 439 if (change) {
375 if (id == 0) 440 if (id == 0)
@@ -380,17 +445,63 @@ static int stac9460_mic_sw_put(struct snd_kcontrol *kcontrol,
380 return change; 445 return change;
381} 446}
382 447
448
449/*
450 * Handler for setting correct codec rate - called when rate change is detected
451 */
452static void stac9460_set_rate_val(struct snd_ice1712 *ice, unsigned int rate)
453{
454 unsigned char old, new;
455 unsigned short int changed;
456 struct wtm_spec *spec = ice->spec;
457
458 if (rate == 0) /* no hint - S/PDIF input is master, simply return */
459 return;
460 else if (rate <= 48000)
461 new = 0x08; /* 256x, base rate mode */
462 else if (rate <= 96000)
463 new = 0x11; /* 256x, mid rate mode */
464 else
465 new = 0x12; /* 128x, high rate mode */
466
467 old = stac9460_get(ice, STAC946X_MASTER_CLOCKING);
468 if (old == new)
469 return;
470 /* change detected, setting master clock, muting first */
471 /* due to possible conflicts with mute controls - mutexing */
472 mutex_lock(&spec->mute_mutex);
473 /* we have to remember current mute status for each DAC */
474 changed = 0xFFFF;
475 stac9460_dac_mute_all(ice, 0, &changed);
476 /*printk(KERN_DEBUG "Rate change: %d, new MC: 0x%02x\n", rate, new);*/
477 stac9460_put(ice, STAC946X_MASTER_CLOCKING, new);
478 stac9460_2_put(ice, STAC946X_MASTER_CLOCKING, new);
479 udelay(10);
480 /* unmuting - only originally unmuted dacs -
481 * i.e. those changed when muting */
482 stac9460_dac_mute_all(ice, 1, &changed);
483 mutex_unlock(&spec->mute_mutex);
484}
485
486
487/*Limits value in dB for fader*/
488static const DECLARE_TLV_DB_SCALE(db_scale_dac, -19125, 75, 0);
489static const DECLARE_TLV_DB_SCALE(db_scale_adc, 0, 150, 0);
490
383/* 491/*
384 * Control tabs 492 * Control tabs
385 */ 493 */
386static struct snd_kcontrol_new stac9640_controls[] = { 494static struct snd_kcontrol_new stac9640_controls[] = {
387 { 495 {
388 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 496 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
497 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
498 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
389 .name = "Master Playback Switch", 499 .name = "Master Playback Switch",
390 .info = stac9460_dac_mute_info, 500 .info = stac9460_dac_mute_info,
391 .get = stac9460_dac_mute_get, 501 .get = stac9460_dac_mute_get,
392 .put = stac9460_dac_mute_put, 502 .put = stac9460_dac_mute_put,
393 .private_value = 1 503 .private_value = 1,
504 .tlv = { .p = db_scale_dac }
394 }, 505 },
395 { 506 {
396 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 507 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -402,7 +513,7 @@ static struct snd_kcontrol_new stac9640_controls[] = {
402 }, 513 },
403 { 514 {
404 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 515 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
405 .name = "MIC/Line switch", 516 .name = "MIC/Line Input Enum",
406 .count = 2, 517 .count = 2,
407 .info = stac9460_mic_sw_info, 518 .info = stac9460_mic_sw_info,
408 .get = stac9460_mic_sw_get, 519 .get = stac9460_mic_sw_get,
@@ -419,11 +530,15 @@ static struct snd_kcontrol_new stac9640_controls[] = {
419 }, 530 },
420 { 531 {
421 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 532 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
533 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
534 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
535
422 .name = "DAC Volume", 536 .name = "DAC Volume",
423 .count = 8, 537 .count = 8,
424 .info = stac9460_dac_vol_info, 538 .info = stac9460_dac_vol_info,
425 .get = stac9460_dac_vol_get, 539 .get = stac9460_dac_vol_get,
426 .put = stac9460_dac_vol_put, 540 .put = stac9460_dac_vol_put,
541 .tlv = { .p = db_scale_dac }
427 }, 542 },
428 { 543 {
429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 544 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -435,12 +550,15 @@ static struct snd_kcontrol_new stac9640_controls[] = {
435 }, 550 },
436 { 551 {
437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 552 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
553 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
554 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
555
438 .name = "ADC Volume", 556 .name = "ADC Volume",
439 .count = 2, 557 .count = 2,
440 .info = stac9460_adc_vol_info, 558 .info = stac9460_adc_vol_info,
441 .get = stac9460_adc_vol_get, 559 .get = stac9460_adc_vol_get,
442 .put = stac9460_adc_vol_put, 560 .put = stac9460_adc_vol_put,
443 561 .tlv = { .p = db_scale_adc }
444 } 562 }
445}; 563};
446 564
@@ -463,41 +581,53 @@ static int wtm_add_controls(struct snd_ice1712 *ice)
463 581
464static int wtm_init(struct snd_ice1712 *ice) 582static int wtm_init(struct snd_ice1712 *ice)
465{ 583{
466 static unsigned short stac_inits_prodigy[] = { 584 static unsigned short stac_inits_wtm[] = {
467 STAC946X_RESET, 0, 585 STAC946X_RESET, 0,
586 STAC946X_MASTER_CLOCKING, 0x11,
468 (unsigned short)-1 587 (unsigned short)-1
469 }; 588 };
470 unsigned short *p; 589 unsigned short *p;
590 struct wtm_spec *spec;
471 591
472 /*WTM 192M*/ 592 /*WTM 192M*/
473 ice->num_total_dacs = 8; 593 ice->num_total_dacs = 8;
474 ice->num_total_adcs = 4; 594 ice->num_total_adcs = 4;
475 ice->force_rdma1 = 1; 595 ice->force_rdma1 = 1;
476 596
597 /*init mutex for dac mute conflict*/
598 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
599 if (!spec)
600 return -ENOMEM;
601 ice->spec = spec;
602 mutex_init(&spec->mute_mutex);
603
604
477 /*initialize codec*/ 605 /*initialize codec*/
478 p = stac_inits_prodigy; 606 p = stac_inits_wtm;
479 for (; *p != (unsigned short)-1; p += 2) { 607 for (; *p != (unsigned short)-1; p += 2) {
480 stac9460_put(ice, p[0], p[1]); 608 stac9460_put(ice, p[0], p[1]);
481 stac9460_2_put(ice, p[0], p[1]); 609 stac9460_2_put(ice, p[0], p[1]);
482 } 610 }
611 ice->gpio.set_pro_rate = stac9460_set_rate_val;
483 return 0; 612 return 0;
484} 613}
485 614
486 615
487static unsigned char wtm_eeprom[] = { 616static unsigned char wtm_eeprom[] = {
488 0x47, /*SYSCONF: clock 192KHz, 4ADC, 8DAC */ 617 [ICE_EEP2_SYSCONF] = 0x67, /*SYSCONF: clock 192KHz, mpu401,
489 0x80, /* ACLINK : I2S */ 618 4ADC, 8DAC */
490 0xf8, /* I2S: vol; 96k, 24bit, 192k */ 619 [ICE_EEP2_ACLINK] = 0x80, /* ACLINK : I2S */
491 0xc1 /*SPDIF: out-en, spidf ext out*/, 620 [ICE_EEP2_I2S] = 0xf8, /* I2S: vol; 96k, 24bit, 192k */
492 0x9f, /* GPIO_DIR */ 621 [ICE_EEP2_SPDIF] = 0xc1, /*SPDIF: out-en, spidf ext out*/
493 0xff, /* GPIO_DIR1 */ 622 [ICE_EEP2_GPIO_DIR] = 0x9f,
494 0x7f, /* GPIO_DIR2 */ 623 [ICE_EEP2_GPIO_DIR1] = 0xff,
495 0x9f, /* GPIO_MASK */ 624 [ICE_EEP2_GPIO_DIR2] = 0x7f,
496 0xff, /* GPIO_MASK1 */ 625 [ICE_EEP2_GPIO_MASK] = 0x9f,
497 0x7f, /* GPIO_MASK2 */ 626 [ICE_EEP2_GPIO_MASK1] = 0xff,
498 0x16, /* GPIO_STATE */ 627 [ICE_EEP2_GPIO_MASK2] = 0x7f,
499 0x80, /* GPIO_STATE1 */ 628 [ICE_EEP2_GPIO_STATE] = 0x16,
500 0x00, /* GPIO_STATE2 */ 629 [ICE_EEP2_GPIO_STATE1] = 0x80,
630 [ICE_EEP2_GPIO_STATE2] = 0x00,
501}; 631};
502 632
503 633
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 2c5484eeb963..749069aa6997 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -1795,7 +1795,7 @@ static struct ac97_pcm ac97_pcm_defs[] = {
1795 }, 1795 },
1796}; 1796};
1797 1797
1798static struct ac97_quirk ac97_quirks[] = { 1798static const struct ac97_quirk ac97_quirks[] = {
1799 { 1799 {
1800 .subvendor = 0x0e11, 1800 .subvendor = 0x0e11,
1801 .subdevice = 0x000e, 1801 .subdevice = 0x000e,
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index ca67f896d117..cb666c73712d 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -6043,23 +6043,30 @@ hdspm_hw_constraints_aes32_sample_rates = {
6043 .mask = 0 6043 .mask = 0
6044}; 6044};
6045 6045
6046static int snd_hdspm_playback_open(struct snd_pcm_substream *substream) 6046static int snd_hdspm_open(struct snd_pcm_substream *substream)
6047{ 6047{
6048 struct hdspm *hdspm = snd_pcm_substream_chip(substream); 6048 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
6049 struct snd_pcm_runtime *runtime = substream->runtime; 6049 struct snd_pcm_runtime *runtime = substream->runtime;
6050 bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
6050 6051
6051 spin_lock_irq(&hdspm->lock); 6052 spin_lock_irq(&hdspm->lock);
6052
6053 snd_pcm_set_sync(substream); 6053 snd_pcm_set_sync(substream);
6054 runtime->hw = (playback) ? snd_hdspm_playback_subinfo :
6055 snd_hdspm_capture_subinfo;
6054 6056
6057 if (playback) {
6058 if (hdspm->capture_substream == NULL)
6059 hdspm_stop_audio(hdspm);
6055 6060
6056 runtime->hw = snd_hdspm_playback_subinfo; 6061 hdspm->playback_pid = current->pid;
6057 6062 hdspm->playback_substream = substream;
6058 if (hdspm->capture_substream == NULL) 6063 } else {
6059 hdspm_stop_audio(hdspm); 6064 if (hdspm->playback_substream == NULL)
6065 hdspm_stop_audio(hdspm);
6060 6066
6061 hdspm->playback_pid = current->pid; 6067 hdspm->capture_pid = current->pid;
6062 hdspm->playback_substream = substream; 6068 hdspm->capture_substream = substream;
6069 }
6063 6070
6064 spin_unlock_irq(&hdspm->lock); 6071 spin_unlock_irq(&hdspm->lock);
6065 6072
@@ -6094,108 +6101,42 @@ static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
6094 &hdspm_hw_constraints_aes32_sample_rates); 6101 &hdspm_hw_constraints_aes32_sample_rates);
6095 } else { 6102 } else {
6096 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 6103 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
6097 snd_hdspm_hw_rule_rate_out_channels, hdspm, 6104 (playback ?
6105 snd_hdspm_hw_rule_rate_out_channels :
6106 snd_hdspm_hw_rule_rate_in_channels), hdspm,
6098 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 6107 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
6099 } 6108 }
6100 6109
6101 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 6110 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
6102 snd_hdspm_hw_rule_out_channels, hdspm, 6111 (playback ? snd_hdspm_hw_rule_out_channels :
6112 snd_hdspm_hw_rule_in_channels), hdspm,
6103 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 6113 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
6104 6114
6105 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 6115 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
6106 snd_hdspm_hw_rule_out_channels_rate, hdspm, 6116 (playback ? snd_hdspm_hw_rule_out_channels_rate :
6117 snd_hdspm_hw_rule_in_channels_rate), hdspm,
6107 SNDRV_PCM_HW_PARAM_RATE, -1); 6118 SNDRV_PCM_HW_PARAM_RATE, -1);
6108 6119
6109 return 0; 6120 return 0;
6110} 6121}
6111 6122
6112static int snd_hdspm_playback_release(struct snd_pcm_substream *substream) 6123static int snd_hdspm_release(struct snd_pcm_substream *substream)
6113{ 6124{
6114 struct hdspm *hdspm = snd_pcm_substream_chip(substream); 6125 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
6126 bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
6115 6127
6116 spin_lock_irq(&hdspm->lock); 6128 spin_lock_irq(&hdspm->lock);
6117 6129
6118 hdspm->playback_pid = -1; 6130 if (playback) {
6119 hdspm->playback_substream = NULL; 6131 hdspm->playback_pid = -1;
6120 6132 hdspm->playback_substream = NULL;
6121 spin_unlock_irq(&hdspm->lock);
6122
6123 return 0;
6124}
6125
6126
6127static int snd_hdspm_capture_open(struct snd_pcm_substream *substream)
6128{
6129 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
6130 struct snd_pcm_runtime *runtime = substream->runtime;
6131
6132 spin_lock_irq(&hdspm->lock);
6133 snd_pcm_set_sync(substream);
6134 runtime->hw = snd_hdspm_capture_subinfo;
6135
6136 if (hdspm->playback_substream == NULL)
6137 hdspm_stop_audio(hdspm);
6138
6139 hdspm->capture_pid = current->pid;
6140 hdspm->capture_substream = substream;
6141
6142 spin_unlock_irq(&hdspm->lock);
6143
6144 snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
6145 snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
6146
6147 switch (hdspm->io_type) {
6148 case AIO:
6149 case RayDAT:
6150 snd_pcm_hw_constraint_minmax(runtime,
6151 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
6152 32, 4096);
6153 snd_pcm_hw_constraint_minmax(runtime,
6154 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
6155 16384, 16384);
6156 break;
6157
6158 default:
6159 snd_pcm_hw_constraint_minmax(runtime,
6160 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
6161 64, 8192);
6162 snd_pcm_hw_constraint_minmax(runtime,
6163 SNDRV_PCM_HW_PARAM_PERIODS,
6164 2, 2);
6165 break;
6166 }
6167
6168 if (AES32 == hdspm->io_type) {
6169 runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
6170 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
6171 &hdspm_hw_constraints_aes32_sample_rates);
6172 } else { 6133 } else {
6173 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 6134 hdspm->capture_pid = -1;
6174 snd_hdspm_hw_rule_rate_in_channels, hdspm, 6135 hdspm->capture_substream = NULL;
6175 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
6176 } 6136 }
6177 6137
6178 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
6179 snd_hdspm_hw_rule_in_channels, hdspm,
6180 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
6181
6182 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
6183 snd_hdspm_hw_rule_in_channels_rate, hdspm,
6184 SNDRV_PCM_HW_PARAM_RATE, -1);
6185
6186 return 0;
6187}
6188
6189static int snd_hdspm_capture_release(struct snd_pcm_substream *substream)
6190{
6191 struct hdspm *hdspm = snd_pcm_substream_chip(substream);
6192
6193 spin_lock_irq(&hdspm->lock);
6194
6195 hdspm->capture_pid = -1;
6196 hdspm->capture_substream = NULL;
6197
6198 spin_unlock_irq(&hdspm->lock); 6138 spin_unlock_irq(&hdspm->lock);
6139
6199 return 0; 6140 return 0;
6200} 6141}
6201 6142
@@ -6413,21 +6354,9 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
6413 return 0; 6354 return 0;
6414} 6355}
6415 6356
6416static struct snd_pcm_ops snd_hdspm_playback_ops = { 6357static struct snd_pcm_ops snd_hdspm_ops = {
6417 .open = snd_hdspm_playback_open, 6358 .open = snd_hdspm_open,
6418 .close = snd_hdspm_playback_release, 6359 .close = snd_hdspm_release,
6419 .ioctl = snd_hdspm_ioctl,
6420 .hw_params = snd_hdspm_hw_params,
6421 .hw_free = snd_hdspm_hw_free,
6422 .prepare = snd_hdspm_prepare,
6423 .trigger = snd_hdspm_trigger,
6424 .pointer = snd_hdspm_hw_pointer,
6425 .page = snd_pcm_sgbuf_ops_page,
6426};
6427
6428static struct snd_pcm_ops snd_hdspm_capture_ops = {
6429 .open = snd_hdspm_capture_open,
6430 .close = snd_hdspm_capture_release,
6431 .ioctl = snd_hdspm_ioctl, 6360 .ioctl = snd_hdspm_ioctl,
6432 .hw_params = snd_hdspm_hw_params, 6361 .hw_params = snd_hdspm_hw_params,
6433 .hw_free = snd_hdspm_hw_free, 6362 .hw_free = snd_hdspm_hw_free,
@@ -6521,9 +6450,9 @@ static int snd_hdspm_create_pcm(struct snd_card *card,
6521 strcpy(pcm->name, hdspm->card_name); 6450 strcpy(pcm->name, hdspm->card_name);
6522 6451
6523 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 6452 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
6524 &snd_hdspm_playback_ops); 6453 &snd_hdspm_ops);
6525 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 6454 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
6526 &snd_hdspm_capture_ops); 6455 &snd_hdspm_ops);
6527 6456
6528 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; 6457 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
6529 6458
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 8622283e89f3..3dd038bdb204 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -1812,7 +1812,7 @@ static void snd_via82xx_mixer_free_ac97(struct snd_ac97 *ac97)
1812 chip->ac97 = NULL; 1812 chip->ac97 = NULL;
1813} 1813}
1814 1814
1815static struct ac97_quirk ac97_quirks[] = { 1815static const struct ac97_quirk ac97_quirks[] = {
1816 { 1816 {
1817 .subvendor = 0x1106, 1817 .subvendor = 0x1106,
1818 .subdevice = 0x4161, 1818 .subdevice = 0x4161,
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-29 21:57:44 -0400