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