projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Move codec suspend/resume to codec driver
[deliverable/linux.git] / sound / pci / hda / hda_codec.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
18478e8b 22#include <linux/mm.h>
1da177e4
LT		 23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/slab.h>
62932df8 26#include <linux/mutex.h>
da155d5b 27#include <linux/module.h>
f4d6a55d 28#include <linux/async.h>
1da177e4
LT		 29#include <sound/core.h>
30#include "hda_codec.h"
31#include <sound/asoundef.h>
302e9c5a 32#include <sound/tlv.h>
1da177e4 33#include <sound/initval.h>
cd372fb3 34#include <sound/jack.h>
1da177e4 35#include "hda_local.h"
123c07ae 36#include "hda_beep.h"
1835a0f9 37#include "hda_jack.h"
2807314d 38#include <sound/hda_hwdep.h>
1da177e4 39
d66fee5d
TI		 40#define CREATE_TRACE_POINTS
41#include "hda_trace.h"
42
83012a7c 43#ifdef CONFIG_PM
d846b174 44#define codec_in_pm(codec) ((codec)->in_pm)
cb53c626
TI		 45static void hda_power_work(struct work_struct *work);
46static void hda_keep_power_on(struct hda_codec *codec);
e581f3db 47#define hda_codec_is_power_on(codec) ((codec)->power_on)
a40e0a88
TI		 48
49static void hda_call_pm_notify(struct hda_codec *codec, bool power_up)
68467f51 50{
a40e0a88
TI		 51 struct hda_bus *bus = codec->bus;
52
53 if ((power_up && codec->pm_up_notified) ||
54 (!power_up && !codec->pm_up_notified))
55 return;
68467f51
TI		 56 if (bus->ops.pm_notify)
57 bus->ops.pm_notify(bus, power_up);
a40e0a88 58 codec->pm_up_notified = power_up;
68467f51 59}
a40e0a88 60
cb53c626 61#else
d846b174 62#define codec_in_pm(codec) 0
cb53c626 63static inline void hda_keep_power_on(struct hda_codec *codec) {}
e581f3db 64#define hda_codec_is_power_on(codec) 1
a40e0a88 65#define hda_call_pm_notify(codec, state) {}
cb53c626
TI		 66#endif
67
d5191e50
TI		 68/**
69 * snd_hda_get_jack_location - Give a location string of the jack
70 * @cfg: pin default config value
71 *
72 * Parse the pin default config value and returns the string of the
73 * jack location, e.g. "Rear", "Front", etc.
74 */
50a9f790
MR		 75const char *snd_hda_get_jack_location(u32 cfg)
76{
77 static char *bases[7] = {
78 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
79 };
80 static unsigned char specials_idx[] = {
81 0x07, 0x08,
82 0x17, 0x18, 0x19,
83 0x37, 0x38
84 };
85 static char *specials[] = {
86 "Rear Panel", "Drive Bar",
87 "Riser", "HDMI", "ATAPI",
88 "Mobile-In", "Mobile-Out"
89 };
90 int i;
91 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
92 if ((cfg & 0x0f) < 7)
93 return bases[cfg & 0x0f];
94 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
95 if (cfg == specials_idx[i])
96 return specials[i];
97 }
98 return "UNKNOWN";
99}
2698ea98 100EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
50a9f790 101
d5191e50
TI		 102/**
103 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
104 * @cfg: pin default config value
105 *
106 * Parse the pin default config value and returns the string of the
107 * jack connectivity, i.e. external or internal connection.
108 */
50a9f790
MR		 109const char *snd_hda_get_jack_connectivity(u32 cfg)
110{
111 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
112
113 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
114}
2698ea98 115EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
50a9f790 116
d5191e50
TI		 117/**
118 * snd_hda_get_jack_type - Give a type string of the jack
119 * @cfg: pin default config value
120 *
121 * Parse the pin default config value and returns the string of the
122 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
123 */
50a9f790
MR		 124const char *snd_hda_get_jack_type(u32 cfg)
125{
126 static char *jack_types[16] = {
127 "Line Out", "Speaker", "HP Out", "CD",
128 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
129 "Line In", "Aux", "Mic", "Telephony",
aeb3a972 130 "SPDIF In", "Digital In", "Reserved", "Other"
50a9f790
MR		 131 };
132
133 return jack_types[(cfg & AC_DEFCFG_DEVICE)
134 >> AC_DEFCFG_DEVICE_SHIFT];
135}
2698ea98 136EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
50a9f790 137
33fa35ed
TI		 138/*
139 * Compose a 32bit command word to be sent to the HD-audio controller
140 */
141static inline unsigned int
e7ecc27e 142make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int flags,
33fa35ed
TI		 143 unsigned int verb, unsigned int parm)
144{
145 u32 val;
146
e7ecc27e 147 if ((codec->addr & ~0xf) || (nid & ~0x7f) ||
82e1b804 148 (verb & ~0xfff) || (parm & ~0xffff)) {
4e76a883 149 codec_err(codec, "hda-codec: out of range cmd %x:%x:%x:%x\n",
e7ecc27e 150 codec->addr, nid, verb, parm);
6430aeeb
WF		 151 return ~0;
152 }
153
154 val = (u32)codec->addr << 28;
33fa35ed
TI		 155 val |= (u32)nid << 20;
156 val |= verb << 8;
157 val |= parm;
158 return val;
159}
160
aa2936f5
TI		 161/*
162 * Send and receive a verb
163 */
164static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
e7ecc27e 165 int flags, unsigned int *res)
aa2936f5
TI		 166{
167 struct hda_bus *bus = codec->bus;
8dd78330 168 int err;
aa2936f5 169
6430aeeb
WF		 170 if (cmd == ~0)
171 return -1;
172
aa2936f5
TI		 173 if (res)
174 *res = -1;
8dd78330 175 again:
aa2936f5
TI		 176 snd_hda_power_up(codec);
177 mutex_lock(&bus->cmd_mutex);
63e51fd7
TI		 178 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
179 bus->no_response_fallback = 1;
3bcce5c0
TI		 180 for (;;) {
181 trace_hda_send_cmd(codec, cmd);
182 err = bus->ops.command(bus, cmd);
183 if (err != -EAGAIN)
184 break;
185 /* process pending verbs */
186 bus->ops.get_response(bus, codec->addr);
187 }
d66fee5d 188 if (!err && res) {
deadff16 189 *res = bus->ops.get_response(bus, codec->addr);
d66fee5d
TI		 190 trace_hda_get_response(codec, *res);
191 }
63e51fd7 192 bus->no_response_fallback = 0;
aa2936f5
TI		 193 mutex_unlock(&bus->cmd_mutex);
194 snd_hda_power_down(codec);
d846b174 195 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
8dd78330 196 if (bus->response_reset) {
4e76a883
TI		 197 codec_dbg(codec,
198 "resetting BUS due to fatal communication error\n");
d66fee5d 199 trace_hda_bus_reset(bus);
8dd78330
TI		 200 bus->ops.bus_reset(bus);
201 }
202 goto again;
203 }
204 /* clear reset-flag when the communication gets recovered */
d846b174 205 if (!err || codec_in_pm(codec))
8dd78330 206 bus->response_reset = 0;
aa2936f5
TI		 207 return err;
208}
209
1da177e4
LT		 210/**
211 * snd_hda_codec_read - send a command and get the response
212 * @codec: the HDA codec
213 * @nid: NID to send the command
e7ecc27e 214 * @flags: optional bit flags
1da177e4
LT		 215 * @verb: the verb to send
216 * @parm: the parameter for the verb
217 *
218 * Send a single command and read the corresponding response.
219 *
220 * Returns the obtained response value, or -1 for an error.
221 */
0ba21762 222unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 223 int flags,
1da177e4
LT		 224 unsigned int verb, unsigned int parm)
225{
e7ecc27e 226 unsigned cmd = make_codec_cmd(codec, nid, flags, verb, parm);
aa2936f5 227 unsigned int res;
e7ecc27e 228 if (codec_exec_verb(codec, cmd, flags, &res))
9857edfd 229 return -1;
1da177e4
LT		 230 return res;
231}
2698ea98 232EXPORT_SYMBOL_GPL(snd_hda_codec_read);
1da177e4
LT		 233
234/**
235 * snd_hda_codec_write - send a single command without waiting for response
236 * @codec: the HDA codec
237 * @nid: NID to send the command
e7ecc27e 238 * @flags: optional bit flags
1da177e4
LT		 239 * @verb: the verb to send
240 * @parm: the parameter for the verb
241 *
242 * Send a single command without waiting for response.
243 *
244 * Returns 0 if successful, or a negative error code.
245 */
e7ecc27e
TI		 246int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
247 unsigned int verb, unsigned int parm)
1da177e4 248{
e7ecc27e 249 unsigned int cmd = make_codec_cmd(codec, nid, flags, verb, parm);
33fa35ed 250 unsigned int res;
e7ecc27e 251 return codec_exec_verb(codec, cmd, flags,
b20f3b83 252 codec->bus->sync_write ? &res : NULL);
1da177e4 253}
2698ea98 254EXPORT_SYMBOL_GPL(snd_hda_codec_write);
1da177e4
LT		 255
256/**
257 * snd_hda_sequence_write - sequence writes
258 * @codec: the HDA codec
259 * @seq: VERB array to send
260 *
261 * Send the commands sequentially from the given array.
262 * The array must be terminated with NID=0.
263 */
264void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
265{
266 for (; seq->nid; seq++)
267 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
268}
2698ea98 269EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
1da177e4
LT		 270
271/**
272 * snd_hda_get_sub_nodes - get the range of sub nodes
273 * @codec: the HDA codec
274 * @nid: NID to parse
275 * @start_id: the pointer to store the start NID
276 *
277 * Parse the NID and store the start NID of its sub-nodes.
278 * Returns the number of sub-nodes.
279 */
0ba21762
TI		 280int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
281 hda_nid_t *start_id)
1da177e4
LT		 282{
283 unsigned int parm;
284
285 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
69eba10e
DC		 286 if (parm == -1) {
287 *start_id = 0;
e8a7f136 288 return 0;
69eba10e 289 }
1da177e4
LT		 290 *start_id = (parm >> 16) & 0x7fff;
291 return (int)(parm & 0x7fff);
292}
2698ea98 293EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
1da177e4 294
ee8e765b
TI		 295/* connection list element */
296struct hda_conn_list {
297 struct list_head list;
298 int len;
299 hda_nid_t nid;
300 hda_nid_t conns[0];
301};
302
b2f934a0 303/* look up the cached results */
ee8e765b
TI		 304static struct hda_conn_list *
305lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
b2f934a0 306{
ee8e765b
TI		 307 struct hda_conn_list *p;
308 list_for_each_entry(p, &codec->conn_list, list) {
309 if (p->nid == nid)
b2f934a0 310 return p;
b2f934a0
TI		 311 }
312 return NULL;
313}
a12d3e1e 314
ee8e765b
TI		 315static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
316 const hda_nid_t *list)
317{
318 struct hda_conn_list *p;
319
320 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
321 if (!p)
322 return -ENOMEM;
323 p->len = len;
324 p->nid = nid;
325 memcpy(p->conns, list, len * sizeof(hda_nid_t));
326 list_add(&p->list, &codec->conn_list);
327 return 0;
328}
329
330static void remove_conn_list(struct hda_codec *codec)
331{
332 while (!list_empty(&codec->conn_list)) {
333 struct hda_conn_list *p;
334 p = list_first_entry(&codec->conn_list, typeof(*p), list);
335 list_del(&p->list);
336 kfree(p);
337 }
338}
339
09cf03b8
TI		 340/* read the connection and add to the cache */
341static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
342{
4eea3091
TI		 343 hda_nid_t list[32];
344 hda_nid_t *result = list;
09cf03b8
TI		 345 int len;
346
347 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
4eea3091
TI		 348 if (len == -ENOSPC) {
349 len = snd_hda_get_num_raw_conns(codec, nid);
350 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
351 if (!result)
352 return -ENOMEM;
353 len = snd_hda_get_raw_connections(codec, nid, result, len);
354 }
355 if (len >= 0)
356 len = snd_hda_override_conn_list(codec, nid, len, result);
357 if (result != list)
358 kfree(result);
359 return len;
09cf03b8
TI		 360}
361
ee8e765b
TI		 362/**
363 * snd_hda_get_conn_list - get connection list
364 * @codec: the HDA codec
365 * @nid: NID to parse
ee8e765b
TI		 366 * @listp: the pointer to store NID list
367 *
368 * Parses the connection list of the given widget and stores the pointer
369 * to the list of NIDs.
370 *
371 * Returns the number of connections, or a negative error code.
372 *
373 * Note that the returned pointer isn't protected against the list
374 * modification. If snd_hda_override_conn_list() might be called
375 * concurrently, protect with a mutex appropriately.
376 */
377int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
378 const hda_nid_t **listp)
379{
380 bool added = false;
381
382 for (;;) {
383 int err;
384 const struct hda_conn_list *p;
385
386 /* if the connection-list is already cached, read it */
387 p = lookup_conn_list(codec, nid);
388 if (p) {
389 if (listp)
390 *listp = p->conns;
391 return p->len;
392 }
393 if (snd_BUG_ON(added))
394 return -EINVAL;
395
396 err = read_and_add_raw_conns(codec, nid);
397 if (err < 0)
398 return err;
399 added = true;
400 }
401}
2698ea98 402EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
ee8e765b 403
1da177e4 404/**
09cf03b8 405 * snd_hda_get_connections - copy connection list
1da177e4
LT		 406 * @codec: the HDA codec
407 * @nid: NID to parse
09cf03b8
TI		 408 * @conn_list: connection list array; when NULL, checks only the size
409 * @max_conns: max. number of connections to store
1da177e4
LT		 410 *
411 * Parses the connection list of the given widget and stores the list
412 * of NIDs.
413 *
414 * Returns the number of connections, or a negative error code.
415 */
09cf03b8
TI		 416int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
417 hda_nid_t *conn_list, int max_conns)
a12d3e1e 418{
ee8e765b
TI		 419 const hda_nid_t *list;
420 int len = snd_hda_get_conn_list(codec, nid, &list);
a12d3e1e 421
ee8e765b
TI		 422 if (len > 0 && conn_list) {
423 if (len > max_conns) {
4e76a883 424 codec_err(codec, "Too many connections %d for NID 0x%x\n",
09cf03b8 425 len, nid);
09cf03b8
TI		 426 return -EINVAL;
427 }
ee8e765b 428 memcpy(conn_list, list, len * sizeof(hda_nid_t));
a12d3e1e
TI		 429 }
430
ee8e765b 431 return len;
a12d3e1e 432}
2698ea98 433EXPORT_SYMBOL_GPL(snd_hda_get_connections);
a12d3e1e 434
4eea3091
TI		 435/* return CONNLIST_LEN parameter of the given widget */
436static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
437{
438 unsigned int wcaps = get_wcaps(codec, nid);
439 unsigned int parm;
440
441 if (!(wcaps & AC_WCAP_CONN_LIST) &&
442 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
443 return 0;
444
445 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
446 if (parm == -1)
447 parm = 0;
448 return parm;
449}
450
451int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
452{
b5f82b10 453 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
4eea3091
TI		 454}
455
9e7717c9
TI		 456/**
457 * snd_hda_get_raw_connections - copy connection list without cache
458 * @codec: the HDA codec
459 * @nid: NID to parse
460 * @conn_list: connection list array
461 * @max_conns: max. number of connections to store
462 *
463 * Like snd_hda_get_connections(), copy the connection list but without
464 * checking through the connection-list cache.
465 * Currently called only from hda_proc.c, so not exported.
466 */
467int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
468 hda_nid_t *conn_list, int max_conns)
1da177e4
LT		 469{
470 unsigned int parm;
54d17403 471 int i, conn_len, conns;
1da177e4 472 unsigned int shift, num_elems, mask;
54d17403 473 hda_nid_t prev_nid;
5fdaecdb 474 int null_count = 0;
1da177e4 475
4eea3091
TI		 476 parm = get_num_conns(codec, nid);
477 if (!parm)
8d087c76 478 return 0;
16a433d8 479
1da177e4
LT		 480 if (parm & AC_CLIST_LONG) {
481 /* long form */
482 shift = 16;
483 num_elems = 2;
484 } else {
485 /* short form */
486 shift = 8;
487 num_elems = 4;
488 }
489 conn_len = parm & AC_CLIST_LENGTH;
1da177e4
LT		 490 mask = (1 << (shift-1)) - 1;
491
0ba21762 492 if (!conn_len)
1da177e4
LT		 493 return 0; /* no connection */
494
495 if (conn_len == 1) {
496 /* single connection */
0ba21762
TI		 497 parm = snd_hda_codec_read(codec, nid, 0,
498 AC_VERB_GET_CONNECT_LIST, 0);
3c6aae44
TI		 499 if (parm == -1 && codec->bus->rirb_error)
500 return -EIO;
b5f82b10
TI		 501 if (conn_list)
502 conn_list[0] = parm & mask;
1da177e4
LT		 503 return 1;
504 }
505
506 /* multi connection */
507 conns = 0;
54d17403
TI		 508 prev_nid = 0;
509 for (i = 0; i < conn_len; i++) {
510 int range_val;
511 hda_nid_t val, n;
512
3c6aae44 513 if (i % num_elems == 0) {
54d17403
TI		 514 parm = snd_hda_codec_read(codec, nid, 0,
515 AC_VERB_GET_CONNECT_LIST, i);
3c6aae44
TI		 516 if (parm == -1 && codec->bus->rirb_error)
517 return -EIO;
518 }
0ba21762 519 range_val = !!(parm & (1 << (shift-1))); /* ranges */
54d17403 520 val = parm & mask;
5fdaecdb 521 if (val == 0 && null_count++) { /* no second chance */
4e76a883
TI		 522 codec_dbg(codec,
523 "invalid CONNECT_LIST verb %x[%i]:%x\n",
2e9bf247
JK		 524 nid, i, parm);
525 return 0;
526 }
54d17403
TI		 527 parm >>= shift;
528 if (range_val) {
529 /* ranges between the previous and this one */
0ba21762 530 if (!prev_nid || prev_nid >= val) {
4e76a883 531 codec_warn(codec,
0ba21762
TI		 532 "invalid dep_range_val %x:%x\n",
533 prev_nid, val);
54d17403
TI		 534 continue;
535 }
536 for (n = prev_nid + 1; n <= val; n++) {
b5f82b10
TI		 537 if (conn_list) {
538 if (conns >= max_conns)
539 return -ENOSPC;
540 conn_list[conns] = n;
541 }
542 conns++;
543 }
544 } else {
545 if (conn_list) {
4eea3091
TI		 546 if (conns >= max_conns)
547 return -ENOSPC;
b5f82b10 548 conn_list[conns] = val;
1da177e4 549 }
b5f82b10 550 conns++;
1da177e4 551 }
54d17403 552 prev_nid = val;
1da177e4
LT		 553 }
554 return conns;
555}
556
b2f934a0
TI		 557/**
558 * snd_hda_override_conn_list - add/modify the connection-list to cache
559 * @codec: the HDA codec
560 * @nid: NID to parse
561 * @len: number of connection list entries
562 * @list: the list of connection entries
563 *
564 * Add or modify the given connection-list to the cache. If the corresponding
565 * cache already exists, invalidate it and append a new one.
566 *
567 * Returns zero or a negative error code.
568 */
569int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
570 const hda_nid_t *list)
571{
ee8e765b 572 struct hda_conn_list *p;
b2f934a0 573
ee8e765b
TI		 574 p = lookup_conn_list(codec, nid);
575 if (p) {
576 list_del(&p->list);
577 kfree(p);
578 }
b2f934a0 579
ee8e765b 580 return add_conn_list(codec, nid, len, list);
b2f934a0 581}
2698ea98 582EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
b2f934a0 583
8d087c76
TI		 584/**
585 * snd_hda_get_conn_index - get the connection index of the given NID
586 * @codec: the HDA codec
587 * @mux: NID containing the list
588 * @nid: NID to select
589 * @recursive: 1 when searching NID recursively, otherwise 0
590 *
591 * Parses the connection list of the widget @mux and checks whether the
592 * widget @nid is present. If it is, return the connection index.
593 * Otherwise it returns -1.
594 */
595int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
596 hda_nid_t nid, int recursive)
a12d3e1e 597{
ee8e765b 598 const hda_nid_t *conn;
8d087c76
TI		 599 int i, nums;
600
ee8e765b 601 nums = snd_hda_get_conn_list(codec, mux, &conn);
8d087c76
TI		 602 for (i = 0; i < nums; i++)
603 if (conn[i] == nid)
604 return i;
605 if (!recursive)
606 return -1;
d94ddd85 607 if (recursive > 10) {
4e76a883 608 codec_dbg(codec, "too deep connection for 0x%x\n", nid);
8d087c76 609 return -1;
a12d3e1e 610 }
8d087c76 611 recursive++;
99e14c9d
TI		 612 for (i = 0; i < nums; i++) {
613 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
614 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
615 continue;
8d087c76
TI		 616 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
617 return i;
99e14c9d 618 }
8d087c76 619 return -1;
a12d3e1e 620}
2698ea98 621EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
1da177e4 622
f1aa0684
ML		 623
624/* return DEVLIST_LEN parameter of the given widget */
625static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
626{
627 unsigned int wcaps = get_wcaps(codec, nid);
628 unsigned int parm;
629
630 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
631 get_wcaps_type(wcaps) != AC_WID_PIN)
632 return 0;
633
634 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
635 if (parm == -1 && codec->bus->rirb_error)
636 parm = 0;
637 return parm & AC_DEV_LIST_LEN_MASK;
638}
639
640/**
641 * snd_hda_get_devices - copy device list without cache
642 * @codec: the HDA codec
643 * @nid: NID of the pin to parse
644 * @dev_list: device list array
645 * @max_devices: max. number of devices to store
646 *
647 * Copy the device list. This info is dynamic and so not cached.
648 * Currently called only from hda_proc.c, so not exported.
649 */
650int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
651 u8 *dev_list, int max_devices)
652{
653 unsigned int parm;
654 int i, dev_len, devices;
655
656 parm = get_num_devices(codec, nid);
657 if (!parm) /* not multi-stream capable */
658 return 0;
659
660 dev_len = parm + 1;
661 dev_len = dev_len < max_devices ? dev_len : max_devices;
662
663 devices = 0;
664 while (devices < dev_len) {
665 parm = snd_hda_codec_read(codec, nid, 0,
666 AC_VERB_GET_DEVICE_LIST, devices);
667 if (parm == -1 && codec->bus->rirb_error)
668 break;
669
670 for (i = 0; i < 8; i++) {
671 dev_list[devices] = (u8)parm;
672 parm >>= 4;
673 devices++;
674 if (devices >= dev_len)
675 break;
676 }
677 }
678 return devices;
679}
680
1da177e4
LT		 681/**
682 * snd_hda_queue_unsol_event - add an unsolicited event to queue
683 * @bus: the BUS
684 * @res: unsolicited event (lower 32bit of RIRB entry)
685 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
686 *
687 * Adds the given event to the queue. The events are processed in
688 * the workqueue asynchronously. Call this function in the interrupt
689 * hanlder when RIRB receives an unsolicited event.
690 *
691 * Returns 0 if successful, or a negative error code.
692 */
693int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
694{
695 struct hda_bus_unsolicited *unsol;
696 unsigned int wp;
697
2195b063
WY		 698 if (!bus || !bus->workq)
699 return 0;
700
ecf726f5 701 trace_hda_unsol_event(bus, res, res_ex);
922c88a8 702 unsol = &bus->unsol;
1da177e4
LT		 703 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
704 unsol->wp = wp;
705
706 wp <<= 1;
707 unsol->queue[wp] = res;
708 unsol->queue[wp + 1] = res_ex;
709
6acaed38 710 queue_work(bus->workq, &unsol->work);
1da177e4
LT		 711
712 return 0;
713}
2698ea98 714EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
1da177e4
LT		 715
716/*
5c1d1a98 717 * process queued unsolicited events
1da177e4 718 */
c4028958 719static void process_unsol_events(struct work_struct *work)
1da177e4 720{
922c88a8
TI		 721 struct hda_bus *bus = container_of(work, struct hda_bus, unsol.work);
722 struct hda_bus_unsolicited *unsol = &bus->unsol;
1da177e4
LT		 723 struct hda_codec *codec;
724 unsigned int rp, caddr, res;
725
726 while (unsol->rp != unsol->wp) {
727 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
728 unsol->rp = rp;
729 rp <<= 1;
730 res = unsol->queue[rp];
731 caddr = unsol->queue[rp + 1];
0ba21762 732 if (!(caddr & (1 << 4))) /* no unsolicited event? */
1da177e4
LT		 733 continue;
734 codec = bus->caddr_tbl[caddr & 0x0f];
735 if (codec && codec->patch_ops.unsol_event)
736 codec->patch_ops.unsol_event(codec, res);
737 }
738}
739
1da177e4
LT		 740/*
741 * destructor
742 */
2565c899 743static void snd_hda_bus_free(struct hda_bus *bus)
1da177e4 744{
0ba21762 745 if (!bus)
2565c899
TI		 746 return;
747
748 WARN_ON(!list_empty(&bus->codec_list));
6acaed38
TI		 749 if (bus->workq)
750 flush_workqueue(bus->workq);
1da177e4
LT		 751 if (bus->ops.private_free)
752 bus->ops.private_free(bus);
6acaed38
TI		 753 if (bus->workq)
754 destroy_workqueue(bus->workq);
0e24dbb7 755
1da177e4 756 kfree(bus);
1da177e4
LT		 757}
758
c8b6bf9b 759static int snd_hda_bus_dev_free(struct snd_device *device)
2565c899
TI		 760{
761 snd_hda_bus_free(device->device_data);
762 return 0;
763}
764
765static int snd_hda_bus_dev_disconnect(struct snd_device *device)
1da177e4
LT		 766{
767 struct hda_bus *bus = device->device_data;
b94d3539 768 bus->shutdown = 1;
2565c899 769 return 0;
1da177e4
LT		 770}
771
772/**
773 * snd_hda_bus_new - create a HDA bus
774 * @card: the card entry
1da177e4
LT		 775 * @busp: the pointer to store the created bus instance
776 *
777 * Returns 0 if successful, or a negative error code.
778 */
6a0f56a7 779int snd_hda_bus_new(struct snd_card *card,
ef744978 780 struct hda_bus **busp)
1da177e4
LT		 781{
782 struct hda_bus *bus;
783 int err;
c8b6bf9b 784 static struct snd_device_ops dev_ops = {
2565c899 785 .dev_disconnect = snd_hda_bus_dev_disconnect,
1da177e4
LT		 786 .dev_free = snd_hda_bus_dev_free,
787 };
788
1da177e4
LT		 789 if (busp)
790 *busp = NULL;
791
e560d8d8 792 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1da177e4 793 if (bus == NULL) {
4e76a883 794 dev_err(card->dev, "can't allocate struct hda_bus\n");
1da177e4
LT		 795 return -ENOMEM;
796 }
797
798 bus->card = card;
62932df8 799 mutex_init(&bus->cmd_mutex);
3f50ac6a 800 mutex_init(&bus->prepare_mutex);
1da177e4 801 INIT_LIST_HEAD(&bus->codec_list);
922c88a8 802 INIT_WORK(&bus->unsol.work, process_unsol_events);
1da177e4 803
e8c0ee5d
TI		 804 snprintf(bus->workq_name, sizeof(bus->workq_name),
805 "hd-audio%d", card->number);
806 bus->workq = create_singlethread_workqueue(bus->workq_name);
6acaed38 807 if (!bus->workq) {
4e76a883 808 dev_err(card->dev, "cannot create workqueue %s\n",
e8c0ee5d 809 bus->workq_name);
6acaed38
TI		 810 kfree(bus);
811 return -ENOMEM;
812 }
813
0ba21762
TI		 814 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
815 if (err < 0) {
1da177e4
LT		 816 snd_hda_bus_free(bus);
817 return err;
818 }
819 if (busp)
820 *busp = bus;
821 return 0;
822}
2698ea98 823EXPORT_SYMBOL_GPL(snd_hda_bus_new);
1da177e4 824
1da177e4 825/*
673b683a 826 * look for an AFG and MFG nodes
1da177e4 827 */
6a0f56a7 828static void setup_fg_nodes(struct hda_codec *codec)
1da177e4 829{
93e82ae7 830 int i, total_nodes, function_id;
1da177e4
LT		 831 hda_nid_t nid;
832
833 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
834 for (i = 0; i < total_nodes; i++, nid++) {
93e82ae7 835 function_id = snd_hda_param_read(codec, nid,
79c944ad 836 AC_PAR_FUNCTION_TYPE);
cd7643bf 837 switch (function_id & 0xff) {
673b683a
SK		 838 case AC_GRP_AUDIO_FUNCTION:
839 codec->afg = nid;
79c944ad
JK		 840 codec->afg_function_id = function_id & 0xff;
841 codec->afg_unsol = (function_id >> 8) & 1;
673b683a
SK		 842 break;
843 case AC_GRP_MODEM_FUNCTION:
844 codec->mfg = nid;
79c944ad
JK		 845 codec->mfg_function_id = function_id & 0xff;
846 codec->mfg_unsol = (function_id >> 8) & 1;
673b683a
SK		 847 break;
848 default:
849 break;
850 }
1da177e4 851 }
1da177e4
LT		 852}
853
54d17403
TI		 854/*
855 * read widget caps for each widget and store in cache
856 */
857static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
858{
859 int i;
860 hda_nid_t nid;
861
862 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
863 &codec->start_nid);
864 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
0ba21762 865 if (!codec->wcaps)
54d17403
TI		 866 return -ENOMEM;
867 nid = codec->start_nid;
868 for (i = 0; i < codec->num_nodes; i++, nid++)
869 codec->wcaps[i] = snd_hda_param_read(codec, nid,
870 AC_PAR_AUDIO_WIDGET_CAP);
871 return 0;
872}
873
3be14149
TI		 874/* read all pin default configurations and save codec->init_pins */
875static int read_pin_defaults(struct hda_codec *codec)
876{
877 int i;
878 hda_nid_t nid = codec->start_nid;
879
880 for (i = 0; i < codec->num_nodes; i++, nid++) {
881 struct hda_pincfg *pin;
882 unsigned int wcaps = get_wcaps(codec, nid);
a22d543a 883 unsigned int wid_type = get_wcaps_type(wcaps);
3be14149
TI		 884 if (wid_type != AC_WID_PIN)
885 continue;
886 pin = snd_array_new(&codec->init_pins);
887 if (!pin)
888 return -ENOMEM;
889 pin->nid = nid;
890 pin->cfg = snd_hda_codec_read(codec, nid, 0,
891 AC_VERB_GET_CONFIG_DEFAULT, 0);
ac0547dc
TI		 892 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
893 AC_VERB_GET_PIN_WIDGET_CONTROL,
894 0);
3be14149
TI		 895 }
896 return 0;
897}
898
899/* look up the given pin config list and return the item matching with NID */
900static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
901 struct snd_array *array,
902 hda_nid_t nid)
903{
904 int i;
905 for (i = 0; i < array->used; i++) {
906 struct hda_pincfg *pin = snd_array_elem(array, i);
907 if (pin->nid == nid)
908 return pin;
909 }
910 return NULL;
911}
912
3be14149
TI		 913/* set the current pin config value for the given NID.
914 * the value is cached, and read via snd_hda_codec_get_pincfg()
915 */
916int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
917 hda_nid_t nid, unsigned int cfg)
918{
919 struct hda_pincfg *pin;
920
d5657ec9
TI		 921 /* the check below may be invalid when pins are added by a fixup
922 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
923 * for now
924 */
925 /*
b82855a0
TI		 926 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
927 return -EINVAL;
d5657ec9 928 */
b82855a0 929
3be14149
TI		 930 pin = look_up_pincfg(codec, list, nid);
931 if (!pin) {
932 pin = snd_array_new(list);
933 if (!pin)
934 return -ENOMEM;
935 pin->nid = nid;
936 }
937 pin->cfg = cfg;
3be14149
TI		 938 return 0;
939}
940
d5191e50
TI		 941/**
942 * snd_hda_codec_set_pincfg - Override a pin default configuration
943 * @codec: the HDA codec
944 * @nid: NID to set the pin config
945 * @cfg: the pin default config value
946 *
947 * Override a pin default configuration value in the cache.
948 * This value can be read by snd_hda_codec_get_pincfg() in a higher
949 * priority than the real hardware value.
950 */
3be14149
TI		 951int snd_hda_codec_set_pincfg(struct hda_codec *codec,
952 hda_nid_t nid, unsigned int cfg)
953{
346ff70f 954 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
3be14149 955}
2698ea98 956EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
3be14149 957
d5191e50
TI		 958/**
959 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
960 * @codec: the HDA codec
961 * @nid: NID to get the pin config
962 *
963 * Get the current pin config value of the given pin NID.
964 * If the pincfg value is cached or overridden via sysfs or driver,
965 * returns the cached value.
966 */
3be14149
TI		 967unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
968{
969 struct hda_pincfg *pin;
970
648a8d27 971#ifdef CONFIG_SND_HDA_RECONFIG
09b70e85
TI		 972 {
973 unsigned int cfg = 0;
974 mutex_lock(&codec->user_mutex);
975 pin = look_up_pincfg(codec, &codec->user_pins, nid);
976 if (pin)
977 cfg = pin->cfg;
978 mutex_unlock(&codec->user_mutex);
979 if (cfg)
980 return cfg;
981 }
3be14149 982#endif
5e7b8e0d
TI		 983 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
984 if (pin)
985 return pin->cfg;
3be14149
TI		 986 pin = look_up_pincfg(codec, &codec->init_pins, nid);
987 if (pin)
988 return pin->cfg;
989 return 0;
990}
2698ea98 991EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
3be14149 992
95a962c3
TI		 993/**
994 * snd_hda_codec_set_pin_target - remember the current pinctl target value
995 * @codec: the HDA codec
996 * @nid: pin NID
997 * @val: assigned pinctl value
998 *
999 * This function stores the given value to a pinctl target value in the
1000 * pincfg table. This isn't always as same as the actually written value
1001 * but can be referred at any time via snd_hda_codec_get_pin_target().
1002 */
d7fdc00a
TI		 1003int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1004 unsigned int val)
1005{
1006 struct hda_pincfg *pin;
1007
1008 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1009 if (!pin)
1010 return -EINVAL;
1011 pin->target = val;
1012 return 0;
1013}
2698ea98 1014EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
d7fdc00a 1015
95a962c3
TI		 1016/**
1017 * snd_hda_codec_get_pin_target - return the current pinctl target value
1018 * @codec: the HDA codec
1019 * @nid: pin NID
1020 */
d7fdc00a
TI		 1021int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1022{
1023 struct hda_pincfg *pin;
1024
1025 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1026 if (!pin)
1027 return 0;
1028 return pin->target;
1029}
2698ea98 1030EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
d7fdc00a 1031
92ee6162
TI		 1032/**
1033 * snd_hda_shutup_pins - Shut up all pins
1034 * @codec: the HDA codec
1035 *
1036 * Clear all pin controls to shup up before suspend for avoiding click noise.
1037 * The controls aren't cached so that they can be resumed properly.
1038 */
1039void snd_hda_shutup_pins(struct hda_codec *codec)
1040{
1041 int i;
ac0547dc
TI		 1042 /* don't shut up pins when unloading the driver; otherwise it breaks
1043 * the default pin setup at the next load of the driver
1044 */
1045 if (codec->bus->shutdown)
1046 return;
92ee6162
TI		 1047 for (i = 0; i < codec->init_pins.used; i++) {
1048 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1049 /* use read here for syncing after issuing each verb */
1050 snd_hda_codec_read(codec, pin->nid, 0,
1051 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1052 }
ac0547dc 1053 codec->pins_shutup = 1;
92ee6162 1054}
2698ea98 1055EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
92ee6162 1056
2a43952a 1057#ifdef CONFIG_PM
ac0547dc
TI		 1058/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1059static void restore_shutup_pins(struct hda_codec *codec)
1060{
1061 int i;
1062 if (!codec->pins_shutup)
1063 return;
1064 if (codec->bus->shutdown)
1065 return;
1066 for (i = 0; i < codec->init_pins.used; i++) {
1067 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1068 snd_hda_codec_write(codec, pin->nid, 0,
1069 AC_VERB_SET_PIN_WIDGET_CONTROL,
1070 pin->ctrl);
1071 }
1072 codec->pins_shutup = 0;
1073}
1c7276cf 1074#endif
ac0547dc 1075
26a6cb6c
DH		 1076static void hda_jackpoll_work(struct work_struct *work)
1077{
1078 struct hda_codec *codec =
1079 container_of(work, struct hda_codec, jackpoll_work.work);
26a6cb6c
DH		 1080
1081 snd_hda_jack_set_dirty_all(codec);
1082 snd_hda_jack_poll_all(codec);
18e60627
WX		 1083
1084 if (!codec->jackpoll_interval)
1085 return;
1086
26a6cb6c
DH		 1087 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1088 codec->jackpoll_interval);
1089}
1090
01751f54
TI		 1091static void init_hda_cache(struct hda_cache_rec *cache,
1092 unsigned int record_size);
1fcaee6e 1093static void free_hda_cache(struct hda_cache_rec *cache);
01751f54 1094
3fdf1469
TI		 1095/* release all pincfg lists */
1096static void free_init_pincfgs(struct hda_codec *codec)
3be14149 1097{
346ff70f 1098 snd_array_free(&codec->driver_pins);
648a8d27 1099#ifdef CONFIG_SND_HDA_RECONFIG
346ff70f 1100 snd_array_free(&codec->user_pins);
3be14149 1101#endif
3be14149
TI		 1102 snd_array_free(&codec->init_pins);
1103}
1104
eb541337
TI		 1105/*
1106 * audio-converter setup caches
1107 */
1108struct hda_cvt_setup {
1109 hda_nid_t nid;
1110 u8 stream_tag;
1111 u8 channel_id;
1112 u16 format_id;
1113 unsigned char active; /* cvt is currently used */
1114 unsigned char dirty; /* setups should be cleared */
1115};
1116
1117/* get or create a cache entry for the given audio converter NID */
1118static struct hda_cvt_setup *
1119get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1120{
1121 struct hda_cvt_setup *p;
1122 int i;
1123
1124 for (i = 0; i < codec->cvt_setups.used; i++) {
1125 p = snd_array_elem(&codec->cvt_setups, i);
1126 if (p->nid == nid)
1127 return p;
1128 }
1129 p = snd_array_new(&codec->cvt_setups);
1130 if (p)
1131 p->nid = nid;
1132 return p;
1133}
1134
1da177e4
LT		 1135/*
1136 * codec destructor
1137 */
1138static void snd_hda_codec_free(struct hda_codec *codec)
1139{
0ba21762 1140 if (!codec)
1da177e4 1141 return;
26a6cb6c 1142 cancel_delayed_work_sync(&codec->jackpoll_work);
d8a766a1
TI		 1143 if (device_is_registered(hda_codec_dev(codec)))
1144 device_del(hda_codec_dev(codec));
59cad16b 1145 snd_hda_jack_tbl_clear(codec);
3fdf1469 1146 free_init_pincfgs(codec);
83012a7c 1147#ifdef CONFIG_PM
cb53c626 1148 cancel_delayed_work(&codec->power_work);
6acaed38 1149 flush_workqueue(codec->bus->workq);
cb53c626 1150#endif
1da177e4 1151 list_del(&codec->list);
d13bd412 1152 snd_array_free(&codec->mixers);
5b0cb1d8 1153 snd_array_free(&codec->nids);
59cad16b 1154 snd_array_free(&codec->cvt_setups);
7c935976 1155 snd_array_free(&codec->spdif_out);
ee8e765b 1156 remove_conn_list(codec);
1da177e4 1157 codec->bus->caddr_tbl[codec->addr] = NULL;
a40e0a88 1158 hda_call_pm_notify(codec, false); /* cancel leftover refcounts */
648a8d27 1159 snd_hda_sysfs_clear(codec);
01751f54 1160 free_hda_cache(&codec->amp_cache);
b3ac5636 1161 free_hda_cache(&codec->cmd_cache);
812a2cca
TI		 1162 kfree(codec->vendor_name);
1163 kfree(codec->chip_name);
f44ac837 1164 kfree(codec->modelname);
54d17403 1165 kfree(codec->wcaps);
0e24dbb7 1166 codec->bus->num_codecs--;
d8a766a1 1167 put_device(hda_codec_dev(codec));
1da177e4
LT		 1168}
1169
b8dfc462
ML		 1170static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1171 hda_nid_t fg, unsigned int power_state);
1172
d819387e 1173static unsigned int hda_set_power_state(struct hda_codec *codec,
bb6ac72f
TI		 1174 unsigned int power_state);
1175
13aeaf68
TI		 1176static int snd_hda_codec_dev_register(struct snd_device *device)
1177{
1178 struct hda_codec *codec = device->device_data;
1179
d604b399
TI		 1180 snd_hda_register_beep_device(codec);
1181 return 0;
13aeaf68
TI		 1182}
1183
1184static int snd_hda_codec_dev_disconnect(struct snd_device *device)
1185{
1186 struct hda_codec *codec = device->device_data;
1187
d604b399 1188 snd_hda_detach_beep_device(codec);
13aeaf68
TI		 1189 return 0;
1190}
1191
2565c899
TI		 1192static int snd_hda_codec_dev_free(struct snd_device *device)
1193{
1194 snd_hda_codec_free(device->device_data);
1195 return 0;
1196}
1197
13aeaf68
TI		 1198/* just free the container */
1199static void snd_hda_codec_dev_release(struct device *dev)
1200{
d8a766a1 1201 kfree(dev_to_hda_codec(dev));
13aeaf68
TI		 1202}
1203
1da177e4
LT		 1204/**
1205 * snd_hda_codec_new - create a HDA codec
1206 * @bus: the bus to assign
1207 * @codec_addr: the codec address
1208 * @codecp: the pointer to store the generated codec
1209 *
1210 * Returns 0 if successful, or a negative error code.
1211 */
6a0f56a7 1212int snd_hda_codec_new(struct hda_bus *bus,
28aedaf7
NL		 1213 unsigned int codec_addr,
1214 struct hda_codec **codecp)
1da177e4
LT		 1215{
1216 struct hda_codec *codec;
d8a766a1 1217 struct device *dev;
ba443687 1218 char component[31];
d819387e 1219 hda_nid_t fg;
1da177e4 1220 int err;
2565c899 1221 static struct snd_device_ops dev_ops = {
13aeaf68
TI		 1222 .dev_register = snd_hda_codec_dev_register,
1223 .dev_disconnect = snd_hda_codec_dev_disconnect,
2565c899
TI		 1224 .dev_free = snd_hda_codec_dev_free,
1225 };
1da177e4 1226
da3cec35
TI		 1227 if (snd_BUG_ON(!bus))
1228 return -EINVAL;
1229 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1230 return -EINVAL;
1da177e4
LT		 1231
1232 if (bus->caddr_tbl[codec_addr]) {
4e76a883
TI		 1233 dev_err(bus->card->dev,
1234 "address 0x%x is already occupied\n",
1235 codec_addr);
1da177e4
LT		 1236 return -EBUSY;
1237 }
1238
e560d8d8 1239 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1da177e4 1240 if (codec == NULL) {
4e76a883 1241 dev_err(bus->card->dev, "can't allocate struct hda_codec\n");
1da177e4
LT		 1242 return -ENOMEM;
1243 }
1244
d8a766a1
TI		 1245 dev = hda_codec_dev(codec);
1246 device_initialize(dev);
1247 dev->parent = bus->card->dev;
1248 dev->bus = &snd_hda_bus_type;
1249 dev->release = snd_hda_codec_dev_release;
1250 dev->groups = snd_hda_dev_attr_groups;
1251 dev_set_name(dev, "hdaudioC%dD%d", bus->card->number, codec_addr);
1252 dev_set_drvdata(dev, codec); /* for sysfs */
59ed1ead 1253 device_enable_async_suspend(dev);
13aeaf68 1254
1da177e4
LT		 1255 codec->bus = bus;
1256 codec->addr = codec_addr;
62932df8 1257 mutex_init(&codec->spdif_mutex);
5a9e02e9 1258 mutex_init(&codec->control_mutex);
c3b6bcc2 1259 mutex_init(&codec->hash_mutex);
01751f54 1260 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
b3ac5636 1261 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
5b0cb1d8
JK		 1262 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1263 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
3be14149 1264 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
346ff70f 1265 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
eb541337 1266 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
7c935976 1267 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
361dab3e 1268 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
c9ce6b26 1269 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
ee8e765b
TI		 1270 INIT_LIST_HEAD(&codec->conn_list);
1271
26a6cb6c 1272 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
7f132927 1273 codec->depop_delay = -1;
f5662e1c 1274 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
1da177e4 1275
83012a7c 1276#ifdef CONFIG_PM
5536c6d6 1277 spin_lock_init(&codec->power_lock);
cb53c626
TI		 1278 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1279 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1280 * the caller has to power down appropriatley after initialization
1281 * phase.
1282 */
1283 hda_keep_power_on(codec);
1284#endif
1285
648a8d27
TI		 1286 snd_hda_sysfs_init(codec);
1287
c382a9f0
TI		 1288 if (codec->bus->modelname) {
1289 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1290 if (!codec->modelname) {
13aeaf68
TI		 1291 err = -ENODEV;
1292 goto error;
c382a9f0
TI		 1293 }
1294 }
1295
1da177e4 1296 list_add_tail(&codec->list, &bus->codec_list);
0e24dbb7 1297 bus->num_codecs++;
0e24dbb7 1298
1da177e4
LT		 1299 bus->caddr_tbl[codec_addr] = codec;
1300
0ba21762
TI		 1301 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1302 AC_PAR_VENDOR_ID);
111d3af5
TI		 1303 if (codec->vendor_id == -1)
1304 /* read again, hopefully the access method was corrected
1305 * in the last read...
1306 */
1307 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1308 AC_PAR_VENDOR_ID);
0ba21762
TI		 1309 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1310 AC_PAR_SUBSYSTEM_ID);
1311 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1312 AC_PAR_REV_ID);
1da177e4 1313
673b683a 1314 setup_fg_nodes(codec);
0ba21762 1315 if (!codec->afg && !codec->mfg) {
4e76a883 1316 dev_err(bus->card->dev, "no AFG or MFG node found\n");
3be14149
TI		 1317 err = -ENODEV;
1318 goto error;
1da177e4
LT		 1319 }
1320
d819387e
TI		 1321 fg = codec->afg ? codec->afg : codec->mfg;
1322 err = read_widget_caps(codec, fg);
3be14149 1323 if (err < 0) {
4e76a883 1324 dev_err(bus->card->dev, "cannot malloc\n");
3be14149 1325 goto error;
54d17403 1326 }
3be14149
TI		 1327 err = read_pin_defaults(codec);
1328 if (err < 0)
1329 goto error;
54d17403 1330
0ba21762 1331 if (!codec->subsystem_id) {
0ba21762 1332 codec->subsystem_id =
d819387e 1333 snd_hda_codec_read(codec, fg, 0,
0ba21762 1334 AC_VERB_GET_SUBSYSTEM_ID, 0);
86284e45
TI		 1335 }
1336
83012a7c 1337#ifdef CONFIG_PM
d819387e 1338 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
b8dfc462 1339 AC_PWRST_CLKSTOP);
5d6147f1 1340#endif
d819387e 1341 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
983f6b93 1342 AC_PWRST_EPSS);
3e9bc58f
TI		 1343#ifdef CONFIG_PM
1344 if (!codec->d3_stop_clk || !codec->epss)
1345 bus->power_keep_link_on = 1;
1346#endif
1347
b8dfc462 1348
bb6ac72f 1349 /* power-up all before initialization */
d819387e 1350 hda_set_power_state(codec, AC_PWRST_D0);
bb6ac72f 1351
6c1f45ea
TI		 1352 snd_hda_codec_proc_new(codec);
1353
6c1f45ea 1354 snd_hda_create_hwdep(codec);
6c1f45ea
TI		 1355
1356 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1357 codec->subsystem_id, codec->revision_id);
1358 snd_component_add(codec->bus->card, component);
1359
2565c899
TI		 1360 err = snd_device_new(bus->card, SNDRV_DEV_CODEC, codec, &dev_ops);
1361 if (err < 0)
1362 goto error;
1363
6c1f45ea
TI		 1364 if (codecp)
1365 *codecp = codec;
1366 return 0;
3be14149
TI		 1367
1368 error:
1369 snd_hda_codec_free(codec);
1370 return err;
6c1f45ea 1371}
2698ea98 1372EXPORT_SYMBOL_GPL(snd_hda_codec_new);
6c1f45ea 1373
95a962c3
TI		 1374/**
1375 * snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
1376 * @codec: the HDA codec
1377 *
1378 * Forcibly refresh the all widget caps and the init pin configurations of
1379 * the given codec.
1380 */
a15d05db
ML		 1381int snd_hda_codec_update_widgets(struct hda_codec *codec)
1382{
1383 hda_nid_t fg;
1384 int err;
1385
1386 /* Assume the function group node does not change,
1387 * only the widget nodes may change.
1388 */
1389 kfree(codec->wcaps);
1390 fg = codec->afg ? codec->afg : codec->mfg;
1391 err = read_widget_caps(codec, fg);
1392 if (err < 0) {
4e76a883 1393 codec_err(codec, "cannot malloc\n");
a15d05db
ML		 1394 return err;
1395 }
1396
1397 snd_array_free(&codec->init_pins);
1398 err = read_pin_defaults(codec);
1399
1400 return err;
1401}
2698ea98 1402EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
a15d05db 1403
ed360813
TI		 1404/* update the stream-id if changed */
1405static void update_pcm_stream_id(struct hda_codec *codec,
1406 struct hda_cvt_setup *p, hda_nid_t nid,
1407 u32 stream_tag, int channel_id)
1408{
1409 unsigned int oldval, newval;
1410
1411 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1412 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1413 newval = (stream_tag << 4) | channel_id;
1414 if (oldval != newval)
1415 snd_hda_codec_write(codec, nid, 0,
1416 AC_VERB_SET_CHANNEL_STREAMID,
1417 newval);
1418 p->stream_tag = stream_tag;
1419 p->channel_id = channel_id;
1420 }
1421}
1422
1423/* update the format-id if changed */
1424static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1425 hda_nid_t nid, int format)
1426{
1427 unsigned int oldval;
1428
1429 if (p->format_id != format) {
1430 oldval = snd_hda_codec_read(codec, nid, 0,
1431 AC_VERB_GET_STREAM_FORMAT, 0);
1432 if (oldval != format) {
1433 msleep(1);
1434 snd_hda_codec_write(codec, nid, 0,
1435 AC_VERB_SET_STREAM_FORMAT,
1436 format);
1437 }
1438 p->format_id = format;
1439 }
1440}
1441
1da177e4
LT		 1442/**
1443 * snd_hda_codec_setup_stream - set up the codec for streaming
1444 * @codec: the CODEC to set up
1445 * @nid: the NID to set up
1446 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1447 * @channel_id: channel id to pass, zero based.
1448 * @format: stream format.
1449 */
0ba21762
TI		 1450void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1451 u32 stream_tag,
1da177e4
LT		 1452 int channel_id, int format)
1453{
3f50ac6a 1454 struct hda_codec *c;
eb541337 1455 struct hda_cvt_setup *p;
62b7e5e0 1456 int type;
eb541337
TI		 1457 int i;
1458
0ba21762 1459 if (!nid)
d21b37ea
TI		 1460 return;
1461
4e76a883
TI		 1462 codec_dbg(codec,
1463 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1464 nid, stream_tag, channel_id, format);
eb541337 1465 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1466 if (!p)
eb541337 1467 return;
ed360813
TI		 1468
1469 if (codec->pcm_format_first)
1470 update_pcm_format(codec, p, nid, format);
1471 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1472 if (!codec->pcm_format_first)
1473 update_pcm_format(codec, p, nid, format);
1474
eb541337
TI		 1475 p->active = 1;
1476 p->dirty = 0;
1477
1478 /* make other inactive cvts with the same stream-tag dirty */
62b7e5e0 1479 type = get_wcaps_type(get_wcaps(codec, nid));
3f50ac6a
TI		 1480 list_for_each_entry(c, &codec->bus->codec_list, list) {
1481 for (i = 0; i < c->cvt_setups.used; i++) {
1482 p = snd_array_elem(&c->cvt_setups, i);
62b7e5e0 1483 if (!p->active && p->stream_tag == stream_tag &&
54c2a89f 1484 get_wcaps_type(get_wcaps(c, p->nid)) == type)
3f50ac6a
TI		 1485 p->dirty = 1;
1486 }
eb541337 1487 }
1da177e4 1488}
2698ea98 1489EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1da177e4 1490
f0cea797
TI		 1491static void really_cleanup_stream(struct hda_codec *codec,
1492 struct hda_cvt_setup *q);
1493
d5191e50 1494/**
f0cea797 1495 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
d5191e50
TI		 1496 * @codec: the CODEC to clean up
1497 * @nid: the NID to clean up
f0cea797 1498 * @do_now: really clean up the stream instead of clearing the active flag
d5191e50 1499 */
f0cea797
TI		 1500void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1501 int do_now)
888afa15 1502{
eb541337
TI		 1503 struct hda_cvt_setup *p;
1504
888afa15
TI		 1505 if (!nid)
1506 return;
1507
0e7adbe2
TI		 1508 if (codec->no_sticky_stream)
1509 do_now = 1;
1510
4e76a883 1511 codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
eb541337 1512 p = get_hda_cvt_setup(codec, nid);
6c35ae3c 1513 if (p) {
f0cea797
TI		 1514 /* here we just clear the active flag when do_now isn't set;
1515 * actual clean-ups will be done later in
1516 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1517 */
1518 if (do_now)
1519 really_cleanup_stream(codec, p);
1520 else
1521 p->active = 0;
1522 }
eb541337 1523}
2698ea98 1524EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
eb541337
TI		 1525
1526static void really_cleanup_stream(struct hda_codec *codec,
1527 struct hda_cvt_setup *q)
1528{
1529 hda_nid_t nid = q->nid;
218264ae
TI		 1530 if (q->stream_tag || q->channel_id)
1531 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1532 if (q->format_id)
1533 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1534);
eb541337
TI		 1535 memset(q, 0, sizeof(*q));
1536 q->nid = nid;
1537}
1538
1539/* clean up the all conflicting obsolete streams */
1540static void purify_inactive_streams(struct hda_codec *codec)
1541{
3f50ac6a 1542 struct hda_codec *c;
eb541337
TI		 1543 int i;
1544
3f50ac6a
TI		 1545 list_for_each_entry(c, &codec->bus->codec_list, list) {
1546 for (i = 0; i < c->cvt_setups.used; i++) {
1547 struct hda_cvt_setup *p;
1548 p = snd_array_elem(&c->cvt_setups, i);
1549 if (p->dirty)
1550 really_cleanup_stream(c, p);
1551 }
eb541337
TI		 1552 }
1553}
1554
2a43952a 1555#ifdef CONFIG_PM
eb541337
TI		 1556/* clean up all streams; called from suspend */
1557static void hda_cleanup_all_streams(struct hda_codec *codec)
1558{
1559 int i;
1560
1561 for (i = 0; i < codec->cvt_setups.used; i++) {
1562 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1563 if (p->stream_tag)
1564 really_cleanup_stream(codec, p);
1565 }
888afa15 1566}
1c7276cf 1567#endif
888afa15 1568
1da177e4
LT		 1569/*
1570 * amp access functions
1571 */
1572
4a19faee 1573/* FIXME: more better hash key? */
28aedaf7 1574#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1575#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1576#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1577#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1578#define INFO_AMP_CAPS (1<<0)
4a19faee 1579#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1580
1581/* initialize the hash table */
6a0f56a7 1582static void init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1583 unsigned int record_size)
1584{
1585 memset(cache, 0, sizeof(*cache));
1586 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1587 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1588}
1589
1fcaee6e 1590static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1591{
603c4019 1592 snd_array_free(&cache->buf);
1da177e4
LT		 1593}
1594
1595/* query the hash. allocate an entry if not found. */
a68d5a54 1596static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1da177e4 1597{
01751f54
TI		 1598 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1599 u16 cur = cache->hash[idx];
1600 struct hda_cache_head *info;
1da177e4
LT		 1601
1602 while (cur != 0xffff) {
f43aa025 1603 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1604 if (info->key == key)
1605 return info;
1606 cur = info->next;
1607 }
a68d5a54
TI		 1608 return NULL;
1609}
1da177e4 1610
a68d5a54
TI		 1611/* query the hash. allocate an entry if not found. */
1612static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1613 u32 key)
1614{
1615 struct hda_cache_head *info = get_hash(cache, key);
1616 if (!info) {
1617 u16 idx, cur;
1618 /* add a new hash entry */
1619 info = snd_array_new(&cache->buf);
1620 if (!info)
1621 return NULL;
1622 cur = snd_array_index(&cache->buf, info);
1623 info->key = key;
1624 info->val = 0;
c370dd6e 1625 info->dirty = 0;
a68d5a54
TI		 1626 idx = key % (u16)ARRAY_SIZE(cache->hash);
1627 info->next = cache->hash[idx];
1628 cache->hash[idx] = cur;
1629 }
1da177e4
LT		 1630 return info;
1631}
1632
01751f54
TI		 1633/* query and allocate an amp hash entry */
1634static inline struct hda_amp_info *
1635get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1636{
1637 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1638}
1639
c3b6bcc2
TI		 1640/* overwrite the value with the key in the caps hash */
1641static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1642{
1643 struct hda_amp_info *info;
1644
1645 mutex_lock(&codec->hash_mutex);
1646 info = get_alloc_amp_hash(codec, key);
1647 if (!info) {
1648 mutex_unlock(&codec->hash_mutex);
1649 return -EINVAL;
1650 }
1651 info->amp_caps = val;
1652 info->head.val |= INFO_AMP_CAPS;
1653 mutex_unlock(&codec->hash_mutex);
1654 return 0;
1655}
1656
1657/* query the value from the caps hash; if not found, fetch the current
1658 * value from the given function and store in the hash
1659 */
1660static unsigned int
1661query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1662 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1663{
1664 struct hda_amp_info *info;
1665 unsigned int val;
1666
1667 mutex_lock(&codec->hash_mutex);
1668 info = get_alloc_amp_hash(codec, key);
1669 if (!info) {
1670 mutex_unlock(&codec->hash_mutex);
1671 return 0;
1672 }
1673 if (!(info->head.val & INFO_AMP_CAPS)) {
1674 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1675 val = func(codec, nid, dir);
1676 write_caps_hash(codec, key, val);
1677 } else {
1678 val = info->amp_caps;
1679 mutex_unlock(&codec->hash_mutex);
1680 }
1681 return val;
1682}
1683
1684static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1685 int direction)
1686{
1687 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1688 nid = codec->afg;
1689 return snd_hda_param_read(codec, nid,
1690 direction == HDA_OUTPUT ?
1691 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1692}
1693
d5191e50
TI		 1694/**
1695 * query_amp_caps - query AMP capabilities
1696 * @codec: the HD-auio codec
1697 * @nid: the NID to query
1698 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1699 *
1700 * Query AMP capabilities for the given widget and direction.
1701 * Returns the obtained capability bits.
1702 *
1703 * When cap bits have been already read, this doesn't read again but
1704 * returns the cached value.
1da177e4 1705 */
09a99959 1706u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1707{
c3b6bcc2
TI		 1708 return query_caps_hash(codec, nid, direction,
1709 HDA_HASH_KEY(nid, direction, 0),
1710 read_amp_cap);
1da177e4 1711}
2698ea98 1712EXPORT_SYMBOL_GPL(query_amp_caps);
1da177e4 1713
861a04ed
DH		 1714/**
1715 * snd_hda_check_amp_caps - query AMP capabilities
1716 * @codec: the HD-audio codec
1717 * @nid: the NID to query
1718 * @dir: either #HDA_INPUT or #HDA_OUTPUT
a11e9b16 1719 * @bits: bit mask to check the result
861a04ed
DH		 1720 *
1721 * Check whether the widget has the given amp capability for the direction.
1722 */
1723bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
1724 int dir, unsigned int bits)
1725{
1726 if (!nid)
1727 return false;
1728 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
1729 if (query_amp_caps(codec, nid, dir) & bits)
1730 return true;
1731 return false;
1732}
1733EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
1734
d5191e50
TI		 1735/**
1736 * snd_hda_override_amp_caps - Override the AMP capabilities
1737 * @codec: the CODEC to clean up
1738 * @nid: the NID to clean up
a11e9b16 1739 * @dir: either #HDA_INPUT or #HDA_OUTPUT
d5191e50
TI		 1740 * @caps: the capability bits to set
1741 *
1742 * Override the cached AMP caps bits value by the given one.
1743 * This function is useful if the driver needs to adjust the AMP ranges,
1744 * e.g. limit to 0dB, etc.
1745 *
1746 * Returns zero if successful or a negative error code.
1747 */
897cc188
TI		 1748int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1749 unsigned int caps)
1750{
c3b6bcc2 1751 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
897cc188 1752}
2698ea98 1753EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1327a32b 1754
c3b6bcc2
TI		 1755static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1756 int dir)
92c7c8a7
TI		 1757{
1758 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1759}
1760
d5191e50
TI		 1761/**
1762 * snd_hda_query_pin_caps - Query PIN capabilities
1763 * @codec: the HD-auio codec
1764 * @nid: the NID to query
1765 *
1766 * Query PIN capabilities for the given widget.
1767 * Returns the obtained capability bits.
1768 *
1769 * When cap bits have been already read, this doesn't read again but
1770 * returns the cached value.
1771 */
92c7c8a7
TI		 1772u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1773{
c3b6bcc2 1774 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
92c7c8a7
TI		 1775 read_pin_cap);
1776}
2698ea98 1777EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
897cc188 1778
f57c2565
TI		 1779/**
1780 * snd_hda_override_pin_caps - Override the pin capabilities
1781 * @codec: the CODEC
1782 * @nid: the NID to override
1783 * @caps: the capability bits to set
1784 *
1785 * Override the cached PIN capabilitiy bits value by the given one.
1786 *
1787 * Returns zero if successful or a negative error code.
1788 */
1789int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1790 unsigned int caps)
1791{
c3b6bcc2 1792 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
f57c2565 1793}
2698ea98 1794EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
f57c2565 1795
c3b6bcc2
TI		 1796/* read or sync the hash value with the current value;
1797 * call within hash_mutex
1da177e4 1798 */
c3b6bcc2
TI		 1799static struct hda_amp_info *
1800update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
280e57d5 1801 int direction, int index, bool init_only)
1da177e4 1802{
c3b6bcc2
TI		 1803 struct hda_amp_info *info;
1804 unsigned int parm, val = 0;
1805 bool val_read = false;
1da177e4 1806
c3b6bcc2
TI		 1807 retry:
1808 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1809 if (!info)
1810 return NULL;
1811 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1812 if (!val_read) {
1813 mutex_unlock(&codec->hash_mutex);
1814 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1815 parm |= direction == HDA_OUTPUT ?
1816 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1817 parm |= index;
1818 val = snd_hda_codec_read(codec, nid, 0,
0ba21762 1819 AC_VERB_GET_AMP_GAIN_MUTE, parm);
c3b6bcc2
TI		 1820 val &= 0xff;
1821 val_read = true;
1822 mutex_lock(&codec->hash_mutex);
1823 goto retry;
1824 }
1825 info->vol[ch] = val;
1826 info->head.val |= INFO_AMP_VOL(ch);
280e57d5
TI		 1827 } else if (init_only)
1828 return NULL;
c3b6bcc2 1829 return info;
1da177e4
LT		 1830}
1831
1832/*
c3b6bcc2 1833 * write the current volume in info to the h/w
1da177e4 1834 */
2ce4886a 1835static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
0ba21762
TI		 1836 hda_nid_t nid, int ch, int direction, int index,
1837 int val)
1da177e4
LT		 1838{
1839 u32 parm;
1840
1841 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1842 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1843 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2ce4886a
TI		 1844 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
1845 (amp_caps & AC_AMPCAP_MIN_MUTE))
3868137e
TI		 1846 ; /* set the zero value as a fake mute */
1847 else
1848 parm |= val;
1da177e4
LT		 1849 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1850}
1851
d5191e50
TI		 1852/**
1853 * snd_hda_codec_amp_read - Read AMP value
1854 * @codec: HD-audio codec
1855 * @nid: NID to read the AMP value
1856 * @ch: channel (left=0 or right=1)
1857 * @direction: #HDA_INPUT or #HDA_OUTPUT
1858 * @index: the index value (only for input direction)
1859 *
1860 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 1861 */
834be88d
TI		 1862int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1863 int direction, int index)
1da177e4 1864{
0ba21762 1865 struct hda_amp_info *info;
c3b6bcc2
TI		 1866 unsigned int val = 0;
1867
1868 mutex_lock(&codec->hash_mutex);
280e57d5 1869 info = update_amp_hash(codec, nid, ch, direction, index, false);
c3b6bcc2
TI		 1870 if (info)
1871 val = info->vol[ch];
1872 mutex_unlock(&codec->hash_mutex);
1873 return val;
1da177e4 1874}
2698ea98 1875EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
1da177e4 1876
280e57d5
TI		 1877static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1878 int direction, int idx, int mask, int val,
781c7b96 1879 bool init_only, bool cache_only)
1da177e4 1880{
0ba21762 1881 struct hda_amp_info *info;
2ce4886a 1882 unsigned int caps;
4a19faee 1883
46712646
TI		 1884 if (snd_BUG_ON(mask & ~0xff))
1885 mask &= 0xff;
4a19faee 1886 val &= mask;
c3b6bcc2
TI		 1887
1888 mutex_lock(&codec->hash_mutex);
280e57d5 1889 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
c3b6bcc2
TI		 1890 if (!info) {
1891 mutex_unlock(&codec->hash_mutex);
1892 return 0;
1893 }
1894 val |= info->vol[ch] & ~mask;
1895 if (info->vol[ch] == val) {
1896 mutex_unlock(&codec->hash_mutex);
1da177e4 1897 return 0;
c3b6bcc2
TI		 1898 }
1899 info->vol[ch] = val;
781c7b96 1900 info->head.dirty |= cache_only;
2ce4886a 1901 caps = info->amp_caps;
c3b6bcc2 1902 mutex_unlock(&codec->hash_mutex);
de1e37b7 1903 if (!cache_only)
2ce4886a 1904 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
1da177e4
LT		 1905 return 1;
1906}
280e57d5
TI		 1907
1908/**
1909 * snd_hda_codec_amp_update - update the AMP value
1910 * @codec: HD-audio codec
1911 * @nid: NID to read the AMP value
1912 * @ch: channel (left=0 or right=1)
1913 * @direction: #HDA_INPUT or #HDA_OUTPUT
1914 * @idx: the index value (only for input direction)
1915 * @mask: bit mask to set
1916 * @val: the bits value to set
1917 *
1918 * Update the AMP value with a bit mask.
1919 * Returns 0 if the value is unchanged, 1 if changed.
1920 */
1921int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1922 int direction, int idx, int mask, int val)
1923{
781c7b96
TI		 1924 return codec_amp_update(codec, nid, ch, direction, idx, mask, val,
1925 false, codec->cached_write);
280e57d5 1926}
2698ea98 1927EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
1da177e4 1928
d5191e50
TI		 1929/**
1930 * snd_hda_codec_amp_stereo - update the AMP stereo values
1931 * @codec: HD-audio codec
1932 * @nid: NID to read the AMP value
1933 * @direction: #HDA_INPUT or #HDA_OUTPUT
1934 * @idx: the index value (only for input direction)
1935 * @mask: bit mask to set
1936 * @val: the bits value to set
1937 *
1938 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1939 * stereo widget with the same mask and value.
47fd830a
TI		 1940 */
1941int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1942 int direction, int idx, int mask, int val)
1943{
1944 int ch, ret = 0;
46712646
TI		 1945
1946 if (snd_BUG_ON(mask & ~0xff))
1947 mask &= 0xff;
47fd830a
TI		 1948 for (ch = 0; ch < 2; ch++)
1949 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1950 idx, mask, val);
1951 return ret;
1952}
2698ea98 1953EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
47fd830a 1954
95a962c3
TI		 1955/**
1956 * snd_hda_codec_amp_init - initialize the AMP value
1957 * @codec: the HDA codec
1958 * @nid: NID to read the AMP value
1959 * @ch: channel (left=0 or right=1)
1960 * @dir: #HDA_INPUT or #HDA_OUTPUT
1961 * @idx: the index value (only for input direction)
1962 * @mask: bit mask to set
1963 * @val: the bits value to set
1964 *
1965 * Works like snd_hda_codec_amp_update() but it writes the value only at
280e57d5
TI		 1966 * the first access. If the amp was already initialized / updated beforehand,
1967 * this does nothing.
1968 */
1969int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1970 int dir, int idx, int mask, int val)
1971{
781c7b96
TI		 1972 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true,
1973 codec->cached_write);
280e57d5 1974}
2698ea98 1975EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
280e57d5 1976
95a962c3
TI		 1977/**
1978 * snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
1979 * @codec: the HDA codec
1980 * @nid: NID to read the AMP value
1981 * @dir: #HDA_INPUT or #HDA_OUTPUT
1982 * @idx: the index value (only for input direction)
1983 * @mask: bit mask to set
1984 * @val: the bits value to set
1985 *
1986 * Call snd_hda_codec_amp_init() for both stereo channels.
1987 */
280e57d5
TI		 1988int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1989 int dir, int idx, int mask, int val)
1990{
1991 int ch, ret = 0;
1992
1993 if (snd_BUG_ON(mask & ~0xff))
1994 mask &= 0xff;
1995 for (ch = 0; ch < 2; ch++)
1996 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1997 idx, mask, val);
1998 return ret;
1999}
2698ea98 2000EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
280e57d5 2001
d5191e50
TI		 2002/**
2003 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2004 * @codec: HD-audio codec
2005 *
2006 * Resume the all amp commands from the cache.
2007 */
b3ac5636
TI		 2008void snd_hda_codec_resume_amp(struct hda_codec *codec)
2009{
b3ac5636
TI		 2010 int i;
2011
c370dd6e 2012 mutex_lock(&codec->hash_mutex);
aa88a355 2013 codec->cached_write = 0;
c370dd6e
TI		 2014 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2015 struct hda_amp_info *buffer;
2016 u32 key;
b3ac5636
TI		 2017 hda_nid_t nid;
2018 unsigned int idx, dir, ch;
2ce4886a 2019 struct hda_amp_info info;
c370dd6e
TI		 2020
2021 buffer = snd_array_elem(&codec->amp_cache.buf, i);
8565f052
TI		 2022 if (!buffer->head.dirty)
2023 continue;
2024 buffer->head.dirty = 0;
2ce4886a
TI		 2025 info = *buffer;
2026 key = info.head.key;
b3ac5636
TI		 2027 if (!key)
2028 continue;
2029 nid = key & 0xff;
2030 idx = (key >> 16) & 0xff;
2031 dir = (key >> 24) & 0xff;
2032 for (ch = 0; ch < 2; ch++) {
2ce4886a 2033 if (!(info.head.val & INFO_AMP_VOL(ch)))
b3ac5636 2034 continue;
c370dd6e 2035 mutex_unlock(&codec->hash_mutex);
2ce4886a
TI		 2036 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2037 info.vol[ch]);
c370dd6e 2038 mutex_lock(&codec->hash_mutex);
b3ac5636
TI		 2039 }
2040 }
c370dd6e 2041 mutex_unlock(&codec->hash_mutex);
b3ac5636 2042}
2698ea98 2043EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
1da177e4 2044
afbd9b84
TI		 2045static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2046 unsigned int ofs)
2047{
2048 u32 caps = query_amp_caps(codec, nid, dir);
2049 /* get num steps */
2050 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2051 if (ofs < caps)
2052 caps -= ofs;
2053 return caps;
2054}
2055
d5191e50
TI		 2056/**
2057 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
a11e9b16
TI		 2058 * @kcontrol: referred ctl element
2059 * @uinfo: pointer to get/store the data
d5191e50
TI		 2060 *
2061 * The control element is supposed to have the private_value field
2062 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2063 */
0ba21762
TI		 2064int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2065 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2066{
2067 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2068 u16 nid = get_amp_nid(kcontrol);
2069 u8 chs = get_amp_channels(kcontrol);
2070 int dir = get_amp_direction(kcontrol);
29fdbec2 2071 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4 2072
afbd9b84
TI		 2073 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2074 uinfo->count = chs == 3 ? 2 : 1;
2075 uinfo->value.integer.min = 0;
2076 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2077 if (!uinfo->value.integer.max) {
4e76a883
TI		 2078 codec_warn(codec,
2079 "num_steps = 0 for NID=0x%x (ctl = %s)\n",
2080 nid, kcontrol->id.name);
1da177e4
LT		 2081 return -EINVAL;
2082 }
1da177e4
LT		 2083 return 0;
2084}
2698ea98 2085EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
1da177e4 2086
29fdbec2
TI		 2087
2088static inline unsigned int
2089read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2090 int ch, int dir, int idx, unsigned int ofs)
2091{
2092 unsigned int val;
2093 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2094 val &= HDA_AMP_VOLMASK;
2095 if (val >= ofs)
2096 val -= ofs;
2097 else
2098 val = 0;
2099 return val;
2100}
2101
2102static inline int
2103update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2104 int ch, int dir, int idx, unsigned int ofs,
2105 unsigned int val)
2106{
afbd9b84
TI		 2107 unsigned int maxval;
2108
29fdbec2
TI		 2109 if (val > 0)
2110 val += ofs;
7ccc3efa
TI		 2111 /* ofs = 0: raw max value */
2112 maxval = get_amp_max_value(codec, nid, dir, 0);
afbd9b84
TI		 2113 if (val > maxval)
2114 val = maxval;
781c7b96
TI		 2115 return codec_amp_update(codec, nid, ch, dir, idx, HDA_AMP_VOLMASK, val,
2116 false, !hda_codec_is_power_on(codec));
29fdbec2
TI		 2117}
2118
d5191e50
TI		 2119/**
2120 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
a11e9b16
TI		 2121 * @kcontrol: ctl element
2122 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2123 *
2124 * The control element is supposed to have the private_value field
2125 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2126 */
0ba21762
TI		 2127int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2128 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2129{
2130 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2131 hda_nid_t nid = get_amp_nid(kcontrol);
2132 int chs = get_amp_channels(kcontrol);
2133 int dir = get_amp_direction(kcontrol);
2134 int idx = get_amp_index(kcontrol);
29fdbec2 2135 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2136 long *valp = ucontrol->value.integer.value;
2137
2138 if (chs & 1)
29fdbec2 2139 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 2140 if (chs & 2)
29fdbec2 2141 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 2142 return 0;
2143}
2698ea98 2144EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
1da177e4 2145
d5191e50
TI		 2146/**
2147 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
a11e9b16
TI		 2148 * @kcontrol: ctl element
2149 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2150 *
2151 * The control element is supposed to have the private_value field
2152 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2153 */
0ba21762
TI		 2154int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2155 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2156{
2157 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2158 hda_nid_t nid = get_amp_nid(kcontrol);
2159 int chs = get_amp_channels(kcontrol);
2160 int dir = get_amp_direction(kcontrol);
2161 int idx = get_amp_index(kcontrol);
29fdbec2 2162 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 2163 long *valp = ucontrol->value.integer.value;
2164 int change = 0;
2165
b9f5a89c 2166 if (chs & 1) {
29fdbec2 2167 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 2168 valp++;
2169 }
4a19faee 2170 if (chs & 2)
29fdbec2 2171 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1da177e4
LT		 2172 return change;
2173}
2698ea98 2174EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
1da177e4 2175
d5191e50
TI		 2176/**
2177 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
a11e9b16
TI		 2178 * @kcontrol: ctl element
2179 * @op_flag: operation flag
2180 * @size: byte size of input TLV
2181 * @_tlv: TLV data
d5191e50
TI		 2182 *
2183 * The control element is supposed to have the private_value field
2184 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2185 */
302e9c5a
JK		 2186int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2187 unsigned int size, unsigned int __user *_tlv)
2188{
2189 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2190 hda_nid_t nid = get_amp_nid(kcontrol);
2191 int dir = get_amp_direction(kcontrol);
29fdbec2 2192 unsigned int ofs = get_amp_offset(kcontrol);
de8c85f7 2193 bool min_mute = get_amp_min_mute(kcontrol);
302e9c5a
JK		 2194 u32 caps, val1, val2;
2195
2196 if (size < 4 * sizeof(unsigned int))
2197 return -ENOMEM;
2198 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 2199 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2200 val2 = (val2 + 1) * 25;
302e9c5a 2201 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 2202 val1 += ofs;
302e9c5a 2203 val1 = ((int)val1) * ((int)val2);
3868137e 2204 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
c08d9169 2205 val2 |= TLV_DB_SCALE_MUTE;
302e9c5a
JK		 2206 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2207 return -EFAULT;
2208 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2209 return -EFAULT;
2210 if (put_user(val1, _tlv + 2))
2211 return -EFAULT;
2212 if (put_user(val2, _tlv + 3))
2213 return -EFAULT;
2214 return 0;
2215}
2698ea98 2216EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
302e9c5a 2217
d5191e50
TI		 2218/**
2219 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2220 * @codec: HD-audio codec
2221 * @nid: NID of a reference widget
2222 * @dir: #HDA_INPUT or #HDA_OUTPUT
2223 * @tlv: TLV data to be stored, at least 4 elements
2224 *
2225 * Set (static) TLV data for a virtual master volume using the AMP caps
2226 * obtained from the reference NID.
2227 * The volume range is recalculated as if the max volume is 0dB.
2134ea4f
TI		 2228 */
2229void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2230 unsigned int *tlv)
2231{
2232 u32 caps;
2233 int nums, step;
2234
2235 caps = query_amp_caps(codec, nid, dir);
2236 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2237 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2238 step = (step + 1) * 25;
2239 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2240 tlv[1] = 2 * sizeof(unsigned int);
2241 tlv[2] = -nums * step;
2242 tlv[3] = step;
2243}
2698ea98 2244EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 2245
2246/* find a mixer control element with the given name */
09f99701 2247static struct snd_kcontrol *
dcda5806 2248find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2134ea4f
TI		 2249{
2250 struct snd_ctl_elem_id id;
2251 memset(&id, 0, sizeof(id));
2252 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
dcda5806 2253 id.device = dev;
09f99701 2254 id.index = idx;
18cb7109
TI		 2255 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2256 return NULL;
2134ea4f
TI		 2257 strcpy(id.name, name);
2258 return snd_ctl_find_id(codec->bus->card, &id);
2259}
2260
d5191e50
TI		 2261/**
2262 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2263 * @codec: HD-audio codec
2264 * @name: ctl id name string
2265 *
2266 * Get the control element with the given id string and IFACE_MIXER.
2267 */
09f99701
TI		 2268struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2269 const char *name)
2270{
dcda5806 2271 return find_mixer_ctl(codec, name, 0, 0);
09f99701 2272}
2698ea98 2273EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
09f99701 2274
dcda5806 2275static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
ea9b43ad 2276 int start_idx)
1afe206a 2277{
ea9b43ad
TI		 2278 int i, idx;
2279 /* 16 ctlrs should be large enough */
2280 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2281 if (!find_mixer_ctl(codec, name, 0, idx))
1afe206a
TI		 2282 return idx;
2283 }
2284 return -EBUSY;
2285}
2286
d5191e50 2287/**
5b0cb1d8 2288 * snd_hda_ctl_add - Add a control element and assign to the codec
d5191e50
TI		 2289 * @codec: HD-audio codec
2290 * @nid: corresponding NID (optional)
2291 * @kctl: the control element to assign
2292 *
2293 * Add the given control element to an array inside the codec instance.
2294 * All control elements belonging to a codec are supposed to be added
2295 * by this function so that a proper clean-up works at the free or
2296 * reconfiguration time.
2297 *
2298 * If non-zero @nid is passed, the NID is assigned to the control element.
2299 * The assignment is shown in the codec proc file.
2300 *
2301 * snd_hda_ctl_add() checks the control subdev id field whether
2302 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
9e3fd871
JK		 2303 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2304 * specifies if kctl->private_value is a HDA amplifier value.
d5191e50 2305 */
3911a4c1
JK		 2306int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2307 struct snd_kcontrol *kctl)
d13bd412
TI		 2308{
2309 int err;
9e3fd871 2310 unsigned short flags = 0;
3911a4c1 2311 struct hda_nid_item *item;
d13bd412 2312
5e26dfd0 2313 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
9e3fd871 2314 flags |= HDA_NID_ITEM_AMP;
5e26dfd0
JK		 2315 if (nid == 0)
2316 nid = get_amp_nid_(kctl->private_value);
2317 }
9e3fd871
JK		 2318 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2319 nid = kctl->id.subdevice & 0xffff;
5e26dfd0 2320 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
4d02d1b6 2321 kctl->id.subdevice = 0;
d13bd412
TI		 2322 err = snd_ctl_add(codec->bus->card, kctl);
2323 if (err < 0)
2324 return err;
3911a4c1
JK		 2325 item = snd_array_new(&codec->mixers);
2326 if (!item)
d13bd412 2327 return -ENOMEM;
3911a4c1
JK		 2328 item->kctl = kctl;
2329 item->nid = nid;
9e3fd871 2330 item->flags = flags;
d13bd412
TI		 2331 return 0;
2332}
2698ea98 2333EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
d13bd412 2334
5b0cb1d8
JK		 2335/**
2336 * snd_hda_add_nid - Assign a NID to a control element
2337 * @codec: HD-audio codec
2338 * @nid: corresponding NID (optional)
2339 * @kctl: the control element to assign
2340 * @index: index to kctl
2341 *
2342 * Add the given control element to an array inside the codec instance.
2343 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2344 * NID:KCTL mapping - for example "Capture Source" selector.
2345 */
2346int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2347 unsigned int index, hda_nid_t nid)
2348{
2349 struct hda_nid_item *item;
2350
2351 if (nid > 0) {
2352 item = snd_array_new(&codec->nids);
2353 if (!item)
2354 return -ENOMEM;
2355 item->kctl = kctl;
2356 item->index = index;
2357 item->nid = nid;
2358 return 0;
2359 }
4e76a883
TI		 2360 codec_err(codec, "no NID for mapping control %s:%d:%d\n",
2361 kctl->id.name, kctl->id.index, index);
5b0cb1d8
JK		 2362 return -EINVAL;
2363}
2698ea98 2364EXPORT_SYMBOL_GPL(snd_hda_add_nid);
5b0cb1d8 2365
d5191e50
TI		 2366/**
2367 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2368 * @codec: HD-audio codec
2369 */
d13bd412
TI		 2370void snd_hda_ctls_clear(struct hda_codec *codec)
2371{
2372 int i;
3911a4c1 2373 struct hda_nid_item *items = codec->mixers.list;
d13bd412 2374 for (i = 0; i < codec->mixers.used; i++)
3911a4c1 2375 snd_ctl_remove(codec->bus->card, items[i].kctl);
d13bd412 2376 snd_array_free(&codec->mixers);
5b0cb1d8 2377 snd_array_free(&codec->nids);
d13bd412
TI		 2378}
2379
95a962c3
TI		 2380/**
2381 * snd_hda_lock_devices - pseudo device locking
2382 * @bus: the BUS
2383 *
a65d629c
TI		 2384 * toggle card->shutdown to allow/disallow the device access (as a hack)
2385 */
d3d020bd 2386int snd_hda_lock_devices(struct hda_bus *bus)
6c1f45ea 2387{
d3d020bd
TI		 2388 struct snd_card *card = bus->card;
2389 struct hda_codec *codec;
2390
a65d629c 2391 spin_lock(&card->files_lock);
d3d020bd
TI		 2392 if (card->shutdown)
2393 goto err_unlock;
a65d629c 2394 card->shutdown = 1;
d3d020bd
TI		 2395 if (!list_empty(&card->ctl_files))
2396 goto err_clear;
2397
2398 list_for_each_entry(codec, &bus->codec_list, list) {
2399 int pcm;
2400 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2401 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2402 if (!cpcm->pcm)
2403 continue;
2404 if (cpcm->pcm->streams[0].substream_opened ||
2405 cpcm->pcm->streams[1].substream_opened)
2406 goto err_clear;
2407 }
2408 }
a65d629c
TI		 2409 spin_unlock(&card->files_lock);
2410 return 0;
d3d020bd
TI		 2411
2412 err_clear:
2413 card->shutdown = 0;
2414 err_unlock:
2415 spin_unlock(&card->files_lock);
2416 return -EINVAL;
a65d629c 2417}
2698ea98 2418EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
a65d629c 2419
95a962c3
TI		 2420/**
2421 * snd_hda_unlock_devices - pseudo device unlocking
2422 * @bus: the BUS
2423 */
d3d020bd 2424void snd_hda_unlock_devices(struct hda_bus *bus)
a65d629c 2425{
d3d020bd
TI		 2426 struct snd_card *card = bus->card;
2427
2428 card = bus->card;
a65d629c
TI		 2429 spin_lock(&card->files_lock);
2430 card->shutdown = 0;
2431 spin_unlock(&card->files_lock);
2432}
2698ea98 2433EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
a65d629c 2434
d5191e50
TI		 2435/**
2436 * snd_hda_codec_reset - Clear all objects assigned to the codec
2437 * @codec: HD-audio codec
2438 *
2439 * This frees the all PCM and control elements assigned to the codec, and
2440 * clears the caches and restores the pin default configurations.
2441 *
2442 * When a device is being used, it returns -EBSY. If successfully freed,
2443 * returns zero.
2444 */
a65d629c
TI		 2445int snd_hda_codec_reset(struct hda_codec *codec)
2446{
d3d020bd
TI		 2447 struct hda_bus *bus = codec->bus;
2448 struct snd_card *card = bus->card;
2449 int i;
a65d629c 2450
d3d020bd 2451 if (snd_hda_lock_devices(bus) < 0)
a65d629c 2452 return -EBUSY;
a65d629c
TI		 2453
2454 /* OK, let it free */
26a6cb6c 2455 cancel_delayed_work_sync(&codec->jackpoll_work);
83012a7c 2456#ifdef CONFIG_PM
a2d96e77 2457 cancel_delayed_work_sync(&codec->power_work);
d3d020bd 2458 flush_workqueue(bus->workq);
6c1f45ea
TI		 2459#endif
2460 snd_hda_ctls_clear(codec);
83a35e36 2461 /* release PCMs */
6c1f45ea 2462 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 2463 if (codec->pcm_info[i].pcm) {
a65d629c 2464 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4 2465 clear_bit(codec->pcm_info[i].device,
d3d020bd 2466 bus->pcm_dev_bits);
529bd6c4 2467 }
6c1f45ea 2468 }
d604b399 2469 snd_hda_detach_beep_device(codec);
d8a766a1
TI		 2470 if (device_is_registered(hda_codec_dev(codec)))
2471 device_del(hda_codec_dev(codec));
2472
07dc59f0 2473 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1835a0f9 2474 snd_hda_jack_tbl_clear(codec);
56d17712 2475 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 2476 codec->spec = NULL;
2477 free_hda_cache(&codec->amp_cache);
2478 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 2479 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2480 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 2481 /* free only driver_pins so that init_pins + user_pins are restored */
2482 snd_array_free(&codec->driver_pins);
09a6071b
TI		 2483 snd_array_free(&codec->cvt_setups);
2484 snd_array_free(&codec->spdif_out);
c9ce6b26 2485 snd_array_free(&codec->verbs);
6c1f45ea
TI		 2486 codec->num_pcms = 0;
2487 codec->pcm_info = NULL;
2488 codec->preset = NULL;
d1f1af2d
TI		 2489 codec->slave_dig_outs = NULL;
2490 codec->spdif_status_reset = 0;
a65d629c
TI		 2491
2492 /* allow device access again */
d3d020bd 2493 snd_hda_unlock_devices(bus);
a65d629c 2494 return 0;
6c1f45ea
TI		 2495}
2496
6194b99d 2497typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
aeb4b88e
TI		 2498
2499/* apply the function to all matching slave ctls in the mixer list */
2500static int map_slaves(struct hda_codec *codec, const char * const *slaves,
9322ca54 2501 const char *suffix, map_slave_func_t func, void *data)
aeb4b88e
TI		 2502{
2503 struct hda_nid_item *items;
2504 const char * const *s;
2505 int i, err;
2506
2507 items = codec->mixers.list;
2508 for (i = 0; i < codec->mixers.used; i++) {
2509 struct snd_kcontrol *sctl = items[i].kctl;
ca16ec02 2510 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
aeb4b88e
TI		 2511 continue;
2512 for (s = slaves; *s; s++) {
9322ca54
TI		 2513 char tmpname[sizeof(sctl->id.name)];
2514 const char *name = *s;
2515 if (suffix) {
2516 snprintf(tmpname, sizeof(tmpname), "%s %s",
2517 name, suffix);
2518 name = tmpname;
2519 }
9322ca54 2520 if (!strcmp(sctl->id.name, name)) {
6194b99d 2521 err = func(codec, data, sctl);
aeb4b88e
TI		 2522 if (err)
2523 return err;
2524 break;
2525 }
2526 }
2527 }
2528 return 0;
2529}
2530
6194b99d
TI		 2531static int check_slave_present(struct hda_codec *codec,
2532 void *data, struct snd_kcontrol *sctl)
aeb4b88e
TI		 2533{
2534 return 1;
2535}
2536
18478e8b 2537/* guess the value corresponding to 0dB */
6194b99d
TI		 2538static int get_kctl_0dB_offset(struct hda_codec *codec,
2539 struct snd_kcontrol *kctl, int *step_to_check)
18478e8b
TI		 2540{
2541 int _tlv[4];
2542 const int *tlv = NULL;
2543 int val = -1;
2544
2545 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2546 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2547 mm_segment_t fs = get_fs();
2548 set_fs(get_ds());
2549 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2550 tlv = _tlv;
2551 set_fs(fs);
2552 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2553 tlv = kctl->tlv.p;
a4e7a121
TI		 2554 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
2555 int step = tlv[3];
2556 step &= ~TLV_DB_SCALE_MUTE;
2557 if (!step)
2558 return -1;
485e3e0c 2559 if (*step_to_check && *step_to_check != step) {
6194b99d 2560 codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
4e76a883 2561- *step_to_check, step);
485e3e0c
TI		 2562 return -1;
2563 }
2564 *step_to_check = step;
a4e7a121
TI		 2565 val = -tlv[2] / step;
2566 }
18478e8b
TI		 2567 return val;
2568}
2569
2570/* call kctl->put with the given value(s) */
2571static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2572{
2573 struct snd_ctl_elem_value *ucontrol;
2574 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2575 if (!ucontrol)
2576 return -ENOMEM;
2577 ucontrol->value.integer.value[0] = val;
2578 ucontrol->value.integer.value[1] = val;
2579 kctl->put(kctl, ucontrol);
2580 kfree(ucontrol);
2581 return 0;
2582}
2583
2584/* initialize the slave volume with 0dB */
6194b99d
TI		 2585static int init_slave_0dB(struct hda_codec *codec,
2586 void *data, struct snd_kcontrol *slave)
18478e8b 2587{
6194b99d 2588 int offset = get_kctl_0dB_offset(codec, slave, data);
18478e8b
TI		 2589 if (offset > 0)
2590 put_kctl_with_value(slave, offset);
2591 return 0;
2592}
2593
2594/* unmute the slave */
6194b99d
TI		 2595static int init_slave_unmute(struct hda_codec *codec,
2596 void *data, struct snd_kcontrol *slave)
18478e8b
TI		 2597{
2598 return put_kctl_with_value(slave, 1);
2599}
2600
e8750940
TI		 2601static int add_slave(struct hda_codec *codec,
2602 void *data, struct snd_kcontrol *slave)
2603{
2604 return snd_ctl_add_slave(data, slave);
2605}
2606
d5191e50 2607/**
95a962c3 2608 * __snd_hda_add_vmaster - create a virtual master control and add slaves
d5191e50
TI		 2609 * @codec: HD-audio codec
2610 * @name: vmaster control name
2611 * @tlv: TLV data (optional)
2612 * @slaves: slave control names (optional)
9322ca54 2613 * @suffix: suffix string to each slave name (optional)
18478e8b 2614 * @init_slave_vol: initialize slaves to unmute/0dB
29e5853d 2615 * @ctl_ret: store the vmaster kcontrol in return
d5191e50
TI		 2616 *
2617 * Create a virtual master control with the given name. The TLV data
2618 * must be either NULL or a valid data.
2619 *
2620 * @slaves is a NULL-terminated array of strings, each of which is a
2621 * slave control name. All controls with these names are assigned to
2622 * the new virtual master control.
2623 *
2624 * This function returns zero if successful or a negative error code.
2625 */
18478e8b 2626int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
9322ca54 2627 unsigned int *tlv, const char * const *slaves,
29e5853d
TI		 2628 const char *suffix, bool init_slave_vol,
2629 struct snd_kcontrol **ctl_ret)
2134ea4f
TI		 2630{
2631 struct snd_kcontrol *kctl;
2134ea4f
TI		 2632 int err;
2633
29e5853d
TI		 2634 if (ctl_ret)
2635 *ctl_ret = NULL;
2636
9322ca54 2637 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
aeb4b88e 2638 if (err != 1) {
4e76a883 2639 codec_dbg(codec, "No slave found for %s\n", name);
2f085549
TI		 2640 return 0;
2641 }
2134ea4f
TI		 2642 kctl = snd_ctl_make_virtual_master(name, tlv);
2643 if (!kctl)
2644 return -ENOMEM;
3911a4c1 2645 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 2646 if (err < 0)
2647 return err;
28aedaf7 2648
e8750940 2649 err = map_slaves(codec, slaves, suffix, add_slave, kctl);
aeb4b88e
TI		 2650 if (err < 0)
2651 return err;
18478e8b
TI		 2652
2653 /* init with master mute & zero volume */
2654 put_kctl_with_value(kctl, 0);
485e3e0c
TI		 2655 if (init_slave_vol) {
2656 int step = 0;
18478e8b 2657 map_slaves(codec, slaves, suffix,
485e3e0c
TI		 2658 tlv ? init_slave_0dB : init_slave_unmute, &step);
2659 }
18478e8b 2660
29e5853d
TI		 2661 if (ctl_ret)
2662 *ctl_ret = kctl;
2134ea4f
TI		 2663 return 0;
2664}
2698ea98 2665EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2134ea4f 2666
d2f344b5
TI		 2667/*
2668 * mute-LED control using vmaster
2669 */
2670static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2671 struct snd_ctl_elem_info *uinfo)
2672{
2673 static const char * const texts[] = {
c86c2d44 2674 "On", "Off", "Follow Master"
d2f344b5 2675 };
d2f344b5 2676
3ff72219 2677 return snd_ctl_enum_info(uinfo, 1, 3, texts);
d2f344b5
TI		 2678}
2679
2680static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2681 struct snd_ctl_elem_value *ucontrol)
2682{
2683 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2684 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2685 return 0;
2686}
2687
2688static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2689 struct snd_ctl_elem_value *ucontrol)
2690{
2691 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2692 unsigned int old_mode = hook->mute_mode;
2693
2694 hook->mute_mode = ucontrol->value.enumerated.item[0];
2695 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2696 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2697 if (old_mode == hook->mute_mode)
2698 return 0;
2699 snd_hda_sync_vmaster_hook(hook);
2700 return 1;
2701}
2702
2703static struct snd_kcontrol_new vmaster_mute_mode = {
2704 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2705 .name = "Mute-LED Mode",
2706 .info = vmaster_mute_mode_info,
2707 .get = vmaster_mute_mode_get,
2708 .put = vmaster_mute_mode_put,
2709};
2710
95a962c3
TI		 2711/**
2712 * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
2713 * @codec: the HDA codec
2714 * @hook: the vmaster hook object
2715 * @expose_enum_ctl: flag to create an enum ctl
2716 *
2717 * Add a mute-LED hook with the given vmaster switch kctl.
2718 * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
2719 * created and associated with the given hook.
d2f344b5
TI		 2720 */
2721int snd_hda_add_vmaster_hook(struct hda_codec *codec,
f29735cb
TI		 2722 struct hda_vmaster_mute_hook *hook,
2723 bool expose_enum_ctl)
d2f344b5
TI		 2724{
2725 struct snd_kcontrol *kctl;
2726
2727 if (!hook->hook || !hook->sw_kctl)
2728 return 0;
2729 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2730 hook->codec = codec;
2731 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
f29735cb
TI		 2732 if (!expose_enum_ctl)
2733 return 0;
d2f344b5
TI		 2734 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2735 if (!kctl)
2736 return -ENOMEM;
2737 return snd_hda_ctl_add(codec, 0, kctl);
2738}
2698ea98 2739EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
d2f344b5 2740
95a962c3
TI		 2741/**
2742 * snd_hda_sync_vmaster_hook - Sync vmaster hook
2743 * @hook: the vmaster hook
2744 *
2745 * Call the hook with the current value for synchronization.
2746 * Should be called in init callback.
d2f344b5
TI		 2747 */
2748void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2749{
2750 if (!hook->hook || !hook->codec)
2751 return;
594813ff
TI		 2752 /* don't call vmaster hook in the destructor since it might have
2753 * been already destroyed
2754 */
2755 if (hook->codec->bus->shutdown)
2756 return;
d2f344b5
TI		 2757 switch (hook->mute_mode) {
2758 case HDA_VMUTE_FOLLOW_MASTER:
2759 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2760 break;
2761 default:
2762 hook->hook(hook->codec, hook->mute_mode);
2763 break;
2764 }
2765}
2698ea98 2766EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
d2f344b5
TI		 2767
2768
d5191e50
TI		 2769/**
2770 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
a11e9b16
TI		 2771 * @kcontrol: referred ctl element
2772 * @uinfo: pointer to get/store the data
d5191e50
TI		 2773 *
2774 * The control element is supposed to have the private_value field
2775 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2776 */
0ba21762
TI		 2777int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2778 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 2779{
2780 int chs = get_amp_channels(kcontrol);
2781
2782 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2783 uinfo->count = chs == 3 ? 2 : 1;
2784 uinfo->value.integer.min = 0;
2785 uinfo->value.integer.max = 1;
2786 return 0;
2787}
2698ea98 2788EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
1da177e4 2789
d5191e50
TI		 2790/**
2791 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
a11e9b16
TI		 2792 * @kcontrol: ctl element
2793 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2794 *
2795 * The control element is supposed to have the private_value field
2796 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2797 */
0ba21762
TI		 2798int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2799 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2800{
2801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2802 hda_nid_t nid = get_amp_nid(kcontrol);
2803 int chs = get_amp_channels(kcontrol);
2804 int dir = get_amp_direction(kcontrol);
2805 int idx = get_amp_index(kcontrol);
2806 long *valp = ucontrol->value.integer.value;
2807
2808 if (chs & 1)
0ba21762 2809 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 2810 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 2811 if (chs & 2)
0ba21762 2812 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 2813 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 2814 return 0;
2815}
2698ea98 2816EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
1da177e4 2817
d5191e50
TI		 2818/**
2819 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
a11e9b16
TI		 2820 * @kcontrol: ctl element
2821 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2822 *
2823 * The control element is supposed to have the private_value field
2824 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2825 */
0ba21762
TI		 2826int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2827 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2828{
2829 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2830 hda_nid_t nid = get_amp_nid(kcontrol);
2831 int chs = get_amp_channels(kcontrol);
2832 int dir = get_amp_direction(kcontrol);
2833 int idx = get_amp_index(kcontrol);
1da177e4
LT		 2834 long *valp = ucontrol->value.integer.value;
2835 int change = 0;
2836
b9f5a89c 2837 if (chs & 1) {
781c7b96
TI		 2838 change = codec_amp_update(codec, nid, 0, dir, idx,
2839 HDA_AMP_MUTE,
2840 *valp ? 0 : HDA_AMP_MUTE, false,
2841 !hda_codec_is_power_on(codec));
b9f5a89c
NG		 2842 valp++;
2843 }
4a19faee 2844 if (chs & 2)
781c7b96
TI		 2845 change |= codec_amp_update(codec, nid, 1, dir, idx,
2846 HDA_AMP_MUTE,
2847 *valp ? 0 : HDA_AMP_MUTE, false,
2848 !hda_codec_is_power_on(codec));
9e5341b9 2849 hda_call_check_power_status(codec, nid);
1da177e4
LT		 2850 return change;
2851}
2698ea98 2852EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
1da177e4 2853
985be54b
TI		 2854/*
2855 * bound volume controls
2856 *
2857 * bind multiple volumes (# indices, from 0)
2858 */
2859
2860#define AMP_VAL_IDX_SHIFT 19
2861#define AMP_VAL_IDX_MASK (0x0f<<19)
2862
d5191e50
TI		 2863/**
2864 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
a11e9b16
TI		 2865 * @kcontrol: ctl element
2866 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2867 *
2868 * The control element is supposed to have the private_value field
2869 * set up via HDA_BIND_MUTE*() macros.
2870 */
0ba21762
TI		 2871int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2872 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2873{
2874 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2875 unsigned long pval;
2876 int err;
2877
5a9e02e9 2878 mutex_lock(&codec->control_mutex);
985be54b
TI		 2879 pval = kcontrol->private_value;
2880 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2881 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2882 kcontrol->private_value = pval;
5a9e02e9 2883 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2884 return err;
2885}
2698ea98 2886EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
985be54b 2887
d5191e50
TI		 2888/**
2889 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
a11e9b16
TI		 2890 * @kcontrol: ctl element
2891 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2892 *
2893 * The control element is supposed to have the private_value field
2894 * set up via HDA_BIND_MUTE*() macros.
2895 */
0ba21762
TI		 2896int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2897 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 2898{
2899 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2900 unsigned long pval;
2901 int i, indices, err = 0, change = 0;
2902
5a9e02e9 2903 mutex_lock(&codec->control_mutex);
985be54b
TI		 2904 pval = kcontrol->private_value;
2905 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2906 for (i = 0; i < indices; i++) {
0ba21762
TI		 2907 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2908 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 2909 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2910 if (err < 0)
2911 break;
2912 change |= err;
2913 }
2914 kcontrol->private_value = pval;
5a9e02e9 2915 mutex_unlock(&codec->control_mutex);
985be54b
TI		 2916 return err < 0 ? err : change;
2917}
2698ea98 2918EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
985be54b 2919
d5191e50
TI		 2920/**
2921 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
a11e9b16
TI		 2922 * @kcontrol: referred ctl element
2923 * @uinfo: pointer to get/store the data
d5191e50
TI		 2924 *
2925 * The control element is supposed to have the private_value field
2926 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
532d5381
TI		 2927 */
2928int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2929 struct snd_ctl_elem_info *uinfo)
2930{
2931 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2932 struct hda_bind_ctls *c;
2933 int err;
2934
5a9e02e9 2935 mutex_lock(&codec->control_mutex);
14c65f98 2936 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2937 kcontrol->private_value = *c->values;
2938 err = c->ops->info(kcontrol, uinfo);
2939 kcontrol->private_value = (long)c;
5a9e02e9 2940 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2941 return err;
2942}
2698ea98 2943EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
532d5381 2944
d5191e50
TI		 2945/**
2946 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
a11e9b16
TI		 2947 * @kcontrol: ctl element
2948 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2949 *
2950 * The control element is supposed to have the private_value field
2951 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2952 */
532d5381
TI		 2953int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2954 struct snd_ctl_elem_value *ucontrol)
2955{
2956 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2957 struct hda_bind_ctls *c;
2958 int err;
2959
5a9e02e9 2960 mutex_lock(&codec->control_mutex);
14c65f98 2961 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2962 kcontrol->private_value = *c->values;
2963 err = c->ops->get(kcontrol, ucontrol);
2964 kcontrol->private_value = (long)c;
5a9e02e9 2965 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2966 return err;
2967}
2698ea98 2968EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
532d5381 2969
d5191e50
TI		 2970/**
2971 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
a11e9b16
TI		 2972 * @kcontrol: ctl element
2973 * @ucontrol: pointer to get/store the data
d5191e50
TI		 2974 *
2975 * The control element is supposed to have the private_value field
2976 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2977 */
532d5381
TI		 2978int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2979 struct snd_ctl_elem_value *ucontrol)
2980{
2981 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2982 struct hda_bind_ctls *c;
2983 unsigned long *vals;
2984 int err = 0, change = 0;
2985
5a9e02e9 2986 mutex_lock(&codec->control_mutex);
14c65f98 2987 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 2988 for (vals = c->values; *vals; vals++) {
2989 kcontrol->private_value = *vals;
2990 err = c->ops->put(kcontrol, ucontrol);
2991 if (err < 0)
2992 break;
2993 change |= err;
2994 }
2995 kcontrol->private_value = (long)c;
5a9e02e9 2996 mutex_unlock(&codec->control_mutex);
532d5381
TI		 2997 return err < 0 ? err : change;
2998}
2698ea98 2999EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
532d5381 3000
d5191e50
TI		 3001/**
3002 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
a11e9b16
TI		 3003 * @kcontrol: ctl element
3004 * @op_flag: operation flag
3005 * @size: byte size of input TLV
3006 * @tlv: TLV data
d5191e50
TI		 3007 *
3008 * The control element is supposed to have the private_value field
3009 * set up via HDA_BIND_VOL() macro.
3010 */
532d5381
TI		 3011int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3012 unsigned int size, unsigned int __user *tlv)
3013{
3014 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3015 struct hda_bind_ctls *c;
3016 int err;
3017
5a9e02e9 3018 mutex_lock(&codec->control_mutex);
14c65f98 3019 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 3020 kcontrol->private_value = *c->values;
3021 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3022 kcontrol->private_value = (long)c;
5a9e02e9 3023 mutex_unlock(&codec->control_mutex);
532d5381
TI		 3024 return err;
3025}
2698ea98 3026EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
532d5381
TI		 3027
3028struct hda_ctl_ops snd_hda_bind_vol = {
3029 .info = snd_hda_mixer_amp_volume_info,
3030 .get = snd_hda_mixer_amp_volume_get,
3031 .put = snd_hda_mixer_amp_volume_put,
3032 .tlv = snd_hda_mixer_amp_tlv
3033};
2698ea98 3034EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
532d5381
TI		 3035
3036struct hda_ctl_ops snd_hda_bind_sw = {
3037 .info = snd_hda_mixer_amp_switch_info,
3038 .get = snd_hda_mixer_amp_switch_get,
3039 .put = snd_hda_mixer_amp_switch_put,
3040 .tlv = snd_hda_mixer_amp_tlv
3041};
2698ea98 3042EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
532d5381 3043
1da177e4
LT		 3044/*
3045 * SPDIF out controls
3046 */
3047
0ba21762
TI		 3048static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3049 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3050{
3051 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3052 uinfo->count = 1;
3053 return 0;
3054}
3055
0ba21762
TI		 3056static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3057 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3058{
3059 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3060 IEC958_AES0_NONAUDIO |
3061 IEC958_AES0_CON_EMPHASIS_5015 |
3062 IEC958_AES0_CON_NOT_COPYRIGHT;
3063 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3064 IEC958_AES1_CON_ORIGINAL;
3065 return 0;
3066}
3067
0ba21762
TI		 3068static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3069 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3070{
3071 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3072 IEC958_AES0_NONAUDIO |
3073 IEC958_AES0_PRO_EMPHASIS_5015;
3074 return 0;
3075}
3076
0ba21762
TI		 3077static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3078 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3079{
3080 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3081 int idx = kcontrol->private_value;
e3245cdd 3082 struct hda_spdif_out *spdif;
1da177e4 3083
e3245cdd
TI		 3084 mutex_lock(&codec->spdif_mutex);
3085 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976
SW		 3086 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3087 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3088 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3089 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
e3245cdd 3090 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3091
3092 return 0;
3093}
3094
3095/* convert from SPDIF status bits to HDA SPDIF bits
3096 * bit 0 (DigEn) is always set zero (to be filled later)
3097 */
3098static unsigned short convert_from_spdif_status(unsigned int sbits)
3099{
3100 unsigned short val = 0;
3101
3102 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 3103 val |= AC_DIG1_PROFESSIONAL;
1da177e4 3104 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 3105 val |= AC_DIG1_NONAUDIO;
1da177e4 3106 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 3107 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3108 IEC958_AES0_PRO_EMPHASIS_5015)
3109 val |= AC_DIG1_EMPHASIS;
1da177e4 3110 } else {
0ba21762
TI		 3111 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3112 IEC958_AES0_CON_EMPHASIS_5015)
3113 val |= AC_DIG1_EMPHASIS;
3114 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3115 val |= AC_DIG1_COPYRIGHT;
1da177e4 3116 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 3117 val |= AC_DIG1_LEVEL;
1da177e4
LT		 3118 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3119 }
3120 return val;
3121}
3122
3123/* convert to SPDIF status bits from HDA SPDIF bits
3124 */
3125static unsigned int convert_to_spdif_status(unsigned short val)
3126{
3127 unsigned int sbits = 0;
3128
0ba21762 3129 if (val & AC_DIG1_NONAUDIO)
1da177e4 3130 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 3131 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 3132 sbits |= IEC958_AES0_PROFESSIONAL;
3133 if (sbits & IEC958_AES0_PROFESSIONAL) {
a686fd14 3134 if (val & AC_DIG1_EMPHASIS)
1da177e4
LT		 3135 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3136 } else {
0ba21762 3137 if (val & AC_DIG1_EMPHASIS)
1da177e4 3138 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 3139 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 3140 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 3141 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 3142 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3143 sbits |= val & (0x7f << 8);
3144 }
3145 return sbits;
3146}
3147
2f72853c
TI		 3148/* set digital convert verbs both for the given NID and its slaves */
3149static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3150 int verb, int val)
3151{
dda14410 3152 const hda_nid_t *d;
2f72853c 3153
9e976976 3154 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 3155 d = codec->slave_dig_outs;
3156 if (!d)
3157 return;
3158 for (; *d; d++)
9e976976 3159 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 3160}
3161
3162static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3163 int dig1, int dig2)
3164{
3165 if (dig1 != -1)
3166 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3167 if (dig2 != -1)
3168 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3169}
3170
0ba21762
TI		 3171static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3172 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3173{
3174 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3175 int idx = kcontrol->private_value;
e3245cdd
TI		 3176 struct hda_spdif_out *spdif;
3177 hda_nid_t nid;
1da177e4
LT		 3178 unsigned short val;
3179 int change;
3180
62932df8 3181 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3182 spdif = snd_array_elem(&codec->spdif_out, idx);
3183 nid = spdif->nid;
7c935976 3184 spdif->status = ucontrol->value.iec958.status[0] |
1da177e4
LT		 3185 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3186 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3187 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
7c935976
SW		 3188 val = convert_from_spdif_status(spdif->status);
3189 val |= spdif->ctls & 1;
3190 change = spdif->ctls != val;
3191 spdif->ctls = val;
74b654c9 3192 if (change && nid != (u16)-1)
2f72853c 3193 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
62932df8 3194 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3195 return change;
3196}
3197
a5ce8890 3198#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 3199
0ba21762
TI		 3200static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3201 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3202{
3203 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3204 int idx = kcontrol->private_value;
e3245cdd 3205 struct hda_spdif_out *spdif;
1da177e4 3206
e3245cdd
TI		 3207 mutex_lock(&codec->spdif_mutex);
3208 spdif = snd_array_elem(&codec->spdif_out, idx);
7c935976 3209 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
e3245cdd 3210 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3211 return 0;
3212}
3213
74b654c9
SW		 3214static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3215 int dig1, int dig2)
3216{
3217 set_dig_out_convert(codec, nid, dig1, dig2);
3218 /* unmute amp switch (if any) */
3219 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3220 (dig1 & AC_DIG1_ENABLE))
3221 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3222 HDA_AMP_MUTE, 0);
3223}
3224
0ba21762
TI		 3225static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3226 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3227{
3228 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
7c935976 3229 int idx = kcontrol->private_value;
e3245cdd
TI		 3230 struct hda_spdif_out *spdif;
3231 hda_nid_t nid;
1da177e4
LT		 3232 unsigned short val;
3233 int change;
3234
62932df8 3235 mutex_lock(&codec->spdif_mutex);
e3245cdd
TI		 3236 spdif = snd_array_elem(&codec->spdif_out, idx);
3237 nid = spdif->nid;
7c935976 3238 val = spdif->ctls & ~AC_DIG1_ENABLE;
1da177e4 3239 if (ucontrol->value.integer.value[0])
0ba21762 3240 val |= AC_DIG1_ENABLE;
7c935976 3241 change = spdif->ctls != val;
74b654c9
SW		 3242 spdif->ctls = val;
3243 if (change && nid != (u16)-1)
3244 set_spdif_ctls(codec, nid, val & 0xff, -1);
62932df8 3245 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3246 return change;
3247}
3248
c8b6bf9b 3249static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 3250 {
3251 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3252 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3253 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
1da177e4
LT		 3254 .info = snd_hda_spdif_mask_info,
3255 .get = snd_hda_spdif_cmask_get,
3256 },
3257 {
3258 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3259 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3260 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
1da177e4
LT		 3261 .info = snd_hda_spdif_mask_info,
3262 .get = snd_hda_spdif_pmask_get,
3263 },
3264 {
3265 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3266 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1da177e4
LT		 3267 .info = snd_hda_spdif_mask_info,
3268 .get = snd_hda_spdif_default_get,
3269 .put = snd_hda_spdif_default_put,
3270 },
3271 {
3272 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3273 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1da177e4
LT		 3274 .info = snd_hda_spdif_out_switch_info,
3275 .get = snd_hda_spdif_out_switch_get,
3276 .put = snd_hda_spdif_out_switch_put,
3277 },
3278 { } /* end */
3279};
3280
3281/**
dcda5806 3282 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
1da177e4 3283 * @codec: the HDA codec
dcda5806
TI		 3284 * @associated_nid: NID that new ctls associated with
3285 * @cvt_nid: converter NID
3286 * @type: HDA_PCM_TYPE_*
3287 * Creates controls related with the digital output.
3288 * Called from each patch supporting the digital out.
1da177e4
LT		 3289 *
3290 * Returns 0 if successful, or a negative error code.
3291 */
dcda5806
TI		 3292int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3293 hda_nid_t associated_nid,
3294 hda_nid_t cvt_nid,
3295 int type)
1da177e4
LT		 3296{
3297 int err;
c8b6bf9b
TI		 3298 struct snd_kcontrol *kctl;
3299 struct snd_kcontrol_new *dig_mix;
ea9b43ad
TI		 3300 int idx = 0;
3301 const int spdif_index = 16;
7c935976 3302 struct hda_spdif_out *spdif;
ea9b43ad 3303 struct hda_bus *bus = codec->bus;
1da177e4 3304
ea9b43ad 3305 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
dcda5806 3306 type == HDA_PCM_TYPE_SPDIF) {
ea9b43ad
TI		 3307 idx = spdif_index;
3308 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
dcda5806 3309 type == HDA_PCM_TYPE_HDMI) {
ea9b43ad
TI		 3310 /* suppose a single SPDIF device */
3311 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3312 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3313 if (!kctl)
3314 break;
3315 kctl->id.index = spdif_index;
dcda5806 3316 }
ea9b43ad 3317 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
dcda5806 3318 }
ea9b43ad
TI		 3319 if (!bus->primary_dig_out_type)
3320 bus->primary_dig_out_type = type;
dcda5806 3321
ea9b43ad 3322 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
1afe206a 3323 if (idx < 0) {
4e76a883 3324 codec_err(codec, "too many IEC958 outputs\n");
09f99701
TI		 3325 return -EBUSY;
3326 }
7c935976 3327 spdif = snd_array_new(&codec->spdif_out);
25336e8a
ML		 3328 if (!spdif)
3329 return -ENOMEM;
1da177e4
LT		 3330 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3331 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 3332 if (!kctl)
3333 return -ENOMEM;
09f99701 3334 kctl->id.index = idx;
7c935976 3335 kctl->private_value = codec->spdif_out.used - 1;
74b654c9 3336 err = snd_hda_ctl_add(codec, associated_nid, kctl);
0ba21762 3337 if (err < 0)
1da177e4
LT		 3338 return err;
3339 }
74b654c9
SW		 3340 spdif->nid = cvt_nid;
3341 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
7c935976
SW		 3342 AC_VERB_GET_DIGI_CONVERT_1, 0);
3343 spdif->status = convert_to_spdif_status(spdif->ctls);
1da177e4
LT		 3344 return 0;
3345}
2698ea98 3346EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
1da177e4 3347
95a962c3
TI		 3348/**
3349 * snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
3350 * @codec: the HDA codec
3351 * @nid: widget NID
3352 *
e3245cdd
TI		 3353 * call within spdif_mutex lock
3354 */
7c935976
SW		 3355struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3356 hda_nid_t nid)
3357{
3358 int i;
3359 for (i = 0; i < codec->spdif_out.used; i++) {
3360 struct hda_spdif_out *spdif =
3361 snd_array_elem(&codec->spdif_out, i);
3362 if (spdif->nid == nid)
3363 return spdif;
3364 }
3365 return NULL;
3366}
2698ea98 3367EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
7c935976 3368
95a962c3
TI		 3369/**
3370 * snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
3371 * @codec: the HDA codec
3372 * @idx: the SPDIF ctl index
3373 *
3374 * Unassign the widget from the given SPDIF control.
3375 */
74b654c9
SW		 3376void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3377{
e3245cdd 3378 struct hda_spdif_out *spdif;
74b654c9
SW		 3379
3380 mutex_lock(&codec->spdif_mutex);
e3245cdd 3381 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3382 spdif->nid = (u16)-1;
3383 mutex_unlock(&codec->spdif_mutex);
3384}
2698ea98 3385EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
74b654c9 3386
95a962c3
TI		 3387/**
3388 * snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
3389 * @codec: the HDA codec
3390 * @idx: the SPDIF ctl idx
3391 * @nid: widget NID
3392 *
3393 * Assign the widget to the SPDIF control with the given index.
3394 */
74b654c9
SW		 3395void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3396{
e3245cdd 3397 struct hda_spdif_out *spdif;
74b654c9
SW		 3398 unsigned short val;
3399
3400 mutex_lock(&codec->spdif_mutex);
e3245cdd 3401 spdif = snd_array_elem(&codec->spdif_out, idx);
74b654c9
SW		 3402 if (spdif->nid != nid) {
3403 spdif->nid = nid;
3404 val = spdif->ctls;
3405 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3406 }
3407 mutex_unlock(&codec->spdif_mutex);
3408}
2698ea98 3409EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
74b654c9 3410
9a08160b
TI		 3411/*
3412 * SPDIF sharing with analog output
3413 */
3414static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3415 struct snd_ctl_elem_value *ucontrol)
3416{
3417 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3418 ucontrol->value.integer.value[0] = mout->share_spdif;
3419 return 0;
3420}
3421
3422static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3423 struct snd_ctl_elem_value *ucontrol)
3424{
3425 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3426 mout->share_spdif = !!ucontrol->value.integer.value[0];
3427 return 0;
3428}
3429
3430static struct snd_kcontrol_new spdif_share_sw = {
3431 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3432 .name = "IEC958 Default PCM Playback Switch",
3433 .info = snd_ctl_boolean_mono_info,
3434 .get = spdif_share_sw_get,
3435 .put = spdif_share_sw_put,
3436};
3437
d5191e50
TI		 3438/**
3439 * snd_hda_create_spdif_share_sw - create Default PCM switch
3440 * @codec: the HDA codec
3441 * @mout: multi-out instance
3442 */
9a08160b
TI		 3443int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3444 struct hda_multi_out *mout)
3445{
4c7a548a
ML		 3446 struct snd_kcontrol *kctl;
3447
9a08160b
TI		 3448 if (!mout->dig_out_nid)
3449 return 0;
4c7a548a
ML		 3450
3451 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3452 if (!kctl)
3453 return -ENOMEM;
9a08160b 3454 /* ATTENTION: here mout is passed as private_data, instead of codec */
4c7a548a 3455 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
9a08160b 3456}
2698ea98 3457EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
9a08160b 3458
1da177e4
LT		 3459/*
3460 * SPDIF input
3461 */
3462
3463#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3464
0ba21762
TI		 3465static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3466 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3467{
3468 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3469
3470 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3471 return 0;
3472}
3473
0ba21762
TI		 3474static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3475 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3476{
3477 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3478 hda_nid_t nid = kcontrol->private_value;
3479 unsigned int val = !!ucontrol->value.integer.value[0];
3480 int change;
3481
62932df8 3482 mutex_lock(&codec->spdif_mutex);
1da177e4 3483 change = codec->spdif_in_enable != val;
82beb8fd 3484 if (change) {
1da177e4 3485 codec->spdif_in_enable = val;
82beb8fd
TI		 3486 snd_hda_codec_write_cache(codec, nid, 0,
3487 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 3488 }
62932df8 3489 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3490 return change;
3491}
3492
0ba21762
TI		 3493static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3494 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 3495{
3496 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3497 hda_nid_t nid = kcontrol->private_value;
3498 unsigned short val;
3499 unsigned int sbits;
3500
3982d17e 3501 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 3502 sbits = convert_to_spdif_status(val);
3503 ucontrol->value.iec958.status[0] = sbits;
3504 ucontrol->value.iec958.status[1] = sbits >> 8;
3505 ucontrol->value.iec958.status[2] = sbits >> 16;
3506 ucontrol->value.iec958.status[3] = sbits >> 24;
3507 return 0;
3508}
3509
c8b6bf9b 3510static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 3511 {
3512 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3513 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
1da177e4
LT		 3514 .info = snd_hda_spdif_in_switch_info,
3515 .get = snd_hda_spdif_in_switch_get,
3516 .put = snd_hda_spdif_in_switch_put,
3517 },
3518 {
3519 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3520 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
28aedaf7 3521 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1da177e4
LT		 3522 .info = snd_hda_spdif_mask_info,
3523 .get = snd_hda_spdif_in_status_get,
3524 },
3525 { } /* end */
3526};
3527
3528/**
3529 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3530 * @codec: the HDA codec
3531 * @nid: audio in widget NID
3532 *
3533 * Creates controls related with the SPDIF input.
3534 * Called from each patch supporting the SPDIF in.
3535 *
3536 * Returns 0 if successful, or a negative error code.
3537 */
12f288bf 3538int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 3539{
3540 int err;
c8b6bf9b
TI		 3541 struct snd_kcontrol *kctl;
3542 struct snd_kcontrol_new *dig_mix;
09f99701 3543 int idx;
1da177e4 3544
dcda5806 3545 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
1afe206a 3546 if (idx < 0) {
4e76a883 3547 codec_err(codec, "too many IEC958 inputs\n");
09f99701
TI		 3548 return -EBUSY;
3549 }
1da177e4
LT		 3550 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3551 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 3552 if (!kctl)
3553 return -ENOMEM;
1da177e4 3554 kctl->private_value = nid;
3911a4c1 3555 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 3556 if (err < 0)
1da177e4
LT		 3557 return err;
3558 }
0ba21762 3559 codec->spdif_in_enable =
3982d17e
AP		 3560 snd_hda_codec_read(codec, nid, 0,
3561 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 3562 AC_DIG1_ENABLE;
1da177e4
LT		 3563 return 0;
3564}
2698ea98 3565EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
1da177e4 3566
82beb8fd
TI		 3567/*
3568 * command cache
3569 */
1da177e4 3570
c370dd6e 3571/* build a 31bit cache key with the widget id and the command parameter */
b3ac5636
TI		 3572#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3573#define get_cmd_cache_nid(key) ((key) & 0xff)
3574#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3575
3576/**
3577 * snd_hda_codec_write_cache - send a single command with caching
3578 * @codec: the HDA codec
3579 * @nid: NID to send the command
e7ecc27e 3580 * @flags: optional bit flags
b3ac5636
TI		 3581 * @verb: the verb to send
3582 * @parm: the parameter for the verb
3583 *
3584 * Send a single command without waiting for response.
3585 *
3586 * Returns 0 if successful, or a negative error code.
3587 */
3588int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3589 int flags, unsigned int verb, unsigned int parm)
b3ac5636 3590{
c370dd6e 3591 int err;
aa2936f5
TI		 3592 struct hda_cache_head *c;
3593 u32 key;
de1e37b7 3594 unsigned int cache_only;
33fa35ed 3595
de1e37b7
TI		 3596 cache_only = codec->cached_write;
3597 if (!cache_only) {
e7ecc27e 3598 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
c370dd6e
TI		 3599 if (err < 0)
3600 return err;
3601 }
3602
aa2936f5
TI		 3603 /* parm may contain the verb stuff for get/set amp */
3604 verb = verb | (parm >> 8);
3605 parm &= 0xff;
3606 key = build_cmd_cache_key(nid, verb);
3607 mutex_lock(&codec->bus->cmd_mutex);
3608 c = get_alloc_hash(&codec->cmd_cache, key);
c370dd6e 3609 if (c) {
aa2936f5 3610 c->val = parm;
de1e37b7 3611 c->dirty = cache_only;
c370dd6e 3612 }
aa2936f5
TI		 3613 mutex_unlock(&codec->bus->cmd_mutex);
3614 return 0;
b3ac5636 3615}
2698ea98 3616EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
b3ac5636 3617
a68d5a54
TI		 3618/**
3619 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3620 * @codec: the HDA codec
3621 * @nid: NID to send the command
e7ecc27e 3622 * @flags: optional bit flags
a68d5a54
TI		 3623 * @verb: the verb to send
3624 * @parm: the parameter for the verb
3625 *
3626 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3627 * command if the parameter is already identical with the cached value.
3628 * If not, it sends the command and refreshes the cache.
3629 *
3630 * Returns 0 if successful, or a negative error code.
3631 */
3632int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
e7ecc27e 3633 int flags, unsigned int verb, unsigned int parm)
a68d5a54
TI		 3634{
3635 struct hda_cache_head *c;
3636 u32 key;
3637
3638 /* parm may contain the verb stuff for get/set amp */
3639 verb = verb | (parm >> 8);
3640 parm &= 0xff;
3641 key = build_cmd_cache_key(nid, verb);
3642 mutex_lock(&codec->bus->cmd_mutex);
3643 c = get_hash(&codec->cmd_cache, key);
3644 if (c && c->val == parm) {
3645 mutex_unlock(&codec->bus->cmd_mutex);
3646 return 0;
3647 }
3648 mutex_unlock(&codec->bus->cmd_mutex);
e7ecc27e 3649 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
a68d5a54 3650}
2698ea98 3651EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
a68d5a54 3652
d5191e50
TI		 3653/**
3654 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3655 * @codec: HD-audio codec
3656 *
3657 * Execute all verbs recorded in the command caches to resume.
3658 */
b3ac5636
TI		 3659void snd_hda_codec_resume_cache(struct hda_codec *codec)
3660{
b3ac5636
TI		 3661 int i;
3662
c370dd6e 3663 mutex_lock(&codec->hash_mutex);
aa88a355 3664 codec->cached_write = 0;
c370dd6e
TI		 3665 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3666 struct hda_cache_head *buffer;
3667 u32 key;
3668
3669 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3670 key = buffer->key;
b3ac5636
TI		 3671 if (!key)
3672 continue;
c370dd6e
TI		 3673 if (!buffer->dirty)
3674 continue;
3675 buffer->dirty = 0;
3676 mutex_unlock(&codec->hash_mutex);
b3ac5636
TI		 3677 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3678 get_cmd_cache_cmd(key), buffer->val);
c370dd6e 3679 mutex_lock(&codec->hash_mutex);
b3ac5636 3680 }
c370dd6e 3681 mutex_unlock(&codec->hash_mutex);
b3ac5636 3682}
2698ea98 3683EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
b3ac5636
TI		 3684
3685/**
3686 * snd_hda_sequence_write_cache - sequence writes with caching
3687 * @codec: the HDA codec
3688 * @seq: VERB array to send
3689 *
3690 * Send the commands sequentially from the given array.
3691 * Thte commands are recorded on cache for power-save and resume.
3692 * The array must be terminated with NID=0.
3693 */
3694void snd_hda_sequence_write_cache(struct hda_codec *codec,
3695 const struct hda_verb *seq)
3696{
3697 for (; seq->nid; seq++)
3698 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3699 seq->param);
3700}
2698ea98 3701EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
b3ac5636 3702
dc870f38
TI		 3703/**
3704 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3705 * @codec: HD-audio codec
3706 */
3707void snd_hda_codec_flush_cache(struct hda_codec *codec)
3708{
3709 snd_hda_codec_resume_amp(codec);
3710 snd_hda_codec_resume_cache(codec);
3711}
2698ea98 3712EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
dc870f38 3713
95a962c3
TI		 3714/**
3715 * snd_hda_codec_set_power_to_all - Set the power state to all widgets
3716 * @codec: the HDA codec
3717 * @fg: function group (not used now)
3718 * @power_state: the power state to set (AC_PWRST_*)
3719 *
3720 * Set the given power state to all widgets that have the power control.
3721 * If the codec has power_filter set, it evaluates the power state and
3722 * filter out if it's unchanged as D3.
3723 */
4d7fbdbc 3724void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
9419ab6b 3725 unsigned int power_state)
54d17403 3726{
4d7fbdbc 3727 hda_nid_t nid = codec->start_nid;
cb53c626 3728 int i;
54d17403 3729
cb53c626 3730 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d 3731 unsigned int wcaps = get_wcaps(codec, nid);
9419ab6b 3732 unsigned int state = power_state;
4d7fbdbc
TI		 3733 if (!(wcaps & AC_WCAP_POWER))
3734 continue;
9419ab6b
TI		 3735 if (codec->power_filter) {
3736 state = codec->power_filter(codec, nid, power_state);
3737 if (state != power_state && power_state == AC_PWRST_D3)
4d7fbdbc 3738 continue;
1194b5b7 3739 }
4d7fbdbc 3740 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
9419ab6b 3741 state);
54d17403 3742 }
cb53c626 3743}
2698ea98 3744EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
4d7fbdbc 3745
0c7f46ad
WX		 3746/*
3747 * supported power states check
3748 */
3749static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3750 unsigned int power_state)
3751{
3752 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3753
e037cb4a 3754 if (sup == -1)
0c7f46ad
WX		 3755 return false;
3756 if (sup & power_state)
3757 return true;
3758 else
3759 return false;
3760}
3761
432c641e
TI		 3762/*
3763 * wait until the state is reached, returns the current state
3764 */
3765static unsigned int hda_sync_power_state(struct hda_codec *codec,
3766 hda_nid_t fg,
3767 unsigned int power_state)
3768{
3769 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3770 unsigned int state, actual_state;
3771
3772 for (;;) {
3773 state = snd_hda_codec_read(codec, fg, 0,
3774 AC_VERB_GET_POWER_STATE, 0);
3775 if (state & AC_PWRST_ERROR)
3776 break;
3777 actual_state = (state >> 4) & 0x0f;
3778 if (actual_state == power_state)
3779 break;
3780 if (time_after_eq(jiffies, end_time))
3781 break;
3782 /* wait until the codec reachs to the target state */
3783 msleep(1);
3784 }
3785 return state;
3786}
3787
95a962c3
TI		 3788/**
3789 * snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
3790 * @codec: the HDA codec
3791 * @nid: widget NID
3792 * @power_state: power state to evalue
3793 *
3794 * Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
3795 * This can be used a codec power_filter callback.
3796 */
ba615b86
TI		 3797unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3798 hda_nid_t nid,
3799 unsigned int power_state)
9419ab6b 3800{
dfc6e469
TI		 3801 if (nid == codec->afg || nid == codec->mfg)
3802 return power_state;
9419ab6b
TI		 3803 if (power_state == AC_PWRST_D3 &&
3804 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3805 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3806 int eapd = snd_hda_codec_read(codec, nid, 0,
3807 AC_VERB_GET_EAPD_BTLENABLE, 0);
3808 if (eapd & 0x02)
3809 return AC_PWRST_D0;
3810 }
3811 return power_state;
3812}
2698ea98 3813EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
9419ab6b 3814
4d7fbdbc 3815/*
08fa20ae 3816 * set power state of the codec, and return the power state
4d7fbdbc 3817 */
d819387e 3818static unsigned int hda_set_power_state(struct hda_codec *codec,
08fa20ae 3819 unsigned int power_state)
4d7fbdbc 3820{
d819387e 3821 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
09617ce4
WX		 3822 int count;
3823 unsigned int state;
63e51fd7 3824 int flags = 0;
09617ce4 3825
4d7fbdbc 3826 /* this delay seems necessary to avoid click noise at power-down */
0f4ccbb0 3827 if (power_state == AC_PWRST_D3) {
7f132927
ML		 3828 if (codec->depop_delay < 0)
3829 msleep(codec->epss ? 10 : 100);
3830 else if (codec->depop_delay > 0)
3831 msleep(codec->depop_delay);
63e51fd7 3832 flags = HDA_RW_NO_RESPONSE_FALLBACK;
0f4ccbb0 3833 }
09617ce4
WX		 3834
3835 /* repeat power states setting at most 10 times*/
3836 for (count = 0; count < 10; count++) {
432c641e
TI		 3837 if (codec->patch_ops.set_power_state)
3838 codec->patch_ops.set_power_state(codec, fg,
3839 power_state);
3840 else {
dfc6e469
TI		 3841 state = power_state;
3842 if (codec->power_filter)
3843 state = codec->power_filter(codec, fg, state);
3844 if (state == power_state || power_state != AC_PWRST_D3)
3845 snd_hda_codec_read(codec, fg, flags,
3846 AC_VERB_SET_POWER_STATE,
3847 state);
9419ab6b 3848 snd_hda_codec_set_power_to_all(codec, fg, power_state);
432c641e
TI		 3849 }
3850 state = hda_sync_power_state(codec, fg, power_state);
09617ce4
WX		 3851 if (!(state & AC_PWRST_ERROR))
3852 break;
3853 }
b8dfc462 3854
08fa20ae 3855 return state;
4d7fbdbc 3856}
cb53c626 3857
b9c590bb
TI		 3858/* sync power states of all widgets;
3859 * this is called at the end of codec parsing
3860 */
3861static void sync_power_up_states(struct hda_codec *codec)
3862{
3863 hda_nid_t nid = codec->start_nid;
3864 int i;
3865
ba615b86
TI		 3866 /* don't care if no filter is used */
3867 if (!codec->power_filter)
b9c590bb
TI		 3868 return;
3869
3870 for (i = 0; i < codec->num_nodes; i++, nid++) {
3871 unsigned int wcaps = get_wcaps(codec, nid);
9040d102 3872 unsigned int target;
b9c590bb
TI		 3873 if (!(wcaps & AC_WCAP_POWER))
3874 continue;
3875 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3876 if (target == AC_PWRST_D0)
3877 continue;
9040d102 3878 if (!snd_hda_check_power_state(codec, nid, target))
b9c590bb
TI		 3879 snd_hda_codec_write(codec, nid, 0,
3880 AC_VERB_SET_POWER_STATE, target);
3881 }
3882}
3883
648a8d27 3884#ifdef CONFIG_SND_HDA_RECONFIG
11aeff08
TI		 3885/* execute additional init verbs */
3886static void hda_exec_init_verbs(struct hda_codec *codec)
3887{
3888 if (codec->init_verbs.list)
3889 snd_hda_sequence_write(codec, codec->init_verbs.list);
3890}
3891#else
3892static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3893#endif
3894
2a43952a 3895#ifdef CONFIG_PM
cb53c626
TI		 3896/*
3897 * call suspend and power-down; used both from PM and power-save
08fa20ae 3898 * this function returns the power state in the end
cb53c626 3899 */
d17344b3 3900static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
cb53c626 3901{
08fa20ae
TI		 3902 unsigned int state;
3903
989c3187
TI		 3904 codec->in_pm = 1;
3905
cb53c626 3906 if (codec->patch_ops.suspend)
68cb2b55 3907 codec->patch_ops.suspend(codec);
eb541337 3908 hda_cleanup_all_streams(codec);
d819387e 3909 state = hda_set_power_state(codec, AC_PWRST_D3);
d17344b3
DR		 3910 /* Cancel delayed work if we aren't currently running from it. */
3911 if (!in_wq)
3912 cancel_delayed_work_sync(&codec->power_work);
a2d96e77
TI		 3913 spin_lock(&codec->power_lock);
3914 snd_hda_update_power_acct(codec);
3915 trace_hda_power_down(codec);
95e99fda 3916 codec->power_on = 0;
a221e287 3917 codec->power_transition = 0;
a2f6309e 3918 codec->power_jiffies = jiffies;
a2d96e77 3919 spin_unlock(&codec->power_lock);
989c3187 3920 codec->in_pm = 0;
08fa20ae 3921 return state;
54d17403
TI		 3922}
3923
c370dd6e
TI		 3924/* mark all entries of cmd and amp caches dirty */
3925static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3926{
3927 int i;
3928 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3929 struct hda_cache_head *cmd;
3930 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3931 cmd->dirty = 1;
3932 }
3933 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3934 struct hda_amp_info *amp;
f038fcac 3935 amp = snd_array_elem(&codec->amp_cache.buf, i);
c370dd6e
TI		 3936 amp->head.dirty = 1;
3937 }
3938}
3939
cb53c626
TI		 3940/*
3941 * kick up codec; used both from PM and power-save
3942 */
3943static void hda_call_codec_resume(struct hda_codec *codec)
3944{
989c3187
TI		 3945 codec->in_pm = 1;
3946
c370dd6e
TI		 3947 hda_mark_cmd_cache_dirty(codec);
3948
7f30830b
TI		 3949 /* set as if powered on for avoiding re-entering the resume
3950 * in the resume / power-save sequence
3951 */
3952 hda_keep_power_on(codec);
d819387e 3953 hda_set_power_state(codec, AC_PWRST_D0);
ac0547dc 3954 restore_shutup_pins(codec);
11aeff08 3955 hda_exec_init_verbs(codec);
31614bb8 3956 snd_hda_jack_set_dirty_all(codec);
cb53c626
TI		 3957 if (codec->patch_ops.resume)
3958 codec->patch_ops.resume(codec);
3959 else {
9d99f312
TI		 3960 if (codec->patch_ops.init)
3961 codec->patch_ops.init(codec);
cb53c626
TI		 3962 snd_hda_codec_resume_amp(codec);
3963 snd_hda_codec_resume_cache(codec);
3964 }
26a6cb6c
DH		 3965
3966 if (codec->jackpoll_interval)
3967 hda_jackpoll_work(&codec->jackpoll_work.work);
31614bb8 3968 else
26a6cb6c 3969 snd_hda_jack_report_sync(codec);
989c3187
TI		 3970
3971 codec->in_pm = 0;
7f30830b 3972 snd_hda_power_down(codec); /* flag down before returning */
cb53c626 3973}
59ed1ead
TI		 3974
3975static int hda_codec_driver_suspend(struct device *dev)
3976{
3977 struct hda_codec *codec = dev_to_hda_codec(dev);
3978 int i;
3979
3980 cancel_delayed_work_sync(&codec->jackpoll_work);
3981 for (i = 0; i < codec->num_pcms; i++)
3982 snd_pcm_suspend_all(codec->pcm_info[i].pcm);
3983 hda_call_codec_suspend(codec, false);
3984 return 0;
3985}
3986
3987static int hda_codec_driver_resume(struct device *dev)
3988{
3989 hda_call_codec_resume(dev_to_hda_codec(dev));
3990 return 0;
3991}
2a43952a 3992#endif /* CONFIG_PM */
cb53c626 3993
59ed1ead
TI		 3994/* referred in hda_bind.c */
3995const struct dev_pm_ops hda_codec_driver_pm = {
3996 SET_SYSTEM_SLEEP_PM_OPS(hda_codec_driver_suspend,
3997 hda_codec_driver_resume)
3998};
54d17403 3999
1da177e4
LT		 4000/**
4001 * snd_hda_build_controls - build mixer controls
4002 * @bus: the BUS
4003 *
4004 * Creates mixer controls for each codec included in the bus.
4005 *
4006 * Returns 0 if successful, otherwise a negative error code.
4007 */
6a0f56a7 4008int snd_hda_build_controls(struct hda_bus *bus)
1da177e4 4009{
0ba21762 4010 struct hda_codec *codec;
1da177e4 4011
0ba21762 4012 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 4013 int err = snd_hda_codec_build_controls(codec);
f93d461b 4014 if (err < 0) {
4e76a883
TI		 4015 codec_err(codec,
4016 "cannot build controls for #%d (error %d)\n",
4017 codec->addr, err);
f93d461b
TI		 4018 err = snd_hda_codec_reset(codec);
4019 if (err < 0) {
4e76a883
TI		 4020 codec_err(codec,
4021 "cannot revert codec\n");
f93d461b
TI		 4022 return err;
4023 }
4024 }
1da177e4 4025 }
6c1f45ea
TI		 4026 return 0;
4027}
2698ea98 4028EXPORT_SYMBOL_GPL(snd_hda_build_controls);
cb53c626 4029
9c9a5175
TI		 4030/*
4031 * add standard channel maps if not specified
4032 */
4033static int add_std_chmaps(struct hda_codec *codec)
4034{
4035 int i, str, err;
4036
4037 for (i = 0; i < codec->num_pcms; i++) {
4038 for (str = 0; str < 2; str++) {
4039 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4040 struct hda_pcm_stream *hinfo =
4041 &codec->pcm_info[i].stream[str];
4042 struct snd_pcm_chmap *chmap;
ee81abb6 4043 const struct snd_pcm_chmap_elem *elem;
9c9a5175
TI		 4044
4045 if (codec->pcm_info[i].own_chmap)
4046 continue;
4047 if (!pcm || !hinfo->substreams)
4048 continue;
ee81abb6
TI		 4049 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4050 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
9c9a5175
TI		 4051 hinfo->channels_max,
4052 0, &chmap);
4053 if (err < 0)
4054 return err;
4055 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4056 }
4057 }
4058 return 0;
4059}
4060
ee81abb6
TI		 4061/* default channel maps for 2.1 speakers;
4062 * since HD-audio supports only stereo, odd number channels are omitted
4063 */
4064const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4065 { .channels = 2,
4066 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4067 { .channels = 4,
4068 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4069 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4070 { }
4071};
4072EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4073
6c1f45ea
TI		 4074int snd_hda_codec_build_controls(struct hda_codec *codec)
4075{
4076 int err = 0;
11aeff08 4077 hda_exec_init_verbs(codec);
6c1f45ea
TI		 4078 /* continue to initialize... */
4079 if (codec->patch_ops.init)
4080 err = codec->patch_ops.init(codec);
4081 if (!err && codec->patch_ops.build_controls)
4082 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 4083 if (err < 0)
4084 return err;
9c9a5175
TI		 4085
4086 /* we create chmaps here instead of build_pcms */
4087 err = add_std_chmaps(codec);
4088 if (err < 0)
4089 return err;
4090
26a6cb6c
DH		 4091 if (codec->jackpoll_interval)
4092 hda_jackpoll_work(&codec->jackpoll_work.work);
4093 else
4094 snd_hda_jack_report_sync(codec); /* call at the last init point */
b9c590bb 4095 sync_power_up_states(codec);
1da177e4
LT		 4096 return 0;
4097}
4098
1da177e4
LT		 4099/*
4100 * stream formats
4101 */
befdf316
TI		 4102struct hda_rate_tbl {
4103 unsigned int hz;
4104 unsigned int alsa_bits;
4105 unsigned int hda_fmt;
4106};
4107
92f10b3f
TI		 4108/* rate = base * mult / div */
4109#define HDA_RATE(base, mult, div) \
4110 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4111 (((div) - 1) << AC_FMT_DIV_SHIFT))
4112
befdf316 4113static struct hda_rate_tbl rate_bits[] = {
1da177e4 4114 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 4115
4116 /* autodetected value used in snd_hda_query_supported_pcm */
92f10b3f
TI		 4117 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4118 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4119 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4120 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4121 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4122 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4123 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4124 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4125 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4126 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4127 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
a961f9fe
TI		 4128#define AC_PAR_PCM_RATE_BITS 11
4129 /* up to bits 10, 384kHZ isn't supported properly */
4130
4131 /* not autodetected value */
92f10b3f 4132 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
9d8f53f2 4133
befdf316 4134 { 0 } /* terminator */
1da177e4
LT		 4135};
4136
4137/**
4138 * snd_hda_calc_stream_format - calculate format bitset
6194b99d 4139 * @codec: HD-audio codec
1da177e4
LT		 4140 * @rate: the sample rate
4141 * @channels: the number of channels
4142 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4143 * @maxbps: the max. bps
a11e9b16 4144 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant)
1da177e4
LT		 4145 *
4146 * Calculate the format bitset from the given rate, channels and th PCM format.
4147 *
4148 * Return zero if invalid.
4149 */
6194b99d
TI		 4150unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
4151 unsigned int rate,
1da177e4
LT		 4152 unsigned int channels,
4153 unsigned int format,
32c168c8
AH		 4154 unsigned int maxbps,
4155 unsigned short spdif_ctls)
1da177e4
LT		 4156{
4157 int i;
4158 unsigned int val = 0;
4159
befdf316
TI		 4160 for (i = 0; rate_bits[i].hz; i++)
4161 if (rate_bits[i].hz == rate) {
4162 val = rate_bits[i].hda_fmt;
1da177e4
LT		 4163 break;
4164 }
0ba21762 4165 if (!rate_bits[i].hz) {
6194b99d 4166 codec_dbg(codec, "invalid rate %d\n", rate);
1da177e4
LT		 4167 return 0;
4168 }
4169
4170 if (channels == 0 || channels > 8) {
6194b99d 4171 codec_dbg(codec, "invalid channels %d\n", channels);
1da177e4
LT		 4172 return 0;
4173 }
4174 val |= channels - 1;
4175
4176 switch (snd_pcm_format_width(format)) {
28aedaf7 4177 case 8:
92f10b3f 4178 val |= AC_FMT_BITS_8;
28aedaf7
NL		 4179 break;
4180 case 16:
92f10b3f 4181 val |= AC_FMT_BITS_16;
28aedaf7 4182 break;
1da177e4
LT		 4183 case 20:
4184 case 24:
4185 case 32:
b0bb3aa6 4186 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
92f10b3f 4187 val |= AC_FMT_BITS_32;
1da177e4 4188 else if (maxbps >= 24)
92f10b3f 4189 val |= AC_FMT_BITS_24;
1da177e4 4190 else
92f10b3f 4191 val |= AC_FMT_BITS_20;
1da177e4
LT		 4192 break;
4193 default:
6194b99d 4194 codec_dbg(codec, "invalid format width %d\n",
4e76a883 4195 snd_pcm_format_width(format));
1da177e4
LT		 4196 return 0;
4197 }
4198
32c168c8 4199 if (spdif_ctls & AC_DIG1_NONAUDIO)
92f10b3f 4200 val |= AC_FMT_TYPE_NON_PCM;
32c168c8 4201
1da177e4
LT		 4202 return val;
4203}
2698ea98 4204EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
1da177e4 4205
c3b6bcc2
TI		 4206static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4207 int dir)
92c7c8a7
TI		 4208{
4209 unsigned int val = 0;
4210 if (nid != codec->afg &&
4211 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4212 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4213 if (!val || val == -1)
4214 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4215 if (!val || val == -1)
4216 return 0;
4217 return val;
4218}
4219
4220static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4221{
c3b6bcc2 4222 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
92c7c8a7
TI		 4223 get_pcm_param);
4224}
4225
c3b6bcc2
TI		 4226static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4227 int dir)
92c7c8a7
TI		 4228{
4229 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4230 if (!streams || streams == -1)
4231 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4232 if (!streams || streams == -1)
4233 return 0;
4234 return streams;
4235}
4236
4237static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4238{
c3b6bcc2 4239 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
92c7c8a7
TI		 4240 get_stream_param);
4241}
4242
1da177e4
LT		 4243/**
4244 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4245 * @codec: the HDA codec
4246 * @nid: NID to query
4247 * @ratesp: the pointer to store the detected rate bitflags
4248 * @formatsp: the pointer to store the detected formats
4249 * @bpsp: the pointer to store the detected format widths
4250 *
4251 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4252 * or @bsps argument is ignored.
4253 *
4254 * Returns 0 if successful, otherwise a negative error code.
4255 */
384a48d7 4256int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 4257 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4258{
ee504710 4259 unsigned int i, val, wcaps;
1da177e4 4260
ee504710 4261 wcaps = get_wcaps(codec, nid);
92c7c8a7 4262 val = query_pcm_param(codec, nid);
1da177e4
LT		 4263
4264 if (ratesp) {
4265 u32 rates = 0;
a961f9fe 4266 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 4267 if (val & (1 << i))
befdf316 4268 rates |= rate_bits[i].alsa_bits;
1da177e4 4269 }
ee504710 4270 if (rates == 0) {
4e76a883
TI		 4271 codec_err(codec,
4272 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
4273 nid, val,
4274 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
ee504710
JK		 4275 return -EIO;
4276 }
1da177e4
LT		 4277 *ratesp = rates;
4278 }
4279
4280 if (formatsp || bpsp) {
4281 u64 formats = 0;
ee504710 4282 unsigned int streams, bps;
1da177e4 4283
92c7c8a7
TI		 4284 streams = query_stream_param(codec, nid);
4285 if (!streams)
1da177e4 4286 return -EIO;
1da177e4
LT		 4287
4288 bps = 0;
4289 if (streams & AC_SUPFMT_PCM) {
4290 if (val & AC_SUPPCM_BITS_8) {
4291 formats |= SNDRV_PCM_FMTBIT_U8;
4292 bps = 8;
4293 }
4294 if (val & AC_SUPPCM_BITS_16) {
4295 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4296 bps = 16;
4297 }
4298 if (wcaps & AC_WCAP_DIGITAL) {
4299 if (val & AC_SUPPCM_BITS_32)
4300 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4301 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4302 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4303 if (val & AC_SUPPCM_BITS_24)
4304 bps = 24;
4305 else if (val & AC_SUPPCM_BITS_20)
4306 bps = 20;
0ba21762
TI		 4307 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4308 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 4309 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4310 if (val & AC_SUPPCM_BITS_32)
4311 bps = 32;
1da177e4
LT		 4312 else if (val & AC_SUPPCM_BITS_24)
4313 bps = 24;
33ef7651
NG		 4314 else if (val & AC_SUPPCM_BITS_20)
4315 bps = 20;
1da177e4
LT		 4316 }
4317 }
8c7dd890 4318#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
b5025c50 4319 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 4320 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 4321 if (!bps)
4322 bps = 32;
b5025c50 4323 }
8c7dd890 4324#endif
b5025c50 4325 if (streams == AC_SUPFMT_AC3) {
0ba21762 4326 /* should be exclusive */
1da177e4
LT		 4327 /* temporary hack: we have still no proper support
4328 * for the direct AC3 stream...
4329 */
4330 formats |= SNDRV_PCM_FMTBIT_U8;
4331 bps = 8;
4332 }
ee504710 4333 if (formats == 0) {
4e76a883
TI		 4334 codec_err(codec,
4335 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
4336 nid, val,
4337 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4338 streams);
ee504710
JK		 4339 return -EIO;
4340 }
1da177e4
LT		 4341 if (formatsp)
4342 *formatsp = formats;
4343 if (bpsp)
4344 *bpsp = bps;
4345 }
4346
4347 return 0;
4348}
2698ea98 4349EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
1da177e4
LT		 4350
4351/**
d5191e50
TI		 4352 * snd_hda_is_supported_format - Check the validity of the format
4353 * @codec: HD-audio codec
4354 * @nid: NID to check
4355 * @format: the HD-audio format value to check
4356 *
4357 * Check whether the given node supports the format value.
1da177e4
LT		 4358 *
4359 * Returns 1 if supported, 0 if not.
4360 */
4361int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4362 unsigned int format)
4363{
4364 int i;
4365 unsigned int val = 0, rate, stream;
4366
92c7c8a7
TI		 4367 val = query_pcm_param(codec, nid);
4368 if (!val)
4369 return 0;
1da177e4
LT		 4370
4371 rate = format & 0xff00;
a961f9fe 4372 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 4373 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 4374 if (val & (1 << i))
4375 break;
4376 return 0;
4377 }
a961f9fe 4378 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 4379 return 0;
4380
92c7c8a7
TI		 4381 stream = query_stream_param(codec, nid);
4382 if (!stream)
1da177e4
LT		 4383 return 0;
4384
4385 if (stream & AC_SUPFMT_PCM) {
4386 switch (format & 0xf0) {
4387 case 0x00:
0ba21762 4388 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 4389 return 0;
4390 break;
4391 case 0x10:
0ba21762 4392 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 4393 return 0;
4394 break;
4395 case 0x20:
0ba21762 4396 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 4397 return 0;
4398 break;
4399 case 0x30:
0ba21762 4400 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 4401 return 0;
4402 break;
4403 case 0x40:
0ba21762 4404 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 4405 return 0;
4406 break;
4407 default:
4408 return 0;
4409 }
4410 } else {
4411 /* FIXME: check for float32 and AC3? */
4412 }
4413
4414 return 1;
4415}
2698ea98 4416EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
1da177e4
LT		 4417
4418/*
4419 * PCM stuff
4420 */
4421static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4422 struct hda_codec *codec,
c8b6bf9b 4423 struct snd_pcm_substream *substream)
1da177e4
LT		 4424{
4425 return 0;
4426}
4427
4428static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4429 struct hda_codec *codec,
4430 unsigned int stream_tag,
4431 unsigned int format,
c8b6bf9b 4432 struct snd_pcm_substream *substream)
1da177e4
LT		 4433{
4434 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4435 return 0;
4436}
4437
4438static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4439 struct hda_codec *codec,
c8b6bf9b 4440 struct snd_pcm_substream *substream)
1da177e4 4441{
888afa15 4442 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 4443 return 0;
4444}
4445
6c1f45ea
TI		 4446static int set_pcm_default_values(struct hda_codec *codec,
4447 struct hda_pcm_stream *info)
1da177e4 4448{
ee504710
JK		 4449 int err;
4450
0ba21762
TI		 4451 /* query support PCM information from the given NID */
4452 if (info->nid && (!info->rates || !info->formats)) {
ee504710 4453 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 4454 info->rates ? NULL : &info->rates,
4455 info->formats ? NULL : &info->formats,
4456 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 4457 if (err < 0)
4458 return err;
1da177e4
LT		 4459 }
4460 if (info->ops.open == NULL)
4461 info->ops.open = hda_pcm_default_open_close;
4462 if (info->ops.close == NULL)
4463 info->ops.close = hda_pcm_default_open_close;
4464 if (info->ops.prepare == NULL) {
da3cec35
TI		 4465 if (snd_BUG_ON(!info->nid))
4466 return -EINVAL;
1da177e4
LT		 4467 info->ops.prepare = hda_pcm_default_prepare;
4468 }
1da177e4 4469 if (info->ops.cleanup == NULL) {
da3cec35
TI		 4470 if (snd_BUG_ON(!info->nid))
4471 return -EINVAL;
1da177e4
LT		 4472 info->ops.cleanup = hda_pcm_default_cleanup;
4473 }
4474 return 0;
4475}
4476
eb541337
TI		 4477/*
4478 * codec prepare/cleanup entries
4479 */
95a962c3
TI		 4480/**
4481 * snd_hda_codec_prepare - Prepare a stream
4482 * @codec: the HDA codec
4483 * @hinfo: PCM information
4484 * @stream: stream tag to assign
4485 * @format: format id to assign
4486 * @substream: PCM substream to assign
4487 *
4488 * Calls the prepare callback set by the codec with the given arguments.
4489 * Clean up the inactive streams when successful.
4490 */
eb541337
TI		 4491int snd_hda_codec_prepare(struct hda_codec *codec,
4492 struct hda_pcm_stream *hinfo,
4493 unsigned int stream,
4494 unsigned int format,
4495 struct snd_pcm_substream *substream)
4496{
4497 int ret;
3f50ac6a 4498 mutex_lock(&codec->bus->prepare_mutex);
eb541337
TI		 4499 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4500 if (ret >= 0)
4501 purify_inactive_streams(codec);
3f50ac6a 4502 mutex_unlock(&codec->bus->prepare_mutex);
eb541337
TI		 4503 return ret;
4504}
2698ea98 4505EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
eb541337 4506
95a962c3
TI		 4507/**
4508 * snd_hda_codec_cleanup - Prepare a stream
4509 * @codec: the HDA codec
4510 * @hinfo: PCM information
4511 * @substream: PCM substream
4512 *
4513 * Calls the cleanup callback set by the codec with the given arguments.
4514 */
eb541337
TI		 4515void snd_hda_codec_cleanup(struct hda_codec *codec,
4516 struct hda_pcm_stream *hinfo,
4517 struct snd_pcm_substream *substream)
4518{
3f50ac6a 4519 mutex_lock(&codec->bus->prepare_mutex);
eb541337 4520 hinfo->ops.cleanup(hinfo, codec, substream);
3f50ac6a 4521 mutex_unlock(&codec->bus->prepare_mutex);
eb541337 4522}
2698ea98 4523EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
eb541337 4524
d5191e50 4525/* global */
e3303235
JK		 4526const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4527 "Audio", "SPDIF", "HDMI", "Modem"
4528};
4529
529bd6c4
TI		 4530/*
4531 * get the empty PCM device number to assign
4532 */
36bb00d4 4533static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
529bd6c4 4534{
f5d6def5 4535 /* audio device indices; not linear to keep compatibility */
36bb00d4
TI		 4536 /* assigned to static slots up to dev#10; if more needed, assign
4537 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4538 */
f5d6def5
WF		 4539 static int audio_idx[HDA_PCM_NTYPES][5] = {
4540 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4541 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 4542 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 4543 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 4544 };
f5d6def5
WF		 4545 int i;
4546
4547 if (type >= HDA_PCM_NTYPES) {
4e76a883 4548 dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
529bd6c4
TI		 4549 return -EINVAL;
4550 }
f5d6def5 4551
36bb00d4
TI		 4552 for (i = 0; audio_idx[type][i] >= 0; i++) {
4553#ifndef CONFIG_SND_DYNAMIC_MINORS
4554 if (audio_idx[type][i] >= 8)
4555 break;
4556#endif
f5d6def5
WF		 4557 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4558 return audio_idx[type][i];
36bb00d4 4559 }
f5d6def5 4560
36bb00d4 4561#ifdef CONFIG_SND_DYNAMIC_MINORS
01b65bfb
TI		 4562 /* non-fixed slots starting from 10 */
4563 for (i = 10; i < 32; i++) {
4564 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4565 return i;
4566 }
36bb00d4 4567#endif
01b65bfb 4568
4e76a883 4569 dev_warn(bus->card->dev, "Too many %s devices\n",
28aedaf7 4570 snd_hda_pcm_type_name[type]);
36bb00d4 4571#ifndef CONFIG_SND_DYNAMIC_MINORS
4e76a883
TI		 4572 dev_warn(bus->card->dev,
4573 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
36bb00d4 4574#endif
f5d6def5 4575 return -EAGAIN;
529bd6c4
TI		 4576}
4577
176d5335
TI		 4578/*
4579 * attach a new PCM stream
4580 */
529bd6c4 4581static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 4582{
33fa35ed 4583 struct hda_bus *bus = codec->bus;
176d5335
TI		 4584 struct hda_pcm_stream *info;
4585 int stream, err;
4586
b91f080f 4587 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 4588 return -EINVAL;
4589 for (stream = 0; stream < 2; stream++) {
4590 info = &pcm->stream[stream];
4591 if (info->substreams) {
4592 err = set_pcm_default_values(codec, info);
4593 if (err < 0)
4594 return err;
4595 }
4596 }
33fa35ed 4597 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 4598}
4599
529bd6c4
TI		 4600/* assign all PCMs of the given codec */
4601int snd_hda_codec_build_pcms(struct hda_codec *codec)
4602{
4603 unsigned int pcm;
4604 int err;
4605
4606 if (!codec->num_pcms) {
4607 if (!codec->patch_ops.build_pcms)
4608 return 0;
4609 err = codec->patch_ops.build_pcms(codec);
6e655bf2 4610 if (err < 0) {
4e76a883
TI		 4611 codec_err(codec,
4612 "cannot build PCMs for #%d (error %d)\n",
4613 codec->addr, err);
6e655bf2
TI		 4614 err = snd_hda_codec_reset(codec);
4615 if (err < 0) {
4e76a883
TI		 4616 codec_err(codec,
4617 "cannot revert codec\n");
6e655bf2
TI		 4618 return err;
4619 }
4620 }
529bd6c4
TI		 4621 }
4622 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4623 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4624 int dev;
4625
4626 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 4627 continue; /* no substreams assigned */
529bd6c4
TI		 4628
4629 if (!cpcm->pcm) {
4630 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4631 if (dev < 0)
6e655bf2 4632 continue; /* no fatal error */
529bd6c4
TI		 4633 cpcm->device = dev;
4634 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2 4635 if (err < 0) {
4e76a883
TI		 4636 codec_err(codec,
4637 "cannot attach PCM stream %d for codec #%d\n",
4638 dev, codec->addr);
6e655bf2
TI		 4639 continue; /* no fatal error */
4640 }
529bd6c4
TI		 4641 }
4642 }
4643 return 0;
4644}
4645
1da177e4
LT		 4646/**
4647 * snd_hda_build_pcms - build PCM information
4648 * @bus: the BUS
4649 *
4650 * Create PCM information for each codec included in the bus.
4651 *
4652 * The build_pcms codec patch is requested to set up codec->num_pcms and
4653 * codec->pcm_info properly. The array is referred by the top-level driver
4654 * to create its PCM instances.
4655 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4656 * callback.
4657 *
4658 * At least, substreams, channels_min and channels_max must be filled for
4659 * each stream. substreams = 0 indicates that the stream doesn't exist.
4660 * When rates and/or formats are zero, the supported values are queried
4661 * from the given nid. The nid is used also by the default ops.prepare
4662 * and ops.cleanup callbacks.
4663 *
4664 * The driver needs to call ops.open in its open callback. Similarly,
4665 * ops.close is supposed to be called in the close callback.
4666 * ops.prepare should be called in the prepare or hw_params callback
4667 * with the proper parameters for set up.
4668 * ops.cleanup should be called in hw_free for clean up of streams.
4669 *
25985edc 4670 * This function returns 0 if successful, or a negative error code.
1da177e4 4671 */
5cb543db 4672int snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 4673{
0ba21762 4674 struct hda_codec *codec;
1da177e4 4675
0ba21762 4676 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 4677 int err = snd_hda_codec_build_pcms(codec);
4678 if (err < 0)
4679 return err;
1da177e4
LT		 4680 }
4681 return 0;
4682}
2698ea98 4683EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
1da177e4 4684
1da177e4
LT		 4685/**
4686 * snd_hda_add_new_ctls - create controls from the array
4687 * @codec: the HDA codec
c8b6bf9b 4688 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 4689 *
4690 * This helper function creates and add new controls in the given array.
4691 * The array must be terminated with an empty entry as terminator.
4692 *
4693 * Returns 0 if successful, or a negative error code.
4694 */
031024ee
TI		 4695int snd_hda_add_new_ctls(struct hda_codec *codec,
4696 const struct snd_kcontrol_new *knew)
1da177e4 4697{
4d02d1b6 4698 int err;
1da177e4
LT		 4699
4700 for (; knew->name; knew++) {
54d17403 4701 struct snd_kcontrol *kctl;
1afe206a 4702 int addr = 0, idx = 0;
5b0cb1d8
JK		 4703 if (knew->iface == -1) /* skip this codec private value */
4704 continue;
1afe206a 4705 for (;;) {
54d17403 4706 kctl = snd_ctl_new1(knew, codec);
0ba21762 4707 if (!kctl)
54d17403 4708 return -ENOMEM;
1afe206a
TI		 4709 if (addr > 0)
4710 kctl->id.device = addr;
4711 if (idx > 0)
4712 kctl->id.index = idx;
3911a4c1 4713 err = snd_hda_ctl_add(codec, 0, kctl);
1afe206a
TI		 4714 if (!err)
4715 break;
4716 /* try first with another device index corresponding to
4717 * the codec addr; if it still fails (or it's the
4718 * primary codec), then try another control index
4719 */
4720 if (!addr && codec->addr)
4721 addr = codec->addr;
4722 else if (!idx && !knew->index) {
4723 idx = find_empty_mixer_ctl_idx(codec,
dcda5806 4724 knew->name, 0);
1afe206a
TI		 4725 if (idx <= 0)
4726 return err;
4727 } else
54d17403
TI		 4728 return err;
4729 }
1da177e4
LT		 4730 }
4731 return 0;
4732}
2698ea98 4733EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
1da177e4 4734
83012a7c 4735#ifdef CONFIG_PM
cb53c626
TI		 4736static void hda_power_work(struct work_struct *work)
4737{
4738 struct hda_codec *codec =
4739 container_of(work, struct hda_codec, power_work.work);
33fa35ed 4740 struct hda_bus *bus = codec->bus;
08fa20ae 4741 unsigned int state;
cb53c626 4742
5536c6d6 4743 spin_lock(&codec->power_lock);
a2d96e77
TI		 4744 if (codec->power_transition > 0) { /* during power-up sequence? */
4745 spin_unlock(&codec->power_lock);
4746 return;
4747 }
2e492462
ML		 4748 if (!codec->power_on || codec->power_count) {
4749 codec->power_transition = 0;
5536c6d6 4750 spin_unlock(&codec->power_lock);
cb53c626 4751 return;
2e492462 4752 }
5536c6d6
TI		 4753 spin_unlock(&codec->power_lock);
4754
d17344b3 4755 state = hda_call_codec_suspend(codec, true);
a40e0a88
TI		 4756 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK))
4757 hda_call_pm_notify(codec, false);
cb53c626
TI		 4758}
4759
4760static void hda_keep_power_on(struct hda_codec *codec)
4761{
5536c6d6 4762 spin_lock(&codec->power_lock);
cb53c626
TI		 4763 codec->power_count++;
4764 codec->power_on = 1;
a2f6309e 4765 codec->power_jiffies = jiffies;
5536c6d6 4766 spin_unlock(&codec->power_lock);
a40e0a88 4767 hda_call_pm_notify(codec, true);
a2f6309e
TI		 4768}
4769
d5191e50 4770/* update the power on/off account with the current jiffies */
a2f6309e
TI		 4771void snd_hda_update_power_acct(struct hda_codec *codec)
4772{
4773 unsigned long delta = jiffies - codec->power_jiffies;
4774 if (codec->power_on)
4775 codec->power_on_acct += delta;
4776 else
4777 codec->power_off_acct += delta;
4778 codec->power_jiffies += delta;
cb53c626
TI		 4779}
4780
b4a91cf0
DR		 4781/* Transition to powered up, if wait_power_down then wait for a pending
4782 * transition to D3 to complete. A pending D3 transition is indicated
4783 * with power_transition == -1. */
c376e2c7 4784/* call this with codec->power_lock held! */
b4a91cf0 4785static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
cb53c626 4786{
b4a91cf0
DR		 4787 /* Return if power_on or transitioning to power_on, unless currently
4788 * powering down. */
4789 if ((codec->power_on || codec->power_transition > 0) &&
c376e2c7 4790 !(wait_power_down && codec->power_transition < 0))
cb53c626 4791 return;
a2d96e77 4792 spin_unlock(&codec->power_lock);
cb53c626 4793
a2d96e77
TI		 4794 cancel_delayed_work_sync(&codec->power_work);
4795
4796 spin_lock(&codec->power_lock);
b43d2247
DR		 4797 /* If the power down delayed work was cancelled above before starting,
4798 * then there is no need to go through power up here.
4799 */
4800 if (codec->power_on) {
535b6c51
TI		 4801 if (codec->power_transition < 0)
4802 codec->power_transition = 0;
b43d2247
DR		 4803 return;
4804 }
c376e2c7 4805
d66fee5d 4806 trace_hda_power_up(codec);
a2f6309e 4807 snd_hda_update_power_acct(codec);
cb53c626 4808 codec->power_on = 1;
a2f6309e 4809 codec->power_jiffies = jiffies;
7f30830b 4810 codec->power_transition = 1; /* avoid reentrance */
5536c6d6
TI		 4811 spin_unlock(&codec->power_lock);
4812
cb53c626 4813 hda_call_codec_resume(codec);
5536c6d6
TI		 4814
4815 spin_lock(&codec->power_lock);
a221e287 4816 codec->power_transition = 0;
cb53c626 4817}
b4a91cf0 4818
c376e2c7
TI		 4819#define power_save(codec) \
4820 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
1289e9e8 4821
c376e2c7
TI		 4822/* Transition to powered down */
4823static void __snd_hda_power_down(struct hda_codec *codec)
b4a91cf0 4824{
c376e2c7
TI		 4825 if (!codec->power_on || codec->power_count || codec->power_transition)
4826 return;
b4a91cf0 4827
c376e2c7
TI		 4828 if (power_save(codec)) {
4829 codec->power_transition = -1; /* avoid reentrance */
4830 queue_delayed_work(codec->bus->workq, &codec->power_work,
4831 msecs_to_jiffies(power_save(codec) * 1000));
4832 }
4833}
cb53c626 4834
d5191e50 4835/**
c376e2c7 4836 * snd_hda_power_save - Power-up/down/sync the codec
d5191e50 4837 * @codec: HD-audio codec
c376e2c7 4838 * @delta: the counter delta to change
a11e9b16 4839 * @d3wait: sync for D3 transition complete
d5191e50 4840 *
c376e2c7
TI		 4841 * Change the power-up counter via @delta, and power up or down the hardware
4842 * appropriately. For the power-down, queue to the delayed action.
4843 * Passing zero to @delta means to synchronize the power state.
28aedaf7 4844 */
c376e2c7 4845void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
cb53c626 4846{
5536c6d6 4847 spin_lock(&codec->power_lock);
c376e2c7 4848 codec->power_count += delta;
b244d335 4849 trace_hda_power_count(codec);
c376e2c7
TI		 4850 if (delta > 0)
4851 __snd_hda_power_up(codec, d3wait);
4852 else
4853 __snd_hda_power_down(codec);
5536c6d6 4854 spin_unlock(&codec->power_lock);
cb53c626 4855}
2698ea98 4856EXPORT_SYMBOL_GPL(snd_hda_power_save);
cb53c626 4857
d5191e50
TI		 4858/**
4859 * snd_hda_check_amp_list_power - Check the amp list and update the power
4860 * @codec: HD-audio codec
4861 * @check: the object containing an AMP list and the status
4862 * @nid: NID to check / update
4863 *
4864 * Check whether the given NID is in the amp list. If it's in the list,
4865 * check the current AMP status, and update the the power-status according
4866 * to the mute status.
4867 *
4868 * This function is supposed to be set or called from the check_power_status
4869 * patch ops.
28aedaf7 4870 */
cb53c626
TI		 4871int snd_hda_check_amp_list_power(struct hda_codec *codec,
4872 struct hda_loopback_check *check,
4873 hda_nid_t nid)
4874{
031024ee 4875 const struct hda_amp_list *p;
cb53c626
TI		 4876 int ch, v;
4877
4878 if (!check->amplist)
4879 return 0;
4880 for (p = check->amplist; p->nid; p++) {
4881 if (p->nid == nid)
4882 break;
4883 }
4884 if (!p->nid)
4885 return 0; /* nothing changed */
4886
4887 for (p = check->amplist; p->nid; p++) {
4888 for (ch = 0; ch < 2; ch++) {
4889 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4890 p->idx);
4891 if (!(v & HDA_AMP_MUTE) && v > 0) {
4892 if (!check->power_on) {
4893 check->power_on = 1;
4894 snd_hda_power_up(codec);
4895 }
4896 return 1;
4897 }
4898 }
4899 }
4900 if (check->power_on) {
4901 check->power_on = 0;
4902 snd_hda_power_down(codec);
4903 }
4904 return 0;
4905}
2698ea98 4906EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
cb53c626 4907#endif
1da177e4 4908
c8b6bf9b 4909/*
d2a6d7dc
TI		 4910 * Channel mode helper
4911 */
d5191e50
TI		 4912
4913/**
4914 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
a11e9b16
TI		 4915 * @codec: the HDA codec
4916 * @uinfo: pointer to get/store the data
4917 * @chmode: channel mode array
4918 * @num_chmodes: channel mode array size
d5191e50 4919 */
0ba21762
TI		 4920int snd_hda_ch_mode_info(struct hda_codec *codec,
4921 struct snd_ctl_elem_info *uinfo,
4922 const struct hda_channel_mode *chmode,
4923 int num_chmodes)
d2a6d7dc
TI		 4924{
4925 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4926 uinfo->count = 1;
4927 uinfo->value.enumerated.items = num_chmodes;
4928 if (uinfo->value.enumerated.item >= num_chmodes)
4929 uinfo->value.enumerated.item = num_chmodes - 1;
4930 sprintf(uinfo->value.enumerated.name, "%dch",
4931 chmode[uinfo->value.enumerated.item].channels);
4932 return 0;
4933}
2698ea98 4934EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
d2a6d7dc 4935
d5191e50
TI		 4936/**
4937 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
a11e9b16
TI		 4938 * @codec: the HDA codec
4939 * @ucontrol: pointer to get/store the data
4940 * @chmode: channel mode array
4941 * @num_chmodes: channel mode array size
4942 * @max_channels: max number of channels
d5191e50 4943 */
0ba21762
TI		 4944int snd_hda_ch_mode_get(struct hda_codec *codec,
4945 struct snd_ctl_elem_value *ucontrol,
4946 const struct hda_channel_mode *chmode,
4947 int num_chmodes,
d2a6d7dc
TI		 4948 int max_channels)
4949{
4950 int i;
4951
4952 for (i = 0; i < num_chmodes; i++) {
4953 if (max_channels == chmode[i].channels) {
4954 ucontrol->value.enumerated.item[0] = i;
4955 break;
4956 }
4957 }
4958 return 0;
4959}
2698ea98 4960EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
d2a6d7dc 4961
d5191e50
TI		 4962/**
4963 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
a11e9b16
TI		 4964 * @codec: the HDA codec
4965 * @ucontrol: pointer to get/store the data
4966 * @chmode: channel mode array
4967 * @num_chmodes: channel mode array size
4968 * @max_channelsp: pointer to store the max channels
d5191e50 4969 */
0ba21762
TI		 4970int snd_hda_ch_mode_put(struct hda_codec *codec,
4971 struct snd_ctl_elem_value *ucontrol,
4972 const struct hda_channel_mode *chmode,
4973 int num_chmodes,
d2a6d7dc
TI		 4974 int *max_channelsp)
4975{
4976 unsigned int mode;
4977
4978 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 4979 if (mode >= num_chmodes)
4980 return -EINVAL;
82beb8fd 4981 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 4982 return 0;
4983 /* change the current channel setting */
4984 *max_channelsp = chmode[mode].channels;
4985 if (chmode[mode].sequence)
82beb8fd 4986 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 4987 return 1;
4988}
2698ea98 4989EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
d2a6d7dc 4990
1da177e4
LT		 4991/*
4992 * input MUX helper
4993 */
d5191e50
TI		 4994
4995/**
4996 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
a11e9b16
TI		 4997 * @imux: imux helper object
4998 * @uinfo: pointer to get/store the data
d5191e50 4999 */
0ba21762
TI		 5000int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5001 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 5002{
5003 unsigned int index;
5004
5005 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5006 uinfo->count = 1;
5007 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 5008 if (!imux->num_items)
5009 return 0;
1da177e4
LT		 5010 index = uinfo->value.enumerated.item;
5011 if (index >= imux->num_items)
5012 index = imux->num_items - 1;
5013 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5014 return 0;
5015}
2698ea98 5016EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
1da177e4 5017
d5191e50
TI		 5018/**
5019 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
a11e9b16
TI		 5020 * @codec: the HDA codec
5021 * @imux: imux helper object
5022 * @ucontrol: pointer to get/store the data
5023 * @nid: input mux NID
5024 * @cur_val: pointer to get/store the current imux value
d5191e50 5025 */
0ba21762
TI		 5026int snd_hda_input_mux_put(struct hda_codec *codec,
5027 const struct hda_input_mux *imux,
5028 struct snd_ctl_elem_value *ucontrol,
5029 hda_nid_t nid,
1da177e4
LT		 5030 unsigned int *cur_val)
5031{
5032 unsigned int idx;
5033
5513b0c5
TI		 5034 if (!imux->num_items)
5035 return 0;
1da177e4
LT		 5036 idx = ucontrol->value.enumerated.item[0];
5037 if (idx >= imux->num_items)
5038 idx = imux->num_items - 1;
82beb8fd 5039 if (*cur_val == idx)
1da177e4 5040 return 0;
82beb8fd
TI		 5041 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5042 imux->items[idx].index);
1da177e4
LT		 5043 *cur_val = idx;
5044 return 1;
5045}
2698ea98 5046EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
1da177e4
LT		 5047
5048
a11e9b16
TI		 5049/**
5050 * snd_hda_enum_helper_info - Helper for simple enum ctls
5051 * @kcontrol: ctl element
5052 * @uinfo: pointer to get/store the data
5053 * @num_items: number of enum items
5054 * @texts: enum item string array
5055 *
dda415d4
TI		 5056 * process kcontrol info callback of a simple string enum array
5057 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5058 */
5059int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5060 struct snd_ctl_elem_info *uinfo,
5061 int num_items, const char * const *texts)
5062{
5063 static const char * const texts_default[] = {
5064 "Disabled", "Enabled"
5065 };
5066
5067 if (!texts || !num_items) {
5068 num_items = 2;
5069 texts = texts_default;
5070 }
5071
3ff72219 5072 return snd_ctl_enum_info(uinfo, 1, num_items, texts);
dda415d4 5073}
2698ea98 5074EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
dda415d4 5075
1da177e4
LT		 5076/*
5077 * Multi-channel / digital-out PCM helper functions
5078 */
5079
6b97eb45
TI		 5080/* setup SPDIF output stream */
5081static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5082 unsigned int stream_tag, unsigned int format)
5083{
3bef1c37
LD		 5084 struct hda_spdif_out *spdif;
5085 unsigned int curr_fmt;
5086 bool reset;
5087
5088 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5089 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5090 AC_VERB_GET_STREAM_FORMAT, 0);
5091 reset = codec->spdif_status_reset &&
5092 (spdif->ctls & AC_DIG1_ENABLE) &&
5093 curr_fmt != format;
5094
5095 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5096 updated */
5097 if (reset)
28aedaf7 5098 set_dig_out_convert(codec, nid,
7c935976 5099 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
2f72853c 5100 -1);
6b97eb45 5101 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c 5102 if (codec->slave_dig_outs) {
dda14410 5103 const hda_nid_t *d;
2f72853c
TI		 5104 for (d = codec->slave_dig_outs; *d; d++)
5105 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5106 format);
5107 }
6b97eb45 5108 /* turn on again (if needed) */
3bef1c37 5109 if (reset)
2f72853c 5110 set_dig_out_convert(codec, nid,
7c935976 5111 spdif->ctls & 0xff, -1);
2f72853c 5112}
de51ca12 5113
2f72853c
TI		 5114static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5115{
5116 snd_hda_codec_cleanup_stream(codec, nid);
5117 if (codec->slave_dig_outs) {
dda14410 5118 const hda_nid_t *d;
2f72853c
TI		 5119 for (d = codec->slave_dig_outs; *d; d++)
5120 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 5121 }
6b97eb45
TI		 5122}
5123
d5191e50
TI		 5124/**
5125 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5126 * @bus: HD-audio bus
5127 */
fb8d1a34
TI		 5128void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5129{
5130 struct hda_codec *codec;
5131
5132 if (!bus)
5133 return;
5134 list_for_each_entry(codec, &bus->codec_list, list) {
e581f3db
TI		 5135 if (hda_codec_is_power_on(codec) &&
5136 codec->patch_ops.reboot_notify)
fb8d1a34
TI		 5137 codec->patch_ops.reboot_notify(codec);
5138 }
5139}
2698ea98 5140EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
fb8d1a34 5141
d5191e50
TI		 5142/**
5143 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
a11e9b16
TI		 5144 * @codec: the HDA codec
5145 * @mout: hda_multi_out object
1da177e4 5146 */
0ba21762
TI		 5147int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5148 struct hda_multi_out *mout)
1da177e4 5149{
62932df8 5150 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 5151 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5152 /* already opened as analog dup; reset it once */
2f72853c 5153 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 5154 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 5155 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5156 return 0;
5157}
2698ea98 5158EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
1da177e4 5159
d5191e50
TI		 5160/**
5161 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
a11e9b16
TI		 5162 * @codec: the HDA codec
5163 * @mout: hda_multi_out object
5164 * @stream_tag: stream tag to assign
5165 * @format: format id to assign
5166 * @substream: PCM substream to assign
d5191e50 5167 */
6b97eb45
TI		 5168int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5169 struct hda_multi_out *mout,
5170 unsigned int stream_tag,
5171 unsigned int format,
5172 struct snd_pcm_substream *substream)
5173{
5174 mutex_lock(&codec->spdif_mutex);
5175 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5176 mutex_unlock(&codec->spdif_mutex);
5177 return 0;
5178}
2698ea98 5179EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
6b97eb45 5180
d5191e50
TI		 5181/**
5182 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
a11e9b16
TI		 5183 * @codec: the HDA codec
5184 * @mout: hda_multi_out object
d5191e50 5185 */
9411e21c
TI		 5186int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5187 struct hda_multi_out *mout)
5188{
5189 mutex_lock(&codec->spdif_mutex);
5190 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5191 mutex_unlock(&codec->spdif_mutex);
5192 return 0;
5193}
2698ea98 5194EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
9411e21c 5195
d5191e50
TI		 5196/**
5197 * snd_hda_multi_out_dig_close - release the digital out stream
a11e9b16
TI		 5198 * @codec: the HDA codec
5199 * @mout: hda_multi_out object
1da177e4 5200 */
0ba21762
TI		 5201int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5202 struct hda_multi_out *mout)
1da177e4 5203{
62932df8 5204 mutex_lock(&codec->spdif_mutex);
1da177e4 5205 mout->dig_out_used = 0;
62932df8 5206 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5207 return 0;
5208}
2698ea98 5209EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
1da177e4 5210
d5191e50
TI		 5211/**
5212 * snd_hda_multi_out_analog_open - open analog outputs
a11e9b16
TI		 5213 * @codec: the HDA codec
5214 * @mout: hda_multi_out object
5215 * @substream: PCM substream to assign
5216 * @hinfo: PCM information to assign
d5191e50
TI		 5217 *
5218 * Open analog outputs and set up the hw-constraints.
5219 * If the digital outputs can be opened as slave, open the digital
5220 * outputs, too.
1da177e4 5221 */
0ba21762
TI		 5222int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5223 struct hda_multi_out *mout,
9a08160b
TI		 5224 struct snd_pcm_substream *substream,
5225 struct hda_pcm_stream *hinfo)
5226{
5227 struct snd_pcm_runtime *runtime = substream->runtime;
5228 runtime->hw.channels_max = mout->max_channels;
5229 if (mout->dig_out_nid) {
5230 if (!mout->analog_rates) {
5231 mout->analog_rates = hinfo->rates;
5232 mout->analog_formats = hinfo->formats;
5233 mout->analog_maxbps = hinfo->maxbps;
5234 } else {
5235 runtime->hw.rates = mout->analog_rates;
5236 runtime->hw.formats = mout->analog_formats;
5237 hinfo->maxbps = mout->analog_maxbps;
5238 }
5239 if (!mout->spdif_rates) {
5240 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5241 &mout->spdif_rates,
5242 &mout->spdif_formats,
5243 &mout->spdif_maxbps);
5244 }
5245 mutex_lock(&codec->spdif_mutex);
5246 if (mout->share_spdif) {
022b466f
TI		 5247 if ((runtime->hw.rates & mout->spdif_rates) &&
5248 (runtime->hw.formats & mout->spdif_formats)) {
5249 runtime->hw.rates &= mout->spdif_rates;
5250 runtime->hw.formats &= mout->spdif_formats;
5251 if (mout->spdif_maxbps < hinfo->maxbps)
5252 hinfo->maxbps = mout->spdif_maxbps;
5253 } else {
5254 mout->share_spdif = 0;
5255 /* FIXME: need notify? */
5256 }
9a08160b 5257 }
eaa9985b 5258 mutex_unlock(&codec->spdif_mutex);
9a08160b 5259 }
1da177e4
LT		 5260 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5261 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5262}
2698ea98 5263EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
1da177e4 5264
d5191e50
TI		 5265/**
5266 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
a11e9b16
TI		 5267 * @codec: the HDA codec
5268 * @mout: hda_multi_out object
5269 * @stream_tag: stream tag to assign
5270 * @format: format id to assign
5271 * @substream: PCM substream to assign
d5191e50
TI		 5272 *
5273 * Set up the i/o for analog out.
5274 * When the digital out is available, copy the front out to digital out, too.
1da177e4 5275 */
0ba21762
TI		 5276int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5277 struct hda_multi_out *mout,
1da177e4
LT		 5278 unsigned int stream_tag,
5279 unsigned int format,
c8b6bf9b 5280 struct snd_pcm_substream *substream)
1da177e4 5281{
dda14410 5282 const hda_nid_t *nids = mout->dac_nids;
1da177e4 5283 int chs = substream->runtime->channels;
e3245cdd 5284 struct hda_spdif_out *spdif;
1da177e4
LT		 5285 int i;
5286
62932df8 5287 mutex_lock(&codec->spdif_mutex);
e3245cdd 5288 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
9a08160b
TI		 5289 if (mout->dig_out_nid && mout->share_spdif &&
5290 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 5291 if (chs == 2 &&
0ba21762
TI		 5292 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5293 format) &&
7c935976 5294 !(spdif->status & IEC958_AES0_NONAUDIO)) {
1da177e4 5295 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 5296 setup_dig_out_stream(codec, mout->dig_out_nid,
5297 stream_tag, format);
1da177e4
LT		 5298 } else {
5299 mout->dig_out_used = 0;
2f72853c 5300 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 5301 }
5302 }
62932df8 5303 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5304
5305 /* front */
0ba21762
TI		 5306 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5307 0, format);
d29240ce
TI		 5308 if (!mout->no_share_stream &&
5309 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 5310 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 5311 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5312 0, format);
82bc955f 5313 /* extra outputs copied from front */
a06dbfc2
TI		 5314 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5315 if (!mout->no_share_stream && mout->hp_out_nid[i])
5316 snd_hda_codec_setup_stream(codec,
5317 mout->hp_out_nid[i],
5318 stream_tag, 0, format);
82bc955f 5319
1da177e4
LT		 5320 /* surrounds */
5321 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 5322 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 5323 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5324 i * 2, format);
d29240ce 5325 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 5326 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5327 0, format);
1da177e4 5328 }
cd4035e8
DH		 5329
5330 /* extra surrounds */
5331 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
5332 int ch = 0;
5333 if (!mout->extra_out_nid[i])
5334 break;
5335 if (chs >= (i + 1) * 2)
5336 ch = i * 2;
5337 else if (!mout->no_share_stream)
5338 break;
5339 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
5340 stream_tag, ch, format);
5341 }
5342
1da177e4
LT		 5343 return 0;
5344}
2698ea98 5345EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
1da177e4 5346
d5191e50
TI		 5347/**
5348 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
a11e9b16
TI		 5349 * @codec: the HDA codec
5350 * @mout: hda_multi_out object
1da177e4 5351 */
0ba21762
TI		 5352int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5353 struct hda_multi_out *mout)
1da177e4 5354{
dda14410 5355 const hda_nid_t *nids = mout->dac_nids;
1da177e4
LT		 5356 int i;
5357
5358 for (i = 0; i < mout->num_dacs; i++)
888afa15 5359 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 5360 if (mout->hp_nid)
888afa15 5361 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
a06dbfc2
TI		 5362 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5363 if (mout->hp_out_nid[i])
5364 snd_hda_codec_cleanup_stream(codec,
5365 mout->hp_out_nid[i]);
82bc955f
TI		 5366 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5367 if (mout->extra_out_nid[i])
888afa15
TI		 5368 snd_hda_codec_cleanup_stream(codec,
5369 mout->extra_out_nid[i]);
62932df8 5370 mutex_lock(&codec->spdif_mutex);
1da177e4 5371 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 5372 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 5373 mout->dig_out_used = 0;
5374 }
62932df8 5375 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 5376 return 0;
5377}
2698ea98 5378EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
1da177e4 5379
4740860b
TI		 5380/**
5381 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
a11e9b16
TI		 5382 * @codec: the HDA codec
5383 * @pin: referred pin NID
4740860b
TI		 5384 *
5385 * Guess the suitable VREF pin bits to be set as the pin-control value.
5386 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5387 */
5388unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5389{
5390 unsigned int pincap;
5391 unsigned int oldval;
5392 oldval = snd_hda_codec_read(codec, pin, 0,
5393 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5394 pincap = snd_hda_query_pin_caps(codec, pin);
5395 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5396 /* Exception: if the default pin setup is vref50, we give it priority */
5397 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5398 return AC_PINCTL_VREF_80;
5399 else if (pincap & AC_PINCAP_VREF_50)
5400 return AC_PINCTL_VREF_50;
5401 else if (pincap & AC_PINCAP_VREF_100)
5402 return AC_PINCTL_VREF_100;
5403 else if (pincap & AC_PINCAP_VREF_GRD)
5404 return AC_PINCTL_VREF_GRD;
5405 return AC_PINCTL_VREF_HIZ;
5406}
2698ea98 5407EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
4740860b 5408
a11e9b16
TI		 5409/**
5410 * snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
5411 * @codec: the HDA codec
5412 * @pin: referred pin NID
5413 * @val: pin ctl value to audit
5414 */
62f3a2f7
TI		 5415unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5416 hda_nid_t pin, unsigned int val)
5417{
5418 static unsigned int cap_lists[][2] = {
5419 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5420 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5421 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5422 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5423 };
5424 unsigned int cap;
5425
5426 if (!val)
5427 return 0;
5428 cap = snd_hda_query_pin_caps(codec, pin);
5429 if (!cap)
5430 return val; /* don't know what to do... */
5431
5432 if (val & AC_PINCTL_OUT_EN) {
5433 if (!(cap & AC_PINCAP_OUT))
5434 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5435 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5436 val &= ~AC_PINCTL_HP_EN;
5437 }
5438
5439 if (val & AC_PINCTL_IN_EN) {
5440 if (!(cap & AC_PINCAP_IN))
5441 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5442 else {
5443 unsigned int vcap, vref;
5444 int i;
5445 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5446 vref = val & AC_PINCTL_VREFEN;
5447 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5448 if (vref == cap_lists[i][0] &&
5449 !(vcap & cap_lists[i][1])) {
5450 if (i == ARRAY_SIZE(cap_lists) - 1)
5451 vref = AC_PINCTL_VREF_HIZ;
5452 else
5453 vref = cap_lists[i + 1][0];
5454 }
5455 }
5456 val &= ~AC_PINCTL_VREFEN;
5457 val |= vref;
5458 }
5459 }
5460
5461 return val;
5462}
2698ea98 5463EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
62f3a2f7 5464
a11e9b16
TI		 5465/**
5466 * _snd_hda_pin_ctl - Helper to set pin ctl value
5467 * @codec: the HDA codec
5468 * @pin: referred pin NID
5469 * @val: pin control value to set
5470 * @cached: access over codec pinctl cache or direct write
5471 *
5472 * This function is a helper to set a pin ctl value more safely.
5473 * It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
5474 * value in pin target array via snd_hda_codec_set_pin_target(), then
5475 * actually writes the value via either snd_hda_codec_update_cache() or
5476 * snd_hda_codec_write() depending on @cached flag.
5477 */
cdd03ced
TI		 5478int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5479 unsigned int val, bool cached)
5480{
62f3a2f7 5481 val = snd_hda_correct_pin_ctl(codec, pin, val);
d7fdc00a 5482 snd_hda_codec_set_pin_target(codec, pin, val);
cdd03ced
TI		 5483 if (cached)
5484 return snd_hda_codec_update_cache(codec, pin, 0,
5485 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5486 else
5487 return snd_hda_codec_write(codec, pin, 0,
5488 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5489}
2698ea98 5490EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
cdd03ced 5491
990061c2
TI		 5492/**
5493 * snd_hda_add_imux_item - Add an item to input_mux
a11e9b16
TI		 5494 * @codec: the HDA codec
5495 * @imux: imux helper object
5496 * @label: the name of imux item to assign
5497 * @index: index number of imux item to assign
5498 * @type_idx: pointer to store the resultant label index
990061c2
TI		 5499 *
5500 * When the same label is used already in the existing items, the number
5501 * suffix is appended to the label. This label index number is stored
5502 * to type_idx when non-NULL pointer is given.
5503 */
6194b99d
TI		 5504int snd_hda_add_imux_item(struct hda_codec *codec,
5505 struct hda_input_mux *imux, const char *label,
10a20af7
TI		 5506 int index, int *type_idx)
5507{
5508 int i, label_idx = 0;
5509 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
6194b99d 5510 codec_err(codec, "hda_codec: Too many imux items!\n");
10a20af7
TI		 5511 return -EINVAL;
5512 }
5513 for (i = 0; i < imux->num_items; i++) {
5514 if (!strncmp(label, imux->items[i].label, strlen(label)))
5515 label_idx++;
d7b1ae9d 5516 }
10a20af7
TI		 5517 if (type_idx)
5518 *type_idx = label_idx;
5519 if (label_idx > 0)
5520 snprintf(imux->items[imux->num_items].label,
5521 sizeof(imux->items[imux->num_items].label),
5522 "%s %d", label, label_idx);
b5786e85 5523 else
10a20af7
TI		 5524 strlcpy(imux->items[imux->num_items].label, label,
5525 sizeof(imux->items[imux->num_items].label));
5526 imux->items[imux->num_items].index = index;
5527 imux->num_items++;
5528 return 0;
d7b1ae9d 5529}
2698ea98 5530EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
d7b1ae9d 5531
1da177e4 5532/**
59ed1ead
TI		 5533 * snd_hda_bus_reset - Reset the bus
5534 * @bus: HD-audio bus
1da177e4 5535 */
59ed1ead 5536void snd_hda_bus_reset(struct hda_bus *bus)
1da177e4 5537{
0ba21762 5538 struct hda_codec *codec;
1da177e4 5539
0ba21762 5540 list_for_each_entry(codec, &bus->codec_list, list) {
59ed1ead 5541 /* FIXME: maybe a better way needed for forced reset */
26a6cb6c 5542 cancel_delayed_work_sync(&codec->jackpoll_work);
59ed1ead 5543#ifdef CONFIG_PM
0e24dbb7 5544 if (hda_codec_is_power_on(codec)) {
59ed1ead 5545 hda_call_codec_suspend(codec, false);
12edb893 5546 hda_call_codec_resume(codec);
59ed1ead
TI		 5547 }
5548#endif
1da177e4 5549 }
1da177e4 5550}
59ed1ead 5551EXPORT_SYMBOL_GPL(snd_hda_bus_reset);
b2e18597
TI		 5552
5553/*
5554 * generic arrays
5555 */
5556
d5191e50
TI		 5557/**
5558 * snd_array_new - get a new element from the given array
5559 * @array: the array object
28aedaf7 5560 *
d5191e50
TI		 5561 * Get a new element from the given array. If it exceeds the
5562 * pre-allocated array size, re-allocate the array.
5563 *
5564 * Returns NULL if allocation failed.
b2e18597
TI		 5565 */
5566void *snd_array_new(struct snd_array *array)
5567{
12f17717
TI		 5568 if (snd_BUG_ON(!array->elem_size))
5569 return NULL;
b2e18597
TI		 5570 if (array->used >= array->alloced) {
5571 int num = array->alloced + array->alloc_align;
3101ba03 5572 int size = (num + 1) * array->elem_size;
b910d9ae
TI		 5573 void *nlist;
5574 if (snd_BUG_ON(num >= 4096))
5575 return NULL;
5265fd9a 5576 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
b2e18597
TI		 5577 if (!nlist)
5578 return NULL;
b2e18597
TI		 5579 array->list = nlist;
5580 array->alloced = num;
5581 }
f43aa025 5582 return snd_array_elem(array, array->used++);
b2e18597 5583}
2698ea98 5584EXPORT_SYMBOL_GPL(snd_array_new);
b2e18597 5585
d5191e50
TI		 5586/**
5587 * snd_array_free - free the given array elements
5588 * @array: the array object
5589 */
b2e18597
TI		 5590void snd_array_free(struct snd_array *array)
5591{
5592 kfree(array->list);
5593 array->used = 0;
5594 array->alloced = 0;
5595 array->list = NULL;
5596}
2698ea98 5597EXPORT_SYMBOL_GPL(snd_array_free);
b2022266 5598
d5191e50
TI		 5599/**
5600 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5601 * @pcm: PCM caps bits
5602 * @buf: the string buffer to write
5603 * @buflen: the max buffer length
5604 *
5605 * used by hda_proc.c and hda_eld.c
5606 */
b2022266
TI		 5607void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5608{
5609 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5610 int i, j;
5611
5612 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5613 if (pcm & (AC_SUPPCM_BITS_8 << i))
5614 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5615
5616 buf[j] = '\0'; /* necessary when j == 0 */
5617}
2698ea98 5618EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
1289e9e8
TI		 5619
5620MODULE_DESCRIPTION("HDA codec core");
5621MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.064397 seconds and 5 git commands to generate.