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)
490 static struct snd_device_ops dev_ops = {
491 .dev_register = snd_hda_bus_dev_register,
492 .dev_free = snd_hda_bus_dev_free,
495 if (snd_BUG_ON(!temp))
497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
503 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
510 bus->private_data = temp->private_data;
511 bus->pci = temp->pci;
512 bus->modelname = temp->modelname;
513 bus->power_save = temp->power_save;
514 bus->ops = temp->ops;
516 mutex_init(&bus->cmd_mutex);
517 INIT_LIST_HEAD(&bus->codec_list);
519 snprintf(bus->workq_name, sizeof(bus->workq_name),
520 "hd-audio%d", card->number);
521 bus->workq = create_singlethread_workqueue(bus->workq_name);
523 snd_printk(KERN_ERR "cannot create workqueue %s\n",
529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
531 snd_hda_bus_free(bus);
538 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
540 #ifdef CONFIG_SND_HDA_GENERIC
541 #define is_generic_config(codec) \
542 (codec->modelname && !strcmp(codec->modelname, "generic"))
544 #define is_generic_config(codec) 0
548 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
550 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
554 * find a matching codec preset
556 static const struct hda_codec_preset *
557 find_codec_preset(struct hda_codec *codec)
559 struct hda_codec_preset_list *tbl;
560 const struct hda_codec_preset *preset;
561 int mod_requested = 0;
563 if (is_generic_config(codec))
564 return NULL; /* use the generic parser */
567 mutex_lock(&preset_mutex);
568 list_for_each_entry(tbl, &hda_preset_tables, list) {
569 if (!try_module_get(tbl->owner)) {
570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
573 for (preset = tbl->preset; preset->id; preset++) {
574 u32 mask = preset->mask;
575 if (preset->afg && preset->afg != codec->afg)
577 if (preset->mfg && preset->mfg != codec->mfg)
581 if (preset->id == (codec->vendor_id & mask) &&
583 preset->rev == codec->revision_id)) {
584 mutex_unlock(&preset_mutex);
585 codec->owner = tbl->owner;
589 module_put(tbl->owner);
591 mutex_unlock(&preset_mutex);
593 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
600 (codec->vendor_id >> 16) & 0xffff);
601 request_module(name);
609 * get_codec_name - store the codec name
611 static int get_codec_name(struct hda_codec *codec)
613 const struct hda_vendor_id *c;
614 const char *vendor = NULL;
615 u16 vendor_id = codec->vendor_id >> 16;
616 char tmp[16], name[32];
618 for (c = hda_vendor_ids; c->id; c++) {
619 if (c->id == vendor_id) {
625 sprintf(tmp, "Generic %04x", vendor_id);
628 if (codec->preset && codec->preset->name)
629 snprintf(name, sizeof(name), "%s %s", vendor,
630 codec->preset->name);
632 snprintf(name, sizeof(name), "%s ID %x", vendor,
633 codec->vendor_id & 0xffff);
634 codec->name = kstrdup(name, GFP_KERNEL);
641 * look for an AFG and MFG nodes
643 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
649 for (i = 0; i < total_nodes; i++, nid++) {
651 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
652 switch (func & 0xff) {
653 case AC_GRP_AUDIO_FUNCTION:
656 case AC_GRP_MODEM_FUNCTION:
666 * read widget caps for each widget and store in cache
668 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
678 nid = codec->start_nid;
679 for (i = 0; i < codec->num_nodes; i++, nid++)
680 codec->wcaps[i] = snd_hda_param_read(codec, nid,
681 AC_PAR_AUDIO_WIDGET_CAP);
686 static void init_hda_cache(struct hda_cache_rec *cache,
687 unsigned int record_size);
688 static void free_hda_cache(struct hda_cache_rec *cache);
693 static void snd_hda_codec_free(struct hda_codec *codec)
697 #ifdef CONFIG_SND_HDA_POWER_SAVE
698 cancel_delayed_work(&codec->power_work);
699 flush_workqueue(codec->bus->workq);
701 list_del(&codec->list);
702 snd_array_free(&codec->mixers);
703 codec->bus->caddr_tbl[codec->addr] = NULL;
704 if (codec->patch_ops.free)
705 codec->patch_ops.free(codec);
706 module_put(codec->owner);
707 free_hda_cache(&codec->amp_cache);
708 free_hda_cache(&codec->cmd_cache);
710 kfree(codec->modelname);
716 * snd_hda_codec_new - create a HDA codec
717 * @bus: the bus to assign
718 * @codec_addr: the codec address
719 * @codecp: the pointer to store the generated codec
721 * Returns 0 if successful, or a negative error code.
723 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
724 int do_init, struct hda_codec **codecp)
726 struct hda_codec *codec;
730 if (snd_BUG_ON(!bus))
732 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
735 if (bus->caddr_tbl[codec_addr]) {
736 snd_printk(KERN_ERR "hda_codec: "
737 "address 0x%x is already occupied\n", codec_addr);
741 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
743 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
748 codec->addr = codec_addr;
749 mutex_init(&codec->spdif_mutex);
750 mutex_init(&codec->control_mutex);
751 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
752 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
753 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
754 if (codec->bus->modelname) {
755 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
756 if (!codec->modelname) {
757 snd_hda_codec_free(codec);
762 #ifdef CONFIG_SND_HDA_POWER_SAVE
763 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
764 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
765 * the caller has to power down appropriatley after initialization
768 hda_keep_power_on(codec);
771 list_add_tail(&codec->list, &bus->codec_list);
772 bus->caddr_tbl[codec_addr] = codec;
774 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
776 if (codec->vendor_id == -1)
777 /* read again, hopefully the access method was corrected
778 * in the last read...
780 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
782 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
783 AC_PAR_SUBSYSTEM_ID);
784 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
787 setup_fg_nodes(codec);
788 if (!codec->afg && !codec->mfg) {
789 snd_printdd("hda_codec: no AFG or MFG node found\n");
790 snd_hda_codec_free(codec);
794 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
795 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
796 snd_hda_codec_free(codec);
800 if (!codec->subsystem_id) {
801 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
802 codec->subsystem_id =
803 snd_hda_codec_read(codec, nid, 0,
804 AC_VERB_GET_SUBSYSTEM_ID, 0);
807 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
810 err = snd_hda_codec_configure(codec);
812 snd_hda_codec_free(codec);
816 snd_hda_codec_proc_new(codec);
818 snd_hda_create_hwdep(codec);
820 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
821 codec->subsystem_id, codec->revision_id);
822 snd_component_add(codec->bus->card, component);
828 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
830 int snd_hda_codec_configure(struct hda_codec *codec)
834 codec->preset = find_codec_preset(codec);
836 err = get_codec_name(codec);
840 /* audio codec should override the mixer name */
841 if (codec->afg || !*codec->bus->card->mixername)
842 strlcpy(codec->bus->card->mixername, codec->name,
843 sizeof(codec->bus->card->mixername));
845 if (is_generic_config(codec)) {
846 err = snd_hda_parse_generic_codec(codec);
849 if (codec->preset && codec->preset->patch) {
850 err = codec->preset->patch(codec);
854 /* call the default parser */
855 err = snd_hda_parse_generic_codec(codec);
857 printk(KERN_ERR "hda-codec: No codec parser is available\n");
860 if (!err && codec->patch_ops.unsol_event)
861 err = init_unsol_queue(codec->bus);
866 * snd_hda_codec_setup_stream - set up the codec for streaming
867 * @codec: the CODEC to set up
868 * @nid: the NID to set up
869 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
870 * @channel_id: channel id to pass, zero based.
871 * @format: stream format.
873 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
875 int channel_id, int format)
880 snd_printdd("hda_codec_setup_stream: "
881 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
882 nid, stream_tag, channel_id, format);
883 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
884 (stream_tag << 4) | channel_id);
886 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
888 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
890 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
895 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
896 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
897 #if 0 /* keep the format */
899 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
902 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
905 * amp access functions
908 /* FIXME: more better hash key? */
909 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
910 #define INFO_AMP_CAPS (1<<0)
911 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
913 /* initialize the hash table */
914 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
915 unsigned int record_size)
917 memset(cache, 0, sizeof(*cache));
918 memset(cache->hash, 0xff, sizeof(cache->hash));
919 snd_array_init(&cache->buf, record_size, 64);
922 static void free_hda_cache(struct hda_cache_rec *cache)
924 snd_array_free(&cache->buf);
927 /* query the hash. allocate an entry if not found. */
928 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
931 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
932 u16 cur = cache->hash[idx];
933 struct hda_cache_head *info;
935 while (cur != 0xffff) {
936 info = snd_array_elem(&cache->buf, cur);
937 if (info->key == key)
942 /* add a new hash entry */
943 info = snd_array_new(&cache->buf);
946 cur = snd_array_index(&cache->buf, info);
949 info->next = cache->hash[idx];
950 cache->hash[idx] = cur;
955 /* query and allocate an amp hash entry */
956 static inline struct hda_amp_info *
957 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
959 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
963 * query AMP capabilities for the given widget and direction
965 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
967 struct hda_amp_info *info;
969 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
972 if (!(info->head.val & INFO_AMP_CAPS)) {
973 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
975 info->amp_caps = snd_hda_param_read(codec, nid,
976 direction == HDA_OUTPUT ?
980 info->head.val |= INFO_AMP_CAPS;
982 return info->amp_caps;
984 EXPORT_SYMBOL_HDA(query_amp_caps);
986 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
989 struct hda_amp_info *info;
991 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
994 info->amp_caps = caps;
995 info->head.val |= INFO_AMP_CAPS;
998 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1001 * read the current volume to info
1002 * if the cache exists, read the cache value.
1004 static unsigned int get_vol_mute(struct hda_codec *codec,
1005 struct hda_amp_info *info, hda_nid_t nid,
1006 int ch, int direction, int index)
1010 if (info->head.val & INFO_AMP_VOL(ch))
1011 return info->vol[ch];
1013 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1014 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1016 val = snd_hda_codec_read(codec, nid, 0,
1017 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1018 info->vol[ch] = val & 0xff;
1019 info->head.val |= INFO_AMP_VOL(ch);
1020 return info->vol[ch];
1024 * write the current volume in info to the h/w and update the cache
1026 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1027 hda_nid_t nid, int ch, int direction, int index,
1032 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1033 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1034 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1036 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1037 info->vol[ch] = val;
1041 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1043 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1044 int direction, int index)
1046 struct hda_amp_info *info;
1047 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1050 return get_vol_mute(codec, info, nid, ch, direction, index);
1052 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1055 * update the AMP value, mask = bit mask to set, val = the value
1057 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1058 int direction, int idx, int mask, int val)
1060 struct hda_amp_info *info;
1062 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1066 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1067 if (info->vol[ch] == val)
1069 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1072 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1075 * update the AMP stereo with the same mask and value
1077 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1078 int direction, int idx, int mask, int val)
1081 for (ch = 0; ch < 2; ch++)
1082 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1086 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1088 #ifdef SND_HDA_NEEDS_RESUME
1089 /* resume the all amp commands from the cache */
1090 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1092 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1095 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1096 u32 key = buffer->head.key;
1098 unsigned int idx, dir, ch;
1102 idx = (key >> 16) & 0xff;
1103 dir = (key >> 24) & 0xff;
1104 for (ch = 0; ch < 2; ch++) {
1105 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1107 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1112 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1113 #endif /* SND_HDA_NEEDS_RESUME */
1116 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1117 struct snd_ctl_elem_info *uinfo)
1119 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1120 u16 nid = get_amp_nid(kcontrol);
1121 u8 chs = get_amp_channels(kcontrol);
1122 int dir = get_amp_direction(kcontrol);
1123 unsigned int ofs = get_amp_offset(kcontrol);
1126 caps = query_amp_caps(codec, nid, dir);
1128 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1130 printk(KERN_WARNING "hda_codec: "
1131 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1137 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1138 uinfo->count = chs == 3 ? 2 : 1;
1139 uinfo->value.integer.min = 0;
1140 uinfo->value.integer.max = caps;
1143 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1146 static inline unsigned int
1147 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1148 int ch, int dir, int idx, unsigned int ofs)
1151 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1152 val &= HDA_AMP_VOLMASK;
1161 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1162 int ch, int dir, int idx, unsigned int ofs,
1167 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1168 HDA_AMP_VOLMASK, val);
1171 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1172 struct snd_ctl_elem_value *ucontrol)
1174 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1175 hda_nid_t nid = get_amp_nid(kcontrol);
1176 int chs = get_amp_channels(kcontrol);
1177 int dir = get_amp_direction(kcontrol);
1178 int idx = get_amp_index(kcontrol);
1179 unsigned int ofs = get_amp_offset(kcontrol);
1180 long *valp = ucontrol->value.integer.value;
1183 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1185 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1188 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1190 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1191 struct snd_ctl_elem_value *ucontrol)
1193 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1194 hda_nid_t nid = get_amp_nid(kcontrol);
1195 int chs = get_amp_channels(kcontrol);
1196 int dir = get_amp_direction(kcontrol);
1197 int idx = get_amp_index(kcontrol);
1198 unsigned int ofs = get_amp_offset(kcontrol);
1199 long *valp = ucontrol->value.integer.value;
1202 snd_hda_power_up(codec);
1204 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1208 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1209 snd_hda_power_down(codec);
1212 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1214 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1215 unsigned int size, unsigned int __user *_tlv)
1217 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1218 hda_nid_t nid = get_amp_nid(kcontrol);
1219 int dir = get_amp_direction(kcontrol);
1220 unsigned int ofs = get_amp_offset(kcontrol);
1221 u32 caps, val1, val2;
1223 if (size < 4 * sizeof(unsigned int))
1225 caps = query_amp_caps(codec, nid, dir);
1226 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1227 val2 = (val2 + 1) * 25;
1228 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1230 val1 = ((int)val1) * ((int)val2);
1231 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1233 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1235 if (put_user(val1, _tlv + 2))
1237 if (put_user(val2, _tlv + 3))
1241 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1244 * set (static) TLV for virtual master volume; recalculated as max 0dB
1246 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1252 caps = query_amp_caps(codec, nid, dir);
1253 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1254 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1255 step = (step + 1) * 25;
1256 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1257 tlv[1] = 2 * sizeof(unsigned int);
1258 tlv[2] = -nums * step;
1261 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1263 /* find a mixer control element with the given name */
1264 static struct snd_kcontrol *
1265 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1266 const char *name, int idx)
1268 struct snd_ctl_elem_id id;
1269 memset(&id, 0, sizeof(id));
1270 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1272 strcpy(id.name, name);
1273 return snd_ctl_find_id(codec->bus->card, &id);
1276 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1279 return _snd_hda_find_mixer_ctl(codec, name, 0);
1281 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1283 /* Add a control element and assign to the codec */
1284 int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1287 struct snd_kcontrol **knewp;
1289 err = snd_ctl_add(codec->bus->card, kctl);
1292 knewp = snd_array_new(&codec->mixers);
1298 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1300 #ifdef CONFIG_SND_HDA_RECONFIG
1301 /* Clear all controls assigned to the given codec */
1302 void snd_hda_ctls_clear(struct hda_codec *codec)
1305 struct snd_kcontrol **kctls = codec->mixers.list;
1306 for (i = 0; i < codec->mixers.used; i++)
1307 snd_ctl_remove(codec->bus->card, kctls[i]);
1308 snd_array_free(&codec->mixers);
1311 void snd_hda_codec_reset(struct hda_codec *codec)
1315 #ifdef CONFIG_SND_HDA_POWER_SAVE
1316 cancel_delayed_work(&codec->power_work);
1317 flush_workqueue(codec->bus->workq);
1319 snd_hda_ctls_clear(codec);
1321 for (i = 0; i < codec->num_pcms; i++) {
1322 if (codec->pcm_info[i].pcm) {
1323 snd_device_free(codec->bus->card,
1324 codec->pcm_info[i].pcm);
1325 clear_bit(codec->pcm_info[i].device,
1326 codec->bus->pcm_dev_bits);
1329 if (codec->patch_ops.free)
1330 codec->patch_ops.free(codec);
1331 codec->proc_widget_hook = NULL;
1333 free_hda_cache(&codec->amp_cache);
1334 free_hda_cache(&codec->cmd_cache);
1335 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1336 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1337 codec->num_pcms = 0;
1338 codec->pcm_info = NULL;
1339 codec->preset = NULL;
1340 module_put(codec->owner);
1341 codec->owner = NULL;
1343 #endif /* CONFIG_SND_HDA_RECONFIG */
1345 /* create a virtual master control and add slaves */
1346 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1347 unsigned int *tlv, const char **slaves)
1349 struct snd_kcontrol *kctl;
1353 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1356 snd_printdd("No slave found for %s\n", name);
1359 kctl = snd_ctl_make_virtual_master(name, tlv);
1362 err = snd_hda_ctl_add(codec, kctl);
1366 for (s = slaves; *s; s++) {
1367 struct snd_kcontrol *sctl;
1369 sctl = snd_hda_find_mixer_ctl(codec, *s);
1371 snd_printdd("Cannot find slave %s, skipped\n", *s);
1374 err = snd_ctl_add_slave(kctl, sctl);
1380 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
1383 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1384 struct snd_ctl_elem_info *uinfo)
1386 int chs = get_amp_channels(kcontrol);
1388 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1389 uinfo->count = chs == 3 ? 2 : 1;
1390 uinfo->value.integer.min = 0;
1391 uinfo->value.integer.max = 1;
1394 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1396 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1397 struct snd_ctl_elem_value *ucontrol)
1399 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1400 hda_nid_t nid = get_amp_nid(kcontrol);
1401 int chs = get_amp_channels(kcontrol);
1402 int dir = get_amp_direction(kcontrol);
1403 int idx = get_amp_index(kcontrol);
1404 long *valp = ucontrol->value.integer.value;
1407 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
1408 HDA_AMP_MUTE) ? 0 : 1;
1410 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
1411 HDA_AMP_MUTE) ? 0 : 1;
1414 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1416 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1417 struct snd_ctl_elem_value *ucontrol)
1419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1420 hda_nid_t nid = get_amp_nid(kcontrol);
1421 int chs = get_amp_channels(kcontrol);
1422 int dir = get_amp_direction(kcontrol);
1423 int idx = get_amp_index(kcontrol);
1424 long *valp = ucontrol->value.integer.value;
1427 snd_hda_power_up(codec);
1429 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
1431 *valp ? 0 : HDA_AMP_MUTE);
1435 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
1437 *valp ? 0 : HDA_AMP_MUTE);
1438 #ifdef CONFIG_SND_HDA_POWER_SAVE
1439 if (codec->patch_ops.check_power_status)
1440 codec->patch_ops.check_power_status(codec, nid);
1442 snd_hda_power_down(codec);
1445 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1448 * bound volume controls
1450 * bind multiple volumes (# indices, from 0)
1453 #define AMP_VAL_IDX_SHIFT 19
1454 #define AMP_VAL_IDX_MASK (0x0f<<19)
1456 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1457 struct snd_ctl_elem_value *ucontrol)
1459 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1463 mutex_lock(&codec->control_mutex);
1464 pval = kcontrol->private_value;
1465 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1466 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1467 kcontrol->private_value = pval;
1468 mutex_unlock(&codec->control_mutex);
1471 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
1473 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1474 struct snd_ctl_elem_value *ucontrol)
1476 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1478 int i, indices, err = 0, change = 0;
1480 mutex_lock(&codec->control_mutex);
1481 pval = kcontrol->private_value;
1482 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1483 for (i = 0; i < indices; i++) {
1484 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1485 (i << AMP_VAL_IDX_SHIFT);
1486 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1491 kcontrol->private_value = pval;
1492 mutex_unlock(&codec->control_mutex);
1493 return err < 0 ? err : change;
1495 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
1498 * generic bound volume/swtich controls
1500 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1501 struct snd_ctl_elem_info *uinfo)
1503 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1504 struct hda_bind_ctls *c;
1507 mutex_lock(&codec->control_mutex);
1508 c = (struct hda_bind_ctls *)kcontrol->private_value;
1509 kcontrol->private_value = *c->values;
1510 err = c->ops->info(kcontrol, uinfo);
1511 kcontrol->private_value = (long)c;
1512 mutex_unlock(&codec->control_mutex);
1515 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
1517 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1518 struct snd_ctl_elem_value *ucontrol)
1520 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521 struct hda_bind_ctls *c;
1524 mutex_lock(&codec->control_mutex);
1525 c = (struct hda_bind_ctls *)kcontrol->private_value;
1526 kcontrol->private_value = *c->values;
1527 err = c->ops->get(kcontrol, ucontrol);
1528 kcontrol->private_value = (long)c;
1529 mutex_unlock(&codec->control_mutex);
1532 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
1534 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1535 struct snd_ctl_elem_value *ucontrol)
1537 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1538 struct hda_bind_ctls *c;
1539 unsigned long *vals;
1540 int err = 0, change = 0;
1542 mutex_lock(&codec->control_mutex);
1543 c = (struct hda_bind_ctls *)kcontrol->private_value;
1544 for (vals = c->values; *vals; vals++) {
1545 kcontrol->private_value = *vals;
1546 err = c->ops->put(kcontrol, ucontrol);
1551 kcontrol->private_value = (long)c;
1552 mutex_unlock(&codec->control_mutex);
1553 return err < 0 ? err : change;
1555 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
1557 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1558 unsigned int size, unsigned int __user *tlv)
1560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1561 struct hda_bind_ctls *c;
1564 mutex_lock(&codec->control_mutex);
1565 c = (struct hda_bind_ctls *)kcontrol->private_value;
1566 kcontrol->private_value = *c->values;
1567 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1568 kcontrol->private_value = (long)c;
1569 mutex_unlock(&codec->control_mutex);
1572 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
1574 struct hda_ctl_ops snd_hda_bind_vol = {
1575 .info = snd_hda_mixer_amp_volume_info,
1576 .get = snd_hda_mixer_amp_volume_get,
1577 .put = snd_hda_mixer_amp_volume_put,
1578 .tlv = snd_hda_mixer_amp_tlv
1580 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
1582 struct hda_ctl_ops snd_hda_bind_sw = {
1583 .info = snd_hda_mixer_amp_switch_info,
1584 .get = snd_hda_mixer_amp_switch_get,
1585 .put = snd_hda_mixer_amp_switch_put,
1586 .tlv = snd_hda_mixer_amp_tlv
1588 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
1591 * SPDIF out controls
1594 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1595 struct snd_ctl_elem_info *uinfo)
1597 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1602 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1603 struct snd_ctl_elem_value *ucontrol)
1605 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1606 IEC958_AES0_NONAUDIO |
1607 IEC958_AES0_CON_EMPHASIS_5015 |
1608 IEC958_AES0_CON_NOT_COPYRIGHT;
1609 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1610 IEC958_AES1_CON_ORIGINAL;
1614 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1615 struct snd_ctl_elem_value *ucontrol)
1617 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1618 IEC958_AES0_NONAUDIO |
1619 IEC958_AES0_PRO_EMPHASIS_5015;
1623 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1624 struct snd_ctl_elem_value *ucontrol)
1626 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1628 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1629 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1630 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1631 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1636 /* convert from SPDIF status bits to HDA SPDIF bits
1637 * bit 0 (DigEn) is always set zero (to be filled later)
1639 static unsigned short convert_from_spdif_status(unsigned int sbits)
1641 unsigned short val = 0;
1643 if (sbits & IEC958_AES0_PROFESSIONAL)
1644 val |= AC_DIG1_PROFESSIONAL;
1645 if (sbits & IEC958_AES0_NONAUDIO)
1646 val |= AC_DIG1_NONAUDIO;
1647 if (sbits & IEC958_AES0_PROFESSIONAL) {
1648 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1649 IEC958_AES0_PRO_EMPHASIS_5015)
1650 val |= AC_DIG1_EMPHASIS;
1652 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1653 IEC958_AES0_CON_EMPHASIS_5015)
1654 val |= AC_DIG1_EMPHASIS;
1655 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1656 val |= AC_DIG1_COPYRIGHT;
1657 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
1658 val |= AC_DIG1_LEVEL;
1659 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1664 /* convert to SPDIF status bits from HDA SPDIF bits
1666 static unsigned int convert_to_spdif_status(unsigned short val)
1668 unsigned int sbits = 0;
1670 if (val & AC_DIG1_NONAUDIO)
1671 sbits |= IEC958_AES0_NONAUDIO;
1672 if (val & AC_DIG1_PROFESSIONAL)
1673 sbits |= IEC958_AES0_PROFESSIONAL;
1674 if (sbits & IEC958_AES0_PROFESSIONAL) {
1675 if (sbits & AC_DIG1_EMPHASIS)
1676 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1678 if (val & AC_DIG1_EMPHASIS)
1679 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
1680 if (!(val & AC_DIG1_COPYRIGHT))
1681 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
1682 if (val & AC_DIG1_LEVEL)
1683 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1684 sbits |= val & (0x7f << 8);
1689 /* set digital convert verbs both for the given NID and its slaves */
1690 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1695 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
1696 d = codec->slave_dig_outs;
1700 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
1703 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1707 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1709 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1712 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1713 struct snd_ctl_elem_value *ucontrol)
1715 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1716 hda_nid_t nid = kcontrol->private_value;
1720 mutex_lock(&codec->spdif_mutex);
1721 codec->spdif_status = ucontrol->value.iec958.status[0] |
1722 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1723 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1724 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1725 val = convert_from_spdif_status(codec->spdif_status);
1726 val |= codec->spdif_ctls & 1;
1727 change = codec->spdif_ctls != val;
1728 codec->spdif_ctls = val;
1731 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1733 mutex_unlock(&codec->spdif_mutex);
1737 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1739 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1740 struct snd_ctl_elem_value *ucontrol)
1742 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1744 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1748 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1749 struct snd_ctl_elem_value *ucontrol)
1751 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1752 hda_nid_t nid = kcontrol->private_value;
1756 mutex_lock(&codec->spdif_mutex);
1757 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1758 if (ucontrol->value.integer.value[0])
1759 val |= AC_DIG1_ENABLE;
1760 change = codec->spdif_ctls != val;
1762 codec->spdif_ctls = val;
1763 set_dig_out_convert(codec, nid, val & 0xff, -1);
1764 /* unmute amp switch (if any) */
1765 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
1766 (val & AC_DIG1_ENABLE))
1767 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1770 mutex_unlock(&codec->spdif_mutex);
1774 static struct snd_kcontrol_new dig_mixes[] = {
1776 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1777 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1778 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1779 .info = snd_hda_spdif_mask_info,
1780 .get = snd_hda_spdif_cmask_get,
1783 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1784 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1785 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1786 .info = snd_hda_spdif_mask_info,
1787 .get = snd_hda_spdif_pmask_get,
1790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1791 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1792 .info = snd_hda_spdif_mask_info,
1793 .get = snd_hda_spdif_default_get,
1794 .put = snd_hda_spdif_default_put,
1797 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1798 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1799 .info = snd_hda_spdif_out_switch_info,
1800 .get = snd_hda_spdif_out_switch_get,
1801 .put = snd_hda_spdif_out_switch_put,
1806 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1809 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1810 * @codec: the HDA codec
1811 * @nid: audio out widget NID
1813 * Creates controls related with the SPDIF output.
1814 * Called from each patch supporting the SPDIF out.
1816 * Returns 0 if successful, or a negative error code.
1818 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1821 struct snd_kcontrol *kctl;
1822 struct snd_kcontrol_new *dig_mix;
1825 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1826 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1830 if (idx >= SPDIF_MAX_IDX) {
1831 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1834 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1835 kctl = snd_ctl_new1(dig_mix, codec);
1838 kctl->id.index = idx;
1839 kctl->private_value = nid;
1840 err = snd_hda_ctl_add(codec, kctl);
1845 snd_hda_codec_read(codec, nid, 0,
1846 AC_VERB_GET_DIGI_CONVERT_1, 0);
1847 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1850 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1853 * SPDIF sharing with analog output
1855 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1856 struct snd_ctl_elem_value *ucontrol)
1858 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1859 ucontrol->value.integer.value[0] = mout->share_spdif;
1863 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1864 struct snd_ctl_elem_value *ucontrol)
1866 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1867 mout->share_spdif = !!ucontrol->value.integer.value[0];
1871 static struct snd_kcontrol_new spdif_share_sw = {
1872 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1873 .name = "IEC958 Default PCM Playback Switch",
1874 .info = snd_ctl_boolean_mono_info,
1875 .get = spdif_share_sw_get,
1876 .put = spdif_share_sw_put,
1879 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1880 struct hda_multi_out *mout)
1882 if (!mout->dig_out_nid)
1884 /* ATTENTION: here mout is passed as private_data, instead of codec */
1885 return snd_hda_ctl_add(codec,
1886 snd_ctl_new1(&spdif_share_sw, mout));
1888 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
1894 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1896 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1897 struct snd_ctl_elem_value *ucontrol)
1899 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1901 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1905 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1906 struct snd_ctl_elem_value *ucontrol)
1908 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1909 hda_nid_t nid = kcontrol->private_value;
1910 unsigned int val = !!ucontrol->value.integer.value[0];
1913 mutex_lock(&codec->spdif_mutex);
1914 change = codec->spdif_in_enable != val;
1916 codec->spdif_in_enable = val;
1917 snd_hda_codec_write_cache(codec, nid, 0,
1918 AC_VERB_SET_DIGI_CONVERT_1, val);
1920 mutex_unlock(&codec->spdif_mutex);
1924 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1925 struct snd_ctl_elem_value *ucontrol)
1927 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1928 hda_nid_t nid = kcontrol->private_value;
1932 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1933 sbits = convert_to_spdif_status(val);
1934 ucontrol->value.iec958.status[0] = sbits;
1935 ucontrol->value.iec958.status[1] = sbits >> 8;
1936 ucontrol->value.iec958.status[2] = sbits >> 16;
1937 ucontrol->value.iec958.status[3] = sbits >> 24;
1941 static struct snd_kcontrol_new dig_in_ctls[] = {
1943 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1944 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1945 .info = snd_hda_spdif_in_switch_info,
1946 .get = snd_hda_spdif_in_switch_get,
1947 .put = snd_hda_spdif_in_switch_put,
1950 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1951 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1952 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1953 .info = snd_hda_spdif_mask_info,
1954 .get = snd_hda_spdif_in_status_get,
1960 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1961 * @codec: the HDA codec
1962 * @nid: audio in widget NID
1964 * Creates controls related with the SPDIF input.
1965 * Called from each patch supporting the SPDIF in.
1967 * Returns 0 if successful, or a negative error code.
1969 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1972 struct snd_kcontrol *kctl;
1973 struct snd_kcontrol_new *dig_mix;
1976 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1977 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1981 if (idx >= SPDIF_MAX_IDX) {
1982 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1985 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1986 kctl = snd_ctl_new1(dig_mix, codec);
1989 kctl->private_value = nid;
1990 err = snd_hda_ctl_add(codec, kctl);
1994 codec->spdif_in_enable =
1995 snd_hda_codec_read(codec, nid, 0,
1996 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2000 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2002 #ifdef SND_HDA_NEEDS_RESUME
2007 /* build a 32bit cache key with the widget id and the command parameter */
2008 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2009 #define get_cmd_cache_nid(key) ((key) & 0xff)
2010 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2013 * snd_hda_codec_write_cache - send a single command with caching
2014 * @codec: the HDA codec
2015 * @nid: NID to send the command
2016 * @direct: direct flag
2017 * @verb: the verb to send
2018 * @parm: the parameter for the verb
2020 * Send a single command without waiting for response.
2022 * Returns 0 if successful, or a negative error code.
2024 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2025 int direct, unsigned int verb, unsigned int parm)
2027 struct hda_bus *bus = codec->bus;
2031 res = make_codec_cmd(codec, nid, direct, verb, parm);
2032 snd_hda_power_up(codec);
2033 mutex_lock(&bus->cmd_mutex);
2034 err = bus->ops.command(bus, res);
2036 struct hda_cache_head *c;
2037 u32 key = build_cmd_cache_key(nid, verb);
2038 c = get_alloc_hash(&codec->cmd_cache, key);
2042 mutex_unlock(&bus->cmd_mutex);
2043 snd_hda_power_down(codec);
2046 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2048 /* resume the all commands from the cache */
2049 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2051 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2054 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2055 u32 key = buffer->key;
2058 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2059 get_cmd_cache_cmd(key), buffer->val);
2062 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2065 * snd_hda_sequence_write_cache - sequence writes with caching
2066 * @codec: the HDA codec
2067 * @seq: VERB array to send
2069 * Send the commands sequentially from the given array.
2070 * Thte commands are recorded on cache for power-save and resume.
2071 * The array must be terminated with NID=0.
2073 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2074 const struct hda_verb *seq)
2076 for (; seq->nid; seq++)
2077 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2080 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2081 #endif /* SND_HDA_NEEDS_RESUME */
2084 * set power state of the codec
2086 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2087 unsigned int power_state)
2092 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2094 msleep(10); /* partial workaround for "azx_get_response timeout" */
2096 nid = codec->start_nid;
2097 for (i = 0; i < codec->num_nodes; i++, nid++) {
2098 unsigned int wcaps = get_wcaps(codec, nid);
2099 if (wcaps & AC_WCAP_POWER) {
2100 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2102 if (wid_type == AC_WID_PIN) {
2103 unsigned int pincap;
2105 * don't power down the widget if it controls
2106 * eapd and EAPD_BTLENABLE is set.
2108 pincap = snd_hda_param_read(codec, nid,
2110 if (pincap & AC_PINCAP_EAPD) {
2111 int eapd = snd_hda_codec_read(codec,
2113 AC_VERB_GET_EAPD_BTLENABLE, 0);
2115 if (power_state == AC_PWRST_D3 && eapd)
2119 snd_hda_codec_write(codec, nid, 0,
2120 AC_VERB_SET_POWER_STATE,
2125 if (power_state == AC_PWRST_D0) {
2126 unsigned long end_time;
2129 /* wait until the codec reachs to D0 */
2130 end_time = jiffies + msecs_to_jiffies(500);
2132 state = snd_hda_codec_read(codec, fg, 0,
2133 AC_VERB_GET_POWER_STATE, 0);
2134 if (state == power_state)
2137 } while (time_after_eq(end_time, jiffies));
2141 #ifdef CONFIG_SND_HDA_HWDEP
2142 /* execute additional init verbs */
2143 static void hda_exec_init_verbs(struct hda_codec *codec)
2145 if (codec->init_verbs.list)
2146 snd_hda_sequence_write(codec, codec->init_verbs.list);
2149 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2152 #ifdef SND_HDA_NEEDS_RESUME
2154 * call suspend and power-down; used both from PM and power-save
2156 static void hda_call_codec_suspend(struct hda_codec *codec)
2158 if (codec->patch_ops.suspend)
2159 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2160 hda_set_power_state(codec,
2161 codec->afg ? codec->afg : codec->mfg,
2163 #ifdef CONFIG_SND_HDA_POWER_SAVE
2164 cancel_delayed_work(&codec->power_work);
2165 codec->power_on = 0;
2166 codec->power_transition = 0;
2171 * kick up codec; used both from PM and power-save
2173 static void hda_call_codec_resume(struct hda_codec *codec)
2175 hda_set_power_state(codec,
2176 codec->afg ? codec->afg : codec->mfg,
2178 hda_exec_init_verbs(codec);
2179 if (codec->patch_ops.resume)
2180 codec->patch_ops.resume(codec);
2182 if (codec->patch_ops.init)
2183 codec->patch_ops.init(codec);
2184 snd_hda_codec_resume_amp(codec);
2185 snd_hda_codec_resume_cache(codec);
2188 #endif /* SND_HDA_NEEDS_RESUME */
2192 * snd_hda_build_controls - build mixer controls
2195 * Creates mixer controls for each codec included in the bus.
2197 * Returns 0 if successful, otherwise a negative error code.
2199 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
2201 struct hda_codec *codec;
2203 list_for_each_entry(codec, &bus->codec_list, list) {
2204 int err = snd_hda_codec_build_controls(codec);
2210 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
2212 int snd_hda_codec_build_controls(struct hda_codec *codec)
2215 /* fake as if already powered-on */
2216 hda_keep_power_on(codec);
2218 hda_set_power_state(codec,
2219 codec->afg ? codec->afg : codec->mfg,
2221 hda_exec_init_verbs(codec);
2222 /* continue to initialize... */
2223 if (codec->patch_ops.init)
2224 err = codec->patch_ops.init(codec);
2225 if (!err && codec->patch_ops.build_controls)
2226 err = codec->patch_ops.build_controls(codec);
2227 snd_hda_power_down(codec);
2236 struct hda_rate_tbl {
2238 unsigned int alsa_bits;
2239 unsigned int hda_fmt;
2242 static struct hda_rate_tbl rate_bits[] = {
2243 /* rate in Hz, ALSA rate bitmask, HDA format value */
2245 /* autodetected value used in snd_hda_query_supported_pcm */
2246 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2247 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2248 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2249 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2250 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2251 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2252 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2253 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2254 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2255 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2256 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
2257 #define AC_PAR_PCM_RATE_BITS 11
2258 /* up to bits 10, 384kHZ isn't supported properly */
2260 /* not autodetected value */
2261 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
2263 { 0 } /* terminator */
2267 * snd_hda_calc_stream_format - calculate format bitset
2268 * @rate: the sample rate
2269 * @channels: the number of channels
2270 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2271 * @maxbps: the max. bps
2273 * Calculate the format bitset from the given rate, channels and th PCM format.
2275 * Return zero if invalid.
2277 unsigned int snd_hda_calc_stream_format(unsigned int rate,
2278 unsigned int channels,
2279 unsigned int format,
2280 unsigned int maxbps)
2283 unsigned int val = 0;
2285 for (i = 0; rate_bits[i].hz; i++)
2286 if (rate_bits[i].hz == rate) {
2287 val = rate_bits[i].hda_fmt;
2290 if (!rate_bits[i].hz) {
2291 snd_printdd("invalid rate %d\n", rate);
2295 if (channels == 0 || channels > 8) {
2296 snd_printdd("invalid channels %d\n", channels);
2299 val |= channels - 1;
2301 switch (snd_pcm_format_width(format)) {
2302 case 8: val |= 0x00; break;
2303 case 16: val |= 0x10; break;
2309 else if (maxbps >= 24)
2315 snd_printdd("invalid format width %d\n",
2316 snd_pcm_format_width(format));
2322 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
2325 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2326 * @codec: the HDA codec
2327 * @nid: NID to query
2328 * @ratesp: the pointer to store the detected rate bitflags
2329 * @formatsp: the pointer to store the detected formats
2330 * @bpsp: the pointer to store the detected format widths
2332 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2333 * or @bsps argument is ignored.
2335 * Returns 0 if successful, otherwise a negative error code.
2337 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
2338 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2341 unsigned int val, streams;
2344 if (nid != codec->afg &&
2345 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2346 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2351 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2355 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
2357 rates |= rate_bits[i].alsa_bits;
2362 if (formatsp || bpsp) {
2367 wcaps = get_wcaps(codec, nid);
2368 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2372 streams = snd_hda_param_read(codec, codec->afg,
2379 if (streams & AC_SUPFMT_PCM) {
2380 if (val & AC_SUPPCM_BITS_8) {
2381 formats |= SNDRV_PCM_FMTBIT_U8;
2384 if (val & AC_SUPPCM_BITS_16) {
2385 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2388 if (wcaps & AC_WCAP_DIGITAL) {
2389 if (val & AC_SUPPCM_BITS_32)
2390 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2391 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2392 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2393 if (val & AC_SUPPCM_BITS_24)
2395 else if (val & AC_SUPPCM_BITS_20)
2397 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2398 AC_SUPPCM_BITS_32)) {
2399 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2400 if (val & AC_SUPPCM_BITS_32)
2402 else if (val & AC_SUPPCM_BITS_24)
2404 else if (val & AC_SUPPCM_BITS_20)
2408 else if (streams == AC_SUPFMT_FLOAT32) {
2409 /* should be exclusive */
2410 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2412 } else if (streams == AC_SUPFMT_AC3) {
2413 /* should be exclusive */
2414 /* temporary hack: we have still no proper support
2415 * for the direct AC3 stream...
2417 formats |= SNDRV_PCM_FMTBIT_U8;
2421 *formatsp = formats;
2430 * snd_hda_is_supported_format - check whether the given node supports
2433 * Returns 1 if supported, 0 if not.
2435 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2436 unsigned int format)
2439 unsigned int val = 0, rate, stream;
2441 if (nid != codec->afg &&
2442 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
2443 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2448 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2453 rate = format & 0xff00;
2454 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
2455 if (rate_bits[i].hda_fmt == rate) {
2460 if (i >= AC_PAR_PCM_RATE_BITS)
2463 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2466 if (!stream && nid != codec->afg)
2467 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2468 if (!stream || stream == -1)
2471 if (stream & AC_SUPFMT_PCM) {
2472 switch (format & 0xf0) {
2474 if (!(val & AC_SUPPCM_BITS_8))
2478 if (!(val & AC_SUPPCM_BITS_16))
2482 if (!(val & AC_SUPPCM_BITS_20))
2486 if (!(val & AC_SUPPCM_BITS_24))
2490 if (!(val & AC_SUPPCM_BITS_32))
2497 /* FIXME: check for float32 and AC3? */
2502 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
2507 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2508 struct hda_codec *codec,
2509 struct snd_pcm_substream *substream)
2514 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2515 struct hda_codec *codec,
2516 unsigned int stream_tag,
2517 unsigned int format,
2518 struct snd_pcm_substream *substream)
2520 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2524 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2525 struct hda_codec *codec,
2526 struct snd_pcm_substream *substream)
2528 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2532 static int set_pcm_default_values(struct hda_codec *codec,
2533 struct hda_pcm_stream *info)
2535 /* query support PCM information from the given NID */
2536 if (info->nid && (!info->rates || !info->formats)) {
2537 snd_hda_query_supported_pcm(codec, info->nid,
2538 info->rates ? NULL : &info->rates,
2539 info->formats ? NULL : &info->formats,
2540 info->maxbps ? NULL : &info->maxbps);
2542 if (info->ops.open == NULL)
2543 info->ops.open = hda_pcm_default_open_close;
2544 if (info->ops.close == NULL)
2545 info->ops.close = hda_pcm_default_open_close;
2546 if (info->ops.prepare == NULL) {
2547 if (snd_BUG_ON(!info->nid))
2549 info->ops.prepare = hda_pcm_default_prepare;
2551 if (info->ops.cleanup == NULL) {
2552 if (snd_BUG_ON(!info->nid))
2554 info->ops.cleanup = hda_pcm_default_cleanup;
2560 * get the empty PCM device number to assign
2562 static int get_empty_pcm_device(struct hda_bus *bus, int type)
2564 static const char *dev_name[HDA_PCM_NTYPES] = {
2565 "Audio", "SPDIF", "HDMI", "Modem"
2567 /* starting device index for each PCM type */
2568 static int dev_idx[HDA_PCM_NTYPES] = {
2569 [HDA_PCM_TYPE_AUDIO] = 0,
2570 [HDA_PCM_TYPE_SPDIF] = 1,
2571 [HDA_PCM_TYPE_HDMI] = 3,
2572 [HDA_PCM_TYPE_MODEM] = 6
2574 /* normal audio device indices; not linear to keep compatibility */
2575 static int audio_idx[4] = { 0, 2, 4, 5 };
2579 case HDA_PCM_TYPE_AUDIO:
2580 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2582 if (!test_bit(dev, bus->pcm_dev_bits))
2585 if (i >= ARRAY_SIZE(audio_idx)) {
2586 snd_printk(KERN_WARNING "Too many audio devices\n");
2590 case HDA_PCM_TYPE_SPDIF:
2591 case HDA_PCM_TYPE_HDMI:
2592 case HDA_PCM_TYPE_MODEM:
2593 dev = dev_idx[type];
2594 if (test_bit(dev, bus->pcm_dev_bits)) {
2595 snd_printk(KERN_WARNING "%s already defined\n",
2601 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2604 set_bit(dev, bus->pcm_dev_bits);
2609 * attach a new PCM stream
2611 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
2613 struct hda_bus *bus = codec->bus;
2614 struct hda_pcm_stream *info;
2617 if (snd_BUG_ON(!pcm->name))
2619 for (stream = 0; stream < 2; stream++) {
2620 info = &pcm->stream[stream];
2621 if (info->substreams) {
2622 err = set_pcm_default_values(codec, info);
2627 return bus->ops.attach_pcm(bus, codec, pcm);
2630 /* assign all PCMs of the given codec */
2631 int snd_hda_codec_build_pcms(struct hda_codec *codec)
2636 if (!codec->num_pcms) {
2637 if (!codec->patch_ops.build_pcms)
2639 err = codec->patch_ops.build_pcms(codec);
2643 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2644 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2647 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2648 continue; /* no substreams assigned */
2651 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2655 err = snd_hda_attach_pcm(codec, cpcm);
2664 * snd_hda_build_pcms - build PCM information
2667 * Create PCM information for each codec included in the bus.
2669 * The build_pcms codec patch is requested to set up codec->num_pcms and
2670 * codec->pcm_info properly. The array is referred by the top-level driver
2671 * to create its PCM instances.
2672 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2675 * At least, substreams, channels_min and channels_max must be filled for
2676 * each stream. substreams = 0 indicates that the stream doesn't exist.
2677 * When rates and/or formats are zero, the supported values are queried
2678 * from the given nid. The nid is used also by the default ops.prepare
2679 * and ops.cleanup callbacks.
2681 * The driver needs to call ops.open in its open callback. Similarly,
2682 * ops.close is supposed to be called in the close callback.
2683 * ops.prepare should be called in the prepare or hw_params callback
2684 * with the proper parameters for set up.
2685 * ops.cleanup should be called in hw_free for clean up of streams.
2687 * This function returns 0 if successfull, or a negative error code.
2689 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
2691 struct hda_codec *codec;
2693 list_for_each_entry(codec, &bus->codec_list, list) {
2694 int err = snd_hda_codec_build_pcms(codec);
2700 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
2703 * snd_hda_check_board_config - compare the current codec with the config table
2704 * @codec: the HDA codec
2705 * @num_configs: number of config enums
2706 * @models: array of model name strings
2707 * @tbl: configuration table, terminated by null entries
2709 * Compares the modelname or PCI subsystem id of the current codec with the
2710 * given configuration table. If a matching entry is found, returns its
2711 * config value (supposed to be 0 or positive).
2713 * If no entries are matching, the function returns a negative value.
2715 int snd_hda_check_board_config(struct hda_codec *codec,
2716 int num_configs, const char **models,
2717 const struct snd_pci_quirk *tbl)
2719 if (codec->modelname && models) {
2721 for (i = 0; i < num_configs; i++) {
2723 !strcmp(codec->modelname, models[i])) {
2724 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2725 "selected\n", models[i]);
2731 if (!codec->bus->pci || !tbl)
2734 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2737 if (tbl->value >= 0 && tbl->value < num_configs) {
2738 #ifdef CONFIG_SND_DEBUG_VERBOSE
2740 const char *model = NULL;
2742 model = models[tbl->value];
2744 sprintf(tmp, "#%d", tbl->value);
2747 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2748 "for config %x:%x (%s)\n",
2749 model, tbl->subvendor, tbl->subdevice,
2750 (tbl->name ? tbl->name : "Unknown device"));
2756 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
2759 * snd_hda_check_board_codec_sid_config - compare the current codec
2760 subsystem ID with the
2763 This is important for Gateway notebooks with SB450 HDA Audio
2764 where the vendor ID of the PCI device is:
2765 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2766 and the vendor/subvendor are found only at the codec.
2768 * @codec: the HDA codec
2769 * @num_configs: number of config enums
2770 * @models: array of model name strings
2771 * @tbl: configuration table, terminated by null entries
2773 * Compares the modelname or PCI subsystem id of the current codec with the
2774 * given configuration table. If a matching entry is found, returns its
2775 * config value (supposed to be 0 or positive).
2777 * If no entries are matching, the function returns a negative value.
2779 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2780 int num_configs, const char **models,
2781 const struct snd_pci_quirk *tbl)
2783 const struct snd_pci_quirk *q;
2785 /* Search for codec ID */
2786 for (q = tbl; q->subvendor; q++) {
2787 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2789 if (vendorid == codec->subsystem_id)
2798 if (tbl->value >= 0 && tbl->value < num_configs) {
2799 #ifdef CONFIG_SND_DEBUG_DETECT
2801 const char *model = NULL;
2803 model = models[tbl->value];
2805 sprintf(tmp, "#%d", tbl->value);
2808 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2809 "for config %x:%x (%s)\n",
2810 model, tbl->subvendor, tbl->subdevice,
2811 (tbl->name ? tbl->name : "Unknown device"));
2817 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2820 * snd_hda_add_new_ctls - create controls from the array
2821 * @codec: the HDA codec
2822 * @knew: the array of struct snd_kcontrol_new
2824 * This helper function creates and add new controls in the given array.
2825 * The array must be terminated with an empty entry as terminator.
2827 * Returns 0 if successful, or a negative error code.
2829 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
2833 for (; knew->name; knew++) {
2834 struct snd_kcontrol *kctl;
2835 kctl = snd_ctl_new1(knew, codec);
2838 err = snd_hda_ctl_add(codec, kctl);
2842 kctl = snd_ctl_new1(knew, codec);
2845 kctl->id.device = codec->addr;
2846 err = snd_hda_ctl_add(codec, kctl);
2853 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
2855 #ifdef CONFIG_SND_HDA_POWER_SAVE
2856 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2857 unsigned int power_state);
2859 static void hda_power_work(struct work_struct *work)
2861 struct hda_codec *codec =
2862 container_of(work, struct hda_codec, power_work.work);
2863 struct hda_bus *bus = codec->bus;
2865 if (!codec->power_on || codec->power_count) {
2866 codec->power_transition = 0;
2870 hda_call_codec_suspend(codec);
2871 if (bus->ops.pm_notify)
2872 bus->ops.pm_notify(bus);
2875 static void hda_keep_power_on(struct hda_codec *codec)
2877 codec->power_count++;
2878 codec->power_on = 1;
2881 void snd_hda_power_up(struct hda_codec *codec)
2883 struct hda_bus *bus = codec->bus;
2885 codec->power_count++;
2886 if (codec->power_on || codec->power_transition)
2889 codec->power_on = 1;
2890 if (bus->ops.pm_notify)
2891 bus->ops.pm_notify(bus);
2892 hda_call_codec_resume(codec);
2893 cancel_delayed_work(&codec->power_work);
2894 codec->power_transition = 0;
2896 EXPORT_SYMBOL_HDA(snd_hda_power_up);
2898 #define power_save(codec) \
2899 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2901 #define power_save(codec) \
2902 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2904 void snd_hda_power_down(struct hda_codec *codec)
2906 --codec->power_count;
2907 if (!codec->power_on || codec->power_count || codec->power_transition)
2909 if (power_save(codec)) {
2910 codec->power_transition = 1; /* avoid reentrance */
2911 queue_delayed_work(codec->bus->workq, &codec->power_work,
2912 msecs_to_jiffies(power_save(codec) * 1000));
2915 EXPORT_SYMBOL_HDA(snd_hda_power_down);
2917 int snd_hda_check_amp_list_power(struct hda_codec *codec,
2918 struct hda_loopback_check *check,
2921 struct hda_amp_list *p;
2924 if (!check->amplist)
2926 for (p = check->amplist; p->nid; p++) {
2931 return 0; /* nothing changed */
2933 for (p = check->amplist; p->nid; p++) {
2934 for (ch = 0; ch < 2; ch++) {
2935 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2937 if (!(v & HDA_AMP_MUTE) && v > 0) {
2938 if (!check->power_on) {
2939 check->power_on = 1;
2940 snd_hda_power_up(codec);
2946 if (check->power_on) {
2947 check->power_on = 0;
2948 snd_hda_power_down(codec);
2952 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
2956 * Channel mode helper
2958 int snd_hda_ch_mode_info(struct hda_codec *codec,
2959 struct snd_ctl_elem_info *uinfo,
2960 const struct hda_channel_mode *chmode,
2963 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2965 uinfo->value.enumerated.items = num_chmodes;
2966 if (uinfo->value.enumerated.item >= num_chmodes)
2967 uinfo->value.enumerated.item = num_chmodes - 1;
2968 sprintf(uinfo->value.enumerated.name, "%dch",
2969 chmode[uinfo->value.enumerated.item].channels);
2972 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
2974 int snd_hda_ch_mode_get(struct hda_codec *codec,
2975 struct snd_ctl_elem_value *ucontrol,
2976 const struct hda_channel_mode *chmode,
2982 for (i = 0; i < num_chmodes; i++) {
2983 if (max_channels == chmode[i].channels) {
2984 ucontrol->value.enumerated.item[0] = i;
2990 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
2992 int snd_hda_ch_mode_put(struct hda_codec *codec,
2993 struct snd_ctl_elem_value *ucontrol,
2994 const struct hda_channel_mode *chmode,
3000 mode = ucontrol->value.enumerated.item[0];
3001 if (mode >= num_chmodes)
3003 if (*max_channelsp == chmode[mode].channels)
3005 /* change the current channel setting */
3006 *max_channelsp = chmode[mode].channels;
3007 if (chmode[mode].sequence)
3008 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
3011 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
3016 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3017 struct snd_ctl_elem_info *uinfo)
3021 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3023 uinfo->value.enumerated.items = imux->num_items;
3024 if (!imux->num_items)
3026 index = uinfo->value.enumerated.item;
3027 if (index >= imux->num_items)
3028 index = imux->num_items - 1;
3029 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3032 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
3034 int snd_hda_input_mux_put(struct hda_codec *codec,
3035 const struct hda_input_mux *imux,
3036 struct snd_ctl_elem_value *ucontrol,
3038 unsigned int *cur_val)
3042 if (!imux->num_items)
3044 idx = ucontrol->value.enumerated.item[0];
3045 if (idx >= imux->num_items)
3046 idx = imux->num_items - 1;
3047 if (*cur_val == idx)
3049 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3050 imux->items[idx].index);
3054 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
3058 * Multi-channel / digital-out PCM helper functions
3061 /* setup SPDIF output stream */
3062 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3063 unsigned int stream_tag, unsigned int format)
3065 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3066 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3067 set_dig_out_convert(codec, nid,
3068 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3070 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
3071 if (codec->slave_dig_outs) {
3073 for (d = codec->slave_dig_outs; *d; d++)
3074 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3077 /* turn on again (if needed) */
3078 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3079 set_dig_out_convert(codec, nid,
3080 codec->spdif_ctls & 0xff, -1);
3083 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3085 snd_hda_codec_cleanup_stream(codec, nid);
3086 if (codec->slave_dig_outs) {
3088 for (d = codec->slave_dig_outs; *d; d++)
3089 snd_hda_codec_cleanup_stream(codec, *d);
3094 * open the digital out in the exclusive mode
3096 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3097 struct hda_multi_out *mout)
3099 mutex_lock(&codec->spdif_mutex);
3100 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3101 /* already opened as analog dup; reset it once */
3102 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3103 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
3104 mutex_unlock(&codec->spdif_mutex);
3107 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
3109 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3110 struct hda_multi_out *mout,
3111 unsigned int stream_tag,
3112 unsigned int format,
3113 struct snd_pcm_substream *substream)
3115 mutex_lock(&codec->spdif_mutex);
3116 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3117 mutex_unlock(&codec->spdif_mutex);
3120 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
3123 * release the digital out
3125 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3126 struct hda_multi_out *mout)
3128 mutex_lock(&codec->spdif_mutex);
3129 mout->dig_out_used = 0;
3130 mutex_unlock(&codec->spdif_mutex);
3133 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
3136 * set up more restrictions for analog out
3138 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3139 struct hda_multi_out *mout,
3140 struct snd_pcm_substream *substream,
3141 struct hda_pcm_stream *hinfo)
3143 struct snd_pcm_runtime *runtime = substream->runtime;
3144 runtime->hw.channels_max = mout->max_channels;
3145 if (mout->dig_out_nid) {
3146 if (!mout->analog_rates) {
3147 mout->analog_rates = hinfo->rates;
3148 mout->analog_formats = hinfo->formats;
3149 mout->analog_maxbps = hinfo->maxbps;
3151 runtime->hw.rates = mout->analog_rates;
3152 runtime->hw.formats = mout->analog_formats;
3153 hinfo->maxbps = mout->analog_maxbps;
3155 if (!mout->spdif_rates) {
3156 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3158 &mout->spdif_formats,
3159 &mout->spdif_maxbps);
3161 mutex_lock(&codec->spdif_mutex);
3162 if (mout->share_spdif) {
3163 runtime->hw.rates &= mout->spdif_rates;
3164 runtime->hw.formats &= mout->spdif_formats;
3165 if (mout->spdif_maxbps < hinfo->maxbps)
3166 hinfo->maxbps = mout->spdif_maxbps;
3168 mutex_unlock(&codec->spdif_mutex);
3170 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3171 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3173 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
3176 * set up the i/o for analog out
3177 * when the digital out is available, copy the front out to digital out, too.
3179 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3180 struct hda_multi_out *mout,
3181 unsigned int stream_tag,
3182 unsigned int format,
3183 struct snd_pcm_substream *substream)
3185 hda_nid_t *nids = mout->dac_nids;
3186 int chs = substream->runtime->channels;
3189 mutex_lock(&codec->spdif_mutex);
3190 if (mout->dig_out_nid && mout->share_spdif &&
3191 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
3193 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3195 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
3196 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
3197 setup_dig_out_stream(codec, mout->dig_out_nid,
3198 stream_tag, format);
3200 mout->dig_out_used = 0;
3201 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3204 mutex_unlock(&codec->spdif_mutex);
3207 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3209 if (!mout->no_share_stream &&
3210 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
3211 /* headphone out will just decode front left/right (stereo) */
3212 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3214 /* extra outputs copied from front */
3215 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3216 if (!mout->no_share_stream && mout->extra_out_nid[i])
3217 snd_hda_codec_setup_stream(codec,
3218 mout->extra_out_nid[i],
3219 stream_tag, 0, format);
3222 for (i = 1; i < mout->num_dacs; i++) {
3223 if (chs >= (i + 1) * 2) /* independent out */
3224 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3226 else if (!mout->no_share_stream) /* copy front */
3227 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3232 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
3235 * clean up the setting for analog out
3237 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3238 struct hda_multi_out *mout)
3240 hda_nid_t *nids = mout->dac_nids;
3243 for (i = 0; i < mout->num_dacs; i++)
3244 snd_hda_codec_cleanup_stream(codec, nids[i]);
3246 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
3247 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3248 if (mout->extra_out_nid[i])
3249 snd_hda_codec_cleanup_stream(codec,
3250 mout->extra_out_nid[i]);
3251 mutex_lock(&codec->spdif_mutex);
3252 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
3253 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3254 mout->dig_out_used = 0;
3256 mutex_unlock(&codec->spdif_mutex);
3259 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
3262 * Helper for automatic pin configuration
3265 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
3267 for (; *list; list++)
3275 * Sort an associated group of pins according to their sequence numbers.
3277 static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3284 for (i = 0; i < num_pins; i++) {
3285 for (j = i + 1; j < num_pins; j++) {
3286 if (sequences[i] > sequences[j]) {
3288 sequences[i] = sequences[j];
3300 * Parse all pin widgets and store the useful pin nids to cfg
3302 * The number of line-outs or any primary output is stored in line_outs,
3303 * and the corresponding output pins are assigned to line_out_pins[],
3304 * in the order of front, rear, CLFE, side, ...
3306 * If more extra outputs (speaker and headphone) are found, the pins are
3307 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
3308 * is detected, one of speaker of HP pins is assigned as the primary
3309 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3310 * if any analog output exists.
3312 * The analog input pins are assigned to input_pins array.
3313 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3316 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3317 struct auto_pin_cfg *cfg,
3318 hda_nid_t *ignore_nids)
3320 hda_nid_t nid, end_nid;
3321 short seq, assoc_line_out, assoc_speaker;
3322 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3323 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
3324 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
3326 memset(cfg, 0, sizeof(*cfg));
3328 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3329 memset(sequences_speaker, 0, sizeof(sequences_speaker));
3330 memset(sequences_hp, 0, sizeof(sequences_hp));
3331 assoc_line_out = assoc_speaker = 0;
3333 end_nid = codec->start_nid + codec->num_nodes;
3334 for (nid = codec->start_nid; nid < end_nid; nid++) {
3335 unsigned int wid_caps = get_wcaps(codec, nid);
3336 unsigned int wid_type =
3337 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3338 unsigned int def_conf;
3341 /* read all default configuration for pin complex */
3342 if (wid_type != AC_WID_PIN)
3344 /* ignore the given nids (e.g. pc-beep returns error) */
3345 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3348 def_conf = snd_hda_codec_read(codec, nid, 0,
3349 AC_VERB_GET_CONFIG_DEFAULT, 0);
3350 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3352 loc = get_defcfg_location(def_conf);
3353 switch (get_defcfg_device(def_conf)) {
3354 case AC_JACK_LINE_OUT:
3355 seq = get_defcfg_sequence(def_conf);
3356 assoc = get_defcfg_association(def_conf);
3358 if (!(wid_caps & AC_WCAP_STEREO))
3359 if (!cfg->mono_out_pin)
3360 cfg->mono_out_pin = nid;
3363 if (!assoc_line_out)
3364 assoc_line_out = assoc;
3365 else if (assoc_line_out != assoc)
3367 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3369 cfg->line_out_pins[cfg->line_outs] = nid;
3370 sequences_line_out[cfg->line_outs] = seq;
3373 case AC_JACK_SPEAKER:
3374 seq = get_defcfg_sequence(def_conf);
3375 assoc = get_defcfg_association(def_conf);
3378 if (! assoc_speaker)
3379 assoc_speaker = assoc;
3380 else if (assoc_speaker != assoc)
3382 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3384 cfg->speaker_pins[cfg->speaker_outs] = nid;
3385 sequences_speaker[cfg->speaker_outs] = seq;
3386 cfg->speaker_outs++;
3388 case AC_JACK_HP_OUT:
3389 seq = get_defcfg_sequence(def_conf);
3390 assoc = get_defcfg_association(def_conf);
3391 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3393 cfg->hp_pins[cfg->hp_outs] = nid;
3394 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
3397 case AC_JACK_MIC_IN: {
3399 if (loc == AC_JACK_LOC_FRONT) {
3400 preferred = AUTO_PIN_FRONT_MIC;
3403 preferred = AUTO_PIN_MIC;
3404 alt = AUTO_PIN_FRONT_MIC;
3406 if (!cfg->input_pins[preferred])
3407 cfg->input_pins[preferred] = nid;
3408 else if (!cfg->input_pins[alt])
3409 cfg->input_pins[alt] = nid;
3412 case AC_JACK_LINE_IN:
3413 if (loc == AC_JACK_LOC_FRONT)
3414 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3416 cfg->input_pins[AUTO_PIN_LINE] = nid;
3419 cfg->input_pins[AUTO_PIN_CD] = nid;
3422 cfg->input_pins[AUTO_PIN_AUX] = nid;
3424 case AC_JACK_SPDIF_OUT:
3425 case AC_JACK_DIG_OTHER_OUT:
3426 cfg->dig_out_pin = nid;
3427 if (loc == AC_JACK_LOC_HDMI)
3428 cfg->dig_out_type = HDA_PCM_TYPE_HDMI;
3430 cfg->dig_out_type = HDA_PCM_TYPE_SPDIF;
3432 case AC_JACK_SPDIF_IN:
3433 case AC_JACK_DIG_OTHER_IN:
3434 cfg->dig_in_pin = nid;
3435 if (loc == AC_JACK_LOC_HDMI)
3436 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3438 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
3444 * If no line-out is defined but multiple HPs are found,
3445 * some of them might be the real line-outs.
3447 if (!cfg->line_outs && cfg->hp_outs > 1) {
3449 while (i < cfg->hp_outs) {
3450 /* The real HPs should have the sequence 0x0f */
3451 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3455 /* Move it to the line-out table */
3456 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3457 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3460 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3461 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3462 memmove(sequences_hp + i - 1, sequences_hp + i,
3463 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3467 /* sort by sequence */
3468 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3470 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3472 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3475 /* if we have only one mic, make it AUTO_PIN_MIC */
3476 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3477 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3478 cfg->input_pins[AUTO_PIN_MIC] =
3479 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3480 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3482 /* ditto for line-in */
3483 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3484 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3485 cfg->input_pins[AUTO_PIN_LINE] =
3486 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3487 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3491 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3492 * as a primary output
3494 if (!cfg->line_outs) {
3495 if (cfg->speaker_outs) {
3496 cfg->line_outs = cfg->speaker_outs;
3497 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3498 sizeof(cfg->speaker_pins));
3499 cfg->speaker_outs = 0;
3500 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3501 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3502 } else if (cfg->hp_outs) {
3503 cfg->line_outs = cfg->hp_outs;
3504 memcpy(cfg->line_out_pins, cfg->hp_pins,
3505 sizeof(cfg->hp_pins));
3507 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3508 cfg->line_out_type = AUTO_PIN_HP_OUT;
3512 /* Reorder the surround channels
3513 * ALSA sequence is front/surr/clfe/side
3515 * 4-ch: front/surr => OK as it is
3516 * 6-ch: front/clfe/surr
3517 * 8-ch: front/clfe/rear/side|fc
3519 switch (cfg->line_outs) {
3522 nid = cfg->line_out_pins[1];
3523 cfg->line_out_pins[1] = cfg->line_out_pins[2];
3524 cfg->line_out_pins[2] = nid;
3529 * debug prints of the parsed results
3531 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3532 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3533 cfg->line_out_pins[2], cfg->line_out_pins[3],
3534 cfg->line_out_pins[4]);
3535 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3536 cfg->speaker_outs, cfg->speaker_pins[0],
3537 cfg->speaker_pins[1], cfg->speaker_pins[2],
3538 cfg->speaker_pins[3], cfg->speaker_pins[4]);
3539 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3540 cfg->hp_outs, cfg->hp_pins[0],
3541 cfg->hp_pins[1], cfg->hp_pins[2],
3542 cfg->hp_pins[3], cfg->hp_pins[4]);
3543 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
3544 if (cfg->dig_out_pin)
3545 snd_printd(" dig-out=0x%x\n", cfg->dig_out_pin);
3546 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3547 " cd=0x%x, aux=0x%x\n",
3548 cfg->input_pins[AUTO_PIN_MIC],
3549 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3550 cfg->input_pins[AUTO_PIN_LINE],
3551 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3552 cfg->input_pins[AUTO_PIN_CD],
3553 cfg->input_pins[AUTO_PIN_AUX]);
3554 if (cfg->dig_out_pin)
3555 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
3559 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
3561 /* labels for input pins */
3562 const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3563 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3565 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
3574 * snd_hda_suspend - suspend the codecs
3576 * @state: suspsend state
3578 * Returns 0 if successful.
3580 int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3582 struct hda_codec *codec;
3584 list_for_each_entry(codec, &bus->codec_list, list) {
3585 #ifdef CONFIG_SND_HDA_POWER_SAVE
3586 if (!codec->power_on)
3589 hda_call_codec_suspend(codec);
3593 EXPORT_SYMBOL_HDA(snd_hda_suspend);
3596 * snd_hda_resume - resume the codecs
3599 * Returns 0 if successful.
3601 * This fucntion is defined only when POWER_SAVE isn't set.
3602 * In the power-save mode, the codec is resumed dynamically.
3604 int snd_hda_resume(struct hda_bus *bus)
3606 struct hda_codec *codec;
3608 list_for_each_entry(codec, &bus->codec_list, list) {
3609 if (snd_hda_codec_needs_resume(codec))
3610 hda_call_codec_resume(codec);
3614 EXPORT_SYMBOL_HDA(snd_hda_resume);
3615 #endif /* CONFIG_PM */
3621 /* get a new element from the given array
3622 * if it exceeds the pre-allocated array size, re-allocate the array
3624 void *snd_array_new(struct snd_array *array)
3626 if (array->used >= array->alloced) {
3627 int num = array->alloced + array->alloc_align;
3629 if (snd_BUG_ON(num >= 4096))
3631 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
3635 memcpy(nlist, array->list,
3636 array->elem_size * array->alloced);
3639 array->list = nlist;
3640 array->alloced = num;
3642 return snd_array_elem(array, array->used++);
3644 EXPORT_SYMBOL_HDA(snd_array_new);
3646 /* free the given array elements */
3647 void snd_array_free(struct snd_array *array)
3654 EXPORT_SYMBOL_HDA(snd_array_free);
3657 * used by hda_proc.c and hda_eld.c
3659 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3661 static unsigned int rates[] = {
3662 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3663 96000, 176400, 192000, 384000
3667 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3669 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3671 buf[j] = '\0'; /* necessary when j == 0 */
3673 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
3675 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3677 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3680 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3681 if (pcm & (AC_SUPPCM_BITS_8 << i))
3682 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3684 buf[j] = '\0'; /* necessary when j == 0 */
3686 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
3688 MODULE_DESCRIPTION("HDA codec core");
3689 MODULE_LICENSE("GPL");