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);
1389 /* update the stream-id if changed */
1390 static void update_pcm_stream_id(struct hda_codec *codec,
1391 struct hda_cvt_setup *p, hda_nid_t nid,
1392 u32 stream_tag, int channel_id)
1394 unsigned int oldval, newval;
1396 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1397 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1398 newval = (stream_tag << 4) | channel_id;
1399 if (oldval != newval)
1400 snd_hda_codec_write(codec, nid, 0,
1401 AC_VERB_SET_CHANNEL_STREAMID,
1403 p->stream_tag = stream_tag;
1404 p->channel_id = channel_id;
1408 /* update the format-id if changed */
1409 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1410 hda_nid_t nid, int format)
1412 unsigned int oldval;
1414 if (p->format_id != format) {
1415 oldval = snd_hda_codec_read(codec, nid, 0,
1416 AC_VERB_GET_STREAM_FORMAT, 0);
1417 if (oldval != format) {
1419 snd_hda_codec_write(codec, nid, 0,
1420 AC_VERB_SET_STREAM_FORMAT,
1423 p->format_id = format;
1428 * snd_hda_codec_setup_stream - set up the codec for streaming
1429 * @codec: the CODEC to set up
1430 * @nid: the NID to set up
1431 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1432 * @channel_id: channel id to pass, zero based.
1433 * @format: stream format.
1435 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1437 int channel_id, int format)
1439 struct hda_codec *c;
1440 struct hda_cvt_setup *p;
1447 snd_printdd("hda_codec_setup_stream: "
1448 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1449 nid, stream_tag, channel_id, format);
1450 p = get_hda_cvt_setup(codec, nid);
1454 if (codec->pcm_format_first)
1455 update_pcm_format(codec, p, nid, format);
1456 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1457 if (!codec->pcm_format_first)
1458 update_pcm_format(codec, p, nid, format);
1463 /* make other inactive cvts with the same stream-tag dirty */
1464 type = get_wcaps_type(get_wcaps(codec, nid));
1465 list_for_each_entry(c, &codec->bus->codec_list, list) {
1466 for (i = 0; i < c->cvt_setups.used; i++) {
1467 p = snd_array_elem(&c->cvt_setups, i);
1468 if (!p->active && p->stream_tag == stream_tag &&
1469 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1474 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1476 static void really_cleanup_stream(struct hda_codec *codec,
1477 struct hda_cvt_setup *q);
1480 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1481 * @codec: the CODEC to clean up
1482 * @nid: the NID to clean up
1483 * @do_now: really clean up the stream instead of clearing the active flag
1485 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1488 struct hda_cvt_setup *p;
1493 if (codec->no_sticky_stream)
1496 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1497 p = get_hda_cvt_setup(codec, nid);
1499 /* here we just clear the active flag when do_now isn't set;
1500 * actual clean-ups will be done later in
1501 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1504 really_cleanup_stream(codec, p);
1509 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1511 static void really_cleanup_stream(struct hda_codec *codec,
1512 struct hda_cvt_setup *q)
1514 hda_nid_t nid = q->nid;
1515 if (q->stream_tag || q->channel_id)
1516 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1518 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1520 memset(q, 0, sizeof(*q));
1524 /* clean up the all conflicting obsolete streams */
1525 static void purify_inactive_streams(struct hda_codec *codec)
1527 struct hda_codec *c;
1530 list_for_each_entry(c, &codec->bus->codec_list, list) {
1531 for (i = 0; i < c->cvt_setups.used; i++) {
1532 struct hda_cvt_setup *p;
1533 p = snd_array_elem(&c->cvt_setups, i);
1535 really_cleanup_stream(c, p);
1541 /* clean up all streams; called from suspend */
1542 static void hda_cleanup_all_streams(struct hda_codec *codec)
1546 for (i = 0; i < codec->cvt_setups.used; i++) {
1547 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1549 really_cleanup_stream(codec, p);
1555 * amp access functions
1558 /* FIXME: more better hash key? */
1559 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1560 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1561 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1562 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1563 #define INFO_AMP_CAPS (1<<0)
1564 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1566 /* initialize the hash table */
1567 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1568 unsigned int record_size)
1570 memset(cache, 0, sizeof(*cache));
1571 memset(cache->hash, 0xff, sizeof(cache->hash));
1572 snd_array_init(&cache->buf, record_size, 64);
1575 static void free_hda_cache(struct hda_cache_rec *cache)
1577 snd_array_free(&cache->buf);
1580 /* query the hash. allocate an entry if not found. */
1581 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1583 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1584 u16 cur = cache->hash[idx];
1585 struct hda_cache_head *info;
1587 while (cur != 0xffff) {
1588 info = snd_array_elem(&cache->buf, cur);
1589 if (info->key == key)
1596 /* query the hash. allocate an entry if not found. */
1597 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1600 struct hda_cache_head *info = get_hash(cache, key);
1603 /* add a new hash entry */
1604 info = snd_array_new(&cache->buf);
1607 cur = snd_array_index(&cache->buf, info);
1610 idx = key % (u16)ARRAY_SIZE(cache->hash);
1611 info->next = cache->hash[idx];
1612 cache->hash[idx] = cur;
1617 /* query and allocate an amp hash entry */
1618 static inline struct hda_amp_info *
1619 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1621 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1624 /* overwrite the value with the key in the caps hash */
1625 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1627 struct hda_amp_info *info;
1629 mutex_lock(&codec->hash_mutex);
1630 info = get_alloc_amp_hash(codec, key);
1632 mutex_unlock(&codec->hash_mutex);
1635 info->amp_caps = val;
1636 info->head.val |= INFO_AMP_CAPS;
1637 mutex_unlock(&codec->hash_mutex);
1641 /* query the value from the caps hash; if not found, fetch the current
1642 * value from the given function and store in the hash
1645 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1646 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1648 struct hda_amp_info *info;
1651 mutex_lock(&codec->hash_mutex);
1652 info = get_alloc_amp_hash(codec, key);
1654 mutex_unlock(&codec->hash_mutex);
1657 if (!(info->head.val & INFO_AMP_CAPS)) {
1658 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1659 val = func(codec, nid, dir);
1660 write_caps_hash(codec, key, val);
1662 val = info->amp_caps;
1663 mutex_unlock(&codec->hash_mutex);
1668 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1671 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1673 return snd_hda_param_read(codec, nid,
1674 direction == HDA_OUTPUT ?
1675 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1679 * query_amp_caps - query AMP capabilities
1680 * @codec: the HD-auio codec
1681 * @nid: the NID to query
1682 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1684 * Query AMP capabilities for the given widget and direction.
1685 * Returns the obtained capability bits.
1687 * When cap bits have been already read, this doesn't read again but
1688 * returns the cached value.
1690 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1692 return query_caps_hash(codec, nid, direction,
1693 HDA_HASH_KEY(nid, direction, 0),
1696 EXPORT_SYMBOL_HDA(query_amp_caps);
1699 * snd_hda_override_amp_caps - Override the AMP capabilities
1700 * @codec: the CODEC to clean up
1701 * @nid: the NID to clean up
1702 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1703 * @caps: the capability bits to set
1705 * Override the cached AMP caps bits value by the given one.
1706 * This function is useful if the driver needs to adjust the AMP ranges,
1707 * e.g. limit to 0dB, etc.
1709 * Returns zero if successful or a negative error code.
1711 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1714 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1716 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1718 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1721 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1725 * snd_hda_query_pin_caps - Query PIN capabilities
1726 * @codec: the HD-auio codec
1727 * @nid: the NID to query
1729 * Query PIN capabilities for the given widget.
1730 * Returns the obtained capability bits.
1732 * When cap bits have been already read, this doesn't read again but
1733 * returns the cached value.
1735 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1737 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1740 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1743 * snd_hda_override_pin_caps - Override the pin capabilities
1745 * @nid: the NID to override
1746 * @caps: the capability bits to set
1748 * Override the cached PIN capabilitiy bits value by the given one.
1750 * Returns zero if successful or a negative error code.
1752 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1755 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1757 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1759 /* read or sync the hash value with the current value;
1760 * call within hash_mutex
1762 static struct hda_amp_info *
1763 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1764 int direction, int index)
1766 struct hda_amp_info *info;
1767 unsigned int parm, val = 0;
1768 bool val_read = false;
1771 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1774 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1776 mutex_unlock(&codec->hash_mutex);
1777 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1778 parm |= direction == HDA_OUTPUT ?
1779 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1781 val = snd_hda_codec_read(codec, nid, 0,
1782 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1785 mutex_lock(&codec->hash_mutex);
1788 info->vol[ch] = val;
1789 info->head.val |= INFO_AMP_VOL(ch);
1795 * write the current volume in info to the h/w
1797 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1798 hda_nid_t nid, int ch, int direction, int index,
1803 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1804 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1805 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1806 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1807 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1808 ; /* set the zero value as a fake mute */
1811 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1815 * snd_hda_codec_amp_read - Read AMP value
1816 * @codec: HD-audio codec
1817 * @nid: NID to read the AMP value
1818 * @ch: channel (left=0 or right=1)
1819 * @direction: #HDA_INPUT or #HDA_OUTPUT
1820 * @index: the index value (only for input direction)
1822 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1824 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1825 int direction, int index)
1827 struct hda_amp_info *info;
1828 unsigned int val = 0;
1830 mutex_lock(&codec->hash_mutex);
1831 info = update_amp_hash(codec, nid, ch, direction, index);
1833 val = info->vol[ch];
1834 mutex_unlock(&codec->hash_mutex);
1837 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1840 * snd_hda_codec_amp_update - update the AMP value
1841 * @codec: HD-audio codec
1842 * @nid: NID to read the AMP value
1843 * @ch: channel (left=0 or right=1)
1844 * @direction: #HDA_INPUT or #HDA_OUTPUT
1845 * @idx: the index value (only for input direction)
1846 * @mask: bit mask to set
1847 * @val: the bits value to set
1849 * Update the AMP value with a bit mask.
1850 * Returns 0 if the value is unchanged, 1 if changed.
1852 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1853 int direction, int idx, int mask, int val)
1855 struct hda_amp_info *info;
1857 if (snd_BUG_ON(mask & ~0xff))
1861 mutex_lock(&codec->hash_mutex);
1862 info = update_amp_hash(codec, nid, ch, direction, idx);
1864 mutex_unlock(&codec->hash_mutex);
1867 val |= info->vol[ch] & ~mask;
1868 if (info->vol[ch] == val) {
1869 mutex_unlock(&codec->hash_mutex);
1872 info->vol[ch] = val;
1873 mutex_unlock(&codec->hash_mutex);
1874 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1877 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1880 * snd_hda_codec_amp_stereo - update the AMP stereo values
1881 * @codec: HD-audio codec
1882 * @nid: NID to read the AMP value
1883 * @direction: #HDA_INPUT or #HDA_OUTPUT
1884 * @idx: the index value (only for input direction)
1885 * @mask: bit mask to set
1886 * @val: the bits value to set
1888 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1889 * stereo widget with the same mask and value.
1891 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1892 int direction, int idx, int mask, int val)
1896 if (snd_BUG_ON(mask & ~0xff))
1898 for (ch = 0; ch < 2; ch++)
1899 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1903 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1907 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1908 * @codec: HD-audio codec
1910 * Resume the all amp commands from the cache.
1912 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1914 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1917 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1918 u32 key = buffer->head.key;
1920 unsigned int idx, dir, ch;
1924 idx = (key >> 16) & 0xff;
1925 dir = (key >> 24) & 0xff;
1926 for (ch = 0; ch < 2; ch++) {
1927 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1929 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1934 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1935 #endif /* CONFIG_PM */
1937 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1940 u32 caps = query_amp_caps(codec, nid, dir);
1942 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1949 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1951 * The control element is supposed to have the private_value field
1952 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1954 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1955 struct snd_ctl_elem_info *uinfo)
1957 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1958 u16 nid = get_amp_nid(kcontrol);
1959 u8 chs = get_amp_channels(kcontrol);
1960 int dir = get_amp_direction(kcontrol);
1961 unsigned int ofs = get_amp_offset(kcontrol);
1963 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1964 uinfo->count = chs == 3 ? 2 : 1;
1965 uinfo->value.integer.min = 0;
1966 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1967 if (!uinfo->value.integer.max) {
1968 printk(KERN_WARNING "hda_codec: "
1969 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1975 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1978 static inline unsigned int
1979 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1980 int ch, int dir, int idx, unsigned int ofs)
1983 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1984 val &= HDA_AMP_VOLMASK;
1993 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1994 int ch, int dir, int idx, unsigned int ofs,
1997 unsigned int maxval;
2001 /* ofs = 0: raw max value */
2002 maxval = get_amp_max_value(codec, nid, dir, 0);
2005 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2006 HDA_AMP_VOLMASK, val);
2010 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2012 * The control element is supposed to have the private_value field
2013 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2015 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2016 struct snd_ctl_elem_value *ucontrol)
2018 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2019 hda_nid_t nid = get_amp_nid(kcontrol);
2020 int chs = get_amp_channels(kcontrol);
2021 int dir = get_amp_direction(kcontrol);
2022 int idx = get_amp_index(kcontrol);
2023 unsigned int ofs = get_amp_offset(kcontrol);
2024 long *valp = ucontrol->value.integer.value;
2027 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2029 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2032 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2035 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2037 * The control element is supposed to have the private_value field
2038 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2040 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2041 struct snd_ctl_elem_value *ucontrol)
2043 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2044 hda_nid_t nid = get_amp_nid(kcontrol);
2045 int chs = get_amp_channels(kcontrol);
2046 int dir = get_amp_direction(kcontrol);
2047 int idx = get_amp_index(kcontrol);
2048 unsigned int ofs = get_amp_offset(kcontrol);
2049 long *valp = ucontrol->value.integer.value;
2052 snd_hda_power_up(codec);
2054 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2058 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2059 snd_hda_power_down(codec);
2062 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2065 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2067 * The control element is supposed to have the private_value field
2068 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2070 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2071 unsigned int size, unsigned int __user *_tlv)
2073 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2074 hda_nid_t nid = get_amp_nid(kcontrol);
2075 int dir = get_amp_direction(kcontrol);
2076 unsigned int ofs = get_amp_offset(kcontrol);
2077 bool min_mute = get_amp_min_mute(kcontrol);
2078 u32 caps, val1, val2;
2080 if (size < 4 * sizeof(unsigned int))
2082 caps = query_amp_caps(codec, nid, dir);
2083 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2084 val2 = (val2 + 1) * 25;
2085 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2087 val1 = ((int)val1) * ((int)val2);
2088 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2089 val2 |= TLV_DB_SCALE_MUTE;
2090 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2092 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2094 if (put_user(val1, _tlv + 2))
2096 if (put_user(val2, _tlv + 3))
2100 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2103 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2104 * @codec: HD-audio codec
2105 * @nid: NID of a reference widget
2106 * @dir: #HDA_INPUT or #HDA_OUTPUT
2107 * @tlv: TLV data to be stored, at least 4 elements
2109 * Set (static) TLV data for a virtual master volume using the AMP caps
2110 * obtained from the reference NID.
2111 * The volume range is recalculated as if the max volume is 0dB.
2113 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2119 caps = query_amp_caps(codec, nid, dir);
2120 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2121 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2122 step = (step + 1) * 25;
2123 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2124 tlv[1] = 2 * sizeof(unsigned int);
2125 tlv[2] = -nums * step;
2128 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2130 /* find a mixer control element with the given name */
2131 static struct snd_kcontrol *
2132 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2133 const char *name, int idx)
2135 struct snd_ctl_elem_id id;
2136 memset(&id, 0, sizeof(id));
2137 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2139 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2141 strcpy(id.name, name);
2142 return snd_ctl_find_id(codec->bus->card, &id);
2146 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2147 * @codec: HD-audio codec
2148 * @name: ctl id name string
2150 * Get the control element with the given id string and IFACE_MIXER.
2152 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2155 return _snd_hda_find_mixer_ctl(codec, name, 0);
2157 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2159 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2162 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2163 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2170 * snd_hda_ctl_add - Add a control element and assign to the codec
2171 * @codec: HD-audio codec
2172 * @nid: corresponding NID (optional)
2173 * @kctl: the control element to assign
2175 * Add the given control element to an array inside the codec instance.
2176 * All control elements belonging to a codec are supposed to be added
2177 * by this function so that a proper clean-up works at the free or
2178 * reconfiguration time.
2180 * If non-zero @nid is passed, the NID is assigned to the control element.
2181 * The assignment is shown in the codec proc file.
2183 * snd_hda_ctl_add() checks the control subdev id field whether
2184 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2185 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2186 * specifies if kctl->private_value is a HDA amplifier value.
2188 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2189 struct snd_kcontrol *kctl)
2192 unsigned short flags = 0;
2193 struct hda_nid_item *item;
2195 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2196 flags |= HDA_NID_ITEM_AMP;
2198 nid = get_amp_nid_(kctl->private_value);
2200 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2201 nid = kctl->id.subdevice & 0xffff;
2202 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2203 kctl->id.subdevice = 0;
2204 err = snd_ctl_add(codec->bus->card, kctl);
2207 item = snd_array_new(&codec->mixers);
2212 item->flags = flags;
2215 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2218 * snd_hda_add_nid - Assign a NID to a control element
2219 * @codec: HD-audio codec
2220 * @nid: corresponding NID (optional)
2221 * @kctl: the control element to assign
2222 * @index: index to kctl
2224 * Add the given control element to an array inside the codec instance.
2225 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2226 * NID:KCTL mapping - for example "Capture Source" selector.
2228 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2229 unsigned int index, hda_nid_t nid)
2231 struct hda_nid_item *item;
2234 item = snd_array_new(&codec->nids);
2238 item->index = index;
2242 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2243 kctl->id.name, kctl->id.index, index);
2246 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2249 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2250 * @codec: HD-audio codec
2252 void snd_hda_ctls_clear(struct hda_codec *codec)
2255 struct hda_nid_item *items = codec->mixers.list;
2256 for (i = 0; i < codec->mixers.used; i++)
2257 snd_ctl_remove(codec->bus->card, items[i].kctl);
2258 snd_array_free(&codec->mixers);
2259 snd_array_free(&codec->nids);
2262 /* pseudo device locking
2263 * toggle card->shutdown to allow/disallow the device access (as a hack)
2265 int snd_hda_lock_devices(struct hda_bus *bus)
2267 struct snd_card *card = bus->card;
2268 struct hda_codec *codec;
2270 spin_lock(&card->files_lock);
2274 if (!list_empty(&card->ctl_files))
2277 list_for_each_entry(codec, &bus->codec_list, list) {
2279 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2280 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2283 if (cpcm->pcm->streams[0].substream_opened ||
2284 cpcm->pcm->streams[1].substream_opened)
2288 spin_unlock(&card->files_lock);
2294 spin_unlock(&card->files_lock);
2297 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2299 void snd_hda_unlock_devices(struct hda_bus *bus)
2301 struct snd_card *card = bus->card;
2304 spin_lock(&card->files_lock);
2306 spin_unlock(&card->files_lock);
2308 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2311 * snd_hda_codec_reset - Clear all objects assigned to the codec
2312 * @codec: HD-audio codec
2314 * This frees the all PCM and control elements assigned to the codec, and
2315 * clears the caches and restores the pin default configurations.
2317 * When a device is being used, it returns -EBSY. If successfully freed,
2320 int snd_hda_codec_reset(struct hda_codec *codec)
2322 struct hda_bus *bus = codec->bus;
2323 struct snd_card *card = bus->card;
2326 if (snd_hda_lock_devices(bus) < 0)
2329 /* OK, let it free */
2331 #ifdef CONFIG_SND_HDA_POWER_SAVE
2332 cancel_delayed_work_sync(&codec->power_work);
2333 codec->power_on = 0;
2334 codec->power_transition = 0;
2335 codec->power_jiffies = jiffies;
2336 flush_workqueue(bus->workq);
2338 snd_hda_ctls_clear(codec);
2340 for (i = 0; i < codec->num_pcms; i++) {
2341 if (codec->pcm_info[i].pcm) {
2342 snd_device_free(card, codec->pcm_info[i].pcm);
2343 clear_bit(codec->pcm_info[i].device,
2347 if (codec->patch_ops.free)
2348 codec->patch_ops.free(codec);
2349 snd_hda_jack_tbl_clear(codec);
2350 codec->proc_widget_hook = NULL;
2352 free_hda_cache(&codec->amp_cache);
2353 free_hda_cache(&codec->cmd_cache);
2354 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2355 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2356 /* free only driver_pins so that init_pins + user_pins are restored */
2357 snd_array_free(&codec->driver_pins);
2358 restore_pincfgs(codec);
2359 snd_array_free(&codec->cvt_setups);
2360 snd_array_free(&codec->spdif_out);
2361 codec->num_pcms = 0;
2362 codec->pcm_info = NULL;
2363 codec->preset = NULL;
2364 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2365 codec->slave_dig_outs = NULL;
2366 codec->spdif_status_reset = 0;
2367 module_put(codec->owner);
2368 codec->owner = NULL;
2370 /* allow device access again */
2371 snd_hda_unlock_devices(bus);
2375 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2377 /* apply the function to all matching slave ctls in the mixer list */
2378 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2379 const char *suffix, map_slave_func_t func, void *data)
2381 struct hda_nid_item *items;
2382 const char * const *s;
2385 items = codec->mixers.list;
2386 for (i = 0; i < codec->mixers.used; i++) {
2387 struct snd_kcontrol *sctl = items[i].kctl;
2388 if (!sctl || !sctl->id.name ||
2389 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2391 for (s = slaves; *s; s++) {
2392 char tmpname[sizeof(sctl->id.name)];
2393 const char *name = *s;
2395 snprintf(tmpname, sizeof(tmpname), "%s %s",
2399 if (!strcmp(sctl->id.name, name)) {
2400 err = func(data, sctl);
2410 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2415 /* guess the value corresponding to 0dB */
2416 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2419 const int *tlv = NULL;
2422 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2423 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2424 mm_segment_t fs = get_fs();
2426 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2429 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2431 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2432 val = -tlv[2] / tlv[3];
2436 /* call kctl->put with the given value(s) */
2437 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2439 struct snd_ctl_elem_value *ucontrol;
2440 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2443 ucontrol->value.integer.value[0] = val;
2444 ucontrol->value.integer.value[1] = val;
2445 kctl->put(kctl, ucontrol);
2450 /* initialize the slave volume with 0dB */
2451 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2453 int offset = get_kctl_0dB_offset(slave);
2455 put_kctl_with_value(slave, offset);
2459 /* unmute the slave */
2460 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2462 return put_kctl_with_value(slave, 1);
2466 * snd_hda_add_vmaster - create a virtual master control and add slaves
2467 * @codec: HD-audio codec
2468 * @name: vmaster control name
2469 * @tlv: TLV data (optional)
2470 * @slaves: slave control names (optional)
2471 * @suffix: suffix string to each slave name (optional)
2472 * @init_slave_vol: initialize slaves to unmute/0dB
2473 * @ctl_ret: store the vmaster kcontrol in return
2475 * Create a virtual master control with the given name. The TLV data
2476 * must be either NULL or a valid data.
2478 * @slaves is a NULL-terminated array of strings, each of which is a
2479 * slave control name. All controls with these names are assigned to
2480 * the new virtual master control.
2482 * This function returns zero if successful or a negative error code.
2484 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2485 unsigned int *tlv, const char * const *slaves,
2486 const char *suffix, bool init_slave_vol,
2487 struct snd_kcontrol **ctl_ret)
2489 struct snd_kcontrol *kctl;
2495 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2497 snd_printdd("No slave found for %s\n", name);
2500 kctl = snd_ctl_make_virtual_master(name, tlv);
2503 err = snd_hda_ctl_add(codec, 0, kctl);
2507 err = map_slaves(codec, slaves, suffix,
2508 (map_slave_func_t)snd_ctl_add_slave, kctl);
2512 /* init with master mute & zero volume */
2513 put_kctl_with_value(kctl, 0);
2515 map_slaves(codec, slaves, suffix,
2516 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2522 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2525 * mute-LED control using vmaster
2527 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2528 struct snd_ctl_elem_info *uinfo)
2530 static const char * const texts[] = {
2531 "Off", "On", "Follow Master"
2535 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2537 uinfo->value.enumerated.items = 3;
2538 index = uinfo->value.enumerated.item;
2541 strcpy(uinfo->value.enumerated.name, texts[index]);
2545 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2546 struct snd_ctl_elem_value *ucontrol)
2548 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2549 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2553 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2554 struct snd_ctl_elem_value *ucontrol)
2556 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2557 unsigned int old_mode = hook->mute_mode;
2559 hook->mute_mode = ucontrol->value.enumerated.item[0];
2560 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2561 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2562 if (old_mode == hook->mute_mode)
2564 snd_hda_sync_vmaster_hook(hook);
2568 static struct snd_kcontrol_new vmaster_mute_mode = {
2569 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2570 .name = "Mute-LED Mode",
2571 .info = vmaster_mute_mode_info,
2572 .get = vmaster_mute_mode_get,
2573 .put = vmaster_mute_mode_put,
2577 * Add a mute-LED hook with the given vmaster switch kctl
2578 * "Mute-LED Mode" control is automatically created and associated with
2581 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2582 struct hda_vmaster_mute_hook *hook,
2583 bool expose_enum_ctl)
2585 struct snd_kcontrol *kctl;
2587 if (!hook->hook || !hook->sw_kctl)
2589 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2590 hook->codec = codec;
2591 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2592 if (!expose_enum_ctl)
2594 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2597 return snd_hda_ctl_add(codec, 0, kctl);
2599 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2602 * Call the hook with the current value for synchronization
2603 * Should be called in init callback
2605 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2607 if (!hook->hook || !hook->codec)
2609 switch (hook->mute_mode) {
2610 case HDA_VMUTE_FOLLOW_MASTER:
2611 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2614 hook->hook(hook->codec, hook->mute_mode);
2618 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2622 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2624 * The control element is supposed to have the private_value field
2625 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2627 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2628 struct snd_ctl_elem_info *uinfo)
2630 int chs = get_amp_channels(kcontrol);
2632 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2633 uinfo->count = chs == 3 ? 2 : 1;
2634 uinfo->value.integer.min = 0;
2635 uinfo->value.integer.max = 1;
2638 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2641 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2643 * The control element is supposed to have the private_value field
2644 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2646 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2647 struct snd_ctl_elem_value *ucontrol)
2649 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2650 hda_nid_t nid = get_amp_nid(kcontrol);
2651 int chs = get_amp_channels(kcontrol);
2652 int dir = get_amp_direction(kcontrol);
2653 int idx = get_amp_index(kcontrol);
2654 long *valp = ucontrol->value.integer.value;
2657 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2658 HDA_AMP_MUTE) ? 0 : 1;
2660 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2661 HDA_AMP_MUTE) ? 0 : 1;
2664 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2667 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2669 * The control element is supposed to have the private_value field
2670 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2672 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2673 struct snd_ctl_elem_value *ucontrol)
2675 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2676 hda_nid_t nid = get_amp_nid(kcontrol);
2677 int chs = get_amp_channels(kcontrol);
2678 int dir = get_amp_direction(kcontrol);
2679 int idx = get_amp_index(kcontrol);
2680 long *valp = ucontrol->value.integer.value;
2683 snd_hda_power_up(codec);
2685 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2687 *valp ? 0 : HDA_AMP_MUTE);
2691 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2693 *valp ? 0 : HDA_AMP_MUTE);
2694 hda_call_check_power_status(codec, nid);
2695 snd_hda_power_down(codec);
2698 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2701 * bound volume controls
2703 * bind multiple volumes (# indices, from 0)
2706 #define AMP_VAL_IDX_SHIFT 19
2707 #define AMP_VAL_IDX_MASK (0x0f<<19)
2710 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2712 * The control element is supposed to have the private_value field
2713 * set up via HDA_BIND_MUTE*() macros.
2715 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2716 struct snd_ctl_elem_value *ucontrol)
2718 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2722 mutex_lock(&codec->control_mutex);
2723 pval = kcontrol->private_value;
2724 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2725 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2726 kcontrol->private_value = pval;
2727 mutex_unlock(&codec->control_mutex);
2730 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2733 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2735 * The control element is supposed to have the private_value field
2736 * set up via HDA_BIND_MUTE*() macros.
2738 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2739 struct snd_ctl_elem_value *ucontrol)
2741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2743 int i, indices, err = 0, change = 0;
2745 mutex_lock(&codec->control_mutex);
2746 pval = kcontrol->private_value;
2747 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2748 for (i = 0; i < indices; i++) {
2749 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2750 (i << AMP_VAL_IDX_SHIFT);
2751 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2756 kcontrol->private_value = pval;
2757 mutex_unlock(&codec->control_mutex);
2758 return err < 0 ? err : change;
2760 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2763 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2765 * The control element is supposed to have the private_value field
2766 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2768 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2769 struct snd_ctl_elem_info *uinfo)
2771 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2772 struct hda_bind_ctls *c;
2775 mutex_lock(&codec->control_mutex);
2776 c = (struct hda_bind_ctls *)kcontrol->private_value;
2777 kcontrol->private_value = *c->values;
2778 err = c->ops->info(kcontrol, uinfo);
2779 kcontrol->private_value = (long)c;
2780 mutex_unlock(&codec->control_mutex);
2783 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2786 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2788 * The control element is supposed to have the private_value field
2789 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2791 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2792 struct snd_ctl_elem_value *ucontrol)
2794 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2795 struct hda_bind_ctls *c;
2798 mutex_lock(&codec->control_mutex);
2799 c = (struct hda_bind_ctls *)kcontrol->private_value;
2800 kcontrol->private_value = *c->values;
2801 err = c->ops->get(kcontrol, ucontrol);
2802 kcontrol->private_value = (long)c;
2803 mutex_unlock(&codec->control_mutex);
2806 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2809 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2811 * The control element is supposed to have the private_value field
2812 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2814 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2815 struct snd_ctl_elem_value *ucontrol)
2817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2818 struct hda_bind_ctls *c;
2819 unsigned long *vals;
2820 int err = 0, change = 0;
2822 mutex_lock(&codec->control_mutex);
2823 c = (struct hda_bind_ctls *)kcontrol->private_value;
2824 for (vals = c->values; *vals; vals++) {
2825 kcontrol->private_value = *vals;
2826 err = c->ops->put(kcontrol, ucontrol);
2831 kcontrol->private_value = (long)c;
2832 mutex_unlock(&codec->control_mutex);
2833 return err < 0 ? err : change;
2835 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2838 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2840 * The control element is supposed to have the private_value field
2841 * set up via HDA_BIND_VOL() macro.
2843 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2844 unsigned int size, unsigned int __user *tlv)
2846 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2847 struct hda_bind_ctls *c;
2850 mutex_lock(&codec->control_mutex);
2851 c = (struct hda_bind_ctls *)kcontrol->private_value;
2852 kcontrol->private_value = *c->values;
2853 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2854 kcontrol->private_value = (long)c;
2855 mutex_unlock(&codec->control_mutex);
2858 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2860 struct hda_ctl_ops snd_hda_bind_vol = {
2861 .info = snd_hda_mixer_amp_volume_info,
2862 .get = snd_hda_mixer_amp_volume_get,
2863 .put = snd_hda_mixer_amp_volume_put,
2864 .tlv = snd_hda_mixer_amp_tlv
2866 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2868 struct hda_ctl_ops snd_hda_bind_sw = {
2869 .info = snd_hda_mixer_amp_switch_info,
2870 .get = snd_hda_mixer_amp_switch_get,
2871 .put = snd_hda_mixer_amp_switch_put,
2872 .tlv = snd_hda_mixer_amp_tlv
2874 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2877 * SPDIF out controls
2880 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2881 struct snd_ctl_elem_info *uinfo)
2883 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2888 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2889 struct snd_ctl_elem_value *ucontrol)
2891 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2892 IEC958_AES0_NONAUDIO |
2893 IEC958_AES0_CON_EMPHASIS_5015 |
2894 IEC958_AES0_CON_NOT_COPYRIGHT;
2895 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2896 IEC958_AES1_CON_ORIGINAL;
2900 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2901 struct snd_ctl_elem_value *ucontrol)
2903 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2904 IEC958_AES0_NONAUDIO |
2905 IEC958_AES0_PRO_EMPHASIS_5015;
2909 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2910 struct snd_ctl_elem_value *ucontrol)
2912 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2913 int idx = kcontrol->private_value;
2914 struct hda_spdif_out *spdif;
2916 mutex_lock(&codec->spdif_mutex);
2917 spdif = snd_array_elem(&codec->spdif_out, idx);
2918 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2919 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2920 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2921 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2922 mutex_unlock(&codec->spdif_mutex);
2927 /* convert from SPDIF status bits to HDA SPDIF bits
2928 * bit 0 (DigEn) is always set zero (to be filled later)
2930 static unsigned short convert_from_spdif_status(unsigned int sbits)
2932 unsigned short val = 0;
2934 if (sbits & IEC958_AES0_PROFESSIONAL)
2935 val |= AC_DIG1_PROFESSIONAL;
2936 if (sbits & IEC958_AES0_NONAUDIO)
2937 val |= AC_DIG1_NONAUDIO;
2938 if (sbits & IEC958_AES0_PROFESSIONAL) {
2939 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2940 IEC958_AES0_PRO_EMPHASIS_5015)
2941 val |= AC_DIG1_EMPHASIS;
2943 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2944 IEC958_AES0_CON_EMPHASIS_5015)
2945 val |= AC_DIG1_EMPHASIS;
2946 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2947 val |= AC_DIG1_COPYRIGHT;
2948 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2949 val |= AC_DIG1_LEVEL;
2950 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2955 /* convert to SPDIF status bits from HDA SPDIF bits
2957 static unsigned int convert_to_spdif_status(unsigned short val)
2959 unsigned int sbits = 0;
2961 if (val & AC_DIG1_NONAUDIO)
2962 sbits |= IEC958_AES0_NONAUDIO;
2963 if (val & AC_DIG1_PROFESSIONAL)
2964 sbits |= IEC958_AES0_PROFESSIONAL;
2965 if (sbits & IEC958_AES0_PROFESSIONAL) {
2966 if (sbits & AC_DIG1_EMPHASIS)
2967 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2969 if (val & AC_DIG1_EMPHASIS)
2970 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2971 if (!(val & AC_DIG1_COPYRIGHT))
2972 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2973 if (val & AC_DIG1_LEVEL)
2974 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2975 sbits |= val & (0x7f << 8);
2980 /* set digital convert verbs both for the given NID and its slaves */
2981 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2986 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2987 d = codec->slave_dig_outs;
2991 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2994 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2998 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3000 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3003 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3004 struct snd_ctl_elem_value *ucontrol)
3006 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3007 int idx = kcontrol->private_value;
3008 struct hda_spdif_out *spdif;
3013 mutex_lock(&codec->spdif_mutex);
3014 spdif = snd_array_elem(&codec->spdif_out, idx);
3016 spdif->status = ucontrol->value.iec958.status[0] |
3017 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3018 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3019 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3020 val = convert_from_spdif_status(spdif->status);
3021 val |= spdif->ctls & 1;
3022 change = spdif->ctls != val;
3024 if (change && nid != (u16)-1)
3025 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3026 mutex_unlock(&codec->spdif_mutex);
3030 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3032 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3033 struct snd_ctl_elem_value *ucontrol)
3035 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3036 int idx = kcontrol->private_value;
3037 struct hda_spdif_out *spdif;
3039 mutex_lock(&codec->spdif_mutex);
3040 spdif = snd_array_elem(&codec->spdif_out, idx);
3041 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3042 mutex_unlock(&codec->spdif_mutex);
3046 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3049 set_dig_out_convert(codec, nid, dig1, dig2);
3050 /* unmute amp switch (if any) */
3051 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3052 (dig1 & AC_DIG1_ENABLE))
3053 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3057 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3058 struct snd_ctl_elem_value *ucontrol)
3060 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3061 int idx = kcontrol->private_value;
3062 struct hda_spdif_out *spdif;
3067 mutex_lock(&codec->spdif_mutex);
3068 spdif = snd_array_elem(&codec->spdif_out, idx);
3070 val = spdif->ctls & ~AC_DIG1_ENABLE;
3071 if (ucontrol->value.integer.value[0])
3072 val |= AC_DIG1_ENABLE;
3073 change = spdif->ctls != val;
3075 if (change && nid != (u16)-1)
3076 set_spdif_ctls(codec, nid, val & 0xff, -1);
3077 mutex_unlock(&codec->spdif_mutex);
3081 static struct snd_kcontrol_new dig_mixes[] = {
3083 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3084 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3085 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3086 .info = snd_hda_spdif_mask_info,
3087 .get = snd_hda_spdif_cmask_get,
3090 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3091 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3092 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3093 .info = snd_hda_spdif_mask_info,
3094 .get = snd_hda_spdif_pmask_get,
3097 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3098 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3099 .info = snd_hda_spdif_mask_info,
3100 .get = snd_hda_spdif_default_get,
3101 .put = snd_hda_spdif_default_put,
3104 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3105 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3106 .info = snd_hda_spdif_out_switch_info,
3107 .get = snd_hda_spdif_out_switch_get,
3108 .put = snd_hda_spdif_out_switch_put,
3114 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3115 * @codec: the HDA codec
3116 * @nid: audio out widget NID
3118 * Creates controls related with the SPDIF output.
3119 * Called from each patch supporting the SPDIF out.
3121 * Returns 0 if successful, or a negative error code.
3123 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3124 hda_nid_t associated_nid,
3128 struct snd_kcontrol *kctl;
3129 struct snd_kcontrol_new *dig_mix;
3131 struct hda_spdif_out *spdif;
3133 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3135 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3138 spdif = snd_array_new(&codec->spdif_out);
3139 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3140 kctl = snd_ctl_new1(dig_mix, codec);
3143 kctl->id.index = idx;
3144 kctl->private_value = codec->spdif_out.used - 1;
3145 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3149 spdif->nid = cvt_nid;
3150 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3151 AC_VERB_GET_DIGI_CONVERT_1, 0);
3152 spdif->status = convert_to_spdif_status(spdif->ctls);
3155 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3157 /* get the hda_spdif_out entry from the given NID
3158 * call within spdif_mutex lock
3160 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3164 for (i = 0; i < codec->spdif_out.used; i++) {
3165 struct hda_spdif_out *spdif =
3166 snd_array_elem(&codec->spdif_out, i);
3167 if (spdif->nid == nid)
3172 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3174 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3176 struct hda_spdif_out *spdif;
3178 mutex_lock(&codec->spdif_mutex);
3179 spdif = snd_array_elem(&codec->spdif_out, idx);
3180 spdif->nid = (u16)-1;
3181 mutex_unlock(&codec->spdif_mutex);
3183 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3185 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3187 struct hda_spdif_out *spdif;
3190 mutex_lock(&codec->spdif_mutex);
3191 spdif = snd_array_elem(&codec->spdif_out, idx);
3192 if (spdif->nid != nid) {
3195 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3197 mutex_unlock(&codec->spdif_mutex);
3199 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3202 * SPDIF sharing with analog output
3204 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3205 struct snd_ctl_elem_value *ucontrol)
3207 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3208 ucontrol->value.integer.value[0] = mout->share_spdif;
3212 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3213 struct snd_ctl_elem_value *ucontrol)
3215 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3216 mout->share_spdif = !!ucontrol->value.integer.value[0];
3220 static struct snd_kcontrol_new spdif_share_sw = {
3221 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3222 .name = "IEC958 Default PCM Playback Switch",
3223 .info = snd_ctl_boolean_mono_info,
3224 .get = spdif_share_sw_get,
3225 .put = spdif_share_sw_put,
3229 * snd_hda_create_spdif_share_sw - create Default PCM switch
3230 * @codec: the HDA codec
3231 * @mout: multi-out instance
3233 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3234 struct hda_multi_out *mout)
3236 if (!mout->dig_out_nid)
3238 /* ATTENTION: here mout is passed as private_data, instead of codec */
3239 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3240 snd_ctl_new1(&spdif_share_sw, mout));
3242 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3248 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3250 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3251 struct snd_ctl_elem_value *ucontrol)
3253 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3255 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3259 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3260 struct snd_ctl_elem_value *ucontrol)
3262 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3263 hda_nid_t nid = kcontrol->private_value;
3264 unsigned int val = !!ucontrol->value.integer.value[0];
3267 mutex_lock(&codec->spdif_mutex);
3268 change = codec->spdif_in_enable != val;
3270 codec->spdif_in_enable = val;
3271 snd_hda_codec_write_cache(codec, nid, 0,
3272 AC_VERB_SET_DIGI_CONVERT_1, val);
3274 mutex_unlock(&codec->spdif_mutex);
3278 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3279 struct snd_ctl_elem_value *ucontrol)
3281 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3282 hda_nid_t nid = kcontrol->private_value;
3286 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3287 sbits = convert_to_spdif_status(val);
3288 ucontrol->value.iec958.status[0] = sbits;
3289 ucontrol->value.iec958.status[1] = sbits >> 8;
3290 ucontrol->value.iec958.status[2] = sbits >> 16;
3291 ucontrol->value.iec958.status[3] = sbits >> 24;
3295 static struct snd_kcontrol_new dig_in_ctls[] = {
3297 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3298 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3299 .info = snd_hda_spdif_in_switch_info,
3300 .get = snd_hda_spdif_in_switch_get,
3301 .put = snd_hda_spdif_in_switch_put,
3304 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3305 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3306 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3307 .info = snd_hda_spdif_mask_info,
3308 .get = snd_hda_spdif_in_status_get,
3314 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3315 * @codec: the HDA codec
3316 * @nid: audio in widget NID
3318 * Creates controls related with the SPDIF input.
3319 * Called from each patch supporting the SPDIF in.
3321 * Returns 0 if successful, or a negative error code.
3323 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3326 struct snd_kcontrol *kctl;
3327 struct snd_kcontrol_new *dig_mix;
3330 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3332 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3335 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3336 kctl = snd_ctl_new1(dig_mix, codec);
3339 kctl->private_value = nid;
3340 err = snd_hda_ctl_add(codec, nid, kctl);
3344 codec->spdif_in_enable =
3345 snd_hda_codec_read(codec, nid, 0,
3346 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3350 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3357 /* build a 32bit cache key with the widget id and the command parameter */
3358 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3359 #define get_cmd_cache_nid(key) ((key) & 0xff)
3360 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3363 * snd_hda_codec_write_cache - send a single command with caching
3364 * @codec: the HDA codec
3365 * @nid: NID to send the command
3366 * @direct: direct flag
3367 * @verb: the verb to send
3368 * @parm: the parameter for the verb
3370 * Send a single command without waiting for response.
3372 * Returns 0 if successful, or a negative error code.
3374 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3375 int direct, unsigned int verb, unsigned int parm)
3377 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3378 struct hda_cache_head *c;
3383 /* parm may contain the verb stuff for get/set amp */
3384 verb = verb | (parm >> 8);
3386 key = build_cmd_cache_key(nid, verb);
3387 mutex_lock(&codec->bus->cmd_mutex);
3388 c = get_alloc_hash(&codec->cmd_cache, key);
3391 mutex_unlock(&codec->bus->cmd_mutex);
3394 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3397 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3398 * @codec: the HDA codec
3399 * @nid: NID to send the command
3400 * @direct: direct flag
3401 * @verb: the verb to send
3402 * @parm: the parameter for the verb
3404 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3405 * command if the parameter is already identical with the cached value.
3406 * If not, it sends the command and refreshes the cache.
3408 * Returns 0 if successful, or a negative error code.
3410 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3411 int direct, unsigned int verb, unsigned int parm)
3413 struct hda_cache_head *c;
3416 /* parm may contain the verb stuff for get/set amp */
3417 verb = verb | (parm >> 8);
3419 key = build_cmd_cache_key(nid, verb);
3420 mutex_lock(&codec->bus->cmd_mutex);
3421 c = get_hash(&codec->cmd_cache, key);
3422 if (c && c->val == parm) {
3423 mutex_unlock(&codec->bus->cmd_mutex);
3426 mutex_unlock(&codec->bus->cmd_mutex);
3427 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3429 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3432 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3433 * @codec: HD-audio codec
3435 * Execute all verbs recorded in the command caches to resume.
3437 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3439 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3442 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3443 u32 key = buffer->key;
3446 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3447 get_cmd_cache_cmd(key), buffer->val);
3450 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3453 * snd_hda_sequence_write_cache - sequence writes with caching
3454 * @codec: the HDA codec
3455 * @seq: VERB array to send
3457 * Send the commands sequentially from the given array.
3458 * Thte commands are recorded on cache for power-save and resume.
3459 * The array must be terminated with NID=0.
3461 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3462 const struct hda_verb *seq)
3464 for (; seq->nid; seq++)
3465 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3468 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3469 #endif /* CONFIG_PM */
3471 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3472 unsigned int power_state,
3473 bool eapd_workaround)
3475 hda_nid_t nid = codec->start_nid;
3478 for (i = 0; i < codec->num_nodes; i++, nid++) {
3479 unsigned int wcaps = get_wcaps(codec, nid);
3480 if (!(wcaps & AC_WCAP_POWER))
3482 /* don't power down the widget if it controls eapd and
3483 * EAPD_BTLENABLE is set.
3485 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3486 get_wcaps_type(wcaps) == AC_WID_PIN &&
3487 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3488 int eapd = snd_hda_codec_read(codec, nid, 0,
3489 AC_VERB_GET_EAPD_BTLENABLE, 0);
3493 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3497 if (power_state == AC_PWRST_D0) {
3498 unsigned long end_time;
3500 /* wait until the codec reachs to D0 */
3501 end_time = jiffies + msecs_to_jiffies(500);
3503 state = snd_hda_codec_read(codec, fg, 0,
3504 AC_VERB_GET_POWER_STATE, 0);
3505 if (state == power_state)
3508 } while (time_after_eq(end_time, jiffies));
3511 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3514 * supported power states check
3516 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3517 unsigned int power_state)
3519 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3523 if (sup & power_state)
3530 * set power state of the codec
3532 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3533 unsigned int power_state)
3538 if (codec->patch_ops.set_power_state) {
3539 codec->patch_ops.set_power_state(codec, fg, power_state);
3543 /* this delay seems necessary to avoid click noise at power-down */
3544 if (power_state == AC_PWRST_D3) {
3545 /* transition time less than 10ms for power down */
3546 bool epss = snd_hda_codec_get_supported_ps(codec, fg, AC_PWRST_EPSS);
3547 msleep(epss ? 10 : 100);
3550 /* repeat power states setting at most 10 times*/
3551 for (count = 0; count < 10; count++) {
3552 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3554 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3555 state = snd_hda_codec_read(codec, fg, 0,
3556 AC_VERB_GET_POWER_STATE, 0);
3557 if (!(state & AC_PWRST_ERROR))
3562 #ifdef CONFIG_SND_HDA_HWDEP
3563 /* execute additional init verbs */
3564 static void hda_exec_init_verbs(struct hda_codec *codec)
3566 if (codec->init_verbs.list)
3567 snd_hda_sequence_write(codec, codec->init_verbs.list);
3570 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3575 * call suspend and power-down; used both from PM and power-save
3577 static void hda_call_codec_suspend(struct hda_codec *codec)
3579 if (codec->patch_ops.suspend)
3580 codec->patch_ops.suspend(codec);
3581 hda_cleanup_all_streams(codec);
3582 hda_set_power_state(codec,
3583 codec->afg ? codec->afg : codec->mfg,
3585 #ifdef CONFIG_SND_HDA_POWER_SAVE
3586 cancel_delayed_work(&codec->power_work);
3587 spin_lock(&codec->power_lock);
3588 snd_hda_update_power_acct(codec);
3589 trace_hda_power_down(codec);
3590 codec->power_on = 0;
3591 codec->power_transition = 0;
3592 codec->power_jiffies = jiffies;
3593 spin_unlock(&codec->power_lock);
3598 * kick up codec; used both from PM and power-save
3600 static void hda_call_codec_resume(struct hda_codec *codec)
3602 /* set as if powered on for avoiding re-entering the resume
3603 * in the resume / power-save sequence
3605 hda_keep_power_on(codec);
3606 hda_set_power_state(codec,
3607 codec->afg ? codec->afg : codec->mfg,
3609 restore_pincfgs(codec); /* restore all current pin configs */
3610 restore_shutup_pins(codec);
3611 hda_exec_init_verbs(codec);
3612 snd_hda_jack_set_dirty_all(codec);
3613 if (codec->patch_ops.resume)
3614 codec->patch_ops.resume(codec);
3616 if (codec->patch_ops.init)
3617 codec->patch_ops.init(codec);
3618 snd_hda_codec_resume_amp(codec);
3619 snd_hda_codec_resume_cache(codec);
3621 snd_hda_power_down(codec); /* flag down before returning */
3623 #endif /* CONFIG_PM */
3627 * snd_hda_build_controls - build mixer controls
3630 * Creates mixer controls for each codec included in the bus.
3632 * Returns 0 if successful, otherwise a negative error code.
3634 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3636 struct hda_codec *codec;
3638 list_for_each_entry(codec, &bus->codec_list, list) {
3639 int err = snd_hda_codec_build_controls(codec);
3641 printk(KERN_ERR "hda_codec: cannot build controls "
3642 "for #%d (error %d)\n", codec->addr, err);
3643 err = snd_hda_codec_reset(codec);
3646 "hda_codec: cannot revert codec\n");
3653 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3655 int snd_hda_codec_build_controls(struct hda_codec *codec)
3658 hda_exec_init_verbs(codec);
3659 /* continue to initialize... */
3660 if (codec->patch_ops.init)
3661 err = codec->patch_ops.init(codec);
3662 if (!err && codec->patch_ops.build_controls)
3663 err = codec->patch_ops.build_controls(codec);
3672 struct hda_rate_tbl {
3674 unsigned int alsa_bits;
3675 unsigned int hda_fmt;
3678 /* rate = base * mult / div */
3679 #define HDA_RATE(base, mult, div) \
3680 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3681 (((div) - 1) << AC_FMT_DIV_SHIFT))
3683 static struct hda_rate_tbl rate_bits[] = {
3684 /* rate in Hz, ALSA rate bitmask, HDA format value */
3686 /* autodetected value used in snd_hda_query_supported_pcm */
3687 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3688 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3689 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3690 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3691 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3692 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3693 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3694 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3695 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3696 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3697 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3698 #define AC_PAR_PCM_RATE_BITS 11
3699 /* up to bits 10, 384kHZ isn't supported properly */
3701 /* not autodetected value */
3702 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3704 { 0 } /* terminator */
3708 * snd_hda_calc_stream_format - calculate format bitset
3709 * @rate: the sample rate
3710 * @channels: the number of channels
3711 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3712 * @maxbps: the max. bps
3714 * Calculate the format bitset from the given rate, channels and th PCM format.
3716 * Return zero if invalid.
3718 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3719 unsigned int channels,
3720 unsigned int format,
3721 unsigned int maxbps,
3722 unsigned short spdif_ctls)
3725 unsigned int val = 0;
3727 for (i = 0; rate_bits[i].hz; i++)
3728 if (rate_bits[i].hz == rate) {
3729 val = rate_bits[i].hda_fmt;
3732 if (!rate_bits[i].hz) {
3733 snd_printdd("invalid rate %d\n", rate);
3737 if (channels == 0 || channels > 8) {
3738 snd_printdd("invalid channels %d\n", channels);
3741 val |= channels - 1;
3743 switch (snd_pcm_format_width(format)) {
3745 val |= AC_FMT_BITS_8;
3748 val |= AC_FMT_BITS_16;
3753 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3754 val |= AC_FMT_BITS_32;
3755 else if (maxbps >= 24)
3756 val |= AC_FMT_BITS_24;
3758 val |= AC_FMT_BITS_20;
3761 snd_printdd("invalid format width %d\n",
3762 snd_pcm_format_width(format));
3766 if (spdif_ctls & AC_DIG1_NONAUDIO)
3767 val |= AC_FMT_TYPE_NON_PCM;
3771 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3773 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3776 unsigned int val = 0;
3777 if (nid != codec->afg &&
3778 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3779 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3780 if (!val || val == -1)
3781 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3782 if (!val || val == -1)
3787 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3789 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
3793 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3796 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3797 if (!streams || streams == -1)
3798 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3799 if (!streams || streams == -1)
3804 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3806 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
3811 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3812 * @codec: the HDA codec
3813 * @nid: NID to query
3814 * @ratesp: the pointer to store the detected rate bitflags
3815 * @formatsp: the pointer to store the detected formats
3816 * @bpsp: the pointer to store the detected format widths
3818 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3819 * or @bsps argument is ignored.
3821 * Returns 0 if successful, otherwise a negative error code.
3823 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3824 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3826 unsigned int i, val, wcaps;
3828 wcaps = get_wcaps(codec, nid);
3829 val = query_pcm_param(codec, nid);
3833 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3835 rates |= rate_bits[i].alsa_bits;
3838 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3839 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3841 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3847 if (formatsp || bpsp) {
3849 unsigned int streams, bps;
3851 streams = query_stream_param(codec, nid);
3856 if (streams & AC_SUPFMT_PCM) {
3857 if (val & AC_SUPPCM_BITS_8) {
3858 formats |= SNDRV_PCM_FMTBIT_U8;
3861 if (val & AC_SUPPCM_BITS_16) {
3862 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3865 if (wcaps & AC_WCAP_DIGITAL) {
3866 if (val & AC_SUPPCM_BITS_32)
3867 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3868 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3869 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3870 if (val & AC_SUPPCM_BITS_24)
3872 else if (val & AC_SUPPCM_BITS_20)
3874 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3875 AC_SUPPCM_BITS_32)) {
3876 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3877 if (val & AC_SUPPCM_BITS_32)
3879 else if (val & AC_SUPPCM_BITS_24)
3881 else if (val & AC_SUPPCM_BITS_20)
3885 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3886 if (streams & AC_SUPFMT_FLOAT32) {
3887 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3892 if (streams == AC_SUPFMT_AC3) {
3893 /* should be exclusive */
3894 /* temporary hack: we have still no proper support
3895 * for the direct AC3 stream...
3897 formats |= SNDRV_PCM_FMTBIT_U8;
3901 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3902 "(nid=0x%x, val=0x%x, ovrd=%i, "
3905 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3910 *formatsp = formats;
3917 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3920 * snd_hda_is_supported_format - Check the validity of the format
3921 * @codec: HD-audio codec
3922 * @nid: NID to check
3923 * @format: the HD-audio format value to check
3925 * Check whether the given node supports the format value.
3927 * Returns 1 if supported, 0 if not.
3929 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3930 unsigned int format)
3933 unsigned int val = 0, rate, stream;
3935 val = query_pcm_param(codec, nid);
3939 rate = format & 0xff00;
3940 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3941 if (rate_bits[i].hda_fmt == rate) {
3946 if (i >= AC_PAR_PCM_RATE_BITS)
3949 stream = query_stream_param(codec, nid);
3953 if (stream & AC_SUPFMT_PCM) {
3954 switch (format & 0xf0) {
3956 if (!(val & AC_SUPPCM_BITS_8))
3960 if (!(val & AC_SUPPCM_BITS_16))
3964 if (!(val & AC_SUPPCM_BITS_20))
3968 if (!(val & AC_SUPPCM_BITS_24))
3972 if (!(val & AC_SUPPCM_BITS_32))
3979 /* FIXME: check for float32 and AC3? */
3984 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3989 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3990 struct hda_codec *codec,
3991 struct snd_pcm_substream *substream)
3996 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3997 struct hda_codec *codec,
3998 unsigned int stream_tag,
3999 unsigned int format,
4000 struct snd_pcm_substream *substream)
4002 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4006 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4007 struct hda_codec *codec,
4008 struct snd_pcm_substream *substream)
4010 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4014 static int set_pcm_default_values(struct hda_codec *codec,
4015 struct hda_pcm_stream *info)
4019 /* query support PCM information from the given NID */
4020 if (info->nid && (!info->rates || !info->formats)) {
4021 err = snd_hda_query_supported_pcm(codec, info->nid,
4022 info->rates ? NULL : &info->rates,
4023 info->formats ? NULL : &info->formats,
4024 info->maxbps ? NULL : &info->maxbps);
4028 if (info->ops.open == NULL)
4029 info->ops.open = hda_pcm_default_open_close;
4030 if (info->ops.close == NULL)
4031 info->ops.close = hda_pcm_default_open_close;
4032 if (info->ops.prepare == NULL) {
4033 if (snd_BUG_ON(!info->nid))
4035 info->ops.prepare = hda_pcm_default_prepare;
4037 if (info->ops.cleanup == NULL) {
4038 if (snd_BUG_ON(!info->nid))
4040 info->ops.cleanup = hda_pcm_default_cleanup;
4046 * codec prepare/cleanup entries
4048 int snd_hda_codec_prepare(struct hda_codec *codec,
4049 struct hda_pcm_stream *hinfo,
4050 unsigned int stream,
4051 unsigned int format,
4052 struct snd_pcm_substream *substream)
4055 mutex_lock(&codec->bus->prepare_mutex);
4056 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4058 purify_inactive_streams(codec);
4059 mutex_unlock(&codec->bus->prepare_mutex);
4062 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4064 void snd_hda_codec_cleanup(struct hda_codec *codec,
4065 struct hda_pcm_stream *hinfo,
4066 struct snd_pcm_substream *substream)
4068 mutex_lock(&codec->bus->prepare_mutex);
4069 hinfo->ops.cleanup(hinfo, codec, substream);
4070 mutex_unlock(&codec->bus->prepare_mutex);
4072 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4075 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4076 "Audio", "SPDIF", "HDMI", "Modem"
4080 * get the empty PCM device number to assign
4082 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4084 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4086 /* audio device indices; not linear to keep compatibility */
4087 static int audio_idx[HDA_PCM_NTYPES][5] = {
4088 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4089 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4090 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4091 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4095 if (type >= HDA_PCM_NTYPES) {
4096 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4100 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4101 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4102 return audio_idx[type][i];
4104 /* non-fixed slots starting from 10 */
4105 for (i = 10; i < 32; i++) {
4106 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4110 snd_printk(KERN_WARNING "Too many %s devices\n",
4111 snd_hda_pcm_type_name[type]);
4116 * attach a new PCM stream
4118 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4120 struct hda_bus *bus = codec->bus;
4121 struct hda_pcm_stream *info;
4124 if (snd_BUG_ON(!pcm->name))
4126 for (stream = 0; stream < 2; stream++) {
4127 info = &pcm->stream[stream];
4128 if (info->substreams) {
4129 err = set_pcm_default_values(codec, info);
4134 return bus->ops.attach_pcm(bus, codec, pcm);
4137 /* assign all PCMs of the given codec */
4138 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4143 if (!codec->num_pcms) {
4144 if (!codec->patch_ops.build_pcms)
4146 err = codec->patch_ops.build_pcms(codec);
4148 printk(KERN_ERR "hda_codec: cannot build PCMs"
4149 "for #%d (error %d)\n", codec->addr, err);
4150 err = snd_hda_codec_reset(codec);
4153 "hda_codec: cannot revert codec\n");
4158 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4159 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4162 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4163 continue; /* no substreams assigned */
4166 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4168 continue; /* no fatal error */
4170 err = snd_hda_attach_pcm(codec, cpcm);
4172 printk(KERN_ERR "hda_codec: cannot attach "
4173 "PCM stream %d for codec #%d\n",
4175 continue; /* no fatal error */
4183 * snd_hda_build_pcms - build PCM information
4186 * Create PCM information for each codec included in the bus.
4188 * The build_pcms codec patch is requested to set up codec->num_pcms and
4189 * codec->pcm_info properly. The array is referred by the top-level driver
4190 * to create its PCM instances.
4191 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4194 * At least, substreams, channels_min and channels_max must be filled for
4195 * each stream. substreams = 0 indicates that the stream doesn't exist.
4196 * When rates and/or formats are zero, the supported values are queried
4197 * from the given nid. The nid is used also by the default ops.prepare
4198 * and ops.cleanup callbacks.
4200 * The driver needs to call ops.open in its open callback. Similarly,
4201 * ops.close is supposed to be called in the close callback.
4202 * ops.prepare should be called in the prepare or hw_params callback
4203 * with the proper parameters for set up.
4204 * ops.cleanup should be called in hw_free for clean up of streams.
4206 * This function returns 0 if successful, or a negative error code.
4208 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
4210 struct hda_codec *codec;
4212 list_for_each_entry(codec, &bus->codec_list, list) {
4213 int err = snd_hda_codec_build_pcms(codec);
4219 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4222 * snd_hda_check_board_config - compare the current codec with the config table
4223 * @codec: the HDA codec
4224 * @num_configs: number of config enums
4225 * @models: array of model name strings
4226 * @tbl: configuration table, terminated by null entries
4228 * Compares the modelname or PCI subsystem id of the current codec with the
4229 * given configuration table. If a matching entry is found, returns its
4230 * config value (supposed to be 0 or positive).
4232 * If no entries are matching, the function returns a negative value.
4234 int snd_hda_check_board_config(struct hda_codec *codec,
4235 int num_configs, const char * const *models,
4236 const struct snd_pci_quirk *tbl)
4238 if (codec->modelname && models) {
4240 for (i = 0; i < num_configs; i++) {
4242 !strcmp(codec->modelname, models[i])) {
4243 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4244 "selected\n", models[i]);
4250 if (!codec->bus->pci || !tbl)
4253 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4256 if (tbl->value >= 0 && tbl->value < num_configs) {
4257 #ifdef CONFIG_SND_DEBUG_VERBOSE
4259 const char *model = NULL;
4261 model = models[tbl->value];
4263 sprintf(tmp, "#%d", tbl->value);
4266 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4267 "for config %x:%x (%s)\n",
4268 model, tbl->subvendor, tbl->subdevice,
4269 (tbl->name ? tbl->name : "Unknown device"));
4275 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4278 * snd_hda_check_board_codec_sid_config - compare the current codec
4279 subsystem ID with the
4282 This is important for Gateway notebooks with SB450 HDA Audio
4283 where the vendor ID of the PCI device is:
4284 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4285 and the vendor/subvendor are found only at the codec.
4287 * @codec: the HDA codec
4288 * @num_configs: number of config enums
4289 * @models: array of model name strings
4290 * @tbl: configuration table, terminated by null entries
4292 * Compares the modelname or PCI subsystem id of the current codec with the
4293 * given configuration table. If a matching entry is found, returns its
4294 * config value (supposed to be 0 or positive).
4296 * If no entries are matching, the function returns a negative value.
4298 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4299 int num_configs, const char * const *models,
4300 const struct snd_pci_quirk *tbl)
4302 const struct snd_pci_quirk *q;
4304 /* Search for codec ID */
4305 for (q = tbl; q->subvendor; q++) {
4306 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4307 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4308 if ((codec->subsystem_id & mask) == id)
4317 if (tbl->value >= 0 && tbl->value < num_configs) {
4318 #ifdef CONFIG_SND_DEBUG_VERBOSE
4320 const char *model = NULL;
4322 model = models[tbl->value];
4324 sprintf(tmp, "#%d", tbl->value);
4327 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4328 "for config %x:%x (%s)\n",
4329 model, tbl->subvendor, tbl->subdevice,
4330 (tbl->name ? tbl->name : "Unknown device"));
4336 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4339 * snd_hda_add_new_ctls - create controls from the array
4340 * @codec: the HDA codec
4341 * @knew: the array of struct snd_kcontrol_new
4343 * This helper function creates and add new controls in the given array.
4344 * The array must be terminated with an empty entry as terminator.
4346 * Returns 0 if successful, or a negative error code.
4348 int snd_hda_add_new_ctls(struct hda_codec *codec,
4349 const struct snd_kcontrol_new *knew)
4353 for (; knew->name; knew++) {
4354 struct snd_kcontrol *kctl;
4355 int addr = 0, idx = 0;
4356 if (knew->iface == -1) /* skip this codec private value */
4359 kctl = snd_ctl_new1(knew, codec);
4363 kctl->id.device = addr;
4365 kctl->id.index = idx;
4366 err = snd_hda_ctl_add(codec, 0, kctl);
4369 /* try first with another device index corresponding to
4370 * the codec addr; if it still fails (or it's the
4371 * primary codec), then try another control index
4373 if (!addr && codec->addr)
4375 else if (!idx && !knew->index) {
4376 idx = find_empty_mixer_ctl_idx(codec,
4386 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4388 #ifdef CONFIG_SND_HDA_POWER_SAVE
4389 static void hda_power_work(struct work_struct *work)
4391 struct hda_codec *codec =
4392 container_of(work, struct hda_codec, power_work.work);
4393 struct hda_bus *bus = codec->bus;
4395 spin_lock(&codec->power_lock);
4396 if (codec->power_transition > 0) { /* during power-up sequence? */
4397 spin_unlock(&codec->power_lock);
4400 if (!codec->power_on || codec->power_count) {
4401 codec->power_transition = 0;
4402 spin_unlock(&codec->power_lock);
4405 spin_unlock(&codec->power_lock);
4407 hda_call_codec_suspend(codec);
4408 if (bus->ops.pm_notify)
4409 bus->ops.pm_notify(bus);
4412 static void hda_keep_power_on(struct hda_codec *codec)
4414 spin_lock(&codec->power_lock);
4415 codec->power_count++;
4416 codec->power_on = 1;
4417 codec->power_jiffies = jiffies;
4418 spin_unlock(&codec->power_lock);
4421 /* update the power on/off account with the current jiffies */
4422 void snd_hda_update_power_acct(struct hda_codec *codec)
4424 unsigned long delta = jiffies - codec->power_jiffies;
4425 if (codec->power_on)
4426 codec->power_on_acct += delta;
4428 codec->power_off_acct += delta;
4429 codec->power_jiffies += delta;
4432 /* Transition to powered up, if wait_power_down then wait for a pending
4433 * transition to D3 to complete. A pending D3 transition is indicated
4434 * with power_transition == -1. */
4435 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4437 struct hda_bus *bus = codec->bus;
4439 spin_lock(&codec->power_lock);
4440 codec->power_count++;
4441 /* Return if power_on or transitioning to power_on, unless currently
4443 if ((codec->power_on || codec->power_transition > 0) &&
4444 !(wait_power_down && codec->power_transition < 0)) {
4445 spin_unlock(&codec->power_lock);
4448 spin_unlock(&codec->power_lock);
4450 cancel_delayed_work_sync(&codec->power_work);
4452 spin_lock(&codec->power_lock);
4453 /* If the power down delayed work was cancelled above before starting,
4454 * then there is no need to go through power up here.
4456 if (codec->power_on) {
4457 if (codec->power_transition < 0)
4458 codec->power_transition = 0;
4459 spin_unlock(&codec->power_lock);
4462 trace_hda_power_up(codec);
4463 snd_hda_update_power_acct(codec);
4464 codec->power_on = 1;
4465 codec->power_jiffies = jiffies;
4466 codec->power_transition = 1; /* avoid reentrance */
4467 spin_unlock(&codec->power_lock);
4469 if (bus->ops.pm_notify)
4470 bus->ops.pm_notify(bus);
4471 hda_call_codec_resume(codec);
4473 spin_lock(&codec->power_lock);
4474 codec->power_transition = 0;
4475 spin_unlock(&codec->power_lock);
4479 * snd_hda_power_up - Power-up the codec
4480 * @codec: HD-audio codec
4482 * Increment the power-up counter and power up the hardware really when
4483 * not turned on yet.
4485 void snd_hda_power_up(struct hda_codec *codec)
4487 __snd_hda_power_up(codec, false);
4489 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4492 * snd_hda_power_up_d3wait - Power-up the codec after waiting for any pending
4493 * D3 transition to complete. This differs from snd_hda_power_up() when
4494 * power_transition == -1. snd_hda_power_up sees this case as a nop,
4495 * snd_hda_power_up_d3wait waits for the D3 transition to complete then powers
4497 * @codec: HD-audio codec
4499 * Cancel any power down operation hapenning on the work queue, then power up.
4501 void snd_hda_power_up_d3wait(struct hda_codec *codec)
4503 /* This will cancel and wait for pending power_work to complete. */
4504 __snd_hda_power_up(codec, true);
4506 EXPORT_SYMBOL_HDA(snd_hda_power_up_d3wait);
4508 #define power_save(codec) \
4509 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4512 * snd_hda_power_down - Power-down the codec
4513 * @codec: HD-audio codec
4515 * Decrement the power-up counter and schedules the power-off work if
4516 * the counter rearches to zero.
4518 void snd_hda_power_down(struct hda_codec *codec)
4520 spin_lock(&codec->power_lock);
4521 --codec->power_count;
4522 if (!codec->power_on || codec->power_count || codec->power_transition) {
4523 spin_unlock(&codec->power_lock);
4526 if (power_save(codec)) {
4527 codec->power_transition = -1; /* avoid reentrance */
4528 queue_delayed_work(codec->bus->workq, &codec->power_work,
4529 msecs_to_jiffies(power_save(codec) * 1000));
4531 spin_unlock(&codec->power_lock);
4533 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4536 * snd_hda_check_amp_list_power - Check the amp list and update the power
4537 * @codec: HD-audio codec
4538 * @check: the object containing an AMP list and the status
4539 * @nid: NID to check / update
4541 * Check whether the given NID is in the amp list. If it's in the list,
4542 * check the current AMP status, and update the the power-status according
4543 * to the mute status.
4545 * This function is supposed to be set or called from the check_power_status
4548 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4549 struct hda_loopback_check *check,
4552 const struct hda_amp_list *p;
4555 if (!check->amplist)
4557 for (p = check->amplist; p->nid; p++) {
4562 return 0; /* nothing changed */
4564 for (p = check->amplist; p->nid; p++) {
4565 for (ch = 0; ch < 2; ch++) {
4566 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4568 if (!(v & HDA_AMP_MUTE) && v > 0) {
4569 if (!check->power_on) {
4570 check->power_on = 1;
4571 snd_hda_power_up(codec);
4577 if (check->power_on) {
4578 check->power_on = 0;
4579 snd_hda_power_down(codec);
4583 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4587 * Channel mode helper
4591 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4593 int snd_hda_ch_mode_info(struct hda_codec *codec,
4594 struct snd_ctl_elem_info *uinfo,
4595 const struct hda_channel_mode *chmode,
4598 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4600 uinfo->value.enumerated.items = num_chmodes;
4601 if (uinfo->value.enumerated.item >= num_chmodes)
4602 uinfo->value.enumerated.item = num_chmodes - 1;
4603 sprintf(uinfo->value.enumerated.name, "%dch",
4604 chmode[uinfo->value.enumerated.item].channels);
4607 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4610 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4612 int snd_hda_ch_mode_get(struct hda_codec *codec,
4613 struct snd_ctl_elem_value *ucontrol,
4614 const struct hda_channel_mode *chmode,
4620 for (i = 0; i < num_chmodes; i++) {
4621 if (max_channels == chmode[i].channels) {
4622 ucontrol->value.enumerated.item[0] = i;
4628 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4631 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4633 int snd_hda_ch_mode_put(struct hda_codec *codec,
4634 struct snd_ctl_elem_value *ucontrol,
4635 const struct hda_channel_mode *chmode,
4641 mode = ucontrol->value.enumerated.item[0];
4642 if (mode >= num_chmodes)
4644 if (*max_channelsp == chmode[mode].channels)
4646 /* change the current channel setting */
4647 *max_channelsp = chmode[mode].channels;
4648 if (chmode[mode].sequence)
4649 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4652 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4659 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4661 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4662 struct snd_ctl_elem_info *uinfo)
4666 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4668 uinfo->value.enumerated.items = imux->num_items;
4669 if (!imux->num_items)
4671 index = uinfo->value.enumerated.item;
4672 if (index >= imux->num_items)
4673 index = imux->num_items - 1;
4674 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4677 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4680 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4682 int snd_hda_input_mux_put(struct hda_codec *codec,
4683 const struct hda_input_mux *imux,
4684 struct snd_ctl_elem_value *ucontrol,
4686 unsigned int *cur_val)
4690 if (!imux->num_items)
4692 idx = ucontrol->value.enumerated.item[0];
4693 if (idx >= imux->num_items)
4694 idx = imux->num_items - 1;
4695 if (*cur_val == idx)
4697 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4698 imux->items[idx].index);
4702 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4706 * Multi-channel / digital-out PCM helper functions
4709 /* setup SPDIF output stream */
4710 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4711 unsigned int stream_tag, unsigned int format)
4713 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4715 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4716 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4717 set_dig_out_convert(codec, nid,
4718 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4720 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4721 if (codec->slave_dig_outs) {
4723 for (d = codec->slave_dig_outs; *d; d++)
4724 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4727 /* turn on again (if needed) */
4728 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4729 set_dig_out_convert(codec, nid,
4730 spdif->ctls & 0xff, -1);
4733 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4735 snd_hda_codec_cleanup_stream(codec, nid);
4736 if (codec->slave_dig_outs) {
4738 for (d = codec->slave_dig_outs; *d; d++)
4739 snd_hda_codec_cleanup_stream(codec, *d);
4744 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4745 * @bus: HD-audio bus
4747 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4749 struct hda_codec *codec;
4753 list_for_each_entry(codec, &bus->codec_list, list) {
4754 if (hda_codec_is_power_on(codec) &&
4755 codec->patch_ops.reboot_notify)
4756 codec->patch_ops.reboot_notify(codec);
4759 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4762 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4764 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4765 struct hda_multi_out *mout)
4767 mutex_lock(&codec->spdif_mutex);
4768 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4769 /* already opened as analog dup; reset it once */
4770 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4771 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4772 mutex_unlock(&codec->spdif_mutex);
4775 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4778 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4780 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4781 struct hda_multi_out *mout,
4782 unsigned int stream_tag,
4783 unsigned int format,
4784 struct snd_pcm_substream *substream)
4786 mutex_lock(&codec->spdif_mutex);
4787 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4788 mutex_unlock(&codec->spdif_mutex);
4791 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4794 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4796 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4797 struct hda_multi_out *mout)
4799 mutex_lock(&codec->spdif_mutex);
4800 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4801 mutex_unlock(&codec->spdif_mutex);
4804 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4807 * snd_hda_multi_out_dig_close - release the digital out stream
4809 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4810 struct hda_multi_out *mout)
4812 mutex_lock(&codec->spdif_mutex);
4813 mout->dig_out_used = 0;
4814 mutex_unlock(&codec->spdif_mutex);
4817 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4820 * snd_hda_multi_out_analog_open - open analog outputs
4822 * Open analog outputs and set up the hw-constraints.
4823 * If the digital outputs can be opened as slave, open the digital
4826 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4827 struct hda_multi_out *mout,
4828 struct snd_pcm_substream *substream,
4829 struct hda_pcm_stream *hinfo)
4831 struct snd_pcm_runtime *runtime = substream->runtime;
4832 runtime->hw.channels_max = mout->max_channels;
4833 if (mout->dig_out_nid) {
4834 if (!mout->analog_rates) {
4835 mout->analog_rates = hinfo->rates;
4836 mout->analog_formats = hinfo->formats;
4837 mout->analog_maxbps = hinfo->maxbps;
4839 runtime->hw.rates = mout->analog_rates;
4840 runtime->hw.formats = mout->analog_formats;
4841 hinfo->maxbps = mout->analog_maxbps;
4843 if (!mout->spdif_rates) {
4844 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4846 &mout->spdif_formats,
4847 &mout->spdif_maxbps);
4849 mutex_lock(&codec->spdif_mutex);
4850 if (mout->share_spdif) {
4851 if ((runtime->hw.rates & mout->spdif_rates) &&
4852 (runtime->hw.formats & mout->spdif_formats)) {
4853 runtime->hw.rates &= mout->spdif_rates;
4854 runtime->hw.formats &= mout->spdif_formats;
4855 if (mout->spdif_maxbps < hinfo->maxbps)
4856 hinfo->maxbps = mout->spdif_maxbps;
4858 mout->share_spdif = 0;
4859 /* FIXME: need notify? */
4862 mutex_unlock(&codec->spdif_mutex);
4864 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4865 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4867 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4870 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4872 * Set up the i/o for analog out.
4873 * When the digital out is available, copy the front out to digital out, too.
4875 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4876 struct hda_multi_out *mout,
4877 unsigned int stream_tag,
4878 unsigned int format,
4879 struct snd_pcm_substream *substream)
4881 const hda_nid_t *nids = mout->dac_nids;
4882 int chs = substream->runtime->channels;
4883 struct hda_spdif_out *spdif;
4886 mutex_lock(&codec->spdif_mutex);
4887 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4888 if (mout->dig_out_nid && mout->share_spdif &&
4889 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4891 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4893 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4894 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4895 setup_dig_out_stream(codec, mout->dig_out_nid,
4896 stream_tag, format);
4898 mout->dig_out_used = 0;
4899 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4902 mutex_unlock(&codec->spdif_mutex);
4905 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4907 if (!mout->no_share_stream &&
4908 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4909 /* headphone out will just decode front left/right (stereo) */
4910 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4912 /* extra outputs copied from front */
4913 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4914 if (!mout->no_share_stream && mout->hp_out_nid[i])
4915 snd_hda_codec_setup_stream(codec,
4916 mout->hp_out_nid[i],
4917 stream_tag, 0, format);
4918 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4919 if (!mout->no_share_stream && mout->extra_out_nid[i])
4920 snd_hda_codec_setup_stream(codec,
4921 mout->extra_out_nid[i],
4922 stream_tag, 0, format);
4925 for (i = 1; i < mout->num_dacs; i++) {
4926 if (chs >= (i + 1) * 2) /* independent out */
4927 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4929 else if (!mout->no_share_stream) /* copy front */
4930 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4935 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4938 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4940 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4941 struct hda_multi_out *mout)
4943 const hda_nid_t *nids = mout->dac_nids;
4946 for (i = 0; i < mout->num_dacs; i++)
4947 snd_hda_codec_cleanup_stream(codec, nids[i]);
4949 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4950 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4951 if (mout->hp_out_nid[i])
4952 snd_hda_codec_cleanup_stream(codec,
4953 mout->hp_out_nid[i]);
4954 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4955 if (mout->extra_out_nid[i])
4956 snd_hda_codec_cleanup_stream(codec,
4957 mout->extra_out_nid[i]);
4958 mutex_lock(&codec->spdif_mutex);
4959 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4960 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4961 mout->dig_out_used = 0;
4963 mutex_unlock(&codec->spdif_mutex);
4966 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4969 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
4971 * Guess the suitable VREF pin bits to be set as the pin-control value.
4972 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
4974 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
4976 unsigned int pincap;
4977 unsigned int oldval;
4978 oldval = snd_hda_codec_read(codec, pin, 0,
4979 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4980 pincap = snd_hda_query_pin_caps(codec, pin);
4981 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
4982 /* Exception: if the default pin setup is vref50, we give it priority */
4983 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
4984 return AC_PINCTL_VREF_80;
4985 else if (pincap & AC_PINCAP_VREF_50)
4986 return AC_PINCTL_VREF_50;
4987 else if (pincap & AC_PINCAP_VREF_100)
4988 return AC_PINCTL_VREF_100;
4989 else if (pincap & AC_PINCAP_VREF_GRD)
4990 return AC_PINCTL_VREF_GRD;
4991 return AC_PINCTL_VREF_HIZ;
4993 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
4995 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
4996 unsigned int val, bool cached)
4999 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
5000 if (cap && (val & AC_PINCTL_OUT_EN)) {
5001 if (!(cap & AC_PINCAP_OUT))
5002 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5003 else if ((val & AC_PINCTL_HP_EN) &&
5004 !(cap & AC_PINCAP_HP_DRV))
5005 val &= ~AC_PINCTL_HP_EN;
5007 if (cap && (val & AC_PINCTL_IN_EN)) {
5008 if (!(cap & AC_PINCAP_IN))
5009 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5013 return snd_hda_codec_update_cache(codec, pin, 0,
5014 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5016 return snd_hda_codec_write(codec, pin, 0,
5017 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5019 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5022 * snd_hda_add_imux_item - Add an item to input_mux
5024 * When the same label is used already in the existing items, the number
5025 * suffix is appended to the label. This label index number is stored
5026 * to type_idx when non-NULL pointer is given.
5028 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5029 int index, int *type_idx)
5031 int i, label_idx = 0;
5032 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5033 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5036 for (i = 0; i < imux->num_items; i++) {
5037 if (!strncmp(label, imux->items[i].label, strlen(label)))
5041 *type_idx = label_idx;
5043 snprintf(imux->items[imux->num_items].label,
5044 sizeof(imux->items[imux->num_items].label),
5045 "%s %d", label, label_idx);
5047 strlcpy(imux->items[imux->num_items].label, label,
5048 sizeof(imux->items[imux->num_items].label));
5049 imux->items[imux->num_items].index = index;
5053 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5062 * snd_hda_suspend - suspend the codecs
5065 * Returns 0 if successful.
5067 int snd_hda_suspend(struct hda_bus *bus)
5069 struct hda_codec *codec;
5071 list_for_each_entry(codec, &bus->codec_list, list) {
5072 if (hda_codec_is_power_on(codec))
5073 hda_call_codec_suspend(codec);
5077 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5080 * snd_hda_resume - resume the codecs
5083 * Returns 0 if successful.
5085 * This function is defined only when POWER_SAVE isn't set.
5086 * In the power-save mode, the codec is resumed dynamically.
5088 int snd_hda_resume(struct hda_bus *bus)
5090 struct hda_codec *codec;
5092 list_for_each_entry(codec, &bus->codec_list, list) {
5093 hda_call_codec_resume(codec);
5097 EXPORT_SYMBOL_HDA(snd_hda_resume);
5098 #endif /* CONFIG_PM */
5105 * snd_array_new - get a new element from the given array
5106 * @array: the array object
5108 * Get a new element from the given array. If it exceeds the
5109 * pre-allocated array size, re-allocate the array.
5111 * Returns NULL if allocation failed.
5113 void *snd_array_new(struct snd_array *array)
5115 if (array->used >= array->alloced) {
5116 int num = array->alloced + array->alloc_align;
5117 int size = (num + 1) * array->elem_size;
5118 int oldsize = array->alloced * array->elem_size;
5120 if (snd_BUG_ON(num >= 4096))
5122 nlist = krealloc(array->list, size, GFP_KERNEL);
5125 memset(nlist + oldsize, 0, size - oldsize);
5126 array->list = nlist;
5127 array->alloced = num;
5129 return snd_array_elem(array, array->used++);
5131 EXPORT_SYMBOL_HDA(snd_array_new);
5134 * snd_array_free - free the given array elements
5135 * @array: the array object
5137 void snd_array_free(struct snd_array *array)
5144 EXPORT_SYMBOL_HDA(snd_array_free);
5147 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5148 * @pcm: PCM caps bits
5149 * @buf: the string buffer to write
5150 * @buflen: the max buffer length
5152 * used by hda_proc.c and hda_eld.c
5154 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5156 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5159 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5160 if (pcm & (AC_SUPPCM_BITS_8 << i))
5161 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5163 buf[j] = '\0'; /* necessary when j == 0 */
5165 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5167 MODULE_DESCRIPTION("HDA codec core");
5168 MODULE_LICENSE("GPL");