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