2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
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.
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.
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
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>
36 * vendor / preset table
39 struct hda_vendor_id {
44 /* codec vendor labels */
45 static struct hda_vendor_id hda_vendor_ids[] = {
47 { 0x1057, "Motorola" },
48 { 0x1095, "Silicon Image" },
50 { 0x10ec, "Realtek" },
54 { 0x11d4, "Analog Devices" },
55 { 0x13f6, "C-Media" },
56 { 0x14f1, "Conexant" },
57 { 0x17e8, "Chrontel" },
59 { 0x1aec, "Wolfson Microelectronics" },
60 { 0x434d, "C-Media" },
62 { 0x8384, "SigmaTel" },
66 static DEFINE_MUTEX(preset_mutex);
67 static LIST_HEAD(hda_preset_tables);
69 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
76 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
78 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
85 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
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);
91 static inline void hda_keep_power_on(struct hda_codec *codec) {}
94 const char *snd_hda_get_jack_location(u32 cfg)
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 static unsigned char specials_idx[] = {
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
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])
119 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
121 const char *snd_hda_get_jack_connectivity(u32 cfg)
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
129 const char *snd_hda_get_jack_type(u32 cfg)
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"
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
141 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
144 * Compose a 32bit command word to be sent to the HD-audio controller
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)
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
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
168 * Send a single command and read the corresponding response.
170 * Returns the obtained response value, or -1 for an error.
172 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
174 unsigned int verb, unsigned int parm)
176 struct hda_bus *bus = codec->bus;
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);
185 res = (unsigned int)-1;
186 mutex_unlock(&bus->cmd_mutex);
187 snd_hda_power_down(codec);
190 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
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
200 * Send a single command without waiting for response.
202 * Returns 0 if successful, or a negative error code.
204 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
207 struct hda_bus *bus = codec->bus;
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);
219 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
229 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
234 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
240 * @start_id: the pointer to store the start NID
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
245 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
256 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
265 * Parses the connection list of the given widget and stores the list
268 * Returns the number of connections, or a negative error code.
270 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
274 int i, conn_len, conns;
275 unsigned int shift, num_elems, mask;
278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
291 conn_len = parm & AC_CLIST_LENGTH;
292 mask = (1 << (shift-1)) - 1;
295 return 0; /* no connection */
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;
305 /* multi connection */
308 for (i = 0; i < conn_len; i++) {
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 */
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",
326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
329 "Too many connections\n");
332 conn_list[conns++] = n;
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
339 conn_list[conns++] = val;
345 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
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.
358 * Returns 0 if successful, or a negative error code.
360 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
362 struct hda_bus_unsolicited *unsol;
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
376 queue_work(bus->workq, &unsol->work);
380 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
383 * process queued unsolicited events
385 static void process_unsol_events(struct work_struct *work)
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;
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
408 * initialize unsolicited queue
410 static int init_unsol_queue(struct hda_bus *bus)
412 struct hda_bus_unsolicited *unsol;
414 if (bus->unsol) /* already initialized */
417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
423 INIT_WORK(&unsol->work, process_unsol_events);
432 static void snd_hda_codec_free(struct hda_codec *codec);
434 static int snd_hda_bus_free(struct hda_bus *bus)
436 struct hda_codec *codec, *n;
441 flush_workqueue(bus->workq);
444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
445 snd_hda_codec_free(codec);
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
450 destroy_workqueue(bus->workq);
455 static int snd_hda_bus_dev_free(struct snd_device *device)
457 struct hda_bus *bus = device->device_data;
459 return snd_hda_bus_free(bus);
462 #ifdef CONFIG_SND_HDA_HWDEP
463 static int snd_hda_bus_dev_register(struct snd_device *device)
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);
473 #define snd_hda_bus_dev_register NULL
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
482 * Returns 0 if successful, or a negative error code.
484 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
485 const struct hda_bus_template *temp,
486 struct hda_bus **busp)
491 static struct snd_device_ops dev_ops = {
492 .dev_register = snd_hda_bus_dev_register,
493 .dev_free = snd_hda_bus_dev_free,
496 if (snd_BUG_ON(!temp))
498 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
504 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
506 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
511 bus->private_data = temp->private_data;
512 bus->pci = temp->pci;
513 bus->modelname = temp->modelname;
514 bus->power_save = temp->power_save;
515 bus->ops = temp->ops;
517 mutex_init(&bus->cmd_mutex);
518 INIT_LIST_HEAD(&bus->codec_list);
520 snprintf(qname, sizeof(qname), "hda%d", card->number);
521 bus->workq = create_workqueue(qname);
523 snd_printk(KERN_ERR "cannot create workqueue %s\n", qname);
528 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
530 snd_hda_bus_free(bus);
537 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
539 #ifdef CONFIG_SND_HDA_GENERIC
540 #define is_generic_config(codec) \
541 (codec->modelname && !strcmp(codec->modelname, "generic"))
543 #define is_generic_config(codec) 0
547 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
549 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
553 * find a matching codec preset
555 static const struct hda_codec_preset *
556 find_codec_preset(struct hda_codec *codec)
558 struct hda_codec_preset_list *tbl;
559 const struct hda_codec_preset *preset;
560 int mod_requested = 0;
562 if (is_generic_config(codec))
563 return NULL; /* use the generic parser */
566 mutex_lock(&preset_mutex);
567 list_for_each_entry(tbl, &hda_preset_tables, list) {
568 if (!try_module_get(tbl->owner)) {
569 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
572 for (preset = tbl->preset; preset->id; preset++) {
573 u32 mask = preset->mask;
574 if (preset->afg && preset->afg != codec->afg)
576 if (preset->mfg && preset->mfg != codec->mfg)
580 if (preset->id == (codec->vendor_id & mask) &&
582 preset->rev == codec->revision_id)) {
583 mutex_unlock(&preset_mutex);
584 codec->owner = tbl->owner;
588 module_put(tbl->owner);
590 mutex_unlock(&preset_mutex);
592 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
595 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
598 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
599 (codec->vendor_id >> 16) & 0xffff);
600 request_module(name);
608 * get_codec_name - store the codec name
610 static int get_codec_name(struct hda_codec *codec)
612 const struct hda_vendor_id *c;
613 const char *vendor = NULL;
614 u16 vendor_id = codec->vendor_id >> 16;
615 char tmp[16], name[32];
617 for (c = hda_vendor_ids; c->id; c++) {
618 if (c->id == vendor_id) {
624 sprintf(tmp, "Generic %04x", vendor_id);
627 if (codec->preset && codec->preset->name)
628 snprintf(name, sizeof(name), "%s %s", vendor,
629 codec->preset->name);
631 snprintf(name, sizeof(name), "%s ID %x", vendor,
632 codec->vendor_id & 0xffff);
633 codec->name = kstrdup(name, GFP_KERNEL);
640 * look for an AFG and MFG nodes
642 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
647 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
648 for (i = 0; i < total_nodes; i++, nid++) {
650 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
651 switch (func & 0xff) {
652 case AC_GRP_AUDIO_FUNCTION:
655 case AC_GRP_MODEM_FUNCTION:
665 * read widget caps for each widget and store in cache
667 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
672 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
674 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
677 nid = codec->start_nid;
678 for (i = 0; i < codec->num_nodes; i++, nid++)
679 codec->wcaps[i] = snd_hda_param_read(codec, nid,
680 AC_PAR_AUDIO_WIDGET_CAP);
685 static void init_hda_cache(struct hda_cache_rec *cache,
686 unsigned int record_size);
687 static void free_hda_cache(struct hda_cache_rec *cache);
692 static void snd_hda_codec_free(struct hda_codec *codec)
696 #ifdef CONFIG_SND_HDA_POWER_SAVE
697 cancel_delayed_work(&codec->power_work);
698 flush_workqueue(codec->bus->workq);
700 list_del(&codec->list);
701 snd_array_free(&codec->mixers);
702 codec->bus->caddr_tbl[codec->addr] = NULL;
703 if (codec->patch_ops.free)
704 codec->patch_ops.free(codec);
705 module_put(codec->owner);
706 free_hda_cache(&codec->amp_cache);
707 free_hda_cache(&codec->cmd_cache);
709 kfree(codec->modelname);
715 * snd_hda_codec_new - create a HDA codec
716 * @bus: the bus to assign
717 * @codec_addr: the codec address
718 * @codecp: the pointer to store the generated codec
720 * Returns 0 if successful, or a negative error code.
722 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
723 int do_init, struct hda_codec **codecp)
725 struct hda_codec *codec;
729 if (snd_BUG_ON(!bus))
731 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
734 if (bus->caddr_tbl[codec_addr]) {
735 snd_printk(KERN_ERR "hda_codec: "
736 "address 0x%x is already occupied\n", codec_addr);
740 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
742 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
747 codec->addr = codec_addr;
748 mutex_init(&codec->spdif_mutex);
749 mutex_init(&codec->control_mutex);
750 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
751 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
752 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
753 if (codec->bus->modelname) {
754 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
755 if (!codec->modelname) {
756 snd_hda_codec_free(codec);
761 #ifdef CONFIG_SND_HDA_POWER_SAVE
762 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
763 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
764 * the caller has to power down appropriatley after initialization
767 hda_keep_power_on(codec);
770 list_add_tail(&codec->list, &bus->codec_list);
771 bus->caddr_tbl[codec_addr] = codec;
773 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
775 if (codec->vendor_id == -1)
776 /* read again, hopefully the access method was corrected
777 * in the last read...
779 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
781 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
782 AC_PAR_SUBSYSTEM_ID);
783 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
786 setup_fg_nodes(codec);
787 if (!codec->afg && !codec->mfg) {
788 snd_printdd("hda_codec: no AFG or MFG node found\n");
789 snd_hda_codec_free(codec);
793 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
794 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
795 snd_hda_codec_free(codec);
799 if (!codec->subsystem_id) {
800 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
801 codec->subsystem_id =
802 snd_hda_codec_read(codec, nid, 0,
803 AC_VERB_GET_SUBSYSTEM_ID, 0);
806 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
809 err = snd_hda_codec_configure(codec);
811 snd_hda_codec_free(codec);
815 snd_hda_codec_proc_new(codec);
817 snd_hda_create_hwdep(codec);
819 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
820 codec->subsystem_id, codec->revision_id);
821 snd_component_add(codec->bus->card, component);
827 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
829 int snd_hda_codec_configure(struct hda_codec *codec)
833 codec->preset = find_codec_preset(codec);
835 err = get_codec_name(codec);
839 /* audio codec should override the mixer name */
840 if (codec->afg || !*codec->bus->card->mixername)
841 strlcpy(codec->bus->card->mixername, codec->name,
842 sizeof(codec->bus->card->mixername));
844 if (is_generic_config(codec)) {
845 err = snd_hda_parse_generic_codec(codec);
848 if (codec->preset && codec->preset->patch) {
849 err = codec->preset->patch(codec);
853 /* call the default parser */
854 err = snd_hda_parse_generic_codec(codec);
856 printk(KERN_ERR "hda-codec: No codec parser is available\n");
859 if (!err && codec->patch_ops.unsol_event)
860 err = init_unsol_queue(codec->bus);
865 * snd_hda_codec_setup_stream - set up the codec for streaming
866 * @codec: the CODEC to set up
867 * @nid: the NID to set up
868 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
869 * @channel_id: channel id to pass, zero based.
870 * @format: stream format.
872 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
874 int channel_id, int format)
879 snd_printdd("hda_codec_setup_stream: "
880 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
881 nid, stream_tag, channel_id, format);
882 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
883 (stream_tag << 4) | channel_id);
885 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
887 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
889 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
894 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
895 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
896 #if 0 /* keep the format */
898 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
901 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
904 * amp access functions
907 /* FIXME: more better hash key? */
908 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
909 #define INFO_AMP_CAPS (1<<0)
910 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
912 /* initialize the hash table */
913 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
914 unsigned int record_size)
916 memset(cache, 0, sizeof(*cache));
917 memset(cache->hash, 0xff, sizeof(cache->hash));
918 snd_array_init(&cache->buf, record_size, 64);
921 static void free_hda_cache(struct hda_cache_rec *cache)
923 snd_array_free(&cache->buf);
926 /* query the hash. allocate an entry if not found. */
927 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
930 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
931 u16 cur = cache->hash[idx];
932 struct hda_cache_head *info;
934 while (cur != 0xffff) {
935 info = snd_array_elem(&cache->buf, cur);
936 if (info->key == key)
941 /* add a new hash entry */
942 info = snd_array_new(&cache->buf);
945 cur = snd_array_index(&cache->buf, info);
948 info->next = cache->hash[idx];
949 cache->hash[idx] = cur;
954 /* query and allocate an amp hash entry */
955 static inline struct hda_amp_info *
956 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
958 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
962 * query AMP capabilities for the given widget and direction
964 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
966 struct hda_amp_info *info;
968 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
971 if (!(info->head.val & INFO_AMP_CAPS)) {
972 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
974 info->amp_caps = snd_hda_param_read(codec, nid,
975 direction == HDA_OUTPUT ?
979 info->head.val |= INFO_AMP_CAPS;
981 return info->amp_caps;
983 EXPORT_SYMBOL_HDA(query_amp_caps);
985 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
988 struct hda_amp_info *info;
990 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
993 info->amp_caps = caps;
994 info->head.val |= INFO_AMP_CAPS;
997 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1000 * read the current volume to info
1001 * if the cache exists, read the cache value.
1003 static unsigned int get_vol_mute(struct hda_codec *codec,
1004 struct hda_amp_info *info, hda_nid_t nid,
1005 int ch, int direction, int index)
1009 if (info->head.val & INFO_AMP_VOL(ch))
1010 return info->vol[ch];
1012 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1013 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1015 val = snd_hda_codec_read(codec, nid, 0,
1016 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1017 info->vol[ch] = val & 0xff;
1018 info->head.val |= INFO_AMP_VOL(ch);
1019 return info->vol[ch];
1023 * write the current volume in info to the h/w and update the cache
1025 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1026 hda_nid_t nid, int ch, int direction, int index,
1031 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1032 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1033 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1035 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1036 info->vol[ch] = val;
1040 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1042 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1043 int direction, int index)
1045 struct hda_amp_info *info;
1046 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1049 return get_vol_mute(codec, info, nid, ch, direction, index);
1051 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1054 * update the AMP value, mask = bit mask to set, val = the value
1056 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1057 int direction, int idx, int mask, int val)
1059 struct hda_amp_info *info;
1061 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1065 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1066 if (info->vol[ch] == val)
1068 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1071 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1074 * update the AMP stereo with the same mask and value
1076 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1077 int direction, int idx, int mask, int val)
1080 for (ch = 0; ch < 2; ch++)
1081 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1085 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1087 #ifdef SND_HDA_NEEDS_RESUME
1088 /* resume the all amp commands from the cache */
1089 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1091 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1094 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1095 u32 key = buffer->head.key;
1097 unsigned int idx, dir, ch;
1101 idx = (key >> 16) & 0xff;
1102 dir = (key >> 24) & 0xff;
1103 for (ch = 0; ch < 2; ch++) {
1104 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1106 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1111 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1112 #endif /* SND_HDA_NEEDS_RESUME */
1115 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1116 struct snd_ctl_elem_info *uinfo)
1118 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1119 u16 nid = get_amp_nid(kcontrol);
1120 u8 chs = get_amp_channels(kcontrol);
1121 int dir = get_amp_direction(kcontrol);
1122 unsigned int ofs = get_amp_offset(kcontrol);
1125 caps = query_amp_caps(codec, nid, dir);
1127 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1129 printk(KERN_WARNING "hda_codec: "
1130 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1136 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1137 uinfo->count = chs == 3 ? 2 : 1;
1138 uinfo->value.integer.min = 0;
1139 uinfo->value.integer.max = caps;
1142 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1145 static inline unsigned int
1146 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1147 int ch, int dir, int idx, unsigned int ofs)
1150 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1151 val &= HDA_AMP_VOLMASK;
1160 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1161 int ch, int dir, int idx, unsigned int ofs,
1166 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1167 HDA_AMP_VOLMASK, val);
1170 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1171 struct snd_ctl_elem_value *ucontrol)
1173 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1174 hda_nid_t nid = get_amp_nid(kcontrol);
1175 int chs = get_amp_channels(kcontrol);
1176 int dir = get_amp_direction(kcontrol);
1177 int idx = get_amp_index(kcontrol);
1178 unsigned int ofs = get_amp_offset(kcontrol);
1179 long *valp = ucontrol->value.integer.value;
1182 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1184 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1187 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1189 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1190 struct snd_ctl_elem_value *ucontrol)
1192 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1193 hda_nid_t nid = get_amp_nid(kcontrol);
1194 int chs = get_amp_channels(kcontrol);
1195 int dir = get_amp_direction(kcontrol);
1196 int idx = get_amp_index(kcontrol);
1197 unsigned int ofs = get_amp_offset(kcontrol);
1198 long *valp = ucontrol->value.integer.value;
1201 snd_hda_power_up(codec);
1203 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1207 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1208 snd_hda_power_down(codec);
1211 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1213 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1214 unsigned int size, unsigned int __user *_tlv)
1216 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1217 hda_nid_t nid = get_amp_nid(kcontrol);
1218 int dir = get_amp_direction(kcontrol);
1219 unsigned int ofs = get_amp_offset(kcontrol);
1220 u32 caps, val1, val2;
1222 if (size < 4 * sizeof(unsigned int))
1224 caps = query_amp_caps(codec, nid, dir);
1225 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1226 val2 = (val2 + 1) * 25;
1227 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1229 val1 = ((int)val1) * ((int)val2);
1230 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1232 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1234 if (put_user(val1, _tlv + 2))
1236 if (put_user(val2, _tlv + 3))
1240 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1243 * set (static) TLV for virtual master volume; recalculated as max 0dB
1245 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1251 caps = query_amp_caps(codec, nid, dir);
1252 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1253 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1254 step = (step + 1) * 25;
1255 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1256 tlv[1] = 2 * sizeof(unsigned int);
1257 tlv[2] = -nums * step;
1260 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1262 /* find a mixer control element with the given name */
1263 static struct snd_kcontrol *
1264 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1265 const char *name, int idx)
1267 struct snd_ctl_elem_id id;
1268 memset(&id, 0, sizeof(id));
1269 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1271 strcpy(id.name, name);
1272 return snd_ctl_find_id(codec->bus->card, &id);
1275 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1278 return _snd_hda_find_mixer_ctl(codec, name, 0);
1280 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1282 /* Add a control element and assign to the codec */
1283 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1286 struct snd_kcontrol **knewp;
1288 err = snd_ctl_add(codec->bus->card, kctl);
1291 knewp = snd_array_new(&codec->mixers);
1297 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1299 #ifdef CONFIG_SND_HDA_RECONFIG
1300 /* Clear all controls assigned to the given codec */
1301 void snd_hda_ctls_clear(struct hda_codec *codec)
1304 struct snd_kcontrol **kctls = codec->mixers.list;
1305 for (i = 0; i < codec->mixers.used; i++)
1306 snd_ctl_remove(codec->bus->card, kctls[i]);
1307 snd_array_free(&codec->mixers);
1310 void snd_hda_codec_reset(struct hda_codec *codec)
1314 #ifdef CONFIG_SND_HDA_POWER_SAVE
1315 cancel_delayed_work(&codec->power_work);
1316 flush_workqueue(codec->bus->workq);
1318 snd_hda_ctls_clear(codec);
1320 for (i = 0; i < codec->num_pcms; i++) {
1321 if (codec->pcm_info[i].pcm) {
1322 snd_device_free(codec->bus->card,
1323 codec->pcm_info[i].pcm);
1324 clear_bit(codec->pcm_info[i].device,
1325 codec->bus->pcm_dev_bits);
1328 if (codec->patch_ops.free)
1329 codec->patch_ops.free(codec);
1330 codec->proc_widget_hook = NULL;
1332 free_hda_cache(&codec->amp_cache);
1333 free_hda_cache(&codec->cmd_cache);
1334 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1335 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1336 codec->num_pcms = 0;
1337 codec->pcm_info = NULL;
1338 codec->preset = NULL;
1339 module_put(codec->owner);
1340 codec->owner = NULL;
1342 #endif /* CONFIG_SND_HDA_RECONFIG */
1344 /* create a virtual master control and add slaves */
1345 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1346 unsigned int *tlv, const char **slaves)
1348 struct snd_kcontrol *kctl;
1352 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1355 snd_printdd("No slave found for %s\n", name);
1358 kctl = snd_ctl_make_virtual_master(name, tlv);
1361 err = snd_hda_ctl_add(codec, kctl);
1365 for (s = slaves; *s; s++) {
1366 struct snd_kcontrol *sctl;
1368 sctl = snd_hda_find_mixer_ctl(codec, *s);
1370 snd_printdd("Cannot find slave %s, skipped\n", *s);
1373 err = snd_ctl_add_slave(kctl, sctl);
1379 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1382 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1383 struct snd_ctl_elem_info *uinfo)
1385 int chs = get_amp_channels(kcontrol);
1387 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1388 uinfo->count = chs == 3 ? 2 : 1;
1389 uinfo->value.integer.min = 0;
1390 uinfo->value.integer.max = 1;
1393 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1395 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1396 struct snd_ctl_elem_value *ucontrol)
1398 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1399 hda_nid_t nid = get_amp_nid(kcontrol);
1400 int chs = get_amp_channels(kcontrol);
1401 int dir = get_amp_direction(kcontrol);
1402 int idx = get_amp_index(kcontrol);
1403 long *valp = ucontrol->value.integer.value;
1406 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1407 HDA_AMP_MUTE) ? 0 : 1;
1409 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1410 HDA_AMP_MUTE) ? 0 : 1;
1413 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1415 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1416 struct snd_ctl_elem_value *ucontrol)
1418 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1419 hda_nid_t nid = get_amp_nid(kcontrol);
1420 int chs = get_amp_channels(kcontrol);
1421 int dir = get_amp_direction(kcontrol);
1422 int idx = get_amp_index(kcontrol);
1423 long *valp = ucontrol->value.integer.value;
1426 snd_hda_power_up(codec);
1428 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1430 *valp ? 0 : HDA_AMP_MUTE);
1434 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1436 *valp ? 0 : HDA_AMP_MUTE);
1437 #ifdef CONFIG_SND_HDA_POWER_SAVE
1438 if (codec->patch_ops.check_power_status)
1439 codec->patch_ops.check_power_status(codec, nid);
1441 snd_hda_power_down(codec);
1444 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1447 * bound volume controls
1449 * bind multiple volumes (# indices, from 0)
1452 #define AMP_VAL_IDX_SHIFT 19
1453 #define AMP_VAL_IDX_MASK (0x0f<<19)
1455 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1456 struct snd_ctl_elem_value *ucontrol)
1458 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1462 mutex_lock(&codec->control_mutex);
1463 pval = kcontrol->private_value;
1464 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1465 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1466 kcontrol->private_value = pval;
1467 mutex_unlock(&codec->control_mutex);
1470 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1472 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1473 struct snd_ctl_elem_value *ucontrol)
1475 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1477 int i, indices, err = 0, change = 0;
1479 mutex_lock(&codec->control_mutex);
1480 pval = kcontrol->private_value;
1481 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1482 for (i = 0; i < indices; i++) {
1483 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1484 (i << AMP_VAL_IDX_SHIFT);
1485 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1490 kcontrol->private_value = pval;
1491 mutex_unlock(&codec->control_mutex);
1492 return err < 0 ? err : change;
1494 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1497 * generic bound volume/swtich controls
1499 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1500 struct snd_ctl_elem_info *uinfo)
1502 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1503 struct hda_bind_ctls *c;
1506 mutex_lock(&codec->control_mutex);
1507 c = (struct hda_bind_ctls *)kcontrol->private_value;
1508 kcontrol->private_value = *c->values;
1509 err = c->ops->info(kcontrol, uinfo);
1510 kcontrol->private_value = (long)c;
1511 mutex_unlock(&codec->control_mutex);
1514 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1516 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1517 struct snd_ctl_elem_value *ucontrol)
1519 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1520 struct hda_bind_ctls *c;
1523 mutex_lock(&codec->control_mutex);
1524 c = (struct hda_bind_ctls *)kcontrol->private_value;
1525 kcontrol->private_value = *c->values;
1526 err = c->ops->get(kcontrol, ucontrol);
1527 kcontrol->private_value = (long)c;
1528 mutex_unlock(&codec->control_mutex);
1531 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1533 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1534 struct snd_ctl_elem_value *ucontrol)
1536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1537 struct hda_bind_ctls *c;
1538 unsigned long *vals;
1539 int err = 0, change = 0;
1541 mutex_lock(&codec->control_mutex);
1542 c = (struct hda_bind_ctls *)kcontrol->private_value;
1543 for (vals = c->values; *vals; vals++) {
1544 kcontrol->private_value = *vals;
1545 err = c->ops->put(kcontrol, ucontrol);
1550 kcontrol->private_value = (long)c;
1551 mutex_unlock(&codec->control_mutex);
1552 return err < 0 ? err : change;
1554 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1556 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1557 unsigned int size, unsigned int __user *tlv)
1559 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1560 struct hda_bind_ctls *c;
1563 mutex_lock(&codec->control_mutex);
1564 c = (struct hda_bind_ctls *)kcontrol->private_value;
1565 kcontrol->private_value = *c->values;
1566 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1567 kcontrol->private_value = (long)c;
1568 mutex_unlock(&codec->control_mutex);
1571 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1573 struct hda_ctl_ops snd_hda_bind_vol = {
1574 .info = snd_hda_mixer_amp_volume_info,
1575 .get = snd_hda_mixer_amp_volume_get,
1576 .put = snd_hda_mixer_amp_volume_put,
1577 .tlv = snd_hda_mixer_amp_tlv
1579 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1581 struct hda_ctl_ops snd_hda_bind_sw = {
1582 .info = snd_hda_mixer_amp_switch_info,
1583 .get = snd_hda_mixer_amp_switch_get,
1584 .put = snd_hda_mixer_amp_switch_put,
1585 .tlv = snd_hda_mixer_amp_tlv
1587 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1590 * SPDIF out controls
1593 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1594 struct snd_ctl_elem_info *uinfo)
1596 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1601 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1602 struct snd_ctl_elem_value *ucontrol)
1604 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1605 IEC958_AES0_NONAUDIO |
1606 IEC958_AES0_CON_EMPHASIS_5015 |
1607 IEC958_AES0_CON_NOT_COPYRIGHT;
1608 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1609 IEC958_AES1_CON_ORIGINAL;
1613 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1614 struct snd_ctl_elem_value *ucontrol)
1616 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1617 IEC958_AES0_NONAUDIO |
1618 IEC958_AES0_PRO_EMPHASIS_5015;
1622 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1623 struct snd_ctl_elem_value *ucontrol)
1625 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1627 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1628 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1629 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1630 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1635 /* convert from SPDIF status bits to HDA SPDIF bits
1636 * bit 0 (DigEn) is always set zero (to be filled later)
1638 static unsigned short convert_from_spdif_status(unsigned int sbits)
1640 unsigned short val = 0;
1642 if (sbits & IEC958_AES0_PROFESSIONAL)
1643 val |= AC_DIG1_PROFESSIONAL;
1644 if (sbits & IEC958_AES0_NONAUDIO)
1645 val |= AC_DIG1_NONAUDIO;
1646 if (sbits & IEC958_AES0_PROFESSIONAL) {
1647 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1648 IEC958_AES0_PRO_EMPHASIS_5015)
1649 val |= AC_DIG1_EMPHASIS;
1651 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1652 IEC958_AES0_CON_EMPHASIS_5015)
1653 val |= AC_DIG1_EMPHASIS;
1654 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1655 val |= AC_DIG1_COPYRIGHT;
1656 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1657 val |= AC_DIG1_LEVEL;
1658 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1663 /* convert to SPDIF status bits from HDA SPDIF bits
1665 static unsigned int convert_to_spdif_status(unsigned short val)
1667 unsigned int sbits = 0;
1669 if (val & AC_DIG1_NONAUDIO)
1670 sbits |= IEC958_AES0_NONAUDIO;
1671 if (val & AC_DIG1_PROFESSIONAL)
1672 sbits |= IEC958_AES0_PROFESSIONAL;
1673 if (sbits & IEC958_AES0_PROFESSIONAL) {
1674 if (sbits & AC_DIG1_EMPHASIS)
1675 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1677 if (val & AC_DIG1_EMPHASIS)
1678 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1679 if (!(val & AC_DIG1_COPYRIGHT))
1680 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1681 if (val & AC_DIG1_LEVEL)
1682 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1683 sbits |= val & (0x7f << 8);
1688 /* set digital convert verbs both for the given NID and its slaves */
1689 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1694 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1695 d = codec->slave_dig_outs;
1699 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1702 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1706 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1708 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1711 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1712 struct snd_ctl_elem_value *ucontrol)
1714 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1715 hda_nid_t nid = kcontrol->private_value;
1719 mutex_lock(&codec->spdif_mutex);
1720 codec->spdif_status = ucontrol->value.iec958.status[0] |
1721 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1722 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1723 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1724 val = convert_from_spdif_status(codec->spdif_status);
1725 val |= codec->spdif_ctls & 1;
1726 change = codec->spdif_ctls != val;
1727 codec->spdif_ctls = val;
1730 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1732 mutex_unlock(&codec->spdif_mutex);
1736 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1738 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1739 struct snd_ctl_elem_value *ucontrol)
1741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1743 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1747 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1748 struct snd_ctl_elem_value *ucontrol)
1750 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1751 hda_nid_t nid = kcontrol->private_value;
1755 mutex_lock(&codec->spdif_mutex);
1756 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1757 if (ucontrol->value.integer.value[0])
1758 val |= AC_DIG1_ENABLE;
1759 change = codec->spdif_ctls != val;
1761 codec->spdif_ctls = val;
1762 set_dig_out_convert(codec, nid, val & 0xff, -1);
1763 /* unmute amp switch (if any) */
1764 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1765 (val & AC_DIG1_ENABLE))
1766 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1769 mutex_unlock(&codec->spdif_mutex);
1773 static struct snd_kcontrol_new dig_mixes[] = {
1775 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1776 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1777 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1778 .info = snd_hda_spdif_mask_info,
1779 .get = snd_hda_spdif_cmask_get,
1782 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1783 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1784 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1785 .info = snd_hda_spdif_mask_info,
1786 .get = snd_hda_spdif_pmask_get,
1789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1790 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1791 .info = snd_hda_spdif_mask_info,
1792 .get = snd_hda_spdif_default_get,
1793 .put = snd_hda_spdif_default_put,
1796 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1797 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1798 .info = snd_hda_spdif_out_switch_info,
1799 .get = snd_hda_spdif_out_switch_get,
1800 .put = snd_hda_spdif_out_switch_put,
1805 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1808 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1809 * @codec: the HDA codec
1810 * @nid: audio out widget NID
1812 * Creates controls related with the SPDIF output.
1813 * Called from each patch supporting the SPDIF out.
1815 * Returns 0 if successful, or a negative error code.
1817 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1820 struct snd_kcontrol *kctl;
1821 struct snd_kcontrol_new *dig_mix;
1824 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1825 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1829 if (idx >= SPDIF_MAX_IDX) {
1830 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1833 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1834 kctl = snd_ctl_new1(dig_mix, codec);
1837 kctl->id.index = idx;
1838 kctl->private_value = nid;
1839 err = snd_hda_ctl_add(codec, kctl);
1844 snd_hda_codec_read(codec, nid, 0,
1845 AC_VERB_GET_DIGI_CONVERT_1, 0);
1846 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1849 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1852 * SPDIF sharing with analog output
1854 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1855 struct snd_ctl_elem_value *ucontrol)
1857 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1858 ucontrol->value.integer.value[0] = mout->share_spdif;
1862 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1863 struct snd_ctl_elem_value *ucontrol)
1865 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1866 mout->share_spdif = !!ucontrol->value.integer.value[0];
1870 static struct snd_kcontrol_new spdif_share_sw = {
1871 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1872 .name = "IEC958 Default PCM Playback Switch",
1873 .info = snd_ctl_boolean_mono_info,
1874 .get = spdif_share_sw_get,
1875 .put = spdif_share_sw_put,
1878 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1879 struct hda_multi_out *mout)
1881 if (!mout->dig_out_nid)
1883 /* ATTENTION: here mout is passed as private_data, instead of codec */
1884 return snd_hda_ctl_add(codec,
1885 snd_ctl_new1(&spdif_share_sw, mout));
1887 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1893 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1895 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_value *ucontrol)
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1900 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1904 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1905 struct snd_ctl_elem_value *ucontrol)
1907 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908 hda_nid_t nid = kcontrol->private_value;
1909 unsigned int val = !!ucontrol->value.integer.value[0];
1912 mutex_lock(&codec->spdif_mutex);
1913 change = codec->spdif_in_enable != val;
1915 codec->spdif_in_enable = val;
1916 snd_hda_codec_write_cache(codec, nid, 0,
1917 AC_VERB_SET_DIGI_CONVERT_1, val);
1919 mutex_unlock(&codec->spdif_mutex);
1923 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1924 struct snd_ctl_elem_value *ucontrol)
1926 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1927 hda_nid_t nid = kcontrol->private_value;
1931 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1932 sbits = convert_to_spdif_status(val);
1933 ucontrol->value.iec958.status[0] = sbits;
1934 ucontrol->value.iec958.status[1] = sbits >> 8;
1935 ucontrol->value.iec958.status[2] = sbits >> 16;
1936 ucontrol->value.iec958.status[3] = sbits >> 24;
1940 static struct snd_kcontrol_new dig_in_ctls[] = {
1942 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1943 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1944 .info = snd_hda_spdif_in_switch_info,
1945 .get = snd_hda_spdif_in_switch_get,
1946 .put = snd_hda_spdif_in_switch_put,
1949 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1950 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1951 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1952 .info = snd_hda_spdif_mask_info,
1953 .get = snd_hda_spdif_in_status_get,
1959 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1960 * @codec: the HDA codec
1961 * @nid: audio in widget NID
1963 * Creates controls related with the SPDIF input.
1964 * Called from each patch supporting the SPDIF in.
1966 * Returns 0 if successful, or a negative error code.
1968 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1971 struct snd_kcontrol *kctl;
1972 struct snd_kcontrol_new *dig_mix;
1975 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1976 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1980 if (idx >= SPDIF_MAX_IDX) {
1981 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1984 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1985 kctl = snd_ctl_new1(dig_mix, codec);
1986 kctl->private_value = nid;
1987 err = snd_hda_ctl_add(codec, kctl);
1991 codec->spdif_in_enable =
1992 snd_hda_codec_read(codec, nid, 0,
1993 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1997 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1999 #ifdef SND_HDA_NEEDS_RESUME
2004 /* build a 32bit cache key with the widget id and the command parameter */
2005 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2006 #define get_cmd_cache_nid(key) ((key) & 0xff)
2007 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2010 * snd_hda_codec_write_cache - send a single command with caching
2011 * @codec: the HDA codec
2012 * @nid: NID to send the command
2013 * @direct: direct flag
2014 * @verb: the verb to send
2015 * @parm: the parameter for the verb
2017 * Send a single command without waiting for response.
2019 * Returns 0 if successful, or a negative error code.
2021 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2022 int direct, unsigned int verb, unsigned int parm)
2024 struct hda_bus *bus = codec->bus;
2028 res = make_codec_cmd(codec, nid, direct, verb, parm);
2029 snd_hda_power_up(codec);
2030 mutex_lock(&bus->cmd_mutex);
2031 err = bus->ops.command(bus, res);
2033 struct hda_cache_head *c;
2034 u32 key = build_cmd_cache_key(nid, verb);
2035 c = get_alloc_hash(&codec->cmd_cache, key);
2039 mutex_unlock(&bus->cmd_mutex);
2040 snd_hda_power_down(codec);
2043 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2045 /* resume the all commands from the cache */
2046 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2048 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2051 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2052 u32 key = buffer->key;
2055 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2056 get_cmd_cache_cmd(key), buffer->val);
2059 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2062 * snd_hda_sequence_write_cache - sequence writes with caching
2063 * @codec: the HDA codec
2064 * @seq: VERB array to send
2066 * Send the commands sequentially from the given array.
2067 * Thte commands are recorded on cache for power-save and resume.
2068 * The array must be terminated with NID=0.
2070 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2071 const struct hda_verb *seq)
2073 for (; seq->nid; seq++)
2074 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2077 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2078 #endif /* SND_HDA_NEEDS_RESUME */
2081 * set power state of the codec
2083 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2084 unsigned int power_state)
2089 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2091 msleep(10); /* partial workaround for "azx_get_response timeout" */
2093 nid = codec->start_nid;
2094 for (i = 0; i < codec->num_nodes; i++, nid++) {
2095 unsigned int wcaps = get_wcaps(codec, nid);
2096 if (wcaps & AC_WCAP_POWER) {
2097 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2099 if (wid_type == AC_WID_PIN) {
2100 unsigned int pincap;
2102 * don't power down the widget if it controls
2103 * eapd and EAPD_BTLENABLE is set.
2105 pincap = snd_hda_param_read(codec, nid,
2107 if (pincap & AC_PINCAP_EAPD) {
2108 int eapd = snd_hda_codec_read(codec,
2110 AC_VERB_GET_EAPD_BTLENABLE, 0);
2112 if (power_state == AC_PWRST_D3 && eapd)
2116 snd_hda_codec_write(codec, nid, 0,
2117 AC_VERB_SET_POWER_STATE,
2122 if (power_state == AC_PWRST_D0) {
2123 unsigned long end_time;
2126 /* wait until the codec reachs to D0 */
2127 end_time = jiffies + msecs_to_jiffies(500);
2129 state = snd_hda_codec_read(codec, fg, 0,
2130 AC_VERB_GET_POWER_STATE, 0);
2131 if (state == power_state)
2134 } while (time_after_eq(end_time, jiffies));
2138 #ifdef CONFIG_SND_HDA_HWDEP
2139 /* execute additional init verbs */
2140 static void hda_exec_init_verbs(struct hda_codec *codec)
2142 if (codec->init_verbs.list)
2143 snd_hda_sequence_write(codec, codec->init_verbs.list);
2146 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2149 #ifdef SND_HDA_NEEDS_RESUME
2151 * call suspend and power-down; used both from PM and power-save
2153 static void hda_call_codec_suspend(struct hda_codec *codec)
2155 if (codec->patch_ops.suspend)
2156 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2157 hda_set_power_state(codec,
2158 codec->afg ? codec->afg : codec->mfg,
2160 #ifdef CONFIG_SND_HDA_POWER_SAVE
2161 cancel_delayed_work(&codec->power_work);
2162 codec->power_on = 0;
2163 codec->power_transition = 0;
2168 * kick up codec; used both from PM and power-save
2170 static void hda_call_codec_resume(struct hda_codec *codec)
2172 hda_set_power_state(codec,
2173 codec->afg ? codec->afg : codec->mfg,
2175 hda_exec_init_verbs(codec);
2176 if (codec->patch_ops.resume)
2177 codec->patch_ops.resume(codec);
2179 if (codec->patch_ops.init)
2180 codec->patch_ops.init(codec);
2181 snd_hda_codec_resume_amp(codec);
2182 snd_hda_codec_resume_cache(codec);
2185 #endif /* SND_HDA_NEEDS_RESUME */
2189 * snd_hda_build_controls - build mixer controls
2192 * Creates mixer controls for each codec included in the bus.
2194 * Returns 0 if successful, otherwise a negative error code.
2196 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2198 struct hda_codec *codec;
2200 list_for_each_entry(codec, &bus->codec_list, list) {
2201 int err = snd_hda_codec_build_controls(codec);
2207 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2209 int snd_hda_codec_build_controls(struct hda_codec *codec)
2212 /* fake as if already powered-on */
2213 hda_keep_power_on(codec);
2215 hda_set_power_state(codec,
2216 codec->afg ? codec->afg : codec->mfg,
2218 hda_exec_init_verbs(codec);
2219 /* continue to initialize... */
2220 if (codec->patch_ops.init)
2221 err = codec->patch_ops.init(codec);
2222 if (!err && codec->patch_ops.build_controls)
2223 err = codec->patch_ops.build_controls(codec);
2224 snd_hda_power_down(codec);
2233 struct hda_rate_tbl {
2235 unsigned int alsa_bits;
2236 unsigned int hda_fmt;
2239 static struct hda_rate_tbl rate_bits[] = {
2240 /* rate in Hz, ALSA rate bitmask, HDA format value */
2242 /* autodetected value used in snd_hda_query_supported_pcm */
2243 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2244 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2245 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2246 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2247 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2248 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2249 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2250 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2251 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2252 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2253 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2254 #define AC_PAR_PCM_RATE_BITS 11
2255 /* up to bits 10, 384kHZ isn't supported properly */
2257 /* not autodetected value */
2258 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2260 { 0 } /* terminator */
2264 * snd_hda_calc_stream_format - calculate format bitset
2265 * @rate: the sample rate
2266 * @channels: the number of channels
2267 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2268 * @maxbps: the max. bps
2270 * Calculate the format bitset from the given rate, channels and th PCM format.
2272 * Return zero if invalid.
2274 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2275 unsigned int channels,
2276 unsigned int format,
2277 unsigned int maxbps)
2280 unsigned int val = 0;
2282 for (i = 0; rate_bits[i].hz; i++)
2283 if (rate_bits[i].hz == rate) {
2284 val = rate_bits[i].hda_fmt;
2287 if (!rate_bits[i].hz) {
2288 snd_printdd("invalid rate %d\n", rate);
2292 if (channels == 0 || channels > 8) {
2293 snd_printdd("invalid channels %d\n", channels);
2296 val |= channels - 1;
2298 switch (snd_pcm_format_width(format)) {
2299 case 8: val |= 0x00; break;
2300 case 16: val |= 0x10; break;
2306 else if (maxbps >= 24)
2312 snd_printdd("invalid format width %d\n",
2313 snd_pcm_format_width(format));
2319 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2322 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2323 * @codec: the HDA codec
2324 * @nid: NID to query
2325 * @ratesp: the pointer to store the detected rate bitflags
2326 * @formatsp: the pointer to store the detected formats
2327 * @bpsp: the pointer to store the detected format widths
2329 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2330 * or @bsps argument is ignored.
2332 * Returns 0 if successful, otherwise a negative error code.
2334 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2335 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2338 unsigned int val, streams;
2341 if (nid != codec->afg &&
2342 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2343 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2348 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2352 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2354 rates |= rate_bits[i].alsa_bits;
2359 if (formatsp || bpsp) {
2364 wcaps = get_wcaps(codec, nid);
2365 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2369 streams = snd_hda_param_read(codec, codec->afg,
2376 if (streams & AC_SUPFMT_PCM) {
2377 if (val & AC_SUPPCM_BITS_8) {
2378 formats |= SNDRV_PCM_FMTBIT_U8;
2381 if (val & AC_SUPPCM_BITS_16) {
2382 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2385 if (wcaps & AC_WCAP_DIGITAL) {
2386 if (val & AC_SUPPCM_BITS_32)
2387 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2388 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2389 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2390 if (val & AC_SUPPCM_BITS_24)
2392 else if (val & AC_SUPPCM_BITS_20)
2394 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2395 AC_SUPPCM_BITS_32)) {
2396 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2397 if (val & AC_SUPPCM_BITS_32)
2399 else if (val & AC_SUPPCM_BITS_24)
2401 else if (val & AC_SUPPCM_BITS_20)
2405 else if (streams == AC_SUPFMT_FLOAT32) {
2406 /* should be exclusive */
2407 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2409 } else if (streams == AC_SUPFMT_AC3) {
2410 /* should be exclusive */
2411 /* temporary hack: we have still no proper support
2412 * for the direct AC3 stream...
2414 formats |= SNDRV_PCM_FMTBIT_U8;
2418 *formatsp = formats;
2427 * snd_hda_is_supported_format - check whether the given node supports
2430 * Returns 1 if supported, 0 if not.
2432 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2433 unsigned int format)
2436 unsigned int val = 0, rate, stream;
2438 if (nid != codec->afg &&
2439 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2440 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2445 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2450 rate = format & 0xff00;
2451 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2452 if (rate_bits[i].hda_fmt == rate) {
2457 if (i >= AC_PAR_PCM_RATE_BITS)
2460 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2463 if (!stream && nid != codec->afg)
2464 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2465 if (!stream || stream == -1)
2468 if (stream & AC_SUPFMT_PCM) {
2469 switch (format & 0xf0) {
2471 if (!(val & AC_SUPPCM_BITS_8))
2475 if (!(val & AC_SUPPCM_BITS_16))
2479 if (!(val & AC_SUPPCM_BITS_20))
2483 if (!(val & AC_SUPPCM_BITS_24))
2487 if (!(val & AC_SUPPCM_BITS_32))
2494 /* FIXME: check for float32 and AC3? */
2499 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2504 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2505 struct hda_codec *codec,
2506 struct snd_pcm_substream *substream)
2511 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2512 struct hda_codec *codec,
2513 unsigned int stream_tag,
2514 unsigned int format,
2515 struct snd_pcm_substream *substream)
2517 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2521 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2522 struct hda_codec *codec,
2523 struct snd_pcm_substream *substream)
2525 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2529 static int set_pcm_default_values(struct hda_codec *codec,
2530 struct hda_pcm_stream *info)
2532 /* query support PCM information from the given NID */
2533 if (info->nid && (!info->rates || !info->formats)) {
2534 snd_hda_query_supported_pcm(codec, info->nid,
2535 info->rates ? NULL : &info->rates,
2536 info->formats ? NULL : &info->formats,
2537 info->maxbps ? NULL : &info->maxbps);
2539 if (info->ops.open == NULL)
2540 info->ops.open = hda_pcm_default_open_close;
2541 if (info->ops.close == NULL)
2542 info->ops.close = hda_pcm_default_open_close;
2543 if (info->ops.prepare == NULL) {
2544 if (snd_BUG_ON(!info->nid))
2546 info->ops.prepare = hda_pcm_default_prepare;
2548 if (info->ops.cleanup == NULL) {
2549 if (snd_BUG_ON(!info->nid))
2551 info->ops.cleanup = hda_pcm_default_cleanup;
2557 * get the empty PCM device number to assign
2559 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2561 static const char *dev_name[HDA_PCM_NTYPES] = {
2562 "Audio", "SPDIF", "HDMI", "Modem"
2564 /* starting device index for each PCM type */
2565 static int dev_idx[HDA_PCM_NTYPES] = {
2566 [HDA_PCM_TYPE_AUDIO] = 0,
2567 [HDA_PCM_TYPE_SPDIF] = 1,
2568 [HDA_PCM_TYPE_HDMI] = 3,
2569 [HDA_PCM_TYPE_MODEM] = 6
2571 /* normal audio device indices; not linear to keep compatibility */
2572 static int audio_idx[4] = { 0, 2, 4, 5 };
2576 case HDA_PCM_TYPE_AUDIO:
2577 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2579 if (!test_bit(dev, bus->pcm_dev_bits))
2582 if (i >= ARRAY_SIZE(audio_idx)) {
2583 snd_printk(KERN_WARNING "Too many audio devices\n");
2587 case HDA_PCM_TYPE_SPDIF:
2588 case HDA_PCM_TYPE_HDMI:
2589 case HDA_PCM_TYPE_MODEM:
2590 dev = dev_idx[type];
2591 if (test_bit(dev, bus->pcm_dev_bits)) {
2592 snd_printk(KERN_WARNING "%s already defined\n",
2598 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2601 set_bit(dev, bus->pcm_dev_bits);
2606 * attach a new PCM stream
2608 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2610 struct hda_bus *bus = codec->bus;
2611 struct hda_pcm_stream *info;
2614 if (snd_BUG_ON(!pcm->name))
2616 for (stream = 0; stream < 2; stream++) {
2617 info = &pcm->stream[stream];
2618 if (info->substreams) {
2619 err = set_pcm_default_values(codec, info);
2624 return bus->ops.attach_pcm(bus, codec, pcm);
2627 /* assign all PCMs of the given codec */
2628 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2633 if (!codec->num_pcms) {
2634 if (!codec->patch_ops.build_pcms)
2636 err = codec->patch_ops.build_pcms(codec);
2640 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2641 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2644 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2645 return 0; /* no substreams assigned */
2648 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2652 err = snd_hda_attach_pcm(codec, cpcm);
2661 * snd_hda_build_pcms - build PCM information
2664 * Create PCM information for each codec included in the bus.
2666 * The build_pcms codec patch is requested to set up codec->num_pcms and
2667 * codec->pcm_info properly. The array is referred by the top-level driver
2668 * to create its PCM instances.
2669 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2672 * At least, substreams, channels_min and channels_max must be filled for
2673 * each stream. substreams = 0 indicates that the stream doesn't exist.
2674 * When rates and/or formats are zero, the supported values are queried
2675 * from the given nid. The nid is used also by the default ops.prepare
2676 * and ops.cleanup callbacks.
2678 * The driver needs to call ops.open in its open callback. Similarly,
2679 * ops.close is supposed to be called in the close callback.
2680 * ops.prepare should be called in the prepare or hw_params callback
2681 * with the proper parameters for set up.
2682 * ops.cleanup should be called in hw_free for clean up of streams.
2684 * This function returns 0 if successfull, or a negative error code.
2686 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2688 struct hda_codec *codec;
2690 list_for_each_entry(codec, &bus->codec_list, list) {
2691 int err = snd_hda_codec_build_pcms(codec);
2697 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2700 * snd_hda_check_board_config - compare the current codec with the config table
2701 * @codec: the HDA codec
2702 * @num_configs: number of config enums
2703 * @models: array of model name strings
2704 * @tbl: configuration table, terminated by null entries
2706 * Compares the modelname or PCI subsystem id of the current codec with the
2707 * given configuration table. If a matching entry is found, returns its
2708 * config value (supposed to be 0 or positive).
2710 * If no entries are matching, the function returns a negative value.
2712 int snd_hda_check_board_config(struct hda_codec *codec,
2713 int num_configs, const char **models,
2714 const struct snd_pci_quirk *tbl)
2716 if (codec->modelname && models) {
2718 for (i = 0; i < num_configs; i++) {
2720 !strcmp(codec->modelname, models[i])) {
2721 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2722 "selected\n", models[i]);
2728 if (!codec->bus->pci || !tbl)
2731 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2734 if (tbl->value >= 0 && tbl->value < num_configs) {
2735 #ifdef CONFIG_SND_DEBUG_VERBOSE
2737 const char *model = NULL;
2739 model = models[tbl->value];
2741 sprintf(tmp, "#%d", tbl->value);
2744 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2745 "for config %x:%x (%s)\n",
2746 model, tbl->subvendor, tbl->subdevice,
2747 (tbl->name ? tbl->name : "Unknown device"));
2753 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2756 * snd_hda_check_board_codec_sid_config - compare the current codec
2757 subsystem ID with the
2760 This is important for Gateway notebooks with SB450 HDA Audio
2761 where the vendor ID of the PCI device is:
2762 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2763 and the vendor/subvendor are found only at the codec.
2765 * @codec: the HDA codec
2766 * @num_configs: number of config enums
2767 * @models: array of model name strings
2768 * @tbl: configuration table, terminated by null entries
2770 * Compares the modelname or PCI subsystem id of the current codec with the
2771 * given configuration table. If a matching entry is found, returns its
2772 * config value (supposed to be 0 or positive).
2774 * If no entries are matching, the function returns a negative value.
2776 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2777 int num_configs, const char **models,
2778 const struct snd_pci_quirk *tbl)
2780 const struct snd_pci_quirk *q;
2782 /* Search for codec ID */
2783 for (q = tbl; q->subvendor; q++) {
2784 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2786 if (vendorid == codec->subsystem_id)
2795 if (tbl->value >= 0 && tbl->value < num_configs) {
2796 #ifdef CONFIG_SND_DEBUG_DETECT
2798 const char *model = NULL;
2800 model = models[tbl->value];
2802 sprintf(tmp, "#%d", tbl->value);
2805 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2806 "for config %x:%x (%s)\n",
2807 model, tbl->subvendor, tbl->subdevice,
2808 (tbl->name ? tbl->name : "Unknown device"));
2814 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2817 * snd_hda_add_new_ctls - create controls from the array
2818 * @codec: the HDA codec
2819 * @knew: the array of struct snd_kcontrol_new
2821 * This helper function creates and add new controls in the given array.
2822 * The array must be terminated with an empty entry as terminator.
2824 * Returns 0 if successful, or a negative error code.
2826 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2830 for (; knew->name; knew++) {
2831 struct snd_kcontrol *kctl;
2832 kctl = snd_ctl_new1(knew, codec);
2835 err = snd_hda_ctl_add(codec, kctl);
2839 kctl = snd_ctl_new1(knew, codec);
2842 kctl->id.device = codec->addr;
2843 err = snd_hda_ctl_add(codec, kctl);
2850 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2852 #ifdef CONFIG_SND_HDA_POWER_SAVE
2853 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2854 unsigned int power_state);
2856 static void hda_power_work(struct work_struct *work)
2858 struct hda_codec *codec =
2859 container_of(work, struct hda_codec, power_work.work);
2860 struct hda_bus *bus = codec->bus;
2862 if (!codec->power_on || codec->power_count) {
2863 codec->power_transition = 0;
2867 hda_call_codec_suspend(codec);
2868 if (bus->ops.pm_notify)
2869 bus->ops.pm_notify(bus);
2872 static void hda_keep_power_on(struct hda_codec *codec)
2874 codec->power_count++;
2875 codec->power_on = 1;
2878 void snd_hda_power_up(struct hda_codec *codec)
2880 struct hda_bus *bus = codec->bus;
2882 codec->power_count++;
2883 if (codec->power_on || codec->power_transition)
2886 codec->power_on = 1;
2887 if (bus->ops.pm_notify)
2888 bus->ops.pm_notify(bus);
2889 hda_call_codec_resume(codec);
2890 cancel_delayed_work(&codec->power_work);
2891 codec->power_transition = 0;
2893 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2895 #define power_save(codec) \
2896 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2898 #define power_save(codec) \
2899 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2901 void snd_hda_power_down(struct hda_codec *codec)
2903 --codec->power_count;
2904 if (!codec->power_on || codec->power_count || codec->power_transition)
2906 if (power_save(codec)) {
2907 codec->power_transition = 1; /* avoid reentrance */
2908 queue_delayed_work(codec->bus->workq, &codec->power_work,
2909 msecs_to_jiffies(power_save(codec) * 1000));
2912 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2914 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2915 struct hda_loopback_check *check,
2918 struct hda_amp_list *p;
2921 if (!check->amplist)
2923 for (p = check->amplist; p->nid; p++) {
2928 return 0; /* nothing changed */
2930 for (p = check->amplist; p->nid; p++) {
2931 for (ch = 0; ch < 2; ch++) {
2932 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2934 if (!(v & HDA_AMP_MUTE) && v > 0) {
2935 if (!check->power_on) {
2936 check->power_on = 1;
2937 snd_hda_power_up(codec);
2943 if (check->power_on) {
2944 check->power_on = 0;
2945 snd_hda_power_down(codec);
2949 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2953 * Channel mode helper
2955 int snd_hda_ch_mode_info(struct hda_codec *codec,
2956 struct snd_ctl_elem_info *uinfo,
2957 const struct hda_channel_mode *chmode,
2960 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2962 uinfo->value.enumerated.items = num_chmodes;
2963 if (uinfo->value.enumerated.item >= num_chmodes)
2964 uinfo->value.enumerated.item = num_chmodes - 1;
2965 sprintf(uinfo->value.enumerated.name, "%dch",
2966 chmode[uinfo->value.enumerated.item].channels);
2969 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2971 int snd_hda_ch_mode_get(struct hda_codec *codec,
2972 struct snd_ctl_elem_value *ucontrol,
2973 const struct hda_channel_mode *chmode,
2979 for (i = 0; i < num_chmodes; i++) {
2980 if (max_channels == chmode[i].channels) {
2981 ucontrol->value.enumerated.item[0] = i;
2987 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2989 int snd_hda_ch_mode_put(struct hda_codec *codec,
2990 struct snd_ctl_elem_value *ucontrol,
2991 const struct hda_channel_mode *chmode,
2997 mode = ucontrol->value.enumerated.item[0];
2998 if (mode >= num_chmodes)
3000 if (*max_channelsp == chmode[mode].channels)
3002 /* change the current channel setting */
3003 *max_channelsp = chmode[mode].channels;
3004 if (chmode[mode].sequence)
3005 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3008 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3013 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3014 struct snd_ctl_elem_info *uinfo)
3018 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3020 uinfo->value.enumerated.items = imux->num_items;
3021 if (!imux->num_items)
3023 index = uinfo->value.enumerated.item;
3024 if (index >= imux->num_items)
3025 index = imux->num_items - 1;
3026 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3029 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3031 int snd_hda_input_mux_put(struct hda_codec *codec,
3032 const struct hda_input_mux *imux,
3033 struct snd_ctl_elem_value *ucontrol,
3035 unsigned int *cur_val)
3039 if (!imux->num_items)
3041 idx = ucontrol->value.enumerated.item[0];
3042 if (idx >= imux->num_items)
3043 idx = imux->num_items - 1;
3044 if (*cur_val == idx)
3046 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3047 imux->items[idx].index);
3051 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3055 * Multi-channel / digital-out PCM helper functions
3058 /* setup SPDIF output stream */
3059 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3060 unsigned int stream_tag, unsigned int format)
3062 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3063 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3064 set_dig_out_convert(codec, nid,
3065 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3067 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3068 if (codec->slave_dig_outs) {
3070 for (d = codec->slave_dig_outs; *d; d++)
3071 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3074 /* turn on again (if needed) */
3075 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3076 set_dig_out_convert(codec, nid,
3077 codec->spdif_ctls & 0xff, -1);
3080 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3082 snd_hda_codec_cleanup_stream(codec, nid);
3083 if (codec->slave_dig_outs) {
3085 for (d = codec->slave_dig_outs; *d; d++)
3086 snd_hda_codec_cleanup_stream(codec, *d);
3091 * open the digital out in the exclusive mode
3093 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3094 struct hda_multi_out *mout)
3096 mutex_lock(&codec->spdif_mutex);
3097 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3098 /* already opened as analog dup; reset it once */
3099 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3100 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3101 mutex_unlock(&codec->spdif_mutex);
3104 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3106 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3107 struct hda_multi_out *mout,
3108 unsigned int stream_tag,
3109 unsigned int format,
3110 struct snd_pcm_substream *substream)
3112 mutex_lock(&codec->spdif_mutex);
3113 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3114 mutex_unlock(&codec->spdif_mutex);
3117 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3120 * release the digital out
3122 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3123 struct hda_multi_out *mout)
3125 mutex_lock(&codec->spdif_mutex);
3126 mout->dig_out_used = 0;
3127 mutex_unlock(&codec->spdif_mutex);
3130 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3133 * set up more restrictions for analog out
3135 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3136 struct hda_multi_out *mout,
3137 struct snd_pcm_substream *substream,
3138 struct hda_pcm_stream *hinfo)
3140 struct snd_pcm_runtime *runtime = substream->runtime;
3141 runtime->hw.channels_max = mout->max_channels;
3142 if (mout->dig_out_nid) {
3143 if (!mout->analog_rates) {
3144 mout->analog_rates = hinfo->rates;
3145 mout->analog_formats = hinfo->formats;
3146 mout->analog_maxbps = hinfo->maxbps;
3148 runtime->hw.rates = mout->analog_rates;
3149 runtime->hw.formats = mout->analog_formats;
3150 hinfo->maxbps = mout->analog_maxbps;
3152 if (!mout->spdif_rates) {
3153 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3155 &mout->spdif_formats,
3156 &mout->spdif_maxbps);
3158 mutex_lock(&codec->spdif_mutex);
3159 if (mout->share_spdif) {
3160 runtime->hw.rates &= mout->spdif_rates;
3161 runtime->hw.formats &= mout->spdif_formats;
3162 if (mout->spdif_maxbps < hinfo->maxbps)
3163 hinfo->maxbps = mout->spdif_maxbps;
3165 mutex_unlock(&codec->spdif_mutex);
3167 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3168 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3170 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3173 * set up the i/o for analog out
3174 * when the digital out is available, copy the front out to digital out, too.
3176 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3177 struct hda_multi_out *mout,
3178 unsigned int stream_tag,
3179 unsigned int format,
3180 struct snd_pcm_substream *substream)
3182 hda_nid_t *nids = mout->dac_nids;
3183 int chs = substream->runtime->channels;
3186 mutex_lock(&codec->spdif_mutex);
3187 if (mout->dig_out_nid && mout->share_spdif &&
3188 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3190 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3192 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3193 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3194 setup_dig_out_stream(codec, mout->dig_out_nid,
3195 stream_tag, format);
3197 mout->dig_out_used = 0;
3198 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3201 mutex_unlock(&codec->spdif_mutex);
3204 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3206 if (!mout->no_share_stream &&
3207 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3208 /* headphone out will just decode front left/right (stereo) */
3209 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3211 /* extra outputs copied from front */
3212 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3213 if (!mout->no_share_stream && mout->extra_out_nid[i])
3214 snd_hda_codec_setup_stream(codec,
3215 mout->extra_out_nid[i],
3216 stream_tag, 0, format);
3219 for (i = 1; i < mout->num_dacs; i++) {
3220 if (chs >= (i + 1) * 2) /* independent out */
3221 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3223 else if (!mout->no_share_stream) /* copy front */
3224 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3229 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3232 * clean up the setting for analog out
3234 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3235 struct hda_multi_out *mout)
3237 hda_nid_t *nids = mout->dac_nids;
3240 for (i = 0; i < mout->num_dacs; i++)
3241 snd_hda_codec_cleanup_stream(codec, nids[i]);
3243 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3244 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3245 if (mout->extra_out_nid[i])
3246 snd_hda_codec_cleanup_stream(codec,
3247 mout->extra_out_nid[i]);
3248 mutex_lock(&codec->spdif_mutex);
3249 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3250 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3251 mout->dig_out_used = 0;
3253 mutex_unlock(&codec->spdif_mutex);
3256 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3259 * Helper for automatic pin configuration
3262 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3264 for (; *list; list++)
3272 * Sort an associated group of pins according to their sequence numbers.
3274 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3281 for (i = 0; i < num_pins; i++) {
3282 for (j = i + 1; j < num_pins; j++) {
3283 if (sequences[i] > sequences[j]) {
3285 sequences[i] = sequences[j];
3297 * Parse all pin widgets and store the useful pin nids to cfg
3299 * The number of line-outs or any primary output is stored in line_outs,
3300 * and the corresponding output pins are assigned to line_out_pins[],
3301 * in the order of front, rear, CLFE, side, ...
3303 * If more extra outputs (speaker and headphone) are found, the pins are
3304 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3305 * is detected, one of speaker of HP pins is assigned as the primary
3306 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3307 * if any analog output exists.
3309 * The analog input pins are assigned to input_pins array.
3310 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3313 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3314 struct auto_pin_cfg *cfg,
3315 hda_nid_t *ignore_nids)
3317 hda_nid_t nid, end_nid;
3318 short seq, assoc_line_out, assoc_speaker;
3319 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3320 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3321 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3323 memset(cfg, 0, sizeof(*cfg));
3325 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3326 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3327 memset(sequences_hp, 0, sizeof(sequences_hp));
3328 assoc_line_out = assoc_speaker = 0;
3330 end_nid = codec->start_nid + codec->num_nodes;
3331 for (nid = codec->start_nid; nid < end_nid; nid++) {
3332 unsigned int wid_caps = get_wcaps(codec, nid);
3333 unsigned int wid_type =
3334 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3335 unsigned int def_conf;
3338 /* read all default configuration for pin complex */
3339 if (wid_type != AC_WID_PIN)
3341 /* ignore the given nids (e.g. pc-beep returns error) */
3342 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3345 def_conf = snd_hda_codec_read(codec, nid, 0,
3346 AC_VERB_GET_CONFIG_DEFAULT, 0);
3347 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3349 loc = get_defcfg_location(def_conf);
3350 switch (get_defcfg_device(def_conf)) {
3351 case AC_JACK_LINE_OUT:
3352 seq = get_defcfg_sequence(def_conf);
3353 assoc = get_defcfg_association(def_conf);
3355 if (!(wid_caps & AC_WCAP_STEREO))
3356 if (!cfg->mono_out_pin)
3357 cfg->mono_out_pin = nid;
3360 if (!assoc_line_out)
3361 assoc_line_out = assoc;
3362 else if (assoc_line_out != assoc)
3364 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3366 cfg->line_out_pins[cfg->line_outs] = nid;
3367 sequences_line_out[cfg->line_outs] = seq;
3370 case AC_JACK_SPEAKER:
3371 seq = get_defcfg_sequence(def_conf);
3372 assoc = get_defcfg_association(def_conf);
3375 if (! assoc_speaker)
3376 assoc_speaker = assoc;
3377 else if (assoc_speaker != assoc)
3379 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3381 cfg->speaker_pins[cfg->speaker_outs] = nid;
3382 sequences_speaker[cfg->speaker_outs] = seq;
3383 cfg->speaker_outs++;
3385 case AC_JACK_HP_OUT:
3386 seq = get_defcfg_sequence(def_conf);
3387 assoc = get_defcfg_association(def_conf);
3388 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3390 cfg->hp_pins[cfg->hp_outs] = nid;
3391 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3394 case AC_JACK_MIC_IN: {
3396 if (loc == AC_JACK_LOC_FRONT) {
3397 preferred = AUTO_PIN_FRONT_MIC;
3400 preferred = AUTO_PIN_MIC;
3401 alt = AUTO_PIN_FRONT_MIC;
3403 if (!cfg->input_pins[preferred])
3404 cfg->input_pins[preferred] = nid;
3405 else if (!cfg->input_pins[alt])
3406 cfg->input_pins[alt] = nid;
3409 case AC_JACK_LINE_IN:
3410 if (loc == AC_JACK_LOC_FRONT)
3411 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3413 cfg->input_pins[AUTO_PIN_LINE] = nid;
3416 cfg->input_pins[AUTO_PIN_CD] = nid;
3419 cfg->input_pins[AUTO_PIN_AUX] = nid;
3421 case AC_JACK_SPDIF_OUT:
3422 cfg->dig_out_pin = nid;
3424 case AC_JACK_SPDIF_IN:
3425 cfg->dig_in_pin = nid;
3431 * If no line-out is defined but multiple HPs are found,
3432 * some of them might be the real line-outs.
3434 if (!cfg->line_outs && cfg->hp_outs > 1) {
3436 while (i < cfg->hp_outs) {
3437 /* The real HPs should have the sequence 0x0f */
3438 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3442 /* Move it to the line-out table */
3443 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3444 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3447 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3448 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3449 memmove(sequences_hp + i - 1, sequences_hp + i,
3450 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3454 /* sort by sequence */
3455 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3457 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3459 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3462 /* if we have only one mic, make it AUTO_PIN_MIC */
3463 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3464 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3465 cfg->input_pins[AUTO_PIN_MIC] =
3466 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3467 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3469 /* ditto for line-in */
3470 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3471 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3472 cfg->input_pins[AUTO_PIN_LINE] =
3473 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3474 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3478 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3479 * as a primary output
3481 if (!cfg->line_outs) {
3482 if (cfg->speaker_outs) {
3483 cfg->line_outs = cfg->speaker_outs;
3484 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3485 sizeof(cfg->speaker_pins));
3486 cfg->speaker_outs = 0;
3487 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3488 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3489 } else if (cfg->hp_outs) {
3490 cfg->line_outs = cfg->hp_outs;
3491 memcpy(cfg->line_out_pins, cfg->hp_pins,
3492 sizeof(cfg->hp_pins));
3494 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3495 cfg->line_out_type = AUTO_PIN_HP_OUT;
3499 /* Reorder the surround channels
3500 * ALSA sequence is front/surr/clfe/side
3502 * 4-ch: front/surr => OK as it is
3503 * 6-ch: front/clfe/surr
3504 * 8-ch: front/clfe/rear/side|fc
3506 switch (cfg->line_outs) {
3509 nid = cfg->line_out_pins[1];
3510 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3511 cfg->line_out_pins[2] = nid;
3516 * debug prints of the parsed results
3518 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3519 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3520 cfg->line_out_pins[2], cfg->line_out_pins[3],
3521 cfg->line_out_pins[4]);
3522 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3523 cfg->speaker_outs, cfg->speaker_pins[0],
3524 cfg->speaker_pins[1], cfg->speaker_pins[2],
3525 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3526 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3527 cfg->hp_outs, cfg->hp_pins[0],
3528 cfg->hp_pins[1], cfg->hp_pins[2],
3529 cfg->hp_pins[3], cfg->hp_pins[4]);
3530 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3531 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3532 " cd=0x%x, aux=0x%x\n",
3533 cfg->input_pins[AUTO_PIN_MIC],
3534 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3535 cfg->input_pins[AUTO_PIN_LINE],
3536 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3537 cfg->input_pins[AUTO_PIN_CD],
3538 cfg->input_pins[AUTO_PIN_AUX]);
3542 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3544 /* labels for input pins */
3545 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3546 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3548 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3557 * snd_hda_suspend - suspend the codecs
3559 * @state: suspsend state
3561 * Returns 0 if successful.
3563 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3565 struct hda_codec *codec;
3567 list_for_each_entry(codec, &bus->codec_list, list) {
3568 #ifdef CONFIG_SND_HDA_POWER_SAVE
3569 if (!codec->power_on)
3572 hda_call_codec_suspend(codec);
3576 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3579 * snd_hda_resume - resume the codecs
3582 * Returns 0 if successful.
3584 * This fucntion is defined only when POWER_SAVE isn't set.
3585 * In the power-save mode, the codec is resumed dynamically.
3587 int snd_hda_resume(struct hda_bus *bus)
3589 struct hda_codec *codec;
3591 list_for_each_entry(codec, &bus->codec_list, list) {
3592 if (snd_hda_codec_needs_resume(codec))
3593 hda_call_codec_resume(codec);
3597 EXPORT_SYMBOL_HDA(snd_hda_resume);
3598 #endif /* CONFIG_PM */
3604 /* get a new element from the given array
3605 * if it exceeds the pre-allocated array size, re-allocate the array
3607 void *snd_array_new(struct snd_array *array)
3609 if (array->used >= array->alloced) {
3610 int num = array->alloced + array->alloc_align;
3612 if (snd_BUG_ON(num >= 4096))
3614 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3618 memcpy(nlist, array->list,
3619 array->elem_size * array->alloced);
3622 array->list = nlist;
3623 array->alloced = num;
3625 return snd_array_elem(array, array->used++);
3627 EXPORT_SYMBOL_HDA(snd_array_new);
3629 /* free the given array elements */
3630 void snd_array_free(struct snd_array *array)
3637 EXPORT_SYMBOL_HDA(snd_array_free);
3640 * used by hda_proc.c and hda_eld.c
3642 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3644 static unsigned int rates[] = {
3645 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3646 96000, 176400, 192000, 384000
3650 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3652 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3654 buf[j] = '\0'; /* necessary when j == 0 */
3656 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3658 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3660 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3663 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3664 if (pcm & (AC_SUPPCM_BITS_8 << i))
3665 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3667 buf[j] = '\0'; /* necessary when j == 0 */
3669 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3671 MODULE_DESCRIPTION("HDA codec core");
3672 MODULE_LICENSE("GPL");