?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
repo init
[linux-rt-nao.git] / sound / pci / hda / hda_codec.c
blobcef1ce05b18d62c0cc805c710cee4c934a832092
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 <sound/hda_hwdep.h>
34
35 /*
36 * vendor / preset table
37 */
38
39 struct hda_vendor_id {
40 unsigned int id;
41 const char *name;
42 };
43
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
46 { 0x1002, "ATI" },
47 { 0x1057, "Motorola" },
48 { 0x1095, "Silicon Image" },
49 { 0x10de, "Nvidia" },
50 { 0x10ec, "Realtek" },
51 { 0x1106, "VIA" },
52 { 0x111d, "IDT" },
53 { 0x11c1, "LSI" },
54 { 0x11d4, "Analog Devices" },
55 { 0x13f6, "C-Media" },
56 { 0x14f1, "Conexant" },
57 { 0x17e8, "Chrontel" },
58 { 0x1854, "LG" },
59 { 0x1aec, "Wolfson Microelectronics" },
60 { 0x434d, "C-Media" },
61 { 0x8086, "Intel" },
62 { 0x8384, "SigmaTel" },
63 {} /* terminator */
64 };
65
66 static DEFINE_MUTEX(preset_mutex);
67 static LIST_HEAD(hda_preset_tables);
68
69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
70 {
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
74 return 0;
75 }
76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
77
78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
79 {
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
83 return 0;
84 }
85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
86
87 #ifdef CONFIG_SND_HDA_POWER_SAVE
88 static void hda_power_work(struct work_struct *work);
89 static void hda_keep_power_on(struct hda_codec *codec);
90 #else
91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
92 #endif
93
94 const char *snd_hda_get_jack_location(u32 cfg)
95 {
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
98 };
99 static unsigned char specials_idx[] = {
100 0x07, 0x08,
101 0x17, 0x18, 0x19,
102 0x37, 0x38
103 };
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
108 };
109 int i;
110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
111 if ((cfg & 0x0f) < 7)
112 return bases[cfg & 0x0f];
113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
114 if (cfg == specials_idx[i])
115 return specials[i];
116 }
117 return "UNKNOWN";
118 }
119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
120
121 const char *snd_hda_get_jack_connectivity(u32 cfg)
122 {
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
124
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
126 }
127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
128
129 const char *snd_hda_get_jack_type(u32 cfg)
130 {
131 static char *jack_types[16] = {
132 "Line Out", "Speaker", "HP Out", "CD",
133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
134 "Line In", "Aux", "Mic", "Telephony",
135 "SPDIF In", "Digitial In", "Reserved", "Other"
136 };
137
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
140 }
141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
142
143 /*
144 * Compose a 32bit command word to be sent to the HD-audio controller
145 */
146 static inline unsigned int
147 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
148 unsigned int verb, unsigned int parm)
149 {
150 u32 val;
151
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
155 val |= verb << 8;
156 val |= parm;
157 return val;
158 }
159
160 /**
161 * snd_hda_codec_read - send a command and get the response
162 * @codec: the HDA codec
163 * @nid: NID to send the command
164 * @direct: direct flag
165 * @verb: the verb to send
166 * @parm: the parameter for the verb
167 *
168 * Send a single command and read the corresponding response.
169 *
170 * Returns the obtained response value, or -1 for an error.
171 */
172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
173 int direct,
174 unsigned int verb, unsigned int parm)
175 {
176 struct hda_bus *bus = codec->bus;
177 unsigned int res;
178
179 res = make_codec_cmd(codec, nid, direct, verb, parm);
180 snd_hda_power_up(codec);
181 mutex_lock(&bus->cmd_mutex);
182 if (!bus->ops.command(bus, res))
183 res = bus->ops.get_response(bus);
184 else
185 res = (unsigned int)-1;
186 mutex_unlock(&bus->cmd_mutex);
187 snd_hda_power_down(codec);
188 return res;
189 }
190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
191
192 /**
193 * snd_hda_codec_write - send a single command without waiting for response
194 * @codec: the HDA codec
195 * @nid: NID to send the command
196 * @direct: direct flag
197 * @verb: the verb to send
198 * @parm: the parameter for the verb
199 *
200 * Send a single command without waiting for response.
201 *
202 * Returns 0 if successful, or a negative error code.
203 */
204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
206 {
207 struct hda_bus *bus = codec->bus;
208 unsigned int res;
209 int err;
210
211 res = make_codec_cmd(codec, nid, direct, verb, parm);
212 snd_hda_power_up(codec);
213 mutex_lock(&bus->cmd_mutex);
214 err = bus->ops.command(bus, res);
215 mutex_unlock(&bus->cmd_mutex);
216 snd_hda_power_down(codec);
217 return err;
218 }
219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
220
221 /**
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
225 *
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
228 */
229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
230 {
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
233 }
234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
235
236 /**
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
239 * @nid: NID to parse
240 * @start_id: the pointer to store the start NID
241 *
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
244 */
245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
246 hda_nid_t *start_id)
247 {
248 unsigned int parm;
249
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
251 if (parm == -1)
252 return 0;
253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
255 }
256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
257
258 /**
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
261 * @nid: NID to parse
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
264 *
265 * Parses the connection list of the given widget and stores the list
266 * of NIDs.
267 *
268 * Returns the number of connections, or a negative error code.
269 */
270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
272 {
273 unsigned int parm;
274 int i, conn_len, conns;
275 unsigned int shift, num_elems, mask;
276 hda_nid_t prev_nid;
277
278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
279 return -EINVAL;
280
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
283 /* long form */
284 shift = 16;
285 num_elems = 2;
286 } else {
287 /* short form */
288 shift = 8;
289 num_elems = 4;
290 }
291 conn_len = parm & AC_CLIST_LENGTH;
292 mask = (1 << (shift-1)) - 1;
293
294 if (!conn_len)
295 return 0; /* no connection */
296
297 if (conn_len == 1) {
298 /* single connection */
299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, 0);
301 conn_list[0] = parm & mask;
302 return 1;
303 }
304
305 /* multi connection */
306 conns = 0;
307 prev_nid = 0;
308 for (i = 0; i < conn_len; i++) {
309 int range_val;
310 hda_nid_t val, n;
311
312 if (i % num_elems == 0)
313 parm = snd_hda_codec_read(codec, nid, 0,
314 AC_VERB_GET_CONNECT_LIST, i);
315 range_val = !!(parm & (1 << (shift-1))); /* ranges */
316 val = parm & mask;
317 parm >>= shift;
318 if (range_val) {
319 /* ranges between the previous and this one */
320 if (!prev_nid || prev_nid >= val) {
321 snd_printk(KERN_WARNING "hda_codec: "
322 "invalid dep_range_val %x:%x\n",
323 prev_nid, val);
324 continue;
325 }
326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
328 snd_printk(KERN_ERR
329 "Too many connections\n");
330 return -EINVAL;
331 }
332 conn_list[conns++] = n;
333 }
334 } else {
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
337 return -EINVAL;
338 }
339 conn_list[conns++] = val;
340 }
341 prev_nid = val;
342 }
343 return conns;
344 }
345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
346
347
348 /**
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
350 * @bus: the BUS
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
353 *
354 * Adds the given event to the queue. The events are processed in
355 * the workqueue asynchronously. Call this function in the interrupt
356 * hanlder when RIRB receives an unsolicited event.
357 *
358 * Returns 0 if successful, or a negative error code.
359 */
360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
361 {
362 struct hda_bus_unsolicited *unsol;
363 unsigned int wp;
364
365 unsol = bus->unsol;
366 if (!unsol)
367 return 0;
368
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
370 unsol->wp = wp;
371
372 wp <<= 1;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
375
376 queue_work(bus->workq, &unsol->work);
377
378 return 0;
379 }
380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
381
382 /*
383 * process queued unsolicited events
384 */
385 static void process_unsol_events(struct work_struct *work)
386 {
387 struct hda_bus_unsolicited *unsol =
388 container_of(work, struct hda_bus_unsolicited, work);
389 struct hda_bus *bus = unsol->bus;
390 struct hda_codec *codec;
391 unsigned int rp, caddr, res;
392
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
395 unsol->rp = rp;
396 rp <<= 1;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
400 continue;
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
404 }
405 }
406
407 /*
408 * initialize unsolicited queue
409 */
410 static int init_unsol_queue(struct hda_bus *bus)
411 {
412 struct hda_bus_unsolicited *unsol;
413
414 if (bus->unsol) /* already initialized */
415 return 0;
416
417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
418 if (!unsol) {
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
421 return -ENOMEM;
422 }
423 INIT_WORK(&unsol->work, process_unsol_events);
424 unsol->bus = bus;
425 bus->unsol = unsol;
426 return 0;
427 }
428
429 /*
430 * destructor
431 */
432 static void snd_hda_codec_free(struct hda_codec *codec);
433
434 static int snd_hda_bus_free(struct hda_bus *bus)
435 {
436 struct hda_codec *codec, *n;
437
438 if (!bus)
439 return 0;
440 if (bus->workq)
441 flush_workqueue(bus->workq);
442 if (bus->unsol)
443 kfree(bus->unsol);
444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
445 snd_hda_codec_free(codec);
446 }
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
449 if (bus->workq)
450 destroy_workqueue(bus->workq);
451 kfree(bus);
452 return 0;
453 }
454
455 static int snd_hda_bus_dev_free(struct snd_device *device)
456 {
457 struct hda_bus *bus = device->device_data;
458 bus->shutdown = 1;
459 return snd_hda_bus_free(bus);
460 }
461
462 #ifdef CONFIG_SND_HDA_HWDEP
463 static int snd_hda_bus_dev_register(struct snd_device *device)
464 {
465 struct hda_bus *bus = device->device_data;
466 struct hda_codec *codec;
467 list_for_each_entry(codec, &bus->codec_list, list) {
468 snd_hda_hwdep_add_sysfs(codec);
469 }
470 return 0;
471 }
472 #else
473 #define snd_hda_bus_dev_register NULL
474 #endif
475
476 /**
477 * snd_hda_bus_new - create a HDA bus
478 * @card: the card entry
479 * @temp: the template for hda_bus information
480 * @busp: the pointer to store the created bus instance
481 *
482 * Returns 0 if successful, or a negative error code.
483 */
484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
485 const struct hda_bus_template *temp,
486 struct hda_bus **busp)
487 {
488 struct hda_bus *bus;
489 int err;
490 static struct snd_device_ops dev_ops = {
491 .dev_register = snd_hda_bus_dev_register,
492 .dev_free = snd_hda_bus_dev_free,
493 };
494
495 if (snd_BUG_ON(!temp))
496 return -EINVAL;
497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
498 return -EINVAL;
499
500 if (busp)
501 *busp = NULL;
502
503 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
504 if (bus == NULL) {
505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
506 return -ENOMEM;
507 }
508
509 bus->card = card;
510 bus->private_data = temp->private_data;
511 bus->pci = temp->pci;
512 bus->modelname = temp->modelname;
513 bus->power_save = temp->power_save;
514 bus->ops = temp->ops;
515
516 mutex_init(&bus->cmd_mutex);
517 INIT_LIST_HEAD(&bus->codec_list);
518
519 snprintf(bus->workq_name, sizeof(bus->workq_name),
520 "hd-audio%d", card->number);
521 bus->workq = create_singlethread_workqueue(bus->workq_name);
522 if (!bus->workq) {
523 snd_printk(KERN_ERR "cannot create workqueue %s\n",
524 bus->workq_name);
525 kfree(bus);
526 return -ENOMEM;
527 }
528
529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
530 if (err < 0) {
531 snd_hda_bus_free(bus);
532 return err;
533 }
534 if (busp)
535 *busp = bus;
536 return 0;
537 }
538 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
539
540 #ifdef CONFIG_SND_HDA_GENERIC
541 #define is_generic_config(codec) \
542 (codec->modelname && !strcmp(codec->modelname, "generic"))
543 #else
544 #define is_generic_config(codec) 0
545 #endif
546
547 #ifdef MODULE
548 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
549 #else
550 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
551 #endif
552
553 /*
554 * find a matching codec preset
555 */
556 static const struct hda_codec_preset *
557 find_codec_preset(struct hda_codec *codec)
558 {
559 struct hda_codec_preset_list *tbl;
560 const struct hda_codec_preset *preset;
561 int mod_requested = 0;
562
563 if (is_generic_config(codec))
564 return NULL; /* use the generic parser */
565
566 again:
567 mutex_lock(&preset_mutex);
568 list_for_each_entry(tbl, &hda_preset_tables, list) {
569 if (!try_module_get(tbl->owner)) {
570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
571 continue;
572 }
573 for (preset = tbl->preset; preset->id; preset++) {
574 u32 mask = preset->mask;
575 if (preset->afg && preset->afg != codec->afg)
576 continue;
577 if (preset->mfg && preset->mfg != codec->mfg)
578 continue;
579 if (!mask)
580 mask = ~0;
581 if (preset->id == (codec->vendor_id & mask) &&
582 (!preset->rev ||
583 preset->rev == codec->revision_id)) {
584 mutex_unlock(&preset_mutex);
585 codec->owner = tbl->owner;
586 return preset;
587 }
588 }
589 module_put(tbl->owner);
590 }
591 mutex_unlock(&preset_mutex);
592
593 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
594 char name[32];
595 if (!mod_requested)
596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
597 codec->vendor_id);
598 else
599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
600 (codec->vendor_id >> 16) & 0xffff);
601 request_module(name);
602 mod_requested++;
603 goto again;
604 }
605 return NULL;
606 }
607
608 /*
609 * get_codec_name - store the codec name
610 */
611 static int get_codec_name(struct hda_codec *codec)
612 {
613 const struct hda_vendor_id *c;
614 const char *vendor = NULL;
615 u16 vendor_id = codec->vendor_id >> 16;
616 char tmp[16], name[32];
617
618 for (c = hda_vendor_ids; c->id; c++) {
619 if (c->id == vendor_id) {
620 vendor = c->name;
621 break;
622 }
623 }
624 if (!vendor) {
625 sprintf(tmp, "Generic %04x", vendor_id);
626 vendor = tmp;
627 }
628 if (codec->preset && codec->preset->name)
629 snprintf(name, sizeof(name), "%s %s", vendor,
630 codec->preset->name);
631 else
632 snprintf(name, sizeof(name), "%s ID %x", vendor,
633 codec->vendor_id & 0xffff);
634 codec->name = kstrdup(name, GFP_KERNEL);
635 if (!codec->name)
636 return -ENOMEM;
637 return 0;
638 }
639
640 /*
641 * look for an AFG and MFG nodes
642 */
643 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
644 {
645 int i, total_nodes;
646 hda_nid_t nid;
647
648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
649 for (i = 0; i < total_nodes; i++, nid++) {
650 unsigned int func;
651 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
652 switch (func & 0xff) {
653 case AC_GRP_AUDIO_FUNCTION:
654 codec->afg = nid;
655 break;
656 case AC_GRP_MODEM_FUNCTION:
657 codec->mfg = nid;
658 break;
659 default:
660 break;
661 }
662 }
663 }
664
665 /*
666 * read widget caps for each widget and store in cache
667 */
668 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
669 {
670 int i;
671 hda_nid_t nid;
672
673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
674 &codec->start_nid);
675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
676 if (!codec->wcaps)
677 return -ENOMEM;
678 nid = codec->start_nid;
679 for (i = 0; i < codec->num_nodes; i++, nid++)
680 codec->wcaps[i] = snd_hda_param_read(codec, nid,
681 AC_PAR_AUDIO_WIDGET_CAP);
682 return 0;
683 }
684
685
686 static void init_hda_cache(struct hda_cache_rec *cache,
687 unsigned int record_size);
688 static void free_hda_cache(struct hda_cache_rec *cache);
689
690 /*
691 * codec destructor
692 */
693 static void snd_hda_codec_free(struct hda_codec *codec)
694 {
695 if (!codec)
696 return;
697 #ifdef CONFIG_SND_HDA_POWER_SAVE
698 cancel_delayed_work(&codec->power_work);
699 flush_workqueue(codec->bus->workq);
700 #endif
701 list_del(&codec->list);
702 snd_array_free(&codec->mixers);
703 codec->bus->caddr_tbl[codec->addr] = NULL;
704 if (codec->patch_ops.free)
705 codec->patch_ops.free(codec);
706 module_put(codec->owner);
707 free_hda_cache(&codec->amp_cache);
708 free_hda_cache(&codec->cmd_cache);
709 kfree(codec->name);
710 kfree(codec->modelname);
711 kfree(codec->wcaps);
712 kfree(codec);
713 }
714
715 /**
716 * snd_hda_codec_new - create a HDA codec
717 * @bus: the bus to assign
718 * @codec_addr: the codec address
719 * @codecp: the pointer to store the generated codec
720 *
721 * Returns 0 if successful, or a negative error code.
722 */
723 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
724 int do_init, struct hda_codec **codecp)
725 {
726 struct hda_codec *codec;
727 char component[31];
728 int err;
729
730 if (snd_BUG_ON(!bus))
731 return -EINVAL;
732 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
733 return -EINVAL;
734
735 if (bus->caddr_tbl[codec_addr]) {
736 snd_printk(KERN_ERR "hda_codec: "
737 "address 0x%x is already occupied\n", codec_addr);
738 return -EBUSY;
739 }
740
741 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
742 if (codec == NULL) {
743 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
744 return -ENOMEM;
745 }
746
747 codec->bus = bus;
748 codec->addr = codec_addr;
749 mutex_init(&codec->spdif_mutex);
750 mutex_init(&codec->control_mutex);
751 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
752 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
753 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
754 if (codec->bus->modelname) {
755 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
756 if (!codec->modelname) {
757 snd_hda_codec_free(codec);
758 return -ENODEV;
759 }
760 }
761
762 #ifdef CONFIG_SND_HDA_POWER_SAVE
763 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
764 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
765 * the caller has to power down appropriatley after initialization
766 * phase.
767 */
768 hda_keep_power_on(codec);
769 #endif
770
771 list_add_tail(&codec->list, &bus->codec_list);
772 bus->caddr_tbl[codec_addr] = codec;
773
774 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
775 AC_PAR_VENDOR_ID);
776 if (codec->vendor_id == -1)
777 /* read again, hopefully the access method was corrected
778 * in the last read...
779 */
780 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
781 AC_PAR_VENDOR_ID);
782 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
783 AC_PAR_SUBSYSTEM_ID);
784 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
785 AC_PAR_REV_ID);
786
787 setup_fg_nodes(codec);
788 if (!codec->afg && !codec->mfg) {
789 snd_printdd("hda_codec: no AFG or MFG node found\n");
790 snd_hda_codec_free(codec);
791 return -ENODEV;
792 }
793
794 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
795 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
796 snd_hda_codec_free(codec);
797 return -ENOMEM;
798 }
799
800 if (!codec->subsystem_id) {
801 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
802 codec->subsystem_id =
803 snd_hda_codec_read(codec, nid, 0,
804 AC_VERB_GET_SUBSYSTEM_ID, 0);
805 }
806 if (bus->modelname)
807 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
808
809 if (do_init) {
810 err = snd_hda_codec_configure(codec);
811 if (err < 0) {
812 snd_hda_codec_free(codec);
813 return err;
814 }
815 }
816 snd_hda_codec_proc_new(codec);
817
818 snd_hda_create_hwdep(codec);
819
820 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
821 codec->subsystem_id, codec->revision_id);
822 snd_component_add(codec->bus->card, component);
823
824 if (codecp)
825 *codecp = codec;
826 return 0;
827 }
828 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
829
830 int snd_hda_codec_configure(struct hda_codec *codec)
831 {
832 int err;
833
834 codec->preset = find_codec_preset(codec);
835 if (!codec->name) {
836 err = get_codec_name(codec);
837 if (err < 0)
838 return err;
839 }
840 /* audio codec should override the mixer name */
841 if (codec->afg || !*codec->bus->card->mixername)
842 strlcpy(codec->bus->card->mixername, codec->name,
843 sizeof(codec->bus->card->mixername));
844
845 if (is_generic_config(codec)) {
846 err = snd_hda_parse_generic_codec(codec);
847 goto patched;
848 }
849 if (codec->preset && codec->preset->patch) {
850 err = codec->preset->patch(codec);
851 goto patched;
852 }
853
854 /* call the default parser */
855 err = snd_hda_parse_generic_codec(codec);
856 if (err < 0)
857 printk(KERN_ERR "hda-codec: No codec parser is available\n");
858
859 patched:
860 if (!err && codec->patch_ops.unsol_event)
861 err = init_unsol_queue(codec->bus);
862 return err;
863 }
864
865 /**
866 * snd_hda_codec_setup_stream - set up the codec for streaming
867 * @codec: the CODEC to set up
868 * @nid: the NID to set up
869 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
870 * @channel_id: channel id to pass, zero based.
871 * @format: stream format.
872 */
873 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
874 u32 stream_tag,
875 int channel_id, int format)
876 {
877 if (!nid)
878 return;
879
880 snd_printdd("hda_codec_setup_stream: "
881 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
882 nid, stream_tag, channel_id, format);
883 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
884 (stream_tag << 4) | channel_id);
885 msleep(1);
886 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
887 }
888 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
889
890 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
891 {
892 if (!nid)
893 return;
894
895 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
896 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
897 #if 0 /* keep the format */
898 msleep(1);
899 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
900 #endif
901 }
902 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
903
904 /*
905 * amp access functions
906 */
907
908 /* FIXME: more better hash key? */
909 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
910 #define INFO_AMP_CAPS (1<<0)
911 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
912
913 /* initialize the hash table */
914 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
915 unsigned int record_size)
916 {
917 memset(cache, 0, sizeof(*cache));
918 memset(cache->hash, 0xff, sizeof(cache->hash));
919 snd_array_init(&cache->buf, record_size, 64);
920 }
921
922 static void free_hda_cache(struct hda_cache_rec *cache)
923 {
924 snd_array_free(&cache->buf);
925 }
926
927 /* query the hash. allocate an entry if not found. */
928 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
929 u32 key)
930 {
931 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
932 u16 cur = cache->hash[idx];
933 struct hda_cache_head *info;
934
935 while (cur != 0xffff) {
936 info = snd_array_elem(&cache->buf, cur);
937 if (info->key == key)
938 return info;
939 cur = info->next;
940 }
941
942 /* add a new hash entry */
943 info = snd_array_new(&cache->buf);
944 if (!info)
945 return NULL;
946 cur = snd_array_index(&cache->buf, info);
947 info->key = key;
948 info->val = 0;
949 info->next = cache->hash[idx];
950 cache->hash[idx] = cur;
951
952 return info;
953 }
954
955 /* query and allocate an amp hash entry */
956 static inline struct hda_amp_info *
957 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
958 {
959 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
960 }
961
962 /*
963 * query AMP capabilities for the given widget and direction
964 */
965 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
966 {
967 struct hda_amp_info *info;
968
969 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
970 if (!info)
971 return 0;
972 if (!(info->head.val & INFO_AMP_CAPS)) {
973 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
974 nid = codec->afg;
975 info->amp_caps = snd_hda_param_read(codec, nid,
976 direction == HDA_OUTPUT ?
977 AC_PAR_AMP_OUT_CAP :
978 AC_PAR_AMP_IN_CAP);
979 if (info->amp_caps)
980 info->head.val |= INFO_AMP_CAPS;
981 }
982 return info->amp_caps;
983 }
984 EXPORT_SYMBOL_HDA(query_amp_caps);
985
986 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
987 unsigned int caps)
988 {
989 struct hda_amp_info *info;
990
991 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
992 if (!info)
993 return -EINVAL;
994 info->amp_caps = caps;
995 info->head.val |= INFO_AMP_CAPS;
996 return 0;
997 }
998 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
999
1000 /*
1001 * read the current volume to info
1002 * if the cache exists, read the cache value.
1003 */
1004 static unsigned int get_vol_mute(struct hda_codec *codec,
1005 struct hda_amp_info *info, hda_nid_t nid,
1006 int ch, int direction, int index)
1007 {
1008 u32 val, parm;
1009
1010 if (info->head.val & INFO_AMP_VOL(ch))
1011 return info->vol[ch];
1012
1013 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1014 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1015 parm |= index;
1016 val = snd_hda_codec_read(codec, nid, 0,
1017 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1018 info->vol[ch] = val & 0xff;
1019 info->head.val |= INFO_AMP_VOL(ch);
1020 return info->vol[ch];
1021 }
1022
1023 /*
1024 * write the current volume in info to the h/w and update the cache
1025 */
1026 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1027 hda_nid_t nid, int ch, int direction, int index,
1028 int val)
1029 {
1030 u32 parm;
1031
1032 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1033 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1034 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1035 parm |= val;
1036 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1037 info->vol[ch] = val;
1038 }
1039
1040 /*
1041 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1042 */
1043 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1044 int direction, int index)
1045 {
1046 struct hda_amp_info *info;
1047 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1048 if (!info)
1049 return 0;
1050 return get_vol_mute(codec, info, nid, ch, direction, index);
1051 }
1052 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1053
1054 /*
1055 * update the AMP value, mask = bit mask to set, val = the value
1056 */
1057 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1058 int direction, int idx, int mask, int val)
1059 {
1060 struct hda_amp_info *info;
1061
1062 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1063 if (!info)
1064 return 0;
1065 val &= mask;
1066 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1067 if (info->vol[ch] == val)
1068 return 0;
1069 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1070 return 1;
1071 }
1072 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1073
1074 /*
1075 * update the AMP stereo with the same mask and value
1076 */
1077 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1078 int direction, int idx, int mask, int val)
1079 {
1080 int ch, ret = 0;
1081 for (ch = 0; ch < 2; ch++)
1082 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1083 idx, mask, val);
1084 return ret;
1085 }
1086 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1087
1088 #ifdef SND_HDA_NEEDS_RESUME
1089 /* resume the all amp commands from the cache */
1090 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1091 {
1092 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1093 int i;
1094
1095 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1096 u32 key = buffer->head.key;
1097 hda_nid_t nid;
1098 unsigned int idx, dir, ch;
1099 if (!key)
1100 continue;
1101 nid = key & 0xff;
1102 idx = (key >> 16) & 0xff;
1103 dir = (key >> 24) & 0xff;
1104 for (ch = 0; ch < 2; ch++) {
1105 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1106 continue;
1107 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1108 buffer->vol[ch]);
1109 }
1110 }
1111 }
1112 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1113 #endif /* SND_HDA_NEEDS_RESUME */
1114
1115 /* volume */
1116 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1117 struct snd_ctl_elem_info *uinfo)
1118 {
1119 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1120 u16 nid = get_amp_nid(kcontrol);
1121 u8 chs = get_amp_channels(kcontrol);
1122 int dir = get_amp_direction(kcontrol);
1123 u32 caps;
1124
1125 caps = query_amp_caps(codec, nid, dir);
1126 /* num steps */
1127 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1128 if (!caps) {
1129 printk(KERN_WARNING "hda_codec: "
1130 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1131 kcontrol->id.name);
1132 return -EINVAL;
1133 }
1134 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1135 uinfo->count = chs == 3 ? 2 : 1;
1136 uinfo->value.integer.min = 0;
1137 uinfo->value.integer.max = caps;
1138 return 0;
1139 }
1140 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1141
1142 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1143 struct snd_ctl_elem_value *ucontrol)
1144 {
1145 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1146 hda_nid_t nid = get_amp_nid(kcontrol);
1147 int chs = get_amp_channels(kcontrol);
1148 int dir = get_amp_direction(kcontrol);
1149 int idx = get_amp_index(kcontrol);
1150 long *valp = ucontrol->value.integer.value;
1151
1152 if (chs & 1)
1153 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1154 & HDA_AMP_VOLMASK;
1155 if (chs & 2)
1156 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1157 & HDA_AMP_VOLMASK;
1158 return 0;
1159 }
1160 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1161
1162 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1163 struct snd_ctl_elem_value *ucontrol)
1164 {
1165 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1166 hda_nid_t nid = get_amp_nid(kcontrol);
1167 int chs = get_amp_channels(kcontrol);
1168 int dir = get_amp_direction(kcontrol);
1169 int idx = get_amp_index(kcontrol);
1170 long *valp = ucontrol->value.integer.value;
1171 int change = 0;
1172
1173 snd_hda_power_up(codec);
1174 if (chs & 1) {
1175 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1176 0x7f, *valp);
1177 valp++;
1178 }
1179 if (chs & 2)
1180 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1181 0x7f, *valp);
1182 snd_hda_power_down(codec);
1183 return change;
1184 }
1185 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1186
1187 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1188 unsigned int size, unsigned int __user *_tlv)
1189 {
1190 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1191 hda_nid_t nid = get_amp_nid(kcontrol);
1192 int dir = get_amp_direction(kcontrol);
1193 u32 caps, val1, val2;
1194
1195 if (size < 4 * sizeof(unsigned int))
1196 return -ENOMEM;
1197 caps = query_amp_caps(codec, nid, dir);
1198 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1199 val2 = (val2 + 1) * 25;
1200 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1201 val1 = ((int)val1) * ((int)val2);
1202 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1203 return -EFAULT;
1204 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1205 return -EFAULT;
1206 if (put_user(val1, _tlv + 2))
1207 return -EFAULT;
1208 if (put_user(val2, _tlv + 3))
1209 return -EFAULT;
1210 return 0;
1211 }
1212 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1213
1214 /*
1215 * set (static) TLV for virtual master volume; recalculated as max 0dB
1216 */
1217 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1218 unsigned int *tlv)
1219 {
1220 u32 caps;
1221 int nums, step;
1222
1223 caps = query_amp_caps(codec, nid, dir);
1224 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1225 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1226 step = (step + 1) * 25;
1227 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1228 tlv[1] = 2 * sizeof(unsigned int);
1229 tlv[2] = -nums * step;
1230 tlv[3] = step;
1231 }
1232 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1233
1234 /* find a mixer control element with the given name */
1235 static struct snd_kcontrol *
1236 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1237 const char *name, int idx)
1238 {
1239 struct snd_ctl_elem_id id;
1240 memset(&id, 0, sizeof(id));
1241 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1242 id.index = idx;
1243 strcpy(id.name, name);
1244 return snd_ctl_find_id(codec->bus->card, &id);
1245 }
1246
1247 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1248 const char *name)
1249 {
1250 return _snd_hda_find_mixer_ctl(codec, name, 0);
1251 }
1252 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1253
1254 /* Add a control element and assign to the codec */
1255 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1256 {
1257 int err;
1258 struct snd_kcontrol **knewp;
1259
1260 err = snd_ctl_add(codec->bus->card, kctl);
1261 if (err < 0)
1262 return err;
1263 knewp = snd_array_new(&codec->mixers);
1264 if (!knewp)
1265 return -ENOMEM;
1266 *knewp = kctl;
1267 return 0;
1268 }
1269 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1270
1271 #ifdef CONFIG_SND_HDA_RECONFIG
1272 /* Clear all controls assigned to the given codec */
1273 void snd_hda_ctls_clear(struct hda_codec *codec)
1274 {
1275 int i;
1276 struct snd_kcontrol **kctls = codec->mixers.list;
1277 for (i = 0; i < codec->mixers.used; i++)
1278 snd_ctl_remove(codec->bus->card, kctls[i]);
1279 snd_array_free(&codec->mixers);
1280 }
1281
1282 void snd_hda_codec_reset(struct hda_codec *codec)
1283 {
1284 int i;
1285
1286 #ifdef CONFIG_SND_HDA_POWER_SAVE
1287 cancel_delayed_work(&codec->power_work);
1288 flush_workqueue(codec->bus->workq);
1289 #endif
1290 snd_hda_ctls_clear(codec);
1291 /* relase PCMs */
1292 for (i = 0; i < codec->num_pcms; i++) {
1293 if (codec->pcm_info[i].pcm) {
1294 snd_device_free(codec->bus->card,
1295 codec->pcm_info[i].pcm);
1296 clear_bit(codec->pcm_info[i].device,
1297 codec->bus->pcm_dev_bits);
1298 }
1299 }
1300 if (codec->patch_ops.free)
1301 codec->patch_ops.free(codec);
1302 codec->proc_widget_hook = NULL;
1303 codec->spec = NULL;
1304 free_hda_cache(&codec->amp_cache);
1305 free_hda_cache(&codec->cmd_cache);
1306 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1307 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1308 codec->num_pcms = 0;
1309 codec->pcm_info = NULL;
1310 codec->preset = NULL;
1311 module_put(codec->owner);
1312 codec->owner = NULL;
1313 }
1314 #endif /* CONFIG_SND_HDA_RECONFIG */
1315
1316 /* create a virtual master control and add slaves */
1317 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1318 unsigned int *tlv, const char **slaves)
1319 {
1320 struct snd_kcontrol *kctl;
1321 const char **s;
1322 int err;
1323
1324 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1325 ;
1326 if (!*s) {
1327 snd_printdd("No slave found for %s\n", name);
1328 return 0;
1329 }
1330 kctl = snd_ctl_make_virtual_master(name, tlv);
1331 if (!kctl)
1332 return -ENOMEM;
1333 err = snd_hda_ctl_add(codec, kctl);
1334 if (err < 0)
1335 return err;
1336
1337 for (s = slaves; *s; s++) {
1338 struct snd_kcontrol *sctl;
1339
1340 sctl = snd_hda_find_mixer_ctl(codec, *s);
1341 if (!sctl) {
1342 snd_printdd("Cannot find slave %s, skipped\n", *s);
1343 continue;
1344 }
1345 err = snd_ctl_add_slave(kctl, sctl);
1346 if (err < 0)
1347 return err;
1348 }
1349 return 0;
1350 }
1351 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1352
1353 /* switch */
1354 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1355 struct snd_ctl_elem_info *uinfo)
1356 {
1357 int chs = get_amp_channels(kcontrol);
1358
1359 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1360 uinfo->count = chs == 3 ? 2 : 1;
1361 uinfo->value.integer.min = 0;
1362 uinfo->value.integer.max = 1;
1363 return 0;
1364 }
1365 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1366
1367 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1368 struct snd_ctl_elem_value *ucontrol)
1369 {
1370 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1371 hda_nid_t nid = get_amp_nid(kcontrol);
1372 int chs = get_amp_channels(kcontrol);
1373 int dir = get_amp_direction(kcontrol);
1374 int idx = get_amp_index(kcontrol);
1375 long *valp = ucontrol->value.integer.value;
1376
1377 if (chs & 1)
1378 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1379 HDA_AMP_MUTE) ? 0 : 1;
1380 if (chs & 2)
1381 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1382 HDA_AMP_MUTE) ? 0 : 1;
1383 return 0;
1384 }
1385 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1386
1387 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1388 struct snd_ctl_elem_value *ucontrol)
1389 {
1390 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1391 hda_nid_t nid = get_amp_nid(kcontrol);
1392 int chs = get_amp_channels(kcontrol);
1393 int dir = get_amp_direction(kcontrol);
1394 int idx = get_amp_index(kcontrol);
1395 long *valp = ucontrol->value.integer.value;
1396 int change = 0;
1397
1398 snd_hda_power_up(codec);
1399 if (chs & 1) {
1400 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1401 HDA_AMP_MUTE,
1402 *valp ? 0 : HDA_AMP_MUTE);
1403 valp++;
1404 }
1405 if (chs & 2)
1406 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1407 HDA_AMP_MUTE,
1408 *valp ? 0 : HDA_AMP_MUTE);
1409 #ifdef CONFIG_SND_HDA_POWER_SAVE
1410 if (codec->patch_ops.check_power_status)
1411 codec->patch_ops.check_power_status(codec, nid);
1412 #endif
1413 snd_hda_power_down(codec);
1414 return change;
1415 }
1416 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1417
1418 /*
1419 * bound volume controls
1420 *
1421 * bind multiple volumes (# indices, from 0)
1422 */
1423
1424 #define AMP_VAL_IDX_SHIFT 19
1425 #define AMP_VAL_IDX_MASK (0x0f<<19)
1426
1427 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1428 struct snd_ctl_elem_value *ucontrol)
1429 {
1430 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1431 unsigned long pval;
1432 int err;
1433
1434 mutex_lock(&codec->control_mutex);
1435 pval = kcontrol->private_value;
1436 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1437 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1438 kcontrol->private_value = pval;
1439 mutex_unlock(&codec->control_mutex);
1440 return err;
1441 }
1442 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1443
1444 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1445 struct snd_ctl_elem_value *ucontrol)
1446 {
1447 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1448 unsigned long pval;
1449 int i, indices, err = 0, change = 0;
1450
1451 mutex_lock(&codec->control_mutex);
1452 pval = kcontrol->private_value;
1453 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1454 for (i = 0; i < indices; i++) {
1455 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1456 (i << AMP_VAL_IDX_SHIFT);
1457 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1458 if (err < 0)
1459 break;
1460 change |= err;
1461 }
1462 kcontrol->private_value = pval;
1463 mutex_unlock(&codec->control_mutex);
1464 return err < 0 ? err : change;
1465 }
1466 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1467
1468 /*
1469 * generic bound volume/swtich controls
1470 */
1471 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1472 struct snd_ctl_elem_info *uinfo)
1473 {
1474 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1475 struct hda_bind_ctls *c;
1476 int err;
1477
1478 mutex_lock(&codec->control_mutex);
1479 c = (struct hda_bind_ctls *)kcontrol->private_value;
1480 kcontrol->private_value = *c->values;
1481 err = c->ops->info(kcontrol, uinfo);
1482 kcontrol->private_value = (long)c;
1483 mutex_unlock(&codec->control_mutex);
1484 return err;
1485 }
1486 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1487
1488 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1489 struct snd_ctl_elem_value *ucontrol)
1490 {
1491 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1492 struct hda_bind_ctls *c;
1493 int err;
1494
1495 mutex_lock(&codec->control_mutex);
1496 c = (struct hda_bind_ctls *)kcontrol->private_value;
1497 kcontrol->private_value = *c->values;
1498 err = c->ops->get(kcontrol, ucontrol);
1499 kcontrol->private_value = (long)c;
1500 mutex_unlock(&codec->control_mutex);
1501 return err;
1502 }
1503 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1504
1505 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1506 struct snd_ctl_elem_value *ucontrol)
1507 {
1508 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1509 struct hda_bind_ctls *c;
1510 unsigned long *vals;
1511 int err = 0, change = 0;
1512
1513 mutex_lock(&codec->control_mutex);
1514 c = (struct hda_bind_ctls *)kcontrol->private_value;
1515 for (vals = c->values; *vals; vals++) {
1516 kcontrol->private_value = *vals;
1517 err = c->ops->put(kcontrol, ucontrol);
1518 if (err < 0)
1519 break;
1520 change |= err;
1521 }
1522 kcontrol->private_value = (long)c;
1523 mutex_unlock(&codec->control_mutex);
1524 return err < 0 ? err : change;
1525 }
1526 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1527
1528 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1529 unsigned int size, unsigned int __user *tlv)
1530 {
1531 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1532 struct hda_bind_ctls *c;
1533 int err;
1534
1535 mutex_lock(&codec->control_mutex);
1536 c = (struct hda_bind_ctls *)kcontrol->private_value;
1537 kcontrol->private_value = *c->values;
1538 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1539 kcontrol->private_value = (long)c;
1540 mutex_unlock(&codec->control_mutex);
1541 return err;
1542 }
1543 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1544
1545 struct hda_ctl_ops snd_hda_bind_vol = {
1546 .info = snd_hda_mixer_amp_volume_info,
1547 .get = snd_hda_mixer_amp_volume_get,
1548 .put = snd_hda_mixer_amp_volume_put,
1549 .tlv = snd_hda_mixer_amp_tlv
1550 };
1551 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1552
1553 struct hda_ctl_ops snd_hda_bind_sw = {
1554 .info = snd_hda_mixer_amp_switch_info,
1555 .get = snd_hda_mixer_amp_switch_get,
1556 .put = snd_hda_mixer_amp_switch_put,
1557 .tlv = snd_hda_mixer_amp_tlv
1558 };
1559 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1560
1561 /*
1562 * SPDIF out controls
1563 */
1564
1565 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1566 struct snd_ctl_elem_info *uinfo)
1567 {
1568 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1569 uinfo->count = 1;
1570 return 0;
1571 }
1572
1573 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1574 struct snd_ctl_elem_value *ucontrol)
1575 {
1576 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1577 IEC958_AES0_NONAUDIO |
1578 IEC958_AES0_CON_EMPHASIS_5015 |
1579 IEC958_AES0_CON_NOT_COPYRIGHT;
1580 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1581 IEC958_AES1_CON_ORIGINAL;
1582 return 0;
1583 }
1584
1585 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1586 struct snd_ctl_elem_value *ucontrol)
1587 {
1588 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1589 IEC958_AES0_NONAUDIO |
1590 IEC958_AES0_PRO_EMPHASIS_5015;
1591 return 0;
1592 }
1593
1594 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1595 struct snd_ctl_elem_value *ucontrol)
1596 {
1597 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1598
1599 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1600 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1601 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1602 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1603
1604 return 0;
1605 }
1606
1607 /* convert from SPDIF status bits to HDA SPDIF bits
1608 * bit 0 (DigEn) is always set zero (to be filled later)
1609 */
1610 static unsigned short convert_from_spdif_status(unsigned int sbits)
1611 {
1612 unsigned short val = 0;
1613
1614 if (sbits & IEC958_AES0_PROFESSIONAL)
1615 val |= AC_DIG1_PROFESSIONAL;
1616 if (sbits & IEC958_AES0_NONAUDIO)
1617 val |= AC_DIG1_NONAUDIO;
1618 if (sbits & IEC958_AES0_PROFESSIONAL) {
1619 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1620 IEC958_AES0_PRO_EMPHASIS_5015)
1621 val |= AC_DIG1_EMPHASIS;
1622 } else {
1623 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1624 IEC958_AES0_CON_EMPHASIS_5015)
1625 val |= AC_DIG1_EMPHASIS;
1626 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1627 val |= AC_DIG1_COPYRIGHT;
1628 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1629 val |= AC_DIG1_LEVEL;
1630 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1631 }
1632 return val;
1633 }
1634
1635 /* convert to SPDIF status bits from HDA SPDIF bits
1636 */
1637 static unsigned int convert_to_spdif_status(unsigned short val)
1638 {
1639 unsigned int sbits = 0;
1640
1641 if (val & AC_DIG1_NONAUDIO)
1642 sbits |= IEC958_AES0_NONAUDIO;
1643 if (val & AC_DIG1_PROFESSIONAL)
1644 sbits |= IEC958_AES0_PROFESSIONAL;
1645 if (sbits & IEC958_AES0_PROFESSIONAL) {
1646 if (sbits & AC_DIG1_EMPHASIS)
1647 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1648 } else {
1649 if (val & AC_DIG1_EMPHASIS)
1650 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1651 if (!(val & AC_DIG1_COPYRIGHT))
1652 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1653 if (val & AC_DIG1_LEVEL)
1654 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1655 sbits |= val & (0x7f << 8);
1656 }
1657 return sbits;
1658 }
1659
1660 /* set digital convert verbs both for the given NID and its slaves */
1661 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1662 int verb, int val)
1663 {
1664 hda_nid_t *d;
1665
1666 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1667 d = codec->slave_dig_outs;
1668 if (!d)
1669 return;
1670 for (; *d; d++)
1671 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1672 }
1673
1674 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1675 int dig1, int dig2)
1676 {
1677 if (dig1 != -1)
1678 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1679 if (dig2 != -1)
1680 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1681 }
1682
1683 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1684 struct snd_ctl_elem_value *ucontrol)
1685 {
1686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1687 hda_nid_t nid = kcontrol->private_value;
1688 unsigned short val;
1689 int change;
1690
1691 mutex_lock(&codec->spdif_mutex);
1692 codec->spdif_status = ucontrol->value.iec958.status[0] |
1693 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1694 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1695 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1696 val = convert_from_spdif_status(codec->spdif_status);
1697 val |= codec->spdif_ctls & 1;
1698 change = codec->spdif_ctls != val;
1699 codec->spdif_ctls = val;
1700
1701 if (change)
1702 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1703
1704 mutex_unlock(&codec->spdif_mutex);
1705 return change;
1706 }
1707
1708 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1709
1710 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1711 struct snd_ctl_elem_value *ucontrol)
1712 {
1713 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1714
1715 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1716 return 0;
1717 }
1718
1719 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1720 struct snd_ctl_elem_value *ucontrol)
1721 {
1722 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1723 hda_nid_t nid = kcontrol->private_value;
1724 unsigned short val;
1725 int change;
1726
1727 mutex_lock(&codec->spdif_mutex);
1728 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1729 if (ucontrol->value.integer.value[0])
1730 val |= AC_DIG1_ENABLE;
1731 change = codec->spdif_ctls != val;
1732 if (change) {
1733 codec->spdif_ctls = val;
1734 set_dig_out_convert(codec, nid, val & 0xff, -1);
1735 /* unmute amp switch (if any) */
1736 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1737 (val & AC_DIG1_ENABLE))
1738 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1739 HDA_AMP_MUTE, 0);
1740 }
1741 mutex_unlock(&codec->spdif_mutex);
1742 return change;
1743 }
1744
1745 static struct snd_kcontrol_new dig_mixes[] = {
1746 {
1747 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1749 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1750 .info = snd_hda_spdif_mask_info,
1751 .get = snd_hda_spdif_cmask_get,
1752 },
1753 {
1754 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1756 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1757 .info = snd_hda_spdif_mask_info,
1758 .get = snd_hda_spdif_pmask_get,
1759 },
1760 {
1761 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1762 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1763 .info = snd_hda_spdif_mask_info,
1764 .get = snd_hda_spdif_default_get,
1765 .put = snd_hda_spdif_default_put,
1766 },
1767 {
1768 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1769 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1770 .info = snd_hda_spdif_out_switch_info,
1771 .get = snd_hda_spdif_out_switch_get,
1772 .put = snd_hda_spdif_out_switch_put,
1773 },
1774 { } /* end */
1775 };
1776
1777 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1778
1779 /**
1780 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1781 * @codec: the HDA codec
1782 * @nid: audio out widget NID
1783 *
1784 * Creates controls related with the SPDIF output.
1785 * Called from each patch supporting the SPDIF out.
1786 *
1787 * Returns 0 if successful, or a negative error code.
1788 */
1789 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1790 {
1791 int err;
1792 struct snd_kcontrol *kctl;
1793 struct snd_kcontrol_new *dig_mix;
1794 int idx;
1795
1796 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1797 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1798 idx))
1799 break;
1800 }
1801 if (idx >= SPDIF_MAX_IDX) {
1802 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1803 return -EBUSY;
1804 }
1805 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1806 kctl = snd_ctl_new1(dig_mix, codec);
1807 if (!kctl)
1808 return -ENOMEM;
1809 kctl->id.index = idx;
1810 kctl->private_value = nid;
1811 err = snd_hda_ctl_add(codec, kctl);
1812 if (err < 0)
1813 return err;
1814 }
1815 codec->spdif_ctls =
1816 snd_hda_codec_read(codec, nid, 0,
1817 AC_VERB_GET_DIGI_CONVERT_1, 0);
1818 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1819 return 0;
1820 }
1821 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1822
1823 /*
1824 * SPDIF sharing with analog output
1825 */
1826 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1827 struct snd_ctl_elem_value *ucontrol)
1828 {
1829 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1830 ucontrol->value.integer.value[0] = mout->share_spdif;
1831 return 0;
1832 }
1833
1834 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1835 struct snd_ctl_elem_value *ucontrol)
1836 {
1837 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1838 mout->share_spdif = !!ucontrol->value.integer.value[0];
1839 return 0;
1840 }
1841
1842 static struct snd_kcontrol_new spdif_share_sw = {
1843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1844 .name = "IEC958 Default PCM Playback Switch",
1845 .info = snd_ctl_boolean_mono_info,
1846 .get = spdif_share_sw_get,
1847 .put = spdif_share_sw_put,
1848 };
1849
1850 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1851 struct hda_multi_out *mout)
1852 {
1853 if (!mout->dig_out_nid)
1854 return 0;
1855 /* ATTENTION: here mout is passed as private_data, instead of codec */
1856 return snd_hda_ctl_add(codec,
1857 snd_ctl_new1(&spdif_share_sw, mout));
1858 }
1859 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1860
1861 /*
1862 * SPDIF input
1863 */
1864
1865 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1866
1867 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1868 struct snd_ctl_elem_value *ucontrol)
1869 {
1870 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1871
1872 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1873 return 0;
1874 }
1875
1876 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1877 struct snd_ctl_elem_value *ucontrol)
1878 {
1879 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1880 hda_nid_t nid = kcontrol->private_value;
1881 unsigned int val = !!ucontrol->value.integer.value[0];
1882 int change;
1883
1884 mutex_lock(&codec->spdif_mutex);
1885 change = codec->spdif_in_enable != val;
1886 if (change) {
1887 codec->spdif_in_enable = val;
1888 snd_hda_codec_write_cache(codec, nid, 0,
1889 AC_VERB_SET_DIGI_CONVERT_1, val);
1890 }
1891 mutex_unlock(&codec->spdif_mutex);
1892 return change;
1893 }
1894
1895 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_value *ucontrol)
1897 {
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1899 hda_nid_t nid = kcontrol->private_value;
1900 unsigned short val;
1901 unsigned int sbits;
1902
1903 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1904 sbits = convert_to_spdif_status(val);
1905 ucontrol->value.iec958.status[0] = sbits;
1906 ucontrol->value.iec958.status[1] = sbits >> 8;
1907 ucontrol->value.iec958.status[2] = sbits >> 16;
1908 ucontrol->value.iec958.status[3] = sbits >> 24;
1909 return 0;
1910 }
1911
1912 static struct snd_kcontrol_new dig_in_ctls[] = {
1913 {
1914 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1915 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1916 .info = snd_hda_spdif_in_switch_info,
1917 .get = snd_hda_spdif_in_switch_get,
1918 .put = snd_hda_spdif_in_switch_put,
1919 },
1920 {
1921 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1922 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1923 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1924 .info = snd_hda_spdif_mask_info,
1925 .get = snd_hda_spdif_in_status_get,
1926 },
1927 { } /* end */
1928 };
1929
1930 /**
1931 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1932 * @codec: the HDA codec
1933 * @nid: audio in widget NID
1934 *
1935 * Creates controls related with the SPDIF input.
1936 * Called from each patch supporting the SPDIF in.
1937 *
1938 * Returns 0 if successful, or a negative error code.
1939 */
1940 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1941 {
1942 int err;
1943 struct snd_kcontrol *kctl;
1944 struct snd_kcontrol_new *dig_mix;
1945 int idx;
1946
1947 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1948 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1949 idx))
1950 break;
1951 }
1952 if (idx >= SPDIF_MAX_IDX) {
1953 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1954 return -EBUSY;
1955 }
1956 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1957 kctl = snd_ctl_new1(dig_mix, codec);
1958 kctl->private_value = nid;
1959 err = snd_hda_ctl_add(codec, kctl);
1960 if (err < 0)
1961 return err;
1962 }
1963 codec->spdif_in_enable =
1964 snd_hda_codec_read(codec, nid, 0,
1965 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1966 AC_DIG1_ENABLE;
1967 return 0;
1968 }
1969 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1970
1971 #ifdef SND_HDA_NEEDS_RESUME
1972 /*
1973 * command cache
1974 */
1975
1976 /* build a 32bit cache key with the widget id and the command parameter */
1977 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1978 #define get_cmd_cache_nid(key) ((key) & 0xff)
1979 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1980
1981 /**
1982 * snd_hda_codec_write_cache - send a single command with caching
1983 * @codec: the HDA codec
1984 * @nid: NID to send the command
1985 * @direct: direct flag
1986 * @verb: the verb to send
1987 * @parm: the parameter for the verb
1988 *
1989 * Send a single command without waiting for response.
1990 *
1991 * Returns 0 if successful, or a negative error code.
1992 */
1993 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1994 int direct, unsigned int verb, unsigned int parm)
1995 {
1996 struct hda_bus *bus = codec->bus;
1997 unsigned int res;
1998 int err;
1999
2000 res = make_codec_cmd(codec, nid, direct, verb, parm);
2001 snd_hda_power_up(codec);
2002 mutex_lock(&bus->cmd_mutex);
2003 err = bus->ops.command(bus, res);
2004 if (!err) {
2005 struct hda_cache_head *c;
2006 u32 key;
2007 /* parm may contain the verb stuff for get/set amp */
2008 verb = verb | (parm >> 8);
2009 parm &= 0xff;
2010 key = build_cmd_cache_key(nid, verb);
2011 c = get_alloc_hash(&codec->cmd_cache, key);
2012 if (c)
2013 c->val = parm;
2014 }
2015 mutex_unlock(&bus->cmd_mutex);
2016 snd_hda_power_down(codec);
2017 return err;
2018 }
2019 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2020
2021 /* resume the all commands from the cache */
2022 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2023 {
2024 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2025 int i;
2026
2027 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2028 u32 key = buffer->key;
2029 if (!key)
2030 continue;
2031 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2032 get_cmd_cache_cmd(key), buffer->val);
2033 }
2034 }
2035 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2036
2037 /**
2038 * snd_hda_sequence_write_cache - sequence writes with caching
2039 * @codec: the HDA codec
2040 * @seq: VERB array to send
2041 *
2042 * Send the commands sequentially from the given array.
2043 * Thte commands are recorded on cache for power-save and resume.
2044 * The array must be terminated with NID=0.
2045 */
2046 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2047 const struct hda_verb *seq)
2048 {
2049 for (; seq->nid; seq++)
2050 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2051 seq->param);
2052 }
2053 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2054 #endif /* SND_HDA_NEEDS_RESUME */
2055
2056 /*
2057 * set power state of the codec
2058 */
2059 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2060 unsigned int power_state)
2061 {
2062 hda_nid_t nid;
2063 int i;
2064
2065 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2066 power_state);
2067 msleep(10); /* partial workaround for "azx_get_response timeout" */
2068
2069 nid = codec->start_nid;
2070 for (i = 0; i < codec->num_nodes; i++, nid++) {
2071 unsigned int wcaps = get_wcaps(codec, nid);
2072 if (wcaps & AC_WCAP_POWER) {
2073 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2074 AC_WCAP_TYPE_SHIFT;
2075 if (wid_type == AC_WID_PIN) {
2076 unsigned int pincap;
2077 /*
2078 * don't power down the widget if it controls
2079 * eapd and EAPD_BTLENABLE is set.
2080 */
2081 pincap = snd_hda_param_read(codec, nid,
2082 AC_PAR_PIN_CAP);
2083 if (pincap & AC_PINCAP_EAPD) {
2084 int eapd = snd_hda_codec_read(codec,
2085 nid, 0,
2086 AC_VERB_GET_EAPD_BTLENABLE, 0);
2087 eapd &= 0x02;
2088 if (power_state == AC_PWRST_D3 && eapd)
2089 continue;
2090 }
2091 }
2092 snd_hda_codec_write(codec, nid, 0,
2093 AC_VERB_SET_POWER_STATE,
2094 power_state);
2095 }
2096 }
2097
2098 if (power_state == AC_PWRST_D0) {
2099 unsigned long end_time;
2100 int state;
2101 msleep(10);
2102 /* wait until the codec reachs to D0 */
2103 end_time = jiffies + msecs_to_jiffies(500);
2104 do {
2105 state = snd_hda_codec_read(codec, fg, 0,
2106 AC_VERB_GET_POWER_STATE, 0);
2107 if (state == power_state)
2108 break;
2109 msleep(1);
2110 } while (time_after_eq(end_time, jiffies));
2111 }
2112 }
2113
2114 #ifdef CONFIG_SND_HDA_HWDEP
2115 /* execute additional init verbs */
2116 static void hda_exec_init_verbs(struct hda_codec *codec)
2117 {
2118 if (codec->init_verbs.list)
2119 snd_hda_sequence_write(codec, codec->init_verbs.list);
2120 }
2121 #else
2122 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2123 #endif
2124
2125 #ifdef SND_HDA_NEEDS_RESUME
2126 /*
2127 * call suspend and power-down; used both from PM and power-save
2128 */
2129 static void hda_call_codec_suspend(struct hda_codec *codec)
2130 {
2131 if (codec->patch_ops.suspend)
2132 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2133 hda_set_power_state(codec,
2134 codec->afg ? codec->afg : codec->mfg,
2135 AC_PWRST_D3);
2136 #ifdef CONFIG_SND_HDA_POWER_SAVE
2137 cancel_delayed_work(&codec->power_work);
2138 codec->power_on = 0;
2139 codec->power_transition = 0;
2140 #endif
2141 }
2142
2143 /*
2144 * kick up codec; used both from PM and power-save
2145 */
2146 static void hda_call_codec_resume(struct hda_codec *codec)
2147 {
2148 hda_set_power_state(codec,
2149 codec->afg ? codec->afg : codec->mfg,
2150 AC_PWRST_D0);
2151 hda_exec_init_verbs(codec);
2152 if (codec->patch_ops.resume)
2153 codec->patch_ops.resume(codec);
2154 else {
2155 if (codec->patch_ops.init)
2156 codec->patch_ops.init(codec);
2157 snd_hda_codec_resume_amp(codec);
2158 snd_hda_codec_resume_cache(codec);
2159 }
2160 }
2161 #endif /* SND_HDA_NEEDS_RESUME */
2162
2163
2164 /**
2165 * snd_hda_build_controls - build mixer controls
2166 * @bus: the BUS
2167 *
2168 * Creates mixer controls for each codec included in the bus.
2169 *
2170 * Returns 0 if successful, otherwise a negative error code.
2171 */
2172 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2173 {
2174 struct hda_codec *codec;
2175
2176 list_for_each_entry(codec, &bus->codec_list, list) {
2177 int err = snd_hda_codec_build_controls(codec);
2178 if (err < 0)
2179 return err;
2180 }
2181 return 0;
2182 }
2183 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2184
2185 int snd_hda_codec_build_controls(struct hda_codec *codec)
2186 {
2187 int err = 0;
2188 /* fake as if already powered-on */
2189 hda_keep_power_on(codec);
2190 /* then fire up */
2191 hda_set_power_state(codec,
2192 codec->afg ? codec->afg : codec->mfg,
2193 AC_PWRST_D0);
2194 hda_exec_init_verbs(codec);
2195 /* continue to initialize... */
2196 if (codec->patch_ops.init)
2197 err = codec->patch_ops.init(codec);
2198 if (!err && codec->patch_ops.build_controls)
2199 err = codec->patch_ops.build_controls(codec);
2200 snd_hda_power_down(codec);
2201 if (err < 0)
2202 return err;
2203 return 0;
2204 }
2205
2206 /*
2207 * stream formats
2208 */
2209 struct hda_rate_tbl {
2210 unsigned int hz;
2211 unsigned int alsa_bits;
2212 unsigned int hda_fmt;
2213 };
2214
2215 static struct hda_rate_tbl rate_bits[] = {
2216 /* rate in Hz, ALSA rate bitmask, HDA format value */
2217
2218 /* autodetected value used in snd_hda_query_supported_pcm */
2219 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2220 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2221 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2222 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2223 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2224 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2225 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2226 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2227 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2228 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2229 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2230 #define AC_PAR_PCM_RATE_BITS 11
2231 /* up to bits 10, 384kHZ isn't supported properly */
2232
2233 /* not autodetected value */
2234 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2235
2236 { 0 } /* terminator */
2237 };
2238
2239 /**
2240 * snd_hda_calc_stream_format - calculate format bitset
2241 * @rate: the sample rate
2242 * @channels: the number of channels
2243 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2244 * @maxbps: the max. bps
2245 *
2246 * Calculate the format bitset from the given rate, channels and th PCM format.
2247 *
2248 * Return zero if invalid.
2249 */
2250 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2251 unsigned int channels,
2252 unsigned int format,
2253 unsigned int maxbps)
2254 {
2255 int i;
2256 unsigned int val = 0;
2257
2258 for (i = 0; rate_bits[i].hz; i++)
2259 if (rate_bits[i].hz == rate) {
2260 val = rate_bits[i].hda_fmt;
2261 break;
2262 }
2263 if (!rate_bits[i].hz) {
2264 snd_printdd("invalid rate %d\n", rate);
2265 return 0;
2266 }
2267
2268 if (channels == 0 || channels > 8) {
2269 snd_printdd("invalid channels %d\n", channels);
2270 return 0;
2271 }
2272 val |= channels - 1;
2273
2274 switch (snd_pcm_format_width(format)) {
2275 case 8: val |= 0x00; break;
2276 case 16: val |= 0x10; break;
2277 case 20:
2278 case 24:
2279 case 32:
2280 if (maxbps >= 32)
2281 val |= 0x40;
2282 else if (maxbps >= 24)
2283 val |= 0x30;
2284 else
2285 val |= 0x20;
2286 break;
2287 default:
2288 snd_printdd("invalid format width %d\n",
2289 snd_pcm_format_width(format));
2290 return 0;
2291 }
2292
2293 return val;
2294 }
2295 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2296
2297 /**
2298 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2299 * @codec: the HDA codec
2300 * @nid: NID to query
2301 * @ratesp: the pointer to store the detected rate bitflags
2302 * @formatsp: the pointer to store the detected formats
2303 * @bpsp: the pointer to store the detected format widths
2304 *
2305 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2306 * or @bsps argument is ignored.
2307 *
2308 * Returns 0 if successful, otherwise a negative error code.
2309 */
2310 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2311 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2312 {
2313 int i;
2314 unsigned int val, streams;
2315
2316 val = 0;
2317 if (nid != codec->afg &&
2318 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2319 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2320 if (val == -1)
2321 return -EIO;
2322 }
2323 if (!val)
2324 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2325
2326 if (ratesp) {
2327 u32 rates = 0;
2328 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2329 if (val & (1 << i))
2330 rates |= rate_bits[i].alsa_bits;
2331 }
2332 *ratesp = rates;
2333 }
2334
2335 if (formatsp || bpsp) {
2336 u64 formats = 0;
2337 unsigned int bps;
2338 unsigned int wcaps;
2339
2340 wcaps = get_wcaps(codec, nid);
2341 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2342 if (streams == -1)
2343 return -EIO;
2344 if (!streams) {
2345 streams = snd_hda_param_read(codec, codec->afg,
2346 AC_PAR_STREAM);
2347 if (streams == -1)
2348 return -EIO;
2349 }
2350
2351 bps = 0;
2352 if (streams & AC_SUPFMT_PCM) {
2353 if (val & AC_SUPPCM_BITS_8) {
2354 formats |= SNDRV_PCM_FMTBIT_U8;
2355 bps = 8;
2356 }
2357 if (val & AC_SUPPCM_BITS_16) {
2358 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2359 bps = 16;
2360 }
2361 if (wcaps & AC_WCAP_DIGITAL) {
2362 if (val & AC_SUPPCM_BITS_32)
2363 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2364 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2365 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2366 if (val & AC_SUPPCM_BITS_24)
2367 bps = 24;
2368 else if (val & AC_SUPPCM_BITS_20)
2369 bps = 20;
2370 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2371 AC_SUPPCM_BITS_32)) {
2372 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2373 if (val & AC_SUPPCM_BITS_32)
2374 bps = 32;
2375 else if (val & AC_SUPPCM_BITS_24)
2376 bps = 24;
2377 else if (val & AC_SUPPCM_BITS_20)
2378 bps = 20;
2379 }
2380 }
2381 else if (streams == AC_SUPFMT_FLOAT32) {
2382 /* should be exclusive */
2383 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2384 bps = 32;
2385 } else if (streams == AC_SUPFMT_AC3) {
2386 /* should be exclusive */
2387 /* temporary hack: we have still no proper support
2388 * for the direct AC3 stream...
2389 */
2390 formats |= SNDRV_PCM_FMTBIT_U8;
2391 bps = 8;
2392 }
2393 if (formatsp)
2394 *formatsp = formats;
2395 if (bpsp)
2396 *bpsp = bps;
2397 }
2398
2399 return 0;
2400 }
2401
2402 /**
2403 * snd_hda_is_supported_format - check whether the given node supports
2404 * the format val
2405 *
2406 * Returns 1 if supported, 0 if not.
2407 */
2408 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2409 unsigned int format)
2410 {
2411 int i;
2412 unsigned int val = 0, rate, stream;
2413
2414 if (nid != codec->afg &&
2415 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2416 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2417 if (val == -1)
2418 return 0;
2419 }
2420 if (!val) {
2421 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2422 if (val == -1)
2423 return 0;
2424 }
2425
2426 rate = format & 0xff00;
2427 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2428 if (rate_bits[i].hda_fmt == rate) {
2429 if (val & (1 << i))
2430 break;
2431 return 0;
2432 }
2433 if (i >= AC_PAR_PCM_RATE_BITS)
2434 return 0;
2435
2436 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2437 if (stream == -1)
2438 return 0;
2439 if (!stream && nid != codec->afg)
2440 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2441 if (!stream || stream == -1)
2442 return 0;
2443
2444 if (stream & AC_SUPFMT_PCM) {
2445 switch (format & 0xf0) {
2446 case 0x00:
2447 if (!(val & AC_SUPPCM_BITS_8))
2448 return 0;
2449 break;
2450 case 0x10:
2451 if (!(val & AC_SUPPCM_BITS_16))
2452 return 0;
2453 break;
2454 case 0x20:
2455 if (!(val & AC_SUPPCM_BITS_20))
2456 return 0;
2457 break;
2458 case 0x30:
2459 if (!(val & AC_SUPPCM_BITS_24))
2460 return 0;
2461 break;
2462 case 0x40:
2463 if (!(val & AC_SUPPCM_BITS_32))
2464 return 0;
2465 break;
2466 default:
2467 return 0;
2468 }
2469 } else {
2470 /* FIXME: check for float32 and AC3? */
2471 }
2472
2473 return 1;
2474 }
2475 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2476
2477 /*
2478 * PCM stuff
2479 */
2480 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2481 struct hda_codec *codec,
2482 struct snd_pcm_substream *substream)
2483 {
2484 return 0;
2485 }
2486
2487 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2488 struct hda_codec *codec,
2489 unsigned int stream_tag,
2490 unsigned int format,
2491 struct snd_pcm_substream *substream)
2492 {
2493 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2494 return 0;
2495 }
2496
2497 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2498 struct hda_codec *codec,
2499 struct snd_pcm_substream *substream)
2500 {
2501 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2502 return 0;
2503 }
2504
2505 static int set_pcm_default_values(struct hda_codec *codec,
2506 struct hda_pcm_stream *info)
2507 {
2508 /* query support PCM information from the given NID */
2509 if (info->nid && (!info->rates || !info->formats)) {
2510 snd_hda_query_supported_pcm(codec, info->nid,
2511 info->rates ? NULL : &info->rates,
2512 info->formats ? NULL : &info->formats,
2513 info->maxbps ? NULL : &info->maxbps);
2514 }
2515 if (info->ops.open == NULL)
2516 info->ops.open = hda_pcm_default_open_close;
2517 if (info->ops.close == NULL)
2518 info->ops.close = hda_pcm_default_open_close;
2519 if (info->ops.prepare == NULL) {
2520 if (snd_BUG_ON(!info->nid))
2521 return -EINVAL;
2522 info->ops.prepare = hda_pcm_default_prepare;
2523 }
2524 if (info->ops.cleanup == NULL) {
2525 if (snd_BUG_ON(!info->nid))
2526 return -EINVAL;
2527 info->ops.cleanup = hda_pcm_default_cleanup;
2528 }
2529 return 0;
2530 }
2531
2532 /*
2533 * get the empty PCM device number to assign
2534 */
2535 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2536 {
2537 static const char *dev_name[HDA_PCM_NTYPES] = {
2538 "Audio", "SPDIF", "HDMI", "Modem"
2539 };
2540 /* starting device index for each PCM type */
2541 static int dev_idx[HDA_PCM_NTYPES] = {
2542 [HDA_PCM_TYPE_AUDIO] = 0,
2543 [HDA_PCM_TYPE_SPDIF] = 1,
2544 [HDA_PCM_TYPE_HDMI] = 3,
2545 [HDA_PCM_TYPE_MODEM] = 6
2546 };
2547 /* normal audio device indices; not linear to keep compatibility */
2548 static int audio_idx[4] = { 0, 2, 4, 5 };
2549 int i, dev;
2550
2551 switch (type) {
2552 case HDA_PCM_TYPE_AUDIO:
2553 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2554 dev = audio_idx[i];
2555 if (!test_bit(dev, bus->pcm_dev_bits))
2556 break;
2557 }
2558 if (i >= ARRAY_SIZE(audio_idx)) {
2559 snd_printk(KERN_WARNING "Too many audio devices\n");
2560 return -EAGAIN;
2561 }
2562 break;
2563 case HDA_PCM_TYPE_SPDIF:
2564 case HDA_PCM_TYPE_HDMI:
2565 case HDA_PCM_TYPE_MODEM:
2566 dev = dev_idx[type];
2567 if (test_bit(dev, bus->pcm_dev_bits)) {
2568 snd_printk(KERN_WARNING "%s already defined\n",
2569 dev_name[type]);
2570 return -EAGAIN;
2571 }
2572 break;
2573 default:
2574 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2575 return -EINVAL;
2576 }
2577 set_bit(dev, bus->pcm_dev_bits);
2578 return dev;
2579 }
2580
2581 /*
2582 * attach a new PCM stream
2583 */
2584 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2585 {
2586 struct hda_bus *bus = codec->bus;
2587 struct hda_pcm_stream *info;
2588 int stream, err;
2589
2590 if (snd_BUG_ON(!pcm->name))
2591 return -EINVAL;
2592 for (stream = 0; stream < 2; stream++) {
2593 info = &pcm->stream[stream];
2594 if (info->substreams) {
2595 err = set_pcm_default_values(codec, info);
2596 if (err < 0)
2597 return err;
2598 }
2599 }
2600 return bus->ops.attach_pcm(bus, codec, pcm);
2601 }
2602
2603 /* assign all PCMs of the given codec */
2604 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2605 {
2606 unsigned int pcm;
2607 int err;
2608
2609 if (!codec->num_pcms) {
2610 if (!codec->patch_ops.build_pcms)
2611 return 0;
2612 err = codec->patch_ops.build_pcms(codec);
2613 if (err < 0)
2614 return err;
2615 }
2616 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2617 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2618 int dev;
2619
2620 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2621 return 0; /* no substreams assigned */
2622
2623 if (!cpcm->pcm) {
2624 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2625 if (dev < 0)
2626 return 0;
2627 cpcm->device = dev;
2628 err = snd_hda_attach_pcm(codec, cpcm);
2629 if (err < 0)
2630 return err;
2631 }
2632 }
2633 return 0;
2634 }
2635
2636 /**
2637 * snd_hda_build_pcms - build PCM information
2638 * @bus: the BUS
2639 *
2640 * Create PCM information for each codec included in the bus.
2641 *
2642 * The build_pcms codec patch is requested to set up codec->num_pcms and
2643 * codec->pcm_info properly. The array is referred by the top-level driver
2644 * to create its PCM instances.
2645 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2646 * callback.
2647 *
2648 * At least, substreams, channels_min and channels_max must be filled for
2649 * each stream. substreams = 0 indicates that the stream doesn't exist.
2650 * When rates and/or formats are zero, the supported values are queried
2651 * from the given nid. The nid is used also by the default ops.prepare
2652 * and ops.cleanup callbacks.
2653 *
2654 * The driver needs to call ops.open in its open callback. Similarly,
2655 * ops.close is supposed to be called in the close callback.
2656 * ops.prepare should be called in the prepare or hw_params callback
2657 * with the proper parameters for set up.
2658 * ops.cleanup should be called in hw_free for clean up of streams.
2659 *
2660 * This function returns 0 if successfull, or a negative error code.
2661 */
2662 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2663 {
2664 struct hda_codec *codec;
2665
2666 list_for_each_entry(codec, &bus->codec_list, list) {
2667 int err = snd_hda_codec_build_pcms(codec);
2668 if (err < 0)
2669 return err;
2670 }
2671 return 0;
2672 }
2673 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2674
2675 /**
2676 * snd_hda_check_board_config - compare the current codec with the config table
2677 * @codec: the HDA codec
2678 * @num_configs: number of config enums
2679 * @models: array of model name strings
2680 * @tbl: configuration table, terminated by null entries
2681 *
2682 * Compares the modelname or PCI subsystem id of the current codec with the
2683 * given configuration table. If a matching entry is found, returns its
2684 * config value (supposed to be 0 or positive).
2685 *
2686 * If no entries are matching, the function returns a negative value.
2687 */
2688 int snd_hda_check_board_config(struct hda_codec *codec,
2689 int num_configs, const char **models,
2690 const struct snd_pci_quirk *tbl)
2691 {
2692 if (codec->modelname && models) {
2693 int i;
2694 for (i = 0; i < num_configs; i++) {
2695 if (models[i] &&
2696 !strcmp(codec->modelname, models[i])) {
2697 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2698 "selected\n", models[i]);
2699 return i;
2700 }
2701 }
2702 }
2703
2704 if (!codec->bus->pci || !tbl)
2705 return -1;
2706
2707 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2708 if (!tbl)
2709 return -1;
2710 if (tbl->value >= 0 && tbl->value < num_configs) {
2711 #ifdef CONFIG_SND_DEBUG_VERBOSE
2712 char tmp[10];
2713 const char *model = NULL;
2714 if (models)
2715 model = models[tbl->value];
2716 if (!model) {
2717 sprintf(tmp, "#%d", tbl->value);
2718 model = tmp;
2719 }
2720 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2721 "for config %x:%x (%s)\n",
2722 model, tbl->subvendor, tbl->subdevice,
2723 (tbl->name ? tbl->name : "Unknown device"));
2724 #endif
2725 return tbl->value;
2726 }
2727 return -1;
2728 }
2729 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2730
2731 /**
2732 * snd_hda_check_board_codec_sid_config - compare the current codec
2733 subsystem ID with the
2734 config table
2735
2736 This is important for Gateway notebooks with SB450 HDA Audio
2737 where the vendor ID of the PCI device is:
2738 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2739 and the vendor/subvendor are found only at the codec.
2740
2741 * @codec: the HDA codec
2742 * @num_configs: number of config enums
2743 * @models: array of model name strings
2744 * @tbl: configuration table, terminated by null entries
2745 *
2746 * Compares the modelname or PCI subsystem id of the current codec with the
2747 * given configuration table. If a matching entry is found, returns its
2748 * config value (supposed to be 0 or positive).
2749 *
2750 * If no entries are matching, the function returns a negative value.
2751 */
2752 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2753 int num_configs, const char **models,
2754 const struct snd_pci_quirk *tbl)
2755 {
2756 const struct snd_pci_quirk *q;
2757
2758 /* Search for codec ID */
2759 for (q = tbl; q->subvendor; q++) {
2760 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2761
2762 if (vendorid == codec->subsystem_id)
2763 break;
2764 }
2765
2766 if (!q->subvendor)
2767 return -1;
2768
2769 tbl = q;
2770
2771 if (tbl->value >= 0 && tbl->value < num_configs) {
2772 #ifdef CONFIG_SND_DEBUG_DETECT
2773 char tmp[10];
2774 const char *model = NULL;
2775 if (models)
2776 model = models[tbl->value];
2777 if (!model) {
2778 sprintf(tmp, "#%d", tbl->value);
2779 model = tmp;
2780 }
2781 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2782 "for config %x:%x (%s)\n",
2783 model, tbl->subvendor, tbl->subdevice,
2784 (tbl->name ? tbl->name : "Unknown device"));
2785 #endif
2786 return tbl->value;
2787 }
2788 return -1;
2789 }
2790 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2791
2792 /**
2793 * snd_hda_add_new_ctls - create controls from the array
2794 * @codec: the HDA codec
2795 * @knew: the array of struct snd_kcontrol_new
2796 *
2797 * This helper function creates and add new controls in the given array.
2798 * The array must be terminated with an empty entry as terminator.
2799 *
2800 * Returns 0 if successful, or a negative error code.
2801 */
2802 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2803 {
2804 int err;
2805
2806 for (; knew->name; knew++) {
2807 struct snd_kcontrol *kctl;
2808 kctl = snd_ctl_new1(knew, codec);
2809 if (!kctl)
2810 return -ENOMEM;
2811 err = snd_hda_ctl_add(codec, kctl);
2812 if (err < 0) {
2813 if (!codec->addr)
2814 return err;
2815 kctl = snd_ctl_new1(knew, codec);
2816 if (!kctl)
2817 return -ENOMEM;
2818 kctl->id.device = codec->addr;
2819 err = snd_hda_ctl_add(codec, kctl);
2820 if (err < 0)
2821 return err;
2822 }
2823 }
2824 return 0;
2825 }
2826 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2827
2828 #ifdef CONFIG_SND_HDA_POWER_SAVE
2829 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2830 unsigned int power_state);
2831
2832 static void hda_power_work(struct work_struct *work)
2833 {
2834 struct hda_codec *codec =
2835 container_of(work, struct hda_codec, power_work.work);
2836 struct hda_bus *bus = codec->bus;
2837
2838 if (!codec->power_on || codec->power_count) {
2839 codec->power_transition = 0;
2840 return;
2841 }
2842
2843 hda_call_codec_suspend(codec);
2844 if (bus->ops.pm_notify)
2845 bus->ops.pm_notify(bus);
2846 }
2847
2848 static void hda_keep_power_on(struct hda_codec *codec)
2849 {
2850 codec->power_count++;
2851 codec->power_on = 1;
2852 }
2853
2854 void snd_hda_power_up(struct hda_codec *codec)
2855 {
2856 struct hda_bus *bus = codec->bus;
2857
2858 codec->power_count++;
2859 if (codec->power_on || codec->power_transition)
2860 return;
2861
2862 codec->power_on = 1;
2863 if (bus->ops.pm_notify)
2864 bus->ops.pm_notify(bus);
2865 hda_call_codec_resume(codec);
2866 cancel_delayed_work(&codec->power_work);
2867 codec->power_transition = 0;
2868 }
2869 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2870
2871 #define power_save(codec) \
2872 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2873
2874 #define power_save(codec) \
2875 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2876
2877 void snd_hda_power_down(struct hda_codec *codec)
2878 {
2879 --codec->power_count;
2880 if (!codec->power_on || codec->power_count || codec->power_transition)
2881 return;
2882 if (power_save(codec)) {
2883 codec->power_transition = 1; /* avoid reentrance */
2884 queue_delayed_work(codec->bus->workq, &codec->power_work,
2885 msecs_to_jiffies(power_save(codec) * 1000));
2886 }
2887 }
2888 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2889
2890 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2891 struct hda_loopback_check *check,
2892 hda_nid_t nid)
2893 {
2894 struct hda_amp_list *p;
2895 int ch, v;
2896
2897 if (!check->amplist)
2898 return 0;
2899 for (p = check->amplist; p->nid; p++) {
2900 if (p->nid == nid)
2901 break;
2902 }
2903 if (!p->nid)
2904 return 0; /* nothing changed */
2905
2906 for (p = check->amplist; p->nid; p++) {
2907 for (ch = 0; ch < 2; ch++) {
2908 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2909 p->idx);
2910 if (!(v & HDA_AMP_MUTE) && v > 0) {
2911 if (!check->power_on) {
2912 check->power_on = 1;
2913 snd_hda_power_up(codec);
2914 }
2915 return 1;
2916 }
2917 }
2918 }
2919 if (check->power_on) {
2920 check->power_on = 0;
2921 snd_hda_power_down(codec);
2922 }
2923 return 0;
2924 }
2925 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2926 #endif
2927
2928 /*
2929 * Channel mode helper
2930 */
2931 int snd_hda_ch_mode_info(struct hda_codec *codec,
2932 struct snd_ctl_elem_info *uinfo,
2933 const struct hda_channel_mode *chmode,
2934 int num_chmodes)
2935 {
2936 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2937 uinfo->count = 1;
2938 uinfo->value.enumerated.items = num_chmodes;
2939 if (uinfo->value.enumerated.item >= num_chmodes)
2940 uinfo->value.enumerated.item = num_chmodes - 1;
2941 sprintf(uinfo->value.enumerated.name, "%dch",
2942 chmode[uinfo->value.enumerated.item].channels);
2943 return 0;
2944 }
2945 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2946
2947 int snd_hda_ch_mode_get(struct hda_codec *codec,
2948 struct snd_ctl_elem_value *ucontrol,
2949 const struct hda_channel_mode *chmode,
2950 int num_chmodes,
2951 int max_channels)
2952 {
2953 int i;
2954
2955 for (i = 0; i < num_chmodes; i++) {
2956 if (max_channels == chmode[i].channels) {
2957 ucontrol->value.enumerated.item[0] = i;
2958 break;
2959 }
2960 }
2961 return 0;
2962 }
2963 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2964
2965 int snd_hda_ch_mode_put(struct hda_codec *codec,
2966 struct snd_ctl_elem_value *ucontrol,
2967 const struct hda_channel_mode *chmode,
2968 int num_chmodes,
2969 int *max_channelsp)
2970 {
2971 unsigned int mode;
2972
2973 mode = ucontrol->value.enumerated.item[0];
2974 if (mode >= num_chmodes)
2975 return -EINVAL;
2976 if (*max_channelsp == chmode[mode].channels)
2977 return 0;
2978 /* change the current channel setting */
2979 *max_channelsp = chmode[mode].channels;
2980 if (chmode[mode].sequence)
2981 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2982 return 1;
2983 }
2984 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
2985
2986 /*
2987 * input MUX helper
2988 */
2989 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2990 struct snd_ctl_elem_info *uinfo)
2991 {
2992 unsigned int index;
2993
2994 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2995 uinfo->count = 1;
2996 uinfo->value.enumerated.items = imux->num_items;
2997 if (!imux->num_items)
2998 return 0;
2999 index = uinfo->value.enumerated.item;
3000 if (index >= imux->num_items)
3001 index = imux->num_items - 1;
3002 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3003 return 0;
3004 }
3005 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3006
3007 int snd_hda_input_mux_put(struct hda_codec *codec,
3008 const struct hda_input_mux *imux,
3009 struct snd_ctl_elem_value *ucontrol,
3010 hda_nid_t nid,
3011 unsigned int *cur_val)
3012 {
3013 unsigned int idx;
3014
3015 if (!imux->num_items)
3016 return 0;
3017 idx = ucontrol->value.enumerated.item[0];
3018 if (idx >= imux->num_items)
3019 idx = imux->num_items - 1;
3020 if (*cur_val == idx)
3021 return 0;
3022 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3023 imux->items[idx].index);
3024 *cur_val = idx;
3025 return 1;
3026 }
3027 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3028
3029
3030 /*
3031 * Multi-channel / digital-out PCM helper functions
3032 */
3033
3034 /* setup SPDIF output stream */
3035 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3036 unsigned int stream_tag, unsigned int format)
3037 {
3038 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3039 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3040 set_dig_out_convert(codec, nid,
3041 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3042 -1);
3043 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3044 if (codec->slave_dig_outs) {
3045 hda_nid_t *d;
3046 for (d = codec->slave_dig_outs; *d; d++)
3047 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3048 format);
3049 }
3050 /* turn on again (if needed) */
3051 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3052 set_dig_out_convert(codec, nid,
3053 codec->spdif_ctls & 0xff, -1);
3054 }
3055
3056 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3057 {
3058 snd_hda_codec_cleanup_stream(codec, nid);
3059 if (codec->slave_dig_outs) {
3060 hda_nid_t *d;
3061 for (d = codec->slave_dig_outs; *d; d++)
3062 snd_hda_codec_cleanup_stream(codec, *d);
3063 }
3064 }
3065
3066 /*
3067 * open the digital out in the exclusive mode
3068 */
3069 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3070 struct hda_multi_out *mout)
3071 {
3072 mutex_lock(&codec->spdif_mutex);
3073 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3074 /* already opened as analog dup; reset it once */
3075 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3076 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3077 mutex_unlock(&codec->spdif_mutex);
3078 return 0;
3079 }
3080 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3081
3082 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3083 struct hda_multi_out *mout,
3084 unsigned int stream_tag,
3085 unsigned int format,
3086 struct snd_pcm_substream *substream)
3087 {
3088 mutex_lock(&codec->spdif_mutex);
3089 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3090 mutex_unlock(&codec->spdif_mutex);
3091 return 0;
3092 }
3093 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3094
3095 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3096 struct hda_multi_out *mout)
3097 {
3098 mutex_lock(&codec->spdif_mutex);
3099 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3100 mutex_unlock(&codec->spdif_mutex);
3101 return 0;
3102 }
3103 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3104
3105 /*
3106 * release the digital out
3107 */
3108 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3109 struct hda_multi_out *mout)
3110 {
3111 mutex_lock(&codec->spdif_mutex);
3112 mout->dig_out_used = 0;
3113 mutex_unlock(&codec->spdif_mutex);
3114 return 0;
3115 }
3116 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3117
3118 /*
3119 * set up more restrictions for analog out
3120 */
3121 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3122 struct hda_multi_out *mout,
3123 struct snd_pcm_substream *substream,
3124 struct hda_pcm_stream *hinfo)
3125 {
3126 struct snd_pcm_runtime *runtime = substream->runtime;
3127 runtime->hw.channels_max = mout->max_channels;
3128 if (mout->dig_out_nid) {
3129 if (!mout->analog_rates) {
3130 mout->analog_rates = hinfo->rates;
3131 mout->analog_formats = hinfo->formats;
3132 mout->analog_maxbps = hinfo->maxbps;
3133 } else {
3134 runtime->hw.rates = mout->analog_rates;
3135 runtime->hw.formats = mout->analog_formats;
3136 hinfo->maxbps = mout->analog_maxbps;
3137 }
3138 if (!mout->spdif_rates) {
3139 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3140 &mout->spdif_rates,
3141 &mout->spdif_formats,
3142 &mout->spdif_maxbps);
3143 }
3144 mutex_lock(&codec->spdif_mutex);
3145 if (mout->share_spdif) {
3146 runtime->hw.rates &= mout->spdif_rates;
3147 runtime->hw.formats &= mout->spdif_formats;
3148 if (mout->spdif_maxbps < hinfo->maxbps)
3149 hinfo->maxbps = mout->spdif_maxbps;
3150 }
3151 mutex_unlock(&codec->spdif_mutex);
3152 }
3153 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3154 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3155 }
3156 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3157
3158 /*
3159 * set up the i/o for analog out
3160 * when the digital out is available, copy the front out to digital out, too.
3161 */
3162 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3163 struct hda_multi_out *mout,
3164 unsigned int stream_tag,
3165 unsigned int format,
3166 struct snd_pcm_substream *substream)
3167 {
3168 hda_nid_t *nids = mout->dac_nids;
3169 int chs = substream->runtime->channels;
3170 int i;
3171
3172 mutex_lock(&codec->spdif_mutex);
3173 if (mout->dig_out_nid && mout->share_spdif &&
3174 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3175 if (chs == 2 &&
3176 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3177 format) &&
3178 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3179 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3180 setup_dig_out_stream(codec, mout->dig_out_nid,
3181 stream_tag, format);
3182 } else {
3183 mout->dig_out_used = 0;
3184 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3185 }
3186 }
3187 mutex_unlock(&codec->spdif_mutex);
3188
3189 /* front */
3190 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3191 0, format);
3192 if (!mout->no_share_stream &&
3193 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3194 /* headphone out will just decode front left/right (stereo) */
3195 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3196 0, format);
3197 /* extra outputs copied from front */
3198 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3199 if (!mout->no_share_stream && mout->extra_out_nid[i])
3200 snd_hda_codec_setup_stream(codec,
3201 mout->extra_out_nid[i],
3202 stream_tag, 0, format);
3203
3204 /* surrounds */
3205 for (i = 1; i < mout->num_dacs; i++) {
3206 if (chs >= (i + 1) * 2) /* independent out */
3207 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3208 i * 2, format);
3209 else if (!mout->no_share_stream) /* copy front */
3210 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3211 0, format);
3212 }
3213 return 0;
3214 }
3215 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3216
3217 /*
3218 * clean up the setting for analog out
3219 */
3220 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3221 struct hda_multi_out *mout)
3222 {
3223 hda_nid_t *nids = mout->dac_nids;
3224 int i;
3225
3226 for (i = 0; i < mout->num_dacs; i++)
3227 snd_hda_codec_cleanup_stream(codec, nids[i]);
3228 if (mout->hp_nid)
3229 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3230 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3231 if (mout->extra_out_nid[i])
3232 snd_hda_codec_cleanup_stream(codec,
3233 mout->extra_out_nid[i]);
3234 mutex_lock(&codec->spdif_mutex);
3235 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3236 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3237 mout->dig_out_used = 0;
3238 }
3239 mutex_unlock(&codec->spdif_mutex);
3240 return 0;
3241 }
3242 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3243
3244 /*
3245 * Helper for automatic pin configuration
3246 */
3247
3248 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3249 {
3250 for (; *list; list++)
3251 if (*list == nid)
3252 return 1;
3253 return 0;
3254 }
3255
3256
3257 /*
3258 * Sort an associated group of pins according to their sequence numbers.
3259 */
3260 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3261 int num_pins)
3262 {
3263 int i, j;
3264 short seq;
3265 hda_nid_t nid;
3266
3267 for (i = 0; i < num_pins; i++) {
3268 for (j = i + 1; j < num_pins; j++) {
3269 if (sequences[i] > sequences[j]) {
3270 seq = sequences[i];
3271 sequences[i] = sequences[j];
3272 sequences[j] = seq;
3273 nid = pins[i];
3274 pins[i] = pins[j];
3275 pins[j] = nid;
3276 }
3277 }
3278 }
3279 }
3280
3281
3282 /*
3283 * Parse all pin widgets and store the useful pin nids to cfg
3284 *
3285 * The number of line-outs or any primary output is stored in line_outs,
3286 * and the corresponding output pins are assigned to line_out_pins[],
3287 * in the order of front, rear, CLFE, side, ...
3288 *
3289 * If more extra outputs (speaker and headphone) are found, the pins are
3290 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3291 * is detected, one of speaker of HP pins is assigned as the primary
3292 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3293 * if any analog output exists.
3294 *
3295 * The analog input pins are assigned to input_pins array.
3296 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3297 * respectively.
3298 */
3299 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3300 struct auto_pin_cfg *cfg,
3301 hda_nid_t *ignore_nids)
3302 {
3303 hda_nid_t nid, end_nid;
3304 short seq, assoc_line_out, assoc_speaker;
3305 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3306 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3307 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3308
3309 memset(cfg, 0, sizeof(*cfg));
3310
3311 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3312 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3313 memset(sequences_hp, 0, sizeof(sequences_hp));
3314 assoc_line_out = assoc_speaker = 0;
3315
3316 end_nid = codec->start_nid + codec->num_nodes;
3317 for (nid = codec->start_nid; nid < end_nid; nid++) {
3318 unsigned int wid_caps = get_wcaps(codec, nid);
3319 unsigned int wid_type =
3320 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3321 unsigned int def_conf;
3322 short assoc, loc;
3323
3324 /* read all default configuration for pin complex */
3325 if (wid_type != AC_WID_PIN)
3326 continue;
3327 /* ignore the given nids (e.g. pc-beep returns error) */
3328 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3329 continue;
3330
3331 def_conf = snd_hda_codec_read(codec, nid, 0,
3332 AC_VERB_GET_CONFIG_DEFAULT, 0);
3333 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3334 continue;
3335 loc = get_defcfg_location(def_conf);
3336 switch (get_defcfg_device(def_conf)) {
3337 case AC_JACK_LINE_OUT:
3338 seq = get_defcfg_sequence(def_conf);
3339 assoc = get_defcfg_association(def_conf);
3340
3341 if (!(wid_caps & AC_WCAP_STEREO))
3342 if (!cfg->mono_out_pin)
3343 cfg->mono_out_pin = nid;
3344 if (!assoc)
3345 continue;
3346 if (!assoc_line_out)
3347 assoc_line_out = assoc;
3348 else if (assoc_line_out != assoc)
3349 continue;
3350 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3351 continue;
3352 cfg->line_out_pins[cfg->line_outs] = nid;
3353 sequences_line_out[cfg->line_outs] = seq;
3354 cfg->line_outs++;
3355 break;
3356 case AC_JACK_SPEAKER:
3357 seq = get_defcfg_sequence(def_conf);
3358 assoc = get_defcfg_association(def_conf);
3359 if (! assoc)
3360 continue;
3361 if (! assoc_speaker)
3362 assoc_speaker = assoc;
3363 else if (assoc_speaker != assoc)
3364 continue;
3365 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3366 continue;
3367 cfg->speaker_pins[cfg->speaker_outs] = nid;
3368 sequences_speaker[cfg->speaker_outs] = seq;
3369 cfg->speaker_outs++;
3370 break;
3371 case AC_JACK_HP_OUT:
3372 seq = get_defcfg_sequence(def_conf);
3373 assoc = get_defcfg_association(def_conf);
3374 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3375 continue;
3376 cfg->hp_pins[cfg->hp_outs] = nid;
3377 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3378 cfg->hp_outs++;
3379 break;
3380 case AC_JACK_MIC_IN: {
3381 int preferred, alt;
3382 if (loc == AC_JACK_LOC_FRONT) {
3383 preferred = AUTO_PIN_FRONT_MIC;
3384 alt = AUTO_PIN_MIC;
3385 } else {
3386 preferred = AUTO_PIN_MIC;
3387 alt = AUTO_PIN_FRONT_MIC;
3388 }
3389 if (!cfg->input_pins[preferred])
3390 cfg->input_pins[preferred] = nid;
3391 else if (!cfg->input_pins[alt])
3392 cfg->input_pins[alt] = nid;
3393 break;
3394 }
3395 case AC_JACK_LINE_IN:
3396 if (loc == AC_JACK_LOC_FRONT)
3397 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3398 else
3399 cfg->input_pins[AUTO_PIN_LINE] = nid;
3400 break;
3401 case AC_JACK_CD:
3402 cfg->input_pins[AUTO_PIN_CD] = nid;
3403 break;
3404 case AC_JACK_AUX:
3405 cfg->input_pins[AUTO_PIN_AUX] = nid;
3406 break;
3407 case AC_JACK_SPDIF_OUT:
3408 cfg->dig_out_pin = nid;
3409 break;
3410 case AC_JACK_SPDIF_IN:
3411 cfg->dig_in_pin = nid;
3412 break;
3413 }
3414 }
3415
3416 /* FIX-UP:
3417 * If no line-out is defined but multiple HPs are found,
3418 * some of them might be the real line-outs.
3419 */
3420 if (!cfg->line_outs && cfg->hp_outs > 1) {
3421 int i = 0;
3422 while (i < cfg->hp_outs) {
3423 /* The real HPs should have the sequence 0x0f */
3424 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3425 i++;
3426 continue;
3427 }
3428 /* Move it to the line-out table */
3429 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3430 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3431 cfg->line_outs++;
3432 cfg->hp_outs--;
3433 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3434 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3435 memmove(sequences_hp + i - 1, sequences_hp + i,
3436 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3437 }
3438 }
3439
3440 /* sort by sequence */
3441 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3442 cfg->line_outs);
3443 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3444 cfg->speaker_outs);
3445 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3446 cfg->hp_outs);
3447
3448 /* if we have only one mic, make it AUTO_PIN_MIC */
3449 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3450 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3451 cfg->input_pins[AUTO_PIN_MIC] =
3452 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3453 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3454 }
3455 /* ditto for line-in */
3456 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3457 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3458 cfg->input_pins[AUTO_PIN_LINE] =
3459 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3460 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3461 }
3462
3463 /*
3464 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3465 * as a primary output
3466 */
3467 if (!cfg->line_outs) {
3468 if (cfg->speaker_outs) {
3469 cfg->line_outs = cfg->speaker_outs;
3470 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3471 sizeof(cfg->speaker_pins));
3472 cfg->speaker_outs = 0;
3473 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3474 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3475 } else if (cfg->hp_outs) {
3476 cfg->line_outs = cfg->hp_outs;
3477 memcpy(cfg->line_out_pins, cfg->hp_pins,
3478 sizeof(cfg->hp_pins));
3479 cfg->hp_outs = 0;
3480 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3481 cfg->line_out_type = AUTO_PIN_HP_OUT;
3482 }
3483 }
3484
3485 /* Reorder the surround channels
3486 * ALSA sequence is front/surr/clfe/side
3487 * HDA sequence is:
3488 * 4-ch: front/surr => OK as it is
3489 * 6-ch: front/clfe/surr
3490 * 8-ch: front/clfe/rear/side|fc
3491 */
3492 switch (cfg->line_outs) {
3493 case 3:
3494 case 4:
3495 nid = cfg->line_out_pins[1];
3496 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3497 cfg->line_out_pins[2] = nid;
3498 break;
3499 }
3500
3501 /*
3502 * debug prints of the parsed results
3503 */
3504 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3505 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3506 cfg->line_out_pins[2], cfg->line_out_pins[3],
3507 cfg->line_out_pins[4]);
3508 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3509 cfg->speaker_outs, cfg->speaker_pins[0],
3510 cfg->speaker_pins[1], cfg->speaker_pins[2],
3511 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3512 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3513 cfg->hp_outs, cfg->hp_pins[0],
3514 cfg->hp_pins[1], cfg->hp_pins[2],
3515 cfg->hp_pins[3], cfg->hp_pins[4]);
3516 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3517 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3518 " cd=0x%x, aux=0x%x\n",
3519 cfg->input_pins[AUTO_PIN_MIC],
3520 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3521 cfg->input_pins[AUTO_PIN_LINE],
3522 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3523 cfg->input_pins[AUTO_PIN_CD],
3524 cfg->input_pins[AUTO_PIN_AUX]);
3525
3526 return 0;
3527 }
3528 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3529
3530 /* labels for input pins */
3531 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3532 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3533 };
3534 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3535
3536
3537 #ifdef CONFIG_PM
3538 /*
3539 * power management
3540 */
3541
3542 /**
3543 * snd_hda_suspend - suspend the codecs
3544 * @bus: the HDA bus
3545 * @state: suspsend state
3546 *
3547 * Returns 0 if successful.
3548 */
3549 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3550 {
3551 struct hda_codec *codec;
3552
3553 list_for_each_entry(codec, &bus->codec_list, list) {
3554 #ifdef CONFIG_SND_HDA_POWER_SAVE
3555 if (!codec->power_on)
3556 continue;
3557 #endif
3558 hda_call_codec_suspend(codec);
3559 }
3560 return 0;
3561 }
3562 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3563
3564 /**
3565 * snd_hda_resume - resume the codecs
3566 * @bus: the HDA bus
3567 *
3568 * Returns 0 if successful.
3569 *
3570 * This fucntion is defined only when POWER_SAVE isn't set.
3571 * In the power-save mode, the codec is resumed dynamically.
3572 */
3573 int snd_hda_resume(struct hda_bus *bus)
3574 {
3575 struct hda_codec *codec;
3576
3577 list_for_each_entry(codec, &bus->codec_list, list) {
3578 if (snd_hda_codec_needs_resume(codec))
3579 hda_call_codec_resume(codec);
3580 }
3581 return 0;
3582 }
3583 EXPORT_SYMBOL_HDA(snd_hda_resume);
3584 #endif /* CONFIG_PM */
3585
3586 /*
3587 * generic arrays
3588 */
3589
3590 /* get a new element from the given array
3591 * if it exceeds the pre-allocated array size, re-allocate the array
3592 */
3593 void *snd_array_new(struct snd_array *array)
3594 {
3595 if (array->used >= array->alloced) {
3596 int num = array->alloced + array->alloc_align;
3597 void *nlist;
3598 if (snd_BUG_ON(num >= 4096))
3599 return NULL;
3600 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3601 if (!nlist)
3602 return NULL;
3603 if (array->list) {
3604 memcpy(nlist, array->list,
3605 array->elem_size * array->alloced);
3606 kfree(array->list);
3607 }
3608 array->list = nlist;
3609 array->alloced = num;
3610 }
3611 return snd_array_elem(array, array->used++);
3612 }
3613 EXPORT_SYMBOL_HDA(snd_array_new);
3614
3615 /* free the given array elements */
3616 void snd_array_free(struct snd_array *array)
3617 {
3618 kfree(array->list);
3619 array->used = 0;
3620 array->alloced = 0;
3621 array->list = NULL;
3622 }
3623 EXPORT_SYMBOL_HDA(snd_array_free);
3624
3625 /*
3626 * used by hda_proc.c and hda_eld.c
3627 */
3628 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3629 {
3630 static unsigned int rates[] = {
3631 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3632 96000, 176400, 192000, 384000
3633 };
3634 int i, j;
3635
3636 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3637 if (pcm & (1 << i))
3638 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3639
3640 buf[j] = '\0'; /* necessary when j == 0 */
3641 }
3642 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3643
3644 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3645 {
3646 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3647 int i, j;
3648
3649 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3650 if (pcm & (AC_SUPPCM_BITS_8 << i))
3651 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3652
3653 buf[j] = '\0'; /* necessary when j == 0 */
3654 }
3655 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3656
3657 MODULE_DESCRIPTION("HDA codec core");
3658 MODULE_LICENSE("GPL");
(Inofficial) Linux kernel tree running on the Nao robot