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);
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)
101 static inline void hda_call_pm_notify(struct hda_bus *bus, bool power_up)
103 if (bus->ops.pm_notify)
104 bus->ops.pm_notify(bus, power_up);
107 static inline void hda_keep_power_on(struct hda_codec *codec) {}
108 #define hda_codec_is_power_on(codec) 1
109 #define hda_call_pm_notify(bus, state) {}
113 * snd_hda_get_jack_location - Give a location string of the jack
114 * @cfg: pin default config value
116 * Parse the pin default config value and returns the string of the
117 * jack location, e.g. "Rear", "Front", etc.
119 const char *snd_hda_get_jack_location(u32 cfg)
121 static char *bases[7] = {
122 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
124 static unsigned char specials_idx[] = {
129 static char *specials[] = {
130 "Rear Panel", "Drive Bar",
131 "Riser", "HDMI", "ATAPI",
132 "Mobile-In", "Mobile-Out"
135 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
136 if ((cfg & 0x0f) < 7)
137 return bases[cfg & 0x0f];
138 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
139 if (cfg == specials_idx[i])
144 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
147 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
148 * @cfg: pin default config value
150 * Parse the pin default config value and returns the string of the
151 * jack connectivity, i.e. external or internal connection.
153 const char *snd_hda_get_jack_connectivity(u32 cfg)
155 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
157 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
159 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
162 * snd_hda_get_jack_type - Give a type string of the jack
163 * @cfg: pin default config value
165 * Parse the pin default config value and returns the string of the
166 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
168 const char *snd_hda_get_jack_type(u32 cfg)
170 static char *jack_types[16] = {
171 "Line Out", "Speaker", "HP Out", "CD",
172 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
173 "Line In", "Aux", "Mic", "Telephony",
174 "SPDIF In", "Digitial In", "Reserved", "Other"
177 return jack_types[(cfg & AC_DEFCFG_DEVICE)
178 >> AC_DEFCFG_DEVICE_SHIFT];
180 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
183 * Compose a 32bit command word to be sent to the HD-audio controller
185 static inline unsigned int
186 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
187 unsigned int verb, unsigned int parm)
191 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
192 (verb & ~0xfff) || (parm & ~0xffff)) {
193 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
194 codec->addr, direct, nid, verb, parm);
198 val = (u32)codec->addr << 28;
199 val |= (u32)direct << 27;
200 val |= (u32)nid << 20;
207 * Send and receive a verb
209 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
212 struct hda_bus *bus = codec->bus;
221 snd_hda_power_up(codec);
222 mutex_lock(&bus->cmd_mutex);
223 trace_hda_send_cmd(codec, cmd);
224 err = bus->ops.command(bus, cmd);
226 *res = bus->ops.get_response(bus, codec->addr);
227 trace_hda_get_response(codec, *res);
229 mutex_unlock(&bus->cmd_mutex);
230 snd_hda_power_down(codec);
231 if (!codec->in_pm && res && *res == -1 && bus->rirb_error) {
232 if (bus->response_reset) {
233 snd_printd("hda_codec: resetting BUS due to "
234 "fatal communication error\n");
235 trace_hda_bus_reset(bus);
236 bus->ops.bus_reset(bus);
240 /* clear reset-flag when the communication gets recovered */
241 if (!err || codec->in_pm)
242 bus->response_reset = 0;
247 * snd_hda_codec_read - send a command and get the response
248 * @codec: the HDA codec
249 * @nid: NID to send the command
250 * @direct: direct flag
251 * @verb: the verb to send
252 * @parm: the parameter for the verb
254 * Send a single command and read the corresponding response.
256 * Returns the obtained response value, or -1 for an error.
258 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
260 unsigned int verb, unsigned int parm)
262 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
264 if (codec_exec_verb(codec, cmd, &res))
268 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
271 * snd_hda_codec_write - send a single command without waiting for response
272 * @codec: the HDA codec
273 * @nid: NID to send the command
274 * @direct: direct flag
275 * @verb: the verb to send
276 * @parm: the parameter for the verb
278 * Send a single command without waiting for response.
280 * Returns 0 if successful, or a negative error code.
282 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
283 unsigned int verb, unsigned int parm)
285 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
287 return codec_exec_verb(codec, cmd,
288 codec->bus->sync_write ? &res : NULL);
290 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
293 * snd_hda_sequence_write - sequence writes
294 * @codec: the HDA codec
295 * @seq: VERB array to send
297 * Send the commands sequentially from the given array.
298 * The array must be terminated with NID=0.
300 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
302 for (; seq->nid; seq++)
303 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
305 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
308 * snd_hda_get_sub_nodes - get the range of sub nodes
309 * @codec: the HDA codec
311 * @start_id: the pointer to store the start NID
313 * Parse the NID and store the start NID of its sub-nodes.
314 * Returns the number of sub-nodes.
316 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
321 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
324 *start_id = (parm >> 16) & 0x7fff;
325 return (int)(parm & 0x7fff);
327 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
329 /* look up the cached results */
330 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
333 for (i = 0; i < array->used; ) {
334 hda_nid_t *p = snd_array_elem(array, i);
343 /* read the connection and add to the cache */
344 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
346 hda_nid_t list[HDA_MAX_CONNECTIONS];
349 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
352 return snd_hda_override_conn_list(codec, nid, len, list);
356 * snd_hda_get_connections - copy connection list
357 * @codec: the HDA codec
359 * @conn_list: connection list array; when NULL, checks only the size
360 * @max_conns: max. number of connections to store
362 * Parses the connection list of the given widget and stores the list
365 * Returns the number of connections, or a negative error code.
367 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
368 hda_nid_t *conn_list, int max_conns)
370 struct snd_array *array = &codec->conn_lists;
376 mutex_lock(&codec->hash_mutex);
378 /* if the connection-list is already cached, read it */
379 p = lookup_conn_list(array, nid);
382 if (conn_list && len > max_conns) {
383 snd_printk(KERN_ERR "hda_codec: "
384 "Too many connections %d for NID 0x%x\n",
386 mutex_unlock(&codec->hash_mutex);
389 if (conn_list && len)
390 memcpy(conn_list, p + 2, len * sizeof(hda_nid_t));
392 mutex_unlock(&codec->hash_mutex);
395 if (snd_BUG_ON(added))
398 len = read_and_add_raw_conns(codec, nid);
404 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
407 * snd_hda_get_raw_connections - copy connection list without cache
408 * @codec: the HDA codec
410 * @conn_list: connection list array
411 * @max_conns: max. number of connections to store
413 * Like snd_hda_get_connections(), copy the connection list but without
414 * checking through the connection-list cache.
415 * Currently called only from hda_proc.c, so not exported.
417 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
418 hda_nid_t *conn_list, int max_conns)
421 int i, conn_len, conns;
422 unsigned int shift, num_elems, mask;
426 if (snd_BUG_ON(!conn_list || max_conns <= 0))
429 wcaps = get_wcaps(codec, nid);
430 if (!(wcaps & AC_WCAP_CONN_LIST) &&
431 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
434 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
435 if (parm & AC_CLIST_LONG) {
444 conn_len = parm & AC_CLIST_LENGTH;
445 mask = (1 << (shift-1)) - 1;
448 return 0; /* no connection */
451 /* single connection */
452 parm = snd_hda_codec_read(codec, nid, 0,
453 AC_VERB_GET_CONNECT_LIST, 0);
454 if (parm == -1 && codec->bus->rirb_error)
456 conn_list[0] = parm & mask;
460 /* multi connection */
463 for (i = 0; i < conn_len; i++) {
467 if (i % num_elems == 0) {
468 parm = snd_hda_codec_read(codec, nid, 0,
469 AC_VERB_GET_CONNECT_LIST, i);
470 if (parm == -1 && codec->bus->rirb_error)
473 range_val = !!(parm & (1 << (shift-1))); /* ranges */
476 snd_printk(KERN_WARNING "hda_codec: "
477 "invalid CONNECT_LIST verb %x[%i]:%x\n",
483 /* ranges between the previous and this one */
484 if (!prev_nid || prev_nid >= val) {
485 snd_printk(KERN_WARNING "hda_codec: "
486 "invalid dep_range_val %x:%x\n",
490 for (n = prev_nid + 1; n <= val; n++) {
491 if (conns >= max_conns) {
492 snd_printk(KERN_ERR "hda_codec: "
493 "Too many connections %d for NID 0x%x\n",
497 conn_list[conns++] = n;
500 if (conns >= max_conns) {
501 snd_printk(KERN_ERR "hda_codec: "
502 "Too many connections %d for NID 0x%x\n",
506 conn_list[conns++] = val;
513 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
515 hda_nid_t *p = snd_array_new(array);
523 * snd_hda_override_conn_list - add/modify the connection-list to cache
524 * @codec: the HDA codec
526 * @len: number of connection list entries
527 * @list: the list of connection entries
529 * Add or modify the given connection-list to the cache. If the corresponding
530 * cache already exists, invalidate it and append a new one.
532 * Returns zero or a negative error code.
534 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
535 const hda_nid_t *list)
537 struct snd_array *array = &codec->conn_lists;
541 mutex_lock(&codec->hash_mutex);
542 p = lookup_conn_list(array, nid);
544 *p = -1; /* invalidate the old entry */
546 old_used = array->used;
547 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
549 for (i = 0; i < len; i++)
550 if (!add_conn_list(array, list[i]))
552 mutex_unlock(&codec->hash_mutex);
556 array->used = old_used;
557 mutex_unlock(&codec->hash_mutex);
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 unsigned 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 snd_hda_jack_tbl_clear(codec);
1194 restore_init_pincfgs(codec);
1196 cancel_delayed_work(&codec->power_work);
1197 flush_workqueue(codec->bus->workq);
1199 list_del(&codec->list);
1200 snd_array_free(&codec->mixers);
1201 snd_array_free(&codec->nids);
1202 snd_array_free(&codec->cvt_setups);
1203 snd_array_free(&codec->conn_lists);
1204 snd_array_free(&codec->spdif_out);
1205 codec->bus->caddr_tbl[codec->addr] = NULL;
1206 if (codec->patch_ops.free)
1207 codec->patch_ops.free(codec);
1209 if (!codec->pm_down_notified) /* cancel leftover refcounts */
1210 hda_call_pm_notify(codec->bus, false);
1212 module_put(codec->owner);
1213 free_hda_cache(&codec->amp_cache);
1214 free_hda_cache(&codec->cmd_cache);
1215 kfree(codec->vendor_name);
1216 kfree(codec->chip_name);
1217 kfree(codec->modelname);
1218 kfree(codec->wcaps);
1222 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1223 hda_nid_t fg, unsigned int power_state);
1225 static unsigned int hda_set_power_state(struct hda_codec *codec,
1226 unsigned int power_state);
1229 * snd_hda_codec_new - create a HDA codec
1230 * @bus: the bus to assign
1231 * @codec_addr: the codec address
1232 * @codecp: the pointer to store the generated codec
1234 * Returns 0 if successful, or a negative error code.
1236 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1237 unsigned int codec_addr,
1238 struct hda_codec **codecp)
1240 struct hda_codec *codec;
1245 if (snd_BUG_ON(!bus))
1247 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1250 if (bus->caddr_tbl[codec_addr]) {
1251 snd_printk(KERN_ERR "hda_codec: "
1252 "address 0x%x is already occupied\n", codec_addr);
1256 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1257 if (codec == NULL) {
1258 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1263 codec->addr = codec_addr;
1264 mutex_init(&codec->spdif_mutex);
1265 mutex_init(&codec->control_mutex);
1266 mutex_init(&codec->hash_mutex);
1267 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1268 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1269 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1270 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1271 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1272 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1273 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1274 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1275 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1278 spin_lock_init(&codec->power_lock);
1279 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1280 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1281 * the caller has to power down appropriatley after initialization
1284 hda_keep_power_on(codec);
1285 hda_call_pm_notify(bus, true);
1288 if (codec->bus->modelname) {
1289 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1290 if (!codec->modelname) {
1291 snd_hda_codec_free(codec);
1296 list_add_tail(&codec->list, &bus->codec_list);
1297 bus->caddr_tbl[codec_addr] = codec;
1299 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1301 if (codec->vendor_id == -1)
1302 /* read again, hopefully the access method was corrected
1303 * in the last read...
1305 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1307 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1308 AC_PAR_SUBSYSTEM_ID);
1309 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1312 setup_fg_nodes(codec);
1313 if (!codec->afg && !codec->mfg) {
1314 snd_printdd("hda_codec: no AFG or MFG node found\n");
1319 fg = codec->afg ? codec->afg : codec->mfg;
1320 err = read_widget_caps(codec, fg);
1322 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1325 err = read_pin_defaults(codec);
1329 if (!codec->subsystem_id) {
1330 codec->subsystem_id =
1331 snd_hda_codec_read(codec, fg, 0,
1332 AC_VERB_GET_SUBSYSTEM_ID, 0);
1336 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1338 if (!codec->d3_stop_clk)
1339 bus->power_keep_link_on = 1;
1341 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1344 /* power-up all before initialization */
1345 hda_set_power_state(codec, AC_PWRST_D0);
1347 snd_hda_codec_proc_new(codec);
1349 snd_hda_create_hwdep(codec);
1351 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1352 codec->subsystem_id, codec->revision_id);
1353 snd_component_add(codec->bus->card, component);
1360 snd_hda_codec_free(codec);
1363 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1366 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1367 * @codec: the HDA codec
1369 * Start parsing of the given codec tree and (re-)initialize the whole
1372 * Returns 0 if successful or a negative error code.
1374 int snd_hda_codec_configure(struct hda_codec *codec)
1378 codec->preset = find_codec_preset(codec);
1379 if (!codec->vendor_name || !codec->chip_name) {
1380 err = get_codec_name(codec);
1385 if (is_generic_config(codec)) {
1386 err = snd_hda_parse_generic_codec(codec);
1389 if (codec->preset && codec->preset->patch) {
1390 err = codec->preset->patch(codec);
1394 /* call the default parser */
1395 err = snd_hda_parse_generic_codec(codec);
1397 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1400 if (!err && codec->patch_ops.unsol_event)
1401 err = init_unsol_queue(codec->bus);
1402 /* audio codec should override the mixer name */
1403 if (!err && (codec->afg || !*codec->bus->card->mixername))
1404 snprintf(codec->bus->card->mixername,
1405 sizeof(codec->bus->card->mixername),
1406 "%s %s", codec->vendor_name, codec->chip_name);
1409 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1411 /* update the stream-id if changed */
1412 static void update_pcm_stream_id(struct hda_codec *codec,
1413 struct hda_cvt_setup *p, hda_nid_t nid,
1414 u32 stream_tag, int channel_id)
1416 unsigned int oldval, newval;
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;
1430 /* update the format-id if changed */
1431 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1432 hda_nid_t nid, int format)
1434 unsigned int oldval;
1436 if (p->format_id != format) {
1437 oldval = snd_hda_codec_read(codec, nid, 0,
1438 AC_VERB_GET_STREAM_FORMAT, 0);
1439 if (oldval != format) {
1441 snd_hda_codec_write(codec, nid, 0,
1442 AC_VERB_SET_STREAM_FORMAT,
1445 p->format_id = format;
1450 * snd_hda_codec_setup_stream - set up the codec for streaming
1451 * @codec: the CODEC to set up
1452 * @nid: the NID to set up
1453 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1454 * @channel_id: channel id to pass, zero based.
1455 * @format: stream format.
1457 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1459 int channel_id, int format)
1461 struct hda_codec *c;
1462 struct hda_cvt_setup *p;
1469 snd_printdd("hda_codec_setup_stream: "
1470 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1471 nid, stream_tag, channel_id, format);
1472 p = get_hda_cvt_setup(codec, nid);
1476 if (codec->pcm_format_first)
1477 update_pcm_format(codec, p, nid, format);
1478 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1479 if (!codec->pcm_format_first)
1480 update_pcm_format(codec, p, nid, format);
1485 /* make other inactive cvts with the same stream-tag dirty */
1486 type = get_wcaps_type(get_wcaps(codec, nid));
1487 list_for_each_entry(c, &codec->bus->codec_list, list) {
1488 for (i = 0; i < c->cvt_setups.used; i++) {
1489 p = snd_array_elem(&c->cvt_setups, i);
1490 if (!p->active && p->stream_tag == stream_tag &&
1491 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1496 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1498 static void really_cleanup_stream(struct hda_codec *codec,
1499 struct hda_cvt_setup *q);
1502 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1503 * @codec: the CODEC to clean up
1504 * @nid: the NID to clean up
1505 * @do_now: really clean up the stream instead of clearing the active flag
1507 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1510 struct hda_cvt_setup *p;
1515 if (codec->no_sticky_stream)
1518 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1519 p = get_hda_cvt_setup(codec, nid);
1521 /* here we just clear the active flag when do_now isn't set;
1522 * actual clean-ups will be done later in
1523 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1526 really_cleanup_stream(codec, p);
1531 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1533 static void really_cleanup_stream(struct hda_codec *codec,
1534 struct hda_cvt_setup *q)
1536 hda_nid_t nid = q->nid;
1537 if (q->stream_tag || q->channel_id)
1538 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1540 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1542 memset(q, 0, sizeof(*q));
1546 /* clean up the all conflicting obsolete streams */
1547 static void purify_inactive_streams(struct hda_codec *codec)
1549 struct hda_codec *c;
1552 list_for_each_entry(c, &codec->bus->codec_list, list) {
1553 for (i = 0; i < c->cvt_setups.used; i++) {
1554 struct hda_cvt_setup *p;
1555 p = snd_array_elem(&c->cvt_setups, i);
1557 really_cleanup_stream(c, p);
1563 /* clean up all streams; called from suspend */
1564 static void hda_cleanup_all_streams(struct hda_codec *codec)
1568 for (i = 0; i < codec->cvt_setups.used; i++) {
1569 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1571 really_cleanup_stream(codec, p);
1577 * amp access functions
1580 /* FIXME: more better hash key? */
1581 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1582 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1583 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1584 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1585 #define INFO_AMP_CAPS (1<<0)
1586 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1588 /* initialize the hash table */
1589 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1590 unsigned int record_size)
1592 memset(cache, 0, sizeof(*cache));
1593 memset(cache->hash, 0xff, sizeof(cache->hash));
1594 snd_array_init(&cache->buf, record_size, 64);
1597 static void free_hda_cache(struct hda_cache_rec *cache)
1599 snd_array_free(&cache->buf);
1602 /* query the hash. allocate an entry if not found. */
1603 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1605 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1606 u16 cur = cache->hash[idx];
1607 struct hda_cache_head *info;
1609 while (cur != 0xffff) {
1610 info = snd_array_elem(&cache->buf, cur);
1611 if (info->key == key)
1618 /* query the hash. allocate an entry if not found. */
1619 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1622 struct hda_cache_head *info = get_hash(cache, key);
1625 /* add a new hash entry */
1626 info = snd_array_new(&cache->buf);
1629 cur = snd_array_index(&cache->buf, info);
1632 idx = key % (u16)ARRAY_SIZE(cache->hash);
1633 info->next = cache->hash[idx];
1634 cache->hash[idx] = cur;
1639 /* query and allocate an amp hash entry */
1640 static inline struct hda_amp_info *
1641 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1643 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1646 /* overwrite the value with the key in the caps hash */
1647 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1649 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 info->amp_caps = val;
1658 info->head.val |= INFO_AMP_CAPS;
1659 mutex_unlock(&codec->hash_mutex);
1663 /* query the value from the caps hash; if not found, fetch the current
1664 * value from the given function and store in the hash
1667 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1668 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1670 struct hda_amp_info *info;
1673 mutex_lock(&codec->hash_mutex);
1674 info = get_alloc_amp_hash(codec, key);
1676 mutex_unlock(&codec->hash_mutex);
1679 if (!(info->head.val & INFO_AMP_CAPS)) {
1680 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1681 val = func(codec, nid, dir);
1682 write_caps_hash(codec, key, val);
1684 val = info->amp_caps;
1685 mutex_unlock(&codec->hash_mutex);
1690 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1693 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1695 return snd_hda_param_read(codec, nid,
1696 direction == HDA_OUTPUT ?
1697 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1701 * query_amp_caps - query AMP capabilities
1702 * @codec: the HD-auio codec
1703 * @nid: the NID to query
1704 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1706 * Query AMP capabilities for the given widget and direction.
1707 * Returns the obtained capability bits.
1709 * When cap bits have been already read, this doesn't read again but
1710 * returns the cached value.
1712 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1714 return query_caps_hash(codec, nid, direction,
1715 HDA_HASH_KEY(nid, direction, 0),
1718 EXPORT_SYMBOL_HDA(query_amp_caps);
1721 * snd_hda_override_amp_caps - Override the AMP capabilities
1722 * @codec: the CODEC to clean up
1723 * @nid: the NID to clean up
1724 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1725 * @caps: the capability bits to set
1727 * Override the cached AMP caps bits value by the given one.
1728 * This function is useful if the driver needs to adjust the AMP ranges,
1729 * e.g. limit to 0dB, etc.
1731 * Returns zero if successful or a negative error code.
1733 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1736 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1738 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1740 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1743 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1747 * snd_hda_query_pin_caps - Query PIN capabilities
1748 * @codec: the HD-auio codec
1749 * @nid: the NID to query
1751 * Query PIN capabilities for the given widget.
1752 * Returns the obtained capability bits.
1754 * When cap bits have been already read, this doesn't read again but
1755 * returns the cached value.
1757 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1759 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1762 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1765 * snd_hda_override_pin_caps - Override the pin capabilities
1767 * @nid: the NID to override
1768 * @caps: the capability bits to set
1770 * Override the cached PIN capabilitiy bits value by the given one.
1772 * Returns zero if successful or a negative error code.
1774 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1777 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1779 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1781 /* read or sync the hash value with the current value;
1782 * call within hash_mutex
1784 static struct hda_amp_info *
1785 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1786 int direction, int index)
1788 struct hda_amp_info *info;
1789 unsigned int parm, val = 0;
1790 bool val_read = false;
1793 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1796 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1798 mutex_unlock(&codec->hash_mutex);
1799 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1800 parm |= direction == HDA_OUTPUT ?
1801 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1803 val = snd_hda_codec_read(codec, nid, 0,
1804 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1807 mutex_lock(&codec->hash_mutex);
1810 info->vol[ch] = val;
1811 info->head.val |= INFO_AMP_VOL(ch);
1817 * write the current volume in info to the h/w
1819 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1820 hda_nid_t nid, int ch, int direction, int index,
1825 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1826 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1827 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1828 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1829 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1830 ; /* set the zero value as a fake mute */
1833 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1837 * snd_hda_codec_amp_read - Read AMP value
1838 * @codec: HD-audio codec
1839 * @nid: NID to read the AMP value
1840 * @ch: channel (left=0 or right=1)
1841 * @direction: #HDA_INPUT or #HDA_OUTPUT
1842 * @index: the index value (only for input direction)
1844 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1846 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1847 int direction, int index)
1849 struct hda_amp_info *info;
1850 unsigned int val = 0;
1852 mutex_lock(&codec->hash_mutex);
1853 info = update_amp_hash(codec, nid, ch, direction, index);
1855 val = info->vol[ch];
1856 mutex_unlock(&codec->hash_mutex);
1859 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1862 * snd_hda_codec_amp_update - update the AMP value
1863 * @codec: HD-audio codec
1864 * @nid: NID to read the AMP value
1865 * @ch: channel (left=0 or right=1)
1866 * @direction: #HDA_INPUT or #HDA_OUTPUT
1867 * @idx: the index value (only for input direction)
1868 * @mask: bit mask to set
1869 * @val: the bits value to set
1871 * Update the AMP value with a bit mask.
1872 * Returns 0 if the value is unchanged, 1 if changed.
1874 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1875 int direction, int idx, int mask, int val)
1877 struct hda_amp_info *info;
1879 if (snd_BUG_ON(mask & ~0xff))
1883 mutex_lock(&codec->hash_mutex);
1884 info = update_amp_hash(codec, nid, ch, direction, idx);
1886 mutex_unlock(&codec->hash_mutex);
1889 val |= info->vol[ch] & ~mask;
1890 if (info->vol[ch] == val) {
1891 mutex_unlock(&codec->hash_mutex);
1894 info->vol[ch] = val;
1895 mutex_unlock(&codec->hash_mutex);
1896 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1899 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1902 * snd_hda_codec_amp_stereo - update the AMP stereo values
1903 * @codec: HD-audio codec
1904 * @nid: NID to read the AMP value
1905 * @direction: #HDA_INPUT or #HDA_OUTPUT
1906 * @idx: the index value (only for input direction)
1907 * @mask: bit mask to set
1908 * @val: the bits value to set
1910 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1911 * stereo widget with the same mask and value.
1913 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1914 int direction, int idx, int mask, int val)
1918 if (snd_BUG_ON(mask & ~0xff))
1920 for (ch = 0; ch < 2; ch++)
1921 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1925 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1929 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1930 * @codec: HD-audio codec
1932 * Resume the all amp commands from the cache.
1934 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1936 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1939 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1940 u32 key = buffer->head.key;
1942 unsigned int idx, dir, ch;
1946 idx = (key >> 16) & 0xff;
1947 dir = (key >> 24) & 0xff;
1948 for (ch = 0; ch < 2; ch++) {
1949 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1951 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1956 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1957 #endif /* CONFIG_PM */
1959 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1962 u32 caps = query_amp_caps(codec, nid, dir);
1964 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1971 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1973 * The control element is supposed to have the private_value field
1974 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1976 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1977 struct snd_ctl_elem_info *uinfo)
1979 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1980 u16 nid = get_amp_nid(kcontrol);
1981 u8 chs = get_amp_channels(kcontrol);
1982 int dir = get_amp_direction(kcontrol);
1983 unsigned int ofs = get_amp_offset(kcontrol);
1985 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1986 uinfo->count = chs == 3 ? 2 : 1;
1987 uinfo->value.integer.min = 0;
1988 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1989 if (!uinfo->value.integer.max) {
1990 printk(KERN_WARNING "hda_codec: "
1991 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1997 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
2000 static inline unsigned int
2001 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2002 int ch, int dir, int idx, unsigned int ofs)
2005 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2006 val &= HDA_AMP_VOLMASK;
2015 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2016 int ch, int dir, int idx, unsigned int ofs,
2019 unsigned int maxval;
2023 /* ofs = 0: raw max value */
2024 maxval = get_amp_max_value(codec, nid, dir, 0);
2027 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2028 HDA_AMP_VOLMASK, val);
2032 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2034 * The control element is supposed to have the private_value field
2035 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2037 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2038 struct snd_ctl_elem_value *ucontrol)
2040 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2041 hda_nid_t nid = get_amp_nid(kcontrol);
2042 int chs = get_amp_channels(kcontrol);
2043 int dir = get_amp_direction(kcontrol);
2044 int idx = get_amp_index(kcontrol);
2045 unsigned int ofs = get_amp_offset(kcontrol);
2046 long *valp = ucontrol->value.integer.value;
2049 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2051 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2054 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2057 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2059 * The control element is supposed to have the private_value field
2060 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2062 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2063 struct snd_ctl_elem_value *ucontrol)
2065 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2066 hda_nid_t nid = get_amp_nid(kcontrol);
2067 int chs = get_amp_channels(kcontrol);
2068 int dir = get_amp_direction(kcontrol);
2069 int idx = get_amp_index(kcontrol);
2070 unsigned int ofs = get_amp_offset(kcontrol);
2071 long *valp = ucontrol->value.integer.value;
2074 snd_hda_power_up(codec);
2076 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2080 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2081 snd_hda_power_down(codec);
2084 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2087 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2089 * The control element is supposed to have the private_value field
2090 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2092 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2093 unsigned int size, unsigned int __user *_tlv)
2095 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2096 hda_nid_t nid = get_amp_nid(kcontrol);
2097 int dir = get_amp_direction(kcontrol);
2098 unsigned int ofs = get_amp_offset(kcontrol);
2099 bool min_mute = get_amp_min_mute(kcontrol);
2100 u32 caps, val1, val2;
2102 if (size < 4 * sizeof(unsigned int))
2104 caps = query_amp_caps(codec, nid, dir);
2105 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2106 val2 = (val2 + 1) * 25;
2107 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2109 val1 = ((int)val1) * ((int)val2);
2110 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2111 val2 |= TLV_DB_SCALE_MUTE;
2112 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2114 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2116 if (put_user(val1, _tlv + 2))
2118 if (put_user(val2, _tlv + 3))
2122 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2125 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2126 * @codec: HD-audio codec
2127 * @nid: NID of a reference widget
2128 * @dir: #HDA_INPUT or #HDA_OUTPUT
2129 * @tlv: TLV data to be stored, at least 4 elements
2131 * Set (static) TLV data for a virtual master volume using the AMP caps
2132 * obtained from the reference NID.
2133 * The volume range is recalculated as if the max volume is 0dB.
2135 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2141 caps = query_amp_caps(codec, nid, dir);
2142 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2143 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2144 step = (step + 1) * 25;
2145 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2146 tlv[1] = 2 * sizeof(unsigned int);
2147 tlv[2] = -nums * step;
2150 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2152 /* find a mixer control element with the given name */
2153 static struct snd_kcontrol *
2154 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2155 const char *name, int idx)
2157 struct snd_ctl_elem_id id;
2158 memset(&id, 0, sizeof(id));
2159 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2161 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2163 strcpy(id.name, name);
2164 return snd_ctl_find_id(codec->bus->card, &id);
2168 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2169 * @codec: HD-audio codec
2170 * @name: ctl id name string
2172 * Get the control element with the given id string and IFACE_MIXER.
2174 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2177 return _snd_hda_find_mixer_ctl(codec, name, 0);
2179 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2181 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2184 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2185 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2192 * snd_hda_ctl_add - Add a control element and assign to the codec
2193 * @codec: HD-audio codec
2194 * @nid: corresponding NID (optional)
2195 * @kctl: the control element to assign
2197 * Add the given control element to an array inside the codec instance.
2198 * All control elements belonging to a codec are supposed to be added
2199 * by this function so that a proper clean-up works at the free or
2200 * reconfiguration time.
2202 * If non-zero @nid is passed, the NID is assigned to the control element.
2203 * The assignment is shown in the codec proc file.
2205 * snd_hda_ctl_add() checks the control subdev id field whether
2206 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2207 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2208 * specifies if kctl->private_value is a HDA amplifier value.
2210 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2211 struct snd_kcontrol *kctl)
2214 unsigned short flags = 0;
2215 struct hda_nid_item *item;
2217 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2218 flags |= HDA_NID_ITEM_AMP;
2220 nid = get_amp_nid_(kctl->private_value);
2222 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2223 nid = kctl->id.subdevice & 0xffff;
2224 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2225 kctl->id.subdevice = 0;
2226 err = snd_ctl_add(codec->bus->card, kctl);
2229 item = snd_array_new(&codec->mixers);
2234 item->flags = flags;
2237 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2240 * snd_hda_add_nid - Assign a NID to a control element
2241 * @codec: HD-audio codec
2242 * @nid: corresponding NID (optional)
2243 * @kctl: the control element to assign
2244 * @index: index to kctl
2246 * Add the given control element to an array inside the codec instance.
2247 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2248 * NID:KCTL mapping - for example "Capture Source" selector.
2250 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2251 unsigned int index, hda_nid_t nid)
2253 struct hda_nid_item *item;
2256 item = snd_array_new(&codec->nids);
2260 item->index = index;
2264 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2265 kctl->id.name, kctl->id.index, index);
2268 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2271 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2272 * @codec: HD-audio codec
2274 void snd_hda_ctls_clear(struct hda_codec *codec)
2277 struct hda_nid_item *items = codec->mixers.list;
2278 for (i = 0; i < codec->mixers.used; i++)
2279 snd_ctl_remove(codec->bus->card, items[i].kctl);
2280 snd_array_free(&codec->mixers);
2281 snd_array_free(&codec->nids);
2284 /* pseudo device locking
2285 * toggle card->shutdown to allow/disallow the device access (as a hack)
2287 int snd_hda_lock_devices(struct hda_bus *bus)
2289 struct snd_card *card = bus->card;
2290 struct hda_codec *codec;
2292 spin_lock(&card->files_lock);
2296 if (!list_empty(&card->ctl_files))
2299 list_for_each_entry(codec, &bus->codec_list, list) {
2301 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2302 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2305 if (cpcm->pcm->streams[0].substream_opened ||
2306 cpcm->pcm->streams[1].substream_opened)
2310 spin_unlock(&card->files_lock);
2316 spin_unlock(&card->files_lock);
2319 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2321 void snd_hda_unlock_devices(struct hda_bus *bus)
2323 struct snd_card *card = bus->card;
2326 spin_lock(&card->files_lock);
2328 spin_unlock(&card->files_lock);
2330 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2333 * snd_hda_codec_reset - Clear all objects assigned to the codec
2334 * @codec: HD-audio codec
2336 * This frees the all PCM and control elements assigned to the codec, and
2337 * clears the caches and restores the pin default configurations.
2339 * When a device is being used, it returns -EBSY. If successfully freed,
2342 int snd_hda_codec_reset(struct hda_codec *codec)
2344 struct hda_bus *bus = codec->bus;
2345 struct snd_card *card = bus->card;
2348 if (snd_hda_lock_devices(bus) < 0)
2351 /* OK, let it free */
2354 cancel_delayed_work_sync(&codec->power_work);
2355 codec->power_on = 0;
2356 codec->power_transition = 0;
2357 codec->power_jiffies = jiffies;
2358 flush_workqueue(bus->workq);
2360 snd_hda_ctls_clear(codec);
2362 for (i = 0; i < codec->num_pcms; i++) {
2363 if (codec->pcm_info[i].pcm) {
2364 snd_device_free(card, codec->pcm_info[i].pcm);
2365 clear_bit(codec->pcm_info[i].device,
2369 if (codec->patch_ops.free)
2370 codec->patch_ops.free(codec);
2371 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2372 snd_hda_jack_tbl_clear(codec);
2373 codec->proc_widget_hook = NULL;
2375 free_hda_cache(&codec->amp_cache);
2376 free_hda_cache(&codec->cmd_cache);
2377 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2378 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2379 /* free only driver_pins so that init_pins + user_pins are restored */
2380 snd_array_free(&codec->driver_pins);
2381 restore_pincfgs(codec);
2382 snd_array_free(&codec->cvt_setups);
2383 snd_array_free(&codec->spdif_out);
2384 codec->num_pcms = 0;
2385 codec->pcm_info = NULL;
2386 codec->preset = NULL;
2387 codec->slave_dig_outs = NULL;
2388 codec->spdif_status_reset = 0;
2389 module_put(codec->owner);
2390 codec->owner = NULL;
2392 /* allow device access again */
2393 snd_hda_unlock_devices(bus);
2397 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2399 /* apply the function to all matching slave ctls in the mixer list */
2400 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2401 const char *suffix, map_slave_func_t func, void *data)
2403 struct hda_nid_item *items;
2404 const char * const *s;
2407 items = codec->mixers.list;
2408 for (i = 0; i < codec->mixers.used; i++) {
2409 struct snd_kcontrol *sctl = items[i].kctl;
2410 if (!sctl || !sctl->id.name ||
2411 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2413 for (s = slaves; *s; s++) {
2414 char tmpname[sizeof(sctl->id.name)];
2415 const char *name = *s;
2417 snprintf(tmpname, sizeof(tmpname), "%s %s",
2421 if (!strcmp(sctl->id.name, name)) {
2422 err = func(data, sctl);
2432 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2437 /* guess the value corresponding to 0dB */
2438 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2441 const int *tlv = NULL;
2444 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2445 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2446 mm_segment_t fs = get_fs();
2448 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2451 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2453 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2454 val = -tlv[2] / tlv[3];
2458 /* call kctl->put with the given value(s) */
2459 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2461 struct snd_ctl_elem_value *ucontrol;
2462 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2465 ucontrol->value.integer.value[0] = val;
2466 ucontrol->value.integer.value[1] = val;
2467 kctl->put(kctl, ucontrol);
2472 /* initialize the slave volume with 0dB */
2473 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2475 int offset = get_kctl_0dB_offset(slave);
2477 put_kctl_with_value(slave, offset);
2481 /* unmute the slave */
2482 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2484 return put_kctl_with_value(slave, 1);
2488 * snd_hda_add_vmaster - create a virtual master control and add slaves
2489 * @codec: HD-audio codec
2490 * @name: vmaster control name
2491 * @tlv: TLV data (optional)
2492 * @slaves: slave control names (optional)
2493 * @suffix: suffix string to each slave name (optional)
2494 * @init_slave_vol: initialize slaves to unmute/0dB
2495 * @ctl_ret: store the vmaster kcontrol in return
2497 * Create a virtual master control with the given name. The TLV data
2498 * must be either NULL or a valid data.
2500 * @slaves is a NULL-terminated array of strings, each of which is a
2501 * slave control name. All controls with these names are assigned to
2502 * the new virtual master control.
2504 * This function returns zero if successful or a negative error code.
2506 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2507 unsigned int *tlv, const char * const *slaves,
2508 const char *suffix, bool init_slave_vol,
2509 struct snd_kcontrol **ctl_ret)
2511 struct snd_kcontrol *kctl;
2517 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2519 snd_printdd("No slave found for %s\n", name);
2522 kctl = snd_ctl_make_virtual_master(name, tlv);
2525 err = snd_hda_ctl_add(codec, 0, kctl);
2529 err = map_slaves(codec, slaves, suffix,
2530 (map_slave_func_t)snd_ctl_add_slave, kctl);
2534 /* init with master mute & zero volume */
2535 put_kctl_with_value(kctl, 0);
2537 map_slaves(codec, slaves, suffix,
2538 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2544 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2547 * mute-LED control using vmaster
2549 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2550 struct snd_ctl_elem_info *uinfo)
2552 static const char * const texts[] = {
2553 "Off", "On", "Follow Master"
2557 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2559 uinfo->value.enumerated.items = 3;
2560 index = uinfo->value.enumerated.item;
2563 strcpy(uinfo->value.enumerated.name, texts[index]);
2567 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2568 struct snd_ctl_elem_value *ucontrol)
2570 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2571 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2575 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2576 struct snd_ctl_elem_value *ucontrol)
2578 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2579 unsigned int old_mode = hook->mute_mode;
2581 hook->mute_mode = ucontrol->value.enumerated.item[0];
2582 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2583 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2584 if (old_mode == hook->mute_mode)
2586 snd_hda_sync_vmaster_hook(hook);
2590 static struct snd_kcontrol_new vmaster_mute_mode = {
2591 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2592 .name = "Mute-LED Mode",
2593 .info = vmaster_mute_mode_info,
2594 .get = vmaster_mute_mode_get,
2595 .put = vmaster_mute_mode_put,
2599 * Add a mute-LED hook with the given vmaster switch kctl
2600 * "Mute-LED Mode" control is automatically created and associated with
2603 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2604 struct hda_vmaster_mute_hook *hook,
2605 bool expose_enum_ctl)
2607 struct snd_kcontrol *kctl;
2609 if (!hook->hook || !hook->sw_kctl)
2611 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2612 hook->codec = codec;
2613 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2614 if (!expose_enum_ctl)
2616 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2619 return snd_hda_ctl_add(codec, 0, kctl);
2621 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2624 * Call the hook with the current value for synchronization
2625 * Should be called in init callback
2627 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2629 if (!hook->hook || !hook->codec)
2631 switch (hook->mute_mode) {
2632 case HDA_VMUTE_FOLLOW_MASTER:
2633 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2636 hook->hook(hook->codec, hook->mute_mode);
2640 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2644 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2646 * The control element is supposed to have the private_value field
2647 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2649 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2650 struct snd_ctl_elem_info *uinfo)
2652 int chs = get_amp_channels(kcontrol);
2654 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2655 uinfo->count = chs == 3 ? 2 : 1;
2656 uinfo->value.integer.min = 0;
2657 uinfo->value.integer.max = 1;
2660 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2663 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2665 * The control element is supposed to have the private_value field
2666 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2668 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2669 struct snd_ctl_elem_value *ucontrol)
2671 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2672 hda_nid_t nid = get_amp_nid(kcontrol);
2673 int chs = get_amp_channels(kcontrol);
2674 int dir = get_amp_direction(kcontrol);
2675 int idx = get_amp_index(kcontrol);
2676 long *valp = ucontrol->value.integer.value;
2679 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2680 HDA_AMP_MUTE) ? 0 : 1;
2682 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2683 HDA_AMP_MUTE) ? 0 : 1;
2686 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2689 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2691 * The control element is supposed to have the private_value field
2692 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2694 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2695 struct snd_ctl_elem_value *ucontrol)
2697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2698 hda_nid_t nid = get_amp_nid(kcontrol);
2699 int chs = get_amp_channels(kcontrol);
2700 int dir = get_amp_direction(kcontrol);
2701 int idx = get_amp_index(kcontrol);
2702 long *valp = ucontrol->value.integer.value;
2705 snd_hda_power_up(codec);
2707 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2709 *valp ? 0 : HDA_AMP_MUTE);
2713 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2715 *valp ? 0 : HDA_AMP_MUTE);
2716 hda_call_check_power_status(codec, nid);
2717 snd_hda_power_down(codec);
2720 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2723 * bound volume controls
2725 * bind multiple volumes (# indices, from 0)
2728 #define AMP_VAL_IDX_SHIFT 19
2729 #define AMP_VAL_IDX_MASK (0x0f<<19)
2732 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2734 * The control element is supposed to have the private_value field
2735 * set up via HDA_BIND_MUTE*() macros.
2737 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2738 struct snd_ctl_elem_value *ucontrol)
2740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2744 mutex_lock(&codec->control_mutex);
2745 pval = kcontrol->private_value;
2746 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2747 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2748 kcontrol->private_value = pval;
2749 mutex_unlock(&codec->control_mutex);
2752 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2755 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2757 * The control element is supposed to have the private_value field
2758 * set up via HDA_BIND_MUTE*() macros.
2760 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2761 struct snd_ctl_elem_value *ucontrol)
2763 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2765 int i, indices, err = 0, change = 0;
2767 mutex_lock(&codec->control_mutex);
2768 pval = kcontrol->private_value;
2769 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2770 for (i = 0; i < indices; i++) {
2771 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2772 (i << AMP_VAL_IDX_SHIFT);
2773 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2778 kcontrol->private_value = pval;
2779 mutex_unlock(&codec->control_mutex);
2780 return err < 0 ? err : change;
2782 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2785 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2787 * The control element is supposed to have the private_value field
2788 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2790 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2791 struct snd_ctl_elem_info *uinfo)
2793 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2794 struct hda_bind_ctls *c;
2797 mutex_lock(&codec->control_mutex);
2798 c = (struct hda_bind_ctls *)kcontrol->private_value;
2799 kcontrol->private_value = *c->values;
2800 err = c->ops->info(kcontrol, uinfo);
2801 kcontrol->private_value = (long)c;
2802 mutex_unlock(&codec->control_mutex);
2805 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2808 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2810 * The control element is supposed to have the private_value field
2811 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2813 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2814 struct snd_ctl_elem_value *ucontrol)
2816 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2817 struct hda_bind_ctls *c;
2820 mutex_lock(&codec->control_mutex);
2821 c = (struct hda_bind_ctls *)kcontrol->private_value;
2822 kcontrol->private_value = *c->values;
2823 err = c->ops->get(kcontrol, ucontrol);
2824 kcontrol->private_value = (long)c;
2825 mutex_unlock(&codec->control_mutex);
2828 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2831 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2833 * The control element is supposed to have the private_value field
2834 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2836 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2837 struct snd_ctl_elem_value *ucontrol)
2839 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2840 struct hda_bind_ctls *c;
2841 unsigned long *vals;
2842 int err = 0, change = 0;
2844 mutex_lock(&codec->control_mutex);
2845 c = (struct hda_bind_ctls *)kcontrol->private_value;
2846 for (vals = c->values; *vals; vals++) {
2847 kcontrol->private_value = *vals;
2848 err = c->ops->put(kcontrol, ucontrol);
2853 kcontrol->private_value = (long)c;
2854 mutex_unlock(&codec->control_mutex);
2855 return err < 0 ? err : change;
2857 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2860 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2862 * The control element is supposed to have the private_value field
2863 * set up via HDA_BIND_VOL() macro.
2865 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2866 unsigned int size, unsigned int __user *tlv)
2868 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2869 struct hda_bind_ctls *c;
2872 mutex_lock(&codec->control_mutex);
2873 c = (struct hda_bind_ctls *)kcontrol->private_value;
2874 kcontrol->private_value = *c->values;
2875 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2876 kcontrol->private_value = (long)c;
2877 mutex_unlock(&codec->control_mutex);
2880 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2882 struct hda_ctl_ops snd_hda_bind_vol = {
2883 .info = snd_hda_mixer_amp_volume_info,
2884 .get = snd_hda_mixer_amp_volume_get,
2885 .put = snd_hda_mixer_amp_volume_put,
2886 .tlv = snd_hda_mixer_amp_tlv
2888 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2890 struct hda_ctl_ops snd_hda_bind_sw = {
2891 .info = snd_hda_mixer_amp_switch_info,
2892 .get = snd_hda_mixer_amp_switch_get,
2893 .put = snd_hda_mixer_amp_switch_put,
2894 .tlv = snd_hda_mixer_amp_tlv
2896 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2899 * SPDIF out controls
2902 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2903 struct snd_ctl_elem_info *uinfo)
2905 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2910 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2911 struct snd_ctl_elem_value *ucontrol)
2913 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2914 IEC958_AES0_NONAUDIO |
2915 IEC958_AES0_CON_EMPHASIS_5015 |
2916 IEC958_AES0_CON_NOT_COPYRIGHT;
2917 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2918 IEC958_AES1_CON_ORIGINAL;
2922 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2923 struct snd_ctl_elem_value *ucontrol)
2925 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2926 IEC958_AES0_NONAUDIO |
2927 IEC958_AES0_PRO_EMPHASIS_5015;
2931 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2932 struct snd_ctl_elem_value *ucontrol)
2934 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2935 int idx = kcontrol->private_value;
2936 struct hda_spdif_out *spdif;
2938 mutex_lock(&codec->spdif_mutex);
2939 spdif = snd_array_elem(&codec->spdif_out, idx);
2940 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2941 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2942 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2943 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2944 mutex_unlock(&codec->spdif_mutex);
2949 /* convert from SPDIF status bits to HDA SPDIF bits
2950 * bit 0 (DigEn) is always set zero (to be filled later)
2952 static unsigned short convert_from_spdif_status(unsigned int sbits)
2954 unsigned short val = 0;
2956 if (sbits & IEC958_AES0_PROFESSIONAL)
2957 val |= AC_DIG1_PROFESSIONAL;
2958 if (sbits & IEC958_AES0_NONAUDIO)
2959 val |= AC_DIG1_NONAUDIO;
2960 if (sbits & IEC958_AES0_PROFESSIONAL) {
2961 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2962 IEC958_AES0_PRO_EMPHASIS_5015)
2963 val |= AC_DIG1_EMPHASIS;
2965 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2966 IEC958_AES0_CON_EMPHASIS_5015)
2967 val |= AC_DIG1_EMPHASIS;
2968 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2969 val |= AC_DIG1_COPYRIGHT;
2970 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2971 val |= AC_DIG1_LEVEL;
2972 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2977 /* convert to SPDIF status bits from HDA SPDIF bits
2979 static unsigned int convert_to_spdif_status(unsigned short val)
2981 unsigned int sbits = 0;
2983 if (val & AC_DIG1_NONAUDIO)
2984 sbits |= IEC958_AES0_NONAUDIO;
2985 if (val & AC_DIG1_PROFESSIONAL)
2986 sbits |= IEC958_AES0_PROFESSIONAL;
2987 if (sbits & IEC958_AES0_PROFESSIONAL) {
2988 if (sbits & AC_DIG1_EMPHASIS)
2989 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2991 if (val & AC_DIG1_EMPHASIS)
2992 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2993 if (!(val & AC_DIG1_COPYRIGHT))
2994 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2995 if (val & AC_DIG1_LEVEL)
2996 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2997 sbits |= val & (0x7f << 8);
3002 /* set digital convert verbs both for the given NID and its slaves */
3003 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3008 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3009 d = codec->slave_dig_outs;
3013 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3016 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3020 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3022 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3025 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3026 struct snd_ctl_elem_value *ucontrol)
3028 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3029 int idx = kcontrol->private_value;
3030 struct hda_spdif_out *spdif;
3035 mutex_lock(&codec->spdif_mutex);
3036 spdif = snd_array_elem(&codec->spdif_out, idx);
3038 spdif->status = ucontrol->value.iec958.status[0] |
3039 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3040 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3041 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3042 val = convert_from_spdif_status(spdif->status);
3043 val |= spdif->ctls & 1;
3044 change = spdif->ctls != val;
3046 if (change && nid != (u16)-1)
3047 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3048 mutex_unlock(&codec->spdif_mutex);
3052 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3054 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3055 struct snd_ctl_elem_value *ucontrol)
3057 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3058 int idx = kcontrol->private_value;
3059 struct hda_spdif_out *spdif;
3061 mutex_lock(&codec->spdif_mutex);
3062 spdif = snd_array_elem(&codec->spdif_out, idx);
3063 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3064 mutex_unlock(&codec->spdif_mutex);
3068 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3071 set_dig_out_convert(codec, nid, dig1, dig2);
3072 /* unmute amp switch (if any) */
3073 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3074 (dig1 & AC_DIG1_ENABLE))
3075 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3079 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3080 struct snd_ctl_elem_value *ucontrol)
3082 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3083 int idx = kcontrol->private_value;
3084 struct hda_spdif_out *spdif;
3089 mutex_lock(&codec->spdif_mutex);
3090 spdif = snd_array_elem(&codec->spdif_out, idx);
3092 val = spdif->ctls & ~AC_DIG1_ENABLE;
3093 if (ucontrol->value.integer.value[0])
3094 val |= AC_DIG1_ENABLE;
3095 change = spdif->ctls != val;
3097 if (change && nid != (u16)-1)
3098 set_spdif_ctls(codec, nid, val & 0xff, -1);
3099 mutex_unlock(&codec->spdif_mutex);
3103 static struct snd_kcontrol_new dig_mixes[] = {
3105 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3106 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3107 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3108 .info = snd_hda_spdif_mask_info,
3109 .get = snd_hda_spdif_cmask_get,
3112 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3113 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3114 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3115 .info = snd_hda_spdif_mask_info,
3116 .get = snd_hda_spdif_pmask_get,
3119 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3120 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3121 .info = snd_hda_spdif_mask_info,
3122 .get = snd_hda_spdif_default_get,
3123 .put = snd_hda_spdif_default_put,
3126 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3127 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3128 .info = snd_hda_spdif_out_switch_info,
3129 .get = snd_hda_spdif_out_switch_get,
3130 .put = snd_hda_spdif_out_switch_put,
3136 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3137 * @codec: the HDA codec
3138 * @nid: audio out widget NID
3140 * Creates controls related with the SPDIF output.
3141 * Called from each patch supporting the SPDIF out.
3143 * Returns 0 if successful, or a negative error code.
3145 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3146 hda_nid_t associated_nid,
3150 struct snd_kcontrol *kctl;
3151 struct snd_kcontrol_new *dig_mix;
3153 struct hda_spdif_out *spdif;
3155 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3157 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3160 spdif = snd_array_new(&codec->spdif_out);
3161 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3162 kctl = snd_ctl_new1(dig_mix, codec);
3165 kctl->id.index = idx;
3166 kctl->private_value = codec->spdif_out.used - 1;
3167 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3171 spdif->nid = cvt_nid;
3172 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3173 AC_VERB_GET_DIGI_CONVERT_1, 0);
3174 spdif->status = convert_to_spdif_status(spdif->ctls);
3177 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
3179 /* get the hda_spdif_out entry from the given NID
3180 * call within spdif_mutex lock
3182 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3186 for (i = 0; i < codec->spdif_out.used; i++) {
3187 struct hda_spdif_out *spdif =
3188 snd_array_elem(&codec->spdif_out, i);
3189 if (spdif->nid == nid)
3194 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3196 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3198 struct hda_spdif_out *spdif;
3200 mutex_lock(&codec->spdif_mutex);
3201 spdif = snd_array_elem(&codec->spdif_out, idx);
3202 spdif->nid = (u16)-1;
3203 mutex_unlock(&codec->spdif_mutex);
3205 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3207 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3209 struct hda_spdif_out *spdif;
3212 mutex_lock(&codec->spdif_mutex);
3213 spdif = snd_array_elem(&codec->spdif_out, idx);
3214 if (spdif->nid != nid) {
3217 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3219 mutex_unlock(&codec->spdif_mutex);
3221 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3224 * SPDIF sharing with analog output
3226 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3227 struct snd_ctl_elem_value *ucontrol)
3229 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3230 ucontrol->value.integer.value[0] = mout->share_spdif;
3234 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3235 struct snd_ctl_elem_value *ucontrol)
3237 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3238 mout->share_spdif = !!ucontrol->value.integer.value[0];
3242 static struct snd_kcontrol_new spdif_share_sw = {
3243 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3244 .name = "IEC958 Default PCM Playback Switch",
3245 .info = snd_ctl_boolean_mono_info,
3246 .get = spdif_share_sw_get,
3247 .put = spdif_share_sw_put,
3251 * snd_hda_create_spdif_share_sw - create Default PCM switch
3252 * @codec: the HDA codec
3253 * @mout: multi-out instance
3255 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3256 struct hda_multi_out *mout)
3258 if (!mout->dig_out_nid)
3260 /* ATTENTION: here mout is passed as private_data, instead of codec */
3261 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3262 snd_ctl_new1(&spdif_share_sw, mout));
3264 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3270 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3272 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3273 struct snd_ctl_elem_value *ucontrol)
3275 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3277 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3281 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3282 struct snd_ctl_elem_value *ucontrol)
3284 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3285 hda_nid_t nid = kcontrol->private_value;
3286 unsigned int val = !!ucontrol->value.integer.value[0];
3289 mutex_lock(&codec->spdif_mutex);
3290 change = codec->spdif_in_enable != val;
3292 codec->spdif_in_enable = val;
3293 snd_hda_codec_write_cache(codec, nid, 0,
3294 AC_VERB_SET_DIGI_CONVERT_1, val);
3296 mutex_unlock(&codec->spdif_mutex);
3300 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3301 struct snd_ctl_elem_value *ucontrol)
3303 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3304 hda_nid_t nid = kcontrol->private_value;
3308 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3309 sbits = convert_to_spdif_status(val);
3310 ucontrol->value.iec958.status[0] = sbits;
3311 ucontrol->value.iec958.status[1] = sbits >> 8;
3312 ucontrol->value.iec958.status[2] = sbits >> 16;
3313 ucontrol->value.iec958.status[3] = sbits >> 24;
3317 static struct snd_kcontrol_new dig_in_ctls[] = {
3319 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3320 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3321 .info = snd_hda_spdif_in_switch_info,
3322 .get = snd_hda_spdif_in_switch_get,
3323 .put = snd_hda_spdif_in_switch_put,
3326 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3327 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3328 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3329 .info = snd_hda_spdif_mask_info,
3330 .get = snd_hda_spdif_in_status_get,
3336 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3337 * @codec: the HDA codec
3338 * @nid: audio in widget NID
3340 * Creates controls related with the SPDIF input.
3341 * Called from each patch supporting the SPDIF in.
3343 * Returns 0 if successful, or a negative error code.
3345 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3348 struct snd_kcontrol *kctl;
3349 struct snd_kcontrol_new *dig_mix;
3352 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3354 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3357 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3358 kctl = snd_ctl_new1(dig_mix, codec);
3361 kctl->private_value = nid;
3362 err = snd_hda_ctl_add(codec, nid, kctl);
3366 codec->spdif_in_enable =
3367 snd_hda_codec_read(codec, nid, 0,
3368 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3372 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3379 /* build a 32bit cache key with the widget id and the command parameter */
3380 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3381 #define get_cmd_cache_nid(key) ((key) & 0xff)
3382 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3385 * snd_hda_codec_write_cache - send a single command with caching
3386 * @codec: the HDA codec
3387 * @nid: NID to send the command
3388 * @direct: direct flag
3389 * @verb: the verb to send
3390 * @parm: the parameter for the verb
3392 * Send a single command without waiting for response.
3394 * Returns 0 if successful, or a negative error code.
3396 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3397 int direct, unsigned int verb, unsigned int parm)
3399 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3400 struct hda_cache_head *c;
3405 /* parm may contain the verb stuff for get/set amp */
3406 verb = verb | (parm >> 8);
3408 key = build_cmd_cache_key(nid, verb);
3409 mutex_lock(&codec->bus->cmd_mutex);
3410 c = get_alloc_hash(&codec->cmd_cache, key);
3413 mutex_unlock(&codec->bus->cmd_mutex);
3416 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3419 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3420 * @codec: the HDA codec
3421 * @nid: NID to send the command
3422 * @direct: direct flag
3423 * @verb: the verb to send
3424 * @parm: the parameter for the verb
3426 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3427 * command if the parameter is already identical with the cached value.
3428 * If not, it sends the command and refreshes the cache.
3430 * Returns 0 if successful, or a negative error code.
3432 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3433 int direct, unsigned int verb, unsigned int parm)
3435 struct hda_cache_head *c;
3438 /* parm may contain the verb stuff for get/set amp */
3439 verb = verb | (parm >> 8);
3441 key = build_cmd_cache_key(nid, verb);
3442 mutex_lock(&codec->bus->cmd_mutex);
3443 c = get_hash(&codec->cmd_cache, key);
3444 if (c && c->val == parm) {
3445 mutex_unlock(&codec->bus->cmd_mutex);
3448 mutex_unlock(&codec->bus->cmd_mutex);
3449 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3451 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3454 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3455 * @codec: HD-audio codec
3457 * Execute all verbs recorded in the command caches to resume.
3459 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3461 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3464 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3465 u32 key = buffer->key;
3468 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3469 get_cmd_cache_cmd(key), buffer->val);
3472 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3475 * snd_hda_sequence_write_cache - sequence writes with caching
3476 * @codec: the HDA codec
3477 * @seq: VERB array to send
3479 * Send the commands sequentially from the given array.
3480 * Thte commands are recorded on cache for power-save and resume.
3481 * The array must be terminated with NID=0.
3483 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3484 const struct hda_verb *seq)
3486 for (; seq->nid; seq++)
3487 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3490 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3491 #endif /* CONFIG_PM */
3493 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3494 unsigned int power_state,
3495 bool eapd_workaround)
3497 hda_nid_t nid = codec->start_nid;
3500 for (i = 0; i < codec->num_nodes; i++, nid++) {
3501 unsigned int wcaps = get_wcaps(codec, nid);
3502 if (!(wcaps & AC_WCAP_POWER))
3504 /* don't power down the widget if it controls eapd and
3505 * EAPD_BTLENABLE is set.
3507 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3508 get_wcaps_type(wcaps) == AC_WID_PIN &&
3509 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3510 int eapd = snd_hda_codec_read(codec, nid, 0,
3511 AC_VERB_GET_EAPD_BTLENABLE, 0);
3515 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3519 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3522 * supported power states check
3524 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3525 unsigned int power_state)
3527 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3531 if (sup & power_state)
3538 * wait until the state is reached, returns the current state
3540 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3542 unsigned int power_state)
3544 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3545 unsigned int state, actual_state;
3548 state = snd_hda_codec_read(codec, fg, 0,
3549 AC_VERB_GET_POWER_STATE, 0);
3550 if (state & AC_PWRST_ERROR)
3552 actual_state = (state >> 4) & 0x0f;
3553 if (actual_state == power_state)
3555 if (time_after_eq(jiffies, end_time))
3557 /* wait until the codec reachs to the target state */
3564 * set power state of the codec, and return the power state
3566 static unsigned int hda_set_power_state(struct hda_codec *codec,
3567 unsigned int power_state)
3569 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3573 /* this delay seems necessary to avoid click noise at power-down */
3574 if (power_state == AC_PWRST_D3) {
3575 /* transition time less than 10ms for power down */
3576 msleep(codec->epss ? 10 : 100);
3579 /* repeat power states setting at most 10 times*/
3580 for (count = 0; count < 10; count++) {
3581 if (codec->patch_ops.set_power_state)
3582 codec->patch_ops.set_power_state(codec, fg,
3585 snd_hda_codec_read(codec, fg, 0,
3586 AC_VERB_SET_POWER_STATE,
3588 snd_hda_codec_set_power_to_all(codec, fg, power_state,
3591 state = hda_sync_power_state(codec, fg, power_state);
3592 if (!(state & AC_PWRST_ERROR))
3599 #ifdef CONFIG_SND_HDA_HWDEP
3600 /* execute additional init verbs */
3601 static void hda_exec_init_verbs(struct hda_codec *codec)
3603 if (codec->init_verbs.list)
3604 snd_hda_sequence_write(codec, codec->init_verbs.list);
3607 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3612 * call suspend and power-down; used both from PM and power-save
3613 * this function returns the power state in the end
3615 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
3621 if (codec->patch_ops.suspend)
3622 codec->patch_ops.suspend(codec);
3623 hda_cleanup_all_streams(codec);
3624 state = hda_set_power_state(codec, AC_PWRST_D3);
3625 /* Cancel delayed work if we aren't currently running from it. */
3627 cancel_delayed_work_sync(&codec->power_work);
3628 spin_lock(&codec->power_lock);
3629 snd_hda_update_power_acct(codec);
3630 trace_hda_power_down(codec);
3631 codec->power_on = 0;
3632 codec->power_transition = 0;
3633 codec->power_jiffies = jiffies;
3634 spin_unlock(&codec->power_lock);
3640 * kick up codec; used both from PM and power-save
3642 static void hda_call_codec_resume(struct hda_codec *codec)
3646 /* set as if powered on for avoiding re-entering the resume
3647 * in the resume / power-save sequence
3649 hda_keep_power_on(codec);
3650 hda_set_power_state(codec, AC_PWRST_D0);
3651 restore_pincfgs(codec); /* restore all current pin configs */
3652 restore_shutup_pins(codec);
3653 hda_exec_init_verbs(codec);
3654 snd_hda_jack_set_dirty_all(codec);
3655 if (codec->patch_ops.resume)
3656 codec->patch_ops.resume(codec);
3658 if (codec->patch_ops.init)
3659 codec->patch_ops.init(codec);
3660 snd_hda_codec_resume_amp(codec);
3661 snd_hda_codec_resume_cache(codec);
3663 snd_hda_jack_report_sync(codec);
3666 snd_hda_power_down(codec); /* flag down before returning */
3668 #endif /* CONFIG_PM */
3672 * snd_hda_build_controls - build mixer controls
3675 * Creates mixer controls for each codec included in the bus.
3677 * Returns 0 if successful, otherwise a negative error code.
3679 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3681 struct hda_codec *codec;
3683 list_for_each_entry(codec, &bus->codec_list, list) {
3684 int err = snd_hda_codec_build_controls(codec);
3686 printk(KERN_ERR "hda_codec: cannot build controls "
3687 "for #%d (error %d)\n", codec->addr, err);
3688 err = snd_hda_codec_reset(codec);
3691 "hda_codec: cannot revert codec\n");
3698 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3701 * add standard channel maps if not specified
3703 static int add_std_chmaps(struct hda_codec *codec)
3707 for (i = 0; i < codec->num_pcms; i++) {
3708 for (str = 0; str < 2; str++) {
3709 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
3710 struct hda_pcm_stream *hinfo =
3711 &codec->pcm_info[i].stream[str];
3712 struct snd_pcm_chmap *chmap;
3714 if (codec->pcm_info[i].own_chmap)
3716 if (!pcm || !hinfo->substreams)
3718 err = snd_pcm_add_chmap_ctls(pcm, str,
3720 hinfo->channels_max,
3724 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3730 int snd_hda_codec_build_controls(struct hda_codec *codec)
3733 hda_exec_init_verbs(codec);
3734 /* continue to initialize... */
3735 if (codec->patch_ops.init)
3736 err = codec->patch_ops.init(codec);
3737 if (!err && codec->patch_ops.build_controls)
3738 err = codec->patch_ops.build_controls(codec);
3742 /* we create chmaps here instead of build_pcms */
3743 err = add_std_chmaps(codec);
3747 snd_hda_jack_report_sync(codec); /* call at the last init point */
3754 struct hda_rate_tbl {
3756 unsigned int alsa_bits;
3757 unsigned int hda_fmt;
3760 /* rate = base * mult / div */
3761 #define HDA_RATE(base, mult, div) \
3762 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3763 (((div) - 1) << AC_FMT_DIV_SHIFT))
3765 static struct hda_rate_tbl rate_bits[] = {
3766 /* rate in Hz, ALSA rate bitmask, HDA format value */
3768 /* autodetected value used in snd_hda_query_supported_pcm */
3769 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3770 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3771 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3772 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3773 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3774 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3775 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3776 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3777 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3778 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3779 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3780 #define AC_PAR_PCM_RATE_BITS 11
3781 /* up to bits 10, 384kHZ isn't supported properly */
3783 /* not autodetected value */
3784 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3786 { 0 } /* terminator */
3790 * snd_hda_calc_stream_format - calculate format bitset
3791 * @rate: the sample rate
3792 * @channels: the number of channels
3793 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3794 * @maxbps: the max. bps
3796 * Calculate the format bitset from the given rate, channels and th PCM format.
3798 * Return zero if invalid.
3800 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3801 unsigned int channels,
3802 unsigned int format,
3803 unsigned int maxbps,
3804 unsigned short spdif_ctls)
3807 unsigned int val = 0;
3809 for (i = 0; rate_bits[i].hz; i++)
3810 if (rate_bits[i].hz == rate) {
3811 val = rate_bits[i].hda_fmt;
3814 if (!rate_bits[i].hz) {
3815 snd_printdd("invalid rate %d\n", rate);
3819 if (channels == 0 || channels > 8) {
3820 snd_printdd("invalid channels %d\n", channels);
3823 val |= channels - 1;
3825 switch (snd_pcm_format_width(format)) {
3827 val |= AC_FMT_BITS_8;
3830 val |= AC_FMT_BITS_16;
3835 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3836 val |= AC_FMT_BITS_32;
3837 else if (maxbps >= 24)
3838 val |= AC_FMT_BITS_24;
3840 val |= AC_FMT_BITS_20;
3843 snd_printdd("invalid format width %d\n",
3844 snd_pcm_format_width(format));
3848 if (spdif_ctls & AC_DIG1_NONAUDIO)
3849 val |= AC_FMT_TYPE_NON_PCM;
3853 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3855 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
3858 unsigned int val = 0;
3859 if (nid != codec->afg &&
3860 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3861 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3862 if (!val || val == -1)
3863 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3864 if (!val || val == -1)
3869 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3871 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
3875 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
3878 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3879 if (!streams || streams == -1)
3880 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3881 if (!streams || streams == -1)
3886 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3888 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
3893 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3894 * @codec: the HDA codec
3895 * @nid: NID to query
3896 * @ratesp: the pointer to store the detected rate bitflags
3897 * @formatsp: the pointer to store the detected formats
3898 * @bpsp: the pointer to store the detected format widths
3900 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3901 * or @bsps argument is ignored.
3903 * Returns 0 if successful, otherwise a negative error code.
3905 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3906 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3908 unsigned int i, val, wcaps;
3910 wcaps = get_wcaps(codec, nid);
3911 val = query_pcm_param(codec, nid);
3915 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3917 rates |= rate_bits[i].alsa_bits;
3920 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3921 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3923 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3929 if (formatsp || bpsp) {
3931 unsigned int streams, bps;
3933 streams = query_stream_param(codec, nid);
3938 if (streams & AC_SUPFMT_PCM) {
3939 if (val & AC_SUPPCM_BITS_8) {
3940 formats |= SNDRV_PCM_FMTBIT_U8;
3943 if (val & AC_SUPPCM_BITS_16) {
3944 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3947 if (wcaps & AC_WCAP_DIGITAL) {
3948 if (val & AC_SUPPCM_BITS_32)
3949 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3950 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3951 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3952 if (val & AC_SUPPCM_BITS_24)
3954 else if (val & AC_SUPPCM_BITS_20)
3956 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3957 AC_SUPPCM_BITS_32)) {
3958 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3959 if (val & AC_SUPPCM_BITS_32)
3961 else if (val & AC_SUPPCM_BITS_24)
3963 else if (val & AC_SUPPCM_BITS_20)
3967 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
3968 if (streams & AC_SUPFMT_FLOAT32) {
3969 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3974 if (streams == AC_SUPFMT_AC3) {
3975 /* should be exclusive */
3976 /* temporary hack: we have still no proper support
3977 * for the direct AC3 stream...
3979 formats |= SNDRV_PCM_FMTBIT_U8;
3983 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3984 "(nid=0x%x, val=0x%x, ovrd=%i, "
3987 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3992 *formatsp = formats;
3999 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
4002 * snd_hda_is_supported_format - Check the validity of the format
4003 * @codec: HD-audio codec
4004 * @nid: NID to check
4005 * @format: the HD-audio format value to check
4007 * Check whether the given node supports the format value.
4009 * Returns 1 if supported, 0 if not.
4011 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4012 unsigned int format)
4015 unsigned int val = 0, rate, stream;
4017 val = query_pcm_param(codec, nid);
4021 rate = format & 0xff00;
4022 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4023 if (rate_bits[i].hda_fmt == rate) {
4028 if (i >= AC_PAR_PCM_RATE_BITS)
4031 stream = query_stream_param(codec, nid);
4035 if (stream & AC_SUPFMT_PCM) {
4036 switch (format & 0xf0) {
4038 if (!(val & AC_SUPPCM_BITS_8))
4042 if (!(val & AC_SUPPCM_BITS_16))
4046 if (!(val & AC_SUPPCM_BITS_20))
4050 if (!(val & AC_SUPPCM_BITS_24))
4054 if (!(val & AC_SUPPCM_BITS_32))
4061 /* FIXME: check for float32 and AC3? */
4066 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
4071 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4072 struct hda_codec *codec,
4073 struct snd_pcm_substream *substream)
4078 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4079 struct hda_codec *codec,
4080 unsigned int stream_tag,
4081 unsigned int format,
4082 struct snd_pcm_substream *substream)
4084 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4088 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4089 struct hda_codec *codec,
4090 struct snd_pcm_substream *substream)
4092 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4096 static int set_pcm_default_values(struct hda_codec *codec,
4097 struct hda_pcm_stream *info)
4101 /* query support PCM information from the given NID */
4102 if (info->nid && (!info->rates || !info->formats)) {
4103 err = snd_hda_query_supported_pcm(codec, info->nid,
4104 info->rates ? NULL : &info->rates,
4105 info->formats ? NULL : &info->formats,
4106 info->maxbps ? NULL : &info->maxbps);
4110 if (info->ops.open == NULL)
4111 info->ops.open = hda_pcm_default_open_close;
4112 if (info->ops.close == NULL)
4113 info->ops.close = hda_pcm_default_open_close;
4114 if (info->ops.prepare == NULL) {
4115 if (snd_BUG_ON(!info->nid))
4117 info->ops.prepare = hda_pcm_default_prepare;
4119 if (info->ops.cleanup == NULL) {
4120 if (snd_BUG_ON(!info->nid))
4122 info->ops.cleanup = hda_pcm_default_cleanup;
4128 * codec prepare/cleanup entries
4130 int snd_hda_codec_prepare(struct hda_codec *codec,
4131 struct hda_pcm_stream *hinfo,
4132 unsigned int stream,
4133 unsigned int format,
4134 struct snd_pcm_substream *substream)
4137 mutex_lock(&codec->bus->prepare_mutex);
4138 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4140 purify_inactive_streams(codec);
4141 mutex_unlock(&codec->bus->prepare_mutex);
4144 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4146 void snd_hda_codec_cleanup(struct hda_codec *codec,
4147 struct hda_pcm_stream *hinfo,
4148 struct snd_pcm_substream *substream)
4150 mutex_lock(&codec->bus->prepare_mutex);
4151 hinfo->ops.cleanup(hinfo, codec, substream);
4152 mutex_unlock(&codec->bus->prepare_mutex);
4154 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4157 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4158 "Audio", "SPDIF", "HDMI", "Modem"
4162 * get the empty PCM device number to assign
4164 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4166 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4168 /* audio device indices; not linear to keep compatibility */
4169 static int audio_idx[HDA_PCM_NTYPES][5] = {
4170 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4171 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4172 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4173 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4177 if (type >= HDA_PCM_NTYPES) {
4178 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4182 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4183 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4184 return audio_idx[type][i];
4186 /* non-fixed slots starting from 10 */
4187 for (i = 10; i < 32; i++) {
4188 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4192 snd_printk(KERN_WARNING "Too many %s devices\n",
4193 snd_hda_pcm_type_name[type]);
4198 * attach a new PCM stream
4200 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4202 struct hda_bus *bus = codec->bus;
4203 struct hda_pcm_stream *info;
4206 if (snd_BUG_ON(!pcm->name))
4208 for (stream = 0; stream < 2; stream++) {
4209 info = &pcm->stream[stream];
4210 if (info->substreams) {
4211 err = set_pcm_default_values(codec, info);
4216 return bus->ops.attach_pcm(bus, codec, pcm);
4219 /* assign all PCMs of the given codec */
4220 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4225 if (!codec->num_pcms) {
4226 if (!codec->patch_ops.build_pcms)
4228 err = codec->patch_ops.build_pcms(codec);
4230 printk(KERN_ERR "hda_codec: cannot build PCMs"
4231 "for #%d (error %d)\n", codec->addr, err);
4232 err = snd_hda_codec_reset(codec);
4235 "hda_codec: cannot revert codec\n");
4240 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4241 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4244 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4245 continue; /* no substreams assigned */
4248 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4250 continue; /* no fatal error */
4252 err = snd_hda_attach_pcm(codec, cpcm);
4254 printk(KERN_ERR "hda_codec: cannot attach "
4255 "PCM stream %d for codec #%d\n",
4257 continue; /* no fatal error */
4265 * snd_hda_build_pcms - build PCM information
4268 * Create PCM information for each codec included in the bus.
4270 * The build_pcms codec patch is requested to set up codec->num_pcms and
4271 * codec->pcm_info properly. The array is referred by the top-level driver
4272 * to create its PCM instances.
4273 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4276 * At least, substreams, channels_min and channels_max must be filled for
4277 * each stream. substreams = 0 indicates that the stream doesn't exist.
4278 * When rates and/or formats are zero, the supported values are queried
4279 * from the given nid. The nid is used also by the default ops.prepare
4280 * and ops.cleanup callbacks.
4282 * The driver needs to call ops.open in its open callback. Similarly,
4283 * ops.close is supposed to be called in the close callback.
4284 * ops.prepare should be called in the prepare or hw_params callback
4285 * with the proper parameters for set up.
4286 * ops.cleanup should be called in hw_free for clean up of streams.
4288 * This function returns 0 if successful, or a negative error code.
4290 int snd_hda_build_pcms(struct hda_bus *bus)
4292 struct hda_codec *codec;
4294 list_for_each_entry(codec, &bus->codec_list, list) {
4295 int err = snd_hda_codec_build_pcms(codec);
4301 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4304 * snd_hda_check_board_config - compare the current codec with the config table
4305 * @codec: the HDA codec
4306 * @num_configs: number of config enums
4307 * @models: array of model name strings
4308 * @tbl: configuration table, terminated by null entries
4310 * Compares the modelname or PCI subsystem id of the current codec with the
4311 * given configuration table. If a matching entry is found, returns its
4312 * config value (supposed to be 0 or positive).
4314 * If no entries are matching, the function returns a negative value.
4316 int snd_hda_check_board_config(struct hda_codec *codec,
4317 int num_configs, const char * const *models,
4318 const struct snd_pci_quirk *tbl)
4320 if (codec->modelname && models) {
4322 for (i = 0; i < num_configs; i++) {
4324 !strcmp(codec->modelname, models[i])) {
4325 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4326 "selected\n", models[i]);
4332 if (!codec->bus->pci || !tbl)
4335 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4338 if (tbl->value >= 0 && tbl->value < num_configs) {
4339 #ifdef CONFIG_SND_DEBUG_VERBOSE
4341 const char *model = NULL;
4343 model = models[tbl->value];
4345 sprintf(tmp, "#%d", tbl->value);
4348 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4349 "for config %x:%x (%s)\n",
4350 model, tbl->subvendor, tbl->subdevice,
4351 (tbl->name ? tbl->name : "Unknown device"));
4357 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4360 * snd_hda_check_board_codec_sid_config - compare the current codec
4361 subsystem ID with the
4364 This is important for Gateway notebooks with SB450 HDA Audio
4365 where the vendor ID of the PCI device is:
4366 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4367 and the vendor/subvendor are found only at the codec.
4369 * @codec: the HDA codec
4370 * @num_configs: number of config enums
4371 * @models: array of model name strings
4372 * @tbl: configuration table, terminated by null entries
4374 * Compares the modelname or PCI subsystem id of the current codec with the
4375 * given configuration table. If a matching entry is found, returns its
4376 * config value (supposed to be 0 or positive).
4378 * If no entries are matching, the function returns a negative value.
4380 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4381 int num_configs, const char * const *models,
4382 const struct snd_pci_quirk *tbl)
4384 const struct snd_pci_quirk *q;
4386 /* Search for codec ID */
4387 for (q = tbl; q->subvendor; q++) {
4388 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4389 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4390 if ((codec->subsystem_id & mask) == id)
4399 if (tbl->value >= 0 && tbl->value < num_configs) {
4400 #ifdef CONFIG_SND_DEBUG_VERBOSE
4402 const char *model = NULL;
4404 model = models[tbl->value];
4406 sprintf(tmp, "#%d", tbl->value);
4409 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4410 "for config %x:%x (%s)\n",
4411 model, tbl->subvendor, tbl->subdevice,
4412 (tbl->name ? tbl->name : "Unknown device"));
4418 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4421 * snd_hda_add_new_ctls - create controls from the array
4422 * @codec: the HDA codec
4423 * @knew: the array of struct snd_kcontrol_new
4425 * This helper function creates and add new controls in the given array.
4426 * The array must be terminated with an empty entry as terminator.
4428 * Returns 0 if successful, or a negative error code.
4430 int snd_hda_add_new_ctls(struct hda_codec *codec,
4431 const struct snd_kcontrol_new *knew)
4435 for (; knew->name; knew++) {
4436 struct snd_kcontrol *kctl;
4437 int addr = 0, idx = 0;
4438 if (knew->iface == -1) /* skip this codec private value */
4441 kctl = snd_ctl_new1(knew, codec);
4445 kctl->id.device = addr;
4447 kctl->id.index = idx;
4448 err = snd_hda_ctl_add(codec, 0, kctl);
4451 /* try first with another device index corresponding to
4452 * the codec addr; if it still fails (or it's the
4453 * primary codec), then try another control index
4455 if (!addr && codec->addr)
4457 else if (!idx && !knew->index) {
4458 idx = find_empty_mixer_ctl_idx(codec,
4468 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4471 static void hda_power_work(struct work_struct *work)
4473 struct hda_codec *codec =
4474 container_of(work, struct hda_codec, power_work.work);
4475 struct hda_bus *bus = codec->bus;
4478 spin_lock(&codec->power_lock);
4479 if (codec->power_transition > 0) { /* during power-up sequence? */
4480 spin_unlock(&codec->power_lock);
4483 if (!codec->power_on || codec->power_count) {
4484 codec->power_transition = 0;
4485 spin_unlock(&codec->power_lock);
4488 spin_unlock(&codec->power_lock);
4490 state = hda_call_codec_suspend(codec, true);
4491 codec->pm_down_notified = 0;
4492 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
4493 codec->pm_down_notified = 1;
4494 hda_call_pm_notify(bus, false);
4498 static void hda_keep_power_on(struct hda_codec *codec)
4500 spin_lock(&codec->power_lock);
4501 codec->power_count++;
4502 codec->power_on = 1;
4503 codec->power_jiffies = jiffies;
4504 spin_unlock(&codec->power_lock);
4507 /* update the power on/off account with the current jiffies */
4508 void snd_hda_update_power_acct(struct hda_codec *codec)
4510 unsigned long delta = jiffies - codec->power_jiffies;
4511 if (codec->power_on)
4512 codec->power_on_acct += delta;
4514 codec->power_off_acct += delta;
4515 codec->power_jiffies += delta;
4518 /* Transition to powered up, if wait_power_down then wait for a pending
4519 * transition to D3 to complete. A pending D3 transition is indicated
4520 * with power_transition == -1. */
4521 /* call this with codec->power_lock held! */
4522 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4524 struct hda_bus *bus = codec->bus;
4526 /* Return if power_on or transitioning to power_on, unless currently
4528 if ((codec->power_on || codec->power_transition > 0) &&
4529 !(wait_power_down && codec->power_transition < 0))
4531 spin_unlock(&codec->power_lock);
4533 cancel_delayed_work_sync(&codec->power_work);
4535 spin_lock(&codec->power_lock);
4536 /* If the power down delayed work was cancelled above before starting,
4537 * then there is no need to go through power up here.
4539 if (codec->power_on) {
4540 if (codec->power_transition < 0)
4541 codec->power_transition = 0;
4545 trace_hda_power_up(codec);
4546 snd_hda_update_power_acct(codec);
4547 codec->power_on = 1;
4548 codec->power_jiffies = jiffies;
4549 codec->power_transition = 1; /* avoid reentrance */
4550 spin_unlock(&codec->power_lock);
4552 if (codec->pm_down_notified) {
4553 codec->pm_down_notified = 0;
4554 hda_call_pm_notify(bus, true);
4557 hda_call_codec_resume(codec);
4559 spin_lock(&codec->power_lock);
4560 codec->power_transition = 0;
4563 #define power_save(codec) \
4564 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4566 /* Transition to powered down */
4567 static void __snd_hda_power_down(struct hda_codec *codec)
4569 if (!codec->power_on || codec->power_count || codec->power_transition)
4572 if (power_save(codec)) {
4573 codec->power_transition = -1; /* avoid reentrance */
4574 queue_delayed_work(codec->bus->workq, &codec->power_work,
4575 msecs_to_jiffies(power_save(codec) * 1000));
4580 * snd_hda_power_save - Power-up/down/sync the codec
4581 * @codec: HD-audio codec
4582 * @delta: the counter delta to change
4584 * Change the power-up counter via @delta, and power up or down the hardware
4585 * appropriately. For the power-down, queue to the delayed action.
4586 * Passing zero to @delta means to synchronize the power state.
4588 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4590 spin_lock(&codec->power_lock);
4591 codec->power_count += delta;
4592 trace_hda_power_count(codec);
4594 __snd_hda_power_up(codec, d3wait);
4596 __snd_hda_power_down(codec);
4597 spin_unlock(&codec->power_lock);
4599 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4602 * snd_hda_check_amp_list_power - Check the amp list and update the power
4603 * @codec: HD-audio codec
4604 * @check: the object containing an AMP list and the status
4605 * @nid: NID to check / update
4607 * Check whether the given NID is in the amp list. If it's in the list,
4608 * check the current AMP status, and update the the power-status according
4609 * to the mute status.
4611 * This function is supposed to be set or called from the check_power_status
4614 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4615 struct hda_loopback_check *check,
4618 const struct hda_amp_list *p;
4621 if (!check->amplist)
4623 for (p = check->amplist; p->nid; p++) {
4628 return 0; /* nothing changed */
4630 for (p = check->amplist; p->nid; p++) {
4631 for (ch = 0; ch < 2; ch++) {
4632 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4634 if (!(v & HDA_AMP_MUTE) && v > 0) {
4635 if (!check->power_on) {
4636 check->power_on = 1;
4637 snd_hda_power_up(codec);
4643 if (check->power_on) {
4644 check->power_on = 0;
4645 snd_hda_power_down(codec);
4649 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4653 * Channel mode helper
4657 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4659 int snd_hda_ch_mode_info(struct hda_codec *codec,
4660 struct snd_ctl_elem_info *uinfo,
4661 const struct hda_channel_mode *chmode,
4664 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4666 uinfo->value.enumerated.items = num_chmodes;
4667 if (uinfo->value.enumerated.item >= num_chmodes)
4668 uinfo->value.enumerated.item = num_chmodes - 1;
4669 sprintf(uinfo->value.enumerated.name, "%dch",
4670 chmode[uinfo->value.enumerated.item].channels);
4673 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4676 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4678 int snd_hda_ch_mode_get(struct hda_codec *codec,
4679 struct snd_ctl_elem_value *ucontrol,
4680 const struct hda_channel_mode *chmode,
4686 for (i = 0; i < num_chmodes; i++) {
4687 if (max_channels == chmode[i].channels) {
4688 ucontrol->value.enumerated.item[0] = i;
4694 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4697 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4699 int snd_hda_ch_mode_put(struct hda_codec *codec,
4700 struct snd_ctl_elem_value *ucontrol,
4701 const struct hda_channel_mode *chmode,
4707 mode = ucontrol->value.enumerated.item[0];
4708 if (mode >= num_chmodes)
4710 if (*max_channelsp == chmode[mode].channels)
4712 /* change the current channel setting */
4713 *max_channelsp = chmode[mode].channels;
4714 if (chmode[mode].sequence)
4715 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4718 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4725 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4727 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4728 struct snd_ctl_elem_info *uinfo)
4732 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4734 uinfo->value.enumerated.items = imux->num_items;
4735 if (!imux->num_items)
4737 index = uinfo->value.enumerated.item;
4738 if (index >= imux->num_items)
4739 index = imux->num_items - 1;
4740 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4743 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4746 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4748 int snd_hda_input_mux_put(struct hda_codec *codec,
4749 const struct hda_input_mux *imux,
4750 struct snd_ctl_elem_value *ucontrol,
4752 unsigned int *cur_val)
4756 if (!imux->num_items)
4758 idx = ucontrol->value.enumerated.item[0];
4759 if (idx >= imux->num_items)
4760 idx = imux->num_items - 1;
4761 if (*cur_val == idx)
4763 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4764 imux->items[idx].index);
4768 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4772 * Multi-channel / digital-out PCM helper functions
4775 /* setup SPDIF output stream */
4776 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4777 unsigned int stream_tag, unsigned int format)
4779 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4781 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4782 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4783 set_dig_out_convert(codec, nid,
4784 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4786 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4787 if (codec->slave_dig_outs) {
4789 for (d = codec->slave_dig_outs; *d; d++)
4790 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4793 /* turn on again (if needed) */
4794 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4795 set_dig_out_convert(codec, nid,
4796 spdif->ctls & 0xff, -1);
4799 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4801 snd_hda_codec_cleanup_stream(codec, nid);
4802 if (codec->slave_dig_outs) {
4804 for (d = codec->slave_dig_outs; *d; d++)
4805 snd_hda_codec_cleanup_stream(codec, *d);
4810 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4811 * @bus: HD-audio bus
4813 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4815 struct hda_codec *codec;
4819 list_for_each_entry(codec, &bus->codec_list, list) {
4820 if (hda_codec_is_power_on(codec) &&
4821 codec->patch_ops.reboot_notify)
4822 codec->patch_ops.reboot_notify(codec);
4825 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4828 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4830 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4831 struct hda_multi_out *mout)
4833 mutex_lock(&codec->spdif_mutex);
4834 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4835 /* already opened as analog dup; reset it once */
4836 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4837 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4838 mutex_unlock(&codec->spdif_mutex);
4841 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4844 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4846 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4847 struct hda_multi_out *mout,
4848 unsigned int stream_tag,
4849 unsigned int format,
4850 struct snd_pcm_substream *substream)
4852 mutex_lock(&codec->spdif_mutex);
4853 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4854 mutex_unlock(&codec->spdif_mutex);
4857 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4860 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4862 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4863 struct hda_multi_out *mout)
4865 mutex_lock(&codec->spdif_mutex);
4866 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4867 mutex_unlock(&codec->spdif_mutex);
4870 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4873 * snd_hda_multi_out_dig_close - release the digital out stream
4875 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4876 struct hda_multi_out *mout)
4878 mutex_lock(&codec->spdif_mutex);
4879 mout->dig_out_used = 0;
4880 mutex_unlock(&codec->spdif_mutex);
4883 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4886 * snd_hda_multi_out_analog_open - open analog outputs
4888 * Open analog outputs and set up the hw-constraints.
4889 * If the digital outputs can be opened as slave, open the digital
4892 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4893 struct hda_multi_out *mout,
4894 struct snd_pcm_substream *substream,
4895 struct hda_pcm_stream *hinfo)
4897 struct snd_pcm_runtime *runtime = substream->runtime;
4898 runtime->hw.channels_max = mout->max_channels;
4899 if (mout->dig_out_nid) {
4900 if (!mout->analog_rates) {
4901 mout->analog_rates = hinfo->rates;
4902 mout->analog_formats = hinfo->formats;
4903 mout->analog_maxbps = hinfo->maxbps;
4905 runtime->hw.rates = mout->analog_rates;
4906 runtime->hw.formats = mout->analog_formats;
4907 hinfo->maxbps = mout->analog_maxbps;
4909 if (!mout->spdif_rates) {
4910 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4912 &mout->spdif_formats,
4913 &mout->spdif_maxbps);
4915 mutex_lock(&codec->spdif_mutex);
4916 if (mout->share_spdif) {
4917 if ((runtime->hw.rates & mout->spdif_rates) &&
4918 (runtime->hw.formats & mout->spdif_formats)) {
4919 runtime->hw.rates &= mout->spdif_rates;
4920 runtime->hw.formats &= mout->spdif_formats;
4921 if (mout->spdif_maxbps < hinfo->maxbps)
4922 hinfo->maxbps = mout->spdif_maxbps;
4924 mout->share_spdif = 0;
4925 /* FIXME: need notify? */
4928 mutex_unlock(&codec->spdif_mutex);
4930 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4931 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4933 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4936 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4938 * Set up the i/o for analog out.
4939 * When the digital out is available, copy the front out to digital out, too.
4941 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4942 struct hda_multi_out *mout,
4943 unsigned int stream_tag,
4944 unsigned int format,
4945 struct snd_pcm_substream *substream)
4947 const hda_nid_t *nids = mout->dac_nids;
4948 int chs = substream->runtime->channels;
4949 struct hda_spdif_out *spdif;
4952 mutex_lock(&codec->spdif_mutex);
4953 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4954 if (mout->dig_out_nid && mout->share_spdif &&
4955 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4957 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4959 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4960 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4961 setup_dig_out_stream(codec, mout->dig_out_nid,
4962 stream_tag, format);
4964 mout->dig_out_used = 0;
4965 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4968 mutex_unlock(&codec->spdif_mutex);
4971 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4973 if (!mout->no_share_stream &&
4974 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4975 /* headphone out will just decode front left/right (stereo) */
4976 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4978 /* extra outputs copied from front */
4979 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4980 if (!mout->no_share_stream && mout->hp_out_nid[i])
4981 snd_hda_codec_setup_stream(codec,
4982 mout->hp_out_nid[i],
4983 stream_tag, 0, format);
4984 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4985 if (!mout->no_share_stream && mout->extra_out_nid[i])
4986 snd_hda_codec_setup_stream(codec,
4987 mout->extra_out_nid[i],
4988 stream_tag, 0, format);
4991 for (i = 1; i < mout->num_dacs; i++) {
4992 if (chs >= (i + 1) * 2) /* independent out */
4993 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4995 else if (!mout->no_share_stream) /* copy front */
4996 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5001 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
5004 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5006 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5007 struct hda_multi_out *mout)
5009 const hda_nid_t *nids = mout->dac_nids;
5012 for (i = 0; i < mout->num_dacs; i++)
5013 snd_hda_codec_cleanup_stream(codec, nids[i]);
5015 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5016 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5017 if (mout->hp_out_nid[i])
5018 snd_hda_codec_cleanup_stream(codec,
5019 mout->hp_out_nid[i]);
5020 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5021 if (mout->extra_out_nid[i])
5022 snd_hda_codec_cleanup_stream(codec,
5023 mout->extra_out_nid[i]);
5024 mutex_lock(&codec->spdif_mutex);
5025 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5026 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5027 mout->dig_out_used = 0;
5029 mutex_unlock(&codec->spdif_mutex);
5032 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
5035 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5037 * Guess the suitable VREF pin bits to be set as the pin-control value.
5038 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5040 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5042 unsigned int pincap;
5043 unsigned int oldval;
5044 oldval = snd_hda_codec_read(codec, pin, 0,
5045 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5046 pincap = snd_hda_query_pin_caps(codec, pin);
5047 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5048 /* Exception: if the default pin setup is vref50, we give it priority */
5049 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5050 return AC_PINCTL_VREF_80;
5051 else if (pincap & AC_PINCAP_VREF_50)
5052 return AC_PINCTL_VREF_50;
5053 else if (pincap & AC_PINCAP_VREF_100)
5054 return AC_PINCTL_VREF_100;
5055 else if (pincap & AC_PINCAP_VREF_GRD)
5056 return AC_PINCTL_VREF_GRD;
5057 return AC_PINCTL_VREF_HIZ;
5059 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5061 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5062 unsigned int val, bool cached)
5065 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
5066 if (cap && (val & AC_PINCTL_OUT_EN)) {
5067 if (!(cap & AC_PINCAP_OUT))
5068 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5069 else if ((val & AC_PINCTL_HP_EN) &&
5070 !(cap & AC_PINCAP_HP_DRV))
5071 val &= ~AC_PINCTL_HP_EN;
5073 if (cap && (val & AC_PINCTL_IN_EN)) {
5074 if (!(cap & AC_PINCAP_IN))
5075 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5079 return snd_hda_codec_update_cache(codec, pin, 0,
5080 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5082 return snd_hda_codec_write(codec, pin, 0,
5083 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5085 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5088 * snd_hda_add_imux_item - Add an item to input_mux
5090 * When the same label is used already in the existing items, the number
5091 * suffix is appended to the label. This label index number is stored
5092 * to type_idx when non-NULL pointer is given.
5094 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5095 int index, int *type_idx)
5097 int i, label_idx = 0;
5098 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5099 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5102 for (i = 0; i < imux->num_items; i++) {
5103 if (!strncmp(label, imux->items[i].label, strlen(label)))
5107 *type_idx = label_idx;
5109 snprintf(imux->items[imux->num_items].label,
5110 sizeof(imux->items[imux->num_items].label),
5111 "%s %d", label, label_idx);
5113 strlcpy(imux->items[imux->num_items].label, label,
5114 sizeof(imux->items[imux->num_items].label));
5115 imux->items[imux->num_items].index = index;
5119 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5128 * snd_hda_suspend - suspend the codecs
5131 * Returns 0 if successful.
5133 int snd_hda_suspend(struct hda_bus *bus)
5135 struct hda_codec *codec;
5137 list_for_each_entry(codec, &bus->codec_list, list) {
5138 if (hda_codec_is_power_on(codec))
5139 hda_call_codec_suspend(codec, false);
5143 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5146 * snd_hda_resume - resume the codecs
5149 * Returns 0 if successful.
5151 int snd_hda_resume(struct hda_bus *bus)
5153 struct hda_codec *codec;
5155 list_for_each_entry(codec, &bus->codec_list, list) {
5156 hda_call_codec_resume(codec);
5160 EXPORT_SYMBOL_HDA(snd_hda_resume);
5161 #endif /* CONFIG_PM */
5168 * snd_array_new - get a new element from the given array
5169 * @array: the array object
5171 * Get a new element from the given array. If it exceeds the
5172 * pre-allocated array size, re-allocate the array.
5174 * Returns NULL if allocation failed.
5176 void *snd_array_new(struct snd_array *array)
5178 if (snd_BUG_ON(!array->elem_size))
5180 if (array->used >= array->alloced) {
5181 int num = array->alloced + array->alloc_align;
5182 int size = (num + 1) * array->elem_size;
5183 int oldsize = array->alloced * array->elem_size;
5185 if (snd_BUG_ON(num >= 4096))
5187 nlist = krealloc(array->list, size, GFP_KERNEL);
5190 memset(nlist + oldsize, 0, size - oldsize);
5191 array->list = nlist;
5192 array->alloced = num;
5194 return snd_array_elem(array, array->used++);
5196 EXPORT_SYMBOL_HDA(snd_array_new);
5199 * snd_array_free - free the given array elements
5200 * @array: the array object
5202 void snd_array_free(struct snd_array *array)
5209 EXPORT_SYMBOL_HDA(snd_array_free);
5212 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5213 * @pcm: PCM caps bits
5214 * @buf: the string buffer to write
5215 * @buflen: the max buffer length
5217 * used by hda_proc.c and hda_eld.c
5219 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5221 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5224 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5225 if (pcm & (AC_SUPPCM_BITS_8 << i))
5226 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5228 buf[j] = '\0'; /* necessary when j == 0 */
5230 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5232 MODULE_DESCRIPTION("HDA codec core");
5233 MODULE_LICENSE("GPL");