hda_intel.c 114 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 *
3 4
 *  hda_intel.c - Implementation of primary alsa driver code base
 *                for Intel HD Audio.
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 *
 *  Copyright(c) 2004 Intel Corporation. All rights reserved.
 *
 *  Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
 *                     PeiSen Hou <pshou@realtek.com.tw>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the Free
 *  Software Foundation; either version 2 of the License, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along with
 *  this program; if not, write to the Free Software Foundation, Inc., 59
 *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 *  CONTACTS:
 *
 *  Matt Jared		matt.jared@intel.com
 *  Andy Kopp		andy.kopp@intel.com
 *  Dan Kogan		dan.d.kogan@intel.com
 *
 *  CHANGES:
 *
 *  2004.12.01	Major rewrite by tiwai, merged the work of pshou
 * 
 */

#include <linux/delay.h>
#include <linux/interrupt.h>
39
#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
40
#include <linux/module.h>
41
#include <linux/dma-mapping.h>
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/pci.h>
46
#include <linux/mutex.h>
47
#include <linux/reboot.h>
48
#include <linux/io.h>
49
#include <linux/pm_runtime.h>
50 51
#include <linux/clocksource.h>
#include <linux/time.h>
52
#include <linux/completion.h>
53

54 55 56 57 58
#ifdef CONFIG_X86
/* for snoop control */
#include <asm/pgtable.h>
#include <asm/cacheflush.h>
#endif
Linus Torvalds's avatar
Linus Torvalds committed
59 60
#include <sound/core.h>
#include <sound/initval.h>
61
#include <linux/vgaarb.h>
62
#include <linux/vga_switcheroo.h>
63
#include <linux/firmware.h>
Linus Torvalds's avatar
Linus Torvalds committed
64
#include "hda_codec.h"
65
#include "hda_i915.h"
Linus Torvalds's avatar
Linus Torvalds committed
66 67


68 69
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
70
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
71
static char *model[SNDRV_CARDS];
72
static int position_fix[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
73
static int bdl_pos_adj[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
74
static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
75
static int probe_only[SNDRV_CARDS];
76
static int jackpoll_ms[SNDRV_CARDS];
77
static bool single_cmd;
78
static int enable_msi = -1;
79 80 81
#ifdef CONFIG_SND_HDA_PATCH_LOADER
static char *patch[SNDRV_CARDS];
#endif
82
#ifdef CONFIG_SND_HDA_INPUT_BEEP
83
static bool beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
84 85
					CONFIG_SND_HDA_INPUT_BEEP_MODE};
#endif
Linus Torvalds's avatar
Linus Torvalds committed
86

87
module_param_array(index, int, NULL, 0444);
Linus Torvalds's avatar
Linus Torvalds committed
88
MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
89
module_param_array(id, charp, NULL, 0444);
Linus Torvalds's avatar
Linus Torvalds committed
90
MODULE_PARM_DESC(id, "ID string for Intel HD audio interface.");
91 92 93
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable Intel HD audio interface.");
module_param_array(model, charp, NULL, 0444);
Linus Torvalds's avatar
Linus Torvalds committed
94
MODULE_PARM_DESC(model, "Use the given board model.");
95
module_param_array(position_fix, int, NULL, 0444);
96
MODULE_PARM_DESC(position_fix, "DMA pointer read method."
97
		 "(-1 = system default, 0 = auto, 1 = LPIB, 2 = POSBUF, 3 = VIACOMBO, 4 = COMBO).");
98 99
module_param_array(bdl_pos_adj, int, NULL, 0644);
MODULE_PARM_DESC(bdl_pos_adj, "BDL position adjustment offset.");
100
module_param_array(probe_mask, int, NULL, 0444);
101
MODULE_PARM_DESC(probe_mask, "Bitmask to probe codecs (default = -1).");
102
module_param_array(probe_only, int, NULL, 0444);
103
MODULE_PARM_DESC(probe_only, "Only probing and no codec initialization.");
104 105
module_param_array(jackpoll_ms, int, NULL, 0444);
MODULE_PARM_DESC(jackpoll_ms, "Ms between polling for jack events (default = 0, using unsol events only)");
106
module_param(single_cmd, bool, 0444);
107 108
MODULE_PARM_DESC(single_cmd, "Use single command to communicate with codecs "
		 "(for debugging only).");
109
module_param(enable_msi, bint, 0444);
110
MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
111 112 113 114
#ifdef CONFIG_SND_HDA_PATCH_LOADER
module_param_array(patch, charp, NULL, 0444);
MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface.");
#endif
115
#ifdef CONFIG_SND_HDA_INPUT_BEEP
116
module_param_array(beep_mode, bool, NULL, 0444);
117
MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
118
			    "(0=off, 1=on) (default=1).");
119
#endif
120

121
#ifdef CONFIG_PM
122 123 124 125 126 127 128
static int param_set_xint(const char *val, const struct kernel_param *kp);
static struct kernel_param_ops param_ops_xint = {
	.set = param_set_xint,
	.get = param_get_int,
};
#define param_check_xint param_check_int

129
static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
130
module_param(power_save, xint, 0644);
131 132
MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "
		 "(in second, 0 = disable).");
Linus Torvalds's avatar
Linus Torvalds committed
133

134 135 136 137
/* reset the HD-audio controller in power save mode.
 * this may give more power-saving, but will take longer time to
 * wake up.
 */
138 139
static bool power_save_controller = 1;
module_param(power_save_controller, bool, 0644);
140
MODULE_PARM_DESC(power_save_controller, "Reset controller in power save mode.");
141
#endif /* CONFIG_PM */
142

143 144
static int align_buffer_size = -1;
module_param(align_buffer_size, bint, 0644);
145 146 147
MODULE_PARM_DESC(align_buffer_size,
		"Force buffer and period sizes to be multiple of 128 bytes.");

148 149 150 151 152 153 154 155 156 157 158
#ifdef CONFIG_X86
static bool hda_snoop = true;
module_param_named(snoop, hda_snoop, bool, 0444);
MODULE_PARM_DESC(snoop, "Enable/disable snooping");
#define azx_snoop(chip)		(chip)->snoop
#else
#define hda_snoop		true
#define azx_snoop(chip)		true
#endif


Linus Torvalds's avatar
Linus Torvalds committed
159 160 161
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
			 "{Intel, ICH6M},"
162
			 "{Intel, ICH7},"
163
			 "{Intel, ESB2},"
164
			 "{Intel, ICH8},"
165
			 "{Intel, ICH9},"
166
			 "{Intel, ICH10},"
167
			 "{Intel, PCH},"
168
			 "{Intel, CPT},"
169
			 "{Intel, PPT},"
170
			 "{Intel, LPT},"
171
			 "{Intel, LPT_LP},"
172
			 "{Intel, WPT_LP},"
173
			 "{Intel, HPT},"
174
			 "{Intel, PBG},"
175
			 "{Intel, SCH},"
176
			 "{ATI, SB450},"
177
			 "{ATI, SB600},"
178
			 "{ATI, RS600},"
179
			 "{ATI, RS690},"
180 181
			 "{ATI, RS780},"
			 "{ATI, R600},"
182 183
			 "{ATI, RV630},"
			 "{ATI, RV610},"
