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