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
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
38 #include <sound/hda_hwdep.h>
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
44 * vendor / preset table
47 struct hda_vendor_id {
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
55 { 0x1013, "Cirrus Logic" },
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
59 { 0x10ec, "Realtek" },
60 { 0x1102, "Creative" },
64 { 0x11d4, "Analog Devices" },
65 { 0x13f6, "C-Media" },
66 { 0x14f1, "Conexant" },
67 { 0x17e8, "Chrontel" },
69 { 0x1aec, "Wolfson Microelectronics" },
70 { 0x434d, "C-Media" },
72 { 0x8384, "SigmaTel" },
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
97 #ifdef CONFIG_SND_HDA_POWER_SAVE
98 static void hda_power_work(struct work_struct *work);
99 static void hda_keep_power_on(struct hda_codec *codec);
100 #define hda_codec_is_power_on(codec) ((codec)->power_on)
102 static inline void hda_keep_power_on(struct hda_codec *codec) {}
103 #define hda_codec_is_power_on(codec) 1
107 * snd_hda_get_jack_location - Give a location string of the jack
108 * @cfg: pin default config value
110 * Parse the pin default config value and returns the string of the
111 * jack location, e.g. "Rear", "Front", etc.
113 const char *snd_hda_get_jack_location(u32 cfg)
115 static char *bases[7] = {
116 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
118 static unsigned char specials_idx[] = {
123 static char *specials[] = {
124 "Rear Panel", "Drive Bar",
125 "Riser", "HDMI", "ATAPI",
126 "Mobile-In", "Mobile-Out"
129 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
130 if ((cfg & 0x0f) < 7)
131 return bases[cfg & 0x0f];
132 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
133 if (cfg == specials_idx[i])
138 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
141 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
142 * @cfg: pin default config value
144 * Parse the pin default config value and returns the string of the
145 * jack connectivity, i.e. external or internal connection.
147 const char *snd_hda_get_jack_connectivity(u32 cfg)
149 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
151 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
153 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
156 * snd_hda_get_jack_type - Give a type string of the jack
157 * @cfg: pin default config value
159 * Parse the pin default config value and returns the string of the
160 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
162 const char *snd_hda_get_jack_type(u32 cfg)
164 static char *jack_types[16] = {
165 "Line Out", "Speaker", "HP Out", "CD",
166 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
167 "Line In", "Aux", "Mic", "Telephony",
168 "SPDIF In", "Digitial In", "Reserved", "Other"
171 return jack_types[(cfg & AC_DEFCFG_DEVICE)
172 >> AC_DEFCFG_DEVICE_SHIFT];
174 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
177 * Compose a 32bit command word to be sent to the HD-audio controller
179 static inline unsigned int
180 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
181 unsigned int verb, unsigned int parm)
185 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
186 (verb & ~0xfff) || (parm & ~0xffff)) {
187 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
188 codec->addr, direct, nid, verb, parm);
192 val = (u32)codec->addr << 28;
193 val |= (u32)direct << 27;
194 val |= (u32)nid << 20;
201 * Send and receive a verb
203 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
206 struct hda_bus *bus = codec->bus;
215 snd_hda_power_up(codec);
216 mutex_lock(&bus->cmd_mutex);
217 trace_hda_send_cmd(codec, cmd);
218 err = bus->ops.command(bus, cmd);
220 *res = bus->ops.get_response(bus, codec->addr);
221 trace_hda_get_response(codec, *res);
223 mutex_unlock(&bus->cmd_mutex);
224 snd_hda_power_down(codec);
225 if (res && *res == -1 && bus->rirb_error) {
226 if (bus->response_reset) {
227 snd_printd("hda_codec: resetting BUS due to "
228 "fatal communication error\n");
229 trace_hda_bus_reset(bus);
230 bus->ops.bus_reset(bus);
234 /* clear reset-flag when the communication gets recovered */
236 bus->response_reset = 0;
241 * snd_hda_codec_read - send a command and get the response
242 * @codec: the HDA codec
243 * @nid: NID to send the command
244 * @direct: direct flag
245 * @verb: the verb to send
246 * @parm: the parameter for the verb
248 * Send a single command and read the corresponding response.
250 * Returns the obtained response value, or -1 for an error.
252 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
254 unsigned int verb, unsigned int parm)
256 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
258 if (codec_exec_verb(codec, cmd, &res))
262 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
265 * snd_hda_codec_write - send a single command without waiting for response
266 * @codec: the HDA codec
267 * @nid: NID to send the command
268 * @direct: direct flag
269 * @verb: the verb to send
270 * @parm: the parameter for the verb
272 * Send a single command without waiting for response.
274 * Returns 0 if successful, or a negative error code.
276 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
277 unsigned int verb, unsigned int parm)
279 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
281 return codec_exec_verb(codec, cmd,
282 codec->bus->sync_write ? &res : NULL);
284 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
287 * snd_hda_sequence_write - sequence writes
288 * @codec: the HDA codec
289 * @seq: VERB array to send
291 * Send the commands sequentially from the given array.
292 * The array must be terminated with NID=0.
294 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
296 for (; seq->nid; seq++)
297 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
299 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
302 * snd_hda_get_sub_nodes - get the range of sub nodes
303 * @codec: the HDA codec
305 * @start_id: the pointer to store the start NID
307 * Parse the NID and store the start NID of its sub-nodes.
308 * Returns the number of sub-nodes.
310 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
315 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
318 *start_id = (parm >> 16) & 0x7fff;
319 return (int)(parm & 0x7fff);
321 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
323 /* look up the cached results */
324 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
327 for (i = 0; i < array->used; ) {
328 hda_nid_t *p = snd_array_elem(array, i);
337 /* read the connection and add to the cache */
338 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
340 hda_nid_t list[HDA_MAX_CONNECTIONS];
343 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
346 return snd_hda_override_conn_list(codec, nid, len, list);
350 * snd_hda_get_connections - copy connection list
351 * @codec: the HDA codec
353 * @conn_list: connection list array; when NULL, checks only the size
354 * @max_conns: max. number of connections to store
356 * Parses the connection list of the given widget and stores the list
359 * Returns the number of connections, or a negative error code.
361 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
362 hda_nid_t *conn_list, int max_conns)
364 struct snd_array *array = &codec->conn_lists;
370 mutex_lock(&codec->hash_mutex);
372 /* if the connection-list is already cached, read it */
373 p = lookup_conn_list(array, nid);
376 if (conn_list && len > max_conns) {
377 snd_printk(KERN_ERR "hda_codec: "
378 "Too many connections %d for NID 0x%x\n",
380 mutex_unlock(&codec->hash_mutex);
383 if (conn_list && len)
384 memcpy(conn_list, p + 2, len * sizeof(hda_nid_t));
386 mutex_unlock(&codec->hash_mutex);
389 if (snd_BUG_ON(added))
392 len = read_and_add_raw_conns(codec, nid);
398 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
401 * snd_hda_get_raw_connections - copy connection list without cache
402 * @codec: the HDA codec
404 * @conn_list: connection list array
405 * @max_conns: max. number of connections to store
407 * Like snd_hda_get_connections(), copy the connection list but without
408 * checking through the connection-list cache.
409 * Currently called only from hda_proc.c, so not exported.
411 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
412 hda_nid_t *conn_list, int max_conns)
415 int i, conn_len, conns;
416 unsigned int shift, num_elems, mask;
420 if (snd_BUG_ON(!conn_list || max_conns <= 0))
423 wcaps = get_wcaps(codec, nid);
424 if (!(wcaps & AC_WCAP_CONN_LIST) &&
425 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
428 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
429 if (parm & AC_CLIST_LONG) {
438 conn_len = parm & AC_CLIST_LENGTH;
439 mask = (1 << (shift-1)) - 1;
442 return 0; /* no connection */
445 /* single connection */
446 parm = snd_hda_codec_read(codec, nid, 0,
447 AC_VERB_GET_CONNECT_LIST, 0);
448 if (parm == -1 && codec->bus->rirb_error)
450 conn_list[0] = parm & mask;
454 /* multi connection */
457 for (i = 0; i < conn_len; i++) {
461 if (i % num_elems == 0) {
462 parm = snd_hda_codec_read(codec, nid, 0,
463 AC_VERB_GET_CONNECT_LIST, i);
464 if (parm == -1 && codec->bus->rirb_error)
467 range_val = !!(parm & (1 << (shift-1))); /* ranges */
470 snd_printk(KERN_WARNING "hda_codec: "
471 "invalid CONNECT_LIST verb %x[%i]:%x\n",
477 /* ranges between the previous and this one */
478 if (!prev_nid || prev_nid >= val) {
479 snd_printk(KERN_WARNING "hda_codec: "
480 "invalid dep_range_val %x:%x\n",
484 for (n = prev_nid + 1; n <= val; n++) {
485 if (conns >= max_conns) {
486 snd_printk(KERN_ERR "hda_codec: "
487 "Too many connections %d for NID 0x%x\n",
491 conn_list[conns++] = n;
494 if (conns >= max_conns) {
495 snd_printk(KERN_ERR "hda_codec: "
496 "Too many connections %d for NID 0x%x\n",
500 conn_list[conns++] = val;
507 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
509 hda_nid_t *p = snd_array_new(array);
517 * snd_hda_override_conn_list - add/modify the connection-list to cache
518 * @codec: the HDA codec
520 * @len: number of connection list entries
521 * @list: the list of connection entries
523 * Add or modify the given connection-list to the cache. If the corresponding
524 * cache already exists, invalidate it and append a new one.
526 * Returns zero or a negative error code.
528 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
529 const hda_nid_t *list)
531 struct snd_array *array = &codec->conn_lists;
535 mutex_lock(&codec->hash_mutex);
536 p = lookup_conn_list(array, nid);
538 *p = -1; /* invalidate the old entry */
540 old_used = array->used;
541 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
543 for (i = 0; i < len; i++)
544 if (!add_conn_list(array, list[i]))
546 mutex_unlock(&codec->hash_mutex);
550 array->used = old_used;
551 mutex_unlock(&codec->hash_mutex);
554 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
557 * snd_hda_get_conn_index - get the connection index of the given NID
558 * @codec: the HDA codec
559 * @mux: NID containing the list
560 * @nid: NID to select
561 * @recursive: 1 when searching NID recursively, otherwise 0
563 * Parses the connection list of the widget @mux and checks whether the
564 * widget @nid is present. If it is, return the connection index.
565 * Otherwise it returns -1.
567 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
568 hda_nid_t nid, int recursive)
570 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
573 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
574 for (i = 0; i < nums; i++)
580 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
584 for (i = 0; i < nums; i++) {
585 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
586 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
588 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
593 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
596 * snd_hda_queue_unsol_event - add an unsolicited event to queue
598 * @res: unsolicited event (lower 32bit of RIRB entry)
599 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
601 * Adds the given event to the queue. The events are processed in
602 * the workqueue asynchronously. Call this function in the interrupt
603 * hanlder when RIRB receives an unsolicited event.
605 * Returns 0 if successful, or a negative error code.
607 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
609 struct hda_bus_unsolicited *unsol;
612 trace_hda_unsol_event(bus, res, res_ex);
617 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
621 unsol->queue[wp] = res;
622 unsol->queue[wp + 1] = res_ex;
624 queue_work(bus->workq, &unsol->work);
628 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
631 * process queued unsolicited events
633 static void process_unsol_events(struct work_struct *work)
635 struct hda_bus_unsolicited *unsol =
636 container_of(work, struct hda_bus_unsolicited, work);
637 struct hda_bus *bus = unsol->bus;
638 struct hda_codec *codec;
639 unsigned int rp, caddr, res;
641 while (unsol->rp != unsol->wp) {
642 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
645 res = unsol->queue[rp];
646 caddr = unsol->queue[rp + 1];
647 if (!(caddr & (1 << 4))) /* no unsolicited event? */
649 codec = bus->caddr_tbl[caddr & 0x0f];
650 if (codec && codec->patch_ops.unsol_event)
651 codec->patch_ops.unsol_event(codec, res);
656 * initialize unsolicited queue
658 static int init_unsol_queue(struct hda_bus *bus)
660 struct hda_bus_unsolicited *unsol;
662 if (bus->unsol) /* already initialized */
665 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
667 snd_printk(KERN_ERR "hda_codec: "
668 "can't allocate unsolicited queue\n");
671 INIT_WORK(&unsol->work, process_unsol_events);
680 static void snd_hda_codec_free(struct hda_codec *codec);
682 static int snd_hda_bus_free(struct hda_bus *bus)
684 struct hda_codec *codec, *n;
689 flush_workqueue(bus->workq);
692 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
693 snd_hda_codec_free(codec);
695 if (bus->ops.private_free)
696 bus->ops.private_free(bus);
698 destroy_workqueue(bus->workq);
703 static int snd_hda_bus_dev_free(struct snd_device *device)
705 struct hda_bus *bus = device->device_data;
707 return snd_hda_bus_free(bus);
710 #ifdef CONFIG_SND_HDA_HWDEP
711 static int snd_hda_bus_dev_register(struct snd_device *device)
713 struct hda_bus *bus = device->device_data;
714 struct hda_codec *codec;
715 list_for_each_entry(codec, &bus->codec_list, list) {
716 snd_hda_hwdep_add_sysfs(codec);
717 snd_hda_hwdep_add_power_sysfs(codec);
722 #define snd_hda_bus_dev_register NULL
726 * snd_hda_bus_new - create a HDA bus
727 * @card: the card entry
728 * @temp: the template for hda_bus information
729 * @busp: the pointer to store the created bus instance
731 * Returns 0 if successful, or a negative error code.
733 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
734 const struct hda_bus_template *temp,
735 struct hda_bus **busp)
739 static struct snd_device_ops dev_ops = {
740 .dev_register = snd_hda_bus_dev_register,
741 .dev_free = snd_hda_bus_dev_free,
744 if (snd_BUG_ON(!temp))
746 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
752 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
754 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
759 bus->private_data = temp->private_data;
760 bus->pci = temp->pci;
761 bus->modelname = temp->modelname;
762 bus->power_save = temp->power_save;
763 bus->ops = temp->ops;
765 mutex_init(&bus->cmd_mutex);
766 mutex_init(&bus->prepare_mutex);
767 INIT_LIST_HEAD(&bus->codec_list);
769 snprintf(bus->workq_name, sizeof(bus->workq_name),
770 "hd-audio%d", card->number);
771 bus->workq = create_singlethread_workqueue(bus->workq_name);
773 snd_printk(KERN_ERR "cannot create workqueue %s\n",
779 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
781 snd_hda_bus_free(bus);
788 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
790 #ifdef CONFIG_SND_HDA_GENERIC
791 #define is_generic_config(codec) \
792 (codec->modelname && !strcmp(codec->modelname, "generic"))
794 #define is_generic_config(codec) 0
798 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
800 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
804 * find a matching codec preset
806 static const struct hda_codec_preset *
807 find_codec_preset(struct hda_codec *codec)
809 struct hda_codec_preset_list *tbl;
810 const struct hda_codec_preset *preset;
811 int mod_requested = 0;
813 if (is_generic_config(codec))
814 return NULL; /* use the generic parser */
817 mutex_lock(&preset_mutex);
818 list_for_each_entry(tbl, &hda_preset_tables, list) {
819 if (!try_module_get(tbl->owner)) {
820 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
823 for (preset = tbl->preset; preset->id; preset++) {
824 u32 mask = preset->mask;
825 if (preset->afg && preset->afg != codec->afg)
827 if (preset->mfg && preset->mfg != codec->mfg)
831 if (preset->id == (codec->vendor_id & mask) &&
833 preset->rev == codec->revision_id)) {
834 mutex_unlock(&preset_mutex);
835 codec->owner = tbl->owner;
839 module_put(tbl->owner);
841 mutex_unlock(&preset_mutex);
843 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
846 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
849 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
850 (codec->vendor_id >> 16) & 0xffff);
851 request_module(name);
859 * get_codec_name - store the codec name
861 static int get_codec_name(struct hda_codec *codec)
863 const struct hda_vendor_id *c;
864 const char *vendor = NULL;
865 u16 vendor_id = codec->vendor_id >> 16;
868 if (codec->vendor_name)
871 for (c = hda_vendor_ids; c->id; c++) {
872 if (c->id == vendor_id) {
878 sprintf(tmp, "Generic %04x", vendor_id);
881 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
882 if (!codec->vendor_name)
886 if (codec->chip_name)
889 if (codec->preset && codec->preset->name)
890 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
892 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
893 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
895 if (!codec->chip_name)
901 * look for an AFG and MFG nodes
903 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
905 int i, total_nodes, function_id;
908 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
909 for (i = 0; i < total_nodes; i++, nid++) {
910 function_id = snd_hda_param_read(codec, nid,
911 AC_PAR_FUNCTION_TYPE);
912 switch (function_id & 0xff) {
913 case AC_GRP_AUDIO_FUNCTION:
915 codec->afg_function_id = function_id & 0xff;
916 codec->afg_unsol = (function_id >> 8) & 1;
918 case AC_GRP_MODEM_FUNCTION:
920 codec->mfg_function_id = function_id & 0xff;
921 codec->mfg_unsol = (function_id >> 8) & 1;
930 * read widget caps for each widget and store in cache
932 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
937 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
939 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
942 nid = codec->start_nid;
943 for (i = 0; i < codec->num_nodes; i++, nid++)
944 codec->wcaps[i] = snd_hda_param_read(codec, nid,
945 AC_PAR_AUDIO_WIDGET_CAP);
949 /* read all pin default configurations and save codec->init_pins */
950 static int read_pin_defaults(struct hda_codec *codec)
953 hda_nid_t nid = codec->start_nid;
955 for (i = 0; i < codec->num_nodes; i++, nid++) {
956 struct hda_pincfg *pin;
957 unsigned int wcaps = get_wcaps(codec, nid);
958 unsigned int wid_type = get_wcaps_type(wcaps);
959 if (wid_type != AC_WID_PIN)
961 pin = snd_array_new(&codec->init_pins);
965 pin->cfg = snd_hda_codec_read(codec, nid, 0,
966 AC_VERB_GET_CONFIG_DEFAULT, 0);
967 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
968 AC_VERB_GET_PIN_WIDGET_CONTROL,
974 /* look up the given pin config list and return the item matching with NID */
975 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
976 struct snd_array *array,
980 for (i = 0; i < array->used; i++) {
981 struct hda_pincfg *pin = snd_array_elem(array, i);
988 /* write a config value for the given NID */
989 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
993 for (i = 0; i < 4; i++) {
994 snd_hda_codec_write(codec, nid, 0,
995 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1001 /* set the current pin config value for the given NID.
1002 * the value is cached, and read via snd_hda_codec_get_pincfg()
1004 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1005 hda_nid_t nid, unsigned int cfg)
1007 struct hda_pincfg *pin;
1008 unsigned int oldcfg;
1010 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1013 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
1014 pin = look_up_pincfg(codec, list, nid);
1016 pin = snd_array_new(list);
1023 /* change only when needed; e.g. if the pincfg is already present
1024 * in user_pins[], don't write it
1026 cfg = snd_hda_codec_get_pincfg(codec, nid);
1028 set_pincfg(codec, nid, cfg);
1033 * snd_hda_codec_set_pincfg - Override a pin default configuration
1034 * @codec: the HDA codec
1035 * @nid: NID to set the pin config
1036 * @cfg: the pin default config value
1038 * Override a pin default configuration value in the cache.
1039 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1040 * priority than the real hardware value.
1042 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1043 hda_nid_t nid, unsigned int cfg)
1045 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1047 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1050 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1051 * @codec: the HDA codec
1052 * @nid: NID to get the pin config
1054 * Get the current pin config value of the given pin NID.
1055 * If the pincfg value is cached or overridden via sysfs or driver,
1056 * returns the cached value.
1058 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1060 struct hda_pincfg *pin;
1062 #ifdef CONFIG_SND_HDA_HWDEP
1063 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1067 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1070 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1075 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1077 /* restore all current pin configs */
1078 static void restore_pincfgs(struct hda_codec *codec)
1081 for (i = 0; i < codec->init_pins.used; i++) {
1082 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1083 set_pincfg(codec, pin->nid,
1084 snd_hda_codec_get_pincfg(codec, pin->nid));
1089 * snd_hda_shutup_pins - Shut up all pins
1090 * @codec: the HDA codec
1092 * Clear all pin controls to shup up before suspend for avoiding click noise.
1093 * The controls aren't cached so that they can be resumed properly.
1095 void snd_hda_shutup_pins(struct hda_codec *codec)
1098 /* don't shut up pins when unloading the driver; otherwise it breaks
1099 * the default pin setup at the next load of the driver
1101 if (codec->bus->shutdown)
1103 for (i = 0; i < codec->init_pins.used; i++) {
1104 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1105 /* use read here for syncing after issuing each verb */
1106 snd_hda_codec_read(codec, pin->nid, 0,
1107 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1109 codec->pins_shutup = 1;
1111 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1114 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1115 static void restore_shutup_pins(struct hda_codec *codec)
1118 if (!codec->pins_shutup)
1120 if (codec->bus->shutdown)
1122 for (i = 0; i < codec->init_pins.used; i++) {
1123 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1124 snd_hda_codec_write(codec, pin->nid, 0,
1125 AC_VERB_SET_PIN_WIDGET_CONTROL,
1128 codec->pins_shutup = 0;
1132 static void init_hda_cache(struct hda_cache_rec *cache,
1133 unsigned int record_size);
1134 static void free_hda_cache(struct hda_cache_rec *cache);
1136 /* restore the initial pin cfgs and release all pincfg lists */
1137 static void restore_init_pincfgs(struct hda_codec *codec)
1139 /* first free driver_pins and user_pins, then call restore_pincfg
1140 * so that only the values in init_pins are restored
1142 snd_array_free(&codec->driver_pins);
1143 #ifdef CONFIG_SND_HDA_HWDEP
1144 snd_array_free(&codec->user_pins);
1146 restore_pincfgs(codec);
1147 snd_array_free(&codec->init_pins);
1151 * audio-converter setup caches
1153 struct hda_cvt_setup {
1158 unsigned char active; /* cvt is currently used */
1159 unsigned char dirty; /* setups should be cleared */
1162 /* get or create a cache entry for the given audio converter NID */
1163 static struct hda_cvt_setup *
1164 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1166 struct hda_cvt_setup *p;
1169 for (i = 0; i < codec->cvt_setups.used; i++) {
1170 p = snd_array_elem(&codec->cvt_setups, i);
1174 p = snd_array_new(&codec->cvt_setups);
1183 static void snd_hda_codec_free(struct hda_codec *codec)
1187 snd_hda_jack_tbl_clear(codec);
1188 restore_init_pincfgs(codec);
1189 #ifdef CONFIG_SND_HDA_POWER_SAVE
1190 cancel_delayed_work(&codec->power_work);
1191 flush_workqueue(codec->bus->workq);
1193 list_del(&codec->list);
1194 snd_array_free(&codec->mixers);
1195 snd_array_free(&codec->nids);
1196 snd_array_free(&codec->cvt_setups);
1197 snd_array_free(&codec->conn_lists);
1198 snd_array_free(&codec->spdif_out);
1199 codec->bus->caddr_tbl[codec->addr] = NULL;
1200 if (codec->patch_ops.free)
1201 codec->patch_ops.free(codec);
1202 module_put(codec->owner);
1203 free_hda_cache(&codec->amp_cache);
1204 free_hda_cache(&codec->cmd_cache);
1205 kfree(codec->vendor_name);
1206 kfree(codec->chip_name);
1207 kfree(codec->modelname);
1208 kfree(codec->wcaps);
1212 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1213 unsigned int power_state);
1216 * snd_hda_codec_new - create a HDA codec
1217 * @bus: the bus to assign
1218 * @codec_addr: the codec address
1219 * @codecp: the pointer to store the generated codec
1221 * Returns 0 if successful, or a negative error code.
1223 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1224 unsigned int codec_addr,
1225 struct hda_codec **codecp)
1227 struct hda_codec *codec;
1231 if (snd_BUG_ON(!bus))
1233 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1236 if (bus->caddr_tbl[codec_addr]) {
1237 snd_printk(KERN_ERR "hda_codec: "
1238 "address 0x%x is already occupied\n", codec_addr);
1242 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1243 if (codec == NULL) {
1244 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1249 codec->addr = codec_addr;
1250 mutex_init(&codec->spdif_mutex);
1251 mutex_init(&codec->control_mutex);
1252 mutex_init(&codec->hash_mutex);
1253 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1254 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1255 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1256 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1257 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1258 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1259 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1260 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1261 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1263 #ifdef CONFIG_SND_HDA_POWER_SAVE
1264 spin_lock_init(&codec->power_lock);
1265 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1266 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1267 * the caller has to power down appropriatley after initialization
1270 hda_keep_power_on(codec);
1273 if (codec->bus->modelname) {
1274 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1275 if (!codec->modelname) {
1276 snd_hda_codec_free(codec);
1281 list_add_tail(&codec->list, &bus->codec_list);
1282 bus->caddr_tbl[codec_addr] = codec;
1284 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1286 if (codec->vendor_id == -1)
1287 /* read again, hopefully the access method was corrected
1288 * in the last read...
1290 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1292 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1293 AC_PAR_SUBSYSTEM_ID);
1294 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1297 setup_fg_nodes(codec);
1298 if (!codec->afg && !codec->mfg) {
1299 snd_printdd("hda_codec: no AFG or MFG node found\n");
1304 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1306 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1309 err = read_pin_defaults(codec);
1313 if (!codec->subsystem_id) {
1314 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1315 codec->subsystem_id =
1316 snd_hda_codec_read(codec, nid, 0,
1317 AC_VERB_GET_SUBSYSTEM_ID, 0);
1320 /* power-up all before initialization */
1321 hda_set_power_state(codec,
1322 codec->afg ? codec->afg : codec->mfg,
1325 snd_hda_codec_proc_new(codec);
1327 snd_hda_create_hwdep(codec);
1329 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1330 codec->subsystem_id, codec->revision_id);
1331 snd_component_add(codec->bus->card, component);
1338 snd_hda_codec_free(codec);
1341 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1344 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1345 * @codec: the HDA codec
1347 * Start parsing of the given codec tree and (re-)initialize the whole
1350 * Returns 0 if successful or a negative error code.
1352 int snd_hda_codec_configure(struct hda_codec *codec)
1356 codec->preset = find_codec_preset(codec);
1357 if (!codec->vendor_name || !codec->chip_name) {
1358 err = get_codec_name(codec);
1363 if (is_generic_config(codec)) {
1364 err = snd_hda_parse_generic_codec(codec);
1367 if (codec->preset && codec->preset->patch) {
1368 err = codec->preset->patch(codec);
1372 /* call the default parser */
1373 err = snd_hda_parse_generic_codec(codec);
1375 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1378 if (!err && codec->patch_ops.unsol_event)
1379 err = init_unsol_queue(codec->bus);
1380 /* audio codec should override the mixer name */
1381 if (!err && (codec->afg || !*codec->bus->card->mixername))
1382 snprintf(codec->bus->card->mixername,
1383 sizeof(codec->bus->card->mixername),
1384 "%s %s", codec->vendor_name, codec->chip_name);
1387 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1390 * snd_hda_codec_setup_stream - set up the codec for streaming
1391 * @codec: the CODEC to set up
1392 * @nid: the NID to set up
1393 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1394 * @channel_id: channel id to pass, zero based.
1395 * @format: stream format.
1397 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1399 int channel_id, int format)
1401 struct hda_codec *c;
1402 struct hda_cvt_setup *p;
1403 unsigned int oldval, newval;
1410 snd_printdd("hda_codec_setup_stream: "
1411 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1412 nid, stream_tag, channel_id, format);
1413 p = get_hda_cvt_setup(codec, nid);
1416 /* update the stream-id if changed */
1417 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1418 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1419 newval = (stream_tag << 4) | channel_id;
1420 if (oldval != newval)
1421 snd_hda_codec_write(codec, nid, 0,
1422 AC_VERB_SET_CHANNEL_STREAMID,
1424 p->stream_tag = stream_tag;
1425 p->channel_id = channel_id;
1427 /* update the format-id if changed */
1428 if (p->format_id != format) {
1429 oldval = snd_hda_codec_read(codec, nid, 0,
1430 AC_VERB_GET_STREAM_FORMAT, 0);
1431 if (oldval != format) {
1433 snd_hda_codec_write(codec, nid, 0,
1434 AC_VERB_SET_STREAM_FORMAT,
1437 p->format_id = format;
1442 /* make other inactive cvts with the same stream-tag dirty */
1443 type = get_wcaps_type(get_wcaps(codec, nid));
1444 list_for_each_entry(c, &codec->bus->codec_list, list) {
1445 for (i = 0; i < c->cvt_setups.used; i++) {
1446 p = snd_array_elem(&c->cvt_setups, i);
1447 if (!p->active && p->stream_tag == stream_tag &&
1448 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1453 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1455 static void really_cleanup_stream(struct hda_codec *codec,
1456 struct hda_cvt_setup *q);
1459 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1460 * @codec: the CODEC to clean up
1461 * @nid: the NID to clean up
1462 * @do_now: really clean up the stream instead of clearing the active flag
1464 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1467 struct hda_cvt_setup *p;
1472 if (codec->no_sticky_stream)
1475 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1476 p = get_hda_cvt_setup(codec, nid);
1478 /* here we just clear the active flag when do_now isn't set;
1479 * actual clean-ups will be done later in
1480 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1483 really_cleanup_stream(codec, p);
1488 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1490 static void really_cleanup_stream(struct hda_codec *codec,
1491 struct hda_cvt_setup *q)
1493 hda_nid_t nid = q->nid;
1494 if (q->stream_tag || q->channel_id)
1495 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1497 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1499 memset(q, 0, sizeof(*q));
1503 /* clean up the all conflicting obsolete streams */
1504 static void purify_inactive_streams(struct hda_codec *codec)
1506 struct hda_codec *c;
1509 list_for_each_entry(c, &codec->bus->codec_list, list) {
1510 for (i = 0; i < c->cvt_setups.used; i++) {
1511 struct hda_cvt_setup *p;
1512 p = snd_array_elem(&c->cvt_setups, i);
1514 really_cleanup_stream(c, p);
1520 /* clean up all streams; called from suspend */
1521 static void hda_cleanup_all_streams(struct hda_codec *codec)
1525 for (i = 0; i < codec->cvt_setups.used; i++) {
1526 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1528 really_cleanup_stream(codec, p);
1534 * amp access functions
1537 /* FIXME: more better hash key? */
1538 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1539 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1540 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1541 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1542 #define INFO_AMP_CAPS (1<<0)
1543 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1545 /* initialize the hash table */
1546 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1547 unsigned int record_size)
1549 memset(cache, 0, sizeof(*cache));
1550 memset(cache->hash, 0xff, sizeof(cache->hash));
1551 snd_array_init(&cache->buf, record_size, 64);
1554 static void free_hda_cache(struct hda_cache_rec *cache)
1556 snd_array_free(&cache->buf);
1559 /* query the hash. allocate an entry if not found. */
1560 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1562 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1563 u16 cur = cache->hash[idx];
1564 struct hda_cache_head *info;
1566 while (cur != 0xffff) {
1567 info = snd_array_elem(&cache->buf, cur);
1568 if (info->key == key)
1575 /* query the hash. allocate an entry if not found. */
1576 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1579 struct hda_cache_head *info = get_hash(cache, key);
1582 /* add a new hash entry */
1583 info = snd_array_new(&cache->buf);
1586 cur = snd_array_index(&cache->buf, info);
1589 idx = key % (u16)ARRAY_SIZE(cache->hash);
1590 info->next = cache->hash[idx];
1591 cache->hash[idx] = cur;
1596 /* query and allocate an amp hash entry */
1597 static inline struct hda_amp_info *
1598 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1600 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1603 /* overwrite the value with the key in the caps hash */
1604 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1606 struct hda_amp_info *info;
1608 mutex_lock(&codec->hash_mutex);
1609 info = get_alloc_amp_hash(codec, key);
1611 mutex_unlock(&codec->hash_mutex);
1614 info->amp_caps = val;
1615 info->head.val |= INFO_AMP_CAPS;
1616 mutex_unlock(&codec->hash_mutex);
1620 /* query the value from the caps hash; if not found, fetch the current
1621 * value from the given function and store in the hash
1624 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1625 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1627 struct hda_amp_info *info;
1630 mutex_lock(&codec->hash_mutex);
1631 info = get_alloc_amp_hash(codec, key);
1633 mutex_unlock(&codec->hash_mutex);
1636 if (!(info->head.val & INFO_AMP_CAPS)) {
1637 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1638 val = func(codec, nid, dir);
1639 write_caps_hash(codec, key, val);
1641 val = info->amp_caps;
1642 mutex_unlock(&codec->hash_mutex);
1647 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1650 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1652 return snd_hda_param_read(codec, nid,
1653 direction == HDA_OUTPUT ?
1654 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1658 * query_amp_caps - query AMP capabilities
1659 * @codec: the HD-auio codec
1660 * @nid: the NID to query
1661 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1663 * Query AMP capabilities for the given widget and direction.
1664 * Returns the obtained capability bits.
1666 * When cap bits have been already read, this doesn't read again but
1667 * returns the cached value.
1669 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1671 return query_caps_hash(codec, nid, direction,
1672 HDA_HASH_KEY(nid, direction, 0),
1675 EXPORT_SYMBOL_HDA(query_amp_caps);
1678 * snd_hda_override_amp_caps - Override the AMP capabilities
1679 * @codec: the CODEC to clean up
1680 * @nid: the NID to clean up
1681 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1682 * @caps: the capability bits to set
1684 * Override the cached AMP caps bits value by the given one.
1685 * This function is useful if the driver needs to adjust the AMP ranges,
1686 * e.g. limit to 0dB, etc.
1688 * Returns zero if successful or a negative error code.
1690 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1693 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1695 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1697 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1700 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1704 * snd_hda_query_pin_caps - Query PIN capabilities
1705 * @codec: the HD-auio codec
1706 * @nid: the NID to query
1708 * Query PIN capabilities for the given widget.
1709 * Returns the obtained capability bits.
1711 * When cap bits have been already read, this doesn't read again but
1712 * returns the cached value.
1714 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1716 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1719 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1722 * snd_hda_override_pin_caps - Override the pin capabilities
1724 * @nid: the NID to override
1725 * @caps: the capability bits to set
1727 * Override the cached PIN capabilitiy bits value by the given one.
1729 * Returns zero if successful or a negative error code.
1731 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1734 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1736 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1738 /* read or sync the hash value with the current value;
1739 * call within hash_mutex
1741 static struct hda_amp_info *
1742 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1743 int direction, int index)
1745 struct hda_amp_info *info;
1746 unsigned int parm, val = 0;
1747 bool val_read = false;
1750 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1753 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1755 mutex_unlock(&codec->hash_mutex);
1756 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1757 parm |= direction == HDA_OUTPUT ?
1758 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1760 val = snd_hda_codec_read(codec, nid, 0,
1761 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1764 mutex_lock(&codec->hash_mutex);
1767 info->vol[ch] = val;
1768 info->head.val |= INFO_AMP_VOL(ch);
1774 * write the current volume in info to the h/w
1776 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1777 hda_nid_t nid, int ch, int direction, int index,
1782 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1783 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1784 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1785 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1786 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1787 ; /* set the zero value as a fake mute */
1790 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1794 * snd_hda_codec_amp_read - Read AMP value
1795 * @codec: HD-audio codec
1796 * @nid: NID to read the AMP value
1797 * @ch: channel (left=0 or right=1)
1798 * @direction: #HDA_INPUT or #HDA_OUTPUT
1799 * @index: the index value (only for input direction)
1801 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1803 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1804 int direction, int index)
1806 struct hda_amp_info *info;
1807 unsigned int val = 0;
1809 mutex_lock(&codec->hash_mutex);
1810 info = update_amp_hash(codec, nid, ch, direction, index);
1812 val = info->vol[ch];
1813 mutex_unlock(&codec->hash_mutex);
1816 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1819 * snd_hda_codec_amp_update - update the AMP value
1820 * @codec: HD-audio codec
1821 * @nid: NID to read the AMP value
1822 * @ch: channel (left=0 or right=1)
1823 * @direction: #HDA_INPUT or #HDA_OUTPUT
1824 * @idx: the index value (only for input direction)
1825 * @mask: bit mask to set
1826 * @val: the bits value to set
1828 * Update the AMP value with a bit mask.
1829 * Returns 0 if the value is unchanged, 1 if changed.
1831 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1832 int direction, int idx, int mask, int val)
1834 struct hda_amp_info *info;
1836 if (snd_BUG_ON(mask & ~0xff))
1840 mutex_lock(&codec->hash_mutex);
1841 info = update_amp_hash(codec, nid, ch, direction, idx);
1843 mutex_unlock(&codec->hash_mutex);
1846 val |= info->vol[ch] & ~mask;
1847 if (info->vol[ch] == val) {
1848 mutex_unlock(&codec->hash_mutex);
1851 info->vol[ch] = val;
1852 mutex_unlock(&codec->hash_mutex);
1853 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1856 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1859 * snd_hda_codec_amp_stereo - update the AMP stereo values
1860 * @codec: HD-audio codec
1861 * @nid: NID to read the AMP value
1862 * @direction: #HDA_INPUT or #HDA_OUTPUT
1863 * @idx: the index value (only for input direction)
1864 * @mask: bit mask to set
1865 * @val: the bits value to set
1867 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1868 * stereo widget with the same mask and value.
1870 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1871 int direction, int idx, int mask, int val)
1875 if (snd_BUG_ON(mask & ~0xff))
1877 for (ch = 0; ch < 2; ch++)
1878 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1882 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1886 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1887 * @codec: HD-audio codec
1889 * Resume the all amp commands from the cache.
1891 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1893 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1896 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1897 u32 key = buffer->head.key;
1899 unsigned int idx, dir, ch;
1903 idx = (key >> 16) & 0xff;
1904 dir = (key >> 24) & 0xff;
1905 for (ch = 0; ch < 2; ch++) {
1906 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1908 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1913 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1914 #endif /* CONFIG_PM */
1916 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1919 u32 caps = query_amp_caps(codec, nid, dir);
1921 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1928 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1930 * The control element is supposed to have the private_value field
1931 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1933 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1934 struct snd_ctl_elem_info *uinfo)
1936 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1937 u16 nid = get_amp_nid(kcontrol);
1938 u8 chs = get_amp_channels(kcontrol);
1939 int dir = get_amp_direction(kcontrol);
1940 unsigned int ofs = get_amp_offset(kcontrol);
1942 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1943 uinfo->count = chs == 3 ? 2 : 1;
1944 uinfo->value.integer.min = 0;
1945 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1946 if (!uinfo->value.integer.max) {
1947 printk(KERN_WARNING "hda_codec: "
1948 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1954 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1957 static inline unsigned int
1958 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1959 int ch, int dir, int idx, unsigned int ofs)
1962 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1963 val &= HDA_AMP_VOLMASK;
1972 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1973 int ch, int dir, int idx, unsigned int ofs,
1976 unsigned int maxval;
1980 /* ofs = 0: raw max value */
1981 maxval = get_amp_max_value(codec, nid, dir, 0);
1984 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1985 HDA_AMP_VOLMASK, val);
1989 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1991 * The control element is supposed to have the private_value field
1992 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1994 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1995 struct snd_ctl_elem_value *ucontrol)
1997 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1998 hda_nid_t nid = get_amp_nid(kcontrol);
1999 int chs = get_amp_channels(kcontrol);
2000 int dir = get_amp_direction(kcontrol);
2001 int idx = get_amp_index(kcontrol);
2002 unsigned int ofs = get_amp_offset(kcontrol);
2003 long *valp = ucontrol->value.integer.value;
2006 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2008 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2011 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2014 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2016 * The control element is supposed to have the private_value field
2017 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2019 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2020 struct snd_ctl_elem_value *ucontrol)
2022 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2023 hda_nid_t nid = get_amp_nid(kcontrol);
2024 int chs = get_amp_channels(kcontrol);
2025 int dir = get_amp_direction(kcontrol);
2026 int idx = get_amp_index(kcontrol);
2027 unsigned int ofs = get_amp_offset(kcontrol);
2028 long *valp = ucontrol->value.integer.value;
2031 snd_hda_power_up(codec);
2033 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2037 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2038 snd_hda_power_down(codec);
2041 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2044 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2046 * The control element is supposed to have the private_value field
2047 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2049 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2050 unsigned int size, unsigned int __user *_tlv)
2052 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2053 hda_nid_t nid = get_amp_nid(kcontrol);
2054 int dir = get_amp_direction(kcontrol);
2055 unsigned int ofs = get_amp_offset(kcontrol);
2056 bool min_mute = get_amp_min_mute(kcontrol);
2057 u32 caps, val1, val2;
2059 if (size < 4 * sizeof(unsigned int))
2061 caps = query_amp_caps(codec, nid, dir);
2062 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2063 val2 = (val2 + 1) * 25;
2064 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2066 val1 = ((int)val1) * ((int)val2);
2067 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2068 val2 |= TLV_DB_SCALE_MUTE;
2069 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2071 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2073 if (put_user(val1, _tlv + 2))
2075 if (put_user(val2, _tlv + 3))
2079 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2082 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2083 * @codec: HD-audio codec
2084 * @nid: NID of a reference widget
2085 * @dir: #HDA_INPUT or #HDA_OUTPUT
2086 * @tlv: TLV data to be stored, at least 4 elements
2088 * Set (static) TLV data for a virtual master volume using the AMP caps
2089 * obtained from the reference NID.
2090 * The volume range is recalculated as if the max volume is 0dB.
2092 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2098 caps = query_amp_caps(codec, nid, dir);
2099 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2100 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2101 step = (step + 1) * 25;
2102 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2103 tlv[1] = 2 * sizeof(unsigned int);
2104 tlv[2] = -nums * step;
2107 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2109 /* find a mixer control element with the given name */
2110 static struct snd_kcontrol *
2111 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2112 const char *name, int idx)
2114 struct snd_ctl_elem_id id;
2115 memset(&id, 0, sizeof(id));
2116 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2118 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2120 strcpy(id.name, name);
2121 return snd_ctl_find_id(codec->bus->card, &id);
2125 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2126 * @codec: HD-audio codec
2127 * @name: ctl id name string
2129 * Get the control element with the given id string and IFACE_MIXER.
2131 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2134 return _snd_hda_find_mixer_ctl(codec, name, 0);
2136 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2138 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2141 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2142 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2149 * snd_hda_ctl_add - Add a control element and assign to the codec
2150 * @codec: HD-audio codec
2151 * @nid: corresponding NID (optional)
2152 * @kctl: the control element to assign
2154 * Add the given control element to an array inside the codec instance.
2155 * All control elements belonging to a codec are supposed to be added
2156 * by this function so that a proper clean-up works at the free or
2157 * reconfiguration time.
2159 * If non-zero @nid is passed, the NID is assigned to the control element.
2160 * The assignment is shown in the codec proc file.
2162 * snd_hda_ctl_add() checks the control subdev id field whether
2163 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2164 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2165 * specifies if kctl->private_value is a HDA amplifier value.
2167 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2168 struct snd_kcontrol *kctl)
2171 unsigned short flags = 0;
2172 struct hda_nid_item *item;
2174 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2175 flags |= HDA_NID_ITEM_AMP;
2177 nid = get_amp_nid_(kctl->private_value);
2179 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2180 nid = kctl->id.subdevice & 0xffff;
2181 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2182 kctl->id.subdevice = 0;
2183 err = snd_ctl_add(codec->bus->card, kctl);
2186 item = snd_array_new(&codec->mixers);
2191 item->flags = flags;
2194 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2197 * snd_hda_add_nid - Assign a NID to a control element
2198 * @codec: HD-audio codec
2199 * @nid: corresponding NID (optional)
2200 * @kctl: the control element to assign
2201 * @index: index to kctl
2203 * Add the given control element to an array inside the codec instance.
2204 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2205 * NID:KCTL mapping - for example "Capture Source" selector.
2207 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2208 unsigned int index, hda_nid_t nid)
2210 struct hda_nid_item *item;
2213 item = snd_array_new(&codec->nids);
2217 item->index = index;
2221 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2222 kctl->id.name, kctl->id.index, index);
2225 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2228 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2229 * @codec: HD-audio codec
2231 void snd_hda_ctls_clear(struct hda_codec *codec)
2234 struct hda_nid_item *items = codec->mixers.list;
2235 for (i = 0; i < codec->mixers.used; i++)
2236 snd_ctl_remove(codec->bus->card, items[i].kctl);
2237 snd_array_free(&codec->mixers);
2238 snd_array_free(&codec->nids);
2241 /* pseudo device locking
2242 * toggle card->shutdown to allow/disallow the device access (as a hack)
2244 int snd_hda_lock_devices(struct hda_bus *bus)
2246 struct snd_card *card = bus->card;
2247 struct hda_codec *codec;
2249 spin_lock(&card->files_lock);
2253 if (!list_empty(&card->ctl_files))
2256 list_for_each_entry(codec, &bus->codec_list, list) {
2258 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2259 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2262 if (cpcm->pcm->streams[0].substream_opened ||
2263 cpcm->pcm->streams[1].substream_opened)
2267 spin_unlock(&card->files_lock);
2273 spin_unlock(&card->files_lock);
2276 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2278 void snd_hda_unlock_devices(struct hda_bus *bus)
2280 struct snd_card *card = bus->card;
2283 spin_lock(&card->files_lock);
2285 spin_unlock(&card->files_lock);
2287 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2290 * snd_hda_codec_reset - Clear all objects assigned to the codec
2291 * @codec: HD-audio codec
2293 * This frees the all PCM and control elements assigned to the codec, and
2294 * clears the caches and restores the pin default configurations.
2296 * When a device is being used, it returns -EBSY. If successfully freed,
2299 int snd_hda_codec_reset(struct hda_codec *codec)
2301 struct hda_bus *bus = codec->bus;
2302 struct snd_card *card = bus->card;
2305 if (snd_hda_lock_devices(bus) < 0)
2308 /* OK, let it free */
2310 #ifdef CONFIG_SND_HDA_POWER_SAVE
2311 cancel_delayed_work_sync(&codec->power_work);
2312 codec->power_on = 0;
2313 codec->power_transition = 0;
2314 codec->power_jiffies = jiffies;
2315 flush_workqueue(bus->workq);
2317 snd_hda_ctls_clear(codec);
2319 for (i = 0; i < codec->num_pcms; i++) {
2320 if (codec->pcm_info[i].pcm) {
2321 snd_device_free(card, codec->pcm_info[i].pcm);
2322 clear_bit(codec->pcm_info[i].device,
2326 if (codec->patch_ops.free)
2327 codec->patch_ops.free(codec);
2328 snd_hda_jack_tbl_clear(codec);
2329 codec->proc_widget_hook = NULL;
2331 free_hda_cache(&codec->amp_cache);
2332 free_hda_cache(&codec->cmd_cache);
2333 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2334 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2335 /* free only driver_pins so that init_pins + user_pins are restored */
2336 snd_array_free(&codec->driver_pins);
2337 restore_pincfgs(codec);
2338 snd_array_free(&codec->cvt_setups);
2339 snd_array_free(&codec->spdif_out);
2340 codec->num_pcms = 0;
2341 codec->pcm_info = NULL;
2342 codec->preset = NULL;
2343 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2344 codec->slave_dig_outs = NULL;
2345 codec->spdif_status_reset = 0;
2346 module_put(codec->owner);
2347 codec->owner = NULL;
2349 /* allow device access again */
2350 snd_hda_unlock_devices(bus);
2354 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2356 /* apply the function to all matching slave ctls in the mixer list */
2357 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2358 const char *suffix, map_slave_func_t func, void *data)
2360 struct hda_nid_item *items;
2361 const char * const *s;
2364 items = codec->mixers.list;
2365 for (i = 0; i < codec->mixers.used; i++) {
2366 struct snd_kcontrol *sctl = items[i].kctl;
2367 if (!sctl || !sctl->id.name ||
2368 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2370 for (s = slaves; *s; s++) {
2371 char tmpname[sizeof(sctl->id.name)];
2372 const char *name = *s;
2374 snprintf(tmpname, sizeof(tmpname), "%s %s",
2378 if (!strcmp(sctl->id.name, name)) {
2379 err = func(data, sctl);
2389 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2394 /* guess the value corresponding to 0dB */
2395 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2398 const int *tlv = NULL;
2401 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2402 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2403 mm_segment_t fs = get_fs();
2405 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2408 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2410 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2411 val = -tlv[2] / tlv[3];
2415 /* call kctl->put with the given value(s) */
2416 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2418 struct snd_ctl_elem_value *ucontrol;
2419 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2422 ucontrol->value.integer.value[0] = val;
2423 ucontrol->value.integer.value[1] = val;
2424 kctl->put(kctl, ucontrol);
2429 /* initialize the slave volume with 0dB */
2430 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2432 int offset = get_kctl_0dB_offset(slave);
2434 put_kctl_with_value(slave, offset);
2438 /* unmute the slave */
2439 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2441 return put_kctl_with_value(slave, 1);
2445 * snd_hda_add_vmaster - create a virtual master control and add slaves
2446 * @codec: HD-audio codec
2447 * @name: vmaster control name
2448 * @tlv: TLV data (optional)
2449 * @slaves: slave control names (optional)
2450 * @suffix: suffix string to each slave name (optional)
2451 * @init_slave_vol: initialize slaves to unmute/0dB
2452 * @ctl_ret: store the vmaster kcontrol in return
2454 * Create a virtual master control with the given name. The TLV data
2455 * must be either NULL or a valid data.
2457 * @slaves is a NULL-terminated array of strings, each of which is a
2458 * slave control name. All controls with these names are assigned to
2459 * the new virtual master control.
2461 * This function returns zero if successful or a negative error code.
2463 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2464 unsigned int *tlv, const char * const *slaves,
2465 const char *suffix, bool init_slave_vol,
2466 struct snd_kcontrol **ctl_ret)
2468 struct snd_kcontrol *kctl;
2474 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2476 snd_printdd("No slave found for %s\n", name);
2479 kctl = snd_ctl_make_virtual_master(name, tlv);
2482 err = snd_hda_ctl_add(codec, 0, kctl);
2486 err = map_slaves(codec, slaves, suffix,
2487 (map_slave_func_t)snd_ctl_add_slave, kctl);
2491 /* init with master mute & zero volume */
2492 put_kctl_with_value(kctl, 0);
2494 map_slaves(codec, slaves, suffix,
2495 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2501 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2504 * mute-LED control using vmaster
2506 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2507 struct snd_ctl_elem_info *uinfo)
2509 static const char * const texts[] = {
2510 "Off", "On", "Follow Master"
2514 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2516 uinfo->value.enumerated.items = 3;
2517 index = uinfo->value.enumerated.item;
2520 strcpy(uinfo->value.enumerated.name, texts[index]);
2524 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2525 struct snd_ctl_elem_value *ucontrol)
2527 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2528 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2532 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2533 struct snd_ctl_elem_value *ucontrol)
2535 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2536 unsigned int old_mode = hook->mute_mode;
2538 hook->mute_mode = ucontrol->value.enumerated.item[0];
2539 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2540 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2541 if (old_mode == hook->mute_mode)
2543 snd_hda_sync_vmaster_hook(hook);
2547 static struct snd_kcontrol_new vmaster_mute_mode = {
2548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2549 .name = "Mute-LED Mode",
2550 .info = vmaster_mute_mode_info,
2551 .get = vmaster_mute_mode_get,
2552 .put = vmaster_mute_mode_put,
2556 * Add a mute-LED hook with the given vmaster switch kctl
2557 * "Mute-LED Mode" control is automatically created and associated with
2560 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2561 struct hda_vmaster_mute_hook *hook,
2562 bool expose_enum_ctl)
2564 struct snd_kcontrol *kctl;
2566 if (!hook->hook || !hook->sw_kctl)
2568 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2569 hook->codec = codec;
2570 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2571 if (!expose_enum_ctl)
2573 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2576 return snd_hda_ctl_add(codec, 0, kctl);
2578 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2581 * Call the hook with the current value for synchronization
2582 * Should be called in init callback
2584 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2586 if (!hook->hook || !hook->codec)
2588 switch (hook->mute_mode) {
2589 case HDA_VMUTE_FOLLOW_MASTER:
2590 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2593 hook->hook(hook->codec, hook->mute_mode);
2597 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2601 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2603 * The control element is supposed to have the private_value field
2604 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2606 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2607 struct snd_ctl_elem_info *uinfo)
2609 int chs = get_amp_channels(kcontrol);
2611 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2612 uinfo->count = chs == 3 ? 2 : 1;
2613 uinfo->value.integer.min = 0;
2614 uinfo->value.integer.max = 1;
2617 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2620 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2622 * The control element is supposed to have the private_value field
2623 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2625 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2626 struct snd_ctl_elem_value *ucontrol)
2628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2629 hda_nid_t nid = get_amp_nid(kcontrol);
2630 int chs = get_amp_channels(kcontrol);
2631 int dir = get_amp_direction(kcontrol);
2632 int idx = get_amp_index(kcontrol);
2633 long *valp = ucontrol->value.integer.value;
2636 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2637 HDA_AMP_MUTE) ? 0 : 1;
2639 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2640 HDA_AMP_MUTE) ? 0 : 1;
2643 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2646 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2648 * The control element is supposed to have the private_value field
2649 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2651 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2652 struct snd_ctl_elem_value *ucontrol)
2654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2655 hda_nid_t nid = get_amp_nid(kcontrol);
2656 int chs = get_amp_channels(kcontrol);
2657 int dir = get_amp_direction(kcontrol);
2658 int idx = get_amp_index(kcontrol);
2659 long *valp = ucontrol->value.integer.value;
2662 snd_hda_power_up(codec);
2664 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2666 *valp ? 0 : HDA_AMP_MUTE);
2670 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2672 *valp ? 0 : HDA_AMP_MUTE);
2673 hda_call_check_power_status(codec, nid);
2674 snd_hda_power_down(codec);
2677 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2679 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2681 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2683 * This function calls snd_hda_enable_beep_device(), which behaves differently
2684 * depending on beep_mode option.
2686 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2687 struct snd_ctl_elem_value *ucontrol)
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 long *valp = ucontrol->value.integer.value;
2692 snd_hda_enable_beep_device(codec, *valp);
2693 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2695 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2696 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2699 * bound volume controls
2701 * bind multiple volumes (# indices, from 0)
2704 #define AMP_VAL_IDX_SHIFT 19
2705 #define AMP_VAL_IDX_MASK (0x0f<<19)
2708 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2710 * The control element is supposed to have the private_value field
2711 * set up via HDA_BIND_MUTE*() macros.
2713 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2714 struct snd_ctl_elem_value *ucontrol)
2716 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2720 mutex_lock(&codec->control_mutex);
2721 pval = kcontrol->private_value;
2722 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2723 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2724 kcontrol->private_value = pval;
2725 mutex_unlock(&codec->control_mutex);
2728 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2731 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2733 * The control element is supposed to have the private_value field
2734 * set up via HDA_BIND_MUTE*() macros.
2736 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2737 struct snd_ctl_elem_value *ucontrol)
2739 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2741 int i, indices, err = 0, change = 0;
2743 mutex_lock(&codec->control_mutex);
2744 pval = kcontrol->private_value;
2745 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2746 for (i = 0; i < indices; i++) {
2747 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2748 (i << AMP_VAL_IDX_SHIFT);
2749 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2754 kcontrol->private_value = pval;
2755 mutex_unlock(&codec->control_mutex);
2756 return err < 0 ? err : change;
2758 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2761 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2763 * The control element is supposed to have the private_value field
2764 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2766 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2767 struct snd_ctl_elem_info *uinfo)
2769 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2770 struct hda_bind_ctls *c;
2773 mutex_lock(&codec->control_mutex);
2774 c = (struct hda_bind_ctls *)kcontrol->private_value;
2775 kcontrol->private_value = *c->values;
2776 err = c->ops->info(kcontrol, uinfo);
2777 kcontrol->private_value = (long)c;
2778 mutex_unlock(&codec->control_mutex);
2781 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2784 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2786 * The control element is supposed to have the private_value field
2787 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2789 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2790 struct snd_ctl_elem_value *ucontrol)
2792 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2793 struct hda_bind_ctls *c;
2796 mutex_lock(&codec->control_mutex);
2797 c = (struct hda_bind_ctls *)kcontrol->private_value;
2798 kcontrol->private_value = *c->values;
2799 err = c->ops->get(kcontrol, ucontrol);
2800 kcontrol->private_value = (long)c;
2801 mutex_unlock(&codec->control_mutex);
2804 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2807 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2809 * The control element is supposed to have the private_value field
2810 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2812 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2813 struct snd_ctl_elem_value *ucontrol)
2815 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2816 struct hda_bind_ctls *c;
2817 unsigned long *vals;
2818 int err = 0, change = 0;
2820 mutex_lock(&codec->control_mutex);
2821 c = (struct hda_bind_ctls *)kcontrol->private_value;
2822 for (vals = c->values; *vals; vals++) {
2823 kcontrol->private_value = *vals;
2824 err = c->ops->put(kcontrol, ucontrol);
2829 kcontrol->private_value = (long)c;
2830 mutex_unlock(&codec->control_mutex);
2831 return err < 0 ? err : change;
2833 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2836 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2838 * The control element is supposed to have the private_value field
2839 * set up via HDA_BIND_VOL() macro.
2841 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2842 unsigned int size, unsigned int __user *tlv)
2844 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2845 struct hda_bind_ctls *c;
2848 mutex_lock(&codec->control_mutex);
2849 c = (struct hda_bind_ctls *)kcontrol->private_value;
2850 kcontrol->private_value = *c->values;
2851 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2852 kcontrol->private_value = (long)c;
2853 mutex_unlock(&codec->control_mutex);
2856 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2858 struct hda_ctl_ops snd_hda_bind_vol = {
2859 .info = snd_hda_mixer_amp_volume_info,
2860 .get = snd_hda_mixer_amp_volume_get,
2861 .put = snd_hda_mixer_amp_volume_put,
2862 .tlv = snd_hda_mixer_amp_tlv
2864 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2866 struct hda_ctl_ops snd_hda_bind_sw = {
2867 .info = snd_hda_mixer_amp_switch_info,
2868 .get = snd_hda_mixer_amp_switch_get,
2869 .put = snd_hda_mixer_amp_switch_put,
2870 .tlv = snd_hda_mixer_amp_tlv
2872 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2875 * SPDIF out controls
2878 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2879 struct snd_ctl_elem_info *uinfo)
2881 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2886 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2887 struct snd_ctl_elem_value *ucontrol)
2889 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2890 IEC958_AES0_NONAUDIO |
2891 IEC958_AES0_CON_EMPHASIS_5015 |
2892 IEC958_AES0_CON_NOT_COPYRIGHT;
2893 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2894 IEC958_AES1_CON_ORIGINAL;
2898 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2899 struct snd_ctl_elem_value *ucontrol)
2901 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2902 IEC958_AES0_NONAUDIO |
2903 IEC958_AES0_PRO_EMPHASIS_5015;
2907 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2908 struct snd_ctl_elem_value *ucontrol)
2910 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2911 int idx = kcontrol->private_value;
2912 struct hda_spdif_out *spdif;
2914 mutex_lock(&codec->spdif_mutex);
2915 spdif = snd_array_elem(&codec->spdif_out, idx);
2916 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2917 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2918 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2919 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2920 mutex_unlock(&codec->spdif_mutex);
2925 /* convert from SPDIF status bits to HDA SPDIF bits
2926 * bit 0 (DigEn) is always set zero (to be filled later)
2928 static unsigned short convert_from_spdif_status(unsigned int sbits)
2930 unsigned short val = 0;
2932 if (sbits & IEC958_AES0_PROFESSIONAL)
2933 val |= AC_DIG1_PROFESSIONAL;
2934 if (sbits & IEC958_AES0_NONAUDIO)
2935 val |= AC_DIG1_NONAUDIO;
2936 if (sbits & IEC958_AES0_PROFESSIONAL) {
2937 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2938 IEC958_AES0_PRO_EMPHASIS_5015)
2939 val |= AC_DIG1_EMPHASIS;
2941 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2942 IEC958_AES0_CON_EMPHASIS_5015)
2943 val |= AC_DIG1_EMPHASIS;
2944 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2945 val |= AC_DIG1_COPYRIGHT;
2946 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2947 val |= AC_DIG1_LEVEL;
2948 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2953 /* convert to SPDIF status bits from HDA SPDIF bits
2955 static unsigned int convert_to_spdif_status(unsigned short val)
2957 unsigned int sbits = 0;
2959 if (val & AC_DIG1_NONAUDIO)
2960 sbits |= IEC958_AES0_NONAUDIO;
2961 if (val & AC_DIG1_PROFESSIONAL)
2962 sbits |= IEC958_AES0_PROFESSIONAL;
2963 if (sbits & IEC958_AES0_PROFESSIONAL) {
2964 if (sbits & AC_DIG1_EMPHASIS)
2965 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2967 if (val & AC_DIG1_EMPHASIS)
2968 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2969 if (!(val & AC_DIG1_COPYRIGHT))
2970 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2971 if (val & AC_DIG1_LEVEL)
2972 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2973 sbits |= val & (0x7f << 8);
2978 /* set digital convert verbs both for the given NID and its slaves */
2979 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2984 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2985 d = codec->slave_dig_outs;
2989 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2992 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2996 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2998 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3001 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3002 struct snd_ctl_elem_value *ucontrol)
3004 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3005 int idx = kcontrol->private_value;
3006 struct hda_spdif_out *spdif;
3011 mutex_lock(&codec->spdif_mutex);
3012 spdif = snd_array_elem(&codec->spdif_out, idx);
3014 spdif->status = ucontrol->value.iec958.status[0] |
3015 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3016 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3017 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3018 val = convert_from_spdif_status(spdif->status);
3019 val |= spdif->ctls & 1;
3020 change = spdif->ctls != val;
3022 if (change && nid != (u16)-1)
3023 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3024 mutex_unlock(&codec->spdif_mutex);
3028 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3030 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3031 struct snd_ctl_elem_value *ucontrol)
3033 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3034 int idx = kcontrol->private_value;
3035 struct hda_spdif_out *spdif;
3037 mutex_lock(&codec->spdif_mutex);
3038 spdif = snd_array_elem(&codec->spdif_out, idx);
3039 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3040 mutex_unlock(&codec->spdif_mutex);
3044 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3047 set_dig_out_convert(codec, nid, dig1, dig2);
3048 /* unmute amp switch (if any) */
3049 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3050 (dig1 & AC_DIG1_ENABLE))
3051 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3055 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3056 struct snd_ctl_elem_value *ucontrol)
3058 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3059 int idx = kcontrol->private_value;
3060 struct hda_spdif_out *spdif;
3065 mutex_lock(&codec->spdif_mutex);
3066 spdif = snd_array_elem(&codec->spdif_out, idx);
3068 val = spdif->ctls & ~AC_DIG1_ENABLE;
3069 if (ucontrol->value.integer.value[0])
3070 val |= AC_DIG1_ENABLE;
3071 change = spdif->ctls != val;
3073 if (change && nid != (u16)-1)
3074 set_spdif_ctls(codec, nid, val & 0xff, -1);
3075 mutex_unlock(&codec->spdif_mutex);
3079 static struct snd_kcontrol_new dig_mixes[] = {
3081 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3082 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3083 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3084 .info = snd_hda_spdif_mask_info,
3085 .get = snd_hda_spdif_cmask_get,
3088 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3089 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3090 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3091 .info = snd_hda_spdif_mask_info,
3092 .get = snd_hda_spdif_pmask_get,
3095 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3096 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3097 .info = snd_hda_spdif_mask_info,
3098 .get = snd_hda_spdif_default_get,
3099 .put = snd_hda_spdif_default_put,
3102 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3103 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3104 .info = snd_hda_spdif_out_switch_info,
3105 .get = snd_hda_spdif_out_switch_get,
3106 .put = snd_hda_spdif_out_switch_put,
3112 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3113 * @codec: the HDA codec
3114 * @nid: audio out widget NID
3116 * Creates controls related with the SPDIF output.
3117 * Called from each patch supporting the SPDIF out.
3119 * Returns 0 if successful, or a negative error code.
3121 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3122 hda_nid_t associated_nid,
3126 struct snd_kcontrol *kctl;
3127 struct snd_kcontrol_new *dig_mix;
3129 struct hda_spdif_out *spdif;
3131 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3133 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3136 spdif = snd_array_new(&codec->spdif_out);
3137 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3138 kctl = snd_ctl_new1(dig_mix, codec);
3141 kctl->id.index = idx;
3142 kctl->private_value = codec->spdif_out.used - 1;
3143 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3147 spdif->nid = cvt_nid;
3148 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3149 AC_VERB_GET_DIGI_CONVERT_1, 0);
3150 spdif->status = convert_to_spdif_status(spdif->ctls);
3153 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3155 /* get the hda_spdif_out entry from the given NID
3156 * call within spdif_mutex lock
3158 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3162 for (i = 0; i < codec->spdif_out.used; i++) {
3163 struct hda_spdif_out *spdif =
3164 snd_array_elem(&codec->spdif_out, i);
3165 if (spdif->nid == nid)
3170 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3172 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3174 struct hda_spdif_out *spdif;
3176 mutex_lock(&codec->spdif_mutex);
3177 spdif = snd_array_elem(&codec->spdif_out, idx);
3178 spdif->nid = (u16)-1;
3179 mutex_unlock(&codec->spdif_mutex);
3181 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3183 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3185 struct hda_spdif_out *spdif;
3188 mutex_lock(&codec->spdif_mutex);
3189 spdif = snd_array_elem(&codec->spdif_out, idx);
3190 if (spdif->nid != nid) {
3193 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3195 mutex_unlock(&codec->spdif_mutex);
3197 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3200 * SPDIF sharing with analog output
3202 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3203 struct snd_ctl_elem_value *ucontrol)
3205 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3206 ucontrol->value.integer.value[0] = mout->share_spdif;
3210 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3211 struct snd_ctl_elem_value *ucontrol)
3213 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3214 mout->share_spdif = !!ucontrol->value.integer.value[0];
3218 static struct snd_kcontrol_new spdif_share_sw = {
3219 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3220 .name = "IEC958 Default PCM Playback Switch",
3221 .info = snd_ctl_boolean_mono_info,
3222 .get = spdif_share_sw_get,
3223 .put = spdif_share_sw_put,
3227 * snd_hda_create_spdif_share_sw - create Default PCM switch
3228 * @codec: the HDA codec
3229 * @mout: multi-out instance
3231 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3232 struct hda_multi_out *mout)
3234 if (!mout->dig_out_nid)
3236 /* ATTENTION: here mout is passed as private_data, instead of codec */
3237 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3238 snd_ctl_new1(&spdif_share_sw, mout));
3240 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3246 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3248 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3249 struct snd_ctl_elem_value *ucontrol)
3251 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3253 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3257 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3258 struct snd_ctl_elem_value *ucontrol)
3260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3261 hda_nid_t nid = kcontrol->private_value;
3262 unsigned int val = !!ucontrol->value.integer.value[0];
3265 mutex_lock(&codec->spdif_mutex);
3266 change = codec->spdif_in_enable != val;
3268 codec->spdif_in_enable = val;
3269 snd_hda_codec_write_cache(codec, nid, 0,
3270 AC_VERB_SET_DIGI_CONVERT_1, val);
3272 mutex_unlock(&codec->spdif_mutex);
3276 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3277 struct snd_ctl_elem_value *ucontrol)
3279 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3280 hda_nid_t nid = kcontrol->private_value;
3284 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3285 sbits = convert_to_spdif_status(val);
3286 ucontrol->value.iec958.status[0] = sbits;
3287 ucontrol->value.iec958.status[1] = sbits >> 8;
3288 ucontrol->value.iec958.status[2] = sbits >> 16;
3289 ucontrol->value.iec958.status[3] = sbits >> 24;
3293 static struct snd_kcontrol_new dig_in_ctls[] = {
3295 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3296 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3297 .info = snd_hda_spdif_in_switch_info,
3298 .get = snd_hda_spdif_in_switch_get,
3299 .put = snd_hda_spdif_in_switch_put,
3302 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3303 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3304 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3305 .info = snd_hda_spdif_mask_info,
3306 .get = snd_hda_spdif_in_status_get,
3312 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3313 * @codec: the HDA codec
3314 * @nid: audio in widget NID
3316 * Creates controls related with the SPDIF input.
3317 * Called from each patch supporting the SPDIF in.
3319 * Returns 0 if successful, or a negative error code.
3321 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3324 struct snd_kcontrol *kctl;
3325 struct snd_kcontrol_new *dig_mix;
3328 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3330 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3333 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3334 kctl = snd_ctl_new1(dig_mix, codec);
3337 kctl->private_value = nid;
3338 err = snd_hda_ctl_add(codec, nid, kctl);
3342 codec->spdif_in_enable =
3343 snd_hda_codec_read(codec, nid, 0,
3344 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3348 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3355 /* build a 32bit cache key with the widget id and the command parameter */
3356 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3357 #define get_cmd_cache_nid(key) ((key) & 0xff)
3358 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3361 * snd_hda_codec_write_cache - send a single command with caching
3362 * @codec: the HDA codec
3363 * @nid: NID to send the command
3364 * @direct: direct flag
3365 * @verb: the verb to send
3366 * @parm: the parameter for the verb
3368 * Send a single command without waiting for response.
3370 * Returns 0 if successful, or a negative error code.
3372 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3373 int direct, unsigned int verb, unsigned int parm)
3375 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3376 struct hda_cache_head *c;
3381 /* parm may contain the verb stuff for get/set amp */
3382 verb = verb | (parm >> 8);
3384 key = build_cmd_cache_key(nid, verb);
3385 mutex_lock(&codec->bus->cmd_mutex);
3386 c = get_alloc_hash(&codec->cmd_cache, key);
3389 mutex_unlock(&codec->bus->cmd_mutex);
3392 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3395 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3396 * @codec: the HDA codec
3397 * @nid: NID to send the command
3398 * @direct: direct flag
3399 * @verb: the verb to send
3400 * @parm: the parameter for the verb
3402 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3403 * command if the parameter is already identical with the cached value.
3404 * If not, it sends the command and refreshes the cache.
3406 * Returns 0 if successful, or a negative error code.
3408 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3409 int direct, unsigned int verb, unsigned int parm)
3411 struct hda_cache_head *c;
3414 /* parm may contain the verb stuff for get/set amp */
3415 verb = verb | (parm >> 8);
3417 key = build_cmd_cache_key(nid, verb);
3418 mutex_lock(&codec->bus->cmd_mutex);
3419 c = get_hash(&codec->cmd_cache, key);
3420 if (c && c->val == parm) {
3421 mutex_unlock(&codec->bus->cmd_mutex);
3424 mutex_unlock(&codec->bus->cmd_mutex);
3425 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3427 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3430 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3431 * @codec: HD-audio codec
3433 * Execute all verbs recorded in the command caches to resume.
3435 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3437 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3440 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3441 u32 key = buffer->key;
3444 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3445 get_cmd_cache_cmd(key), buffer->val);
3448 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3451 * snd_hda_sequence_write_cache - sequence writes with caching
3452 * @codec: the HDA codec
3453 * @seq: VERB array to send
3455 * Send the commands sequentially from the given array.
3456 * Thte commands are recorded on cache for power-save and resume.
3457 * The array must be terminated with NID=0.
3459 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3460 const struct hda_verb *seq)
3462 for (; seq->nid; seq++)
3463 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3466 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3467 #endif /* CONFIG_PM */
3469 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3470 unsigned int power_state,
3471 bool eapd_workaround)
3473 hda_nid_t nid = codec->start_nid;
3476 for (i = 0; i < codec->num_nodes; i++, nid++) {
3477 unsigned int wcaps = get_wcaps(codec, nid);
3478 if (!(wcaps & AC_WCAP_POWER))
3480 /* don't power down the widget if it controls eapd and
3481 * EAPD_BTLENABLE is set.
3483 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3484 get_wcaps_type(wcaps) == AC_WID_PIN &&
3485 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3486 int eapd = snd_hda_codec_read(codec, nid, 0,
3487 AC_VERB_GET_EAPD_BTLENABLE, 0);
3491 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3495 if (power_state == AC_PWRST_D0) {
3496 unsigned long end_time;
3498 /* wait until the codec reachs to D0 */
3499 end_time = jiffies + msecs_to_jiffies(500);
3501 state = snd_hda_codec_read(codec, fg, 0,
3502 AC_VERB_GET_POWER_STATE, 0);
3503 if (state == power_state)
3506 } while (time_after_eq(end_time, jiffies));
3509 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3512 * set power state of the codec
3514 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3515 unsigned int power_state)
3517 if (codec->patch_ops.set_power_state) {
3518 codec->patch_ops.set_power_state(codec, fg, power_state);
3522 /* this delay seems necessary to avoid click noise at power-down */
3523 if (power_state == AC_PWRST_D3)
3525 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3527 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3530 #ifdef CONFIG_SND_HDA_HWDEP
3531 /* execute additional init verbs */
3532 static void hda_exec_init_verbs(struct hda_codec *codec)
3534 if (codec->init_verbs.list)
3535 snd_hda_sequence_write(codec, codec->init_verbs.list);
3538 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3543 * call suspend and power-down; used both from PM and power-save
3545 static void hda_call_codec_suspend(struct hda_codec *codec)
3547 if (codec->patch_ops.suspend)
3548 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3549 hda_cleanup_all_streams(codec);
3550 hda_set_power_state(codec,
3551 codec->afg ? codec->afg : codec->mfg,
3553 #ifdef CONFIG_SND_HDA_POWER_SAVE
3554 cancel_delayed_work(&codec->power_work);
3555 spin_lock(&codec->power_lock);
3556 snd_hda_update_power_acct(codec);
3557 trace_hda_power_down(codec);
3558 codec->power_on = 0;
3559 codec->power_transition = 0;
3560 codec->power_jiffies = jiffies;
3561 spin_unlock(&codec->power_lock);
3566 * kick up codec; used both from PM and power-save
3568 static void hda_call_codec_resume(struct hda_codec *codec)
3570 /* set as if powered on for avoiding re-entering the resume
3571 * in the resume / power-save sequence
3573 hda_keep_power_on(codec);
3574 hda_set_power_state(codec,
3575 codec->afg ? codec->afg : codec->mfg,
3577 restore_pincfgs(codec); /* restore all current pin configs */
3578 restore_shutup_pins(codec);
3579 hda_exec_init_verbs(codec);
3580 snd_hda_jack_set_dirty_all(codec);
3581 if (codec->patch_ops.resume)
3582 codec->patch_ops.resume(codec);
3584 if (codec->patch_ops.init)
3585 codec->patch_ops.init(codec);
3586 snd_hda_codec_resume_amp(codec);
3587 snd_hda_codec_resume_cache(codec);
3589 snd_hda_power_down(codec); /* flag down before returning */
3591 #endif /* CONFIG_PM */
3595 * snd_hda_build_controls - build mixer controls
3598 * Creates mixer controls for each codec included in the bus.
3600 * Returns 0 if successful, otherwise a negative error code.
3602 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3604 struct hda_codec *codec;
3606 list_for_each_entry(codec, &bus->codec_list, list) {
3607 int err = snd_hda_codec_build_controls(codec);
3609 printk(KERN_ERR "hda_codec: cannot build controls "
3610 "for #%d (error %d)\n", codec->addr, err);
3611 err = snd_hda_codec_reset(codec);
3614 "hda_codec: cannot revert codec\n");
3621 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3623 int snd_hda_codec_build_controls(struct hda_codec *codec)
3626 hda_exec_init_verbs(codec);
3627 /* continue to initialize... */
3628 if (codec->patch_ops.init)
3629 err = codec->patch_ops.init(codec);
3630 if (!err && codec->patch_ops.build_controls)
3631 err = codec->patch_ops.build_controls(codec);
3640 struct hda_rate_tbl {
3642 unsigned int alsa_bits;
3643 unsigned int hda_fmt;
3646 /* rate = base * mult / div */
3647 #define HDA_RATE(base, mult, div) \
3648 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3649 (((div) - 1) << AC_FMT_DIV_SHIFT))
3651 static struct hda_rate_tbl rate_bits[] = {
3652 /* rate in Hz, ALSA rate bitmask, HDA format value */
3654 /* autodetected value used in snd_hda_query_supported_pcm */
3655 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3656 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3657 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3658 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3659 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3660 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3661 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3662 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3663 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3664 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3665 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3666 #define AC_PAR_PCM_RATE_BITS 11
3667 /* up to bits 10, 384kHZ isn't supported properly */
3669 /* not autodetected value */
3670 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3672 { 0 } /* terminator */
3676 * snd_hda_calc_stream_format - calculate format bitset
3677 * @rate: the sample rate
3678 * @channels: the number of channels
3679 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3680 * @maxbps: the max. bps
3682 * Calculate the format bitset from the given rate, channels and th PCM format.
3684 * Return zero if invalid.
3686 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3687 unsigned int channels,
3688 unsigned int format,
3689 unsigned int maxbps,
3690 unsigned short spdif_ctls)
3693 unsigned int val = 0;
3695 for (i = 0; rate_bits[i].hz; i++)
3696 if (rate_bits[i].hz == rate) {
3697 val = rate_bits[i].hda_fmt;
3700 if (!rate_bits[i].hz) {
3701 snd_printdd("invalid rate %d\n", rate);
3705 if (channels == 0 || channels > 8) {
3706 snd_printdd("invalid channels %d\n", channels);
3709 val |= channels - 1;
3711 switch (snd_pcm_format_width(format)) {
3713 val |= AC_FMT_BITS_8;
3716 val |= AC_FMT_BITS_16;
3721 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3722 val |= AC_FMT_BITS_32;
3723 else if (maxbps >= 24)
3724 val |= AC_FMT_BITS_24;
3726 val |= AC_FMT_BITS_20;
3729 snd_printdd("invalid format width %d\n",
3730 snd_pcm_format_width(format));
3734 if (spdif_ctls & AC_DIG1_NONAUDIO)
3735 val |= AC_FMT_TYPE_NON_PCM;
3739 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3741 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3744 unsigned int val = 0;
3745 if (nid != codec->afg &&
3746 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3747 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3748 if (!val || val == -1)
3749 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3750 if (!val || val == -1)
3755 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3757 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
3761 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3764 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3765 if (!streams || streams == -1)
3766 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3767 if (!streams || streams == -1)
3772 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3774 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
3779 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3780 * @codec: the HDA codec
3781 * @nid: NID to query
3782 * @ratesp: the pointer to store the detected rate bitflags
3783 * @formatsp: the pointer to store the detected formats
3784 * @bpsp: the pointer to store the detected format widths
3786 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3787 * or @bsps argument is ignored.
3789 * Returns 0 if successful, otherwise a negative error code.
3791 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3792 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3794 unsigned int i, val, wcaps;
3796 wcaps = get_wcaps(codec, nid);
3797 val = query_pcm_param(codec, nid);
3801 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3803 rates |= rate_bits[i].alsa_bits;
3806 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3807 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3809 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3815 if (formatsp || bpsp) {
3817 unsigned int streams, bps;
3819 streams = query_stream_param(codec, nid);
3824 if (streams & AC_SUPFMT_PCM) {
3825 if (val & AC_SUPPCM_BITS_8) {
3826 formats |= SNDRV_PCM_FMTBIT_U8;
3829 if (val & AC_SUPPCM_BITS_16) {
3830 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3833 if (wcaps & AC_WCAP_DIGITAL) {
3834 if (val & AC_SUPPCM_BITS_32)
3835 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3836 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3837 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3838 if (val & AC_SUPPCM_BITS_24)
3840 else if (val & AC_SUPPCM_BITS_20)
3842 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3843 AC_SUPPCM_BITS_32)) {
3844 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3845 if (val & AC_SUPPCM_BITS_32)
3847 else if (val & AC_SUPPCM_BITS_24)
3849 else if (val & AC_SUPPCM_BITS_20)
3853 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3854 if (streams & AC_SUPFMT_FLOAT32) {
3855 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3860 if (streams == AC_SUPFMT_AC3) {
3861 /* should be exclusive */
3862 /* temporary hack: we have still no proper support
3863 * for the direct AC3 stream...
3865 formats |= SNDRV_PCM_FMTBIT_U8;
3869 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3870 "(nid=0x%x, val=0x%x, ovrd=%i, "
3873 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3878 *formatsp = formats;
3885 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3888 * snd_hda_is_supported_format - Check the validity of the format
3889 * @codec: HD-audio codec
3890 * @nid: NID to check
3891 * @format: the HD-audio format value to check
3893 * Check whether the given node supports the format value.
3895 * Returns 1 if supported, 0 if not.
3897 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3898 unsigned int format)
3901 unsigned int val = 0, rate, stream;
3903 val = query_pcm_param(codec, nid);
3907 rate = format & 0xff00;
3908 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3909 if (rate_bits[i].hda_fmt == rate) {
3914 if (i >= AC_PAR_PCM_RATE_BITS)
3917 stream = query_stream_param(codec, nid);
3921 if (stream & AC_SUPFMT_PCM) {
3922 switch (format & 0xf0) {
3924 if (!(val & AC_SUPPCM_BITS_8))
3928 if (!(val & AC_SUPPCM_BITS_16))
3932 if (!(val & AC_SUPPCM_BITS_20))
3936 if (!(val & AC_SUPPCM_BITS_24))
3940 if (!(val & AC_SUPPCM_BITS_32))
3947 /* FIXME: check for float32 and AC3? */
3952 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3957 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3958 struct hda_codec *codec,
3959 struct snd_pcm_substream *substream)
3964 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3965 struct hda_codec *codec,
3966 unsigned int stream_tag,
3967 unsigned int format,
3968 struct snd_pcm_substream *substream)
3970 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3974 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3975 struct hda_codec *codec,
3976 struct snd_pcm_substream *substream)
3978 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3982 static int set_pcm_default_values(struct hda_codec *codec,
3983 struct hda_pcm_stream *info)
3987 /* query support PCM information from the given NID */
3988 if (info->nid && (!info->rates || !info->formats)) {
3989 err = snd_hda_query_supported_pcm(codec, info->nid,
3990 info->rates ? NULL : &info->rates,
3991 info->formats ? NULL : &info->formats,
3992 info->maxbps ? NULL : &info->maxbps);
3996 if (info->ops.open == NULL)
3997 info->ops.open = hda_pcm_default_open_close;
3998 if (info->ops.close == NULL)
3999 info->ops.close = hda_pcm_default_open_close;
4000 if (info->ops.prepare == NULL) {
4001 if (snd_BUG_ON(!info->nid))
4003 info->ops.prepare = hda_pcm_default_prepare;
4005 if (info->ops.cleanup == NULL) {
4006 if (snd_BUG_ON(!info->nid))
4008 info->ops.cleanup = hda_pcm_default_cleanup;
4014 * codec prepare/cleanup entries
4016 int snd_hda_codec_prepare(struct hda_codec *codec,
4017 struct hda_pcm_stream *hinfo,
4018 unsigned int stream,
4019 unsigned int format,
4020 struct snd_pcm_substream *substream)
4023 mutex_lock(&codec->bus->prepare_mutex);
4024 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4026 purify_inactive_streams(codec);
4027 mutex_unlock(&codec->bus->prepare_mutex);
4030 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4032 void snd_hda_codec_cleanup(struct hda_codec *codec,
4033 struct hda_pcm_stream *hinfo,
4034 struct snd_pcm_substream *substream)
4036 mutex_lock(&codec->bus->prepare_mutex);
4037 hinfo->ops.cleanup(hinfo, codec, substream);
4038 mutex_unlock(&codec->bus->prepare_mutex);
4040 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4043 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4044 "Audio", "SPDIF", "HDMI", "Modem"
4048 * get the empty PCM device number to assign
4050 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4052 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4054 /* audio device indices; not linear to keep compatibility */
4055 static int audio_idx[HDA_PCM_NTYPES][5] = {
4056 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4057 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4058 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4059 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4063 if (type >= HDA_PCM_NTYPES) {
4064 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4068 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4069 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4070 return audio_idx[type][i];
4072 /* non-fixed slots starting from 10 */
4073 for (i = 10; i < 32; i++) {
4074 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4078 snd_printk(KERN_WARNING "Too many %s devices\n",
4079 snd_hda_pcm_type_name[type]);
4084 * attach a new PCM stream
4086 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4088 struct hda_bus *bus = codec->bus;
4089 struct hda_pcm_stream *info;
4092 if (snd_BUG_ON(!pcm->name))
4094 for (stream = 0; stream < 2; stream++) {
4095 info = &pcm->stream[stream];
4096 if (info->substreams) {
4097 err = set_pcm_default_values(codec, info);
4102 return bus->ops.attach_pcm(bus, codec, pcm);
4105 /* assign all PCMs of the given codec */
4106 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4111 if (!codec->num_pcms) {
4112 if (!codec->patch_ops.build_pcms)
4114 err = codec->patch_ops.build_pcms(codec);
4116 printk(KERN_ERR "hda_codec: cannot build PCMs"
4117 "for #%d (error %d)\n", codec->addr, err);
4118 err = snd_hda_codec_reset(codec);
4121 "hda_codec: cannot revert codec\n");
4126 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4127 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4130 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4131 continue; /* no substreams assigned */
4134 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4136 continue; /* no fatal error */
4138 err = snd_hda_attach_pcm(codec, cpcm);
4140 printk(KERN_ERR "hda_codec: cannot attach "
4141 "PCM stream %d for codec #%d\n",
4143 continue; /* no fatal error */
4151 * snd_hda_build_pcms - build PCM information
4154 * Create PCM information for each codec included in the bus.
4156 * The build_pcms codec patch is requested to set up codec->num_pcms and
4157 * codec->pcm_info properly. The array is referred by the top-level driver
4158 * to create its PCM instances.
4159 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4162 * At least, substreams, channels_min and channels_max must be filled for
4163 * each stream. substreams = 0 indicates that the stream doesn't exist.
4164 * When rates and/or formats are zero, the supported values are queried
4165 * from the given nid. The nid is used also by the default ops.prepare
4166 * and ops.cleanup callbacks.
4168 * The driver needs to call ops.open in its open callback. Similarly,
4169 * ops.close is supposed to be called in the close callback.
4170 * ops.prepare should be called in the prepare or hw_params callback
4171 * with the proper parameters for set up.
4172 * ops.cleanup should be called in hw_free for clean up of streams.
4174 * This function returns 0 if successful, or a negative error code.
4176 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4178 struct hda_codec *codec;
4180 list_for_each_entry(codec, &bus->codec_list, list) {
4181 int err = snd_hda_codec_build_pcms(codec);
4187 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4190 * snd_hda_check_board_config - compare the current codec with the config table
4191 * @codec: the HDA codec
4192 * @num_configs: number of config enums
4193 * @models: array of model name strings
4194 * @tbl: configuration table, terminated by null entries
4196 * Compares the modelname or PCI subsystem id of the current codec with the
4197 * given configuration table. If a matching entry is found, returns its
4198 * config value (supposed to be 0 or positive).
4200 * If no entries are matching, the function returns a negative value.
4202 int snd_hda_check_board_config(struct hda_codec *codec,
4203 int num_configs, const char * const *models,
4204 const struct snd_pci_quirk *tbl)
4206 if (codec->modelname && models) {
4208 for (i = 0; i < num_configs; i++) {
4210 !strcmp(codec->modelname, models[i])) {
4211 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4212 "selected\n", models[i]);
4218 if (!codec->bus->pci || !tbl)
4221 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4224 if (tbl->value >= 0 && tbl->value < num_configs) {
4225 #ifdef CONFIG_SND_DEBUG_VERBOSE
4227 const char *model = NULL;
4229 model = models[tbl->value];
4231 sprintf(tmp, "#%d", tbl->value);
4234 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4235 "for config %x:%x (%s)\n",
4236 model, tbl->subvendor, tbl->subdevice,
4237 (tbl->name ? tbl->name : "Unknown device"));
4243 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4246 * snd_hda_check_board_codec_sid_config - compare the current codec
4247 subsystem ID with the
4250 This is important for Gateway notebooks with SB450 HDA Audio
4251 where the vendor ID of the PCI device is:
4252 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4253 and the vendor/subvendor are found only at the codec.
4255 * @codec: the HDA codec
4256 * @num_configs: number of config enums
4257 * @models: array of model name strings
4258 * @tbl: configuration table, terminated by null entries
4260 * Compares the modelname or PCI subsystem id of the current codec with the
4261 * given configuration table. If a matching entry is found, returns its
4262 * config value (supposed to be 0 or positive).
4264 * If no entries are matching, the function returns a negative value.
4266 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4267 int num_configs, const char * const *models,
4268 const struct snd_pci_quirk *tbl)
4270 const struct snd_pci_quirk *q;
4272 /* Search for codec ID */
4273 for (q = tbl; q->subvendor; q++) {
4274 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4275 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4276 if ((codec->subsystem_id & mask) == id)
4285 if (tbl->value >= 0 && tbl->value < num_configs) {
4286 #ifdef CONFIG_SND_DEBUG_VERBOSE
4288 const char *model = NULL;
4290 model = models[tbl->value];
4292 sprintf(tmp, "#%d", tbl->value);
4295 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4296 "for config %x:%x (%s)\n",
4297 model, tbl->subvendor, tbl->subdevice,
4298 (tbl->name ? tbl->name : "Unknown device"));
4304 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4307 * snd_hda_add_new_ctls - create controls from the array
4308 * @codec: the HDA codec
4309 * @knew: the array of struct snd_kcontrol_new
4311 * This helper function creates and add new controls in the given array.
4312 * The array must be terminated with an empty entry as terminator.
4314 * Returns 0 if successful, or a negative error code.
4316 int snd_hda_add_new_ctls(struct hda_codec *codec,
4317 const struct snd_kcontrol_new *knew)
4321 for (; knew->name; knew++) {
4322 struct snd_kcontrol *kctl;
4323 int addr = 0, idx = 0;
4324 if (knew->iface == -1) /* skip this codec private value */
4327 kctl = snd_ctl_new1(knew, codec);
4331 kctl->id.device = addr;
4333 kctl->id.index = idx;
4334 err = snd_hda_ctl_add(codec, 0, kctl);
4337 /* try first with another device index corresponding to
4338 * the codec addr; if it still fails (or it's the
4339 * primary codec), then try another control index
4341 if (!addr && codec->addr)
4343 else if (!idx && !knew->index) {
4344 idx = find_empty_mixer_ctl_idx(codec,
4354 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4356 #ifdef CONFIG_SND_HDA_POWER_SAVE
4357 static void hda_power_work(struct work_struct *work)
4359 struct hda_codec *codec =
4360 container_of(work, struct hda_codec, power_work.work);
4361 struct hda_bus *bus = codec->bus;
4363 spin_lock(&codec->power_lock);
4364 if (codec->power_transition > 0) { /* during power-up sequence? */
4365 spin_unlock(&codec->power_lock);
4368 if (!codec->power_on || codec->power_count) {
4369 codec->power_transition = 0;
4370 spin_unlock(&codec->power_lock);
4373 spin_unlock(&codec->power_lock);
4375 hda_call_codec_suspend(codec);
4376 if (bus->ops.pm_notify)
4377 bus->ops.pm_notify(bus);
4380 static void hda_keep_power_on(struct hda_codec *codec)
4382 spin_lock(&codec->power_lock);
4383 codec->power_count++;
4384 codec->power_on = 1;
4385 codec->power_jiffies = jiffies;
4386 spin_unlock(&codec->power_lock);
4389 /* update the power on/off account with the current jiffies */
4390 void snd_hda_update_power_acct(struct hda_codec *codec)
4392 unsigned long delta = jiffies - codec->power_jiffies;
4393 if (codec->power_on)
4394 codec->power_on_acct += delta;
4396 codec->power_off_acct += delta;
4397 codec->power_jiffies += delta;
4400 /* Transition to powered up, if wait_power_down then wait for a pending
4401 * transition to D3 to complete. A pending D3 transition is indicated
4402 * with power_transition == -1. */
4403 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4405 struct hda_bus *bus = codec->bus;
4407 spin_lock(&codec->power_lock);
4408 codec->power_count++;
4409 /* Return if power_on or transitioning to power_on, unless currently
4411 if ((codec->power_on || codec->power_transition > 0) &&
4412 !(wait_power_down && codec->power_transition < 0)) {
4413 spin_unlock(&codec->power_lock);
4416 spin_unlock(&codec->power_lock);
4418 cancel_delayed_work_sync(&codec->power_work);
4420 spin_lock(&codec->power_lock);
4421 trace_hda_power_up(codec);
4422 snd_hda_update_power_acct(codec);
4423 codec->power_on = 1;
4424 codec->power_jiffies = jiffies;
4425 codec->power_transition = 1; /* avoid reentrance */
4426 spin_unlock(&codec->power_lock);
4428 if (bus->ops.pm_notify)
4429 bus->ops.pm_notify(bus);
4430 hda_call_codec_resume(codec);
4432 spin_lock(&codec->power_lock);
4433 codec->power_transition = 0;
4434 spin_unlock(&codec->power_lock);
4438 * snd_hda_power_up - Power-up the codec
4439 * @codec: HD-audio codec
4441 * Increment the power-up counter and power up the hardware really when
4442 * not turned on yet.
4444 void snd_hda_power_up(struct hda_codec *codec)
4446 __snd_hda_power_up(codec, false);
4448 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4451 * snd_hda_power_up_d3wait - Power-up the codec after waiting for any pending
4452 * D3 transition to complete. This differs from snd_hda_power_up() when
4453 * power_transition == -1. snd_hda_power_up sees this case as a nop,
4454 * snd_hda_power_up_d3wait waits for the D3 transition to complete then powers
4456 * @codec: HD-audio codec
4458 * Cancel any power down operation hapenning on the work queue, then power up.
4460 void snd_hda_power_up_d3wait(struct hda_codec *codec)
4462 /* This will cancel and wait for pending power_work to complete. */
4463 __snd_hda_power_up(codec, true);
4465 EXPORT_SYMBOL_HDA(snd_hda_power_up_d3wait);
4467 #define power_save(codec) \
4468 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4471 * snd_hda_power_down - Power-down the codec
4472 * @codec: HD-audio codec
4474 * Decrement the power-up counter and schedules the power-off work if
4475 * the counter rearches to zero.
4477 void snd_hda_power_down(struct hda_codec *codec)
4479 spin_lock(&codec->power_lock);
4480 --codec->power_count;
4481 if (!codec->power_on || codec->power_count || codec->power_transition) {
4482 spin_unlock(&codec->power_lock);
4485 if (power_save(codec)) {
4486 codec->power_transition = -1; /* avoid reentrance */
4487 queue_delayed_work(codec->bus->workq, &codec->power_work,
4488 msecs_to_jiffies(power_save(codec) * 1000));
4490 spin_unlock(&codec->power_lock);
4492 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4495 * snd_hda_check_amp_list_power - Check the amp list and update the power
4496 * @codec: HD-audio codec
4497 * @check: the object containing an AMP list and the status
4498 * @nid: NID to check / update
4500 * Check whether the given NID is in the amp list. If it's in the list,
4501 * check the current AMP status, and update the the power-status according
4502 * to the mute status.
4504 * This function is supposed to be set or called from the check_power_status
4507 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4508 struct hda_loopback_check *check,
4511 const struct hda_amp_list *p;
4514 if (!check->amplist)
4516 for (p = check->amplist; p->nid; p++) {
4521 return 0; /* nothing changed */
4523 for (p = check->amplist; p->nid; p++) {
4524 for (ch = 0; ch < 2; ch++) {
4525 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4527 if (!(v & HDA_AMP_MUTE) && v > 0) {
4528 if (!check->power_on) {
4529 check->power_on = 1;
4530 snd_hda_power_up(codec);
4536 if (check->power_on) {
4537 check->power_on = 0;
4538 snd_hda_power_down(codec);
4542 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4546 * Channel mode helper
4550 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4552 int snd_hda_ch_mode_info(struct hda_codec *codec,
4553 struct snd_ctl_elem_info *uinfo,
4554 const struct hda_channel_mode *chmode,
4557 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4559 uinfo->value.enumerated.items = num_chmodes;
4560 if (uinfo->value.enumerated.item >= num_chmodes)
4561 uinfo->value.enumerated.item = num_chmodes - 1;
4562 sprintf(uinfo->value.enumerated.name, "%dch",
4563 chmode[uinfo->value.enumerated.item].channels);
4566 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4569 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4571 int snd_hda_ch_mode_get(struct hda_codec *codec,
4572 struct snd_ctl_elem_value *ucontrol,
4573 const struct hda_channel_mode *chmode,
4579 for (i = 0; i < num_chmodes; i++) {
4580 if (max_channels == chmode[i].channels) {
4581 ucontrol->value.enumerated.item[0] = i;
4587 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4590 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4592 int snd_hda_ch_mode_put(struct hda_codec *codec,
4593 struct snd_ctl_elem_value *ucontrol,
4594 const struct hda_channel_mode *chmode,
4600 mode = ucontrol->value.enumerated.item[0];
4601 if (mode >= num_chmodes)
4603 if (*max_channelsp == chmode[mode].channels)
4605 /* change the current channel setting */
4606 *max_channelsp = chmode[mode].channels;
4607 if (chmode[mode].sequence)
4608 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4611 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4618 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4620 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4621 struct snd_ctl_elem_info *uinfo)
4625 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4627 uinfo->value.enumerated.items = imux->num_items;
4628 if (!imux->num_items)
4630 index = uinfo->value.enumerated.item;
4631 if (index >= imux->num_items)
4632 index = imux->num_items - 1;
4633 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4636 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4639 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4641 int snd_hda_input_mux_put(struct hda_codec *codec,
4642 const struct hda_input_mux *imux,
4643 struct snd_ctl_elem_value *ucontrol,
4645 unsigned int *cur_val)
4649 if (!imux->num_items)
4651 idx = ucontrol->value.enumerated.item[0];
4652 if (idx >= imux->num_items)
4653 idx = imux->num_items - 1;
4654 if (*cur_val == idx)
4656 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4657 imux->items[idx].index);
4661 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4665 * Multi-channel / digital-out PCM helper functions
4668 /* setup SPDIF output stream */
4669 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4670 unsigned int stream_tag, unsigned int format)
4672 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4674 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4675 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4676 set_dig_out_convert(codec, nid,
4677 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4679 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4680 if (codec->slave_dig_outs) {
4682 for (d = codec->slave_dig_outs; *d; d++)
4683 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4686 /* turn on again (if needed) */
4687 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4688 set_dig_out_convert(codec, nid,
4689 spdif->ctls & 0xff, -1);
4692 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4694 snd_hda_codec_cleanup_stream(codec, nid);
4695 if (codec->slave_dig_outs) {
4697 for (d = codec->slave_dig_outs; *d; d++)
4698 snd_hda_codec_cleanup_stream(codec, *d);
4703 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4704 * @bus: HD-audio bus
4706 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4708 struct hda_codec *codec;
4712 list_for_each_entry(codec, &bus->codec_list, list) {
4713 if (hda_codec_is_power_on(codec) &&
4714 codec->patch_ops.reboot_notify)
4715 codec->patch_ops.reboot_notify(codec);
4718 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4721 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4723 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4724 struct hda_multi_out *mout)
4726 mutex_lock(&codec->spdif_mutex);
4727 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4728 /* already opened as analog dup; reset it once */
4729 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4730 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4731 mutex_unlock(&codec->spdif_mutex);
4734 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4737 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4739 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4740 struct hda_multi_out *mout,
4741 unsigned int stream_tag,
4742 unsigned int format,
4743 struct snd_pcm_substream *substream)
4745 mutex_lock(&codec->spdif_mutex);
4746 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4747 mutex_unlock(&codec->spdif_mutex);
4750 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4753 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4755 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4756 struct hda_multi_out *mout)
4758 mutex_lock(&codec->spdif_mutex);
4759 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4760 mutex_unlock(&codec->spdif_mutex);
4763 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4766 * snd_hda_multi_out_dig_close - release the digital out stream
4768 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4769 struct hda_multi_out *mout)
4771 mutex_lock(&codec->spdif_mutex);
4772 mout->dig_out_used = 0;
4773 mutex_unlock(&codec->spdif_mutex);
4776 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4779 * snd_hda_multi_out_analog_open - open analog outputs
4781 * Open analog outputs and set up the hw-constraints.
4782 * If the digital outputs can be opened as slave, open the digital
4785 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4786 struct hda_multi_out *mout,
4787 struct snd_pcm_substream *substream,
4788 struct hda_pcm_stream *hinfo)
4790 struct snd_pcm_runtime *runtime = substream->runtime;
4791 runtime->hw.channels_max = mout->max_channels;
4792 if (mout->dig_out_nid) {
4793 if (!mout->analog_rates) {
4794 mout->analog_rates = hinfo->rates;
4795 mout->analog_formats = hinfo->formats;
4796 mout->analog_maxbps = hinfo->maxbps;
4798 runtime->hw.rates = mout->analog_rates;
4799 runtime->hw.formats = mout->analog_formats;
4800 hinfo->maxbps = mout->analog_maxbps;
4802 if (!mout->spdif_rates) {
4803 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4805 &mout->spdif_formats,
4806 &mout->spdif_maxbps);
4808 mutex_lock(&codec->spdif_mutex);
4809 if (mout->share_spdif) {
4810 if ((runtime->hw.rates & mout->spdif_rates) &&
4811 (runtime->hw.formats & mout->spdif_formats)) {
4812 runtime->hw.rates &= mout->spdif_rates;
4813 runtime->hw.formats &= mout->spdif_formats;
4814 if (mout->spdif_maxbps < hinfo->maxbps)
4815 hinfo->maxbps = mout->spdif_maxbps;
4817 mout->share_spdif = 0;
4818 /* FIXME: need notify? */
4821 mutex_unlock(&codec->spdif_mutex);
4823 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4824 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4826 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4829 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4831 * Set up the i/o for analog out.
4832 * When the digital out is available, copy the front out to digital out, too.
4834 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4835 struct hda_multi_out *mout,
4836 unsigned int stream_tag,
4837 unsigned int format,
4838 struct snd_pcm_substream *substream)
4840 const hda_nid_t *nids = mout->dac_nids;
4841 int chs = substream->runtime->channels;
4842 struct hda_spdif_out *spdif;
4845 mutex_lock(&codec->spdif_mutex);
4846 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4847 if (mout->dig_out_nid && mout->share_spdif &&
4848 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4850 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4852 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4853 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4854 setup_dig_out_stream(codec, mout->dig_out_nid,
4855 stream_tag, format);
4857 mout->dig_out_used = 0;
4858 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4861 mutex_unlock(&codec->spdif_mutex);
4864 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4866 if (!mout->no_share_stream &&
4867 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4868 /* headphone out will just decode front left/right (stereo) */
4869 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4871 /* extra outputs copied from front */
4872 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4873 if (!mout->no_share_stream && mout->hp_out_nid[i])
4874 snd_hda_codec_setup_stream(codec,
4875 mout->hp_out_nid[i],
4876 stream_tag, 0, format);
4877 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4878 if (!mout->no_share_stream && mout->extra_out_nid[i])
4879 snd_hda_codec_setup_stream(codec,
4880 mout->extra_out_nid[i],
4881 stream_tag, 0, format);
4884 for (i = 1; i < mout->num_dacs; i++) {
4885 if (chs >= (i + 1) * 2) /* independent out */
4886 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4888 else if (!mout->no_share_stream) /* copy front */
4889 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4894 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4897 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4899 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4900 struct hda_multi_out *mout)
4902 const hda_nid_t *nids = mout->dac_nids;
4905 for (i = 0; i < mout->num_dacs; i++)
4906 snd_hda_codec_cleanup_stream(codec, nids[i]);
4908 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4909 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4910 if (mout->hp_out_nid[i])
4911 snd_hda_codec_cleanup_stream(codec,
4912 mout->hp_out_nid[i]);
4913 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4914 if (mout->extra_out_nid[i])
4915 snd_hda_codec_cleanup_stream(codec,
4916 mout->extra_out_nid[i]);
4917 mutex_lock(&codec->spdif_mutex);
4918 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4919 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4920 mout->dig_out_used = 0;
4922 mutex_unlock(&codec->spdif_mutex);
4925 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4928 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4930 * Guess the suitable VREF pin bits to be set as the pin-control value.
4931 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4933 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4935 unsigned int pincap;
4936 unsigned int oldval;
4937 oldval = snd_hda_codec_read(codec, pin, 0,
4938 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4939 pincap = snd_hda_query_pin_caps(codec, pin);
4940 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4941 /* Exception: if the default pin setup is vref50, we give it priority */
4942 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4943 return AC_PINCTL_VREF_80;
4944 else if (pincap & AC_PINCAP_VREF_50)
4945 return AC_PINCTL_VREF_50;
4946 else if (pincap & AC_PINCAP_VREF_100)
4947 return AC_PINCTL_VREF_100;
4948 else if (pincap & AC_PINCAP_VREF_GRD)
4949 return AC_PINCTL_VREF_GRD;
4950 return AC_PINCTL_VREF_HIZ;
4952 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
4954 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4955 unsigned int val, bool cached)
4958 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
4959 if (cap && (val & AC_PINCTL_OUT_EN)) {
4960 if (!(cap & AC_PINCAP_OUT))
4961 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4962 else if ((val & AC_PINCTL_HP_EN) &&
4963 !(cap & AC_PINCAP_HP_DRV))
4964 val &= ~AC_PINCTL_HP_EN;
4966 if (cap && (val & AC_PINCTL_IN_EN)) {
4967 if (!(cap & AC_PINCAP_IN))
4968 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
4972 return snd_hda_codec_update_cache(codec, pin, 0,
4973 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4975 return snd_hda_codec_write(codec, pin, 0,
4976 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
4978 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
4981 * snd_hda_add_imux_item - Add an item to input_mux
4983 * When the same label is used already in the existing items, the number
4984 * suffix is appended to the label. This label index number is stored
4985 * to type_idx when non-NULL pointer is given.
4987 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
4988 int index, int *type_idx)
4990 int i, label_idx = 0;
4991 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4992 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
4995 for (i = 0; i < imux->num_items; i++) {
4996 if (!strncmp(label, imux->items[i].label, strlen(label)))
5000 *type_idx = label_idx;
5002 snprintf(imux->items[imux->num_items].label,
5003 sizeof(imux->items[imux->num_items].label),
5004 "%s %d", label, label_idx);
5006 strlcpy(imux->items[imux->num_items].label, label,
5007 sizeof(imux->items[imux->num_items].label));
5008 imux->items[imux->num_items].index = index;
5012 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5021 * snd_hda_suspend - suspend the codecs
5024 * Returns 0 if successful.
5026 int snd_hda_suspend(struct hda_bus *bus)
5028 struct hda_codec *codec;
5030 list_for_each_entry(codec, &bus->codec_list, list) {
5031 if (hda_codec_is_power_on(codec))
5032 hda_call_codec_suspend(codec);
5036 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5039 * snd_hda_resume - resume the codecs
5042 * Returns 0 if successful.
5044 * This function is defined only when POWER_SAVE isn't set.
5045 * In the power-save mode, the codec is resumed dynamically.
5047 int snd_hda_resume(struct hda_bus *bus)
5049 struct hda_codec *codec;
5051 list_for_each_entry(codec, &bus->codec_list, list) {
5052 hda_call_codec_resume(codec);
5056 EXPORT_SYMBOL_HDA(snd_hda_resume);
5057 #endif /* CONFIG_PM */
5064 * snd_array_new - get a new element from the given array
5065 * @array: the array object
5067 * Get a new element from the given array. If it exceeds the
5068 * pre-allocated array size, re-allocate the array.
5070 * Returns NULL if allocation failed.
5072 void *snd_array_new(struct snd_array *array)
5074 if (array->used >= array->alloced) {
5075 int num = array->alloced + array->alloc_align;
5076 int size = (num + 1) * array->elem_size;
5077 int oldsize = array->alloced * array->elem_size;
5079 if (snd_BUG_ON(num >= 4096))
5081 nlist = krealloc(array->list, size, GFP_KERNEL);
5084 memset(nlist + oldsize, 0, size - oldsize);
5085 array->list = nlist;
5086 array->alloced = num;
5088 return snd_array_elem(array, array->used++);
5090 EXPORT_SYMBOL_HDA(snd_array_new);
5093 * snd_array_free - free the given array elements
5094 * @array: the array object
5096 void snd_array_free(struct snd_array *array)
5103 EXPORT_SYMBOL_HDA(snd_array_free);
5106 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5107 * @pcm: PCM caps bits
5108 * @buf: the string buffer to write
5109 * @buflen: the max buffer length
5111 * used by hda_proc.c and hda_eld.c
5113 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5115 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5118 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5119 if (pcm & (AC_SUPPCM_BITS_8 << i))
5120 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5122 buf[j] = '\0'; /* necessary when j == 0 */
5124 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5126 MODULE_DESCRIPTION("HDA codec core");
5127 MODULE_LICENSE("GPL");