2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <linux/module.h>
28 #include <sound/core.h>
29 #include "hda_codec.h"
30 #include <sound/asoundef.h>
31 #include <sound/tlv.h>
32 #include <sound/initval.h>
33 #include <sound/jack.h>
34 #include "hda_local.h"
36 #include <sound/hda_hwdep.h>
38 #define CREATE_TRACE_POINTS
39 #include "hda_trace.h"
42 * vendor / preset table
45 struct hda_vendor_id {
50 /* codec vendor labels */
51 static struct hda_vendor_id hda_vendor_ids[] = {
53 { 0x1013, "Cirrus Logic" },
54 { 0x1057, "Motorola" },
55 { 0x1095, "Silicon Image" },
57 { 0x10ec, "Realtek" },
58 { 0x1102, "Creative" },
62 { 0x11d4, "Analog Devices" },
63 { 0x13f6, "C-Media" },
64 { 0x14f1, "Conexant" },
65 { 0x17e8, "Chrontel" },
67 { 0x1aec, "Wolfson Microelectronics" },
68 { 0x434d, "C-Media" },
70 { 0x8384, "SigmaTel" },
74 static DEFINE_MUTEX(preset_mutex);
75 static LIST_HEAD(hda_preset_tables);
77 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
79 mutex_lock(&preset_mutex);
80 list_add_tail(&preset->list, &hda_preset_tables);
81 mutex_unlock(&preset_mutex);
84 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
86 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
88 mutex_lock(&preset_mutex);
89 list_del(&preset->list);
90 mutex_unlock(&preset_mutex);
93 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
95 #ifdef CONFIG_SND_HDA_POWER_SAVE
96 static void hda_power_work(struct work_struct *work);
97 static void hda_keep_power_on(struct hda_codec *codec);
98 #define hda_codec_is_power_on(codec) ((codec)->power_on)
100 static inline void hda_keep_power_on(struct hda_codec *codec) {}
101 #define hda_codec_is_power_on(codec) 1
105 * snd_hda_get_jack_location - Give a location string of the jack
106 * @cfg: pin default config value
108 * Parse the pin default config value and returns the string of the
109 * jack location, e.g. "Rear", "Front", etc.
111 const char *snd_hda_get_jack_location(u32 cfg)
113 static char *bases[7] = {
114 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
116 static unsigned char specials_idx[] = {
121 static char *specials[] = {
122 "Rear Panel", "Drive Bar",
123 "Riser", "HDMI", "ATAPI",
124 "Mobile-In", "Mobile-Out"
127 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
128 if ((cfg & 0x0f) < 7)
129 return bases[cfg & 0x0f];
130 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
131 if (cfg == specials_idx[i])
136 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
139 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
140 * @cfg: pin default config value
142 * Parse the pin default config value and returns the string of the
143 * jack connectivity, i.e. external or internal connection.
145 const char *snd_hda_get_jack_connectivity(u32 cfg)
147 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
149 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
151 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
154 * snd_hda_get_jack_type - Give a type string of the jack
155 * @cfg: pin default config value
157 * Parse the pin default config value and returns the string of the
158 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
160 const char *snd_hda_get_jack_type(u32 cfg)
162 static char *jack_types[16] = {
163 "Line Out", "Speaker", "HP Out", "CD",
164 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
165 "Line In", "Aux", "Mic", "Telephony",
166 "SPDIF In", "Digitial In", "Reserved", "Other"
169 return jack_types[(cfg & AC_DEFCFG_DEVICE)
170 >> AC_DEFCFG_DEVICE_SHIFT];
172 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
175 * Compose a 32bit command word to be sent to the HD-audio controller
177 static inline unsigned int
178 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
179 unsigned int verb, unsigned int parm)
183 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
184 (verb & ~0xfff) || (parm & ~0xffff)) {
185 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
186 codec->addr, direct, nid, verb, parm);
190 val = (u32)codec->addr << 28;
191 val |= (u32)direct << 27;
192 val |= (u32)nid << 20;
199 * Send and receive a verb
201 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
204 struct hda_bus *bus = codec->bus;
213 snd_hda_power_up(codec);
214 mutex_lock(&bus->cmd_mutex);
215 trace_hda_send_cmd(codec, cmd);
216 err = bus->ops.command(bus, cmd);
218 *res = bus->ops.get_response(bus, codec->addr);
219 trace_hda_get_response(codec, *res);
221 mutex_unlock(&bus->cmd_mutex);
222 snd_hda_power_down(codec);
223 if (res && *res == -1 && bus->rirb_error) {
224 if (bus->response_reset) {
225 snd_printd("hda_codec: resetting BUS due to "
226 "fatal communication error\n");
227 trace_hda_bus_reset(bus);
228 bus->ops.bus_reset(bus);
232 /* clear reset-flag when the communication gets recovered */
234 bus->response_reset = 0;
239 * snd_hda_codec_read - send a command and get the response
240 * @codec: the HDA codec
241 * @nid: NID to send the command
242 * @direct: direct flag
243 * @verb: the verb to send
244 * @parm: the parameter for the verb
246 * Send a single command and read the corresponding response.
248 * Returns the obtained response value, or -1 for an error.
250 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
252 unsigned int verb, unsigned int parm)
254 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
256 if (codec_exec_verb(codec, cmd, &res))
260 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
263 * snd_hda_codec_write - send a single command without waiting for response
264 * @codec: the HDA codec
265 * @nid: NID to send the command
266 * @direct: direct flag
267 * @verb: the verb to send
268 * @parm: the parameter for the verb
270 * Send a single command without waiting for response.
272 * Returns 0 if successful, or a negative error code.
274 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
275 unsigned int verb, unsigned int parm)
277 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
279 return codec_exec_verb(codec, cmd,
280 codec->bus->sync_write ? &res : NULL);
282 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
285 * snd_hda_sequence_write - sequence writes
286 * @codec: the HDA codec
287 * @seq: VERB array to send
289 * Send the commands sequentially from the given array.
290 * The array must be terminated with NID=0.
292 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
294 for (; seq->nid; seq++)
295 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
297 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
300 * snd_hda_get_sub_nodes - get the range of sub nodes
301 * @codec: the HDA codec
303 * @start_id: the pointer to store the start NID
305 * Parse the NID and store the start NID of its sub-nodes.
306 * Returns the number of sub-nodes.
308 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
313 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
316 *start_id = (parm >> 16) & 0x7fff;
317 return (int)(parm & 0x7fff);
319 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
321 /* look up the cached results */
322 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
325 for (i = 0; i < array->used; ) {
326 hda_nid_t *p = snd_array_elem(array, i);
336 * snd_hda_get_conn_list - get connection list
337 * @codec: the HDA codec
339 * @listp: the pointer to store NID list
341 * Parses the connection list of the given widget and stores the list
344 * Returns the number of connections, or a negative error code.
346 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
347 const hda_nid_t **listp)
349 struct snd_array *array = &codec->conn_lists;
351 hda_nid_t list[HDA_MAX_CONNECTIONS];
356 /* if the connection-list is already cached, read it */
357 p = lookup_conn_list(array, nid);
363 if (snd_BUG_ON(added))
366 /* read the connection and add to the cache */
367 len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
370 err = snd_hda_override_conn_list(codec, nid, len, list);
376 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
379 * snd_hda_get_connections - copy connection list
380 * @codec: the HDA codec
382 * @conn_list: connection list array
383 * @max_conns: max. number of connections to store
385 * Parses the connection list of the given widget and stores the list
388 * Returns the number of connections, or a negative error code.
390 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
391 hda_nid_t *conn_list, int max_conns)
393 const hda_nid_t *list;
394 int len = snd_hda_get_conn_list(codec, nid, &list);
398 if (len > max_conns) {
399 snd_printk(KERN_ERR "hda_codec: "
400 "Too many connections %d for NID 0x%x\n",
404 memcpy(conn_list, list, len * sizeof(hda_nid_t));
407 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
410 * snd_hda_get_raw_connections - copy connection list without cache
411 * @codec: the HDA codec
413 * @conn_list: connection list array
414 * @max_conns: max. number of connections to store
416 * Like snd_hda_get_connections(), copy the connection list but without
417 * checking through the connection-list cache.
418 * Currently called only from hda_proc.c, so not exported.
420 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
421 hda_nid_t *conn_list, int max_conns)
424 int i, conn_len, conns;
425 unsigned int shift, num_elems, mask;
429 if (snd_BUG_ON(!conn_list || max_conns <= 0))
432 wcaps = get_wcaps(codec, nid);
433 if (!(wcaps & AC_WCAP_CONN_LIST) &&
434 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
437 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
438 if (parm & AC_CLIST_LONG) {
447 conn_len = parm & AC_CLIST_LENGTH;
448 mask = (1 << (shift-1)) - 1;
451 return 0; /* no connection */
454 /* single connection */
455 parm = snd_hda_codec_read(codec, nid, 0,
456 AC_VERB_GET_CONNECT_LIST, 0);
457 if (parm == -1 && codec->bus->rirb_error)
459 conn_list[0] = parm & mask;
463 /* multi connection */
466 for (i = 0; i < conn_len; i++) {
470 if (i % num_elems == 0) {
471 parm = snd_hda_codec_read(codec, nid, 0,
472 AC_VERB_GET_CONNECT_LIST, i);
473 if (parm == -1 && codec->bus->rirb_error)
476 range_val = !!(parm & (1 << (shift-1))); /* ranges */
479 snd_printk(KERN_WARNING "hda_codec: "
480 "invalid CONNECT_LIST verb %x[%i]:%x\n",
486 /* ranges between the previous and this one */
487 if (!prev_nid || prev_nid >= val) {
488 snd_printk(KERN_WARNING "hda_codec: "
489 "invalid dep_range_val %x:%x\n",
493 for (n = prev_nid + 1; n <= val; 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++] = n;
503 if (conns >= max_conns) {
504 snd_printk(KERN_ERR "hda_codec: "
505 "Too many connections %d for NID 0x%x\n",
509 conn_list[conns++] = val;
516 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
518 hda_nid_t *p = snd_array_new(array);
526 * snd_hda_override_conn_list - add/modify the connection-list to cache
527 * @codec: the HDA codec
529 * @len: number of connection list entries
530 * @list: the list of connection entries
532 * Add or modify the given connection-list to the cache. If the corresponding
533 * cache already exists, invalidate it and append a new one.
535 * Returns zero or a negative error code.
537 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
538 const hda_nid_t *list)
540 struct snd_array *array = &codec->conn_lists;
544 p = lookup_conn_list(array, nid);
546 *p = -1; /* invalidate the old entry */
548 old_used = array->used;
549 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
551 for (i = 0; i < len; i++)
552 if (!add_conn_list(array, list[i]))
557 array->used = old_used;
560 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
563 * snd_hda_get_conn_index - get the connection index of the given NID
564 * @codec: the HDA codec
565 * @mux: NID containing the list
566 * @nid: NID to select
567 * @recursive: 1 when searching NID recursively, otherwise 0
569 * Parses the connection list of the widget @mux and checks whether the
570 * widget @nid is present. If it is, return the connection index.
571 * Otherwise it returns -1.
573 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
574 hda_nid_t nid, int recursive)
576 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
579 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
580 for (i = 0; i < nums; i++)
586 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
590 for (i = 0; i < nums; i++) {
591 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
592 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
594 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
599 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
602 * snd_hda_queue_unsol_event - add an unsolicited event to queue
604 * @res: unsolicited event (lower 32bit of RIRB entry)
605 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
607 * Adds the given event to the queue. The events are processed in
608 * the workqueue asynchronously. Call this function in the interrupt
609 * hanlder when RIRB receives an unsolicited event.
611 * Returns 0 if successful, or a negative error code.
613 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
615 struct hda_bus_unsolicited *unsol;
618 trace_hda_unsol_event(bus, res, res_ex);
623 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
627 unsol->queue[wp] = res;
628 unsol->queue[wp + 1] = res_ex;
630 queue_work(bus->workq, &unsol->work);
634 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
637 * process queued unsolicited events
639 static void process_unsol_events(struct work_struct *work)
641 struct hda_bus_unsolicited *unsol =
642 container_of(work, struct hda_bus_unsolicited, work);
643 struct hda_bus *bus = unsol->bus;
644 struct hda_codec *codec;
645 unsigned int rp, caddr, res;
647 while (unsol->rp != unsol->wp) {
648 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
651 res = unsol->queue[rp];
652 caddr = unsol->queue[rp + 1];
653 if (!(caddr & (1 << 4))) /* no unsolicited event? */
655 codec = bus->caddr_tbl[caddr & 0x0f];
656 if (codec && codec->patch_ops.unsol_event)
657 codec->patch_ops.unsol_event(codec, res);
662 * initialize unsolicited queue
664 static int init_unsol_queue(struct hda_bus *bus)
666 struct hda_bus_unsolicited *unsol;
668 if (bus->unsol) /* already initialized */
671 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
673 snd_printk(KERN_ERR "hda_codec: "
674 "can't allocate unsolicited queue\n");
677 INIT_WORK(&unsol->work, process_unsol_events);
686 static void snd_hda_codec_free(struct hda_codec *codec);
688 static int snd_hda_bus_free(struct hda_bus *bus)
690 struct hda_codec *codec, *n;
695 flush_workqueue(bus->workq);
698 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
699 snd_hda_codec_free(codec);
701 if (bus->ops.private_free)
702 bus->ops.private_free(bus);
704 destroy_workqueue(bus->workq);
709 static int snd_hda_bus_dev_free(struct snd_device *device)
711 struct hda_bus *bus = device->device_data;
713 return snd_hda_bus_free(bus);
716 #ifdef CONFIG_SND_HDA_HWDEP
717 static int snd_hda_bus_dev_register(struct snd_device *device)
719 struct hda_bus *bus = device->device_data;
720 struct hda_codec *codec;
721 list_for_each_entry(codec, &bus->codec_list, list) {
722 snd_hda_hwdep_add_sysfs(codec);
723 snd_hda_hwdep_add_power_sysfs(codec);
728 #define snd_hda_bus_dev_register NULL
732 * snd_hda_bus_new - create a HDA bus
733 * @card: the card entry
734 * @temp: the template for hda_bus information
735 * @busp: the pointer to store the created bus instance
737 * Returns 0 if successful, or a negative error code.
739 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
740 const struct hda_bus_template *temp,
741 struct hda_bus **busp)
745 static struct snd_device_ops dev_ops = {
746 .dev_register = snd_hda_bus_dev_register,
747 .dev_free = snd_hda_bus_dev_free,
750 if (snd_BUG_ON(!temp))
752 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
758 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
760 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
765 bus->private_data = temp->private_data;
766 bus->pci = temp->pci;
767 bus->modelname = temp->modelname;
768 bus->power_save = temp->power_save;
769 bus->ops = temp->ops;
771 mutex_init(&bus->cmd_mutex);
772 mutex_init(&bus->prepare_mutex);
773 INIT_LIST_HEAD(&bus->codec_list);
775 snprintf(bus->workq_name, sizeof(bus->workq_name),
776 "hd-audio%d", card->number);
777 bus->workq = create_singlethread_workqueue(bus->workq_name);
779 snd_printk(KERN_ERR "cannot create workqueue %s\n",
785 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
787 snd_hda_bus_free(bus);
794 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
796 #ifdef CONFIG_SND_HDA_GENERIC
797 #define is_generic_config(codec) \
798 (codec->modelname && !strcmp(codec->modelname, "generic"))
800 #define is_generic_config(codec) 0
804 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
806 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
810 * find a matching codec preset
812 static const struct hda_codec_preset *
813 find_codec_preset(struct hda_codec *codec)
815 struct hda_codec_preset_list *tbl;
816 const struct hda_codec_preset *preset;
817 int mod_requested = 0;
819 if (is_generic_config(codec))
820 return NULL; /* use the generic parser */
823 mutex_lock(&preset_mutex);
824 list_for_each_entry(tbl, &hda_preset_tables, list) {
825 if (!try_module_get(tbl->owner)) {
826 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
829 for (preset = tbl->preset; preset->id; preset++) {
830 u32 mask = preset->mask;
831 if (preset->afg && preset->afg != codec->afg)
833 if (preset->mfg && preset->mfg != codec->mfg)
837 if (preset->id == (codec->vendor_id & mask) &&
839 preset->rev == codec->revision_id)) {
840 mutex_unlock(&preset_mutex);
841 codec->owner = tbl->owner;
845 module_put(tbl->owner);
847 mutex_unlock(&preset_mutex);
849 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
852 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
855 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
856 (codec->vendor_id >> 16) & 0xffff);
857 request_module(name);
865 * get_codec_name - store the codec name
867 static int get_codec_name(struct hda_codec *codec)
869 const struct hda_vendor_id *c;
870 const char *vendor = NULL;
871 u16 vendor_id = codec->vendor_id >> 16;
874 if (codec->vendor_name)
877 for (c = hda_vendor_ids; c->id; c++) {
878 if (c->id == vendor_id) {
884 sprintf(tmp, "Generic %04x", vendor_id);
887 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
888 if (!codec->vendor_name)
892 if (codec->chip_name)
895 if (codec->preset && codec->preset->name)
896 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
898 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
899 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
901 if (!codec->chip_name)
907 * look for an AFG and MFG nodes
909 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
911 int i, total_nodes, function_id;
914 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
915 for (i = 0; i < total_nodes; i++, nid++) {
916 function_id = snd_hda_param_read(codec, nid,
917 AC_PAR_FUNCTION_TYPE);
918 switch (function_id & 0xff) {
919 case AC_GRP_AUDIO_FUNCTION:
921 codec->afg_function_id = function_id & 0xff;
922 codec->afg_unsol = (function_id >> 8) & 1;
924 case AC_GRP_MODEM_FUNCTION:
926 codec->mfg_function_id = function_id & 0xff;
927 codec->mfg_unsol = (function_id >> 8) & 1;
936 * read widget caps for each widget and store in cache
938 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
943 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
945 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
948 nid = codec->start_nid;
949 for (i = 0; i < codec->num_nodes; i++, nid++)
950 codec->wcaps[i] = snd_hda_param_read(codec, nid,
951 AC_PAR_AUDIO_WIDGET_CAP);
955 /* read all pin default configurations and save codec->init_pins */
956 static int read_pin_defaults(struct hda_codec *codec)
959 hda_nid_t nid = codec->start_nid;
961 for (i = 0; i < codec->num_nodes; i++, nid++) {
962 struct hda_pincfg *pin;
963 unsigned int wcaps = get_wcaps(codec, nid);
964 unsigned int wid_type = get_wcaps_type(wcaps);
965 if (wid_type != AC_WID_PIN)
967 pin = snd_array_new(&codec->init_pins);
971 pin->cfg = snd_hda_codec_read(codec, nid, 0,
972 AC_VERB_GET_CONFIG_DEFAULT, 0);
973 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
974 AC_VERB_GET_PIN_WIDGET_CONTROL,
980 /* look up the given pin config list and return the item matching with NID */
981 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
982 struct snd_array *array,
986 for (i = 0; i < array->used; i++) {
987 struct hda_pincfg *pin = snd_array_elem(array, i);
994 /* write a config value for the given NID */
995 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
999 for (i = 0; i < 4; i++) {
1000 snd_hda_codec_write(codec, nid, 0,
1001 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1007 /* set the current pin config value for the given NID.
1008 * the value is cached, and read via snd_hda_codec_get_pincfg()
1010 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1011 hda_nid_t nid, unsigned int cfg)
1013 struct hda_pincfg *pin;
1014 unsigned int oldcfg;
1016 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1019 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
1020 pin = look_up_pincfg(codec, list, nid);
1022 pin = snd_array_new(list);
1029 /* change only when needed; e.g. if the pincfg is already present
1030 * in user_pins[], don't write it
1032 cfg = snd_hda_codec_get_pincfg(codec, nid);
1034 set_pincfg(codec, nid, cfg);
1039 * snd_hda_codec_set_pincfg - Override a pin default configuration
1040 * @codec: the HDA codec
1041 * @nid: NID to set the pin config
1042 * @cfg: the pin default config value
1044 * Override a pin default configuration value in the cache.
1045 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1046 * priority than the real hardware value.
1048 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1049 hda_nid_t nid, unsigned int cfg)
1051 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1053 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1056 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1057 * @codec: the HDA codec
1058 * @nid: NID to get the pin config
1060 * Get the current pin config value of the given pin NID.
1061 * If the pincfg value is cached or overridden via sysfs or driver,
1062 * returns the cached value.
1064 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1066 struct hda_pincfg *pin;
1068 #ifdef CONFIG_SND_HDA_HWDEP
1069 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1073 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1076 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1081 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1083 /* restore all current pin configs */
1084 static void restore_pincfgs(struct hda_codec *codec)
1087 for (i = 0; i < codec->init_pins.used; i++) {
1088 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1089 set_pincfg(codec, pin->nid,
1090 snd_hda_codec_get_pincfg(codec, pin->nid));
1095 * snd_hda_shutup_pins - Shut up all pins
1096 * @codec: the HDA codec
1098 * Clear all pin controls to shup up before suspend for avoiding click noise.
1099 * The controls aren't cached so that they can be resumed properly.
1101 void snd_hda_shutup_pins(struct hda_codec *codec)
1104 /* don't shut up pins when unloading the driver; otherwise it breaks
1105 * the default pin setup at the next load of the driver
1107 if (codec->bus->shutdown)
1109 for (i = 0; i < codec->init_pins.used; i++) {
1110 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1111 /* use read here for syncing after issuing each verb */
1112 snd_hda_codec_read(codec, pin->nid, 0,
1113 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1115 codec->pins_shutup = 1;
1117 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1120 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1121 static void restore_shutup_pins(struct hda_codec *codec)
1124 if (!codec->pins_shutup)
1126 if (codec->bus->shutdown)
1128 for (i = 0; i < codec->init_pins.used; i++) {
1129 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1130 snd_hda_codec_write(codec, pin->nid, 0,
1131 AC_VERB_SET_PIN_WIDGET_CONTROL,
1134 codec->pins_shutup = 0;
1138 static void init_hda_cache(struct hda_cache_rec *cache,
1139 unsigned int record_size);
1140 static void free_hda_cache(struct hda_cache_rec *cache);
1142 /* restore the initial pin cfgs and release all pincfg lists */
1143 static void restore_init_pincfgs(struct hda_codec *codec)
1145 /* first free driver_pins and user_pins, then call restore_pincfg
1146 * so that only the values in init_pins are restored
1148 snd_array_free(&codec->driver_pins);
1149 #ifdef CONFIG_SND_HDA_HWDEP
1150 snd_array_free(&codec->user_pins);
1152 restore_pincfgs(codec);
1153 snd_array_free(&codec->init_pins);
1157 * audio-converter setup caches
1159 struct hda_cvt_setup {
1164 unsigned char active; /* cvt is currently used */
1165 unsigned char dirty; /* setups should be cleared */
1168 /* get or create a cache entry for the given audio converter NID */
1169 static struct hda_cvt_setup *
1170 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1172 struct hda_cvt_setup *p;
1175 for (i = 0; i < codec->cvt_setups.used; i++) {
1176 p = snd_array_elem(&codec->cvt_setups, i);
1180 p = snd_array_new(&codec->cvt_setups);
1189 static void snd_hda_codec_free(struct hda_codec *codec)
1193 restore_init_pincfgs(codec);
1194 #ifdef CONFIG_SND_HDA_POWER_SAVE
1195 cancel_delayed_work(&codec->power_work);
1196 flush_workqueue(codec->bus->workq);
1198 list_del(&codec->list);
1199 snd_array_free(&codec->mixers);
1200 snd_array_free(&codec->nids);
1201 snd_array_free(&codec->conn_lists);
1202 snd_array_free(&codec->spdif_out);
1203 codec->bus->caddr_tbl[codec->addr] = NULL;
1204 if (codec->patch_ops.free)
1205 codec->patch_ops.free(codec);
1206 module_put(codec->owner);
1207 free_hda_cache(&codec->amp_cache);
1208 free_hda_cache(&codec->cmd_cache);
1209 kfree(codec->vendor_name);
1210 kfree(codec->chip_name);
1211 kfree(codec->modelname);
1212 kfree(codec->wcaps);
1216 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1217 unsigned int power_state);
1220 * snd_hda_codec_new - create a HDA codec
1221 * @bus: the bus to assign
1222 * @codec_addr: the codec address
1223 * @codecp: the pointer to store the generated codec
1225 * Returns 0 if successful, or a negative error code.
1227 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1228 unsigned int codec_addr,
1229 struct hda_codec **codecp)
1231 struct hda_codec *codec;
1235 if (snd_BUG_ON(!bus))
1237 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1240 if (bus->caddr_tbl[codec_addr]) {
1241 snd_printk(KERN_ERR "hda_codec: "
1242 "address 0x%x is already occupied\n", codec_addr);
1246 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1247 if (codec == NULL) {
1248 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1253 codec->addr = codec_addr;
1254 mutex_init(&codec->spdif_mutex);
1255 mutex_init(&codec->control_mutex);
1256 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1257 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1258 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1259 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1260 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1261 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1262 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1263 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1264 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1265 if (codec->bus->modelname) {
1266 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1267 if (!codec->modelname) {
1268 snd_hda_codec_free(codec);
1273 #ifdef CONFIG_SND_HDA_POWER_SAVE
1274 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1275 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1276 * the caller has to power down appropriatley after initialization
1279 hda_keep_power_on(codec);
1282 list_add_tail(&codec->list, &bus->codec_list);
1283 bus->caddr_tbl[codec_addr] = codec;
1285 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1287 if (codec->vendor_id == -1)
1288 /* read again, hopefully the access method was corrected
1289 * in the last read...
1291 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1293 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1294 AC_PAR_SUBSYSTEM_ID);
1295 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1298 setup_fg_nodes(codec);
1299 if (!codec->afg && !codec->mfg) {
1300 snd_printdd("hda_codec: no AFG or MFG node found\n");
1305 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1307 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1310 err = read_pin_defaults(codec);
1314 if (!codec->subsystem_id) {
1315 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1316 codec->subsystem_id =
1317 snd_hda_codec_read(codec, nid, 0,
1318 AC_VERB_GET_SUBSYSTEM_ID, 0);
1321 /* power-up all before initialization */
1322 hda_set_power_state(codec,
1323 codec->afg ? codec->afg : codec->mfg,
1326 snd_hda_codec_proc_new(codec);
1328 snd_hda_create_hwdep(codec);
1330 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1331 codec->subsystem_id, codec->revision_id);
1332 snd_component_add(codec->bus->card, component);
1339 snd_hda_codec_free(codec);
1342 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1345 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1346 * @codec: the HDA codec
1348 * Start parsing of the given codec tree and (re-)initialize the whole
1351 * Returns 0 if successful or a negative error code.
1353 int snd_hda_codec_configure(struct hda_codec *codec)
1357 codec->preset = find_codec_preset(codec);
1358 if (!codec->vendor_name || !codec->chip_name) {
1359 err = get_codec_name(codec);
1364 if (is_generic_config(codec)) {
1365 err = snd_hda_parse_generic_codec(codec);
1368 if (codec->preset && codec->preset->patch) {
1369 err = codec->preset->patch(codec);
1373 /* call the default parser */
1374 err = snd_hda_parse_generic_codec(codec);
1376 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1379 if (!err && codec->patch_ops.unsol_event)
1380 err = init_unsol_queue(codec->bus);
1381 /* audio codec should override the mixer name */
1382 if (!err && (codec->afg || !*codec->bus->card->mixername))
1383 snprintf(codec->bus->card->mixername,
1384 sizeof(codec->bus->card->mixername),
1385 "%s %s", codec->vendor_name, codec->chip_name);
1388 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1391 * snd_hda_codec_setup_stream - set up the codec for streaming
1392 * @codec: the CODEC to set up
1393 * @nid: the NID to set up
1394 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1395 * @channel_id: channel id to pass, zero based.
1396 * @format: stream format.
1398 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1400 int channel_id, int format)
1402 struct hda_codec *c;
1403 struct hda_cvt_setup *p;
1404 unsigned int oldval, newval;
1411 snd_printdd("hda_codec_setup_stream: "
1412 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1413 nid, stream_tag, channel_id, format);
1414 p = get_hda_cvt_setup(codec, nid);
1417 /* update the stream-id if changed */
1418 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1419 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1420 newval = (stream_tag << 4) | channel_id;
1421 if (oldval != newval)
1422 snd_hda_codec_write(codec, nid, 0,
1423 AC_VERB_SET_CHANNEL_STREAMID,
1425 p->stream_tag = stream_tag;
1426 p->channel_id = channel_id;
1428 /* update the format-id if changed */
1429 if (p->format_id != format) {
1430 oldval = snd_hda_codec_read(codec, nid, 0,
1431 AC_VERB_GET_STREAM_FORMAT, 0);
1432 if (oldval != format) {
1434 snd_hda_codec_write(codec, nid, 0,
1435 AC_VERB_SET_STREAM_FORMAT,
1438 p->format_id = format;
1443 /* make other inactive cvts with the same stream-tag dirty */
1444 type = get_wcaps_type(get_wcaps(codec, nid));
1445 list_for_each_entry(c, &codec->bus->codec_list, list) {
1446 for (i = 0; i < c->cvt_setups.used; i++) {
1447 p = snd_array_elem(&c->cvt_setups, i);
1448 if (!p->active && p->stream_tag == stream_tag &&
1449 get_wcaps_type(get_wcaps(codec, p->nid)) == type)
1454 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1456 static void really_cleanup_stream(struct hda_codec *codec,
1457 struct hda_cvt_setup *q);
1460 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1461 * @codec: the CODEC to clean up
1462 * @nid: the NID to clean up
1463 * @do_now: really clean up the stream instead of clearing the active flag
1465 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1468 struct hda_cvt_setup *p;
1473 if (codec->no_sticky_stream)
1476 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1477 p = get_hda_cvt_setup(codec, nid);
1479 /* here we just clear the active flag when do_now isn't set;
1480 * actual clean-ups will be done later in
1481 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1484 really_cleanup_stream(codec, p);
1489 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1491 static void really_cleanup_stream(struct hda_codec *codec,
1492 struct hda_cvt_setup *q)
1494 hda_nid_t nid = q->nid;
1495 if (q->stream_tag || q->channel_id)
1496 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1498 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1500 memset(q, 0, sizeof(*q));
1504 /* clean up the all conflicting obsolete streams */
1505 static void purify_inactive_streams(struct hda_codec *codec)
1507 struct hda_codec *c;
1510 list_for_each_entry(c, &codec->bus->codec_list, list) {
1511 for (i = 0; i < c->cvt_setups.used; i++) {
1512 struct hda_cvt_setup *p;
1513 p = snd_array_elem(&c->cvt_setups, i);
1515 really_cleanup_stream(c, p);
1521 /* clean up all streams; called from suspend */
1522 static void hda_cleanup_all_streams(struct hda_codec *codec)
1526 for (i = 0; i < codec->cvt_setups.used; i++) {
1527 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1529 really_cleanup_stream(codec, p);
1535 * amp access functions
1538 /* FIXME: more better hash key? */
1539 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1540 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1541 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1542 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1543 #define INFO_AMP_CAPS (1<<0)
1544 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1546 /* initialize the hash table */
1547 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1548 unsigned int record_size)
1550 memset(cache, 0, sizeof(*cache));
1551 memset(cache->hash, 0xff, sizeof(cache->hash));
1552 snd_array_init(&cache->buf, record_size, 64);
1555 static void free_hda_cache(struct hda_cache_rec *cache)
1557 snd_array_free(&cache->buf);
1560 /* query the hash. allocate an entry if not found. */
1561 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1563 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1564 u16 cur = cache->hash[idx];
1565 struct hda_cache_head *info;
1567 while (cur != 0xffff) {
1568 info = snd_array_elem(&cache->buf, cur);
1569 if (info->key == key)
1576 /* query the hash. allocate an entry if not found. */
1577 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1580 struct hda_cache_head *info = get_hash(cache, key);
1583 /* add a new hash entry */
1584 info = snd_array_new(&cache->buf);
1587 cur = snd_array_index(&cache->buf, info);
1590 idx = key % (u16)ARRAY_SIZE(cache->hash);
1591 info->next = cache->hash[idx];
1592 cache->hash[idx] = cur;
1597 /* query and allocate an amp hash entry */
1598 static inline struct hda_amp_info *
1599 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1601 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1605 * query_amp_caps - query AMP capabilities
1606 * @codec: the HD-auio codec
1607 * @nid: the NID to query
1608 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1610 * Query AMP capabilities for the given widget and direction.
1611 * Returns the obtained capability bits.
1613 * When cap bits have been already read, this doesn't read again but
1614 * returns the cached value.
1616 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1618 struct hda_amp_info *info;
1620 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1623 if (!(info->head.val & INFO_AMP_CAPS)) {
1624 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1626 info->amp_caps = snd_hda_param_read(codec, nid,
1627 direction == HDA_OUTPUT ?
1628 AC_PAR_AMP_OUT_CAP :
1631 info->head.val |= INFO_AMP_CAPS;
1633 return info->amp_caps;
1635 EXPORT_SYMBOL_HDA(query_amp_caps);
1638 * snd_hda_override_amp_caps - Override the AMP capabilities
1639 * @codec: the CODEC to clean up
1640 * @nid: the NID to clean up
1641 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1642 * @caps: the capability bits to set
1644 * Override the cached AMP caps bits value by the given one.
1645 * This function is useful if the driver needs to adjust the AMP ranges,
1646 * e.g. limit to 0dB, etc.
1648 * Returns zero if successful or a negative error code.
1650 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1653 struct hda_amp_info *info;
1655 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1658 info->amp_caps = caps;
1659 info->head.val |= INFO_AMP_CAPS;
1662 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1665 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1666 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1668 struct hda_amp_info *info;
1670 info = get_alloc_amp_hash(codec, key);
1673 if (!info->head.val) {
1674 info->head.val |= INFO_AMP_CAPS;
1675 info->amp_caps = func(codec, nid);
1677 return info->amp_caps;
1680 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1682 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1686 * snd_hda_query_pin_caps - Query PIN capabilities
1687 * @codec: the HD-auio codec
1688 * @nid: the NID to query
1690 * Query PIN capabilities for the given widget.
1691 * Returns the obtained capability bits.
1693 * When cap bits have been already read, this doesn't read again but
1694 * returns the cached value.
1696 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1698 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1701 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1704 * snd_hda_override_pin_caps - Override the pin capabilities
1706 * @nid: the NID to override
1707 * @caps: the capability bits to set
1709 * Override the cached PIN capabilitiy bits value by the given one.
1711 * Returns zero if successful or a negative error code.
1713 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1716 struct hda_amp_info *info;
1717 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1720 info->amp_caps = caps;
1721 info->head.val |= INFO_AMP_CAPS;
1724 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1727 * snd_hda_pin_sense - execute pin sense measurement
1728 * @codec: the CODEC to sense
1729 * @nid: the pin NID to sense
1731 * Execute necessary pin sense measurement and return its Presence Detect,
1732 * Impedance, ELD Valid etc. status bits.
1734 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1738 if (!codec->no_trigger_sense) {
1739 pincap = snd_hda_query_pin_caps(codec, nid);
1740 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1741 snd_hda_codec_read(codec, nid, 0,
1742 AC_VERB_SET_PIN_SENSE, 0);
1744 return snd_hda_codec_read(codec, nid, 0,
1745 AC_VERB_GET_PIN_SENSE, 0);
1747 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1750 * snd_hda_jack_detect - query pin Presence Detect status
1751 * @codec: the CODEC to sense
1752 * @nid: the pin NID to sense
1754 * Query and return the pin's Presence Detect status.
1756 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1758 u32 sense = snd_hda_pin_sense(codec, nid);
1759 return !!(sense & AC_PINSENSE_PRESENCE);
1761 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1764 * read the current volume to info
1765 * if the cache exists, read the cache value.
1767 static unsigned int get_vol_mute(struct hda_codec *codec,
1768 struct hda_amp_info *info, hda_nid_t nid,
1769 int ch, int direction, int index)
1773 if (info->head.val & INFO_AMP_VOL(ch))
1774 return info->vol[ch];
1776 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1777 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1779 val = snd_hda_codec_read(codec, nid, 0,
1780 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1781 info->vol[ch] = val & 0xff;
1782 info->head.val |= INFO_AMP_VOL(ch);
1783 return info->vol[ch];
1787 * write the current volume in info to the h/w and update the cache
1789 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1790 hda_nid_t nid, int ch, int direction, int index,
1795 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1796 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1797 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1799 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1800 info->vol[ch] = val;
1804 * snd_hda_codec_amp_read - Read AMP value
1805 * @codec: HD-audio codec
1806 * @nid: NID to read the AMP value
1807 * @ch: channel (left=0 or right=1)
1808 * @direction: #HDA_INPUT or #HDA_OUTPUT
1809 * @index: the index value (only for input direction)
1811 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1813 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1814 int direction, int index)
1816 struct hda_amp_info *info;
1817 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1820 return get_vol_mute(codec, info, nid, ch, direction, index);
1822 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1825 * snd_hda_codec_amp_update - update the AMP value
1826 * @codec: HD-audio codec
1827 * @nid: NID to read the AMP value
1828 * @ch: channel (left=0 or right=1)
1829 * @direction: #HDA_INPUT or #HDA_OUTPUT
1830 * @idx: the index value (only for input direction)
1831 * @mask: bit mask to set
1832 * @val: the bits value to set
1834 * Update the AMP value with a bit mask.
1835 * Returns 0 if the value is unchanged, 1 if changed.
1837 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1838 int direction, int idx, int mask, int val)
1840 struct hda_amp_info *info;
1842 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1845 if (snd_BUG_ON(mask & ~0xff))
1848 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1849 if (info->vol[ch] == val)
1851 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1854 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1857 * snd_hda_codec_amp_stereo - update the AMP stereo values
1858 * @codec: HD-audio codec
1859 * @nid: NID to read the AMP value
1860 * @direction: #HDA_INPUT or #HDA_OUTPUT
1861 * @idx: the index value (only for input direction)
1862 * @mask: bit mask to set
1863 * @val: the bits value to set
1865 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1866 * stereo widget with the same mask and value.
1868 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1869 int direction, int idx, int mask, int val)
1873 if (snd_BUG_ON(mask & ~0xff))
1875 for (ch = 0; ch < 2; ch++)
1876 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1880 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1884 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1885 * @codec: HD-audio codec
1887 * Resume the all amp commands from the cache.
1889 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1891 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1894 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1895 u32 key = buffer->head.key;
1897 unsigned int idx, dir, ch;
1901 idx = (key >> 16) & 0xff;
1902 dir = (key >> 24) & 0xff;
1903 for (ch = 0; ch < 2; ch++) {
1904 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1906 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1911 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1912 #endif /* CONFIG_PM */
1914 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1917 u32 caps = query_amp_caps(codec, nid, dir);
1919 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1926 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1928 * The control element is supposed to have the private_value field
1929 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1931 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1932 struct snd_ctl_elem_info *uinfo)
1934 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1935 u16 nid = get_amp_nid(kcontrol);
1936 u8 chs = get_amp_channels(kcontrol);
1937 int dir = get_amp_direction(kcontrol);
1938 unsigned int ofs = get_amp_offset(kcontrol);
1940 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1941 uinfo->count = chs == 3 ? 2 : 1;
1942 uinfo->value.integer.min = 0;
1943 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1944 if (!uinfo->value.integer.max) {
1945 printk(KERN_WARNING "hda_codec: "
1946 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1952 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1955 static inline unsigned int
1956 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1957 int ch, int dir, int idx, unsigned int ofs)
1960 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1961 val &= HDA_AMP_VOLMASK;
1970 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1971 int ch, int dir, int idx, unsigned int ofs,
1974 unsigned int maxval;
1978 /* ofs = 0: raw max value */
1979 maxval = get_amp_max_value(codec, nid, dir, 0);
1982 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1983 HDA_AMP_VOLMASK, val);
1987 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1989 * The control element is supposed to have the private_value field
1990 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1992 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1993 struct snd_ctl_elem_value *ucontrol)
1995 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1996 hda_nid_t nid = get_amp_nid(kcontrol);
1997 int chs = get_amp_channels(kcontrol);
1998 int dir = get_amp_direction(kcontrol);
1999 int idx = get_amp_index(kcontrol);
2000 unsigned int ofs = get_amp_offset(kcontrol);
2001 long *valp = ucontrol->value.integer.value;
2004 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2006 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2009 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2012 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2014 * The control element is supposed to have the private_value field
2015 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2017 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2018 struct snd_ctl_elem_value *ucontrol)
2020 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2021 hda_nid_t nid = get_amp_nid(kcontrol);
2022 int chs = get_amp_channels(kcontrol);
2023 int dir = get_amp_direction(kcontrol);
2024 int idx = get_amp_index(kcontrol);
2025 unsigned int ofs = get_amp_offset(kcontrol);
2026 long *valp = ucontrol->value.integer.value;
2029 snd_hda_power_up(codec);
2031 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2035 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2036 snd_hda_power_down(codec);
2039 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2042 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2044 * The control element is supposed to have the private_value field
2045 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2047 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2048 unsigned int size, unsigned int __user *_tlv)
2050 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2051 hda_nid_t nid = get_amp_nid(kcontrol);
2052 int dir = get_amp_direction(kcontrol);
2053 unsigned int ofs = get_amp_offset(kcontrol);
2054 bool min_mute = get_amp_min_mute(kcontrol);
2055 u32 caps, val1, val2;
2057 if (size < 4 * sizeof(unsigned int))
2059 caps = query_amp_caps(codec, nid, dir);
2060 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2061 val2 = (val2 + 1) * 25;
2062 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2064 val1 = ((int)val1) * ((int)val2);
2066 val2 |= TLV_DB_SCALE_MUTE;
2067 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2069 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2071 if (put_user(val1, _tlv + 2))
2073 if (put_user(val2, _tlv + 3))
2077 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2080 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2081 * @codec: HD-audio codec
2082 * @nid: NID of a reference widget
2083 * @dir: #HDA_INPUT or #HDA_OUTPUT
2084 * @tlv: TLV data to be stored, at least 4 elements
2086 * Set (static) TLV data for a virtual master volume using the AMP caps
2087 * obtained from the reference NID.
2088 * The volume range is recalculated as if the max volume is 0dB.
2090 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2096 caps = query_amp_caps(codec, nid, dir);
2097 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2098 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2099 step = (step + 1) * 25;
2100 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2101 tlv[1] = 2 * sizeof(unsigned int);
2102 tlv[2] = -nums * step;
2105 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2107 /* find a mixer control element with the given name */
2108 static struct snd_kcontrol *
2109 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2110 const char *name, int idx)
2112 struct snd_ctl_elem_id id;
2113 memset(&id, 0, sizeof(id));
2114 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2116 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2118 strcpy(id.name, name);
2119 return snd_ctl_find_id(codec->bus->card, &id);
2123 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2124 * @codec: HD-audio codec
2125 * @name: ctl id name string
2127 * Get the control element with the given id string and IFACE_MIXER.
2129 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2132 return _snd_hda_find_mixer_ctl(codec, name, 0);
2134 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2136 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2139 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2140 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2147 * snd_hda_ctl_add - Add a control element and assign to the codec
2148 * @codec: HD-audio codec
2149 * @nid: corresponding NID (optional)
2150 * @kctl: the control element to assign
2152 * Add the given control element to an array inside the codec instance.
2153 * All control elements belonging to a codec are supposed to be added
2154 * by this function so that a proper clean-up works at the free or
2155 * reconfiguration time.
2157 * If non-zero @nid is passed, the NID is assigned to the control element.
2158 * The assignment is shown in the codec proc file.
2160 * snd_hda_ctl_add() checks the control subdev id field whether
2161 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2162 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2163 * specifies if kctl->private_value is a HDA amplifier value.
2165 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2166 struct snd_kcontrol *kctl)
2169 unsigned short flags = 0;
2170 struct hda_nid_item *item;
2172 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2173 flags |= HDA_NID_ITEM_AMP;
2175 nid = get_amp_nid_(kctl->private_value);
2177 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2178 nid = kctl->id.subdevice & 0xffff;
2179 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2180 kctl->id.subdevice = 0;
2181 err = snd_ctl_add(codec->bus->card, kctl);
2184 item = snd_array_new(&codec->mixers);
2189 item->flags = flags;
2192 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2195 * snd_hda_add_nid - Assign a NID to a control element
2196 * @codec: HD-audio codec
2197 * @nid: corresponding NID (optional)
2198 * @kctl: the control element to assign
2199 * @index: index to kctl
2201 * Add the given control element to an array inside the codec instance.
2202 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2203 * NID:KCTL mapping - for example "Capture Source" selector.
2205 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2206 unsigned int index, hda_nid_t nid)
2208 struct hda_nid_item *item;
2211 item = snd_array_new(&codec->nids);
2215 item->index = index;
2219 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2220 kctl->id.name, kctl->id.index, index);
2223 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2226 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2227 * @codec: HD-audio codec
2229 void snd_hda_ctls_clear(struct hda_codec *codec)
2232 struct hda_nid_item *items = codec->mixers.list;
2233 for (i = 0; i < codec->mixers.used; i++)
2234 snd_ctl_remove(codec->bus->card, items[i].kctl);
2235 snd_array_free(&codec->mixers);
2236 snd_array_free(&codec->nids);
2239 /* pseudo device locking
2240 * toggle card->shutdown to allow/disallow the device access (as a hack)
2242 static int hda_lock_devices(struct snd_card *card)
2244 spin_lock(&card->files_lock);
2245 if (card->shutdown) {
2246 spin_unlock(&card->files_lock);
2250 spin_unlock(&card->files_lock);
2254 static void hda_unlock_devices(struct snd_card *card)
2256 spin_lock(&card->files_lock);
2258 spin_unlock(&card->files_lock);
2262 * snd_hda_codec_reset - Clear all objects assigned to the codec
2263 * @codec: HD-audio codec
2265 * This frees the all PCM and control elements assigned to the codec, and
2266 * clears the caches and restores the pin default configurations.
2268 * When a device is being used, it returns -EBSY. If successfully freed,
2271 int snd_hda_codec_reset(struct hda_codec *codec)
2273 struct snd_card *card = codec->bus->card;
2276 if (hda_lock_devices(card) < 0)
2278 /* check whether the codec isn't used by any mixer or PCM streams */
2279 if (!list_empty(&card->ctl_files)) {
2280 hda_unlock_devices(card);
2283 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2284 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2287 if (cpcm->pcm->streams[0].substream_opened ||
2288 cpcm->pcm->streams[1].substream_opened) {
2289 hda_unlock_devices(card);
2294 /* OK, let it free */
2296 #ifdef CONFIG_SND_HDA_POWER_SAVE
2297 cancel_delayed_work(&codec->power_work);
2298 flush_workqueue(codec->bus->workq);
2300 snd_hda_ctls_clear(codec);
2302 for (i = 0; i < codec->num_pcms; i++) {
2303 if (codec->pcm_info[i].pcm) {
2304 snd_device_free(card, codec->pcm_info[i].pcm);
2305 clear_bit(codec->pcm_info[i].device,
2306 codec->bus->pcm_dev_bits);
2309 if (codec->patch_ops.free)
2310 codec->patch_ops.free(codec);
2311 codec->proc_widget_hook = NULL;
2313 free_hda_cache(&codec->amp_cache);
2314 free_hda_cache(&codec->cmd_cache);
2315 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2316 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2317 /* free only driver_pins so that init_pins + user_pins are restored */
2318 snd_array_free(&codec->driver_pins);
2319 restore_pincfgs(codec);
2320 codec->num_pcms = 0;
2321 codec->pcm_info = NULL;
2322 codec->preset = NULL;
2323 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2324 codec->slave_dig_outs = NULL;
2325 codec->spdif_status_reset = 0;
2326 module_put(codec->owner);
2327 codec->owner = NULL;
2329 /* allow device access again */
2330 hda_unlock_devices(card);
2335 * snd_hda_add_vmaster - create a virtual master control and add slaves
2336 * @codec: HD-audio codec
2337 * @name: vmaster control name
2338 * @tlv: TLV data (optional)
2339 * @slaves: slave control names (optional)
2341 * Create a virtual master control with the given name. The TLV data
2342 * must be either NULL or a valid data.
2344 * @slaves is a NULL-terminated array of strings, each of which is a
2345 * slave control name. All controls with these names are assigned to
2346 * the new virtual master control.
2348 * This function returns zero if successful or a negative error code.
2350 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2351 unsigned int *tlv, const char * const *slaves)
2353 struct snd_kcontrol *kctl;
2354 const char * const *s;
2357 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
2360 snd_printdd("No slave found for %s\n", name);
2363 kctl = snd_ctl_make_virtual_master(name, tlv);
2366 err = snd_hda_ctl_add(codec, 0, kctl);
2370 for (s = slaves; *s; s++) {
2371 struct snd_kcontrol *sctl;
2374 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
2377 snd_printdd("Cannot find slave %s, "
2381 err = snd_ctl_add_slave(kctl, sctl);
2389 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2392 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2394 * The control element is supposed to have the private_value field
2395 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2397 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2398 struct snd_ctl_elem_info *uinfo)
2400 int chs = get_amp_channels(kcontrol);
2402 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2403 uinfo->count = chs == 3 ? 2 : 1;
2404 uinfo->value.integer.min = 0;
2405 uinfo->value.integer.max = 1;
2408 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2411 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2413 * The control element is supposed to have the private_value field
2414 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2416 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2417 struct snd_ctl_elem_value *ucontrol)
2419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2420 hda_nid_t nid = get_amp_nid(kcontrol);
2421 int chs = get_amp_channels(kcontrol);
2422 int dir = get_amp_direction(kcontrol);
2423 int idx = get_amp_index(kcontrol);
2424 long *valp = ucontrol->value.integer.value;
2427 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2428 HDA_AMP_MUTE) ? 0 : 1;
2430 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2431 HDA_AMP_MUTE) ? 0 : 1;
2434 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2437 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2439 * The control element is supposed to have the private_value field
2440 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2442 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2443 struct snd_ctl_elem_value *ucontrol)
2445 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2446 hda_nid_t nid = get_amp_nid(kcontrol);
2447 int chs = get_amp_channels(kcontrol);
2448 int dir = get_amp_direction(kcontrol);
2449 int idx = get_amp_index(kcontrol);
2450 long *valp = ucontrol->value.integer.value;
2453 snd_hda_power_up(codec);
2455 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2457 *valp ? 0 : HDA_AMP_MUTE);
2461 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2463 *valp ? 0 : HDA_AMP_MUTE);
2464 hda_call_check_power_status(codec, nid);
2465 snd_hda_power_down(codec);
2468 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2470 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2472 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2474 * This function calls snd_hda_enable_beep_device(), which behaves differently
2475 * depending on beep_mode option.
2477 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2478 struct snd_ctl_elem_value *ucontrol)
2480 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2481 long *valp = ucontrol->value.integer.value;
2483 snd_hda_enable_beep_device(codec, *valp);
2484 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2486 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2487 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2490 * bound volume controls
2492 * bind multiple volumes (# indices, from 0)
2495 #define AMP_VAL_IDX_SHIFT 19
2496 #define AMP_VAL_IDX_MASK (0x0f<<19)
2499 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2501 * The control element is supposed to have the private_value field
2502 * set up via HDA_BIND_MUTE*() macros.
2504 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2505 struct snd_ctl_elem_value *ucontrol)
2507 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2511 mutex_lock(&codec->control_mutex);
2512 pval = kcontrol->private_value;
2513 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2514 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2515 kcontrol->private_value = pval;
2516 mutex_unlock(&codec->control_mutex);
2519 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2522 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2524 * The control element is supposed to have the private_value field
2525 * set up via HDA_BIND_MUTE*() macros.
2527 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2528 struct snd_ctl_elem_value *ucontrol)
2530 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2532 int i, indices, err = 0, change = 0;
2534 mutex_lock(&codec->control_mutex);
2535 pval = kcontrol->private_value;
2536 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2537 for (i = 0; i < indices; i++) {
2538 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2539 (i << AMP_VAL_IDX_SHIFT);
2540 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2545 kcontrol->private_value = pval;
2546 mutex_unlock(&codec->control_mutex);
2547 return err < 0 ? err : change;
2549 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2552 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2554 * The control element is supposed to have the private_value field
2555 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2557 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2558 struct snd_ctl_elem_info *uinfo)
2560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2561 struct hda_bind_ctls *c;
2564 mutex_lock(&codec->control_mutex);
2565 c = (struct hda_bind_ctls *)kcontrol->private_value;
2566 kcontrol->private_value = *c->values;
2567 err = c->ops->info(kcontrol, uinfo);
2568 kcontrol->private_value = (long)c;
2569 mutex_unlock(&codec->control_mutex);
2572 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2575 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2577 * The control element is supposed to have the private_value field
2578 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2580 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2581 struct snd_ctl_elem_value *ucontrol)
2583 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2584 struct hda_bind_ctls *c;
2587 mutex_lock(&codec->control_mutex);
2588 c = (struct hda_bind_ctls *)kcontrol->private_value;
2589 kcontrol->private_value = *c->values;
2590 err = c->ops->get(kcontrol, ucontrol);
2591 kcontrol->private_value = (long)c;
2592 mutex_unlock(&codec->control_mutex);
2595 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2598 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2600 * The control element is supposed to have the private_value field
2601 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2603 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2604 struct snd_ctl_elem_value *ucontrol)
2606 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2607 struct hda_bind_ctls *c;
2608 unsigned long *vals;
2609 int err = 0, change = 0;
2611 mutex_lock(&codec->control_mutex);
2612 c = (struct hda_bind_ctls *)kcontrol->private_value;
2613 for (vals = c->values; *vals; vals++) {
2614 kcontrol->private_value = *vals;
2615 err = c->ops->put(kcontrol, ucontrol);
2620 kcontrol->private_value = (long)c;
2621 mutex_unlock(&codec->control_mutex);
2622 return err < 0 ? err : change;
2624 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2627 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2629 * The control element is supposed to have the private_value field
2630 * set up via HDA_BIND_VOL() macro.
2632 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2633 unsigned int size, unsigned int __user *tlv)
2635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2636 struct hda_bind_ctls *c;
2639 mutex_lock(&codec->control_mutex);
2640 c = (struct hda_bind_ctls *)kcontrol->private_value;
2641 kcontrol->private_value = *c->values;
2642 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2643 kcontrol->private_value = (long)c;
2644 mutex_unlock(&codec->control_mutex);
2647 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2649 struct hda_ctl_ops snd_hda_bind_vol = {
2650 .info = snd_hda_mixer_amp_volume_info,
2651 .get = snd_hda_mixer_amp_volume_get,
2652 .put = snd_hda_mixer_amp_volume_put,
2653 .tlv = snd_hda_mixer_amp_tlv
2655 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2657 struct hda_ctl_ops snd_hda_bind_sw = {
2658 .info = snd_hda_mixer_amp_switch_info,
2659 .get = snd_hda_mixer_amp_switch_get,
2660 .put = snd_hda_mixer_amp_switch_put,
2661 .tlv = snd_hda_mixer_amp_tlv
2663 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2666 * SPDIF out controls
2669 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2670 struct snd_ctl_elem_info *uinfo)
2672 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2677 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2678 struct snd_ctl_elem_value *ucontrol)
2680 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2681 IEC958_AES0_NONAUDIO |
2682 IEC958_AES0_CON_EMPHASIS_5015 |
2683 IEC958_AES0_CON_NOT_COPYRIGHT;
2684 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2685 IEC958_AES1_CON_ORIGINAL;
2689 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2690 struct snd_ctl_elem_value *ucontrol)
2692 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2693 IEC958_AES0_NONAUDIO |
2694 IEC958_AES0_PRO_EMPHASIS_5015;
2698 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2699 struct snd_ctl_elem_value *ucontrol)
2701 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2702 int idx = kcontrol->private_value;
2703 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2705 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2706 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2707 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2708 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2713 /* convert from SPDIF status bits to HDA SPDIF bits
2714 * bit 0 (DigEn) is always set zero (to be filled later)
2716 static unsigned short convert_from_spdif_status(unsigned int sbits)
2718 unsigned short val = 0;
2720 if (sbits & IEC958_AES0_PROFESSIONAL)
2721 val |= AC_DIG1_PROFESSIONAL;
2722 if (sbits & IEC958_AES0_NONAUDIO)
2723 val |= AC_DIG1_NONAUDIO;
2724 if (sbits & IEC958_AES0_PROFESSIONAL) {
2725 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2726 IEC958_AES0_PRO_EMPHASIS_5015)
2727 val |= AC_DIG1_EMPHASIS;
2729 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2730 IEC958_AES0_CON_EMPHASIS_5015)
2731 val |= AC_DIG1_EMPHASIS;
2732 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2733 val |= AC_DIG1_COPYRIGHT;
2734 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2735 val |= AC_DIG1_LEVEL;
2736 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2741 /* convert to SPDIF status bits from HDA SPDIF bits
2743 static unsigned int convert_to_spdif_status(unsigned short val)
2745 unsigned int sbits = 0;
2747 if (val & AC_DIG1_NONAUDIO)
2748 sbits |= IEC958_AES0_NONAUDIO;
2749 if (val & AC_DIG1_PROFESSIONAL)
2750 sbits |= IEC958_AES0_PROFESSIONAL;
2751 if (sbits & IEC958_AES0_PROFESSIONAL) {
2752 if (sbits & AC_DIG1_EMPHASIS)
2753 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2755 if (val & AC_DIG1_EMPHASIS)
2756 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2757 if (!(val & AC_DIG1_COPYRIGHT))
2758 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2759 if (val & AC_DIG1_LEVEL)
2760 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2761 sbits |= val & (0x7f << 8);
2766 /* set digital convert verbs both for the given NID and its slaves */
2767 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2772 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2773 d = codec->slave_dig_outs;
2777 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2780 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2784 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2786 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2789 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2790 struct snd_ctl_elem_value *ucontrol)
2792 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2793 int idx = kcontrol->private_value;
2794 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2795 hda_nid_t nid = spdif->nid;
2799 mutex_lock(&codec->spdif_mutex);
2800 spdif->status = ucontrol->value.iec958.status[0] |
2801 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2802 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2803 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2804 val = convert_from_spdif_status(spdif->status);
2805 val |= spdif->ctls & 1;
2806 change = spdif->ctls != val;
2808 if (change && nid != (u16)-1)
2809 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2810 mutex_unlock(&codec->spdif_mutex);
2814 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2816 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2817 struct snd_ctl_elem_value *ucontrol)
2819 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2820 int idx = kcontrol->private_value;
2821 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2823 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2827 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2830 set_dig_out_convert(codec, nid, dig1, dig2);
2831 /* unmute amp switch (if any) */
2832 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2833 (dig1 & AC_DIG1_ENABLE))
2834 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2838 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2839 struct snd_ctl_elem_value *ucontrol)
2841 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2842 int idx = kcontrol->private_value;
2843 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2844 hda_nid_t nid = spdif->nid;
2848 mutex_lock(&codec->spdif_mutex);
2849 val = spdif->ctls & ~AC_DIG1_ENABLE;
2850 if (ucontrol->value.integer.value[0])
2851 val |= AC_DIG1_ENABLE;
2852 change = spdif->ctls != val;
2854 if (change && nid != (u16)-1)
2855 set_spdif_ctls(codec, nid, val & 0xff, -1);
2856 mutex_unlock(&codec->spdif_mutex);
2860 static struct snd_kcontrol_new dig_mixes[] = {
2862 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2863 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2864 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2865 .info = snd_hda_spdif_mask_info,
2866 .get = snd_hda_spdif_cmask_get,
2869 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2870 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2871 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2872 .info = snd_hda_spdif_mask_info,
2873 .get = snd_hda_spdif_pmask_get,
2876 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2877 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2878 .info = snd_hda_spdif_mask_info,
2879 .get = snd_hda_spdif_default_get,
2880 .put = snd_hda_spdif_default_put,
2883 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2884 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2885 .info = snd_hda_spdif_out_switch_info,
2886 .get = snd_hda_spdif_out_switch_get,
2887 .put = snd_hda_spdif_out_switch_put,
2893 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2894 * @codec: the HDA codec
2895 * @nid: audio out widget NID
2897 * Creates controls related with the SPDIF output.
2898 * Called from each patch supporting the SPDIF out.
2900 * Returns 0 if successful, or a negative error code.
2902 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2903 hda_nid_t associated_nid,
2907 struct snd_kcontrol *kctl;
2908 struct snd_kcontrol_new *dig_mix;
2910 struct hda_spdif_out *spdif;
2912 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2914 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2917 spdif = snd_array_new(&codec->spdif_out);
2918 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2919 kctl = snd_ctl_new1(dig_mix, codec);
2922 kctl->id.index = idx;
2923 kctl->private_value = codec->spdif_out.used - 1;
2924 err = snd_hda_ctl_add(codec, associated_nid, kctl);
2928 spdif->nid = cvt_nid;
2929 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
2930 AC_VERB_GET_DIGI_CONVERT_1, 0);
2931 spdif->status = convert_to_spdif_status(spdif->ctls);
2934 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2936 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2940 for (i = 0; i < codec->spdif_out.used; i++) {
2941 struct hda_spdif_out *spdif =
2942 snd_array_elem(&codec->spdif_out, i);
2943 if (spdif->nid == nid)
2948 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
2950 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2952 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2954 mutex_lock(&codec->spdif_mutex);
2955 spdif->nid = (u16)-1;
2956 mutex_unlock(&codec->spdif_mutex);
2958 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
2960 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2962 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2965 mutex_lock(&codec->spdif_mutex);
2966 if (spdif->nid != nid) {
2969 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2971 mutex_unlock(&codec->spdif_mutex);
2973 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
2976 * SPDIF sharing with analog output
2978 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2979 struct snd_ctl_elem_value *ucontrol)
2981 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2982 ucontrol->value.integer.value[0] = mout->share_spdif;
2986 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2987 struct snd_ctl_elem_value *ucontrol)
2989 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2990 mout->share_spdif = !!ucontrol->value.integer.value[0];
2994 static struct snd_kcontrol_new spdif_share_sw = {
2995 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2996 .name = "IEC958 Default PCM Playback Switch",
2997 .info = snd_ctl_boolean_mono_info,
2998 .get = spdif_share_sw_get,
2999 .put = spdif_share_sw_put,
3003 * snd_hda_create_spdif_share_sw - create Default PCM switch
3004 * @codec: the HDA codec
3005 * @mout: multi-out instance
3007 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3008 struct hda_multi_out *mout)
3010 if (!mout->dig_out_nid)
3012 /* ATTENTION: here mout is passed as private_data, instead of codec */
3013 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3014 snd_ctl_new1(&spdif_share_sw, mout));
3016 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3022 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3024 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3025 struct snd_ctl_elem_value *ucontrol)
3027 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3029 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3033 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3034 struct snd_ctl_elem_value *ucontrol)
3036 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3037 hda_nid_t nid = kcontrol->private_value;
3038 unsigned int val = !!ucontrol->value.integer.value[0];
3041 mutex_lock(&codec->spdif_mutex);
3042 change = codec->spdif_in_enable != val;
3044 codec->spdif_in_enable = val;
3045 snd_hda_codec_write_cache(codec, nid, 0,
3046 AC_VERB_SET_DIGI_CONVERT_1, val);
3048 mutex_unlock(&codec->spdif_mutex);
3052 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3053 struct snd_ctl_elem_value *ucontrol)
3055 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3056 hda_nid_t nid = kcontrol->private_value;
3060 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3061 sbits = convert_to_spdif_status(val);
3062 ucontrol->value.iec958.status[0] = sbits;
3063 ucontrol->value.iec958.status[1] = sbits >> 8;
3064 ucontrol->value.iec958.status[2] = sbits >> 16;
3065 ucontrol->value.iec958.status[3] = sbits >> 24;
3069 static struct snd_kcontrol_new dig_in_ctls[] = {
3071 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3072 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3073 .info = snd_hda_spdif_in_switch_info,
3074 .get = snd_hda_spdif_in_switch_get,
3075 .put = snd_hda_spdif_in_switch_put,
3078 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3079 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3080 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3081 .info = snd_hda_spdif_mask_info,
3082 .get = snd_hda_spdif_in_status_get,
3088 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3089 * @codec: the HDA codec
3090 * @nid: audio in widget NID
3092 * Creates controls related with the SPDIF input.
3093 * Called from each patch supporting the SPDIF in.
3095 * Returns 0 if successful, or a negative error code.
3097 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3100 struct snd_kcontrol *kctl;
3101 struct snd_kcontrol_new *dig_mix;
3104 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3106 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3109 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3110 kctl = snd_ctl_new1(dig_mix, codec);
3113 kctl->private_value = nid;
3114 err = snd_hda_ctl_add(codec, nid, kctl);
3118 codec->spdif_in_enable =
3119 snd_hda_codec_read(codec, nid, 0,
3120 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3124 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3131 /* build a 32bit cache key with the widget id and the command parameter */
3132 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3133 #define get_cmd_cache_nid(key) ((key) & 0xff)
3134 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3137 * snd_hda_codec_write_cache - send a single command with caching
3138 * @codec: the HDA codec
3139 * @nid: NID to send the command
3140 * @direct: direct flag
3141 * @verb: the verb to send
3142 * @parm: the parameter for the verb
3144 * Send a single command without waiting for response.
3146 * Returns 0 if successful, or a negative error code.
3148 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3149 int direct, unsigned int verb, unsigned int parm)
3151 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3152 struct hda_cache_head *c;
3157 /* parm may contain the verb stuff for get/set amp */
3158 verb = verb | (parm >> 8);
3160 key = build_cmd_cache_key(nid, verb);
3161 mutex_lock(&codec->bus->cmd_mutex);
3162 c = get_alloc_hash(&codec->cmd_cache, key);
3165 mutex_unlock(&codec->bus->cmd_mutex);
3168 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3171 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3172 * @codec: the HDA codec
3173 * @nid: NID to send the command
3174 * @direct: direct flag
3175 * @verb: the verb to send
3176 * @parm: the parameter for the verb
3178 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3179 * command if the parameter is already identical with the cached value.
3180 * If not, it sends the command and refreshes the cache.
3182 * Returns 0 if successful, or a negative error code.
3184 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3185 int direct, unsigned int verb, unsigned int parm)
3187 struct hda_cache_head *c;
3190 /* parm may contain the verb stuff for get/set amp */
3191 verb = verb | (parm >> 8);
3193 key = build_cmd_cache_key(nid, verb);
3194 mutex_lock(&codec->bus->cmd_mutex);
3195 c = get_hash(&codec->cmd_cache, key);
3196 if (c && c->val == parm) {
3197 mutex_unlock(&codec->bus->cmd_mutex);
3200 mutex_unlock(&codec->bus->cmd_mutex);
3201 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3203 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3206 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3207 * @codec: HD-audio codec
3209 * Execute all verbs recorded in the command caches to resume.
3211 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3213 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3216 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3217 u32 key = buffer->key;
3220 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3221 get_cmd_cache_cmd(key), buffer->val);
3224 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3227 * snd_hda_sequence_write_cache - sequence writes with caching
3228 * @codec: the HDA codec
3229 * @seq: VERB array to send
3231 * Send the commands sequentially from the given array.