2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <linux/module.h>
28 #include <sound/core.h>
29 #include "hda_codec.h"
30 #include <sound/asoundef.h>
31 #include <sound/tlv.h>
32 #include <sound/initval.h>
33 #include <sound/jack.h>
34 #include "hda_local.h"
37 #include <sound/hda_hwdep.h>
39 #define CREATE_TRACE_POINTS
40 #include "hda_trace.h"
43 * vendor / preset table
46 struct hda_vendor_id {
51 /* codec vendor labels */
52 static struct hda_vendor_id hda_vendor_ids[] = {
54 { 0x1013, "Cirrus Logic" },
55 { 0x1057, "Motorola" },
56 { 0x1095, "Silicon Image" },
58 { 0x10ec, "Realtek" },
59 { 0x1102, "Creative" },
63 { 0x11d4, "Analog Devices" },
64 { 0x13f6, "C-Media" },
65 { 0x14f1, "Conexant" },
66 { 0x17e8, "Chrontel" },
68 { 0x1aec, "Wolfson Microelectronics" },
69 { 0x434d, "C-Media" },
71 { 0x8384, "SigmaTel" },
75 static DEFINE_MUTEX(preset_mutex);
76 static LIST_HEAD(hda_preset_tables);
78 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
80 mutex_lock(&preset_mutex);
81 list_add_tail(&preset->list, &hda_preset_tables);
82 mutex_unlock(&preset_mutex);
85 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
87 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
89 mutex_lock(&preset_mutex);
90 list_del(&preset->list);
91 mutex_unlock(&preset_mutex);
94 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
96 #ifdef CONFIG_SND_HDA_POWER_SAVE
97 static void hda_power_work(struct work_struct *work);
98 static void hda_keep_power_on(struct hda_codec *codec);
99 #define hda_codec_is_power_on(codec) ((codec)->power_on)
101 static inline void hda_keep_power_on(struct hda_codec *codec) {}
102 #define hda_codec_is_power_on(codec) 1
106 * snd_hda_get_jack_location - Give a location string of the jack
107 * @cfg: pin default config value
109 * Parse the pin default config value and returns the string of the
110 * jack location, e.g. "Rear", "Front", etc.
112 const char *snd_hda_get_jack_location(u32 cfg)
114 static char *bases[7] = {
115 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
117 static unsigned char specials_idx[] = {
122 static char *specials[] = {
123 "Rear Panel", "Drive Bar",
124 "Riser", "HDMI", "ATAPI",
125 "Mobile-In", "Mobile-Out"
128 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
129 if ((cfg & 0x0f) < 7)
130 return bases[cfg & 0x0f];
131 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
132 if (cfg == specials_idx[i])
137 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
140 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
141 * @cfg: pin default config value
143 * Parse the pin default config value and returns the string of the
144 * jack connectivity, i.e. external or internal connection.
146 const char *snd_hda_get_jack_connectivity(u32 cfg)
148 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
150 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
152 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
155 * snd_hda_get_jack_type - Give a type string of the jack
156 * @cfg: pin default config value
158 * Parse the pin default config value and returns the string of the
159 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
161 const char *snd_hda_get_jack_type(u32 cfg)
163 static char *jack_types[16] = {
164 "Line Out", "Speaker", "HP Out", "CD",
165 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
166 "Line In", "Aux", "Mic", "Telephony",
167 "SPDIF In", "Digitial In", "Reserved", "Other"
170 return jack_types[(cfg & AC_DEFCFG_DEVICE)
171 >> AC_DEFCFG_DEVICE_SHIFT];
173 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
176 * Compose a 32bit command word to be sent to the HD-audio controller
178 static inline unsigned int
179 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
180 unsigned int verb, unsigned int parm)
184 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
185 (verb & ~0xfff) || (parm & ~0xffff)) {
186 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
187 codec->addr, direct, nid, verb, parm);
191 val = (u32)codec->addr << 28;
192 val |= (u32)direct << 27;
193 val |= (u32)nid << 20;
200 * Send and receive a verb
202 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
205 struct hda_bus *bus = codec->bus;
214 snd_hda_power_up(codec);
215 mutex_lock(&bus->cmd_mutex);
216 trace_hda_send_cmd(codec, cmd);
217 err = bus->ops.command(bus, cmd);
219 *res = bus->ops.get_response(bus, codec->addr);
220 trace_hda_get_response(codec, *res);
222 mutex_unlock(&bus->cmd_mutex);
223 snd_hda_power_down(codec);
224 if (res && *res == -1 && bus->rirb_error) {
225 if (bus->response_reset) {
226 snd_printd("hda_codec: resetting BUS due to "
227 "fatal communication error\n");
228 trace_hda_bus_reset(bus);
229 bus->ops.bus_reset(bus);
233 /* clear reset-flag when the communication gets recovered */
235 bus->response_reset = 0;
240 * snd_hda_codec_read - send a command and get the response
241 * @codec: the HDA codec
242 * @nid: NID to send the command
243 * @direct: direct flag
244 * @verb: the verb to send
245 * @parm: the parameter for the verb
247 * Send a single command and read the corresponding response.
249 * Returns the obtained response value, or -1 for an error.
251 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
253 unsigned int verb, unsigned int parm)
255 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
257 if (codec_exec_verb(codec, cmd, &res))
261 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
264 * snd_hda_codec_write - send a single command without waiting for response
265 * @codec: the HDA codec
266 * @nid: NID to send the command
267 * @direct: direct flag
268 * @verb: the verb to send
269 * @parm: the parameter for the verb
271 * Send a single command without waiting for response.
273 * Returns 0 if successful, or a negative error code.
275 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
276 unsigned int verb, unsigned int parm)
278 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
280 return codec_exec_verb(codec, cmd,
281 codec->bus->sync_write ? &res : NULL);
283 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
286 * snd_hda_sequence_write - sequence writes
287 * @codec: the HDA codec
288 * @seq: VERB array to send
290 * Send the commands sequentially from the given array.
291 * The array must be terminated with NID=0.
293 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
295 for (; seq->nid; seq++)
296 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
298 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
301 * snd_hda_get_sub_nodes - get the range of sub nodes
302 * @codec: the HDA codec
304 * @start_id: the pointer to store the start NID
306 * Parse the NID and store the start NID of its sub-nodes.
307 * Returns the number of sub-nodes.
309 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
314 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
317 *start_id = (parm >> 16) & 0x7fff;
318 return (int)(parm & 0x7fff);
320 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
322 /* look up the cached results */
323 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
326 for (i = 0; i < array->used; ) {
327 hda_nid_t *p = snd_array_elem(array, i);
337 * snd_hda_get_conn_list - get connection list
338 * @codec: the HDA codec
340 * @listp: the pointer to store NID list
342 * Parses the connection list of the given widget and stores the list
345 * Returns the number of connections, or a negative error code.
347 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
348 const hda_nid_t **listp)
350 struct snd_array *array = &codec->conn_lists;
352 hda_nid_t list[HDA_MAX_CONNECTIONS];
357 /* if the connection-list is already cached, read it */
358 p = lookup_conn_list(array, nid);
364 if (snd_BUG_ON(added))
367 /* read the connection and add to the cache */
368 len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
371 err = snd_hda_override_conn_list(codec, nid, len, list);
377 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
380 * snd_hda_get_connections - copy connection list
381 * @codec: the HDA codec
383 * @conn_list: connection list array
384 * @max_conns: max. number of connections to store
386 * Parses the connection list of the given widget and stores the list
389 * Returns the number of connections, or a negative error code.
391 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
392 hda_nid_t *conn_list, int max_conns)
394 const hda_nid_t *list;
395 int len = snd_hda_get_conn_list(codec, nid, &list);
399 if (len > max_conns) {
400 snd_printk(KERN_ERR "hda_codec: "
401 "Too many connections %d for NID 0x%x\n",
405 memcpy(conn_list, list, len * sizeof(hda_nid_t));
408 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
411 * snd_hda_get_raw_connections - copy connection list without cache
412 * @codec: the HDA codec
414 * @conn_list: connection list array
415 * @max_conns: max. number of connections to store
417 * Like snd_hda_get_connections(), copy the connection list but without
418 * checking through the connection-list cache.
419 * Currently called only from hda_proc.c, so not exported.
421 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
422 hda_nid_t *conn_list, int max_conns)
425 int i, conn_len, conns;
426 unsigned int shift, num_elems, mask;
430 if (snd_BUG_ON(!conn_list || max_conns <= 0))
433 wcaps = get_wcaps(codec, nid);
434 if (!(wcaps & AC_WCAP_CONN_LIST) &&
435 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
438 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
439 if (parm & AC_CLIST_LONG) {
448 conn_len = parm & AC_CLIST_LENGTH;
449 mask = (1 << (shift-1)) - 1;
452 return 0; /* no connection */
455 /* single connection */
456 parm = snd_hda_codec_read(codec, nid, 0,
457 AC_VERB_GET_CONNECT_LIST, 0);
458 if (parm == -1 && codec->bus->rirb_error)
460 conn_list[0] = parm & mask;
464 /* multi connection */
467 for (i = 0; i < conn_len; i++) {
471 if (i % num_elems == 0) {
472 parm = snd_hda_codec_read(codec, nid, 0,
473 AC_VERB_GET_CONNECT_LIST, i);
474 if (parm == -1 && codec->bus->rirb_error)
477 range_val = !!(parm & (1 << (shift-1))); /* ranges */
480 snd_printk(KERN_WARNING "hda_codec: "
481 "invalid CONNECT_LIST verb %x[%i]:%x\n",
487 /* ranges between the previous and this one */
488 if (!prev_nid || prev_nid >= val) {
489 snd_printk(KERN_WARNING "hda_codec: "
490 "invalid dep_range_val %x:%x\n",
494 for (n = prev_nid + 1; n <= val; n++) {
495 if (conns >= max_conns) {
496 snd_printk(KERN_ERR "hda_codec: "
497 "Too many connections %d for NID 0x%x\n",
501 conn_list[conns++] = n;
504 if (conns >= max_conns) {
505 snd_printk(KERN_ERR "hda_codec: "
506 "Too many connections %d for NID 0x%x\n",
510 conn_list[conns++] = val;
517 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
519 hda_nid_t *p = snd_array_new(array);
527 * snd_hda_override_conn_list - add/modify the connection-list to cache
528 * @codec: the HDA codec
530 * @len: number of connection list entries
531 * @list: the list of connection entries
533 * Add or modify the given connection-list to the cache. If the corresponding
534 * cache already exists, invalidate it and append a new one.
536 * Returns zero or a negative error code.
538 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
539 const hda_nid_t *list)
541 struct snd_array *array = &codec->conn_lists;
545 p = lookup_conn_list(array, nid);
547 *p = -1; /* invalidate the old entry */
549 old_used = array->used;
550 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
552 for (i = 0; i < len; i++)
553 if (!add_conn_list(array, list[i]))
558 array->used = old_used;
561 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
564 * snd_hda_get_conn_index - get the connection index of the given NID
565 * @codec: the HDA codec
566 * @mux: NID containing the list
567 * @nid: NID to select
568 * @recursive: 1 when searching NID recursively, otherwise 0
570 * Parses the connection list of the widget @mux and checks whether the
571 * widget @nid is present. If it is, return the connection index.
572 * Otherwise it returns -1.
574 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
575 hda_nid_t nid, int recursive)
577 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
580 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
581 for (i = 0; i < nums; i++)
587 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
591 for (i = 0; i < nums; i++) {
592 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
593 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
595 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
600 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
603 * snd_hda_queue_unsol_event - add an unsolicited event to queue
605 * @res: unsolicited event (lower 32bit of RIRB entry)
606 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
608 * Adds the given event to the queue. The events are processed in
609 * the workqueue asynchronously. Call this function in the interrupt
610 * hanlder when RIRB receives an unsolicited event.
612 * Returns 0 if successful, or a negative error code.
614 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
616 struct hda_bus_unsolicited *unsol;
619 trace_hda_unsol_event(bus, res, res_ex);
624 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
628 unsol->queue[wp] = res;
629 unsol->queue[wp + 1] = res_ex;
631 queue_work(bus->workq, &unsol->work);
635 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
638 * process queued unsolicited events
640 static void process_unsol_events(struct work_struct *work)
642 struct hda_bus_unsolicited *unsol =
643 container_of(work, struct hda_bus_unsolicited, work);
644 struct hda_bus *bus = unsol->bus;
645 struct hda_codec *codec;
646 unsigned int rp, caddr, res;
648 while (unsol->rp != unsol->wp) {
649 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
652 res = unsol->queue[rp];
653 caddr = unsol->queue[rp + 1];
654 if (!(caddr & (1 << 4))) /* no unsolicited event? */
656 codec = bus->caddr_tbl[caddr & 0x0f];
657 if (codec && codec->patch_ops.unsol_event)
658 codec->patch_ops.unsol_event(codec, res);
663 * initialize unsolicited queue
665 static int init_unsol_queue(struct hda_bus *bus)
667 struct hda_bus_unsolicited *unsol;
669 if (bus->unsol) /* already initialized */
672 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
674 snd_printk(KERN_ERR "hda_codec: "
675 "can't allocate unsolicited queue\n");
678 INIT_WORK(&unsol->work, process_unsol_events);
687 static void snd_hda_codec_free(struct hda_codec *codec);
689 static int snd_hda_bus_free(struct hda_bus *bus)
691 struct hda_codec *codec, *n;
696 flush_workqueue(bus->workq);
699 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
700 snd_hda_codec_free(codec);
702 if (bus->ops.private_free)
703 bus->ops.private_free(bus);
705 destroy_workqueue(bus->workq);
710 static int snd_hda_bus_dev_free(struct snd_device *device)
712 struct hda_bus *bus = device->device_data;
714 return snd_hda_bus_free(bus);
717 #ifdef CONFIG_SND_HDA_HWDEP
718 static int snd_hda_bus_dev_register(struct snd_device *device)
720 struct hda_bus *bus = device->device_data;
721 struct hda_codec *codec;
722 list_for_each_entry(codec, &bus->codec_list, list) {
723 snd_hda_hwdep_add_sysfs(codec);
724 snd_hda_hwdep_add_power_sysfs(codec);
729 #define snd_hda_bus_dev_register NULL
733 * snd_hda_bus_new - create a HDA bus
734 * @card: the card entry
735 * @temp: the template for hda_bus information
736 * @busp: the pointer to store the created bus instance
738 * Returns 0 if successful, or a negative error code.
740 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
741 const struct hda_bus_template *temp,
742 struct hda_bus **busp)
746 static struct snd_device_ops dev_ops = {
747 .dev_register = snd_hda_bus_dev_register,
748 .dev_free = snd_hda_bus_dev_free,
751 if (snd_BUG_ON(!temp))
753 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
759 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
761 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
766 bus->private_data = temp->private_data;
767 bus->pci = temp->pci;
768 bus->modelname = temp->modelname;
769 bus->power_save = temp->power_save;
770 bus->ops = temp->ops;
772 mutex_init(&bus->cmd_mutex);
773 mutex_init(&bus->prepare_mutex);
774 INIT_LIST_HEAD(&bus->codec_list);
776 snprintf(bus->workq_name, sizeof(bus->workq_name),
777 "hd-audio%d", card->number);
778 bus->workq = create_singlethread_workqueue(bus->workq_name);
780 snd_printk(KERN_ERR "cannot create workqueue %s\n",
786 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
788 snd_hda_bus_free(bus);
795 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
797 #ifdef CONFIG_SND_HDA_GENERIC
798 #define is_generic_config(codec) \
799 (codec->modelname && !strcmp(codec->modelname, "generic"))
801 #define is_generic_config(codec) 0
805 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
807 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
811 * find a matching codec preset
813 static const struct hda_codec_preset *
814 find_codec_preset(struct hda_codec *codec)
816 struct hda_codec_preset_list *tbl;
817 const struct hda_codec_preset *preset;
818 int mod_requested = 0;
820 if (is_generic_config(codec))
821 return NULL; /* use the generic parser */
824 mutex_lock(&preset_mutex);
825 list_for_each_entry(tbl, &hda_preset_tables, list) {
826 if (!try_module_get(tbl->owner)) {
827 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
830 for (preset = tbl->preset; preset->id; preset++) {
831 u32 mask = preset->mask;
832 if (preset->afg && preset->afg != codec->afg)
834 if (preset->mfg && preset->mfg != codec->mfg)
838 if (preset->id == (codec->vendor_id & mask) &&
840 preset->rev == codec->revision_id)) {
841 mutex_unlock(&preset_mutex);
842 codec->owner = tbl->owner;
846 module_put(tbl->owner);
848 mutex_unlock(&preset_mutex);
850 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
853 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
856 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
857 (codec->vendor_id >> 16) & 0xffff);
858 request_module(name);
866 * get_codec_name - store the codec name
868 static int get_codec_name(struct hda_codec *codec)
870 const struct hda_vendor_id *c;
871 const char *vendor = NULL;
872 u16 vendor_id = codec->vendor_id >> 16;
875 if (codec->vendor_name)
878 for (c = hda_vendor_ids; c->id; c++) {
879 if (c->id == vendor_id) {
885 sprintf(tmp, "Generic %04x", vendor_id);
888 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
889 if (!codec->vendor_name)
893 if (codec->chip_name)
896 if (codec->preset && codec->preset->name)
897 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
899 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
900 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
902 if (!codec->chip_name)
908 * look for an AFG and MFG nodes
910 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
912 int i, total_nodes, function_id;
915 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
916 for (i = 0; i < total_nodes; i++, nid++) {
917 function_id = snd_hda_param_read(codec, nid,
918 AC_PAR_FUNCTION_TYPE);
919 switch (function_id & 0xff) {
920 case AC_GRP_AUDIO_FUNCTION:
922 codec->afg_function_id = function_id & 0xff;
923 codec->afg_unsol = (function_id >> 8) & 1;
925 case AC_GRP_MODEM_FUNCTION:
927 codec->mfg_function_id = function_id & 0xff;
928 codec->mfg_unsol = (function_id >> 8) & 1;
937 * read widget caps for each widget and store in cache
939 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
944 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
946 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
949 nid = codec->start_nid;
950 for (i = 0; i < codec->num_nodes; i++, nid++)
951 codec->wcaps[i] = snd_hda_param_read(codec, nid,
952 AC_PAR_AUDIO_WIDGET_CAP);
956 /* read all pin default configurations and save codec->init_pins */
957 static int read_pin_defaults(struct hda_codec *codec)
960 hda_nid_t nid = codec->start_nid;
962 for (i = 0; i < codec->num_nodes; i++, nid++) {
963 struct hda_pincfg *pin;
964 unsigned int wcaps = get_wcaps(codec, nid);
965 unsigned int wid_type = get_wcaps_type(wcaps);
966 if (wid_type != AC_WID_PIN)
968 pin = snd_array_new(&codec->init_pins);
972 pin->cfg = snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_CONFIG_DEFAULT, 0);
974 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
975 AC_VERB_GET_PIN_WIDGET_CONTROL,
981 /* look up the given pin config list and return the item matching with NID */
982 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
983 struct snd_array *array,
987 for (i = 0; i < array->used; i++) {
988 struct hda_pincfg *pin = snd_array_elem(array, i);
995 /* write a config value for the given NID */
996 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
1000 for (i = 0; i < 4; i++) {
1001 snd_hda_codec_write(codec, nid, 0,
1002 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1008 /* set the current pin config value for the given NID.
1009 * the value is cached, and read via snd_hda_codec_get_pincfg()
1011 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1012 hda_nid_t nid, unsigned int cfg)
1014 struct hda_pincfg *pin;
1015 unsigned int oldcfg;
1017 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1020 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
1021 pin = look_up_pincfg(codec, list, nid);
1023 pin = snd_array_new(list);
1030 /* change only when needed; e.g. if the pincfg is already present
1031 * in user_pins[], don't write it
1033 cfg = snd_hda_codec_get_pincfg(codec, nid);
1035 set_pincfg(codec, nid, cfg);
1040 * snd_hda_codec_set_pincfg - Override a pin default configuration
1041 * @codec: the HDA codec
1042 * @nid: NID to set the pin config
1043 * @cfg: the pin default config value
1045 * Override a pin default configuration value in the cache.
1046 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1047 * priority than the real hardware value.
1049 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1050 hda_nid_t nid, unsigned int cfg)
1052 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1054 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1057 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1058 * @codec: the HDA codec
1059 * @nid: NID to get the pin config
1061 * Get the current pin config value of the given pin NID.
1062 * If the pincfg value is cached or overridden via sysfs or driver,
1063 * returns the cached value.
1065 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1067 struct hda_pincfg *pin;
1069 #ifdef CONFIG_SND_HDA_HWDEP
1070 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1074 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1077 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1082 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1084 /* restore all current pin configs */
1085 static void restore_pincfgs(struct hda_codec *codec)
1088 for (i = 0; i < codec->init_pins.used; i++) {
1089 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1090 set_pincfg(codec, pin->nid,
1091 snd_hda_codec_get_pincfg(codec, pin->nid));
1096 * snd_hda_shutup_pins - Shut up all pins
1097 * @codec: the HDA codec
1099 * Clear all pin controls to shup up before suspend for avoiding click noise.
1100 * The controls aren't cached so that they can be resumed properly.
1102 void snd_hda_shutup_pins(struct hda_codec *codec)
1105 /* don't shut up pins when unloading the driver; otherwise it breaks
1106 * the default pin setup at the next load of the driver
1108 if (codec->bus->shutdown)
1110 for (i = 0; i < codec->init_pins.used; i++) {
1111 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1112 /* use read here for syncing after issuing each verb */
1113 snd_hda_codec_read(codec, pin->nid, 0,
1114 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1116 codec->pins_shutup = 1;
1118 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1121 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1122 static void restore_shutup_pins(struct hda_codec *codec)
1125 if (!codec->pins_shutup)
1127 if (codec->bus->shutdown)
1129 for (i = 0; i < codec->init_pins.used; i++) {
1130 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1131 snd_hda_codec_write(codec, pin->nid, 0,
1132 AC_VERB_SET_PIN_WIDGET_CONTROL,
1135 codec->pins_shutup = 0;
1139 static void init_hda_cache(struct hda_cache_rec *cache,
1140 unsigned int record_size);
1141 static void free_hda_cache(struct hda_cache_rec *cache);
1143 /* restore the initial pin cfgs and release all pincfg lists */
1144 static void restore_init_pincfgs(struct hda_codec *codec)
1146 /* first free driver_pins and user_pins, then call restore_pincfg
1147 * so that only the values in init_pins are restored
1149 snd_array_free(&codec->driver_pins);
1150 #ifdef CONFIG_SND_HDA_HWDEP
1151 snd_array_free(&codec->user_pins);
1153 restore_pincfgs(codec);
1154 snd_array_free(&codec->init_pins);
1158 * audio-converter setup caches
1160 struct hda_cvt_setup {
1165 unsigned char active; /* cvt is currently used */
1166 unsigned char dirty; /* setups should be cleared */
1169 /* get or create a cache entry for the given audio converter NID */
1170 static struct hda_cvt_setup *
1171 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1173 struct hda_cvt_setup *p;
1176 for (i = 0; i < codec->cvt_setups.used; i++) {
1177 p = snd_array_elem(&codec->cvt_setups, i);
1181 p = snd_array_new(&codec->cvt_setups);
1190 static void snd_hda_codec_free(struct hda_codec *codec)
1194 restore_init_pincfgs(codec);
1195 #ifdef CONFIG_SND_HDA_POWER_SAVE
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->conn_lists);
1203 snd_array_free(&codec->spdif_out);
1204 codec->bus->caddr_tbl[codec->addr] = NULL;
1205 if (codec->patch_ops.free)
1206 codec->patch_ops.free(codec);
1207 module_put(codec->owner);
1208 free_hda_cache(&codec->amp_cache);
1209 free_hda_cache(&codec->cmd_cache);
1210 kfree(codec->vendor_name);
1211 kfree(codec->chip_name);
1212 kfree(codec->modelname);
1213 kfree(codec->wcaps);
1217 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1218 unsigned int power_state);
1221 * snd_hda_codec_new - create a HDA codec
1222 * @bus: the bus to assign
1223 * @codec_addr: the codec address
1224 * @codecp: the pointer to store the generated codec
1226 * Returns 0 if successful, or a negative error code.
1228 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1229 unsigned int codec_addr,
1230 struct hda_codec **codecp)
1232 struct hda_codec *codec;
1236 if (snd_BUG_ON(!bus))
1238 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1241 if (bus->caddr_tbl[codec_addr]) {
1242 snd_printk(KERN_ERR "hda_codec: "
1243 "address 0x%x is already occupied\n", codec_addr);
1247 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1248 if (codec == NULL) {
1249 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1254 codec->addr = codec_addr;
1255 mutex_init(&codec->spdif_mutex);
1256 mutex_init(&codec->control_mutex);
1257 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1258 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1259 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1260 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1261 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1262 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1263 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1264 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1265 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1266 if (codec->bus->modelname) {
1267 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1268 if (!codec->modelname) {
1269 snd_hda_codec_free(codec);
1274 #ifdef CONFIG_SND_HDA_POWER_SAVE
1275 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1276 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1277 * the caller has to power down appropriatley after initialization
1280 hda_keep_power_on(codec);
1283 list_add_tail(&codec->list, &bus->codec_list);
1284 bus->caddr_tbl[codec_addr] = codec;
1286 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1288 if (codec->vendor_id == -1)
1289 /* read again, hopefully the access method was corrected
1290 * in the last read...
1292 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1294 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1295 AC_PAR_SUBSYSTEM_ID);
1296 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1299 setup_fg_nodes(codec);
1300 if (!codec->afg && !codec->mfg) {
1301 snd_printdd("hda_codec: no AFG or MFG node found\n");
1306 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1308 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1311 err = read_pin_defaults(codec);
1315 if (!codec->subsystem_id) {
1316 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1317 codec->subsystem_id =
1318 snd_hda_codec_read(codec, nid, 0,
1319 AC_VERB_GET_SUBSYSTEM_ID, 0);
1322 /* power-up all before initialization */
1323 hda_set_power_state(codec,
1324 codec->afg ? codec->afg : codec->mfg,
1327 snd_hda_codec_proc_new(codec);
1329 snd_hda_create_hwdep(codec);
1331 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1332 codec->subsystem_id, codec->revision_id);
1333 snd_component_add(codec->bus->card, component);
1340 snd_hda_codec_free(codec);
1343 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1346 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1347 * @codec: the HDA codec
1349 * Start parsing of the given codec tree and (re-)initialize the whole
1352 * Returns 0 if successful or a negative error code.
1354 int snd_hda_codec_configure(struct hda_codec *codec)
1358 codec->preset = find_codec_preset(codec);
1359 if (!codec->vendor_name || !codec->chip_name) {
1360 err = get_codec_name(codec);
1365 if (is_generic_config(codec)) {
1366 err = snd_hda_parse_generic_codec(codec);
1369 if (codec->preset && codec->preset->patch) {
1370 err = codec->preset->patch(codec);
1374 /* call the default parser */
1375 err = snd_hda_parse_generic_codec(codec);
1377 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1380 if (!err && codec->patch_ops.unsol_event)
1381 err = init_unsol_queue(codec->bus);
1382 /* audio codec should override the mixer name */
1383 if (!err && (codec->afg || !*codec->bus->card->mixername))
1384 snprintf(codec->bus->card->mixername,
1385 sizeof(codec->bus->card->mixername),
1386 "%s %s", codec->vendor_name, codec->chip_name);
1389 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1392 * snd_hda_codec_setup_stream - set up the codec for streaming
1393 * @codec: the CODEC to set up
1394 * @nid: the NID to set up
1395 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1396 * @channel_id: channel id to pass, zero based.
1397 * @format: stream format.
1399 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1401 int channel_id, int format)
1403 struct hda_codec *c;
1404 struct hda_cvt_setup *p;
1405 unsigned int oldval, newval;
1412 snd_printdd("hda_codec_setup_stream: "
1413 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1414 nid, stream_tag, channel_id, format);
1415 p = get_hda_cvt_setup(codec, nid);
1418 /* update the stream-id if changed */
1419 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1420 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1421 newval = (stream_tag << 4) | channel_id;
1422 if (oldval != newval)
1423 snd_hda_codec_write(codec, nid, 0,
1424 AC_VERB_SET_CHANNEL_STREAMID,
1426 p->stream_tag = stream_tag;
1427 p->channel_id = channel_id;
1429 /* update the format-id if changed */
1430 if (p->format_id != format) {
1431 oldval = snd_hda_codec_read(codec, nid, 0,
1432 AC_VERB_GET_STREAM_FORMAT, 0);
1433 if (oldval != format) {
1435 snd_hda_codec_write(codec, nid, 0,
1436 AC_VERB_SET_STREAM_FORMAT,
1439 p->format_id = format;
1444 /* make other inactive cvts with the same stream-tag dirty */
1445 type = get_wcaps_type(get_wcaps(codec, nid));
1446 list_for_each_entry(c, &codec->bus->codec_list, list) {
1447 for (i = 0; i < c->cvt_setups.used; i++) {
1448 p = snd_array_elem(&c->cvt_setups, i);
1449 if (!p->active && p->stream_tag == stream_tag &&
1450 get_wcaps_type(get_wcaps(codec, p->nid)) == type)
1455 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1457 static void really_cleanup_stream(struct hda_codec *codec,
1458 struct hda_cvt_setup *q);
1461 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1462 * @codec: the CODEC to clean up
1463 * @nid: the NID to clean up
1464 * @do_now: really clean up the stream instead of clearing the active flag
1466 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1469 struct hda_cvt_setup *p;
1474 if (codec->no_sticky_stream)
1477 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1478 p = get_hda_cvt_setup(codec, nid);
1480 /* here we just clear the active flag when do_now isn't set;
1481 * actual clean-ups will be done later in
1482 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1485 really_cleanup_stream(codec, p);
1490 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1492 static void really_cleanup_stream(struct hda_codec *codec,
1493 struct hda_cvt_setup *q)
1495 hda_nid_t nid = q->nid;
1496 if (q->stream_tag || q->channel_id)
1497 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1499 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1501 memset(q, 0, sizeof(*q));
1505 /* clean up the all conflicting obsolete streams */
1506 static void purify_inactive_streams(struct hda_codec *codec)
1508 struct hda_codec *c;
1511 list_for_each_entry(c, &codec->bus->codec_list, list) {
1512 for (i = 0; i < c->cvt_setups.used; i++) {
1513 struct hda_cvt_setup *p;
1514 p = snd_array_elem(&c->cvt_setups, i);
1516 really_cleanup_stream(c, p);
1522 /* clean up all streams; called from suspend */
1523 static void hda_cleanup_all_streams(struct hda_codec *codec)
1527 for (i = 0; i < codec->cvt_setups.used; i++) {
1528 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1530 really_cleanup_stream(codec, p);
1536 * amp access functions
1539 /* FIXME: more better hash key? */
1540 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1541 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1542 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1543 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1544 #define INFO_AMP_CAPS (1<<0)
1545 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1547 /* initialize the hash table */
1548 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1549 unsigned int record_size)
1551 memset(cache, 0, sizeof(*cache));
1552 memset(cache->hash, 0xff, sizeof(cache->hash));
1553 snd_array_init(&cache->buf, record_size, 64);
1556 static void free_hda_cache(struct hda_cache_rec *cache)
1558 snd_array_free(&cache->buf);
1561 /* query the hash. allocate an entry if not found. */
1562 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1564 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1565 u16 cur = cache->hash[idx];
1566 struct hda_cache_head *info;
1568 while (cur != 0xffff) {
1569 info = snd_array_elem(&cache->buf, cur);
1570 if (info->key == key)
1577 /* query the hash. allocate an entry if not found. */
1578 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1581 struct hda_cache_head *info = get_hash(cache, key);
1584 /* add a new hash entry */
1585 info = snd_array_new(&cache->buf);
1588 cur = snd_array_index(&cache->buf, info);
1591 idx = key % (u16)ARRAY_SIZE(cache->hash);
1592 info->next = cache->hash[idx];
1593 cache->hash[idx] = cur;
1598 /* query and allocate an amp hash entry */
1599 static inline struct hda_amp_info *
1600 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1602 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1606 * query_amp_caps - query AMP capabilities
1607 * @codec: the HD-auio codec
1608 * @nid: the NID to query
1609 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1611 * Query AMP capabilities for the given widget and direction.
1612 * Returns the obtained capability bits.
1614 * When cap bits have been already read, this doesn't read again but
1615 * returns the cached value.
1617 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1619 struct hda_amp_info *info;
1621 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1624 if (!(info->head.val & INFO_AMP_CAPS)) {
1625 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1627 info->amp_caps = snd_hda_param_read(codec, nid,
1628 direction == HDA_OUTPUT ?
1629 AC_PAR_AMP_OUT_CAP :
1632 info->head.val |= INFO_AMP_CAPS;
1634 return info->amp_caps;
1636 EXPORT_SYMBOL_HDA(query_amp_caps);
1639 * snd_hda_override_amp_caps - Override the AMP capabilities
1640 * @codec: the CODEC to clean up
1641 * @nid: the NID to clean up
1642 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1643 * @caps: the capability bits to set
1645 * Override the cached AMP caps bits value by the given one.
1646 * This function is useful if the driver needs to adjust the AMP ranges,
1647 * e.g. limit to 0dB, etc.
1649 * Returns zero if successful or a negative error code.
1651 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1654 struct hda_amp_info *info;
1656 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1659 info->amp_caps = caps;
1660 info->head.val |= INFO_AMP_CAPS;
1663 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1666 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1667 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1669 struct hda_amp_info *info;
1671 info = get_alloc_amp_hash(codec, key);
1674 if (!info->head.val) {
1675 info->head.val |= INFO_AMP_CAPS;
1676 info->amp_caps = func(codec, nid);
1678 return info->amp_caps;
1681 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1683 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1687 * snd_hda_query_pin_caps - Query PIN capabilities
1688 * @codec: the HD-auio codec
1689 * @nid: the NID to query
1691 * Query PIN capabilities for the given widget.
1692 * Returns the obtained capability bits.
1694 * When cap bits have been already read, this doesn't read again but
1695 * returns the cached value.
1697 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1699 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1702 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1705 * snd_hda_override_pin_caps - Override the pin capabilities
1707 * @nid: the NID to override
1708 * @caps: the capability bits to set
1710 * Override the cached PIN capabilitiy bits value by the given one.
1712 * Returns zero if successful or a negative error code.
1714 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1717 struct hda_amp_info *info;
1718 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1721 info->amp_caps = caps;
1722 info->head.val |= INFO_AMP_CAPS;
1725 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1728 * read the current volume to info
1729 * if the cache exists, read the cache value.
1731 static unsigned int get_vol_mute(struct hda_codec *codec,
1732 struct hda_amp_info *info, hda_nid_t nid,
1733 int ch, int direction, int index)
1737 if (info->head.val & INFO_AMP_VOL(ch))
1738 return info->vol[ch];
1740 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1741 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1743 val = snd_hda_codec_read(codec, nid, 0,
1744 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1745 info->vol[ch] = val & 0xff;
1746 info->head.val |= INFO_AMP_VOL(ch);
1747 return info->vol[ch];
1751 * write the current volume in info to the h/w and update the cache
1753 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1754 hda_nid_t nid, int ch, int direction, int index,
1759 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1760 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1761 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1763 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1764 info->vol[ch] = val;
1768 * snd_hda_codec_amp_read - Read AMP value
1769 * @codec: HD-audio codec
1770 * @nid: NID to read the AMP value
1771 * @ch: channel (left=0 or right=1)
1772 * @direction: #HDA_INPUT or #HDA_OUTPUT
1773 * @index: the index value (only for input direction)
1775 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1777 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1778 int direction, int index)
1780 struct hda_amp_info *info;
1781 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1784 return get_vol_mute(codec, info, nid, ch, direction, index);
1786 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1789 * snd_hda_codec_amp_update - update the AMP value
1790 * @codec: HD-audio codec
1791 * @nid: NID to read the AMP value
1792 * @ch: channel (left=0 or right=1)
1793 * @direction: #HDA_INPUT or #HDA_OUTPUT
1794 * @idx: the index value (only for input direction)
1795 * @mask: bit mask to set
1796 * @val: the bits value to set
1798 * Update the AMP value with a bit mask.
1799 * Returns 0 if the value is unchanged, 1 if changed.
1801 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1802 int direction, int idx, int mask, int val)
1804 struct hda_amp_info *info;
1806 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1809 if (snd_BUG_ON(mask & ~0xff))
1812 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1813 if (info->vol[ch] == val)
1815 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1818 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1821 * snd_hda_codec_amp_stereo - update the AMP stereo values
1822 * @codec: HD-audio codec
1823 * @nid: NID to read the AMP value
1824 * @direction: #HDA_INPUT or #HDA_OUTPUT
1825 * @idx: the index value (only for input direction)
1826 * @mask: bit mask to set
1827 * @val: the bits value to set
1829 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1830 * stereo widget with the same mask and value.
1832 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1833 int direction, int idx, int mask, int val)
1837 if (snd_BUG_ON(mask & ~0xff))
1839 for (ch = 0; ch < 2; ch++)
1840 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1844 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1848 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1849 * @codec: HD-audio codec
1851 * Resume the all amp commands from the cache.
1853 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1855 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1858 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1859 u32 key = buffer->head.key;
1861 unsigned int idx, dir, ch;
1865 idx = (key >> 16) & 0xff;
1866 dir = (key >> 24) & 0xff;
1867 for (ch = 0; ch < 2; ch++) {
1868 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1870 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1875 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1876 #endif /* CONFIG_PM */
1878 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1881 u32 caps = query_amp_caps(codec, nid, dir);
1883 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1890 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1892 * The control element is supposed to have the private_value field
1893 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1895 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_info *uinfo)
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1899 u16 nid = get_amp_nid(kcontrol);
1900 u8 chs = get_amp_channels(kcontrol);
1901 int dir = get_amp_direction(kcontrol);
1902 unsigned int ofs = get_amp_offset(kcontrol);
1904 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1905 uinfo->count = chs == 3 ? 2 : 1;
1906 uinfo->value.integer.min = 0;
1907 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1908 if (!uinfo->value.integer.max) {
1909 printk(KERN_WARNING "hda_codec: "
1910 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1916 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1919 static inline unsigned int
1920 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1921 int ch, int dir, int idx, unsigned int ofs)
1924 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1925 val &= HDA_AMP_VOLMASK;
1934 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1935 int ch, int dir, int idx, unsigned int ofs,
1938 unsigned int maxval;
1942 /* ofs = 0: raw max value */
1943 maxval = get_amp_max_value(codec, nid, dir, 0);
1946 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1947 HDA_AMP_VOLMASK, val);
1951 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1953 * The control element is supposed to have the private_value field
1954 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1956 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1957 struct snd_ctl_elem_value *ucontrol)
1959 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1960 hda_nid_t nid = get_amp_nid(kcontrol);
1961 int chs = get_amp_channels(kcontrol);
1962 int dir = get_amp_direction(kcontrol);
1963 int idx = get_amp_index(kcontrol);
1964 unsigned int ofs = get_amp_offset(kcontrol);
1965 long *valp = ucontrol->value.integer.value;
1968 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1970 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1973 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1976 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1978 * The control element is supposed to have the private_value field
1979 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1981 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1982 struct snd_ctl_elem_value *ucontrol)
1984 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1985 hda_nid_t nid = get_amp_nid(kcontrol);
1986 int chs = get_amp_channels(kcontrol);
1987 int dir = get_amp_direction(kcontrol);
1988 int idx = get_amp_index(kcontrol);
1989 unsigned int ofs = get_amp_offset(kcontrol);
1990 long *valp = ucontrol->value.integer.value;
1993 snd_hda_power_up(codec);
1995 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1999 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2000 snd_hda_power_down(codec);
2003 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2006 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2008 * The control element is supposed to have the private_value field
2009 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2011 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2012 unsigned int size, unsigned int __user *_tlv)
2014 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2015 hda_nid_t nid = get_amp_nid(kcontrol);
2016 int dir = get_amp_direction(kcontrol);
2017 unsigned int ofs = get_amp_offset(kcontrol);
2018 bool min_mute = get_amp_min_mute(kcontrol);
2019 u32 caps, val1, val2;
2021 if (size < 4 * sizeof(unsigned int))
2023 caps = query_amp_caps(codec, nid, dir);
2024 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2025 val2 = (val2 + 1) * 25;
2026 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2028 val1 = ((int)val1) * ((int)val2);
2030 val2 |= TLV_DB_SCALE_MUTE;
2031 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2033 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2035 if (put_user(val1, _tlv + 2))
2037 if (put_user(val2, _tlv + 3))
2041 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2044 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2045 * @codec: HD-audio codec
2046 * @nid: NID of a reference widget
2047 * @dir: #HDA_INPUT or #HDA_OUTPUT
2048 * @tlv: TLV data to be stored, at least 4 elements
2050 * Set (static) TLV data for a virtual master volume using the AMP caps
2051 * obtained from the reference NID.
2052 * The volume range is recalculated as if the max volume is 0dB.
2054 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2060 caps = query_amp_caps(codec, nid, dir);
2061 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2062 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2063 step = (step + 1) * 25;
2064 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2065 tlv[1] = 2 * sizeof(unsigned int);
2066 tlv[2] = -nums * step;
2069 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2071 /* find a mixer control element with the given name */
2072 static struct snd_kcontrol *
2073 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2074 const char *name, int idx)
2076 struct snd_ctl_elem_id id;
2077 memset(&id, 0, sizeof(id));
2078 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2080 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2082 strcpy(id.name, name);
2083 return snd_ctl_find_id(codec->bus->card, &id);
2087 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2088 * @codec: HD-audio codec
2089 * @name: ctl id name string
2091 * Get the control element with the given id string and IFACE_MIXER.
2093 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2096 return _snd_hda_find_mixer_ctl(codec, name, 0);
2098 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2100 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2103 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2104 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2111 * snd_hda_ctl_add - Add a control element and assign to the codec
2112 * @codec: HD-audio codec
2113 * @nid: corresponding NID (optional)
2114 * @kctl: the control element to assign
2116 * Add the given control element to an array inside the codec instance.
2117 * All control elements belonging to a codec are supposed to be added
2118 * by this function so that a proper clean-up works at the free or
2119 * reconfiguration time.
2121 * If non-zero @nid is passed, the NID is assigned to the control element.
2122 * The assignment is shown in the codec proc file.
2124 * snd_hda_ctl_add() checks the control subdev id field whether
2125 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2126 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2127 * specifies if kctl->private_value is a HDA amplifier value.
2129 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2130 struct snd_kcontrol *kctl)
2133 unsigned short flags = 0;
2134 struct hda_nid_item *item;
2136 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2137 flags |= HDA_NID_ITEM_AMP;
2139 nid = get_amp_nid_(kctl->private_value);
2141 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2142 nid = kctl->id.subdevice & 0xffff;
2143 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2144 kctl->id.subdevice = 0;
2145 err = snd_ctl_add(codec->bus->card, kctl);
2148 item = snd_array_new(&codec->mixers);
2153 item->flags = flags;
2156 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2159 * snd_hda_add_nid - Assign a NID to a control element
2160 * @codec: HD-audio codec
2161 * @nid: corresponding NID (optional)
2162 * @kctl: the control element to assign
2163 * @index: index to kctl
2165 * Add the given control element to an array inside the codec instance.
2166 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2167 * NID:KCTL mapping - for example "Capture Source" selector.
2169 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2170 unsigned int index, hda_nid_t nid)
2172 struct hda_nid_item *item;
2175 item = snd_array_new(&codec->nids);
2179 item->index = index;
2183 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2184 kctl->id.name, kctl->id.index, index);
2187 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2190 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2191 * @codec: HD-audio codec
2193 void snd_hda_ctls_clear(struct hda_codec *codec)
2196 struct hda_nid_item *items = codec->mixers.list;
2197 for (i = 0; i < codec->mixers.used; i++)
2198 snd_ctl_remove(codec->bus->card, items[i].kctl);
2199 snd_array_free(&codec->mixers);
2200 snd_array_free(&codec->nids);
2203 /* pseudo device locking
2204 * toggle card->shutdown to allow/disallow the device access (as a hack)
2206 static int hda_lock_devices(struct snd_card *card)
2208 spin_lock(&card->files_lock);
2209 if (card->shutdown) {
2210 spin_unlock(&card->files_lock);
2214 spin_unlock(&card->files_lock);
2218 static void hda_unlock_devices(struct snd_card *card)
2220 spin_lock(&card->files_lock);
2222 spin_unlock(&card->files_lock);
2226 * snd_hda_codec_reset - Clear all objects assigned to the codec
2227 * @codec: HD-audio codec
2229 * This frees the all PCM and control elements assigned to the codec, and
2230 * clears the caches and restores the pin default configurations.
2232 * When a device is being used, it returns -EBSY. If successfully freed,
2235 int snd_hda_codec_reset(struct hda_codec *codec)
2237 struct snd_card *card = codec->bus->card;
2240 if (hda_lock_devices(card) < 0)
2242 /* check whether the codec isn't used by any mixer or PCM streams */
2243 if (!list_empty(&card->ctl_files)) {
2244 hda_unlock_devices(card);
2247 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2248 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2251 if (cpcm->pcm->streams[0].substream_opened ||
2252 cpcm->pcm->streams[1].substream_opened) {
2253 hda_unlock_devices(card);
2258 /* OK, let it free */
2260 #ifdef CONFIG_SND_HDA_POWER_SAVE
2261 cancel_delayed_work(&codec->power_work);
2262 flush_workqueue(codec->bus->workq);
2264 snd_hda_ctls_clear(codec);
2266 for (i = 0; i < codec->num_pcms; i++) {
2267 if (codec->pcm_info[i].pcm) {
2268 snd_device_free(card, codec->pcm_info[i].pcm);
2269 clear_bit(codec->pcm_info[i].device,
2270 codec->bus->pcm_dev_bits);
2273 if (codec->patch_ops.free)
2274 codec->patch_ops.free(codec);
2275 snd_hda_jack_tbl_clear(codec);
2276 codec->proc_widget_hook = NULL;
2278 free_hda_cache(&codec->amp_cache);
2279 free_hda_cache(&codec->cmd_cache);
2280 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2281 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2282 /* free only driver_pins so that init_pins + user_pins are restored */
2283 snd_array_free(&codec->driver_pins);
2284 restore_pincfgs(codec);
2285 codec->num_pcms = 0;
2286 codec->pcm_info = NULL;
2287 codec->preset = NULL;
2288 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2289 codec->slave_dig_outs = NULL;
2290 codec->spdif_status_reset = 0;
2291 module_put(codec->owner);
2292 codec->owner = NULL;
2294 /* allow device access again */
2295 hda_unlock_devices(card);
2299 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2301 /* apply the function to all matching slave ctls in the mixer list */
2302 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2303 map_slave_func_t func, void *data)
2305 struct hda_nid_item *items;
2306 const char * const *s;
2309 items = codec->mixers.list;
2310 for (i = 0; i < codec->mixers.used; i++) {
2311 struct snd_kcontrol *sctl = items[i].kctl;
2312 if (!sctl || !sctl->id.name ||
2313 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2315 for (s = slaves; *s; s++) {
2316 if (!strcmp(sctl->id.name, *s)) {
2317 err = func(data, sctl);
2327 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2333 * snd_hda_add_vmaster - create a virtual master control and add slaves
2334 * @codec: HD-audio codec
2335 * @name: vmaster control name
2336 * @tlv: TLV data (optional)
2337 * @slaves: slave control names (optional)
2339 * Create a virtual master control with the given name. The TLV data
2340 * must be either NULL or a valid data.
2342 * @slaves is a NULL-terminated array of strings, each of which is a
2343 * slave control name. All controls with these names are assigned to
2344 * the new virtual master control.
2346 * This function returns zero if successful or a negative error code.
2348 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2349 unsigned int *tlv, const char * const *slaves)
2351 struct snd_kcontrol *kctl;
2354 err = map_slaves(codec, slaves, check_slave_present, NULL);
2356 snd_printdd("No slave found for %s\n", name);
2359 kctl = snd_ctl_make_virtual_master(name, tlv);
2362 err = snd_hda_ctl_add(codec, 0, kctl);
2366 err = map_slaves(codec, slaves, (map_slave_func_t)snd_ctl_add_slave,
2372 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2375 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2377 * The control element is supposed to have the private_value field
2378 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2380 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2381 struct snd_ctl_elem_info *uinfo)
2383 int chs = get_amp_channels(kcontrol);
2385 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2386 uinfo->count = chs == 3 ? 2 : 1;
2387 uinfo->value.integer.min = 0;
2388 uinfo->value.integer.max = 1;
2391 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2394 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2396 * The control element is supposed to have the private_value field
2397 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2399 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2400 struct snd_ctl_elem_value *ucontrol)
2402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2403 hda_nid_t nid = get_amp_nid(kcontrol);
2404 int chs = get_amp_channels(kcontrol);
2405 int dir = get_amp_direction(kcontrol);
2406 int idx = get_amp_index(kcontrol);
2407 long *valp = ucontrol->value.integer.value;
2410 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2411 HDA_AMP_MUTE) ? 0 : 1;
2413 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2414 HDA_AMP_MUTE) ? 0 : 1;
2417 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2420 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2422 * The control element is supposed to have the private_value field
2423 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2425 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2426 struct snd_ctl_elem_value *ucontrol)
2428 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2429 hda_nid_t nid = get_amp_nid(kcontrol);
2430 int chs = get_amp_channels(kcontrol);
2431 int dir = get_amp_direction(kcontrol);
2432 int idx = get_amp_index(kcontrol);
2433 long *valp = ucontrol->value.integer.value;
2436 snd_hda_power_up(codec);
2438 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2440 *valp ? 0 : HDA_AMP_MUTE);
2444 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2446 *valp ? 0 : HDA_AMP_MUTE);
2447 hda_call_check_power_status(codec, nid);
2448 snd_hda_power_down(codec);
2451 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2453 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2455 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2457 * This function calls snd_hda_enable_beep_device(), which behaves differently
2458 * depending on beep_mode option.
2460 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2461 struct snd_ctl_elem_value *ucontrol)
2463 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2464 long *valp = ucontrol->value.integer.value;
2466 snd_hda_enable_beep_device(codec, *valp);
2467 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2469 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2470 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2473 * bound volume controls
2475 * bind multiple volumes (# indices, from 0)
2478 #define AMP_VAL_IDX_SHIFT 19
2479 #define AMP_VAL_IDX_MASK (0x0f<<19)
2482 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2484 * The control element is supposed to have the private_value field
2485 * set up via HDA_BIND_MUTE*() macros.
2487 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2488 struct snd_ctl_elem_value *ucontrol)
2490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2494 mutex_lock(&codec->control_mutex);
2495 pval = kcontrol->private_value;
2496 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2497 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2498 kcontrol->private_value = pval;
2499 mutex_unlock(&codec->control_mutex);
2502 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2505 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2507 * The control element is supposed to have the private_value field
2508 * set up via HDA_BIND_MUTE*() macros.
2510 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2511 struct snd_ctl_elem_value *ucontrol)
2513 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2515 int i, indices, err = 0, change = 0;
2517 mutex_lock(&codec->control_mutex);
2518 pval = kcontrol->private_value;
2519 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2520 for (i = 0; i < indices; i++) {
2521 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2522 (i << AMP_VAL_IDX_SHIFT);
2523 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2528 kcontrol->private_value = pval;
2529 mutex_unlock(&codec->control_mutex);
2530 return err < 0 ? err : change;
2532 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2535 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2537 * The control element is supposed to have the private_value field
2538 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2540 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2541 struct snd_ctl_elem_info *uinfo)
2543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2544 struct hda_bind_ctls *c;
2547 mutex_lock(&codec->control_mutex);
2548 c = (struct hda_bind_ctls *)kcontrol->private_value;
2549 kcontrol->private_value = *c->values;
2550 err = c->ops->info(kcontrol, uinfo);
2551 kcontrol->private_value = (long)c;
2552 mutex_unlock(&codec->control_mutex);
2555 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2558 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2560 * The control element is supposed to have the private_value field
2561 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2563 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2564 struct snd_ctl_elem_value *ucontrol)
2566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2567 struct hda_bind_ctls *c;
2570 mutex_lock(&codec->control_mutex);
2571 c = (struct hda_bind_ctls *)kcontrol->private_value;
2572 kcontrol->private_value = *c->values;
2573 err = c->ops->get(kcontrol, ucontrol);
2574 kcontrol->private_value = (long)c;
2575 mutex_unlock(&codec->control_mutex);
2578 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2581 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2583 * The control element is supposed to have the private_value field
2584 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2586 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2587 struct snd_ctl_elem_value *ucontrol)
2589 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2590 struct hda_bind_ctls *c;
2591 unsigned long *vals;
2592 int err = 0, change = 0;
2594 mutex_lock(&codec->control_mutex);
2595 c = (struct hda_bind_ctls *)kcontrol->private_value;
2596 for (vals = c->values; *vals; vals++) {
2597 kcontrol->private_value = *vals;
2598 err = c->ops->put(kcontrol, ucontrol);
2603 kcontrol->private_value = (long)c;
2604 mutex_unlock(&codec->control_mutex);
2605 return err < 0 ? err : change;
2607 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2610 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2612 * The control element is supposed to have the private_value field
2613 * set up via HDA_BIND_VOL() macro.
2615 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2616 unsigned int size, unsigned int __user *tlv)
2618 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2619 struct hda_bind_ctls *c;
2622 mutex_lock(&codec->control_mutex);
2623 c = (struct hda_bind_ctls *)kcontrol->private_value;
2624 kcontrol->private_value = *c->values;
2625 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2626 kcontrol->private_value = (long)c;
2627 mutex_unlock(&codec->control_mutex);
2630 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2632 struct hda_ctl_ops snd_hda_bind_vol = {
2633 .info = snd_hda_mixer_amp_volume_info,
2634 .get = snd_hda_mixer_amp_volume_get,
2635 .put = snd_hda_mixer_amp_volume_put,
2636 .tlv = snd_hda_mixer_amp_tlv
2638 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2640 struct hda_ctl_ops snd_hda_bind_sw = {
2641 .info = snd_hda_mixer_amp_switch_info,
2642 .get = snd_hda_mixer_amp_switch_get,
2643 .put = snd_hda_mixer_amp_switch_put,
2644 .tlv = snd_hda_mixer_amp_tlv
2646 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2649 * SPDIF out controls
2652 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2653 struct snd_ctl_elem_info *uinfo)
2655 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2660 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2661 struct snd_ctl_elem_value *ucontrol)
2663 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2664 IEC958_AES0_NONAUDIO |
2665 IEC958_AES0_CON_EMPHASIS_5015 |
2666 IEC958_AES0_CON_NOT_COPYRIGHT;
2667 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2668 IEC958_AES1_CON_ORIGINAL;
2672 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2673 struct snd_ctl_elem_value *ucontrol)
2675 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2676 IEC958_AES0_NONAUDIO |
2677 IEC958_AES0_PRO_EMPHASIS_5015;
2681 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2682 struct snd_ctl_elem_value *ucontrol)
2684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2685 int idx = kcontrol->private_value;
2686 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2688 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2689 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2690 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2691 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2696 /* convert from SPDIF status bits to HDA SPDIF bits
2697 * bit 0 (DigEn) is always set zero (to be filled later)
2699 static unsigned short convert_from_spdif_status(unsigned int sbits)
2701 unsigned short val = 0;
2703 if (sbits & IEC958_AES0_PROFESSIONAL)
2704 val |= AC_DIG1_PROFESSIONAL;
2705 if (sbits & IEC958_AES0_NONAUDIO)
2706 val |= AC_DIG1_NONAUDIO;
2707 if (sbits & IEC958_AES0_PROFESSIONAL) {
2708 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2709 IEC958_AES0_PRO_EMPHASIS_5015)
2710 val |= AC_DIG1_EMPHASIS;
2712 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2713 IEC958_AES0_CON_EMPHASIS_5015)
2714 val |= AC_DIG1_EMPHASIS;
2715 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2716 val |= AC_DIG1_COPYRIGHT;
2717 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2718 val |= AC_DIG1_LEVEL;
2719 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2724 /* convert to SPDIF status bits from HDA SPDIF bits
2726 static unsigned int convert_to_spdif_status(unsigned short val)
2728 unsigned int sbits = 0;
2730 if (val & AC_DIG1_NONAUDIO)
2731 sbits |= IEC958_AES0_NONAUDIO;
2732 if (val & AC_DIG1_PROFESSIONAL)
2733 sbits |= IEC958_AES0_PROFESSIONAL;
2734 if (sbits & IEC958_AES0_PROFESSIONAL) {
2735 if (sbits & AC_DIG1_EMPHASIS)
2736 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2738 if (val & AC_DIG1_EMPHASIS)
2739 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2740 if (!(val & AC_DIG1_COPYRIGHT))
2741 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2742 if (val & AC_DIG1_LEVEL)
2743 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2744 sbits |= val & (0x7f << 8);
2749 /* set digital convert verbs both for the given NID and its slaves */
2750 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2755 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2756 d = codec->slave_dig_outs;
2760 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2763 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2767 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2769 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2772 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2773 struct snd_ctl_elem_value *ucontrol)
2775 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2776 int idx = kcontrol->private_value;
2777 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2778 hda_nid_t nid = spdif->nid;
2782 mutex_lock(&codec->spdif_mutex);
2783 spdif->status = ucontrol->value.iec958.status[0] |
2784 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2785 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2786 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2787 val = convert_from_spdif_status(spdif->status);
2788 val |= spdif->ctls & 1;
2789 change = spdif->ctls != val;
2791 if (change && nid != (u16)-1)
2792 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2793 mutex_unlock(&codec->spdif_mutex);
2797 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2799 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2800 struct snd_ctl_elem_value *ucontrol)
2802 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2803 int idx = kcontrol->private_value;
2804 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2806 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2810 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2813 set_dig_out_convert(codec, nid, dig1, dig2);
2814 /* unmute amp switch (if any) */
2815 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2816 (dig1 & AC_DIG1_ENABLE))
2817 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2821 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2822 struct snd_ctl_elem_value *ucontrol)
2824 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2825 int idx = kcontrol->private_value;
2826 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2827 hda_nid_t nid = spdif->nid;
2831 mutex_lock(&codec->spdif_mutex);
2832 val = spdif->ctls & ~AC_DIG1_ENABLE;
2833 if (ucontrol->value.integer.value[0])
2834 val |= AC_DIG1_ENABLE;
2835 change = spdif->ctls != val;
2837 if (change && nid != (u16)-1)
2838 set_spdif_ctls(codec, nid, val & 0xff, -1);
2839 mutex_unlock(&codec->spdif_mutex);
2843 static struct snd_kcontrol_new dig_mixes[] = {
2845 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2847 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2848 .info = snd_hda_spdif_mask_info,
2849 .get = snd_hda_spdif_cmask_get,
2852 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2854 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2855 .info = snd_hda_spdif_mask_info,
2856 .get = snd_hda_spdif_pmask_get,
2859 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2860 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2861 .info = snd_hda_spdif_mask_info,
2862 .get = snd_hda_spdif_default_get,
2863 .put = snd_hda_spdif_default_put,
2866 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2867 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2868 .info = snd_hda_spdif_out_switch_info,
2869 .get = snd_hda_spdif_out_switch_get,
2870 .put = snd_hda_spdif_out_switch_put,
2876 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2877 * @codec: the HDA codec
2878 * @nid: audio out widget NID
2880 * Creates controls related with the SPDIF output.
2881 * Called from each patch supporting the SPDIF out.
2883 * Returns 0 if successful, or a negative error code.
2885 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2886 hda_nid_t associated_nid,
2890 struct snd_kcontrol *kctl;
2891 struct snd_kcontrol_new *dig_mix;
2893 struct hda_spdif_out *spdif;
2895 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2897 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2900 spdif = snd_array_new(&codec->spdif_out);
2901 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2902 kctl = snd_ctl_new1(dig_mix, codec);
2905 kctl->id.index = idx;
2906 kctl->private_value = codec->spdif_out.used - 1;
2907 err = snd_hda_ctl_add(codec, associated_nid, kctl);
2911 spdif->nid = cvt_nid;
2912 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
2913 AC_VERB_GET_DIGI_CONVERT_1, 0);
2914 spdif->status = convert_to_spdif_status(spdif->ctls);
2917 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2919 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2923 for (i = 0; i < codec->spdif_out.used; i++) {
2924 struct hda_spdif_out *spdif =
2925 snd_array_elem(&codec->spdif_out, i);
2926 if (spdif->nid == nid)
2931 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
2933 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2935 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2937 mutex_lock(&codec->spdif_mutex);
2938 spdif->nid = (u16)-1;
2939 mutex_unlock(&codec->spdif_mutex);
2941 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
2943 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2945 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2948 mutex_lock(&codec->spdif_mutex);
2949 if (spdif->nid != nid) {
2952 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2954 mutex_unlock(&codec->spdif_mutex);
2956 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
2959 * SPDIF sharing with analog output
2961 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2962 struct snd_ctl_elem_value *ucontrol)
2964 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2965 ucontrol->value.integer.value[0] = mout->share_spdif;
2969 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2970 struct snd_ctl_elem_value *ucontrol)
2972 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2973 mout->share_spdif = !!ucontrol->value.integer.value[0];
2977 static struct snd_kcontrol_new spdif_share_sw = {
2978 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2979 .name = "IEC958 Default PCM Playback Switch",
2980 .info = snd_ctl_boolean_mono_info,
2981 .get = spdif_share_sw_get,
2982 .put = spdif_share_sw_put,
2986 * snd_hda_create_spdif_share_sw - create Default PCM switch
2987 * @codec: the HDA codec
2988 * @mout: multi-out instance
2990 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2991 struct hda_multi_out *mout)
2993 if (!mout->dig_out_nid)
2995 /* ATTENTION: here mout is passed as private_data, instead of codec */
2996 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2997 snd_ctl_new1(&spdif_share_sw, mout));
2999 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3005 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3007 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3008 struct snd_ctl_elem_value *ucontrol)
3010 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3012 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3016 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3017 struct snd_ctl_elem_value *ucontrol)
3019 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3020 hda_nid_t nid = kcontrol->private_value;
3021 unsigned int val = !!ucontrol->value.integer.value[0];
3024 mutex_lock(&codec->spdif_mutex);
3025 change = codec->spdif_in_enable != val;
3027 codec->spdif_in_enable = val;
3028 snd_hda_codec_write_cache(codec, nid, 0,
3029 AC_VERB_SET_DIGI_CONVERT_1, val);
3031 mutex_unlock(&codec->spdif_mutex);
3035 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3036 struct snd_ctl_elem_value *ucontrol)
3038 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3039 hda_nid_t nid = kcontrol->private_value;
3043 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3044 sbits = convert_to_spdif_status(val);
3045 ucontrol->value.iec958.status[0] = sbits;
3046 ucontrol->value.iec958.status[1] = sbits >> 8;
3047 ucontrol->value.iec958.status[2] = sbits >> 16;
3048 ucontrol->value.iec958.status[3] = sbits >> 24;
3052 static struct snd_kcontrol_new dig_in_ctls[] = {
3054 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3055 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3056 .info = snd_hda_spdif_in_switch_info,
3057 .get = snd_hda_spdif_in_switch_get,
3058 .put = snd_hda_spdif_in_switch_put,
3061 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3062 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3063 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3064 .info = snd_hda_spdif_mask_info,
3065 .get = snd_hda_spdif_in_status_get,
3071 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3072 * @codec: the HDA codec
3073 * @nid: audio in widget NID
3075 * Creates controls related with the SPDIF input.
3076 * Called from each patch supporting the SPDIF in.
3078 * Returns 0 if successful, or a negative error code.
3080 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3083 struct snd_kcontrol *kctl;
3084 struct snd_kcontrol_new *dig_mix;
3087 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3089 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3092 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3093 kctl = snd_ctl_new1(dig_mix, codec);
3096 kctl->private_value = nid;
3097 err = snd_hda_ctl_add(codec, nid, kctl);
3101 codec->spdif_in_enable =
3102 snd_hda_codec_read(codec, nid, 0,
3103 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3107 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3114 /* build a 32bit cache key with the widget id and the command parameter */
3115 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3116 #define get_cmd_cache_nid(key) ((key) & 0xff)
3117 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3120 * snd_hda_codec_write_cache - send a single command with caching
3121 * @codec: the HDA codec
3122 * @nid: NID to send the command
3123 * @direct: direct flag
3124 * @verb: the verb to send
3125 * @parm: the parameter for the verb
3127 * Send a single command without waiting for response.
3129 * Returns 0 if successful, or a negative error code.
3131 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3132 int direct, unsigned int verb, unsigned int parm)
3134 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3135 struct hda_cache_head *c;
3140 /* parm may contain the verb stuff for get/set amp */
3141 verb = verb | (parm >> 8);
3143 key = build_cmd_cache_key(nid, verb);
3144 mutex_lock(&codec->bus->cmd_mutex);
3145 c = get_alloc_hash(&codec->cmd_cache, key);
3148 mutex_unlock(&codec->bus->cmd_mutex);
3151 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3154 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3155 * @codec: the HDA codec
3156 * @nid: NID to send the command
3157 * @direct: direct flag
3158 * @verb: the verb to send
3159 * @parm: the parameter for the verb
3161 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3162 * command if the parameter is already identical with the cached value.
3163 * If not, it sends the command and refreshes the cache.
3165 * Returns 0 if successful, or a negative error code.
3167 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3168 int direct, unsigned int verb, unsigned int parm)
3170 struct hda_cache_head *c;
3173 /* parm may contain the verb stuff for get/set amp */
3174 verb = verb | (parm >> 8);
3176 key = build_cmd_cache_key(nid, verb);
3177 mutex_lock(&codec->bus->cmd_mutex);
3178 c = get_hash(&codec->cmd_cache, key);
3179 if (c && c->val == parm) {
3180 mutex_unlock(&codec->bus->cmd_mutex);
3183 mutex_unlock(&codec->bus->cmd_mutex);
3184 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3186 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3189 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3190 * @codec: HD-audio codec
3192 * Execute all verbs recorded in the command caches to resume.
3194 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3196 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3199 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3200 u32 key = buffer->key;
3203 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3204 get_cmd_cache_cmd(key), buffer->val);
3207 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3210 * snd_hda_sequence_write_cache - sequence writes with caching
3211 * @codec: the HDA codec
3212 * @seq: VERB array to send
3214 * Send the commands sequentially from the given array.
3215 * Thte commands are recorded on cache for power-save and resume.
3216 * The array must be terminated with NID=0.
3218 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3219 const struct hda_verb *seq)
3221 for (; seq->nid; seq++)
3222 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3225 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3226 #endif /* CONFIG_PM */
3228 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3229 unsigned int power_state,
3230 bool eapd_workaround)
3232 hda_nid_t nid = codec->start_nid;
3235 for (i = 0; i < codec->num_nodes; i++, nid++) {
3236 unsigned int wcaps = get_wcaps(codec, nid);
3237 if (!(wcaps & AC_WCAP_POWER))
3239 /* don't power down the widget if it controls eapd and
3240 * EAPD_BTLENABLE is set.
3242 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3243 get_wcaps_type(wcaps) == AC_WID_PIN &&
3244 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3245 int eapd = snd_hda_codec_read(codec, nid, 0,
3246 AC_VERB_GET_EAPD_BTLENABLE, 0);
3250 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3254 if (power_state == AC_PWRST_D0) {
3255 unsigned long end_time;
3257 /* wait until the codec reachs to D0 */
3258 end_time = jiffies + msecs_to_jiffies(500);
3260 state = snd_hda_codec_read(codec, fg, 0,
3261 AC_VERB_GET_POWER_STATE, 0);
3262 if (state == power_state)
3265 } while (time_after_eq(end_time, jiffies));
3268 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3271 * set power state of the codec
3273 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3274 unsigned int power_state)
3276 if (codec->patch_ops.set_power_state) {
3277 codec->patch_ops.set_power_state(codec, fg, power_state);
3281 /* this delay seems necessary to avoid click noise at power-down */
3282 if (power_state == AC_PWRST_D3)
3284 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3286 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3289 #ifdef CONFIG_SND_HDA_HWDEP
3290 /* execute additional init verbs */
3291 static void hda_exec_init_verbs(struct hda_codec *codec)
3293 if (codec->init_verbs.list)
3294 snd_hda_sequence_write(codec, codec->init_verbs.list);
3297 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3302 * call suspend and power-down; used both from PM and power-save
3304 static void hda_call_codec_suspend(struct hda_codec *codec)
3306 if (codec->patch_ops.suspend)
3307 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3308 hda_cleanup_all_streams(codec);
3309 hda_set_power_state(codec,
3310 codec->afg ? codec->afg : codec->mfg,
3312 #ifdef CONFIG_SND_HDA_POWER_SAVE
3313 snd_hda_update_power_acct(codec);
3314 cancel_delayed_work(&codec->power_work);
3315 codec->power_on = 0;
3316 codec->power_transition = 0;
3317 codec->power_jiffies = jiffies;
3322 * kick up codec; used both from PM and power-save
3324 static void hda_call_codec_resume(struct hda_codec *codec)
3326 hda_set_power_state(codec,
3327 codec->afg ? codec->afg : codec->mfg,
3329 restore_pincfgs(codec); /* restore all current pin configs */
3330 restore_shutup_pins(codec);
3331 hda_exec_init_verbs(codec);
3332 snd_hda_jack_set_dirty_all(codec);
3333 if (codec->patch_ops.resume)
3334 codec->patch_ops.resume(codec);
3336 if (codec->patch_ops.init)
3337 codec->patch_ops.init(codec);
3338 snd_hda_codec_resume_amp(codec);
3339 snd_hda_codec_resume_cache(codec);
3342 #endif /* CONFIG_PM */
3346 * snd_hda_build_controls - build mixer controls
3349 * Creates mixer controls for each codec included in the bus.
3351 * Returns 0 if successful, otherwise a negative error code.
3353 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3355 struct hda_codec *codec;
3357 list_for_each_entry(codec, &bus->codec_list, list) {
3358 int err = snd_hda_codec_build_controls(codec);
3360 printk(KERN_ERR "hda_codec: cannot build controls "
3361 "for #%d (error %d)\n", codec->addr, err);
3362 err = snd_hda_codec_reset(codec);
3365 "hda_codec: cannot revert codec\n");
3372 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3374 int snd_hda_codec_build_controls(struct hda_codec *codec)
3377 hda_exec_init_verbs(codec);
3378 /* continue to initialize... */
3379 if (codec->patch_ops.init)
3380 err = codec->patch_ops.init(codec);
3381 if (!err && codec->patch_ops.build_controls)
3382 err = codec->patch_ops.build_controls(codec);
3391 struct hda_rate_tbl {
3393 unsigned int alsa_bits;
3394 unsigned int hda_fmt;
3397 /* rate = base * mult / div */
3398 #define HDA_RATE(base, mult, div) \
3399 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3400 (((div) - 1) << AC_FMT_DIV_SHIFT))
3402 static struct hda_rate_tbl rate_bits[] = {
3403 /* rate in Hz, ALSA rate bitmask, HDA format value */
3405 /* autodetected value used in snd_hda_query_supported_pcm */
3406 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3407 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3408 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3409 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3410 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3411 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3412 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3413 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3414 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3415 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3416 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3417 #define AC_PAR_PCM_RATE_BITS 11
3418 /* up to bits 10, 384kHZ isn't supported properly */
3420 /* not autodetected value */
3421 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3423 { 0 } /* terminator */
3427 * snd_hda_calc_stream_format - calculate format bitset
3428 * @rate: the sample rate
3429 * @channels: the number of channels
3430 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3431 * @maxbps: the max. bps
3433 * Calculate the format bitset from the given rate, channels and th PCM format.
3435 * Return zero if invalid.
3437 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3438 unsigned int channels,
3439 unsigned int format,
3440 unsigned int maxbps,
3441 unsigned short spdif_ctls)
3444 unsigned int val = 0;
3446 for (i = 0; rate_bits[i].hz; i++)
3447 if (rate_bits[i].hz == rate) {
3448 val = rate_bits[i].hda_fmt;
3451 if (!rate_bits[i].hz) {
3452 snd_printdd("invalid rate %d\n", rate);
3456 if (channels == 0 || channels > 8) {
3457 snd_printdd("invalid channels %d\n", channels);
3460 val |= channels - 1;
3462 switch (snd_pcm_format_width(format)) {
3464 val |= AC_FMT_BITS_8;
3467 val |= AC_FMT_BITS_16;
3472 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3473 val |= AC_FMT_BITS_32;
3474 else if (maxbps >= 24)
3475 val |= AC_FMT_BITS_24;
3477 val |= AC_FMT_BITS_20;
3480 snd_printdd("invalid format width %d\n",
3481 snd_pcm_format_width(format));
3485 if (spdif_ctls & AC_DIG1_NONAUDIO)
3486 val |= AC_FMT_TYPE_NON_PCM;
3490 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3492 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3494 unsigned int val = 0;
3495 if (nid != codec->afg &&
3496 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3497 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3498 if (!val || val == -1)
3499 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3500 if (!val || val == -1)
3505 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3507 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3511 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3513 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3514 if (!streams || streams == -1)
3515 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3516 if (!streams || streams == -1)
3521 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3523 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3528 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3529 * @codec: the HDA codec
3530 * @nid: NID to query
3531 * @ratesp: the pointer to store the detected rate bitflags
3532 * @formatsp: the pointer to store the detected formats
3533 * @bpsp: the pointer to store the detected format widths
3535 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3536 * or @bsps argument is ignored.
3538 * Returns 0 if successful, otherwise a negative error code.
3540 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3541 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3543 unsigned int i, val, wcaps;
3545 wcaps = get_wcaps(codec, nid);
3546 val = query_pcm_param(codec, nid);
3550 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3552 rates |= rate_bits[i].alsa_bits;
3555 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3556 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3558 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3564 if (formatsp || bpsp) {
3566 unsigned int streams, bps;
3568 streams = query_stream_param(codec, nid);
3573 if (streams & AC_SUPFMT_PCM) {
3574 if (val & AC_SUPPCM_BITS_8) {
3575 formats |= SNDRV_PCM_FMTBIT_U8;
3578 if (val & AC_SUPPCM_BITS_16) {
3579 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3582 if (wcaps & AC_WCAP_DIGITAL) {
3583 if (val & AC_SUPPCM_BITS_32)
3584 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3585 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3586 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3587 if (val & AC_SUPPCM_BITS_24)
3589 else if (val & AC_SUPPCM_BITS_20)
3591 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3592 AC_SUPPCM_BITS_32)) {
3593 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3594 if (val & AC_SUPPCM_BITS_32)
3596 else if (val & AC_SUPPCM_BITS_24)
3598 else if (val & AC_SUPPCM_BITS_20)
3602 if (streams & AC_SUPFMT_FLOAT32) {
3603 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3607 if (streams == AC_SUPFMT_AC3) {
3608 /* should be exclusive */
3609 /* temporary hack: we have still no proper support
3610 * for the direct AC3 stream...
3612 formats |= SNDRV_PCM_FMTBIT_U8;
3616 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3617 "(nid=0x%x, val=0x%x, ovrd=%i, "
3620 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3625 *formatsp = formats;
3632 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3635 * snd_hda_is_supported_format - Check the validity of the format
3636 * @codec: HD-audio codec
3637 * @nid: NID to check
3638 * @format: the HD-audio format value to check
3640 * Check whether the given node supports the format value.
3642 * Returns 1 if supported, 0 if not.
3644 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3645 unsigned int format)
3648 unsigned int val = 0, rate, stream;
3650 val = query_pcm_param(codec, nid);
3654 rate = format & 0xff00;
3655 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3656 if (rate_bits[i].hda_fmt == rate) {
3661 if (i >= AC_PAR_PCM_RATE_BITS)
3664 stream = query_stream_param(codec, nid);
3668 if (stream & AC_SUPFMT_PCM) {
3669 switch (format & 0xf0) {
3671 if (!(val & AC_SUPPCM_BITS_8))
3675 if (!(val & AC_SUPPCM_BITS_16))
3679 if (!(val & AC_SUPPCM_BITS_20))
3683 if (!(val & AC_SUPPCM_BITS_24))
3687 if (!(val & AC_SUPPCM_BITS_32))
3694 /* FIXME: check for float32 and AC3? */
3699 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3704 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3705 struct hda_codec *codec,
3706 struct snd_pcm_substream *substream)
3711 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3712 struct hda_codec *codec,
3713 unsigned int stream_tag,
3714 unsigned int format,
3715 struct snd_pcm_substream *substream)
3717 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3721 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3722 struct hda_codec *codec,
3723 struct snd_pcm_substream *substream)
3725 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3729 static int set_pcm_default_values(struct hda_codec *codec,
3730 struct hda_pcm_stream *info)
3734 /* query support PCM information from the given NID */
3735 if (info->nid && (!info->rates || !info->formats)) {
3736 err = snd_hda_query_supported_pcm(codec, info->nid,
3737 info->rates ? NULL : &info->rates,
3738 info->formats ? NULL : &info->formats,
3739 info->maxbps ? NULL : &info->maxbps);
3743 if (info->ops.open == NULL)
3744 info->ops.open = hda_pcm_default_open_close;
3745 if (info->ops.close == NULL)
3746 info->ops.close = hda_pcm_default_open_close;
3747 if (info->ops.prepare == NULL) {
3748 if (snd_BUG_ON(!info->nid))
3750 info->ops.prepare = hda_pcm_default_prepare;
3752 if (info->ops.cleanup == NULL) {
3753 if (snd_BUG_ON(!info->nid))
3755 info->ops.cleanup = hda_pcm_default_cleanup;
3761 * codec prepare/cleanup entries
3763 int snd_hda_codec_prepare(struct hda_codec *codec,
3764 struct hda_pcm_stream *hinfo,
3765 unsigned int stream,
3766 unsigned int format,
3767 struct snd_pcm_substream *substream)
3770 mutex_lock(&codec->bus->prepare_mutex);
3771 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3773 purify_inactive_streams(codec);
3774 mutex_unlock(&codec->bus->prepare_mutex);
3777 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3779 void snd_hda_codec_cleanup(struct hda_codec *codec,
3780 struct hda_pcm_stream *hinfo,
3781 struct snd_pcm_substream *substream)
3783 mutex_lock(&codec->bus->prepare_mutex);
3784 hinfo->ops.cleanup(hinfo, codec, substream);
3785 mutex_unlock(&codec->bus->prepare_mutex);
3787 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3790 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3791 "Audio", "SPDIF", "HDMI", "Modem"
3795 * get the empty PCM device number to assign
3797 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3799 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3801 /* audio device indices; not linear to keep compatibility */
3802 static int audio_idx[HDA_PCM_NTYPES][5] = {
3803 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3804 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3805 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3806 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3810 if (type >= HDA_PCM_NTYPES) {
3811 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3815 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3816 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3817 return audio_idx[type][i];
3819 /* non-fixed slots starting from 10 */
3820 for (i = 10; i < 32; i++) {
3821 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3825 snd_printk(KERN_WARNING "Too many %s devices\n",
3826 snd_hda_pcm_type_name[type]);
3831 * attach a new PCM stream
3833 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3835 struct hda_bus *bus = codec->bus;
3836 struct hda_pcm_stream *info;
3839 if (snd_BUG_ON(!pcm->name))
3841 for (stream = 0; stream < 2; stream++) {
3842 info = &pcm->stream[stream];
3843 if (info->substreams) {
3844 err = set_pcm_default_values(codec, info);
3849 return bus->ops.attach_pcm(bus, codec, pcm);
3852 /* assign all PCMs of the given codec */
3853 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3858 if (!codec->num_pcms) {
3859 if (!codec->patch_ops.build_pcms)
3861 err = codec->patch_ops.build_pcms(codec);
3863 printk(KERN_ERR "hda_codec: cannot build PCMs"
3864 "for #%d (error %d)\n", codec->addr, err);
3865 err = snd_hda_codec_reset(codec);
3868 "hda_codec: cannot revert codec\n");
3873 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3874 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3877 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3878 continue; /* no substreams assigned */
3881 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3883 continue; /* no fatal error */
3885 err = snd_hda_attach_pcm(codec, cpcm);
3887 printk(KERN_ERR "hda_codec: cannot attach "
3888 "PCM stream %d for codec #%d\n",
3890 continue; /* no fatal error */
3898 * snd_hda_build_pcms - build PCM information
3901 * Create PCM information for each codec included in the bus.
3903 * The build_pcms codec patch is requested to set up codec->num_pcms and
3904 * codec->pcm_info properly. The array is referred by the top-level driver
3905 * to create its PCM instances.
3906 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3909 * At least, substreams, channels_min and channels_max must be filled for
3910 * each stream. substreams = 0 indicates that the stream doesn't exist.
3911 * When rates and/or formats are zero, the supported values are queried
3912 * from the given nid. The nid is used also by the default ops.prepare
3913 * and ops.cleanup callbacks.
3915 * The driver needs to call ops.open in its open callback. Similarly,
3916 * ops.close is supposed to be called in the close callback.
3917 * ops.prepare should be called in the prepare or hw_params callback
3918 * with the proper parameters for set up.
3919 * ops.cleanup should be called in hw_free for clean up of streams.
3921 * This function returns 0 if successful, or a negative error code.
3923 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3925 struct hda_codec *codec;
3927 list_for_each_entry(codec, &bus->codec_list, list) {
3928 int err = snd_hda_codec_build_pcms(codec);
3934 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3937 * snd_hda_check_board_config - compare the current codec with the config table
3938 * @codec: the HDA codec
3939 * @num_configs: number of config enums
3940 * @models: array of model name strings
3941 * @tbl: configuration table, terminated by null entries
3943 * Compares the modelname or PCI subsystem id of the current codec with the
3944 * given configuration table. If a matching entry is found, returns its
3945 * config value (supposed to be 0 or positive).
3947 * If no entries are matching, the function returns a negative value.
3949 int snd_hda_check_board_config(struct hda_codec *codec,
3950 int num_configs, const char * const *models,
3951 const struct snd_pci_quirk *tbl)
3953 if (codec->modelname && models) {
3955 for (i = 0; i < num_configs; i++) {
3957 !strcmp(codec->modelname, models[i])) {
3958 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3959 "selected\n", models[i]);
3965 if (!codec->bus->pci || !tbl)
3968 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3971 if (tbl->value >= 0 && tbl->value < num_configs) {
3972 #ifdef CONFIG_SND_DEBUG_VERBOSE
3974 const char *model = NULL;
3976 model = models[tbl->value];
3978 sprintf(tmp, "#%d", tbl->value);
3981 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3982 "for config %x:%x (%s)\n",
3983 model, tbl->subvendor, tbl->subdevice,
3984 (tbl->name ? tbl->name : "Unknown device"));
3990 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3993 * snd_hda_check_board_codec_sid_config - compare the current codec
3994 subsystem ID with the
3997 This is important for Gateway notebooks with SB450 HDA Audio
3998 where the vendor ID of the PCI device is:
3999 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4000 and the vendor/subvendor are found only at the codec.
4002 * @codec: the HDA codec
4003 * @num_configs: number of config enums
4004 * @models: array of model name strings
4005 * @tbl: configuration table, terminated by null entries
4007 * Compares the modelname or PCI subsystem id of the current codec with the
4008 * given configuration table. If a matching entry is found, returns its
4009 * config value (supposed to be 0 or positive).
4011 * If no entries are matching, the function returns a negative value.
4013 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4014 int num_configs, const char * const *models,
4015 const struct snd_pci_quirk *tbl)
4017 const struct snd_pci_quirk *q;
4019 /* Search for codec ID */
4020 for (q = tbl; q->subvendor; q++) {
4021 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4022 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4023 if ((codec->subsystem_id & mask) == id)
4032 if (tbl->value >= 0 && tbl->value < num_configs) {
4033 #ifdef CONFIG_SND_DEBUG_VERBOSE
4035 const char *model = NULL;
4037 model = models[tbl->value];
4039 sprintf(tmp, "#%d", tbl->value);
4042 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4043 "for config %x:%x (%s)\n",
4044 model, tbl->subvendor, tbl->subdevice,
4045 (tbl->name ? tbl->name : "Unknown device"));
4051 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4054 * snd_hda_add_new_ctls - create controls from the array
4055 * @codec: the HDA codec
4056 * @knew: the array of struct snd_kcontrol_new
4058 * This helper function creates and add new controls in the given array.
4059 * The array must be terminated with an empty entry as terminator.
4061 * Returns 0 if successful, or a negative error code.
4063 int snd_hda_add_new_ctls(struct hda_codec *codec,
4064 const struct snd_kcontrol_new *knew)
4068 for (; knew->name; knew++) {
4069 struct snd_kcontrol *kctl;
4070 int addr = 0, idx = 0;
4071 if (knew->iface == -1) /* skip this codec private value */
4074 kctl = snd_ctl_new1(knew, codec);
4078 kctl->id.device = addr;
4080 kctl->id.index = idx;
4081 err = snd_hda_ctl_add(codec, 0, kctl);
4084 /* try first with another device index corresponding to
4085 * the codec addr; if it still fails (or it's the
4086 * primary codec), then try another control index
4088 if (!addr && codec->addr)
4090 else if (!idx && !knew->index) {
4091 idx = find_empty_mixer_ctl_idx(codec,
4101 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4103 #ifdef CONFIG_SND_HDA_POWER_SAVE
4104 static void hda_power_work(struct work_struct *work)
4106 struct hda_codec *codec =
4107 container_of(work, struct hda_codec, power_work.work);
4108 struct hda_bus *bus = codec->bus;
4110 if (!codec->power_on || codec->power_count) {
4111 codec->power_transition = 0;
4115 trace_hda_power_down(codec);
4116 hda_call_codec_suspend(codec);
4117 if (bus->ops.pm_notify)
4118 bus->ops.pm_notify(bus);
4121 static void hda_keep_power_on(struct hda_codec *codec)
4123 codec->power_count++;
4124 codec->power_on = 1;
4125 codec->power_jiffies = jiffies;
4128 /* update the power on/off account with the current jiffies */
4129 void snd_hda_update_power_acct(struct hda_codec *codec)
4131 unsigned long delta = jiffies - codec->power_jiffies;
4132 if (codec->power_on)
4133 codec->power_on_acct += delta;
4135 codec->power_off_acct += delta;
4136 codec->power_jiffies += delta;
4140 * snd_hda_power_up - Power-up the codec
4141 * @codec: HD-audio codec
4143 * Increment the power-up counter and power up the hardware really when
4144 * not turned on yet.
4146 void snd_hda_power_up(struct hda_codec *codec)
4148 struct hda_bus *bus = codec->bus;
4150 codec->power_count++;
4151 if (codec->power_on || codec->power_transition)
4154 trace_hda_power_up(codec);
4155 snd_hda_update_power_acct(codec);
4156 codec->power_on = 1;
4157 codec->power_jiffies = jiffies;
4158 if (bus->ops.pm_notify)
4159 bus->ops.pm_notify(bus);
4160 hda_call_codec_resume(codec);
4161 cancel_delayed_work(&codec->power_work);
4162 codec->power_transition = 0;
4164 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4166 #define power_save(codec) \
4167 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4170 * snd_hda_power_down - Power-down the codec
4171 * @codec: HD-audio codec
4173 * Decrement the power-up counter and schedules the power-off work if
4174 * the counter rearches to zero.
4176 void snd_hda_power_down(struct hda_codec *codec)
4178 --codec->power_count;
4179 if (!codec->power_on || codec->power_count || codec->power_transition)
4181 if (power_save(codec)) {
4182 codec->power_transition = 1; /* avoid reentrance */
4183 queue_delayed_work(codec->bus->workq, &codec->power_work,
4184 msecs_to_jiffies(power_save(codec) * 1000));
4187 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4190 * snd_hda_check_amp_list_power - Check the amp list and update the power
4191 * @codec: HD-audio codec
4192 * @check: the object containing an AMP list and the status
4193 * @nid: NID to check / update
4195 * Check whether the given NID is in the amp list. If it's in the list,
4196 * check the current AMP status, and update the the power-status according
4197 * to the mute status.
4199 * This function is supposed to be set or called from the check_power_status
4202 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4203 struct hda_loopback_check *check,
4206 const struct hda_amp_list *p;
4209 if (!check->amplist)
4211 for (p = check->amplist; p->nid; p++) {
4216 return 0; /* nothing changed */
4218 for (p = check->amplist; p->nid; p++) {
4219 for (ch = 0; ch < 2; ch++) {
4220 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4222 if (!(v & HDA_AMP_MUTE) && v > 0) {
4223 if (!check->power_on) {
4224 check->power_on = 1;
4225 snd_hda_power_up(codec);
4231 if (check->power_on) {
4232 check->power_on = 0;
4233 snd_hda_power_down(codec);
4237 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4241 * Channel mode helper
4245 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4247 int snd_hda_ch_mode_info(struct hda_codec *codec,
4248 struct snd_ctl_elem_info *uinfo,
4249 const struct hda_channel_mode *chmode,
4252 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4254 uinfo->value.enumerated.items = num_chmodes;
4255 if (uinfo->value.enumerated.item >= num_chmodes)
4256 uinfo->value.enumerated.item = num_chmodes - 1;
4257 sprintf(uinfo->value.enumerated.name, "%dch",
4258 chmode[uinfo->value.enumerated.item].channels);
4261 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4264 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4266 int snd_hda_ch_mode_get(struct hda_codec *codec,
4267 struct snd_ctl_elem_value *ucontrol,
4268 const struct hda_channel_mode *chmode,
4274 for (i = 0; i < num_chmodes; i++) {
4275 if (max_channels == chmode[i].channels) {
4276 ucontrol->value.enumerated.item[0] = i;
4282 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4285 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4287 int snd_hda_ch_mode_put(struct hda_codec *codec,
4288 struct snd_ctl_elem_value *ucontrol,
4289 const struct hda_channel_mode *chmode,
4295 mode = ucontrol->value.enumerated.item[0];
4296 if (mode >= num_chmodes)
4298 if (*max_channelsp == chmode[mode].channels)
4300 /* change the current channel setting */
4301 *max_channelsp = chmode[mode].channels;
4302 if (chmode[mode].sequence)
4303 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4306 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4313 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4315 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4316 struct snd_ctl_elem_info *uinfo)
4320 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4322 uinfo->value.enumerated.items = imux->num_items;
4323 if (!imux->num_items)
4325 index = uinfo->value.enumerated.item;
4326 if (index >= imux->num_items)
4327 index = imux->num_items - 1;
4328 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4331 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4334 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4336 int snd_hda_input_mux_put(struct hda_codec *codec,
4337 const struct hda_input_mux *imux,
4338 struct snd_ctl_elem_value *ucontrol,
4340 unsigned int *cur_val)
4344 if (!imux->num_items)
4346 idx = ucontrol->value.enumerated.item[0];
4347 if (idx >= imux->num_items)
4348 idx = imux->num_items - 1;
4349 if (*cur_val == idx)
4351 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4352 imux->items[idx].index);
4356 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4360 * Multi-channel / digital-out PCM helper functions
4363 /* setup SPDIF output stream */
4364 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4365 unsigned int stream_tag, unsigned int format)
4367 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4369 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4370 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4371 set_dig_out_convert(codec, nid,
4372 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4374 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4375 if (codec->slave_dig_outs) {
4377 for (d = codec->slave_dig_outs; *d; d++)
4378 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4381 /* turn on again (if needed) */
4382 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4383 set_dig_out_convert(codec, nid,
4384 spdif->ctls & 0xff, -1);
4387 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4389 snd_hda_codec_cleanup_stream(codec, nid);
4390 if (codec->slave_dig_outs) {
4392 for (d = codec->slave_dig_outs; *d; d++)
4393 snd_hda_codec_cleanup_stream(codec, *d);
4398 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4399 * @bus: HD-audio bus
4401 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4403 struct hda_codec *codec;
4407 list_for_each_entry(codec, &bus->codec_list, list) {
4408 if (hda_codec_is_power_on(codec) &&
4409 codec->patch_ops.reboot_notify)
4410 codec->patch_ops.reboot_notify(codec);
4413 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4416 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4418 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4419 struct hda_multi_out *mout)
4421 mutex_lock(&codec->spdif_mutex);
4422 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4423 /* already opened as analog dup; reset it once */
4424 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4425 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4426 mutex_unlock(&codec->spdif_mutex);
4429 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4432 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4434 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4435 struct hda_multi_out *mout,
4436 unsigned int stream_tag,
4437 unsigned int format,
4438 struct snd_pcm_substream *substream)
4440 mutex_lock(&codec->spdif_mutex);
4441 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4442 mutex_unlock(&codec->spdif_mutex);
4445 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4448 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4450 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4451 struct hda_multi_out *mout)
4453 mutex_lock(&codec->spdif_mutex);
4454 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4455 mutex_unlock(&codec->spdif_mutex);
4458 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4461 * snd_hda_multi_out_dig_close - release the digital out stream
4463 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4464 struct hda_multi_out *mout)
4466 mutex_lock(&codec->spdif_mutex);
4467 mout->dig_out_used = 0;
4468 mutex_unlock(&codec->spdif_mutex);
4471 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4474 * snd_hda_multi_out_analog_open - open analog outputs
4476 * Open analog outputs and set up the hw-constraints.
4477 * If the digital outputs can be opened as slave, open the digital
4480 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4481 struct hda_multi_out *mout,
4482 struct snd_pcm_substream *substream,
4483 struct hda_pcm_stream *hinfo)
4485 struct snd_pcm_runtime *runtime = substream->runtime;
4486 runtime->hw.channels_max = mout->max_channels;
4487 if (mout->dig_out_nid) {
4488 if (!mout->analog_rates) {
4489 mout->analog_rates = hinfo->rates;
4490 mout->analog_formats = hinfo->formats;
4491 mout->analog_maxbps = hinfo->maxbps;
4493 runtime->hw.rates = mout->analog_rates;
4494 runtime->hw.formats = mout->analog_formats;
4495 hinfo->maxbps = mout->analog_maxbps;
4497 if (!mout->spdif_rates) {
4498 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4500 &mout->spdif_formats,
4501 &mout->spdif_maxbps);
4503 mutex_lock(&codec->spdif_mutex);
4504 if (mout->share_spdif) {
4505 if ((runtime->hw.rates & mout->spdif_rates) &&
4506 (runtime->hw.formats & mout->spdif_formats)) {
4507 runtime->hw.rates &= mout->spdif_rates;
4508 runtime->hw.formats &= mout->spdif_formats;
4509 if (mout->spdif_maxbps < hinfo->maxbps)
4510 hinfo->maxbps = mout->spdif_maxbps;
4512 mout->share_spdif = 0;
4513 /* FIXME: need notify? */
4516 mutex_unlock(&codec->spdif_mutex);
4518 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4519 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4521 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4524 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4526 * Set up the i/o for analog out.
4527 * When the digital out is available, copy the front out to digital out, too.
4529 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4530 struct hda_multi_out *mout,
4531 unsigned int stream_tag,
4532 unsigned int format,
4533 struct snd_pcm_substream *substream)
4535 const hda_nid_t *nids = mout->dac_nids;
4536 int chs = substream->runtime->channels;
4537 struct hda_spdif_out *spdif =
4538 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4541 mutex_lock(&codec->spdif_mutex);
4542 if (mout->dig_out_nid && mout->share_spdif &&
4543 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4545 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4547 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4548 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4549 setup_dig_out_stream(codec, mout->dig_out_nid,
4550 stream_tag, format);
4552 mout->dig_out_used = 0;
4553 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4556 mutex_unlock(&codec->spdif_mutex);
4559 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4561 if (!mout->no_share_stream &&
4562 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4563 /* headphone out will just decode front left/right (stereo) */
4564 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4566 /* extra outputs copied from front */
4567 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4568 if (!mout->no_share_stream && mout->hp_out_nid[i])
4569 snd_hda_codec_setup_stream(codec,
4570 mout->hp_out_nid[i],
4571 stream_tag, 0, format);
4572 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4573 if (!mout->no_share_stream && mout->extra_out_nid[i])
4574 snd_hda_codec_setup_stream(codec,
4575 mout->extra_out_nid[i],
4576 stream_tag, 0, format);
4579 for (i = 1; i < mout->num_dacs; i++) {
4580 if (chs >= (i + 1) * 2) /* independent out */
4581 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4583 else if (!mout->no_share_stream) /* copy front */
4584 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4589 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4592 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4594 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4595 struct hda_multi_out *mout)
4597 const hda_nid_t *nids = mout->dac_nids;
4600 for (i = 0; i < mout->num_dacs; i++)
4601 snd_hda_codec_cleanup_stream(codec, nids[i]);
4603 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4604 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4605 if (mout->hp_out_nid[i])
4606 snd_hda_codec_cleanup_stream(codec,
4607 mout->hp_out_nid[i]);
4608 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4609 if (mout->extra_out_nid[i])
4610 snd_hda_codec_cleanup_stream(codec,
4611 mout->extra_out_nid[i]);
4612 mutex_lock(&codec->spdif_mutex);
4613 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4614 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4615 mout->dig_out_used = 0;
4617 mutex_unlock(&codec->spdif_mutex);
4620 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4623 * Helper for automatic pin configuration
4626 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
4628 for (; *list; list++)
4636 * Sort an associated group of pins according to their sequence numbers.
4638 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4645 for (i = 0; i < num_pins; i++) {
4646 for (j = i + 1; j < num_pins; j++) {
4647 if (sequences[i] > sequences[j]) {
4649 sequences[i] = sequences[j];
4660 /* add the found input-pin to the cfg->inputs[] table */
4661 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4664 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4665 cfg->inputs[cfg->num_inputs].pin = nid;
4666 cfg->inputs[cfg->num_inputs].type = type;
4671 /* sort inputs in the order of AUTO_PIN_* type */
4672 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4676 for (i = 0; i < cfg->num_inputs; i++) {
4677 for (j = i + 1; j < cfg->num_inputs; j++) {
4678 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4679 struct auto_pin_cfg_item tmp;
4680 tmp = cfg->inputs[i];
4681 cfg->inputs[i] = cfg->inputs[j];
4682 cfg->inputs[j] = tmp;
4688 /* Reorder the surround channels
4689 * ALSA sequence is front/surr/clfe/side
4691 * 4-ch: front/surr => OK as it is
4692 * 6-ch: front/clfe/surr
4693 * 8-ch: front/clfe/rear/side|fc
4695 static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4710 * Parse all pin widgets and store the useful pin nids to cfg
4712 * The number of line-outs or any primary output is stored in line_outs,
4713 * and the corresponding output pins are assigned to line_out_pins[],
4714 * in the order of front, rear, CLFE, side, ...
4716 * If more extra outputs (speaker and headphone) are found, the pins are
4717 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4718 * is detected, one of speaker of HP pins is assigned as the primary
4719 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4720 * if any analog output exists.
4722 * The analog input pins are assigned to inputs array.
4723 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4726 int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4727 struct auto_pin_cfg *cfg,
4728 const hda_nid_t *ignore_nids,
4729 unsigned int cond_flags)
4731 hda_nid_t nid, end_nid;
4732 short seq, assoc_line_out;
4733 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4734 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4735 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4738 memset(cfg, 0, sizeof(*cfg));
4740 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4741 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4742 memset(sequences_hp, 0, sizeof(sequences_hp));
4745 codec->ignore_misc_bit = true;
4746 end_nid = codec->start_nid + codec->num_nodes;
4747 for (nid = codec->start_nid; nid < end_nid; nid++) {
4748 unsigned int wid_caps = get_wcaps(codec, nid);
4749 unsigned int wid_type = get_wcaps_type(wid_caps);
4750 unsigned int def_conf;
4751 short assoc, loc, conn, dev;
4753 /* read all default configuration for pin complex */
4754 if (wid_type != AC_WID_PIN)
4756 /* ignore the given nids (e.g. pc-beep returns error) */
4757 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4760 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4761 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4762 AC_DEFCFG_MISC_NO_PRESENCE))
4763 codec->ignore_misc_bit = false;
4764 conn = get_defcfg_connect(def_conf);
4765 if (conn == AC_JACK_PORT_NONE)
4767 loc = get_defcfg_location(def_conf);
4768 dev = get_defcfg_device(def_conf);
4770 /* workaround for buggy BIOS setups */
4771 if (dev == AC_JACK_LINE_OUT) {
4772 if (conn == AC_JACK_PORT_FIXED)
4773 dev = AC_JACK_SPEAKER;
4777 case AC_JACK_LINE_OUT:
4778 seq = get_defcfg_sequence(def_conf);
4779 assoc = get_defcfg_association(def_conf);
4781 if (!(wid_caps & AC_WCAP_STEREO))
4782 if (!cfg->mono_out_pin)
4783 cfg->mono_out_pin = nid;
4786 if (!assoc_line_out)
4787 assoc_line_out = assoc;
4788 else if (assoc_line_out != assoc)
4790 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4792 cfg->line_out_pins[cfg->line_outs] = nid;
4793 sequences_line_out[cfg->line_outs] = seq;
4796 case AC_JACK_SPEAKER:
4797 seq = get_defcfg_sequence(def_conf);
4798 assoc = get_defcfg_association(def_conf);
4799 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4801 cfg->speaker_pins[cfg->speaker_outs] = nid;
4802 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
4803 cfg->speaker_outs++;
4805 case AC_JACK_HP_OUT:
4806 seq = get_defcfg_sequence(def_conf);
4807 assoc = get_defcfg_association(def_conf);
4808 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4810 cfg->hp_pins[cfg->hp_outs] = nid;
4811 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4814 case AC_JACK_MIC_IN:
4815 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4817 case AC_JACK_LINE_IN:
4818 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4821 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4824 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
4826 case AC_JACK_SPDIF_OUT:
4827 case AC_JACK_DIG_OTHER_OUT:
4828 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4830 cfg->dig_out_pins[cfg->dig_outs] = nid;
4831 cfg->dig_out_type[cfg->dig_outs] =
4832 (loc == AC_JACK_LOC_HDMI) ?
4833 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4836 case AC_JACK_SPDIF_IN:
4837 case AC_JACK_DIG_OTHER_IN:
4838 cfg->dig_in_pin = nid;
4839 if (loc == AC_JACK_LOC_HDMI)
4840 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4842 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4848 * If no line-out is defined but multiple HPs are found,
4849 * some of them might be the real line-outs.
4851 if (!cfg->line_outs && cfg->hp_outs > 1 &&
4852 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
4854 while (i < cfg->hp_outs) {
4855 /* The real HPs should have the sequence 0x0f */
4856 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4860 /* Move it to the line-out table */
4861 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4862 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4865 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4866 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4867 memmove(sequences_hp + i, sequences_hp + i + 1,
4868 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4870 memset(cfg->hp_pins + cfg->hp_outs, 0,
4871 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
4873 cfg->line_out_type = AUTO_PIN_HP_OUT;
4877 /* sort by sequence */
4878 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4880 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4882 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4886 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4887 * as a primary output
4889 if (!cfg->line_outs &&
4890 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
4891 if (cfg->speaker_outs) {
4892 cfg->line_outs = cfg->speaker_outs;
4893 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4894 sizeof(cfg->speaker_pins));
4895 cfg->speaker_outs = 0;
4896 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4897 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4898 } else if (cfg->hp_outs) {
4899 cfg->line_outs = cfg->hp_outs;
4900 memcpy(cfg->line_out_pins, cfg->hp_pins,
4901 sizeof(cfg->hp_pins));
4903 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4904 cfg->line_out_type = AUTO_PIN_HP_OUT;
4908 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
4909 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
4910 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
4912 sort_autocfg_input_pins(cfg);
4915 * debug prints of the parsed results
4917 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
4918 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4919 cfg->line_out_pins[2], cfg->line_out_pins[3],
4920 cfg->line_out_pins[4],
4921 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
4922 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
4923 "speaker" : "line"));
4924 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4925 cfg->speaker_outs, cfg->speaker_pins[0],
4926 cfg->speaker_pins[1], cfg->speaker_pins[2],
4927 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4928 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4929 cfg->hp_outs, cfg->hp_pins[0],
4930 cfg->hp_pins[1], cfg->hp_pins[2],
4931 cfg->hp_pins[3], cfg->hp_pins[4]);
4932 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4934 snd_printd(" dig-out=0x%x/0x%x\n",
4935 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4936 snd_printd(" inputs:");
4937 for (i = 0; i < cfg->num_inputs; i++) {
4938 snd_printd(" %s=0x%x",
4939 hda_get_autocfg_input_label(codec, cfg, i),
4940 cfg->inputs[i].pin);
4943 if (cfg->dig_in_pin)
4944 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4948 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
4950 int snd_hda_get_input_pin_attr(unsigned int def_conf)
4952 unsigned int loc = get_defcfg_location(def_conf);
4953 unsigned int conn = get_defcfg_connect(def_conf);
4954 if (conn == AC_JACK_PORT_NONE)
4955 return INPUT_PIN_ATTR_UNUSED;
4956 /* Windows may claim the internal mic to be BOTH, too */
4957 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
4958 return INPUT_PIN_ATTR_INT;
4959 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
4960 return INPUT_PIN_ATTR_INT;
4961 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
4962 return INPUT_PIN_ATTR_DOCK;
4963 if (loc == AC_JACK_LOC_REAR)
4964 return INPUT_PIN_ATTR_REAR;
4965 if (loc == AC_JACK_LOC_FRONT)
4966 return INPUT_PIN_ATTR_FRONT;
4967 return INPUT_PIN_ATTR_NORMAL;
4969 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
4972 * hda_get_input_pin_label - Give a label for the given input pin
4974 * When check_location is true, the function checks the pin location
4975 * for mic and line-in pins, and set an appropriate prefix like "Front",
4976 * "Rear", "Internal".
4979 static const char *hda_get_input_pin_label(struct hda_codec *codec,
4980 hda_nid_t pin, bool check_location)
4982 unsigned int def_conf;
4983 static const char * const mic_names[] = {
4984 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4988 def_conf = snd_hda_codec_get_pincfg(codec, pin);
4990 switch (get_defcfg_device(def_conf)) {
4991 case AC_JACK_MIC_IN:
4992 if (!check_location)
4994 attr = snd_hda_get_input_pin_attr(def_conf);
4997 return mic_names[attr - 1];
4998 case AC_JACK_LINE_IN:
4999 if (!check_location)
5001 attr = snd_hda_get_input_pin_attr(def_conf);
5004 if (attr == INPUT_PIN_ATTR_DOCK)
5011 case AC_JACK_SPDIF_IN:
5013 case AC_JACK_DIG_OTHER_IN:
5014 return "Digital In";
5020 /* Check whether the location prefix needs to be added to the label.
5021 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5022 * have to put "Front" prefix to each label. In such a case, returns false.
5024 static int check_mic_location_need(struct hda_codec *codec,
5025 const struct auto_pin_cfg *cfg,
5031 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
5032 attr = snd_hda_get_input_pin_attr(defc);
5033 /* for internal or docking mics, we need locations */
5034 if (attr <= INPUT_PIN_ATTR_NORMAL)
5038 for (i = 0; i < cfg->num_inputs; i++) {
5039 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
5040 attr2 = snd_hda_get_input_pin_attr(defc);
5041 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
5042 if (attr && attr != attr2)
5043 return 1; /* different locations found */
5051 * hda_get_autocfg_input_label - Get a label for the given input
5053 * Get a label for the given input pin defined by the autocfg item.
5054 * Unlike hda_get_input_pin_label(), this function checks all inputs
5055 * defined in autocfg and avoids the redundant mic/line prefix as much as
5058 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5059 const struct auto_pin_cfg *cfg,
5062 int type = cfg->inputs[input].type;
5063 int has_multiple_pins = 0;
5065 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5066 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5067 has_multiple_pins = 1;
5068 if (has_multiple_pins && type == AUTO_PIN_MIC)
5069 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
5070 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5073 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5075 /* return the position of NID in the list, or -1 if not found */
5076 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5079 for (i = 0; i < nums; i++)
5085 /* get a unique suffix or an index number */
5086 static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5087 int num_pins, int *indexp)
5089 static const char * const channel_sfx[] = {
5090 " Front", " Surround", " CLFE", " Side"
5094 i = find_idx_in_nid_list(nid, pins, num_pins);
5099 if (num_pins > ARRAY_SIZE(channel_sfx)) {
5104 return channel_sfx[i];
5107 static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5108 const struct auto_pin_cfg *cfg,
5109 const char *name, char *label, int maxlen,
5112 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5113 int attr = snd_hda_get_input_pin_attr(def_conf);
5114 const char *pfx = "", *sfx = "";
5116 /* handle as a speaker if it's a fixed line-out */
5117 if (!strcmp(name, "Line-Out") && attr == INPUT_PIN_ATTR_INT)
5119 /* check the location */
5121 case INPUT_PIN_ATTR_DOCK:
5124 case INPUT_PIN_ATTR_FRONT:
5129 /* try to give a unique suffix if needed */
5130 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5133 sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5136 /* don't add channel suffix for Headphone controls */
5137 int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5144 snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5149 * snd_hda_get_pin_label - Get a label for the given I/O pin
5151 * Get a label for the given pin. This function works for both input and
5152 * output pins. When @cfg is given as non-NULL, the function tries to get
5153 * an optimized label using hda_get_autocfg_input_label().
5155 * This function tries to give a unique label string for the pin as much as
5156 * possible. For example, when the multiple line-outs are present, it adds
5157 * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5158 * If no unique name with a suffix is available and @indexp is non-NULL, the
5159 * index number is stored in the pointer.
5161 int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5162 const struct auto_pin_cfg *cfg,
5163 char *label, int maxlen, int *indexp)
5165 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5166 const char *name = NULL;
5171 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
5174 switch (get_defcfg_device(def_conf)) {
5175 case AC_JACK_LINE_OUT:
5176 return fill_audio_out_name(codec, nid, cfg, "Line-Out",
5177 label, maxlen, indexp);
5178 case AC_JACK_SPEAKER:
5179 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5180 label, maxlen, indexp);
5181 case AC_JACK_HP_OUT:
5182 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5183 label, maxlen, indexp);
5184 case AC_JACK_SPDIF_OUT:
5185 case AC_JACK_DIG_OTHER_OUT:
5186 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
5190 if (cfg && indexp) {
5191 i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5199 for (i = 0; i < cfg->num_inputs; i++) {
5200 if (cfg->inputs[i].pin != nid)
5202 name = hda_get_autocfg_input_label(codec, cfg, i);
5208 name = hda_get_input_pin_label(codec, nid, true);
5213 strlcpy(label, name, maxlen);
5216 EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5219 * snd_hda_add_imux_item - Add an item to input_mux
5221 * When the same label is used already in the existing items, the number
5222 * suffix is appended to the label. This label index number is stored
5223 * to type_idx when non-NULL pointer is given.
5225 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5226 int index, int *type_idx)
5228 int i, label_idx = 0;
5229 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5230 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5233 for (i = 0; i < imux->num_items; i++) {
5234 if (!strncmp(label, imux->items[i].label, strlen(label)))
5238 *type_idx = label_idx;
5240 snprintf(imux->items[imux->num_items].label,
5241 sizeof(imux->items[imux->num_items].label),
5242 "%s %d", label, label_idx);
5244 strlcpy(imux->items[imux->num_items].label, label,
5245 sizeof(imux->items[imux->num_items].label));
5246 imux->items[imux->num_items].index = index;
5250 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5259 * snd_hda_suspend - suspend the codecs
5262 * Returns 0 if successful.
5264 int snd_hda_suspend(struct hda_bus *bus)
5266 struct hda_codec *codec;
5268 list_for_each_entry(codec, &bus->codec_list, list) {
5269 if (hda_codec_is_power_on(codec))
5270 hda_call_codec_suspend(codec);
5271 if (codec->patch_ops.post_suspend)
5272 codec->patch_ops.post_suspend(codec);
5276 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5279 * snd_hda_resume - resume the codecs
5282 * Returns 0 if successful.
5284 * This function is defined only when POWER_SAVE isn't set.
5285 * In the power-save mode, the codec is resumed dynamically.
5287 int snd_hda_resume(struct hda_bus *bus)
5289 struct hda_codec *codec;
5291 list_for_each_entry(codec, &bus->codec_list, list) {
5292 if (codec->patch_ops.pre_resume)
5293 codec->patch_ops.pre_resume(codec);
5294 if (snd_hda_codec_needs_resume(codec))
5295 hda_call_codec_resume(codec);
5299 EXPORT_SYMBOL_HDA(snd_hda_resume);
5300 #endif /* CONFIG_PM */
5307 * snd_array_new - get a new element from the given array
5308 * @array: the array object
5310 * Get a new element from the given array. If it exceeds the
5311 * pre-allocated array size, re-allocate the array.
5313 * Returns NULL if allocation failed.
5315 void *snd_array_new(struct snd_array *array)
5317 if (array->used >= array->alloced) {
5318 int num = array->alloced + array->alloc_align;
5319 int size = (num + 1) * array->elem_size;
5320 int oldsize = array->alloced * array->elem_size;
5322 if (snd_BUG_ON(num >= 4096))
5324 nlist = krealloc(array->list, size, GFP_KERNEL);
5327 memset(nlist + oldsize, 0, size - oldsize);
5328 array->list = nlist;
5329 array->alloced = num;
5331 return snd_array_elem(array, array->used++);
5333 EXPORT_SYMBOL_HDA(snd_array_new);
5336 * snd_array_free - free the given array elements
5337 * @array: the array object
5339 void snd_array_free(struct snd_array *array)
5346 EXPORT_SYMBOL_HDA(snd_array_free);
5349 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5350 * @pcm: PCM caps bits
5351 * @buf: the string buffer to write
5352 * @buflen: the max buffer length
5354 * used by hda_proc.c and hda_eld.c
5356 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5358 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5361 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5362 if (pcm & (AC_SUPPCM_BITS_8 << i))
5363 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5365 buf[j] = '\0'; /* necessary when j == 0 */
5367 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5369 MODULE_DESCRIPTION("HDA codec core");
5370 MODULE_LICENSE("GPL");