184 185 186 187
			 "{ATI, RV670},"
			 "{ATI, RV635},"
			 "{ATI, RV620},"
			 "{ATI, RV770},"
188
			 "{VIA, VT8251},"
189
			 "{VIA, VT8237A},"
190 191
			 "{SiS, SIS966},"
			 "{ULI, M5461}}");
Linus Torvalds's avatar
Linus Torvalds committed
192 193
MODULE_DESCRIPTION("Intel HDA driver");

194 195 196
#ifdef CONFIG_SND_VERBOSE_PRINTK
#define SFX	/* nop */
#else
197
#define SFX	"hda-intel "
198
#endif
199

200 201 202 203 204 205 206
#if defined(CONFIG_PM) && defined(CONFIG_VGA_SWITCHEROO)
#ifdef CONFIG_SND_HDA_CODEC_HDMI
#define SUPPORT_VGA_SWITCHEROO
#endif
#endif


Linus Torvalds's avatar
Linus Torvalds committed
207 208 209 210
/*
 * registers
 */
#define ICH6_REG_GCAP			0x00
211 212 213 214 215
#define   ICH6_GCAP_64OK	(1 << 0)   /* 64bit address support */
#define   ICH6_GCAP_NSDO	(3 << 1)   /* # of serial data out signals */
#define   ICH6_GCAP_BSS		(31 << 3)  /* # of bidirectional streams */
#define   ICH6_GCAP_ISS		(15 << 8)  /* # of input streams */
#define   ICH6_GCAP_OSS		(15 << 12) /* # of output streams */
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220
#define ICH6_REG_VMIN			0x02
#define ICH6_REG_VMAJ			0x03
#define ICH6_REG_OUTPAY			0x04
#define ICH6_REG_INPAY			0x06
#define ICH6_REG_GCTL			0x08
221
#define   ICH6_GCTL_RESET	(1 << 0)   /* controller reset */
222 223
#define   ICH6_GCTL_FCNTRL	(1 << 1)   /* flush control */
#define   ICH6_GCTL_UNSOL	(1 << 8)   /* accept unsol. response enable */
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
#define ICH6_REG_WAKEEN			0x0c
#define ICH6_REG_STATESTS		0x0e
#define ICH6_REG_GSTS			0x10
227
#define   ICH6_GSTS_FSTS	(1 << 1)   /* flush status */
Linus Torvalds's avatar
Linus Torvalds committed
228 229
#define ICH6_REG_INTCTL			0x20
#define ICH6_REG_INTSTS			0x24
230
#define ICH6_REG_WALLCLK		0x30	/* 24Mhz source */
231 232
#define ICH6_REG_OLD_SSYNC		0x34	/* SSYNC for old ICH */
#define ICH6_REG_SSYNC			0x38
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235
#define ICH6_REG_CORBLBASE		0x40
#define ICH6_REG_CORBUBASE		0x44
#define ICH6_REG_CORBWP			0x48
236 237
#define ICH6_REG_CORBRP			0x4a
#define   ICH6_CORBRP_RST	(1 << 15)  /* read pointer reset */
Linus Torvalds's avatar
Linus Torvalds committed
238
#define ICH6_REG_CORBCTL		0x4c
239 240
#define   ICH6_CORBCTL_RUN	(1 << 1)   /* enable DMA */
#define   ICH6_CORBCTL_CMEIE	(1 << 0)   /* enable memory error irq */
Linus Torvalds's avatar
Linus Torvalds committed
241
#define ICH6_REG_CORBSTS		0x4d
242
#define   ICH6_CORBSTS_CMEI	(1 << 0)   /* memory error indication */
Linus Torvalds's avatar
Linus Torvalds committed
243 244 245 246 247
#define ICH6_REG_CORBSIZE		0x4e

#define ICH6_REG_RIRBLBASE		0x50
#define ICH6_REG_RIRBUBASE		0x54
#define ICH6_REG_RIRBWP			0x58
248
#define   ICH6_RIRBWP_RST	(1 << 15)  /* write pointer reset */
Linus Torvalds's avatar
Linus Torvalds committed
249 250
#define ICH6_REG_RINTCNT		0x5a
#define ICH6_REG_RIRBCTL		0x5c
251 252 253
#define   ICH6_RBCTL_IRQ_EN	(1 << 0)   /* enable IRQ */
#define   ICH6_RBCTL_DMA_EN	(1 << 1)   /* enable DMA */
#define   ICH6_RBCTL_OVERRUN_EN	(1 << 2)   /* enable overrun irq */
Linus Torvalds's avatar
Linus Torvalds committed
254
#define ICH6_REG_RIRBSTS		0x5d
255 256
#define   ICH6_RBSTS_IRQ	(1 << 0)   /* response irq */
#define   ICH6_RBSTS_OVERRUN	(1 << 2)   /* overrun irq */
Linus Torvalds's avatar
Linus Torvalds committed
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
#define ICH6_REG_RIRBSIZE		0x5e

#define ICH6_REG_IC			0x60
#define ICH6_REG_IR			0x64
#define ICH6_REG_IRS			0x68
#define   ICH6_IRS_VALID	(1<<1)
#define   ICH6_IRS_BUSY		(1<<0)

#define ICH6_REG_DPLBASE		0x70
#define ICH6_REG_DPUBASE		0x74
#define   ICH6_DPLBASE_ENABLE	0x1	/* Enable position buffer */

/* SD offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };

/* stream register offsets from stream base */
#define ICH6_REG_SD_CTL			0x00
#define ICH6_REG_SD_STS			0x03
#define ICH6_REG_SD_LPIB		0x04
#define ICH6_REG_SD_CBL			0x08
#define ICH6_REG_SD_LVI			0x0c
#define ICH6_REG_SD_FIFOW		0x0e
#define ICH6_REG_SD_FIFOSIZE		0x10
#define ICH6_REG_SD_FORMAT		0x12
#define ICH6_REG_SD_BDLPL		0x18
#define ICH6_REG_SD_BDLPU		0x1c

/* PCI space */
#define ICH6_PCIREG_TCSEL	0x44

/*
 * other constants
 */

/* max number of SDs */
292 293 294 295 296 297 298 299
/* ICH, ATI and VIA have 4 playback and 4 capture */
#define ICH6_NUM_CAPTURE	4
#define ICH6_NUM_PLAYBACK	4

/* ULI has 6 playback and 5 capture */
#define ULI_NUM_CAPTURE		5
#define ULI_NUM_PLAYBACK	6

300
/* ATI HDMI may have up to 8 playbacks and 0 capture */
301
#define ATIHDMI_NUM_CAPTURE	0
302
#define ATIHDMI_NUM_PLAYBACK	8
303

304 305 306 307
/* TERA has 4 playback and 3 capture */
#define TERA_NUM_CAPTURE	3
#define TERA_NUM_PLAYBACK	4

308 309 310
/* this number is statically defined for simplicity */
#define MAX_AZX_DEV		16

Linus Torvalds's avatar
Linus Torvalds committed
311
/* max number of fragments - we may use more if allocating more pages for BDL */
312 313 314
#define BDL_SIZE		4096
#define AZX_MAX_BDL_ENTRIES	(BDL_SIZE / 16)
#define AZX_MAX_FRAG		32
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318 319 320 321 322
/* max buffer size - no h/w limit, you can increase as you like */
#define AZX_MAX_BUF_SIZE	(1024*1024*1024)

