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