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