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 schedule_work(&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_scheduled_work();
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);
453 static int snd_hda_bus_dev_free(struct snd_device *device)
455 struct hda_bus *bus = device->device_data;
457 return snd_hda_bus_free(bus);
460 #ifdef CONFIG_SND_HDA_HWDEP
461 static int snd_hda_bus_dev_register(struct snd_device *device)
463 struct hda_bus *bus = device->device_data;
464 struct hda_codec *codec;
465 list_for_each_entry(codec, &bus->codec_list, list) {
466 snd_hda_hwdep_add_sysfs(codec);
471 #define snd_hda_bus_dev_register NULL
475 * snd_hda_bus_new - create a HDA bus
476 * @card: the card entry
477 * @temp: the template for hda_bus information
478 * @busp: the pointer to store the created bus instance
480 * Returns 0 if successful, or a negative error code.
482 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
483 const struct hda_bus_template *temp,
484 struct hda_bus **busp)
488 static struct snd_device_ops dev_ops = {
489 .dev_register = snd_hda_bus_dev_register,
490 .dev_free = snd_hda_bus_dev_free,
493 if (snd_BUG_ON(!temp))
495 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
501 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
503 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
508 bus->private_data = temp->private_data;
509 bus->pci = temp->pci;
510 bus->modelname = temp->modelname;
511 bus->power_save = temp->power_save;
512 bus->ops = temp->ops;
514 mutex_init(&bus->cmd_mutex);
515 INIT_LIST_HEAD(&bus->codec_list);
517 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
519 snd_hda_bus_free(bus);
526 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
528 #ifdef CONFIG_SND_HDA_GENERIC
529 #define is_generic_config(codec) \
530 (codec->modelname && !strcmp(codec->modelname, "generic"))
532 #define is_generic_config(codec) 0
536 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
538 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
542 * find a matching codec preset
544 static const struct hda_codec_preset *
545 find_codec_preset(struct hda_codec *codec)
547 struct hda_codec_preset_list *tbl;
548 const struct hda_codec_preset *preset;
549 int mod_requested = 0;
551 if (is_generic_config(codec))
552 return NULL; /* use the generic parser */
555 mutex_lock(&preset_mutex);
556 list_for_each_entry(tbl, &hda_preset_tables, list) {
557 if (!try_module_get(tbl->owner)) {
558 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
561 for (preset = tbl->preset; preset->id; preset++) {
562 u32 mask = preset->mask;
563 if (preset->afg && preset->afg != codec->afg)
565 if (preset->mfg && preset->mfg != codec->mfg)
569 if (preset->id == (codec->vendor_id & mask) &&
571 preset->rev == codec->revision_id)) {
572 mutex_unlock(&preset_mutex);
573 codec->owner = tbl->owner;
577 module_put(tbl->owner);
579 mutex_unlock(&preset_mutex);
581 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
584 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
587 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
588 (codec->vendor_id >> 16) & 0xffff);
589 request_module(name);
597 * get_codec_name - store the codec name
599 static int get_codec_name(struct hda_codec *codec)
601 const struct hda_vendor_id *c;
602 const char *vendor = NULL;
603 u16 vendor_id = codec->vendor_id >> 16;
604 char tmp[16], name[32];
606 for (c = hda_vendor_ids; c->id; c++) {
607 if (c->id == vendor_id) {
613 sprintf(tmp, "Generic %04x", vendor_id);
616 if (codec->preset && codec->preset->name)
617 snprintf(name, sizeof(name), "%s %s", vendor,
618 codec->preset->name);
620 snprintf(name, sizeof(name), "%s ID %x", vendor,
621 codec->vendor_id & 0xffff);
622 codec->name = kstrdup(name, GFP_KERNEL);
629 * look for an AFG and MFG nodes
631 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
636 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
637 for (i = 0; i < total_nodes; i++, nid++) {
639 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
640 switch (func & 0xff) {
641 case AC_GRP_AUDIO_FUNCTION:
644 case AC_GRP_MODEM_FUNCTION:
654 * read widget caps for each widget and store in cache
656 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
661 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
663 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
666 nid = codec->start_nid;
667 for (i = 0; i < codec->num_nodes; i++, nid++)
668 codec->wcaps[i] = snd_hda_param_read(codec, nid,
669 AC_PAR_AUDIO_WIDGET_CAP);
674 static void init_hda_cache(struct hda_cache_rec *cache,
675 unsigned int record_size);
676 static void free_hda_cache(struct hda_cache_rec *cache);
681 static void snd_hda_codec_free(struct hda_codec *codec)
685 #ifdef CONFIG_SND_HDA_POWER_SAVE
686 cancel_delayed_work(&codec->power_work);
687 flush_scheduled_work();
689 list_del(&codec->list);
690 snd_array_free(&codec->mixers);
691 codec->bus->caddr_tbl[codec->addr] = NULL;
692 if (codec->patch_ops.free)
693 codec->patch_ops.free(codec);
694 module_put(codec->owner);
695 free_hda_cache(&codec->amp_cache);
696 free_hda_cache(&codec->cmd_cache);
698 kfree(codec->modelname);
704 * snd_hda_codec_new - create a HDA codec
705 * @bus: the bus to assign
706 * @codec_addr: the codec address
707 * @codecp: the pointer to store the generated codec
709 * Returns 0 if successful, or a negative error code.
711 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
712 struct hda_codec **codecp)
714 struct hda_codec *codec;
718 if (snd_BUG_ON(!bus))
720 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
723 if (bus->caddr_tbl[codec_addr]) {
724 snd_printk(KERN_ERR "hda_codec: "
725 "address 0x%x is already occupied\n", codec_addr);
729 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
731 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
736 codec->addr = codec_addr;
737 mutex_init(&codec->spdif_mutex);
738 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
739 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
740 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
741 if (codec->bus->modelname) {
742 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
743 if (!codec->modelname) {
744 snd_hda_codec_free(codec);
749 #ifdef CONFIG_SND_HDA_POWER_SAVE
750 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
751 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
752 * the caller has to power down appropriatley after initialization
755 hda_keep_power_on(codec);
758 list_add_tail(&codec->list, &bus->codec_list);
759 bus->caddr_tbl[codec_addr] = codec;
761 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
763 if (codec->vendor_id == -1)
764 /* read again, hopefully the access method was corrected
765 * in the last read...
767 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
769 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
770 AC_PAR_SUBSYSTEM_ID);
771 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
774 setup_fg_nodes(codec);
775 if (!codec->afg && !codec->mfg) {
776 snd_printdd("hda_codec: no AFG or MFG node found\n");
777 snd_hda_codec_free(codec);
781 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
782 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
783 snd_hda_codec_free(codec);
787 if (!codec->subsystem_id) {
788 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
789 codec->subsystem_id =
790 snd_hda_codec_read(codec, nid, 0,
791 AC_VERB_GET_SUBSYSTEM_ID, 0);
794 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
796 err = snd_hda_codec_configure(codec);
798 snd_hda_codec_free(codec);
801 snd_hda_codec_proc_new(codec);
803 snd_hda_create_hwdep(codec);
805 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
806 codec->subsystem_id, codec->revision_id);
807 snd_component_add(codec->bus->card, component);
813 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
815 int snd_hda_codec_configure(struct hda_codec *codec)
819 codec->preset = find_codec_preset(codec);
821 err = get_codec_name(codec);
825 /* audio codec should override the mixer name */
826 if (codec->afg || !*codec->bus->card->mixername)
827 strlcpy(codec->bus->card->mixername, codec->name,
828 sizeof(codec->bus->card->mixername));
830 if (is_generic_config(codec)) {
831 err = snd_hda_parse_generic_codec(codec);
834 if (codec->preset && codec->preset->patch) {
835 err = codec->preset->patch(codec);
839 /* call the default parser */
840 err = snd_hda_parse_generic_codec(codec);
842 printk(KERN_ERR "hda-codec: No codec parser is available\n");
845 if (!err && codec->patch_ops.unsol_event)
846 err = init_unsol_queue(codec->bus);
851 * snd_hda_codec_setup_stream - set up the codec for streaming
852 * @codec: the CODEC to set up
853 * @nid: the NID to set up
854 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
855 * @channel_id: channel id to pass, zero based.
856 * @format: stream format.
858 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
860 int channel_id, int format)
865 snd_printdd("hda_codec_setup_stream: "
866 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
867 nid, stream_tag, channel_id, format);
868 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
869 (stream_tag << 4) | channel_id);
871 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
873 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
875 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
880 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
881 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
882 #if 0 /* keep the format */
884 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
887 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
890 * amp access functions
893 /* FIXME: more better hash key? */
894 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
895 #define INFO_AMP_CAPS (1<<0)
896 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
898 /* initialize the hash table */
899 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
900 unsigned int record_size)
902 memset(cache, 0, sizeof(*cache));
903 memset(cache->hash, 0xff, sizeof(cache->hash));
904 snd_array_init(&cache->buf, record_size, 64);
907 static void free_hda_cache(struct hda_cache_rec *cache)
909 snd_array_free(&cache->buf);
912 /* query the hash. allocate an entry if not found. */
913 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
916 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
917 u16 cur = cache->hash[idx];
918 struct hda_cache_head *info;
920 while (cur != 0xffff) {
921 info = snd_array_elem(&cache->buf, cur);
922 if (info->key == key)
927 /* add a new hash entry */
928 info = snd_array_new(&cache->buf);
931 cur = snd_array_index(&cache->buf, info);
934 info->next = cache->hash[idx];
935 cache->hash[idx] = cur;
940 /* query and allocate an amp hash entry */
941 static inline struct hda_amp_info *
942 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
944 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
948 * query AMP capabilities for the given widget and direction
950 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
952 struct hda_amp_info *info;
954 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
957 if (!(info->head.val & INFO_AMP_CAPS)) {
958 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
960 info->amp_caps = snd_hda_param_read(codec, nid,
961 direction == HDA_OUTPUT ?
965 info->head.val |= INFO_AMP_CAPS;
967 return info->amp_caps;
969 EXPORT_SYMBOL_HDA(query_amp_caps);
971 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
974 struct hda_amp_info *info;
976 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
979 info->amp_caps = caps;
980 info->head.val |= INFO_AMP_CAPS;
983 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
986 * read the current volume to info
987 * if the cache exists, read the cache value.
989 static unsigned int get_vol_mute(struct hda_codec *codec,
990 struct hda_amp_info *info, hda_nid_t nid,
991 int ch, int direction, int index)
995 if (info->head.val & INFO_AMP_VOL(ch))
996 return info->vol[ch];
998 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
999 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1001 val = snd_hda_codec_read(codec, nid, 0,
1002 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1003 info->vol[ch] = val & 0xff;
1004 info->head.val |= INFO_AMP_VOL(ch);
1005 return info->vol[ch];
1009 * write the current volume in info to the h/w and update the cache
1011 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1012 hda_nid_t nid, int ch, int direction, int index,
1017 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1018 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1019 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1021 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1022 info->vol[ch] = val;
1026 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1028 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1029 int direction, int index)
1031 struct hda_amp_info *info;
1032 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1035 return get_vol_mute(codec, info, nid, ch, direction, index);
1037 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1040 * update the AMP value, mask = bit mask to set, val = the value
1042 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1043 int direction, int idx, int mask, int val)
1045 struct hda_amp_info *info;
1047 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1051 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1052 if (info->vol[ch] == val)
1054 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1057 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1060 * update the AMP stereo with the same mask and value
1062 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1063 int direction, int idx, int mask, int val)
1066 for (ch = 0; ch < 2; ch++)
1067 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1071 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1073 #ifdef SND_HDA_NEEDS_RESUME
1074 /* resume the all amp commands from the cache */
1075 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1077 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1080 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1081 u32 key = buffer->head.key;
1083 unsigned int idx, dir, ch;
1087 idx = (key >> 16) & 0xff;
1088 dir = (key >> 24) & 0xff;
1089 for (ch = 0; ch < 2; ch++) {
1090 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1092 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1097 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1098 #endif /* SND_HDA_NEEDS_RESUME */
1101 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1102 struct snd_ctl_elem_info *uinfo)
1104 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1105 u16 nid = get_amp_nid(kcontrol);
1106 u8 chs = get_amp_channels(kcontrol);
1107 int dir = get_amp_direction(kcontrol);
1110 caps = query_amp_caps(codec, nid, dir);
1112 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1114 printk(KERN_WARNING "hda_codec: "
1115 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1119 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1120 uinfo->count = chs == 3 ? 2 : 1;
1121 uinfo->value.integer.min = 0;
1122 uinfo->value.integer.max = caps;
1125 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1127 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1128 struct snd_ctl_elem_value *ucontrol)
1130 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1131 hda_nid_t nid = get_amp_nid(kcontrol);
1132 int chs = get_amp_channels(kcontrol);
1133 int dir = get_amp_direction(kcontrol);
1134 int idx = get_amp_index(kcontrol);
1135 long *valp = ucontrol->value.integer.value;
1138 *valp++ = snd_hda_codec_amp_read(codec, nid, 0, dir, idx)
1141 *valp = snd_hda_codec_amp_read(codec, nid, 1, dir, idx)
1145 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1147 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1148 struct snd_ctl_elem_value *ucontrol)
1150 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1151 hda_nid_t nid = get_amp_nid(kcontrol);
1152 int chs = get_amp_channels(kcontrol);
1153 int dir = get_amp_direction(kcontrol);
1154 int idx = get_amp_index(kcontrol);
1155 long *valp = ucontrol->value.integer.value;
1158 snd_hda_power_up(codec);
1160 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1165 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1167 snd_hda_power_down(codec);
1170 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1172 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1173 unsigned int size, unsigned int __user *_tlv)
1175 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1176 hda_nid_t nid = get_amp_nid(kcontrol);
1177 int dir = get_amp_direction(kcontrol);
1178 u32 caps, val1, val2;
1180 if (size < 4 * sizeof(unsigned int))
1182 caps = query_amp_caps(codec, nid, dir);
1183 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1184 val2 = (val2 + 1) * 25;
1185 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1186 val1 = ((int)val1) * ((int)val2);
1187 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1189 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1191 if (put_user(val1, _tlv + 2))
1193 if (put_user(val2, _tlv + 3))
1197 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1200 * set (static) TLV for virtual master volume; recalculated as max 0dB
1202 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1208 caps = query_amp_caps(codec, nid, dir);
1209 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1210 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1211 step = (step + 1) * 25;
1212 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1213 tlv[1] = 2 * sizeof(unsigned int);
1214 tlv[2] = -nums * step;
1217 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1219 /* find a mixer control element with the given name */
1220 static struct snd_kcontrol *
1221 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1222 const char *name, int idx)
1224 struct snd_ctl_elem_id id;
1225 memset(&id, 0, sizeof(id));
1226 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1228 strcpy(id.name, name);
1229 return snd_ctl_find_id(codec->bus->card, &id);
1232 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1235 return _snd_hda_find_mixer_ctl(codec, name, 0);
1237 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1239 /* Add a control element and assign to the codec */
1240 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1243 struct snd_kcontrol **knewp;
1245 err = snd_ctl_add(codec->bus->card, kctl);
1248 knewp = snd_array_new(&codec->mixers);
1254 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1256 #ifdef CONFIG_SND_HDA_RECONFIG
1257 /* Clear all controls assigned to the given codec */
1258 void snd_hda_ctls_clear(struct hda_codec *codec)
1261 struct snd_kcontrol **kctls = codec->mixers.list;
1262 for (i = 0; i < codec->mixers.used; i++)
1263 snd_ctl_remove(codec->bus->card, kctls[i]);
1264 snd_array_free(&codec->mixers);
1267 void snd_hda_codec_reset(struct hda_codec *codec)
1271 #ifdef CONFIG_SND_HDA_POWER_SAVE
1272 cancel_delayed_work(&codec->power_work);
1273 flush_scheduled_work();
1275 snd_hda_ctls_clear(codec);
1277 for (i = 0; i < codec->num_pcms; i++) {
1278 if (codec->pcm_info[i].pcm) {
1279 snd_device_free(codec->bus->card,
1280 codec->pcm_info[i].pcm);
1281 clear_bit(codec->pcm_info[i].device,
1282 codec->bus->pcm_dev_bits);
1285 if (codec->patch_ops.free)
1286 codec->patch_ops.free(codec);
1287 codec->proc_widget_hook = NULL;
1289 free_hda_cache(&codec->amp_cache);
1290 free_hda_cache(&codec->cmd_cache);
1291 codec->num_pcms = 0;
1292 codec->pcm_info = NULL;
1293 codec->preset = NULL;
1294 module_put(codec->owner);
1295 codec->owner = NULL;
1297 #endif /* CONFIG_SND_HDA_RECONFIG */
1299 /* create a virtual master control and add slaves */
1300 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1301 unsigned int *tlv, const char **slaves)
1303 struct snd_kcontrol *kctl;
1307 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1310 snd_printdd("No slave found for %s\n", name);
1313 kctl = snd_ctl_make_virtual_master(name, tlv);
1316 err = snd_hda_ctl_add(codec, kctl);
1320 for (s = slaves; *s; s++) {
1321 struct snd_kcontrol *sctl;
1323 sctl = snd_hda_find_mixer_ctl(codec, *s);
1325 snd_printdd("Cannot find slave %s, skipped\n", *s);
1328 err = snd_ctl_add_slave(kctl, sctl);
1334 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1337 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1338 struct snd_ctl_elem_info *uinfo)
1340 int chs = get_amp_channels(kcontrol);
1342 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1343 uinfo->count = chs == 3 ? 2 : 1;
1344 uinfo->value.integer.min = 0;
1345 uinfo->value.integer.max = 1;
1348 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1350 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1351 struct snd_ctl_elem_value *ucontrol)
1353 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1354 hda_nid_t nid = get_amp_nid(kcontrol);
1355 int chs = get_amp_channels(kcontrol);
1356 int dir = get_amp_direction(kcontrol);
1357 int idx = get_amp_index(kcontrol);
1358 long *valp = ucontrol->value.integer.value;
1361 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1362 HDA_AMP_MUTE) ? 0 : 1;
1364 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1365 HDA_AMP_MUTE) ? 0 : 1;
1368 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1370 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1371 struct snd_ctl_elem_value *ucontrol)
1373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1374 hda_nid_t nid = get_amp_nid(kcontrol);
1375 int chs = get_amp_channels(kcontrol);
1376 int dir = get_amp_direction(kcontrol);
1377 int idx = get_amp_index(kcontrol);
1378 long *valp = ucontrol->value.integer.value;
1381 snd_hda_power_up(codec);
1383 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1385 *valp ? 0 : HDA_AMP_MUTE);
1389 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1391 *valp ? 0 : HDA_AMP_MUTE);
1392 #ifdef CONFIG_SND_HDA_POWER_SAVE
1393 if (codec->patch_ops.check_power_status)
1394 codec->patch_ops.check_power_status(codec, nid);
1396 snd_hda_power_down(codec);
1399 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1402 * bound volume controls
1404 * bind multiple volumes (# indices, from 0)
1407 #define AMP_VAL_IDX_SHIFT 19
1408 #define AMP_VAL_IDX_MASK (0x0f<<19)
1410 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1411 struct snd_ctl_elem_value *ucontrol)
1413 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1417 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1418 pval = kcontrol->private_value;
1419 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1420 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1421 kcontrol->private_value = pval;
1422 mutex_unlock(&codec->spdif_mutex);
1425 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1427 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1428 struct snd_ctl_elem_value *ucontrol)
1430 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1432 int i, indices, err = 0, change = 0;
1434 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1435 pval = kcontrol->private_value;
1436 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1437 for (i = 0; i < indices; i++) {
1438 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1439 (i << AMP_VAL_IDX_SHIFT);
1440 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1445 kcontrol->private_value = pval;
1446 mutex_unlock(&codec->spdif_mutex);
1447 return err < 0 ? err : change;
1449 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1452 * generic bound volume/swtich controls
1454 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1455 struct snd_ctl_elem_info *uinfo)
1457 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1458 struct hda_bind_ctls *c;
1461 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1462 c = (struct hda_bind_ctls *)kcontrol->private_value;
1463 kcontrol->private_value = *c->values;
1464 err = c->ops->info(kcontrol, uinfo);
1465 kcontrol->private_value = (long)c;
1466 mutex_unlock(&codec->spdif_mutex);
1469 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1471 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1472 struct snd_ctl_elem_value *ucontrol)
1474 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1475 struct hda_bind_ctls *c;
1478 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1479 c = (struct hda_bind_ctls *)kcontrol->private_value;
1480 kcontrol->private_value = *c->values;
1481 err = c->ops->get(kcontrol, ucontrol);
1482 kcontrol->private_value = (long)c;
1483 mutex_unlock(&codec->spdif_mutex);
1486 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1488 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1489 struct snd_ctl_elem_value *ucontrol)
1491 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1492 struct hda_bind_ctls *c;
1493 unsigned long *vals;
1494 int err = 0, change = 0;
1496 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1497 c = (struct hda_bind_ctls *)kcontrol->private_value;
1498 for (vals = c->values; *vals; vals++) {
1499 kcontrol->private_value = *vals;
1500 err = c->ops->put(kcontrol, ucontrol);
1505 kcontrol->private_value = (long)c;
1506 mutex_unlock(&codec->spdif_mutex);
1507 return err < 0 ? err : change;
1509 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1511 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1512 unsigned int size, unsigned int __user *tlv)
1514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1515 struct hda_bind_ctls *c;
1518 mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1519 c = (struct hda_bind_ctls *)kcontrol->private_value;
1520 kcontrol->private_value = *c->values;
1521 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1522 kcontrol->private_value = (long)c;
1523 mutex_unlock(&codec->spdif_mutex);
1526 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1528 struct hda_ctl_ops snd_hda_bind_vol = {
1529 .info = snd_hda_mixer_amp_volume_info,
1530 .get = snd_hda_mixer_amp_volume_get,
1531 .put = snd_hda_mixer_amp_volume_put,
1532 .tlv = snd_hda_mixer_amp_tlv
1534 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1536 struct hda_ctl_ops snd_hda_bind_sw = {
1537 .info = snd_hda_mixer_amp_switch_info,
1538 .get = snd_hda_mixer_amp_switch_get,
1539 .put = snd_hda_mixer_amp_switch_put,
1540 .tlv = snd_hda_mixer_amp_tlv
1542 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1545 * SPDIF out controls
1548 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1549 struct snd_ctl_elem_info *uinfo)
1551 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1556 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1557 struct snd_ctl_elem_value *ucontrol)
1559 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1560 IEC958_AES0_NONAUDIO |
1561 IEC958_AES0_CON_EMPHASIS_5015 |
1562 IEC958_AES0_CON_NOT_COPYRIGHT;
1563 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1564 IEC958_AES1_CON_ORIGINAL;
1568 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1569 struct snd_ctl_elem_value *ucontrol)
1571 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1572 IEC958_AES0_NONAUDIO |
1573 IEC958_AES0_PRO_EMPHASIS_5015;
1577 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1578 struct snd_ctl_elem_value *ucontrol)
1580 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1582 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1583 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1584 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1585 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1590 /* convert from SPDIF status bits to HDA SPDIF bits
1591 * bit 0 (DigEn) is always set zero (to be filled later)
1593 static unsigned short convert_from_spdif_status(unsigned int sbits)
1595 unsigned short val = 0;
1597 if (sbits & IEC958_AES0_PROFESSIONAL)
1598 val |= AC_DIG1_PROFESSIONAL;
1599 if (sbits & IEC958_AES0_NONAUDIO)
1600 val |= AC_DIG1_NONAUDIO;
1601 if (sbits & IEC958_AES0_PROFESSIONAL) {
1602 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1603 IEC958_AES0_PRO_EMPHASIS_5015)
1604 val |= AC_DIG1_EMPHASIS;
1606 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1607 IEC958_AES0_CON_EMPHASIS_5015)
1608 val |= AC_DIG1_EMPHASIS;
1609 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1610 val |= AC_DIG1_COPYRIGHT;
1611 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1612 val |= AC_DIG1_LEVEL;
1613 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1618 /* convert to SPDIF status bits from HDA SPDIF bits
1620 static unsigned int convert_to_spdif_status(unsigned short val)
1622 unsigned int sbits = 0;
1624 if (val & AC_DIG1_NONAUDIO)
1625 sbits |= IEC958_AES0_NONAUDIO;
1626 if (val & AC_DIG1_PROFESSIONAL)
1627 sbits |= IEC958_AES0_PROFESSIONAL;
1628 if (sbits & IEC958_AES0_PROFESSIONAL) {
1629 if (sbits & AC_DIG1_EMPHASIS)
1630 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1632 if (val & AC_DIG1_EMPHASIS)
1633 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1634 if (!(val & AC_DIG1_COPYRIGHT))
1635 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1636 if (val & AC_DIG1_LEVEL)
1637 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1638 sbits |= val & (0x7f << 8);
1643 /* set digital convert verbs both for the given NID and its slaves */
1644 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1649 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1650 d = codec->slave_dig_outs;
1654 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1657 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1661 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1663 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1666 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1667 struct snd_ctl_elem_value *ucontrol)
1669 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1670 hda_nid_t nid = kcontrol->private_value;
1674 mutex_lock(&codec->spdif_mutex);
1675 codec->spdif_status = ucontrol->value.iec958.status[0] |
1676 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1677 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1678 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1679 val = convert_from_spdif_status(codec->spdif_status);
1680 val |= codec->spdif_ctls & 1;
1681 change = codec->spdif_ctls != val;
1682 codec->spdif_ctls = val;
1685 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1687 mutex_unlock(&codec->spdif_mutex);
1691 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1693 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1694 struct snd_ctl_elem_value *ucontrol)
1696 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1698 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1702 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1703 struct snd_ctl_elem_value *ucontrol)
1705 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1706 hda_nid_t nid = kcontrol->private_value;
1710 mutex_lock(&codec->spdif_mutex);
1711 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1712 if (ucontrol->value.integer.value[0])
1713 val |= AC_DIG1_ENABLE;
1714 change = codec->spdif_ctls != val;
1716 codec->spdif_ctls = val;
1717 set_dig_out_convert(codec, nid, val & 0xff, -1);
1718 /* unmute amp switch (if any) */
1719 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1720 (val & AC_DIG1_ENABLE))
1721 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1724 mutex_unlock(&codec->spdif_mutex);
1728 static struct snd_kcontrol_new dig_mixes[] = {
1730 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1731 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1732 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1733 .info = snd_hda_spdif_mask_info,
1734 .get = snd_hda_spdif_cmask_get,
1737 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1738 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1739 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1740 .info = snd_hda_spdif_mask_info,
1741 .get = snd_hda_spdif_pmask_get,
1744 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1745 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1746 .info = snd_hda_spdif_mask_info,
1747 .get = snd_hda_spdif_default_get,
1748 .put = snd_hda_spdif_default_put,
1751 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1752 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1753 .info = snd_hda_spdif_out_switch_info,
1754 .get = snd_hda_spdif_out_switch_get,
1755 .put = snd_hda_spdif_out_switch_put,
1760 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1763 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1764 * @codec: the HDA codec
1765 * @nid: audio out widget NID
1767 * Creates controls related with the SPDIF output.
1768 * Called from each patch supporting the SPDIF out.
1770 * Returns 0 if successful, or a negative error code.
1772 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1775 struct snd_kcontrol *kctl;
1776 struct snd_kcontrol_new *dig_mix;
1779 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1780 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1784 if (idx >= SPDIF_MAX_IDX) {
1785 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1788 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1789 kctl = snd_ctl_new1(dig_mix, codec);
1792 kctl->id.index = idx;
1793 kctl->private_value = nid;
1794 err = snd_hda_ctl_add(codec, kctl);
1799 snd_hda_codec_read(codec, nid, 0,
1800 AC_VERB_GET_DIGI_CONVERT_1, 0);
1801 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1804 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1807 * SPDIF sharing with analog output
1809 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1810 struct snd_ctl_elem_value *ucontrol)
1812 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1813 ucontrol->value.integer.value[0] = mout->share_spdif;
1817 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1818 struct snd_ctl_elem_value *ucontrol)
1820 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1821 mout->share_spdif = !!ucontrol->value.integer.value[0];
1825 static struct snd_kcontrol_new spdif_share_sw = {
1826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1827 .name = "IEC958 Default PCM Playback Switch",
1828 .info = snd_ctl_boolean_mono_info,
1829 .get = spdif_share_sw_get,
1830 .put = spdif_share_sw_put,
1833 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1834 struct hda_multi_out *mout)
1836 if (!mout->dig_out_nid)
1838 /* ATTENTION: here mout is passed as private_data, instead of codec */
1839 return snd_hda_ctl_add(codec,
1840 snd_ctl_new1(&spdif_share_sw, mout));
1842 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1848 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1850 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1851 struct snd_ctl_elem_value *ucontrol)
1853 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1855 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1859 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1860 struct snd_ctl_elem_value *ucontrol)
1862 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1863 hda_nid_t nid = kcontrol->private_value;
1864 unsigned int val = !!ucontrol->value.integer.value[0];
1867 mutex_lock(&codec->spdif_mutex);
1868 change = codec->spdif_in_enable != val;
1870 codec->spdif_in_enable = val;
1871 snd_hda_codec_write_cache(codec, nid, 0,
1872 AC_VERB_SET_DIGI_CONVERT_1, val);
1874 mutex_unlock(&codec->spdif_mutex);
1878 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1879 struct snd_ctl_elem_value *ucontrol)
1881 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1882 hda_nid_t nid = kcontrol->private_value;
1886 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1887 sbits = convert_to_spdif_status(val);
1888 ucontrol->value.iec958.status[0] = sbits;
1889 ucontrol->value.iec958.status[1] = sbits >> 8;
1890 ucontrol->value.iec958.status[2] = sbits >> 16;
1891 ucontrol->value.iec958.status[3] = sbits >> 24;
1895 static struct snd_kcontrol_new dig_in_ctls[] = {
1897 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1898 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1899 .info = snd_hda_spdif_in_switch_info,
1900 .get = snd_hda_spdif_in_switch_get,
1901 .put = snd_hda_spdif_in_switch_put,
1904 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1905 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1906 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1907 .info = snd_hda_spdif_mask_info,
1908 .get = snd_hda_spdif_in_status_get,
1914 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1915 * @codec: the HDA codec
1916 * @nid: audio in widget NID
1918 * Creates controls related with the SPDIF input.
1919 * Called from each patch supporting the SPDIF in.
1921 * Returns 0 if successful, or a negative error code.
1923 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1926 struct snd_kcontrol *kctl;
1927 struct snd_kcontrol_new *dig_mix;
1930 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1931 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1935 if (idx >= SPDIF_MAX_IDX) {
1936 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1939 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1940 kctl = snd_ctl_new1(dig_mix, codec);
1941 kctl->private_value = nid;
1942 err = snd_hda_ctl_add(codec, kctl);
1946 codec->spdif_in_enable =
1947 snd_hda_codec_read(codec, nid, 0,
1948 AC_VERB_GET_DIGI_CONVERT_1, 0) &
1952 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1954 #ifdef SND_HDA_NEEDS_RESUME
1959 /* build a 32bit cache key with the widget id and the command parameter */
1960 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1961 #define get_cmd_cache_nid(key) ((key) & 0xff)
1962 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1965 * snd_hda_codec_write_cache - send a single command with caching
1966 * @codec: the HDA codec
1967 * @nid: NID to send the command
1968 * @direct: direct flag
1969 * @verb: the verb to send
1970 * @parm: the parameter for the verb
1972 * Send a single command without waiting for response.
1974 * Returns 0 if successful, or a negative error code.
1976 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
1977 int direct, unsigned int verb, unsigned int parm)
1979 struct hda_bus *bus = codec->bus;
1983 res = make_codec_cmd(codec, nid, direct, verb, parm);
1984 snd_hda_power_up(codec);
1985 mutex_lock(&bus->cmd_mutex);
1986 err = bus->ops.command(bus, res);
1988 struct hda_cache_head *c;
1989 u32 key = build_cmd_cache_key(nid, verb);
1990 c = get_alloc_hash(&codec->cmd_cache, key);
1994 mutex_unlock(&bus->cmd_mutex);
1995 snd_hda_power_down(codec);
1998 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2000 /* resume the all commands from the cache */
2001 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2003 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2006 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2007 u32 key = buffer->key;
2010 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2011 get_cmd_cache_cmd(key), buffer->val);
2014 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2017 * snd_hda_sequence_write_cache - sequence writes with caching
2018 * @codec: the HDA codec
2019 * @seq: VERB array to send
2021 * Send the commands sequentially from the given array.
2022 * Thte commands are recorded on cache for power-save and resume.
2023 * The array must be terminated with NID=0.
2025 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2026 const struct hda_verb *seq)
2028 for (; seq->nid; seq++)
2029 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2032 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2033 #endif /* SND_HDA_NEEDS_RESUME */
2036 * set power state of the codec
2038 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2039 unsigned int power_state)
2044 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2046 msleep(10); /* partial workaround for "azx_get_response timeout" */
2048 nid = codec->start_nid;
2049 for (i = 0; i < codec->num_nodes; i++, nid++) {
2050 unsigned int wcaps = get_wcaps(codec, nid);
2051 if (wcaps & AC_WCAP_POWER) {
2052 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2054 if (wid_type == AC_WID_PIN) {
2055 unsigned int pincap;
2057 * don't power down the widget if it controls
2058 * eapd and EAPD_BTLENABLE is set.
2060 pincap = snd_hda_param_read(codec, nid,
2062 if (pincap & AC_PINCAP_EAPD) {
2063 int eapd = snd_hda_codec_read(codec,
2065 AC_VERB_GET_EAPD_BTLENABLE, 0);
2067 if (power_state == AC_PWRST_D3 && eapd)
2071 snd_hda_codec_write(codec, nid, 0,
2072 AC_VERB_SET_POWER_STATE,
2077 if (power_state == AC_PWRST_D0) {
2078 unsigned long end_time;
2081 /* wait until the codec reachs to D0 */
2082 end_time = jiffies + msecs_to_jiffies(500);
2084 state = snd_hda_codec_read(codec, fg, 0,
2085 AC_VERB_GET_POWER_STATE, 0);
2086 if (state == power_state)
2089 } while (time_after_eq(end_time, jiffies));
2093 #ifdef CONFIG_SND_HDA_HWDEP
2094 /* execute additional init verbs */
2095 static void hda_exec_init_verbs(struct hda_codec *codec)
2097 if (codec->init_verbs.list)
2098 snd_hda_sequence_write(codec, codec->init_verbs.list);
2101 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2104 #ifdef SND_HDA_NEEDS_RESUME
2106 * call suspend and power-down; used both from PM and power-save
2108 static void hda_call_codec_suspend(struct hda_codec *codec)
2110 if (codec->patch_ops.suspend)
2111 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2112 hda_set_power_state(codec,
2113 codec->afg ? codec->afg : codec->mfg,
2115 #ifdef CONFIG_SND_HDA_POWER_SAVE
2116 cancel_delayed_work(&codec->power_work);
2117 codec->power_on = 0;
2118 codec->power_transition = 0;
2123 * kick up codec; used both from PM and power-save
2125 static void hda_call_codec_resume(struct hda_codec *codec)
2127 hda_set_power_state(codec,
2128 codec->afg ? codec->afg : codec->mfg,
2130 hda_exec_init_verbs(codec);
2131 if (codec->patch_ops.resume)
2132 codec->patch_ops.resume(codec);
2134 if (codec->patch_ops.init)
2135 codec->patch_ops.init(codec);
2136 snd_hda_codec_resume_amp(codec);
2137 snd_hda_codec_resume_cache(codec);
2140 #endif /* SND_HDA_NEEDS_RESUME */
2144 * snd_hda_build_controls - build mixer controls
2147 * Creates mixer controls for each codec included in the bus.
2149 * Returns 0 if successful, otherwise a negative error code.
2151 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2153 struct hda_codec *codec;
2155 list_for_each_entry(codec, &bus->codec_list, list) {
2156 int err = snd_hda_codec_build_controls(codec);
2162 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2164 int snd_hda_codec_build_controls(struct hda_codec *codec)
2167 /* fake as if already powered-on */
2168 hda_keep_power_on(codec);
2170 hda_set_power_state(codec,
2171 codec->afg ? codec->afg : codec->mfg,
2173 hda_exec_init_verbs(codec);
2174 /* continue to initialize... */
2175 if (codec->patch_ops.init)
2176 err = codec->patch_ops.init(codec);
2177 if (!err && codec->patch_ops.build_controls)
2178 err = codec->patch_ops.build_controls(codec);
2179 snd_hda_power_down(codec);
2188 struct hda_rate_tbl {
2190 unsigned int alsa_bits;
2191 unsigned int hda_fmt;
2194 static struct hda_rate_tbl rate_bits[] = {
2195 /* rate in Hz, ALSA rate bitmask, HDA format value */
2197 /* autodetected value used in snd_hda_query_supported_pcm */
2198 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2199 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2200 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2201 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2202 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2203 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2204 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2205 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2206 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2207 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2208 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2209 #define AC_PAR_PCM_RATE_BITS 11
2210 /* up to bits 10, 384kHZ isn't supported properly */
2212 /* not autodetected value */
2213 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2215 { 0 } /* terminator */
2219 * snd_hda_calc_stream_format - calculate format bitset
2220 * @rate: the sample rate
2221 * @channels: the number of channels
2222 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2223 * @maxbps: the max. bps
2225 * Calculate the format bitset from the given rate, channels and th PCM format.
2227 * Return zero if invalid.
2229 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2230 unsigned int channels,
2231 unsigned int format,
2232 unsigned int maxbps)
2235 unsigned int val = 0;
2237 for (i = 0; rate_bits[i].hz; i++)
2238 if (rate_bits[i].hz == rate) {
2239 val = rate_bits[i].hda_fmt;
2242 if (!rate_bits[i].hz) {
2243 snd_printdd("invalid rate %d\n", rate);
2247 if (channels == 0 || channels > 8) {
2248 snd_printdd("invalid channels %d\n", channels);
2251 val |= channels - 1;
2253 switch (snd_pcm_format_width(format)) {
2254 case 8: val |= 0x00; break;
2255 case 16: val |= 0x10; break;
2261 else if (maxbps >= 24)
2267 snd_printdd("invalid format width %d\n",
2268 snd_pcm_format_width(format));
2274 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2277 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2278 * @codec: the HDA codec
2279 * @nid: NID to query
2280 * @ratesp: the pointer to store the detected rate bitflags
2281 * @formatsp: the pointer to store the detected formats
2282 * @bpsp: the pointer to store the detected format widths
2284 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2285 * or @bsps argument is ignored.
2287 * Returns 0 if successful, otherwise a negative error code.
2289 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2290 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2293 unsigned int val, streams;
2296 if (nid != codec->afg &&
2297 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2298 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2303 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2307 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2309 rates |= rate_bits[i].alsa_bits;
2314 if (formatsp || bpsp) {
2319 wcaps = get_wcaps(codec, nid);
2320 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2324 streams = snd_hda_param_read(codec, codec->afg,
2331 if (streams & AC_SUPFMT_PCM) {
2332 if (val & AC_SUPPCM_BITS_8) {
2333 formats |= SNDRV_PCM_FMTBIT_U8;
2336 if (val & AC_SUPPCM_BITS_16) {
2337 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2340 if (wcaps & AC_WCAP_DIGITAL) {
2341 if (val & AC_SUPPCM_BITS_32)
2342 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2343 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2344 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2345 if (val & AC_SUPPCM_BITS_24)
2347 else if (val & AC_SUPPCM_BITS_20)
2349 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2350 AC_SUPPCM_BITS_32)) {
2351 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2352 if (val & AC_SUPPCM_BITS_32)
2354 else if (val & AC_SUPPCM_BITS_24)
2356 else if (val & AC_SUPPCM_BITS_20)
2360 else if (streams == AC_SUPFMT_FLOAT32) {
2361 /* should be exclusive */
2362 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2364 } else if (streams == AC_SUPFMT_AC3) {
2365 /* should be exclusive */
2366 /* temporary hack: we have still no proper support
2367 * for the direct AC3 stream...
2369 formats |= SNDRV_PCM_FMTBIT_U8;
2373 *formatsp = formats;
2382 * snd_hda_is_supported_format - check whether the given node supports
2385 * Returns 1 if supported, 0 if not.
2387 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2388 unsigned int format)
2391 unsigned int val = 0, rate, stream;
2393 if (nid != codec->afg &&
2394 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2395 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2400 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2405 rate = format & 0xff00;
2406 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2407 if (rate_bits[i].hda_fmt == rate) {
2412 if (i >= AC_PAR_PCM_RATE_BITS)
2415 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2418 if (!stream && nid != codec->afg)
2419 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2420 if (!stream || stream == -1)
2423 if (stream & AC_SUPFMT_PCM) {
2424 switch (format & 0xf0) {
2426 if (!(val & AC_SUPPCM_BITS_8))
2430 if (!(val & AC_SUPPCM_BITS_16))
2434 if (!(val & AC_SUPPCM_BITS_20))
2438 if (!(val & AC_SUPPCM_BITS_24))
2442 if (!(val & AC_SUPPCM_BITS_32))
2449 /* FIXME: check for float32 and AC3? */
2454 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2459 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2460 struct hda_codec *codec,
2461 struct snd_pcm_substream *substream)
2466 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2467 struct hda_codec *codec,
2468 unsigned int stream_tag,
2469 unsigned int format,
2470 struct snd_pcm_substream *substream)
2472 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2476 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2477 struct hda_codec *codec,
2478 struct snd_pcm_substream *substream)
2480 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2484 static int set_pcm_default_values(struct hda_codec *codec,
2485 struct hda_pcm_stream *info)
2487 /* query support PCM information from the given NID */
2488 if (info->nid && (!info->rates || !info->formats)) {
2489 snd_hda_query_supported_pcm(codec, info->nid,
2490 info->rates ? NULL : &info->rates,
2491 info->formats ? NULL : &info->formats,
2492 info->maxbps ? NULL : &info->maxbps);
2494 if (info->ops.open == NULL)
2495 info->ops.open = hda_pcm_default_open_close;
2496 if (info->ops.close == NULL)
2497 info->ops.close = hda_pcm_default_open_close;
2498 if (info->ops.prepare == NULL) {
2499 if (snd_BUG_ON(!info->nid))
2501 info->ops.prepare = hda_pcm_default_prepare;
2503 if (info->ops.cleanup == NULL) {
2504 if (snd_BUG_ON(!info->nid))
2506 info->ops.cleanup = hda_pcm_default_cleanup;
2512 * get the empty PCM device number to assign
2514 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2516 static const char *dev_name[HDA_PCM_NTYPES] = {
2517 "Audio", "SPDIF", "HDMI", "Modem"
2519 /* starting device index for each PCM type */
2520 static int dev_idx[HDA_PCM_NTYPES] = {
2521 [HDA_PCM_TYPE_AUDIO] = 0,
2522 [HDA_PCM_TYPE_SPDIF] = 1,
2523 [HDA_PCM_TYPE_HDMI] = 3,
2524 [HDA_PCM_TYPE_MODEM] = 6
2526 /* normal audio device indices; not linear to keep compatibility */
2527 static int audio_idx[4] = { 0, 2, 4, 5 };
2531 case HDA_PCM_TYPE_AUDIO:
2532 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2534 if (!test_bit(dev, bus->pcm_dev_bits))
2537 if (i >= ARRAY_SIZE(audio_idx)) {
2538 snd_printk(KERN_WARNING "Too many audio devices\n");
2542 case HDA_PCM_TYPE_SPDIF:
2543 case HDA_PCM_TYPE_HDMI:
2544 case HDA_PCM_TYPE_MODEM:
2545 dev = dev_idx[type];
2546 if (test_bit(dev, bus->pcm_dev_bits)) {
2547 snd_printk(KERN_WARNING "%s already defined\n",
2553 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2556 set_bit(dev, bus->pcm_dev_bits);
2561 * attach a new PCM stream
2563 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2565 struct hda_bus *bus = codec->bus;
2566 struct hda_pcm_stream *info;
2569 if (snd_BUG_ON(!pcm->name))
2571 for (stream = 0; stream < 2; stream++) {
2572 info = &pcm->stream[stream];
2573 if (info->substreams) {
2574 err = set_pcm_default_values(codec, info);
2579 return bus->ops.attach_pcm(bus, codec, pcm);
2582 /* assign all PCMs of the given codec */
2583 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2588 if (!codec->num_pcms) {
2589 if (!codec->patch_ops.build_pcms)
2591 err = codec->patch_ops.build_pcms(codec);
2595 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2596 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2599 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2600 return 0; /* no substreams assigned */
2603 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2607 err = snd_hda_attach_pcm(codec, cpcm);
2616 * snd_hda_build_pcms - build PCM information
2619 * Create PCM information for each codec included in the bus.
2621 * The build_pcms codec patch is requested to set up codec->num_pcms and
2622 * codec->pcm_info properly. The array is referred by the top-level driver
2623 * to create its PCM instances.
2624 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2627 * At least, substreams, channels_min and channels_max must be filled for
2628 * each stream. substreams = 0 indicates that the stream doesn't exist.
2629 * When rates and/or formats are zero, the supported values are queried
2630 * from the given nid. The nid is used also by the default ops.prepare
2631 * and ops.cleanup callbacks.
2633 * The driver needs to call ops.open in its open callback. Similarly,
2634 * ops.close is supposed to be called in the close callback.
2635 * ops.prepare should be called in the prepare or hw_params callback
2636 * with the proper parameters for set up.
2637 * ops.cleanup should be called in hw_free for clean up of streams.
2639 * This function returns 0 if successfull, or a negative error code.
2641 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2643 struct hda_codec *codec;
2645 list_for_each_entry(codec, &bus->codec_list, list) {
2646 int err = snd_hda_codec_build_pcms(codec);
2652 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2655 * snd_hda_check_board_config - compare the current codec with the config table
2656 * @codec: the HDA codec
2657 * @num_configs: number of config enums
2658 * @models: array of model name strings
2659 * @tbl: configuration table, terminated by null entries
2661 * Compares the modelname or PCI subsystem id of the current codec with the
2662 * given configuration table. If a matching entry is found, returns its
2663 * config value (supposed to be 0 or positive).
2665 * If no entries are matching, the function returns a negative value.
2667 int snd_hda_check_board_config(struct hda_codec *codec,
2668 int num_configs, const char **models,
2669 const struct snd_pci_quirk *tbl)
2671 if (codec->modelname && models) {
2673 for (i = 0; i < num_configs; i++) {
2675 !strcmp(codec->modelname, models[i])) {
2676 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2677 "selected\n", models[i]);
2683 if (!codec->bus->pci || !tbl)
2686 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2689 if (tbl->value >= 0 && tbl->value < num_configs) {
2690 #ifdef CONFIG_SND_DEBUG_VERBOSE
2692 const char *model = NULL;
2694 model = models[tbl->value];
2696 sprintf(tmp, "#%d", tbl->value);
2699 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2700 "for config %x:%x (%s)\n",
2701 model, tbl->subvendor, tbl->subdevice,
2702 (tbl->name ? tbl->name : "Unknown device"));
2708 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2711 * snd_hda_add_new_ctls - create controls from the array
2712 * @codec: the HDA codec
2713 * @knew: the array of struct snd_kcontrol_new
2715 * This helper function creates and add new controls in the given array.
2716 * The array must be terminated with an empty entry as terminator.
2718 * Returns 0 if successful, or a negative error code.
2720 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2724 for (; knew->name; knew++) {
2725 struct snd_kcontrol *kctl;
2726 kctl = snd_ctl_new1(knew, codec);
2729 err = snd_hda_ctl_add(codec, kctl);
2733 kctl = snd_ctl_new1(knew, codec);
2736 kctl->id.device = codec->addr;
2737 err = snd_hda_ctl_add(codec, kctl);
2744 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2746 #ifdef CONFIG_SND_HDA_POWER_SAVE
2747 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2748 unsigned int power_state);
2750 static void hda_power_work(struct work_struct *work)
2752 struct hda_codec *codec =
2753 container_of(work, struct hda_codec, power_work.work);
2754 struct hda_bus *bus = codec->bus;
2756 if (!codec->power_on || codec->power_count) {
2757 codec->power_transition = 0;
2761 hda_call_codec_suspend(codec);
2762 if (bus->ops.pm_notify)
2763 bus->ops.pm_notify(bus);
2766 static void hda_keep_power_on(struct hda_codec *codec)
2768 codec->power_count++;
2769 codec->power_on = 1;
2772 void snd_hda_power_up(struct hda_codec *codec)
2774 struct hda_bus *bus = codec->bus;
2776 codec->power_count++;
2777 if (codec->power_on || codec->power_transition)
2780 codec->power_on = 1;
2781 if (bus->ops.pm_notify)
2782 bus->ops.pm_notify(bus);
2783 hda_call_codec_resume(codec);
2784 cancel_delayed_work(&codec->power_work);
2785 codec->power_transition = 0;
2787 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2789 #define power_save(codec) \
2790 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2792 #define power_save(codec) \
2793 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2795 void snd_hda_power_down(struct hda_codec *codec)
2797 --codec->power_count;
2798 if (!codec->power_on || codec->power_count || codec->power_transition)
2800 if (power_save(codec)) {
2801 codec->power_transition = 1; /* avoid reentrance */
2802 schedule_delayed_work(&codec->power_work,
2803 msecs_to_jiffies(power_save(codec) * 1000));
2806 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2808 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2809 struct hda_loopback_check *check,
2812 struct hda_amp_list *p;
2815 if (!check->amplist)
2817 for (p = check->amplist; p->nid; p++) {
2822 return 0; /* nothing changed */
2824 for (p = check->amplist; p->nid; p++) {
2825 for (ch = 0; ch < 2; ch++) {
2826 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2828 if (!(v & HDA_AMP_MUTE) && v > 0) {
2829 if (!check->power_on) {
2830 check->power_on = 1;
2831 snd_hda_power_up(codec);
2837 if (check->power_on) {
2838 check->power_on = 0;
2839 snd_hda_power_down(codec);
2843 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2847 * Channel mode helper
2849 int snd_hda_ch_mode_info(struct hda_codec *codec,
2850 struct snd_ctl_elem_info *uinfo,
2851 const struct hda_channel_mode *chmode,
2854 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2856 uinfo->value.enumerated.items = num_chmodes;
2857 if (uinfo->value.enumerated.item >= num_chmodes)
2858 uinfo->value.enumerated.item = num_chmodes - 1;
2859 sprintf(uinfo->value.enumerated.name, "%dch",
2860 chmode[uinfo->value.enumerated.item].channels);
2863 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2865 int snd_hda_ch_mode_get(struct hda_codec *codec,
2866 struct snd_ctl_elem_value *ucontrol,
2867 const struct hda_channel_mode *chmode,
2873 for (i = 0; i < num_chmodes; i++) {
2874 if (max_channels == chmode[i].channels) {
2875 ucontrol->value.enumerated.item[0] = i;
2881 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2883 int snd_hda_ch_mode_put(struct hda_codec *codec,
2884 struct snd_ctl_elem_value *ucontrol,
2885 const struct hda_channel_mode *chmode,
2891 mode = ucontrol->value.enumerated.item[0];
2892 if (mode >= num_chmodes)
2894 if (*max_channelsp == chmode[mode].channels)
2896 /* change the current channel setting */
2897 *max_channelsp = chmode[mode].channels;
2898 if (chmode[mode].sequence)
2899 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
2902 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
2907 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
2908 struct snd_ctl_elem_info *uinfo)
2912 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2914 uinfo->value.enumerated.items = imux->num_items;
2915 if (!imux->num_items)
2917 index = uinfo->value.enumerated.item;
2918 if (index >= imux->num_items)
2919 index = imux->num_items - 1;
2920 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
2923 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
2925 int snd_hda_input_mux_put(struct hda_codec *codec,
2926 const struct hda_input_mux *imux,
2927 struct snd_ctl_elem_value *ucontrol,
2929 unsigned int *cur_val)
2933 if (!imux->num_items)
2935 idx = ucontrol->value.enumerated.item[0];
2936 if (idx >= imux->num_items)
2937 idx = imux->num_items - 1;
2938 if (*cur_val == idx)
2940 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
2941 imux->items[idx].index);
2945 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
2949 * Multi-channel / digital-out PCM helper functions
2952 /* setup SPDIF output stream */
2953 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
2954 unsigned int stream_tag, unsigned int format)
2956 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2957 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2958 set_dig_out_convert(codec, nid,
2959 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
2961 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2962 if (codec->slave_dig_outs) {
2964 for (d = codec->slave_dig_outs; *d; d++)
2965 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
2968 /* turn on again (if needed) */
2969 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
2970 set_dig_out_convert(codec, nid,
2971 codec->spdif_ctls & 0xff, -1);
2974 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
2976 snd_hda_codec_cleanup_stream(codec, nid);
2977 if (codec->slave_dig_outs) {
2979 for (d = codec->slave_dig_outs; *d; d++)
2980 snd_hda_codec_cleanup_stream(codec, *d);
2985 * open the digital out in the exclusive mode
2987 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
2988 struct hda_multi_out *mout)
2990 mutex_lock(&codec->spdif_mutex);
2991 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
2992 /* already opened as analog dup; reset it once */
2993 cleanup_dig_out_stream(codec, mout->dig_out_nid);
2994 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
2995 mutex_unlock(&codec->spdif_mutex);
2998 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3000 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3001 struct hda_multi_out *mout,
3002 unsigned int stream_tag,
3003 unsigned int format,
3004 struct snd_pcm_substream *substream)
3006 mutex_lock(&codec->spdif_mutex);
3007 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3008 mutex_unlock(&codec->spdif_mutex);
3011 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3014 * release the digital out
3016 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3017 struct hda_multi_out *mout)
3019 mutex_lock(&codec->spdif_mutex);
3020 mout->dig_out_used = 0;
3021 mutex_unlock(&codec->spdif_mutex);
3024 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3027 * set up more restrictions for analog out
3029 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3030 struct hda_multi_out *mout,
3031 struct snd_pcm_substream *substream,
3032 struct hda_pcm_stream *hinfo)
3034 struct snd_pcm_runtime *runtime = substream->runtime;
3035 runtime->hw.channels_max = mout->max_channels;
3036 if (mout->dig_out_nid) {
3037 if (!mout->analog_rates) {
3038 mout->analog_rates = hinfo->rates;
3039 mout->analog_formats = hinfo->formats;
3040 mout->analog_maxbps = hinfo->maxbps;
3042 runtime->hw.rates = mout->analog_rates;
3043 runtime->hw.formats = mout->analog_formats;
3044 hinfo->maxbps = mout->analog_maxbps;
3046 if (!mout->spdif_rates) {
3047 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3049 &mout->spdif_formats,
3050 &mout->spdif_maxbps);
3052 mutex_lock(&codec->spdif_mutex);
3053 if (mout->share_spdif) {
3054 runtime->hw.rates &= mout->spdif_rates;
3055 runtime->hw.formats &= mout->spdif_formats;
3056 if (mout->spdif_maxbps < hinfo->maxbps)
3057 hinfo->maxbps = mout->spdif_maxbps;
3059 mutex_unlock(&codec->spdif_mutex);
3061 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3062 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3064 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3067 * set up the i/o for analog out
3068 * when the digital out is available, copy the front out to digital out, too.
3070 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3071 struct hda_multi_out *mout,
3072 unsigned int stream_tag,
3073 unsigned int format,
3074 struct snd_pcm_substream *substream)
3076 hda_nid_t *nids = mout->dac_nids;
3077 int chs = substream->runtime->channels;
3080 mutex_lock(&codec->spdif_mutex);
3081 if (mout->dig_out_nid && mout->share_spdif &&
3082 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3084 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3086 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3087 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3088 setup_dig_out_stream(codec, mout->dig_out_nid,
3089 stream_tag, format);
3091 mout->dig_out_used = 0;
3092 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3095 mutex_unlock(&codec->spdif_mutex);
3098 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3100 if (!mout->no_share_stream &&
3101 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3102 /* headphone out will just decode front left/right (stereo) */
3103 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3105 /* extra outputs copied from front */
3106 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3107 if (!mout->no_share_stream && mout->extra_out_nid[i])
3108 snd_hda_codec_setup_stream(codec,
3109 mout->extra_out_nid[i],
3110 stream_tag, 0, format);
3113 for (i = 1; i < mout->num_dacs; i++) {
3114 if (chs >= (i + 1) * 2) /* independent out */
3115 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3117 else if (!mout->no_share_stream) /* copy front */
3118 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3123 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3126 * clean up the setting for analog out
3128 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3129 struct hda_multi_out *mout)
3131 hda_nid_t *nids = mout->dac_nids;
3134 for (i = 0; i < mout->num_dacs; i++)
3135 snd_hda_codec_cleanup_stream(codec, nids[i]);
3137 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3138 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3139 if (mout->extra_out_nid[i])
3140 snd_hda_codec_cleanup_stream(codec,
3141 mout->extra_out_nid[i]);
3142 mutex_lock(&codec->spdif_mutex);
3143 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3144 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3145 mout->dig_out_used = 0;
3147 mutex_unlock(&codec->spdif_mutex);
3150 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3153 * Helper for automatic pin configuration
3156 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3158 for (; *list; list++)
3166 * Sort an associated group of pins according to their sequence numbers.
3168 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3175 for (i = 0; i < num_pins; i++) {
3176 for (j = i + 1; j < num_pins; j++) {
3177 if (sequences[i] > sequences[j]) {
3179 sequences[i] = sequences[j];
3191 * Parse all pin widgets and store the useful pin nids to cfg
3193 * The number of line-outs or any primary output is stored in line_outs,
3194 * and the corresponding output pins are assigned to line_out_pins[],
3195 * in the order of front, rear, CLFE, side, ...
3197 * If more extra outputs (speaker and headphone) are found, the pins are
3198 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3199 * is detected, one of speaker of HP pins is assigned as the primary
3200 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3201 * if any analog output exists.
3203 * The analog input pins are assigned to input_pins array.
3204 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3207 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3208 struct auto_pin_cfg *cfg,
3209 hda_nid_t *ignore_nids)
3211 hda_nid_t nid, end_nid;
3212 short seq, assoc_line_out, assoc_speaker;
3213 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3214 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3215 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3217 memset(cfg, 0, sizeof(*cfg));
3219 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3220 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3221 memset(sequences_hp, 0, sizeof(sequences_hp));
3222 assoc_line_out = assoc_speaker = 0;
3224 end_nid = codec->start_nid + codec->num_nodes;
3225 for (nid = codec->start_nid; nid < end_nid; nid++) {
3226 unsigned int wid_caps = get_wcaps(codec, nid);
3227 unsigned int wid_type =
3228 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3229 unsigned int def_conf;
3232 /* read all default configuration for pin complex */
3233 if (wid_type != AC_WID_PIN)
3235 /* ignore the given nids (e.g. pc-beep returns error) */
3236 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3239 def_conf = snd_hda_codec_read(codec, nid, 0,
3240 AC_VERB_GET_CONFIG_DEFAULT, 0);
3241 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3243 loc = get_defcfg_location(def_conf);
3244 switch (get_defcfg_device(def_conf)) {
3245 case AC_JACK_LINE_OUT:
3246 seq = get_defcfg_sequence(def_conf);
3247 assoc = get_defcfg_association(def_conf);
3249 if (!(wid_caps & AC_WCAP_STEREO))
3250 if (!cfg->mono_out_pin)
3251 cfg->mono_out_pin = nid;
3254 if (!assoc_line_out)
3255 assoc_line_out = assoc;
3256 else if (assoc_line_out != assoc)
3258 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3260 cfg->line_out_pins[cfg->line_outs] = nid;
3261 sequences_line_out[cfg->line_outs] = seq;
3264 case AC_JACK_SPEAKER:
3265 seq = get_defcfg_sequence(def_conf);
3266 assoc = get_defcfg_association(def_conf);
3269 if (! assoc_speaker)
3270 assoc_speaker = assoc;
3271 else if (assoc_speaker != assoc)
3273 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3275 cfg->speaker_pins[cfg->speaker_outs] = nid;
3276 sequences_speaker[cfg->speaker_outs] = seq;
3277 cfg->speaker_outs++;
3279 case AC_JACK_HP_OUT:
3280 seq = get_defcfg_sequence(def_conf);
3281 assoc = get_defcfg_association(def_conf);
3282 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3284 cfg->hp_pins[cfg->hp_outs] = nid;
3285 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3288 case AC_JACK_MIC_IN: {
3290 if (loc == AC_JACK_LOC_FRONT) {
3291 preferred = AUTO_PIN_FRONT_MIC;
3294 preferred = AUTO_PIN_MIC;
3295 alt = AUTO_PIN_FRONT_MIC;
3297 if (!cfg->input_pins[preferred])
3298 cfg->input_pins[preferred] = nid;
3299 else if (!cfg->input_pins[alt])
3300 cfg->input_pins[alt] = nid;
3303 case AC_JACK_LINE_IN:
3304 if (loc == AC_JACK_LOC_FRONT)
3305 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3307 cfg->input_pins[AUTO_PIN_LINE] = nid;
3310 cfg->input_pins[AUTO_PIN_CD] = nid;
3313 cfg->input_pins[AUTO_PIN_AUX] = nid;
3315 case AC_JACK_SPDIF_OUT:
3316 cfg->dig_out_pin = nid;
3318 case AC_JACK_SPDIF_IN:
3319 cfg->dig_in_pin = nid;
3325 * If no line-out is defined but multiple HPs are found,
3326 * some of them might be the real line-outs.
3328 if (!cfg->line_outs && cfg->hp_outs > 1) {
3330 while (i < cfg->hp_outs) {
3331 /* The real HPs should have the sequence 0x0f */
3332 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3336 /* Move it to the line-out table */
3337 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3338 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3341 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3342 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3343 memmove(sequences_hp + i - 1, sequences_hp + i,
3344 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3348 /* sort by sequence */
3349 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3351 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3353 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3356 /* if we have only one mic, make it AUTO_PIN_MIC */
3357 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3358 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3359 cfg->input_pins[AUTO_PIN_MIC] =
3360 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3361 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3363 /* ditto for line-in */
3364 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3365 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3366 cfg->input_pins[AUTO_PIN_LINE] =
3367 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3368 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3372 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3373 * as a primary output
3375 if (!cfg->line_outs) {
3376 if (cfg->speaker_outs) {
3377 cfg->line_outs = cfg->speaker_outs;
3378 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3379 sizeof(cfg->speaker_pins));
3380 cfg->speaker_outs = 0;
3381 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3382 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3383 } else if (cfg->hp_outs) {
3384 cfg->line_outs = cfg->hp_outs;
3385 memcpy(cfg->line_out_pins, cfg->hp_pins,
3386 sizeof(cfg->hp_pins));
3388 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3389 cfg->line_out_type = AUTO_PIN_HP_OUT;
3393 /* Reorder the surround channels
3394 * ALSA sequence is front/surr/clfe/side
3396 * 4-ch: front/surr => OK as it is
3397 * 6-ch: front/clfe/surr
3398 * 8-ch: front/clfe/rear/side|fc
3400 switch (cfg->line_outs) {
3403 nid = cfg->line_out_pins[1];
3404 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3405 cfg->line_out_pins[2] = nid;
3410 * debug prints of the parsed results
3412 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3413 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3414 cfg->line_out_pins[2], cfg->line_out_pins[3],
3415 cfg->line_out_pins[4]);
3416 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3417 cfg->speaker_outs, cfg->speaker_pins[0],
3418 cfg->speaker_pins[1], cfg->speaker_pins[2],
3419 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3420 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3421 cfg->hp_outs, cfg->hp_pins[0],
3422 cfg->hp_pins[1], cfg->hp_pins[2],
3423 cfg->hp_pins[3], cfg->hp_pins[4]);
3424 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3425 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3426 " cd=0x%x, aux=0x%x\n",
3427 cfg->input_pins[AUTO_PIN_MIC],
3428 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3429 cfg->input_pins[AUTO_PIN_LINE],
3430 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3431 cfg->input_pins[AUTO_PIN_CD],
3432 cfg->input_pins[AUTO_PIN_AUX]);
3436 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3438 /* labels for input pins */
3439 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3440 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3442 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3451 * snd_hda_suspend - suspend the codecs
3453 * @state: suspsend state
3455 * Returns 0 if successful.
3457 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3459 struct hda_codec *codec;
3461 list_for_each_entry(codec, &bus->codec_list, list) {
3462 #ifdef CONFIG_SND_HDA_POWER_SAVE
3463 if (!codec->power_on)
3466 hda_call_codec_suspend(codec);
3470 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3473 * snd_hda_resume - resume the codecs
3476 * Returns 0 if successful.
3478 * This fucntion is defined only when POWER_SAVE isn't set.
3479 * In the power-save mode, the codec is resumed dynamically.
3481 int snd_hda_resume(struct hda_bus *bus)
3483 struct hda_codec *codec;
3485 list_for_each_entry(codec, &bus->codec_list, list) {
3486 if (snd_hda_codec_needs_resume(codec))
3487 hda_call_codec_resume(codec);
3491 EXPORT_SYMBOL_HDA(snd_hda_resume);
3492 #endif /* CONFIG_PM */
3498 /* get a new element from the given array
3499 * if it exceeds the pre-allocated array size, re-allocate the array
3501 void *snd_array_new(struct snd_array *array)
3503 if (array->used >= array->alloced) {
3504 int num = array->alloced + array->alloc_align;
3506 if (snd_BUG_ON(num >= 4096))
3508 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3512 memcpy(nlist, array->list,
3513 array->elem_size * array->alloced);
3516 array->list = nlist;
3517 array->alloced = num;
3519 return snd_array_elem(array, array->used++);
3521 EXPORT_SYMBOL_HDA(snd_array_new);
3523 /* free the given array elements */
3524 void snd_array_free(struct snd_array *array)
3531 EXPORT_SYMBOL_HDA(snd_array_free);
3534 * used by hda_proc.c and hda_eld.c
3536 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3538 static unsigned int rates[] = {
3539 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3540 96000, 176400, 192000, 384000
3544 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3546 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3548 buf[j] = '\0'; /* necessary when j == 0 */
3550 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3552 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3554 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3557 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3558 if (pcm & (AC_SUPPCM_BITS_8 << i))
3559 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3561 buf[j] = '\0'; /* necessary when j == 0 */
3563 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3565 MODULE_DESCRIPTION("HDA codec core");
3566 MODULE_LICENSE("GPL");