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