blob: 5c84d40b770048cef41bde27422dc8b022b05e80 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 *
Takashi Iwaid01ce992007-07-27 16:52:19 +02003 * hda_intel.c - Implementation of primary alsa driver code base
4 * for Intel HD Audio.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Copyright(c) 2004 Intel Corporation. All rights reserved.
7 *
8 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
9 * PeiSen Hou <pshou@realtek.com.tw>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * more details.
20 *
21 * You should have received a copy of the GNU General Public License along with
22 * this program; if not, write to the Free Software Foundation, Inc., 59
23 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 *
25 * CONTACTS:
26 *
27 * Matt Jared matt.jared@intel.com
28 * Andy Kopp andy.kopp@intel.com
29 * Dan Kogan dan.d.kogan@intel.com
30 *
31 * CHANGES:
32 *
33 * 2004.12.01 Major rewrite by tiwai, merged the work of pshou
34 *
35 */
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/delay.h>
38#include <linux/interrupt.h>
Randy Dunlap362775e2005-11-07 14:43:23 +010039#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/module.h>
Andrew Morton24982c52008-03-04 10:08:58 +010041#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/moduleparam.h>
43#include <linux/init.h>
44#include <linux/slab.h>
45#include <linux/pci.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010046#include <linux/mutex.h>
Takashi Iwai27fe48d92011-09-28 17:16:09 +020047#include <linux/io.h>
Mengdong Linb8dfc4622012-08-23 17:32:30 +080048#include <linux/pm_runtime.h>
Pierre-Louis Bossart5d890f52012-10-22 16:42:16 -050049#include <linux/clocksource.h>
50#include <linux/time.h>
Takashi Iwaif4c482a2012-12-04 15:09:23 +010051#include <linux/completion.h>
Pierre-Louis Bossart5d890f52012-10-22 16:42:16 -050052
Takashi Iwai27fe48d92011-09-28 17:16:09 +020053#ifdef CONFIG_X86
54/* for snoop control */
55#include <asm/pgtable.h>
56#include <asm/cacheflush.h>
57#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <sound/core.h>
59#include <sound/initval.h>
Takashi Iwai91219472012-04-26 12:13:25 +020060#include <linux/vgaarb.h>
Takashi Iwaia82d51e2012-04-26 12:23:42 +020061#include <linux/vga_switcheroo.h>
Takashi Iwai4918cda2012-08-09 12:33:28 +020062#include <linux/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#include "hda_codec.h"
Dylan Reid05e84872014-02-28 15:41:22 -080064#include "hda_controller.h"
Imre Deak347de1f2015-01-08 17:54:15 +020065#include "hda_intel.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Libin Yang785d8c42015-05-12 09:43:22 +080067#define CREATE_TRACE_POINTS
68#include "hda_intel_trace.h"
69
Takashi Iwaib6050ef2014-06-26 16:50:16 +020070/* position fix mode */
71enum {
72 POS_FIX_AUTO,
73 POS_FIX_LPIB,
74 POS_FIX_POSBUF,
75 POS_FIX_VIACOMBO,
76 POS_FIX_COMBO,
77};
78
Takashi Iwai9a34af42014-06-26 17:19:20 +020079/* Defines for ATI HD Audio support in SB450 south bridge */
80#define ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR 0x42
81#define ATI_SB450_HDAUDIO_ENABLE_SNOOP 0x02
82
83/* Defines for Nvidia HDA support */
84#define NVIDIA_HDA_TRANSREG_ADDR 0x4e
85#define NVIDIA_HDA_ENABLE_COHBITS 0x0f
86#define NVIDIA_HDA_ISTRM_COH 0x4d
87#define NVIDIA_HDA_OSTRM_COH 0x4c
88#define NVIDIA_HDA_ENABLE_COHBIT 0x01
89
90/* Defines for Intel SCH HDA snoop control */
91#define INTEL_SCH_HDA_DEVC 0x78
92#define INTEL_SCH_HDA_DEVC_NOSNOOP (0x1<<11)
93
94/* Define IN stream 0 FIFO size offset in VIA controller */
95#define VIA_IN_STREAM0_FIFO_SIZE_OFFSET 0x90
96/* Define VIA HD Audio Device ID*/
97#define VIA_HDAC_DEVICE_ID 0x3288
98
Takashi Iwai33124922014-06-26 17:28:06 +020099/* max number of SDs */
100/* ICH, ATI and VIA have 4 playback and 4 capture */
101#define ICH6_NUM_CAPTURE 4
102#define ICH6_NUM_PLAYBACK 4
103
104/* ULI has 6 playback and 5 capture */
105#define ULI_NUM_CAPTURE 5
106#define ULI_NUM_PLAYBACK 6
107
108/* ATI HDMI may have up to 8 playbacks and 0 capture */
109#define ATIHDMI_NUM_CAPTURE 0
110#define ATIHDMI_NUM_PLAYBACK 8
111
112/* TERA has 4 playback and 3 capture */
113#define TERA_NUM_CAPTURE 3
114#define TERA_NUM_PLAYBACK 4
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100117static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
118static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
Rusty Russella67ff6a2011-12-15 13:49:36 +1030119static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100120static char *model[SNDRV_CARDS];
Takashi Iwai1dac6692012-09-13 14:59:47 +0200121static int position_fix[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
Takashi Iwai5c0d7bc2008-06-10 17:53:35 +0200122static int bdl_pos_adj[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100123static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100124static int probe_only[SNDRV_CARDS];
David Henningsson26a6cb62012-10-09 15:04:21 +0200125static int jackpoll_ms[SNDRV_CARDS];
Rusty Russella67ff6a2011-12-15 13:49:36 +1030126static bool single_cmd;
Takashi Iwai716238552009-09-28 13:14:04 +0200127static int enable_msi = -1;
Takashi Iwai4ea6fbc2009-06-17 09:52:54 +0200128#ifdef CONFIG_SND_HDA_PATCH_LOADER
129static char *patch[SNDRV_CARDS];
130#endif
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +0100131#ifdef CONFIG_SND_HDA_INPUT_BEEP
Takashi Iwai0920c9b2012-07-03 16:58:48 +0200132static bool beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +0100133 CONFIG_SND_HDA_INPUT_BEEP_MODE};
134#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100136module_param_array(index, int, NULL, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100138module_param_array(id, charp, NULL, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139MODULE_PARM_DESC(id, "ID string for Intel HD audio interface.");
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100140module_param_array(enable, bool, NULL, 0444);
141MODULE_PARM_DESC(enable, "Enable Intel HD audio interface.");
142module_param_array(model, charp, NULL, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143MODULE_PARM_DESC(model, "Use the given board model.");
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100144module_param_array(position_fix, int, NULL, 0444);
David Henningsson4cb36312010-09-30 10:12:50 +0200145MODULE_PARM_DESC(position_fix, "DMA pointer read method."
Takashi Iwai1dac6692012-09-13 14:59:47 +0200146 "(-1 = system default, 0 = auto, 1 = LPIB, 2 = POSBUF, 3 = VIACOMBO, 4 = COMBO).");
Takashi Iwai555e2192008-06-10 17:53:34 +0200147module_param_array(bdl_pos_adj, int, NULL, 0644);
148MODULE_PARM_DESC(bdl_pos_adj, "BDL position adjustment offset.");
Takashi Iwai5aba4f82008-01-07 15:16:37 +0100149module_param_array(probe_mask, int, NULL, 0444);
Takashi Iwai606ad752005-11-24 16:03:40 +0100150MODULE_PARM_DESC(probe_mask, "Bitmask to probe codecs (default = -1).");
Jaroslav Kysela079e6832010-03-26 11:16:59 +0100151module_param_array(probe_only, int, NULL, 0444);
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100152MODULE_PARM_DESC(probe_only, "Only probing and no codec initialization.");
David Henningsson26a6cb62012-10-09 15:04:21 +0200153module_param_array(jackpoll_ms, int, NULL, 0444);
154MODULE_PARM_DESC(jackpoll_ms, "Ms between polling for jack events (default = 0, using unsol events only)");
Takashi Iwai27346162006-01-12 18:28:44 +0100155module_param(single_cmd, bool, 0444);
Takashi Iwaid01ce992007-07-27 16:52:19 +0200156MODULE_PARM_DESC(single_cmd, "Use single command to communicate with codecs "
157 "(for debugging only).");
Takashi Iwaiac9ef6c2012-01-20 12:08:44 +0100158module_param(enable_msi, bint, 0444);
Takashi Iwai134a11f2006-11-10 12:08:37 +0100159MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
Takashi Iwai4ea6fbc2009-06-17 09:52:54 +0200160#ifdef CONFIG_SND_HDA_PATCH_LOADER
161module_param_array(patch, charp, NULL, 0444);
162MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface.");
163#endif
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +0100164#ifdef CONFIG_SND_HDA_INPUT_BEEP
Takashi Iwai0920c9b2012-07-03 16:58:48 +0200165module_param_array(beep_mode, bool, NULL, 0444);
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +0100166MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
Takashi Iwai0920c9b2012-07-03 16:58:48 +0200167 "(0=off, 1=on) (default=1).");
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +0100168#endif
Takashi Iwai606ad752005-11-24 16:03:40 +0100169
Takashi Iwai83012a72012-08-24 18:38:08 +0200170#ifdef CONFIG_PM
Takashi Iwai65fcd412012-08-14 17:13:32 +0200171static int param_set_xint(const char *val, const struct kernel_param *kp);
172static struct kernel_param_ops param_ops_xint = {
173 .set = param_set_xint,
174 .get = param_get_int,
175};
176#define param_check_xint param_check_int
177
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100178static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
Takashi Iwai65fcd412012-08-14 17:13:32 +0200179module_param(power_save, xint, 0644);
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100180MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
181 "(in second, 0 = disable).");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Takashi Iwaidee1b662007-08-13 16:10:30 +0200183/* reset the HD-audio controller in power save mode.
184 * this may give more power-saving, but will take longer time to
185 * wake up.
186 */
Takashi Iwai8fc24422013-04-04 15:35:24 +0200187static bool power_save_controller = 1;
188module_param(power_save_controller, bool, 0644);
Takashi Iwaidee1b662007-08-13 16:10:30 +0200189MODULE_PARM_DESC(power_save_controller, "Reset controller in power save mode.");
Dylan Reide62a42a2014-02-28 15:41:19 -0800190#else
Takashi Iwaibb573922015-02-20 09:26:04 +0100191#define power_save 0
Takashi Iwai83012a72012-08-24 18:38:08 +0200192#endif /* CONFIG_PM */
Takashi Iwaidee1b662007-08-13 16:10:30 +0200193
Takashi Iwai7bfe0592012-01-23 17:53:39 +0100194static int align_buffer_size = -1;
195module_param(align_buffer_size, bint, 0644);
Pierre-Louis Bossart2ae66c22011-08-04 10:12:56 -0500196MODULE_PARM_DESC(align_buffer_size,
197 "Force buffer and period sizes to be multiple of 128 bytes.");
198
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200199#ifdef CONFIG_X86
Takashi Iwai7c732012014-11-25 12:54:16 +0100200static int hda_snoop = -1;
201module_param_named(snoop, hda_snoop, bint, 0444);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200202MODULE_PARM_DESC(snoop, "Enable/disable snooping");
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200203#else
204#define hda_snoop true
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200205#endif
206
207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208MODULE_LICENSE("GPL");
209MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
210 "{Intel, ICH6M},"
Jason Gaston2f1b3812005-05-01 08:58:50 -0700211 "{Intel, ICH7},"
Frederick Lif5d40b32005-05-12 14:55:20 +0200212 "{Intel, ESB2},"
Jason Gastond2981392006-01-10 11:07:37 +0100213 "{Intel, ICH8},"
Jason Gastonf9cc8a82006-11-22 11:53:52 +0100214 "{Intel, ICH9},"
Jason Gastonc34f5a02008-01-29 12:38:49 +0100215 "{Intel, ICH10},"
Seth Heasleyb29c2362008-08-08 15:56:39 -0700216 "{Intel, PCH},"
Seth Heasleyd2f2fcd2010-01-12 17:03:35 -0800217 "{Intel, CPT},"
Seth Heasleyd2edeb72011-04-20 10:59:57 -0700218 "{Intel, PPT},"
Seth Heasley8bc039a2012-01-23 16:24:31 -0800219 "{Intel, LPT},"
James Ralston144dad92012-08-09 09:38:59 -0700220 "{Intel, LPT_LP},"
James Ralston4eeca492013-11-04 09:27:45 -0800221 "{Intel, WPT_LP},"
James Ralstonc8b00fd2014-10-13 15:22:03 -0700222 "{Intel, SPT},"
Devin Rylesb4565912014-11-07 18:02:47 -0500223 "{Intel, SPT_LP},"
Wang Xingchaoe926f2c2012-06-13 10:23:51 +0800224 "{Intel, HPT},"
Seth Heasleycea310e2010-09-10 16:29:56 -0700225 "{Intel, PBG},"
Tobin Davis4979bca2008-01-30 08:13:55 +0100226 "{Intel, SCH},"
Takashi Iwaifc20a562005-05-12 15:00:41 +0200227 "{ATI, SB450},"
Felix Kuehling89be83f2006-03-31 12:33:59 +0200228 "{ATI, SB600},"
Felix Kuehling778b6e12006-05-17 11:22:21 +0200229 "{ATI, RS600},"
Felix Kuehling5b15c952006-10-16 12:49:47 +0200230 "{ATI, RS690},"
Wolke Liue6db1112007-04-27 12:20:57 +0200231 "{ATI, RS780},"
232 "{ATI, R600},"
Herton Ronaldo Krzesinski2797f722007-11-05 18:21:56 +0100233 "{ATI, RV630},"
234 "{ATI, RV610},"
Wolke Liu27da1832007-11-16 11:06:30 +0100235 "{ATI, RV670},"
236 "{ATI, RV635},"
237 "{ATI, RV620},"
238 "{ATI, RV770},"
Takashi Iwaifc20a562005-05-12 15:00:41 +0200239 "{VIA, VT8251},"
Takashi Iwai47672312005-08-12 16:44:04 +0200240 "{VIA, VT8237A},"
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200241 "{SiS, SIS966},"
242 "{ULI, M5461}}");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243MODULE_DESCRIPTION("Intel HDA driver");
244
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200245#if defined(CONFIG_PM) && defined(CONFIG_VGA_SWITCHEROO)
Takashi Iwaif8f1bec2014-02-06 18:14:03 +0100246#if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200247#define SUPPORT_VGA_SWITCHEROO
248#endif
249#endif
250
251
Takashi Iwaicb53c622007-08-10 17:21:45 +0200252/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200255/* driver types */
256enum {
257 AZX_DRIVER_ICH,
Seth Heasley32679f92010-02-22 17:31:09 -0800258 AZX_DRIVER_PCH,
Tobin Davis4979bca2008-01-30 08:13:55 +0100259 AZX_DRIVER_SCH,
Takashi Iwaifab12852013-11-05 17:54:05 +0100260 AZX_DRIVER_HDMI,
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200261 AZX_DRIVER_ATI,
Felix Kuehling778b6e12006-05-17 11:22:21 +0200262 AZX_DRIVER_ATIHDMI,
Andiry Xu1815b342011-12-14 16:10:27 +0800263 AZX_DRIVER_ATIHDMI_NS,
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200264 AZX_DRIVER_VIA,
265 AZX_DRIVER_SIS,
266 AZX_DRIVER_ULI,
Vinod Gda3fca22005-09-13 18:49:12 +0200267 AZX_DRIVER_NVIDIA,
Kailang Yangf2690022008-05-27 11:44:55 +0200268 AZX_DRIVER_TERA,
Takashi Iwai14d34f12010-10-21 09:03:25 +0200269 AZX_DRIVER_CTX,
Takashi Iwai5ae763b2012-05-08 10:34:08 +0200270 AZX_DRIVER_CTHDA,
Takashi Iwaic563f472014-08-06 14:27:42 +0200271 AZX_DRIVER_CMEDIA,
Yang, Libinc4da29c2008-11-13 11:07:07 +0100272 AZX_DRIVER_GENERIC,
Takashi Iwai2f5983f2008-09-03 16:00:44 +0200273 AZX_NUM_DRIVERS, /* keep this as last entry */
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200274};
275
Takashi Iwai37e661e2014-11-25 11:28:07 +0100276#define azx_get_snoop_type(chip) \
277 (((chip)->driver_caps & AZX_DCAPS_SNOOP_MASK) >> 10)
278#define AZX_DCAPS_SNOOP_TYPE(type) ((AZX_SNOOP_TYPE_ ## type) << 10)
279
Takashi Iwaib42b4af2014-12-03 09:47:20 +0100280/* quirks for old Intel chipsets */
281#define AZX_DCAPS_INTEL_ICH \
Takashi Iwai103884a2014-12-03 09:56:20 +0100282 (AZX_DCAPS_OLD_SSYNC | AZX_DCAPS_NO_ALIGN_BUFSIZE)
Takashi Iwaib42b4af2014-12-03 09:47:20 +0100283
Takashi Iwai2ea3c6a2012-11-19 20:03:37 +0100284/* quirks for Intel PCH */
Takashi Iwaid7dab4d2013-01-08 13:51:30 +0100285#define AZX_DCAPS_INTEL_PCH_NOPM \
Takashi Iwai103884a2014-12-03 09:56:20 +0100286 (AZX_DCAPS_NO_ALIGN_BUFSIZE | AZX_DCAPS_COUNT_LPIB_DELAY |\
Takashi Iwai37e661e2014-11-25 11:28:07 +0100287 AZX_DCAPS_REVERSE_ASSIGN | AZX_DCAPS_SNOOP_TYPE(SCH))
Takashi Iwaid7dab4d2013-01-08 13:51:30 +0100288
289#define AZX_DCAPS_INTEL_PCH \
290 (AZX_DCAPS_INTEL_PCH_NOPM | AZX_DCAPS_PM_RUNTIME)
Takashi Iwai9477c582011-05-25 09:11:37 +0200291
Takashi Iwai33499a12013-11-05 17:34:46 +0100292#define AZX_DCAPS_INTEL_HASWELL \
Takashi Iwai103884a2014-12-03 09:56:20 +0100293 (/*AZX_DCAPS_ALIGN_BUFSIZE |*/ AZX_DCAPS_COUNT_LPIB_DELAY |\
Takashi Iwai37e661e2014-11-25 11:28:07 +0100294 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_POWERWELL |\
295 AZX_DCAPS_SNOOP_TYPE(SCH))
Takashi Iwai33499a12013-11-05 17:34:46 +0100296
Libin Yang54a04052014-06-09 15:28:59 +0800297/* Broadwell HDMI can't use position buffer reliably, force to use LPIB */
298#define AZX_DCAPS_INTEL_BROADWELL \
Takashi Iwai103884a2014-12-03 09:56:20 +0100299 (/*AZX_DCAPS_ALIGN_BUFSIZE |*/ AZX_DCAPS_POSFIX_LPIB |\
Takashi Iwai37e661e2014-11-25 11:28:07 +0100300 AZX_DCAPS_PM_RUNTIME | AZX_DCAPS_I915_POWERWELL |\
301 AZX_DCAPS_SNOOP_TYPE(SCH))
Libin Yang54a04052014-06-09 15:28:59 +0800302
Mengdong Lin40cc2392015-04-21 13:12:23 +0800303#define AZX_DCAPS_INTEL_BAYTRAIL \
304 (AZX_DCAPS_INTEL_PCH_NOPM | AZX_DCAPS_I915_POWERWELL)
305
Libin Yang2d846c72015-04-07 20:32:20 +0800306#define AZX_DCAPS_INTEL_BRASWELL \
307 (AZX_DCAPS_INTEL_PCH | AZX_DCAPS_I915_POWERWELL)
308
Libin Yangd6795822014-12-19 08:44:31 +0800309#define AZX_DCAPS_INTEL_SKYLAKE \
Libin Yang2d846c72015-04-07 20:32:20 +0800310 (AZX_DCAPS_INTEL_PCH | AZX_DCAPS_SEPARATE_STREAM_TAG |\
311 AZX_DCAPS_I915_POWERWELL)
Libin Yangd6795822014-12-19 08:44:31 +0800312
Takashi Iwai9477c582011-05-25 09:11:37 +0200313/* quirks for ATI SB / AMD Hudson */
314#define AZX_DCAPS_PRESET_ATI_SB \
Takashi Iwai37e661e2014-11-25 11:28:07 +0100315 (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB |\
316 AZX_DCAPS_SNOOP_TYPE(ATI))
Takashi Iwai9477c582011-05-25 09:11:37 +0200317
318/* quirks for ATI/AMD HDMI */
319#define AZX_DCAPS_PRESET_ATI_HDMI \
Benjamin Herrenschmidtdb79afa2014-11-24 14:17:08 +1100320 (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB|\
321 AZX_DCAPS_NO_MSI64)
Takashi Iwai9477c582011-05-25 09:11:37 +0200322
Takashi Iwai37e661e2014-11-25 11:28:07 +0100323/* quirks for ATI HDMI with snoop off */
324#define AZX_DCAPS_PRESET_ATI_HDMI_NS \
325 (AZX_DCAPS_PRESET_ATI_HDMI | AZX_DCAPS_SNOOP_OFF)
326
Takashi Iwai9477c582011-05-25 09:11:37 +0200327/* quirks for Nvidia */
328#define AZX_DCAPS_PRESET_NVIDIA \
Takashi Iwai103884a2014-12-03 09:56:20 +0100329 (AZX_DCAPS_RIRB_DELAY | AZX_DCAPS_NO_MSI | /*AZX_DCAPS_ALIGN_BUFSIZE |*/ \
Takashi Iwai37e661e2014-11-25 11:28:07 +0100330 AZX_DCAPS_NO_64BIT | AZX_DCAPS_CORBRP_SELF_CLEAR |\
331 AZX_DCAPS_SNOOP_TYPE(NVIDIA))
Takashi Iwai9477c582011-05-25 09:11:37 +0200332
Takashi Iwai5ae763b2012-05-08 10:34:08 +0200333#define AZX_DCAPS_PRESET_CTHDA \
Takashi Iwai37e661e2014-11-25 11:28:07 +0100334 (AZX_DCAPS_NO_MSI | AZX_DCAPS_POSFIX_LPIB |\
335 AZX_DCAPS_4K_BDLE_BOUNDARY | AZX_DCAPS_SNOOP_OFF)
Takashi Iwai5ae763b2012-05-08 10:34:08 +0200336
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200337/*
338 * VGA-switcher support
339 */
340#ifdef SUPPORT_VGA_SWITCHEROO
Takashi Iwai5cb543d2012-08-09 13:49:23 +0200341#define use_vga_switcheroo(chip) ((chip)->use_vga_switcheroo)
342#else
343#define use_vga_switcheroo(chip) 0
344#endif
345
Takashi Iwai48c8b0e2012-12-07 07:40:35 +0100346static char *driver_short_names[] = {
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200347 [AZX_DRIVER_ICH] = "HDA Intel",
Seth Heasley32679f92010-02-22 17:31:09 -0800348 [AZX_DRIVER_PCH] = "HDA Intel PCH",
Tobin Davis4979bca2008-01-30 08:13:55 +0100349 [AZX_DRIVER_SCH] = "HDA Intel MID",
Takashi Iwaifab12852013-11-05 17:54:05 +0100350 [AZX_DRIVER_HDMI] = "HDA Intel HDMI",
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200351 [AZX_DRIVER_ATI] = "HDA ATI SB",
Felix Kuehling778b6e12006-05-17 11:22:21 +0200352 [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
Andiry Xu1815b342011-12-14 16:10:27 +0800353 [AZX_DRIVER_ATIHDMI_NS] = "HDA ATI HDMI",
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200354 [AZX_DRIVER_VIA] = "HDA VIA VT82xx",
355 [AZX_DRIVER_SIS] = "HDA SIS966",
Vinod Gda3fca22005-09-13 18:49:12 +0200356 [AZX_DRIVER_ULI] = "HDA ULI M5461",
357 [AZX_DRIVER_NVIDIA] = "HDA NVidia",
Kailang Yangf2690022008-05-27 11:44:55 +0200358 [AZX_DRIVER_TERA] = "HDA Teradici",
Takashi Iwai14d34f12010-10-21 09:03:25 +0200359 [AZX_DRIVER_CTX] = "HDA Creative",
Takashi Iwai5ae763b2012-05-08 10:34:08 +0200360 [AZX_DRIVER_CTHDA] = "HDA Creative",
Takashi Iwaic563f472014-08-06 14:27:42 +0200361 [AZX_DRIVER_CMEDIA] = "HDA C-Media",
Yang, Libinc4da29c2008-11-13 11:07:07 +0100362 [AZX_DRIVER_GENERIC] = "HD-Audio Generic",
Takashi Iwai07e4ca52005-08-24 14:14:57 +0200363};
364
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200365#ifdef CONFIG_X86
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100366static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool on)
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200367{
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100368 int pages;
369
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200370 if (azx_snoop(chip))
371 return;
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100372 if (!dmab || !dmab->area || !dmab->bytes)
373 return;
374
375#ifdef CONFIG_SND_DMA_SGBUF
376 if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_SG) {
377 struct snd_sg_buf *sgbuf = dmab->private_data;
Takashi Iwai3b70bdb2014-10-29 16:13:05 +0100378 if (chip->driver_type == AZX_DRIVER_CMEDIA)
379 return; /* deal with only CORB/RIRB buffers */
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200380 if (on)
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100381 set_pages_array_wc(sgbuf->page_table, sgbuf->pages);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200382 else
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100383 set_pages_array_wb(sgbuf->page_table, sgbuf->pages);
384 return;
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200385 }
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100386#endif
387
388 pages = (dmab->bytes + PAGE_SIZE - 1) >> PAGE_SHIFT;
389 if (on)
390 set_memory_wc((unsigned long)dmab->area, pages);
391 else
392 set_memory_wb((unsigned long)dmab->area, pages);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200393}
394
395static inline void mark_pages_wc(struct azx *chip, struct snd_dma_buffer *buf,
396 bool on)
397{
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100398 __mark_pages_wc(chip, buf, on);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200399}
400static inline void mark_runtime_wc(struct azx *chip, struct azx_dev *azx_dev,
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100401 struct snd_pcm_substream *substream, bool on)
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200402{
403 if (azx_dev->wc_marked != on) {
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100404 __mark_pages_wc(chip, snd_pcm_get_dma_buf(substream), on);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200405 azx_dev->wc_marked = on;
406 }
407}
408#else
409/* NOP for other archs */
410static inline void mark_pages_wc(struct azx *chip, struct snd_dma_buffer *buf,
411 bool on)
412{
413}
414static inline void mark_runtime_wc(struct azx *chip, struct azx_dev *azx_dev,
Takashi Iwai9ddf1ae2013-01-29 18:07:22 +0100415 struct snd_pcm_substream *substream, bool on)
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200416{
417}
418#endif
419
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200420static int azx_acquire_irq(struct azx *chip, int do_disconnect);
Takashi Iwai111d3af2006-02-16 18:17:58 +0100421
Takashi Iwaicb53c622007-08-10 17:21:45 +0200422/*
423 * initialize the PCI registers
424 */
425/* update bits in a PCI register byte */
426static void update_pci_byte(struct pci_dev *pci, unsigned int reg,
427 unsigned char mask, unsigned char val)
428{
429 unsigned char data;
430
431 pci_read_config_byte(pci, reg, &data);
432 data &= ~mask;
433 data |= (val & mask);
434 pci_write_config_byte(pci, reg, data);
435}
436
437static void azx_init_pci(struct azx *chip)
438{
Takashi Iwai37e661e2014-11-25 11:28:07 +0100439 int snoop_type = azx_get_snoop_type(chip);
440
Takashi Iwaicb53c622007-08-10 17:21:45 +0200441 /* Clear bits 0-2 of PCI register TCSEL (at offset 0x44)
442 * TCSEL == Traffic Class Select Register, which sets PCI express QOS
443 * Ensuring these bits are 0 clears playback static on some HD Audio
Adam Lackorzynskia09e89f2011-03-10 17:41:56 +0100444 * codecs.
445 * The PCI register TCSEL is defined in the Intel manuals.
Takashi Iwaicb53c622007-08-10 17:21:45 +0200446 */
Linus Torvalds46f2cc82011-05-27 19:45:28 -0700447 if (!(chip->driver_caps & AZX_DCAPS_NO_TCSEL)) {
Takashi Iwai4e76a882014-02-25 12:21:03 +0100448 dev_dbg(chip->card->dev, "Clearing TCSEL\n");
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +0200449 update_pci_byte(chip->pci, AZX_PCIREG_TCSEL, 0x07, 0);
Takashi Iwai9477c582011-05-25 09:11:37 +0200450 }
Takashi Iwaicb53c622007-08-10 17:21:45 +0200451
Takashi Iwai9477c582011-05-25 09:11:37 +0200452 /* For ATI SB450/600/700/800/900 and AMD Hudson azalia HD audio,
453 * we need to enable snoop.
454 */
Takashi Iwai37e661e2014-11-25 11:28:07 +0100455 if (snoop_type == AZX_SNOOP_TYPE_ATI) {
Takashi Iwai4e76a882014-02-25 12:21:03 +0100456 dev_dbg(chip->card->dev, "Setting ATI snoop: %d\n",
457 azx_snoop(chip));
Takashi Iwaicb53c622007-08-10 17:21:45 +0200458 update_pci_byte(chip->pci,
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200459 ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR, 0x07,
460 azx_snoop(chip) ? ATI_SB450_HDAUDIO_ENABLE_SNOOP : 0);
Takashi Iwai9477c582011-05-25 09:11:37 +0200461 }
462
463 /* For NVIDIA HDA, enable snoop */
Takashi Iwai37e661e2014-11-25 11:28:07 +0100464 if (snoop_type == AZX_SNOOP_TYPE_NVIDIA) {
Takashi Iwai4e76a882014-02-25 12:21:03 +0100465 dev_dbg(chip->card->dev, "Setting Nvidia snoop: %d\n",
466 azx_snoop(chip));
Takashi Iwaicb53c622007-08-10 17:21:45 +0200467 update_pci_byte(chip->pci,
468 NVIDIA_HDA_TRANSREG_ADDR,
469 0x0f, NVIDIA_HDA_ENABLE_COHBITS);
Peer Chen320dcc32008-08-20 16:43:24 -0700470 update_pci_byte(chip->pci,
471 NVIDIA_HDA_ISTRM_COH,
472 0x01, NVIDIA_HDA_ENABLE_COHBIT);
473 update_pci_byte(chip->pci,
474 NVIDIA_HDA_OSTRM_COH,
475 0x01, NVIDIA_HDA_ENABLE_COHBIT);
Takashi Iwai9477c582011-05-25 09:11:37 +0200476 }
477
478 /* Enable SCH/PCH snoop if needed */
Takashi Iwai37e661e2014-11-25 11:28:07 +0100479 if (snoop_type == AZX_SNOOP_TYPE_SCH) {
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200480 unsigned short snoop;
Takashi Iwai90a5ad52008-02-22 18:36:22 +0100481 pci_read_config_word(chip->pci, INTEL_SCH_HDA_DEVC, &snoop);
Takashi Iwai27fe48d92011-09-28 17:16:09 +0200482 if ((!azx_snoop(chip) && !(snoop & INTEL_SCH_HDA_DEVC_NOSNOOP)) ||
483 (azx_snoop(chip) && (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP))) {
484 snoop &= ~INTEL_SCH_HDA_DEVC_NOSNOOP;
485 if (!azx_snoop(chip))
486 snoop |= INTEL_SCH_HDA_DEVC_NOSNOOP;
487 pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC, snoop);
Takashi Iwai90a5ad52008-02-22 18:36:22 +0100488 pci_read_config_word(chip->pci,
489 INTEL_SCH_HDA_DEVC, &snoop);
Takashi Iwai90a5ad52008-02-22 18:36:22 +0100490 }
Takashi Iwai4e76a882014-02-25 12:21:03 +0100491 dev_dbg(chip->card->dev, "SCH snoop: %s\n",
492 (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) ?
493 "Disabled" : "Enabled");
Vinod Gda3fca22005-09-13 18:49:12 +0200494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495}
496
Lu, Han0a673522015-05-05 09:05:48 +0800497static void hda_intel_init_chip(struct azx *chip, bool full_reset)
498{
499 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
500
501 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
502 hda_set_codec_wakeup(hda, true);
503 azx_init_chip(chip, full_reset);
504 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
505 hda_set_codec_wakeup(hda, false);
506}
507
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200508/* calculate runtime delay from LPIB */
509static int azx_get_delay_from_lpib(struct azx *chip, struct azx_dev *azx_dev,
510 unsigned int pos)
511{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200512 struct snd_pcm_substream *substream = azx_dev->core.substream;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200513 int stream = substream->stream;
514 unsigned int lpib_pos = azx_get_pos_lpib(chip, azx_dev);
515 int delay;
516
517 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
518 delay = pos - lpib_pos;
519 else
520 delay = lpib_pos - pos;
521 if (delay < 0) {
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200522 if (delay >= azx_dev->core.delay_negative_threshold)
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200523 delay = 0;
524 else
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200525 delay += azx_dev->core.bufsize;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200526 }
527
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200528 if (delay >= azx_dev->core.period_bytes) {
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200529 dev_info(chip->card->dev,
530 "Unstable LPIB (%d >= %d); disabling LPIB delay counting\n",
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200531 delay, azx_dev->core.period_bytes);
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200532 delay = 0;
533 chip->driver_caps &= ~AZX_DCAPS_COUNT_LPIB_DELAY;
534 chip->get_delay[stream] = NULL;
535 }
536
537 return bytes_to_frames(substream->runtime, delay);
538}
539
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200540static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev);
541
Dylan Reid7ca954a2014-02-28 15:41:28 -0800542/* called from IRQ */
543static int azx_position_check(struct azx *chip, struct azx_dev *azx_dev)
544{
Takashi Iwai9a34af42014-06-26 17:19:20 +0200545 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Dylan Reid7ca954a2014-02-28 15:41:28 -0800546 int ok;
547
548 ok = azx_position_ok(chip, azx_dev);
549 if (ok == 1) {
550 azx_dev->irq_pending = 0;
551 return ok;
Takashi Iwai2f35c632015-02-27 22:43:26 +0100552 } else if (ok == 0) {
Dylan Reid7ca954a2014-02-28 15:41:28 -0800553 /* bogus IRQ, process it later */
554 azx_dev->irq_pending = 1;
Takashi Iwai2f35c632015-02-27 22:43:26 +0100555 schedule_work(&hda->irq_pending_work);
Dylan Reid7ca954a2014-02-28 15:41:28 -0800556 }
557 return 0;
558}
559
Mengdong Lin17eccb22015-04-29 17:43:29 +0800560/* Enable/disable i915 display power for the link */
561static int azx_intel_link_power(struct azx *chip, bool enable)
562{
563 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
564
565 return hda_display_power(hda, enable);
566}
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568/*
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200569 * Check whether the current DMA position is acceptable for updating
570 * periods. Returns non-zero if it's OK.
571 *
572 * Many HD-audio controllers appear pretty inaccurate about
573 * the update-IRQ timing. The IRQ is issued before actually the
574 * data is processed. So, we need to process it afterwords in a
575 * workqueue.
576 */
577static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
578{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200579 struct snd_pcm_substream *substream = azx_dev->core.substream;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200580 int stream = substream->stream;
Jaroslav Kyselae5463722010-05-11 10:21:46 +0200581 u32 wallclk;
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200582 unsigned int pos;
583
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200584 wallclk = azx_readl(chip, WALLCLK) - azx_dev->core.start_wallclk;
585 if (wallclk < (azx_dev->core.period_wallclk * 2) / 3)
Jaroslav Kyselafa00e042009-04-10 12:20:45 +0200586 return -1; /* bogus (too early) interrupt */
Jaroslav Kyselafa00e042009-04-10 12:20:45 +0200587
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200588 if (chip->get_position[stream])
589 pos = chip->get_position[stream](chip, azx_dev);
590 else { /* use the position buffer as default */
591 pos = azx_get_pos_posbuf(chip, azx_dev);
592 if (!pos || pos == (u32)-1) {
593 dev_info(chip->card->dev,
594 "Invalid position buffer, using LPIB read method instead.\n");
595 chip->get_position[stream] = azx_get_pos_lpib;
Takashi Iwaiccc98862015-04-14 22:06:53 +0200596 if (chip->get_position[0] == azx_get_pos_lpib &&
597 chip->get_position[1] == azx_get_pos_lpib)
598 azx_bus(chip)->use_posbuf = false;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200599 pos = azx_get_pos_lpib(chip, azx_dev);
600 chip->get_delay[stream] = NULL;
601 } else {
602 chip->get_position[stream] = azx_get_pos_posbuf;
603 if (chip->driver_caps & AZX_DCAPS_COUNT_LPIB_DELAY)
604 chip->get_delay[stream] = azx_get_delay_from_lpib;
605 }
606 }
607
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200608 if (pos >= azx_dev->core.bufsize)
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200609 pos = 0;
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200610
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200611 if (WARN_ONCE(!azx_dev->core.period_bytes,
Takashi Iwaid6d8bf52010-02-12 18:17:06 +0100612 "hda-intel: zero azx_dev->period_bytes"))
Jaroslav Kyselaf48f6062010-05-11 12:10:47 +0200613 return -1; /* this shouldn't happen! */
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200614 if (wallclk < (azx_dev->core.period_wallclk * 5) / 4 &&
615 pos % azx_dev->core.period_bytes > azx_dev->core.period_bytes / 2)
Jaroslav Kyselaf48f6062010-05-11 12:10:47 +0200616 /* NG - it's below the first next period boundary */
Dylan Reid9cdc0112014-02-28 15:41:14 -0800617 return chip->bdl_pos_adj[chip->dev_index] ? 0 : -1;
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200618 azx_dev->core.start_wallclk += wallclk;
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200619 return 1; /* OK, it's fine */
620}
621
622/*
623 * The work for pending PCM period updates.
624 */
625static void azx_irq_pending_work(struct work_struct *work)
626{
Takashi Iwai9a34af42014-06-26 17:19:20 +0200627 struct hda_intel *hda = container_of(work, struct hda_intel, irq_pending_work);
628 struct azx *chip = &hda->chip;
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200629 struct hdac_bus *bus = azx_bus(chip);
630 struct hdac_stream *s;
631 int pending, ok;
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200632
Takashi Iwai9a34af42014-06-26 17:19:20 +0200633 if (!hda->irq_pending_warned) {
Takashi Iwai4e76a882014-02-25 12:21:03 +0100634 dev_info(chip->card->dev,
635 "IRQ timing workaround is activated for card #%d. Suggest a bigger bdl_pos_adj.\n",
636 chip->card->number);
Takashi Iwai9a34af42014-06-26 17:19:20 +0200637 hda->irq_pending_warned = 1;
Takashi Iwaia6a950a2008-06-10 17:53:35 +0200638 }
639
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200640 for (;;) {
641 pending = 0;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200642 spin_lock_irq(&bus->reg_lock);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200643 list_for_each_entry(s, &bus->stream_list, list) {
644 struct azx_dev *azx_dev = stream_to_azx_dev(s);
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200645 if (!azx_dev->irq_pending ||
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200646 !s->substream ||
647 !s->running)
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200648 continue;
Jaroslav Kyselae5463722010-05-11 10:21:46 +0200649 ok = azx_position_ok(chip, azx_dev);
650 if (ok > 0) {
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200651 azx_dev->irq_pending = 0;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200652 spin_unlock(&bus->reg_lock);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200653 snd_pcm_period_elapsed(s->substream);
Takashi Iwaia41d1222015-04-14 22:13:18 +0200654 spin_lock(&bus->reg_lock);
Jaroslav Kyselae5463722010-05-11 10:21:46 +0200655 } else if (ok < 0) {
656 pending = 0; /* too early */
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200657 } else
658 pending++;
659 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200660 spin_unlock_irq(&bus->reg_lock);
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200661 if (!pending)
662 return;
Takashi Iwai08af4952010-08-03 14:39:04 +0200663 msleep(1);
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200664 }
665}
666
667/* clear irq_pending flags and assure no on-going workq */
668static void azx_clear_irq_pending(struct azx *chip)
669{
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200670 struct hdac_bus *bus = azx_bus(chip);
671 struct hdac_stream *s;
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200672
Takashi Iwaia41d1222015-04-14 22:13:18 +0200673 spin_lock_irq(&bus->reg_lock);
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200674 list_for_each_entry(s, &bus->stream_list, list) {
675 struct azx_dev *azx_dev = stream_to_azx_dev(s);
676 azx_dev->irq_pending = 0;
677 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200678 spin_unlock_irq(&bus->reg_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200681static int azx_acquire_irq(struct azx *chip, int do_disconnect)
682{
Takashi Iwaia41d1222015-04-14 22:13:18 +0200683 struct hdac_bus *bus = azx_bus(chip);
684
Takashi Iwai437a5a42006-11-21 12:14:23 +0100685 if (request_irq(chip->pci->irq, azx_interrupt,
686 chip->msi ? 0 : IRQF_SHARED,
Takashi Iwai934c2b62011-06-10 16:36:37 +0200687 KBUILD_MODNAME, chip)) {
Takashi Iwai4e76a882014-02-25 12:21:03 +0100688 dev_err(chip->card->dev,
689 "unable to grab IRQ %d, disabling device\n",
690 chip->pci->irq);
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200691 if (do_disconnect)
692 snd_card_disconnect(chip->card);
693 return -1;
694 }
Takashi Iwaia41d1222015-04-14 22:13:18 +0200695 bus->irq = chip->pci->irq;
Takashi Iwai69e13412006-11-21 12:10:55 +0100696 pci_intx(chip->pci, !chip->msi);
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200697 return 0;
698}
699
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200700/* get the current DMA position with correction on VIA chips */
701static unsigned int azx_via_get_position(struct azx *chip,
702 struct azx_dev *azx_dev)
703{
704 unsigned int link_pos, mini_pos, bound_pos;
705 unsigned int mod_link_pos, mod_dma_pos, mod_mini_pos;
706 unsigned int fifo_size;
707
Takashi Iwai1604eee2015-04-16 12:14:17 +0200708 link_pos = snd_hdac_stream_get_pos_lpib(azx_stream(azx_dev));
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200709 if (azx_dev->core.substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200710 /* Playback, no problem using link position */
711 return link_pos;
712 }
713
714 /* Capture */
715 /* For new chipset,
716 * use mod to get the DMA position just like old chipset
717 */
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200718 mod_dma_pos = le32_to_cpu(*azx_dev->core.posbuf);
719 mod_dma_pos %= azx_dev->core.period_bytes;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200720
721 /* azx_dev->fifo_size can't get FIFO size of in stream.
722 * Get from base address + offset.
723 */
Takashi Iwaia41d1222015-04-14 22:13:18 +0200724 fifo_size = readw(azx_bus(chip)->remap_addr +
725 VIA_IN_STREAM0_FIFO_SIZE_OFFSET);
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200726
727 if (azx_dev->insufficient) {
728 /* Link position never gather than FIFO size */
729 if (link_pos <= fifo_size)
730 return 0;
731
732 azx_dev->insufficient = 0;
733 }
734
735 if (link_pos <= fifo_size)
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200736 mini_pos = azx_dev->core.bufsize + link_pos - fifo_size;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200737 else
738 mini_pos = link_pos - fifo_size;
739
740 /* Find nearest previous boudary */
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200741 mod_mini_pos = mini_pos % azx_dev->core.period_bytes;
742 mod_link_pos = link_pos % azx_dev->core.period_bytes;
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200743 if (mod_link_pos >= fifo_size)
744 bound_pos = link_pos - mod_link_pos;
745 else if (mod_dma_pos >= mod_mini_pos)
746 bound_pos = mini_pos - mod_mini_pos;
747 else {
Takashi Iwai7833c3f2015-04-14 18:13:13 +0200748 bound_pos = mini_pos - mod_mini_pos + azx_dev->core.period_bytes;
749 if (bound_pos >= azx_dev->core.bufsize)
Takashi Iwaib6050ef2014-06-26 16:50:16 +0200750 bound_pos = 0;
751 }
752
753 /* Calculate real DMA position we want */
754 return bound_pos + mod_dma_pos;
755}
756
Takashi Iwai83012a72012-08-24 18:38:08 +0200757#ifdef CONFIG_PM
Takashi Iwai65fcd412012-08-14 17:13:32 +0200758static DEFINE_MUTEX(card_list_lock);
759static LIST_HEAD(card_list);
760
761static void azx_add_card_list(struct azx *chip)
762{
Takashi Iwai9a34af42014-06-26 17:19:20 +0200763 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai65fcd412012-08-14 17:13:32 +0200764 mutex_lock(&card_list_lock);
Takashi Iwai9a34af42014-06-26 17:19:20 +0200765 list_add(&hda->list, &card_list);
Takashi Iwai65fcd412012-08-14 17:13:32 +0200766 mutex_unlock(&card_list_lock);
767}
768
769static void azx_del_card_list(struct azx *chip)
770{
Takashi Iwai9a34af42014-06-26 17:19:20 +0200771 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai65fcd412012-08-14 17:13:32 +0200772 mutex_lock(&card_list_lock);
Takashi Iwai9a34af42014-06-26 17:19:20 +0200773 list_del_init(&hda->list);
Takashi Iwai65fcd412012-08-14 17:13:32 +0200774 mutex_unlock(&card_list_lock);
775}
776
777/* trigger power-save check at writing parameter */
778static int param_set_xint(const char *val, const struct kernel_param *kp)
779{
Takashi Iwai9a34af42014-06-26 17:19:20 +0200780 struct hda_intel *hda;
Takashi Iwai65fcd412012-08-14 17:13:32 +0200781 struct azx *chip;
Takashi Iwai65fcd412012-08-14 17:13:32 +0200782 int prev = power_save;
783 int ret = param_set_int(val, kp);
784
785 if (ret || prev == power_save)
786 return ret;
787
788 mutex_lock(&card_list_lock);
Takashi Iwai9a34af42014-06-26 17:19:20 +0200789 list_for_each_entry(hda, &card_list, list) {
790 chip = &hda->chip;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200791 if (!hda->probe_continued || chip->disabled)
Takashi Iwai65fcd412012-08-14 17:13:32 +0200792 continue;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200793 snd_hda_set_power_save(&chip->bus, power_save * 1000);
Takashi Iwai65fcd412012-08-14 17:13:32 +0200794 }
795 mutex_unlock(&card_list_lock);
796 return 0;
797}
798#else
799#define azx_add_card_list(chip) /* NOP */
800#define azx_del_card_list(chip) /* NOP */
Takashi Iwai83012a72012-08-24 18:38:08 +0200801#endif /* CONFIG_PM */
Takashi Iwai5c0b9be2008-12-11 11:47:17 +0100802
Takashi Iwai7ccbde52012-08-14 18:10:09 +0200803#if defined(CONFIG_PM_SLEEP) || defined(SUPPORT_VGA_SWITCHEROO)
Takashi Iwai5c0b9be2008-12-11 11:47:17 +0100804/*
805 * power management
806 */
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200807static int azx_suspend(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200809 struct snd_card *card = dev_get_drvdata(dev);
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200810 struct azx *chip;
811 struct hda_intel *hda;
Takashi Iwaia41d1222015-04-14 22:13:18 +0200812 struct hdac_bus *bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200814 if (!card)
815 return 0;
816
817 chip = card->private_data;
818 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai1618e842014-07-15 15:27:19 +0200819 if (chip->disabled || hda->init_failed)
Takashi Iwaic5c21522012-12-04 17:01:25 +0100820 return 0;
821
Takashi Iwaia41d1222015-04-14 22:13:18 +0200822 bus = azx_bus(chip);
Takashi Iwai421a1252005-11-17 16:11:09 +0100823 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
Takashi Iwai9ad593f2008-05-16 12:34:47 +0200824 azx_clear_irq_pending(chip);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200825 azx_stop_chip(chip);
Mengdong Lin7295b262013-06-25 05:58:49 -0400826 azx_enter_link_reset(chip);
Takashi Iwaia41d1222015-04-14 22:13:18 +0200827 if (bus->irq >= 0) {
828 free_irq(bus->irq, chip);
829 bus->irq = -1;
Takashi Iwai30b35392006-10-11 18:52:53 +0200830 }
Mengdong Lina07187c2014-06-26 18:45:16 +0800831
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200832 if (chip->msi)
Takashi Iwai43001c92006-09-08 12:30:03 +0200833 pci_disable_msi(chip->pci);
Mengdong Lin795614d2015-04-29 17:43:36 +0800834 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
835 && hda->need_i915_power)
Imre Deak926981a2015-01-08 17:54:16 +0200836 hda_display_power(hda, false);
Libin Yang785d8c42015-05-12 09:43:22 +0800837
838 trace_azx_suspend(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 return 0;
840}
841
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200842static int azx_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200844 struct pci_dev *pci = to_pci_dev(dev);
845 struct snd_card *card = dev_get_drvdata(dev);
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200846 struct azx *chip;
847 struct hda_intel *hda;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200849 if (!card)
850 return 0;
851
852 chip = card->private_data;
853 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai1618e842014-07-15 15:27:19 +0200854 if (chip->disabled || hda->init_failed)
Takashi Iwaic5c21522012-12-04 17:01:25 +0100855 return 0;
856
Mengdong Lin795614d2015-04-29 17:43:36 +0800857 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
858 && hda->need_i915_power) {
Imre Deak926981a2015-01-08 17:54:16 +0200859 hda_display_power(hda, true);
860 haswell_set_bclk(hda);
Mengdong Lina07187c2014-06-26 18:45:16 +0800861 }
Takashi Iwai68e7fff2006-10-23 13:40:59 +0200862 if (chip->msi)
863 if (pci_enable_msi(pci) < 0)
864 chip->msi = 0;
865 if (azx_acquire_irq(chip, 1) < 0)
Takashi Iwai30b35392006-10-11 18:52:53 +0200866 return -EIO;
Takashi Iwaicb53c622007-08-10 17:21:45 +0200867 azx_init_pci(chip);
Maxim Levitskyd804ad92007-09-03 15:28:04 +0200868
Lu, Han0a673522015-05-05 09:05:48 +0800869 hda_intel_init_chip(chip, true);
Maxim Levitskyd804ad92007-09-03 15:28:04 +0200870
Takashi Iwai421a1252005-11-17 16:11:09 +0100871 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
Libin Yang785d8c42015-05-12 09:43:22 +0800872
873 trace_azx_resume(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return 0;
875}
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800876#endif /* CONFIG_PM_SLEEP || SUPPORT_VGA_SWITCHEROO */
877
Rafael J. Wysocki641d3342014-12-13 00:42:18 +0100878#ifdef CONFIG_PM
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800879static int azx_runtime_suspend(struct device *dev)
880{
881 struct snd_card *card = dev_get_drvdata(dev);
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200882 struct azx *chip;
883 struct hda_intel *hda;
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800884
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200885 if (!card)
886 return 0;
887
888 chip = card->private_data;
889 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai1618e842014-07-15 15:27:19 +0200890 if (chip->disabled || hda->init_failed)
Dave Airlie246efa42013-07-29 15:19:29 +1000891 return 0;
892
Takashi Iwai364aa712015-02-19 16:51:17 +0100893 if (!azx_has_pm_runtime(chip))
Dave Airlie246efa42013-07-29 15:19:29 +1000894 return 0;
895
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400896 /* enable controller wake up event */
897 azx_writew(chip, WAKEEN, azx_readw(chip, WAKEEN) |
898 STATESTS_INT_MASK);
899
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800900 azx_stop_chip(chip);
Takashi Iwai873ce8a2013-11-26 11:58:40 +0100901 azx_enter_link_reset(chip);
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800902 azx_clear_irq_pending(chip);
Mengdong Lin795614d2015-04-29 17:43:36 +0800903 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
904 && hda->need_i915_power)
Imre Deak926981a2015-01-08 17:54:16 +0200905 hda_display_power(hda, false);
Mengdong Line4d9e512014-07-03 17:02:23 +0800906
Libin Yang785d8c42015-05-12 09:43:22 +0800907 trace_azx_runtime_suspend(chip);
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800908 return 0;
909}
910
911static int azx_runtime_resume(struct device *dev)
912{
913 struct snd_card *card = dev_get_drvdata(dev);
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200914 struct azx *chip;
915 struct hda_intel *hda;
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400916 struct hda_codec *codec;
917 int status;
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800918
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200919 if (!card)
920 return 0;
921
922 chip = card->private_data;
923 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai1618e842014-07-15 15:27:19 +0200924 if (chip->disabled || hda->init_failed)
Dave Airlie246efa42013-07-29 15:19:29 +1000925 return 0;
926
Takashi Iwai364aa712015-02-19 16:51:17 +0100927 if (!azx_has_pm_runtime(chip))
Dave Airlie246efa42013-07-29 15:19:29 +1000928 return 0;
929
Mengdong Lin795614d2015-04-29 17:43:36 +0800930 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
931 && hda->need_i915_power) {
Imre Deak926981a2015-01-08 17:54:16 +0200932 hda_display_power(hda, true);
933 haswell_set_bclk(hda);
Lu, Han0a673522015-05-05 09:05:48 +0800934 /* toggle codec wakeup bit for STATESTS read */
935 hda_set_codec_wakeup(hda, true);
936 hda_set_codec_wakeup(hda, false);
Mengdong Lina07187c2014-06-26 18:45:16 +0800937 }
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400938
939 /* Read STATESTS before controller reset */
940 status = azx_readw(chip, STATESTS);
941
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800942 azx_init_pci(chip);
Lu, Han0a673522015-05-05 09:05:48 +0800943 hda_intel_init_chip(chip, true);
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400944
Takashi Iwaia41d1222015-04-14 22:13:18 +0200945 if (status) {
946 list_for_each_codec(codec, &chip->bus)
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400947 if (status & (1 << codec->addr))
Takashi Iwai2f35c632015-02-27 22:43:26 +0100948 schedule_delayed_work(&codec->jackpoll_work,
949 codec->jackpoll_interval);
Wang Xingchao7d4f6062013-07-25 23:34:46 -0400950 }
951
952 /* disable controller Wake Up event*/
953 azx_writew(chip, WAKEEN, azx_readw(chip, WAKEEN) &
954 ~STATESTS_INT_MASK);
955
Libin Yang785d8c42015-05-12 09:43:22 +0800956 trace_azx_runtime_resume(chip);
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800957 return 0;
958}
Takashi Iwai6eb827d2012-12-12 11:50:12 +0100959
960static int azx_runtime_idle(struct device *dev)
961{
962 struct snd_card *card = dev_get_drvdata(dev);
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200963 struct azx *chip;
964 struct hda_intel *hda;
Takashi Iwai6eb827d2012-12-12 11:50:12 +0100965
Takashi Iwai2d9772e2014-07-16 16:31:04 +0200966 if (!card)
967 return 0;
968
969 chip = card->private_data;
970 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai1618e842014-07-15 15:27:19 +0200971 if (chip->disabled || hda->init_failed)
Dave Airlie246efa42013-07-29 15:19:29 +1000972 return 0;
973
Takashi Iwai55ed9cd2015-02-19 17:35:32 +0100974 if (!power_save_controller || !azx_has_pm_runtime(chip) ||
Takashi Iwaia41d1222015-04-14 22:13:18 +0200975 azx_bus(chip)->codec_powered)
Takashi Iwai6eb827d2012-12-12 11:50:12 +0100976 return -EBUSY;
977
978 return 0;
979}
980
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800981static const struct dev_pm_ops azx_pm = {
982 SET_SYSTEM_SLEEP_PM_OPS(azx_suspend, azx_resume)
Takashi Iwai6eb827d2012-12-12 11:50:12 +0100983 SET_RUNTIME_PM_OPS(azx_runtime_suspend, azx_runtime_resume, azx_runtime_idle)
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800984};
985
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200986#define AZX_PM_OPS &azx_pm
987#else
Takashi Iwai68cb2b52012-07-02 15:20:37 +0200988#define AZX_PM_OPS NULL
Mengdong Linb8dfc4622012-08-23 17:32:30 +0800989#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991
Takashi Iwai48c8b0e2012-12-07 07:40:35 +0100992static int azx_probe_continue(struct azx *chip);
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200993
Steven Newbury8393ec4a2012-06-08 13:06:29 +0200994#ifdef SUPPORT_VGA_SWITCHEROO
Bill Pembertone23e7a12012-12-06 12:35:10 -0500995static struct pci_dev *get_bound_vga(struct pci_dev *pci);
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200996
Takashi Iwaia82d51e2012-04-26 12:23:42 +0200997static void azx_vs_set_state(struct pci_dev *pci,
998 enum vga_switcheroo_state state)
999{
1000 struct snd_card *card = pci_get_drvdata(pci);
1001 struct azx *chip = card->private_data;
Takashi Iwai9a34af42014-06-26 17:19:20 +02001002 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001003 bool disabled;
1004
Takashi Iwai9a34af42014-06-26 17:19:20 +02001005 wait_for_completion(&hda->probe_wait);
1006 if (hda->init_failed)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001007 return;
1008
1009 disabled = (state == VGA_SWITCHEROO_OFF);
1010 if (chip->disabled == disabled)
1011 return;
1012
Takashi Iwaia41d1222015-04-14 22:13:18 +02001013 if (!hda->probe_continued) {
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001014 chip->disabled = disabled;
1015 if (!disabled) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001016 dev_info(chip->card->dev,
1017 "Start delayed initialization\n");
Takashi Iwai5c906802013-05-30 22:07:09 +08001018 if (azx_probe_continue(chip) < 0) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001019 dev_err(chip->card->dev, "initialization error\n");
Takashi Iwai9a34af42014-06-26 17:19:20 +02001020 hda->init_failed = true;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001021 }
1022 }
1023 } else {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001024 dev_info(chip->card->dev, "%s via VGA-switcheroo\n",
1025 disabled ? "Disabling" : "Enabling");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001026 if (disabled) {
Dylan Reid89287562014-02-28 15:41:15 -08001027 pm_runtime_put_sync_suspend(card->dev);
1028 azx_suspend(card->dev);
Dave Airlie246efa42013-07-29 15:19:29 +10001029 /* when we get suspended by vga switcheroo we end up in D3cold,
1030 * however we have no ACPI handle, so pci/acpi can't put us there,
1031 * put ourselves there */
1032 pci->current_state = PCI_D3cold;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001033 chip->disabled = true;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001034 if (snd_hda_lock_devices(&chip->bus))
Takashi Iwai4e76a882014-02-25 12:21:03 +01001035 dev_warn(chip->card->dev,
1036 "Cannot lock devices!\n");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001037 } else {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001038 snd_hda_unlock_devices(&chip->bus);
Dylan Reid89287562014-02-28 15:41:15 -08001039 pm_runtime_get_noresume(card->dev);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001040 chip->disabled = false;
Dylan Reid89287562014-02-28 15:41:15 -08001041 azx_resume(card->dev);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001042 }
1043 }
1044}
1045
1046static bool azx_vs_can_switch(struct pci_dev *pci)
1047{
1048 struct snd_card *card = pci_get_drvdata(pci);
1049 struct azx *chip = card->private_data;
Takashi Iwai9a34af42014-06-26 17:19:20 +02001050 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001051
Takashi Iwai9a34af42014-06-26 17:19:20 +02001052 wait_for_completion(&hda->probe_wait);
1053 if (hda->init_failed)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001054 return false;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001055 if (chip->disabled || !hda->probe_continued)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001056 return true;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001057 if (snd_hda_lock_devices(&chip->bus))
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001058 return false;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001059 snd_hda_unlock_devices(&chip->bus);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001060 return true;
1061}
1062
Bill Pembertone23e7a12012-12-06 12:35:10 -05001063static void init_vga_switcheroo(struct azx *chip)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001064{
Takashi Iwai9a34af42014-06-26 17:19:20 +02001065 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001066 struct pci_dev *p = get_bound_vga(chip->pci);
1067 if (p) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001068 dev_info(chip->card->dev,
1069 "Handle VGA-switcheroo audio client\n");
Takashi Iwai9a34af42014-06-26 17:19:20 +02001070 hda->use_vga_switcheroo = 1;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001071 pci_dev_put(p);
1072 }
1073}
1074
1075static const struct vga_switcheroo_client_ops azx_vs_ops = {
1076 .set_gpu_state = azx_vs_set_state,
1077 .can_switch = azx_vs_can_switch,
1078};
1079
Bill Pembertone23e7a12012-12-06 12:35:10 -05001080static int register_vga_switcheroo(struct azx *chip)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001081{
Takashi Iwai9a34af42014-06-26 17:19:20 +02001082 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwai128960a2012-10-12 17:28:18 +02001083 int err;
1084
Takashi Iwai9a34af42014-06-26 17:19:20 +02001085 if (!hda->use_vga_switcheroo)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001086 return 0;
1087 /* FIXME: currently only handling DIS controller
1088 * is there any machine with two switchable HDMI audio controllers?
1089 */
Takashi Iwai128960a2012-10-12 17:28:18 +02001090 err = vga_switcheroo_register_audio_client(chip->pci, &azx_vs_ops,
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001091 VGA_SWITCHEROO_DIS,
Takashi Iwaia41d1222015-04-14 22:13:18 +02001092 hda->probe_continued);
Takashi Iwai128960a2012-10-12 17:28:18 +02001093 if (err < 0)
1094 return err;
Takashi Iwai9a34af42014-06-26 17:19:20 +02001095 hda->vga_switcheroo_registered = 1;
Dave Airlie246efa42013-07-29 15:19:29 +10001096
1097 /* register as an optimus hdmi audio power domain */
Dylan Reid89287562014-02-28 15:41:15 -08001098 vga_switcheroo_init_domain_pm_optimus_hdmi_audio(chip->card->dev,
Takashi Iwai9a34af42014-06-26 17:19:20 +02001099 &hda->hdmi_pm_domain);
Takashi Iwai128960a2012-10-12 17:28:18 +02001100 return 0;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001101}
1102#else
1103#define init_vga_switcheroo(chip) /* NOP */
1104#define register_vga_switcheroo(chip) 0
Steven Newbury8393ec4a2012-06-08 13:06:29 +02001105#define check_hdmi_disabled(pci) false
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001106#endif /* SUPPORT_VGA_SWITCHER */
1107
Takashi Iwai0cbf0092008-10-29 16:18:25 +01001108/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 * destructor
1110 */
Takashi Iwaia98f90f2005-11-17 14:59:02 +01001111static int azx_free(struct azx *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112{
Wang Xingchaoc67e2222013-05-30 22:07:08 +08001113 struct pci_dev *pci = chip->pci;
Mengdong Lina07187c2014-06-26 18:45:16 +08001114 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001115 struct hdac_bus *bus = azx_bus(chip);
Takashi Iwai4ce107b2008-02-06 14:50:19 +01001116
Takashi Iwai364aa712015-02-19 16:51:17 +01001117 if (azx_has_pm_runtime(chip) && chip->running)
Wang Xingchaoc67e2222013-05-30 22:07:08 +08001118 pm_runtime_get_noresume(&pci->dev);
1119
Takashi Iwai65fcd412012-08-14 17:13:32 +02001120 azx_del_card_list(chip);
1121
Takashi Iwai9a34af42014-06-26 17:19:20 +02001122 hda->init_failed = 1; /* to be sure */
1123 complete_all(&hda->probe_wait);
Takashi Iwaif4c482a2012-12-04 15:09:23 +01001124
Takashi Iwai9a34af42014-06-26 17:19:20 +02001125 if (use_vga_switcheroo(hda)) {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001126 if (chip->disabled && hda->probe_continued)
1127 snd_hda_unlock_devices(&chip->bus);
Takashi Iwai9a34af42014-06-26 17:19:20 +02001128 if (hda->vga_switcheroo_registered)
Takashi Iwai128960a2012-10-12 17:28:18 +02001129 vga_switcheroo_unregister_client(chip->pci);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001130 }
1131
Takashi Iwaia41d1222015-04-14 22:13:18 +02001132 if (bus->chip_init) {
Takashi Iwai9ad593f2008-05-16 12:34:47 +02001133 azx_clear_irq_pending(chip);
Takashi Iwai7833c3f2015-04-14 18:13:13 +02001134 azx_stop_all_streams(chip);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001135 azx_stop_chip(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 }
1137
Takashi Iwaia41d1222015-04-14 22:13:18 +02001138 if (bus->irq >= 0)
1139 free_irq(bus->irq, (void*)chip);
Takashi Iwai68e7fff2006-10-23 13:40:59 +02001140 if (chip->msi)
Takashi Iwai30b35392006-10-11 18:52:53 +02001141 pci_disable_msi(chip->pci);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001142 iounmap(bus->remap_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Dylan Reid67908992014-02-28 15:41:23 -08001144 azx_free_stream_pages(chip);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001145 azx_free_streams(chip);
1146 snd_hdac_bus_exit(bus);
1147
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001148 if (chip->region_requested)
1149 pci_release_regions(chip->pci);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 pci_disable_device(chip->pci);
Takashi Iwai4918cda2012-08-09 12:33:28 +02001152#ifdef CONFIG_SND_HDA_PATCH_LOADER
Markus Elfringf0acd282014-11-17 10:44:33 +01001153 release_firmware(chip->fw);
Takashi Iwai4918cda2012-08-09 12:33:28 +02001154#endif
Wang Xingchao99a20082013-05-30 22:07:10 +08001155 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
Mengdong Lin795614d2015-04-29 17:43:36 +08001156 if (hda->need_i915_power)
1157 hda_display_power(hda, false);
Imre Deak926981a2015-01-08 17:54:16 +02001158 hda_i915_exit(hda);
Wang Xingchao99a20082013-05-30 22:07:10 +08001159 }
Mengdong Lina07187c2014-06-26 18:45:16 +08001160 kfree(hda);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 return 0;
1163}
1164
Takashi Iwaia41d1222015-04-14 22:13:18 +02001165static int azx_dev_disconnect(struct snd_device *device)
1166{
1167 struct azx *chip = device->device_data;
1168
1169 chip->bus.shutdown = 1;
1170 return 0;
1171}
1172
Takashi Iwaia98f90f2005-11-17 14:59:02 +01001173static int azx_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174{
1175 return azx_free(device->device_data);
1176}
1177
Steven Newbury8393ec4a2012-06-08 13:06:29 +02001178#ifdef SUPPORT_VGA_SWITCHEROO
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179/*
Takashi Iwai91219472012-04-26 12:13:25 +02001180 * Check of disabled HDMI controller by vga-switcheroo
1181 */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001182static struct pci_dev *get_bound_vga(struct pci_dev *pci)
Takashi Iwai91219472012-04-26 12:13:25 +02001183{
1184 struct pci_dev *p;
1185
1186 /* check only discrete GPU */
1187 switch (pci->vendor) {
1188 case PCI_VENDOR_ID_ATI:
1189 case PCI_VENDOR_ID_AMD:
1190 case PCI_VENDOR_ID_NVIDIA:
1191 if (pci->devfn == 1) {
1192 p = pci_get_domain_bus_and_slot(pci_domain_nr(pci->bus),
1193 pci->bus->number, 0);
1194 if (p) {
1195 if ((p->class >> 8) == PCI_CLASS_DISPLAY_VGA)
1196 return p;
1197 pci_dev_put(p);
1198 }
1199 }
1200 break;
1201 }
1202 return NULL;
1203}
1204
Bill Pembertone23e7a12012-12-06 12:35:10 -05001205static bool check_hdmi_disabled(struct pci_dev *pci)
Takashi Iwai91219472012-04-26 12:13:25 +02001206{
1207 bool vga_inactive = false;
1208 struct pci_dev *p = get_bound_vga(pci);
1209
1210 if (p) {
Takashi Iwai12b78a72012-06-07 12:15:16 +02001211 if (vga_switcheroo_get_client_state(p) == VGA_SWITCHEROO_OFF)
Takashi Iwai91219472012-04-26 12:13:25 +02001212 vga_inactive = true;
1213 pci_dev_put(p);
1214 }
1215 return vga_inactive;
1216}
Steven Newbury8393ec4a2012-06-08 13:06:29 +02001217#endif /* SUPPORT_VGA_SWITCHEROO */
Takashi Iwai91219472012-04-26 12:13:25 +02001218
1219/*
Takashi Iwai3372a152007-02-01 15:46:50 +01001220 * white/black-listing for position_fix
1221 */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001222static struct snd_pci_quirk position_fix_list[] = {
Takashi Iwaid2e1c972008-06-10 17:53:34 +02001223 SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB),
1224 SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB),
Takashi Iwai2f703e72009-12-01 14:17:37 +01001225 SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB),
Takashi Iwaid2e1c972008-06-10 17:53:34 +02001226 SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB),
Daniel T Chendd37f8e2010-05-30 01:17:03 -04001227 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS", POS_FIX_LPIB),
Daniel T Chen9f75c1b2010-05-30 13:08:41 -04001228 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS M2V", POS_FIX_LPIB),
Daniel T Chene96d3122010-05-27 18:32:18 -04001229 SND_PCI_QUIRK(0x104d, 0x9069, "Sony VPCS11V9E", POS_FIX_LPIB),
David Henningssonb01de4f2012-01-12 16:31:14 +01001230 SND_PCI_QUIRK(0x10de, 0xcb89, "Macbook Pro 7,1", POS_FIX_LPIB),
Daniel T Chen61bb42c2010-05-29 11:04:11 -04001231 SND_PCI_QUIRK(0x1297, 0x3166, "Shuttle", POS_FIX_LPIB),
Daniel T Chen9ec8dda2010-03-28 02:34:40 -04001232 SND_PCI_QUIRK(0x1458, 0xa022, "ga-ma770-ud3", POS_FIX_LPIB),
Takashi Iwai45d4ebf2009-11-30 11:58:30 +01001233 SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB),
Takashi Iwai8815cd02010-04-15 09:02:41 +02001234 SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB),
Daniel T Chenb90c0762010-05-30 19:31:41 -04001235 SND_PCI_QUIRK(0x1849, 0x0888, "775Dual-VSTA", POS_FIX_LPIB),
Daniel T Chen0e0280d2010-04-21 19:55:43 -04001236 SND_PCI_QUIRK(0x8086, 0x2503, "DG965OT AAD63733-203", POS_FIX_LPIB),
Takashi Iwai3372a152007-02-01 15:46:50 +01001237 {}
1238};
1239
Bill Pembertone23e7a12012-12-06 12:35:10 -05001240static int check_position_fix(struct azx *chip, int fix)
Takashi Iwai3372a152007-02-01 15:46:50 +01001241{
1242 const struct snd_pci_quirk *q;
1243
Takashi Iwaic673ba12009-03-17 07:49:14 +01001244 switch (fix) {
Takashi Iwai1dac6692012-09-13 14:59:47 +02001245 case POS_FIX_AUTO:
Takashi Iwaic673ba12009-03-17 07:49:14 +01001246 case POS_FIX_LPIB:
1247 case POS_FIX_POSBUF:
David Henningsson4cb36312010-09-30 10:12:50 +02001248 case POS_FIX_VIACOMBO:
Takashi Iwaia6f2fd52012-02-28 11:58:40 +01001249 case POS_FIX_COMBO:
Takashi Iwaic673ba12009-03-17 07:49:14 +01001250 return fix;
1251 }
1252
Takashi Iwaic673ba12009-03-17 07:49:14 +01001253 q = snd_pci_quirk_lookup(chip->pci, position_fix_list);
1254 if (q) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001255 dev_info(chip->card->dev,
1256 "position_fix set to %d for device %04x:%04x\n",
1257 q->value, q->subvendor, q->subdevice);
Takashi Iwaic673ba12009-03-17 07:49:14 +01001258 return q->value;
Takashi Iwai3372a152007-02-01 15:46:50 +01001259 }
David Henningssonbdd9ef22010-10-04 12:02:14 +02001260
1261 /* Check VIA/ATI HD Audio Controller exist */
Takashi Iwai9477c582011-05-25 09:11:37 +02001262 if (chip->driver_caps & AZX_DCAPS_POSFIX_VIA) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001263 dev_dbg(chip->card->dev, "Using VIACOMBO position fix\n");
David Henningssonbdd9ef22010-10-04 12:02:14 +02001264 return POS_FIX_VIACOMBO;
1265 }
Takashi Iwai9477c582011-05-25 09:11:37 +02001266 if (chip->driver_caps & AZX_DCAPS_POSFIX_LPIB) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001267 dev_dbg(chip->card->dev, "Using LPIB position fix\n");
Takashi Iwai9477c582011-05-25 09:11:37 +02001268 return POS_FIX_LPIB;
1269 }
Takashi Iwaic673ba12009-03-17 07:49:14 +01001270 return POS_FIX_AUTO;
Takashi Iwai3372a152007-02-01 15:46:50 +01001271}
1272
Takashi Iwaib6050ef2014-06-26 16:50:16 +02001273static void assign_position_fix(struct azx *chip, int fix)
1274{
1275 static azx_get_pos_callback_t callbacks[] = {
1276 [POS_FIX_AUTO] = NULL,
1277 [POS_FIX_LPIB] = azx_get_pos_lpib,
1278 [POS_FIX_POSBUF] = azx_get_pos_posbuf,
1279 [POS_FIX_VIACOMBO] = azx_via_get_position,
1280 [POS_FIX_COMBO] = azx_get_pos_lpib,
1281 };
1282
1283 chip->get_position[0] = chip->get_position[1] = callbacks[fix];
1284
1285 /* combo mode uses LPIB only for playback */
1286 if (fix == POS_FIX_COMBO)
1287 chip->get_position[1] = NULL;
1288
1289 if (fix == POS_FIX_POSBUF &&
1290 (chip->driver_caps & AZX_DCAPS_COUNT_LPIB_DELAY)) {
1291 chip->get_delay[0] = chip->get_delay[1] =
1292 azx_get_delay_from_lpib;
1293 }
1294
1295}
1296
Takashi Iwai3372a152007-02-01 15:46:50 +01001297/*
Takashi Iwai669ba272007-08-17 09:17:36 +02001298 * black-lists for probe_mask
1299 */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001300static struct snd_pci_quirk probe_mask_list[] = {
Takashi Iwai669ba272007-08-17 09:17:36 +02001301 /* Thinkpad often breaks the controller communication when accessing
1302 * to the non-working (or non-existing) modem codec slot.
1303 */
1304 SND_PCI_QUIRK(0x1014, 0x05b7, "Thinkpad Z60", 0x01),
1305 SND_PCI_QUIRK(0x17aa, 0x2010, "Thinkpad X/T/R60", 0x01),
1306 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X/T/R61", 0x01),
Takashi Iwai0edb9452008-11-07 14:53:09 +01001307 /* broken BIOS */
1308 SND_PCI_QUIRK(0x1028, 0x20ac, "Dell Studio Desktop", 0x01),
Takashi Iwaief1681d2008-11-24 17:29:28 +01001309 /* including bogus ALC268 in slot#2 that conflicts with ALC888 */
1310 SND_PCI_QUIRK(0x17c0, 0x4085, "Medion MD96630", 0x01),
Takashi Iwai20db7cb2009-02-13 08:18:48 +01001311 /* forced codec slots */
Ozan Çağlayan93574842009-05-23 15:00:04 +03001312 SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
Takashi Iwai20db7cb2009-02-13 08:18:48 +01001313 SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
Jaroslav Kyselaf3af9052012-04-26 17:52:35 +02001314 /* WinFast VP200 H (Teradici) user reported broken communication */
1315 SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
Takashi Iwai669ba272007-08-17 09:17:36 +02001316 {}
1317};
1318
Takashi Iwaif1eaaee2009-02-13 08:16:55 +01001319#define AZX_FORCE_CODEC_MASK 0x100
1320
Bill Pembertone23e7a12012-12-06 12:35:10 -05001321static void check_probe_mask(struct azx *chip, int dev)
Takashi Iwai669ba272007-08-17 09:17:36 +02001322{
1323 const struct snd_pci_quirk *q;
1324
Takashi Iwaif1eaaee2009-02-13 08:16:55 +01001325 chip->codec_probe_mask = probe_mask[dev];
1326 if (chip->codec_probe_mask == -1) {
Takashi Iwai669ba272007-08-17 09:17:36 +02001327 q = snd_pci_quirk_lookup(chip->pci, probe_mask_list);
1328 if (q) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001329 dev_info(chip->card->dev,
1330 "probe_mask set to 0x%x for device %04x:%04x\n",
1331 q->value, q->subvendor, q->subdevice);
Takashi Iwaif1eaaee2009-02-13 08:16:55 +01001332 chip->codec_probe_mask = q->value;
Takashi Iwai669ba272007-08-17 09:17:36 +02001333 }
1334 }
Takashi Iwaif1eaaee2009-02-13 08:16:55 +01001335
1336 /* check forced option */
1337 if (chip->codec_probe_mask != -1 &&
1338 (chip->codec_probe_mask & AZX_FORCE_CODEC_MASK)) {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001339 azx_bus(chip)->codec_mask = chip->codec_probe_mask & 0xff;
Takashi Iwai4e76a882014-02-25 12:21:03 +01001340 dev_info(chip->card->dev, "codec_mask forced to 0x%x\n",
Takashi Iwaia41d1222015-04-14 22:13:18 +02001341 (int)azx_bus(chip)->codec_mask);
Takashi Iwaif1eaaee2009-02-13 08:16:55 +01001342 }
Takashi Iwai669ba272007-08-17 09:17:36 +02001343}
1344
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001345/*
Takashi Iwai716238552009-09-28 13:14:04 +02001346 * white/black-list for enable_msi
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001347 */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001348static struct snd_pci_quirk msi_black_list[] = {
David Henningsson693e0cb2013-12-12 09:52:03 +01001349 SND_PCI_QUIRK(0x103c, 0x2191, "HP", 0), /* AMD Hudson */
1350 SND_PCI_QUIRK(0x103c, 0x2192, "HP", 0), /* AMD Hudson */
1351 SND_PCI_QUIRK(0x103c, 0x21f7, "HP", 0), /* AMD Hudson */
1352 SND_PCI_QUIRK(0x103c, 0x21fa, "HP", 0), /* AMD Hudson */
Takashi Iwai9dc83982009-12-22 08:15:01 +01001353 SND_PCI_QUIRK(0x1043, 0x81f2, "ASUS", 0), /* Athlon64 X2 + nvidia */
Takashi Iwai0a27fcf2010-02-15 17:05:28 +01001354 SND_PCI_QUIRK(0x1043, 0x81f6, "ASUS", 0), /* nvidia */
Ralf Gerbigecd21622010-03-09 18:25:47 +01001355 SND_PCI_QUIRK(0x1043, 0x822d, "ASUS", 0), /* Athlon64 X2 + nvidia MCP55 */
Takashi Iwai83f72152013-09-09 10:20:48 +02001356 SND_PCI_QUIRK(0x1179, 0xfb44, "Toshiba Satellite C870", 0), /* AMD Hudson */
Michele Ballabio4193d132010-03-06 21:06:46 +01001357 SND_PCI_QUIRK(0x1849, 0x0888, "ASRock", 0), /* Athlon64 X2 + nvidia */
Takashi Iwai38155952010-04-04 12:14:03 +02001358 SND_PCI_QUIRK(0xa0a0, 0x0575, "Aopen MZ915-M", 0), /* ICH6 */
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001359 {}
1360};
1361
Bill Pembertone23e7a12012-12-06 12:35:10 -05001362static void check_msi(struct azx *chip)
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001363{
1364 const struct snd_pci_quirk *q;
1365
Takashi Iwai716238552009-09-28 13:14:04 +02001366 if (enable_msi >= 0) {
1367 chip->msi = !!enable_msi;
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001368 return;
Takashi Iwai716238552009-09-28 13:14:04 +02001369 }
1370 chip->msi = 1; /* enable MSI as default */
1371 q = snd_pci_quirk_lookup(chip->pci, msi_black_list);
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001372 if (q) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001373 dev_info(chip->card->dev,
1374 "msi for device %04x:%04x set to %d\n",
1375 q->subvendor, q->subdevice, q->value);
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001376 chip->msi = q->value;
Takashi Iwai80c43ed2010-03-15 15:51:53 +01001377 return;
1378 }
1379
1380 /* NVidia chipsets seem to cause troubles with MSI */
Takashi Iwai9477c582011-05-25 09:11:37 +02001381 if (chip->driver_caps & AZX_DCAPS_NO_MSI) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001382 dev_info(chip->card->dev, "Disabling MSI\n");
Takashi Iwai80c43ed2010-03-15 15:51:53 +01001383 chip->msi = 0;
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001384 }
1385}
1386
Takashi Iwaia1585d72011-12-14 09:27:04 +01001387/* check the snoop mode availability */
Bill Pembertone23e7a12012-12-06 12:35:10 -05001388static void azx_check_snoop_available(struct azx *chip)
Takashi Iwaia1585d72011-12-14 09:27:04 +01001389{
Takashi Iwai7c732012014-11-25 12:54:16 +01001390 int snoop = hda_snoop;
Takashi Iwaia1585d72011-12-14 09:27:04 +01001391
Takashi Iwai7c732012014-11-25 12:54:16 +01001392 if (snoop >= 0) {
1393 dev_info(chip->card->dev, "Force to %s mode by module option\n",
1394 snoop ? "snoop" : "non-snoop");
1395 chip->snoop = snoop;
1396 return;
1397 }
1398
1399 snoop = true;
Takashi Iwai37e661e2014-11-25 11:28:07 +01001400 if (azx_get_snoop_type(chip) == AZX_SNOOP_TYPE_NONE &&
1401 chip->driver_type == AZX_DRIVER_VIA) {
Takashi Iwaia1585d72011-12-14 09:27:04 +01001402 /* force to non-snoop mode for a new VIA controller
1403 * when BIOS is set
1404 */
Takashi Iwai7c732012014-11-25 12:54:16 +01001405 u8 val;
1406 pci_read_config_byte(chip->pci, 0x42, &val);
1407 if (!(val & 0x80) && chip->pci->revision == 0x30)
1408 snoop = false;
Takashi Iwaia1585d72011-12-14 09:27:04 +01001409 }
1410
Takashi Iwai37e661e2014-11-25 11:28:07 +01001411 if (chip->driver_caps & AZX_DCAPS_SNOOP_OFF)
1412 snoop = false;
1413
Takashi Iwai7c732012014-11-25 12:54:16 +01001414 chip->snoop = snoop;
1415 if (!snoop)
1416 dev_info(chip->card->dev, "Force to non-snoop mode\n");
Takashi Iwaia1585d72011-12-14 09:27:04 +01001417}
Takashi Iwai669ba272007-08-17 09:17:36 +02001418
Wang Xingchao99a20082013-05-30 22:07:10 +08001419static void azx_probe_work(struct work_struct *work)
1420{
Takashi Iwai9a34af42014-06-26 17:19:20 +02001421 struct hda_intel *hda = container_of(work, struct hda_intel, probe_work);
1422 azx_probe_continue(&hda->chip);
Wang Xingchao99a20082013-05-30 22:07:10 +08001423}
Wang Xingchao99a20082013-05-30 22:07:10 +08001424
Takashi Iwai669ba272007-08-17 09:17:36 +02001425/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 * constructor
1427 */
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001428static const struct hdac_io_ops pci_hda_io_ops;
1429static const struct hda_controller_ops pci_hda_ops;
1430
Bill Pembertone23e7a12012-12-06 12:35:10 -05001431static int azx_create(struct snd_card *card, struct pci_dev *pci,
1432 int dev, unsigned int driver_caps,
1433 struct azx **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434{
Takashi Iwaia98f90f2005-11-17 14:59:02 +01001435 static struct snd_device_ops ops = {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001436 .dev_disconnect = azx_dev_disconnect,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 .dev_free = azx_dev_free,
1438 };
Mengdong Lina07187c2014-06-26 18:45:16 +08001439 struct hda_intel *hda;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001440 struct azx *chip;
1441 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
1443 *rchip = NULL;
Tobin Davisbcd72002008-01-15 11:23:55 +01001444
Pavel Machek927fc862006-08-31 17:03:43 +02001445 err = pci_enable_device(pci);
1446 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 return err;
1448
Mengdong Lina07187c2014-06-26 18:45:16 +08001449 hda = kzalloc(sizeof(*hda), GFP_KERNEL);
1450 if (!hda) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 pci_disable_device(pci);
1452 return -ENOMEM;
1453 }
1454
Mengdong Lina07187c2014-06-26 18:45:16 +08001455 chip = &hda->chip;
Ingo Molnar62932df2006-01-16 16:34:20 +01001456 mutex_init(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 chip->card = card;
1458 chip->pci = pci;
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001459 chip->ops = &pci_hda_ops;
Takashi Iwai9477c582011-05-25 09:11:37 +02001460 chip->driver_caps = driver_caps;
1461 chip->driver_type = driver_caps & 0xff;
Takashi Iwai4d8e22e2009-08-11 14:21:26 +02001462 check_msi(chip);
Takashi Iwai555e2192008-06-10 17:53:34 +02001463 chip->dev_index = dev;
Dylan Reid749ee282014-02-28 15:41:18 -08001464 chip->jackpoll_ms = jackpoll_ms;
Takashi Iwai01b65bf2011-11-24 14:31:46 +01001465 INIT_LIST_HEAD(&chip->pcm_list);
Takashi Iwai9a34af42014-06-26 17:19:20 +02001466 INIT_WORK(&hda->irq_pending_work, azx_irq_pending_work);
1467 INIT_LIST_HEAD(&hda->list);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001468 init_vga_switcheroo(chip);
Takashi Iwai9a34af42014-06-26 17:19:20 +02001469 init_completion(&hda->probe_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Takashi Iwaib6050ef2014-06-26 16:50:16 +02001471 assign_position_fix(chip, check_position_fix(chip, position_fix[dev]));
Takashi Iwaia6f2fd52012-02-28 11:58:40 +01001472
Takashi Iwai5aba4f82008-01-07 15:16:37 +01001473 check_probe_mask(chip, dev);
Takashi Iwai3372a152007-02-01 15:46:50 +01001474
Takashi Iwai27346162006-01-12 18:28:44 +01001475 chip->single_cmd = single_cmd;
Takashi Iwaia1585d72011-12-14 09:27:04 +01001476 azx_check_snoop_available(chip);
Takashi Iwaic74db862005-05-12 14:26:27 +02001477
Takashi Iwai5c0d7bc2008-06-10 17:53:35 +02001478 if (bdl_pos_adj[dev] < 0) {
1479 switch (chip->driver_type) {
Takashi Iwai0c6341a2008-06-13 20:50:27 +02001480 case AZX_DRIVER_ICH:
Seth Heasley32679f92010-02-22 17:31:09 -08001481 case AZX_DRIVER_PCH:
Takashi Iwai0c6341a2008-06-13 20:50:27 +02001482 bdl_pos_adj[dev] = 1;
Takashi Iwai5c0d7bc2008-06-10 17:53:35 +02001483 break;
1484 default:
Takashi Iwai0c6341a2008-06-13 20:50:27 +02001485 bdl_pos_adj[dev] = 32;
Takashi Iwai5c0d7bc2008-06-10 17:53:35 +02001486 break;
1487 }
1488 }
Dylan Reid9cdc0112014-02-28 15:41:14 -08001489 chip->bdl_pos_adj = bdl_pos_adj;
Takashi Iwai5c0d7bc2008-06-10 17:53:35 +02001490
Takashi Iwaia41d1222015-04-14 22:13:18 +02001491 err = azx_bus_init(chip, model[dev], &pci_hda_io_ops);
1492 if (err < 0) {
1493 kfree(hda);
1494 pci_disable_device(pci);
1495 return err;
1496 }
1497
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001498 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1499 if (err < 0) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001500 dev_err(card->dev, "Error creating device [card]!\n");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001501 azx_free(chip);
1502 return err;
1503 }
1504
Wang Xingchao99a20082013-05-30 22:07:10 +08001505 /* continue probing in work context as may trigger request module */
Takashi Iwai9a34af42014-06-26 17:19:20 +02001506 INIT_WORK(&hda->probe_work, azx_probe_work);
Wang Xingchao99a20082013-05-30 22:07:10 +08001507
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001508 *rchip = chip;
Wang Xingchao99a20082013-05-30 22:07:10 +08001509
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001510 return 0;
1511}
1512
Takashi Iwai48c8b0e2012-12-07 07:40:35 +01001513static int azx_first_init(struct azx *chip)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001514{
1515 int dev = chip->dev_index;
1516 struct pci_dev *pci = chip->pci;
1517 struct snd_card *card = chip->card;
Takashi Iwaia41d1222015-04-14 22:13:18 +02001518 struct hdac_bus *bus = azx_bus(chip);
Dylan Reid67908992014-02-28 15:41:23 -08001519 int err;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001520 unsigned short gcap;
Takashi Iwai413cbf42014-10-01 10:30:53 +02001521 unsigned int dma_bits = 64;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001522
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001523#if BITS_PER_LONG != 64
1524 /* Fix up base address on ULI M5461 */
1525 if (chip->driver_type == AZX_DRIVER_ULI) {
1526 u16 tmp3;
1527 pci_read_config_word(pci, 0x40, &tmp3);
1528 pci_write_config_word(pci, 0x40, tmp3 | 0x10);
1529 pci_write_config_dword(pci, PCI_BASE_ADDRESS_1, 0);
1530 }
1531#endif
1532
Pavel Machek927fc862006-08-31 17:03:43 +02001533 err = pci_request_regions(pci, "ICH HD audio");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001534 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 return err;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001536 chip->region_requested = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Takashi Iwaia41d1222015-04-14 22:13:18 +02001538 bus->addr = pci_resource_start(pci, 0);
1539 bus->remap_addr = pci_ioremap_bar(pci, 0);
1540 if (bus->remap_addr == NULL) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001541 dev_err(card->dev, "ioremap error\n");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001542 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 }
1544
Benjamin Herrenschmidtdb79afa2014-11-24 14:17:08 +11001545 if (chip->msi) {
1546 if (chip->driver_caps & AZX_DCAPS_NO_MSI64) {
1547 dev_dbg(card->dev, "Disabling 64bit MSI\n");
1548 pci->no_64bit_msi = true;
1549 }
Takashi Iwai68e7fff2006-10-23 13:40:59 +02001550 if (pci_enable_msi(pci) < 0)
1551 chip->msi = 0;
Benjamin Herrenschmidtdb79afa2014-11-24 14:17:08 +11001552 }
Stephen Hemminger7376d012006-08-21 19:17:46 +02001553
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001554 if (azx_acquire_irq(chip, 0) < 0)
1555 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556
1557 pci_set_master(pci);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001558 synchronize_irq(bus->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
Tobin Davisbcd72002008-01-15 11:23:55 +01001560 gcap = azx_readw(chip, GCAP);
Takashi Iwai4e76a882014-02-25 12:21:03 +01001561 dev_dbg(card->dev, "chipset global capabilities = 0x%x\n", gcap);
Tobin Davisbcd72002008-01-15 11:23:55 +01001562
Takashi Iwai413cbf42014-10-01 10:30:53 +02001563 /* AMD devices support 40 or 48bit DMA, take the safe one */
1564 if (chip->pci->vendor == PCI_VENDOR_ID_AMD)
1565 dma_bits = 40;
1566
Andiry Brienzadc4c2e62009-07-08 13:55:31 +08001567 /* disable SB600 64bit support for safety */
Takashi Iwai9477c582011-05-25 09:11:37 +02001568 if (chip->pci->vendor == PCI_VENDOR_ID_ATI) {
Andiry Brienzadc4c2e62009-07-08 13:55:31 +08001569 struct pci_dev *p_smbus;
Takashi Iwai413cbf42014-10-01 10:30:53 +02001570 dma_bits = 40;
Andiry Brienzadc4c2e62009-07-08 13:55:31 +08001571 p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
1572 PCI_DEVICE_ID_ATI_SBX00_SMBUS,
1573 NULL);
1574 if (p_smbus) {
1575 if (p_smbus->revision < 0x30)
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +02001576 gcap &= ~AZX_GCAP_64OK;
Andiry Brienzadc4c2e62009-07-08 13:55:31 +08001577 pci_dev_put(p_smbus);
1578 }
1579 }
Takashi Iwai09240cf2009-03-17 07:47:18 +01001580
Takashi Iwai9477c582011-05-25 09:11:37 +02001581 /* disable 64bit DMA address on some devices */
1582 if (chip->driver_caps & AZX_DCAPS_NO_64BIT) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001583 dev_dbg(card->dev, "Disabling 64bit DMA\n");
Takashi Iwaifb1d8ac2014-06-26 17:54:37 +02001584 gcap &= ~AZX_GCAP_64OK;
Takashi Iwai9477c582011-05-25 09:11:37 +02001585 }
Jaroslav Kysela396087e2009-12-09 10:44:47 +01001586
Pierre-Louis Bossart2ae66c22011-08-04 10:12:56 -05001587 /* disable buffer size rounding to 128-byte multiples if supported */
Takashi Iwai7bfe0592012-01-23 17:53:39 +01001588 if (align_buffer_size >= 0)
1589 chip->align_buffer_size = !!align_buffer_size;
1590 else {
Takashi Iwai103884a2014-12-03 09:56:20 +01001591 if (chip->driver_caps & AZX_DCAPS_NO_ALIGN_BUFSIZE)
Takashi Iwai7bfe0592012-01-23 17:53:39 +01001592 chip->align_buffer_size = 0;
Takashi Iwai7bfe0592012-01-23 17:53:39 +01001593 else
1594 chip->align_buffer_size = 1;
1595 }
Pierre-Louis Bossart2ae66c22011-08-04 10:12:56 -05001596
Takashi Iwaicf7aaca2008-02-06 15:05:57 +01001597 /* allow 64bit DMA address if supported by H/W */
Takashi Iwai413cbf42014-10-01 10:30:53 +02001598 if (!(gcap & AZX_GCAP_64OK))
1599 dma_bits = 32;
Quentin Lambert412b9792015-04-15 16:10:17 +02001600 if (!dma_set_mask(&pci->dev, DMA_BIT_MASK(dma_bits))) {
1601 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(dma_bits));
Takashi Iwai413cbf42014-10-01 10:30:53 +02001602 } else {
Quentin Lambert412b9792015-04-15 16:10:17 +02001603 dma_set_mask(&pci->dev, DMA_BIT_MASK(32));
1604 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32));
Takashi Iwai09240cf2009-03-17 07:47:18 +01001605 }
Takashi Iwaicf7aaca2008-02-06 15:05:57 +01001606
Takashi Iwai8b6ed8e2008-02-19 11:36:35 +01001607 /* read number of streams from GCAP register instead of using
1608 * hardcoded value
1609 */
1610 chip->capture_streams = (gcap >> 8) & 0x0f;
1611 chip->playback_streams = (gcap >> 12) & 0x0f;
1612 if (!chip->playback_streams && !chip->capture_streams) {
Tobin Davisbcd72002008-01-15 11:23:55 +01001613 /* gcap didn't give any info, switching to old method */
1614
1615 switch (chip->driver_type) {
1616 case AZX_DRIVER_ULI:
1617 chip->playback_streams = ULI_NUM_PLAYBACK;
1618 chip->capture_streams = ULI_NUM_CAPTURE;
Tobin Davisbcd72002008-01-15 11:23:55 +01001619 break;
1620 case AZX_DRIVER_ATIHDMI:
Andiry Xu1815b342011-12-14 16:10:27 +08001621 case AZX_DRIVER_ATIHDMI_NS:
Tobin Davisbcd72002008-01-15 11:23:55 +01001622 chip->playback_streams = ATIHDMI_NUM_PLAYBACK;
1623 chip->capture_streams = ATIHDMI_NUM_CAPTURE;
Tobin Davisbcd72002008-01-15 11:23:55 +01001624 break;
Yang, Libinc4da29c2008-11-13 11:07:07 +01001625 case AZX_DRIVER_GENERIC:
Tobin Davisbcd72002008-01-15 11:23:55 +01001626 default:
1627 chip->playback_streams = ICH6_NUM_PLAYBACK;
1628 chip->capture_streams = ICH6_NUM_CAPTURE;
Tobin Davisbcd72002008-01-15 11:23:55 +01001629 break;
1630 }
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001631 }
Takashi Iwai8b6ed8e2008-02-19 11:36:35 +01001632 chip->capture_index_offset = 0;
1633 chip->playback_index_offset = chip->capture_streams;
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001634 chip->num_streams = chip->playback_streams + chip->capture_streams;
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001635
Takashi Iwaia41d1222015-04-14 22:13:18 +02001636 /* initialize streams */
1637 err = azx_init_streams(chip);
Dylan Reid67908992014-02-28 15:41:23 -08001638 if (err < 0)
1639 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
1641 err = azx_alloc_stream_pages(chip);
1642 if (err < 0)
1643 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 /* initialize chip */
Takashi Iwaicb53c622007-08-10 17:21:45 +02001646 azx_init_pci(chip);
Mengdong Line4d9e512014-07-03 17:02:23 +08001647
Imre Deak926981a2015-01-08 17:54:16 +02001648 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
1649 struct hda_intel *hda;
1650
1651 hda = container_of(chip, struct hda_intel, chip);
1652 haswell_set_bclk(hda);
1653 }
Mengdong Line4d9e512014-07-03 17:02:23 +08001654
Lu, Han0a673522015-05-05 09:05:48 +08001655 hda_intel_init_chip(chip, (probe_only[dev] & 2) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656
1657 /* codec detection */
Takashi Iwaia41d1222015-04-14 22:13:18 +02001658 if (!azx_bus(chip)->codec_mask) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001659 dev_err(card->dev, "no codecs found!\n");
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001660 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 }
1662
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001663 strcpy(card->driver, "HDA-Intel");
Takashi Iwai18cb7102009-04-16 10:22:24 +02001664 strlcpy(card->shortname, driver_short_names[chip->driver_type],
1665 sizeof(card->shortname));
1666 snprintf(card->longname, sizeof(card->longname),
1667 "%s at 0x%lx irq %i",
Takashi Iwaia41d1222015-04-14 22:13:18 +02001668 card->shortname, bus->addr, bus->irq);
Takashi Iwai07e4ca52005-08-24 14:14:57 +02001669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671}
1672
Takashi Iwai97c6a3d2012-08-09 17:40:46 +02001673#ifdef CONFIG_SND_HDA_PATCH_LOADER
Takashi Iwai5cb543d2012-08-09 13:49:23 +02001674/* callback from request_firmware_nowait() */
1675static void azx_firmware_cb(const struct firmware *fw, void *context)
1676{
1677 struct snd_card *card = context;
1678 struct azx *chip = card->private_data;
1679 struct pci_dev *pci = chip->pci;
1680
1681 if (!fw) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001682 dev_err(card->dev, "Cannot load firmware, aborting\n");
Takashi Iwai5cb543d2012-08-09 13:49:23 +02001683 goto error;
1684 }
1685
1686 chip->fw = fw;
1687 if (!chip->disabled) {
1688 /* continue probing */
1689 if (azx_probe_continue(chip))
1690 goto error;
1691 }
1692 return; /* OK */
1693
1694 error:
1695 snd_card_free(card);
1696 pci_set_drvdata(pci, NULL);
1697}
Takashi Iwai97c6a3d2012-08-09 17:40:46 +02001698#endif
Takashi Iwai5cb543d2012-08-09 13:49:23 +02001699
Dylan Reid40830812014-02-28 15:41:13 -08001700/*
1701 * HDA controller ops.
1702 */
1703
1704/* PCI register access. */
Dylan Reiddb291e32014-03-02 20:44:01 -08001705static void pci_azx_writel(u32 value, u32 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001706{
1707 writel(value, addr);
1708}
1709
Dylan Reiddb291e32014-03-02 20:44:01 -08001710static u32 pci_azx_readl(u32 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001711{
1712 return readl(addr);
1713}
1714
Dylan Reiddb291e32014-03-02 20:44:01 -08001715static void pci_azx_writew(u16 value, u16 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001716{
1717 writew(value, addr);
1718}
1719
Dylan Reiddb291e32014-03-02 20:44:01 -08001720static u16 pci_azx_readw(u16 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001721{
1722 return readw(addr);
1723}
1724
Dylan Reiddb291e32014-03-02 20:44:01 -08001725static void pci_azx_writeb(u8 value, u8 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001726{
1727 writeb(value, addr);
1728}
1729
Dylan Reiddb291e32014-03-02 20:44:01 -08001730static u8 pci_azx_readb(u8 __iomem *addr)
Dylan Reid40830812014-02-28 15:41:13 -08001731{
1732 return readb(addr);
1733}
1734
Dylan Reidf46ea602014-02-28 15:41:16 -08001735static int disable_msi_reset_irq(struct azx *chip)
1736{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001737 struct hdac_bus *bus = azx_bus(chip);
Dylan Reidf46ea602014-02-28 15:41:16 -08001738 int err;
1739
Takashi Iwaia41d1222015-04-14 22:13:18 +02001740 free_irq(bus->irq, chip);
1741 bus->irq = -1;
Dylan Reidf46ea602014-02-28 15:41:16 -08001742 pci_disable_msi(chip->pci);
1743 chip->msi = 0;
1744 err = azx_acquire_irq(chip, 1);
1745 if (err < 0)
1746 return err;
1747
1748 return 0;
1749}
1750
Dylan Reidb419b352014-02-28 15:41:20 -08001751/* DMA page allocation helpers. */
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001752static int dma_alloc_pages(struct hdac_bus *bus,
Dylan Reidb419b352014-02-28 15:41:20 -08001753 int type,
1754 size_t size,
1755 struct snd_dma_buffer *buf)
1756{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001757 struct azx *chip = bus_to_azx(bus);
Dylan Reidb419b352014-02-28 15:41:20 -08001758 int err;
1759
1760 err = snd_dma_alloc_pages(type,
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001761 bus->dev,
Dylan Reidb419b352014-02-28 15:41:20 -08001762 size, buf);
1763 if (err < 0)
1764 return err;
1765 mark_pages_wc(chip, buf, true);
1766 return 0;
1767}
1768
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001769static void dma_free_pages(struct hdac_bus *bus, struct snd_dma_buffer *buf)
Dylan Reidb419b352014-02-28 15:41:20 -08001770{
Takashi Iwaia41d1222015-04-14 22:13:18 +02001771 struct azx *chip = bus_to_azx(bus);
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001772
Dylan Reidb419b352014-02-28 15:41:20 -08001773 mark_pages_wc(chip, buf, false);
1774 snd_dma_free_pages(buf);
1775}
1776
1777static int substream_alloc_pages(struct azx *chip,
1778 struct snd_pcm_substream *substream,
1779 size_t size)
1780{
1781 struct azx_dev *azx_dev = get_azx_dev(substream);
1782 int ret;
1783
1784 mark_runtime_wc(chip, azx_dev, substream, false);
Dylan Reidb419b352014-02-28 15:41:20 -08001785 ret = snd_pcm_lib_malloc_pages(substream, size);
1786 if (ret < 0)
1787 return ret;
1788 mark_runtime_wc(chip, azx_dev, substream, true);
1789 return 0;
1790}
1791
1792static int substream_free_pages(struct azx *chip,
1793 struct snd_pcm_substream *substream)
1794{
1795 struct azx_dev *azx_dev = get_azx_dev(substream);
1796 mark_runtime_wc(chip, azx_dev, substream, false);
1797 return snd_pcm_lib_free_pages(substream);
1798}
1799
Dylan Reid8769b272014-02-28 15:41:21 -08001800static void pcm_mmap_prepare(struct snd_pcm_substream *substream,
1801 struct vm_area_struct *area)
1802{
1803#ifdef CONFIG_X86
1804 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
1805 struct azx *chip = apcm->chip;
Takashi Iwai3b70bdb2014-10-29 16:13:05 +01001806 if (!azx_snoop(chip) && chip->driver_type != AZX_DRIVER_CMEDIA)
Dylan Reid8769b272014-02-28 15:41:21 -08001807 area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
1808#endif
1809}
1810
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001811static const struct hdac_io_ops pci_hda_io_ops = {
Dylan Reid778bde62014-03-02 20:44:00 -08001812 .reg_writel = pci_azx_writel,
1813 .reg_readl = pci_azx_readl,
1814 .reg_writew = pci_azx_writew,
1815 .reg_readw = pci_azx_readw,
1816 .reg_writeb = pci_azx_writeb,
1817 .reg_readb = pci_azx_readb,
Dylan Reidb419b352014-02-28 15:41:20 -08001818 .dma_alloc_pages = dma_alloc_pages,
1819 .dma_free_pages = dma_free_pages,
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001820};
1821
1822static const struct hda_controller_ops pci_hda_ops = {
1823 .disable_msi_reset_irq = disable_msi_reset_irq,
Dylan Reidb419b352014-02-28 15:41:20 -08001824 .substream_alloc_pages = substream_alloc_pages,
1825 .substream_free_pages = substream_free_pages,
Dylan Reid8769b272014-02-28 15:41:21 -08001826 .pcm_mmap_prepare = pcm_mmap_prepare,
Dylan Reid7ca954a2014-02-28 15:41:28 -08001827 .position_check = azx_position_check,
Mengdong Lin17eccb22015-04-29 17:43:29 +08001828 .link_power = azx_intel_link_power,
Dylan Reid40830812014-02-28 15:41:13 -08001829};
1830
Bill Pembertone23e7a12012-12-06 12:35:10 -05001831static int azx_probe(struct pci_dev *pci,
1832 const struct pci_device_id *pci_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833{
Takashi Iwai5aba4f82008-01-07 15:16:37 +01001834 static int dev;
Takashi Iwaia98f90f2005-11-17 14:59:02 +01001835 struct snd_card *card;
Takashi Iwai9a34af42014-06-26 17:19:20 +02001836 struct hda_intel *hda;
Takashi Iwaia98f90f2005-11-17 14:59:02 +01001837 struct azx *chip;
Takashi Iwaiaad730d2013-12-02 13:33:57 +01001838 bool schedule_probe;
Pavel Machek927fc862006-08-31 17:03:43 +02001839 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840
Takashi Iwai5aba4f82008-01-07 15:16:37 +01001841 if (dev >= SNDRV_CARDS)
1842 return -ENODEV;
1843 if (!enable[dev]) {
1844 dev++;
1845 return -ENOENT;
1846 }
1847
Takashi Iwai60c57722014-01-29 14:20:19 +01001848 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1849 0, &card);
Takashi Iwaie58de7b2008-12-28 16:44:30 +01001850 if (err < 0) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001851 dev_err(&pci->dev, "Error creating card!\n");
Takashi Iwaie58de7b2008-12-28 16:44:30 +01001852 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 }
1854
Takashi Iwaia43ff5b2015-04-14 17:26:00 +02001855 err = azx_create(card, pci, dev, pci_id->driver_data, &chip);
Wu Fengguang41dda0f2008-11-20 09:24:52 +08001856 if (err < 0)
1857 goto out_free;
Takashi Iwai421a1252005-11-17 16:11:09 +01001858 card->private_data = chip;
Takashi Iwai9a34af42014-06-26 17:19:20 +02001859 hda = container_of(chip, struct hda_intel, chip);
Takashi Iwaif4c482a2012-12-04 15:09:23 +01001860
1861 pci_set_drvdata(pci, card);
1862
1863 err = register_vga_switcheroo(chip);
1864 if (err < 0) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001865 dev_err(card->dev, "Error registering VGA-switcheroo client\n");
Takashi Iwaif4c482a2012-12-04 15:09:23 +01001866 goto out_free;
1867 }
1868
1869 if (check_hdmi_disabled(pci)) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001870 dev_info(card->dev, "VGA controller is disabled\n");
1871 dev_info(card->dev, "Delaying initialization\n");
Takashi Iwaif4c482a2012-12-04 15:09:23 +01001872 chip->disabled = true;
1873 }
1874
Takashi Iwaiaad730d2013-12-02 13:33:57 +01001875 schedule_probe = !chip->disabled;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876
Takashi Iwai4918cda2012-08-09 12:33:28 +02001877#ifdef CONFIG_SND_HDA_PATCH_LOADER
1878 if (patch[dev] && *patch[dev]) {
Takashi Iwai4e76a882014-02-25 12:21:03 +01001879 dev_info(card->dev, "Applying patch firmware '%s'\n",
1880 patch[dev]);
Takashi Iwai5cb543d2012-08-09 13:49:23 +02001881 err = request_firmware_nowait(THIS_MODULE, true, patch[dev],
1882 &pci->dev, GFP_KERNEL, card,
1883 azx_firmware_cb);
Takashi Iwai4918cda2012-08-09 12:33:28 +02001884 if (err < 0)
1885 goto out_free;
Takashi Iwaiaad730d2013-12-02 13:33:57 +01001886 schedule_probe = false; /* continued in azx_firmware_cb() */
Takashi Iwai4918cda2012-08-09 12:33:28 +02001887 }
1888#endif /* CONFIG_SND_HDA_PATCH_LOADER */
1889
Takashi Iwaiaad730d2013-12-02 13:33:57 +01001890#ifndef CONFIG_SND_HDA_I915
1891 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
Takashi Iwai4e76a882014-02-25 12:21:03 +01001892 dev_err(card->dev, "Haswell must build in CONFIG_SND_HDA_I915\n");
Wang Xingchao99a20082013-05-30 22:07:10 +08001893#endif
Wang Xingchao99a20082013-05-30 22:07:10 +08001894
Takashi Iwaiaad730d2013-12-02 13:33:57 +01001895 if (schedule_probe)
Takashi Iwai9a34af42014-06-26 17:19:20 +02001896 schedule_work(&hda->probe_work);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001897
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001898 dev++;
Takashi Iwai88d071f2013-12-02 11:12:28 +01001899 if (chip->disabled)
Takashi Iwai9a34af42014-06-26 17:19:20 +02001900 complete_all(&hda->probe_wait);
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001901 return 0;
1902
1903out_free:
1904 snd_card_free(card);
1905 return err;
1906}
1907
Dylan Reide62a42a2014-02-28 15:41:19 -08001908/* number of codec slots for each chipset: 0 = default slots (i.e. 4) */
1909static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] = {
1910 [AZX_DRIVER_NVIDIA] = 8,
1911 [AZX_DRIVER_TERA] = 1,
1912};
1913
Takashi Iwai48c8b0e2012-12-07 07:40:35 +01001914static int azx_probe_continue(struct azx *chip)
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001915{
Takashi Iwai9a34af42014-06-26 17:19:20 +02001916 struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
Wang Xingchaoc67e2222013-05-30 22:07:08 +08001917 struct pci_dev *pci = chip->pci;
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001918 int dev = chip->dev_index;
1919 int err;
1920
Takashi Iwaia41d1222015-04-14 22:13:18 +02001921 hda->probe_continued = 1;
Mengdong Lin795614d2015-04-29 17:43:36 +08001922
1923 /* Request display power well for the HDA controller or codec. For
1924 * Haswell/Broadwell, both the display HDA controller and codec need
1925 * this power. For other platforms, like Baytrail/Braswell, only the
1926 * display codec needs the power and it can be released after probe.
1927 */
Wang Xingchao99a20082013-05-30 22:07:10 +08001928 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
Mengdong Lin2bd1f73f2015-04-29 17:43:43 +08001929 /* Baytral/Braswell controllers don't need this power */
1930 if (pci->device != 0x0f04 && pci->device != 0x2284)
1931 hda->need_i915_power = 1;
1932
Imre Deak926981a2015-01-08 17:54:16 +02001933 err = hda_i915_init(hda);
Imre Deakd7055bd2015-01-08 17:54:17 +02001934 if (err < 0)
Mengdong Lin795614d2015-04-29 17:43:36 +08001935 goto i915_power_fail;
1936
Imre Deak926981a2015-01-08 17:54:16 +02001937 err = hda_display_power(hda, true);
Takashi Iwai74b0c2d2014-06-13 15:14:34 +02001938 if (err < 0) {
1939 dev_err(chip->card->dev,
1940 "Cannot turn on display power on i915\n");
Mengdong Lin795614d2015-04-29 17:43:36 +08001941 goto i915_power_fail;
Takashi Iwai74b0c2d2014-06-13 15:14:34 +02001942 }
Wang Xingchao99a20082013-05-30 22:07:10 +08001943 }
1944
Takashi Iwai5c906802013-05-30 22:07:09 +08001945 err = azx_first_init(chip);
1946 if (err < 0)
1947 goto out_free;
1948
Jaroslav Kysela2dca0bb2009-11-13 18:41:52 +01001949#ifdef CONFIG_SND_HDA_INPUT_BEEP
1950 chip->beep_mode = beep_mode[dev];
1951#endif
1952
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 /* create codec instances */
Takashi Iwai96d2bd62015-02-19 18:12:22 +01001954 err = azx_probe_codecs(chip, azx_max_codecs[chip->driver_type]);
1955 if (err < 0)
1956 goto out_free;
1957
Takashi Iwai4ea6fbc2009-06-17 09:52:54 +02001958#ifdef CONFIG_SND_HDA_PATCH_LOADER
Takashi Iwai4918cda2012-08-09 12:33:28 +02001959 if (chip->fw) {
Takashi Iwaia41d1222015-04-14 22:13:18 +02001960 err = snd_hda_load_patch(&chip->bus, chip->fw->size,
Takashi Iwai4918cda2012-08-09 12:33:28 +02001961 chip->fw->data);
Takashi Iwai4ea6fbc2009-06-17 09:52:54 +02001962 if (err < 0)
1963 goto out_free;
Takashi Iwaie39ae852012-11-22 16:18:13 +01001964#ifndef CONFIG_PM
Takashi Iwai4918cda2012-08-09 12:33:28 +02001965 release_firmware(chip->fw); /* no longer needed */
1966 chip->fw = NULL;
Takashi Iwaie39ae852012-11-22 16:18:13 +01001967#endif
Takashi Iwai4ea6fbc2009-06-17 09:52:54 +02001968 }
1969#endif
Jaroslav Kysela10e77dd2010-03-26 11:04:38 +01001970 if ((probe_only[dev] & 1) == 0) {
Takashi Iwaia1e21c92009-06-17 09:33:52 +02001971 err = azx_codec_configure(chip);
1972 if (err < 0)
1973 goto out_free;
1974 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
Takashi Iwaia82d51e2012-04-26 12:23:42 +02001976 err = snd_card_register(chip->card);
Wu Fengguang41dda0f2008-11-20 09:24:52 +08001977 if (err < 0)
1978 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Takashi Iwaicb53c622007-08-10 17:21:45 +02001980 chip->running = 1;
Takashi Iwai65fcd412012-08-14 17:13:32 +02001981 azx_add_card_list(chip);
Takashi Iwaia41d1222015-04-14 22:13:18 +02001982 snd_hda_set_power_save(&chip->bus, power_save * 1000);
Takashi Iwai364aa712015-02-19 16:51:17 +01001983 if (azx_has_pm_runtime(chip) || hda->use_vga_switcheroo)
Wang Xingchaoc67e2222013-05-30 22:07:08 +08001984 pm_runtime_put_noidle(&pci->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985
Wu Fengguang41dda0f2008-11-20 09:24:52 +08001986out_free:
Mengdong Lin795614d2015-04-29 17:43:36 +08001987 if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL
1988 && !hda->need_i915_power)
1989 hda_display_power(hda, false);
1990
1991i915_power_fail:
Takashi Iwai88d071f2013-12-02 11:12:28 +01001992 if (err < 0)
Takashi Iwai9a34af42014-06-26 17:19:20 +02001993 hda->init_failed = 1;
1994 complete_all(&hda->probe_wait);
Wu Fengguang41dda0f2008-11-20 09:24:52 +08001995 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996}
1997
Bill Pembertone23e7a12012-12-06 12:35:10 -05001998static void azx_remove(struct pci_dev *pci)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999{
Takashi Iwai91219472012-04-26 12:13:25 +02002000 struct snd_card *card = pci_get_drvdata(pci);
Mengdong Linb8dfc4622012-08-23 17:32:30 +08002001
Takashi Iwai91219472012-04-26 12:13:25 +02002002 if (card)
2003 snd_card_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004}
2005
Takashi Iwaib2a0baf2015-03-05 17:21:32 +01002006static void azx_shutdown(struct pci_dev *pci)
2007{
2008 struct snd_card *card = pci_get_drvdata(pci);
2009 struct azx *chip;
2010
2011 if (!card)
2012 return;
2013 chip = card->private_data;
2014 if (chip && chip->running)
2015 azx_stop_chip(chip);
2016}
2017
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018/* PCI IDs */
Benoit Taine6f51f6c2014-05-22 17:08:54 +02002019static const struct pci_device_id azx_ids[] = {
Seth Heasleyd2f2fcd2010-01-12 17:03:35 -08002020 /* CPT */
Takashi Iwai9477c582011-05-25 09:11:37 +02002021 { PCI_DEVICE(0x8086, 0x1c20),
Takashi Iwaid7dab4d2013-01-08 13:51:30 +01002022 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
Seth Heasleycea310e2010-09-10 16:29:56 -07002023 /* PBG */
Takashi Iwai9477c582011-05-25 09:11:37 +02002024 { PCI_DEVICE(0x8086, 0x1d20),
Takashi Iwaid7dab4d2013-01-08 13:51:30 +01002025 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
Seth Heasleyd2edeb72011-04-20 10:59:57 -07002026 /* Panther Point */
Takashi Iwai9477c582011-05-25 09:11:37 +02002027 { PCI_DEVICE(0x8086, 0x1e20),
Takashi Iwaide5d0ad2015-02-25 07:53:31 +01002028 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
Seth Heasley8bc039a2012-01-23 16:24:31 -08002029 /* Lynx Point */
2030 { PCI_DEVICE(0x8086, 0x8c20),
Takashi Iwai2ea3c6a2012-11-19 20:03:37 +01002031 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
Takashi Iwai77f07802014-05-23 09:02:44 +02002032 /* 9 Series */
2033 { PCI_DEVICE(0x8086, 0x8ca0),
2034 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
James Ralston884b0882013-02-08 17:29:40 -08002035 /* Wellsburg */
2036 { PCI_DEVICE(0x8086, 0x8d20),
2037 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
2038 { PCI_DEVICE(0x8086, 0x8d21),
2039 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
James Ralston144dad92012-08-09 09:38:59 -07002040 /* Lynx Point-LP */
2041 { PCI_DEVICE(0x8086, 0x9c20),
Takashi Iwai2ea3c6a2012-11-19 20:03:37 +01002042 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
James Ralston144dad92012-08-09 09:38:59 -07002043 /* Lynx Point-LP */
2044 { PCI_DEVICE(0x8086, 0x9c21),
Takashi Iwai2ea3c6a2012-11-19 20:03:37 +01002045 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
James Ralston4eeca492013-11-04 09:27:45 -08002046 /* Wildcat Point-LP */
2047 { PCI_DEVICE(0x8086, 0x9ca0),
2048 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
James Ralstonc8b00fd2014-10-13 15:22:03 -07002049 /* Sunrise Point */
2050 { PCI_DEVICE(0x8086, 0xa170),
Libin Yangdb48abf2015-03-26 13:28:39 +08002051 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_SKYLAKE },
Devin Rylesb4565912014-11-07 18:02:47 -05002052 /* Sunrise Point-LP */
2053 { PCI_DEVICE(0x8086, 0x9d70),
Libin Yangd6795822014-12-19 08:44:31 +08002054 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_SKYLAKE },
Wang Xingchaoe926f2c2012-06-13 10:23:51 +08002055 /* Haswell */
Wang Xingchao4a7c5162013-02-01 22:42:19 +08002056 { PCI_DEVICE(0x8086, 0x0a0c),
Takashi Iwaifab12852013-11-05 17:54:05 +01002057 .driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
Wang Xingchaoe926f2c2012-06-13 10:23:51 +08002058 { PCI_DEVICE(0x8086, 0x0c0c),
Takashi Iwaifab12852013-11-05 17:54:05 +01002059 .driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
Wang Xingchaod279fae2012-09-17 13:10:23 +08002060 { PCI_DEVICE(0x8086, 0x0d0c),
Takashi Iwaifab12852013-11-05 17:54:05 +01002061 .driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
Mengdong Lin862d7612014-01-08 15:55:14 -05002062 /* Broadwell */
2063 { PCI_DEVICE(0x8086, 0x160c),
Libin Yang54a04052014-06-09 15:28:59 +08002064 .driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_BROADWELL },
Pierre-Louis Bossart99df18b2012-09-21 18:39:07 -05002065 /* 5 Series/3400 */
2066 { PCI_DEVICE(0x8086, 0x3b56),
Takashi Iwai2c1350f2013-02-14 09:44:55 +01002067 .driver_data = AZX_DRIVER_SCH | AZX_DCAPS_INTEL_PCH_NOPM },
Takashi Iwaif748abc2013-01-29 10:12:23 +01002068 /* Poulsbo */
Takashi Iwai9477c582011-05-25 09:11:37 +02002069 { PCI_DEVICE(0x8086, 0x811b),
Takashi Iwaif748abc2013-01-29 10:12:23 +01002070 .driver_data = AZX_DRIVER_SCH | AZX_DCAPS_INTEL_PCH_NOPM },
2071 /* Oaktrail */
Li Peng09904b92011-12-28 15:17:26 +00002072 { PCI_DEVICE(0x8086, 0x080a),
Takashi Iwaif748abc2013-01-29 10:12:23 +01002073 .driver_data = AZX_DRIVER_SCH | AZX_DCAPS_INTEL_PCH_NOPM },
Chew, Chiau Eee44007e2013-05-16 15:36:12 +08002074 /* BayTrail */
2075 { PCI_DEVICE(0x8086, 0x0f04),
Mengdong Lin40cc2392015-04-21 13:12:23 +08002076 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_BAYTRAIL },
Libin Yangf31b2ff2014-08-04 09:22:44 +08002077 /* Braswell */
2078 { PCI_DEVICE(0x8086, 0x2284),
Libin Yang2d846c72015-04-07 20:32:20 +08002079 .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_BRASWELL },
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002080 /* ICH6 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002081 { PCI_DEVICE(0x8086, 0x2668),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002082 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2083 /* ICH7 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002084 { PCI_DEVICE(0x8086, 0x27d8),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002085 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2086 /* ESB2 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002087 { PCI_DEVICE(0x8086, 0x269a),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002088 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2089 /* ICH8 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002090 { PCI_DEVICE(0x8086, 0x284b),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002091 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2092 /* ICH9 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002093 { PCI_DEVICE(0x8086, 0x293e),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002094 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2095 /* ICH9 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002096 { PCI_DEVICE(0x8086, 0x293f),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002097 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2098 /* ICH10 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002099 { PCI_DEVICE(0x8086, 0x3a3e),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002100 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
2101 /* ICH10 */
Takashi Iwai8b0bd222011-06-10 14:56:26 +02002102 { PCI_DEVICE(0x8086, 0x3a6e),
Takashi Iwaib42b4af2014-12-03 09:47:20 +01002103 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_INTEL_ICH },
Takashi Iwaib6864532010-09-15 10:17:26 +02002104 /* Generic Intel */
2105 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_ANY_ID),
2106 .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
2107 .class_mask = 0xffffff,
Takashi Iwai103884a2014-12-03 09:56:20 +01002108 .driver_data = AZX_DRIVER_ICH | AZX_DCAPS_NO_ALIGN_BUFSIZE },
Takashi Iwai9477c582011-05-25 09:11:37 +02002109 /* ATI SB 450/600/700/800/900 */
2110 { PCI_DEVICE(0x1002, 0x437b),
2111 .driver_data = AZX_DRIVER_ATI | AZX_DCAPS_PRESET_ATI_SB },
2112 { PCI_DEVICE(0x1002, 0x4383),
2113 .driver_data = AZX_DRIVER_ATI | AZX_DCAPS_PRESET_ATI_SB },
2114 /* AMD Hudson */
2115 { PCI_DEVICE(0x1022, 0x780d),
2116 .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_SB },
Takashi Iwai87218e92008-02-21 08:13:11 +01002117 /* ATI HDMI */
Takashi Iwai9477c582011-05-25 09:11:37 +02002118 { PCI_DEVICE(0x1002, 0x793b),
2119 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2120 { PCI_DEVICE(0x1002, 0x7919),
2121 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2122 { PCI_DEVICE(0x1002, 0x960f),
2123 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2124 { PCI_DEVICE(0x1002, 0x970f),
2125 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2126 { PCI_DEVICE(0x1002, 0xaa00),
2127 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2128 { PCI_DEVICE(0x1002, 0xaa08),
2129 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2130 { PCI_DEVICE(0x1002, 0xaa10),
2131 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2132 { PCI_DEVICE(0x1002, 0xaa18),
2133 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2134 { PCI_DEVICE(0x1002, 0xaa20),
2135 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2136 { PCI_DEVICE(0x1002, 0xaa28),
2137 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2138 { PCI_DEVICE(0x1002, 0xaa30),
2139 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2140 { PCI_DEVICE(0x1002, 0xaa38),
2141 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2142 { PCI_DEVICE(0x1002, 0xaa40),
2143 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2144 { PCI_DEVICE(0x1002, 0xaa48),
2145 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
Clemens Ladischbbaa0d62013-11-05 09:27:10 +01002146 { PCI_DEVICE(0x1002, 0xaa50),
2147 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2148 { PCI_DEVICE(0x1002, 0xaa58),
2149 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2150 { PCI_DEVICE(0x1002, 0xaa60),
2151 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2152 { PCI_DEVICE(0x1002, 0xaa68),
2153 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2154 { PCI_DEVICE(0x1002, 0xaa80),
2155 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2156 { PCI_DEVICE(0x1002, 0xaa88),
2157 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2158 { PCI_DEVICE(0x1002, 0xaa90),
2159 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
2160 { PCI_DEVICE(0x1002, 0xaa98),
2161 .driver_data = AZX_DRIVER_ATIHDMI | AZX_DCAPS_PRESET_ATI_HDMI },
Andiry Xu1815b342011-12-14 16:10:27 +08002162 { PCI_DEVICE(0x1002, 0x9902),
Takashi Iwai37e661e2014-11-25 11:28:07 +01002163 .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
Andiry Xu1815b342011-12-14 16:10:27 +08002164 { PCI_DEVICE(0x1002, 0xaaa0),
Takashi Iwai37e661e2014-11-25 11:28:07 +01002165 .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
Andiry Xu1815b342011-12-14 16:10:27 +08002166 { PCI_DEVICE(0x1002, 0xaaa8),
Takashi Iwai37e661e2014-11-25 11:28:07 +01002167 .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
Andiry Xu1815b342011-12-14 16:10:27 +08002168 { PCI_DEVICE(0x1002, 0xaab0),
Takashi Iwai37e661e2014-11-25 11:28:07 +01002169 .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS },
Takashi Iwai87218e92008-02-21 08:13:11 +01002170 /* VIA VT8251/VT8237A */
Takashi Iwai9477c582011-05-25 09:11:37 +02002171 { PCI_DEVICE(0x1106, 0x3288),
2172 .driver_data = AZX_DRIVER_VIA | AZX_DCAPS_POSFIX_VIA },
Annie Liu754fdff2012-06-08 19:18:39 +08002173 /* VIA GFX VT7122/VX900 */
2174 { PCI_DEVICE(0x1106, 0x9170), .driver_data = AZX_DRIVER_GENERIC },
2175 /* VIA GFX VT6122/VX11 */
2176 { PCI_DEVICE(0x1106, 0x9140), .driver_data = AZX_DRIVER_GENERIC },
Takashi Iwai87218e92008-02-21 08:13:11 +01002177 /* SIS966 */
2178 { PCI_DEVICE(0x1039, 0x7502), .driver_data = AZX_DRIVER_SIS },
2179 /* ULI M5461 */
2180 { PCI_DEVICE(0x10b9, 0x5461), .driver_data = AZX_DRIVER_ULI },
2181 /* NVIDIA MCP */
Takashi Iwai0c2fd1bf42009-12-18 16:41:39 +01002182 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
2183 .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
2184 .class_mask = 0xffffff,
Takashi Iwai9477c582011-05-25 09:11:37 +02002185 .driver_data = AZX_DRIVER_NVIDIA | AZX_DCAPS_PRESET_NVIDIA },
Kailang Yangf2690022008-05-27 11:44:55 +02002186 /* Teradici */
Takashi Iwai9477c582011-05-25 09:11:37 +02002187 { PCI_DEVICE(0x6549, 0x1200),
2188 .driver_data = AZX_DRIVER_TERA | AZX_DCAPS_NO_64BIT },
Lars R. Damerowf0b3da92012-11-02 13:10:39 -07002189 { PCI_DEVICE(0x6549, 0x2200),
2190 .driver_data = AZX_DRIVER_TERA | AZX_DCAPS_NO_64BIT },
Takashi Iwai4e01f542009-04-16 08:53:34 +02002191 /* Creative X-Fi (CA0110-IBG) */
Takashi Iwaif2a8eca2012-06-11 15:51:54 +02002192 /* CTHDA chips */
2193 { PCI_DEVICE(0x1102, 0x0010),
2194 .driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
2195 { PCI_DEVICE(0x1102, 0x0012),
2196 .driver_data = AZX_DRIVER_CTHDA | AZX_DCAPS_PRESET_CTHDA },
Takashi Iwai8eeaa2f2014-02-10 09:48:47 +01002197#if !IS_ENABLED(CONFIG_SND_CTXFI)
Takashi Iwai313f6e22009-05-18 12:40:52 +02002198 /* the following entry conflicts with snd-ctxfi driver,
2199 * as ctxfi driver mutates from HD-audio to native mode with
2200 * a special command sequence.
2201 */
Takashi Iwai4e01f542009-04-16 08:53:34 +02002202 { PCI_DEVICE(PCI_VENDOR_ID_CREATIVE, PCI_ANY_ID),
2203 .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
2204 .class_mask = 0xffffff,
Takashi Iwai9477c582011-05-25 09:11:37 +02002205 .driver_data = AZX_DRIVER_CTX | AZX_DCAPS_CTX_WORKAROUND |
Takashi Iwai69f9ba92011-11-06 13:49:13 +01002206 AZX_DCAPS_RIRB_PRE_DELAY | AZX_DCAPS_POSFIX_LPIB },
Takashi Iwai313f6e22009-05-18 12:40:52 +02002207#else
2208 /* this entry seems still valid -- i.e. without emu20kx chip */
Takashi Iwai9477c582011-05-25 09:11:37 +02002209 { PCI_DEVICE(0x1102, 0x0009),
2210 .driver_data = AZX_DRIVER_CTX | AZX_DCAPS_CTX_WORKAROUND |
Takashi Iwai69f9ba92011-11-06 13:49:13 +01002211 AZX_DCAPS_RIRB_PRE_DELAY | AZX_DCAPS_POSFIX_LPIB },
Takashi Iwai313f6e22009-05-18 12:40:52 +02002212#endif
Takashi Iwaic563f472014-08-06 14:27:42 +02002213 /* CM8888 */
2214 { PCI_DEVICE(0x13f6, 0x5011),
2215 .driver_data = AZX_DRIVER_CMEDIA |
Takashi Iwai37e661e2014-11-25 11:28:07 +01002216 AZX_DCAPS_NO_MSI | AZX_DCAPS_POSFIX_LPIB | AZX_DCAPS_SNOOP_OFF },
Otavio Salvadore35d4b12010-09-26 23:35:06 -03002217 /* Vortex86MX */
2218 { PCI_DEVICE(0x17f3, 0x3010), .driver_data = AZX_DRIVER_GENERIC },
Bankim Bhavsar0f0714c52011-01-17 15:23:21 +01002219 /* VMware HDAudio */
2220 { PCI_DEVICE(0x15ad, 0x1977), .driver_data = AZX_DRIVER_GENERIC },
Andiry Brienza9176b672009-07-17 11:32:32 +08002221 /* AMD/ATI Generic, PCI class code and Vendor ID for HD Audio */
Yang, Libinc4da29c2008-11-13 11:07:07 +01002222 { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_ANY_ID),
2223 .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
2224 .class_mask = 0xffffff,
Takashi Iwai9477c582011-05-25 09:11:37 +02002225 .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_HDMI },
Andiry Brienza9176b672009-07-17 11:32:32 +08002226 { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_ANY_ID),
2227 .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
2228 .class_mask = 0xffffff,
Takashi Iwai9477c582011-05-25 09:11:37 +02002229 .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_HDMI },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 { 0, }
2231};
2232MODULE_DEVICE_TABLE(pci, azx_ids);
2233
2234/* pci_driver definition */
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002235static struct pci_driver azx_driver = {
Takashi Iwai3733e422011-06-10 16:20:20 +02002236 .name = KBUILD_MODNAME,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 .id_table = azx_ids,
2238 .probe = azx_probe,
Bill Pembertone23e7a12012-12-06 12:35:10 -05002239 .remove = azx_remove,
Takashi Iwaib2a0baf2015-03-05 17:21:32 +01002240 .shutdown = azx_shutdown,
Takashi Iwai68cb2b52012-07-02 15:20:37 +02002241 .driver = {
2242 .pm = AZX_PM_OPS,
2243 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244};
2245
Takashi Iwaie9f66d92012-04-24 12:25:00 +02002246module_pci_driver(azx_driver);