/* RIRB int mask: overrun[2], response[0] */
#define RIRB_INT_RESPONSE	0x01
#define RIRB_INT_OVERRUN	0x04
#define RIRB_INT_MASK		0x05

323
/* STATESTS int mask: S3,SD2,SD1,SD0 */
324 325
#define AZX_MAX_CODECS		8
#define AZX_DEFAULT_CODECS	4
326
#define STATESTS_INT_MASK	((1 << AZX_MAX_CODECS) - 1)
Linus Torvalds's avatar
Linus Torvalds committed
327 328 329 330

/* SD_CTL bits */
#define SD_CTL_STREAM_RESET	0x01	/* stream reset bit */
#define SD_CTL_DMA_START	0x02	/* stream DMA start bit */
331 332 333
#define SD_CTL_STRIPE		(3 << 16)	/* stripe control */
#define SD_CTL_TRAFFIC_PRIO	(1 << 18)	/* traffic priority */
#define SD_CTL_DIR		(1 << 19)	/* bi-directional stream */
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336 337 338 339 340
#define SD_CTL_STREAM_TAG_MASK	(0xf << 20)
#define SD_CTL_STREAM_TAG_SHIFT	20

/* SD_CTL and SD_STS */
#define SD_INT_DESC_ERR		0x10	/* descriptor error interrupt */
#define SD_INT_FIFO_ERR		0x08	/* FIFO error interrupt */
#define SD_INT_COMPLETE		0x04	/* completion interrupt */
341 342
#define SD_INT_MASK		(SD_INT_DESC_ERR|SD_INT_FIFO_ERR|\
				 SD_INT_COMPLETE)
Linus Torvalds's avatar
Linus Torvalds committed
343 344 345 346 347

/* SD_STS */
#define SD_STS_FIFO_READY	0x20	/* FIFO ready */

/* INTCTL and INTSTS */
348 349 350
#define ICH6_INT_ALL_STREAM	0xff	   /* all stream interrupts */
#define ICH6_INT_CTRL_EN	0x40000000 /* controller interrupt enable bit */
#define ICH6_INT_GLOBAL_EN	0x80000000 /* global interrupt enable bit */
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355

/* below are so far hardcoded - should read registers in future */
#define ICH6_MAX_CORB_ENTRIES	256
#define ICH6_MAX_RIRB_ENTRIES	256

356 357
/* position fix mode */
enum {
358
	POS_FIX_AUTO,
359
	POS_FIX_LPIB,
360
	POS_FIX_POSBUF,
361
	POS_FIX_VIACOMBO,
362
	POS_FIX_COMBO,
363
};
Linus Torvalds's avatar
Linus Torvalds committed
364

365 366 367 368
/* Defines for ATI HD Audio support in SB450 south bridge */
#define ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR   0x42
#define ATI_SB450_HDAUDIO_ENABLE_SNOOP      0x02

369 370 371
/* Defines for Nvidia HDA support */
#define NVIDIA_HDA_TRANSREG_ADDR      0x4e
#define NVIDIA_HDA_ENABLE_COHBITS     0x0f
372 373 374
#define NVIDIA_HDA_ISTRM_COH          0x4d
#define NVIDIA_HDA_OSTRM_COH          0x4c
#define NVIDIA_HDA_ENABLE_COHBIT      0x01
375

376 377 378 379
/* Defines for Intel SCH HDA snoop control */
#define INTEL_SCH_HDA_DEVC      0x78
#define INTEL_SCH_HDA_DEVC_NOSNOOP       (0x1<<11)

380 381 382 383 384
/* Define IN stream 0 FIFO size offset in VIA controller */
#define VIA_IN_STREAM0_FIFO_SIZE_OFFSET	0x90
/* Define VIA HD Audio Device ID*/
#define VIA_HDAC_DEVICE_ID		0x3288

385 386
/* HD Audio class code */
#define PCI_CLASS_MULTIMEDIA_HD_AUDIO	0x0403
387

Linus Torvalds's avatar
Linus Torvalds committed
388 389 390
/*
 */

391
struct azx_dev {
392
	struct snd_dma_buffer bdl; /* BDL buffer */
393
	u32 *posbuf;		/* position buffer pointer */
Linus Torvalds's avatar
Linus Torvalds committed
394

395
	unsigned int bufsize;	/* size of the play buffer in bytes */
396
	unsigned int period_bytes; /* size of the period in bytes */
397 398
	unsigned int frags;	/* number for period in the play buffer */
	unsigned int fifo_size;	/* FIFO size */
399 400
	unsigned long start_wallclk;	/* start + minimum wallclk */
	unsigned long period_wallclk;	/* wallclk for period */
Linus Torvalds's avatar
Linus Torvalds committed
401

402
	void __iomem *sd_addr;	/* stream descriptor pointer */
Linus Torvalds's avatar
Linus Torvalds committed
403

404
	u32 sd_int_sta_mask;	/* stream int status mask */
Linus Torvalds's avatar
Linus Torvalds committed
405 406

	/* pcm support */
407 408 409 410 411 412
	struct snd_pcm_substream *substream;	/* assigned substream,
						 * set in PCM open
						 */
	unsigned int format_val;	/* format value to be set in the
					 * controller and the codec
					 */
Linus Torvalds's avatar
Linus Torvalds committed
413 414
	unsigned char stream_tag;	/* assigned stream */
	unsigned char index;		/* stream index */
415
	int assigned_key;		/* last device# key assigned to */
Linus Torvalds's avatar
Linus Torvalds committed
416

417 418
	unsigned int opened :1;
	unsigned int running :1;
419
	unsigned int irq_pending :1;
420 421
	unsigned int prepared:1;
	unsigned int locked:1;
422 423 424 425 426 427
	/*
	 * For VIA:
	 *  A flag to ensure DMA position is 0
	 *  when link position is not greater than FIFO size
	 */
	unsigned int insufficient :1;
428
	unsigned int wc_marked:1;
429
	unsigned int no_period_wakeup:1;
430 431 432

	struct timecounter  azx_tc;
	struct cyclecounter azx_cc;
433

434 435
	int delay_negative_threshold;

436 437 438
#ifdef CONFIG_SND_HDA_DSP_LOADER
	struct mutex dsp_mutex;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
439 440
};

441 442 443 444 445 446 447 448 449 450 451 452 453
/* DSP lock helpers */
#ifdef CONFIG_SND_HDA_DSP_LOADER
#define dsp_lock_init(dev)	mutex_init(&(dev)->dsp_mutex)
#define dsp_lock(dev)		mutex_lock(&(dev)->dsp_mutex)
#define dsp_unlock(dev)		mutex_unlock(&(dev)->dsp_mutex)
#define dsp_is_locked(dev)	((dev)->locked)
#else
#define dsp_lock_init(dev)	do {} while (0)
#define dsp_lock(dev)		do {} while (0)
#define dsp_unlock(dev)		do {} while (0)
#define dsp_is_locked(dev)	0
#endif

