]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - sound/pci/hda/hda_codec.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Fix the merge error
[mirror_ubuntu-zesty-kernel.git] / sound / pci / hda / hda_codec.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
1da177e4
LT		 22#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/slab.h>
25#include <linux/pci.h>
62932df8 26#include <linux/mutex.h>
1da177e4
LT		 27#include <sound/core.h>
28#include "hda_codec.h"
29#include <sound/asoundef.h>
302e9c5a 30#include <sound/tlv.h>
1da177e4
LT		 31#include <sound/initval.h>
32#include "hda_local.h"
2807314d 33#include <sound/hda_hwdep.h>
1da177e4 34
1da177e4
LT		 35/*
36 * vendor / preset table
37 */
38
39struct hda_vendor_id {
40 unsigned int id;
41 const char *name;
42};
43
44/* codec vendor labels */
45static struct hda_vendor_id hda_vendor_ids[] = {
c8cd1281 46 { 0x1002, "ATI" },
a9226251 47 { 0x1057, "Motorola" },
c8cd1281 48 { 0x1095, "Silicon Image" },
31117b78 49 { 0x10de, "Nvidia" },
c8cd1281 50 { 0x10ec, "Realtek" },
4e01f54b 51 { 0x1102, "Creative" },
c577b8a1 52 { 0x1106, "VIA" },
7f16859a 53 { 0x111d, "IDT" },
c8cd1281 54 { 0x11c1, "LSI" },
54b903ec 55 { 0x11d4, "Analog Devices" },
1da177e4 56 { 0x13f6, "C-Media" },
a9226251 57 { 0x14f1, "Conexant" },
c8cd1281
TI		 58 { 0x17e8, "Chrontel" },
59 { 0x1854, "LG" },
8199de3b 60 { 0x1aec, "Wolfson Microelectronics" },
1da177e4 61 { 0x434d, "C-Media" },
74c61133 62 { 0x8086, "Intel" },
2f2f4251 63 { 0x8384, "SigmaTel" },
1da177e4
LT		 64 {} /* terminator */
65};
66
1289e9e8
TI		 67static DEFINE_MUTEX(preset_mutex);
68static LIST_HEAD(hda_preset_tables);
69
70int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71{
72 mutex_lock(&preset_mutex);
73 list_add_tail(&preset->list, &hda_preset_tables);
74 mutex_unlock(&preset_mutex);
75 return 0;
76}
ff7a3267 77EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
1289e9e8
TI		 78
79int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80{
81 mutex_lock(&preset_mutex);
82 list_del(&preset->list);
83 mutex_unlock(&preset_mutex);
84 return 0;
85}
ff7a3267 86EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
1da177e4 87
cb53c626
TI		 88#ifdef CONFIG_SND_HDA_POWER_SAVE
89static void hda_power_work(struct work_struct *work);
90static void hda_keep_power_on(struct hda_codec *codec);
91#else
92static inline void hda_keep_power_on(struct hda_codec *codec) {}
93#endif
94
50a9f790
MR		 95const char *snd_hda_get_jack_location(u32 cfg)
96{
97 static char *bases[7] = {
98 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 };
100 static unsigned char specials_idx[] = {
101 0x07, 0x08,
102 0x17, 0x18, 0x19,
103 0x37, 0x38
104 };
105 static char *specials[] = {
106 "Rear Panel", "Drive Bar",
107 "Riser", "HDMI", "ATAPI",
108 "Mobile-In", "Mobile-Out"
109 };
110 int i;
111 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
112 if ((cfg & 0x0f) < 7)
113 return bases[cfg & 0x0f];
114 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
115 if (cfg == specials_idx[i])
116 return specials[i];
117 }
118 return "UNKNOWN";
119}
ff7a3267 120EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
50a9f790
MR		 121
122const char *snd_hda_get_jack_connectivity(u32 cfg)
123{
124 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125
126 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127}
ff7a3267 128EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
50a9f790
MR		 129
130const char *snd_hda_get_jack_type(u32 cfg)
131{
132 static char *jack_types[16] = {
133 "Line Out", "Speaker", "HP Out", "CD",
134 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
135 "Line In", "Aux", "Mic", "Telephony",
136 "SPDIF In", "Digitial In", "Reserved", "Other"
137 };
138
139 return jack_types[(cfg & AC_DEFCFG_DEVICE)
140 >> AC_DEFCFG_DEVICE_SHIFT];
141}
ff7a3267 142EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
50a9f790 143
33fa35ed
TI		 144/*
145 * Compose a 32bit command word to be sent to the HD-audio controller
146 */
147static inline unsigned int
148make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
149 unsigned int verb, unsigned int parm)
150{
151 u32 val;
152
153 val = (u32)(codec->addr & 0x0f) << 28;
154 val |= (u32)direct << 27;
155 val |= (u32)nid << 20;
156 val |= verb << 8;
157 val |= parm;
158 return val;
159}
160
aa2936f5
TI		 161/*
162 * Send and receive a verb
163 */
164static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
165 unsigned int *res)
166{
167 struct hda_bus *bus = codec->bus;
8dd78330 168 int err;
aa2936f5
TI		 169
170 if (res)
171 *res = -1;
8dd78330 172 again:
aa2936f5
TI		 173 snd_hda_power_up(codec);
174 mutex_lock(&bus->cmd_mutex);
aa2936f5 175 err = bus->ops.command(bus, cmd);
8dd78330
TI		 176 if (!err && res)
177 *res = bus->ops.get_response(bus);
aa2936f5
TI		 178 mutex_unlock(&bus->cmd_mutex);
179 snd_hda_power_down(codec);
8dd78330
TI		 180 if (res && *res == -1 && bus->rirb_error) {
181 if (bus->response_reset) {
182 snd_printd("hda_codec: resetting BUS due to "
183 "fatal communication error\n");
184 bus->ops.bus_reset(bus);
185 }
186 goto again;
187 }
188 /* clear reset-flag when the communication gets recovered */
189 if (!err)
190 bus->response_reset = 0;
aa2936f5
TI		 191 return err;
192}
193
1da177e4
LT		 194/**
195 * snd_hda_codec_read - send a command and get the response
196 * @codec: the HDA codec
197 * @nid: NID to send the command
198 * @direct: direct flag
199 * @verb: the verb to send
200 * @parm: the parameter for the verb
201 *
202 * Send a single command and read the corresponding response.
203 *
204 * Returns the obtained response value, or -1 for an error.
205 */
0ba21762
TI		 206unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
207 int direct,
1da177e4
LT		 208 unsigned int verb, unsigned int parm)
209{
aa2936f5
TI		 210 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
211 unsigned int res;
212 codec_exec_verb(codec, cmd, &res);
1da177e4
LT		 213 return res;
214}
ff7a3267 215EXPORT_SYMBOL_HDA(snd_hda_codec_read);
1da177e4
LT		 216
217/**
218 * snd_hda_codec_write - send a single command without waiting for response
219 * @codec: the HDA codec
220 * @nid: NID to send the command
221 * @direct: direct flag
222 * @verb: the verb to send
223 * @parm: the parameter for the verb
224 *
225 * Send a single command without waiting for response.
226 *
227 * Returns 0 if successful, or a negative error code.
228 */
229int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
230 unsigned int verb, unsigned int parm)
231{
aa2936f5 232 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
33fa35ed 233 unsigned int res;
b20f3b83
TI		 234 return codec_exec_verb(codec, cmd,
235 codec->bus->sync_write ? &res : NULL);
1da177e4 236}
ff7a3267 237EXPORT_SYMBOL_HDA(snd_hda_codec_write);
1da177e4
LT		 238
239/**
240 * snd_hda_sequence_write - sequence writes
241 * @codec: the HDA codec
242 * @seq: VERB array to send
243 *
244 * Send the commands sequentially from the given array.
245 * The array must be terminated with NID=0.
246 */
247void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
248{
249 for (; seq->nid; seq++)
250 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
251}
ff7a3267 252EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
1da177e4
LT		 253
254/**
255 * snd_hda_get_sub_nodes - get the range of sub nodes
256 * @codec: the HDA codec
257 * @nid: NID to parse
258 * @start_id: the pointer to store the start NID
259 *
260 * Parse the NID and store the start NID of its sub-nodes.
261 * Returns the number of sub-nodes.
262 */
0ba21762
TI		 263int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
264 hda_nid_t *start_id)
1da177e4
LT		 265{
266 unsigned int parm;
267
268 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
e8a7f136
DT		 269 if (parm == -1)
270 return 0;
1da177e4
LT		 271 *start_id = (parm >> 16) & 0x7fff;
272 return (int)(parm & 0x7fff);
273}
ff7a3267 274EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
1da177e4
LT		 275
276/**
277 * snd_hda_get_connections - get connection list
278 * @codec: the HDA codec
279 * @nid: NID to parse
280 * @conn_list: connection list array
281 * @max_conns: max. number of connections to store
282 *
283 * Parses the connection list of the given widget and stores the list
284 * of NIDs.
285 *
286 * Returns the number of connections, or a negative error code.
287 */
288int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
289 hda_nid_t *conn_list, int max_conns)
290{
291 unsigned int parm;
54d17403 292 int i, conn_len, conns;
1da177e4 293 unsigned int shift, num_elems, mask;
54d17403 294 hda_nid_t prev_nid;
1da177e4 295
da3cec35
TI		 296 if (snd_BUG_ON(!conn_list || max_conns <= 0))
297 return -EINVAL;
1da177e4
LT		 298
299 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
300 if (parm & AC_CLIST_LONG) {
301 /* long form */
302 shift = 16;
303 num_elems = 2;
304 } else {
305 /* short form */
306 shift = 8;
307 num_elems = 4;
308 }
309 conn_len = parm & AC_CLIST_LENGTH;
1da177e4
LT		 310 mask = (1 << (shift-1)) - 1;
311
0ba21762 312 if (!conn_len)
1da177e4
LT		 313 return 0; /* no connection */
314
315 if (conn_len == 1) {
316 /* single connection */
0ba21762
TI		 317 parm = snd_hda_codec_read(codec, nid, 0,
318 AC_VERB_GET_CONNECT_LIST, 0);
1da177e4
LT		 319 conn_list[0] = parm & mask;
320 return 1;
321 }
322
323 /* multi connection */
324 conns = 0;
54d17403
TI		 325 prev_nid = 0;
326 for (i = 0; i < conn_len; i++) {
327 int range_val;
328 hda_nid_t val, n;
329
330 if (i % num_elems == 0)
331 parm = snd_hda_codec_read(codec, nid, 0,
332 AC_VERB_GET_CONNECT_LIST, i);
0ba21762 333 range_val = !!(parm & (1 << (shift-1))); /* ranges */
54d17403
TI		 334 val = parm & mask;
335 parm >>= shift;
336 if (range_val) {
337 /* ranges between the previous and this one */
0ba21762
TI		 338 if (!prev_nid || prev_nid >= val) {
339 snd_printk(KERN_WARNING "hda_codec: "
340 "invalid dep_range_val %x:%x\n",
341 prev_nid, val);
54d17403
TI		 342 continue;
343 }
344 for (n = prev_nid + 1; n <= val; n++) {
345 if (conns >= max_conns) {
0ba21762
TI		 346 snd_printk(KERN_ERR
347 "Too many connections\n");
1da177e4 348 return -EINVAL;
54d17403
TI		 349 }
350 conn_list[conns++] = n;
1da177e4 351 }
54d17403
TI		 352 } else {
353 if (conns >= max_conns) {
354 snd_printk(KERN_ERR "Too many connections\n");
355 return -EINVAL;
356 }
357 conn_list[conns++] = val;
1da177e4 358 }
54d17403 359 prev_nid = val;
1da177e4
LT		 360 }
361 return conns;
362}
ff7a3267 363EXPORT_SYMBOL_HDA(snd_hda_get_connections);
1da177e4
LT		 364
365
366/**
367 * snd_hda_queue_unsol_event - add an unsolicited event to queue
368 * @bus: the BUS
369 * @res: unsolicited event (lower 32bit of RIRB entry)
370 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
371 *
372 * Adds the given event to the queue. The events are processed in
373 * the workqueue asynchronously. Call this function in the interrupt
374 * hanlder when RIRB receives an unsolicited event.
375 *
376 * Returns 0 if successful, or a negative error code.
377 */
378int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
379{
380 struct hda_bus_unsolicited *unsol;
381 unsigned int wp;
382
0ba21762
TI		 383 unsol = bus->unsol;
384 if (!unsol)
1da177e4
LT		 385 return 0;
386
387 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
388 unsol->wp = wp;
389
390 wp <<= 1;
391 unsol->queue[wp] = res;
392 unsol->queue[wp + 1] = res_ex;
393
6acaed38 394 queue_work(bus->workq, &unsol->work);
1da177e4
LT		 395
396 return 0;
397}
ff7a3267 398EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
1da177e4
LT		 399
400/*
5c1d1a98 401 * process queued unsolicited events
1da177e4 402 */
c4028958 403static void process_unsol_events(struct work_struct *work)
1da177e4 404{
c4028958
DH		 405 struct hda_bus_unsolicited *unsol =
406 container_of(work, struct hda_bus_unsolicited, work);
407 struct hda_bus *bus = unsol->bus;
1da177e4
LT		 408 struct hda_codec *codec;
409 unsigned int rp, caddr, res;
410
411 while (unsol->rp != unsol->wp) {
412 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
413 unsol->rp = rp;
414 rp <<= 1;
415 res = unsol->queue[rp];
416 caddr = unsol->queue[rp + 1];
0ba21762 417 if (!(caddr & (1 << 4))) /* no unsolicited event? */
1da177e4
LT		 418 continue;
419 codec = bus->caddr_tbl[caddr & 0x0f];
420 if (codec && codec->patch_ops.unsol_event)
421 codec->patch_ops.unsol_event(codec, res);
422 }
423}
424
425/*
426 * initialize unsolicited queue
427 */
6c1f45ea 428static int init_unsol_queue(struct hda_bus *bus)
1da177e4
LT		 429{
430 struct hda_bus_unsolicited *unsol;
431
9f146bb6
TI		 432 if (bus->unsol) /* already initialized */
433 return 0;
434
e560d8d8 435 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
0ba21762
TI		 436 if (!unsol) {
437 snd_printk(KERN_ERR "hda_codec: "
438 "can't allocate unsolicited queue\n");
1da177e4
LT		 439 return -ENOMEM;
440 }
c4028958
DH		 441 INIT_WORK(&unsol->work, process_unsol_events);
442 unsol->bus = bus;
1da177e4
LT		 443 bus->unsol = unsol;
444 return 0;
445}
446
447/*
448 * destructor
449 */
450static void snd_hda_codec_free(struct hda_codec *codec);
451
452static int snd_hda_bus_free(struct hda_bus *bus)
453{
0ba21762 454 struct hda_codec *codec, *n;
1da177e4 455
0ba21762 456 if (!bus)
1da177e4 457 return 0;
6acaed38
TI		 458 if (bus->workq)
459 flush_workqueue(bus->workq);
460 if (bus->unsol)
1da177e4 461 kfree(bus->unsol);
0ba21762 462 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
1da177e4
LT		 463 snd_hda_codec_free(codec);
464 }
465 if (bus->ops.private_free)
466 bus->ops.private_free(bus);
6acaed38
TI		 467 if (bus->workq)
468 destroy_workqueue(bus->workq);
1da177e4
LT		 469 kfree(bus);
470 return 0;
471}
472
c8b6bf9b 473static int snd_hda_bus_dev_free(struct snd_device *device)
1da177e4
LT		 474{
475 struct hda_bus *bus = device->device_data;
b94d3539 476 bus->shutdown = 1;
1da177e4
LT		 477 return snd_hda_bus_free(bus);
478}
479
d7ffba19
TI		 480#ifdef CONFIG_SND_HDA_HWDEP
481static int snd_hda_bus_dev_register(struct snd_device *device)
482{
483 struct hda_bus *bus = device->device_data;
484 struct hda_codec *codec;
485 list_for_each_entry(codec, &bus->codec_list, list) {
486 snd_hda_hwdep_add_sysfs(codec);
487 }
488 return 0;
489}
490#else
491#define snd_hda_bus_dev_register NULL
492#endif
493
1da177e4
LT		 494/**
495 * snd_hda_bus_new - create a HDA bus
496 * @card: the card entry
497 * @temp: the template for hda_bus information
498 * @busp: the pointer to store the created bus instance
499 *
500 * Returns 0 if successful, or a negative error code.
501 */
1289e9e8 502int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
756e2b01
TI		 503 const struct hda_bus_template *temp,
504 struct hda_bus **busp)
1da177e4
LT		 505{
506 struct hda_bus *bus;
507 int err;
c8b6bf9b 508 static struct snd_device_ops dev_ops = {
d7ffba19 509 .dev_register = snd_hda_bus_dev_register,
1da177e4
LT		 510 .dev_free = snd_hda_bus_dev_free,
511 };
512
da3cec35
TI		 513 if (snd_BUG_ON(!temp))
514 return -EINVAL;
515 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
516 return -EINVAL;
1da177e4
LT		 517
518 if (busp)
519 *busp = NULL;
520
e560d8d8 521 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1da177e4
LT		 522 if (bus == NULL) {
523 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
524 return -ENOMEM;
525 }
526
527 bus->card = card;
528 bus->private_data = temp->private_data;
529 bus->pci = temp->pci;
530 bus->modelname = temp->modelname;
fee2fba3 531 bus->power_save = temp->power_save;
1da177e4
LT		 532 bus->ops = temp->ops;
533
62932df8 534 mutex_init(&bus->cmd_mutex);
1da177e4
LT		 535 INIT_LIST_HEAD(&bus->codec_list);
536
e8c0ee5d
TI		 537 snprintf(bus->workq_name, sizeof(bus->workq_name),
538 "hd-audio%d", card->number);
539 bus->workq = create_singlethread_workqueue(bus->workq_name);
6acaed38 540 if (!bus->workq) {
e8c0ee5d
TI		 541 snd_printk(KERN_ERR "cannot create workqueue %s\n",
542 bus->workq_name);
6acaed38
TI		 543 kfree(bus);
544 return -ENOMEM;
545 }
546
0ba21762
TI		 547 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
548 if (err < 0) {
1da177e4
LT		 549 snd_hda_bus_free(bus);
550 return err;
551 }
552 if (busp)
553 *busp = bus;
554 return 0;
555}
ff7a3267 556EXPORT_SYMBOL_HDA(snd_hda_bus_new);
1da177e4 557
82467611
TI		 558#ifdef CONFIG_SND_HDA_GENERIC
559#define is_generic_config(codec) \
f44ac837 560 (codec->modelname && !strcmp(codec->modelname, "generic"))
82467611
TI		 561#else
562#define is_generic_config(codec) 0
563#endif
564
645f10c1 565#ifdef MODULE
1289e9e8
TI		 566#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
567#else
645f10c1 568#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
1289e9e8
TI		 569#endif
570
1da177e4
LT		 571/*
572 * find a matching codec preset
573 */
6c1f45ea 574static const struct hda_codec_preset *
756e2b01 575find_codec_preset(struct hda_codec *codec)
1da177e4 576{
1289e9e8
TI		 577 struct hda_codec_preset_list *tbl;
578 const struct hda_codec_preset *preset;
579 int mod_requested = 0;
1da177e4 580
82467611 581 if (is_generic_config(codec))
d5ad630b
TI		 582 return NULL; /* use the generic parser */
583
1289e9e8
TI		 584 again:
585 mutex_lock(&preset_mutex);
586 list_for_each_entry(tbl, &hda_preset_tables, list) {
587 if (!try_module_get(tbl->owner)) {
588 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
589 continue;
590 }
591 for (preset = tbl->preset; preset->id; preset++) {
1da177e4 592 u32 mask = preset->mask;
ca7cfae9
MB		 593 if (preset->afg && preset->afg != codec->afg)
594 continue;
595 if (preset->mfg && preset->mfg != codec->mfg)
596 continue;
0ba21762 597 if (!mask)
1da177e4 598 mask = ~0;
9c7f852e 599 if (preset->id == (codec->vendor_id & mask) &&
0ba21762 600 (!preset->rev ||
1289e9e8
TI		 601 preset->rev == codec->revision_id)) {
602 mutex_unlock(&preset_mutex);
603 codec->owner = tbl->owner;
1da177e4 604 return preset;
1289e9e8 605 }
1da177e4 606 }
1289e9e8
TI		 607 module_put(tbl->owner);
608 }
609 mutex_unlock(&preset_mutex);
610
611 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
612 char name[32];
613 if (!mod_requested)
614 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
615 codec->vendor_id);
616 else
617 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
618 (codec->vendor_id >> 16) & 0xffff);
619 request_module(name);
620 mod_requested++;
621 goto again;
1da177e4
LT		 622 }
623 return NULL;
624}
625
626/*
f44ac837 627 * get_codec_name - store the codec name
1da177e4 628 */
f44ac837 629static int get_codec_name(struct hda_codec *codec)
1da177e4
LT		 630{
631 const struct hda_vendor_id *c;
632 const char *vendor = NULL;
633 u16 vendor_id = codec->vendor_id >> 16;
812a2cca
TI		 634 char tmp[16];
635
636 if (codec->vendor_name)
637 goto get_chip_name;
1da177e4
LT		 638
639 for (c = hda_vendor_ids; c->id; c++) {
640 if (c->id == vendor_id) {
641 vendor = c->name;
642 break;
643 }
644 }
0ba21762 645 if (!vendor) {
1da177e4
LT		 646 sprintf(tmp, "Generic %04x", vendor_id);
647 vendor = tmp;
648 }
812a2cca
TI		 649 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
650 if (!codec->vendor_name)
651 return -ENOMEM;
652
653 get_chip_name:
654 if (codec->chip_name)
655 return 0;
656
1da177e4 657 if (codec->preset && codec->preset->name)
812a2cca
TI		 658 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
659 else {
660 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
661 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
662 }
663 if (!codec->chip_name)
f44ac837
TI		 664 return -ENOMEM;
665 return 0;
1da177e4
LT		 666}
667
668/*
673b683a 669 * look for an AFG and MFG nodes
1da177e4 670 */
1289e9e8 671static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
1da177e4 672{
93e82ae7 673 int i, total_nodes, function_id;
1da177e4
LT		 674 hda_nid_t nid;
675
676 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
677 for (i = 0; i < total_nodes; i++, nid++) {
93e82ae7 678 function_id = snd_hda_param_read(codec, nid,
234b4346 679 AC_PAR_FUNCTION_TYPE) & 0xff;
93e82ae7 680 switch (function_id) {
673b683a
SK		 681 case AC_GRP_AUDIO_FUNCTION:
682 codec->afg = nid;
93e82ae7 683 codec->function_id = function_id;
673b683a
SK		 684 break;
685 case AC_GRP_MODEM_FUNCTION:
686 codec->mfg = nid;
93e82ae7 687 codec->function_id = function_id;
673b683a
SK		 688 break;
689 default:
690 break;
691 }
1da177e4 692 }
1da177e4
LT		 693}
694
54d17403
TI		 695/*
696 * read widget caps for each widget and store in cache
697 */
698static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
699{
700 int i;
701 hda_nid_t nid;
702
703 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
704 &codec->start_nid);
705 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
0ba21762 706 if (!codec->wcaps)
54d17403
TI		 707 return -ENOMEM;
708 nid = codec->start_nid;
709 for (i = 0; i < codec->num_nodes; i++, nid++)
710 codec->wcaps[i] = snd_hda_param_read(codec, nid,
711 AC_PAR_AUDIO_WIDGET_CAP);
712 return 0;
713}
714
3be14149
TI		 715/* read all pin default configurations and save codec->init_pins */
716static int read_pin_defaults(struct hda_codec *codec)
717{
718 int i;
719 hda_nid_t nid = codec->start_nid;
720
721 for (i = 0; i < codec->num_nodes; i++, nid++) {
722 struct hda_pincfg *pin;
723 unsigned int wcaps = get_wcaps(codec, nid);
724 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
725 AC_WCAP_TYPE_SHIFT;
726 if (wid_type != AC_WID_PIN)
727 continue;
728 pin = snd_array_new(&codec->init_pins);
729 if (!pin)
730 return -ENOMEM;
731 pin->nid = nid;
732 pin->cfg = snd_hda_codec_read(codec, nid, 0,
733 AC_VERB_GET_CONFIG_DEFAULT, 0);
734 }
735 return 0;
736}
737
738/* look up the given pin config list and return the item matching with NID */
739static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
740 struct snd_array *array,
741 hda_nid_t nid)
742{
743 int i;
744 for (i = 0; i < array->used; i++) {
745 struct hda_pincfg *pin = snd_array_elem(array, i);
746 if (pin->nid == nid)
747 return pin;
748 }
749 return NULL;
750}
751
752/* write a config value for the given NID */
753static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
754 unsigned int cfg)
755{
756 int i;
757 for (i = 0; i < 4; i++) {
758 snd_hda_codec_write(codec, nid, 0,
759 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
760 cfg & 0xff);
761 cfg >>= 8;
762 }
763}
764
765/* set the current pin config value for the given NID.
766 * the value is cached, and read via snd_hda_codec_get_pincfg()
767 */
768int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
769 hda_nid_t nid, unsigned int cfg)
770{
771 struct hda_pincfg *pin;
5e7b8e0d 772 unsigned int oldcfg;
3be14149 773
5e7b8e0d 774 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
3be14149
TI		 775 pin = look_up_pincfg(codec, list, nid);
776 if (!pin) {
777 pin = snd_array_new(list);
778 if (!pin)
779 return -ENOMEM;
780 pin->nid = nid;
781 }
782 pin->cfg = cfg;
5e7b8e0d
TI		 783
784 /* change only when needed; e.g. if the pincfg is already present
785 * in user_pins[], don't write it
786 */
787 cfg = snd_hda_codec_get_pincfg(codec, nid);
788 if (oldcfg != cfg)
789 set_pincfg(codec, nid, cfg);
3be14149
TI		 790 return 0;
791}
792
793int snd_hda_codec_set_pincfg(struct hda_codec *codec,
794 hda_nid_t nid, unsigned int cfg)
795{
346ff70f 796 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
3be14149
TI		 797}
798EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
799
800/* get the current pin config value of the given pin NID */
801unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
802{
803 struct hda_pincfg *pin;
804
3be14149 805#ifdef CONFIG_SND_HDA_HWDEP
346ff70f 806 pin = look_up_pincfg(codec, &codec->user_pins, nid);
3be14149
TI		 807 if (pin)
808 return pin->cfg;
809#endif
5e7b8e0d
TI		 810 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
811 if (pin)
812 return pin->cfg;
3be14149
TI		 813 pin = look_up_pincfg(codec, &codec->init_pins, nid);
814 if (pin)
815 return pin->cfg;
816 return 0;
817}
818EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
819
820/* restore all current pin configs */
821static void restore_pincfgs(struct hda_codec *codec)
822{
823 int i;
824 for (i = 0; i < codec->init_pins.used; i++) {
825 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
826 set_pincfg(codec, pin->nid,
827 snd_hda_codec_get_pincfg(codec, pin->nid));
828 }
829}
54d17403 830
01751f54
TI		 831static void init_hda_cache(struct hda_cache_rec *cache,
832 unsigned int record_size);
1fcaee6e 833static void free_hda_cache(struct hda_cache_rec *cache);
01751f54 834
3be14149
TI		 835/* restore the initial pin cfgs and release all pincfg lists */
836static void restore_init_pincfgs(struct hda_codec *codec)
837{
346ff70f 838 /* first free driver_pins and user_pins, then call restore_pincfg
3be14149
TI		 839 * so that only the values in init_pins are restored
840 */
346ff70f 841 snd_array_free(&codec->driver_pins);
3be14149 842#ifdef CONFIG_SND_HDA_HWDEP
346ff70f 843 snd_array_free(&codec->user_pins);
3be14149
TI		 844#endif
845 restore_pincfgs(codec);
846 snd_array_free(&codec->init_pins);
847}
848
1da177e4
LT		 849/*
850 * codec destructor
851 */
852static void snd_hda_codec_free(struct hda_codec *codec)
853{
0ba21762 854 if (!codec)
1da177e4 855 return;
3be14149 856 restore_init_pincfgs(codec);
cb53c626
TI		 857#ifdef CONFIG_SND_HDA_POWER_SAVE
858 cancel_delayed_work(&codec->power_work);
6acaed38 859 flush_workqueue(codec->bus->workq);
cb53c626 860#endif
1da177e4 861 list_del(&codec->list);
d13bd412 862 snd_array_free(&codec->mixers);
1da177e4
LT		 863 codec->bus->caddr_tbl[codec->addr] = NULL;
864 if (codec->patch_ops.free)
865 codec->patch_ops.free(codec);
1289e9e8 866 module_put(codec->owner);
01751f54 867 free_hda_cache(&codec->amp_cache);
b3ac5636 868 free_hda_cache(&codec->cmd_cache);
812a2cca
TI		 869 kfree(codec->vendor_name);
870 kfree(codec->chip_name);
f44ac837 871 kfree(codec->modelname);
54d17403 872 kfree(codec->wcaps);
1da177e4
LT		 873 kfree(codec);
874}
875
bb6ac72f
TI		 876static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
877 unsigned int power_state);
878
1da177e4
LT		 879/**
880 * snd_hda_codec_new - create a HDA codec
881 * @bus: the bus to assign
882 * @codec_addr: the codec address
883 * @codecp: the pointer to store the generated codec
884 *
885 * Returns 0 if successful, or a negative error code.
886 */
1289e9e8 887int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
a1e21c90 888 struct hda_codec **codecp)
1da177e4
LT		 889{
890 struct hda_codec *codec;
ba443687 891 char component[31];
1da177e4
LT		 892 int err;
893
da3cec35
TI		 894 if (snd_BUG_ON(!bus))
895 return -EINVAL;
896 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
897 return -EINVAL;
1da177e4
LT		 898
899 if (bus->caddr_tbl[codec_addr]) {
0ba21762
TI		 900 snd_printk(KERN_ERR "hda_codec: "
901 "address 0x%x is already occupied\n", codec_addr);
1da177e4
LT		 902 return -EBUSY;
903 }
904
e560d8d8 905 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1da177e4
LT		 906 if (codec == NULL) {
907 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
908 return -ENOMEM;
909 }
910
911 codec->bus = bus;
912 codec->addr = codec_addr;
62932df8 913 mutex_init(&codec->spdif_mutex);
5a9e02e9 914 mutex_init(&codec->control_mutex);
01751f54 915 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
b3ac5636 916 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
d13bd412 917 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
3be14149 918 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
346ff70f 919 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
6c1f45ea
TI		 920 if (codec->bus->modelname) {
921 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
922 if (!codec->modelname) {
923 snd_hda_codec_free(codec);
924 return -ENODEV;
925 }
926 }
1da177e4 927
cb53c626
TI		 928#ifdef CONFIG_SND_HDA_POWER_SAVE
929 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
930 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
931 * the caller has to power down appropriatley after initialization
932 * phase.
933 */
934 hda_keep_power_on(codec);
935#endif
936
1da177e4
LT		 937 list_add_tail(&codec->list, &bus->codec_list);
938 bus->caddr_tbl[codec_addr] = codec;
939
0ba21762
TI		 940 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
941 AC_PAR_VENDOR_ID);
111d3af5
TI		 942 if (codec->vendor_id == -1)
943 /* read again, hopefully the access method was corrected
944 * in the last read...
945 */
946 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
947 AC_PAR_VENDOR_ID);
0ba21762
TI		 948 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
949 AC_PAR_SUBSYSTEM_ID);
950 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
951 AC_PAR_REV_ID);
1da177e4 952
673b683a 953 setup_fg_nodes(codec);
0ba21762 954 if (!codec->afg && !codec->mfg) {
673b683a 955 snd_printdd("hda_codec: no AFG or MFG node found\n");
3be14149
TI		 956 err = -ENODEV;
957 goto error;
1da177e4
LT		 958 }
959
3be14149
TI		 960 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
961 if (err < 0) {
54d17403 962 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
3be14149 963 goto error;
54d17403 964 }
3be14149
TI		 965 err = read_pin_defaults(codec);
966 if (err < 0)
967 goto error;
54d17403 968
0ba21762 969 if (!codec->subsystem_id) {
86284e45 970 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
0ba21762
TI		 971 codec->subsystem_id =
972 snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_SUBSYSTEM_ID, 0);
86284e45
TI		 974 }
975
bb6ac72f
TI		 976 /* power-up all before initialization */
977 hda_set_power_state(codec,
978 codec->afg ? codec->afg : codec->mfg,
979 AC_PWRST_D0);
980
6c1f45ea
TI		 981 snd_hda_codec_proc_new(codec);
982
6c1f45ea 983 snd_hda_create_hwdep(codec);
6c1f45ea
TI		 984
985 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
986 codec->subsystem_id, codec->revision_id);
987 snd_component_add(codec->bus->card, component);
988
989 if (codecp)
990 *codecp = codec;
991 return 0;
3be14149
TI		 992
993 error:
994 snd_hda_codec_free(codec);
995 return err;
6c1f45ea 996}
ff7a3267 997EXPORT_SYMBOL_HDA(snd_hda_codec_new);
6c1f45ea
TI		 998
999int snd_hda_codec_configure(struct hda_codec *codec)
1000{
1001 int err;
1002
d5ad630b 1003 codec->preset = find_codec_preset(codec);
812a2cca 1004 if (!codec->vendor_name || !codec->chip_name) {
f44ac837
TI		 1005 err = get_codec_name(codec);
1006 if (err < 0)
1007 return err;
1008 }
43ea1d47 1009 /* audio codec should override the mixer name */
f44ac837 1010 if (codec->afg || !*codec->bus->card->mixername)
812a2cca
TI		 1011 snprintf(codec->bus->card->mixername,
1012 sizeof(codec->bus->card->mixername),
1013 "%s %s", codec->vendor_name, codec->chip_name);
1da177e4 1014
82467611 1015 if (is_generic_config(codec)) {
1da177e4 1016 err = snd_hda_parse_generic_codec(codec);
82467611
TI		 1017 goto patched;
1018 }
82467611
TI		 1019 if (codec->preset && codec->preset->patch) {
1020 err = codec->preset->patch(codec);
1021 goto patched;
1022 }
1023
1024 /* call the default parser */
82467611 1025 err = snd_hda_parse_generic_codec(codec);
35a1e0cc
TI		 1026 if (err < 0)
1027 printk(KERN_ERR "hda-codec: No codec parser is available\n");
82467611
TI		 1028
1029 patched:
6c1f45ea
TI		 1030 if (!err && codec->patch_ops.unsol_event)
1031 err = init_unsol_queue(codec->bus);
1032 return err;
1da177e4 1033}
a1e21c90 1034EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1da177e4
LT		 1035
1036/**
1037 * snd_hda_codec_setup_stream - set up the codec for streaming
1038 * @codec: the CODEC to set up
1039 * @nid: the NID to set up
1040 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1041 * @channel_id: channel id to pass, zero based.
1042 * @format: stream format.
1043 */
0ba21762
TI		 1044void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1045 u32 stream_tag,
1da177e4
LT		 1046 int channel_id, int format)
1047{
0ba21762 1048 if (!nid)
d21b37ea
TI		 1049 return;
1050
0ba21762
TI		 1051 snd_printdd("hda_codec_setup_stream: "
1052 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1da177e4
LT		 1053 nid, stream_tag, channel_id, format);
1054 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1055 (stream_tag << 4) | channel_id);
1056 msleep(1);
1057 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1058}
ff7a3267 1059EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1da177e4 1060
888afa15
TI		 1061void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1062{
1063 if (!nid)
1064 return;
1065
1066 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1067 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1068#if 0 /* keep the format */
1069 msleep(1);
1070 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1071#endif
1072}
ff7a3267 1073EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
888afa15 1074
1da177e4
LT		 1075/*
1076 * amp access functions
1077 */
1078
4a19faee
TI		 1079/* FIXME: more better hash key? */
1080#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1081#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1082#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1083#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1084#define INFO_AMP_CAPS (1<<0)
4a19faee 1085#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1086
1087/* initialize the hash table */
1289e9e8 1088static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1089 unsigned int record_size)
1090{
1091 memset(cache, 0, sizeof(*cache));
1092 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1093 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1094}
1095
1fcaee6e 1096static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1097{
603c4019 1098 snd_array_free(&cache->buf);
1da177e4
LT		 1099}
1100
1101/* query the hash. allocate an entry if not found. */
01751f54
TI		 1102static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1103 u32 key)
1da177e4 1104{
01751f54
TI		 1105 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1106 u16 cur = cache->hash[idx];
1107 struct hda_cache_head *info;
1da177e4
LT		 1108
1109 while (cur != 0xffff) {
f43aa025 1110 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1111 if (info->key == key)
1112 return info;
1113 cur = info->next;
1114 }
1115
1116 /* add a new hash entry */
603c4019 1117 info = snd_array_new(&cache->buf);
c217429b
TI		 1118 if (!info)
1119 return NULL;
f43aa025 1120 cur = snd_array_index(&cache->buf, info);
1da177e4 1121 info->key = key;
01751f54
TI		 1122 info->val = 0;
1123 info->next = cache->hash[idx];
1124 cache->hash[idx] = cur;
1da177e4
LT		 1125
1126 return info;
1127}
1128
01751f54
TI		 1129/* query and allocate an amp hash entry */
1130static inline struct hda_amp_info *
1131get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1132{
1133 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1134}
1135
1da177e4
LT		 1136/*
1137 * query AMP capabilities for the given widget and direction
1138 */
09a99959 1139u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1140{
0ba21762 1141 struct hda_amp_info *info;
1da177e4 1142
0ba21762
TI		 1143 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1144 if (!info)
1da177e4 1145 return 0;
01751f54 1146 if (!(info->head.val & INFO_AMP_CAPS)) {
0ba21762 1147 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1da177e4 1148 nid = codec->afg;
0ba21762
TI		 1149 info->amp_caps = snd_hda_param_read(codec, nid,
1150 direction == HDA_OUTPUT ?
1151 AC_PAR_AMP_OUT_CAP :
1152 AC_PAR_AMP_IN_CAP);
b75e53f0 1153 if (info->amp_caps)
01751f54 1154 info->head.val |= INFO_AMP_CAPS;
1da177e4
LT		 1155 }
1156 return info->amp_caps;
1157}
ff7a3267 1158EXPORT_SYMBOL_HDA(query_amp_caps);
1da177e4 1159
897cc188
TI		 1160int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1161 unsigned int caps)
1162{
1163 struct hda_amp_info *info;
1164
1165 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1166 if (!info)
1167 return -EINVAL;
1168 info->amp_caps = caps;
01751f54 1169 info->head.val |= INFO_AMP_CAPS;
897cc188
TI		 1170 return 0;
1171}
ff7a3267 1172EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1327a32b 1173
92c7c8a7
TI		 1174static unsigned int
1175query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1176 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1327a32b
TI		 1177{
1178 struct hda_amp_info *info;
1179
92c7c8a7 1180 info = get_alloc_amp_hash(codec, key);
1327a32b
TI		 1181 if (!info)
1182 return 0;
1183 if (!info->head.val) {
1327a32b 1184 info->head.val |= INFO_AMP_CAPS;
92c7c8a7 1185 info->amp_caps = func(codec, nid);
1327a32b
TI		 1186 }
1187 return info->amp_caps;
1188}
92c7c8a7
TI		 1189
1190static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1191{
1192 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1193}
1194
1195u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1196{
1197 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1198 read_pin_cap);
1199}
1327a32b 1200EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
897cc188 1201
1da177e4
LT		 1202/*
1203 * read the current volume to info
4a19faee 1204 * if the cache exists, read the cache value.
1da177e4 1205 */
0ba21762
TI		 1206static unsigned int get_vol_mute(struct hda_codec *codec,
1207 struct hda_amp_info *info, hda_nid_t nid,
1208 int ch, int direction, int index)
1da177e4
LT		 1209{
1210 u32 val, parm;
1211
01751f54 1212 if (info->head.val & INFO_AMP_VOL(ch))
4a19faee 1213 return info->vol[ch];
1da177e4
LT		 1214
1215 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1216 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1217 parm |= index;
0ba21762
TI		 1218 val = snd_hda_codec_read(codec, nid, 0,
1219 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1da177e4 1220 info->vol[ch] = val & 0xff;
01751f54 1221 info->head.val |= INFO_AMP_VOL(ch);
4a19faee 1222 return info->vol[ch];
1da177e4
LT		 1223}
1224
1225/*
4a19faee 1226 * write the current volume in info to the h/w and update the cache
1da177e4 1227 */
4a19faee 1228static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
0ba21762
TI		 1229 hda_nid_t nid, int ch, int direction, int index,
1230 int val)
1da177e4
LT		 1231{
1232 u32 parm;
1233
1234 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1235 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1236 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1237 parm |= val;
1238 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
4a19faee 1239 info->vol[ch] = val;
1da177e4
LT		 1240}
1241
1242/*
4a19faee 1243 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 1244 */
834be88d
TI		 1245int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1246 int direction, int index)
1da177e4 1247{
0ba21762
TI		 1248 struct hda_amp_info *info;
1249 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1250 if (!info)
1da177e4 1251 return 0;
4a19faee 1252 return get_vol_mute(codec, info, nid, ch, direction, index);
1da177e4 1253}
ff7a3267 1254EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1da177e4 1255
4a19faee
TI		 1256/*
1257 * update the AMP value, mask = bit mask to set, val = the value
1258 */
834be88d
TI		 1259int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1260 int direction, int idx, int mask, int val)
1da177e4 1261{
0ba21762 1262 struct hda_amp_info *info;
4a19faee 1263
0ba21762
TI		 1264 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1265 if (!info)
1da177e4 1266 return 0;
4a19faee
TI		 1267 val &= mask;
1268 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
82beb8fd 1269 if (info->vol[ch] == val)
1da177e4 1270 return 0;
4a19faee 1271 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1da177e4
LT		 1272 return 1;
1273}
ff7a3267 1274EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1da177e4 1275
47fd830a
TI		 1276/*
1277 * update the AMP stereo with the same mask and value
1278 */
1279int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1280 int direction, int idx, int mask, int val)
1281{
1282 int ch, ret = 0;
1283 for (ch = 0; ch < 2; ch++)
1284 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1285 idx, mask, val);
1286 return ret;
1287}
ff7a3267 1288EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
47fd830a 1289
cb53c626 1290#ifdef SND_HDA_NEEDS_RESUME
b3ac5636
TI		 1291/* resume the all amp commands from the cache */
1292void snd_hda_codec_resume_amp(struct hda_codec *codec)
1293{
603c4019 1294 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
b3ac5636
TI		 1295 int i;
1296
603c4019 1297 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 1298 u32 key = buffer->head.key;
1299 hda_nid_t nid;
1300 unsigned int idx, dir, ch;
1301 if (!key)
1302 continue;
1303 nid = key & 0xff;
1304 idx = (key >> 16) & 0xff;
1305 dir = (key >> 24) & 0xff;
1306 for (ch = 0; ch < 2; ch++) {
1307 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1308 continue;
1309 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1310 buffer->vol[ch]);
1311 }
1312 }
1313}
ff7a3267 1314EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
cb53c626 1315#endif /* SND_HDA_NEEDS_RESUME */
1da177e4 1316
1da177e4 1317/* volume */
0ba21762
TI		 1318int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1319 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1320{
1321 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1322 u16 nid = get_amp_nid(kcontrol);
1323 u8 chs = get_amp_channels(kcontrol);
1324 int dir = get_amp_direction(kcontrol);
29fdbec2 1325 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1326 u32 caps;
1327
1328 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 1329 /* num steps */
1330 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1331 if (!caps) {
1332 printk(KERN_WARNING "hda_codec: "
9c8f2abd
TI		 1333 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1334 kcontrol->id.name);
1da177e4
LT		 1335 return -EINVAL;
1336 }
29fdbec2
TI		 1337 if (ofs < caps)
1338 caps -= ofs;
1da177e4
LT		 1339 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1340 uinfo->count = chs == 3 ? 2 : 1;
1341 uinfo->value.integer.min = 0;
1342 uinfo->value.integer.max = caps;
1343 return 0;
1344}
ff7a3267 1345EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1da177e4 1346
29fdbec2
TI		 1347
1348static inline unsigned int
1349read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1350 int ch, int dir, int idx, unsigned int ofs)
1351{
1352 unsigned int val;
1353 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1354 val &= HDA_AMP_VOLMASK;
1355 if (val >= ofs)
1356 val -= ofs;
1357 else
1358 val = 0;
1359 return val;
1360}
1361
1362static inline int
1363update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1364 int ch, int dir, int idx, unsigned int ofs,
1365 unsigned int val)
1366{
1367 if (val > 0)
1368 val += ofs;
1369 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1370 HDA_AMP_VOLMASK, val);
1371}
1372
0ba21762
TI		 1373int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1374 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1375{
1376 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1377 hda_nid_t nid = get_amp_nid(kcontrol);
1378 int chs = get_amp_channels(kcontrol);
1379 int dir = get_amp_direction(kcontrol);
1380 int idx = get_amp_index(kcontrol);
29fdbec2 1381 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1382 long *valp = ucontrol->value.integer.value;
1383
1384 if (chs & 1)
29fdbec2 1385 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 1386 if (chs & 2)
29fdbec2 1387 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 1388 return 0;
1389}
ff7a3267 1390EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1da177e4 1391
0ba21762
TI		 1392int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1393 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1394{
1395 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1396 hda_nid_t nid = get_amp_nid(kcontrol);
1397 int chs = get_amp_channels(kcontrol);
1398 int dir = get_amp_direction(kcontrol);
1399 int idx = get_amp_index(kcontrol);
29fdbec2 1400 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1401 long *valp = ucontrol->value.integer.value;
1402 int change = 0;
1403
cb53c626 1404 snd_hda_power_up(codec);
b9f5a89c 1405 if (chs & 1) {
29fdbec2 1406 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 1407 valp++;
1408 }
4a19faee 1409 if (chs & 2)
29fdbec2 1410 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
cb53c626 1411 snd_hda_power_down(codec);
1da177e4
LT		 1412 return change;
1413}
ff7a3267 1414EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1da177e4 1415
302e9c5a
JK		 1416int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1417 unsigned int size, unsigned int __user *_tlv)
1418{
1419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1420 hda_nid_t nid = get_amp_nid(kcontrol);
1421 int dir = get_amp_direction(kcontrol);
29fdbec2 1422 unsigned int ofs = get_amp_offset(kcontrol);
302e9c5a
JK		 1423 u32 caps, val1, val2;
1424
1425 if (size < 4 * sizeof(unsigned int))
1426 return -ENOMEM;
1427 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 1428 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1429 val2 = (val2 + 1) * 25;
302e9c5a 1430 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 1431 val1 += ofs;
302e9c5a 1432 val1 = ((int)val1) * ((int)val2);
302e9c5a
JK		 1433 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1434 return -EFAULT;
1435 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1436 return -EFAULT;
1437 if (put_user(val1, _tlv + 2))
1438 return -EFAULT;
1439 if (put_user(val2, _tlv + 3))
1440 return -EFAULT;
1441 return 0;
1442}
ff7a3267 1443EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
302e9c5a 1444
2134ea4f
TI		 1445/*
1446 * set (static) TLV for virtual master volume; recalculated as max 0dB
1447 */
1448void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1449 unsigned int *tlv)
1450{
1451 u32 caps;
1452 int nums, step;
1453
1454 caps = query_amp_caps(codec, nid, dir);
1455 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1456 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1457 step = (step + 1) * 25;
1458 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1459 tlv[1] = 2 * sizeof(unsigned int);
1460 tlv[2] = -nums * step;
1461 tlv[3] = step;
1462}
ff7a3267 1463EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 1464
1465/* find a mixer control element with the given name */
09f99701
TI		 1466static struct snd_kcontrol *
1467_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1468 const char *name, int idx)
2134ea4f
TI		 1469{
1470 struct snd_ctl_elem_id id;
1471 memset(&id, 0, sizeof(id));
1472 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
09f99701 1473 id.index = idx;
18cb7109
TI		 1474 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1475 return NULL;
2134ea4f
TI		 1476 strcpy(id.name, name);
1477 return snd_ctl_find_id(codec->bus->card, &id);
1478}
1479
09f99701
TI		 1480struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1481 const char *name)
1482{
1483 return _snd_hda_find_mixer_ctl(codec, name, 0);
1484}
ff7a3267 1485EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
09f99701 1486
d13bd412
TI		 1487/* Add a control element and assign to the codec */
1488int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1489{
1490 int err;
1491 struct snd_kcontrol **knewp;
1492
1493 err = snd_ctl_add(codec->bus->card, kctl);
1494 if (err < 0)
1495 return err;
1496 knewp = snd_array_new(&codec->mixers);
1497 if (!knewp)
1498 return -ENOMEM;
1499 *knewp = kctl;
1500 return 0;
1501}
ff7a3267 1502EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
d13bd412
TI		 1503
1504/* Clear all controls assigned to the given codec */
1505void snd_hda_ctls_clear(struct hda_codec *codec)
1506{
1507 int i;
1508 struct snd_kcontrol **kctls = codec->mixers.list;
1509 for (i = 0; i < codec->mixers.used; i++)
1510 snd_ctl_remove(codec->bus->card, kctls[i]);
1511 snd_array_free(&codec->mixers);
1512}
1513
a65d629c
TI		 1514/* pseudo device locking
1515 * toggle card->shutdown to allow/disallow the device access (as a hack)
1516 */
1517static int hda_lock_devices(struct snd_card *card)
6c1f45ea 1518{
a65d629c
TI		 1519 spin_lock(&card->files_lock);
1520 if (card->shutdown) {
1521 spin_unlock(&card->files_lock);
1522 return -EINVAL;
1523 }
1524 card->shutdown = 1;
1525 spin_unlock(&card->files_lock);
1526 return 0;
1527}
1528
1529static void hda_unlock_devices(struct snd_card *card)
1530{
1531 spin_lock(&card->files_lock);
1532 card->shutdown = 0;
1533 spin_unlock(&card->files_lock);
1534}
1535
1536int snd_hda_codec_reset(struct hda_codec *codec)
1537{
1538 struct snd_card *card = codec->bus->card;
1539 int i, pcm;
1540
1541 if (hda_lock_devices(card) < 0)
1542 return -EBUSY;
1543 /* check whether the codec isn't used by any mixer or PCM streams */
1544 if (!list_empty(&card->ctl_files)) {
1545 hda_unlock_devices(card);
1546 return -EBUSY;
1547 }
1548 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1549 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1550 if (!cpcm->pcm)
1551 continue;
1552 if (cpcm->pcm->streams[0].substream_opened ||
1553 cpcm->pcm->streams[1].substream_opened) {
1554 hda_unlock_devices(card);
1555 return -EBUSY;
1556 }
1557 }
1558
1559 /* OK, let it free */
6c1f45ea
TI		 1560
1561#ifdef CONFIG_SND_HDA_POWER_SAVE
1562 cancel_delayed_work(&codec->power_work);
6acaed38 1563 flush_workqueue(codec->bus->workq);
6c1f45ea
TI		 1564#endif
1565 snd_hda_ctls_clear(codec);
1566 /* relase PCMs */
1567 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 1568 if (codec->pcm_info[i].pcm) {
a65d629c 1569 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4
TI		 1570 clear_bit(codec->pcm_info[i].device,
1571 codec->bus->pcm_dev_bits);
1572 }
6c1f45ea
TI		 1573 }
1574 if (codec->patch_ops.free)
1575 codec->patch_ops.free(codec);
56d17712 1576 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 1577 codec->spec = NULL;
1578 free_hda_cache(&codec->amp_cache);
1579 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 1580 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1581 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 1582 /* free only driver_pins so that init_pins + user_pins are restored */
1583 snd_array_free(&codec->driver_pins);
3be14149 1584 restore_pincfgs(codec);
6c1f45ea
TI		 1585 codec->num_pcms = 0;
1586 codec->pcm_info = NULL;
1587 codec->preset = NULL;
d1f1af2d
TI		 1588 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1589 codec->slave_dig_outs = NULL;
1590 codec->spdif_status_reset = 0;
1289e9e8
TI		 1591 module_put(codec->owner);
1592 codec->owner = NULL;
a65d629c
TI		 1593
1594 /* allow device access again */
1595 hda_unlock_devices(card);
1596 return 0;
6c1f45ea
TI		 1597}
1598
2134ea4f
TI		 1599/* create a virtual master control and add slaves */
1600int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1601 unsigned int *tlv, const char **slaves)
1602{
1603 struct snd_kcontrol *kctl;
1604 const char **s;
1605 int err;
1606
2f085549
TI		 1607 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1608 ;
1609 if (!*s) {
1610 snd_printdd("No slave found for %s\n", name);
1611 return 0;
1612 }
2134ea4f
TI		 1613 kctl = snd_ctl_make_virtual_master(name, tlv);
1614 if (!kctl)
1615 return -ENOMEM;
d13bd412 1616 err = snd_hda_ctl_add(codec, kctl);
2134ea4f
TI		 1617 if (err < 0)
1618 return err;
1619
1620 for (s = slaves; *s; s++) {
1621 struct snd_kcontrol *sctl;
7a411ee0
TI		 1622 int i = 0;
1623 for (;;) {
1624 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1625 if (!sctl) {
1626 if (!i)
1627 snd_printdd("Cannot find slave %s, "
1628 "skipped\n", *s);
1629 break;
1630 }
1631 err = snd_ctl_add_slave(kctl, sctl);
1632 if (err < 0)
1633 return err;
1634 i++;
2134ea4f 1635 }
2134ea4f
TI		 1636 }
1637 return 0;
1638}
ff7a3267 1639EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2134ea4f 1640
1da177e4 1641/* switch */
0ba21762
TI		 1642int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1643 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1644{
1645 int chs = get_amp_channels(kcontrol);
1646
1647 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1648 uinfo->count = chs == 3 ? 2 : 1;
1649 uinfo->value.integer.min = 0;
1650 uinfo->value.integer.max = 1;
1651 return 0;
1652}
ff7a3267 1653EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 1654
0ba21762
TI		 1655int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1656 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1657{
1658 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1659 hda_nid_t nid = get_amp_nid(kcontrol);
1660 int chs = get_amp_channels(kcontrol);
1661 int dir = get_amp_direction(kcontrol);
1662 int idx = get_amp_index(kcontrol);
1663 long *valp = ucontrol->value.integer.value;
1664
1665 if (chs & 1)
0ba21762 1666 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 1667 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 1668 if (chs & 2)
0ba21762 1669 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 1670 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 1671 return 0;
1672}
ff7a3267 1673EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 1674
0ba21762
TI		 1675int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1676 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1677{
1678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1679 hda_nid_t nid = get_amp_nid(kcontrol);
1680 int chs = get_amp_channels(kcontrol);
1681 int dir = get_amp_direction(kcontrol);
1682 int idx = get_amp_index(kcontrol);
1da177e4
LT		 1683 long *valp = ucontrol->value.integer.value;
1684 int change = 0;
1685
cb53c626 1686 snd_hda_power_up(codec);
b9f5a89c 1687 if (chs & 1) {
4a19faee 1688 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 1689 HDA_AMP_MUTE,
1690 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 1691 valp++;
1692 }
4a19faee
TI		 1693 if (chs & 2)
1694 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 1695 HDA_AMP_MUTE,
1696 *valp ? 0 : HDA_AMP_MUTE);
cb53c626
TI		 1697#ifdef CONFIG_SND_HDA_POWER_SAVE
1698 if (codec->patch_ops.check_power_status)
1699 codec->patch_ops.check_power_status(codec, nid);
1700#endif
1701 snd_hda_power_down(codec);
1da177e4
LT		 1702 return change;
1703}
ff7a3267 1704EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 1705
985be54b
TI		 1706/*
1707 * bound volume controls
1708 *
1709 * bind multiple volumes (# indices, from 0)
1710 */
1711
1712#define AMP_VAL_IDX_SHIFT 19
1713#define AMP_VAL_IDX_MASK (0x0f<<19)
1714
0ba21762
TI		 1715int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1716 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1717{
1718 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1719 unsigned long pval;
1720 int err;
1721
5a9e02e9 1722 mutex_lock(&codec->control_mutex);
985be54b
TI		 1723 pval = kcontrol->private_value;
1724 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1725 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1726 kcontrol->private_value = pval;
5a9e02e9 1727 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1728 return err;
1729}
ff7a3267 1730EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 1731
0ba21762
TI		 1732int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1733 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1734{
1735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1736 unsigned long pval;
1737 int i, indices, err = 0, change = 0;
1738
5a9e02e9 1739 mutex_lock(&codec->control_mutex);
985be54b
TI		 1740 pval = kcontrol->private_value;
1741 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1742 for (i = 0; i < indices; i++) {
0ba21762
TI		 1743 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1744 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 1745 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1746 if (err < 0)
1747 break;
1748 change |= err;
1749 }
1750 kcontrol->private_value = pval;
5a9e02e9 1751 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1752 return err < 0 ? err : change;
1753}
ff7a3267 1754EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 1755
532d5381
TI		 1756/*
1757 * generic bound volume/swtich controls
1758 */
1759int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1760 struct snd_ctl_elem_info *uinfo)
1761{
1762 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1763 struct hda_bind_ctls *c;
1764 int err;
1765
5a9e02e9 1766 mutex_lock(&codec->control_mutex);
14c65f98 1767 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1768 kcontrol->private_value = *c->values;
1769 err = c->ops->info(kcontrol, uinfo);
1770 kcontrol->private_value = (long)c;
5a9e02e9 1771 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1772 return err;
1773}
ff7a3267 1774EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381
TI		 1775
1776int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1777 struct snd_ctl_elem_value *ucontrol)
1778{
1779 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1780 struct hda_bind_ctls *c;
1781 int err;
1782
5a9e02e9 1783 mutex_lock(&codec->control_mutex);
14c65f98 1784 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1785 kcontrol->private_value = *c->values;
1786 err = c->ops->get(kcontrol, ucontrol);
1787 kcontrol->private_value = (long)c;
5a9e02e9 1788 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1789 return err;
1790}
ff7a3267 1791EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381
TI		 1792
1793int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1794 struct snd_ctl_elem_value *ucontrol)
1795{
1796 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1797 struct hda_bind_ctls *c;
1798 unsigned long *vals;
1799 int err = 0, change = 0;
1800
5a9e02e9 1801 mutex_lock(&codec->control_mutex);
14c65f98 1802 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1803 for (vals = c->values; *vals; vals++) {
1804 kcontrol->private_value = *vals;
1805 err = c->ops->put(kcontrol, ucontrol);
1806 if (err < 0)
1807 break;
1808 change |= err;
1809 }
1810 kcontrol->private_value = (long)c;
5a9e02e9 1811 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1812 return err < 0 ? err : change;
1813}
ff7a3267 1814EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381
TI		 1815
1816int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1817 unsigned int size, unsigned int __user *tlv)
1818{
1819 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1820 struct hda_bind_ctls *c;
1821 int err;
1822
5a9e02e9 1823 mutex_lock(&codec->control_mutex);
14c65f98 1824 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1825 kcontrol->private_value = *c->values;
1826 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1827 kcontrol->private_value = (long)c;
5a9e02e9 1828 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1829 return err;
1830}
ff7a3267 1831EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 1832
1833struct hda_ctl_ops snd_hda_bind_vol = {
1834 .info = snd_hda_mixer_amp_volume_info,
1835 .get = snd_hda_mixer_amp_volume_get,
1836 .put = snd_hda_mixer_amp_volume_put,
1837 .tlv = snd_hda_mixer_amp_tlv
1838};
ff7a3267 1839EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 1840
1841struct hda_ctl_ops snd_hda_bind_sw = {
1842 .info = snd_hda_mixer_amp_switch_info,
1843 .get = snd_hda_mixer_amp_switch_get,
1844 .put = snd_hda_mixer_amp_switch_put,
1845 .tlv = snd_hda_mixer_amp_tlv
1846};
ff7a3267 1847EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 1848
1da177e4
LT		 1849/*
1850 * SPDIF out controls
1851 */
1852
0ba21762
TI		 1853static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1854 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1855{
1856 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1857 uinfo->count = 1;
1858 return 0;
1859}
1860
0ba21762
TI		 1861static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1862 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1863{
1864 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1865 IEC958_AES0_NONAUDIO |
1866 IEC958_AES0_CON_EMPHASIS_5015 |
1867 IEC958_AES0_CON_NOT_COPYRIGHT;
1868 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1869 IEC958_AES1_CON_ORIGINAL;
1870 return 0;
1871}
1872
0ba21762
TI		 1873static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1874 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1875{
1876 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1877 IEC958_AES0_NONAUDIO |
1878 IEC958_AES0_PRO_EMPHASIS_5015;
1879 return 0;
1880}
1881
0ba21762
TI		 1882static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1883 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1884{
1885 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1886
1887 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1888 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1889 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1890 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1891
1892 return 0;
1893}
1894
1895/* convert from SPDIF status bits to HDA SPDIF bits
1896 * bit 0 (DigEn) is always set zero (to be filled later)
1897 */
1898static unsigned short convert_from_spdif_status(unsigned int sbits)
1899{
1900 unsigned short val = 0;
1901
1902 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 1903 val |= AC_DIG1_PROFESSIONAL;
1da177e4 1904 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 1905 val |= AC_DIG1_NONAUDIO;
1da177e4 1906 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 1907 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1908 IEC958_AES0_PRO_EMPHASIS_5015)
1909 val |= AC_DIG1_EMPHASIS;
1da177e4 1910 } else {
0ba21762
TI		 1911 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1912 IEC958_AES0_CON_EMPHASIS_5015)
1913 val |= AC_DIG1_EMPHASIS;
1914 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1915 val |= AC_DIG1_COPYRIGHT;
1da177e4 1916 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 1917 val |= AC_DIG1_LEVEL;
1da177e4
LT		 1918 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1919 }
1920 return val;
1921}
1922
1923/* convert to SPDIF status bits from HDA SPDIF bits
1924 */
1925static unsigned int convert_to_spdif_status(unsigned short val)
1926{
1927 unsigned int sbits = 0;
1928
0ba21762 1929 if (val & AC_DIG1_NONAUDIO)
1da177e4 1930 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 1931 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 1932 sbits |= IEC958_AES0_PROFESSIONAL;
1933 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 1934 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 1935 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1936 } else {
0ba21762 1937 if (val & AC_DIG1_EMPHASIS)
1da177e4 1938 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 1939 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 1940 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 1941 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 1942 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1943 sbits |= val & (0x7f << 8);
1944 }
1945 return sbits;
1946}
1947
2f72853c
TI		 1948/* set digital convert verbs both for the given NID and its slaves */
1949static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1950 int verb, int val)
1951{
1952 hda_nid_t *d;
1953
9e976976 1954 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 1955 d = codec->slave_dig_outs;
1956 if (!d)
1957 return;
1958 for (; *d; d++)
9e976976 1959 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 1960}
1961
1962static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1963 int dig1, int dig2)
1964{
1965 if (dig1 != -1)
1966 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1967 if (dig2 != -1)
1968 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1969}
1970
0ba21762
TI		 1971static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1972 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1973{
1974 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1975 hda_nid_t nid = kcontrol->private_value;
1976 unsigned short val;
1977 int change;
1978
62932df8 1979 mutex_lock(&codec->spdif_mutex);
1da177e4
LT		 1980 codec->spdif_status = ucontrol->value.iec958.status[0] |
1981 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1982 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1983 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1984 val = convert_from_spdif_status(codec->spdif_status);
1985 val |= codec->spdif_ctls & 1;
1986 change = codec->spdif_ctls != val;
1987 codec->spdif_ctls = val;
1988
2f72853c
TI		 1989 if (change)
1990 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1da177e4 1991
62932df8 1992 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 1993 return change;
1994}
1995
a5ce8890 1996#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 1997
0ba21762
TI		 1998static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1999 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2000{
2001 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2002
0ba21762 2003 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1da177e4
LT		 2004 return 0;
2005}
2006
0ba21762
TI		 2007static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2008 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2009{
2010 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2011 hda_nid_t nid = kcontrol->private_value;
2012 unsigned short val;
2013 int change;
2014
62932df8 2015 mutex_lock(&codec->spdif_mutex);
0ba21762 2016 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1da177e4 2017 if (ucontrol->value.integer.value[0])
0ba21762 2018 val |= AC_DIG1_ENABLE;
1da177e4 2019 change = codec->spdif_ctls != val;
82beb8fd 2020 if (change) {
1da177e4 2021 codec->spdif_ctls = val;
2f72853c 2022 set_dig_out_convert(codec, nid, val & 0xff, -1);
0ba21762
TI		 2023 /* unmute amp switch (if any) */
2024 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
47fd830a
TI		 2025 (val & AC_DIG1_ENABLE))
2026 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2027 HDA_AMP_MUTE, 0);
1da177e4 2028 }
62932df8 2029 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2030 return change;
2031}
2032
c8b6bf9b 2033static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2034 {
2035 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2036 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2037 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2038 .info = snd_hda_spdif_mask_info,
2039 .get = snd_hda_spdif_cmask_get,
2040 },
2041 {
2042 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2043 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2044 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2045 .info = snd_hda_spdif_mask_info,
2046 .get = snd_hda_spdif_pmask_get,
2047 },
2048 {
2049 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2050 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2051 .info = snd_hda_spdif_mask_info,
2052 .get = snd_hda_spdif_default_get,
2053 .put = snd_hda_spdif_default_put,
2054 },
2055 {
2056 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2057 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2058 .info = snd_hda_spdif_out_switch_info,
2059 .get = snd_hda_spdif_out_switch_get,
2060 .put = snd_hda_spdif_out_switch_put,
2061 },
2062 { } /* end */
2063};
2064
09f99701
TI		 2065#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2066
1da177e4
LT		 2067/**
2068 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2069 * @codec: the HDA codec
2070 * @nid: audio out widget NID
2071 *
2072 * Creates controls related with the SPDIF output.
2073 * Called from each patch supporting the SPDIF out.
2074 *
2075 * Returns 0 if successful, or a negative error code.
2076 */
12f288bf 2077int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2078{
2079 int err;
c8b6bf9b
TI		 2080 struct snd_kcontrol *kctl;
2081 struct snd_kcontrol_new *dig_mix;
09f99701 2082 int idx;
1da177e4 2083
09f99701
TI		 2084 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2085 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2086 idx))
2087 break;
2088 }
2089 if (idx >= SPDIF_MAX_IDX) {
2090 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2091 return -EBUSY;
2092 }
1da177e4
LT		 2093 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2094 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 2095 if (!kctl)
2096 return -ENOMEM;
09f99701 2097 kctl->id.index = idx;
1da177e4 2098 kctl->private_value = nid;
d13bd412 2099 err = snd_hda_ctl_add(codec, kctl);
0ba21762 2100 if (err < 0)
1da177e4
LT		 2101 return err;
2102 }
0ba21762 2103 codec->spdif_ctls =
3982d17e
AP		 2104 snd_hda_codec_read(codec, nid, 0,
2105 AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2106 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2107 return 0;
2108}
ff7a3267 2109EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 2110
9a08160b
TI		 2111/*
2112 * SPDIF sharing with analog output
2113 */
2114static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2115 struct snd_ctl_elem_value *ucontrol)
2116{
2117 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2118 ucontrol->value.integer.value[0] = mout->share_spdif;
2119 return 0;
2120}
2121
2122static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2123 struct snd_ctl_elem_value *ucontrol)
2124{
2125 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2126 mout->share_spdif = !!ucontrol->value.integer.value[0];
2127 return 0;
2128}
2129
2130static struct snd_kcontrol_new spdif_share_sw = {
2131 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2132 .name = "IEC958 Default PCM Playback Switch",
2133 .info = snd_ctl_boolean_mono_info,
2134 .get = spdif_share_sw_get,
2135 .put = spdif_share_sw_put,
2136};
2137
2138int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2139 struct hda_multi_out *mout)
2140{
2141 if (!mout->dig_out_nid)
2142 return 0;
2143 /* ATTENTION: here mout is passed as private_data, instead of codec */
d13bd412 2144 return snd_hda_ctl_add(codec,
9a08160b
TI		 2145 snd_ctl_new1(&spdif_share_sw, mout));
2146}
ff7a3267 2147EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 2148
1da177e4
LT		 2149/*
2150 * SPDIF input
2151 */
2152
2153#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2154
0ba21762
TI		 2155static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2156 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2157{
2158 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2159
2160 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2161 return 0;
2162}
2163
0ba21762
TI		 2164static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2165 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2166{
2167 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2168 hda_nid_t nid = kcontrol->private_value;
2169 unsigned int val = !!ucontrol->value.integer.value[0];
2170 int change;
2171
62932df8 2172 mutex_lock(&codec->spdif_mutex);
1da177e4 2173 change = codec->spdif_in_enable != val;
82beb8fd 2174 if (change) {
1da177e4 2175 codec->spdif_in_enable = val;
82beb8fd
TI		 2176 snd_hda_codec_write_cache(codec, nid, 0,
2177 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 2178 }
62932df8 2179 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2180 return change;
2181}
2182
0ba21762
TI		 2183static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2184 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2185{
2186 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2187 hda_nid_t nid = kcontrol->private_value;
2188 unsigned short val;
2189 unsigned int sbits;
2190
3982d17e 2191 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2192 sbits = convert_to_spdif_status(val);
2193 ucontrol->value.iec958.status[0] = sbits;
2194 ucontrol->value.iec958.status[1] = sbits >> 8;
2195 ucontrol->value.iec958.status[2] = sbits >> 16;
2196 ucontrol->value.iec958.status[3] = sbits >> 24;
2197 return 0;
2198}
2199
c8b6bf9b 2200static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 2201 {
2202 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2203 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2204 .info = snd_hda_spdif_in_switch_info,
2205 .get = snd_hda_spdif_in_switch_get,
2206 .put = snd_hda_spdif_in_switch_put,
2207 },
2208 {
2209 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2211 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2212 .info = snd_hda_spdif_mask_info,
2213 .get = snd_hda_spdif_in_status_get,
2214 },
2215 { } /* end */
2216};
2217
2218/**
2219 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2220 * @codec: the HDA codec
2221 * @nid: audio in widget NID
2222 *
2223 * Creates controls related with the SPDIF input.
2224 * Called from each patch supporting the SPDIF in.
2225 *
2226 * Returns 0 if successful, or a negative error code.
2227 */
12f288bf 2228int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2229{
2230 int err;
c8b6bf9b
TI		 2231 struct snd_kcontrol *kctl;
2232 struct snd_kcontrol_new *dig_mix;
09f99701 2233 int idx;
1da177e4 2234
09f99701
TI		 2235 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2236 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2237 idx))
2238 break;
2239 }
2240 if (idx >= SPDIF_MAX_IDX) {
2241 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2242 return -EBUSY;
2243 }
1da177e4
LT		 2244 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2245 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 2246 if (!kctl)
2247 return -ENOMEM;
1da177e4 2248 kctl->private_value = nid;
d13bd412 2249 err = snd_hda_ctl_add(codec, kctl);
0ba21762 2250 if (err < 0)
1da177e4
LT		 2251 return err;
2252 }
0ba21762 2253 codec->spdif_in_enable =
3982d17e
AP		 2254 snd_hda_codec_read(codec, nid, 0,
2255 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 2256 AC_DIG1_ENABLE;
1da177e4
LT		 2257 return 0;
2258}
ff7a3267 2259EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 2260
cb53c626 2261#ifdef SND_HDA_NEEDS_RESUME
82beb8fd
TI		 2262/*
2263 * command cache
2264 */
1da177e4 2265
b3ac5636
TI		 2266/* build a 32bit cache key with the widget id and the command parameter */
2267#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2268#define get_cmd_cache_nid(key) ((key) & 0xff)
2269#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2270
2271/**
2272 * snd_hda_codec_write_cache - send a single command with caching
2273 * @codec: the HDA codec
2274 * @nid: NID to send the command
2275 * @direct: direct flag
2276 * @verb: the verb to send
2277 * @parm: the parameter for the verb
2278 *
2279 * Send a single command without waiting for response.
2280 *
2281 * Returns 0 if successful, or a negative error code.
2282 */
2283int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2284 int direct, unsigned int verb, unsigned int parm)
2285{
aa2936f5
TI		 2286 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2287 struct hda_cache_head *c;
2288 u32 key;
33fa35ed 2289
aa2936f5
TI		 2290 if (err < 0)
2291 return err;
2292 /* parm may contain the verb stuff for get/set amp */
2293 verb = verb | (parm >> 8);
2294 parm &= 0xff;
2295 key = build_cmd_cache_key(nid, verb);
2296 mutex_lock(&codec->bus->cmd_mutex);
2297 c = get_alloc_hash(&codec->cmd_cache, key);
2298 if (c)
2299 c->val = parm;
2300 mutex_unlock(&codec->bus->cmd_mutex);
2301 return 0;
b3ac5636 2302}
ff7a3267 2303EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636
TI		 2304
2305/* resume the all commands from the cache */
2306void snd_hda_codec_resume_cache(struct hda_codec *codec)
2307{
603c4019 2308 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 2309 int i;
2310
603c4019 2311 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 2312 u32 key = buffer->key;
2313 if (!key)
2314 continue;
2315 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2316 get_cmd_cache_cmd(key), buffer->val);
2317 }
2318}
ff7a3267 2319EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 2320
2321/**
2322 * snd_hda_sequence_write_cache - sequence writes with caching
2323 * @codec: the HDA codec
2324 * @seq: VERB array to send
2325 *
2326 * Send the commands sequentially from the given array.
2327 * Thte commands are recorded on cache for power-save and resume.
2328 * The array must be terminated with NID=0.
2329 */
2330void snd_hda_sequence_write_cache(struct hda_codec *codec,
2331 const struct hda_verb *seq)
2332{
2333 for (; seq->nid; seq++)
2334 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2335 seq->param);
2336}
ff7a3267 2337EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
cb53c626 2338#endif /* SND_HDA_NEEDS_RESUME */
b3ac5636 2339
54d17403
TI		 2340/*
2341 * set power state of the codec
2342 */
2343static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2344 unsigned int power_state)
2345{
cb53c626
TI		 2346 hda_nid_t nid;
2347 int i;
54d17403
TI		 2348
2349 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2350 power_state);
d2595d86 2351 msleep(10); /* partial workaround for "azx_get_response timeout" */
54d17403 2352
cb53c626
TI		 2353 nid = codec->start_nid;
2354 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d
TI		 2355 unsigned int wcaps = get_wcaps(codec, nid);
2356 if (wcaps & AC_WCAP_POWER) {
2357 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2358 AC_WCAP_TYPE_SHIFT;
a3b48c88
TI		 2359 if (power_state == AC_PWRST_D3 &&
2360 wid_type == AC_WID_PIN) {
7eba5c9d
TI		 2361 unsigned int pincap;
2362 /*
2363 * don't power down the widget if it controls
2364 * eapd and EAPD_BTLENABLE is set.
2365 */
14bafe32 2366 pincap = snd_hda_query_pin_caps(codec, nid);
7eba5c9d
TI		 2367 if (pincap & AC_PINCAP_EAPD) {
2368 int eapd = snd_hda_codec_read(codec,
2369 nid, 0,
2370 AC_VERB_GET_EAPD_BTLENABLE, 0);
2371 eapd &= 0x02;
a3b48c88 2372 if (eapd)
7eba5c9d
TI		 2373 continue;
2374 }
1194b5b7 2375 }
54d17403
TI		 2376 snd_hda_codec_write(codec, nid, 0,
2377 AC_VERB_SET_POWER_STATE,
2378 power_state);
1194b5b7 2379 }
54d17403
TI		 2380 }
2381
cb53c626
TI		 2382 if (power_state == AC_PWRST_D0) {
2383 unsigned long end_time;
2384 int state;
54d17403 2385 msleep(10);
cb53c626
TI		 2386 /* wait until the codec reachs to D0 */
2387 end_time = jiffies + msecs_to_jiffies(500);
2388 do {
2389 state = snd_hda_codec_read(codec, fg, 0,
2390 AC_VERB_GET_POWER_STATE, 0);
2391 if (state == power_state)
2392 break;
2393 msleep(1);
2394 } while (time_after_eq(end_time, jiffies));
2395 }
2396}
2397
11aeff08
TI		 2398#ifdef CONFIG_SND_HDA_HWDEP
2399/* execute additional init verbs */
2400static void hda_exec_init_verbs(struct hda_codec *codec)
2401{
2402 if (codec->init_verbs.list)
2403 snd_hda_sequence_write(codec, codec->init_verbs.list);
2404}
2405#else
2406static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2407#endif
2408
cb53c626
TI		 2409#ifdef SND_HDA_NEEDS_RESUME
2410/*
2411 * call suspend and power-down; used both from PM and power-save
2412 */
2413static void hda_call_codec_suspend(struct hda_codec *codec)
2414{
2415 if (codec->patch_ops.suspend)
2416 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2417 hda_set_power_state(codec,
2418 codec->afg ? codec->afg : codec->mfg,
2419 AC_PWRST_D3);
2420#ifdef CONFIG_SND_HDA_POWER_SAVE
2421 cancel_delayed_work(&codec->power_work);
95e99fda 2422 codec->power_on = 0;
a221e287 2423 codec->power_transition = 0;
cb53c626 2424#endif
54d17403
TI		 2425}
2426
cb53c626
TI		 2427/*
2428 * kick up codec; used both from PM and power-save
2429 */
2430static void hda_call_codec_resume(struct hda_codec *codec)
2431{
2432 hda_set_power_state(codec,
2433 codec->afg ? codec->afg : codec->mfg,
2434 AC_PWRST_D0);
3be14149 2435 restore_pincfgs(codec); /* restore all current pin configs */
11aeff08 2436 hda_exec_init_verbs(codec);
cb53c626
TI		 2437 if (codec->patch_ops.resume)
2438 codec->patch_ops.resume(codec);
2439 else {
9d99f312
TI		 2440 if (codec->patch_ops.init)
2441 codec->patch_ops.init(codec);
cb53c626
TI		 2442 snd_hda_codec_resume_amp(codec);
2443 snd_hda_codec_resume_cache(codec);
2444 }
2445}
2446#endif /* SND_HDA_NEEDS_RESUME */
2447
54d17403 2448
1da177e4
LT		 2449/**
2450 * snd_hda_build_controls - build mixer controls
2451 * @bus: the BUS
2452 *
2453 * Creates mixer controls for each codec included in the bus.
2454 *
2455 * Returns 0 if successful, otherwise a negative error code.
2456 */
1289e9e8 2457int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 2458{
0ba21762 2459 struct hda_codec *codec;
1da177e4 2460
0ba21762 2461 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 2462 int err = snd_hda_codec_build_controls(codec);
f93d461b
TI		 2463 if (err < 0) {
2464 printk(KERN_ERR "hda_codec: cannot build controls"
2465 "for #%d (error %d)\n", codec->addr, err);
2466 err = snd_hda_codec_reset(codec);
2467 if (err < 0) {
2468 printk(KERN_ERR
2469 "hda_codec: cannot revert codec\n");
2470 return err;
2471 }
2472 }
1da177e4 2473 }
6c1f45ea
TI		 2474 return 0;
2475}
ff7a3267 2476EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 2477
6c1f45ea
TI		 2478int snd_hda_codec_build_controls(struct hda_codec *codec)
2479{
2480 int err = 0;
11aeff08 2481 hda_exec_init_verbs(codec);
6c1f45ea
TI		 2482 /* continue to initialize... */
2483 if (codec->patch_ops.init)
2484 err = codec->patch_ops.init(codec);
2485 if (!err && codec->patch_ops.build_controls)
2486 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 2487 if (err < 0)
2488 return err;
1da177e4
LT		 2489 return 0;
2490}
2491
1da177e4
LT		 2492/*
2493 * stream formats
2494 */
befdf316
TI		 2495struct hda_rate_tbl {
2496 unsigned int hz;
2497 unsigned int alsa_bits;
2498 unsigned int hda_fmt;
2499};
2500
2501static struct hda_rate_tbl rate_bits[] = {
1da177e4 2502 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 2503
2504 /* autodetected value used in snd_hda_query_supported_pcm */
1da177e4
LT		 2505 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2506 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2507 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2508 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2509 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2510 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2511 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2512 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2513 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2514 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2515 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
a961f9fe
TI		 2516#define AC_PAR_PCM_RATE_BITS 11
2517 /* up to bits 10, 384kHZ isn't supported properly */
2518
2519 /* not autodetected value */
2520 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
9d8f53f2 2521
befdf316 2522 { 0 } /* terminator */
1da177e4
LT		 2523};
2524
2525/**
2526 * snd_hda_calc_stream_format - calculate format bitset
2527 * @rate: the sample rate
2528 * @channels: the number of channels
2529 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2530 * @maxbps: the max. bps
2531 *
2532 * Calculate the format bitset from the given rate, channels and th PCM format.
2533 *
2534 * Return zero if invalid.
2535 */
2536unsigned int snd_hda_calc_stream_format(unsigned int rate,
2537 unsigned int channels,
2538 unsigned int format,
2539 unsigned int maxbps)
2540{
2541 int i;
2542 unsigned int val = 0;
2543
befdf316
TI		 2544 for (i = 0; rate_bits[i].hz; i++)
2545 if (rate_bits[i].hz == rate) {
2546 val = rate_bits[i].hda_fmt;
1da177e4
LT		 2547 break;
2548 }
0ba21762 2549 if (!rate_bits[i].hz) {
1da177e4
LT		 2550 snd_printdd("invalid rate %d\n", rate);
2551 return 0;
2552 }
2553
2554 if (channels == 0 || channels > 8) {
2555 snd_printdd("invalid channels %d\n", channels);
2556 return 0;
2557 }
2558 val |= channels - 1;
2559
2560 switch (snd_pcm_format_width(format)) {
2561 case 8: val |= 0x00; break;
2562 case 16: val |= 0x10; break;
2563 case 20:
2564 case 24:
2565 case 32:
b0bb3aa6 2566 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
1da177e4
LT		 2567 val |= 0x40;
2568 else if (maxbps >= 24)
2569 val |= 0x30;
2570 else
2571 val |= 0x20;
2572 break;
2573 default:
0ba21762
TI		 2574 snd_printdd("invalid format width %d\n",
2575 snd_pcm_format_width(format));
1da177e4
LT		 2576 return 0;
2577 }
2578
2579 return val;
2580}
ff7a3267 2581EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 2582
92c7c8a7
TI		 2583static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2584{
2585 unsigned int val = 0;
2586 if (nid != codec->afg &&
2587 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2588 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2589 if (!val || val == -1)
2590 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2591 if (!val || val == -1)
2592 return 0;
2593 return val;
2594}
2595
2596static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2597{
2598 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2599 get_pcm_param);
2600}
2601
2602static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2603{
2604 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2605 if (!streams || streams == -1)
2606 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2607 if (!streams || streams == -1)
2608 return 0;
2609 return streams;
2610}
2611
2612static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2613{
2614 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2615 get_stream_param);
2616}
2617
1da177e4
LT		 2618/**
2619 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2620 * @codec: the HDA codec
2621 * @nid: NID to query
2622 * @ratesp: the pointer to store the detected rate bitflags
2623 * @formatsp: the pointer to store the detected formats
2624 * @bpsp: the pointer to store the detected format widths
2625 *
2626 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2627 * or @bsps argument is ignored.
2628 *
2629 * Returns 0 if successful, otherwise a negative error code.
2630 */
986862bd 2631static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 2632 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2633{
ee504710 2634 unsigned int i, val, wcaps;
1da177e4 2635
ee504710 2636 wcaps = get_wcaps(codec, nid);
92c7c8a7 2637 val = query_pcm_param(codec, nid);
1da177e4
LT		 2638
2639 if (ratesp) {
2640 u32 rates = 0;
a961f9fe 2641 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 2642 if (val & (1 << i))
befdf316 2643 rates |= rate_bits[i].alsa_bits;
1da177e4 2644 }
ee504710
JK		 2645 if (rates == 0) {
2646 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2647 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2648 nid, val,
2649 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2650 return -EIO;
2651 }
1da177e4
LT		 2652 *ratesp = rates;
2653 }
2654
2655 if (formatsp || bpsp) {
2656 u64 formats = 0;
ee504710 2657 unsigned int streams, bps;
1da177e4 2658
92c7c8a7
TI		 2659 streams = query_stream_param(codec, nid);
2660 if (!streams)
1da177e4 2661 return -EIO;
1da177e4
LT		 2662
2663 bps = 0;
2664 if (streams & AC_SUPFMT_PCM) {
2665 if (val & AC_SUPPCM_BITS_8) {
2666 formats |= SNDRV_PCM_FMTBIT_U8;
2667 bps = 8;
2668 }
2669 if (val & AC_SUPPCM_BITS_16) {
2670 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2671 bps = 16;
2672 }
2673 if (wcaps & AC_WCAP_DIGITAL) {
2674 if (val & AC_SUPPCM_BITS_32)
2675 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2676 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2677 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2678 if (val & AC_SUPPCM_BITS_24)
2679 bps = 24;
2680 else if (val & AC_SUPPCM_BITS_20)
2681 bps = 20;
0ba21762
TI		 2682 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2683 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 2684 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2685 if (val & AC_SUPPCM_BITS_32)
2686 bps = 32;
1da177e4
LT		 2687 else if (val & AC_SUPPCM_BITS_24)
2688 bps = 24;
33ef7651
NG		 2689 else if (val & AC_SUPPCM_BITS_20)
2690 bps = 20;
1da177e4
LT		 2691 }
2692 }
b5025c50 2693 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 2694 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 2695 if (!bps)
2696 bps = 32;
b5025c50
TI		 2697 }
2698 if (streams == AC_SUPFMT_AC3) {
0ba21762 2699 /* should be exclusive */
1da177e4
LT		 2700 /* temporary hack: we have still no proper support
2701 * for the direct AC3 stream...
2702 */
2703 formats |= SNDRV_PCM_FMTBIT_U8;
2704 bps = 8;
2705 }
ee504710
JK		 2706 if (formats == 0) {
2707 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2708 "(nid=0x%x, val=0x%x, ovrd=%i, "
2709 "streams=0x%x)\n",
2710 nid, val,
2711 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2712 streams);
2713 return -EIO;
2714 }
1da177e4
LT		 2715 if (formatsp)
2716 *formatsp = formats;
2717 if (bpsp)
2718 *bpsp = bps;
2719 }
2720
2721 return 0;
2722}
2723
2724/**
0ba21762
TI		 2725 * snd_hda_is_supported_format - check whether the given node supports
2726 * the format val
1da177e4
LT		 2727 *
2728 * Returns 1 if supported, 0 if not.
2729 */
2730int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2731 unsigned int format)
2732{
2733 int i;
2734 unsigned int val = 0, rate, stream;
2735
92c7c8a7
TI		 2736 val = query_pcm_param(codec, nid);
2737 if (!val)
2738 return 0;
1da177e4
LT		 2739
2740 rate = format & 0xff00;
a961f9fe 2741 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 2742 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 2743 if (val & (1 << i))
2744 break;
2745 return 0;
2746 }
a961f9fe 2747 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 2748 return 0;
2749
92c7c8a7
TI		 2750 stream = query_stream_param(codec, nid);
2751 if (!stream)
1da177e4
LT		 2752 return 0;
2753
2754 if (stream & AC_SUPFMT_PCM) {
2755 switch (format & 0xf0) {
2756 case 0x00:
0ba21762 2757 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 2758 return 0;
2759 break;
2760 case 0x10:
0ba21762 2761 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 2762 return 0;
2763 break;
2764 case 0x20:
0ba21762 2765 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 2766 return 0;
2767 break;
2768 case 0x30:
0ba21762 2769 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 2770 return 0;
2771 break;
2772 case 0x40:
0ba21762 2773 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 2774 return 0;
2775 break;
2776 default:
2777 return 0;
2778 }
2779 } else {
2780 /* FIXME: check for float32 and AC3? */
2781 }
2782
2783 return 1;
2784}
ff7a3267 2785EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 2786
2787/*
2788 * PCM stuff
2789 */
2790static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2791 struct hda_codec *codec,
c8b6bf9b 2792 struct snd_pcm_substream *substream)
1da177e4
LT		 2793{
2794 return 0;
2795}
2796
2797static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2798 struct hda_codec *codec,
2799 unsigned int stream_tag,
2800 unsigned int format,
c8b6bf9b 2801 struct snd_pcm_substream *substream)
1da177e4
LT		 2802{
2803 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2804 return 0;
2805}
2806
2807static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2808 struct hda_codec *codec,
c8b6bf9b 2809 struct snd_pcm_substream *substream)
1da177e4 2810{
888afa15 2811 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 2812 return 0;
2813}
2814
6c1f45ea
TI		 2815static int set_pcm_default_values(struct hda_codec *codec,
2816 struct hda_pcm_stream *info)
1da177e4 2817{
ee504710
JK		 2818 int err;
2819
0ba21762
TI		 2820 /* query support PCM information from the given NID */
2821 if (info->nid && (!info->rates || !info->formats)) {
ee504710 2822 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 2823 info->rates ? NULL : &info->rates,
2824 info->formats ? NULL : &info->formats,
2825 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 2826 if (err < 0)
2827 return err;
1da177e4
LT		 2828 }
2829 if (info->ops.open == NULL)
2830 info->ops.open = hda_pcm_default_open_close;
2831 if (info->ops.close == NULL)
2832 info->ops.close = hda_pcm_default_open_close;
2833 if (info->ops.prepare == NULL) {
da3cec35
TI		 2834 if (snd_BUG_ON(!info->nid))
2835 return -EINVAL;
1da177e4
LT		 2836 info->ops.prepare = hda_pcm_default_prepare;
2837 }
1da177e4 2838 if (info->ops.cleanup == NULL) {
da3cec35
TI		 2839 if (snd_BUG_ON(!info->nid))
2840 return -EINVAL;
1da177e4
LT		 2841 info->ops.cleanup = hda_pcm_default_cleanup;
2842 }
2843 return 0;
2844}
2845
529bd6c4
TI		 2846/*
2847 * get the empty PCM device number to assign
2848 */
2849static int get_empty_pcm_device(struct hda_bus *bus, int type)
2850{
2851 static const char *dev_name[HDA_PCM_NTYPES] = {
2852 "Audio", "SPDIF", "HDMI", "Modem"
2853 };
2854 /* starting device index for each PCM type */
2855 static int dev_idx[HDA_PCM_NTYPES] = {
2856 [HDA_PCM_TYPE_AUDIO] = 0,
2857 [HDA_PCM_TYPE_SPDIF] = 1,
2858 [HDA_PCM_TYPE_HDMI] = 3,
2859 [HDA_PCM_TYPE_MODEM] = 6
2860 };
2861 /* normal audio device indices; not linear to keep compatibility */
2862 static int audio_idx[4] = { 0, 2, 4, 5 };
2863 int i, dev;
2864
2865 switch (type) {
2866 case HDA_PCM_TYPE_AUDIO:
2867 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2868 dev = audio_idx[i];
2869 if (!test_bit(dev, bus->pcm_dev_bits))
82ad39f9 2870 goto ok;
529bd6c4 2871 }
82ad39f9
TI		 2872 snd_printk(KERN_WARNING "Too many audio devices\n");
2873 return -EAGAIN;
529bd6c4
TI		 2874 case HDA_PCM_TYPE_SPDIF:
2875 case HDA_PCM_TYPE_HDMI:
2876 case HDA_PCM_TYPE_MODEM:
2877 dev = dev_idx[type];
2878 if (test_bit(dev, bus->pcm_dev_bits)) {
2879 snd_printk(KERN_WARNING "%s already defined\n",
2880 dev_name[type]);
2881 return -EAGAIN;
2882 }
2883 break;
2884 default:
2885 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2886 return -EINVAL;
2887 }
82ad39f9 2888 ok:
529bd6c4
TI		 2889 set_bit(dev, bus->pcm_dev_bits);
2890 return dev;
2891}
2892
176d5335
TI		 2893/*
2894 * attach a new PCM stream
2895 */
529bd6c4 2896static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 2897{
33fa35ed 2898 struct hda_bus *bus = codec->bus;
176d5335
TI		 2899 struct hda_pcm_stream *info;
2900 int stream, err;
2901
b91f080f 2902 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 2903 return -EINVAL;
2904 for (stream = 0; stream < 2; stream++) {
2905 info = &pcm->stream[stream];
2906 if (info->substreams) {
2907 err = set_pcm_default_values(codec, info);
2908 if (err < 0)
2909 return err;
2910 }
2911 }
33fa35ed 2912 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 2913}
2914
529bd6c4
TI		 2915/* assign all PCMs of the given codec */
2916int snd_hda_codec_build_pcms(struct hda_codec *codec)
2917{
2918 unsigned int pcm;
2919 int err;
2920
2921 if (!codec->num_pcms) {
2922 if (!codec->patch_ops.build_pcms)
2923 return 0;
2924 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 2925 if (err < 0) {
2926 printk(KERN_ERR "hda_codec: cannot build PCMs"
2927 "for #%d (error %d)\n", codec->addr, err);
2928 err = snd_hda_codec_reset(codec);
2929 if (err < 0) {
2930 printk(KERN_ERR
2931 "hda_codec: cannot revert codec\n");
2932 return err;
2933 }
2934 }
529bd6c4
TI		 2935 }
2936 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2937 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2938 int dev;
2939
2940 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 2941 continue; /* no substreams assigned */
529bd6c4
TI		 2942
2943 if (!cpcm->pcm) {
2944 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2945 if (dev < 0)
6e655bf2 2946 continue; /* no fatal error */
529bd6c4
TI		 2947 cpcm->device = dev;
2948 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 2949 if (err < 0) {
2950 printk(KERN_ERR "hda_codec: cannot attach "
2951 "PCM stream %d for codec #%d\n",
2952 dev, codec->addr);
2953 continue; /* no fatal error */
2954 }
529bd6c4
TI		 2955 }
2956 }
2957 return 0;
2958}
2959
1da177e4
LT		 2960/**
2961 * snd_hda_build_pcms - build PCM information
2962 * @bus: the BUS
2963 *
2964 * Create PCM information for each codec included in the bus.
2965 *
2966 * The build_pcms codec patch is requested to set up codec->num_pcms and
2967 * codec->pcm_info properly. The array is referred by the top-level driver
2968 * to create its PCM instances.
2969 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2970 * callback.
2971 *
2972 * At least, substreams, channels_min and channels_max must be filled for
2973 * each stream. substreams = 0 indicates that the stream doesn't exist.
2974 * When rates and/or formats are zero, the supported values are queried
2975 * from the given nid. The nid is used also by the default ops.prepare
2976 * and ops.cleanup callbacks.
2977 *
2978 * The driver needs to call ops.open in its open callback. Similarly,
2979 * ops.close is supposed to be called in the close callback.
2980 * ops.prepare should be called in the prepare or hw_params callback
2981 * with the proper parameters for set up.
2982 * ops.cleanup should be called in hw_free for clean up of streams.
2983 *
2984 * This function returns 0 if successfull, or a negative error code.
2985 */
529bd6c4 2986int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 2987{
0ba21762 2988 struct hda_codec *codec;
1da177e4 2989
0ba21762 2990 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 2991 int err = snd_hda_codec_build_pcms(codec);
2992 if (err < 0)
2993 return err;
1da177e4
LT		 2994 }
2995 return 0;
2996}
ff7a3267 2997EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 2998
1da177e4
LT		 2999/**
3000 * snd_hda_check_board_config - compare the current codec with the config table
3001 * @codec: the HDA codec
f5fcc13c
TI		 3002 * @num_configs: number of config enums
3003 * @models: array of model name strings
1da177e4
LT		 3004 * @tbl: configuration table, terminated by null entries
3005 *
3006 * Compares the modelname or PCI subsystem id of the current codec with the
3007 * given configuration table. If a matching entry is found, returns its
3008 * config value (supposed to be 0 or positive).
3009 *
3010 * If no entries are matching, the function returns a negative value.
3011 */
12f288bf
TI		 3012int snd_hda_check_board_config(struct hda_codec *codec,
3013 int num_configs, const char **models,
3014 const struct snd_pci_quirk *tbl)
1da177e4 3015{
f44ac837 3016 if (codec->modelname && models) {
f5fcc13c
TI		 3017 int i;
3018 for (i = 0; i < num_configs; i++) {
3019 if (models[i] &&
f44ac837 3020 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 3021 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3022 "selected\n", models[i]);
3023 return i;
1da177e4
LT		 3024 }
3025 }
3026 }
3027
f5fcc13c
TI		 3028 if (!codec->bus->pci || !tbl)
3029 return -1;
3030
3031 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3032 if (!tbl)
3033 return -1;
3034 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 3035#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 3036 char tmp[10];
3037 const char *model = NULL;
3038 if (models)
3039 model = models[tbl->value];
3040 if (!model) {
3041 sprintf(tmp, "#%d", tbl->value);
3042 model = tmp;
1da177e4 3043 }
f5fcc13c
TI		 3044 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3045 "for config %x:%x (%s)\n",
3046 model, tbl->subvendor, tbl->subdevice,
3047 (tbl->name ? tbl->name : "Unknown device"));
3048#endif
3049 return tbl->value;
1da177e4
LT		 3050 }
3051 return -1;
3052}
ff7a3267 3053EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 3054
2eda3445
MCC		 3055/**
3056 * snd_hda_check_board_codec_sid_config - compare the current codec
3057 subsystem ID with the
3058 config table
3059
3060 This is important for Gateway notebooks with SB450 HDA Audio
3061 where the vendor ID of the PCI device is:
3062 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3063 and the vendor/subvendor are found only at the codec.
3064
3065 * @codec: the HDA codec
3066 * @num_configs: number of config enums
3067 * @models: array of model name strings
3068 * @tbl: configuration table, terminated by null entries
3069 *
3070 * Compares the modelname or PCI subsystem id of the current codec with the
3071 * given configuration table. If a matching entry is found, returns its
3072 * config value (supposed to be 0 or positive).
3073 *
3074 * If no entries are matching, the function returns a negative value.
3075 */
3076int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3077 int num_configs, const char **models,
3078 const struct snd_pci_quirk *tbl)
3079{
3080 const struct snd_pci_quirk *q;
3081
3082 /* Search for codec ID */
3083 for (q = tbl; q->subvendor; q++) {
3084 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3085
3086 if (vendorid == codec->subsystem_id)
3087 break;
3088 }
3089
3090 if (!q->subvendor)
3091 return -1;
3092
3093 tbl = q;
3094
3095 if (tbl->value >= 0 && tbl->value < num_configs) {
3096#ifdef CONFIG_SND_DEBUG_DETECT
3097 char tmp[10];
3098 const char *model = NULL;
3099 if (models)
3100 model = models[tbl->value];
3101 if (!model) {
3102 sprintf(tmp, "#%d", tbl->value);
3103 model = tmp;
3104 }
3105 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3106 "for config %x:%x (%s)\n",
3107 model, tbl->subvendor, tbl->subdevice,
3108 (tbl->name ? tbl->name : "Unknown device"));
3109#endif
3110 return tbl->value;
3111 }
3112 return -1;
3113}
3114EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3115
1da177e4
LT		 3116/**
3117 * snd_hda_add_new_ctls - create controls from the array
3118 * @codec: the HDA codec
c8b6bf9b 3119 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 3120 *
3121 * This helper function creates and add new controls in the given array.
3122 * The array must be terminated with an empty entry as terminator.
3123 *
3124 * Returns 0 if successful, or a negative error code.
3125 */
12f288bf 3126int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
1da177e4 3127{
cb53c626 3128 int err;
1da177e4
LT		 3129
3130 for (; knew->name; knew++) {
54d17403
TI		 3131 struct snd_kcontrol *kctl;
3132 kctl = snd_ctl_new1(knew, codec);
0ba21762 3133 if (!kctl)
54d17403 3134 return -ENOMEM;
d13bd412 3135 err = snd_hda_ctl_add(codec, kctl);
54d17403 3136 if (err < 0) {
0ba21762 3137 if (!codec->addr)
54d17403
TI		 3138 return err;
3139 kctl = snd_ctl_new1(knew, codec);
0ba21762 3140 if (!kctl)
54d17403
TI		 3141 return -ENOMEM;
3142 kctl->id.device = codec->addr;
d13bd412 3143 err = snd_hda_ctl_add(codec, kctl);
0ba21762 3144 if (err < 0)
54d17403
TI		 3145 return err;
3146 }
1da177e4
LT		 3147 }
3148 return 0;
3149}
ff7a3267 3150EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 3151
cb53c626
TI		 3152#ifdef CONFIG_SND_HDA_POWER_SAVE
3153static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3154 unsigned int power_state);
3155
3156static void hda_power_work(struct work_struct *work)
3157{
3158 struct hda_codec *codec =
3159 container_of(work, struct hda_codec, power_work.work);
33fa35ed 3160 struct hda_bus *bus = codec->bus;
cb53c626 3161
2e492462
ML		 3162 if (!codec->power_on || codec->power_count) {
3163 codec->power_transition = 0;
cb53c626 3164 return;
2e492462 3165 }
cb53c626
TI		 3166
3167 hda_call_codec_suspend(codec);
33fa35ed
TI		 3168 if (bus->ops.pm_notify)
3169 bus->ops.pm_notify(bus);
cb53c626
TI		 3170}
3171
3172static void hda_keep_power_on(struct hda_codec *codec)
3173{
3174 codec->power_count++;
3175 codec->power_on = 1;
3176}
3177
3178void snd_hda_power_up(struct hda_codec *codec)
3179{
33fa35ed
TI		 3180 struct hda_bus *bus = codec->bus;
3181
cb53c626 3182 codec->power_count++;
a221e287 3183 if (codec->power_on || codec->power_transition)
cb53c626
TI		 3184 return;
3185
3186 codec->power_on = 1;
33fa35ed
TI		 3187 if (bus->ops.pm_notify)
3188 bus->ops.pm_notify(bus);
cb53c626
TI		 3189 hda_call_codec_resume(codec);
3190 cancel_delayed_work(&codec->power_work);
a221e287 3191 codec->power_transition = 0;
cb53c626 3192}
ff7a3267 3193EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 3194
3195#define power_save(codec) \
3196 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 3197
fee2fba3
TI		 3198#define power_save(codec) \
3199 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3200
cb53c626
TI		 3201void snd_hda_power_down(struct hda_codec *codec)
3202{
3203 --codec->power_count;
a221e287 3204 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 3205 return;
fee2fba3 3206 if (power_save(codec)) {
a221e287 3207 codec->power_transition = 1; /* avoid reentrance */
c107b41c 3208 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 3209 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 3210 }
cb53c626 3211}
ff7a3267 3212EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626
TI		 3213
3214int snd_hda_check_amp_list_power(struct hda_codec *codec,
3215 struct hda_loopback_check *check,
3216 hda_nid_t nid)
3217{
3218 struct hda_amp_list *p;
3219 int ch, v;
3220
3221 if (!check->amplist)
3222 return 0;
3223 for (p = check->amplist; p->nid; p++) {
3224 if (p->nid == nid)
3225 break;
3226 }
3227 if (!p->nid)
3228 return 0; /* nothing changed */
3229
3230 for (p = check->amplist; p->nid; p++) {
3231 for (ch = 0; ch < 2; ch++) {
3232 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3233 p->idx);
3234 if (!(v & HDA_AMP_MUTE) && v > 0) {
3235 if (!check->power_on) {
3236 check->power_on = 1;
3237 snd_hda_power_up(codec);
3238 }
3239 return 1;
3240 }
3241 }
3242 }
3243 if (check->power_on) {
3244 check->power_on = 0;
3245 snd_hda_power_down(codec);
3246 }
3247 return 0;
3248}
ff7a3267 3249EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 3250#endif
1da177e4 3251
c8b6bf9b 3252/*
d2a6d7dc
TI		 3253 * Channel mode helper
3254 */
0ba21762
TI		 3255int snd_hda_ch_mode_info(struct hda_codec *codec,
3256 struct snd_ctl_elem_info *uinfo,
3257 const struct hda_channel_mode *chmode,
3258 int num_chmodes)
d2a6d7dc
TI		 3259{
3260 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3261 uinfo->count = 1;
3262 uinfo->value.enumerated.items = num_chmodes;
3263 if (uinfo->value.enumerated.item >= num_chmodes)
3264 uinfo->value.enumerated.item = num_chmodes - 1;
3265 sprintf(uinfo->value.enumerated.name, "%dch",
3266 chmode[uinfo->value.enumerated.item].channels);
3267 return 0;
3268}
ff7a3267 3269EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 3270
0ba21762
TI		 3271int snd_hda_ch_mode_get(struct hda_codec *codec,
3272 struct snd_ctl_elem_value *ucontrol,
3273 const struct hda_channel_mode *chmode,
3274 int num_chmodes,
d2a6d7dc
TI		 3275 int max_channels)
3276{
3277 int i;
3278
3279 for (i = 0; i < num_chmodes; i++) {
3280 if (max_channels == chmode[i].channels) {
3281 ucontrol->value.enumerated.item[0] = i;
3282 break;
3283 }
3284 }
3285 return 0;
3286}
ff7a3267 3287EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 3288
0ba21762
TI		 3289int snd_hda_ch_mode_put(struct hda_codec *codec,
3290 struct snd_ctl_elem_value *ucontrol,
3291 const struct hda_channel_mode *chmode,
3292 int num_chmodes,
d2a6d7dc
TI		 3293 int *max_channelsp)
3294{
3295 unsigned int mode;
3296
3297 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 3298 if (mode >= num_chmodes)
3299 return -EINVAL;
82beb8fd 3300 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 3301 return 0;
3302 /* change the current channel setting */
3303 *max_channelsp = chmode[mode].channels;
3304 if (chmode[mode].sequence)
82beb8fd 3305 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 3306 return 1;
3307}
ff7a3267 3308EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 3309
1da177e4
LT		 3310/*
3311 * input MUX helper
3312 */
0ba21762
TI		 3313int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3314 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3315{
3316 unsigned int index;
3317
3318 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3319 uinfo->count = 1;
3320 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 3321 if (!imux->num_items)
3322 return 0;
1da177e4
LT		 3323 index = uinfo->value.enumerated.item;
3324 if (index >= imux->num_items)
3325 index = imux->num_items - 1;
3326 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3327 return 0;
3328}
ff7a3267 3329EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 3330
0ba21762
TI		 3331int snd_hda_input_mux_put(struct hda_codec *codec,
3332 const struct hda_input_mux *imux,
3333 struct snd_ctl_elem_value *ucontrol,
3334 hda_nid_t nid,
1da177e4
LT		 3335 unsigned int *cur_val)
3336{
3337 unsigned int idx;
3338
5513b0c5
TI		 3339 if (!imux->num_items)
3340 return 0;
1da177e4
LT		 3341 idx = ucontrol->value.enumerated.item[0];
3342 if (idx >= imux->num_items)
3343 idx = imux->num_items - 1;
82beb8fd 3344 if (*cur_val == idx)
1da177e4 3345 return 0;
82beb8fd
TI		 3346 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3347 imux->items[idx].index);
1da177e4
LT		 3348 *cur_val = idx;
3349 return 1;
3350}
ff7a3267 3351EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 3352
3353
3354/*
3355 * Multi-channel / digital-out PCM helper functions
3356 */
3357
6b97eb45
TI		 3358/* setup SPDIF output stream */
3359static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3360 unsigned int stream_tag, unsigned int format)
3361{
3362 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2f72853c
TI		 3363 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3364 set_dig_out_convert(codec, nid,
3365 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3366 -1);
6b97eb45 3367 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c
TI		 3368 if (codec->slave_dig_outs) {
3369 hda_nid_t *d;
3370 for (d = codec->slave_dig_outs; *d; d++)
3371 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3372 format);
3373 }
6b97eb45 3374 /* turn on again (if needed) */
2f72853c
TI		 3375 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3376 set_dig_out_convert(codec, nid,
3377 codec->spdif_ctls & 0xff, -1);
3378}
de51ca12 3379
2f72853c
TI		 3380static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3381{
3382 snd_hda_codec_cleanup_stream(codec, nid);
3383 if (codec->slave_dig_outs) {
3384 hda_nid_t *d;
3385 for (d = codec->slave_dig_outs; *d; d++)
3386 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 3387 }
6b97eb45
TI		 3388}
3389
1da177e4
LT		 3390/*
3391 * open the digital out in the exclusive mode
3392 */
0ba21762
TI		 3393int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3394 struct hda_multi_out *mout)
1da177e4 3395{
62932df8 3396 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 3397 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3398 /* already opened as analog dup; reset it once */
2f72853c 3399 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 3400 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 3401 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3402 return 0;
3403}
ff7a3267 3404EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 3405
6b97eb45
TI		 3406int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3407 struct hda_multi_out *mout,
3408 unsigned int stream_tag,
3409 unsigned int format,
3410 struct snd_pcm_substream *substream)
3411{
3412 mutex_lock(&codec->spdif_mutex);
3413 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3414 mutex_unlock(&codec->spdif_mutex);
3415 return 0;
3416}
ff7a3267 3417EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 3418
9411e21c
TI		 3419int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3420 struct hda_multi_out *mout)
3421{
3422 mutex_lock(&codec->spdif_mutex);
3423 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3424 mutex_unlock(&codec->spdif_mutex);
3425 return 0;
3426}
3427EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3428
1da177e4
LT		 3429/*
3430 * release the digital out
3431 */
0ba21762
TI		 3432int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3433 struct hda_multi_out *mout)
1da177e4 3434{
62932df8 3435 mutex_lock(&codec->spdif_mutex);
1da177e4 3436 mout->dig_out_used = 0;
62932df8 3437 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3438 return 0;
3439}
ff7a3267 3440EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4
LT		 3441
3442/*
3443 * set up more restrictions for analog out
3444 */
0ba21762
TI		 3445int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3446 struct hda_multi_out *mout,
9a08160b
TI		 3447 struct snd_pcm_substream *substream,
3448 struct hda_pcm_stream *hinfo)
3449{
3450 struct snd_pcm_runtime *runtime = substream->runtime;
3451 runtime->hw.channels_max = mout->max_channels;
3452 if (mout->dig_out_nid) {
3453 if (!mout->analog_rates) {
3454 mout->analog_rates = hinfo->rates;
3455 mout->analog_formats = hinfo->formats;
3456 mout->analog_maxbps = hinfo->maxbps;
3457 } else {
3458 runtime->hw.rates = mout->analog_rates;
3459 runtime->hw.formats = mout->analog_formats;
3460 hinfo->maxbps = mout->analog_maxbps;
3461 }
3462 if (!mout->spdif_rates) {
3463 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3464 &mout->spdif_rates,
3465 &mout->spdif_formats,
3466 &mout->spdif_maxbps);
3467 }
3468 mutex_lock(&codec->spdif_mutex);
3469 if (mout->share_spdif) {
022b466f
TI		 3470 if ((runtime->hw.rates & mout->spdif_rates) &&
3471 (runtime->hw.formats & mout->spdif_formats)) {
3472 runtime->hw.rates &= mout->spdif_rates;
3473 runtime->hw.formats &= mout->spdif_formats;
3474 if (mout->spdif_maxbps < hinfo->maxbps)
3475 hinfo->maxbps = mout->spdif_maxbps;
3476 } else {
3477 mout->share_spdif = 0;
3478 /* FIXME: need notify? */
3479 }
9a08160b 3480 }
eaa9985b 3481 mutex_unlock(&codec->spdif_mutex);
9a08160b 3482 }
1da177e4
LT		 3483 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3484 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3485}
ff7a3267 3486EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4
LT		 3487
3488/*
3489 * set up the i/o for analog out
3490 * when the digital out is available, copy the front out to digital out, too.
3491 */
0ba21762
TI		 3492int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3493 struct hda_multi_out *mout,
1da177e4
LT		 3494 unsigned int stream_tag,
3495 unsigned int format,
c8b6bf9b 3496 struct snd_pcm_substream *substream)
1da177e4
LT		 3497{
3498 hda_nid_t *nids = mout->dac_nids;
3499 int chs = substream->runtime->channels;
3500 int i;
3501
62932df8 3502 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 3503 if (mout->dig_out_nid && mout->share_spdif &&
3504 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 3505 if (chs == 2 &&
0ba21762
TI		 3506 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3507 format) &&
3508 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
1da177e4 3509 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 3510 setup_dig_out_stream(codec, mout->dig_out_nid,
3511 stream_tag, format);
1da177e4
LT		 3512 } else {
3513 mout->dig_out_used = 0;
2f72853c 3514 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3515 }
3516 }
62932df8 3517 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3518
3519 /* front */
0ba21762
TI		 3520 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3521 0, format);
d29240ce
TI		 3522 if (!mout->no_share_stream &&
3523 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 3524 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 3525 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3526 0, format);
82bc955f
TI		 3527 /* extra outputs copied from front */
3528 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 3529 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 3530 snd_hda_codec_setup_stream(codec,
3531 mout->extra_out_nid[i],
3532 stream_tag, 0, format);
3533
1da177e4
LT		 3534 /* surrounds */
3535 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 3536 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 3537 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3538 i * 2, format);
d29240ce 3539 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 3540 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3541 0, format);
1da177e4
LT		 3542 }
3543 return 0;
3544}
ff7a3267 3545EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4
LT		 3546
3547/*
3548 * clean up the setting for analog out
3549 */
0ba21762
TI		 3550int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3551 struct hda_multi_out *mout)
1da177e4
LT		 3552{
3553 hda_nid_t *nids = mout->dac_nids;
3554 int i;
3555
3556 for (i = 0; i < mout->num_dacs; i++)
888afa15 3557 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 3558 if (mout->hp_nid)
888afa15 3559 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
82bc955f
TI		 3560 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3561 if (mout->extra_out_nid[i])
888afa15
TI		 3562 snd_hda_codec_cleanup_stream(codec,
3563 mout->extra_out_nid[i]);
62932df8 3564 mutex_lock(&codec->spdif_mutex);
1da177e4 3565 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 3566 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3567 mout->dig_out_used = 0;
3568 }
62932df8 3569 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3570 return 0;
3571}
ff7a3267 3572EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 3573
e9edcee0 3574/*
6b34500c 3575 * Helper for automatic pin configuration
e9edcee0 3576 */
df694daa 3577
12f288bf 3578static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
df694daa
KY		 3579{
3580 for (; *list; list++)
3581 if (*list == nid)
3582 return 1;
3583 return 0;
3584}
3585
81937d3b
SL		 3586
3587/*
3588 * Sort an associated group of pins according to their sequence numbers.
3589 */
3590static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3591 int num_pins)
3592{
3593 int i, j;
3594 short seq;
3595 hda_nid_t nid;
3596
3597 for (i = 0; i < num_pins; i++) {
3598 for (j = i + 1; j < num_pins; j++) {
3599 if (sequences[i] > sequences[j]) {
3600 seq = sequences[i];
3601 sequences[i] = sequences[j];
3602 sequences[j] = seq;
3603 nid = pins[i];
3604 pins[i] = pins[j];
3605 pins[j] = nid;
3606 }
3607 }
3608 }
3609}
3610
3611
82bc955f
TI		 3612/*
3613 * Parse all pin widgets and store the useful pin nids to cfg
3614 *
3615 * The number of line-outs or any primary output is stored in line_outs,
3616 * and the corresponding output pins are assigned to line_out_pins[],
3617 * in the order of front, rear, CLFE, side, ...
3618 *
3619 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 3620 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 3621 * is detected, one of speaker of HP pins is assigned as the primary
3622 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3623 * if any analog output exists.
3624 *
3625 * The analog input pins are assigned to input_pins array.
3626 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3627 * respectively.
3628 */
12f288bf
TI		 3629int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3630 struct auto_pin_cfg *cfg,
3631 hda_nid_t *ignore_nids)
e9edcee0 3632{
0ef6ce7b 3633 hda_nid_t nid, end_nid;
81937d3b
SL		 3634 short seq, assoc_line_out, assoc_speaker;
3635 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3636 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 3637 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
e9edcee0
TI		 3638
3639 memset(cfg, 0, sizeof(*cfg));
3640
81937d3b
SL		 3641 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3642 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 3643 memset(sequences_hp, 0, sizeof(sequences_hp));
81937d3b 3644 assoc_line_out = assoc_speaker = 0;
e9edcee0 3645
0ef6ce7b
TI		 3646 end_nid = codec->start_nid + codec->num_nodes;
3647 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 3648 unsigned int wid_caps = get_wcaps(codec, nid);
0ba21762
TI		 3649 unsigned int wid_type =
3650 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
e9edcee0
TI		 3651 unsigned int def_conf;
3652 short assoc, loc;
3653
3654 /* read all default configuration for pin complex */
3655 if (wid_type != AC_WID_PIN)
3656 continue;
df694daa
KY		 3657 /* ignore the given nids (e.g. pc-beep returns error) */
3658 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3659 continue;
3660
c17a1aba 3661 def_conf = snd_hda_codec_get_pincfg(codec, nid);
e9edcee0
TI		 3662 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3663 continue;
3664 loc = get_defcfg_location(def_conf);
3665 switch (get_defcfg_device(def_conf)) {
3666 case AC_JACK_LINE_OUT:
e9edcee0
TI		 3667 seq = get_defcfg_sequence(def_conf);
3668 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 3669
3670 if (!(wid_caps & AC_WCAP_STEREO))
3671 if (!cfg->mono_out_pin)
3672 cfg->mono_out_pin = nid;
0ba21762 3673 if (!assoc)
e9edcee0 3674 continue;
0ba21762 3675 if (!assoc_line_out)
e9edcee0
TI		 3676 assoc_line_out = assoc;
3677 else if (assoc_line_out != assoc)
3678 continue;
3679 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3680 continue;
3681 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 3682 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 3683 cfg->line_outs++;
3684 break;
8d88bc3d 3685 case AC_JACK_SPEAKER:
81937d3b
SL		 3686 seq = get_defcfg_sequence(def_conf);
3687 assoc = get_defcfg_association(def_conf);
3688 if (! assoc)
3689 continue;
3690 if (! assoc_speaker)
3691 assoc_speaker = assoc;
3692 else if (assoc_speaker != assoc)
3693 continue;
82bc955f
TI		 3694 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3695 continue;
3696 cfg->speaker_pins[cfg->speaker_outs] = nid;
81937d3b 3697 sequences_speaker[cfg->speaker_outs] = seq;
82bc955f 3698 cfg->speaker_outs++;
8d88bc3d 3699 break;
e9edcee0 3700 case AC_JACK_HP_OUT:
f889fa91
TI		 3701 seq = get_defcfg_sequence(def_conf);
3702 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 3703 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3704 continue;
3705 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 3706 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 3707 cfg->hp_outs++;
e9edcee0 3708 break;
314634bc
TI		 3709 case AC_JACK_MIC_IN: {
3710 int preferred, alt;
3711 if (loc == AC_JACK_LOC_FRONT) {
3712 preferred = AUTO_PIN_FRONT_MIC;
3713 alt = AUTO_PIN_MIC;
3714 } else {
3715 preferred = AUTO_PIN_MIC;
3716 alt = AUTO_PIN_FRONT_MIC;
3717 }
3718 if (!cfg->input_pins[preferred])
3719 cfg->input_pins[preferred] = nid;
3720 else if (!cfg->input_pins[alt])
3721 cfg->input_pins[alt] = nid;
e9edcee0 3722 break;
314634bc 3723 }
e9edcee0
TI		 3724 case AC_JACK_LINE_IN:
3725 if (loc == AC_JACK_LOC_FRONT)
3726 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3727 else
3728 cfg->input_pins[AUTO_PIN_LINE] = nid;
3729 break;
3730 case AC_JACK_CD:
3731 cfg->input_pins[AUTO_PIN_CD] = nid;
3732 break;
3733 case AC_JACK_AUX:
3734 cfg->input_pins[AUTO_PIN_AUX] = nid;
3735 break;
3736 case AC_JACK_SPDIF_OUT:
1b52ae70 3737 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 3738 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3739 continue;
3740 cfg->dig_out_pins[cfg->dig_outs] = nid;
3741 cfg->dig_out_type[cfg->dig_outs] =
3742 (loc == AC_JACK_LOC_HDMI) ?
3743 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3744 cfg->dig_outs++;
e9edcee0
TI		 3745 break;
3746 case AC_JACK_SPDIF_IN:
1b52ae70 3747 case AC_JACK_DIG_OTHER_IN:
e9edcee0 3748 cfg->dig_in_pin = nid;
2297bd6e
TI		 3749 if (loc == AC_JACK_LOC_HDMI)
3750 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3751 else
3752 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 3753 break;
3754 }
3755 }
3756
5832fcf8
TI		 3757 /* FIX-UP:
3758 * If no line-out is defined but multiple HPs are found,
3759 * some of them might be the real line-outs.
3760 */
3761 if (!cfg->line_outs && cfg->hp_outs > 1) {
3762 int i = 0;
3763 while (i < cfg->hp_outs) {
3764 /* The real HPs should have the sequence 0x0f */
3765 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3766 i++;
3767 continue;
3768 }
3769 /* Move it to the line-out table */
3770 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3771 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3772 cfg->line_outs++;
3773 cfg->hp_outs--;
3774 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3775 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3776 memmove(sequences_hp + i - 1, sequences_hp + i,
3777 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3778 }
3779 }
3780
e9edcee0 3781 /* sort by sequence */
81937d3b
SL		 3782 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3783 cfg->line_outs);
3784 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3785 cfg->speaker_outs);
f889fa91
TI		 3786 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3787 cfg->hp_outs);
81937d3b 3788
f889fa91
TI		 3789 /* if we have only one mic, make it AUTO_PIN_MIC */
3790 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3791 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3792 cfg->input_pins[AUTO_PIN_MIC] =
3793 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3794 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3795 }
3796 /* ditto for line-in */
3797 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3798 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3799 cfg->input_pins[AUTO_PIN_LINE] =
3800 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3801 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3802 }
3803
81937d3b
SL		 3804 /*
3805 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3806 * as a primary output
3807 */
3808 if (!cfg->line_outs) {
3809 if (cfg->speaker_outs) {
3810 cfg->line_outs = cfg->speaker_outs;
3811 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3812 sizeof(cfg->speaker_pins));
3813 cfg->speaker_outs = 0;
3814 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3815 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3816 } else if (cfg->hp_outs) {
3817 cfg->line_outs = cfg->hp_outs;
3818 memcpy(cfg->line_out_pins, cfg->hp_pins,
3819 sizeof(cfg->hp_pins));
3820 cfg->hp_outs = 0;
3821 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3822 cfg->line_out_type = AUTO_PIN_HP_OUT;
3823 }
3824 }
e9edcee0 3825
cb8e2f83
TI		 3826 /* Reorder the surround channels
3827 * ALSA sequence is front/surr/clfe/side
3828 * HDA sequence is:
3829 * 4-ch: front/surr => OK as it is
3830 * 6-ch: front/clfe/surr
9422db40 3831 * 8-ch: front/clfe/rear/side|fc
cb8e2f83
TI		 3832 */
3833 switch (cfg->line_outs) {
3834 case 3:
cb8e2f83
TI		 3835 case 4:
3836 nid = cfg->line_out_pins[1];
9422db40 3837 cfg->line_out_pins[1] = cfg->line_out_pins[2];
cb8e2f83
TI		 3838 cfg->line_out_pins[2] = nid;
3839 break;
e9edcee0
TI		 3840 }
3841
82bc955f
TI		 3842 /*
3843 * debug prints of the parsed results
3844 */
3845 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3846 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3847 cfg->line_out_pins[2], cfg->line_out_pins[3],
3848 cfg->line_out_pins[4]);
3849 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3850 cfg->speaker_outs, cfg->speaker_pins[0],
3851 cfg->speaker_pins[1], cfg->speaker_pins[2],
3852 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 3853 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3854 cfg->hp_outs, cfg->hp_pins[0],
3855 cfg->hp_pins[1], cfg->hp_pins[2],
3856 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 3857 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 3858 if (cfg->dig_outs)
3859 snd_printd(" dig-out=0x%x/0x%x\n",
3860 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
82bc955f
TI		 3861 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3862 " cd=0x%x, aux=0x%x\n",
3863 cfg->input_pins[AUTO_PIN_MIC],
3864 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3865 cfg->input_pins[AUTO_PIN_LINE],
3866 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3867 cfg->input_pins[AUTO_PIN_CD],
3868 cfg->input_pins[AUTO_PIN_AUX]);
32d2c7fa 3869 if (cfg->dig_in_pin)
89ce9e87 3870 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 3871
e9edcee0
TI		 3872 return 0;
3873}
ff7a3267 3874EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
e9edcee0 3875
4a471b7d
TI		 3876/* labels for input pins */
3877const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3878 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3879};
ff7a3267 3880EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4a471b7d
TI		 3881
3882
1da177e4
LT		 3883#ifdef CONFIG_PM
3884/*
3885 * power management
3886 */
3887
3888/**
3889 * snd_hda_suspend - suspend the codecs
3890 * @bus: the HDA bus
1da177e4
LT		 3891 *
3892 * Returns 0 if successful.
3893 */
8dd78330 3894int snd_hda_suspend(struct hda_bus *bus)
1da177e4 3895{
0ba21762 3896 struct hda_codec *codec;
1da177e4 3897
0ba21762 3898 list_for_each_entry(codec, &bus->codec_list, list) {
0b7a2e9c
TI		 3899#ifdef CONFIG_SND_HDA_POWER_SAVE
3900 if (!codec->power_on)
3901 continue;
3902#endif
cb53c626 3903 hda_call_codec_suspend(codec);
1da177e4
LT		 3904 }
3905 return 0;
3906}
ff7a3267 3907EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 3908
3909/**
3910 * snd_hda_resume - resume the codecs
3911 * @bus: the HDA bus
1da177e4
LT		 3912 *
3913 * Returns 0 if successful.
cb53c626
TI		 3914 *
3915 * This fucntion is defined only when POWER_SAVE isn't set.
3916 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 3917 */
3918int snd_hda_resume(struct hda_bus *bus)
3919{
0ba21762 3920 struct hda_codec *codec;
1da177e4 3921
0ba21762 3922 list_for_each_entry(codec, &bus->codec_list, list) {
d804ad92
ML		 3923 if (snd_hda_codec_needs_resume(codec))
3924 hda_call_codec_resume(codec);
1da177e4 3925 }
1da177e4
LT		 3926 return 0;
3927}
ff7a3267 3928EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 3929#endif /* CONFIG_PM */
b2e18597
TI		 3930
3931/*
3932 * generic arrays
3933 */
3934
3935/* get a new element from the given array
3936 * if it exceeds the pre-allocated array size, re-allocate the array
3937 */
3938void *snd_array_new(struct snd_array *array)
3939{
3940 if (array->used >= array->alloced) {
3941 int num = array->alloced + array->alloc_align;
b910d9ae
TI		 3942 void *nlist;
3943 if (snd_BUG_ON(num >= 4096))
3944 return NULL;
3945 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
b2e18597
TI		 3946 if (!nlist)
3947 return NULL;
3948 if (array->list) {
3949 memcpy(nlist, array->list,
3950 array->elem_size * array->alloced);
3951 kfree(array->list);
3952 }
3953 array->list = nlist;
3954 array->alloced = num;
3955 }
f43aa025 3956 return snd_array_elem(array, array->used++);
b2e18597 3957}
ff7a3267 3958EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597
TI		 3959
3960/* free the given array elements */
3961void snd_array_free(struct snd_array *array)
3962{
3963 kfree(array->list);
3964 array->used = 0;
3965 array->alloced = 0;
3966 array->list = NULL;
3967}
ff7a3267 3968EXPORT_SYMBOL_HDA(snd_array_free);
b2022266
TI		 3969
3970/*
3971 * used by hda_proc.c and hda_eld.c
3972 */
3973void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3974{
3975 static unsigned int rates[] = {
3976 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3977 96000, 176400, 192000, 384000
3978 };
3979 int i, j;
3980
3981 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3982 if (pcm & (1 << i))
3983 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3984
3985 buf[j] = '\0'; /* necessary when j == 0 */
3986}
ff7a3267 3987EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
b2022266
TI		 3988
3989void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3990{
3991 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3992 int i, j;
3993
3994 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3995 if (pcm & (AC_SUPPCM_BITS_8 << i))
3996 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3997
3998 buf[j] = '\0'; /* necessary when j == 0 */
3999}
ff7a3267 4000EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 4001
4002MODULE_DESCRIPTION("HDA codec core");
4003MODULE_LICENSE("GPL");
ubuntu-zesty-kernel mirror