projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'fix/hda' into topic/hda
[deliverable/linux.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:
2566 if (maxbps >= 32)
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
LT		 2694 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2695 bps = 32;
b5025c50
TI		 2696 }
2697 if (streams == AC_SUPFMT_AC3) {
0ba21762 2698 /* should be exclusive */
1da177e4
LT		 2699 /* temporary hack: we have still no proper support
2700 * for the direct AC3 stream...
2701 */
2702 formats |= SNDRV_PCM_FMTBIT_U8;
2703 bps = 8;
2704 }
ee504710
JK		 2705 if (formats == 0) {
2706 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2707 "(nid=0x%x, val=0x%x, ovrd=%i, "
2708 "streams=0x%x)\n",
2709 nid, val,
2710 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2711 streams);
2712 return -EIO;
2713 }
1da177e4
LT		 2714 if (formatsp)
2715 *formatsp = formats;
2716 if (bpsp)
2717 *bpsp = bps;
2718 }
2719
2720 return 0;
2721}
2722
2723/**
0ba21762
TI		 2724 * snd_hda_is_supported_format - check whether the given node supports
2725 * the format val
1da177e4
LT		 2726 *
2727 * Returns 1 if supported, 0 if not.
2728 */
2729int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2730 unsigned int format)
2731{
2732 int i;
2733 unsigned int val = 0, rate, stream;
2734
92c7c8a7
TI		 2735 val = query_pcm_param(codec, nid);
2736 if (!val)
2737 return 0;
1da177e4
LT		 2738
2739 rate = format & 0xff00;
a961f9fe 2740 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 2741 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 2742 if (val & (1 << i))
2743 break;
2744 return 0;
2745 }
a961f9fe 2746 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 2747 return 0;
2748
92c7c8a7
TI		 2749 stream = query_stream_param(codec, nid);
2750 if (!stream)
1da177e4
LT		 2751 return 0;
2752
2753 if (stream & AC_SUPFMT_PCM) {
2754 switch (format & 0xf0) {
2755 case 0x00:
0ba21762 2756 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 2757 return 0;
2758 break;
2759 case 0x10:
0ba21762 2760 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 2761 return 0;
2762 break;
2763 case 0x20:
0ba21762 2764 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 2765 return 0;
2766 break;
2767 case 0x30:
0ba21762 2768 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 2769 return 0;
2770 break;
2771 case 0x40:
0ba21762 2772 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 2773 return 0;
2774 break;
2775 default:
2776 return 0;
2777 }
2778 } else {
2779 /* FIXME: check for float32 and AC3? */
2780 }
2781
2782 return 1;
2783}
ff7a3267 2784EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 2785
2786/*
2787 * PCM stuff
2788 */
2789static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2790 struct hda_codec *codec,
c8b6bf9b 2791 struct snd_pcm_substream *substream)
1da177e4
LT		 2792{
2793 return 0;
2794}
2795
2796static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2797 struct hda_codec *codec,
2798 unsigned int stream_tag,
2799 unsigned int format,
c8b6bf9b 2800 struct snd_pcm_substream *substream)
1da177e4
LT		 2801{
2802 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2803 return 0;
2804}
2805
2806static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2807 struct hda_codec *codec,
c8b6bf9b 2808 struct snd_pcm_substream *substream)
1da177e4 2809{
888afa15 2810 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 2811 return 0;
2812}
2813
6c1f45ea
TI		 2814static int set_pcm_default_values(struct hda_codec *codec,
2815 struct hda_pcm_stream *info)
1da177e4 2816{
ee504710
JK		 2817 int err;
2818
0ba21762
TI		 2819 /* query support PCM information from the given NID */
2820 if (info->nid && (!info->rates || !info->formats)) {
ee504710 2821 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 2822 info->rates ? NULL : &info->rates,
2823 info->formats ? NULL : &info->formats,
2824 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 2825 if (err < 0)
2826 return err;
1da177e4
LT		 2827 }
2828 if (info->ops.open == NULL)
2829 info->ops.open = hda_pcm_default_open_close;
2830 if (info->ops.close == NULL)
2831 info->ops.close = hda_pcm_default_open_close;
2832 if (info->ops.prepare == NULL) {
da3cec35
TI		 2833 if (snd_BUG_ON(!info->nid))
2834 return -EINVAL;
1da177e4
LT		 2835 info->ops.prepare = hda_pcm_default_prepare;
2836 }
1da177e4 2837 if (info->ops.cleanup == NULL) {
da3cec35
TI		 2838 if (snd_BUG_ON(!info->nid))
2839 return -EINVAL;
1da177e4
LT		 2840 info->ops.cleanup = hda_pcm_default_cleanup;
2841 }
2842 return 0;
2843}
2844
529bd6c4
TI		 2845/*
2846 * get the empty PCM device number to assign
2847 */
2848static int get_empty_pcm_device(struct hda_bus *bus, int type)
2849{
2850 static const char *dev_name[HDA_PCM_NTYPES] = {
2851 "Audio", "SPDIF", "HDMI", "Modem"
2852 };
2853 /* starting device index for each PCM type */
2854 static int dev_idx[HDA_PCM_NTYPES] = {
2855 [HDA_PCM_TYPE_AUDIO] = 0,
2856 [HDA_PCM_TYPE_SPDIF] = 1,
2857 [HDA_PCM_TYPE_HDMI] = 3,
2858 [HDA_PCM_TYPE_MODEM] = 6
2859 };
2860 /* normal audio device indices; not linear to keep compatibility */
2861 static int audio_idx[4] = { 0, 2, 4, 5 };
2862 int i, dev;
2863
2864 switch (type) {
2865 case HDA_PCM_TYPE_AUDIO:
2866 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2867 dev = audio_idx[i];
2868 if (!test_bit(dev, bus->pcm_dev_bits))
82ad39f9 2869 goto ok;
529bd6c4 2870 }
82ad39f9
TI		 2871 snd_printk(KERN_WARNING "Too many audio devices\n");
2872 return -EAGAIN;
529bd6c4
TI		 2873 case HDA_PCM_TYPE_SPDIF:
2874 case HDA_PCM_TYPE_HDMI:
2875 case HDA_PCM_TYPE_MODEM:
2876 dev = dev_idx[type];
2877 if (test_bit(dev, bus->pcm_dev_bits)) {
2878 snd_printk(KERN_WARNING "%s already defined\n",
2879 dev_name[type]);
2880 return -EAGAIN;
2881 }
2882 break;
2883 default:
2884 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2885 return -EINVAL;
2886 }
82ad39f9 2887 ok:
529bd6c4
TI		 2888 set_bit(dev, bus->pcm_dev_bits);
2889 return dev;
2890}
2891
176d5335
TI		 2892/*
2893 * attach a new PCM stream
2894 */
529bd6c4 2895static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 2896{
33fa35ed 2897 struct hda_bus *bus = codec->bus;
176d5335
TI		 2898 struct hda_pcm_stream *info;
2899 int stream, err;
2900
b91f080f 2901 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 2902 return -EINVAL;
2903 for (stream = 0; stream < 2; stream++) {
2904 info = &pcm->stream[stream];
2905 if (info->substreams) {
2906 err = set_pcm_default_values(codec, info);
2907 if (err < 0)
2908 return err;
2909 }
2910 }
33fa35ed 2911 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 2912}
2913
529bd6c4
TI		 2914/* assign all PCMs of the given codec */
2915int snd_hda_codec_build_pcms(struct hda_codec *codec)
2916{
2917 unsigned int pcm;
2918 int err;
2919
2920 if (!codec->num_pcms) {
2921 if (!codec->patch_ops.build_pcms)
2922 return 0;
2923 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 2924 if (err < 0) {
2925 printk(KERN_ERR "hda_codec: cannot build PCMs"
2926 "for #%d (error %d)\n", codec->addr, err);
2927 err = snd_hda_codec_reset(codec);
2928 if (err < 0) {
2929 printk(KERN_ERR
2930 "hda_codec: cannot revert codec\n");
2931 return err;
2932 }
2933 }
529bd6c4
TI		 2934 }
2935 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2936 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2937 int dev;
2938
2939 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 2940 continue; /* no substreams assigned */
529bd6c4
TI		 2941
2942 if (!cpcm->pcm) {
2943 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2944 if (dev < 0)
6e655bf2 2945 continue; /* no fatal error */
529bd6c4
TI		 2946 cpcm->device = dev;
2947 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 2948 if (err < 0) {
2949 printk(KERN_ERR "hda_codec: cannot attach "
2950 "PCM stream %d for codec #%d\n",
2951 dev, codec->addr);
2952 continue; /* no fatal error */
2953 }
529bd6c4
TI		 2954 }
2955 }
2956 return 0;
2957}
2958
1da177e4
LT		 2959/**
2960 * snd_hda_build_pcms - build PCM information
2961 * @bus: the BUS
2962 *
2963 * Create PCM information for each codec included in the bus.
2964 *
2965 * The build_pcms codec patch is requested to set up codec->num_pcms and
2966 * codec->pcm_info properly. The array is referred by the top-level driver
2967 * to create its PCM instances.
2968 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2969 * callback.
2970 *
2971 * At least, substreams, channels_min and channels_max must be filled for
2972 * each stream. substreams = 0 indicates that the stream doesn't exist.
2973 * When rates and/or formats are zero, the supported values are queried
2974 * from the given nid. The nid is used also by the default ops.prepare
2975 * and ops.cleanup callbacks.
2976 *
2977 * The driver needs to call ops.open in its open callback. Similarly,
2978 * ops.close is supposed to be called in the close callback.
2979 * ops.prepare should be called in the prepare or hw_params callback
2980 * with the proper parameters for set up.
2981 * ops.cleanup should be called in hw_free for clean up of streams.
2982 *
2983 * This function returns 0 if successfull, or a negative error code.
2984 */
529bd6c4 2985int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 2986{
0ba21762 2987 struct hda_codec *codec;
1da177e4 2988
0ba21762 2989 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 2990 int err = snd_hda_codec_build_pcms(codec);
2991 if (err < 0)
2992 return err;
1da177e4
LT		 2993 }
2994 return 0;
2995}
ff7a3267 2996EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 2997
1da177e4
LT		 2998/**
2999 * snd_hda_check_board_config - compare the current codec with the config table
3000 * @codec: the HDA codec
f5fcc13c
TI		 3001 * @num_configs: number of config enums
3002 * @models: array of model name strings
1da177e4
LT		 3003 * @tbl: configuration table, terminated by null entries
3004 *
3005 * Compares the modelname or PCI subsystem id of the current codec with the
3006 * given configuration table. If a matching entry is found, returns its
3007 * config value (supposed to be 0 or positive).
3008 *
3009 * If no entries are matching, the function returns a negative value.
3010 */
12f288bf
TI		 3011int snd_hda_check_board_config(struct hda_codec *codec,
3012 int num_configs, const char **models,
3013 const struct snd_pci_quirk *tbl)
1da177e4 3014{
f44ac837 3015 if (codec->modelname && models) {
f5fcc13c
TI		 3016 int i;
3017 for (i = 0; i < num_configs; i++) {
3018 if (models[i] &&
f44ac837 3019 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 3020 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3021 "selected\n", models[i]);
3022 return i;
1da177e4
LT		 3023 }
3024 }
3025 }
3026
f5fcc13c
TI		 3027 if (!codec->bus->pci || !tbl)
3028 return -1;
3029
3030 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3031 if (!tbl)
3032 return -1;
3033 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 3034#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 3035 char tmp[10];
3036 const char *model = NULL;
3037 if (models)
3038 model = models[tbl->value];
3039 if (!model) {
3040 sprintf(tmp, "#%d", tbl->value);
3041 model = tmp;
1da177e4 3042 }
f5fcc13c
TI		 3043 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3044 "for config %x:%x (%s)\n",
3045 model, tbl->subvendor, tbl->subdevice,
3046 (tbl->name ? tbl->name : "Unknown device"));
3047#endif
3048 return tbl->value;
1da177e4
LT		 3049 }
3050 return -1;
3051}
ff7a3267 3052EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 3053
2eda3445
MCC		 3054/**
3055 * snd_hda_check_board_codec_sid_config - compare the current codec
3056 subsystem ID with the
3057 config table
3058
3059 This is important for Gateway notebooks with SB450 HDA Audio
3060 where the vendor ID of the PCI device is:
3061 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3062 and the vendor/subvendor are found only at the codec.
3063
3064 * @codec: the HDA codec
3065 * @num_configs: number of config enums
3066 * @models: array of model name strings
3067 * @tbl: configuration table, terminated by null entries
3068 *
3069 * Compares the modelname or PCI subsystem id of the current codec with the
3070 * given configuration table. If a matching entry is found, returns its
3071 * config value (supposed to be 0 or positive).
3072 *
3073 * If no entries are matching, the function returns a negative value.
3074 */
3075int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3076 int num_configs, const char **models,
3077 const struct snd_pci_quirk *tbl)
3078{
3079 const struct snd_pci_quirk *q;
3080
3081 /* Search for codec ID */
3082 for (q = tbl; q->subvendor; q++) {
3083 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3084
3085 if (vendorid == codec->subsystem_id)
3086 break;
3087 }
3088
3089 if (!q->subvendor)
3090 return -1;
3091
3092 tbl = q;
3093
3094 if (tbl->value >= 0 && tbl->value < num_configs) {
3095#ifdef CONFIG_SND_DEBUG_DETECT
3096 char tmp[10];
3097 const char *model = NULL;
3098 if (models)
3099 model = models[tbl->value];
3100 if (!model) {
3101 sprintf(tmp, "#%d", tbl->value);
3102 model = tmp;
3103 }
3104 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3105 "for config %x:%x (%s)\n",
3106 model, tbl->subvendor, tbl->subdevice,
3107 (tbl->name ? tbl->name : "Unknown device"));
3108#endif
3109 return tbl->value;
3110 }
3111 return -1;
3112}
3113EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3114
1da177e4
LT		 3115/**
3116 * snd_hda_add_new_ctls - create controls from the array
3117 * @codec: the HDA codec
c8b6bf9b 3118 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 3119 *
3120 * This helper function creates and add new controls in the given array.
3121 * The array must be terminated with an empty entry as terminator.
3122 *
3123 * Returns 0 if successful, or a negative error code.
3124 */
12f288bf 3125int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
1da177e4 3126{
cb53c626 3127 int err;
1da177e4
LT		 3128
3129 for (; knew->name; knew++) {
54d17403
TI		 3130 struct snd_kcontrol *kctl;
3131 kctl = snd_ctl_new1(knew, codec);
0ba21762 3132 if (!kctl)
54d17403 3133 return -ENOMEM;
d13bd412 3134 err = snd_hda_ctl_add(codec, kctl);
54d17403 3135 if (err < 0) {
0ba21762 3136 if (!codec->addr)
54d17403
TI		 3137 return err;
3138 kctl = snd_ctl_new1(knew, codec);
0ba21762 3139 if (!kctl)
54d17403
TI		 3140 return -ENOMEM;
3141 kctl->id.device = codec->addr;
d13bd412 3142 err = snd_hda_ctl_add(codec, kctl);
0ba21762 3143 if (err < 0)
54d17403
TI		 3144 return err;
3145 }
1da177e4
LT		 3146 }
3147 return 0;
3148}
ff7a3267 3149EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 3150
cb53c626
TI		 3151#ifdef CONFIG_SND_HDA_POWER_SAVE
3152static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3153 unsigned int power_state);
3154
3155static void hda_power_work(struct work_struct *work)
3156{
3157 struct hda_codec *codec =
3158 container_of(work, struct hda_codec, power_work.work);
33fa35ed 3159 struct hda_bus *bus = codec->bus;
cb53c626 3160
2e492462
ML		 3161 if (!codec->power_on || codec->power_count) {
3162 codec->power_transition = 0;
cb53c626 3163 return;
2e492462 3164 }
cb53c626
TI		 3165
3166 hda_call_codec_suspend(codec);
33fa35ed
TI		 3167 if (bus->ops.pm_notify)
3168 bus->ops.pm_notify(bus);
cb53c626
TI		 3169}
3170
3171static void hda_keep_power_on(struct hda_codec *codec)
3172{
3173 codec->power_count++;
3174 codec->power_on = 1;
3175}
3176
3177void snd_hda_power_up(struct hda_codec *codec)
3178{
33fa35ed
TI		 3179 struct hda_bus *bus = codec->bus;
3180
cb53c626 3181 codec->power_count++;
a221e287 3182 if (codec->power_on || codec->power_transition)
cb53c626
TI		 3183 return;
3184
3185 codec->power_on = 1;
33fa35ed
TI		 3186 if (bus->ops.pm_notify)
3187 bus->ops.pm_notify(bus);
cb53c626
TI		 3188 hda_call_codec_resume(codec);
3189 cancel_delayed_work(&codec->power_work);
a221e287 3190 codec->power_transition = 0;
cb53c626 3191}
ff7a3267 3192EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 3193
3194#define power_save(codec) \
3195 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 3196
fee2fba3
TI		 3197#define power_save(codec) \
3198 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3199
cb53c626
TI		 3200void snd_hda_power_down(struct hda_codec *codec)
3201{
3202 --codec->power_count;
a221e287 3203 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 3204 return;
fee2fba3 3205 if (power_save(codec)) {
a221e287 3206 codec->power_transition = 1; /* avoid reentrance */
c107b41c 3207 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 3208 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 3209 }
cb53c626 3210}
ff7a3267 3211EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626
TI		 3212
3213int snd_hda_check_amp_list_power(struct hda_codec *codec,
3214 struct hda_loopback_check *check,
3215 hda_nid_t nid)
3216{
3217 struct hda_amp_list *p;
3218 int ch, v;
3219
3220 if (!check->amplist)
3221 return 0;
3222 for (p = check->amplist; p->nid; p++) {
3223 if (p->nid == nid)
3224 break;
3225 }
3226 if (!p->nid)
3227 return 0; /* nothing changed */
3228
3229 for (p = check->amplist; p->nid; p++) {
3230 for (ch = 0; ch < 2; ch++) {
3231 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3232 p->idx);
3233 if (!(v & HDA_AMP_MUTE) && v > 0) {
3234 if (!check->power_on) {
3235 check->power_on = 1;
3236 snd_hda_power_up(codec);
3237 }
3238 return 1;
3239 }
3240 }
3241 }
3242 if (check->power_on) {
3243 check->power_on = 0;
3244 snd_hda_power_down(codec);
3245 }
3246 return 0;
3247}
ff7a3267 3248EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 3249#endif
1da177e4 3250
c8b6bf9b 3251/*
d2a6d7dc
TI		 3252 * Channel mode helper
3253 */
0ba21762
TI		 3254int snd_hda_ch_mode_info(struct hda_codec *codec,
3255 struct snd_ctl_elem_info *uinfo,
3256 const struct hda_channel_mode *chmode,
3257 int num_chmodes)
d2a6d7dc
TI		 3258{
3259 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3260 uinfo->count = 1;
3261 uinfo->value.enumerated.items = num_chmodes;
3262 if (uinfo->value.enumerated.item >= num_chmodes)
3263 uinfo->value.enumerated.item = num_chmodes - 1;
3264 sprintf(uinfo->value.enumerated.name, "%dch",
3265 chmode[uinfo->value.enumerated.item].channels);
3266 return 0;
3267}
ff7a3267 3268EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 3269
0ba21762
TI		 3270int snd_hda_ch_mode_get(struct hda_codec *codec,
3271 struct snd_ctl_elem_value *ucontrol,
3272 const struct hda_channel_mode *chmode,
3273 int num_chmodes,
d2a6d7dc
TI		 3274 int max_channels)
3275{
3276 int i;
3277
3278 for (i = 0; i < num_chmodes; i++) {
3279 if (max_channels == chmode[i].channels) {
3280 ucontrol->value.enumerated.item[0] = i;
3281 break;
3282 }
3283 }
3284 return 0;
3285}
ff7a3267 3286EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 3287
0ba21762
TI		 3288int snd_hda_ch_mode_put(struct hda_codec *codec,
3289 struct snd_ctl_elem_value *ucontrol,
3290 const struct hda_channel_mode *chmode,
3291 int num_chmodes,
d2a6d7dc
TI		 3292 int *max_channelsp)
3293{
3294 unsigned int mode;
3295
3296 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 3297 if (mode >= num_chmodes)
3298 return -EINVAL;
82beb8fd 3299 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 3300 return 0;
3301 /* change the current channel setting */
3302 *max_channelsp = chmode[mode].channels;
3303 if (chmode[mode].sequence)
82beb8fd 3304 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 3305 return 1;
3306}
ff7a3267 3307EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 3308
1da177e4
LT		 3309/*
3310 * input MUX helper
3311 */
0ba21762
TI		 3312int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3313 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3314{
3315 unsigned int index;
3316
3317 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3318 uinfo->count = 1;
3319 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 3320 if (!imux->num_items)
3321 return 0;
1da177e4
LT		 3322 index = uinfo->value.enumerated.item;
3323 if (index >= imux->num_items)
3324 index = imux->num_items - 1;
3325 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3326 return 0;
3327}
ff7a3267 3328EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 3329
0ba21762
TI		 3330int snd_hda_input_mux_put(struct hda_codec *codec,
3331 const struct hda_input_mux *imux,
3332 struct snd_ctl_elem_value *ucontrol,
3333 hda_nid_t nid,
1da177e4
LT		 3334 unsigned int *cur_val)
3335{
3336 unsigned int idx;
3337
5513b0c5
TI		 3338 if (!imux->num_items)
3339 return 0;
1da177e4
LT		 3340 idx = ucontrol->value.enumerated.item[0];
3341 if (idx >= imux->num_items)
3342 idx = imux->num_items - 1;
82beb8fd 3343 if (*cur_val == idx)
1da177e4 3344 return 0;
82beb8fd
TI		 3345 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3346 imux->items[idx].index);
1da177e4
LT		 3347 *cur_val = idx;
3348 return 1;
3349}
ff7a3267 3350EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 3351
3352
3353/*
3354 * Multi-channel / digital-out PCM helper functions
3355 */
3356
6b97eb45
TI		 3357/* setup SPDIF output stream */
3358static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3359 unsigned int stream_tag, unsigned int format)
3360{
3361 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2f72853c
TI		 3362 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3363 set_dig_out_convert(codec, nid,
3364 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3365 -1);
6b97eb45 3366 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c
TI		 3367 if (codec->slave_dig_outs) {
3368 hda_nid_t *d;
3369 for (d = codec->slave_dig_outs; *d; d++)
3370 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3371 format);
3372 }
6b97eb45 3373 /* turn on again (if needed) */
2f72853c
TI		 3374 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3375 set_dig_out_convert(codec, nid,
3376 codec->spdif_ctls & 0xff, -1);
3377}
de51ca12 3378
2f72853c
TI		 3379static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3380{
3381 snd_hda_codec_cleanup_stream(codec, nid);
3382 if (codec->slave_dig_outs) {
3383 hda_nid_t *d;
3384 for (d = codec->slave_dig_outs; *d; d++)
3385 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 3386 }
6b97eb45
TI		 3387}
3388
1da177e4
LT		 3389/*
3390 * open the digital out in the exclusive mode
3391 */
0ba21762
TI		 3392int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3393 struct hda_multi_out *mout)
1da177e4 3394{
62932df8 3395 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 3396 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3397 /* already opened as analog dup; reset it once */
2f72853c 3398 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 3399 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 3400 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3401 return 0;
3402}
ff7a3267 3403EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 3404
6b97eb45
TI		 3405int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3406 struct hda_multi_out *mout,
3407 unsigned int stream_tag,
3408 unsigned int format,
3409 struct snd_pcm_substream *substream)
3410{
3411 mutex_lock(&codec->spdif_mutex);
3412 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3413 mutex_unlock(&codec->spdif_mutex);
3414 return 0;
3415}
ff7a3267 3416EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 3417
9411e21c
TI		 3418int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3419 struct hda_multi_out *mout)
3420{
3421 mutex_lock(&codec->spdif_mutex);
3422 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3423 mutex_unlock(&codec->spdif_mutex);
3424 return 0;
3425}
3426EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3427
1da177e4
LT		 3428/*
3429 * release the digital out
3430 */
0ba21762
TI		 3431int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3432 struct hda_multi_out *mout)
1da177e4 3433{
62932df8 3434 mutex_lock(&codec->spdif_mutex);
1da177e4 3435 mout->dig_out_used = 0;
62932df8 3436 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3437 return 0;
3438}
ff7a3267 3439EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4
LT		 3440
3441/*
3442 * set up more restrictions for analog out
3443 */
0ba21762
TI		 3444int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3445 struct hda_multi_out *mout,
9a08160b
TI		 3446 struct snd_pcm_substream *substream,
3447 struct hda_pcm_stream *hinfo)
3448{
3449 struct snd_pcm_runtime *runtime = substream->runtime;
3450 runtime->hw.channels_max = mout->max_channels;
3451 if (mout->dig_out_nid) {
3452 if (!mout->analog_rates) {
3453 mout->analog_rates = hinfo->rates;
3454 mout->analog_formats = hinfo->formats;
3455 mout->analog_maxbps = hinfo->maxbps;
3456 } else {
3457 runtime->hw.rates = mout->analog_rates;
3458 runtime->hw.formats = mout->analog_formats;
3459 hinfo->maxbps = mout->analog_maxbps;
3460 }
3461 if (!mout->spdif_rates) {
3462 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3463 &mout->spdif_rates,
3464 &mout->spdif_formats,
3465 &mout->spdif_maxbps);
3466 }
3467 mutex_lock(&codec->spdif_mutex);
3468 if (mout->share_spdif) {
3469 runtime->hw.rates &= mout->spdif_rates;
3470 runtime->hw.formats &= mout->spdif_formats;
3471 if (mout->spdif_maxbps < hinfo->maxbps)
3472 hinfo->maxbps = mout->spdif_maxbps;
3473 }
eaa9985b 3474 mutex_unlock(&codec->spdif_mutex);
9a08160b 3475 }
1da177e4
LT		 3476 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3477 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3478}
ff7a3267 3479EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4
LT		 3480
3481/*
3482 * set up the i/o for analog out
3483 * when the digital out is available, copy the front out to digital out, too.
3484 */
0ba21762
TI		 3485int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3486 struct hda_multi_out *mout,
1da177e4
LT		 3487 unsigned int stream_tag,
3488 unsigned int format,
c8b6bf9b 3489 struct snd_pcm_substream *substream)
1da177e4
LT		 3490{
3491 hda_nid_t *nids = mout->dac_nids;
3492 int chs = substream->runtime->channels;
3493 int i;
3494
62932df8 3495 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 3496 if (mout->dig_out_nid && mout->share_spdif &&
3497 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 3498 if (chs == 2 &&
0ba21762
TI		 3499 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3500 format) &&
3501 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
1da177e4 3502 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 3503 setup_dig_out_stream(codec, mout->dig_out_nid,
3504 stream_tag, format);
1da177e4
LT		 3505 } else {
3506 mout->dig_out_used = 0;
2f72853c 3507 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3508 }
3509 }
62932df8 3510 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3511
3512 /* front */
0ba21762
TI		 3513 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3514 0, format);
d29240ce
TI		 3515 if (!mout->no_share_stream &&
3516 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 3517 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 3518 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3519 0, format);
82bc955f
TI		 3520 /* extra outputs copied from front */
3521 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 3522 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 3523 snd_hda_codec_setup_stream(codec,
3524 mout->extra_out_nid[i],
3525 stream_tag, 0, format);
3526
1da177e4
LT		 3527 /* surrounds */
3528 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 3529 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 3530 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3531 i * 2, format);
d29240ce 3532 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 3533 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3534 0, format);
1da177e4
LT		 3535 }
3536 return 0;
3537}
ff7a3267 3538EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4
LT		 3539
3540/*
3541 * clean up the setting for analog out
3542 */
0ba21762
TI		 3543int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3544 struct hda_multi_out *mout)
1da177e4
LT		 3545{
3546 hda_nid_t *nids = mout->dac_nids;
3547 int i;
3548
3549 for (i = 0; i < mout->num_dacs; i++)
888afa15 3550 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 3551 if (mout->hp_nid)
888afa15 3552 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
82bc955f
TI		 3553 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3554 if (mout->extra_out_nid[i])
888afa15
TI		 3555 snd_hda_codec_cleanup_stream(codec,
3556 mout->extra_out_nid[i]);
62932df8 3557 mutex_lock(&codec->spdif_mutex);
1da177e4 3558 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 3559 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3560 mout->dig_out_used = 0;
3561 }
62932df8 3562 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3563 return 0;
3564}
ff7a3267 3565EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 3566
e9edcee0 3567/*
6b34500c 3568 * Helper for automatic pin configuration
e9edcee0 3569 */
df694daa 3570
12f288bf 3571static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
df694daa
KY		 3572{
3573 for (; *list; list++)
3574 if (*list == nid)
3575 return 1;
3576 return 0;
3577}
3578
81937d3b
SL		 3579
3580/*
3581 * Sort an associated group of pins according to their sequence numbers.
3582 */
3583static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3584 int num_pins)
3585{
3586 int i, j;
3587 short seq;
3588 hda_nid_t nid;
3589
3590 for (i = 0; i < num_pins; i++) {
3591 for (j = i + 1; j < num_pins; j++) {
3592 if (sequences[i] > sequences[j]) {
3593 seq = sequences[i];
3594 sequences[i] = sequences[j];
3595 sequences[j] = seq;
3596 nid = pins[i];
3597 pins[i] = pins[j];
3598 pins[j] = nid;
3599 }
3600 }
3601 }
3602}
3603
3604
82bc955f
TI		 3605/*
3606 * Parse all pin widgets and store the useful pin nids to cfg
3607 *
3608 * The number of line-outs or any primary output is stored in line_outs,
3609 * and the corresponding output pins are assigned to line_out_pins[],
3610 * in the order of front, rear, CLFE, side, ...
3611 *
3612 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 3613 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 3614 * is detected, one of speaker of HP pins is assigned as the primary
3615 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3616 * if any analog output exists.
3617 *
3618 * The analog input pins are assigned to input_pins array.
3619 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3620 * respectively.
3621 */
12f288bf
TI		 3622int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3623 struct auto_pin_cfg *cfg,
3624 hda_nid_t *ignore_nids)
e9edcee0 3625{
0ef6ce7b 3626 hda_nid_t nid, end_nid;
81937d3b
SL		 3627 short seq, assoc_line_out, assoc_speaker;
3628 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3629 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 3630 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
e9edcee0
TI		 3631
3632 memset(cfg, 0, sizeof(*cfg));
3633
81937d3b
SL		 3634 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3635 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 3636 memset(sequences_hp, 0, sizeof(sequences_hp));
81937d3b 3637 assoc_line_out = assoc_speaker = 0;
e9edcee0 3638
0ef6ce7b
TI		 3639 end_nid = codec->start_nid + codec->num_nodes;
3640 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 3641 unsigned int wid_caps = get_wcaps(codec, nid);
0ba21762
TI		 3642 unsigned int wid_type =
3643 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
e9edcee0
TI		 3644 unsigned int def_conf;
3645 short assoc, loc;
3646
3647 /* read all default configuration for pin complex */
3648 if (wid_type != AC_WID_PIN)
3649 continue;
df694daa
KY		 3650 /* ignore the given nids (e.g. pc-beep returns error) */
3651 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3652 continue;
3653
c17a1aba 3654 def_conf = snd_hda_codec_get_pincfg(codec, nid);
e9edcee0
TI		 3655 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3656 continue;
3657 loc = get_defcfg_location(def_conf);
3658 switch (get_defcfg_device(def_conf)) {
3659 case AC_JACK_LINE_OUT:
e9edcee0
TI		 3660 seq = get_defcfg_sequence(def_conf);
3661 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 3662
3663 if (!(wid_caps & AC_WCAP_STEREO))
3664 if (!cfg->mono_out_pin)
3665 cfg->mono_out_pin = nid;
0ba21762 3666 if (!assoc)
e9edcee0 3667 continue;
0ba21762 3668 if (!assoc_line_out)
e9edcee0
TI		 3669 assoc_line_out = assoc;
3670 else if (assoc_line_out != assoc)
3671 continue;
3672 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3673 continue;
3674 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 3675 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 3676 cfg->line_outs++;
3677 break;
8d88bc3d 3678 case AC_JACK_SPEAKER:
81937d3b
SL		 3679 seq = get_defcfg_sequence(def_conf);
3680 assoc = get_defcfg_association(def_conf);
3681 if (! assoc)
3682 continue;
3683 if (! assoc_speaker)
3684 assoc_speaker = assoc;
3685 else if (assoc_speaker != assoc)
3686 continue;
82bc955f
TI		 3687 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3688 continue;
3689 cfg->speaker_pins[cfg->speaker_outs] = nid;
81937d3b 3690 sequences_speaker[cfg->speaker_outs] = seq;
82bc955f 3691 cfg->speaker_outs++;
8d88bc3d 3692 break;
e9edcee0 3693 case AC_JACK_HP_OUT:
f889fa91
TI		 3694 seq = get_defcfg_sequence(def_conf);
3695 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 3696 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3697 continue;
3698 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 3699 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 3700 cfg->hp_outs++;
e9edcee0 3701 break;
314634bc
TI		 3702 case AC_JACK_MIC_IN: {
3703 int preferred, alt;
3704 if (loc == AC_JACK_LOC_FRONT) {
3705 preferred = AUTO_PIN_FRONT_MIC;
3706 alt = AUTO_PIN_MIC;
3707 } else {
3708 preferred = AUTO_PIN_MIC;
3709 alt = AUTO_PIN_FRONT_MIC;
3710 }
3711 if (!cfg->input_pins[preferred])
3712 cfg->input_pins[preferred] = nid;
3713 else if (!cfg->input_pins[alt])
3714 cfg->input_pins[alt] = nid;
e9edcee0 3715 break;
314634bc 3716 }
e9edcee0
TI		 3717 case AC_JACK_LINE_IN:
3718 if (loc == AC_JACK_LOC_FRONT)
3719 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3720 else
3721 cfg->input_pins[AUTO_PIN_LINE] = nid;
3722 break;
3723 case AC_JACK_CD:
3724 cfg->input_pins[AUTO_PIN_CD] = nid;
3725 break;
3726 case AC_JACK_AUX:
3727 cfg->input_pins[AUTO_PIN_AUX] = nid;
3728 break;
3729 case AC_JACK_SPDIF_OUT:
1b52ae70 3730 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 3731 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3732 continue;
3733 cfg->dig_out_pins[cfg->dig_outs] = nid;
3734 cfg->dig_out_type[cfg->dig_outs] =
3735 (loc == AC_JACK_LOC_HDMI) ?
3736 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3737 cfg->dig_outs++;
e9edcee0
TI		 3738 break;
3739 case AC_JACK_SPDIF_IN:
1b52ae70 3740 case AC_JACK_DIG_OTHER_IN:
e9edcee0 3741 cfg->dig_in_pin = nid;
2297bd6e
TI		 3742 if (loc == AC_JACK_LOC_HDMI)
3743 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3744 else
3745 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 3746 break;
3747 }
3748 }
3749
5832fcf8
TI		 3750 /* FIX-UP:
3751 * If no line-out is defined but multiple HPs are found,
3752 * some of them might be the real line-outs.
3753 */
3754 if (!cfg->line_outs && cfg->hp_outs > 1) {
3755 int i = 0;
3756 while (i < cfg->hp_outs) {
3757 /* The real HPs should have the sequence 0x0f */
3758 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3759 i++;
3760 continue;
3761 }
3762 /* Move it to the line-out table */
3763 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3764 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3765 cfg->line_outs++;
3766 cfg->hp_outs--;
3767 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3768 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3769 memmove(sequences_hp + i - 1, sequences_hp + i,
3770 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3771 }
3772 }
3773
e9edcee0 3774 /* sort by sequence */
81937d3b
SL		 3775 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3776 cfg->line_outs);
3777 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3778 cfg->speaker_outs);
f889fa91
TI		 3779 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3780 cfg->hp_outs);
81937d3b 3781
f889fa91
TI		 3782 /* if we have only one mic, make it AUTO_PIN_MIC */
3783 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3784 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3785 cfg->input_pins[AUTO_PIN_MIC] =
3786 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3787 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3788 }
3789 /* ditto for line-in */
3790 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3791 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3792 cfg->input_pins[AUTO_PIN_LINE] =
3793 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3794 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3795 }
3796
81937d3b
SL		 3797 /*
3798 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3799 * as a primary output
3800 */
3801 if (!cfg->line_outs) {
3802 if (cfg->speaker_outs) {
3803 cfg->line_outs = cfg->speaker_outs;
3804 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3805 sizeof(cfg->speaker_pins));
3806 cfg->speaker_outs = 0;
3807 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3808 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3809 } else if (cfg->hp_outs) {
3810 cfg->line_outs = cfg->hp_outs;
3811 memcpy(cfg->line_out_pins, cfg->hp_pins,
3812 sizeof(cfg->hp_pins));
3813 cfg->hp_outs = 0;
3814 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3815 cfg->line_out_type = AUTO_PIN_HP_OUT;
3816 }
3817 }
e9edcee0 3818
cb8e2f83
TI		 3819 /* Reorder the surround channels
3820 * ALSA sequence is front/surr/clfe/side
3821 * HDA sequence is:
3822 * 4-ch: front/surr => OK as it is
3823 * 6-ch: front/clfe/surr
9422db40 3824 * 8-ch: front/clfe/rear/side|fc
cb8e2f83
TI		 3825 */
3826 switch (cfg->line_outs) {
3827 case 3:
cb8e2f83
TI		 3828 case 4:
3829 nid = cfg->line_out_pins[1];
9422db40 3830 cfg->line_out_pins[1] = cfg->line_out_pins[2];
cb8e2f83
TI		 3831 cfg->line_out_pins[2] = nid;
3832 break;
e9edcee0
TI		 3833 }
3834
82bc955f
TI		 3835 /*
3836 * debug prints of the parsed results
3837 */
3838 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3839 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3840 cfg->line_out_pins[2], cfg->line_out_pins[3],
3841 cfg->line_out_pins[4]);
3842 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3843 cfg->speaker_outs, cfg->speaker_pins[0],
3844 cfg->speaker_pins[1], cfg->speaker_pins[2],
3845 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 3846 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3847 cfg->hp_outs, cfg->hp_pins[0],
3848 cfg->hp_pins[1], cfg->hp_pins[2],
3849 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 3850 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 3851 if (cfg->dig_outs)
3852 snd_printd(" dig-out=0x%x/0x%x\n",
3853 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
82bc955f
TI		 3854 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3855 " cd=0x%x, aux=0x%x\n",
3856 cfg->input_pins[AUTO_PIN_MIC],
3857 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3858 cfg->input_pins[AUTO_PIN_LINE],
3859 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3860 cfg->input_pins[AUTO_PIN_CD],
3861 cfg->input_pins[AUTO_PIN_AUX]);
32d2c7fa 3862 if (cfg->dig_in_pin)
89ce9e87 3863 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 3864
e9edcee0
TI		 3865 return 0;
3866}
ff7a3267 3867EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
e9edcee0 3868
4a471b7d
TI		 3869/* labels for input pins */
3870const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3871 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3872};
ff7a3267 3873EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4a471b7d
TI		 3874
3875
1da177e4
LT		 3876#ifdef CONFIG_PM
3877/*
3878 * power management
3879 */
3880
3881/**
3882 * snd_hda_suspend - suspend the codecs
3883 * @bus: the HDA bus
1da177e4
LT		 3884 *
3885 * Returns 0 if successful.
3886 */
8dd78330 3887int snd_hda_suspend(struct hda_bus *bus)
1da177e4 3888{
0ba21762 3889 struct hda_codec *codec;
1da177e4 3890
0ba21762 3891 list_for_each_entry(codec, &bus->codec_list, list) {
0b7a2e9c
TI		 3892#ifdef CONFIG_SND_HDA_POWER_SAVE
3893 if (!codec->power_on)
3894 continue;
3895#endif
cb53c626 3896 hda_call_codec_suspend(codec);
1da177e4
LT		 3897 }
3898 return 0;
3899}
ff7a3267 3900EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 3901
3902/**
3903 * snd_hda_resume - resume the codecs
3904 * @bus: the HDA bus
1da177e4
LT		 3905 *
3906 * Returns 0 if successful.
cb53c626
TI		 3907 *
3908 * This fucntion is defined only when POWER_SAVE isn't set.
3909 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 3910 */
3911int snd_hda_resume(struct hda_bus *bus)
3912{
0ba21762 3913 struct hda_codec *codec;
1da177e4 3914
0ba21762 3915 list_for_each_entry(codec, &bus->codec_list, list) {
d804ad92
ML		 3916 if (snd_hda_codec_needs_resume(codec))
3917 hda_call_codec_resume(codec);
1da177e4 3918 }
1da177e4
LT		 3919 return 0;
3920}
ff7a3267 3921EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 3922#endif /* CONFIG_PM */
b2e18597
TI		 3923
3924/*
3925 * generic arrays
3926 */
3927
3928/* get a new element from the given array
3929 * if it exceeds the pre-allocated array size, re-allocate the array
3930 */
3931void *snd_array_new(struct snd_array *array)
3932{
3933 if (array->used >= array->alloced) {
3934 int num = array->alloced + array->alloc_align;
b910d9ae
TI		 3935 void *nlist;
3936 if (snd_BUG_ON(num >= 4096))
3937 return NULL;
3938 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
b2e18597
TI		 3939 if (!nlist)
3940 return NULL;
3941 if (array->list) {
3942 memcpy(nlist, array->list,
3943 array->elem_size * array->alloced);
3944 kfree(array->list);
3945 }
3946 array->list = nlist;
3947 array->alloced = num;
3948 }
f43aa025 3949 return snd_array_elem(array, array->used++);
b2e18597 3950}
ff7a3267 3951EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597
TI		 3952
3953/* free the given array elements */
3954void snd_array_free(struct snd_array *array)
3955{
3956 kfree(array->list);
3957 array->used = 0;
3958 array->alloced = 0;
3959 array->list = NULL;
3960}
ff7a3267 3961EXPORT_SYMBOL_HDA(snd_array_free);
b2022266
TI		 3962
3963/*
3964 * used by hda_proc.c and hda_eld.c
3965 */
3966void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3967{
3968 static unsigned int rates[] = {
3969 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3970 96000, 176400, 192000, 384000
3971 };
3972 int i, j;
3973
3974 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3975 if (pcm & (1 << i))
3976 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3977
3978 buf[j] = '\0'; /* necessary when j == 0 */
3979}
ff7a3267 3980EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
b2022266
TI		 3981
3982void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3983{
3984 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3985 int i, j;
3986
3987 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3988 if (pcm & (AC_SUPPCM_BITS_8 << i))
3989 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3990
3991 buf[j] = '\0'; /* necessary when j == 0 */
3992}
ff7a3267 3993EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 3994
3995MODULE_DESCRIPTION("HDA codec core");
3996MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.685052 seconds and 5 git commands to generate.