Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit eb74926920cfa756087a82e0b081df837177cb95

Authored by Linus Torvalds 2015-01-10 13:23:27 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

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

Pull sound fixes from Takashi Iwai:
 "All a few small regression or stable fixes: a Nvidia HDMI ID addition,
  a regression fix for CAIAQ stream count, a typo fix for GPIO setup
  with STAC/IDT HD-audio codecs, and a Fireworks big-endian fix"

* tag 'sound-3.19-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
  ALSA: fireworks: fix an endianness bug for transaction length
  ALSA: hda - Add new GPU codec ID 0x10de0072 to snd-hda
  ALSA: hda - Fix wrong gpio_dir & gpio_mask hint setups for IDT/STAC codecs
  ALSA: snd-usb-caiaq: fix stream count check

Showing 4 changed files Inline Diff

sound/firewire/fireworks/fireworks_transaction.c
sound/pci/hda/patch_hdmi.c
sound/pci/hda/patch_sigmatel.c
sound/usb/caiaq/audio.c

sound/firewire/fireworks/fireworks_transaction.c

Diff comments View file @ eb74926

1	/*	1	/*
2	* fireworks_transaction.c - a part of driver for Fireworks based devices	2	* fireworks_transaction.c - a part of driver for Fireworks based devices
3	*	3	*
4	* Copyright (c) 2013-2014 Takashi Sakamoto	4	* Copyright (c) 2013-2014 Takashi Sakamoto
5	*	5	*
6	* Licensed under the terms of the GNU General Public License, version 2.	6	* Licensed under the terms of the GNU General Public License, version 2.
7	*/	7	*/
8		8
9	/*	9	/*
10	* Fireworks have its own transaction. The transaction can be delivered by AV/C	10	* Fireworks have its own transaction. The transaction can be delivered by AV/C
11	* Vendor Specific command frame or usual asynchronous transaction. At least,	11	* Vendor Specific command frame or usual asynchronous transaction. At least,
12	* Windows driver and firmware version 5.5 or later don't use AV/C command.	12	* Windows driver and firmware version 5.5 or later don't use AV/C command.
13	*	13	*
14	* Transaction substance:	14	* Transaction substance:
15	* At first, 6 data exist. Following to the data, parameters for each command	15	* At first, 6 data exist. Following to the data, parameters for each command
16	* exist. All of the parameters are 32 bit alighed to big endian.	16	* exist. All of the parameters are 32 bit alighed to big endian.
17	* data[0]: Length of transaction substance	17	* data[0]: Length of transaction substance
18	* data[1]: Transaction version	18	* data[1]: Transaction version
19	* data[2]: Sequence number. This is incremented by the device	19	* data[2]: Sequence number. This is incremented by the device
20	* data[3]: Transaction category	20	* data[3]: Transaction category
21	* data[4]: Transaction command	21	* data[4]: Transaction command
22	* data[5]: Return value in response.	22	* data[5]: Return value in response.
23	* data[6-]: Parameters	23	* data[6-]: Parameters
24	*	24	*
25	* Transaction address:	25	* Transaction address:
26	* command: 0xecc000000000	26	* command: 0xecc000000000
27	* response: 0xecc080000000 (default)	27	* response: 0xecc080000000 (default)
28	*	28	*
29	* I note that the address for response can be changed by command. But this	29	* I note that the address for response can be changed by command. But this
30	* module uses the default address.	30	* module uses the default address.
31	*/	31	*/
32	#include "./fireworks.h"	32	#include "./fireworks.h"
33		33
34	#define MEMORY_SPACE_EFW_COMMAND 0xecc000000000ULL	34	#define MEMORY_SPACE_EFW_COMMAND 0xecc000000000ULL
35	#define MEMORY_SPACE_EFW_RESPONSE 0xecc080000000ULL	35	#define MEMORY_SPACE_EFW_RESPONSE 0xecc080000000ULL
36		36
37	#define ERROR_RETRIES 3	37	#define ERROR_RETRIES 3
38	#define ERROR_DELAY_MS 5	38	#define ERROR_DELAY_MS 5
39	#define EFC_TIMEOUT_MS 125	39	#define EFC_TIMEOUT_MS 125
40		40
41	static DEFINE_SPINLOCK(instances_lock);	41	static DEFINE_SPINLOCK(instances_lock);
42	static struct snd_efw *instances[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;	42	static struct snd_efw *instances[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
43		43
44	static DEFINE_SPINLOCK(transaction_queues_lock);	44	static DEFINE_SPINLOCK(transaction_queues_lock);
45	static LIST_HEAD(transaction_queues);	45	static LIST_HEAD(transaction_queues);
46		46
47	enum transaction_queue_state {	47	enum transaction_queue_state {
48	STATE_PENDING,	48	STATE_PENDING,
49	STATE_BUS_RESET,	49	STATE_BUS_RESET,
50	STATE_COMPLETE	50	STATE_COMPLETE
51	};	51	};
52		52
53	struct transaction_queue {	53	struct transaction_queue {
54	struct list_head list;	54	struct list_head list;
55	struct fw_unit *unit;	55	struct fw_unit *unit;
56	void *buf;	56	void *buf;
57	unsigned int size;	57	unsigned int size;
58	u32 seqnum;	58	u32 seqnum;
59	enum transaction_queue_state state;	59	enum transaction_queue_state state;
60	wait_queue_head_t wait;	60	wait_queue_head_t wait;
61	};	61	};
62		62
63	int snd_efw_transaction_cmd(struct fw_unit *unit,	63	int snd_efw_transaction_cmd(struct fw_unit *unit,
64	const void *cmd, unsigned int size)	64	const void *cmd, unsigned int size)
65	{	65	{
66	return snd_fw_transaction(unit, TCODE_WRITE_BLOCK_REQUEST,	66	return snd_fw_transaction(unit, TCODE_WRITE_BLOCK_REQUEST,
67	MEMORY_SPACE_EFW_COMMAND,	67	MEMORY_SPACE_EFW_COMMAND,
68	(void *)cmd, size, 0);	68	(void *)cmd, size, 0);
69	}	69	}
70		70
71	int snd_efw_transaction_run(struct fw_unit *unit,	71	int snd_efw_transaction_run(struct fw_unit *unit,
72	const void *cmd, unsigned int cmd_size,	72	const void *cmd, unsigned int cmd_size,
73	void *resp, unsigned int resp_size)	73	void *resp, unsigned int resp_size)
74	{	74	{
75	struct transaction_queue t;	75	struct transaction_queue t;
76	unsigned int tries;	76	unsigned int tries;
77	int ret;	77	int ret;
78		78
79	t.unit = unit;	79	t.unit = unit;
80	t.buf = resp;	80	t.buf = resp;
81	t.size = resp_size;	81	t.size = resp_size;
82	t.seqnum = be32_to_cpu(((struct snd_efw_transaction *)cmd)->seqnum) + 1;	82	t.seqnum = be32_to_cpu(((struct snd_efw_transaction *)cmd)->seqnum) + 1;
83	t.state = STATE_PENDING;	83	t.state = STATE_PENDING;
84	init_waitqueue_head(&t.wait);	84	init_waitqueue_head(&t.wait);
85		85
86	spin_lock_irq(&transaction_queues_lock);	86	spin_lock_irq(&transaction_queues_lock);
87	list_add_tail(&t.list, &transaction_queues);	87	list_add_tail(&t.list, &transaction_queues);
88	spin_unlock_irq(&transaction_queues_lock);	88	spin_unlock_irq(&transaction_queues_lock);
89		89
90	tries = 0;	90	tries = 0;
91	do {	91	do {
92	ret = snd_efw_transaction_cmd(t.unit, (void *)cmd, cmd_size);	92	ret = snd_efw_transaction_cmd(t.unit, (void *)cmd, cmd_size);
93	if (ret < 0)	93	if (ret < 0)
94	break;	94	break;
95		95
96	wait_event_timeout(t.wait, t.state != STATE_PENDING,	96	wait_event_timeout(t.wait, t.state != STATE_PENDING,
97	msecs_to_jiffies(EFC_TIMEOUT_MS));	97	msecs_to_jiffies(EFC_TIMEOUT_MS));
98		98
99	if (t.state == STATE_COMPLETE) {	99	if (t.state == STATE_COMPLETE) {
100	ret = t.size;	100	ret = t.size;
101	break;	101	break;
102	} else if (t.state == STATE_BUS_RESET) {	102	} else if (t.state == STATE_BUS_RESET) {
103	msleep(ERROR_DELAY_MS);	103	msleep(ERROR_DELAY_MS);
104	} else if (++tries >= ERROR_RETRIES) {	104	} else if (++tries >= ERROR_RETRIES) {
105	dev_err(&t.unit->device, "EFW transaction timed out\n");	105	dev_err(&t.unit->device, "EFW transaction timed out\n");
106	ret = -EIO;	106	ret = -EIO;
107	break;	107	break;
108	}	108	}
109	} while (1);	109	} while (1);
110		110
111	spin_lock_irq(&transaction_queues_lock);	111	spin_lock_irq(&transaction_queues_lock);
112	list_del(&t.list);	112	list_del(&t.list);
113	spin_unlock_irq(&transaction_queues_lock);	113	spin_unlock_irq(&transaction_queues_lock);
114		114
115	return ret;	115	return ret;
116	}	116	}
117		117
118	static void	118	static void
119	copy_resp_to_buf(struct snd_efw efw, void data, size_t length, int *rcode)	119	copy_resp_to_buf(struct snd_efw efw, void data, size_t length, int *rcode)
120	{	120	{
121	size_t capacity, till_end;	121	size_t capacity, till_end;
122	struct snd_efw_transaction *t;	122	struct snd_efw_transaction *t;
123		123
124	spin_lock_irq(&efw->lock);	124	spin_lock_irq(&efw->lock);
125		125
126	t = (struct snd_efw_transaction *)data;	126	t = (struct snd_efw_transaction *)data;
127	length = min_t(size_t, t->length * sizeof(t->length), length);	127	length = min_t(size_t, be32_to_cpu(t->length) * sizeof(u32), length);
128		128
129	if (efw->push_ptr < efw->pull_ptr)	129	if (efw->push_ptr < efw->pull_ptr)
130	capacity = (unsigned int)(efw->pull_ptr - efw->push_ptr);	130	capacity = (unsigned int)(efw->pull_ptr - efw->push_ptr);
131	else	131	else
132	capacity = snd_efw_resp_buf_size -	132	capacity = snd_efw_resp_buf_size -
133	(unsigned int)(efw->push_ptr - efw->pull_ptr);	133	(unsigned int)(efw->push_ptr - efw->pull_ptr);
134		134
135	/* confirm enough space for this response */	135	/* confirm enough space for this response */
136	if (capacity < length) {	136	if (capacity < length) {
137	*rcode = RCODE_CONFLICT_ERROR;	137	*rcode = RCODE_CONFLICT_ERROR;
138	goto end;	138	goto end;
139	}	139	}
140		140
141	/* copy to ring buffer */	141	/* copy to ring buffer */
142	while (length > 0) {	142	while (length > 0) {
143	till_end = snd_efw_resp_buf_size -	143	till_end = snd_efw_resp_buf_size -
144	(unsigned int)(efw->push_ptr - efw->resp_buf);	144	(unsigned int)(efw->push_ptr - efw->resp_buf);
145	till_end = min_t(unsigned int, length, till_end);	145	till_end = min_t(unsigned int, length, till_end);
146		146
147	memcpy(efw->push_ptr, data, till_end);	147	memcpy(efw->push_ptr, data, till_end);
148		148
149	efw->push_ptr += till_end;	149	efw->push_ptr += till_end;
150	if (efw->push_ptr >= efw->resp_buf + snd_efw_resp_buf_size)	150	if (efw->push_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
151	efw->push_ptr -= snd_efw_resp_buf_size;	151	efw->push_ptr -= snd_efw_resp_buf_size;
152		152
153	length -= till_end;	153	length -= till_end;
154	data += till_end;	154	data += till_end;
155	}	155	}
156		156
157	/* for hwdep */	157	/* for hwdep */
158	efw->resp_queues++;	158	efw->resp_queues++;
159	wake_up(&efw->hwdep_wait);	159	wake_up(&efw->hwdep_wait);
160		160
161	*rcode = RCODE_COMPLETE;	161	*rcode = RCODE_COMPLETE;
162	end:	162	end:
163	spin_unlock_irq(&efw->lock);	163	spin_unlock_irq(&efw->lock);
164	}	164	}
165		165
166	static void	166	static void
167	handle_resp_for_user(struct fw_card *card, int generation, int source,	167	handle_resp_for_user(struct fw_card *card, int generation, int source,
168	void data, size_t length, int rcode)	168	void data, size_t length, int rcode)
169	{	169	{
170	struct fw_device *device;	170	struct fw_device *device;
171	struct snd_efw *efw;	171	struct snd_efw *efw;
172	unsigned int i;	172	unsigned int i;
173		173
174	spin_lock_irq(&instances_lock);	174	spin_lock_irq(&instances_lock);
175		175
176	for (i = 0; i < SNDRV_CARDS; i++) {	176	for (i = 0; i < SNDRV_CARDS; i++) {
177	efw = instances[i];	177	efw = instances[i];
178	if (efw == NULL)	178	if (efw == NULL)
179	continue;	179	continue;
180	device = fw_parent_device(efw->unit);	180	device = fw_parent_device(efw->unit);
181	if ((device->card != card) \|\|	181	if ((device->card != card) \|\|
182	(device->generation != generation))	182	(device->generation != generation))
183	continue;	183	continue;
184	smp_rmb(); /* node id vs. generation */	184	smp_rmb(); /* node id vs. generation */
185	if (device->node_id != source)	185	if (device->node_id != source)
186	continue;	186	continue;
187		187
188	break;	188	break;
189	}	189	}
190	if (i == SNDRV_CARDS)	190	if (i == SNDRV_CARDS)
191	goto end;	191	goto end;
192		192
193	copy_resp_to_buf(efw, data, length, rcode);	193	copy_resp_to_buf(efw, data, length, rcode);
194	end:	194	end:
195	spin_unlock_irq(&instances_lock);	195	spin_unlock_irq(&instances_lock);
196	}	196	}
197		197
198	static void	198	static void
199	handle_resp_for_kernel(struct fw_card *card, int generation, int source,	199	handle_resp_for_kernel(struct fw_card *card, int generation, int source,
200	void data, size_t length, int rcode, u32 seqnum)	200	void data, size_t length, int rcode, u32 seqnum)
201	{	201	{
202	struct fw_device *device;	202	struct fw_device *device;
203	struct transaction_queue *t;	203	struct transaction_queue *t;
204	unsigned long flags;	204	unsigned long flags;
205		205
206	spin_lock_irqsave(&transaction_queues_lock, flags);	206	spin_lock_irqsave(&transaction_queues_lock, flags);
207	list_for_each_entry(t, &transaction_queues, list) {	207	list_for_each_entry(t, &transaction_queues, list) {
208	device = fw_parent_device(t->unit);	208	device = fw_parent_device(t->unit);
209	if ((device->card != card) \|\|	209	if ((device->card != card) \|\|
210	(device->generation != generation))	210	(device->generation != generation))
211	continue;	211	continue;
212	smp_rmb(); /* node_id vs. generation */	212	smp_rmb(); /* node_id vs. generation */
213	if (device->node_id != source)	213	if (device->node_id != source)
214	continue;	214	continue;
215		215
216	if ((t->state == STATE_PENDING) && (t->seqnum == seqnum)) {	216	if ((t->state == STATE_PENDING) && (t->seqnum == seqnum)) {
217	t->state = STATE_COMPLETE;	217	t->state = STATE_COMPLETE;
218	t->size = min_t(unsigned int, length, t->size);	218	t->size = min_t(unsigned int, length, t->size);
219	memcpy(t->buf, data, t->size);	219	memcpy(t->buf, data, t->size);
220	wake_up(&t->wait);	220	wake_up(&t->wait);
221	*rcode = RCODE_COMPLETE;	221	*rcode = RCODE_COMPLETE;
222	}	222	}
223	}	223	}
224	spin_unlock_irqrestore(&transaction_queues_lock, flags);	224	spin_unlock_irqrestore(&transaction_queues_lock, flags);
225	}	225	}
226		226
227	static void	227	static void
228	efw_response(struct fw_card card, struct fw_request request,	228	efw_response(struct fw_card card, struct fw_request request,
229	int tcode, int destination, int source,	229	int tcode, int destination, int source,
230	int generation, unsigned long long offset,	230	int generation, unsigned long long offset,
231	void data, size_t length, void callback_data)	231	void data, size_t length, void callback_data)
232	{	232	{
233	int rcode, dummy;	233	int rcode, dummy;
234	u32 seqnum;	234	u32 seqnum;
235		235
236	rcode = RCODE_TYPE_ERROR;	236	rcode = RCODE_TYPE_ERROR;
237	if (length < sizeof(struct snd_efw_transaction)) {	237	if (length < sizeof(struct snd_efw_transaction)) {
238	rcode = RCODE_DATA_ERROR;	238	rcode = RCODE_DATA_ERROR;
239	goto end;	239	goto end;
240	} else if (offset != MEMORY_SPACE_EFW_RESPONSE) {	240	} else if (offset != MEMORY_SPACE_EFW_RESPONSE) {
241	rcode = RCODE_ADDRESS_ERROR;	241	rcode = RCODE_ADDRESS_ERROR;
242	goto end;	242	goto end;
243	}	243	}
244		244
245	seqnum = be32_to_cpu(((struct snd_efw_transaction *)data)->seqnum);	245	seqnum = be32_to_cpu(((struct snd_efw_transaction *)data)->seqnum);
246	if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX + 1) {	246	if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX + 1) {
247	handle_resp_for_kernel(card, generation, source,	247	handle_resp_for_kernel(card, generation, source,
248	data, length, &rcode, seqnum);	248	data, length, &rcode, seqnum);
249	if (snd_efw_resp_buf_debug)	249	if (snd_efw_resp_buf_debug)
250	handle_resp_for_user(card, generation, source,	250	handle_resp_for_user(card, generation, source,
251	data, length, &dummy);	251	data, length, &dummy);
252	} else {	252	} else {
253	handle_resp_for_user(card, generation, source,	253	handle_resp_for_user(card, generation, source,
254	data, length, &rcode);	254	data, length, &rcode);
255	}	255	}
256	end:	256	end:
257	fw_send_response(card, request, rcode);	257	fw_send_response(card, request, rcode);
258	}	258	}
259		259
260	void snd_efw_transaction_add_instance(struct snd_efw *efw)	260	void snd_efw_transaction_add_instance(struct snd_efw *efw)
261	{	261	{
262	unsigned int i;	262	unsigned int i;
263		263
264	spin_lock_irq(&instances_lock);	264	spin_lock_irq(&instances_lock);
265		265
266	for (i = 0; i < SNDRV_CARDS; i++) {	266	for (i = 0; i < SNDRV_CARDS; i++) {
267	if (instances[i] != NULL)	267	if (instances[i] != NULL)
268	continue;	268	continue;
269	instances[i] = efw;	269	instances[i] = efw;
270	break;	270	break;
271	}	271	}
272		272
273	spin_unlock_irq(&instances_lock);	273	spin_unlock_irq(&instances_lock);
274	}	274	}
275		275
276	void snd_efw_transaction_remove_instance(struct snd_efw *efw)	276	void snd_efw_transaction_remove_instance(struct snd_efw *efw)
277	{	277	{
278	unsigned int i;	278	unsigned int i;
279		279
280	spin_lock_irq(&instances_lock);	280	spin_lock_irq(&instances_lock);
281		281
282	for (i = 0; i < SNDRV_CARDS; i++) {	282	for (i = 0; i < SNDRV_CARDS; i++) {
283	if (instances[i] != efw)	283	if (instances[i] != efw)
284	continue;	284	continue;
285	instances[i] = NULL;	285	instances[i] = NULL;
286	}	286	}
287		287
288	spin_unlock_irq(&instances_lock);	288	spin_unlock_irq(&instances_lock);
289	}	289	}
290		290
291	void snd_efw_transaction_bus_reset(struct fw_unit *unit)	291	void snd_efw_transaction_bus_reset(struct fw_unit *unit)
292	{	292	{
293	struct transaction_queue *t;	293	struct transaction_queue *t;
294		294
295	spin_lock_irq(&transaction_queues_lock);	295	spin_lock_irq(&transaction_queues_lock);
296	list_for_each_entry(t, &transaction_queues, list) {	296	list_for_each_entry(t, &transaction_queues, list) {
297	if ((t->unit == unit) &&	297	if ((t->unit == unit) &&
298	(t->state == STATE_PENDING)) {	298	(t->state == STATE_PENDING)) {
299	t->state = STATE_BUS_RESET;	299	t->state = STATE_BUS_RESET;
300	wake_up(&t->wait);	300	wake_up(&t->wait);
301	}	301	}
302	}	302	}
303	spin_unlock_irq(&transaction_queues_lock);	303	spin_unlock_irq(&transaction_queues_lock);
304	}	304	}
305		305
306	static struct fw_address_handler resp_register_handler = {	306	static struct fw_address_handler resp_register_handler = {
307	.length = SND_EFW_RESPONSE_MAXIMUM_BYTES,	307	.length = SND_EFW_RESPONSE_MAXIMUM_BYTES,
308	.address_callback = efw_response	308	.address_callback = efw_response
309	};	309	};
310		310
311	int snd_efw_transaction_register(void)	311	int snd_efw_transaction_register(void)
312	{	312	{
313	static const struct fw_address_region resp_register_region = {	313	static const struct fw_address_region resp_register_region = {
314	.start = MEMORY_SPACE_EFW_RESPONSE,	314	.start = MEMORY_SPACE_EFW_RESPONSE,
315	.end = MEMORY_SPACE_EFW_RESPONSE +	315	.end = MEMORY_SPACE_EFW_RESPONSE +
316	SND_EFW_RESPONSE_MAXIMUM_BYTES	316	SND_EFW_RESPONSE_MAXIMUM_BYTES
317	};	317	};
318	return fw_core_add_address_handler(&resp_register_handler,	318	return fw_core_add_address_handler(&resp_register_handler,
319	&resp_register_region);	319	&resp_register_region);
320	}	320	}
321		321
322	void snd_efw_transaction_unregister(void)	322	void snd_efw_transaction_unregister(void)
323	{	323	{
324	WARN_ON(!list_empty(&transaction_queues));	324	WARN_ON(!list_empty(&transaction_queues));
325	fw_core_remove_address_handler(&resp_register_handler);	325	fw_core_remove_address_handler(&resp_register_handler);
326	}	326	}
327		327

sound/pci/hda/patch_hdmi.c

Diff comments View file @ eb74926

 /*
  *
  *  patch_hdmi.c - routines for HDMI/DisplayPort codecs
  *
  *  Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
  *  Copyright (c) 2006 ATI Technologies Inc.
  *  Copyright (c) 2008 NVIDIA Corp.  All rights reserved.
  *  Copyright (c) 2008 Wei Ni <wni@nvidia.com>
  *  Copyright (c) 2013 Anssi Hannula <anssi.hannula@iki.fi>
  *
  *  Authors:
  *			Wu Fengguang <wfg@linux.intel.com>
  *
  *  Maintained by:
  *			Wu Fengguang <wfg@linux.intel.com>
  *
  *  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.
  */
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <sound/core.h>
 #include <sound/jack.h>
 #include <sound/asoundef.h>
 #include <sound/tlv.h>
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_jack.h"
 static bool static_hdmi_pcm;
 module_param(static_hdmi_pcm, bool, 0644);
 MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info");
 #define is_haswell(codec)  ((codec)->vendor_id == 0x80862807)
 #define is_broadwell(codec)    ((codec)->vendor_id == 0x80862808)
 #define is_skylake(codec) ((codec)->vendor_id == 0x80862809)
 #define is_haswell_plus(codec) (is_haswell(codec) || is_broadwell(codec) \
 					|| is_skylake(codec))
 #define is_valleyview(codec) ((codec)->vendor_id == 0x80862882)
 #define is_cherryview(codec) ((codec)->vendor_id == 0x80862883)
 #define is_valleyview_plus(codec) (is_valleyview(codec) || is_cherryview(codec))
 struct hdmi_spec_per_cvt {
 	hda_nid_t cvt_nid;
 	int assigned;
 	unsigned int channels_min;
 	unsigned int channels_max;
 	u32 rates;
 	u64 formats;
 	unsigned int maxbps;
 };
 /* max. connections to a widget */
 #define HDA_MAX_CONNECTIONS	32
 struct hdmi_spec_per_pin {
 	hda_nid_t pin_nid;
 	int num_mux_nids;
 	hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
 	int mux_idx;
 	hda_nid_t cvt_nid;
 	struct hda_codec *codec;
 	struct hdmi_eld sink_eld;
 	struct mutex lock;
 	struct delayed_work work;
 	struct snd_kcontrol *eld_ctl;
 	int repoll_count;
 	bool setup; /* the stream has been set up by prepare callback */
 	int channels; /* current number of channels */
 	bool non_pcm;
 	bool chmap_set;		/* channel-map override by ALSA API? */
 	unsigned char chmap[8]; /* ALSA API channel-map */
 	char pcm_name[8];	/* filled in build_pcm callbacks */
 #ifdef CONFIG_PROC_FS
 	struct snd_info_entry *proc_entry;
 #endif
 };
 struct cea_channel_speaker_allocation;
 /* operations used by generic code that can be overridden by patches */
 struct hdmi_ops {
 	int (*pin_get_eld)(struct hda_codec *codec, hda_nid_t pin_nid,
 			   unsigned char *buf, int *eld_size);
 	/* get and set channel assigned to each HDMI ASP (audio sample packet) slot */
 	int (*pin_get_slot_channel)(struct hda_codec *codec, hda_nid_t pin_nid,
 				    int asp_slot);
 	int (*pin_set_slot_channel)(struct hda_codec *codec, hda_nid_t pin_nid,
 				    int asp_slot, int channel);
 	void (*pin_setup_infoframe)(struct hda_codec *codec, hda_nid_t pin_nid,
 				    int ca, int active_channels, int conn_type);
 	/* enable/disable HBR (HD passthrough) */
 	int (*pin_hbr_setup)(struct hda_codec *codec, hda_nid_t pin_nid, bool hbr);
 	int (*setup_stream)(struct hda_codec *codec, hda_nid_t cvt_nid,
 			    hda_nid_t pin_nid, u32 stream_tag, int format);
 	/* Helpers for producing the channel map TLVs. These can be overridden
 	 * for devices that have non-standard mapping requirements. */
 	int (*chmap_cea_alloc_validate_get_type)(struct cea_channel_speaker_allocation *cap,
 						 int channels);
 	void (*cea_alloc_to_tlv_chmap)(struct cea_channel_speaker_allocation *cap,
 				       unsigned int *chmap, int channels);
 	/* check that the user-given chmap is supported */
 	int (*chmap_validate)(int ca, int channels, unsigned char *chmap);
 };
 struct hdmi_spec {
 	int num_cvts;
 	struct snd_array cvts; /* struct hdmi_spec_per_cvt */
 	hda_nid_t cvt_nids[4]; /* only for haswell fix */
 	int num_pins;
 	struct snd_array pins; /* struct hdmi_spec_per_pin */
 	struct snd_array pcm_rec; /* struct hda_pcm */
 	unsigned int channels_max; /* max over all cvts */
 	struct hdmi_eld temp_eld;
 	struct hdmi_ops ops;
 	bool dyn_pin_out;
 	/*
 	 * Non-generic VIA/NVIDIA specific
 	 */
 	struct hda_multi_out multiout;
 	struct hda_pcm_stream pcm_playback;
 };
 struct hdmi_audio_infoframe {
 	u8 type; /* 0x84 */
 	u8 ver;  /* 0x01 */
 	u8 len;  /* 0x0a */
 	u8 checksum;
 	u8 CC02_CT47;	/* CC in bits 0:2, CT in 4:7 */
 	u8 SS01_SF24;
 	u8 CXT04;
 	u8 CA;
 	u8 LFEPBL01_LSV36_DM_INH7;
 };
 struct dp_audio_infoframe {
 	u8 type; /* 0x84 */
 	u8 len;  /* 0x1b */
 	u8 ver;  /* 0x11 << 2 */
 	u8 CC02_CT47;	/* match with HDMI infoframe from this on */
 	u8 SS01_SF24;
 	u8 CXT04;
 	u8 CA;
 	u8 LFEPBL01_LSV36_DM_INH7;
 };
 union audio_infoframe {
 	struct hdmi_audio_infoframe hdmi;
 	struct dp_audio_infoframe dp;
 	u8 bytes[0];
 };
 /*
  * CEA speaker placement:
  *
  *        FLH       FCH        FRH
  *  FLW    FL  FLC   FC   FRC   FR   FRW
  *
  *                                  LFE
  *                     TC
  *
  *          RL  RLC   RC   RRC   RR
  *
  * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
  * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
  */
 enum cea_speaker_placement {
 	FL  = (1 <<  0),	/* Front Left           */
 	FC  = (1 <<  1),	/* Front Center         */
 	FR  = (1 <<  2),	/* Front Right          */
 	FLC = (1 <<  3),	/* Front Left Center    */
 	FRC = (1 <<  4),	/* Front Right Center   */
 	RL  = (1 <<  5),	/* Rear Left            */
 	RC  = (1 <<  6),	/* Rear Center          */
 	RR  = (1 <<  7),	/* Rear Right           */
 	RLC = (1 <<  8),	/* Rear Left Center     */
 	RRC = (1 <<  9),	/* Rear Right Center    */
 	LFE = (1 << 10),	/* Low Frequency Effect */
 	FLW = (1 << 11),	/* Front Left Wide      */
 	FRW = (1 << 12),	/* Front Right Wide     */
 	FLH = (1 << 13),	/* Front Left High      */
 	FCH = (1 << 14),	/* Front Center High    */
 	FRH = (1 << 15),	/* Front Right High     */
 	TC  = (1 << 16),	/* Top Center           */
 };
 /*
  * ELD SA bits in the CEA Speaker Allocation data block
  */
 static int eld_speaker_allocation_bits[] = {
 	[0] = FL | FR,
 	[1] = LFE,
 	[2] = FC,
 	[3] = RL | RR,
 	[4] = RC,
 	[5] = FLC | FRC,
 	[6] = RLC | RRC,
 	/* the following are not defined in ELD yet */
 	[7] = FLW | FRW,
 	[8] = FLH | FRH,
 	[9] = TC,
 	[10] = FCH,
 };
 struct cea_channel_speaker_allocation {
 	int ca_index;
 	int speakers[8];
 	/* derived values, just for convenience */
 	int channels;
 	int spk_mask;
 };
 /*
  * ALSA sequence is:
  *
  *       surround40   surround41   surround50   surround51   surround71
  * ch0   front left   =            =            =            =
  * ch1   front right  =            =            =            =
  * ch2   rear left    =            =            =            =
  * ch3   rear right   =            =            =            =
  * ch4                LFE          center       center       center
  * ch5                                          LFE          LFE
  * ch6                                                       side left
  * ch7                                                       side right
  *
  * surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
  */
 static int hdmi_channel_mapping[0x32][8] = {
 	/* stereo */
 	[0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
 	/* 2.1 */
 	[0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
 	/* Dolby Surround */
 	[0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
 	/* surround40 */
 	[0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
 	/* 4ch */
 	[0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
 	/* surround41 */
 	[0x09] = { 0x00, 0x11, 0x24, 0x35, 0x42, 0xf3, 0xf6, 0xf7 },
 	/* surround50 */
 	[0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
 	/* surround51 */
 	[0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
 	/* 7.1 */
 	[0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
 };
 /*
  * This is an ordered list!
  *
  * The preceding ones have better chances to be selected by
  * hdmi_channel_allocation().
  */
 static struct cea_channel_speaker_allocation channel_allocations[] = {
 /*			  channel:   7     6    5    4    3     2    1    0  */
 { .ca_index = 0x00,  .speakers = {   0,    0,   0,   0,   0,    0,  FR,  FL } },
 				 /* 2.1 */
 { .ca_index = 0x01,  .speakers = {   0,    0,   0,   0,   0,  LFE,  FR,  FL } },
 				 /* Dolby Surround */
 { .ca_index = 0x02,  .speakers = {   0,    0,   0,   0,  FC,    0,  FR,  FL } },
 				 /* surround40 */
 { .ca_index = 0x08,  .speakers = {   0,    0,  RR,  RL,   0,    0,  FR,  FL } },
 				 /* surround41 */
 { .ca_index = 0x09,  .speakers = {   0,    0,  RR,  RL,   0,  LFE,  FR,  FL } },
 				 /* surround50 */
 { .ca_index = 0x0a,  .speakers = {   0,    0,  RR,  RL,  FC,    0,  FR,  FL } },
 				 /* surround51 */
 { .ca_index = 0x0b,  .speakers = {   0,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
 				 /* 6.1 */
 { .ca_index = 0x0f,  .speakers = {   0,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
 				 /* surround71 */
 { .ca_index = 0x13,  .speakers = { RRC,  RLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x03,  .speakers = {   0,    0,   0,   0,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x04,  .speakers = {   0,    0,   0,  RC,   0,    0,  FR,  FL } },
 { .ca_index = 0x05,  .speakers = {   0,    0,   0,  RC,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x06,  .speakers = {   0,    0,   0,  RC,  FC,    0,  FR,  FL } },
 { .ca_index = 0x07,  .speakers = {   0,    0,   0,  RC,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x0c,  .speakers = {   0,   RC,  RR,  RL,   0,    0,  FR,  FL } },
 { .ca_index = 0x0d,  .speakers = {   0,   RC,  RR,  RL,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x0e,  .speakers = {   0,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x10,  .speakers = { RRC,  RLC,  RR,  RL,   0,    0,  FR,  FL } },
 { .ca_index = 0x11,  .speakers = { RRC,  RLC,  RR,  RL,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x12,  .speakers = { RRC,  RLC,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x14,  .speakers = { FRC,  FLC,   0,   0,   0,    0,  FR,  FL } },
 { .ca_index = 0x15,  .speakers = { FRC,  FLC,   0,   0,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x16,  .speakers = { FRC,  FLC,   0,   0,  FC,    0,  FR,  FL } },
 { .ca_index = 0x17,  .speakers = { FRC,  FLC,   0,   0,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x18,  .speakers = { FRC,  FLC,   0,  RC,   0,    0,  FR,  FL } },
 { .ca_index = 0x19,  .speakers = { FRC,  FLC,   0,  RC,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x1a,  .speakers = { FRC,  FLC,   0,  RC,  FC,    0,  FR,  FL } },
 { .ca_index = 0x1b,  .speakers = { FRC,  FLC,   0,  RC,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x1c,  .speakers = { FRC,  FLC,  RR,  RL,   0,    0,  FR,  FL } },
 { .ca_index = 0x1d,  .speakers = { FRC,  FLC,  RR,  RL,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x1e,  .speakers = { FRC,  FLC,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x1f,  .speakers = { FRC,  FLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x20,  .speakers = {   0,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x21,  .speakers = {   0,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x22,  .speakers = {  TC,    0,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x23,  .speakers = {  TC,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x24,  .speakers = { FRH,  FLH,  RR,  RL,   0,    0,  FR,  FL } },
 { .ca_index = 0x25,  .speakers = { FRH,  FLH,  RR,  RL,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x26,  .speakers = { FRW,  FLW,  RR,  RL,   0,    0,  FR,  FL } },
 { .ca_index = 0x27,  .speakers = { FRW,  FLW,  RR,  RL,   0,  LFE,  FR,  FL } },
 { .ca_index = 0x28,  .speakers = {  TC,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x29,  .speakers = {  TC,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x2a,  .speakers = { FCH,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x2b,  .speakers = { FCH,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x2c,  .speakers = {  TC,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x2d,  .speakers = {  TC,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x2e,  .speakers = { FRH,  FLH,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x2f,  .speakers = { FRH,  FLH,  RR,  RL,  FC,  LFE,  FR,  FL } },
 { .ca_index = 0x30,  .speakers = { FRW,  FLW,  RR,  RL,  FC,    0,  FR,  FL } },
 { .ca_index = 0x31,  .speakers = { FRW,  FLW,  RR,  RL,  FC,  LFE,  FR,  FL } },
 };
 /*
  * HDMI routines
  */
 #define get_pin(spec, idx) \
 	((struct hdmi_spec_per_pin *)snd_array_elem(&spec->pins, idx))
 #define get_cvt(spec, idx) \
 	((struct hdmi_spec_per_cvt  *)snd_array_elem(&spec->cvts, idx))
 #define get_pcm_rec(spec, idx) \
 	((struct hda_pcm *)snd_array_elem(&spec->pcm_rec, idx))
 static int pin_nid_to_pin_index(struct hda_codec *codec, hda_nid_t pin_nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++)
 		if (get_pin(spec, pin_idx)->pin_nid == pin_nid)
 			return pin_idx;
 	codec_warn(codec, "HDMI: pin nid %d not registered\n", pin_nid);
 	return -EINVAL;
 }
 static int hinfo_to_pin_index(struct hda_codec *codec,
 			      struct hda_pcm_stream *hinfo)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++)
 		if (get_pcm_rec(spec, pin_idx)->stream == hinfo)
 			return pin_idx;
 	codec_warn(codec, "HDMI: hinfo %p not registered\n", hinfo);
 	return -EINVAL;
 }
 static int cvt_nid_to_cvt_index(struct hda_codec *codec, hda_nid_t cvt_nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int cvt_idx;
 	for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++)
 		if (get_cvt(spec, cvt_idx)->cvt_nid == cvt_nid)
 			return cvt_idx;
 	codec_warn(codec, "HDMI: cvt nid %d not registered\n", cvt_nid);
 	return -EINVAL;
 }
 static int hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol,
 			struct snd_ctl_elem_info *uinfo)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin;
 	struct hdmi_eld *eld;
 	int pin_idx;
 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
 	pin_idx = kcontrol->private_value;
 	per_pin = get_pin(spec, pin_idx);
 	eld = &per_pin->sink_eld;
 	mutex_lock(&per_pin->lock);
 	uinfo->count = eld->eld_valid ? eld->eld_size : 0;
 	mutex_unlock(&per_pin->lock);
 	return 0;
 }
 static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol,
 			struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin;
 	struct hdmi_eld *eld;
 	int pin_idx;
 	pin_idx = kcontrol->private_value;
 	per_pin = get_pin(spec, pin_idx);
 	eld = &per_pin->sink_eld;
 	mutex_lock(&per_pin->lock);
 	if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data)) {
 		mutex_unlock(&per_pin->lock);
 		snd_BUG();
 		return -EINVAL;
 	}
 	memset(ucontrol->value.bytes.data, 0,
 	       ARRAY_SIZE(ucontrol->value.bytes.data));
 	if (eld->eld_valid)
 		memcpy(ucontrol->value.bytes.data, eld->eld_buffer,
 		       eld->eld_size);
 	mutex_unlock(&per_pin->lock);
 	return 0;
 }
 static struct snd_kcontrol_new eld_bytes_ctl = {
 	.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
 	.name = "ELD",
 	.info = hdmi_eld_ctl_info,
 	.get = hdmi_eld_ctl_get,
 };
 static int hdmi_create_eld_ctl(struct hda_codec *codec, int pin_idx,
 			int device)
 {
 	struct snd_kcontrol *kctl;
 	struct hdmi_spec *spec = codec->spec;
 	int err;
 	kctl = snd_ctl_new1(&eld_bytes_ctl, codec);
 	if (!kctl)
 		return -ENOMEM;
 	kctl->private_value = pin_idx;
 	kctl->id.device = device;
 	err = snd_hda_ctl_add(codec, get_pin(spec, pin_idx)->pin_nid, kctl);
 	if (err < 0)
 		return err;
 	get_pin(spec, pin_idx)->eld_ctl = kctl;
 	return 0;
 }
 #ifdef BE_PARANOID
 static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
 				int *packet_index, int *byte_index)
 {
 	int val;
 	val = snd_hda_codec_read(codec, pin_nid, 0,
 				 AC_VERB_GET_HDMI_DIP_INDEX, 0);
 	*packet_index = val >> 5;
 	*byte_index = val & 0x1f;
 }
 #endif
 static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
 				int packet_index, int byte_index)
 {
 	int val;
 	val = (packet_index << 5) | (byte_index & 0x1f);
 	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
 }
 static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
 				unsigned char val)
 {
 	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
 }
 static void hdmi_init_pin(struct hda_codec *codec, hda_nid_t pin_nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_out;
 	/* Unmute */
 	if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
 		snd_hda_codec_write(codec, pin_nid, 0,
 				AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
 	if (spec->dyn_pin_out)
 		/* Disable pin out until stream is active */
 		pin_out = 0;
 	else
 		/* Enable pin out: some machines with GM965 gets broken output
 		 * when the pin is disabled or changed while using with HDMI
 		 */
 		pin_out = PIN_OUT;
 	snd_hda_codec_write(codec, pin_nid, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, pin_out);
 }
 static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t cvt_nid)
 {
 	return 1 + snd_hda_codec_read(codec, cvt_nid, 0,
 					AC_VERB_GET_CVT_CHAN_COUNT, 0);
 }
 static void hdmi_set_channel_count(struct hda_codec *codec,
 				   hda_nid_t cvt_nid, int chs)
 {
 	if (chs != hdmi_get_channel_count(codec, cvt_nid))
 		snd_hda_codec_write(codec, cvt_nid, 0,
 				    AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
 }
 /*
  * ELD proc files
  */
 #ifdef CONFIG_PROC_FS
 static void print_eld_info(struct snd_info_entry *entry,
 			   struct snd_info_buffer *buffer)
 {
 	struct hdmi_spec_per_pin *per_pin = entry->private_data;
 	mutex_lock(&per_pin->lock);
 	snd_hdmi_print_eld_info(&per_pin->sink_eld, buffer);
 	mutex_unlock(&per_pin->lock);
 }
 static void write_eld_info(struct snd_info_entry *entry,
 			   struct snd_info_buffer *buffer)
 {
 	struct hdmi_spec_per_pin *per_pin = entry->private_data;
 	mutex_lock(&per_pin->lock);
 	snd_hdmi_write_eld_info(&per_pin->sink_eld, buffer);
 	mutex_unlock(&per_pin->lock);
 }
 static int eld_proc_new(struct hdmi_spec_per_pin *per_pin, int index)
 {
 	char name[32];
 	struct hda_codec *codec = per_pin->codec;
 	struct snd_info_entry *entry;
 	int err;
 	snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
 	err = snd_card_proc_new(codec->bus->card, name, &entry);
 	if (err < 0)
 		return err;
 	snd_info_set_text_ops(entry, per_pin, print_eld_info);
 	entry->c.text.write = write_eld_info;
 	entry->mode |= S_IWUSR;
 	per_pin->proc_entry = entry;
 	return 0;
 }
 static void eld_proc_free(struct hdmi_spec_per_pin *per_pin)
 {
 	if (!per_pin->codec->bus->shutdown && per_pin->proc_entry) {
 		snd_device_free(per_pin->codec->bus->card, per_pin->proc_entry);
 		per_pin->proc_entry = NULL;
 	}
 }
 #else
 static inline int eld_proc_new(struct hdmi_spec_per_pin *per_pin,
 			       int index)
 {
 	return 0;
 }
 static inline void eld_proc_free(struct hdmi_spec_per_pin *per_pin)
 {
 }
 #endif
 /*
  * Channel mapping routines
  */
 /*
  * Compute derived values in channel_allocations[].
  */
 static void init_channel_allocations(void)
 {
 	int i, j;
 	struct cea_channel_speaker_allocation *p;
 	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
 		p = channel_allocations + i;
 		p->channels = 0;
 		p->spk_mask = 0;
 		for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
 			if (p->speakers[j]) {
 				p->channels++;
 				p->spk_mask |= p->speakers[j];
 			}
 	}
 }
 static int get_channel_allocation_order(int ca)
 {
 	int i;
 	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
 		if (channel_allocations[i].ca_index == ca)
 			break;
 	}
 	return i;
 }
 /*
  * The transformation takes two steps:
  *
  *	eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
  *	      spk_mask => (channel_allocations[])         => ai->CA
  *
  * TODO: it could select the wrong CA from multiple candidates.
 */
 static int hdmi_channel_allocation(struct hda_codec *codec,
 				   struct hdmi_eld *eld, int channels)
 {
 	int i;
 	int ca = 0;
 	int spk_mask = 0;
 	char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
 	/*
 	 * CA defaults to 0 for basic stereo audio
 	 */
 	if (channels <= 2)
 		return 0;
 	/*
 	 * expand ELD's speaker allocation mask
 	 *
 	 * ELD tells the speaker mask in a compact(paired) form,
 	 * expand ELD's notions to match the ones used by Audio InfoFrame.
 	 */
 	for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
 		if (eld->info.spk_alloc & (1 << i))
 			spk_mask |= eld_speaker_allocation_bits[i];
 	}
 	/* search for the first working match in the CA table */
 	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
 		if (channels == channel_allocations[i].channels &&
 		    (spk_mask & channel_allocations[i].spk_mask) ==
 				channel_allocations[i].spk_mask) {
 			ca = channel_allocations[i].ca_index;
 			break;
 		}
 	}
 	if (!ca) {
 		/* if there was no match, select the regular ALSA channel
 		 * allocation with the matching number of channels */
 		for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
 			if (channels == channel_allocations[i].channels) {
 				ca = channel_allocations[i].ca_index;
 				break;
 			}
 		}
 	}
 	snd_print_channel_allocation(eld->info.spk_alloc, buf, sizeof(buf));
 	codec_dbg(codec, "HDMI: select CA 0x%x for %d-channel allocation: %s\n",
 		    ca, channels, buf);
 	return ca;
 }
 static void hdmi_debug_channel_mapping(struct hda_codec *codec,
 				       hda_nid_t pin_nid)
 {
 #ifdef CONFIG_SND_DEBUG_VERBOSE
 	struct hdmi_spec *spec = codec->spec;
 	int i;
 	int channel;
 	for (i = 0; i < 8; i++) {
 		channel = spec->ops.pin_get_slot_channel(codec, pin_nid, i);
 		codec_dbg(codec, "HDMI: ASP channel %d => slot %d\n",
 						channel, i);
 	}
 #endif
 }
 static void hdmi_std_setup_channel_mapping(struct hda_codec *codec,
 				       hda_nid_t pin_nid,
 				       bool non_pcm,
 				       int ca)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct cea_channel_speaker_allocation *ch_alloc;
 	int i;
 	int err;
 	int order;
 	int non_pcm_mapping[8];
 	order = get_channel_allocation_order(ca);
 	ch_alloc = &channel_allocations[order];
 	if (hdmi_channel_mapping[ca][1] == 0) {
 		int hdmi_slot = 0;
 		/* fill actual channel mappings in ALSA channel (i) order */
 		for (i = 0; i < ch_alloc->channels; i++) {
 			while (!ch_alloc->speakers[7 - hdmi_slot] && !WARN_ON(hdmi_slot >= 8))
 				hdmi_slot++; /* skip zero slots */
 			hdmi_channel_mapping[ca][i] = (i << 4) | hdmi_slot++;
 		}
 		/* fill the rest of the slots with ALSA channel 0xf */
 		for (hdmi_slot = 0; hdmi_slot < 8; hdmi_slot++)
 			if (!ch_alloc->speakers[7 - hdmi_slot])
 				hdmi_channel_mapping[ca][i++] = (0xf << 4) | hdmi_slot;
 	}
 	if (non_pcm) {
 		for (i = 0; i < ch_alloc->channels; i++)
 			non_pcm_mapping[i] = (i << 4) | i;
 		for (; i < 8; i++)
 			non_pcm_mapping[i] = (0xf << 4) | i;
 	}
 	for (i = 0; i < 8; i++) {
 		int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i];
 		int hdmi_slot = slotsetup & 0x0f;
 		int channel = (slotsetup & 0xf0) >> 4;
 		err = spec->ops.pin_set_slot_channel(codec, pin_nid, hdmi_slot, channel);
 		if (err) {
 			codec_dbg(codec, "HDMI: channel mapping failed\n");
 			break;
 		}
 	}
 }
 struct channel_map_table {
 	unsigned char map;		/* ALSA API channel map position */
 	int spk_mask;			/* speaker position bit mask */
 };
 static struct channel_map_table map_tables[] = {
 	{ SNDRV_CHMAP_FL,	FL },
 	{ SNDRV_CHMAP_FR,	FR },
 	{ SNDRV_CHMAP_RL,	RL },
 	{ SNDRV_CHMAP_RR,	RR },
 	{ SNDRV_CHMAP_LFE,	LFE },
 	{ SNDRV_CHMAP_FC,	FC },
 	{ SNDRV_CHMAP_RLC,	RLC },
 	{ SNDRV_CHMAP_RRC,	RRC },
 	{ SNDRV_CHMAP_RC,	RC },
 	{ SNDRV_CHMAP_FLC,	FLC },
 	{ SNDRV_CHMAP_FRC,	FRC },
 	{ SNDRV_CHMAP_TFL,	FLH },
 	{ SNDRV_CHMAP_TFR,	FRH },
 	{ SNDRV_CHMAP_FLW,	FLW },
 	{ SNDRV_CHMAP_FRW,	FRW },
 	{ SNDRV_CHMAP_TC,	TC },
 	{ SNDRV_CHMAP_TFC,	FCH },
 	{} /* terminator */
 };
 /* from ALSA API channel position to speaker bit mask */
 static int to_spk_mask(unsigned char c)
 {
 	struct channel_map_table *t = map_tables;
 	for (; t->map; t++) {
 		if (t->map == c)
 			return t->spk_mask;
 	}
 	return 0;
 }
 /* from ALSA API channel position to CEA slot */
 static int to_cea_slot(int ordered_ca, unsigned char pos)
 {
 	int mask = to_spk_mask(pos);
 	int i;
 	if (mask) {
 		for (i = 0; i < 8; i++) {
 			if (channel_allocations[ordered_ca].speakers[7 - i] == mask)
 				return i;
 		}
 	}
 	return -1;
 }
 /* from speaker bit mask to ALSA API channel position */
 static int spk_to_chmap(int spk)
 {
 	struct channel_map_table *t = map_tables;
 	for (; t->map; t++) {
 		if (t->spk_mask == spk)
 			return t->map;
 	}
 	return 0;
 }
 /* from CEA slot to ALSA API channel position */
 static int from_cea_slot(int ordered_ca, unsigned char slot)
 {
 	int mask = channel_allocations[ordered_ca].speakers[7 - slot];
 	return spk_to_chmap(mask);
 }
 /* get the CA index corresponding to the given ALSA API channel map */
 static int hdmi_manual_channel_allocation(int chs, unsigned char *map)
 {
 	int i, spks = 0, spk_mask = 0;
 	for (i = 0; i < chs; i++) {
 		int mask = to_spk_mask(map[i]);
 		if (mask) {
 			spk_mask |= mask;
 			spks++;
 		}
 	}
 	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
 		if ((chs == channel_allocations[i].channels ||
 		     spks == channel_allocations[i].channels) &&
 		    (spk_mask & channel_allocations[i].spk_mask) ==
 				channel_allocations[i].spk_mask)
 			return channel_allocations[i].ca_index;
 	}
 	return -1;
 }
 /* set up the channel slots for the given ALSA API channel map */
 static int hdmi_manual_setup_channel_mapping(struct hda_codec *codec,
 					     hda_nid_t pin_nid,
 					     int chs, unsigned char *map,
 					     int ca)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int ordered_ca = get_channel_allocation_order(ca);
 	int alsa_pos, hdmi_slot;
 	int assignments[8] = {[0 ... 7] = 0xf};
 	for (alsa_pos = 0; alsa_pos < chs; alsa_pos++) {
 		hdmi_slot = to_cea_slot(ordered_ca, map[alsa_pos]);
 		if (hdmi_slot < 0)
 			continue; /* unassigned channel */
 		assignments[hdmi_slot] = alsa_pos;
 	}
 	for (hdmi_slot = 0; hdmi_slot < 8; hdmi_slot++) {
 		int err;
 		err = spec->ops.pin_set_slot_channel(codec, pin_nid, hdmi_slot,
 						     assignments[hdmi_slot]);
 		if (err)
 			return -EINVAL;
 	}
 	return 0;
 }
 /* store ALSA API channel map from the current default map */
 static void hdmi_setup_fake_chmap(unsigned char *map, int ca)
 {
 	int i;
 	int ordered_ca = get_channel_allocation_order(ca);
 	for (i = 0; i < 8; i++) {
 		if (i < channel_allocations[ordered_ca].channels)
 			map[i] = from_cea_slot(ordered_ca, hdmi_channel_mapping[ca][i] & 0x0f);
 		else
 			map[i] = 0;
 	}
 }
 static void hdmi_setup_channel_mapping(struct hda_codec *codec,
 				       hda_nid_t pin_nid, bool non_pcm, int ca,
 				       int channels, unsigned char *map,
 				       bool chmap_set)
 {
 	if (!non_pcm && chmap_set) {
 		hdmi_manual_setup_channel_mapping(codec, pin_nid,
 						  channels, map, ca);
 	} else {
 		hdmi_std_setup_channel_mapping(codec, pin_nid, non_pcm, ca);
 		hdmi_setup_fake_chmap(map, ca);
 	}
 	hdmi_debug_channel_mapping(codec, pin_nid);
 }
 static int hdmi_pin_set_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
 				     int asp_slot, int channel)
 {
 	return snd_hda_codec_write(codec, pin_nid, 0,
 				   AC_VERB_SET_HDMI_CHAN_SLOT,
 				   (channel << 4) | asp_slot);
 }
 static int hdmi_pin_get_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
 				     int asp_slot)
 {
 	return (snd_hda_codec_read(codec, pin_nid, 0,
 				   AC_VERB_GET_HDMI_CHAN_SLOT,
 				   asp_slot) & 0xf0) >> 4;
 }
 /*
  * Audio InfoFrame routines
  */
 /*
  * Enable Audio InfoFrame Transmission
  */
 static void hdmi_start_infoframe_trans(struct hda_codec *codec,
 				       hda_nid_t pin_nid)
 {
 	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
 	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
 						AC_DIPXMIT_BEST);
 }
 /*
  * Disable Audio InfoFrame Transmission
  */
 static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
 				      hda_nid_t pin_nid)
 {
 	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
 	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
 						AC_DIPXMIT_DISABLE);
 }
 static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
 {
 #ifdef CONFIG_SND_DEBUG_VERBOSE
 	int i;
 	int size;
 	size = snd_hdmi_get_eld_size(codec, pin_nid);
 	codec_dbg(codec, "HDMI: ELD buf size is %d\n", size);
 	for (i = 0; i < 8; i++) {
 		size = snd_hda_codec_read(codec, pin_nid, 0,
 						AC_VERB_GET_HDMI_DIP_SIZE, i);
 		codec_dbg(codec, "HDMI: DIP GP[%d] buf size is %d\n", i, size);
 	}
 #endif
 }
 static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
 {
 #ifdef BE_PARANOID
 	int i, j;
 	int size;
 	int pi, bi;
 	for (i = 0; i < 8; i++) {
 		size = snd_hda_codec_read(codec, pin_nid, 0,
 						AC_VERB_GET_HDMI_DIP_SIZE, i);
 		if (size == 0)
 			continue;
 		hdmi_set_dip_index(codec, pin_nid, i, 0x0);
 		for (j = 1; j < 1000; j++) {
 			hdmi_write_dip_byte(codec, pin_nid, 0x0);
 			hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
 			if (pi != i)
 				codec_dbg(codec, "dip index %d: %d != %d\n",
 						bi, pi, i);
 			if (bi == 0) /* byte index wrapped around */
 				break;
 		}
 		codec_dbg(codec,
 			"HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
 			i, size, j);
 	}
 #endif
 }
 static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *hdmi_ai)
 {
 	u8 *bytes = (u8 *)hdmi_ai;
 	u8 sum = 0;
 	int i;
 	hdmi_ai->checksum = 0;
 	for (i = 0; i < sizeof(*hdmi_ai); i++)
 		sum += bytes[i];
 	hdmi_ai->checksum = -sum;
 }
 static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
 				      hda_nid_t pin_nid,
 				      u8 *dip, int size)
 {
 	int i;
 	hdmi_debug_dip_size(codec, pin_nid);
 	hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
 	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
 	for (i = 0; i < size; i++)
 		hdmi_write_dip_byte(codec, pin_nid, dip[i]);
 }
 static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
 				    u8 *dip, int size)
 {
 	u8 val;
 	int i;
 	if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
 							    != AC_DIPXMIT_BEST)
 		return false;
 	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
 	for (i = 0; i < size; i++) {
 		val = snd_hda_codec_read(codec, pin_nid, 0,
 					 AC_VERB_GET_HDMI_DIP_DATA, 0);
 		if (val != dip[i])
 			return false;
 	}
 	return true;
 }
 static void hdmi_pin_setup_infoframe(struct hda_codec *codec,
 				     hda_nid_t pin_nid,
 				     int ca, int active_channels,
 				     int conn_type)
 {
 	union audio_infoframe ai;
 	memset(&ai, 0, sizeof(ai));
 	if (conn_type == 0) { /* HDMI */
 		struct hdmi_audio_infoframe *hdmi_ai = &ai.hdmi;
 		hdmi_ai->type		= 0x84;
 		hdmi_ai->ver		= 0x01;
 		hdmi_ai->len		= 0x0a;
 		hdmi_ai->CC02_CT47	= active_channels - 1;
 		hdmi_ai->CA		= ca;
 		hdmi_checksum_audio_infoframe(hdmi_ai);
 	} else if (conn_type == 1) { /* DisplayPort */
 		struct dp_audio_infoframe *dp_ai = &ai.dp;
 		dp_ai->type		= 0x84;
 		dp_ai->len		= 0x1b;
 		dp_ai->ver		= 0x11 << 2;
 		dp_ai->CC02_CT47	= active_channels - 1;
 		dp_ai->CA		= ca;
 	} else {
 		codec_dbg(codec, "HDMI: unknown connection type at pin %d\n",
 			    pin_nid);
 		return;
 	}
 	/*
 	 * sizeof(ai) is used instead of sizeof(*hdmi_ai) or
 	 * sizeof(*dp_ai) to avoid partial match/update problems when
 	 * the user switches between HDMI/DP monitors.
 	 */
 	if (!hdmi_infoframe_uptodate(codec, pin_nid, ai.bytes,
 					sizeof(ai))) {
 		codec_dbg(codec,
 			  "hdmi_pin_setup_infoframe: pin=%d channels=%d ca=0x%02x\n",
 			    pin_nid,
 			    active_channels, ca);
 		hdmi_stop_infoframe_trans(codec, pin_nid);
 		hdmi_fill_audio_infoframe(codec, pin_nid,
 					    ai.bytes, sizeof(ai));
 		hdmi_start_infoframe_trans(codec, pin_nid);
 	}
 }
 static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
 				       struct hdmi_spec_per_pin *per_pin,
 				       bool non_pcm)
 {
 	struct hdmi_spec *spec = codec->spec;
 	hda_nid_t pin_nid = per_pin->pin_nid;
 	int channels = per_pin->channels;
 	int active_channels;
 	struct hdmi_eld *eld;
 	int ca, ordered_ca;
 	if (!channels)
 		return;
 	if (is_haswell_plus(codec))
 		snd_hda_codec_write(codec, pin_nid, 0,
 					    AC_VERB_SET_AMP_GAIN_MUTE,
 					    AMP_OUT_UNMUTE);
 	eld = &per_pin->sink_eld;
 	if (!non_pcm && per_pin->chmap_set)
 		ca = hdmi_manual_channel_allocation(channels, per_pin->chmap);
 	else
 		ca = hdmi_channel_allocation(codec, eld, channels);
 	if (ca < 0)
 		ca = 0;
 	ordered_ca = get_channel_allocation_order(ca);
 	active_channels = channel_allocations[ordered_ca].channels;
 	hdmi_set_channel_count(codec, per_pin->cvt_nid, active_channels);
 	/*
 	 * always configure channel mapping, it may have been changed by the
 	 * user in the meantime
 	 */
 	hdmi_setup_channel_mapping(codec, pin_nid, non_pcm, ca,
 				   channels, per_pin->chmap,
 				   per_pin->chmap_set);
 	spec->ops.pin_setup_infoframe(codec, pin_nid, ca, active_channels,
 				      eld->info.conn_type);
 	per_pin->non_pcm = non_pcm;
 }
 /*
  * Unsolicited events
  */
 static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll);
 static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx = pin_nid_to_pin_index(codec, nid);
 	if (pin_idx < 0)
 		return;
 	if (hdmi_present_sense(get_pin(spec, pin_idx), 1))
 		snd_hda_jack_report_sync(codec);
 }
 static void jack_callback(struct hda_codec *codec,
 			  struct hda_jack_callback *jack)
 {
 	check_presence_and_report(codec, jack->tbl->nid);
 }
 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
 {
 	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
 	struct hda_jack_tbl *jack;
 	int dev_entry = (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;
 	jack = snd_hda_jack_tbl_get_from_tag(codec, tag);
 	if (!jack)
 		return;
 	jack->jack_dirty = 1;
 	codec_dbg(codec,
 		"HDMI hot plug event: Codec=%d Pin=%d Device=%d Inactive=%d Presence_Detect=%d ELD_Valid=%d\n",
 		codec->addr, jack->nid, dev_entry, !!(res & AC_UNSOL_RES_IA),
 		!!(res & AC_UNSOL_RES_PD), !!(res & AC_UNSOL_RES_ELDV));
 	check_presence_and_report(codec, jack->nid);
 }
 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
 {
 	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
 	int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 	int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
 	int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
 	codec_info(codec,
 		"HDMI CP event: CODEC=%d TAG=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
 		codec->addr,
 		tag,
 		subtag,
 		cp_state,
 		cp_ready);
 	/* TODO */
 	if (cp_state)
 		;
 	if (cp_ready)
 		;
 }
 static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
 {
 	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
 	int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 	if (!snd_hda_jack_tbl_get_from_tag(codec, tag)) {
 		codec_dbg(codec, "Unexpected HDMI event tag 0x%x\n", tag);
 		return;
 	}
 	if (subtag == 0)
 		hdmi_intrinsic_event(codec, res);
 	else
 		hdmi_non_intrinsic_event(codec, res);
 }
 static void haswell_verify_D0(struct hda_codec *codec,
 		hda_nid_t cvt_nid, hda_nid_t nid)
 {
 	int pwr;
 	/* For Haswell, the converter 1/2 may keep in D3 state after bootup,
 	 * thus pins could only choose converter 0 for use. Make sure the
 	 * converters are in correct power state */
 	if (!snd_hda_check_power_state(codec, cvt_nid, AC_PWRST_D0))
 		snd_hda_codec_write(codec, cvt_nid, 0, AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 	if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0)) {
 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
 				    AC_PWRST_D0);
 		msleep(40);
 		pwr = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
 		pwr = (pwr & AC_PWRST_ACTUAL) >> AC_PWRST_ACTUAL_SHIFT;
 		codec_dbg(codec, "Haswell HDMI audio: Power for pin 0x%x is now D%d\n", nid, pwr);
 	}
 }
 /*
  * Callbacks
  */
 /* HBR should be Non-PCM, 8 channels */
 #define is_hbr_format(format) \
 	((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
 static int hdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,
 			      bool hbr)
 {
 	int pinctl, new_pinctl;
 	if (snd_hda_query_pin_caps(codec, pin_nid) & AC_PINCAP_HBR) {
 		pinctl = snd_hda_codec_read(codec, pin_nid, 0,
 					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 		if (pinctl < 0)
 			return hbr ? -EINVAL : 0;
 		new_pinctl = pinctl & ~AC_PINCTL_EPT;
 		if (hbr)
 			new_pinctl |= AC_PINCTL_EPT_HBR;
 		else
 			new_pinctl |= AC_PINCTL_EPT_NATIVE;
 		codec_dbg(codec,
 			  "hdmi_pin_hbr_setup: NID=0x%x, %spinctl=0x%x\n",
 			    pin_nid,
 			    pinctl == new_pinctl ? "" : "new-",
 			    new_pinctl);
 		if (pinctl != new_pinctl)
 			snd_hda_codec_write(codec, pin_nid, 0,
 					    AC_VERB_SET_PIN_WIDGET_CONTROL,
 					    new_pinctl);
 	} else if (hbr)
 		return -EINVAL;
 	return 0;
 }
 static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
 			      hda_nid_t pin_nid, u32 stream_tag, int format)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int err;
 	if (is_haswell_plus(codec))
 		haswell_verify_D0(codec, cvt_nid, pin_nid);
 	err = spec->ops.pin_hbr_setup(codec, pin_nid, is_hbr_format(format));
 	if (err) {
 		codec_dbg(codec, "hdmi_setup_stream: HBR is not supported\n");
 		return err;
 	}
 	snd_hda_codec_setup_stream(codec, cvt_nid, stream_tag, 0, format);
 	return 0;
 }
 static int hdmi_choose_cvt(struct hda_codec *codec,
 			int pin_idx, int *cvt_id, int *mux_id)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin;
 	struct hdmi_spec_per_cvt *per_cvt = NULL;
 	int cvt_idx, mux_idx = 0;
 	per_pin = get_pin(spec, pin_idx);
 	/* Dynamically assign converter to stream */
 	for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
 		per_cvt = get_cvt(spec, cvt_idx);
 		/* Must not already be assigned */
 		if (per_cvt->assigned)
 			continue;
 		/* Must be in pin's mux's list of converters */
 		for (mux_idx = 0; mux_idx < per_pin->num_mux_nids; mux_idx++)
 			if (per_pin->mux_nids[mux_idx] == per_cvt->cvt_nid)
 				break;
 		/* Not in mux list */
 		if (mux_idx == per_pin->num_mux_nids)
 			continue;
 		break;
 	}
 	/* No free converters */
 	if (cvt_idx == spec->num_cvts)
 		return -ENODEV;
 	per_pin->mux_idx = mux_idx;
 	if (cvt_id)
 		*cvt_id = cvt_idx;
 	if (mux_id)
 		*mux_id = mux_idx;
 	return 0;
 }
 /* Assure the pin select the right convetor */
 static void intel_verify_pin_cvt_connect(struct hda_codec *codec,
 			struct hdmi_spec_per_pin *per_pin)
 {
 	hda_nid_t pin_nid = per_pin->pin_nid;
 	int mux_idx, curr;
 	mux_idx = per_pin->mux_idx;
 	curr = snd_hda_codec_read(codec, pin_nid, 0,
 					  AC_VERB_GET_CONNECT_SEL, 0);
 	if (curr != mux_idx)
 		snd_hda_codec_write_cache(codec, pin_nid, 0,
 					    AC_VERB_SET_CONNECT_SEL,
 					    mux_idx);
 }
 /* Intel HDMI workaround to fix audio routing issue:
  * For some Intel display codecs, pins share the same connection list.
  * So a conveter can be selected by multiple pins and playback on any of these
  * pins will generate sound on the external display, because audio flows from
  * the same converter to the display pipeline. Also muting one pin may make
  * other pins have no sound output.
  * So this function assures that an assigned converter for a pin is not selected
  * by any other pins.
  */
 static void intel_not_share_assigned_cvt(struct hda_codec *codec,
 			hda_nid_t pin_nid, int mux_idx)
 {
 	struct hdmi_spec *spec = codec->spec;
 	hda_nid_t nid, end_nid;
 	int cvt_idx, curr;
 	struct hdmi_spec_per_cvt *per_cvt;
 	/* configure all pins, including "no physical connection" ones */
 	end_nid = codec->start_nid + codec->num_nodes;
 	for (nid = codec->start_nid; nid < end_nid; nid++) {
 		unsigned int wid_caps = get_wcaps(codec, nid);
 		unsigned int wid_type = get_wcaps_type(wid_caps);
 		if (wid_type != AC_WID_PIN)
 			continue;
 		if (nid == pin_nid)
 			continue;
 		curr = snd_hda_codec_read(codec, nid, 0,
 					  AC_VERB_GET_CONNECT_SEL, 0);
 		if (curr != mux_idx)
 			continue;
 		/* choose an unassigned converter. The conveters in the
 		 * connection list are in the same order as in the codec.
 		 */
 		for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
 			per_cvt = get_cvt(spec, cvt_idx);
 			if (!per_cvt->assigned) {
 				codec_dbg(codec,
 					  "choose cvt %d for pin nid %d\n",
 					cvt_idx, nid);
 				snd_hda_codec_write_cache(codec, nid, 0,
 					    AC_VERB_SET_CONNECT_SEL,
 					    cvt_idx);
 				break;
 			}
 		}
 	}
 }
 /*
  * HDA PCM callbacks
  */
 static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
 			 struct hda_codec *codec,
 			 struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct snd_pcm_runtime *runtime = substream->runtime;
 	int pin_idx, cvt_idx, mux_idx = 0;
 	struct hdmi_spec_per_pin *per_pin;
 	struct hdmi_eld *eld;
 	struct hdmi_spec_per_cvt *per_cvt = NULL;
 	int err;
 	/* Validate hinfo */
 	pin_idx = hinfo_to_pin_index(codec, hinfo);
 	if (snd_BUG_ON(pin_idx < 0))
 		return -EINVAL;
 	per_pin = get_pin(spec, pin_idx);
 	eld = &per_pin->sink_eld;
 	err = hdmi_choose_cvt(codec, pin_idx, &cvt_idx, &mux_idx);
 	if (err < 0)
 		return err;
 	per_cvt = get_cvt(spec, cvt_idx);
 	/* Claim converter */
 	per_cvt->assigned = 1;
 	per_pin->cvt_nid = per_cvt->cvt_nid;
 	hinfo->nid = per_cvt->cvt_nid;
 	snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
 			    AC_VERB_SET_CONNECT_SEL,
 			    mux_idx);
 	/* configure unused pins to choose other converters */
 	if (is_haswell_plus(codec) || is_valleyview_plus(codec))
 		intel_not_share_assigned_cvt(codec, per_pin->pin_nid, mux_idx);
 	snd_hda_spdif_ctls_assign(codec, pin_idx, per_cvt->cvt_nid);
 	/* Initially set the converter's capabilities */
 	hinfo->channels_min = per_cvt->channels_min;
 	hinfo->channels_max = per_cvt->channels_max;
 	hinfo->rates = per_cvt->rates;
 	hinfo->formats = per_cvt->formats;
 	hinfo->maxbps = per_cvt->maxbps;
 	/* Restrict capabilities by ELD if this isn't disabled */
 	if (!static_hdmi_pcm && eld->eld_valid) {
 		snd_hdmi_eld_update_pcm_info(&eld->info, hinfo);
 		if (hinfo->channels_min > hinfo->channels_max ||
 		    !hinfo->rates || !hinfo->formats) {
 			per_cvt->assigned = 0;
 			hinfo->nid = 0;
 			snd_hda_spdif_ctls_unassign(codec, pin_idx);
 			return -ENODEV;
 		}
 	}
 	/* Store the updated parameters */
 	runtime->hw.channels_min = hinfo->channels_min;
 	runtime->hw.channels_max = hinfo->channels_max;
 	runtime->hw.formats = hinfo->formats;
 	runtime->hw.rates = hinfo->rates;
 	snd_pcm_hw_constraint_step(substream->runtime, 0,
 				   SNDRV_PCM_HW_PARAM_CHANNELS, 2);
 	return 0;
 }
 /*
  * HDA/HDMI auto parsing
  */
 static int hdmi_read_pin_conn(struct hda_codec *codec, int pin_idx)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 	hda_nid_t pin_nid = per_pin->pin_nid;
 	if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
 		codec_warn(codec,
 			   "HDMI: pin %d wcaps %#x does not support connection list\n",
 			   pin_nid, get_wcaps(codec, pin_nid));
 		return -EINVAL;
 	}
 	per_pin->num_mux_nids = snd_hda_get_connections(codec, pin_nid,
 							per_pin->mux_nids,
 							HDA_MAX_CONNECTIONS);
 	return 0;
 }
 static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
 {
 	struct hda_jack_tbl *jack;
 	struct hda_codec *codec = per_pin->codec;
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_eld *eld = &spec->temp_eld;
 	struct hdmi_eld *pin_eld = &per_pin->sink_eld;
 	hda_nid_t pin_nid = per_pin->pin_nid;
 	/*
 	 * Always execute a GetPinSense verb here, even when called from
 	 * hdmi_intrinsic_event; for some NVIDIA HW, the unsolicited
 	 * response's PD bit is not the real PD value, but indicates that
 	 * the real PD value changed. An older version of the HD-audio
 	 * specification worked this way. Hence, we just ignore the data in
 	 * the unsolicited response to avoid custom WARs.
 	 */
 	int present;
 	bool update_eld = false;
 	bool eld_changed = false;
 	bool ret;
 	snd_hda_power_up(codec);
 	present = snd_hda_pin_sense(codec, pin_nid);
 	mutex_lock(&per_pin->lock);
 	pin_eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE);
 	if (pin_eld->monitor_present)
 		eld->eld_valid  = !!(present & AC_PINSENSE_ELDV);
 	else
 		eld->eld_valid = false;
 	codec_dbg(codec,
 		"HDMI status: Codec=%d Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
 		codec->addr, pin_nid, pin_eld->monitor_present, eld->eld_valid);
 	if (eld->eld_valid) {
 		if (spec->ops.pin_get_eld(codec, pin_nid, eld->eld_buffer,
 						     &eld->eld_size) < 0)
 			eld->eld_valid = false;
 		else {
 			memset(&eld->info, 0, sizeof(struct parsed_hdmi_eld));
 			if (snd_hdmi_parse_eld(codec, &eld->info, eld->eld_buffer,
 						    eld->eld_size) < 0)
 				eld->eld_valid = false;
 		}
 		if (eld->eld_valid) {
 			snd_hdmi_show_eld(codec, &eld->info);
 			update_eld = true;
 		}
 		else if (repoll) {
 			queue_delayed_work(codec->bus->workq,
 					   &per_pin->work,
 					   msecs_to_jiffies(300));
 			goto unlock;
 		}
 	}
 	if (pin_eld->eld_valid != eld->eld_valid)
 		eld_changed = true;
 	if (pin_eld->eld_valid && !eld->eld_valid)
 		update_eld = true;
 	if (update_eld) {
 		bool old_eld_valid = pin_eld->eld_valid;
 		pin_eld->eld_valid = eld->eld_valid;
 		if (pin_eld->eld_size != eld->eld_size ||
 			      memcmp(pin_eld->eld_buffer, eld->eld_buffer,
 				     eld->eld_size) != 0) {
 			memcpy(pin_eld->eld_buffer, eld->eld_buffer,
 			       eld->eld_size);
 			eld_changed = true;
 		}
 		pin_eld->eld_size = eld->eld_size;
 		pin_eld->info = eld->info;
 		/*
 		 * Re-setup pin and infoframe. This is needed e.g. when
 		 * - sink is first plugged-in (infoframe is not set up if !monitor_present)
 		 * - transcoder can change during stream playback on Haswell
 		 *   and this can make HW reset converter selection on a pin.
 		 */
 		if (eld->eld_valid && !old_eld_valid && per_pin->setup) {
 			if (is_haswell_plus(codec) ||
 				is_valleyview_plus(codec)) {
 				intel_verify_pin_cvt_connect(codec, per_pin);
 				intel_not_share_assigned_cvt(codec, pin_nid,
 							per_pin->mux_idx);
 			}
 			hdmi_setup_audio_infoframe(codec, per_pin,
 						   per_pin->non_pcm);
 		}
 	}
 	if (eld_changed)
 		snd_ctl_notify(codec->bus->card,
 			       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
 			       &per_pin->eld_ctl->id);
  unlock:
 	ret = !repoll || !pin_eld->monitor_present || pin_eld->eld_valid;
 	jack = snd_hda_jack_tbl_get(codec, pin_nid);
 	if (jack)
 		jack->block_report = !ret;
 	mutex_unlock(&per_pin->lock);
 	snd_hda_power_down(codec);
 	return ret;
 }
 static void hdmi_repoll_eld(struct work_struct *work)
 {
 	struct hdmi_spec_per_pin *per_pin =
 	container_of(to_delayed_work(work), struct hdmi_spec_per_pin, work);
 	if (per_pin->repoll_count++ > 6)
 		per_pin->repoll_count = 0;
 	if (hdmi_present_sense(per_pin, per_pin->repoll_count))
 		snd_hda_jack_report_sync(per_pin->codec);
 }
 static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
 					     hda_nid_t nid);
 static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	unsigned int caps, config;
 	int pin_idx;
 	struct hdmi_spec_per_pin *per_pin;
 	int err;
 	caps = snd_hda_query_pin_caps(codec, pin_nid);
 	if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
 		return 0;
 	config = snd_hda_codec_get_pincfg(codec, pin_nid);
 	if (get_defcfg_connect(config) == AC_JACK_PORT_NONE)
 		return 0;
 	if (is_haswell_plus(codec))
 		intel_haswell_fixup_connect_list(codec, pin_nid);
 	pin_idx = spec->num_pins;
 	per_pin = snd_array_new(&spec->pins);
 	if (!per_pin)
 		return -ENOMEM;
 	per_pin->pin_nid = pin_nid;
 	per_pin->non_pcm = false;
 	err = hdmi_read_pin_conn(codec, pin_idx);
 	if (err < 0)
 		return err;
 	spec->num_pins++;
 	return 0;
 }
 static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t cvt_nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_cvt *per_cvt;
 	unsigned int chans;
 	int err;
 	chans = get_wcaps(codec, cvt_nid);
 	chans = get_wcaps_channels(chans);
 	per_cvt = snd_array_new(&spec->cvts);
 	if (!per_cvt)
 		return -ENOMEM;
 	per_cvt->cvt_nid = cvt_nid;
 	per_cvt->channels_min = 2;
 	if (chans <= 16) {
 		per_cvt->channels_max = chans;
 		if (chans > spec->channels_max)
 			spec->channels_max = chans;
 	}
 	err = snd_hda_query_supported_pcm(codec, cvt_nid,
 					  &per_cvt->rates,
 					  &per_cvt->formats,
 					  &per_cvt->maxbps);
 	if (err < 0)
 		return err;
 	if (spec->num_cvts < ARRAY_SIZE(spec->cvt_nids))
 		spec->cvt_nids[spec->num_cvts] = cvt_nid;
 	spec->num_cvts++;
 	return 0;
 }
 static int hdmi_parse_codec(struct hda_codec *codec)
 {
 	hda_nid_t nid;
 	int i, nodes;
 	nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
 	if (!nid || nodes < 0) {
 		codec_warn(codec, "HDMI: failed to get afg sub nodes\n");
 		return -EINVAL;
 	}
 	for (i = 0; i < nodes; i++, nid++) {
 		unsigned int caps;
 		unsigned int type;
 		caps = get_wcaps(codec, nid);
 		type = get_wcaps_type(caps);
 		if (!(caps & AC_WCAP_DIGITAL))
 			continue;
 		switch (type) {
 		case AC_WID_AUD_OUT:
 			hdmi_add_cvt(codec, nid);
 			break;
 		case AC_WID_PIN:
 			hdmi_add_pin(codec, nid);
 			break;
 		}
 	}
 	return 0;
 }
 /*
  */
 static bool check_non_pcm_per_cvt(struct hda_codec *codec, hda_nid_t cvt_nid)
 {
 	struct hda_spdif_out *spdif;
 	bool non_pcm;
 	mutex_lock(&codec->spdif_mutex);
 	spdif = snd_hda_spdif_out_of_nid(codec, cvt_nid);
 	non_pcm = !!(spdif->status & IEC958_AES0_NONAUDIO);
 	mutex_unlock(&codec->spdif_mutex);
 	return non_pcm;
 }
 /*
  * HDMI callbacks
  */
 static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 					   struct hda_codec *codec,
 					   unsigned int stream_tag,
 					   unsigned int format,
 					   struct snd_pcm_substream *substream)
 {
 	hda_nid_t cvt_nid = hinfo->nid;
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx = hinfo_to_pin_index(codec, hinfo);
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 	hda_nid_t pin_nid = per_pin->pin_nid;
 	bool non_pcm;
 	int pinctl;
 	if (is_haswell_plus(codec) || is_valleyview_plus(codec)) {
 		/* Verify pin:cvt selections to avoid silent audio after S3.
 		 * After S3, the audio driver restores pin:cvt selections
 		 * but this can happen before gfx is ready and such selection
 		 * is overlooked by HW. Thus multiple pins can share a same
 		 * default convertor and mute control will affect each other,
 		 * which can cause a resumed audio playback become silent
 		 * after S3.
 		 */
 		intel_verify_pin_cvt_connect(codec, per_pin);
 		intel_not_share_assigned_cvt(codec, pin_nid, per_pin->mux_idx);
 	}
 	non_pcm = check_non_pcm_per_cvt(codec, cvt_nid);
 	mutex_lock(&per_pin->lock);
 	per_pin->channels = substream->runtime->channels;
 	per_pin->setup = true;
 	hdmi_setup_audio_infoframe(codec, per_pin, non_pcm);
 	mutex_unlock(&per_pin->lock);
 	if (spec->dyn_pin_out) {
 		pinctl = snd_hda_codec_read(codec, pin_nid, 0,
 					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 		snd_hda_codec_write(codec, pin_nid, 0,
 				    AC_VERB_SET_PIN_WIDGET_CONTROL,
 				    pinctl | PIN_OUT);
 	}
 	return spec->ops.setup_stream(codec, cvt_nid, pin_nid, stream_tag, format);
 }
 static int generic_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 					     struct hda_codec *codec,
 					     struct snd_pcm_substream *substream)
 {
 	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
 	return 0;
 }
 static int hdmi_pcm_close(struct hda_pcm_stream *hinfo,
 			  struct hda_codec *codec,
 			  struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int cvt_idx, pin_idx;
 	struct hdmi_spec_per_cvt *per_cvt;
 	struct hdmi_spec_per_pin *per_pin;
 	int pinctl;
 	if (hinfo->nid) {
 		cvt_idx = cvt_nid_to_cvt_index(codec, hinfo->nid);
 		if (snd_BUG_ON(cvt_idx < 0))
 			return -EINVAL;
 		per_cvt = get_cvt(spec, cvt_idx);
 		snd_BUG_ON(!per_cvt->assigned);
 		per_cvt->assigned = 0;
 		hinfo->nid = 0;
 		pin_idx = hinfo_to_pin_index(codec, hinfo);
 		if (snd_BUG_ON(pin_idx < 0))
 			return -EINVAL;
 		per_pin = get_pin(spec, pin_idx);
 		if (spec->dyn_pin_out) {
 			pinctl = snd_hda_codec_read(codec, per_pin->pin_nid, 0,
 					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 			snd_hda_codec_write(codec, per_pin->pin_nid, 0,
 					    AC_VERB_SET_PIN_WIDGET_CONTROL,
 					    pinctl & ~PIN_OUT);
 		}
 		snd_hda_spdif_ctls_unassign(codec, pin_idx);
 		mutex_lock(&per_pin->lock);
 		per_pin->chmap_set = false;
 		memset(per_pin->chmap, 0, sizeof(per_pin->chmap));
 		per_pin->setup = false;
 		per_pin->channels = 0;
 		mutex_unlock(&per_pin->lock);
 	}
 	return 0;
 }
 static const struct hda_pcm_ops generic_ops = {
 	.open = hdmi_pcm_open,
 	.close = hdmi_pcm_close,
 	.prepare = generic_hdmi_playback_pcm_prepare,
 	.cleanup = generic_hdmi_playback_pcm_cleanup,
 };
 /*
  * ALSA API channel-map control callbacks
  */
 static int hdmi_chmap_ctl_info(struct snd_kcontrol *kcontrol,
 			       struct snd_ctl_elem_info *uinfo)
 {
 	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 	struct hda_codec *codec = info->private_data;
 	struct hdmi_spec *spec = codec->spec;
 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 	uinfo->count = spec->channels_max;
 	uinfo->value.integer.min = 0;
 	uinfo->value.integer.max = SNDRV_CHMAP_LAST;
 	return 0;
 }
 static int hdmi_chmap_cea_alloc_validate_get_type(struct cea_channel_speaker_allocation *cap,
 						  int channels)
 {
 	/* If the speaker allocation matches the channel count, it is OK.*/
 	if (cap->channels != channels)
 		return -1;
 	/* all channels are remappable freely */
 	return SNDRV_CTL_TLVT_CHMAP_VAR;
 }
 static void hdmi_cea_alloc_to_tlv_chmap(struct cea_channel_speaker_allocation *cap,
 					unsigned int *chmap, int channels)
 {
 	int count = 0;
 	int c;
 	for (c = 7; c >= 0; c--) {
 		int spk = cap->speakers[c];
 		if (!spk)
 			continue;
 		chmap[count++] = spk_to_chmap(spk);
 	}
 	WARN_ON(count != channels);
 }
 static int hdmi_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 			      unsigned int size, unsigned int __user *tlv)
 {
 	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 	struct hda_codec *codec = info->private_data;
 	struct hdmi_spec *spec = codec->spec;
 	unsigned int __user *dst;
 	int chs, count = 0;
 	if (size < 8)
 		return -ENOMEM;
 	if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
 		return -EFAULT;
 	size -= 8;
 	dst = tlv + 2;
 	for (chs = 2; chs <= spec->channels_max; chs++) {
 		int i;
 		struct cea_channel_speaker_allocation *cap;
 		cap = channel_allocations;
 		for (i = 0; i < ARRAY_SIZE(channel_allocations); i++, cap++) {
 			int chs_bytes = chs * 4;
 			int type = spec->ops.chmap_cea_alloc_validate_get_type(cap, chs);
 			unsigned int tlv_chmap[8];
 			if (type < 0)
 				continue;
 			if (size < 8)
 				return -ENOMEM;
 			if (put_user(type, dst) ||
 			    put_user(chs_bytes, dst + 1))
 				return -EFAULT;
 			dst += 2;
 			size -= 8;
 			count += 8;
 			if (size < chs_bytes)
 				return -ENOMEM;
 			size -= chs_bytes;
 			count += chs_bytes;
 			spec->ops.cea_alloc_to_tlv_chmap(cap, tlv_chmap, chs);
 			if (copy_to_user(dst, tlv_chmap, chs_bytes))
 				return -EFAULT;
 			dst += chs;
 		}
 	}
 	if (put_user(count, tlv + 1))
 		return -EFAULT;
 	return 0;
 }
 static int hdmi_chmap_ctl_get(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 	struct hda_codec *codec = info->private_data;
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx = kcontrol->private_value;
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 	int i;
 	for (i = 0; i < ARRAY_SIZE(per_pin->chmap); i++)
 		ucontrol->value.integer.value[i] = per_pin->chmap[i];
 	return 0;
 }
 static int hdmi_chmap_ctl_put(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 	struct hda_codec *codec = info->private_data;
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx = kcontrol->private_value;
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 	unsigned int ctl_idx;
 	struct snd_pcm_substream *substream;
 	unsigned char chmap[8];
 	int i, err, ca, prepared = 0;
 	ctl_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	substream = snd_pcm_chmap_substream(info, ctl_idx);
 	if (!substream || !substream->runtime)
 		return 0; /* just for avoiding error from alsactl restore */
 	switch (substream->runtime->status->state) {
 	case SNDRV_PCM_STATE_OPEN:
 	case SNDRV_PCM_STATE_SETUP:
 		break;
 	case SNDRV_PCM_STATE_PREPARED:
 		prepared = 1;
 		break;
 	default:
 		return -EBUSY;
 	}
 	memset(chmap, 0, sizeof(chmap));
 	for (i = 0; i < ARRAY_SIZE(chmap); i++)
 		chmap[i] = ucontrol->value.integer.value[i];
 	if (!memcmp(chmap, per_pin->chmap, sizeof(chmap)))
 		return 0;
 	ca = hdmi_manual_channel_allocation(ARRAY_SIZE(chmap), chmap);
 	if (ca < 0)
 		return -EINVAL;
 	if (spec->ops.chmap_validate) {
 		err = spec->ops.chmap_validate(ca, ARRAY_SIZE(chmap), chmap);
 		if (err)
 			return err;
 	}
 	mutex_lock(&per_pin->lock);
 	per_pin->chmap_set = true;
 	memcpy(per_pin->chmap, chmap, sizeof(chmap));
 	if (prepared)
 		hdmi_setup_audio_infoframe(codec, per_pin, per_pin->non_pcm);
 	mutex_unlock(&per_pin->lock);
 	return 0;
 }
 static int generic_hdmi_build_pcms(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hda_pcm *info;
 		struct hda_pcm_stream *pstr;
 		struct hdmi_spec_per_pin *per_pin;
 		per_pin = get_pin(spec, pin_idx);
 		sprintf(per_pin->pcm_name, "HDMI %d", pin_idx);
 		info = snd_array_new(&spec->pcm_rec);
 		if (!info)
 			return -ENOMEM;
 		info->name = per_pin->pcm_name;
 		info->pcm_type = HDA_PCM_TYPE_HDMI;
 		info->own_chmap = true;
 		pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
 		pstr->substreams = 1;
 		pstr->ops = generic_ops;
 		/* other pstr fields are set in open */
 	}
 	codec->num_pcms = spec->num_pins;
 	codec->pcm_info = spec->pcm_rec.list;
 	return 0;
 }
 static int generic_hdmi_build_jack(struct hda_codec *codec, int pin_idx)
 {
 	char hdmi_str[32] = "HDMI/DP";
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 	int pcmdev = get_pcm_rec(spec, pin_idx)->device;
 	if (pcmdev > 0)
 		sprintf(hdmi_str + strlen(hdmi_str), ",pcm=%d", pcmdev);
 	if (!is_jack_detectable(codec, per_pin->pin_nid))
 		strncat(hdmi_str, " Phantom",
 			sizeof(hdmi_str) - strlen(hdmi_str) - 1);
 	return snd_hda_jack_add_kctl(codec, per_pin->pin_nid, hdmi_str, 0);
 }
 static int generic_hdmi_build_controls(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int err;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		err = generic_hdmi_build_jack(codec, pin_idx);
 		if (err < 0)
 			return err;
 		err = snd_hda_create_dig_out_ctls(codec,
 						  per_pin->pin_nid,
 						  per_pin->mux_nids[0],
 						  HDA_PCM_TYPE_HDMI);
 		if (err < 0)
 			return err;
 		snd_hda_spdif_ctls_unassign(codec, pin_idx);
 		/* add control for ELD Bytes */
 		err = hdmi_create_eld_ctl(codec, pin_idx,
 					  get_pcm_rec(spec, pin_idx)->device);
 		if (err < 0)
 			return err;
 		hdmi_present_sense(per_pin, 0);
 	}
 	/* add channel maps */
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct snd_pcm_chmap *chmap;
 		struct snd_kcontrol *kctl;
 		int i;
 		if (!codec->pcm_info[pin_idx].pcm)
 			break;
 		err = snd_pcm_add_chmap_ctls(codec->pcm_info[pin_idx].pcm,
 					     SNDRV_PCM_STREAM_PLAYBACK,
 					     NULL, 0, pin_idx, &chmap);
 		if (err < 0)
 			return err;
 		/* override handlers */
 		chmap->private_data = codec;
 		kctl = chmap->kctl;
 		for (i = 0; i < kctl->count; i++)
 			kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
 		kctl->info = hdmi_chmap_ctl_info;
 		kctl->get = hdmi_chmap_ctl_get;
 		kctl->put = hdmi_chmap_ctl_put;
 		kctl->tlv.c = hdmi_chmap_ctl_tlv;
 	}
 	return 0;
 }
 static int generic_hdmi_init_per_pins(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		per_pin->codec = codec;
 		mutex_init(&per_pin->lock);
 		INIT_DELAYED_WORK(&per_pin->work, hdmi_repoll_eld);
 		eld_proc_new(per_pin, pin_idx);
 	}
 	return 0;
 }
 static int generic_hdmi_init(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		hda_nid_t pin_nid = per_pin->pin_nid;
 		hdmi_init_pin(codec, pin_nid);
 		snd_hda_jack_detect_enable_callback(codec, pin_nid,
 			codec->jackpoll_interval > 0 ? jack_callback : NULL);
 	}
 	return 0;
 }
 static void hdmi_array_init(struct hdmi_spec *spec, int nums)
 {
 	snd_array_init(&spec->pins, sizeof(struct hdmi_spec_per_pin), nums);
 	snd_array_init(&spec->cvts, sizeof(struct hdmi_spec_per_cvt), nums);
 	snd_array_init(&spec->pcm_rec, sizeof(struct hda_pcm), nums);
 }
 static void hdmi_array_free(struct hdmi_spec *spec)
 {
 	snd_array_free(&spec->pins);
 	snd_array_free(&spec->cvts);
 	snd_array_free(&spec->pcm_rec);
 }
 static void generic_hdmi_free(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		cancel_delayed_work(&per_pin->work);
 		eld_proc_free(per_pin);
 	}
 	flush_workqueue(codec->bus->workq);
 	hdmi_array_free(spec);
 	kfree(spec);
 }
 #ifdef CONFIG_PM
 static int generic_hdmi_resume(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx;
 	codec->patch_ops.init(codec);
 	snd_hda_codec_resume_amp(codec);
 	snd_hda_codec_resume_cache(codec);
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		hdmi_present_sense(per_pin, 1);
 	}
 	return 0;
 }
 #endif
 static const struct hda_codec_ops generic_hdmi_patch_ops = {
 	.init			= generic_hdmi_init,
 	.free			= generic_hdmi_free,
 	.build_pcms		= generic_hdmi_build_pcms,
 	.build_controls		= generic_hdmi_build_controls,
 	.unsol_event		= hdmi_unsol_event,
 #ifdef CONFIG_PM
 	.resume			= generic_hdmi_resume,
 #endif
 };
 static const struct hdmi_ops generic_standard_hdmi_ops = {
 	.pin_get_eld				= snd_hdmi_get_eld,
 	.pin_get_slot_channel			= hdmi_pin_get_slot_channel,
 	.pin_set_slot_channel			= hdmi_pin_set_slot_channel,
 	.pin_setup_infoframe			= hdmi_pin_setup_infoframe,
 	.pin_hbr_setup				= hdmi_pin_hbr_setup,
 	.setup_stream				= hdmi_setup_stream,
 	.chmap_cea_alloc_validate_get_type	= hdmi_chmap_cea_alloc_validate_get_type,
 	.cea_alloc_to_tlv_chmap			= hdmi_cea_alloc_to_tlv_chmap,
 };
 static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
 					     hda_nid_t nid)
 {
 	struct hdmi_spec *spec = codec->spec;
 	hda_nid_t conns[4];
 	int nconns;
 	nconns = snd_hda_get_connections(codec, nid, conns, ARRAY_SIZE(conns));
 	if (nconns == spec->num_cvts &&
 	    !memcmp(conns, spec->cvt_nids, spec->num_cvts * sizeof(hda_nid_t)))
 		return;
 	/* override pins connection list */
 	codec_dbg(codec, "hdmi: haswell: override pin connection 0x%x\n", nid);
 	snd_hda_override_conn_list(codec, nid, spec->num_cvts, spec->cvt_nids);
 }
 #define INTEL_VENDOR_NID 0x08
 #define INTEL_GET_VENDOR_VERB 0xf81
 #define INTEL_SET_VENDOR_VERB 0x781
 #define INTEL_EN_DP12			0x02 /* enable DP 1.2 features */
 #define INTEL_EN_ALL_PIN_CVTS	0x01 /* enable 2nd & 3rd pins and convertors */
 static void intel_haswell_enable_all_pins(struct hda_codec *codec,
 					  bool update_tree)
 {
 	unsigned int vendor_param;
 	vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
 				INTEL_GET_VENDOR_VERB, 0);
 	if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS)
 		return;
 	vendor_param |= INTEL_EN_ALL_PIN_CVTS;
 	vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
 				INTEL_SET_VENDOR_VERB, vendor_param);
 	if (vendor_param == -1)
 		return;
 	if (update_tree)
 		snd_hda_codec_update_widgets(codec);
 }
 static void intel_haswell_fixup_enable_dp12(struct hda_codec *codec)
 {
 	unsigned int vendor_param;
 	vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
 				INTEL_GET_VENDOR_VERB, 0);
 	if (vendor_param == -1 || vendor_param & INTEL_EN_DP12)
 		return;
 	/* enable DP1.2 mode */
 	vendor_param |= INTEL_EN_DP12;
 	snd_hda_codec_write_cache(codec, INTEL_VENDOR_NID, 0,
 				INTEL_SET_VENDOR_VERB, vendor_param);
 }
 /* Haswell needs to re-issue the vendor-specific verbs before turning to D0.
  * Otherwise you may get severe h/w communication errors.
  */
 static void haswell_set_power_state(struct hda_codec *codec, hda_nid_t fg,
 				unsigned int power_state)
 {
 	if (power_state == AC_PWRST_D0) {
 		intel_haswell_enable_all_pins(codec, false);
 		intel_haswell_fixup_enable_dp12(codec);
 	}
 	snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, power_state);
 	snd_hda_codec_set_power_to_all(codec, fg, power_state);
 }
 static int patch_generic_hdmi(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec;
 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 	if (spec == NULL)
 		return -ENOMEM;
 	spec->ops = generic_standard_hdmi_ops;
 	codec->spec = spec;
 	hdmi_array_init(spec, 4);
 	if (is_haswell_plus(codec)) {
 		intel_haswell_enable_all_pins(codec, true);
 		intel_haswell_fixup_enable_dp12(codec);
 	}
 	if (is_haswell_plus(codec) || is_valleyview_plus(codec))
 		codec->depop_delay = 0;
 	if (hdmi_parse_codec(codec) < 0) {
 		codec->spec = NULL;
 		kfree(spec);
 		return -EINVAL;
 	}
 	codec->patch_ops = generic_hdmi_patch_ops;
 	if (is_haswell_plus(codec)) {
 		codec->patch_ops.set_power_state = haswell_set_power_state;
 		codec->dp_mst = true;
 	}
 	generic_hdmi_init_per_pins(codec);
 	init_channel_allocations();
 	return 0;
 }
 /*
  * Shared non-generic implementations
  */
 static int simple_playback_build_pcms(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hda_pcm *info;
 	unsigned int chans;
 	struct hda_pcm_stream *pstr;
 	struct hdmi_spec_per_cvt *per_cvt;
 	per_cvt = get_cvt(spec, 0);
 	chans = get_wcaps(codec, per_cvt->cvt_nid);
 	chans = get_wcaps_channels(chans);
 	info = snd_array_new(&spec->pcm_rec);
 	if (!info)
 		return -ENOMEM;
 	info->name = get_pin(spec, 0)->pcm_name;
 	sprintf(info->name, "HDMI 0");
 	info->pcm_type = HDA_PCM_TYPE_HDMI;
 	pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
 	*pstr = spec->pcm_playback;
 	pstr->nid = per_cvt->cvt_nid;
 	if (pstr->channels_max <= 2 && chans && chans <= 16)
 		pstr->channels_max = chans;
 	codec->num_pcms = 1;
 	codec->pcm_info = info;
 	return 0;
 }
 /* unsolicited event for jack sensing */
 static void simple_hdmi_unsol_event(struct hda_codec *codec,
 				    unsigned int res)
 {
 	snd_hda_jack_set_dirty_all(codec);
 	snd_hda_jack_report_sync(codec);
 }
 /* generic_hdmi_build_jack can be used for simple_hdmi, too,
  * as long as spec->pins[] is set correctly
  */
 #define simple_hdmi_build_jack	generic_hdmi_build_jack
 static int simple_playback_build_controls(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_cvt *per_cvt;
 	int err;
 	per_cvt = get_cvt(spec, 0);
 	err = snd_hda_create_dig_out_ctls(codec, per_cvt->cvt_nid,
 					  per_cvt->cvt_nid,
 					  HDA_PCM_TYPE_HDMI);
 	if (err < 0)
 		return err;
 	return simple_hdmi_build_jack(codec, 0);
 }
 static int simple_playback_init(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hdmi_spec_per_pin *per_pin = get_pin(spec, 0);
 	hda_nid_t pin = per_pin->pin_nid;
 	snd_hda_codec_write(codec, pin, 0,
 			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 	/* some codecs require to unmute the pin */
 	if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
 		snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 				    AMP_OUT_UNMUTE);
 	snd_hda_jack_detect_enable(codec, pin);
 	return 0;
 }
 static void simple_playback_free(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	hdmi_array_free(spec);
 	kfree(spec);
 }
 /*
  * Nvidia specific implementations
  */
 #define Nv_VERB_SET_Channel_Allocation          0xF79
 #define Nv_VERB_SET_Info_Frame_Checksum         0xF7A
 #define Nv_VERB_SET_Audio_Protection_On         0xF98
 #define Nv_VERB_SET_Audio_Protection_Off        0xF99
 #define nvhdmi_master_con_nid_7x	0x04
 #define nvhdmi_master_pin_nid_7x	0x05
 static const hda_nid_t nvhdmi_con_nids_7x[4] = {
 	/*front, rear, clfe, rear_surr */
 	0x6, 0x8, 0xa, 0xc,
 };
 static const struct hda_verb nvhdmi_basic_init_7x_2ch[] = {
 	/* set audio protect on */
 	{ 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
 	/* enable digital output on pin widget */
 	{ 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{} /* terminator */
 };
 static const struct hda_verb nvhdmi_basic_init_7x_8ch[] = {
 	/* set audio protect on */
 	{ 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
 	/* enable digital output on pin widget */
 	{ 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{ 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{ 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{ 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{ 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
 	{} /* terminator */
 };
 #ifdef LIMITED_RATE_FMT_SUPPORT
 /* support only the safe format and rate */
 #define SUPPORTED_RATES		SNDRV_PCM_RATE_48000
 #define SUPPORTED_MAXBPS	16
 #define SUPPORTED_FORMATS	SNDRV_PCM_FMTBIT_S16_LE
 #else
 /* support all rates and formats */
 #define SUPPORTED_RATES \
 	(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
 	SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
 	 SNDRV_PCM_RATE_192000)
 #define SUPPORTED_MAXBPS	24
 #define SUPPORTED_FORMATS \
 	(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
 #endif
 static int nvhdmi_7x_init_2ch(struct hda_codec *codec)
 {
 	snd_hda_sequence_write(codec, nvhdmi_basic_init_7x_2ch);
 	return 0;
 }
 static int nvhdmi_7x_init_8ch(struct hda_codec *codec)
 {
 	snd_hda_sequence_write(codec, nvhdmi_basic_init_7x_8ch);
 	return 0;
 }
 static unsigned int channels_2_6_8[] = {
 	2, 6, 8
 };
 static unsigned int channels_2_8[] = {
 	2, 8
 };
 static struct snd_pcm_hw_constraint_list hw_constraints_2_6_8_channels = {
 	.count = ARRAY_SIZE(channels_2_6_8),
 	.list = channels_2_6_8,
 	.mask = 0,
 };
 static struct snd_pcm_hw_constraint_list hw_constraints_2_8_channels = {
 	.count = ARRAY_SIZE(channels_2_8),
 	.list = channels_2_8,
 	.mask = 0,
 };
 static int simple_playback_pcm_open(struct hda_pcm_stream *hinfo,
 				    struct hda_codec *codec,
 				    struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct snd_pcm_hw_constraint_list *hw_constraints_channels = NULL;
 	switch (codec->preset->id) {
 	case 0x10de0002:
 	case 0x10de0003:
 	case 0x10de0005:
 	case 0x10de0006:
 		hw_constraints_channels = &hw_constraints_2_8_channels;
 		break;
 	case 0x10de0007:
 		hw_constraints_channels = &hw_constraints_2_6_8_channels;
 		break;
 	default:
 		break;
 	}
 	if (hw_constraints_channels != NULL) {
 		snd_pcm_hw_constraint_list(substream->runtime, 0,
 				SNDRV_PCM_HW_PARAM_CHANNELS,
 				hw_constraints_channels);
 	} else {
 		snd_pcm_hw_constraint_step(substream->runtime, 0,
 					   SNDRV_PCM_HW_PARAM_CHANNELS, 2);
 	}
 	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 }
 static int simple_playback_pcm_close(struct hda_pcm_stream *hinfo,
 				     struct hda_codec *codec,
 				     struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 }
 static int simple_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 				       struct hda_codec *codec,
 				       unsigned int stream_tag,
 				       unsigned int format,
 				       struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
 					     stream_tag, format, substream);
 }
 static const struct hda_pcm_stream simple_pcm_playback = {
 	.substreams = 1,
 	.channels_min = 2,
 	.channels_max = 2,
 	.ops = {
 		.open = simple_playback_pcm_open,
 		.close = simple_playback_pcm_close,
 		.prepare = simple_playback_pcm_prepare
 	},
 };
 static const struct hda_codec_ops simple_hdmi_patch_ops = {
 	.build_controls = simple_playback_build_controls,
 	.build_pcms = simple_playback_build_pcms,
 	.init = simple_playback_init,
 	.free = simple_playback_free,
 	.unsol_event = simple_hdmi_unsol_event,
 };
 static int patch_simple_hdmi(struct hda_codec *codec,
 			     hda_nid_t cvt_nid, hda_nid_t pin_nid)
 {
 	struct hdmi_spec *spec;
 	struct hdmi_spec_per_cvt *per_cvt;
 	struct hdmi_spec_per_pin *per_pin;
 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 	if (!spec)
 		return -ENOMEM;
 	codec->spec = spec;
 	hdmi_array_init(spec, 1);
 	spec->multiout.num_dacs = 0;  /* no analog */
 	spec->multiout.max_channels = 2;
 	spec->multiout.dig_out_nid = cvt_nid;
 	spec->num_cvts = 1;
 	spec->num_pins = 1;
 	per_pin = snd_array_new(&spec->pins);
 	per_cvt = snd_array_new(&spec->cvts);
 	if (!per_pin || !per_cvt) {
 		simple_playback_free(codec);
 		return -ENOMEM;
 	}
 	per_cvt->cvt_nid = cvt_nid;
 	per_pin->pin_nid = pin_nid;
 	spec->pcm_playback = simple_pcm_playback;
 	codec->patch_ops = simple_hdmi_patch_ops;
 	return 0;
 }
 static void nvhdmi_8ch_7x_set_info_frame_parameters(struct hda_codec *codec,
 						    int channels)
 {
 	unsigned int chanmask;
 	int chan = channels ? (channels - 1) : 1;
 	switch (channels) {
 	default:
 	case 0:
 	case 2:
 		chanmask = 0x00;
 		break;
 	case 4:
 		chanmask = 0x08;
 		break;
 	case 6:
 		chanmask = 0x0b;
 		break;
 	case 8:
 		chanmask = 0x13;
 		break;
 	}
 	/* Set the audio infoframe channel allocation and checksum fields.  The
 	 * channel count is computed implicitly by the hardware. */
 	snd_hda_codec_write(codec, 0x1, 0,
 			Nv_VERB_SET_Channel_Allocation, chanmask);
 	snd_hda_codec_write(codec, 0x1, 0,
 			Nv_VERB_SET_Info_Frame_Checksum,
 			(0x71 - chan - chanmask));
 }
 static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream *hinfo,
 				   struct hda_codec *codec,
 				   struct snd_pcm_substream *substream)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int i;
 	snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x,
 			0, AC_VERB_SET_CHANNEL_STREAMID, 0);
 	for (i = 0; i < 4; i++) {
 		/* set the stream id */
 		snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
 				AC_VERB_SET_CHANNEL_STREAMID, 0);
 		/* set the stream format */
 		snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
 				AC_VERB_SET_STREAM_FORMAT, 0);
 	}
 	/* The audio hardware sends a channel count of 0x7 (8ch) when all the
 	 * streams are disabled. */
 	nvhdmi_8ch_7x_set_info_frame_parameters(codec, 8);
 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 }
 static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream *hinfo,
 				     struct hda_codec *codec,
 				     unsigned int stream_tag,
 				     unsigned int format,
 				     struct snd_pcm_substream *substream)
 {
 	int chs;
 	unsigned int dataDCC2, channel_id;
 	int i;
 	struct hdmi_spec *spec = codec->spec;
 	struct hda_spdif_out *spdif;
 	struct hdmi_spec_per_cvt *per_cvt;
 	mutex_lock(&codec->spdif_mutex);
 	per_cvt = get_cvt(spec, 0);
 	spdif = snd_hda_spdif_out_of_nid(codec, per_cvt->cvt_nid);
 	chs = substream->runtime->channels;
 	dataDCC2 = 0x2;
 	/* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
 	if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
 		snd_hda_codec_write(codec,
 				nvhdmi_master_con_nid_7x,
 				0,
 				AC_VERB_SET_DIGI_CONVERT_1,
 				spdif->ctls & ~AC_DIG1_ENABLE & 0xff);
 	/* set the stream id */
 	snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
 			AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0);
 	/* set the stream format */
 	snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
 			AC_VERB_SET_STREAM_FORMAT, format);
 	/* turn on again (if needed) */
 	/* enable and set the channel status audio/data flag */
 	if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE)) {
 		snd_hda_codec_write(codec,
 				nvhdmi_master_con_nid_7x,
 				0,
 				AC_VERB_SET_DIGI_CONVERT_1,
 				spdif->ctls & 0xff);
 		snd_hda_codec_write(codec,
 				nvhdmi_master_con_nid_7x,
 				0,
 				AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
 	}
 	for (i = 0; i < 4; i++) {
 		if (chs == 2)
 			channel_id = 0;
 		else
 			channel_id = i * 2;
 		/* turn off SPDIF once;
 		 *otherwise the IEC958 bits won't be updated
 		 */
 		if (codec->spdif_status_reset &&
 		(spdif->ctls & AC_DIG1_ENABLE))
 			snd_hda_codec_write(codec,
 				nvhdmi_con_nids_7x[i],
 				0,
 				AC_VERB_SET_DIGI_CONVERT_1,
 				spdif->ctls & ~AC_DIG1_ENABLE & 0xff);
 		/* set the stream id */
 		snd_hda_codec_write(codec,
 				nvhdmi_con_nids_7x[i],
 				0,
 				AC_VERB_SET_CHANNEL_STREAMID,
 				(stream_tag << 4) | channel_id);
 		/* set the stream format */
 		snd_hda_codec_write(codec,
 				nvhdmi_con_nids_7x[i],
 				0,
 				AC_VERB_SET_STREAM_FORMAT,
 				format);
 		/* turn on again (if needed) */
 		/* enable and set the channel status audio/data flag */
 		if (codec->spdif_status_reset &&
 		(spdif->ctls & AC_DIG1_ENABLE)) {
 			snd_hda_codec_write(codec,
 					nvhdmi_con_nids_7x[i],
 					0,
 					AC_VERB_SET_DIGI_CONVERT_1,
 					spdif->ctls & 0xff);
 			snd_hda_codec_write(codec,
 					nvhdmi_con_nids_7x[i],
 					0,
 					AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
 		}
 	}
 	nvhdmi_8ch_7x_set_info_frame_parameters(codec, chs);
 	mutex_unlock(&codec->spdif_mutex);
 	return 0;
 }
 static const struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x = {
 	.substreams = 1,
 	.channels_min = 2,
 	.channels_max = 8,
 	.nid = nvhdmi_master_con_nid_7x,
 	.rates = SUPPORTED_RATES,
 	.maxbps = SUPPORTED_MAXBPS,
 	.formats = SUPPORTED_FORMATS,
 	.ops = {
 		.open = simple_playback_pcm_open,
 		.close = nvhdmi_8ch_7x_pcm_close,
 		.prepare = nvhdmi_8ch_7x_pcm_prepare
 	},
 };
 static int patch_nvhdmi_2ch(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec;
 	int err = patch_simple_hdmi(codec, nvhdmi_master_con_nid_7x,
 				    nvhdmi_master_pin_nid_7x);
 	if (err < 0)
 		return err;
 	codec->patch_ops.init = nvhdmi_7x_init_2ch;
 	/* override the PCM rates, etc, as the codec doesn't give full list */
 	spec = codec->spec;
 	spec->pcm_playback.rates = SUPPORTED_RATES;
 	spec->pcm_playback.maxbps = SUPPORTED_MAXBPS;
 	spec->pcm_playback.formats = SUPPORTED_FORMATS;
 	return 0;
 }
 static int nvhdmi_7x_8ch_build_pcms(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int err = simple_playback_build_pcms(codec);
 	if (!err) {
 		struct hda_pcm *info = get_pcm_rec(spec, 0);
 		info->own_chmap = true;
 	}
 	return err;
 }
 static int nvhdmi_7x_8ch_build_controls(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	struct hda_pcm *info;
 	struct snd_pcm_chmap *chmap;
 	int err;
 	err = simple_playback_build_controls(codec);
 	if (err < 0)
 		return err;
 	/* add channel maps */
 	info = get_pcm_rec(spec, 0);
 	err = snd_pcm_add_chmap_ctls(info->pcm,
 				     SNDRV_PCM_STREAM_PLAYBACK,
 				     snd_pcm_alt_chmaps, 8, 0, &chmap);
 	if (err < 0)
 		return err;
 	switch (codec->preset->id) {
 	case 0x10de0002:
 	case 0x10de0003:
 	case 0x10de0005:
 	case 0x10de0006:
 		chmap->channel_mask = (1U << 2) | (1U << 8);
 		break;
 	case 0x10de0007:
 		chmap->channel_mask = (1U << 2) | (1U << 6) | (1U << 8);
 	}
 	return 0;
 }
 static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec;
 	int err = patch_nvhdmi_2ch(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->multiout.max_channels = 8;
 	spec->pcm_playback = nvhdmi_pcm_playback_8ch_7x;
 	codec->patch_ops.init = nvhdmi_7x_init_8ch;
 	codec->patch_ops.build_pcms = nvhdmi_7x_8ch_build_pcms;
 	codec->patch_ops.build_controls = nvhdmi_7x_8ch_build_controls;
 	/* Initialize the audio infoframe channel mask and checksum to something
 	 * valid */
 	nvhdmi_8ch_7x_set_info_frame_parameters(codec, 8);
 	return 0;
 }
 /*
  * NVIDIA codecs ignore ASP mapping for 2ch - confirmed on:
  * - 0x10de0015
  * - 0x10de0040
  */
 static int nvhdmi_chmap_cea_alloc_validate_get_type(struct cea_channel_speaker_allocation *cap,
 						    int channels)
 {
 	if (cap->ca_index == 0x00 && channels == 2)
 		return SNDRV_CTL_TLVT_CHMAP_FIXED;
 	return hdmi_chmap_cea_alloc_validate_get_type(cap, channels);
 }
 static int nvhdmi_chmap_validate(int ca, int chs, unsigned char *map)
 {
 	if (ca == 0x00 && (map[0] != SNDRV_CHMAP_FL || map[1] != SNDRV_CHMAP_FR))
 		return -EINVAL;
 	return 0;
 }
 static int patch_nvhdmi(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec;
 	int err;
 	err = patch_generic_hdmi(codec);
 	if (err)
 		return err;
 	spec = codec->spec;
 	spec->dyn_pin_out = true;
 	spec->ops.chmap_cea_alloc_validate_get_type =
 		nvhdmi_chmap_cea_alloc_validate_get_type;
 	spec->ops.chmap_validate = nvhdmi_chmap_validate;
 	return 0;
 }
 /*
  * ATI/AMD-specific implementations
  */
 #define is_amdhdmi_rev3_or_later(codec) \
 	((codec)->vendor_id == 0x1002aa01 && ((codec)->revision_id & 0xff00) >= 0x0300)
 #define has_amd_full_remap_support(codec) is_amdhdmi_rev3_or_later(codec)
 /* ATI/AMD specific HDA pin verbs, see the AMD HDA Verbs specification */
 #define ATI_VERB_SET_CHANNEL_ALLOCATION	0x771
 #define ATI_VERB_SET_DOWNMIX_INFO	0x772
 #define ATI_VERB_SET_MULTICHANNEL_01	0x777
 #define ATI_VERB_SET_MULTICHANNEL_23	0x778
 #define ATI_VERB_SET_MULTICHANNEL_45	0x779
 #define ATI_VERB_SET_MULTICHANNEL_67	0x77a
 #define ATI_VERB_SET_HBR_CONTROL	0x77c
 #define ATI_VERB_SET_MULTICHANNEL_1	0x785
 #define ATI_VERB_SET_MULTICHANNEL_3	0x786
 #define ATI_VERB_SET_MULTICHANNEL_5	0x787
 #define ATI_VERB_SET_MULTICHANNEL_7	0x788
 #define ATI_VERB_SET_MULTICHANNEL_MODE	0x789
 #define ATI_VERB_GET_CHANNEL_ALLOCATION	0xf71
 #define ATI_VERB_GET_DOWNMIX_INFO	0xf72
 #define ATI_VERB_GET_MULTICHANNEL_01	0xf77
 #define ATI_VERB_GET_MULTICHANNEL_23	0xf78
 #define ATI_VERB_GET_MULTICHANNEL_45	0xf79
 #define ATI_VERB_GET_MULTICHANNEL_67	0xf7a
 #define ATI_VERB_GET_HBR_CONTROL	0xf7c
 #define ATI_VERB_GET_MULTICHANNEL_1	0xf85
 #define ATI_VERB_GET_MULTICHANNEL_3	0xf86
 #define ATI_VERB_GET_MULTICHANNEL_5	0xf87
 #define ATI_VERB_GET_MULTICHANNEL_7	0xf88
 #define ATI_VERB_GET_MULTICHANNEL_MODE	0xf89
 /* AMD specific HDA cvt verbs */
 #define ATI_VERB_SET_RAMP_RATE		0x770
 #define ATI_VERB_GET_RAMP_RATE		0xf70
 #define ATI_OUT_ENABLE 0x1
 #define ATI_MULTICHANNEL_MODE_PAIRED	0
 #define ATI_MULTICHANNEL_MODE_SINGLE	1
 #define ATI_HBR_CAPABLE 0x01
 #define ATI_HBR_ENABLE 0x10
 static int atihdmi_pin_get_eld(struct hda_codec *codec, hda_nid_t nid,
 			   unsigned char *buf, int *eld_size)
 {
 	/* call hda_eld.c ATI/AMD-specific function */
 	return snd_hdmi_get_eld_ati(codec, nid, buf, eld_size,
 				    is_amdhdmi_rev3_or_later(codec));
 }
 static void atihdmi_pin_setup_infoframe(struct hda_codec *codec, hda_nid_t pin_nid, int ca,
 					int active_channels, int conn_type)
 {
 	snd_hda_codec_write(codec, pin_nid, 0, ATI_VERB_SET_CHANNEL_ALLOCATION, ca);
 }
 static int atihdmi_paired_swap_fc_lfe(int pos)
 {
 	/*
 	 * ATI/AMD have automatic FC/LFE swap built-in
 	 * when in pairwise mapping mode.
 	 */
 	switch (pos) {
 		/* see channel_allocations[].speakers[] */
 		case 2: return 3;
 		case 3: return 2;
 		default: break;
 	}
 	return pos;
 }
 static int atihdmi_paired_chmap_validate(int ca, int chs, unsigned char *map)
 {
 	struct cea_channel_speaker_allocation *cap;
 	int i, j;
 	/* check that only channel pairs need to be remapped on old pre-rev3 ATI/AMD */
 	cap = &channel_allocations[get_channel_allocation_order(ca)];
 	for (i = 0; i < chs; ++i) {
 		int mask = to_spk_mask(map[i]);
 		bool ok = false;
 		bool companion_ok = false;
 		if (!mask)
 			continue;
 		for (j = 0 + i % 2; j < 8; j += 2) {
 			int chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j);
 			if (cap->speakers[chan_idx] == mask) {
 				/* channel is in a supported position */
 				ok = true;
 				if (i % 2 == 0 && i + 1 < chs) {
 					/* even channel, check the odd companion */
 					int comp_chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j + 1);
 					int comp_mask_req = to_spk_mask(map[i+1]);
 					int comp_mask_act = cap->speakers[comp_chan_idx];
 					if (comp_mask_req == comp_mask_act)
 						companion_ok = true;
 					else
 						return -EINVAL;
 				}
 				break;
 			}
 		}
 		if (!ok)
 			return -EINVAL;
 		if (companion_ok)
 			i++; /* companion channel already checked */
 	}
 	return 0;
 }
 static int atihdmi_pin_set_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
 					int hdmi_slot, int stream_channel)
 {
 	int verb;
 	int ati_channel_setup = 0;
 	if (hdmi_slot > 7)
 		return -EINVAL;
 	if (!has_amd_full_remap_support(codec)) {
 		hdmi_slot = atihdmi_paired_swap_fc_lfe(hdmi_slot);
 		/* In case this is an odd slot but without stream channel, do not
 		 * disable the slot since the corresponding even slot could have a
 		 * channel. In case neither have a channel, the slot pair will be
 		 * disabled when this function is called for the even slot. */
 		if (hdmi_slot % 2 != 0 && stream_channel == 0xf)
 			return 0;
 		hdmi_slot -= hdmi_slot % 2;
 		if (stream_channel != 0xf)
 			stream_channel -= stream_channel % 2;
 	}
 	verb = ATI_VERB_SET_MULTICHANNEL_01 + hdmi_slot/2 + (hdmi_slot % 2) * 0x00e;
 	/* ati_channel_setup format: [7..4] = stream_channel_id, [1] = mute, [0] = enable */
 	if (stream_channel != 0xf)
 		ati_channel_setup = (stream_channel << 4) | ATI_OUT_ENABLE;
 	return snd_hda_codec_write(codec, pin_nid, 0, verb, ati_channel_setup);
 }
 static int atihdmi_pin_get_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
 					int asp_slot)
 {
 	bool was_odd = false;
 	int ati_asp_slot = asp_slot;
 	int verb;
 	int ati_channel_setup;
 	if (asp_slot > 7)
 		return -EINVAL;
 	if (!has_amd_full_remap_support(codec)) {
 		ati_asp_slot = atihdmi_paired_swap_fc_lfe(asp_slot);
 		if (ati_asp_slot % 2 != 0) {
 			ati_asp_slot -= 1;
 			was_odd = true;
 		}
 	}
 	verb = ATI_VERB_GET_MULTICHANNEL_01 + ati_asp_slot/2 + (ati_asp_slot % 2) * 0x00e;
 	ati_channel_setup = snd_hda_codec_read(codec, pin_nid, 0, verb, 0);
 	if (!(ati_channel_setup & ATI_OUT_ENABLE))
 		return 0xf;
 	return ((ati_channel_setup & 0xf0) >> 4) + !!was_odd;
 }
 static int atihdmi_paired_chmap_cea_alloc_validate_get_type(struct cea_channel_speaker_allocation *cap,
 							    int channels)
 {
 	int c;
 	/*
 	 * Pre-rev3 ATI/AMD codecs operate in a paired channel mode, so
 	 * we need to take that into account (a single channel may take 2
 	 * channel slots if we need to carry a silent channel next to it).
 	 * On Rev3+ AMD codecs this function is not used.
 	 */
 	int chanpairs = 0;
 	/* We only produce even-numbered channel count TLVs */
 	if ((channels % 2) != 0)
 		return -1;
 	for (c = 0; c < 7; c += 2) {
 		if (cap->speakers[c] || cap->speakers[c+1])
 			chanpairs++;
 	}
 	if (chanpairs * 2 != channels)
 		return -1;
 	return SNDRV_CTL_TLVT_CHMAP_PAIRED;
 }
 static void atihdmi_paired_cea_alloc_to_tlv_chmap(struct cea_channel_speaker_allocation *cap,
 						  unsigned int *chmap, int channels)
 {
 	/* produce paired maps for pre-rev3 ATI/AMD codecs */
 	int count = 0;
 	int c;
 	for (c = 7; c >= 0; c--) {
 		int chan = 7 - atihdmi_paired_swap_fc_lfe(7 - c);
 		int spk = cap->speakers[chan];
 		if (!spk) {
 			/* add N/A channel if the companion channel is occupied */
 			if (cap->speakers[chan + (chan % 2 ? -1 : 1)])
 				chmap[count++] = SNDRV_CHMAP_NA;
 			continue;
 		}
 		chmap[count++] = spk_to_chmap(spk);
 	}
 	WARN_ON(count != channels);
 }
 static int atihdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,
 				 bool hbr)
 {
 	int hbr_ctl, hbr_ctl_new;
 	hbr_ctl = snd_hda_codec_read(codec, pin_nid, 0, ATI_VERB_GET_HBR_CONTROL, 0);
 	if (hbr_ctl >= 0 && (hbr_ctl & ATI_HBR_CAPABLE)) {
 		if (hbr)
 			hbr_ctl_new = hbr_ctl | ATI_HBR_ENABLE;
 		else
 			hbr_ctl_new = hbr_ctl & ~ATI_HBR_ENABLE;
 		codec_dbg(codec,
 			  "atihdmi_pin_hbr_setup: NID=0x%x, %shbr-ctl=0x%x\n",
 				pin_nid,
 				hbr_ctl == hbr_ctl_new ? "" : "new-",
 				hbr_ctl_new);
 		if (hbr_ctl != hbr_ctl_new)
 			snd_hda_codec_write(codec, pin_nid, 0,
 						ATI_VERB_SET_HBR_CONTROL,
 						hbr_ctl_new);
 	} else if (hbr)
 		return -EINVAL;
 	return 0;
 }
 static int atihdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
 				hda_nid_t pin_nid, u32 stream_tag, int format)
 {
 	if (is_amdhdmi_rev3_or_later(codec)) {
 		int ramp_rate = 180; /* default as per AMD spec */
 		/* disable ramp-up/down for non-pcm as per AMD spec */
 		if (format & AC_FMT_TYPE_NON_PCM)
 			ramp_rate = 0;
 		snd_hda_codec_write(codec, cvt_nid, 0, ATI_VERB_SET_RAMP_RATE, ramp_rate);
 	}
 	return hdmi_setup_stream(codec, cvt_nid, pin_nid, stream_tag, format);
 }
 static int atihdmi_init(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec = codec->spec;
 	int pin_idx, err;
 	err = generic_hdmi_init(codec);
 	if (err)
 		return err;
 	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
 		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
 		/* make sure downmix information in infoframe is zero */
 		snd_hda_codec_write(codec, per_pin->pin_nid, 0, ATI_VERB_SET_DOWNMIX_INFO, 0);
 		/* enable channel-wise remap mode if supported */
 		if (has_amd_full_remap_support(codec))
 			snd_hda_codec_write(codec, per_pin->pin_nid, 0,
 					    ATI_VERB_SET_MULTICHANNEL_MODE,
 					    ATI_MULTICHANNEL_MODE_SINGLE);
 	}
 	return 0;
 }
 static int patch_atihdmi(struct hda_codec *codec)
 {
 	struct hdmi_spec *spec;
 	struct hdmi_spec_per_cvt *per_cvt;
 	int err, cvt_idx;
 	err = patch_generic_hdmi(codec);
 	if (err)
 		return err;
 	codec->patch_ops.init = atihdmi_init;
 	spec = codec->spec;
 	spec->ops.pin_get_eld = atihdmi_pin_get_eld;
 	spec->ops.pin_get_slot_channel = atihdmi_pin_get_slot_channel;
 	spec->ops.pin_set_slot_channel = atihdmi_pin_set_slot_channel;
 	spec->ops.pin_setup_infoframe = atihdmi_pin_setup_infoframe;
 	spec->ops.pin_hbr_setup = atihdmi_pin_hbr_setup;
 	spec->ops.setup_stream = atihdmi_setup_stream;
 	if (!has_amd_full_remap_support(codec)) {
 		/* override to ATI/AMD-specific versions with pairwise mapping */
 		spec->ops.chmap_cea_alloc_validate_get_type =
 			atihdmi_paired_chmap_cea_alloc_validate_get_type;
 		spec->ops.cea_alloc_to_tlv_chmap = atihdmi_paired_cea_alloc_to_tlv_chmap;
 		spec->ops.chmap_validate = atihdmi_paired_chmap_validate;
 	}
 	/* ATI/AMD converters do not advertise all of their capabilities */
 	for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
 		per_cvt = get_cvt(spec, cvt_idx);
 		per_cvt->channels_max = max(per_cvt->channels_max, 8u);
 		per_cvt->rates |= SUPPORTED_RATES;
 		per_cvt->formats |= SUPPORTED_FORMATS;
 		per_cvt->maxbps = max(per_cvt->maxbps, 24u);
 	}
 	spec->channels_max = max(spec->channels_max, 8u);
 	return 0;
 }
 /* VIA HDMI Implementation */
 #define VIAHDMI_CVT_NID	0x02	/* audio converter1 */
 #define VIAHDMI_PIN_NID	0x03	/* HDMI output pin1 */
 static int patch_via_hdmi(struct hda_codec *codec)
 {
 	return patch_simple_hdmi(codec, VIAHDMI_CVT_NID, VIAHDMI_PIN_NID);
 }
 /*
  * called from hda_codec.c for generic HDMI support
  */
 int snd_hda_parse_hdmi_codec(struct hda_codec *codec)
 {
 	return patch_generic_hdmi(codec);
 }
 EXPORT_SYMBOL_GPL(snd_hda_parse_hdmi_codec);
 /*
  * patch entries
  */
 static const struct hda_codec_preset snd_hda_preset_hdmi[] = {
 { .id = 0x1002793c, .name = "RS600 HDMI",	.patch = patch_atihdmi },
 { .id = 0x10027919, .name = "RS600 HDMI",	.patch = patch_atihdmi },
 { .id = 0x1002791a, .name = "RS690/780 HDMI",	.patch = patch_atihdmi },
 { .id = 0x1002aa01, .name = "R6xx HDMI",	.patch = patch_atihdmi },
 { .id = 0x10951390, .name = "SiI1390 HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x10951392, .name = "SiI1392 HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x17e80047, .name = "Chrontel HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x10de0002, .name = "MCP77/78 HDMI",	.patch = patch_nvhdmi_8ch_7x },
 { .id = 0x10de0003, .name = "MCP77/78 HDMI",	.patch = patch_nvhdmi_8ch_7x },
 { .id = 0x10de0005, .name = "MCP77/78 HDMI",	.patch = patch_nvhdmi_8ch_7x },
 { .id = 0x10de0006, .name = "MCP77/78 HDMI",	.patch = patch_nvhdmi_8ch_7x },
 { .id = 0x10de0007, .name = "MCP79/7A HDMI",	.patch = patch_nvhdmi_8ch_7x },
 { .id = 0x10de000a, .name = "GPU 0a HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de000b, .name = "GPU 0b HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de000c, .name = "MCP89 HDMI",	.patch = patch_nvhdmi },
 { .id = 0x10de000d, .name = "GPU 0d HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0010, .name = "GPU 10 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0011, .name = "GPU 11 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0012, .name = "GPU 12 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0013, .name = "GPU 13 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0014, .name = "GPU 14 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0015, .name = "GPU 15 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0016, .name = "GPU 16 HDMI/DP",	.patch = patch_nvhdmi },
 /* 17 is known to be absent */
 { .id = 0x10de0018, .name = "GPU 18 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0019, .name = "GPU 19 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de001a, .name = "GPU 1a HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de001b, .name = "GPU 1b HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de001c, .name = "GPU 1c HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0028, .name = "Tegra12x HDMI",	.patch = patch_nvhdmi },
 { .id = 0x10de0040, .name = "GPU 40 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0041, .name = "GPU 41 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0042, .name = "GPU 42 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0043, .name = "GPU 43 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0044, .name = "GPU 44 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0051, .name = "GPU 51 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0060, .name = "GPU 60 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0067, .name = "MCP67 HDMI",	.patch = patch_nvhdmi_2ch },
 { .id = 0x10de0070, .name = "GPU 70 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de0071, .name = "GPU 71 HDMI/DP",	.patch = patch_nvhdmi },
+{ .id = 0x10de0072, .name = "GPU 72 HDMI/DP",	.patch = patch_nvhdmi },
 { .id = 0x10de8001, .name = "MCP73 HDMI",	.patch = patch_nvhdmi_2ch },
 { .id = 0x11069f80, .name = "VX900 HDMI/DP",	.patch = patch_via_hdmi },
 { .id = 0x11069f81, .name = "VX900 HDMI/DP",	.patch = patch_via_hdmi },
 { .id = 0x11069f84, .name = "VX11 HDMI/DP",	.patch = patch_generic_hdmi },
 { .id = 0x11069f85, .name = "VX11 HDMI/DP",	.patch = patch_generic_hdmi },
 { .id = 0x80860054, .name = "IbexPeak HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862801, .name = "Bearlake HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862802, .name = "Cantiga HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862803, .name = "Eaglelake HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862804, .name = "IbexPeak HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862805, .name = "CougarPoint HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862806, .name = "PantherPoint HDMI", .patch = patch_generic_hdmi },
 { .id = 0x80862807, .name = "Haswell HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862808, .name = "Broadwell HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862809, .name = "Skylake HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862880, .name = "CedarTrail HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862882, .name = "Valleyview2 HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x80862883, .name = "Braswell HDMI",	.patch = patch_generic_hdmi },
 { .id = 0x808629fb, .name = "Crestline HDMI",	.patch = patch_generic_hdmi },
 {} /* terminator */
 };
 MODULE_ALIAS("snd-hda-codec-id:1002793c");
 MODULE_ALIAS("snd-hda-codec-id:10027919");
 MODULE_ALIAS("snd-hda-codec-id:1002791a");
 MODULE_ALIAS("snd-hda-codec-id:1002aa01");
 MODULE_ALIAS("snd-hda-codec-id:10951390");
 MODULE_ALIAS("snd-hda-codec-id:10951392");
 MODULE_ALIAS("snd-hda-codec-id:10de0002");
 MODULE_ALIAS("snd-hda-codec-id:10de0003");
 MODULE_ALIAS("snd-hda-codec-id:10de0005");
 MODULE_ALIAS("snd-hda-codec-id:10de0006");
 MODULE_ALIAS("snd-hda-codec-id:10de0007");
 MODULE_ALIAS("snd-hda-codec-id:10de000a");
 MODULE_ALIAS("snd-hda-codec-id:10de000b");
 MODULE_ALIAS("snd-hda-codec-id:10de000c");
 MODULE_ALIAS("snd-hda-codec-id:10de000d");
 MODULE_ALIAS("snd-hda-codec-id:10de0010");
 MODULE_ALIAS("snd-hda-codec-id:10de0011");
 MODULE_ALIAS("snd-hda-codec-id:10de0012");
 MODULE_ALIAS("snd-hda-codec-id:10de0013");
 MODULE_ALIAS("snd-hda-codec-id:10de0014");
 MODULE_ALIAS("snd-hda-codec-id:10de0015");
 MODULE_ALIAS("snd-hda-codec-id:10de0016");
 MODULE_ALIAS("snd-hda-codec-id:10de0018");
 MODULE_ALIAS("snd-hda-codec-id:10de0019");
 MODULE_ALIAS("snd-hda-codec-id:10de001a");
 MODULE_ALIAS("snd-hda-codec-id:10de001b");
 MODULE_ALIAS("snd-hda-codec-id:10de001c");
 MODULE_ALIAS("snd-hda-codec-id:10de0028");
 MODULE_ALIAS("snd-hda-codec-id:10de0040");
 MODULE_ALIAS("snd-hda-codec-id:10de0041");
 MODULE_ALIAS("snd-hda-codec-id:10de0042");
 MODULE_ALIAS("snd-hda-codec-id:10de0043");
 MODULE_ALIAS("snd-hda-codec-id:10de0044");
 MODULE_ALIAS("snd-hda-codec-id:10de0051");
 MODULE_ALIAS("snd-hda-codec-id:10de0060");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
 MODULE_ALIAS("snd-hda-codec-id:10de0070");
 MODULE_ALIAS("snd-hda-codec-id:10de0071");
+MODULE_ALIAS("snd-hda-codec-id:10de0072");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
 MODULE_ALIAS("snd-hda-codec-id:11069f80");
 MODULE_ALIAS("snd-hda-codec-id:11069f81");
 MODULE_ALIAS("snd-hda-codec-id:11069f84");
 MODULE_ALIAS("snd-hda-codec-id:11069f85");
 MODULE_ALIAS("snd-hda-codec-id:17e80047");
 MODULE_ALIAS("snd-hda-codec-id:80860054");
 MODULE_ALIAS("snd-hda-codec-id:80862801");
 MODULE_ALIAS("snd-hda-codec-id:80862802");
 MODULE_ALIAS("snd-hda-codec-id:80862803");
 MODULE_ALIAS("snd-hda-codec-id:80862804");
 MODULE_ALIAS("snd-hda-codec-id:80862805");
 MODULE_ALIAS("snd-hda-codec-id:80862806");
 MODULE_ALIAS("snd-hda-codec-id:80862807");
 MODULE_ALIAS("snd-hda-codec-id:80862808");
 MODULE_ALIAS("snd-hda-codec-id:80862809");
 MODULE_ALIAS("snd-hda-codec-id:80862880");
 MODULE_ALIAS("snd-hda-codec-id:80862882");
 MODULE_ALIAS("snd-hda-codec-id:80862883");
 MODULE_ALIAS("snd-hda-codec-id:808629fb");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("HDMI HD-audio codec");
 MODULE_ALIAS("snd-hda-codec-intelhdmi");
 MODULE_ALIAS("snd-hda-codec-nvhdmi");
 MODULE_ALIAS("snd-hda-codec-atihdmi");
 static struct hda_codec_preset_list intel_list = {
 	.preset = snd_hda_preset_hdmi,
 	.owner = THIS_MODULE,
 };
 static int __init patch_hdmi_init(void)
 {
 	return snd_hda_add_codec_preset(&intel_list);
 }
 static void __exit patch_hdmi_exit(void)
 {
 	snd_hda_delete_codec_preset(&intel_list);
 }
 module_init(patch_hdmi_init)
 module_exit(patch_hdmi_exit)

sound/pci/hda/patch_sigmatel.c

Diff comments View file @ eb74926

 /*
  * Universal Interface for Intel High Definition Audio Codec
  *
  * HD audio interface patch for SigmaTel STAC92xx
  *
  * Copyright (c) 2005 Embedded Alley Solutions, Inc.
  * Matt Porter <mporter@embeddedalley.com>
  *
  * Based on patch_cmedia.c and patch_realtek.c
  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  *
  *  This driver 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 driver 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
  */
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/dmi.h>
 #include <linux/module.h>
 #include <sound/core.h>
 #include <sound/jack.h>
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_auto_parser.h"
 #include "hda_beep.h"
 #include "hda_jack.h"
 #include "hda_generic.h"
 enum {
 	STAC_REF,
 	STAC_9200_OQO,
 	STAC_9200_DELL_D21,
 	STAC_9200_DELL_D22,
 	STAC_9200_DELL_D23,
 	STAC_9200_DELL_M21,
 	STAC_9200_DELL_M22,
 	STAC_9200_DELL_M23,
 	STAC_9200_DELL_M24,
 	STAC_9200_DELL_M25,
 	STAC_9200_DELL_M26,
 	STAC_9200_DELL_M27,
 	STAC_9200_M4,
 	STAC_9200_M4_2,
 	STAC_9200_PANASONIC,
 	STAC_9200_EAPD_INIT,
 	STAC_9200_MODELS
 };
 enum {
 	STAC_9205_REF,
 	STAC_9205_DELL_M42,
 	STAC_9205_DELL_M43,
 	STAC_9205_DELL_M44,
 	STAC_9205_EAPD,
 	STAC_9205_MODELS
 };
 enum {
 	STAC_92HD73XX_NO_JD, /* no jack-detection */
 	STAC_92HD73XX_REF,
 	STAC_92HD73XX_INTEL,
 	STAC_DELL_M6_AMIC,
 	STAC_DELL_M6_DMIC,
 	STAC_DELL_M6_BOTH,
 	STAC_DELL_EQ,
 	STAC_ALIENWARE_M17X,
 	STAC_92HD89XX_HP_FRONT_JACK,
 	STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK,
 	STAC_92HD73XX_MODELS
 };
 enum {
 	STAC_92HD83XXX_REF,
 	STAC_92HD83XXX_PWR_REF,
 	STAC_DELL_S14,
 	STAC_DELL_VOSTRO_3500,
 	STAC_92HD83XXX_HP_cNB11_INTQUAD,
 	STAC_HP_DV7_4000,
 	STAC_HP_ZEPHYR,
 	STAC_92HD83XXX_HP_LED,
 	STAC_92HD83XXX_HP_INV_LED,
 	STAC_92HD83XXX_HP_MIC_LED,
 	STAC_HP_LED_GPIO10,
 	STAC_92HD83XXX_HEADSET_JACK,
 	STAC_92HD83XXX_HP,
 	STAC_HP_ENVY_BASS,
 	STAC_HP_BNB13_EQ,
 	STAC_HP_ENVY_TS_BASS,
 	STAC_92HD83XXX_MODELS
 };
 enum {
 	STAC_92HD71BXX_REF,
 	STAC_DELL_M4_1,
 	STAC_DELL_M4_2,
 	STAC_DELL_M4_3,
 	STAC_HP_M4,
 	STAC_HP_DV4,
 	STAC_HP_DV5,
 	STAC_HP_HDX,
 	STAC_92HD71BXX_HP,
 	STAC_92HD71BXX_NO_DMIC,
 	STAC_92HD71BXX_NO_SMUX,
 	STAC_92HD71BXX_MODELS
 };
 enum {
 	STAC_92HD95_HP_LED,
 	STAC_92HD95_HP_BASS,
 	STAC_92HD95_MODELS
 };
 enum {
 	STAC_925x_REF,
 	STAC_M1,
 	STAC_M1_2,
 	STAC_M2,
 	STAC_M2_2,
 	STAC_M3,
 	STAC_M5,
 	STAC_M6,
 	STAC_925x_MODELS
 };
 enum {
 	STAC_D945_REF,
 	STAC_D945GTP3,
 	STAC_D945GTP5,
 	STAC_INTEL_MAC_V1,
 	STAC_INTEL_MAC_V2,
 	STAC_INTEL_MAC_V3,
 	STAC_INTEL_MAC_V4,
 	STAC_INTEL_MAC_V5,
 	STAC_INTEL_MAC_AUTO,
 	STAC_ECS_202,
 	STAC_922X_DELL_D81,
 	STAC_922X_DELL_D82,
 	STAC_922X_DELL_M81,
 	STAC_922X_DELL_M82,
 	STAC_922X_INTEL_MAC_GPIO,
 	STAC_922X_MODELS
 };
 enum {
 	STAC_D965_REF_NO_JD, /* no jack-detection */
 	STAC_D965_REF,
 	STAC_D965_3ST,
 	STAC_D965_5ST,
 	STAC_D965_5ST_NO_FP,
 	STAC_D965_VERBS,
 	STAC_DELL_3ST,
 	STAC_DELL_BIOS,
 	STAC_DELL_BIOS_AMIC,
 	STAC_DELL_BIOS_SPDIF,
 	STAC_927X_DELL_DMIC,
 	STAC_927X_VOLKNOB,
 	STAC_927X_MODELS
 };
 enum {
 	STAC_9872_VAIO,
 	STAC_9872_MODELS
 };
 struct sigmatel_spec {
 	struct hda_gen_spec gen;
 	unsigned int eapd_switch: 1;
 	unsigned int linear_tone_beep:1;
 	unsigned int headset_jack:1; /* 4-pin headset jack (hp + mono mic) */
 	unsigned int volknob_init:1; /* special volume-knob initialization */
 	unsigned int powerdown_adcs:1;
 	unsigned int have_spdif_mux:1;
 	/* gpio lines */
 	unsigned int eapd_mask;
 	unsigned int gpio_mask;
 	unsigned int gpio_dir;
 	unsigned int gpio_data;
 	unsigned int gpio_mute;
 	unsigned int gpio_led;
 	unsigned int gpio_led_polarity;
 	unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */
 	unsigned int vref_led;
 	int default_polarity;
 	unsigned int mic_mute_led_gpio; /* capture mute LED GPIO */
 	unsigned int mic_enabled; /* current mic mute state (bitmask) */
 	/* stream */
 	unsigned int stream_delay;
 	/* analog loopback */
 	const struct snd_kcontrol_new *aloopback_ctl;
 	unsigned int aloopback;
 	unsigned char aloopback_mask;
 	unsigned char aloopback_shift;
 	/* power management */
 	unsigned int power_map_bits;
 	unsigned int num_pwrs;
 	const hda_nid_t *pwr_nids;
 	unsigned int active_adcs;
 	/* beep widgets */
 	hda_nid_t anabeep_nid;
 	/* SPDIF-out mux */
 	const char * const *spdif_labels;
 	struct hda_input_mux spdif_mux;
 	unsigned int cur_smux[2];
 };
 #define AC_VERB_IDT_SET_POWER_MAP	0x7ec
 #define AC_VERB_IDT_GET_POWER_MAP	0xfec
 static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
 	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
 	0x0f, 0x10, 0x11
 };
 static const hda_nid_t stac92hd83xxx_pwr_nids[7] = {
 	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
 	0x0f, 0x10
 };
 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
 	0x0a, 0x0d, 0x0f
 };
 /*
  * PCM hooks
  */
 static void stac_playback_pcm_hook(struct hda_pcm_stream *hinfo,
 				   struct hda_codec *codec,
 				   struct snd_pcm_substream *substream,
 				   int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_GEN_PCM_ACT_OPEN && spec->stream_delay)
 		msleep(spec->stream_delay);
 }
 static void stac_capture_pcm_hook(struct hda_pcm_stream *hinfo,
 				  struct hda_codec *codec,
 				  struct snd_pcm_substream *substream,
 				  int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int i, idx = 0;
 	if (!spec->powerdown_adcs)
 		return;
 	for (i = 0; i < spec->gen.num_all_adcs; i++) {
 		if (spec->gen.all_adcs[i] == hinfo->nid) {
 			idx = i;
 			break;
 		}
 	}
 	switch (action) {
 	case HDA_GEN_PCM_ACT_OPEN:
 		msleep(40);
 		snd_hda_codec_write(codec, hinfo->nid, 0,
 				    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 		spec->active_adcs |= (1 << idx);
 		break;
 	case HDA_GEN_PCM_ACT_CLOSE:
 		snd_hda_codec_write(codec, hinfo->nid, 0,
 				    AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 		spec->active_adcs &= ~(1 << idx);
 		break;
 	}
 }
 /*
  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
  * funky external mute control using GPIO pins.
  */
 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
 			  unsigned int dir_mask, unsigned int data)
 {
 	unsigned int gpiostate, gpiomask, gpiodir;
 	codec_dbg(codec, "%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
 	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
 				       AC_VERB_GET_GPIO_DATA, 0);
 	gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
 	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
 				      AC_VERB_GET_GPIO_MASK, 0);
 	gpiomask |= mask;
 	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
 				     AC_VERB_GET_GPIO_DIRECTION, 0);
 	gpiodir |= dir_mask;
 	/* Configure GPIOx as CMOS */
 	snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
 	snd_hda_codec_write(codec, codec->afg, 0,
 			    AC_VERB_SET_GPIO_MASK, gpiomask);
 	snd_hda_codec_read(codec, codec->afg, 0,
 			   AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
 	msleep(1);
 	snd_hda_codec_read(codec, codec->afg, 0,
 			   AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
 }
 /* hook for controlling mic-mute LED GPIO */
 static void stac_capture_led_hook(struct hda_codec *codec,
 				  struct snd_kcontrol *kcontrol,
 				  struct snd_ctl_elem_value *ucontrol)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int mask;
 	bool cur_mute, prev_mute;
 	if (!kcontrol || !ucontrol)
 		return;
 	mask = 1U << snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	prev_mute = !spec->mic_enabled;
 	if (ucontrol->value.integer.value[0] ||
 	    ucontrol->value.integer.value[1])
 		spec->mic_enabled |= mask;
 	else
 		spec->mic_enabled &= ~mask;
 	cur_mute = !spec->mic_enabled;
 	if (cur_mute != prev_mute) {
 		if (cur_mute)
 			spec->gpio_data |= spec->mic_mute_led_gpio;
 		else
 			spec->gpio_data &= ~spec->mic_mute_led_gpio;
 		stac_gpio_set(codec, spec->gpio_mask,
 			      spec->gpio_dir, spec->gpio_data);
 	}
 }
 static int stac_vrefout_set(struct hda_codec *codec,
 					hda_nid_t nid, unsigned int new_vref)
 {
 	int error, pinctl;
 	codec_dbg(codec, "%s, nid %x ctl %x\n", __func__, nid, new_vref);
 	pinctl = snd_hda_codec_read(codec, nid, 0,
 				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 	if (pinctl < 0)
 		return pinctl;
 	pinctl &= 0xff;
 	pinctl &= ~AC_PINCTL_VREFEN;
 	pinctl |= (new_vref & AC_PINCTL_VREFEN);
 	error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
 	if (error < 0)
 		return error;
 	return 1;
 }
 /* prevent codec AFG to D3 state when vref-out pin is used for mute LED */
 /* this hook is set in stac_setup_gpio() */
 static unsigned int stac_vref_led_power_filter(struct hda_codec *codec,
 					       hda_nid_t nid,
 					       unsigned int power_state)
 {
 	if (nid == codec->afg && power_state == AC_PWRST_D3)
 		return AC_PWRST_D1;
 	return snd_hda_gen_path_power_filter(codec, nid, power_state);
 }
 /* update mute-LED accoring to the master switch */
 static void stac_update_led_status(struct hda_codec *codec, int enabled)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int muted = !enabled;
 	if (!spec->gpio_led)
 		return;
 	/* LED state is inverted on these systems */
 	if (spec->gpio_led_polarity)
 		muted = !muted;
 	if (!spec->vref_mute_led_nid) {
 		if (muted)
 			spec->gpio_data |= spec->gpio_led;
 		else
 			spec->gpio_data &= ~spec->gpio_led;
 		stac_gpio_set(codec, spec->gpio_mask,
 				spec->gpio_dir, spec->gpio_data);
 	} else {
 		spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD;
 		stac_vrefout_set(codec,	spec->vref_mute_led_nid,
 				 spec->vref_led);
 	}
 }
 /* vmaster hook to update mute LED */
 static void stac_vmaster_hook(void *private_data, int val)
 {
 	stac_update_led_status(private_data, val);
 }
 /* automute hook to handle GPIO mute and EAPD updates */
 static void stac_update_outputs(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (spec->gpio_mute)
 		spec->gen.master_mute =
 			!(snd_hda_codec_read(codec, codec->afg, 0,
 				AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
 	snd_hda_gen_update_outputs(codec);
 	if (spec->eapd_mask && spec->eapd_switch) {
 		unsigned int val = spec->gpio_data;
 		if (spec->gen.speaker_muted)
 			val &= ~spec->eapd_mask;
 		else
 			val |= spec->eapd_mask;
 		if (spec->gpio_data != val) {
 			spec->gpio_data = val;
 			stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir,
 				      val);
 		}
 	}
 }
 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
 				  bool enable, bool do_write)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int idx, val;
 	for (idx = 0; idx < spec->num_pwrs; idx++) {
 		if (spec->pwr_nids[idx] == nid)
 			break;
 	}
 	if (idx >= spec->num_pwrs)
 		return;
 	idx = 1 << idx;
 	val = spec->power_map_bits;
 	if (enable)
 		val &= ~idx;
 	else
 		val |= idx;
 	/* power down unused output ports */
 	if (val != spec->power_map_bits) {
 		spec->power_map_bits = val;
 		if (do_write)
 			snd_hda_codec_write(codec, codec->afg, 0,
 					    AC_VERB_IDT_SET_POWER_MAP, val);
 	}
 }
 /* update power bit per jack plug/unplug */
 static void jack_update_power(struct hda_codec *codec,
 			      struct hda_jack_callback *jack)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int i;
 	if (!spec->num_pwrs)
 		return;
 	if (jack && jack->tbl->nid) {
 		stac_toggle_power_map(codec, jack->tbl->nid,
 				      snd_hda_jack_detect(codec, jack->tbl->nid),
 				      true);
 		return;
 	}
 	/* update all jacks */
 	for (i = 0; i < spec->num_pwrs; i++) {
 		hda_nid_t nid = spec->pwr_nids[i];
 		if (!snd_hda_jack_tbl_get(codec, nid))
 			continue;
 		stac_toggle_power_map(codec, nid,
 				      snd_hda_jack_detect(codec, nid),
 				      false);
 	}
 	snd_hda_codec_write(codec, codec->afg, 0, AC_VERB_IDT_SET_POWER_MAP,
 			    spec->power_map_bits);
 }
 static void stac_vref_event(struct hda_codec *codec,
 			    struct hda_jack_callback *event)
 {
 	unsigned int data;
 	data = snd_hda_codec_read(codec, codec->afg, 0,
 				  AC_VERB_GET_GPIO_DATA, 0);
 	/* toggle VREF state based on GPIOx status */
 	snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
 			    !!(data & (1 << event->private_data)));
 }
 /* initialize the power map and enable the power event to jacks that
  * haven't been assigned to automute
  */
 static void stac_init_power_map(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int i;
 	for (i = 0; i < spec->num_pwrs; i++)  {
 		hda_nid_t nid = spec->pwr_nids[i];
 		unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
 		def_conf = get_defcfg_connect(def_conf);
 		if (def_conf == AC_JACK_PORT_COMPLEX &&
 		    spec->vref_mute_led_nid != nid &&
 		    is_jack_detectable(codec, nid)) {
 			snd_hda_jack_detect_enable_callback(codec, nid,
 							    jack_update_power);
 		} else {
 			if (def_conf == AC_JACK_PORT_NONE)
 				stac_toggle_power_map(codec, nid, false, false);
 			else
 				stac_toggle_power_map(codec, nid, true, false);
 		}
 	}
 }
 /*
  */
 static inline bool get_int_hint(struct hda_codec *codec, const char *key,
 				int *valp)
 {
 	return !snd_hda_get_int_hint(codec, key, valp);
 }
 /* override some hints from the hwdep entry */
 static void stac_store_hints(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int val;
 	if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
 		spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
 			spec->gpio_mask;
 	}
 	if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
-		spec->gpio_mask &= spec->gpio_mask;
-	if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
 		spec->gpio_dir &= spec->gpio_mask;
+	if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
+		spec->gpio_data &= spec->gpio_mask;
 	if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
 		spec->eapd_mask &= spec->gpio_mask;
 	if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
 		spec->gpio_mute &= spec->gpio_mask;
 	val = snd_hda_get_bool_hint(codec, "eapd_switch");
 	if (val >= 0)
 		spec->eapd_switch = val;
 }
 /*
  * loopback controls
  */
 #define stac_aloopback_info snd_ctl_boolean_mono_info
 static int stac_aloopback_get(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	struct sigmatel_spec *spec = codec->spec;
 	ucontrol->value.integer.value[0] = !!(spec->aloopback &
 					      (spec->aloopback_mask << idx));
 	return 0;
 }
 static int stac_aloopback_put(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	unsigned int dac_mode;
 	unsigned int val, idx_val;
 	idx_val = spec->aloopback_mask << idx;
 	if (ucontrol->value.integer.value[0])
 		val = spec->aloopback | idx_val;
 	else
 		val = spec->aloopback & ~idx_val;
 	if (spec->aloopback == val)
 		return 0;
 	spec->aloopback = val;
 	/* Only return the bits defined by the shift value of the
 	 * first two bytes of the mask
 	 */
 	dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
 				      kcontrol->private_value & 0xFFFF, 0x0);
 	dac_mode >>= spec->aloopback_shift;
 	if (spec->aloopback & idx_val) {
 		snd_hda_power_up(codec);
 		dac_mode |= idx_val;
 	} else {
 		snd_hda_power_down(codec);
 		dac_mode &= ~idx_val;
 	}
 	snd_hda_codec_write_cache(codec, codec->afg, 0,
 		kcontrol->private_value >> 16, dac_mode);
 	return 1;
 }
 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
 	{ \
 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 		.name  = "Analog Loopback", \
 		.count = cnt, \
 		.info  = stac_aloopback_info, \
 		.get   = stac_aloopback_get, \
 		.put   = stac_aloopback_put, \
 		.private_value = verb_read | (verb_write << 16), \
 	}
 /*
  * Mute LED handling on HP laptops
  */
 /* check whether it's a HP laptop with a docking port */
 static bool hp_bnb2011_with_dock(struct hda_codec *codec)
 {
 	if (codec->vendor_id != 0x111d7605 &&
 	    codec->vendor_id != 0x111d76d1)
 		return false;
 	switch (codec->subsystem_id) {
 	case 0x103c1618:
 	case 0x103c1619:
 	case 0x103c161a:
 	case 0x103c161b:
 	case 0x103c161c:
 	case 0x103c161d:
 	case 0x103c161e:
 	case 0x103c161f:
 	case 0x103c162a:
 	case 0x103c162b:
 	case 0x103c1630:
 	case 0x103c1631:
 	case 0x103c1633:
 	case 0x103c1634:
 	case 0x103c1635:
 	case 0x103c3587:
 	case 0x103c3588:
 	case 0x103c3589:
 	case 0x103c358a:
 	case 0x103c3667:
 	case 0x103c3668:
 	case 0x103c3669:
 		return true;
 	}
 	return false;
 }
 static bool hp_blike_system(u32 subsystem_id)
 {
 	switch (subsystem_id) {
 	case 0x103c1520:
 	case 0x103c1521:
 	case 0x103c1523:
 	case 0x103c1524:
 	case 0x103c1525:
 	case 0x103c1722:
 	case 0x103c1723:
 	case 0x103c1724:
 	case 0x103c1725:
 	case 0x103c1726:
 	case 0x103c1727:
 	case 0x103c1728:
 	case 0x103c1729:
 	case 0x103c172a:
 	case 0x103c172b:
 	case 0x103c307e:
 	case 0x103c307f:
 	case 0x103c3080:
 	case 0x103c3081:
 	case 0x103c7007:
 	case 0x103c7008:
 		return true;
 	}
 	return false;
 }
 static void set_hp_led_gpio(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int gpio;
 	if (spec->gpio_led)
 		return;
 	gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
 	gpio &= AC_GPIO_IO_COUNT;
 	if (gpio > 3)
 		spec->gpio_led = 0x08; /* GPIO 3 */
 	else
 		spec->gpio_led = 0x01; /* GPIO 0 */
 }
 /*
  * This method searches for the mute LED GPIO configuration
  * provided as OEM string in SMBIOS. The format of that string
  * is HP_Mute_LED_P_G or HP_Mute_LED_P
  * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
  * that corresponds to the NOT muted state of the master volume
  * and G is the index of the GPIO to use as the mute LED control (0..9)
  * If _G portion is missing it is assigned based on the codec ID
  *
  * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
  * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
  *
  *
  * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
  * SMBIOS - at least the ones I have seen do not have them - which include
  * my own system (HP Pavilion dv6-1110ax) and my cousin's
  * HP Pavilion dv9500t CTO.
  * Need more information on whether it is true across the entire series.
  * -- kunal
  */
 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	const struct dmi_device *dev = NULL;
 	if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
 		get_int_hint(codec, "gpio_led_polarity",
 			     &spec->gpio_led_polarity);
 		return 1;
 	}
 	while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
 		if (sscanf(dev->name, "HP_Mute_LED_%u_%x",
 			   &spec->gpio_led_polarity,
 			   &spec->gpio_led) == 2) {
 			unsigned int max_gpio;
 			max_gpio = snd_hda_param_read(codec, codec->afg,
 						      AC_PAR_GPIO_CAP);
 			max_gpio &= AC_GPIO_IO_COUNT;
 			if (spec->gpio_led < max_gpio)
 				spec->gpio_led = 1 << spec->gpio_led;
 			else
 				spec->vref_mute_led_nid = spec->gpio_led;
 			return 1;
 		}
 		if (sscanf(dev->name, "HP_Mute_LED_%u",
 			   &spec->gpio_led_polarity) == 1) {
 			set_hp_led_gpio(codec);
 			return 1;
 		}
 		/* BIOS bug: unfilled OEM string */
 		if (strstr(dev->name, "HP_Mute_LED_P_G")) {
 			set_hp_led_gpio(codec);
 			if (default_polarity >= 0)
 				spec->gpio_led_polarity = default_polarity;
 			else
 				spec->gpio_led_polarity = 1;
 			return 1;
 		}
 	}
 	/*
 	 * Fallback case - if we don't find the DMI strings,
 	 * we statically set the GPIO - if not a B-series system
 	 * and default polarity is provided
 	 */
 	if (!hp_blike_system(codec->subsystem_id) &&
 	    (default_polarity == 0 || default_polarity == 1)) {
 		set_hp_led_gpio(codec);
 		spec->gpio_led_polarity = default_polarity;
 		return 1;
 	}
 	return 0;
 }
 /* check whether a built-in speaker is included in parsed pins */
 static bool has_builtin_speaker(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	hda_nid_t *nid_pin;
 	int nids, i;
 	if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) {
 		nid_pin = spec->gen.autocfg.line_out_pins;
 		nids = spec->gen.autocfg.line_outs;
 	} else {
 		nid_pin = spec->gen.autocfg.speaker_pins;
 		nids = spec->gen.autocfg.speaker_outs;
 	}
 	for (i = 0; i < nids; i++) {
 		unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid_pin[i]);
 		if (snd_hda_get_input_pin_attr(def_conf) == INPUT_PIN_ATTR_INT)
 			return true;
 	}
 	return false;
 }
 /*
  * PC beep controls
  */
 /* create PC beep volume controls */
 static int stac_auto_create_beep_ctls(struct hda_codec *codec,
 						hda_nid_t nid)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
 	struct snd_kcontrol_new *knew;
 	static struct snd_kcontrol_new abeep_mute_ctl =
 		HDA_CODEC_MUTE(NULL, 0, 0, 0);
 	static struct snd_kcontrol_new dbeep_mute_ctl =
 		HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0);
 	static struct snd_kcontrol_new beep_vol_ctl =
 		HDA_CODEC_VOLUME(NULL, 0, 0, 0);
 	/* check for mute support for the the amp */
 	if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
 		const struct snd_kcontrol_new *temp;
 		if (spec->anabeep_nid == nid)
 			temp = &abeep_mute_ctl;
 		else
 			temp = &dbeep_mute_ctl;
 		knew = snd_hda_gen_add_kctl(&spec->gen,
 					    "Beep Playback Switch", temp);
 		if (!knew)
 			return -ENOMEM;
 		knew->private_value =
 			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT);
 	}
 	/* check to see if there is volume support for the amp */
 	if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
 		knew = snd_hda_gen_add_kctl(&spec->gen,
 					    "Beep Playback Volume",
 					    &beep_vol_ctl);
 		if (!knew)
 			return -ENOMEM;
 		knew->private_value =
 			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT);
 	}
 	return 0;
 }
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 #define stac_dig_beep_switch_info snd_ctl_boolean_mono_info
 static int stac_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
 				    struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	ucontrol->value.integer.value[0] = codec->beep->enabled;
 	return 0;
 }
 static int stac_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
 				    struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
 }
 static const struct snd_kcontrol_new stac_dig_beep_ctrl = {
 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 	.name = "Beep Playback Switch",
 	.info = stac_dig_beep_switch_info,
 	.get = stac_dig_beep_switch_get,
 	.put = stac_dig_beep_switch_put,
 };
 static int stac_beep_switch_ctl(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &stac_dig_beep_ctrl))
 		return -ENOMEM;
 	return 0;
 }
 #endif
 /*
  * SPDIF-out mux controls
  */
 static int stac_smux_enum_info(struct snd_kcontrol *kcontrol,
 			       struct snd_ctl_elem_info *uinfo)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	return snd_hda_input_mux_info(&spec->spdif_mux, uinfo);
 }
 static int stac_smux_enum_get(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
 	return 0;
 }
 static int stac_smux_enum_put(struct snd_kcontrol *kcontrol,
 			      struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 	return snd_hda_input_mux_put(codec, &spec->spdif_mux, ucontrol,
 				     spec->gen.autocfg.dig_out_pins[smux_idx],
 				     &spec->cur_smux[smux_idx]);
 }
 static struct snd_kcontrol_new stac_smux_mixer = {
 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 	.name = "IEC958 Playback Source",
 	/* count set later */
 	.info = stac_smux_enum_info,
 	.get = stac_smux_enum_get,
 	.put = stac_smux_enum_put,
 };
 static const char * const stac_spdif_labels[] = {
 	"Digital Playback", "Analog Mux 1", "Analog Mux 2", NULL
 };
 static int stac_create_spdif_mux_ctls(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 	const char * const *labels = spec->spdif_labels;
 	struct snd_kcontrol_new *kctl;
 	int i, num_cons;
 	if (cfg->dig_outs < 1)
 		return 0;
 	num_cons = snd_hda_get_num_conns(codec, cfg->dig_out_pins[0]);
 	if (num_cons <= 1)
 		return 0;
 	if (!labels)
 		labels = stac_spdif_labels;
 	for (i = 0; i < num_cons; i++) {
 		if (snd_BUG_ON(!labels[i]))
 			return -EINVAL;
 		snd_hda_add_imux_item(codec, &spec->spdif_mux, labels[i], i, NULL);
 	}
 	kctl = snd_hda_gen_add_kctl(&spec->gen, NULL, &stac_smux_mixer);
 	if (!kctl)
 		return -ENOMEM;
 	kctl->count = cfg->dig_outs;
 	return 0;
 }
 /*
  */
 static const struct hda_verb stac9200_core_init[] = {
 	/* set dac0mux for dac converter */
 	{ 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 	{}
 };
 static const struct hda_verb stac9200_eapd_init[] = {
 	/* set dac0mux for dac converter */
 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 	{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 	{}
 };
 static const struct hda_verb dell_eq_core_init[] = {
 	/* set master volume to max value without distortion
 	 * and direct control */
 	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
 	{}
 };
 static const struct hda_verb stac92hd73xx_core_init[] = {
 	/* set master volume and direct control */
 	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 	{}
 };
 static const struct hda_verb stac92hd83xxx_core_init[] = {
 	/* power state controls amps */
 	{ 0x01, AC_VERB_SET_EAPD, 1 << 2},
 	{}
 };
 static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = {
 	{ 0x22, 0x785, 0x43 },
 	{ 0x22, 0x782, 0xe0 },
 	{ 0x22, 0x795, 0x00 },
 	{}
 };
 static const struct hda_verb stac92hd71bxx_core_init[] = {
 	/* set master volume and direct control */
 	{ 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 	{}
 };
 static const struct hda_verb stac92hd71bxx_unmute_core_init[] = {
 	/* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
 	{ 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 	{ 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 	{}
 };
 static const struct hda_verb stac925x_core_init[] = {
 	/* set dac0mux for dac converter */
 	{ 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
 	/* mute the master volume */
 	{ 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 	{}
 };
 static const struct hda_verb stac922x_core_init[] = {
 	/* set master volume and direct control */
 	{ 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 	{}
 };
 static const struct hda_verb d965_core_init[] = {
 	/* unmute node 0x1b */
 	{ 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 	/* select node 0x03 as DAC */
 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 	{}
 };
 static const struct hda_verb dell_3st_core_init[] = {
 	/* don't set delta bit */
 	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
 	/* unmute node 0x1b */
 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 	/* select node 0x03 as DAC */
 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 	{}
 };
 static const struct hda_verb stac927x_core_init[] = {
 	/* set master volume and direct control */
 	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 	/* enable analog pc beep path */
 	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 	{}
 };
 static const struct hda_verb stac927x_volknob_core_init[] = {
 	/* don't set delta bit */
 	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
 	/* enable analog pc beep path */
 	{0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 	{}
 };
 static const struct hda_verb stac9205_core_init[] = {
 	/* set master volume and direct control */
 	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 	/* enable analog pc beep path */
 	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 	{}
 };
 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback =
 	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3);
 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback =
 	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4);
 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback =
 	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5);
 static const struct snd_kcontrol_new stac92hd71bxx_loopback =
 	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2);
 static const struct snd_kcontrol_new stac9205_loopback =
 	STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1);
 static const struct snd_kcontrol_new stac927x_loopback =
 	STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1);
 static const struct hda_pintbl ref9200_pin_configs[] = {
 	{ 0x08, 0x01c47010 },
 	{ 0x09, 0x01447010 },
 	{ 0x0d, 0x0221401f },
 	{ 0x0e, 0x01114010 },
 	{ 0x0f, 0x02a19020 },
 	{ 0x10, 0x01a19021 },
 	{ 0x11, 0x90100140 },
 	{ 0x12, 0x01813122 },
 	{}
 };
 static const struct hda_pintbl gateway9200_m4_pin_configs[] = {
 	{ 0x08, 0x400000fe },
 	{ 0x09, 0x404500f4 },
 	{ 0x0d, 0x400100f0 },
 	{ 0x0e, 0x90110010 },
 	{ 0x0f, 0x400100f1 },
 	{ 0x10, 0x02a1902e },
 	{ 0x11, 0x500000f2 },
 	{ 0x12, 0x500000f3 },
 	{}
 };
 static const struct hda_pintbl gateway9200_m4_2_pin_configs[] = {
 	{ 0x08, 0x400000fe },
 	{ 0x09, 0x404500f4 },
 	{ 0x0d, 0x400100f0 },
 	{ 0x0e, 0x90110010 },
 	{ 0x0f, 0x400100f1 },
 	{ 0x10, 0x02a1902e },
 	{ 0x11, 0x500000f2 },
 	{ 0x12, 0x500000f3 },
 	{}
 };
 /*
     STAC 9200 pin configs for
     102801A8
     102801DE
     102801E8
 */
 static const struct hda_pintbl dell9200_d21_pin_configs[] = {
 	{ 0x08, 0x400001f0 },
 	{ 0x09, 0x400001f1 },
 	{ 0x0d, 0x02214030 },
 	{ 0x0e, 0x01014010 },
 	{ 0x0f, 0x02a19020 },
 	{ 0x10, 0x01a19021 },
 	{ 0x11, 0x90100140 },
 	{ 0x12, 0x01813122 },
 	{}
 };
 /*
     STAC 9200 pin configs for
     102801C0
     102801C1
 */
 static const struct hda_pintbl dell9200_d22_pin_configs[] = {
 	{ 0x08, 0x400001f0 },
 	{ 0x09, 0x400001f1 },
 	{ 0x0d, 0x0221401f },
 	{ 0x0e, 0x01014010 },
 	{ 0x0f, 0x01813020 },
 	{ 0x10, 0x02a19021 },
 	{ 0x11, 0x90100140 },
 	{ 0x12, 0x400001f2 },
 	{}
 };
 /*
     STAC 9200 pin configs for
     102801C4 (Dell Dimension E310)
     102801C5
     102801C7
     102801D9
     102801DA
     102801E3
 */
 static const struct hda_pintbl dell9200_d23_pin_configs[] = {
 	{ 0x08, 0x400001f0 },
 	{ 0x09, 0x400001f1 },
 	{ 0x0d, 0x0221401f },
 	{ 0x0e, 0x01014010 },
 	{ 0x0f, 0x01813020 },
 	{ 0x10, 0x01a19021 },
 	{ 0x11, 0x90100140 },
 	{ 0x12, 0x400001f2 },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801B5 (Dell Inspiron 630m)
     102801D8 (Dell Inspiron 640m)
 */
 static const struct hda_pintbl dell9200_m21_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x03441340 },
 	{ 0x0d, 0x0321121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x408003fb },
 	{ 0x10, 0x03a11020 },
 	{ 0x11, 0x401003fc },
 	{ 0x12, 0x403003fd },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801C2 (Dell Latitude D620)
     102801C8
     102801CC (Dell Latitude D820)
     102801D4
     102801D6
 */
 static const struct hda_pintbl dell9200_m22_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x0144131f },
 	{ 0x0d, 0x0321121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x90a70321 },
 	{ 0x10, 0x03a11020 },
 	{ 0x11, 0x401003fb },
 	{ 0x12, 0x40f000fc },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801CE (Dell XPS M1710)
     102801CF (Dell Precision M90)
 */
 static const struct hda_pintbl dell9200_m23_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x01441340 },
 	{ 0x0d, 0x0421421f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x408003fb },
 	{ 0x10, 0x04a1102e },
 	{ 0x11, 0x90170311 },
 	{ 0x12, 0x403003fc },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801C9
     102801CA
     102801CB (Dell Latitude 120L)
     102801D3
 */
 static const struct hda_pintbl dell9200_m24_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x404003fb },
 	{ 0x0d, 0x0321121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x408003fc },
 	{ 0x10, 0x03a11020 },
 	{ 0x11, 0x401003fd },
 	{ 0x12, 0x403003fe },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801BD (Dell Inspiron E1505n)
     102801EE
     102801EF
 */
 static const struct hda_pintbl dell9200_m25_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x01441340 },
 	{ 0x0d, 0x0421121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x408003fb },
 	{ 0x10, 0x04a11020 },
 	{ 0x11, 0x401003fc },
 	{ 0x12, 0x403003fd },
 	{}
 };
 /*
     STAC 9200-32 pin configs for
     102801F5 (Dell Inspiron 1501)
     102801F6
 */
 static const struct hda_pintbl dell9200_m26_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x404003fb },
 	{ 0x0d, 0x0421121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x408003fc },
 	{ 0x10, 0x04a11020 },
 	{ 0x11, 0x401003fd },
 	{ 0x12, 0x403003fe },
 	{}
 };
 /*
     STAC 9200-32
     102801CD (Dell Inspiron E1705/9400)
 */
 static const struct hda_pintbl dell9200_m27_pin_configs[] = {
 	{ 0x08, 0x40c003fa },
 	{ 0x09, 0x01441340 },
 	{ 0x0d, 0x0421121f },
 	{ 0x0e, 0x90170310 },
 	{ 0x0f, 0x90170310 },
 	{ 0x10, 0x04a11020 },
 	{ 0x11, 0x90170310 },
 	{ 0x12, 0x40f003fc },
 	{}
 };
 static const struct hda_pintbl oqo9200_pin_configs[] = {
 	{ 0x08, 0x40c000f0 },
 	{ 0x09, 0x404000f1 },
 	{ 0x0d, 0x0221121f },
 	{ 0x0e, 0x02211210 },
 	{ 0x0f, 0x90170111 },
 	{ 0x10, 0x90a70120 },
 	{ 0x11, 0x400000f2 },
 	{ 0x12, 0x400000f3 },
 	{}
 };
 static void stac9200_fixup_panasonic(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gpio_mask = spec->gpio_dir = 0x09;
 		spec->gpio_data = 0x00;
 		/* CF-74 has no headphone detection, and the driver should *NOT*
 		 * do detection and HP/speaker toggle because the hardware does it.
 		 */
 		spec->gen.suppress_auto_mute = 1;
 	}
 }
 static const struct hda_fixup stac9200_fixups[] = {
 	[STAC_REF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ref9200_pin_configs,
 	},
 	[STAC_9200_OQO] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = oqo9200_pin_configs,
 		.chained = true,
 		.chain_id = STAC_9200_EAPD_INIT,
 	},
 	[STAC_9200_DELL_D21] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_d21_pin_configs,
 	},
 	[STAC_9200_DELL_D22] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_d22_pin_configs,
 	},
 	[STAC_9200_DELL_D23] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_d23_pin_configs,
 	},
 	[STAC_9200_DELL_M21] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m21_pin_configs,
 	},
 	[STAC_9200_DELL_M22] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m22_pin_configs,
 	},
 	[STAC_9200_DELL_M23] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m23_pin_configs,
 	},
 	[STAC_9200_DELL_M24] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m24_pin_configs,
 	},
 	[STAC_9200_DELL_M25] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m25_pin_configs,
 	},
 	[STAC_9200_DELL_M26] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m26_pin_configs,
 	},
 	[STAC_9200_DELL_M27] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell9200_m27_pin_configs,
 	},
 	[STAC_9200_M4] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = gateway9200_m4_pin_configs,
 		.chained = true,
 		.chain_id = STAC_9200_EAPD_INIT,
 	},
 	[STAC_9200_M4_2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = gateway9200_m4_2_pin_configs,
 		.chained = true,
 		.chain_id = STAC_9200_EAPD_INIT,
 	},
 	[STAC_9200_PANASONIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac9200_fixup_panasonic,
 	},
 	[STAC_9200_EAPD_INIT] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 			{}
 		},
 	},
 };
 static const struct hda_model_fixup stac9200_models[] = {
 	{ .id = STAC_REF, .name = "ref" },
 	{ .id = STAC_9200_OQO, .name = "oqo" },
 	{ .id = STAC_9200_DELL_D21, .name = "dell-d21" },
 	{ .id = STAC_9200_DELL_D22, .name = "dell-d22" },
 	{ .id = STAC_9200_DELL_D23, .name = "dell-d23" },
 	{ .id = STAC_9200_DELL_M21, .name = "dell-m21" },
 	{ .id = STAC_9200_DELL_M22, .name = "dell-m22" },
 	{ .id = STAC_9200_DELL_M23, .name = "dell-m23" },
 	{ .id = STAC_9200_DELL_M24, .name = "dell-m24" },
 	{ .id = STAC_9200_DELL_M25, .name = "dell-m25" },
 	{ .id = STAC_9200_DELL_M26, .name = "dell-m26" },
 	{ .id = STAC_9200_DELL_M27, .name = "dell-m27" },
 	{ .id = STAC_9200_M4, .name = "gateway-m4" },
 	{ .id = STAC_9200_M4_2, .name = "gateway-m4-2" },
 	{ .id = STAC_9200_PANASONIC, .name = "panasonic" },
 	{}
 };
 static const struct snd_pci_quirk stac9200_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_REF),
 	/* Dell laptops have BIOS problem */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
 		      "unknown Dell", STAC_9200_DELL_D21),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
 		      "Dell Inspiron 630m", STAC_9200_DELL_M21),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
 		      "Dell Inspiron E1505n", STAC_9200_DELL_M25),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
 		      "unknown Dell", STAC_9200_DELL_D22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
 		      "unknown Dell", STAC_9200_DELL_D22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
 		      "Dell Latitude D620", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
 		      "unknown Dell", STAC_9200_DELL_D23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
 		      "unknown Dell", STAC_9200_DELL_D23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
 		      "unknown Dell", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
 		      "unknown Dell", STAC_9200_DELL_M24),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
 		      "unknown Dell", STAC_9200_DELL_M24),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
 		      "Dell Latitude 120L", STAC_9200_DELL_M24),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
 		      "Dell Latitude D820", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
 		      "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
 		      "Dell XPS M1710", STAC_9200_DELL_M23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
 		      "Dell Precision M90", STAC_9200_DELL_M23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
 		      "unknown Dell", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
 		      "unknown Dell", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
 		      "unknown Dell", STAC_9200_DELL_M22),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
 		      "Dell Inspiron 640m", STAC_9200_DELL_M21),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
 		      "unknown Dell", STAC_9200_DELL_D23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
 		      "unknown Dell", STAC_9200_DELL_D23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
 		      "unknown Dell", STAC_9200_DELL_D21),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
 		      "unknown Dell", STAC_9200_DELL_D23),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
 		      "unknown Dell", STAC_9200_DELL_D21),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
 		      "unknown Dell", STAC_9200_DELL_M25),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
 		      "unknown Dell", STAC_9200_DELL_M25),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
 		      "Dell Inspiron 1501", STAC_9200_DELL_M26),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
 		      "unknown Dell", STAC_9200_DELL_M26),
 	/* Panasonic */
 	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
 	/* Gateway machines needs EAPD to be set on resume */
 	SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
 	SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
 	SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
 	/* OQO Mobile */
 	SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref925x_pin_configs[] = {
 	{ 0x07, 0x40c003f0 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x01813022 },
 	{ 0x0b, 0x02a19021 },
 	{ 0x0c, 0x90a70320 },
 	{ 0x0d, 0x02214210 },
 	{ 0x10, 0x01019020 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM1_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM1_2_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM2_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM2_2_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM3_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x503303f3 },
 	{}
 };
 static const struct hda_pintbl stac925xM5_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x9033032e },
 	{}
 };
 static const struct hda_pintbl stac925xM6_pin_configs[] = {
 	{ 0x07, 0x40c003f4 },
 	{ 0x08, 0x424503f2 },
 	{ 0x0a, 0x400000f3 },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x40a000f0 },
 	{ 0x0d, 0x90100210 },
 	{ 0x10, 0x400003f1 },
 	{ 0x11, 0x90330320 },
 	{}
 };
 static const struct hda_fixup stac925x_fixups[] = {
 	[STAC_REF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ref925x_pin_configs,
 	},
 	[STAC_M1] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM1_pin_configs,
 	},
 	[STAC_M1_2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM1_2_pin_configs,
 	},
 	[STAC_M2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM2_pin_configs,
 	},
 	[STAC_M2_2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM2_2_pin_configs,
 	},
 	[STAC_M3] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM3_pin_configs,
 	},
 	[STAC_M5] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM5_pin_configs,
 	},
 	[STAC_M6] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac925xM6_pin_configs,
 	},
 };
 static const struct hda_model_fixup stac925x_models[] = {
 	{ .id = STAC_REF, .name = "ref" },
 	{ .id = STAC_M1, .name = "m1" },
 	{ .id = STAC_M1_2, .name = "m1-2" },
 	{ .id = STAC_M2, .name = "m2" },
 	{ .id = STAC_M2_2, .name = "m2-2" },
 	{ .id = STAC_M3, .name = "m3" },
 	{ .id = STAC_M5, .name = "m5" },
 	{ .id = STAC_M6, .name = "m6" },
 	{}
 };
 static const struct snd_pci_quirk stac925x_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
 	SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
 	/* Default table for unknown ID */
 	SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
 	/* gateway machines are checked via codec ssid */
 	SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
 	SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
 	SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
 	SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
 	SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
 	/* Not sure about the brand name for those */
 	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
 	SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
 	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
 	SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x02a19040 },
 	{ 0x0c, 0x01a19020 },
 	{ 0x0d, 0x02214030 },
 	{ 0x0e, 0x0181302e },
 	{ 0x0f, 0x01014010 },
 	{ 0x10, 0x01014020 },
 	{ 0x11, 0x01014030 },
 	{ 0x12, 0x02319040 },
 	{ 0x13, 0x90a000f0 },
 	{ 0x14, 0x90a000f0 },
 	{ 0x22, 0x01452050 },
 	{ 0x23, 0x01452050 },
 	{}
 };
 static const struct hda_pintbl dell_m6_pin_configs[] = {
 	{ 0x0a, 0x0321101f },
 	{ 0x0b, 0x4f00000f },
 	{ 0x0c, 0x4f0000f0 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x03a11020 },
 	{ 0x0f, 0x0321101f },
 	{ 0x10, 0x4f0000f0 },
 	{ 0x11, 0x4f0000f0 },
 	{ 0x12, 0x4f0000f0 },
 	{ 0x13, 0x90a60160 },
 	{ 0x14, 0x4f0000f0 },
 	{ 0x22, 0x4f0000f0 },
 	{ 0x23, 0x4f0000f0 },
 	{}
 };
 static const struct hda_pintbl alienware_m17x_pin_configs[] = {
 	{ 0x0a, 0x0321101f },
 	{ 0x0b, 0x0321101f },
 	{ 0x0c, 0x03a11020 },
 	{ 0x0d, 0x03014020 },
 	{ 0x0e, 0x90170110 },
 	{ 0x0f, 0x4f0000f0 },
 	{ 0x10, 0x4f0000f0 },
 	{ 0x11, 0x4f0000f0 },
 	{ 0x12, 0x4f0000f0 },
 	{ 0x13, 0x90a60160 },
 	{ 0x14, 0x4f0000f0 },
 	{ 0x22, 0x4f0000f0 },
 	{ 0x23, 0x904601b0 },
 	{}
 };
 static const struct hda_pintbl intel_dg45id_pin_configs[] = {
 	{ 0x0a, 0x02214230 },
 	{ 0x0b, 0x02A19240 },
 	{ 0x0c, 0x01013214 },
 	{ 0x0d, 0x01014210 },
 	{ 0x0e, 0x01A19250 },
 	{ 0x0f, 0x01011212 },
 	{ 0x10, 0x01016211 },
 	{}
 };
 static const struct hda_pintbl stac92hd89xx_hp_front_jack_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x02A19010 },
 	{}
 };
 static const struct hda_pintbl stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs[] = {
 	{ 0x0e, 0x400000f0 },
 	{}
 };
 static void stac92hd73xx_fixup_ref(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	snd_hda_apply_pincfgs(codec, ref92hd73xx_pin_configs);
 	spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0;
 }
 static void stac92hd73xx_fixup_dell(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	snd_hda_apply_pincfgs(codec, dell_m6_pin_configs);
 	spec->eapd_switch = 0;
 }
 static void stac92hd73xx_fixup_dell_eq(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	stac92hd73xx_fixup_dell(codec);
 	snd_hda_add_verbs(codec, dell_eq_core_init);
 	spec->volknob_init = 1;
 }
 /* Analog Mics */
 static void stac92hd73xx_fixup_dell_m6_amic(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	stac92hd73xx_fixup_dell(codec);
 	snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
 }
 /* Digital Mics */
 static void stac92hd73xx_fixup_dell_m6_dmic(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	stac92hd73xx_fixup_dell(codec);
 	snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
 }
 /* Both */
 static void stac92hd73xx_fixup_dell_m6_both(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	stac92hd73xx_fixup_dell(codec);
 	snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
 	snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
 }
 static void stac92hd73xx_fixup_alienware_m17x(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	snd_hda_apply_pincfgs(codec, alienware_m17x_pin_configs);
 	spec->eapd_switch = 0;
 }
 static void stac92hd73xx_fixup_no_jd(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		codec->no_jack_detect = 1;
 }
 static const struct hda_fixup stac92hd73xx_fixups[] = {
 	[STAC_92HD73XX_REF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_ref,
 	},
 	[STAC_DELL_M6_AMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_dell_m6_amic,
 	},
 	[STAC_DELL_M6_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_dell_m6_dmic,
 	},
 	[STAC_DELL_M6_BOTH] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_dell_m6_both,
 	},
 	[STAC_DELL_EQ]	= {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_dell_eq,
 	},
 	[STAC_ALIENWARE_M17X] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_alienware_m17x,
 	},
 	[STAC_92HD73XX_INTEL] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_dg45id_pin_configs,
 	},
 	[STAC_92HD73XX_NO_JD] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd73xx_fixup_no_jd,
 	},
 	[STAC_92HD89XX_HP_FRONT_JACK] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac92hd89xx_hp_front_jack_pin_configs,
 	},
 	[STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs,
 	}
 };
 static const struct hda_model_fixup stac92hd73xx_models[] = {
 	{ .id = STAC_92HD73XX_NO_JD, .name = "no-jd" },
 	{ .id = STAC_92HD73XX_REF, .name = "ref" },
 	{ .id = STAC_92HD73XX_INTEL, .name = "intel" },
 	{ .id = STAC_DELL_M6_AMIC, .name = "dell-m6-amic" },
 	{ .id = STAC_DELL_M6_DMIC, .name = "dell-m6-dmic" },
 	{ .id = STAC_DELL_M6_BOTH, .name = "dell-m6" },
 	{ .id = STAC_DELL_EQ, .name = "dell-eq" },
 	{ .id = STAC_ALIENWARE_M17X, .name = "alienware" },
 	{}
 };
 static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 				"DFI LanParty", STAC_92HD73XX_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 				"DFI LanParty", STAC_92HD73XX_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
 				"Intel DG45ID", STAC_92HD73XX_INTEL),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
 				"Intel DG45FC", STAC_92HD73XX_INTEL),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
 				"Dell Studio 1535", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
 				"unknown Dell", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
 				"unknown Dell", STAC_DELL_M6_BOTH),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
 				"unknown Dell", STAC_DELL_M6_BOTH),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
 				"unknown Dell", STAC_DELL_M6_AMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
 				"unknown Dell", STAC_DELL_M6_AMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
 				"unknown Dell", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
 				"unknown Dell", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
 				"Dell Studio 1537", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
 				"Dell Studio 17", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
 				"Dell Studio 1555", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
 				"Dell Studio 1557", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
 				"Dell Studio XPS 1645", STAC_DELL_M6_DMIC),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
 				"Dell Studio 1558", STAC_DELL_M6_DMIC),
 	/* codec SSID matching */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
 		      "Alienware M17x", STAC_ALIENWARE_M17X),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
 		      "Alienware M17x", STAC_ALIENWARE_M17X),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
 		      "Alienware M17x R3", STAC_DELL_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1927,
 				"HP Z1 G2", STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2b17,
 				"unknown HP", STAC_92HD89XX_HP_FRONT_JACK),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref92hd83xxx_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x02211010 },
 	{ 0x0c, 0x02a19020 },
 	{ 0x0d, 0x02170130 },
 	{ 0x0e, 0x01014050 },
 	{ 0x0f, 0x01819040 },
 	{ 0x10, 0x01014020 },
 	{ 0x11, 0x90a3014e },
 	{ 0x1f, 0x01451160 },
 	{ 0x20, 0x98560170 },
 	{}
 };
 static const struct hda_pintbl dell_s14_pin_configs[] = {
 	{ 0x0a, 0x0221403f },
 	{ 0x0b, 0x0221101f },
 	{ 0x0c, 0x02a19020 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x40f000f0 },
 	{ 0x0f, 0x40f000f0 },
 	{ 0x10, 0x40f000f0 },
 	{ 0x11, 0x90a60160 },
 	{ 0x1f, 0x40f000f0 },
 	{ 0x20, 0x40f000f0 },
 	{}
 };
 static const struct hda_pintbl dell_vostro_3500_pin_configs[] = {
 	{ 0x0a, 0x02a11020 },
 	{ 0x0b, 0x0221101f },
 	{ 0x0c, 0x400000f0 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x400000f1 },
 	{ 0x0f, 0x400000f2 },
 	{ 0x10, 0x400000f3 },
 	{ 0x11, 0x90a60160 },
 	{ 0x1f, 0x400000f4 },
 	{ 0x20, 0x400000f5 },
 	{}
 };
 static const struct hda_pintbl hp_dv7_4000_pin_configs[] = {
 	{ 0x0a, 0x03a12050 },
 	{ 0x0b, 0x0321201f },
 	{ 0x0c, 0x40f000f0 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x40f000f0 },
 	{ 0x0f, 0x40f000f0 },
 	{ 0x10, 0x90170110 },
 	{ 0x11, 0xd5a30140 },
 	{ 0x1f, 0x40f000f0 },
 	{ 0x20, 0x40f000f0 },
 	{}
 };
 static const struct hda_pintbl hp_zephyr_pin_configs[] = {
 	{ 0x0a, 0x01813050 },
 	{ 0x0b, 0x0421201f },
 	{ 0x0c, 0x04a1205e },
 	{ 0x0d, 0x96130310 },
 	{ 0x0e, 0x96130310 },
 	{ 0x0f, 0x0101401f },
 	{ 0x10, 0x1111611f },
 	{ 0x11, 0xd5a30130 },
 	{}
 };
 static const struct hda_pintbl hp_cNB11_intquad_pin_configs[] = {
 	{ 0x0a, 0x40f000f0 },
 	{ 0x0b, 0x0221101f },
 	{ 0x0c, 0x02a11020 },
 	{ 0x0d, 0x92170110 },
 	{ 0x0e, 0x40f000f0 },
 	{ 0x0f, 0x92170110 },
 	{ 0x10, 0x40f000f0 },
 	{ 0x11, 0xd5a30130 },
 	{ 0x1f, 0x40f000f0 },
 	{ 0x20, 0x40f000f0 },
 	{}
 };
 static void stac92hd83xxx_fixup_hp(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	if (hp_bnb2011_with_dock(codec)) {
 		snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
 		snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
 	}
 	if (find_mute_led_cfg(codec, spec->default_polarity))
 		codec_dbg(codec, "mute LED gpio %d polarity %d\n",
 				spec->gpio_led,
 				spec->gpio_led_polarity);
 	/* allow auto-switching of dock line-in */
 	spec->gen.line_in_auto_switch = true;
 }
 static void stac92hd83xxx_fixup_hp_zephyr(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	snd_hda_apply_pincfgs(codec, hp_zephyr_pin_configs);
 	snd_hda_add_verbs(codec, stac92hd83xxx_hp_zephyr_init);
 }
 static void stac92hd83xxx_fixup_hp_led(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->default_polarity = 0;
 }
 static void stac92hd83xxx_fixup_hp_inv_led(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->default_polarity = 1;
 }
 static void stac92hd83xxx_fixup_hp_mic_led(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->mic_mute_led_gpio = 0x08; /* GPIO3 */
 		/* resetting controller clears GPIO, so we need to keep on */
 		codec->bus->power_keep_link_on = 1;
 	}
 }
 static void stac92hd83xxx_fixup_hp_led_gpio10(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gpio_led = 0x10; /* GPIO4 */
 		spec->default_polarity = 0;
 	}
 }
 static void stac92hd83xxx_fixup_headset_jack(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->headset_jack = 1;
 }
 static const struct hda_verb hp_bnb13_eq_verbs[] = {
 	/* 44.1KHz base */
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x68 },
 	{ 0x22, 0x7A8, 0x17 },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x68 },
 	{ 0x22, 0x7AB, 0x17 },
 	{ 0x22, 0x7AC, 0x00 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x83 },
 	{ 0x22, 0x7A7, 0x2F },
 	{ 0x22, 0x7A8, 0xD1 },
 	{ 0x22, 0x7A9, 0x83 },
 	{ 0x22, 0x7AA, 0x2F },
 	{ 0x22, 0x7AB, 0xD1 },
 	{ 0x22, 0x7AC, 0x01 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x68 },
 	{ 0x22, 0x7A8, 0x17 },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x68 },
 	{ 0x22, 0x7AB, 0x17 },
 	{ 0x22, 0x7AC, 0x02 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x7C },
 	{ 0x22, 0x7A7, 0xC6 },
 	{ 0x22, 0x7A8, 0x0C },
 	{ 0x22, 0x7A9, 0x7C },
 	{ 0x22, 0x7AA, 0xC6 },
 	{ 0x22, 0x7AB, 0x0C },
 	{ 0x22, 0x7AC, 0x03 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC3 },
 	{ 0x22, 0x7A7, 0x25 },
 	{ 0x22, 0x7A8, 0xAF },
 	{ 0x22, 0x7A9, 0xC3 },
 	{ 0x22, 0x7AA, 0x25 },
 	{ 0x22, 0x7AB, 0xAF },
 	{ 0x22, 0x7AC, 0x04 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x85 },
 	{ 0x22, 0x7A8, 0x73 },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x85 },
 	{ 0x22, 0x7AB, 0x73 },
 	{ 0x22, 0x7AC, 0x05 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x85 },
 	{ 0x22, 0x7A7, 0x39 },
 	{ 0x22, 0x7A8, 0xC7 },
 	{ 0x22, 0x7A9, 0x85 },
 	{ 0x22, 0x7AA, 0x39 },
 	{ 0x22, 0x7AB, 0xC7 },
 	{ 0x22, 0x7AC, 0x06 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3C },
 	{ 0x22, 0x7A7, 0x90 },
 	{ 0x22, 0x7A8, 0xB0 },
 	{ 0x22, 0x7A9, 0x3C },
 	{ 0x22, 0x7AA, 0x90 },
 	{ 0x22, 0x7AB, 0xB0 },
 	{ 0x22, 0x7AC, 0x07 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x7A },
 	{ 0x22, 0x7A7, 0xC6 },
 	{ 0x22, 0x7A8, 0x39 },
 	{ 0x22, 0x7A9, 0x7A },
 	{ 0x22, 0x7AA, 0xC6 },
 	{ 0x22, 0x7AB, 0x39 },
 	{ 0x22, 0x7AC, 0x08 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC4 },
 	{ 0x22, 0x7A7, 0xE9 },
 	{ 0x22, 0x7A8, 0xDC },
 	{ 0x22, 0x7A9, 0xC4 },
 	{ 0x22, 0x7AA, 0xE9 },
 	{ 0x22, 0x7AB, 0xDC },
 	{ 0x22, 0x7AC, 0x09 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3D },
 	{ 0x22, 0x7A7, 0xE1 },
 	{ 0x22, 0x7A8, 0x0D },
 	{ 0x22, 0x7A9, 0x3D },
 	{ 0x22, 0x7AA, 0xE1 },
 	{ 0x22, 0x7AB, 0x0D },
 	{ 0x22, 0x7AC, 0x0A },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x89 },
 	{ 0x22, 0x7A7, 0xB6 },
 	{ 0x22, 0x7A8, 0xEB },
 	{ 0x22, 0x7A9, 0x89 },
 	{ 0x22, 0x7AA, 0xB6 },
 	{ 0x22, 0x7AB, 0xEB },
 	{ 0x22, 0x7AC, 0x0B },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x39 },
 	{ 0x22, 0x7A7, 0x9D },
 	{ 0x22, 0x7A8, 0xFE },
 	{ 0x22, 0x7A9, 0x39 },
 	{ 0x22, 0x7AA, 0x9D },
 	{ 0x22, 0x7AB, 0xFE },
 	{ 0x22, 0x7AC, 0x0C },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x76 },
 	{ 0x22, 0x7A7, 0x49 },
 	{ 0x22, 0x7A8, 0x15 },
 	{ 0x22, 0x7A9, 0x76 },
 	{ 0x22, 0x7AA, 0x49 },
 	{ 0x22, 0x7AB, 0x15 },
 	{ 0x22, 0x7AC, 0x0D },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC8 },
 	{ 0x22, 0x7A7, 0x80 },
 	{ 0x22, 0x7A8, 0xF5 },
 	{ 0x22, 0x7A9, 0xC8 },
 	{ 0x22, 0x7AA, 0x80 },
 	{ 0x22, 0x7AB, 0xF5 },
 	{ 0x22, 0x7AC, 0x0E },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x0F },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x90 },
 	{ 0x22, 0x7A7, 0x68 },
 	{ 0x22, 0x7A8, 0xF1 },
 	{ 0x22, 0x7A9, 0x90 },
 	{ 0x22, 0x7AA, 0x68 },
 	{ 0x22, 0x7AB, 0xF1 },
 	{ 0x22, 0x7AC, 0x10 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x34 },
 	{ 0x22, 0x7A7, 0x47 },
 	{ 0x22, 0x7A8, 0x6C },
 	{ 0x22, 0x7A9, 0x34 },
 	{ 0x22, 0x7AA, 0x47 },
 	{ 0x22, 0x7AB, 0x6C },
 	{ 0x22, 0x7AC, 0x11 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x6F },
 	{ 0x22, 0x7A7, 0x97 },
 	{ 0x22, 0x7A8, 0x0F },
 	{ 0x22, 0x7A9, 0x6F },
 	{ 0x22, 0x7AA, 0x97 },
 	{ 0x22, 0x7AB, 0x0F },
 	{ 0x22, 0x7AC, 0x12 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xCB },
 	{ 0x22, 0x7A7, 0xB8 },
 	{ 0x22, 0x7A8, 0x94 },
 	{ 0x22, 0x7A9, 0xCB },
 	{ 0x22, 0x7AA, 0xB8 },
 	{ 0x22, 0x7AB, 0x94 },
 	{ 0x22, 0x7AC, 0x13 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x14 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x95 },
 	{ 0x22, 0x7A7, 0x76 },
 	{ 0x22, 0x7A8, 0x5B },
 	{ 0x22, 0x7A9, 0x95 },
 	{ 0x22, 0x7AA, 0x76 },
 	{ 0x22, 0x7AB, 0x5B },
 	{ 0x22, 0x7AC, 0x15 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x31 },
 	{ 0x22, 0x7A7, 0xAC },
 	{ 0x22, 0x7A8, 0x31 },
 	{ 0x22, 0x7A9, 0x31 },
 	{ 0x22, 0x7AA, 0xAC },
 	{ 0x22, 0x7AB, 0x31 },
 	{ 0x22, 0x7AC, 0x16 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x6A },
 	{ 0x22, 0x7A7, 0x89 },
 	{ 0x22, 0x7A8, 0xA5 },
 	{ 0x22, 0x7A9, 0x6A },
 	{ 0x22, 0x7AA, 0x89 },
 	{ 0x22, 0x7AB, 0xA5 },
 	{ 0x22, 0x7AC, 0x17 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xCE },
 	{ 0x22, 0x7A7, 0x53 },
 	{ 0x22, 0x7A8, 0xCF },
 	{ 0x22, 0x7A9, 0xCE },
 	{ 0x22, 0x7AA, 0x53 },
 	{ 0x22, 0x7AB, 0xCF },
 	{ 0x22, 0x7AC, 0x18 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x19 },
 	{ 0x22, 0x7AD, 0x80 },
 	/* 48KHz base */
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x88 },
 	{ 0x22, 0x7A8, 0xDC },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x88 },
 	{ 0x22, 0x7AB, 0xDC },
 	{ 0x22, 0x7AC, 0x1A },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x82 },
 	{ 0x22, 0x7A7, 0xEE },
 	{ 0x22, 0x7A8, 0x46 },
 	{ 0x22, 0x7A9, 0x82 },
 	{ 0x22, 0x7AA, 0xEE },
 	{ 0x22, 0x7AB, 0x46 },
 	{ 0x22, 0x7AC, 0x1B },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x88 },
 	{ 0x22, 0x7A8, 0xDC },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x88 },
 	{ 0x22, 0x7AB, 0xDC },
 	{ 0x22, 0x7AC, 0x1C },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x7D },
 	{ 0x22, 0x7A7, 0x09 },
 	{ 0x22, 0x7A8, 0x28 },
 	{ 0x22, 0x7A9, 0x7D },
 	{ 0x22, 0x7AA, 0x09 },
 	{ 0x22, 0x7AB, 0x28 },
 	{ 0x22, 0x7AC, 0x1D },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC2 },
 	{ 0x22, 0x7A7, 0xE5 },
 	{ 0x22, 0x7A8, 0xB4 },
 	{ 0x22, 0x7A9, 0xC2 },
 	{ 0x22, 0x7AA, 0xE5 },
 	{ 0x22, 0x7AB, 0xB4 },
 	{ 0x22, 0x7AC, 0x1E },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0xA3 },
 	{ 0x22, 0x7A8, 0x1F },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0xA3 },
 	{ 0x22, 0x7AB, 0x1F },
 	{ 0x22, 0x7AC, 0x1F },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x84 },
 	{ 0x22, 0x7A7, 0xCA },
 	{ 0x22, 0x7A8, 0xF1 },
 	{ 0x22, 0x7A9, 0x84 },
 	{ 0x22, 0x7AA, 0xCA },
 	{ 0x22, 0x7AB, 0xF1 },
 	{ 0x22, 0x7AC, 0x20 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3C },
 	{ 0x22, 0x7A7, 0xD5 },
 	{ 0x22, 0x7A8, 0x9C },
 	{ 0x22, 0x7A9, 0x3C },
 	{ 0x22, 0x7AA, 0xD5 },
 	{ 0x22, 0x7AB, 0x9C },
 	{ 0x22, 0x7AC, 0x21 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x7B },
 	{ 0x22, 0x7A7, 0x35 },
 	{ 0x22, 0x7A8, 0x0F },
 	{ 0x22, 0x7A9, 0x7B },
 	{ 0x22, 0x7AA, 0x35 },
 	{ 0x22, 0x7AB, 0x0F },
 	{ 0x22, 0x7AC, 0x22 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC4 },
 	{ 0x22, 0x7A7, 0x87 },
 	{ 0x22, 0x7A8, 0x45 },
 	{ 0x22, 0x7A9, 0xC4 },
 	{ 0x22, 0x7AA, 0x87 },
 	{ 0x22, 0x7AB, 0x45 },
 	{ 0x22, 0x7AC, 0x23 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3E },
 	{ 0x22, 0x7A7, 0x0A },
 	{ 0x22, 0x7A8, 0x78 },
 	{ 0x22, 0x7A9, 0x3E },
 	{ 0x22, 0x7AA, 0x0A },
 	{ 0x22, 0x7AB, 0x78 },
 	{ 0x22, 0x7AC, 0x24 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x88 },
 	{ 0x22, 0x7A7, 0xE2 },
 	{ 0x22, 0x7A8, 0x05 },
 	{ 0x22, 0x7A9, 0x88 },
 	{ 0x22, 0x7AA, 0xE2 },
 	{ 0x22, 0x7AB, 0x05 },
 	{ 0x22, 0x7AC, 0x25 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x3A },
 	{ 0x22, 0x7A7, 0x1A },
 	{ 0x22, 0x7A8, 0xA3 },
 	{ 0x22, 0x7A9, 0x3A },
 	{ 0x22, 0x7AA, 0x1A },
 	{ 0x22, 0x7AB, 0xA3 },
 	{ 0x22, 0x7AC, 0x26 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x77 },
 	{ 0x22, 0x7A7, 0x1D },
 	{ 0x22, 0x7A8, 0xFB },
 	{ 0x22, 0x7A9, 0x77 },
 	{ 0x22, 0x7AA, 0x1D },
 	{ 0x22, 0x7AB, 0xFB },
 	{ 0x22, 0x7AC, 0x27 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xC7 },
 	{ 0x22, 0x7A7, 0xDA },
 	{ 0x22, 0x7A8, 0xE5 },
 	{ 0x22, 0x7A9, 0xC7 },
 	{ 0x22, 0x7AA, 0xDA },
 	{ 0x22, 0x7AB, 0xE5 },
 	{ 0x22, 0x7AC, 0x28 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x29 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x8E },
 	{ 0x22, 0x7A7, 0xD7 },
 	{ 0x22, 0x7A8, 0x22 },
 	{ 0x22, 0x7A9, 0x8E },
 	{ 0x22, 0x7AA, 0xD7 },
 	{ 0x22, 0x7AB, 0x22 },
 	{ 0x22, 0x7AC, 0x2A },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x35 },
 	{ 0x22, 0x7A7, 0x26 },
 	{ 0x22, 0x7A8, 0xC6 },
 	{ 0x22, 0x7A9, 0x35 },
 	{ 0x22, 0x7AA, 0x26 },
 	{ 0x22, 0x7AB, 0xC6 },
 	{ 0x22, 0x7AC, 0x2B },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x71 },
 	{ 0x22, 0x7A7, 0x28 },
 	{ 0x22, 0x7A8, 0xDE },
 	{ 0x22, 0x7A9, 0x71 },
 	{ 0x22, 0x7AA, 0x28 },
 	{ 0x22, 0x7AB, 0xDE },
 	{ 0x22, 0x7AC, 0x2C },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xCA },
 	{ 0x22, 0x7A7, 0xD9 },
 	{ 0x22, 0x7A8, 0x3A },
 	{ 0x22, 0x7A9, 0xCA },
 	{ 0x22, 0x7AA, 0xD9 },
 	{ 0x22, 0x7AB, 0x3A },
 	{ 0x22, 0x7AC, 0x2D },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x2E },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x93 },
 	{ 0x22, 0x7A7, 0x5E },
 	{ 0x22, 0x7A8, 0xD8 },
 	{ 0x22, 0x7A9, 0x93 },
 	{ 0x22, 0x7AA, 0x5E },
 	{ 0x22, 0x7AB, 0xD8 },
 	{ 0x22, 0x7AC, 0x2F },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x32 },
 	{ 0x22, 0x7A7, 0xB7 },
 	{ 0x22, 0x7A8, 0xB1 },
 	{ 0x22, 0x7A9, 0x32 },
 	{ 0x22, 0x7AA, 0xB7 },
 	{ 0x22, 0x7AB, 0xB1 },
 	{ 0x22, 0x7AC, 0x30 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x6C },
 	{ 0x22, 0x7A7, 0xA1 },
 	{ 0x22, 0x7A8, 0x28 },
 	{ 0x22, 0x7A9, 0x6C },
 	{ 0x22, 0x7AA, 0xA1 },
 	{ 0x22, 0x7AB, 0x28 },
 	{ 0x22, 0x7AC, 0x31 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0xCD },
 	{ 0x22, 0x7A7, 0x48 },
 	{ 0x22, 0x7A8, 0x4F },
 	{ 0x22, 0x7A9, 0xCD },
 	{ 0x22, 0x7AA, 0x48 },
 	{ 0x22, 0x7AB, 0x4F },
 	{ 0x22, 0x7AC, 0x32 },
 	{ 0x22, 0x7AD, 0x80 },
 	{ 0x22, 0x7A6, 0x40 },
 	{ 0x22, 0x7A7, 0x00 },
 	{ 0x22, 0x7A8, 0x00 },
 	{ 0x22, 0x7A9, 0x40 },
 	{ 0x22, 0x7AA, 0x00 },
 	{ 0x22, 0x7AB, 0x00 },
 	{ 0x22, 0x7AC, 0x33 },
 	{ 0x22, 0x7AD, 0x80 },
 	/* common */
 	{ 0x22, 0x782, 0xC1 },
 	{ 0x22, 0x771, 0x2C },
 	{ 0x22, 0x772, 0x2C },
 	{ 0x22, 0x788, 0x04 },
 	{ 0x01, 0x7B0, 0x08 },
 	{}
 };
 static const struct hda_fixup stac92hd83xxx_fixups[] = {
 	[STAC_92HD83XXX_REF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ref92hd83xxx_pin_configs,
 	},
 	[STAC_92HD83XXX_PWR_REF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ref92hd83xxx_pin_configs,
 	},
 	[STAC_DELL_S14] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_s14_pin_configs,
 	},
 	[STAC_DELL_VOSTRO_3500] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_vostro_3500_pin_configs,
 	},
 	[STAC_92HD83XXX_HP_cNB11_INTQUAD] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = hp_cNB11_intquad_pin_configs,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_92HD83XXX_HP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp,
 	},
 	[STAC_HP_DV7_4000] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = hp_dv7_4000_pin_configs,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_HP_ZEPHYR] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp_zephyr,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_92HD83XXX_HP_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp_led,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_92HD83XXX_HP_INV_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp_inv_led,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_92HD83XXX_HP_MIC_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp_mic_led,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_HP_LED_GPIO10] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_hp_led_gpio10,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP,
 	},
 	[STAC_92HD83XXX_HEADSET_JACK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd83xxx_fixup_headset_jack,
 	},
 	[STAC_HP_ENVY_BASS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x0f, 0x90170111 },
 			{}
 		},
 	},
 	[STAC_HP_BNB13_EQ] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = hp_bnb13_eq_verbs,
 		.chained = true,
 		.chain_id = STAC_92HD83XXX_HP_MIC_LED,
 	},
 	[STAC_HP_ENVY_TS_BASS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x10, 0x92170111 },
 			{}
 		},
 	},
 };
 static const struct hda_model_fixup stac92hd83xxx_models[] = {
 	{ .id = STAC_92HD83XXX_REF, .name = "ref" },
 	{ .id = STAC_92HD83XXX_PWR_REF, .name = "mic-ref" },
 	{ .id = STAC_DELL_S14, .name = "dell-s14" },
 	{ .id = STAC_DELL_VOSTRO_3500, .name = "dell-vostro-3500" },
 	{ .id = STAC_92HD83XXX_HP_cNB11_INTQUAD, .name = "hp_cNB11_intquad" },
 	{ .id = STAC_HP_DV7_4000, .name = "hp-dv7-4000" },
 	{ .id = STAC_HP_ZEPHYR, .name = "hp-zephyr" },
 	{ .id = STAC_92HD83XXX_HP_LED, .name = "hp-led" },
 	{ .id = STAC_92HD83XXX_HP_INV_LED, .name = "hp-inv-led" },
 	{ .id = STAC_92HD83XXX_HP_MIC_LED, .name = "hp-mic-led" },
 	{ .id = STAC_92HD83XXX_HEADSET_JACK, .name = "headset-jack" },
 	{ .id = STAC_HP_ENVY_BASS, .name = "hp-envy-bass" },
 	{ .id = STAC_HP_BNB13_EQ, .name = "hp-bnb13-eq" },
 	{ .id = STAC_HP_ENVY_TS_BASS, .name = "hp-envy-ts-bass" },
 	{}
 };
 static const struct snd_pci_quirk stac92hd83xxx_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_92HD83XXX_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_92HD83XXX_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
 		      "unknown Dell", STAC_DELL_S14),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0532,
 		      "Dell Latitude E6230", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0533,
 		      "Dell Latitude E6330", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0534,
 		      "Dell Latitude E6430", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0535,
 		      "Dell Latitude E6530", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053c,
 		      "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053d,
 		      "Dell Latitude E5530", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0549,
 		      "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x057d,
 		      "Dell Latitude E6430s", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0584,
 		      "Dell Latitude E6430U", STAC_92HD83XXX_HEADSET_JACK),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
 		      "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
 			  "HP Pavilion dv7", STAC_HP_DV7_4000),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1888,
 			  "HP Envy Spectre", STAC_HP_ENVY_BASS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1899,
 			  "HP Folio 13", STAC_HP_LED_GPIO10),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18df,
 			  "HP Folio", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18F8,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1909,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x190A,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x190e,
 			  "HP ENVY TS", STAC_HP_ENVY_TS_BASS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1940,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1941,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1942,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1943,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1944,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1945,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1946,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1948,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1949,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194A,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194B,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194C,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194E,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194F,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1950,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1951,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195A,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195B,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195C,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1991,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2103,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2104,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2105,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2106,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2107,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2108,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2109,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x210A,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x210B,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211C,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211D,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211E,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211F,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2120,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2121,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2122,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2123,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x213E,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x213F,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2140,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B2,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B3,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B5,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B6,
 			  "HP bNB13", STAC_HP_BNB13_EQ),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x1900,
 			  "HP", STAC_92HD83XXX_HP_MIC_LED),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x2000,
 			  "HP", STAC_92HD83XXX_HP_MIC_LED),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x2100,
 			  "HP", STAC_92HD83XXX_HP_MIC_LED),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
 			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
 			  "HP", STAC_HP_ZEPHYR),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3660,
 			  "HP Mini", STAC_92HD83XXX_HP_LED),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x144E,
 			  "HP Pavilion dv5", STAC_92HD83XXX_HP_INV_LED),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x148a,
 		      "HP Mini", STAC_92HD83XXX_HP_LED),
 	SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD83XXX_HP),
 	{} /* terminator */
 };
 /* HP dv7 bass switch - GPIO5 */
 #define stac_hp_bass_gpio_info	snd_ctl_boolean_mono_info
 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
 				 struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
 	return 0;
 }
 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
 				 struct snd_ctl_elem_value *ucontrol)
 {
 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 	struct sigmatel_spec *spec = codec->spec;
 	unsigned int gpio_data;
 	gpio_data = (spec->gpio_data & ~0x20) |
 		(ucontrol->value.integer.value[0] ? 0x20 : 0);
 	if (gpio_data == spec->gpio_data)
 		return 0;
 	spec->gpio_data = gpio_data;
 	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
 	return 1;
 }
 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 	.info = stac_hp_bass_gpio_info,
 	.get = stac_hp_bass_gpio_get,
 	.put = stac_hp_bass_gpio_put,
 };
 static int stac_add_hp_bass_switch(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (!snd_hda_gen_add_kctl(&spec->gen, "Bass Speaker Playback Switch",
 				  &stac_hp_bass_sw_ctrl))
 		return -ENOMEM;
 	spec->gpio_mask |= 0x20;
 	spec->gpio_dir |= 0x20;
 	spec->gpio_data |= 0x20;
 	return 0;
 }
 static const struct hda_pintbl ref92hd71bxx_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x02a19040 },
 	{ 0x0c, 0x01a19020 },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x0181302e },
 	{ 0x0f, 0x01014010 },
 	{ 0x14, 0x01019020 },
 	{ 0x18, 0x90a000f0 },
 	{ 0x19, 0x90a000f0 },
 	{ 0x1e, 0x01452050 },
 	{ 0x1f, 0x01452050 },
 	{}
 };
 static const struct hda_pintbl dell_m4_1_pin_configs[] = {
 	{ 0x0a, 0x0421101f },
 	{ 0x0b, 0x04a11221 },
 	{ 0x0c, 0x40f000f0 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x23a1902e },
 	{ 0x0f, 0x23014250 },
 	{ 0x14, 0x40f000f0 },
 	{ 0x18, 0x90a000f0 },
 	{ 0x19, 0x40f000f0 },
 	{ 0x1e, 0x4f0000f0 },
 	{ 0x1f, 0x4f0000f0 },
 	{}
 };
 static const struct hda_pintbl dell_m4_2_pin_configs[] = {
 	{ 0x0a, 0x0421101f },
 	{ 0x0b, 0x04a11221 },
 	{ 0x0c, 0x90a70330 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x23a1902e },
 	{ 0x0f, 0x23014250 },
 	{ 0x14, 0x40f000f0 },
 	{ 0x18, 0x40f000f0 },
 	{ 0x19, 0x40f000f0 },
 	{ 0x1e, 0x044413b0 },
 	{ 0x1f, 0x044413b0 },
 	{}
 };
 static const struct hda_pintbl dell_m4_3_pin_configs[] = {
 	{ 0x0a, 0x0421101f },
 	{ 0x0b, 0x04a11221 },
 	{ 0x0c, 0x90a70330 },
 	{ 0x0d, 0x90170110 },
 	{ 0x0e, 0x40f000f0 },
 	{ 0x0f, 0x40f000f0 },
 	{ 0x14, 0x40f000f0 },
 	{ 0x18, 0x90a000f0 },
 	{ 0x19, 0x40f000f0 },
 	{ 0x1e, 0x044413b0 },
 	{ 0x1f, 0x044413b0 },
 	{}
 };
 static void stac92hd71bxx_fixup_ref(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	snd_hda_apply_pincfgs(codec, ref92hd71bxx_pin_configs);
 	spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0;
 }
 static void stac92hd71bxx_fixup_hp_m4(struct hda_codec *codec,
 				      const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	struct hda_jack_callback *jack;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	/* Enable VREF power saving on GPIO1 detect */
 	snd_hda_codec_write_cache(codec, codec->afg, 0,
 				  AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
 	jack = snd_hda_jack_detect_enable_callback(codec, codec->afg,
 						   stac_vref_event);
 	if (!IS_ERR(jack))
 		jack->private_data = 0x02;
 	spec->gpio_mask |= 0x02;
 	/* enable internal microphone */
 	snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
 }
 static void stac92hd71bxx_fixup_hp_dv4(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	spec->gpio_led = 0x01;
 }
 static void stac92hd71bxx_fixup_hp_dv5(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	unsigned int cap;
 	switch (action) {
 	case HDA_FIXUP_ACT_PRE_PROBE:
 		snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
 		break;
 	case HDA_FIXUP_ACT_PROBE:
 		/* enable bass on HP dv7 */
 		cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
 		cap &= AC_GPIO_IO_COUNT;
 		if (cap >= 6)
 			stac_add_hp_bass_switch(codec);
 		break;
 	}
 }
 static void stac92hd71bxx_fixup_hp_hdx(struct hda_codec *codec,
 				       const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	spec->gpio_led = 0x08;
 }
 static void stac92hd71bxx_fixup_hp(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	if (hp_blike_system(codec->subsystem_id)) {
 		unsigned int pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
 		if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
 			get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER  ||
 			get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
 			/* It was changed in the BIOS to just satisfy MS DTM.
 			 * Lets turn it back into slaved HP
 			 */
 			pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
 					| (AC_JACK_HP_OUT <<
 						AC_DEFCFG_DEVICE_SHIFT);
 			pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
 							| AC_DEFCFG_SEQUENCE)))
 								| 0x1f;
 			snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
 		}
 	}
 	if (find_mute_led_cfg(codec, 1))
 		codec_dbg(codec, "mute LED gpio %d polarity %d\n",
 				spec->gpio_led,
 				spec->gpio_led_polarity);
 }
 static const struct hda_fixup stac92hd71bxx_fixups[] = {
 	[STAC_92HD71BXX_REF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_ref,
 	},
 	[STAC_DELL_M4_1] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_m4_1_pin_configs,
 	},
 	[STAC_DELL_M4_2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_m4_2_pin_configs,
 	},
 	[STAC_DELL_M4_3] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_m4_3_pin_configs,
 	},
 	[STAC_HP_M4] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_hp_m4,
 		.chained = true,
 		.chain_id = STAC_92HD71BXX_HP,
 	},
 	[STAC_HP_DV4] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_hp_dv4,
 		.chained = true,
 		.chain_id = STAC_HP_DV5,
 	},
 	[STAC_HP_DV5] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_hp_dv5,
 		.chained = true,
 		.chain_id = STAC_92HD71BXX_HP,
 	},
 	[STAC_HP_HDX] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_hp_hdx,
 		.chained = true,
 		.chain_id = STAC_92HD71BXX_HP,
 	},
 	[STAC_92HD71BXX_HP] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd71bxx_fixup_hp,
 	},
 };
 static const struct hda_model_fixup stac92hd71bxx_models[] = {
 	{ .id = STAC_92HD71BXX_REF, .name = "ref" },
 	{ .id = STAC_DELL_M4_1, .name = "dell-m4-1" },
 	{ .id = STAC_DELL_M4_2, .name = "dell-m4-2" },
 	{ .id = STAC_DELL_M4_3, .name = "dell-m4-3" },
 	{ .id = STAC_HP_M4, .name = "hp-m4" },
 	{ .id = STAC_HP_DV4, .name = "hp-dv4" },
 	{ .id = STAC_HP_DV5, .name = "hp-dv5" },
 	{ .id = STAC_HP_HDX, .name = "hp-hdx" },
 	{ .id = STAC_HP_DV4, .name = "hp-dv4-1222nr" },
 	{}
 };
 static const struct snd_pci_quirk stac92hd71bxx_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_92HD71BXX_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_92HD71BXX_REF),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
 			  "HP", STAC_HP_DV5),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
 		      "HP", STAC_HP_DV5),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
 		      "HP dv4-7", STAC_HP_DV4),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
 		      "HP dv4-7", STAC_HP_DV5),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
 		      "HP HDX", STAC_HP_HDX),  /* HDX18 */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
 		      "HP mini 1000", STAC_HP_M4),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
 		      "HP HDX", STAC_HP_HDX),  /* HDX16 */
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
 		      "HP dv6", STAC_HP_DV5),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
 		      "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
 		      "HP DV6", STAC_HP_DV5),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
 		      "HP", STAC_HP_DV5),
 	SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD71BXX_HP),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
 				"unknown Dell", STAC_DELL_M4_1),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
 				"unknown Dell", STAC_DELL_M4_2),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
 				"unknown Dell", STAC_DELL_M4_2),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
 				"unknown Dell", STAC_DELL_M4_2),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
 				"unknown Dell", STAC_DELL_M4_2),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
 				"unknown Dell", STAC_DELL_M4_3),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref922x_pin_configs[] = {
 	{ 0x0a, 0x01014010 },
 	{ 0x0b, 0x01016011 },
 	{ 0x0c, 0x01012012 },
 	{ 0x0d, 0x0221401f },
 	{ 0x0e, 0x01813122 },
 	{ 0x0f, 0x01011014 },
 	{ 0x10, 0x01441030 },
 	{ 0x11, 0x01c41030 },
 	{ 0x15, 0x40000100 },
 	{ 0x1b, 0x40000100 },
 	{}
 };
 /*
     STAC 922X pin configs for
     102801A7
     102801AB
     102801A9
     102801D1
     102801D2
 */
 static const struct hda_pintbl dell_922x_d81_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x01a19021 },
 	{ 0x0c, 0x01111012 },
 	{ 0x0d, 0x01114010 },
 	{ 0x0e, 0x02a19020 },
 	{ 0x0f, 0x01117011 },
 	{ 0x10, 0x400001f0 },
 	{ 0x11, 0x400001f1 },
 	{ 0x15, 0x01813122 },
 	{ 0x1b, 0x400001f2 },
 	{}
 };
 /*
     STAC 922X pin configs for
     102801AC
     102801D0
 */
 static const struct hda_pintbl dell_922x_d82_pin_configs[] = {
 	{ 0x0a, 0x02214030 },
 	{ 0x0b, 0x01a19021 },
 	{ 0x0c, 0x01111012 },
 	{ 0x0d, 0x01114010 },
 	{ 0x0e, 0x02a19020 },
 	{ 0x0f, 0x01117011 },
 	{ 0x10, 0x01451140 },
 	{ 0x11, 0x400001f0 },
 	{ 0x15, 0x01813122 },
 	{ 0x1b, 0x400001f1 },
 	{}
 };
 /*
     STAC 922X pin configs for
     102801BF
 */
 static const struct hda_pintbl dell_922x_m81_pin_configs[] = {
 	{ 0x0a, 0x0321101f },
 	{ 0x0b, 0x01112024 },
 	{ 0x0c, 0x01111222 },
 	{ 0x0d, 0x91174220 },
 	{ 0x0e, 0x03a11050 },
 	{ 0x0f, 0x01116221 },
 	{ 0x10, 0x90a70330 },
 	{ 0x11, 0x01452340 },
 	{ 0x15, 0x40C003f1 },
 	{ 0x1b, 0x405003f0 },
 	{}
 };
 /*
     STAC 9221 A1 pin configs for
     102801D7 (Dell XPS M1210)
 */
 static const struct hda_pintbl dell_922x_m82_pin_configs[] = {
 	{ 0x0a, 0x02211211 },
 	{ 0x0b, 0x408103ff },
 	{ 0x0c, 0x02a1123e },
 	{ 0x0d, 0x90100310 },
 	{ 0x0e, 0x408003f1 },
 	{ 0x0f, 0x0221121f },
 	{ 0x10, 0x03451340 },
 	{ 0x11, 0x40c003f2 },
 	{ 0x15, 0x508003f3 },
 	{ 0x1b, 0x405003f4 },
 	{}
 };
 static const struct hda_pintbl d945gtp3_pin_configs[] = {
 	{ 0x0a, 0x0221401f },
 	{ 0x0b, 0x01a19022 },
 	{ 0x0c, 0x01813021 },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x40000100 },
 	{ 0x0f, 0x40000100 },
 	{ 0x10, 0x40000100 },
 	{ 0x11, 0x40000100 },
 	{ 0x15, 0x02a19120 },
 	{ 0x1b, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl d945gtp5_pin_configs[] = {
 	{ 0x0a, 0x0221401f },
 	{ 0x0b, 0x01011012 },
 	{ 0x0c, 0x01813024 },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x01a19021 },
 	{ 0x0f, 0x01016011 },
 	{ 0x10, 0x01452130 },
 	{ 0x11, 0x40000100 },
 	{ 0x15, 0x02a19320 },
 	{ 0x1b, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl intel_mac_v1_pin_configs[] = {
 	{ 0x0a, 0x0121e21f },
 	{ 0x0b, 0x400000ff },
 	{ 0x0c, 0x9017e110 },
 	{ 0x0d, 0x400000fd },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x0181e020 },
 	{ 0x10, 0x1145e030 },
 	{ 0x11, 0x11c5e240 },
 	{ 0x15, 0x400000fc },
 	{ 0x1b, 0x400000fb },
 	{}
 };
 static const struct hda_pintbl intel_mac_v2_pin_configs[] = {
 	{ 0x0a, 0x0121e21f },
 	{ 0x0b, 0x90a7012e },
 	{ 0x0c, 0x9017e110 },
 	{ 0x0d, 0x400000fd },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x0181e020 },
 	{ 0x10, 0x1145e230 },
 	{ 0x11, 0x500000fa },
 	{ 0x15, 0x400000fc },
 	{ 0x1b, 0x400000fb },
 	{}
 };
 static const struct hda_pintbl intel_mac_v3_pin_configs[] = {
 	{ 0x0a, 0x0121e21f },
 	{ 0x0b, 0x90a7012e },
 	{ 0x0c, 0x9017e110 },
 	{ 0x0d, 0x400000fd },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x0181e020 },
 	{ 0x10, 0x1145e230 },
 	{ 0x11, 0x11c5e240 },
 	{ 0x15, 0x400000fc },
 	{ 0x1b, 0x400000fb },
 	{}
 };
 static const struct hda_pintbl intel_mac_v4_pin_configs[] = {
 	{ 0x0a, 0x0321e21f },
 	{ 0x0b, 0x03a1e02e },
 	{ 0x0c, 0x9017e110 },
 	{ 0x0d, 0x9017e11f },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x0381e020 },
 	{ 0x10, 0x1345e230 },
 	{ 0x11, 0x13c5e240 },
 	{ 0x15, 0x400000fc },
 	{ 0x1b, 0x400000fb },
 	{}
 };
 static const struct hda_pintbl intel_mac_v5_pin_configs[] = {
 	{ 0x0a, 0x0321e21f },
 	{ 0x0b, 0x03a1e02e },
 	{ 0x0c, 0x9017e110 },
 	{ 0x0d, 0x9017e11f },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x0381e020 },
 	{ 0x10, 0x1345e230 },
 	{ 0x11, 0x13c5e240 },
 	{ 0x15, 0x400000fc },
 	{ 0x1b, 0x400000fb },
 	{}
 };
 static const struct hda_pintbl ecs202_pin_configs[] = {
 	{ 0x0a, 0x0221401f },
 	{ 0x0b, 0x02a19020 },
 	{ 0x0c, 0x01a19020 },
 	{ 0x0d, 0x01114010 },
 	{ 0x0e, 0x408000f0 },
 	{ 0x0f, 0x01813022 },
 	{ 0x10, 0x074510a0 },
 	{ 0x11, 0x40c400f1 },
 	{ 0x15, 0x9037012e },
 	{ 0x1b, 0x40e000f2 },
 	{}
 };
 /* codec SSIDs for Intel Mac sharing the same PCI SSID 8384:7680 */
 static const struct snd_pci_quirk stac922x_intel_mac_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x0000, 0x0100, "Mac Mini", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x0800, "Mac", STAC_INTEL_MAC_V1),
 	SND_PCI_QUIRK(0x106b, 0x0600, "Mac", STAC_INTEL_MAC_V2),
 	SND_PCI_QUIRK(0x106b, 0x0700, "Mac", STAC_INTEL_MAC_V2),
 	SND_PCI_QUIRK(0x106b, 0x0e00, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x0f00, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x1600, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x1700, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x0200, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x1e00, "Mac", STAC_INTEL_MAC_V3),
 	SND_PCI_QUIRK(0x106b, 0x1a00, "Mac", STAC_INTEL_MAC_V4),
 	SND_PCI_QUIRK(0x106b, 0x0a00, "Mac", STAC_INTEL_MAC_V5),
 	SND_PCI_QUIRK(0x106b, 0x2200, "Mac", STAC_INTEL_MAC_V5),
 	{}
 };
 static const struct hda_fixup stac922x_fixups[];
 /* remap the fixup from codec SSID and apply it */
 static void stac922x_fixup_intel_mac_auto(struct hda_codec *codec,
 					  const struct hda_fixup *fix,
 					  int action)
 {
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
 	snd_hda_pick_fixup(codec, NULL, stac922x_intel_mac_fixup_tbl,
 			   stac922x_fixups);
 	if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
 		snd_hda_apply_fixup(codec, action);
 }
 static void stac922x_fixup_intel_mac_gpio(struct hda_codec *codec,
 					  const struct hda_fixup *fix,
 					  int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		spec->gpio_mask = spec->gpio_dir = 0x03;
 		spec->gpio_data = 0x03;
 	}
 }
 static const struct hda_fixup stac922x_fixups[] = {
 	[STAC_D945_REF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ref922x_pin_configs,
 	},
 	[STAC_D945GTP3] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = d945gtp3_pin_configs,
 	},
 	[STAC_D945GTP5] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = d945gtp5_pin_configs,
 	},
 	[STAC_INTEL_MAC_AUTO] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac922x_fixup_intel_mac_auto,
 	},
 	[STAC_INTEL_MAC_V1] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_mac_v1_pin_configs,
 		.chained = true,
 		.chain_id = STAC_922X_INTEL_MAC_GPIO,
 	},
 	[STAC_INTEL_MAC_V2] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_mac_v2_pin_configs,
 		.chained = true,
 		.chain_id = STAC_922X_INTEL_MAC_GPIO,
 	},
 	[STAC_INTEL_MAC_V3] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_mac_v3_pin_configs,
 		.chained = true,
 		.chain_id = STAC_922X_INTEL_MAC_GPIO,
 	},
 	[STAC_INTEL_MAC_V4] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_mac_v4_pin_configs,
 		.chained = true,
 		.chain_id = STAC_922X_INTEL_MAC_GPIO,
 	},
 	[STAC_INTEL_MAC_V5] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = intel_mac_v5_pin_configs,
 		.chained = true,
 		.chain_id = STAC_922X_INTEL_MAC_GPIO,
 	},
 	[STAC_922X_INTEL_MAC_GPIO] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac922x_fixup_intel_mac_gpio,
 	},
 	[STAC_ECS_202] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = ecs202_pin_configs,
 	},
 	[STAC_922X_DELL_D81] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_922x_d81_pin_configs,
 	},
 	[STAC_922X_DELL_D82] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_922x_d82_pin_configs,
 	},
 	[STAC_922X_DELL_M81] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_922x_m81_pin_configs,
 	},
 	[STAC_922X_DELL_M82] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_922x_m82_pin_configs,
 	},
 };
 static const struct hda_model_fixup stac922x_models[] = {
 	{ .id = STAC_D945_REF, .name = "ref" },
 	{ .id = STAC_D945GTP5, .name = "5stack" },
 	{ .id = STAC_D945GTP3, .name = "3stack" },
 	{ .id = STAC_INTEL_MAC_V1, .name = "intel-mac-v1" },
 	{ .id = STAC_INTEL_MAC_V2, .name = "intel-mac-v2" },
 	{ .id = STAC_INTEL_MAC_V3, .name = "intel-mac-v3" },
 	{ .id = STAC_INTEL_MAC_V4, .name = "intel-mac-v4" },
 	{ .id = STAC_INTEL_MAC_V5, .name = "intel-mac-v5" },
 	{ .id = STAC_INTEL_MAC_AUTO, .name = "intel-mac-auto" },
 	{ .id = STAC_ECS_202, .name = "ecs202" },
 	{ .id = STAC_922X_DELL_D81, .name = "dell-d81" },
 	{ .id = STAC_922X_DELL_D82, .name = "dell-d82" },
 	{ .id = STAC_922X_DELL_M81, .name = "dell-m81" },
 	{ .id = STAC_922X_DELL_M82, .name = "dell-m82" },
 	/* for backward compatibility */
 	{ .id = STAC_INTEL_MAC_V3, .name = "macmini" },
 	{ .id = STAC_INTEL_MAC_V5, .name = "macbook" },
 	{ .id = STAC_INTEL_MAC_V3, .name = "macbook-pro-v1" },
 	{ .id = STAC_INTEL_MAC_V3, .name = "macbook-pro" },
 	{ .id = STAC_INTEL_MAC_V2, .name = "imac-intel" },
 	{ .id = STAC_INTEL_MAC_V3, .name = "imac-intel-20" },
 	{}
 };
 static const struct snd_pci_quirk stac922x_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_D945_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_D945_REF),
 	/* Intel 945G based systems */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
 		      "Intel D945G", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
 		      "Intel D945G", STAC_D945GTP3),
 	/* Intel D945G 5-stack systems */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
 		      "Intel D945G", STAC_D945GTP5),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
 		      "Intel D945G", STAC_D945GTP5),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
 		      "Intel D945G", STAC_D945GTP5),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
 		      "Intel D945G", STAC_D945GTP5),
 	/* Intel 945P based systems */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
 		      "Intel D945P", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
 		      "Intel D945P", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
 		      "Intel D945P", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
 		      "Intel D945P", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
 		      "Intel D945P", STAC_D945GTP3),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
 		      "Intel D945P", STAC_D945GTP5),
 	/* other intel */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
 		      "Intel D945", STAC_D945_REF),
 	/* other systems  */
 	/* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
 	SND_PCI_QUIRK(0x8384, 0x7680, "Mac", STAC_INTEL_MAC_AUTO),
 	/* Dell systems  */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
 		      "unknown Dell", STAC_922X_DELL_D81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
 		      "unknown Dell", STAC_922X_DELL_D81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
 		      "unknown Dell", STAC_922X_DELL_D81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
 		      "unknown Dell", STAC_922X_DELL_D82),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
 		      "unknown Dell", STAC_922X_DELL_M81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
 		      "unknown Dell", STAC_922X_DELL_D82),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
 		      "unknown Dell", STAC_922X_DELL_D81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
 		      "unknown Dell", STAC_922X_DELL_D81),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
 		      "Dell XPS M1210", STAC_922X_DELL_M82),
 	/* ECS/PC Chips boards */
 	SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
 		      "ECS/PC chips", STAC_ECS_202),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref927x_pin_configs[] = {
 	{ 0x0a, 0x02214020 },
 	{ 0x0b, 0x02a19080 },
 	{ 0x0c, 0x0181304e },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x01a19040 },
 	{ 0x0f, 0x01011012 },
 	{ 0x10, 0x01016011 },
 	{ 0x11, 0x0101201f },
 	{ 0x12, 0x183301f0 },
 	{ 0x13, 0x18a001f0 },
 	{ 0x14, 0x18a001f0 },
 	{ 0x21, 0x01442070 },
 	{ 0x22, 0x01c42190 },
 	{ 0x23, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl d965_3st_pin_configs[] = {
 	{ 0x0a, 0x0221401f },
 	{ 0x0b, 0x02a19120 },
 	{ 0x0c, 0x40000100 },
 	{ 0x0d, 0x01014011 },
 	{ 0x0e, 0x01a19021 },
 	{ 0x0f, 0x01813024 },
 	{ 0x10, 0x40000100 },
 	{ 0x11, 0x40000100 },
 	{ 0x12, 0x40000100 },
 	{ 0x13, 0x40000100 },
 	{ 0x14, 0x40000100 },
 	{ 0x21, 0x40000100 },
 	{ 0x22, 0x40000100 },
 	{ 0x23, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl d965_5st_pin_configs[] = {
 	{ 0x0a, 0x02214020 },
 	{ 0x0b, 0x02a19080 },
 	{ 0x0c, 0x0181304e },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x01a19040 },
 	{ 0x0f, 0x01011012 },
 	{ 0x10, 0x01016011 },
 	{ 0x11, 0x40000100 },
 	{ 0x12, 0x40000100 },
 	{ 0x13, 0x40000100 },
 	{ 0x14, 0x40000100 },
 	{ 0x21, 0x01442070 },
 	{ 0x22, 0x40000100 },
 	{ 0x23, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl d965_5st_no_fp_pin_configs[] = {
 	{ 0x0a, 0x40000100 },
 	{ 0x0b, 0x40000100 },
 	{ 0x0c, 0x0181304e },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x01a19040 },
 	{ 0x0f, 0x01011012 },
 	{ 0x10, 0x01016011 },
 	{ 0x11, 0x40000100 },
 	{ 0x12, 0x40000100 },
 	{ 0x13, 0x40000100 },
 	{ 0x14, 0x40000100 },
 	{ 0x21, 0x01442070 },
 	{ 0x22, 0x40000100 },
 	{ 0x23, 0x40000100 },
 	{}
 };
 static const struct hda_pintbl dell_3st_pin_configs[] = {
 	{ 0x0a, 0x02211230 },
 	{ 0x0b, 0x02a11220 },
 	{ 0x0c, 0x01a19040 },
 	{ 0x0d, 0x01114210 },
 	{ 0x0e, 0x01111212 },
 	{ 0x0f, 0x01116211 },
 	{ 0x10, 0x01813050 },
 	{ 0x11, 0x01112214 },
 	{ 0x12, 0x403003fa },
 	{ 0x13, 0x90a60040 },
 	{ 0x14, 0x90a60040 },
 	{ 0x21, 0x404003fb },
 	{ 0x22, 0x40c003fc },
 	{ 0x23, 0x40000100 },
 	{}
 };
 static void stac927x_fixup_ref_no_jd(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	/* no jack detecion for ref-no-jd model */
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		codec->no_jack_detect = 1;
 }
 static void stac927x_fixup_ref(struct hda_codec *codec,
 			       const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		snd_hda_apply_pincfgs(codec, ref927x_pin_configs);
 		spec->eapd_mask = spec->gpio_mask = 0;
 		spec->gpio_dir = spec->gpio_data = 0;
 	}
 }
 static void stac927x_fixup_dell_dmic(struct hda_codec *codec,
 				     const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	if (codec->subsystem_id != 0x1028022f) {
 		/* GPIO2 High = Enable EAPD */
 		spec->eapd_mask = spec->gpio_mask = 0x04;
 		spec->gpio_dir = spec->gpio_data = 0x04;
 	}
 	snd_hda_add_verbs(codec, dell_3st_core_init);
 	spec->volknob_init = 1;
 }
 static void stac927x_fixup_volknob(struct hda_codec *codec,
 				   const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		snd_hda_add_verbs(codec, stac927x_volknob_core_init);
 		spec->volknob_init = 1;
 	}
 }
 static const struct hda_fixup stac927x_fixups[] = {
 	[STAC_D965_REF_NO_JD] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac927x_fixup_ref_no_jd,
 		.chained = true,
 		.chain_id = STAC_D965_REF,
 	},
 	[STAC_D965_REF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac927x_fixup_ref,
 	},
 	[STAC_D965_3ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = d965_3st_pin_configs,
 		.chained = true,
 		.chain_id = STAC_D965_VERBS,
 	},
 	[STAC_D965_5ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = d965_5st_pin_configs,
 		.chained = true,
 		.chain_id = STAC_D965_VERBS,
 	},
 	[STAC_D965_VERBS] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = d965_core_init,
 	},
 	[STAC_D965_5ST_NO_FP] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = d965_5st_no_fp_pin_configs,
 	},
 	[STAC_DELL_3ST] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_3st_pin_configs,
 		.chained = true,
 		.chain_id = STAC_927X_DELL_DMIC,
 	},
 	[STAC_DELL_BIOS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* correct the front output jack as a hp out */
 			{ 0x0f, 0x0221101f },
 			/* correct the front input jack as a mic */
 			{ 0x0e, 0x02a79130 },
 			{}
 		},
 		.chained = true,
 		.chain_id = STAC_927X_DELL_DMIC,
 	},
 	[STAC_DELL_BIOS_AMIC] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* configure the analog microphone on some laptops */
 			{ 0x0c, 0x90a79130 },
 			{}
 		},
 		.chained = true,
 		.chain_id = STAC_DELL_BIOS,
 	},
 	[STAC_DELL_BIOS_SPDIF] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			/* correct the device field to SPDIF out */
 			{ 0x21, 0x01442070 },
 			{}
 		},
 		.chained = true,
 		.chain_id = STAC_DELL_BIOS,
 	},
 	[STAC_927X_DELL_DMIC] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac927x_fixup_dell_dmic,
 	},
 	[STAC_927X_VOLKNOB] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac927x_fixup_volknob,
 	},
 };
 static const struct hda_model_fixup stac927x_models[] = {
 	{ .id = STAC_D965_REF_NO_JD, .name = "ref-no-jd" },
 	{ .id = STAC_D965_REF, .name = "ref" },
 	{ .id = STAC_D965_3ST, .name = "3stack" },
 	{ .id = STAC_D965_5ST, .name = "5stack" },
 	{ .id = STAC_D965_5ST_NO_FP, .name = "5stack-no-fp" },
 	{ .id = STAC_DELL_3ST, .name = "dell-3stack" },
 	{ .id = STAC_DELL_BIOS, .name = "dell-bios" },
 	{ .id = STAC_DELL_BIOS_AMIC, .name = "dell-bios-amic" },
 	{ .id = STAC_927X_VOLKNOB, .name = "volknob" },
 	{}
 };
 static const struct snd_pci_quirk stac927x_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_D965_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_D965_REF),
 	 /* Intel 946 based systems */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
 	/* 965 based 3 stack systems */
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
 			   "Intel D965", STAC_D965_3ST),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
 			   "Intel D965", STAC_D965_3ST),
 	/* Dell 3 stack systems */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
 	/* Dell 3 stack systems with verb table in BIOS */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS_SPDIF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS_SPDIF),
 	/* 965 based 5 stack systems */
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
 			   "Intel D965", STAC_D965_5ST),
 	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
 			   "Intel D965", STAC_D965_5ST),
 	/* volume-knob fixes */
 	SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
 	{} /* terminator */
 };
 static const struct hda_pintbl ref9205_pin_configs[] = {
 	{ 0x0a, 0x40000100 },
 	{ 0x0b, 0x40000100 },
 	{ 0x0c, 0x01016011 },
 	{ 0x0d, 0x01014010 },
 	{ 0x0e, 0x01813122 },
 	{ 0x0f, 0x01a19021 },
 	{ 0x14, 0x01019020 },
 	{ 0x16, 0x40000100 },
 	{ 0x17, 0x90a000f0 },
 	{ 0x18, 0x90a000f0 },
 	{ 0x21, 0x01441030 },
 	{ 0x22, 0x01c41030 },
 	{}
 };
 /*
     STAC 9205 pin configs for
     102801F1
     102801F2
     102801FC
     102801FD
     10280204
     1028021F
     10280228 (Dell Vostro 1500)
     10280229 (Dell Vostro 1700)
 */
 static const struct hda_pintbl dell_9205_m42_pin_configs[] = {
 	{ 0x0a, 0x0321101F },
 	{ 0x0b, 0x03A11020 },
 	{ 0x0c, 0x400003FA },
 	{ 0x0d, 0x90170310 },
 	{ 0x0e, 0x400003FB },
 	{ 0x0f, 0x400003FC },
 	{ 0x14, 0x400003FD },
 	{ 0x16, 0x40F000F9 },
 	{ 0x17, 0x90A60330 },
 	{ 0x18, 0x400003FF },
 	{ 0x21, 0x0144131F },
 	{ 0x22, 0x40C003FE },
 	{}
 };
 /*
     STAC 9205 pin configs for
     102801F9
     102801FA
     102801FE
     102801FF (Dell Precision M4300)
     10280206
     10280200
     10280201
 */
 static const struct hda_pintbl dell_9205_m43_pin_configs[] = {
 	{ 0x0a, 0x0321101f },
 	{ 0x0b, 0x03a11020 },
 	{ 0x0c, 0x90a70330 },
 	{ 0x0d, 0x90170310 },
 	{ 0x0e, 0x400000fe },
 	{ 0x0f, 0x400000ff },
 	{ 0x14, 0x400000fd },
 	{ 0x16, 0x40f000f9 },
 	{ 0x17, 0x400000fa },
 	{ 0x18, 0x400000fc },
 	{ 0x21, 0x0144131f },
 	{ 0x22, 0x40c003f8 },
 	/* Enable SPDIF in/out */
 	{ 0x1f, 0x01441030 },
 	{ 0x20, 0x1c410030 },
 	{}
 };
 static const struct hda_pintbl dell_9205_m44_pin_configs[] = {
 	{ 0x0a, 0x0421101f },
 	{ 0x0b, 0x04a11020 },
 	{ 0x0c, 0x400003fa },
 	{ 0x0d, 0x90170310 },
 	{ 0x0e, 0x400003fb },
 	{ 0x0f, 0x400003fc },
 	{ 0x14, 0x400003fd },
 	{ 0x16, 0x400003f9 },
 	{ 0x17, 0x90a60330 },
 	{ 0x18, 0x400003ff },
 	{ 0x21, 0x01441340 },
 	{ 0x22, 0x40c003fe },
 	{}
 };
 static void stac9205_fixup_ref(struct hda_codec *codec,
 			       const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		snd_hda_apply_pincfgs(codec, ref9205_pin_configs);
 		/* SPDIF-In enabled */
 		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0;
 	}
 }
 static void stac9205_fixup_dell_m43(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	struct hda_jack_callback *jack;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 		snd_hda_apply_pincfgs(codec, dell_9205_m43_pin_configs);
 		/* Enable unsol response for GPIO4/Dock HP connection */
 		snd_hda_codec_write_cache(codec, codec->afg, 0,
 			AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
 		jack = snd_hda_jack_detect_enable_callback(codec, codec->afg,
 							   stac_vref_event);
 		if (!IS_ERR(jack))
 			jack->private_data = 0x01;
 		spec->gpio_dir = 0x0b;
 		spec->eapd_mask = 0x01;
 		spec->gpio_mask = 0x1b;
 		spec->gpio_mute = 0x10;
 		/* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
 		 * GPIO3 Low = DRM
 		 */
 		spec->gpio_data = 0x01;
 	}
 }
 static void stac9205_fixup_eapd(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action == HDA_FIXUP_ACT_PRE_PROBE)
 		spec->eapd_switch = 0;
 }
 static const struct hda_fixup stac9205_fixups[] = {
 	[STAC_9205_REF] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac9205_fixup_ref,
 	},
 	[STAC_9205_DELL_M42] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_9205_m42_pin_configs,
 	},
 	[STAC_9205_DELL_M43] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac9205_fixup_dell_m43,
 	},
 	[STAC_9205_DELL_M44] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = dell_9205_m44_pin_configs,
 	},
 	[STAC_9205_EAPD] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac9205_fixup_eapd,
 	},
 	{}
 };
 static const struct hda_model_fixup stac9205_models[] = {
 	{ .id = STAC_9205_REF, .name = "ref" },
 	{ .id = STAC_9205_DELL_M42, .name = "dell-m42" },
 	{ .id = STAC_9205_DELL_M43, .name = "dell-m43" },
 	{ .id = STAC_9205_DELL_M44, .name = "dell-m44" },
 	{ .id = STAC_9205_EAPD, .name = "eapd" },
 	{}
 };
 static const struct snd_pci_quirk stac9205_fixup_tbl[] = {
 	/* SigmaTel reference board */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
 		      "DFI LanParty", STAC_9205_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
 		      "SigmaTel", STAC_9205_REF),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
 		      "DFI LanParty", STAC_9205_REF),
 	/* Dell */
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
 		      "unknown Dell", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
 		      "unknown Dell", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
 		      "unknown Dell", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
 		      "unknown Dell", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
 		      "Dell Precision M4300", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
 		      "unknown Dell", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
 		      "Dell Precision", STAC_9205_DELL_M43),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
 		      "Dell Inspiron", STAC_9205_DELL_M44),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
 		      "Dell Vostro 1500", STAC_9205_DELL_M42),
 	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
 		      "Dell Vostro 1700", STAC_9205_DELL_M42),
 	/* Gateway */
 	SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
 	SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
 	{} /* terminator */
 };
 static void stac92hd95_fixup_hp_led(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	if (action != HDA_FIXUP_ACT_PRE_PROBE)
 		return;
 	if (find_mute_led_cfg(codec, spec->default_polarity))
 		codec_dbg(codec, "mute LED gpio %d polarity %d\n",
 				spec->gpio_led,
 				spec->gpio_led_polarity);
 }
 static const struct hda_fixup stac92hd95_fixups[] = {
 	[STAC_92HD95_HP_LED] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = stac92hd95_fixup_hp_led,
 	},
 	[STAC_92HD95_HP_BASS] = {
 		.type = HDA_FIXUP_VERBS,
 		.v.verbs = (const struct hda_verb[]) {
 			{0x1a, 0x795, 0x00}, /* HPF to 100Hz */
 			{}
 		},
 		.chained = true,
 		.chain_id = STAC_92HD95_HP_LED,
 	},
 };
 static const struct snd_pci_quirk stac92hd95_fixup_tbl[] = {
 	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1911, "HP Spectre 13", STAC_92HD95_HP_BASS),
 	{} /* terminator */
 };
 static const struct hda_model_fixup stac92hd95_models[] = {
 	{ .id = STAC_92HD95_HP_LED, .name = "hp-led" },
 	{ .id = STAC_92HD95_HP_BASS, .name = "hp-bass" },
 	{}
 };
 static int stac_parse_auto_config(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int err;
 	int flags = 0;
 	if (spec->headset_jack)
 		flags |= HDA_PINCFG_HEADSET_MIC;
 	err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL, flags);
 	if (err < 0)
 		return err;
 	/* add hooks */
 	spec->gen.pcm_playback_hook = stac_playback_pcm_hook;
 	spec->gen.pcm_capture_hook = stac_capture_pcm_hook;
 	spec->gen.automute_hook = stac_update_outputs;
 	err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
 	if (err < 0)
 		return err;
 	/* setup analog beep controls */
 	if (spec->anabeep_nid > 0) {
 		err = stac_auto_create_beep_ctls(codec,
 						 spec->anabeep_nid);
 		if (err < 0)
 			return err;
 	}
 	/* setup digital beep controls and input device */
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 	if (spec->gen.beep_nid) {
 		hda_nid_t nid = spec->gen.beep_nid;
 		unsigned int caps;
 		err = stac_auto_create_beep_ctls(codec, nid);
 		if (err < 0)
 			return err;
 		if (codec->beep) {
 			/* IDT/STAC codecs have linear beep tone parameter */
 			codec->beep->linear_tone = spec->linear_tone_beep;
 			/* if no beep switch is available, make its own one */
 			caps = query_amp_caps(codec, nid, HDA_OUTPUT);
 			if (!(caps & AC_AMPCAP_MUTE)) {
 				err = stac_beep_switch_ctl(codec);
 				if (err < 0)
 					return err;
 			}
 		}
 	}
 #endif
 	if (spec->gpio_led)
 		spec->gen.vmaster_mute.hook = stac_vmaster_hook;
 	if (spec->aloopback_ctl &&
 	    snd_hda_get_bool_hint(codec, "loopback") == 1) {
 		if (!snd_hda_gen_add_kctl(&spec->gen, NULL, spec->aloopback_ctl))
 			return -ENOMEM;
 	}
 	if (spec->have_spdif_mux) {
 		err = stac_create_spdif_mux_ctls(codec);
 		if (err < 0)
 			return err;
 	}
 	stac_init_power_map(codec);
 	return 0;
 }
 static int stac_init(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	int i;
 	/* override some hints */
 	stac_store_hints(codec);
 	/* set up GPIO */
 	/* turn on EAPD statically when spec->eapd_switch isn't set.
 	 * otherwise, unsol event will turn it on/off dynamically
 	 */
 	if (!spec->eapd_switch)
 		spec->gpio_data |= spec->eapd_mask;
 	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
 	snd_hda_gen_init(codec);
 	/* sync the power-map */
 	if (spec->num_pwrs)
 		snd_hda_codec_write(codec, codec->afg, 0,
 				    AC_VERB_IDT_SET_POWER_MAP,
 				    spec->power_map_bits);
 	/* power down inactive ADCs */
 	if (spec->powerdown_adcs) {
 		for (i = 0; i < spec->gen.num_all_adcs; i++) {
 			if (spec->active_adcs & (1 << i))
 				continue;
 			snd_hda_codec_write(codec, spec->gen.all_adcs[i], 0,
 					    AC_VERB_SET_POWER_STATE,
 					    AC_PWRST_D3);
 		}
 	}
 	return 0;
 }
 static void stac_shutup(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	snd_hda_shutup_pins(codec);
 	if (spec->eapd_mask)
 		stac_gpio_set(codec, spec->gpio_mask,
 				spec->gpio_dir, spec->gpio_data &
 				~spec->eapd_mask);
 }
 #define stac_free	snd_hda_gen_free
 #ifdef CONFIG_PROC_FS
 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
 			       struct hda_codec *codec, hda_nid_t nid)
 {
 	if (nid == codec->afg)
 		snd_iprintf(buffer, "Power-Map: 0x%02x\n",
 			    snd_hda_codec_read(codec, nid, 0,
 					       AC_VERB_IDT_GET_POWER_MAP, 0));
 }
 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
 				  struct hda_codec *codec,
 				  unsigned int verb)
 {
 	snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
 		    snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
 }
 /* stac92hd71bxx, stac92hd73xx */
 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
 				 struct hda_codec *codec, hda_nid_t nid)
 {
 	stac92hd_proc_hook(buffer, codec, nid);
 	if (nid == codec->afg)
 		analog_loop_proc_hook(buffer, codec, 0xfa0);
 }
 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
 			       struct hda_codec *codec, hda_nid_t nid)
 {
 	if (nid == codec->afg)
 		analog_loop_proc_hook(buffer, codec, 0xfe0);
 }
 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
 			       struct hda_codec *codec, hda_nid_t nid)
 {
 	if (nid == codec->afg)
 		analog_loop_proc_hook(buffer, codec, 0xfeb);
 }
 #else
 #define stac92hd_proc_hook	NULL
 #define stac92hd7x_proc_hook	NULL
 #define stac9205_proc_hook	NULL
 #define stac927x_proc_hook	NULL
 #endif
 #ifdef CONFIG_PM
 static int stac_suspend(struct hda_codec *codec)
 {
 	stac_shutup(codec);
 	return 0;
 }
 #else
 #define stac_suspend		NULL
 #endif /* CONFIG_PM */
 static const struct hda_codec_ops stac_patch_ops = {
 	.build_controls = snd_hda_gen_build_controls,
 	.build_pcms = snd_hda_gen_build_pcms,
 	.init = stac_init,
 	.free = stac_free,
 	.unsol_event = snd_hda_jack_unsol_event,
 #ifdef CONFIG_PM
 	.suspend = stac_suspend,
 #endif
 	.reboot_notify = stac_shutup,
 };
 static int alloc_stac_spec(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 	if (!spec)
 		return -ENOMEM;
 	snd_hda_gen_spec_init(&spec->gen);
 	codec->spec = spec;
 	codec->no_trigger_sense = 1; /* seems common with STAC/IDT codecs */
 	spec->gen.dac_min_mute = true;
 	return 0;
 }
 static int patch_stac9200(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	codec->patch_ops = stac_patch_ops;
 	codec->power_filter = snd_hda_codec_eapd_power_filter;
 	snd_hda_add_verbs(codec, stac9200_eapd_init);
 	snd_hda_pick_fixup(codec, stac9200_models, stac9200_fixup_tbl,
 			   stac9200_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static int patch_stac925x(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_add_verbs(codec, stac925x_core_init);
 	snd_hda_pick_fixup(codec, stac925x_models, stac925x_fixup_tbl,
 			   stac925x_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static int patch_stac92hd73xx(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	int num_dacs;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 0;
 	spec->gen.mixer_nid = 0x1d;
 	spec->have_spdif_mux = 1;
 	num_dacs = snd_hda_get_num_conns(codec, 0x0a) - 1;
 	if (num_dacs < 3 || num_dacs > 5) {
 		codec_warn(codec,
 			   "Could not determine number of channels defaulting to DAC count\n");
 		num_dacs = 5;
 	}
 	switch (num_dacs) {
 	case 0x3: /* 6 Channel */
 		spec->aloopback_ctl = &stac92hd73xx_6ch_loopback;
 		break;
 	case 0x4: /* 8 Channel */
 		spec->aloopback_ctl = &stac92hd73xx_8ch_loopback;
 		break;
 	case 0x5: /* 10 Channel */
 		spec->aloopback_ctl = &stac92hd73xx_10ch_loopback;
 		break;
 	}
 	spec->aloopback_mask = 0x01;
 	spec->aloopback_shift = 8;
 	spec->gen.beep_nid = 0x1c; /* digital beep */
 	/* GPIO0 High = Enable EAPD */
 	spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
 	spec->gpio_data = 0x01;
 	spec->eapd_switch = 1;
 	spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
 	spec->pwr_nids = stac92hd73xx_pwr_nids;
 	spec->gen.own_eapd_ctl = 1;
 	spec->gen.power_down_unused = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_pick_fixup(codec, stac92hd73xx_models, stac92hd73xx_fixup_tbl,
 			   stac92hd73xx_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	if (!spec->volknob_init)
 		snd_hda_add_verbs(codec, stac92hd73xx_core_init);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	/* Don't GPIO-mute speakers if there are no internal speakers, because
 	 * the GPIO might be necessary for Headphone
 	 */
 	if (spec->eapd_switch && !has_builtin_speaker(codec))
 		spec->eapd_switch = 0;
 	codec->proc_widget_hook = stac92hd7x_proc_hook;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static void stac_setup_gpio(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec = codec->spec;
 	spec->gpio_mask |= spec->eapd_mask;
 	if (spec->gpio_led) {
 		if (!spec->vref_mute_led_nid) {
 			spec->gpio_mask |= spec->gpio_led;
 			spec->gpio_dir |= spec->gpio_led;
 			spec->gpio_data |= spec->gpio_led;
 		} else {
 			codec->power_filter = stac_vref_led_power_filter;
 		}
 	}
 	if (spec->mic_mute_led_gpio) {
 		spec->gpio_mask |= spec->mic_mute_led_gpio;
 		spec->gpio_dir |= spec->mic_mute_led_gpio;
 		spec->mic_enabled = 0;
 		spec->gpio_data |= spec->mic_mute_led_gpio;
 		spec->gen.cap_sync_hook = stac_capture_led_hook;
 	}
 }
 static int patch_stac92hd83xxx(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	codec->epss = 0; /* longer delay needed for D3 */
 	spec = codec->spec;
 	spec->linear_tone_beep = 0;
 	spec->gen.own_eapd_ctl = 1;
 	spec->gen.power_down_unused = 1;
 	spec->gen.mixer_nid = 0x1b;
 	spec->gen.beep_nid = 0x21; /* digital beep */
 	spec->pwr_nids = stac92hd83xxx_pwr_nids;
 	spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
 	spec->default_polarity = -1; /* no default cfg */
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_add_verbs(codec, stac92hd83xxx_core_init);
 	snd_hda_pick_fixup(codec, stac92hd83xxx_models, stac92hd83xxx_fixup_tbl,
 			   stac92hd83xxx_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	stac_setup_gpio(codec);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	codec->proc_widget_hook = stac92hd_proc_hook;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static const hda_nid_t stac92hd95_pwr_nids[] = {
 	0x0a, 0x0b, 0x0c, 0x0d
 };
 static int patch_stac92hd95(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	codec->epss = 0; /* longer delay needed for D3 */
 	spec = codec->spec;
 	spec->linear_tone_beep = 0;
 	spec->gen.own_eapd_ctl = 1;
 	spec->gen.power_down_unused = 1;
 	spec->gen.beep_nid = 0x19; /* digital beep */
 	spec->pwr_nids = stac92hd95_pwr_nids;
 	spec->num_pwrs = ARRAY_SIZE(stac92hd95_pwr_nids);
 	spec->default_polarity = 0;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_pick_fixup(codec, stac92hd95_models, stac92hd95_fixup_tbl,
 			   stac92hd95_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	stac_setup_gpio(codec);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	codec->proc_widget_hook = stac92hd_proc_hook;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static int patch_stac92hd71bxx(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 0;
 	spec->gen.own_eapd_ctl = 1;
 	spec->gen.power_down_unused = 1;
 	spec->gen.mixer_nid = 0x17;
 	spec->have_spdif_mux = 1;
 	codec->patch_ops = stac_patch_ops;
 	/* GPIO0 = EAPD */
 	spec->gpio_mask = 0x01;
 	spec->gpio_dir = 0x01;
 	spec->gpio_data = 0x01;
 	switch (codec->vendor_id) {
 	case 0x111d76b6: /* 4 Port without Analog Mixer */
 	case 0x111d76b7:
 		unmute_init++;
 		break;
 	case 0x111d7608: /* 5 Port with Analog Mixer */
 		if ((codec->revision_id & 0xf) == 0 ||
 		    (codec->revision_id & 0xf) == 1)
 			spec->stream_delay = 40; /* 40 milliseconds */
 		/* disable VSW */
 		unmute_init++;
 		snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
 		snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
 		break;
 	case 0x111d7603: /* 6 Port with Analog Mixer */
 		if ((codec->revision_id & 0xf) == 1)
 			spec->stream_delay = 40; /* 40 milliseconds */
 		break;
 	}
 	if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB)
 		snd_hda_add_verbs(codec, stac92hd71bxx_core_init);
 	if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
 		snd_hda_sequence_write_cache(codec, unmute_init);
 	spec->aloopback_ctl = &stac92hd71bxx_loopback;
 	spec->aloopback_mask = 0x50;
 	spec->aloopback_shift = 0;
 	spec->powerdown_adcs = 1;
 	spec->gen.beep_nid = 0x26; /* digital beep */
 	spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
 	spec->pwr_nids = stac92hd71bxx_pwr_nids;
 	snd_hda_pick_fixup(codec, stac92hd71bxx_models, stac92hd71bxx_fixup_tbl,
 			   stac92hd71bxx_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	stac_setup_gpio(codec);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	codec->proc_widget_hook = stac92hd7x_proc_hook;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static int patch_stac922x(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_add_verbs(codec, stac922x_core_init);
 	/* Fix Mux capture level; max to 2 */
 	snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
 				  (0 << AC_AMPCAP_OFFSET_SHIFT) |
 				  (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
 				  (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 				  (0 << AC_AMPCAP_MUTE_SHIFT));
 	snd_hda_pick_fixup(codec, stac922x_models, stac922x_fixup_tbl,
 			   stac922x_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static const char * const stac927x_spdif_labels[] = {
 	"Digital Playback", "ADAT", "Analog Mux 1",
 	"Analog Mux 2", "Analog Mux 3", NULL
 };
 static int patch_stac927x(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	spec->have_spdif_mux = 1;
 	spec->spdif_labels = stac927x_spdif_labels;
 	spec->gen.beep_nid = 0x23; /* digital beep */
 	/* GPIO0 High = Enable EAPD */
 	spec->eapd_mask = spec->gpio_mask = 0x01;
 	spec->gpio_dir = spec->gpio_data = 0x01;
 	spec->aloopback_ctl = &stac927x_loopback;
 	spec->aloopback_mask = 0x40;
 	spec->aloopback_shift = 0;
 	spec->eapd_switch = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_pick_fixup(codec, stac927x_models, stac927x_fixup_tbl,
 			   stac927x_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	if (!spec->volknob_init)
 		snd_hda_add_verbs(codec, stac927x_core_init);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	codec->proc_widget_hook = stac927x_proc_hook;
 	/*
 	 * !!FIXME!!
 	 * The STAC927x seem to require fairly long delays for certain
 	 * command sequences.  With too short delays (even if the answer
 	 * is set to RIRB properly), it results in the silence output
 	 * on some hardwares like Dell.
 	 *
 	 * The below flag enables the longer delay (see get_response
 	 * in hda_intel.c).
 	 */
 	codec->bus->needs_damn_long_delay = 1;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 static int patch_stac9205(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	spec->have_spdif_mux = 1;
 	spec->gen.beep_nid = 0x23; /* digital beep */
 	snd_hda_add_verbs(codec, stac9205_core_init);
 	spec->aloopback_ctl = &stac9205_loopback;
 	spec->aloopback_mask = 0x40;
 	spec->aloopback_shift = 0;
 	/* GPIO0 High = EAPD */
 	spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
 	spec->gpio_data = 0x01;
 	/* Turn on/off EAPD per HP plugging */
 	spec->eapd_switch = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_pick_fixup(codec, stac9205_models, stac9205_fixup_tbl,
 			   stac9205_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return err;
 	}
 	codec->proc_widget_hook = stac9205_proc_hook;
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 /*
  * STAC9872 hack
  */
 static const struct hda_verb stac9872_core_init[] = {
 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
 	{}
 };
 static const struct hda_pintbl stac9872_vaio_pin_configs[] = {
 	{ 0x0a, 0x03211020 },
 	{ 0x0b, 0x411111f0 },
 	{ 0x0c, 0x411111f0 },
 	{ 0x0d, 0x03a15030 },
 	{ 0x0e, 0x411111f0 },
 	{ 0x0f, 0x90170110 },
 	{ 0x11, 0x411111f0 },
 	{ 0x13, 0x411111f0 },
 	{ 0x14, 0x90a7013e },
 	{}
 };
 static const struct hda_model_fixup stac9872_models[] = {
 	{ .id = STAC_9872_VAIO, .name = "vaio" },
 	{}
 };
 static const struct hda_fixup stac9872_fixups[] = {
 	[STAC_9872_VAIO] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = stac9872_vaio_pin_configs,
 	},
 };
 static const struct snd_pci_quirk stac9872_fixup_tbl[] = {
 	SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
 			   "Sony VAIO F/S", STAC_9872_VAIO),
 	{} /* terminator */
 };
 static int patch_stac9872(struct hda_codec *codec)
 {
 	struct sigmatel_spec *spec;
 	int err;
 	err = alloc_stac_spec(codec);
 	if (err < 0)
 		return err;
 	spec = codec->spec;
 	spec->linear_tone_beep = 1;
 	spec->gen.own_eapd_ctl = 1;
 	codec->patch_ops = stac_patch_ops;
 	snd_hda_add_verbs(codec, stac9872_core_init);
 	snd_hda_pick_fixup(codec, stac9872_models, stac9872_fixup_tbl,
 			   stac9872_fixups);
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
 	err = stac_parse_auto_config(codec);
 	if (err < 0) {
 		stac_free(codec);
 		return -EINVAL;
 	}
 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 	return 0;
 }
 /*
  * patch entries
  */
 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
  	{ .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
  	{ .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
  	{ .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
  	{ .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
  	{ .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
  	{ .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
  	{ .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
  	{ .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
  	{ .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
  	{ .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
  	{ .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
  	{ .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
  	{ .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
  	{ .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
  	{ .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
  	{ .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
  	{ .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
  	{ .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
  	{ .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
  	{ .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
  	{ .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
  	{ .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
  	{ .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
 	{ .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
 	{ .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
 	{ .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
 	{ .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
 	{ .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
 	{ .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
 	{ .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
 	{ .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
  	/* The following does not take into account .id=0x83847661 when subsys =
  	 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
  	 * currently not fully supported.
  	 */
  	{ .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
  	{ .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
  	{ .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
 	{ .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
  	{ .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
  	{ .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
  	{ .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
  	{ .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
  	{ .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
  	{ .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
  	{ .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
  	{ .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
 	{ .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
 	{ .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
 	{ .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d7695, .name = "92HD95", .patch = patch_stac92hd95 },
 	{ .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
 	{ .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
 	{ .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx},
 	{ .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx},
 	{} /* terminator */
 };
 MODULE_ALIAS("snd-hda-codec-id:8384*");
 MODULE_ALIAS("snd-hda-codec-id:111d*");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
 static struct hda_codec_preset_list sigmatel_list = {
 	.preset = snd_hda_preset_sigmatel,
 	.owner = THIS_MODULE,
 };
 static int __init patch_sigmatel_init(void)
 {
 	return snd_hda_add_codec_preset(&sigmatel_list);
 }
 static void __exit patch_sigmatel_exit(void)
 {
 	snd_hda_delete_codec_preset(&sigmatel_list);
 }
 module_init(patch_sigmatel_init)

sound/usb/caiaq/audio.c

Diff comments View file @ eb74926

1	/*	1	/*
2	* Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese	2	* Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese
3	*	3	*
4	* This program is free software; you can redistribute it and/or modify	4	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by	5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or	6	* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.	7	* (at your option) any later version.
8	*	8	*
9	* This program is distributed in the hope that it will be useful,	9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.	12	* GNU General Public License for more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License	14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software	15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	*/	17	*/
18		18
19	#include <linux/device.h>	19	#include <linux/device.h>
20	#include <linux/spinlock.h>	20	#include <linux/spinlock.h>
21	#include <linux/slab.h>	21	#include <linux/slab.h>
22	#include <linux/init.h>	22	#include <linux/init.h>
23	#include <linux/usb.h>	23	#include <linux/usb.h>
24	#include <sound/core.h>	24	#include <sound/core.h>
25	#include <sound/pcm.h>	25	#include <sound/pcm.h>
26		26
27	#include "device.h"	27	#include "device.h"
28	#include "audio.h"	28	#include "audio.h"
29		29
30	#define N_URBS 32	30	#define N_URBS 32
31	#define CLOCK_DRIFT_TOLERANCE 5	31	#define CLOCK_DRIFT_TOLERANCE 5
32	#define FRAMES_PER_URB 8	32	#define FRAMES_PER_URB 8
33	#define BYTES_PER_FRAME 512	33	#define BYTES_PER_FRAME 512
34	#define CHANNELS_PER_STREAM 2	34	#define CHANNELS_PER_STREAM 2
35	#define BYTES_PER_SAMPLE 3	35	#define BYTES_PER_SAMPLE 3
36	#define BYTES_PER_SAMPLE_USB 4	36	#define BYTES_PER_SAMPLE_USB 4
37	#define MAX_BUFFER_SIZE (128*1024)	37	#define MAX_BUFFER_SIZE (128*1024)
38	#define MAX_ENDPOINT_SIZE 512	38	#define MAX_ENDPOINT_SIZE 512
39		39
40	#define ENDPOINT_CAPTURE 2	40	#define ENDPOINT_CAPTURE 2
41	#define ENDPOINT_PLAYBACK 6	41	#define ENDPOINT_PLAYBACK 6
42		42
43	#define MAKE_CHECKBYTE(cdev,stream,i) \	43	#define MAKE_CHECKBYTE(cdev,stream,i) \
44	(stream << 1) \| (~(i / (cdev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)	44	(stream << 1) \| (~(i / (cdev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)
45		45
46	static struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = {	46	static struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = {
47	.info = (SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_INTERLEAVED \|	47	.info = (SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_INTERLEAVED \|
48	SNDRV_PCM_INFO_BLOCK_TRANSFER),	48	SNDRV_PCM_INFO_BLOCK_TRANSFER),
49	.formats = SNDRV_PCM_FMTBIT_S24_3BE,	49	.formats = SNDRV_PCM_FMTBIT_S24_3BE,
50	.rates = (SNDRV_PCM_RATE_44100 \| SNDRV_PCM_RATE_48000 \|	50	.rates = (SNDRV_PCM_RATE_44100 \| SNDRV_PCM_RATE_48000 \|
51	SNDRV_PCM_RATE_96000),	51	SNDRV_PCM_RATE_96000),
52	.rate_min = 44100,	52	.rate_min = 44100,
53	.rate_max = 0, /* will overwrite later */	53	.rate_max = 0, /* will overwrite later */
54	.channels_min = CHANNELS_PER_STREAM,	54	.channels_min = CHANNELS_PER_STREAM,
55	.channels_max = CHANNELS_PER_STREAM,	55	.channels_max = CHANNELS_PER_STREAM,
56	.buffer_bytes_max = MAX_BUFFER_SIZE,	56	.buffer_bytes_max = MAX_BUFFER_SIZE,
57	.period_bytes_min = 128,	57	.period_bytes_min = 128,
58	.period_bytes_max = MAX_BUFFER_SIZE,	58	.period_bytes_max = MAX_BUFFER_SIZE,
59	.periods_min = 1,	59	.periods_min = 1,
60	.periods_max = 1024,	60	.periods_max = 1024,
61	};	61	};
62		62
63	static void	63	static void
64	activate_substream(struct snd_usb_caiaqdev *cdev,	64	activate_substream(struct snd_usb_caiaqdev *cdev,
65	struct snd_pcm_substream *sub)	65	struct snd_pcm_substream *sub)
66	{	66	{
67	spin_lock(&cdev->spinlock);	67	spin_lock(&cdev->spinlock);
68		68
69	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)	69	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
70	cdev->sub_playback[sub->number] = sub;	70	cdev->sub_playback[sub->number] = sub;
71	else	71	else
72	cdev->sub_capture[sub->number] = sub;	72	cdev->sub_capture[sub->number] = sub;
73		73
74	spin_unlock(&cdev->spinlock);	74	spin_unlock(&cdev->spinlock);
75	}	75	}
76		76
77	static void	77	static void
78	deactivate_substream(struct snd_usb_caiaqdev *cdev,	78	deactivate_substream(struct snd_usb_caiaqdev *cdev,
79	struct snd_pcm_substream *sub)	79	struct snd_pcm_substream *sub)
80	{	80	{
81	unsigned long flags;	81	unsigned long flags;
82	spin_lock_irqsave(&cdev->spinlock, flags);	82	spin_lock_irqsave(&cdev->spinlock, flags);
83		83
84	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)	84	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
85	cdev->sub_playback[sub->number] = NULL;	85	cdev->sub_playback[sub->number] = NULL;
86	else	86	else
87	cdev->sub_capture[sub->number] = NULL;	87	cdev->sub_capture[sub->number] = NULL;
88		88
89	spin_unlock_irqrestore(&cdev->spinlock, flags);	89	spin_unlock_irqrestore(&cdev->spinlock, flags);
90	}	90	}
91		91
92	static int	92	static int
93	all_substreams_zero(struct snd_pcm_substream **subs)	93	all_substreams_zero(struct snd_pcm_substream **subs)
94	{	94	{
95	int i;	95	int i;
96	for (i = 0; i < MAX_STREAMS; i++)	96	for (i = 0; i < MAX_STREAMS; i++)
97	if (subs[i] != NULL)	97	if (subs[i] != NULL)
98	return 0;	98	return 0;
99	return 1;	99	return 1;
100	}	100	}
101		101
102	static int stream_start(struct snd_usb_caiaqdev *cdev)	102	static int stream_start(struct snd_usb_caiaqdev *cdev)
103	{	103	{
104	int i, ret;	104	int i, ret;
105	struct device *dev = caiaqdev_to_dev(cdev);	105	struct device *dev = caiaqdev_to_dev(cdev);
106		106
107	dev_dbg(dev, "%s(%p)\n", __func__, cdev);	107	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
108		108
109	if (cdev->streaming)	109	if (cdev->streaming)
110	return -EINVAL;	110	return -EINVAL;
111		111
112	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));	112	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
113	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));	113	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
114	cdev->input_panic = 0;	114	cdev->input_panic = 0;
115	cdev->output_panic = 0;	115	cdev->output_panic = 0;
116	cdev->first_packet = 4;	116	cdev->first_packet = 4;
117	cdev->streaming = 1;	117	cdev->streaming = 1;
118	cdev->warned = 0;	118	cdev->warned = 0;
119		119
120	for (i = 0; i < N_URBS; i++) {	120	for (i = 0; i < N_URBS; i++) {
121	ret = usb_submit_urb(cdev->data_urbs_in[i], GFP_ATOMIC);	121	ret = usb_submit_urb(cdev->data_urbs_in[i], GFP_ATOMIC);
122	if (ret) {	122	if (ret) {
123	dev_err(dev, "unable to trigger read #%d! (ret %d)\n",	123	dev_err(dev, "unable to trigger read #%d! (ret %d)\n",
124	i, ret);	124	i, ret);
125	cdev->streaming = 0;	125	cdev->streaming = 0;
126	return -EPIPE;	126	return -EPIPE;
127	}	127	}
128	}	128	}
129		129
130	return 0;	130	return 0;
131	}	131	}
132		132
133	static void stream_stop(struct snd_usb_caiaqdev *cdev)	133	static void stream_stop(struct snd_usb_caiaqdev *cdev)
134	{	134	{
135	int i;	135	int i;
136	struct device *dev = caiaqdev_to_dev(cdev);	136	struct device *dev = caiaqdev_to_dev(cdev);
137		137
138	dev_dbg(dev, "%s(%p)\n", __func__, cdev);	138	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
139	if (!cdev->streaming)	139	if (!cdev->streaming)
140	return;	140	return;
141		141
142	cdev->streaming = 0;	142	cdev->streaming = 0;
143		143
144	for (i = 0; i < N_URBS; i++) {	144	for (i = 0; i < N_URBS; i++) {
145	usb_kill_urb(cdev->data_urbs_in[i]);	145	usb_kill_urb(cdev->data_urbs_in[i]);
146		146
147	if (test_bit(i, &cdev->outurb_active_mask))	147	if (test_bit(i, &cdev->outurb_active_mask))
148	usb_kill_urb(cdev->data_urbs_out[i]);	148	usb_kill_urb(cdev->data_urbs_out[i]);
149	}	149	}
150		150
151	cdev->outurb_active_mask = 0;	151	cdev->outurb_active_mask = 0;
152	}	152	}
153		153
154	static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream)	154	static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream)
155	{	155	{
156	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);	156	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
157	struct device *dev = caiaqdev_to_dev(cdev);	157	struct device *dev = caiaqdev_to_dev(cdev);
158		158
159	dev_dbg(dev, "%s(%p)\n", __func__, substream);	159	dev_dbg(dev, "%s(%p)\n", __func__, substream);
160	substream->runtime->hw = cdev->pcm_info;	160	substream->runtime->hw = cdev->pcm_info;
161	snd_pcm_limit_hw_rates(substream->runtime);	161	snd_pcm_limit_hw_rates(substream->runtime);
162		162
163	return 0;	163	return 0;
164	}	164	}
165		165
166	static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)	166	static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)
167	{	167	{
168	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);	168	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
169	struct device *dev = caiaqdev_to_dev(cdev);	169	struct device *dev = caiaqdev_to_dev(cdev);
170		170
171	dev_dbg(dev, "%s(%p)\n", __func__, substream);	171	dev_dbg(dev, "%s(%p)\n", __func__, substream);
172	if (all_substreams_zero(cdev->sub_playback) &&	172	if (all_substreams_zero(cdev->sub_playback) &&
173	all_substreams_zero(cdev->sub_capture)) {	173	all_substreams_zero(cdev->sub_capture)) {
174	/* when the last client has stopped streaming,	174	/* when the last client has stopped streaming,
175	* all sample rates are allowed again */	175	* all sample rates are allowed again */
176	stream_stop(cdev);	176	stream_stop(cdev);
177	cdev->pcm_info.rates = cdev->samplerates;	177	cdev->pcm_info.rates = cdev->samplerates;
178	}	178	}
179		179
180	return 0;	180	return 0;
181	}	181	}
182		182
183	static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub,	183	static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub,
184	struct snd_pcm_hw_params *hw_params)	184	struct snd_pcm_hw_params *hw_params)
185	{	185	{
186	return snd_pcm_lib_alloc_vmalloc_buffer(sub,	186	return snd_pcm_lib_alloc_vmalloc_buffer(sub,
187	params_buffer_bytes(hw_params));	187	params_buffer_bytes(hw_params));
188	}	188	}
189		189
190	static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)	190	static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)
191	{	191	{
192	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);	192	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
193	deactivate_substream(cdev, sub);	193	deactivate_substream(cdev, sub);
194	return snd_pcm_lib_free_vmalloc_buffer(sub);	194	return snd_pcm_lib_free_vmalloc_buffer(sub);
195	}	195	}
196		196
197	/* this should probably go upstream */	197	/* this should probably go upstream */
198	#if SNDRV_PCM_RATE_5512 != 1 << 0 \|\| SNDRV_PCM_RATE_192000 != 1 << 12	198	#if SNDRV_PCM_RATE_5512 != 1 << 0 \|\| SNDRV_PCM_RATE_192000 != 1 << 12
199	#error "Change this table"	199	#error "Change this table"
200	#endif	200	#endif
201		201
202	static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,	202	static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
203	48000, 64000, 88200, 96000, 176400, 192000 };	203	48000, 64000, 88200, 96000, 176400, 192000 };
204		204
205	static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)	205	static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
206	{	206	{
207	int bytes_per_sample, bpp, ret, i;	207	int bytes_per_sample, bpp, ret, i;
208	int index = substream->number;	208	int index = substream->number;
209	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);	209	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream);
210	struct snd_pcm_runtime *runtime = substream->runtime;	210	struct snd_pcm_runtime *runtime = substream->runtime;
211	struct device *dev = caiaqdev_to_dev(cdev);	211	struct device *dev = caiaqdev_to_dev(cdev);
212		212
213	dev_dbg(dev, "%s(%p)\n", __func__, substream);	213	dev_dbg(dev, "%s(%p)\n", __func__, substream);
214		214
215	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {	215	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
216	int out_pos;	216	int out_pos;
217		217
218	switch (cdev->spec.data_alignment) {	218	switch (cdev->spec.data_alignment) {
219	case 0:	219	case 0:
220	case 2:	220	case 2:
221	out_pos = BYTES_PER_SAMPLE + 1;	221	out_pos = BYTES_PER_SAMPLE + 1;
222	break;	222	break;
223	case 3:	223	case 3:
224	default:	224	default:
225	out_pos = 0;	225	out_pos = 0;
226	break;	226	break;
227	}	227	}
228		228
229	cdev->period_out_count[index] = out_pos;	229	cdev->period_out_count[index] = out_pos;
230	cdev->audio_out_buf_pos[index] = out_pos;	230	cdev->audio_out_buf_pos[index] = out_pos;
231	} else {	231	} else {
232	int in_pos;	232	int in_pos;
233		233
234	switch (cdev->spec.data_alignment) {	234	switch (cdev->spec.data_alignment) {
235	case 0:	235	case 0:
236	in_pos = BYTES_PER_SAMPLE + 2;	236	in_pos = BYTES_PER_SAMPLE + 2;
237	break;	237	break;
238	case 2:	238	case 2:
239	in_pos = BYTES_PER_SAMPLE;	239	in_pos = BYTES_PER_SAMPLE;
240	break;	240	break;
241	case 3:	241	case 3:
242	default:	242	default:
243	in_pos = 0;	243	in_pos = 0;
244	break;	244	break;
245	}	245	}
246		246
247	cdev->period_in_count[index] = in_pos;	247	cdev->period_in_count[index] = in_pos;
248	cdev->audio_in_buf_pos[index] = in_pos;	248	cdev->audio_in_buf_pos[index] = in_pos;
249	}	249	}
250		250
251	if (cdev->streaming)	251	if (cdev->streaming)
252	return 0;	252	return 0;
253		253
254	/* the first client that opens a stream defines the sample rate	254	/* the first client that opens a stream defines the sample rate
255	* setting for all subsequent calls, until the last client closed. */	255	* setting for all subsequent calls, until the last client closed. */
256	for (i=0; i < ARRAY_SIZE(rates); i++)	256	for (i=0; i < ARRAY_SIZE(rates); i++)
257	if (runtime->rate == rates[i])	257	if (runtime->rate == rates[i])
258	cdev->pcm_info.rates = 1 << i;	258	cdev->pcm_info.rates = 1 << i;
259		259
260	snd_pcm_limit_hw_rates(runtime);	260	snd_pcm_limit_hw_rates(runtime);
261		261
262	bytes_per_sample = BYTES_PER_SAMPLE;	262	bytes_per_sample = BYTES_PER_SAMPLE;
263	if (cdev->spec.data_alignment >= 2)	263	if (cdev->spec.data_alignment >= 2)
264	bytes_per_sample++;	264	bytes_per_sample++;
265		265
266	bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)	266	bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)
267	* bytes_per_sample * CHANNELS_PER_STREAM * cdev->n_streams;	267	* bytes_per_sample * CHANNELS_PER_STREAM * cdev->n_streams;
268		268
269	if (bpp > MAX_ENDPOINT_SIZE)	269	if (bpp > MAX_ENDPOINT_SIZE)
270	bpp = MAX_ENDPOINT_SIZE;	270	bpp = MAX_ENDPOINT_SIZE;
271		271
272	ret = snd_usb_caiaq_set_audio_params(cdev, runtime->rate,	272	ret = snd_usb_caiaq_set_audio_params(cdev, runtime->rate,
273	runtime->sample_bits, bpp);	273	runtime->sample_bits, bpp);
274	if (ret)	274	if (ret)
275	return ret;	275	return ret;
276		276
277	ret = stream_start(cdev);	277	ret = stream_start(cdev);
278	if (ret)	278	if (ret)
279	return ret;	279	return ret;
280		280
281	cdev->output_running = 0;	281	cdev->output_running = 0;
282	wait_event_timeout(cdev->prepare_wait_queue, cdev->output_running, HZ);	282	wait_event_timeout(cdev->prepare_wait_queue, cdev->output_running, HZ);
283	if (!cdev->output_running) {	283	if (!cdev->output_running) {
284	stream_stop(cdev);	284	stream_stop(cdev);
285	return -EPIPE;	285	return -EPIPE;
286	}	286	}
287		287
288	return 0;	288	return 0;
289	}	289	}
290		290
291	static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)	291	static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)
292	{	292	{
293	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);	293	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
294	struct device *dev = caiaqdev_to_dev(cdev);	294	struct device *dev = caiaqdev_to_dev(cdev);
295		295
296	dev_dbg(dev, "%s(%p) cmd %d\n", __func__, sub, cmd);	296	dev_dbg(dev, "%s(%p) cmd %d\n", __func__, sub, cmd);
297		297
298	switch (cmd) {	298	switch (cmd) {
299	case SNDRV_PCM_TRIGGER_START:	299	case SNDRV_PCM_TRIGGER_START:
300	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:	300	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
301	activate_substream(cdev, sub);	301	activate_substream(cdev, sub);
302	break;	302	break;
303	case SNDRV_PCM_TRIGGER_STOP:	303	case SNDRV_PCM_TRIGGER_STOP:
304	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:	304	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
305	deactivate_substream(cdev, sub);	305	deactivate_substream(cdev, sub);
306	break;	306	break;
307	default:	307	default:
308	return -EINVAL;	308	return -EINVAL;
309	}	309	}
310		310
311	return 0;	311	return 0;
312	}	312	}
313		313
314	static snd_pcm_uframes_t	314	static snd_pcm_uframes_t
315	snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)	315	snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
316	{	316	{
317	int index = sub->number;	317	int index = sub->number;
318	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);	318	struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub);
319	snd_pcm_uframes_t ptr;	319	snd_pcm_uframes_t ptr;
320		320
321	spin_lock(&cdev->spinlock);	321	spin_lock(&cdev->spinlock);
322		322
323	if (cdev->input_panic \|\| cdev->output_panic) {	323	if (cdev->input_panic \|\| cdev->output_panic) {
324	ptr = SNDRV_PCM_POS_XRUN;	324	ptr = SNDRV_PCM_POS_XRUN;
325	goto unlock;	325	goto unlock;
326	}	326	}
327		327
328	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)	328	if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
329	ptr = bytes_to_frames(sub->runtime,	329	ptr = bytes_to_frames(sub->runtime,
330	cdev->audio_out_buf_pos[index]);	330	cdev->audio_out_buf_pos[index]);
331	else	331	else
332	ptr = bytes_to_frames(sub->runtime,	332	ptr = bytes_to_frames(sub->runtime,
333	cdev->audio_in_buf_pos[index]);	333	cdev->audio_in_buf_pos[index]);
334		334
335	unlock:	335	unlock:
336	spin_unlock(&cdev->spinlock);	336	spin_unlock(&cdev->spinlock);
337	return ptr;	337	return ptr;
338	}	338	}
339		339
340	/* operators for both playback and capture */	340	/* operators for both playback and capture */
341	static struct snd_pcm_ops snd_usb_caiaq_ops = {	341	static struct snd_pcm_ops snd_usb_caiaq_ops = {
342	.open = snd_usb_caiaq_substream_open,	342	.open = snd_usb_caiaq_substream_open,
343	.close = snd_usb_caiaq_substream_close,	343	.close = snd_usb_caiaq_substream_close,
344	.ioctl = snd_pcm_lib_ioctl,	344	.ioctl = snd_pcm_lib_ioctl,
345	.hw_params = snd_usb_caiaq_pcm_hw_params,	345	.hw_params = snd_usb_caiaq_pcm_hw_params,
346	.hw_free = snd_usb_caiaq_pcm_hw_free,	346	.hw_free = snd_usb_caiaq_pcm_hw_free,
347	.prepare = snd_usb_caiaq_pcm_prepare,	347	.prepare = snd_usb_caiaq_pcm_prepare,
348	.trigger = snd_usb_caiaq_pcm_trigger,	348	.trigger = snd_usb_caiaq_pcm_trigger,
349	.pointer = snd_usb_caiaq_pcm_pointer,	349	.pointer = snd_usb_caiaq_pcm_pointer,
350	.page = snd_pcm_lib_get_vmalloc_page,	350	.page = snd_pcm_lib_get_vmalloc_page,
351	.mmap = snd_pcm_lib_mmap_vmalloc,	351	.mmap = snd_pcm_lib_mmap_vmalloc,
352	};	352	};
353		353
354	static void check_for_elapsed_periods(struct snd_usb_caiaqdev *cdev,	354	static void check_for_elapsed_periods(struct snd_usb_caiaqdev *cdev,
355	struct snd_pcm_substream **subs)	355	struct snd_pcm_substream **subs)
356	{	356	{
357	int stream, pb, *cnt;	357	int stream, pb, *cnt;
358	struct snd_pcm_substream *sub;	358	struct snd_pcm_substream *sub;
359		359
360	for (stream = 0; stream < cdev->n_streams; stream++) {	360	for (stream = 0; stream < cdev->n_streams; stream++) {
361	sub = subs[stream];	361	sub = subs[stream];
362	if (!sub)	362	if (!sub)
363	continue;	363	continue;
364		364
365	pb = snd_pcm_lib_period_bytes(sub);	365	pb = snd_pcm_lib_period_bytes(sub);
366	cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?	366	cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
367	&cdev->period_out_count[stream] :	367	&cdev->period_out_count[stream] :
368	&cdev->period_in_count[stream];	368	&cdev->period_in_count[stream];
369		369
370	if (*cnt >= pb) {	370	if (*cnt >= pb) {
371	snd_pcm_period_elapsed(sub);	371	snd_pcm_period_elapsed(sub);
372	*cnt %= pb;	372	*cnt %= pb;
373	}	373	}
374	}	374	}
375	}	375	}
376		376
377	static void read_in_urb_mode0(struct snd_usb_caiaqdev *cdev,	377	static void read_in_urb_mode0(struct snd_usb_caiaqdev *cdev,
378	const struct urb *urb,	378	const struct urb *urb,
379	const struct usb_iso_packet_descriptor *iso)	379	const struct usb_iso_packet_descriptor *iso)
380	{	380	{
381	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;	381	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
382	struct snd_pcm_substream *sub;	382	struct snd_pcm_substream *sub;
383	int stream, i;	383	int stream, i;
384		384
385	if (all_substreams_zero(cdev->sub_capture))	385	if (all_substreams_zero(cdev->sub_capture))
386	return;	386	return;
387		387
388	for (i = 0; i < iso->actual_length;) {	388	for (i = 0; i < iso->actual_length;) {
389	for (stream = 0; stream < cdev->n_streams; stream++, i++) {	389	for (stream = 0; stream < cdev->n_streams; stream++, i++) {
390	sub = cdev->sub_capture[stream];	390	sub = cdev->sub_capture[stream];
391	if (sub) {	391	if (sub) {
392	struct snd_pcm_runtime *rt = sub->runtime;	392	struct snd_pcm_runtime *rt = sub->runtime;
393	char *audio_buf = rt->dma_area;	393	char *audio_buf = rt->dma_area;
394	int sz = frames_to_bytes(rt, rt->buffer_size);	394	int sz = frames_to_bytes(rt, rt->buffer_size);
395	audio_buf[cdev->audio_in_buf_pos[stream]++]	395	audio_buf[cdev->audio_in_buf_pos[stream]++]
396	= usb_buf[i];	396	= usb_buf[i];
397	cdev->period_in_count[stream]++;	397	cdev->period_in_count[stream]++;
398	if (cdev->audio_in_buf_pos[stream] == sz)	398	if (cdev->audio_in_buf_pos[stream] == sz)
399	cdev->audio_in_buf_pos[stream] = 0;	399	cdev->audio_in_buf_pos[stream] = 0;
400	}	400	}
401	}	401	}
402	}	402	}
403	}	403	}
404		404
405	static void read_in_urb_mode2(struct snd_usb_caiaqdev *cdev,	405	static void read_in_urb_mode2(struct snd_usb_caiaqdev *cdev,
406	const struct urb *urb,	406	const struct urb *urb,
407	const struct usb_iso_packet_descriptor *iso)	407	const struct usb_iso_packet_descriptor *iso)
408	{	408	{
409	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;	409	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
410	unsigned char check_byte;	410	unsigned char check_byte;
411	struct snd_pcm_substream *sub;	411	struct snd_pcm_substream *sub;
412	int stream, i;	412	int stream, i;
413		413
414	for (i = 0; i < iso->actual_length;) {	414	for (i = 0; i < iso->actual_length;) {
415	if (i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == 0) {	415	if (i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == 0) {
416	for (stream = 0;	416	for (stream = 0;
417	stream < cdev->n_streams;	417	stream < cdev->n_streams;
418	stream++, i++) {	418	stream++, i++) {
419	if (cdev->first_packet)	419	if (cdev->first_packet)
420	continue;	420	continue;
421		421
422	check_byte = MAKE_CHECKBYTE(cdev, stream, i);	422	check_byte = MAKE_CHECKBYTE(cdev, stream, i);
423		423
424	if ((usb_buf[i] & 0x3f) != check_byte)	424	if ((usb_buf[i] & 0x3f) != check_byte)
425	cdev->input_panic = 1;	425	cdev->input_panic = 1;
426		426
427	if (usb_buf[i] & 0x80)	427	if (usb_buf[i] & 0x80)
428	cdev->output_panic = 1;	428	cdev->output_panic = 1;
429	}	429	}
430	}	430	}
431	cdev->first_packet = 0;	431	cdev->first_packet = 0;
432		432
433	for (stream = 0; stream < cdev->n_streams; stream++, i++) {	433	for (stream = 0; stream < cdev->n_streams; stream++, i++) {
434	sub = cdev->sub_capture[stream];	434	sub = cdev->sub_capture[stream];
435	if (cdev->input_panic)	435	if (cdev->input_panic)
436	usb_buf[i] = 0;	436	usb_buf[i] = 0;
437		437
438	if (sub) {	438	if (sub) {
439	struct snd_pcm_runtime *rt = sub->runtime;	439	struct snd_pcm_runtime *rt = sub->runtime;
440	char *audio_buf = rt->dma_area;	440	char *audio_buf = rt->dma_area;
441	int sz = frames_to_bytes(rt, rt->buffer_size);	441	int sz = frames_to_bytes(rt, rt->buffer_size);
442	audio_buf[cdev->audio_in_buf_pos[stream]++] =	442	audio_buf[cdev->audio_in_buf_pos[stream]++] =
443	usb_buf[i];	443	usb_buf[i];
444	cdev->period_in_count[stream]++;	444	cdev->period_in_count[stream]++;
445	if (cdev->audio_in_buf_pos[stream] == sz)	445	if (cdev->audio_in_buf_pos[stream] == sz)
446	cdev->audio_in_buf_pos[stream] = 0;	446	cdev->audio_in_buf_pos[stream] = 0;
447	}	447	}
448	}	448	}
449	}	449	}
450	}	450	}
451		451
452	static void read_in_urb_mode3(struct snd_usb_caiaqdev *cdev,	452	static void read_in_urb_mode3(struct snd_usb_caiaqdev *cdev,
453	const struct urb *urb,	453	const struct urb *urb,
454	const struct usb_iso_packet_descriptor *iso)	454	const struct usb_iso_packet_descriptor *iso)
455	{	455	{
456	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;	456	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
457	struct device *dev = caiaqdev_to_dev(cdev);	457	struct device *dev = caiaqdev_to_dev(cdev);
458	int stream, i;	458	int stream, i;
459		459
460	/* paranoia check */	460	/* paranoia check */
461	if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM))	461	if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM))
462	return;	462	return;
463		463
464	for (i = 0; i < iso->actual_length;) {	464	for (i = 0; i < iso->actual_length;) {
465	for (stream = 0; stream < cdev->n_streams; stream++) {	465	for (stream = 0; stream < cdev->n_streams; stream++) {
466	struct snd_pcm_substream *sub = cdev->sub_capture[stream];	466	struct snd_pcm_substream *sub = cdev->sub_capture[stream];
467	char *audio_buf = NULL;	467	char *audio_buf = NULL;
468	int c, n, sz = 0;	468	int c, n, sz = 0;
469		469
470	if (sub && !cdev->input_panic) {	470	if (sub && !cdev->input_panic) {
471	struct snd_pcm_runtime *rt = sub->runtime;	471	struct snd_pcm_runtime *rt = sub->runtime;
472	audio_buf = rt->dma_area;	472	audio_buf = rt->dma_area;
473	sz = frames_to_bytes(rt, rt->buffer_size);	473	sz = frames_to_bytes(rt, rt->buffer_size);
474	}	474	}
475		475
476	for (c = 0; c < CHANNELS_PER_STREAM; c++) {	476	for (c = 0; c < CHANNELS_PER_STREAM; c++) {
477	/* 3 audio data bytes, followed by 1 check byte */	477	/* 3 audio data bytes, followed by 1 check byte */
478	if (audio_buf) {	478	if (audio_buf) {
479	for (n = 0; n < BYTES_PER_SAMPLE; n++) {	479	for (n = 0; n < BYTES_PER_SAMPLE; n++) {
480	audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i+n];	480	audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i+n];
481		481
482	if (cdev->audio_in_buf_pos[stream] == sz)	482	if (cdev->audio_in_buf_pos[stream] == sz)
483	cdev->audio_in_buf_pos[stream] = 0;	483	cdev->audio_in_buf_pos[stream] = 0;
484	}	484	}
485		485
486	cdev->period_in_count[stream] += BYTES_PER_SAMPLE;	486	cdev->period_in_count[stream] += BYTES_PER_SAMPLE;
487	}	487	}
488		488
489	i += BYTES_PER_SAMPLE;	489	i += BYTES_PER_SAMPLE;
490		490
491	if (usb_buf[i] != ((stream << 1) \| c) &&	491	if (usb_buf[i] != ((stream << 1) \| c) &&
492	!cdev->first_packet) {	492	!cdev->first_packet) {
493	if (!cdev->input_panic)	493	if (!cdev->input_panic)
494	dev_warn(dev, " EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",	494	dev_warn(dev, " EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",
495	((stream << 1) \| c), usb_buf[i], c, stream, i);	495	((stream << 1) \| c), usb_buf[i], c, stream, i);
496	cdev->input_panic = 1;	496	cdev->input_panic = 1;
497	}	497	}
498		498
499	i++;	499	i++;
500	}	500	}
501	}	501	}
502	}	502	}
503		503
504	if (cdev->first_packet > 0)	504	if (cdev->first_packet > 0)
505	cdev->first_packet--;	505	cdev->first_packet--;
506	}	506	}
507		507
508	static void read_in_urb(struct snd_usb_caiaqdev *cdev,	508	static void read_in_urb(struct snd_usb_caiaqdev *cdev,
509	const struct urb *urb,	509	const struct urb *urb,
510	const struct usb_iso_packet_descriptor *iso)	510	const struct usb_iso_packet_descriptor *iso)
511	{	511	{
512	struct device *dev = caiaqdev_to_dev(cdev);	512	struct device *dev = caiaqdev_to_dev(cdev);
513		513
514	if (!cdev->streaming)	514	if (!cdev->streaming)
515	return;	515	return;
516		516
517	if (iso->actual_length < cdev->bpp)	517	if (iso->actual_length < cdev->bpp)
518	return;	518	return;
519		519
520	switch (cdev->spec.data_alignment) {	520	switch (cdev->spec.data_alignment) {
521	case 0:	521	case 0:
522	read_in_urb_mode0(cdev, urb, iso);	522	read_in_urb_mode0(cdev, urb, iso);
523	break;	523	break;
524	case 2:	524	case 2:
525	read_in_urb_mode2(cdev, urb, iso);	525	read_in_urb_mode2(cdev, urb, iso);
526	break;	526	break;
527	case 3:	527	case 3:
528	read_in_urb_mode3(cdev, urb, iso);	528	read_in_urb_mode3(cdev, urb, iso);
529	break;	529	break;
530	}	530	}
531		531
532	if ((cdev->input_panic \|\| cdev->output_panic) && !cdev->warned) {	532	if ((cdev->input_panic \|\| cdev->output_panic) && !cdev->warned) {
533	dev_warn(dev, "streaming error detected %s %s\n",	533	dev_warn(dev, "streaming error detected %s %s\n",
534	cdev->input_panic ? "(input)" : "",	534	cdev->input_panic ? "(input)" : "",
535	cdev->output_panic ? "(output)" : "");	535	cdev->output_panic ? "(output)" : "");
536	cdev->warned = 1;	536	cdev->warned = 1;
537	}	537	}
538	}	538	}
539		539
540	static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *cdev,	540	static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *cdev,
541	struct urb *urb,	541	struct urb *urb,
542	const struct usb_iso_packet_descriptor *iso)	542	const struct usb_iso_packet_descriptor *iso)
543	{	543	{
544	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;	544	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
545	struct snd_pcm_substream *sub;	545	struct snd_pcm_substream *sub;
546	int stream, i;	546	int stream, i;
547		547
548	for (i = 0; i < iso->length;) {	548	for (i = 0; i < iso->length;) {
549	for (stream = 0; stream < cdev->n_streams; stream++, i++) {	549	for (stream = 0; stream < cdev->n_streams; stream++, i++) {
550	sub = cdev->sub_playback[stream];	550	sub = cdev->sub_playback[stream];
551	if (sub) {	551	if (sub) {
552	struct snd_pcm_runtime *rt = sub->runtime;	552	struct snd_pcm_runtime *rt = sub->runtime;
553	char *audio_buf = rt->dma_area;	553	char *audio_buf = rt->dma_area;
554	int sz = frames_to_bytes(rt, rt->buffer_size);	554	int sz = frames_to_bytes(rt, rt->buffer_size);
555	usb_buf[i] =	555	usb_buf[i] =
556	audio_buf[cdev->audio_out_buf_pos[stream]];	556	audio_buf[cdev->audio_out_buf_pos[stream]];
557	cdev->period_out_count[stream]++;	557	cdev->period_out_count[stream]++;
558	cdev->audio_out_buf_pos[stream]++;	558	cdev->audio_out_buf_pos[stream]++;
559	if (cdev->audio_out_buf_pos[stream] == sz)	559	if (cdev->audio_out_buf_pos[stream] == sz)
560	cdev->audio_out_buf_pos[stream] = 0;	560	cdev->audio_out_buf_pos[stream] = 0;
561	} else	561	} else
562	usb_buf[i] = 0;	562	usb_buf[i] = 0;
563	}	563	}
564		564
565	/* fill in the check bytes */	565	/* fill in the check bytes */
566	if (cdev->spec.data_alignment == 2 &&	566	if (cdev->spec.data_alignment == 2 &&
567	i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) ==	567	i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) ==
568	(cdev->n_streams * CHANNELS_PER_STREAM))	568	(cdev->n_streams * CHANNELS_PER_STREAM))
569	for (stream = 0; stream < cdev->n_streams; stream++, i++)	569	for (stream = 0; stream < cdev->n_streams; stream++, i++)
570	usb_buf[i] = MAKE_CHECKBYTE(cdev, stream, i);	570	usb_buf[i] = MAKE_CHECKBYTE(cdev, stream, i);
571	}	571	}
572	}	572	}
573		573
574	static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *cdev,	574	static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *cdev,
575	struct urb *urb,	575	struct urb *urb,
576	const struct usb_iso_packet_descriptor *iso)	576	const struct usb_iso_packet_descriptor *iso)
577	{	577	{
578	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;	578	unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
579	int stream, i;	579	int stream, i;
580		580
581	for (i = 0; i < iso->length;) {	581	for (i = 0; i < iso->length;) {
582	for (stream = 0; stream < cdev->n_streams; stream++) {	582	for (stream = 0; stream < cdev->n_streams; stream++) {
583	struct snd_pcm_substream *sub = cdev->sub_playback[stream];	583	struct snd_pcm_substream *sub = cdev->sub_playback[stream];
584	char *audio_buf = NULL;	584	char *audio_buf = NULL;
585	int c, n, sz = 0;	585	int c, n, sz = 0;
586		586
587	if (sub) {	587	if (sub) {
588	struct snd_pcm_runtime *rt = sub->runtime;	588	struct snd_pcm_runtime *rt = sub->runtime;
589	audio_buf = rt->dma_area;	589	audio_buf = rt->dma_area;
590	sz = frames_to_bytes(rt, rt->buffer_size);	590	sz = frames_to_bytes(rt, rt->buffer_size);
591	}	591	}
592		592
593	for (c = 0; c < CHANNELS_PER_STREAM; c++) {	593	for (c = 0; c < CHANNELS_PER_STREAM; c++) {
594	for (n = 0; n < BYTES_PER_SAMPLE; n++) {	594	for (n = 0; n < BYTES_PER_SAMPLE; n++) {
595	if (audio_buf) {	595	if (audio_buf) {
596	usb_buf[i+n] = audio_buf[cdev->audio_out_buf_pos[stream]++];	596	usb_buf[i+n] = audio_buf[cdev->audio_out_buf_pos[stream]++];
597		597
598	if (cdev->audio_out_buf_pos[stream] == sz)	598	if (cdev->audio_out_buf_pos[stream] == sz)
599	cdev->audio_out_buf_pos[stream] = 0;	599	cdev->audio_out_buf_pos[stream] = 0;
600	} else {	600	} else {
601	usb_buf[i+n] = 0;	601	usb_buf[i+n] = 0;
602	}	602	}
603	}	603	}
604		604
605	if (audio_buf)	605	if (audio_buf)
606	cdev->period_out_count[stream] += BYTES_PER_SAMPLE;	606	cdev->period_out_count[stream] += BYTES_PER_SAMPLE;
607		607
608	i += BYTES_PER_SAMPLE;	608	i += BYTES_PER_SAMPLE;
609		609
610	/* fill in the check byte pattern */	610	/* fill in the check byte pattern */
611	usb_buf[i++] = (stream << 1) \| c;	611	usb_buf[i++] = (stream << 1) \| c;
612	}	612	}
613	}	613	}
614	}	614	}
615	}	615	}
616		616
617	static inline void fill_out_urb(struct snd_usb_caiaqdev *cdev,	617	static inline void fill_out_urb(struct snd_usb_caiaqdev *cdev,
618	struct urb *urb,	618	struct urb *urb,
619	const struct usb_iso_packet_descriptor *iso)	619	const struct usb_iso_packet_descriptor *iso)
620	{	620	{
621	switch (cdev->spec.data_alignment) {	621	switch (cdev->spec.data_alignment) {
622	case 0:	622	case 0:
623	case 2:	623	case 2:
624	fill_out_urb_mode_0(cdev, urb, iso);	624	fill_out_urb_mode_0(cdev, urb, iso);
625	break;	625	break;
626	case 3:	626	case 3:
627	fill_out_urb_mode_3(cdev, urb, iso);	627	fill_out_urb_mode_3(cdev, urb, iso);
628	break;	628	break;
629	}	629	}
630	}	630	}
631		631
632	static void read_completed(struct urb *urb)	632	static void read_completed(struct urb *urb)
633	{	633	{
634	struct snd_usb_caiaq_cb_info *info = urb->context;	634	struct snd_usb_caiaq_cb_info *info = urb->context;
635	struct snd_usb_caiaqdev *cdev;	635	struct snd_usb_caiaqdev *cdev;
636	struct device *dev;	636	struct device *dev;
637	struct urb *out = NULL;	637	struct urb *out = NULL;
638	int i, frame, len, send_it = 0, outframe = 0;	638	int i, frame, len, send_it = 0, outframe = 0;
639	size_t offset = 0;	639	size_t offset = 0;
640		640
641	if (urb->status \|\| !info)	641	if (urb->status \|\| !info)
642	return;	642	return;
643		643
644	cdev = info->cdev;	644	cdev = info->cdev;
645	dev = caiaqdev_to_dev(cdev);	645	dev = caiaqdev_to_dev(cdev);
646		646
647	if (!cdev->streaming)	647	if (!cdev->streaming)
648	return;	648	return;
649		649
650	/* find an unused output urb that is unused */	650	/* find an unused output urb that is unused */
651	for (i = 0; i < N_URBS; i++)	651	for (i = 0; i < N_URBS; i++)
652	if (test_and_set_bit(i, &cdev->outurb_active_mask) == 0) {	652	if (test_and_set_bit(i, &cdev->outurb_active_mask) == 0) {
653	out = cdev->data_urbs_out[i];	653	out = cdev->data_urbs_out[i];
654	break;	654	break;
655	}	655	}
656		656
657	if (!out) {	657	if (!out) {
658	dev_err(dev, "Unable to find an output urb to use\n");	658	dev_err(dev, "Unable to find an output urb to use\n");
659	goto requeue;	659	goto requeue;
660	}	660	}
661		661
662	/* read the recently received packet and send back one which has	662	/* read the recently received packet and send back one which has
663	* the same layout */	663	* the same layout */
664	for (frame = 0; frame < FRAMES_PER_URB; frame++) {	664	for (frame = 0; frame < FRAMES_PER_URB; frame++) {
665	if (urb->iso_frame_desc[frame].status)	665	if (urb->iso_frame_desc[frame].status)
666	continue;	666	continue;
667		667
668	len = urb->iso_frame_desc[outframe].actual_length;	668	len = urb->iso_frame_desc[outframe].actual_length;
669	out->iso_frame_desc[outframe].length = len;	669	out->iso_frame_desc[outframe].length = len;
670	out->iso_frame_desc[outframe].actual_length = 0;	670	out->iso_frame_desc[outframe].actual_length = 0;
671	out->iso_frame_desc[outframe].offset = offset;	671	out->iso_frame_desc[outframe].offset = offset;
672	offset += len;	672	offset += len;
673		673
674	if (len > 0) {	674	if (len > 0) {
675	spin_lock(&cdev->spinlock);	675	spin_lock(&cdev->spinlock);
676	fill_out_urb(cdev, out, &out->iso_frame_desc[outframe]);	676	fill_out_urb(cdev, out, &out->iso_frame_desc[outframe]);
677	read_in_urb(cdev, urb, &urb->iso_frame_desc[frame]);	677	read_in_urb(cdev, urb, &urb->iso_frame_desc[frame]);
678	spin_unlock(&cdev->spinlock);	678	spin_unlock(&cdev->spinlock);
679	check_for_elapsed_periods(cdev, cdev->sub_playback);	679	check_for_elapsed_periods(cdev, cdev->sub_playback);
680	check_for_elapsed_periods(cdev, cdev->sub_capture);	680	check_for_elapsed_periods(cdev, cdev->sub_capture);
681	send_it = 1;	681	send_it = 1;
682	}	682	}
683		683
684	outframe++;	684	outframe++;
685	}	685	}
686		686
687	if (send_it) {	687	if (send_it) {
688	out->number_of_packets = outframe;	688	out->number_of_packets = outframe;
689	usb_submit_urb(out, GFP_ATOMIC);	689	usb_submit_urb(out, GFP_ATOMIC);
690	} else {	690	} else {
691	struct snd_usb_caiaq_cb_info *oinfo = out->context;	691	struct snd_usb_caiaq_cb_info *oinfo = out->context;
692	clear_bit(oinfo->index, &cdev->outurb_active_mask);	692	clear_bit(oinfo->index, &cdev->outurb_active_mask);
693	}	693	}
694		694
695	requeue:	695	requeue:
696	/* re-submit inbound urb */	696	/* re-submit inbound urb */
697	for (frame = 0; frame < FRAMES_PER_URB; frame++) {	697	for (frame = 0; frame < FRAMES_PER_URB; frame++) {
698	urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame;	698	urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame;
699	urb->iso_frame_desc[frame].length = BYTES_PER_FRAME;	699	urb->iso_frame_desc[frame].length = BYTES_PER_FRAME;
700	urb->iso_frame_desc[frame].actual_length = 0;	700	urb->iso_frame_desc[frame].actual_length = 0;
701	}	701	}
702		702
703	urb->number_of_packets = FRAMES_PER_URB;	703	urb->number_of_packets = FRAMES_PER_URB;
704	usb_submit_urb(urb, GFP_ATOMIC);	704	usb_submit_urb(urb, GFP_ATOMIC);
705	}	705	}
706		706
707	static void write_completed(struct urb *urb)	707	static void write_completed(struct urb *urb)
708	{	708	{
709	struct snd_usb_caiaq_cb_info *info = urb->context;	709	struct snd_usb_caiaq_cb_info *info = urb->context;
710	struct snd_usb_caiaqdev *cdev = info->cdev;	710	struct snd_usb_caiaqdev *cdev = info->cdev;
711		711
712	if (!cdev->output_running) {	712	if (!cdev->output_running) {
713	cdev->output_running = 1;	713	cdev->output_running = 1;
714	wake_up(&cdev->prepare_wait_queue);	714	wake_up(&cdev->prepare_wait_queue);
715	}	715	}
716		716
717	clear_bit(info->index, &cdev->outurb_active_mask);	717	clear_bit(info->index, &cdev->outurb_active_mask);
718	}	718	}
719		719
720	static struct urb *alloc_urbs(struct snd_usb_caiaqdev cdev, int dir, int *ret)	720	static struct urb *alloc_urbs(struct snd_usb_caiaqdev cdev, int dir, int *ret)
721	{	721	{
722	int i, frame;	722	int i, frame;
723	struct urb **urbs;	723	struct urb **urbs;
724	struct usb_device *usb_dev = cdev->chip.dev;	724	struct usb_device *usb_dev = cdev->chip.dev;
725	struct device *dev = caiaqdev_to_dev(cdev);	725	struct device *dev = caiaqdev_to_dev(cdev);
726	unsigned int pipe;	726	unsigned int pipe;
727		727
728	pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ?	728	pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ?
729	usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) :	729	usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) :
730	usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE);	730	usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE);
731		731
732	urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL);	732	urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL);
733	if (!urbs) {	733	if (!urbs) {
734	dev_err(dev, "unable to kmalloc() urbs, OOM!?\n");	734	dev_err(dev, "unable to kmalloc() urbs, OOM!?\n");
735	*ret = -ENOMEM;	735	*ret = -ENOMEM;
736	return NULL;	736	return NULL;
737	}	737	}
738		738
739	for (i = 0; i < N_URBS; i++) {	739	for (i = 0; i < N_URBS; i++) {
740	urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);	740	urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);
741	if (!urbs[i]) {	741	if (!urbs[i]) {
742	dev_err(dev, "unable to usb_alloc_urb(), OOM!?\n");	742	dev_err(dev, "unable to usb_alloc_urb(), OOM!?\n");
743	*ret = -ENOMEM;	743	*ret = -ENOMEM;
744	return urbs;	744	return urbs;
745	}	745	}
746		746
747	urbs[i]->transfer_buffer =	747	urbs[i]->transfer_buffer =
748	kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL);	748	kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL);
749	if (!urbs[i]->transfer_buffer) {	749	if (!urbs[i]->transfer_buffer) {
750	dev_err(dev, "unable to kmalloc() transfer buffer, OOM!?\n");	750	dev_err(dev, "unable to kmalloc() transfer buffer, OOM!?\n");
751	*ret = -ENOMEM;	751	*ret = -ENOMEM;
752	return urbs;	752	return urbs;
753	}	753	}
754		754
755	for (frame = 0; frame < FRAMES_PER_URB; frame++) {	755	for (frame = 0; frame < FRAMES_PER_URB; frame++) {
756	struct usb_iso_packet_descriptor *iso =	756	struct usb_iso_packet_descriptor *iso =
757	&urbs[i]->iso_frame_desc[frame];	757	&urbs[i]->iso_frame_desc[frame];
758		758
759	iso->offset = BYTES_PER_FRAME * frame;	759	iso->offset = BYTES_PER_FRAME * frame;
760	iso->length = BYTES_PER_FRAME;	760	iso->length = BYTES_PER_FRAME;
761	}	761	}
762		762
763	urbs[i]->dev = usb_dev;	763	urbs[i]->dev = usb_dev;
764	urbs[i]->pipe = pipe;	764	urbs[i]->pipe = pipe;
765	urbs[i]->transfer_buffer_length = FRAMES_PER_URB	765	urbs[i]->transfer_buffer_length = FRAMES_PER_URB
766	* BYTES_PER_FRAME;	766	* BYTES_PER_FRAME;
767	urbs[i]->context = &cdev->data_cb_info[i];	767	urbs[i]->context = &cdev->data_cb_info[i];
768	urbs[i]->interval = 1;	768	urbs[i]->interval = 1;
769	urbs[i]->number_of_packets = FRAMES_PER_URB;	769	urbs[i]->number_of_packets = FRAMES_PER_URB;
770	urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ?	770	urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ?
771	read_completed : write_completed;	771	read_completed : write_completed;
772	}	772	}
773		773
774	*ret = 0;	774	*ret = 0;
775	return urbs;	775	return urbs;
776	}	776	}
777		777
778	static void free_urbs(struct urb **urbs)	778	static void free_urbs(struct urb **urbs)
779	{	779	{
780	int i;	780	int i;
781		781
782	if (!urbs)	782	if (!urbs)
783	return;	783	return;
784		784
785	for (i = 0; i < N_URBS; i++) {	785	for (i = 0; i < N_URBS; i++) {
786	if (!urbs[i])	786	if (!urbs[i])
787	continue;	787	continue;
788		788
789	usb_kill_urb(urbs[i]);	789	usb_kill_urb(urbs[i]);
790	kfree(urbs[i]->transfer_buffer);	790	kfree(urbs[i]->transfer_buffer);
791	usb_free_urb(urbs[i]);	791	usb_free_urb(urbs[i]);
792	}	792	}
793		793
794	kfree(urbs);	794	kfree(urbs);
795	}	795	}
796		796
797	int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev)	797	int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev)
798	{	798	{
799	int i, ret;	799	int i, ret;
800	struct device *dev = caiaqdev_to_dev(cdev);	800	struct device *dev = caiaqdev_to_dev(cdev);
801		801
802	cdev->n_audio_in = max(cdev->spec.num_analog_audio_in,	802	cdev->n_audio_in = max(cdev->spec.num_analog_audio_in,
803	cdev->spec.num_digital_audio_in) /	803	cdev->spec.num_digital_audio_in) /
804	CHANNELS_PER_STREAM;	804	CHANNELS_PER_STREAM;
805	cdev->n_audio_out = max(cdev->spec.num_analog_audio_out,	805	cdev->n_audio_out = max(cdev->spec.num_analog_audio_out,
806	cdev->spec.num_digital_audio_out) /	806	cdev->spec.num_digital_audio_out) /
807	CHANNELS_PER_STREAM;	807	CHANNELS_PER_STREAM;
808	cdev->n_streams = max(cdev->n_audio_in, cdev->n_audio_out);	808	cdev->n_streams = max(cdev->n_audio_in, cdev->n_audio_out);
809		809
810	dev_dbg(dev, "cdev->n_audio_in = %d\n", cdev->n_audio_in);	810	dev_dbg(dev, "cdev->n_audio_in = %d\n", cdev->n_audio_in);
811	dev_dbg(dev, "cdev->n_audio_out = %d\n", cdev->n_audio_out);	811	dev_dbg(dev, "cdev->n_audio_out = %d\n", cdev->n_audio_out);
812	dev_dbg(dev, "cdev->n_streams = %d\n", cdev->n_streams);	812	dev_dbg(dev, "cdev->n_streams = %d\n", cdev->n_streams);
813		813
814	if (cdev->n_streams > MAX_STREAMS) {	814	if (cdev->n_streams > MAX_STREAMS) {
815	dev_err(dev, "unable to initialize device, too many streams.\n");	815	dev_err(dev, "unable to initialize device, too many streams.\n");
816	return -EINVAL;	816	return -EINVAL;
817	}	817	}
818		818
819	if (cdev->n_streams < 2) {	819	if (cdev->n_streams < 1) {
820	dev_err(dev, "bogus number of streams: %d\n", cdev->n_streams);	820	dev_err(dev, "bogus number of streams: %d\n", cdev->n_streams);
821	return -EINVAL;	821	return -EINVAL;
822	}	822	}
823		823
824	ret = snd_pcm_new(cdev->chip.card, cdev->product_name, 0,	824	ret = snd_pcm_new(cdev->chip.card, cdev->product_name, 0,
825	cdev->n_audio_out, cdev->n_audio_in, &cdev->pcm);	825	cdev->n_audio_out, cdev->n_audio_in, &cdev->pcm);
826		826
827	if (ret < 0) {	827	if (ret < 0) {
828	dev_err(dev, "snd_pcm_new() returned %d\n", ret);	828	dev_err(dev, "snd_pcm_new() returned %d\n", ret);
829	return ret;	829	return ret;
830	}	830	}
831		831
832	cdev->pcm->private_data = cdev;	832	cdev->pcm->private_data = cdev;
833	strlcpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name));	833	strlcpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name));
834		834
835	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));	835	memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback));
836	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));	836	memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture));
837		837
838	memcpy(&cdev->pcm_info, &snd_usb_caiaq_pcm_hardware,	838	memcpy(&cdev->pcm_info, &snd_usb_caiaq_pcm_hardware,
839	sizeof(snd_usb_caiaq_pcm_hardware));	839	sizeof(snd_usb_caiaq_pcm_hardware));
840		840
841	/* setup samplerates */	841	/* setup samplerates */
842	cdev->samplerates = cdev->pcm_info.rates;	842	cdev->samplerates = cdev->pcm_info.rates;
843	switch (cdev->chip.usb_id) {	843	switch (cdev->chip.usb_id) {
844	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):	844	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
845	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):	845	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
846	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):	846	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):
847	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):	847	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
848	cdev->samplerates \|= SNDRV_PCM_RATE_192000;	848	cdev->samplerates \|= SNDRV_PCM_RATE_192000;
849	/* fall thru */	849	/* fall thru */
850	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ):	850	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ):
851	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):	851	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
852	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):	852	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
853	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORAUDIO2):	853	case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORAUDIO2):
854	cdev->samplerates \|= SNDRV_PCM_RATE_88200;	854	cdev->samplerates \|= SNDRV_PCM_RATE_88200;
855	break;	855	break;
856	}	856	}
857		857
858	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_PLAYBACK,	858	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
859	&snd_usb_caiaq_ops);	859	&snd_usb_caiaq_ops);
860	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_CAPTURE,	860	snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_CAPTURE,
861	&snd_usb_caiaq_ops);	861	&snd_usb_caiaq_ops);
862		862
863	cdev->data_cb_info =	863	cdev->data_cb_info =
864	kmalloc(sizeof(struct snd_usb_caiaq_cb_info) * N_URBS,	864	kmalloc(sizeof(struct snd_usb_caiaq_cb_info) * N_URBS,
865	GFP_KERNEL);	865	GFP_KERNEL);
866		866
867	if (!cdev->data_cb_info)	867	if (!cdev->data_cb_info)
868	return -ENOMEM;	868	return -ENOMEM;
869		869
870	cdev->outurb_active_mask = 0;	870	cdev->outurb_active_mask = 0;
871	BUILD_BUG_ON(N_URBS > (sizeof(cdev->outurb_active_mask) * 8));	871	BUILD_BUG_ON(N_URBS > (sizeof(cdev->outurb_active_mask) * 8));
872		872
873	for (i = 0; i < N_URBS; i++) {	873	for (i = 0; i < N_URBS; i++) {
874	cdev->data_cb_info[i].cdev = cdev;	874	cdev->data_cb_info[i].cdev = cdev;
875	cdev->data_cb_info[i].index = i;	875	cdev->data_cb_info[i].index = i;
876	}	876	}
877		877
878	cdev->data_urbs_in = alloc_urbs(cdev, SNDRV_PCM_STREAM_CAPTURE, &ret);	878	cdev->data_urbs_in = alloc_urbs(cdev, SNDRV_PCM_STREAM_CAPTURE, &ret);
879	if (ret < 0) {	879	if (ret < 0) {
880	kfree(cdev->data_cb_info);	880	kfree(cdev->data_cb_info);
881	free_urbs(cdev->data_urbs_in);	881	free_urbs(cdev->data_urbs_in);
882	return ret;	882	return ret;
883	}	883	}
884		884
885	cdev->data_urbs_out = alloc_urbs(cdev, SNDRV_PCM_STREAM_PLAYBACK, &ret);	885	cdev->data_urbs_out = alloc_urbs(cdev, SNDRV_PCM_STREAM_PLAYBACK, &ret);
886	if (ret < 0) {	886	if (ret < 0) {
887	kfree(cdev->data_cb_info);	887	kfree(cdev->data_cb_info);
888	free_urbs(cdev->data_urbs_in);	888	free_urbs(cdev->data_urbs_in);
889	free_urbs(cdev->data_urbs_out);	889	free_urbs(cdev->data_urbs_out);
890	return ret;	890	return ret;
891	}	891	}
892		892
893	return 0;	893	return 0;
894	}	894	}
895		895
896	void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *cdev)	896	void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *cdev)
897	{	897	{
898	struct device *dev = caiaqdev_to_dev(cdev);	898	struct device *dev = caiaqdev_to_dev(cdev);
899		899
900	dev_dbg(dev, "%s(%p)\n", __func__, cdev);	900	dev_dbg(dev, "%s(%p)\n", __func__, cdev);
901	stream_stop(cdev);	901	stream_stop(cdev);
902	free_urbs(cdev->data_urbs_in);	902	free_urbs(cdev->data_urbs_in);
903	free_urbs(cdev->data_urbs_out);	903	free_urbs(cdev->data_urbs_out);
904	kfree(cdev->data_cb_info);	904	kfree(cdev->data_cb_info);
905	}	905	}
906		906
907		907