Linus Torvalds's avatar
Linus Torvalds committed
454
/* CORB/RIRB */
455
struct azx_rb {
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460 461
	u32 *buf;		/* CORB/RIRB buffer
				 * Each CORB entry is 4byte, RIRB is 8byte
				 */
	dma_addr_t addr;	/* physical address of CORB/RIRB buffer */
	/* for RIRB */
	unsigned short rp, wp;	/* read/write pointers */
462 463
	int cmds[AZX_MAX_CODECS];	/* number of pending requests */
	u32 res[AZX_MAX_CODECS];	/* last read value */
Linus Torvalds's avatar
Linus Torvalds committed
464 465
};

466 467 468 469 470 471 472 473
struct azx_pcm {
	struct azx *chip;
	struct snd_pcm *pcm;
	struct hda_codec *codec;
	struct hda_pcm_stream *hinfo[2];
	struct list_head list;
};

474 475
struct azx {
	struct snd_card *card;
Linus Torvalds's avatar
Linus Torvalds committed
476
	struct pci_dev *pci;
477
	int dev_index;
Linus Torvalds's avatar
Linus Torvalds committed
478

479 480
	/* chip type specific */
	int driver_type;
481
	unsigned int driver_caps;
482 483 484 485 486 487
	int playback_streams;
	int playback_index_offset;
	int capture_streams;
	int capture_index_offset;
	int num_streams;

Linus Torvalds's avatar
Linus Torvalds committed
488 489 490 491 492 493 494
	/* pci resources */
	unsigned long addr;
	void __iomem *remap_addr;
	int irq;

	/* locks */
	spinlock_t reg_lock;
495
	struct mutex open_mutex;
496
	struct completion probe_wait;
Linus Torvalds's avatar
Linus Torvalds committed
497

498
	/* streams (x num_streams) */
499
	struct azx_dev *azx_dev;
Linus Torvalds's avatar
Linus Torvalds committed
500 501

	/* PCM */
502
	struct list_head pcm_list; /* azx_pcm list */
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505

	/* HD codec */
	unsigned short codec_mask;
506
	int  codec_probe_mask; /* copied from probe_mask option */
Linus Torvalds's avatar
Linus Torvalds committed
507
	struct hda_bus *bus;
508
	unsigned int beep_mode;
Linus Torvalds's avatar
Linus Torvalds committed
509 510

	/* CORB/RIRB */
511 512
	struct azx_rb corb;
	struct azx_rb rirb;
Linus Torvalds's avatar
Linus Torvalds committed
513

514
	/* CORB/RIRB and position buffers */
Linus Torvalds's avatar
Linus Torvalds committed
515 516
	struct snd_dma_buffer rb;
	struct snd_dma_buffer posbuf;
517

518 519 520 521
#ifdef CONFIG_SND_HDA_PATCH_LOADER
	const struct firmware *fw;
#endif

522
	/* flags */
523
	int position_fix[2]; /* for both playback/capture streams */
524
	int poll_count;
525
	unsigned int running :1;
526 527 528
	unsigned int initialized :1;
	unsigned int single_cmd :1;
	unsigned int polling_mode :1;
529
	unsigned int msi :1;
530
	unsigned int irq_pending_warned :1;
531
	unsigned int probing :1; /* codec probing phase */
532
	unsigned int snoop:1;
533
	unsigned int align_buffer_size:1;
534 535 536 537
	unsigned int region_requested:1;

	/* VGA-switcheroo setup */
	unsigned int use_vga_switcheroo:1;
538
	unsigned int vga_switcheroo_registered:1;
539 540
	unsigned int init_failed:1; /* delayed init failed */
	unsigned int disabled:1; /* disabled by VGA-switcher */
541 542

	/* for debugging */
543
	unsigned int last_cmd[AZX_MAX_CODECS];
544 545 546

	/* for pending irqs */
	struct work_struct irq_pending_work;
547

548 549
	struct work_struct probe_work;

550 551
	/* reboot notifier (for mysterious hangup problem at power-down) */
	struct notifier_block reboot_notifier;
552 553 554

	/* card list (for power_save trigger) */
	struct list_head list;
555 556 557 558

#ifdef CONFIG_SND_HDA_DSP_LOADER
	struct azx_dev saved_azx_dev;
#endif
559 560 561

	/* secondary power domain for hdmi audio under vga device */
	struct dev_pm_domain hdmi_pm_domain;
Linus Torvalds's avatar
Linus Torvalds committed
562 563
};

564 565 566
#define CREATE_TRACE_POINTS
#include "hda_intel_trace.h"

567 568 569
/* driver types */
enum {
	AZX_DRIVER_ICH,
570
	AZX_DRIVER_PCH,
571
	AZX_DRIVER_SCH,
572
	AZX_DRIVER_HDMI,
573
	AZX_DRIVER_ATI,
574
	AZX_DRIVER_ATIHDMI,
575
	AZX_DRIVER_ATIHDMI_NS,
576 577 578
	AZX_DRIVER_VIA,
	AZX_DRIVER_SIS,
	AZX_DRIVER_ULI,
579
	AZX_DRIVER_NVIDIA,
580
	AZX_DRIVER_TERA,
581
	AZX_DRIVER_CTX,
582
	AZX_DRIVER_CTHDA,
583
	AZX_DRIVER_GENERIC,
584
	AZX_NUM_DRIVERS, /* keep this as last entry */
585 586
};

587 588 589 590 591 592 593 594 595 596 597 598 599 600
/* driver quirks (capabilities) */
/* bits 0-7 are used for indicating driver type */
#define AZX_DCAPS_NO_TCSEL	(1 << 8)	/* No Intel TCSEL bit */
#define AZX_DCAPS_NO_MSI	(1 << 9)	/* No MSI support */
#define AZX_DCAPS_ATI_SNOOP	(1 << 10)	/* ATI snoop enable */
#define AZX_DCAPS_NVIDIA_SNOOP	(1 << 11)	/* Nvidia snoop enable */
#define AZX_DCAPS_SCH_SNOOP	(1 << 12)	/* SCH/PCH snoop enable */
#define AZX_DCAPS_RIRB_DELAY	(1 << 13)	/* Long delay in read loop */
#define AZX_DCAPS_RIRB_PRE_DELAY (1 << 14)	/* Put a delay before read */
#define AZX_DCAPS_CTX_WORKAROUND (1 << 15)	/* X-Fi workaround */
#define AZX_DCAPS_POSFIX_LPIB	(1 << 16)	/* Use LPIB as default */
#define AZX_DCAPS_POSFIX_VIA	(1 << 17)	/* Use VIACOMBO as default */
#define AZX_DCAPS_NO_64BIT	(1 << 18)	/* No 64bit address */
#define AZX_DCAPS_SYNC_WRITE	(1 << 19)	/* sync each cmd write */
601
#define AZX_DCAPS_OLD_SSYNC	(1 << 20)	/* Old SSYNC reg for ICH */
602
#define AZX_DCAPS_BUFSIZE	(1 << 21)	/* no buffer size alignment */
603
#define AZX_DCAPS_ALIGN_BUFSIZE	(1 << 22)	/* buffer size alignment */
604
#define AZX_DCAPS_4K_BDLE_BOUNDARY (1 << 23)	/* BDLE in 4k boundary */
605
#define AZX_DCAPS_COUNT_LPIB_DELAY  (1 << 25)	/* Take LPIB as delay */
606
#define AZX_DCAPS_PM_RUNTIME	(1 << 26)	/* runtime PM support */
607
#define AZX_DCAPS_I915_POWERWELL (1 << 27)	/* HSW i915 power well support */
608 609

/* quirks for Intel PCH */
610
#define AZX_DCAPS_INTEL_PCH_NOPM \
611
	(AZX_DCAPS_SCH_SNOOP | AZX_DCAPS_BUFSIZE | \
612 613 614 615
	 AZX_DCAPS_COUNT_LPIB_DELAY)

#define AZX_DCAPS_INTEL_PCH \
	(AZX_DCAPS_INTEL_PCH_NOPM | AZX_DCAPS_PM_RUNTIME)
616

617 618 619 620 621
#define AZX_DCAPS_INTEL_HASWELL \
	(AZX_DCAPS_SCH_SNOOP | AZX_DCAPS_ALIGN_BUFSIZE | \
	 AZX_DCAPS_COUNT_LPIB_DELAY | AZX_DCAPS_PM_RUNTIME | \
	 AZX_DCAPS_I915_POWERWELL)

622 623 624 625 626 627 628 629 630 631 632
/* quirks for ATI SB / AMD Hudson */
#define AZX_DCAPS_PRESET_ATI_SB \
	(AZX_DCAPS_ATI_SNOOP | AZX_DCAPS_NO_TCSEL | \
	 AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB)

/* quirks for ATI/AMD HDMI */
#define AZX_DCAPS_PRESET_ATI_HDMI \
	(AZX_DCAPS_NO_TCSEL | AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB)

/* quirks for Nvidia */
#define AZX_DCAPS_PRESET_NVIDIA \
633
	(AZX_DCAPS_NVIDIA_SNOOP | AZX_DCAPS_RIRB_DELAY | AZX_DCAPS_NO_MSI |\
634
	 AZX_DCAPS_ALIGN_BUFSIZE | AZX_DCAPS_NO_64BIT)
635

636 637 638
#define AZX_DCAPS_PRESET_CTHDA \
	(AZX_DCAPS_NO_MSI | AZX_DCAPS_POSFIX_LPIB | AZX_DCAPS_4K_BDLE_BOUNDARY)

639 640 641 642
/*
 * VGA-switcher support
 */
#ifdef SUPPORT_VGA_SWITCHEROO
643 644 645 646 647
#define use_vga_switcheroo(chip)	((chip)->use_vga_switcheroo)
#else
#define use_vga_switcheroo(chip)	0
#endif

648
static char *driver_short_names[] = {
649
	[AZX_DRIVER_ICH] = "HDA Intel",
650
	[AZX_DRIVER_PCH] = "HDA Intel PCH",
651
	[AZX_DRIVER_SCH] = "HDA Intel MID",
652
	[AZX_DRIVER_HDMI] = "HDA Intel HDMI",
653
	[AZX_DRIVER_ATI] = "HDA ATI SB",
654
	[AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
655
	[AZX_DRIVER_ATIHDMI_NS] = "HDA ATI HDMI",
656 657
	[AZX_DRIVER_VIA] = "HDA VIA VT82xx",
	[AZX_DRIVER_SIS] = "HDA SIS966",
658 659
	[AZX_DRIVER_ULI] = "HDA ULI M5461",
	[AZX_DRIVER_NVIDIA] = "HDA NVidia",
660
	[AZX_DRIVER_TERA] = "HDA Teradici", 
661
	[AZX_DRIVER_CTX] = "HDA Creative", 
662
	[AZX_DRIVER_CTHDA] = "HDA Creative",
663
	[AZX_DRIVER_GENERIC] = "HD-Audio Generic",
664 665
};

Linus Torvalds's avatar
Linus Torvalds committed
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
/*
 * macros for easy use
 */
#define azx_writel(chip,reg,value) \
	writel(value, (chip)->remap_addr + ICH6_REG_##reg)
#define azx_readl(chip,reg) \
	readl((chip)->remap_addr + ICH6_REG_##reg)
#define azx_writew(chip,reg,value) \
	writew(value, (chip)->remap_addr + ICH6_REG_##reg)
#define azx_readw(chip,reg) \
	readw((chip)->remap_addr + ICH6_REG_##reg)
#define azx_writeb(chip,reg,value) \
	writeb(value, (chip)->remap_addr + ICH6_REG_##reg)
#define azx_readb(chip,reg) \
	readb((chip)->remap_addr + ICH6_REG_##reg)

#define azx_sd_writel(dev,reg,value) \
	writel(value, (dev)->sd_addr + ICH6_REG_##reg)
#define azx_sd_readl(dev,reg) \
	readl((dev)->sd_addr + ICH6_REG_##reg)
#define azx_sd_writew(dev,reg,value) \
	writew(value, (dev)->sd_addr + ICH6_REG_##reg)
#define azx_sd_readw(dev,reg) \
	readw((dev)->sd_addr + ICH6_REG_##reg)
#define azx_sd_writeb(dev,reg,value) \
	writeb(value, (dev)->sd_addr + ICH6_REG_##reg)
#define azx_sd_readb(dev,reg) \
	readb((dev)->sd_addr + ICH6_REG_##reg)

/* for pcm support */
696
#define get_azx_dev(substream) (substream->runtime->private_data)
Linus Torvalds's avatar
Linus Torvalds committed
697

698
#ifdef CONFIG_X86
699
static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool on)
700
{
701 702
	int pages;

703 704
	if (azx_snoop(chip))
		return;
705 706 707 708 709 710
	if (!dmab || !dmab->area || !dmab->bytes)
		return;

#ifdef CONFIG_SND_DMA_SGBUF
	if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_SG) {
		struct snd_sg_buf *sgbuf = dmab->private_data;
711
		if (on)
712
			set_pages_array_wc(sgbuf->page_table, sgbuf->pages);
713
		else
714 715
			set_pages_array_wb(sgbuf->page_table, sgbuf->pages);
		return;
716
	}
717 718 719 720 721 722 723
#endif

	pages = (dmab->bytes + PAGE_SIZE - 1) >> PAGE_SHIFT;
	if (on)
		set_memory_wc((unsigned long)dmab->area, pages);
	else
		set_memory_wb((unsigned long)dmab->area, pages);
724 725 726 727 728
}

static inline void mark_pages_wc(struct azx *chip, struct snd_dma_buffer *buf,
				 bool on)
{
729
	__mark_pages_wc(chip, buf, on);
730 731
}
static inline void mark_runtime_wc(struct azx *chip, struct azx_dev *azx_dev,
732
				   struct snd_pcm_substream *substream, bool on)
733 734
{
	if (azx_dev->wc_marked != on) {
735
		__mark_pages_wc(chip, snd_pcm_get_dma_buf(substream), on);
736 737 738 739 740 741 742 743 744 745
		azx_dev->wc_marked = on;
	}
}
#else
/* NOP for other archs */
static inline void mark_pages_wc(struct azx *chip, struct snd_dma_buffer *buf,
				 bool on)
{
}
static inline void mark_runtime_wc(struct azx *chip, struct azx_dev *azx_dev,
746
				   struct snd_pcm_substream *substream, bool on)
747 748 749 750
{
}
#endif

751
static int azx_acquire_irq(struct azx *chip, int do_disconnect);
752
static int azx_send_cmd(struct hda_bus *bus, unsigned int val);
Linus Torvalds's avatar
Linus Torvalds committed
753 754 755 756 757 758 759
/*
 * Interface for HD codec
 */

/*
 * CORB / RIRB interface
 */
760
static int azx_alloc_cmd_io(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
761 762 763 764
{
	int err;

	/* single page (at least 4096 bytes) must suffice for both ringbuffes */
765 766
	err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
				  snd_dma_pci_data(chip->pci),
Linus Torvalds's avatar
Linus Torvalds committed
767 768
				  PAGE_SIZE, &chip->rb);
	if (err < 0) {
769
		snd_printk(KERN_ERR SFX "%s: cannot allocate CORB/RIRB\n", pci_name(chip->pci));
Linus Torvalds's avatar
Linus Torvalds committed
770 771
		return err;
	}
772
	mark_pages_wc(chip, &chip->rb, true);
Linus Torvalds's avatar
Linus Torvalds committed
773 774 775
	return 0;
}

776
static void azx_init_cmd_io(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
777
{
778
	spin_lock_irq(&chip->reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
779 780 781 782
	/* CORB set up */
	chip->corb.addr = chip->rb.addr;
	chip->corb.buf = (u32 *)chip->rb.area;
	azx_writel(chip, CORBLBASE, (u32)chip->corb.addr);
783
	azx_writel(chip, CORBUBASE, upper_32_bits(chip->corb.addr));
Linus Torvalds's avatar
Linus Torvalds committed
784

785 786
	/* set the corb size to 256 entries (ULI requires explicitly) */
	azx_writeb(chip, CORBSIZE, 0x02);
Linus Torvalds's avatar
Linus Torvalds committed
787 788 789
	/* set the corb write pointer to 0 */
	azx_writew(chip, CORBWP, 0);
	/* reset the corb hw read pointer */
790
	azx_writew(chip, CORBRP, ICH6_CORBRP_RST);
Linus Torvalds's avatar
Linus Torvalds committed
791
	/* enable corb dma */
792
	azx_writeb(chip, CORBCTL, ICH6_CORBCTL_RUN);
Linus Torvalds's avatar
Linus Torvalds committed
793 794 795 796

	/* RIRB set up */
	chip->rirb.addr = chip->rb.addr + 2048;
	chip->rirb.buf = (u32 *)(chip->rb.area + 2048);
797 798
	chip->rirb.wp = chip->rirb.rp = 0;
	memset(chip->rirb.cmds, 0, sizeof(chip->rirb.cmds));
Linus Torvalds's avatar
Linus Torvalds committed
799
	azx_writel(chip, RIRBLBASE, (u32)chip->rirb.addr);
800
	azx_writel(chip, RIRBUBASE, upper_32_bits(chip->rirb.addr));
Linus Torvalds's avatar
Linus Torvalds committed
801

802 803
	/* set the rirb size to 256 entries (ULI requires explicitly) */
	azx_writeb(chip, RIRBSIZE, 0x02);
Linus Torvalds's avatar
Linus Torvalds committed
804
	/* reset the rirb hw write pointer */
805
	azx_writew(chip, RIRBWP, ICH6_RIRBWP_RST);
Linus Torvalds's avatar
Linus Torvalds committed
806
	/* set N=1, get RIRB response interrupt for new entry */
807
	if (chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND)
808 809 810
		azx_writew(chip, RINTCNT, 0xc0);
	else
		azx_writew(chip, RINTCNT, 1);
Linus Torvalds's avatar
Linus Torvalds committed
811 812
	/* enable rirb dma and response irq */
	azx_writeb(chip, RIRBCTL, ICH6_RBCTL_DMA_EN | ICH6_RBCTL_IRQ_EN);
813
	spin_unlock_irq(&chip->reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
814 815
}

816
static void azx_free_cmd_io(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
817
{
818
	spin_lock_irq(&chip->reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
819 820 821
	/* disable ringbuffer DMAs */
	azx_writeb(chip, RIRBCTL, 0);
	azx_writeb(chip, CORBCTL, 0);
822
	spin_unlock_irq(&chip->reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
823 824
}

825 826 827 828 829 830 831 832 833 834 835 836
static unsigned int azx_command_addr(u32 cmd)
{
	unsigned int addr = cmd >> 28;

	if (addr >= AZX_MAX_CODECS) {
		snd_BUG();
		addr = 0;
	}

	return addr;
}

Linus Torvalds's avatar
Linus Torvalds committed
837
/* send a command */
838
static int azx_corb_send_cmd(struct hda_bus *bus, u32 val)
Linus Torvalds's avatar
Linus Torvalds committed
839
{
840
	struct azx *chip = bus->private_data;
841
	unsigned int addr = azx_command_addr(val);
842
	unsigned int wp, rp;
Linus Torvalds's avatar
Linus Torvalds committed
843

844 845
	spin_lock_irq(&chip->reg_lock);

Linus Torvalds's avatar
Linus Torvalds committed
846
	/* add command to corb */
847 848 849 850
	wp = azx_readw(chip, CORBWP);
	if (wp == 0xffff) {
		/* something wrong, controller likely turned to D3 */
		spin_unlock_irq(&chip->reg_lock);
851
		return -EIO;
852
	}
Linus Torvalds's avatar
Linus Torvalds committed
853 854 855
	wp++;
	wp %= ICH6_MAX_CORB_ENTRIES;

856 857 858 859 860 861 862
	rp = azx_readw(chip, CORBRP);
	if (wp == rp) {
		/* oops, it's full */
		spin_unlock_irq(&chip->reg_lock);
		return -EAGAIN;
	}

863
	chip->rirb.cmds[addr]++;
Linus Torvalds's avatar
Linus Torvalds committed
864 865
	chip->corb.buf[wp] = cpu_to_le32(val);
	azx_writel(chip, CORBWP, wp);
866

Linus Torvalds's avatar
Linus Torvalds committed
867 868 869 870 871 872 873 874
	spin_unlock_irq(&chip->reg_lock);

	return 0;
}

#define ICH6_RIRB_EX_UNSOL_EV	(1<<4)

/* retrieve RIRB entry - called from interrupt handler */
875
static void azx_update_rirb(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
876 877
{
	unsigned int rp, wp;
878
	unsigned int addr;
Linus Torvalds's avatar
Linus Torvalds committed
879 880
	u32 res, res_ex;

881 882 883 884 885 886
	wp = azx_readw(chip, RIRBWP);
	if (wp == 0xffff) {
		/* something wrong, controller likely turned to D3 */
		return;
	}

Linus Torvalds's avatar
Linus Torvalds committed
887 888 889
	if (wp == chip->rirb.wp)
		return;
	chip->rirb.wp = wp;
890

Linus Torvalds's avatar
Linus Torvalds committed
891 892 893 894 895 896 897
	while (chip->rirb.rp != wp) {
		chip->rirb.rp++;
		chip->rirb.rp %= ICH6_MAX_RIRB_ENTRIES;

		rp = chip->rirb.rp << 1; /* an RIRB entry is 8-bytes */
		res_ex = le32_to_cpu(chip->rirb.buf[rp + 1]);
		res = le32_to_cpu(chip->rirb.buf[rp]);
898 899 900 901 902 903 904 905 906
		addr = res_ex & 0xf;
		if ((addr >= AZX_MAX_CODECS) || !(chip->codec_mask & (1 << addr))) {
			snd_printk(KERN_ERR SFX "%s: spurious response %#x:%#x, rp = %d, wp = %d",
				   pci_name(chip->pci),
				   res, res_ex,
				   chip->rirb.rp, wp);
			snd_BUG();
		}
		else if (res_ex & ICH6_RIRB_EX_UNSOL_EV)
Linus Torvalds's avatar
Linus Torvalds committed
907
			snd_hda_queue_unsol_event(chip->bus, res, res_ex);
908 909
		else if (chip->rirb.cmds[addr]) {
			chip->rirb.res[addr] = res;
910
			smp_wmb();
911
			chip->rirb.cmds[addr]--;
912 913
		} else if (printk_ratelimit()) {
			snd_printk(KERN_ERR SFX "%s: spurious response %#x:%#x, last cmd=%#08x\n",
914
				   pci_name(chip->pci),
915 916
				   res, res_ex,
				   chip->last_cmd[addr]);
917
		}
Linus Torvalds's avatar
Linus Torvalds committed
918 919 920 921
	}
}

/* receive a response */
922 923
static unsigned int azx_rirb_get_response(struct hda_bus *bus,
					  unsigned int addr)
Linus Torvalds's avatar
Linus Torvalds committed
924
{
925
	struct azx *chip = bus->private_data;
926
	unsigned long timeout;
927
	unsigned long loopcounter;
928
	int do_poll = 0;
Linus Torvalds's avatar
Linus Torvalds committed
929

930 931
 again:
	timeout = jiffies + msecs_to_jiffies(1000);
932 933

	for (loopcounter = 0;; loopcounter++) {
934
		if (chip->polling_mode || do_poll) {
935 936 937 938
			spin_lock_irq(&chip->reg_lock);
			azx_update_rirb(chip);
			spin_unlock_irq(&chip->reg_lock);
		}
939
		if (!chip->rirb.cmds[addr]) {
940
			smp_rmb();
941
			bus->rirb_error = 0;
942 943 944

			if (!do_poll)
				chip->poll_count = 0;
945
			return chip->rirb.res[addr]; /* the last value */
946
		}
947 948
		if (time_after(jiffies, timeout))
			break;
949
		if (bus->needs_damn_long_delay || loopcounter > 3000)
950 951 952 953 954
			msleep(2); /* temporary workaround */
		else {
			udelay(10);
			cond_resched();
		}
955
	}
956

957 958 959
	if (!bus->no_response_fallback)
		return -1;

960
	if (!chip->polling_mode && chip->poll_count < 2) {
961
		snd_printdd(SFX "%s: azx_get_response timeout, "
962
			   "polling the codec once: last cmd=0x%08x\n",
963
			   pci_name(chip->pci), chip->last_cmd[addr]);
964 965 966 967 968 969
		do_poll = 1;
		chip->poll_count++;
		goto again;
	}


970
	if (!chip->polling_mode) {
971
		snd_printk(KERN_WARNING SFX "%s: azx_get_response timeout, "
972
			   "switching to polling mode: last cmd=0x%08x\n",
973
			   pci_name(chip->pci), chip->last_cmd[addr]);
974 975 976 977
		chip->polling_mode = 1;
		goto again;
	}

978
	if (chip->msi) {
979
		snd_printk(KERN_WARNING SFX "%s: No response from codec, "
980
			   "disabling MSI: last cmd=0x%08x\n",
981
			   pci_name(chip->pci), chip->last_cmd[addr]);
982 983 984 985
		free_irq(chip->irq, chip);
		chip->irq = -1;
		pci_disable_msi(chip->pci);
		chip->msi = 0;
986 987
		if (azx_acquire_irq(chip, 1) < 0) {
			bus->rirb_error = 1;
988
			return -1;
989
		}
990 991 992
		goto again;
	}

993 994 995 996 997 998 999 1000
	if (chip->probing) {
		/* If this critical timeout happens during the codec probing
		 * phase, this is likely an access to a non-existing codec
		 * slot.  Better to return an error and reset the system.
		 */
		return -1;
	}

1001 1002 1003
	/* a fatal communication error; need either to reset or to fallback
	 * to the single_cmd mode
	 */
1004
	bus->rirb_error = 1;
1005
	if (bus->allow_bus_reset && !bus->response_reset && !bus->in_reset) {
1006 1007 1008 1009 1010 1011
		bus->response_reset = 1;
		return -1; /* give a chance to retry */
	}

	snd_printk(KERN_ERR "hda_intel: azx_get_response timeout, "
		   "switching to single_cmd mode: last cmd=0x%08x\n",
1012
		   chip->last_cmd[addr]);
1013 1014
	chip->single_cmd = 1;
	bus->response_reset = 0;
1015
	/* release CORB/RIRB */
1016
	azx_free_cmd_io(chip);
1017 1018
	/* disable unsolicited responses */
	azx_writel(chip, GCTL, azx_readl(chip, GCTL) & ~ICH6_GCTL_UNSOL);
1019
	return -1;
Linus Torvalds's avatar
Linus Torvalds committed
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
}

/*
 * Use the single immediate command instead of CORB/RIRB for simplicity
 *
 * Note: according to Intel, this is not preferred use.  The command was
 *       intended for the BIOS only, and may get confused with unsolicited
 *       responses.  So, we shouldn't use it for normal operation from the
 *       driver.
 *       I left the codes, however, for debugging/testing purposes.
 */

1032
/* receive a response */
1033
static int azx_single_wait_for_response(struct azx *chip, unsigned int addr)
1034 1035 1036 1037 1038 1039 1040
{
	int timeout = 50;

	while (timeout--) {
		/* check IRV busy bit */
		if (azx_readw(chip, IRS) & ICH6_IRS_VALID) {
			/* reuse rirb.res as the response return value */
1041
			chip->rirb.res[addr] = azx_readl(chip, IR);
1042 1043 1044 1045 1046
			return 0;
		}
		udelay(1);
	}
	if (printk_ratelimit())
1047 1048
		snd_printd(SFX "%s: get_response timeout: IRS=0x%x\n",
			   pci_name(chip->pci), azx_readw(chip, IRS));
1049
	chip->rirb.res[addr] = -1;
1050 1051 1052
	return -EIO;
}

Linus Torvalds's avatar
Linus Torvalds committed
1053
/* send a command */
1054
static int azx_single_send_cmd(struct hda_bus *bus, u32 val)
Linus Torvalds's avatar
Linus Torvalds committed
1055
{
1056
	struct azx *chip = bus->private_data;
1057
	unsigned int addr = azx_command_addr(val);
Linus Torvalds's avatar
Linus Torvalds committed
1058 1059
	int timeout = 50;

1060
	bus->rirb_error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1061 1062
	while (timeout--) {
		/* check ICB busy bit */
1063
		if (!((azx_readw(chip, IRS) & ICH6_IRS_BUSY))) {
Linus Torvalds's avatar
Linus Torvalds committed
1064
			/* Clear IRV valid bit */
1065 1066
			azx_writew(chip, IRS, azx_readw(chip, IRS) |
				   ICH6_IRS_VALID);
Linus Torvalds's avatar
Linus Torvalds committed
1067
			azx_writel(chip, IC, val);
1068 1069
			azx_writew(chip, IRS, azx_readw(chip, IRS) |
				   ICH6_IRS_BUSY);
1070
			return azx_single_wait_for_response(chip, addr);
Linus Torvalds's avatar
Linus Torvalds committed
1071 1072 1073
		}
		udelay(1);
	}
1074
	if (printk_ratelimit())
1075 1076
		snd_printd(SFX "%s: send_cmd timeout: IRS=0x%x, val=0x%x\n",
			   pci_name(chip->pci), azx_readw(chip, IRS), val);
Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079 1080
	return -EIO;
}

/* receive a response */
1081 1082
static unsigned int azx_single_get_response(struct hda_bus *bus,
					    unsigned int addr)
Linus Torvalds's avatar
Linus Torvalds committed
1083
{
1084
	struct azx *chip = bus->private_data;
1085
	return chip->rirb.res[addr];
Linus Torvalds's avatar
Linus Torvalds committed
1086 1087
}

1088 1089 1090 1091 1092 1093 1094 1095
/*
 * The below are the main callbacks from hda_codec.
 *
 * They are just the skeleton to call sub-callbacks according to the
 * current setting of chip->single_cmd.
 */

/* send a command */
1096
static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
1097
{
1098
	struct azx *chip = bus->private_data;
1099

1100 1101
	if (chip->disabled)
		return 0;
1102
	chip->last_cmd[azx_command_addr(val)] = val;
1103
	if (chip->single_cmd)
1104
		return azx_single_send_cmd(bus, val);
1105
	else
1106
		return azx_corb_send_cmd(bus, val);
1107 1108 1109
}

/* get a response */
1110 1111
static unsigned int azx_get_response(struct hda_bus *bus,
				     unsigned int addr)
1112
{
1113
	struct azx *chip = bus->private_data;
1114 1115
	if (chip->disabled)
		return 0;
1116
	if (chip->single_cmd)
1117
		return azx_single_get_response(bus, addr);
1118
	else
1119
		return azx_rirb_get_response(bus, addr);
1120 1121
}

1122
#ifdef CONFIG_PM
1123
static void azx_power_notify(struct hda_bus *bus, bool power_up);
1124
#endif
1125

1126 1127 1128 1129 1130 1131 1132 1133 1134
#ifdef CONFIG_SND_HDA_DSP_LOADER
static int azx_load_dsp_prepare(struct hda_bus *bus, unsigned int format,
				unsigned int byte_size,
				struct snd_dma_buffer *bufp);
static void azx_load_dsp_trigger(struct hda_bus *bus, bool start);
static void azx_load_dsp_cleanup(struct hda_bus *bus,
				 struct snd_dma_buffer *dmab);
#endif

1135
/* enter link reset */
1136
static void azx_enter_link_reset(struct azx *chip)
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
{
	unsigned long timeout;

	/* reset controller */
	azx_writel(chip, GCTL, azx_readl(chip, GCTL) & ~ICH6_GCTL_RESET);

	timeout = jiffies + msecs_to_jiffies(100);
	while ((azx_readb(chip, GCTL) & ICH6_GCTL_RESET) &&
			time_before(jiffies, timeout))
		usleep_range(500, 1000);
}

1149 1150
/* exit link reset */
static void azx_exit_link_reset(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
1151
{
1152
	unsigned long timeout;
Linus Torvalds's avatar
Linus Torvalds committed
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
	azx_writeb(chip, GCTL, azx_readb(chip, GCTL) | ICH6_GCTL_RESET);

	timeout = jiffies + msecs_to_jiffies(100);
	while (!azx_readb(chip, GCTL) &&
			time_before(jiffies, timeout))
		usleep_range(500, 1000);
}

/* reset codec link */
static int azx_reset(struct azx *chip, int full_reset)
{
1165 1166 1167
	if (!full_reset)
		goto __skip;

1168
	/* clear STATESTS */
1169
	azx_writew(chip, STATESTS, STATESTS_INT_MASK);
1170

Linus Torvalds's avatar
Linus Torvalds committed
1171
	/* reset controller */
1172
	azx_enter_link_reset(chip);
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175 1176

	/* delay for >= 100us for codec PLL to settle per spec
	 * Rev 0.9 section 5.5.1
	 */
1177
	usleep_range(500, 1000);
Linus Torvalds's avatar
Linus Torvalds committed
1178 1179

	/* Bring controller out of reset */
1180
	azx_exit_link_reset(chip);
Linus Torvalds's avatar
Linus Torvalds committed
1181

1182
	/* Brent Chartrand said to wait >= 540us for codecs to initialize */
1183
	usleep_range(1000, 1200);
Linus Torvalds's avatar
Linus Torvalds committed
1184

1185
      __skip:
Linus Torvalds's avatar
Linus Torvalds committed
1186
	/* check to see if controller is ready */
1187
	if (!azx_readb(chip, GCTL)) {
1188
		snd_printd(SFX "%s: azx_reset: controller not ready!\n", pci_name(chip->pci));
Linus Torvalds's avatar
Linus Torvalds committed
1189 1190 1191
		return -EBUSY;
	}

1192
	/* Accept unsolicited responses */
1193 1194 1195
	if (!chip->single_cmd)
		azx_writel(chip, GCTL, azx_readl(chip, GCTL) |
			   ICH6_GCTL_UNSOL);
1196

Linus Torvalds's avatar
Linus Torvalds committed
1197
	/* detect codecs */
1198
	if (!chip->codec_mask) {
Linus Torvalds's avatar
Linus Torvalds committed
1199
		chip->codec_mask = azx_readw(chip, STATESTS);
1200
		snd_printdd(SFX "%s: codec_mask = 0x%x\n", pci_name(chip->pci), chip->codec_mask);
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
	}

	return 0;
}


/*
 * Lowlevel interface
 */  

/* enable interrupts */
1212
static void azx_int_enable(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
1213 1214 1215 1216 1217 1218 1219
{
	/* enable controller CIE and GIE */
	azx_writel(chip, INTCTL, azx_readl(chip, INTCTL) |
		   ICH6_INT_CTRL_EN | ICH6_INT_GLOBAL_EN);
}

/* disable interrupts */
1220
static void azx_int_disable(struct azx *chip)
Linus Torvalds's avatar
Linus Torvalds committed
1221 1222 1223 1224
{
	int i;

	/* disable interrupts in stream descriptor */
1225
	for (i = 0; i < chip->num_streams; i++) {
1226
		struct azx_dev *azx_dev = &chip->azx_dev[i];
Linus Torvalds's avatar
Linus Torvalds committed
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
		azx_sd_writeb(azx_dev, SD_CTL,
			      azx_sd_readb(azx_dev, SD_CTL) & ~SD_INT_MASK);
	}

	/* disable SIE for all streams */
	azx_writeb(chip, INTCTL, 0);

	/* disable controller CIE and GIE */
	azx_writel(chip, INTCTL, azx_readl(chip, INTCTL) &
		   ~(ICH6_INT_CTRL_EN | ICH6_INT_GLOBAL_EN));
}

/* clear interrupts */