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 <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include <sound/jack.h>
33 #include "hda_local.h"
35 #include <sound/hda_hwdep.h>
37 #define CREATE_TRACE_POINTS
38 #include "hda_trace.h"
41 * vendor / preset table
44 struct hda_vendor_id {
49 /* codec vendor labels */
50 static struct hda_vendor_id hda_vendor_ids[] = {
52 { 0x1013, "Cirrus Logic" },
53 { 0x1057, "Motorola" },
54 { 0x1095, "Silicon Image" },
56 { 0x10ec, "Realtek" },
57 { 0x1102, "Creative" },
61 { 0x11d4, "Analog Devices" },
62 { 0x13f6, "C-Media" },
63 { 0x14f1, "Conexant" },
64 { 0x17e8, "Chrontel" },
66 { 0x1aec, "Wolfson Microelectronics" },
67 { 0x434d, "C-Media" },
69 { 0x8384, "SigmaTel" },
73 static DEFINE_MUTEX(preset_mutex);
74 static LIST_HEAD(hda_preset_tables);
76 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
78 mutex_lock(&preset_mutex);
79 list_add_tail(&preset->list, &hda_preset_tables);
80 mutex_unlock(&preset_mutex);
83 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
85 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
87 mutex_lock(&preset_mutex);
88 list_del(&preset->list);
89 mutex_unlock(&preset_mutex);
92 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
94 #ifdef CONFIG_SND_HDA_POWER_SAVE
95 static void hda_power_work(struct work_struct *work);
96 static void hda_keep_power_on(struct hda_codec *codec);
97 #define hda_codec_is_power_on(codec) ((codec)->power_on)
99 static inline void hda_keep_power_on(struct hda_codec *codec) {}
100 #define hda_codec_is_power_on(codec) 1
104 * snd_hda_get_jack_location - Give a location string of the jack
105 * @cfg: pin default config value
107 * Parse the pin default config value and returns the string of the
108 * jack location, e.g. "Rear", "Front", etc.
110 const char *snd_hda_get_jack_location(u32 cfg)
112 static char *bases[7] = {
113 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
115 static unsigned char specials_idx[] = {
120 static char *specials[] = {
121 "Rear Panel", "Drive Bar",
122 "Riser", "HDMI", "ATAPI",
123 "Mobile-In", "Mobile-Out"
126 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
127 if ((cfg & 0x0f) < 7)
128 return bases[cfg & 0x0f];
129 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
130 if (cfg == specials_idx[i])
135 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
138 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
139 * @cfg: pin default config value
141 * Parse the pin default config value and returns the string of the
142 * jack connectivity, i.e. external or internal connection.
144 const char *snd_hda_get_jack_connectivity(u32 cfg)
146 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
148 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
150 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
153 * snd_hda_get_jack_type - Give a type string of the jack
154 * @cfg: pin default config value
156 * Parse the pin default config value and returns the string of the
157 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
159 const char *snd_hda_get_jack_type(u32 cfg)
161 static char *jack_types[16] = {
162 "Line Out", "Speaker", "HP Out", "CD",
163 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
164 "Line In", "Aux", "Mic", "Telephony",
165 "SPDIF In", "Digitial In", "Reserved", "Other"
168 return jack_types[(cfg & AC_DEFCFG_DEVICE)
169 >> AC_DEFCFG_DEVICE_SHIFT];
171 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
174 * Compose a 32bit command word to be sent to the HD-audio controller
176 static inline unsigned int
177 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
178 unsigned int verb, unsigned int parm)
182 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
183 (verb & ~0xfff) || (parm & ~0xffff)) {
184 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
185 codec->addr, direct, nid, verb, parm);
189 val = (u32)codec->addr << 28;
190 val |= (u32)direct << 27;
191 val |= (u32)nid << 20;
198 * Send and receive a verb
200 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
203 struct hda_bus *bus = codec->bus;
212 snd_hda_power_up(codec);
213 mutex_lock(&bus->cmd_mutex);
214 trace_hda_send_cmd(codec, cmd);
215 err = bus->ops.command(bus, cmd);
217 *res = bus->ops.get_response(bus, codec->addr);
218 trace_hda_get_response(codec, *res);
220 mutex_unlock(&bus->cmd_mutex);
221 snd_hda_power_down(codec);
222 if (res && *res == -1 && bus->rirb_error) {
223 if (bus->response_reset) {
224 snd_printd("hda_codec: resetting BUS due to "
225 "fatal communication error\n");
226 trace_hda_bus_reset(bus);
227 bus->ops.bus_reset(bus);
231 /* clear reset-flag when the communication gets recovered */
233 bus->response_reset = 0;
238 * snd_hda_codec_read - send a command and get the response
239 * @codec: the HDA codec
240 * @nid: NID to send the command
241 * @direct: direct flag
242 * @verb: the verb to send
243 * @parm: the parameter for the verb
245 * Send a single command and read the corresponding response.
247 * Returns the obtained response value, or -1 for an error.
249 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
251 unsigned int verb, unsigned int parm)
253 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
255 if (codec_exec_verb(codec, cmd, &res))
259 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
262 * snd_hda_codec_write - send a single command without waiting for response
263 * @codec: the HDA codec
264 * @nid: NID to send the command
265 * @direct: direct flag
266 * @verb: the verb to send
267 * @parm: the parameter for the verb
269 * Send a single command without waiting for response.
271 * Returns 0 if successful, or a negative error code.
273 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
274 unsigned int verb, unsigned int parm)
276 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
278 return codec_exec_verb(codec, cmd,
279 codec->bus->sync_write ? &res : NULL);
281 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
284 * snd_hda_sequence_write - sequence writes
285 * @codec: the HDA codec
286 * @seq: VERB array to send
288 * Send the commands sequentially from the given array.
289 * The array must be terminated with NID=0.
291 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
293 for (; seq->nid; seq++)
294 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
296 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
299 * snd_hda_get_sub_nodes - get the range of sub nodes
300 * @codec: the HDA codec
302 * @start_id: the pointer to store the start NID
304 * Parse the NID and store the start NID of its sub-nodes.
305 * Returns the number of sub-nodes.
307 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
312 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
315 *start_id = (parm >> 16) & 0x7fff;
316 return (int)(parm & 0x7fff);
318 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
320 /* look up the cached results */
321 static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
324 for (i = 0; i < array->used; ) {
325 hda_nid_t *p = snd_array_elem(array, i);
335 * snd_hda_get_conn_list - get connection list
336 * @codec: the HDA codec
338 * @listp: the pointer to store NID list
340 * Parses the connection list of the given widget and stores the list
343 * Returns the number of connections, or a negative error code.
345 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
346 const hda_nid_t **listp)
348 struct snd_array *array = &codec->conn_lists;
350 hda_nid_t list[HDA_MAX_CONNECTIONS];
355 /* if the connection-list is already cached, read it */
356 p = lookup_conn_list(array, nid);
362 if (snd_BUG_ON(added))
365 /* read the connection and add to the cache */
366 len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
369 err = snd_hda_override_conn_list(codec, nid, len, list);
375 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
378 * snd_hda_get_connections - copy connection list
379 * @codec: the HDA codec
381 * @conn_list: connection list array
382 * @max_conns: max. number of connections to store
384 * Parses the connection list of the given widget and stores the list
387 * Returns the number of connections, or a negative error code.
389 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
390 hda_nid_t *conn_list, int max_conns)
392 const hda_nid_t *list;
393 int len = snd_hda_get_conn_list(codec, nid, &list);
397 if (len > max_conns) {
398 snd_printk(KERN_ERR "hda_codec: "
399 "Too many connections %d for NID 0x%x\n",
403 memcpy(conn_list, list, len * sizeof(hda_nid_t));
406 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
409 * snd_hda_get_raw_connections - copy connection list without cache
410 * @codec: the HDA codec
412 * @conn_list: connection list array
413 * @max_conns: max. number of connections to store
415 * Like snd_hda_get_connections(), copy the connection list but without
416 * checking through the connection-list cache.
417 * Currently called only from hda_proc.c, so not exported.
419 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
420 hda_nid_t *conn_list, int max_conns)
423 int i, conn_len, conns;
424 unsigned int shift, num_elems, mask;
428 if (snd_BUG_ON(!conn_list || max_conns <= 0))
431 wcaps = get_wcaps(codec, nid);
432 if (!(wcaps & AC_WCAP_CONN_LIST) &&
433 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
436 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
437 if (parm & AC_CLIST_LONG) {
446 conn_len = parm & AC_CLIST_LENGTH;
447 mask = (1 << (shift-1)) - 1;
450 return 0; /* no connection */
453 /* single connection */
454 parm = snd_hda_codec_read(codec, nid, 0,
455 AC_VERB_GET_CONNECT_LIST, 0);
456 if (parm == -1 && codec->bus->rirb_error)
458 conn_list[0] = parm & mask;
462 /* multi connection */
465 for (i = 0; i < conn_len; i++) {
469 if (i % num_elems == 0) {
470 parm = snd_hda_codec_read(codec, nid, 0,
471 AC_VERB_GET_CONNECT_LIST, i);
472 if (parm == -1 && codec->bus->rirb_error)
475 range_val = !!(parm & (1 << (shift-1))); /* ranges */
478 snd_printk(KERN_WARNING "hda_codec: "
479 "invalid CONNECT_LIST verb %x[%i]:%x\n",
485 /* ranges between the previous and this one */
486 if (!prev_nid || prev_nid >= val) {
487 snd_printk(KERN_WARNING "hda_codec: "
488 "invalid dep_range_val %x:%x\n",
492 for (n = prev_nid + 1; n <= val; n++) {
493 if (conns >= max_conns) {
494 snd_printk(KERN_ERR "hda_codec: "
495 "Too many connections %d for NID 0x%x\n",
499 conn_list[conns++] = n;
502 if (conns >= max_conns) {
503 snd_printk(KERN_ERR "hda_codec: "
504 "Too many connections %d for NID 0x%x\n",
508 conn_list[conns++] = val;
515 static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
517 hda_nid_t *p = snd_array_new(array);
525 * snd_hda_override_conn_list - add/modify the connection-list to cache
526 * @codec: the HDA codec
528 * @len: number of connection list entries
529 * @list: the list of connection entries
531 * Add or modify the given connection-list to the cache. If the corresponding
532 * cache already exists, invalidate it and append a new one.
534 * Returns zero or a negative error code.
536 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
537 const hda_nid_t *list)
539 struct snd_array *array = &codec->conn_lists;
543 p = lookup_conn_list(array, nid);
545 *p = -1; /* invalidate the old entry */
547 old_used = array->used;
548 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
550 for (i = 0; i < len; i++)
551 if (!add_conn_list(array, list[i]))
556 array->used = old_used;
559 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
562 * snd_hda_get_conn_index - get the connection index of the given NID
563 * @codec: the HDA codec
564 * @mux: NID containing the list
565 * @nid: NID to select
566 * @recursive: 1 when searching NID recursively, otherwise 0
568 * Parses the connection list of the widget @mux and checks whether the
569 * widget @nid is present. If it is, return the connection index.
570 * Otherwise it returns -1.
572 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
573 hda_nid_t nid, int recursive)
575 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
578 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
579 for (i = 0; i < nums; i++)
585 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
589 for (i = 0; i < nums; i++) {
590 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
591 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
593 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
598 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
601 * snd_hda_queue_unsol_event - add an unsolicited event to queue
603 * @res: unsolicited event (lower 32bit of RIRB entry)
604 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
606 * Adds the given event to the queue. The events are processed in
607 * the workqueue asynchronously. Call this function in the interrupt
608 * hanlder when RIRB receives an unsolicited event.
610 * Returns 0 if successful, or a negative error code.
612 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
614 struct hda_bus_unsolicited *unsol;
617 trace_hda_unsol_event(bus, res, res_ex);
622 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
626 unsol->queue[wp] = res;
627 unsol->queue[wp + 1] = res_ex;
629 queue_work(bus->workq, &unsol->work);
633 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
636 * process queued unsolicited events
638 static void process_unsol_events(struct work_struct *work)
640 struct hda_bus_unsolicited *unsol =
641 container_of(work, struct hda_bus_unsolicited, work);
642 struct hda_bus *bus = unsol->bus;
643 struct hda_codec *codec;
644 unsigned int rp, caddr, res;
646 while (unsol->rp != unsol->wp) {
647 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
650 res = unsol->queue[rp];
651 caddr = unsol->queue[rp + 1];
652 if (!(caddr & (1 << 4))) /* no unsolicited event? */
654 codec = bus->caddr_tbl[caddr & 0x0f];
655 if (codec && codec->patch_ops.unsol_event)
656 codec->patch_ops.unsol_event(codec, res);
661 * initialize unsolicited queue
663 static int init_unsol_queue(struct hda_bus *bus)
665 struct hda_bus_unsolicited *unsol;
667 if (bus->unsol) /* already initialized */
670 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
672 snd_printk(KERN_ERR "hda_codec: "
673 "can't allocate unsolicited queue\n");
676 INIT_WORK(&unsol->work, process_unsol_events);
685 static void snd_hda_codec_free(struct hda_codec *codec);
687 static int snd_hda_bus_free(struct hda_bus *bus)
689 struct hda_codec *codec, *n;
694 flush_workqueue(bus->workq);
697 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
698 snd_hda_codec_free(codec);
700 if (bus->ops.private_free)
701 bus->ops.private_free(bus);
703 destroy_workqueue(bus->workq);
708 static int snd_hda_bus_dev_free(struct snd_device *device)
710 struct hda_bus *bus = device->device_data;
712 return snd_hda_bus_free(bus);
715 #ifdef CONFIG_SND_HDA_HWDEP
716 static int snd_hda_bus_dev_register(struct snd_device *device)
718 struct hda_bus *bus = device->device_data;
719 struct hda_codec *codec;
720 list_for_each_entry(codec, &bus->codec_list, list) {
721 snd_hda_hwdep_add_sysfs(codec);
722 snd_hda_hwdep_add_power_sysfs(codec);
727 #define snd_hda_bus_dev_register NULL
731 * snd_hda_bus_new - create a HDA bus
732 * @card: the card entry
733 * @temp: the template for hda_bus information
734 * @busp: the pointer to store the created bus instance
736 * Returns 0 if successful, or a negative error code.
738 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
739 const struct hda_bus_template *temp,
740 struct hda_bus **busp)
744 static struct snd_device_ops dev_ops = {
745 .dev_register = snd_hda_bus_dev_register,
746 .dev_free = snd_hda_bus_dev_free,
749 if (snd_BUG_ON(!temp))
751 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
757 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
759 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
764 bus->private_data = temp->private_data;
765 bus->pci = temp->pci;
766 bus->modelname = temp->modelname;
767 bus->power_save = temp->power_save;
768 bus->ops = temp->ops;
770 mutex_init(&bus->cmd_mutex);
771 mutex_init(&bus->prepare_mutex);
772 INIT_LIST_HEAD(&bus->codec_list);
774 snprintf(bus->workq_name, sizeof(bus->workq_name),
775 "hd-audio%d", card->number);
776 bus->workq = create_singlethread_workqueue(bus->workq_name);
778 snd_printk(KERN_ERR "cannot create workqueue %s\n",
784 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
786 snd_hda_bus_free(bus);
793 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
795 #ifdef CONFIG_SND_HDA_GENERIC
796 #define is_generic_config(codec) \
797 (codec->modelname && !strcmp(codec->modelname, "generic"))
799 #define is_generic_config(codec) 0
803 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
805 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
809 * find a matching codec preset
811 static const struct hda_codec_preset *
812 find_codec_preset(struct hda_codec *codec)
814 struct hda_codec_preset_list *tbl;
815 const struct hda_codec_preset *preset;
816 int mod_requested = 0;
818 if (is_generic_config(codec))
819 return NULL; /* use the generic parser */
822 mutex_lock(&preset_mutex);
823 list_for_each_entry(tbl, &hda_preset_tables, list) {
824 if (!try_module_get(tbl->owner)) {
825 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
828 for (preset = tbl->preset; preset->id; preset++) {
829 u32 mask = preset->mask;
830 if (preset->afg && preset->afg != codec->afg)
832 if (preset->mfg && preset->mfg != codec->mfg)
836 if (preset->id == (codec->vendor_id & mask) &&
838 preset->rev == codec->revision_id)) {
839 mutex_unlock(&preset_mutex);
840 codec->owner = tbl->owner;
844 module_put(tbl->owner);
846 mutex_unlock(&preset_mutex);
848 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
851 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
854 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
855 (codec->vendor_id >> 16) & 0xffff);
856 request_module(name);
864 * get_codec_name - store the codec name
866 static int get_codec_name(struct hda_codec *codec)
868 const struct hda_vendor_id *c;
869 const char *vendor = NULL;
870 u16 vendor_id = codec->vendor_id >> 16;
873 if (codec->vendor_name)
876 for (c = hda_vendor_ids; c->id; c++) {
877 if (c->id == vendor_id) {
883 sprintf(tmp, "Generic %04x", vendor_id);
886 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
887 if (!codec->vendor_name)
891 if (codec->chip_name)
894 if (codec->preset && codec->preset->name)
895 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
897 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
898 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
900 if (!codec->chip_name)
906 * look for an AFG and MFG nodes
908 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
910 int i, total_nodes, function_id;
913 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
914 for (i = 0; i < total_nodes; i++, nid++) {
915 function_id = snd_hda_param_read(codec, nid,
916 AC_PAR_FUNCTION_TYPE);
917 switch (function_id & 0xff) {
918 case AC_GRP_AUDIO_FUNCTION:
920 codec->afg_function_id = function_id & 0xff;
921 codec->afg_unsol = (function_id >> 8) & 1;
923 case AC_GRP_MODEM_FUNCTION:
925 codec->mfg_function_id = function_id & 0xff;
926 codec->mfg_unsol = (function_id >> 8) & 1;
935 * read widget caps for each widget and store in cache
937 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
942 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
944 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
947 nid = codec->start_nid;
948 for (i = 0; i < codec->num_nodes; i++, nid++)
949 codec->wcaps[i] = snd_hda_param_read(codec, nid,
950 AC_PAR_AUDIO_WIDGET_CAP);
954 /* read all pin default configurations and save codec->init_pins */
955 static int read_pin_defaults(struct hda_codec *codec)
958 hda_nid_t nid = codec->start_nid;
960 for (i = 0; i < codec->num_nodes; i++, nid++) {
961 struct hda_pincfg *pin;
962 unsigned int wcaps = get_wcaps(codec, nid);
963 unsigned int wid_type = get_wcaps_type(wcaps);
964 if (wid_type != AC_WID_PIN)
966 pin = snd_array_new(&codec->init_pins);
970 pin->cfg = snd_hda_codec_read(codec, nid, 0,
971 AC_VERB_GET_CONFIG_DEFAULT, 0);
972 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_PIN_WIDGET_CONTROL,
979 /* look up the given pin config list and return the item matching with NID */
980 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
981 struct snd_array *array,
985 for (i = 0; i < array->used; i++) {
986 struct hda_pincfg *pin = snd_array_elem(array, i);
993 /* write a config value for the given NID */
994 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
998 for (i = 0; i < 4; i++) {
999 snd_hda_codec_write(codec, nid, 0,
1000 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1006 /* set the current pin config value for the given NID.
1007 * the value is cached, and read via snd_hda_codec_get_pincfg()
1009 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1010 hda_nid_t nid, unsigned int cfg)
1012 struct hda_pincfg *pin;
1013 unsigned int oldcfg;
1015 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1018 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
1019 pin = look_up_pincfg(codec, list, nid);
1021 pin = snd_array_new(list);
1028 /* change only when needed; e.g. if the pincfg is already present
1029 * in user_pins[], don't write it
1031 cfg = snd_hda_codec_get_pincfg(codec, nid);
1033 set_pincfg(codec, nid, cfg);
1038 * snd_hda_codec_set_pincfg - Override a pin default configuration
1039 * @codec: the HDA codec
1040 * @nid: NID to set the pin config
1041 * @cfg: the pin default config value
1043 * Override a pin default configuration value in the cache.
1044 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1045 * priority than the real hardware value.
1047 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1048 hda_nid_t nid, unsigned int cfg)
1050 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1052 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1055 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1056 * @codec: the HDA codec
1057 * @nid: NID to get the pin config
1059 * Get the current pin config value of the given pin NID.
1060 * If the pincfg value is cached or overridden via sysfs or driver,
1061 * returns the cached value.
1063 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1065 struct hda_pincfg *pin;
1067 #ifdef CONFIG_SND_HDA_HWDEP
1068 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1072 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1075 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1080 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1082 /* restore all current pin configs */
1083 static void restore_pincfgs(struct hda_codec *codec)
1086 for (i = 0; i < codec->init_pins.used; i++) {
1087 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1088 set_pincfg(codec, pin->nid,
1089 snd_hda_codec_get_pincfg(codec, pin->nid));
1094 * snd_hda_shutup_pins - Shut up all pins
1095 * @codec: the HDA codec
1097 * Clear all pin controls to shup up before suspend for avoiding click noise.
1098 * The controls aren't cached so that they can be resumed properly.
1100 void snd_hda_shutup_pins(struct hda_codec *codec)
1103 /* don't shut up pins when unloading the driver; otherwise it breaks
1104 * the default pin setup at the next load of the driver
1106 if (codec->bus->shutdown)
1108 for (i = 0; i < codec->init_pins.used; i++) {
1109 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1110 /* use read here for syncing after issuing each verb */
1111 snd_hda_codec_read(codec, pin->nid, 0,
1112 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1114 codec->pins_shutup = 1;
1116 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1119 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1120 static void restore_shutup_pins(struct hda_codec *codec)
1123 if (!codec->pins_shutup)
1125 if (codec->bus->shutdown)
1127 for (i = 0; i < codec->init_pins.used; i++) {
1128 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1129 snd_hda_codec_write(codec, pin->nid, 0,
1130 AC_VERB_SET_PIN_WIDGET_CONTROL,
1133 codec->pins_shutup = 0;
1137 static void init_hda_cache(struct hda_cache_rec *cache,
1138 unsigned int record_size);
1139 static void free_hda_cache(struct hda_cache_rec *cache);
1141 /* restore the initial pin cfgs and release all pincfg lists */
1142 static void restore_init_pincfgs(struct hda_codec *codec)
1144 /* first free driver_pins and user_pins, then call restore_pincfg
1145 * so that only the values in init_pins are restored
1147 snd_array_free(&codec->driver_pins);
1148 #ifdef CONFIG_SND_HDA_HWDEP
1149 snd_array_free(&codec->user_pins);
1151 restore_pincfgs(codec);
1152 snd_array_free(&codec->init_pins);
1156 * audio-converter setup caches
1158 struct hda_cvt_setup {
1163 unsigned char active; /* cvt is currently used */
1164 unsigned char dirty; /* setups should be cleared */
1167 /* get or create a cache entry for the given audio converter NID */
1168 static struct hda_cvt_setup *
1169 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1171 struct hda_cvt_setup *p;
1174 for (i = 0; i < codec->cvt_setups.used; i++) {
1175 p = snd_array_elem(&codec->cvt_setups, i);
1179 p = snd_array_new(&codec->cvt_setups);
1188 static void snd_hda_codec_free(struct hda_codec *codec)
1192 restore_init_pincfgs(codec);
1193 #ifdef CONFIG_SND_HDA_POWER_SAVE
1194 cancel_delayed_work(&codec->power_work);
1195 flush_workqueue(codec->bus->workq);
1197 list_del(&codec->list);
1198 snd_array_free(&codec->mixers);
1199 snd_array_free(&codec->nids);
1200 snd_array_free(&codec->conn_lists);
1201 snd_array_free(&codec->spdif_out);
1202 codec->bus->caddr_tbl[codec->addr] = NULL;
1203 if (codec->patch_ops.free)
1204 codec->patch_ops.free(codec);
1205 module_put(codec->owner);
1206 free_hda_cache(&codec->amp_cache);
1207 free_hda_cache(&codec->cmd_cache);
1208 kfree(codec->vendor_name);
1209 kfree(codec->chip_name);
1210 kfree(codec->modelname);
1211 kfree(codec->wcaps);
1215 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1216 unsigned int power_state);
1219 * snd_hda_codec_new - create a HDA codec
1220 * @bus: the bus to assign
1221 * @codec_addr: the codec address
1222 * @codecp: the pointer to store the generated codec
1224 * Returns 0 if successful, or a negative error code.
1226 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1227 unsigned int codec_addr,
1228 struct hda_codec **codecp)
1230 struct hda_codec *codec;
1234 if (snd_BUG_ON(!bus))
1236 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1239 if (bus->caddr_tbl[codec_addr]) {
1240 snd_printk(KERN_ERR "hda_codec: "
1241 "address 0x%x is already occupied\n", codec_addr);
1245 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1246 if (codec == NULL) {
1247 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1252 codec->addr = codec_addr;
1253 mutex_init(&codec->spdif_mutex);
1254 mutex_init(&codec->control_mutex);
1255 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1256 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1257 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1258 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1259 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1260 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1261 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1262 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
1263 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1264 if (codec->bus->modelname) {
1265 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1266 if (!codec->modelname) {
1267 snd_hda_codec_free(codec);
1272 #ifdef CONFIG_SND_HDA_POWER_SAVE
1273 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1274 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1275 * the caller has to power down appropriatley after initialization
1278 hda_keep_power_on(codec);
1281 list_add_tail(&codec->list, &bus->codec_list);
1282 bus->caddr_tbl[codec_addr] = codec;
1284 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1286 if (codec->vendor_id == -1)
1287 /* read again, hopefully the access method was corrected
1288 * in the last read...
1290 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1292 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1293 AC_PAR_SUBSYSTEM_ID);
1294 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1297 setup_fg_nodes(codec);
1298 if (!codec->afg && !codec->mfg) {
1299 snd_printdd("hda_codec: no AFG or MFG node found\n");
1304 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1306 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1309 err = read_pin_defaults(codec);
1313 if (!codec->subsystem_id) {
1314 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1315 codec->subsystem_id =
1316 snd_hda_codec_read(codec, nid, 0,
1317 AC_VERB_GET_SUBSYSTEM_ID, 0);
1320 /* power-up all before initialization */
1321 hda_set_power_state(codec,
1322 codec->afg ? codec->afg : codec->mfg,
1325 snd_hda_codec_proc_new(codec);
1327 snd_hda_create_hwdep(codec);
1329 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1330 codec->subsystem_id, codec->revision_id);
1331 snd_component_add(codec->bus->card, component);
1338 snd_hda_codec_free(codec);
1341 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1344 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1345 * @codec: the HDA codec
1347 * Start parsing of the given codec tree and (re-)initialize the whole
1350 * Returns 0 if successful or a negative error code.
1352 int snd_hda_codec_configure(struct hda_codec *codec)
1356 codec->preset = find_codec_preset(codec);
1357 if (!codec->vendor_name || !codec->chip_name) {
1358 err = get_codec_name(codec);
1363 if (is_generic_config(codec)) {
1364 err = snd_hda_parse_generic_codec(codec);
1367 if (codec->preset && codec->preset->patch) {
1368 err = codec->preset->patch(codec);
1372 /* call the default parser */
1373 err = snd_hda_parse_generic_codec(codec);
1375 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1378 if (!err && codec->patch_ops.unsol_event)
1379 err = init_unsol_queue(codec->bus);
1380 /* audio codec should override the mixer name */
1381 if (!err && (codec->afg || !*codec->bus->card->mixername))
1382 snprintf(codec->bus->card->mixername,
1383 sizeof(codec->bus->card->mixername),
1384 "%s %s", codec->vendor_name, codec->chip_name);
1387 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1390 * snd_hda_codec_setup_stream - set up the codec for streaming
1391 * @codec: the CODEC to set up
1392 * @nid: the NID to set up
1393 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1394 * @channel_id: channel id to pass, zero based.
1395 * @format: stream format.
1397 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1399 int channel_id, int format)
1401 struct hda_codec *c;
1402 struct hda_cvt_setup *p;
1403 unsigned int oldval, newval;
1410 snd_printdd("hda_codec_setup_stream: "
1411 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1412 nid, stream_tag, channel_id, format);
1413 p = get_hda_cvt_setup(codec, nid);
1416 /* update the stream-id if changed */
1417 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1418 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1419 newval = (stream_tag << 4) | channel_id;
1420 if (oldval != newval)
1421 snd_hda_codec_write(codec, nid, 0,
1422 AC_VERB_SET_CHANNEL_STREAMID,
1424 p->stream_tag = stream_tag;
1425 p->channel_id = channel_id;
1427 /* update the format-id if changed */
1428 if (p->format_id != format) {
1429 oldval = snd_hda_codec_read(codec, nid, 0,
1430 AC_VERB_GET_STREAM_FORMAT, 0);
1431 if (oldval != format) {
1433 snd_hda_codec_write(codec, nid, 0,
1434 AC_VERB_SET_STREAM_FORMAT,
1437 p->format_id = format;
1442 /* make other inactive cvts with the same stream-tag dirty */
1443 type = get_wcaps_type(get_wcaps(codec, nid));
1444 list_for_each_entry(c, &codec->bus->codec_list, list) {
1445 for (i = 0; i < c->cvt_setups.used; i++) {
1446 p = snd_array_elem(&c->cvt_setups, i);
1447 if (!p->active && p->stream_tag == stream_tag &&
1448 get_wcaps_type(get_wcaps(codec, p->nid)) == type)
1453 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1455 static void really_cleanup_stream(struct hda_codec *codec,
1456 struct hda_cvt_setup *q);
1459 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1460 * @codec: the CODEC to clean up
1461 * @nid: the NID to clean up
1462 * @do_now: really clean up the stream instead of clearing the active flag
1464 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1467 struct hda_cvt_setup *p;
1472 if (codec->no_sticky_stream)
1475 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1476 p = get_hda_cvt_setup(codec, nid);
1478 /* here we just clear the active flag when do_now isn't set;
1479 * actual clean-ups will be done later in
1480 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1483 really_cleanup_stream(codec, p);
1488 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1490 static void really_cleanup_stream(struct hda_codec *codec,
1491 struct hda_cvt_setup *q)
1493 hda_nid_t nid = q->nid;
1494 if (q->stream_tag || q->channel_id)
1495 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1497 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1499 memset(q, 0, sizeof(*q));
1503 /* clean up the all conflicting obsolete streams */
1504 static void purify_inactive_streams(struct hda_codec *codec)
1506 struct hda_codec *c;
1509 list_for_each_entry(c, &codec->bus->codec_list, list) {
1510 for (i = 0; i < c->cvt_setups.used; i++) {
1511 struct hda_cvt_setup *p;
1512 p = snd_array_elem(&c->cvt_setups, i);
1514 really_cleanup_stream(c, p);
1520 /* clean up all streams; called from suspend */
1521 static void hda_cleanup_all_streams(struct hda_codec *codec)
1525 for (i = 0; i < codec->cvt_setups.used; i++) {
1526 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1528 really_cleanup_stream(codec, p);
1534 * amp access functions
1537 /* FIXME: more better hash key? */
1538 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1539 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1540 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1541 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1542 #define INFO_AMP_CAPS (1<<0)
1543 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1545 /* initialize the hash table */
1546 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1547 unsigned int record_size)
1549 memset(cache, 0, sizeof(*cache));
1550 memset(cache->hash, 0xff, sizeof(cache->hash));
1551 snd_array_init(&cache->buf, record_size, 64);
1554 static void free_hda_cache(struct hda_cache_rec *cache)
1556 snd_array_free(&cache->buf);
1559 /* query the hash. allocate an entry if not found. */
1560 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1562 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1563 u16 cur = cache->hash[idx];
1564 struct hda_cache_head *info;
1566 while (cur != 0xffff) {
1567 info = snd_array_elem(&cache->buf, cur);
1568 if (info->key == key)
1575 /* query the hash. allocate an entry if not found. */
1576 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1579 struct hda_cache_head *info = get_hash(cache, key);
1582 /* add a new hash entry */
1583 info = snd_array_new(&cache->buf);
1586 cur = snd_array_index(&cache->buf, info);
1589 idx = key % (u16)ARRAY_SIZE(cache->hash);
1590 info->next = cache->hash[idx];
1591 cache->hash[idx] = cur;
1596 /* query and allocate an amp hash entry */
1597 static inline struct hda_amp_info *
1598 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1600 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1604 * query_amp_caps - query AMP capabilities
1605 * @codec: the HD-auio codec
1606 * @nid: the NID to query
1607 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1609 * Query AMP capabilities for the given widget and direction.
1610 * Returns the obtained capability bits.
1612 * When cap bits have been already read, this doesn't read again but
1613 * returns the cached value.
1615 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1617 struct hda_amp_info *info;
1619 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1622 if (!(info->head.val & INFO_AMP_CAPS)) {
1623 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1625 info->amp_caps = snd_hda_param_read(codec, nid,
1626 direction == HDA_OUTPUT ?
1627 AC_PAR_AMP_OUT_CAP :
1630 info->head.val |= INFO_AMP_CAPS;
1632 return info->amp_caps;
1634 EXPORT_SYMBOL_HDA(query_amp_caps);
1637 * snd_hda_override_amp_caps - Override the AMP capabilities
1638 * @codec: the CODEC to clean up
1639 * @nid: the NID to clean up
1640 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1641 * @caps: the capability bits to set
1643 * Override the cached AMP caps bits value by the given one.
1644 * This function is useful if the driver needs to adjust the AMP ranges,
1645 * e.g. limit to 0dB, etc.
1647 * Returns zero if successful or a negative error code.
1649 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1652 struct hda_amp_info *info;
1654 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1657 info->amp_caps = caps;
1658 info->head.val |= INFO_AMP_CAPS;
1661 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1664 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1665 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1667 struct hda_amp_info *info;
1669 info = get_alloc_amp_hash(codec, key);
1672 if (!info->head.val) {
1673 info->head.val |= INFO_AMP_CAPS;
1674 info->amp_caps = func(codec, nid);
1676 return info->amp_caps;
1679 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1681 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1685 * snd_hda_query_pin_caps - Query PIN capabilities
1686 * @codec: the HD-auio codec
1687 * @nid: the NID to query
1689 * Query PIN capabilities for the given widget.
1690 * Returns the obtained capability bits.
1692 * When cap bits have been already read, this doesn't read again but
1693 * returns the cached value.
1695 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1697 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1700 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1703 * snd_hda_override_pin_caps - Override the pin capabilities
1705 * @nid: the NID to override
1706 * @caps: the capability bits to set
1708 * Override the cached PIN capabilitiy bits value by the given one.
1710 * Returns zero if successful or a negative error code.
1712 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1715 struct hda_amp_info *info;
1716 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1719 info->amp_caps = caps;
1720 info->head.val |= INFO_AMP_CAPS;
1723 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1726 * snd_hda_pin_sense - execute pin sense measurement
1727 * @codec: the CODEC to sense
1728 * @nid: the pin NID to sense
1730 * Execute necessary pin sense measurement and return its Presence Detect,
1731 * Impedance, ELD Valid etc. status bits.
1733 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1737 if (!codec->no_trigger_sense) {
1738 pincap = snd_hda_query_pin_caps(codec, nid);
1739 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1740 snd_hda_codec_read(codec, nid, 0,
1741 AC_VERB_SET_PIN_SENSE, 0);
1743 return snd_hda_codec_read(codec, nid, 0,
1744 AC_VERB_GET_PIN_SENSE, 0);
1746 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1749 * snd_hda_jack_detect - query pin Presence Detect status
1750 * @codec: the CODEC to sense
1751 * @nid: the pin NID to sense
1753 * Query and return the pin's Presence Detect status.
1755 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1757 u32 sense = snd_hda_pin_sense(codec, nid);
1758 return !!(sense & AC_PINSENSE_PRESENCE);
1760 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1763 * read the current volume to info
1764 * if the cache exists, read the cache value.
1766 static unsigned int get_vol_mute(struct hda_codec *codec,
1767 struct hda_amp_info *info, hda_nid_t nid,
1768 int ch, int direction, int index)
1772 if (info->head.val & INFO_AMP_VOL(ch))
1773 return info->vol[ch];
1775 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1776 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1778 val = snd_hda_codec_read(codec, nid, 0,
1779 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1780 info->vol[ch] = val & 0xff;
1781 info->head.val |= INFO_AMP_VOL(ch);
1782 return info->vol[ch];
1786 * write the current volume in info to the h/w and update the cache
1788 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1789 hda_nid_t nid, int ch, int direction, int index,
1794 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1795 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1796 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1798 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1799 info->vol[ch] = val;
1803 * snd_hda_codec_amp_read - Read AMP value
1804 * @codec: HD-audio codec
1805 * @nid: NID to read the AMP value
1806 * @ch: channel (left=0 or right=1)
1807 * @direction: #HDA_INPUT or #HDA_OUTPUT
1808 * @index: the index value (only for input direction)
1810 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1812 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1813 int direction, int index)
1815 struct hda_amp_info *info;
1816 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1819 return get_vol_mute(codec, info, nid, ch, direction, index);
1821 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1824 * snd_hda_codec_amp_update - update the AMP value
1825 * @codec: HD-audio codec
1826 * @nid: NID to read the AMP value
1827 * @ch: channel (left=0 or right=1)
1828 * @direction: #HDA_INPUT or #HDA_OUTPUT
1829 * @idx: the index value (only for input direction)
1830 * @mask: bit mask to set
1831 * @val: the bits value to set
1833 * Update the AMP value with a bit mask.
1834 * Returns 0 if the value is unchanged, 1 if changed.
1836 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1837 int direction, int idx, int mask, int val)
1839 struct hda_amp_info *info;
1841 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1844 if (snd_BUG_ON(mask & ~0xff))
1847 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1848 if (info->vol[ch] == val)
1850 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1853 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1856 * snd_hda_codec_amp_stereo - update the AMP stereo values
1857 * @codec: HD-audio codec
1858 * @nid: NID to read the AMP value
1859 * @direction: #HDA_INPUT or #HDA_OUTPUT
1860 * @idx: the index value (only for input direction)
1861 * @mask: bit mask to set
1862 * @val: the bits value to set
1864 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1865 * stereo widget with the same mask and value.
1867 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1868 int direction, int idx, int mask, int val)
1872 if (snd_BUG_ON(mask & ~0xff))
1874 for (ch = 0; ch < 2; ch++)
1875 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1879 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1883 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1884 * @codec: HD-audio codec
1886 * Resume the all amp commands from the cache.
1888 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1890 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1893 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1894 u32 key = buffer->head.key;
1896 unsigned int idx, dir, ch;
1900 idx = (key >> 16) & 0xff;
1901 dir = (key >> 24) & 0xff;
1902 for (ch = 0; ch < 2; ch++) {
1903 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1905 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1910 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1911 #endif /* CONFIG_PM */
1913 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1916 u32 caps = query_amp_caps(codec, nid, dir);
1918 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1925 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1927 * The control element is supposed to have the private_value field
1928 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1930 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1931 struct snd_ctl_elem_info *uinfo)
1933 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1934 u16 nid = get_amp_nid(kcontrol);
1935 u8 chs = get_amp_channels(kcontrol);
1936 int dir = get_amp_direction(kcontrol);
1937 unsigned int ofs = get_amp_offset(kcontrol);
1939 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1940 uinfo->count = chs == 3 ? 2 : 1;
1941 uinfo->value.integer.min = 0;
1942 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1943 if (!uinfo->value.integer.max) {
1944 printk(KERN_WARNING "hda_codec: "
1945 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1951 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1954 static inline unsigned int
1955 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1956 int ch, int dir, int idx, unsigned int ofs)
1959 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1960 val &= HDA_AMP_VOLMASK;
1969 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1970 int ch, int dir, int idx, unsigned int ofs,
1973 unsigned int maxval;
1977 /* ofs = 0: raw max value */
1978 maxval = get_amp_max_value(codec, nid, dir, 0);
1981 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1982 HDA_AMP_VOLMASK, val);
1986 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1988 * The control element is supposed to have the private_value field
1989 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1991 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1992 struct snd_ctl_elem_value *ucontrol)
1994 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1995 hda_nid_t nid = get_amp_nid(kcontrol);
1996 int chs = get_amp_channels(kcontrol);
1997 int dir = get_amp_direction(kcontrol);
1998 int idx = get_amp_index(kcontrol);
1999 unsigned int ofs = get_amp_offset(kcontrol);
2000 long *valp = ucontrol->value.integer.value;
2003 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2005 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2008 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2011 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2013 * The control element is supposed to have the private_value field
2014 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2016 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2017 struct snd_ctl_elem_value *ucontrol)
2019 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2020 hda_nid_t nid = get_amp_nid(kcontrol);
2021 int chs = get_amp_channels(kcontrol);
2022 int dir = get_amp_direction(kcontrol);
2023 int idx = get_amp_index(kcontrol);
2024 unsigned int ofs = get_amp_offset(kcontrol);
2025 long *valp = ucontrol->value.integer.value;
2028 snd_hda_power_up(codec);
2030 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2034 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2035 snd_hda_power_down(codec);
2038 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2041 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2043 * The control element is supposed to have the private_value field
2044 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2046 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2047 unsigned int size, unsigned int __user *_tlv)
2049 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2050 hda_nid_t nid = get_amp_nid(kcontrol);
2051 int dir = get_amp_direction(kcontrol);
2052 unsigned int ofs = get_amp_offset(kcontrol);
2053 bool min_mute = get_amp_min_mute(kcontrol);
2054 u32 caps, val1, val2;
2056 if (size < 4 * sizeof(unsigned int))
2058 caps = query_amp_caps(codec, nid, dir);
2059 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2060 val2 = (val2 + 1) * 25;
2061 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2063 val1 = ((int)val1) * ((int)val2);
2065 val2 |= TLV_DB_SCALE_MUTE;
2066 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2068 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2070 if (put_user(val1, _tlv + 2))
2072 if (put_user(val2, _tlv + 3))
2076 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2079 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2080 * @codec: HD-audio codec
2081 * @nid: NID of a reference widget
2082 * @dir: #HDA_INPUT or #HDA_OUTPUT
2083 * @tlv: TLV data to be stored, at least 4 elements
2085 * Set (static) TLV data for a virtual master volume using the AMP caps
2086 * obtained from the reference NID.
2087 * The volume range is recalculated as if the max volume is 0dB.
2089 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2095 caps = query_amp_caps(codec, nid, dir);
2096 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2097 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2098 step = (step + 1) * 25;
2099 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2100 tlv[1] = 2 * sizeof(unsigned int);
2101 tlv[2] = -nums * step;
2104 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2106 /* find a mixer control element with the given name */
2107 static struct snd_kcontrol *
2108 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
2109 const char *name, int idx)
2111 struct snd_ctl_elem_id id;
2112 memset(&id, 0, sizeof(id));
2113 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2115 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2117 strcpy(id.name, name);
2118 return snd_ctl_find_id(codec->bus->card, &id);
2122 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2123 * @codec: HD-audio codec
2124 * @name: ctl id name string
2126 * Get the control element with the given id string and IFACE_MIXER.
2128 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2131 return _snd_hda_find_mixer_ctl(codec, name, 0);
2133 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2135 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2138 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2139 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2146 * snd_hda_ctl_add - Add a control element and assign to the codec
2147 * @codec: HD-audio codec
2148 * @nid: corresponding NID (optional)
2149 * @kctl: the control element to assign
2151 * Add the given control element to an array inside the codec instance.
2152 * All control elements belonging to a codec are supposed to be added
2153 * by this function so that a proper clean-up works at the free or
2154 * reconfiguration time.
2156 * If non-zero @nid is passed, the NID is assigned to the control element.
2157 * The assignment is shown in the codec proc file.
2159 * snd_hda_ctl_add() checks the control subdev id field whether
2160 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2161 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2162 * specifies if kctl->private_value is a HDA amplifier value.
2164 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2165 struct snd_kcontrol *kctl)
2168 unsigned short flags = 0;
2169 struct hda_nid_item *item;
2171 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2172 flags |= HDA_NID_ITEM_AMP;
2174 nid = get_amp_nid_(kctl->private_value);
2176 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2177 nid = kctl->id.subdevice & 0xffff;
2178 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2179 kctl->id.subdevice = 0;
2180 err = snd_ctl_add(codec->bus->card, kctl);
2183 item = snd_array_new(&codec->mixers);
2188 item->flags = flags;
2191 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2194 * snd_hda_add_nid - Assign a NID to a control element
2195 * @codec: HD-audio codec
2196 * @nid: corresponding NID (optional)
2197 * @kctl: the control element to assign
2198 * @index: index to kctl
2200 * Add the given control element to an array inside the codec instance.
2201 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2202 * NID:KCTL mapping - for example "Capture Source" selector.
2204 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2205 unsigned int index, hda_nid_t nid)
2207 struct hda_nid_item *item;
2210 item = snd_array_new(&codec->nids);
2214 item->index = index;
2218 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2219 kctl->id.name, kctl->id.index, index);
2222 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2225 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2226 * @codec: HD-audio codec
2228 void snd_hda_ctls_clear(struct hda_codec *codec)
2231 struct hda_nid_item *items = codec->mixers.list;
2232 for (i = 0; i < codec->mixers.used; i++)
2233 snd_ctl_remove(codec->bus->card, items[i].kctl);
2234 snd_array_free(&codec->mixers);
2235 snd_array_free(&codec->nids);
2238 /* pseudo device locking
2239 * toggle card->shutdown to allow/disallow the device access (as a hack)
2241 static int hda_lock_devices(struct snd_card *card)
2243 spin_lock(&card->files_lock);
2244 if (card->shutdown) {
2245 spin_unlock(&card->files_lock);
2249 spin_unlock(&card->files_lock);
2253 static void hda_unlock_devices(struct snd_card *card)
2255 spin_lock(&card->files_lock);
2257 spin_unlock(&card->files_lock);
2261 * snd_hda_codec_reset - Clear all objects assigned to the codec
2262 * @codec: HD-audio codec
2264 * This frees the all PCM and control elements assigned to the codec, and
2265 * clears the caches and restores the pin default configurations.
2267 * When a device is being used, it returns -EBSY. If successfully freed,
2270 int snd_hda_codec_reset(struct hda_codec *codec)
2272 struct snd_card *card = codec->bus->card;
2275 if (hda_lock_devices(card) < 0)
2277 /* check whether the codec isn't used by any mixer or PCM streams */
2278 if (!list_empty(&card->ctl_files)) {
2279 hda_unlock_devices(card);
2282 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2283 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2286 if (cpcm->pcm->streams[0].substream_opened ||
2287 cpcm->pcm->streams[1].substream_opened) {
2288 hda_unlock_devices(card);
2293 /* OK, let it free */
2295 #ifdef CONFIG_SND_HDA_POWER_SAVE
2296 cancel_delayed_work(&codec->power_work);
2297 flush_workqueue(codec->bus->workq);
2299 snd_hda_ctls_clear(codec);
2301 for (i = 0; i < codec->num_pcms; i++) {
2302 if (codec->pcm_info[i].pcm) {
2303 snd_device_free(card, codec->pcm_info[i].pcm);
2304 clear_bit(codec->pcm_info[i].device,
2305 codec->bus->pcm_dev_bits);
2308 if (codec->patch_ops.free)
2309 codec->patch_ops.free(codec);
2310 codec->proc_widget_hook = NULL;
2312 free_hda_cache(&codec->amp_cache);
2313 free_hda_cache(&codec->cmd_cache);
2314 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2315 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2316 /* free only driver_pins so that init_pins + user_pins are restored */
2317 snd_array_free(&codec->driver_pins);
2318 restore_pincfgs(codec);
2319 codec->num_pcms = 0;
2320 codec->pcm_info = NULL;
2321 codec->preset = NULL;
2322 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2323 codec->slave_dig_outs = NULL;
2324 codec->spdif_status_reset = 0;
2325 module_put(codec->owner);
2326 codec->owner = NULL;
2328 /* allow device access again */
2329 hda_unlock_devices(card);
2334 * snd_hda_add_vmaster - create a virtual master control and add slaves
2335 * @codec: HD-audio codec
2336 * @name: vmaster control name
2337 * @tlv: TLV data (optional)
2338 * @slaves: slave control names (optional)
2340 * Create a virtual master control with the given name. The TLV data
2341 * must be either NULL or a valid data.
2343 * @slaves is a NULL-terminated array of strings, each of which is a
2344 * slave control name. All controls with these names are assigned to
2345 * the new virtual master control.
2347 * This function returns zero if successful or a negative error code.
2349 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2350 unsigned int *tlv, const char * const *slaves)
2352 struct snd_kcontrol *kctl;
2353 const char * const *s;
2356 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
2359 snd_printdd("No slave found for %s\n", name);
2362 kctl = snd_ctl_make_virtual_master(name, tlv);
2365 err = snd_hda_ctl_add(codec, 0, kctl);
2369 for (s = slaves; *s; s++) {
2370 struct snd_kcontrol *sctl;
2373 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
2376 snd_printdd("Cannot find slave %s, "
2380 err = snd_ctl_add_slave(kctl, sctl);
2388 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2391 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2393 * The control element is supposed to have the private_value field
2394 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2396 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2397 struct snd_ctl_elem_info *uinfo)
2399 int chs = get_amp_channels(kcontrol);
2401 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2402 uinfo->count = chs == 3 ? 2 : 1;
2403 uinfo->value.integer.min = 0;
2404 uinfo->value.integer.max = 1;
2407 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2410 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2412 * The control element is supposed to have the private_value field
2413 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2415 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2416 struct snd_ctl_elem_value *ucontrol)
2418 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2419 hda_nid_t nid = get_amp_nid(kcontrol);
2420 int chs = get_amp_channels(kcontrol);
2421 int dir = get_amp_direction(kcontrol);
2422 int idx = get_amp_index(kcontrol);
2423 long *valp = ucontrol->value.integer.value;
2426 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2427 HDA_AMP_MUTE) ? 0 : 1;
2429 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2430 HDA_AMP_MUTE) ? 0 : 1;
2433 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2436 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2438 * The control element is supposed to have the private_value field
2439 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2441 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2442 struct snd_ctl_elem_value *ucontrol)
2444 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2445 hda_nid_t nid = get_amp_nid(kcontrol);
2446 int chs = get_amp_channels(kcontrol);
2447 int dir = get_amp_direction(kcontrol);
2448 int idx = get_amp_index(kcontrol);
2449 long *valp = ucontrol->value.integer.value;
2452 snd_hda_power_up(codec);
2454 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2456 *valp ? 0 : HDA_AMP_MUTE);
2460 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2462 *valp ? 0 : HDA_AMP_MUTE);
2463 hda_call_check_power_status(codec, nid);
2464 snd_hda_power_down(codec);
2467 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2469 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2471 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2473 * This function calls snd_hda_enable_beep_device(), which behaves differently
2474 * depending on beep_mode option.
2476 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2477 struct snd_ctl_elem_value *ucontrol)
2479 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2480 long *valp = ucontrol->value.integer.value;
2482 snd_hda_enable_beep_device(codec, *valp);
2483 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2485 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2486 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2489 * bound volume controls
2491 * bind multiple volumes (# indices, from 0)
2494 #define AMP_VAL_IDX_SHIFT 19
2495 #define AMP_VAL_IDX_MASK (0x0f<<19)
2498 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2500 * The control element is supposed to have the private_value field
2501 * set up via HDA_BIND_MUTE*() macros.
2503 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2504 struct snd_ctl_elem_value *ucontrol)
2506 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2510 mutex_lock(&codec->control_mutex);
2511 pval = kcontrol->private_value;
2512 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2513 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2514 kcontrol->private_value = pval;
2515 mutex_unlock(&codec->control_mutex);
2518 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2521 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2523 * The control element is supposed to have the private_value field
2524 * set up via HDA_BIND_MUTE*() macros.
2526 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2527 struct snd_ctl_elem_value *ucontrol)
2529 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2531 int i, indices, err = 0, change = 0;
2533 mutex_lock(&codec->control_mutex);
2534 pval = kcontrol->private_value;
2535 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2536 for (i = 0; i < indices; i++) {
2537 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2538 (i << AMP_VAL_IDX_SHIFT);
2539 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2544 kcontrol->private_value = pval;
2545 mutex_unlock(&codec->control_mutex);
2546 return err < 0 ? err : change;
2548 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2551 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2553 * The control element is supposed to have the private_value field
2554 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2556 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2557 struct snd_ctl_elem_info *uinfo)
2559 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2560 struct hda_bind_ctls *c;
2563 mutex_lock(&codec->control_mutex);
2564 c = (struct hda_bind_ctls *)kcontrol->private_value;
2565 kcontrol->private_value = *c->values;
2566 err = c->ops->info(kcontrol, uinfo);
2567 kcontrol->private_value = (long)c;
2568 mutex_unlock(&codec->control_mutex);
2571 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2574 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2576 * The control element is supposed to have the private_value field
2577 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2579 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2580 struct snd_ctl_elem_value *ucontrol)
2582 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2583 struct hda_bind_ctls *c;
2586 mutex_lock(&codec->control_mutex);
2587 c = (struct hda_bind_ctls *)kcontrol->private_value;
2588 kcontrol->private_value = *c->values;
2589 err = c->ops->get(kcontrol, ucontrol);
2590 kcontrol->private_value = (long)c;
2591 mutex_unlock(&codec->control_mutex);
2594 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2597 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2599 * The control element is supposed to have the private_value field
2600 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2602 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2603 struct snd_ctl_elem_value *ucontrol)
2605 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2606 struct hda_bind_ctls *c;
2607 unsigned long *vals;
2608 int err = 0, change = 0;
2610 mutex_lock(&codec->control_mutex);
2611 c = (struct hda_bind_ctls *)kcontrol->private_value;
2612 for (vals = c->values; *vals; vals++) {
2613 kcontrol->private_value = *vals;
2614 err = c->ops->put(kcontrol, ucontrol);
2619 kcontrol->private_value = (long)c;
2620 mutex_unlock(&codec->control_mutex);
2621 return err < 0 ? err : change;
2623 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2626 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2628 * The control element is supposed to have the private_value field
2629 * set up via HDA_BIND_VOL() macro.
2631 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2632 unsigned int size, unsigned int __user *tlv)
2634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2635 struct hda_bind_ctls *c;
2638 mutex_lock(&codec->control_mutex);
2639 c = (struct hda_bind_ctls *)kcontrol->private_value;
2640 kcontrol->private_value = *c->values;
2641 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2642 kcontrol->private_value = (long)c;
2643 mutex_unlock(&codec->control_mutex);
2646 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2648 struct hda_ctl_ops snd_hda_bind_vol = {
2649 .info = snd_hda_mixer_amp_volume_info,
2650 .get = snd_hda_mixer_amp_volume_get,
2651 .put = snd_hda_mixer_amp_volume_put,
2652 .tlv = snd_hda_mixer_amp_tlv
2654 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2656 struct hda_ctl_ops snd_hda_bind_sw = {
2657 .info = snd_hda_mixer_amp_switch_info,
2658 .get = snd_hda_mixer_amp_switch_get,
2659 .put = snd_hda_mixer_amp_switch_put,
2660 .tlv = snd_hda_mixer_amp_tlv
2662 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2665 * SPDIF out controls
2668 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2669 struct snd_ctl_elem_info *uinfo)
2671 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2676 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2677 struct snd_ctl_elem_value *ucontrol)
2679 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2680 IEC958_AES0_NONAUDIO |
2681 IEC958_AES0_CON_EMPHASIS_5015 |
2682 IEC958_AES0_CON_NOT_COPYRIGHT;
2683 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2684 IEC958_AES1_CON_ORIGINAL;
2688 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2689 struct snd_ctl_elem_value *ucontrol)
2691 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2692 IEC958_AES0_NONAUDIO |
2693 IEC958_AES0_PRO_EMPHASIS_5015;
2697 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2698 struct snd_ctl_elem_value *ucontrol)
2700 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2701 int idx = kcontrol->private_value;
2702 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2704 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2705 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2706 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2707 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
2712 /* convert from SPDIF status bits to HDA SPDIF bits
2713 * bit 0 (DigEn) is always set zero (to be filled later)
2715 static unsigned short convert_from_spdif_status(unsigned int sbits)
2717 unsigned short val = 0;
2719 if (sbits & IEC958_AES0_PROFESSIONAL)
2720 val |= AC_DIG1_PROFESSIONAL;
2721 if (sbits & IEC958_AES0_NONAUDIO)
2722 val |= AC_DIG1_NONAUDIO;
2723 if (sbits & IEC958_AES0_PROFESSIONAL) {
2724 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2725 IEC958_AES0_PRO_EMPHASIS_5015)
2726 val |= AC_DIG1_EMPHASIS;
2728 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2729 IEC958_AES0_CON_EMPHASIS_5015)
2730 val |= AC_DIG1_EMPHASIS;
2731 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2732 val |= AC_DIG1_COPYRIGHT;
2733 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2734 val |= AC_DIG1_LEVEL;
2735 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2740 /* convert to SPDIF status bits from HDA SPDIF bits
2742 static unsigned int convert_to_spdif_status(unsigned short val)
2744 unsigned int sbits = 0;
2746 if (val & AC_DIG1_NONAUDIO)
2747 sbits |= IEC958_AES0_NONAUDIO;
2748 if (val & AC_DIG1_PROFESSIONAL)
2749 sbits |= IEC958_AES0_PROFESSIONAL;
2750 if (sbits & IEC958_AES0_PROFESSIONAL) {
2751 if (sbits & AC_DIG1_EMPHASIS)
2752 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2754 if (val & AC_DIG1_EMPHASIS)
2755 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2756 if (!(val & AC_DIG1_COPYRIGHT))
2757 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2758 if (val & AC_DIG1_LEVEL)
2759 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2760 sbits |= val & (0x7f << 8);
2765 /* set digital convert verbs both for the given NID and its slaves */
2766 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2771 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2772 d = codec->slave_dig_outs;
2776 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2779 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2783 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2785 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2788 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2789 struct snd_ctl_elem_value *ucontrol)
2791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2792 int idx = kcontrol->private_value;
2793 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2794 hda_nid_t nid = spdif->nid;
2798 mutex_lock(&codec->spdif_mutex);
2799 spdif->status = ucontrol->value.iec958.status[0] |
2800 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2801 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2802 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2803 val = convert_from_spdif_status(spdif->status);
2804 val |= spdif->ctls & 1;
2805 change = spdif->ctls != val;
2807 if (change && nid != (u16)-1)
2808 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2809 mutex_unlock(&codec->spdif_mutex);
2813 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2815 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2816 struct snd_ctl_elem_value *ucontrol)
2818 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2819 int idx = kcontrol->private_value;
2820 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2822 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
2826 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2829 set_dig_out_convert(codec, nid, dig1, dig2);
2830 /* unmute amp switch (if any) */
2831 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2832 (dig1 & AC_DIG1_ENABLE))
2833 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2837 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2838 struct snd_ctl_elem_value *ucontrol)
2840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2841 int idx = kcontrol->private_value;
2842 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2843 hda_nid_t nid = spdif->nid;
2847 mutex_lock(&codec->spdif_mutex);
2848 val = spdif->ctls & ~AC_DIG1_ENABLE;
2849 if (ucontrol->value.integer.value[0])
2850 val |= AC_DIG1_ENABLE;
2851 change = spdif->ctls != val;
2853 if (change && nid != (u16)-1)
2854 set_spdif_ctls(codec, nid, val & 0xff, -1);
2855 mutex_unlock(&codec->spdif_mutex);
2859 static struct snd_kcontrol_new dig_mixes[] = {
2861 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2862 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2863 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2864 .info = snd_hda_spdif_mask_info,
2865 .get = snd_hda_spdif_cmask_get,
2868 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2869 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2870 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2871 .info = snd_hda_spdif_mask_info,
2872 .get = snd_hda_spdif_pmask_get,
2875 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2876 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2877 .info = snd_hda_spdif_mask_info,
2878 .get = snd_hda_spdif_default_get,
2879 .put = snd_hda_spdif_default_put,
2882 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2883 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2884 .info = snd_hda_spdif_out_switch_info,
2885 .get = snd_hda_spdif_out_switch_get,
2886 .put = snd_hda_spdif_out_switch_put,
2892 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2893 * @codec: the HDA codec
2894 * @nid: audio out widget NID
2896 * Creates controls related with the SPDIF output.
2897 * Called from each patch supporting the SPDIF out.
2899 * Returns 0 if successful, or a negative error code.
2901 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2902 hda_nid_t associated_nid,
2906 struct snd_kcontrol *kctl;
2907 struct snd_kcontrol_new *dig_mix;
2909 struct hda_spdif_out *spdif;
2911 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2913 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2916 spdif = snd_array_new(&codec->spdif_out);
2917 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2918 kctl = snd_ctl_new1(dig_mix, codec);
2921 kctl->id.index = idx;
2922 kctl->private_value = codec->spdif_out.used - 1;
2923 err = snd_hda_ctl_add(codec, associated_nid, kctl);
2927 spdif->nid = cvt_nid;
2928 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
2929 AC_VERB_GET_DIGI_CONVERT_1, 0);
2930 spdif->status = convert_to_spdif_status(spdif->ctls);
2933 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2935 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2939 for (i = 0; i < codec->spdif_out.used; i++) {
2940 struct hda_spdif_out *spdif =
2941 snd_array_elem(&codec->spdif_out, i);
2942 if (spdif->nid == nid)
2947 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
2949 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2951 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2953 mutex_lock(&codec->spdif_mutex);
2954 spdif->nid = (u16)-1;
2955 mutex_unlock(&codec->spdif_mutex);
2957 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
2959 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2961 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2964 mutex_lock(&codec->spdif_mutex);
2965 if (spdif->nid != nid) {
2968 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2970 mutex_unlock(&codec->spdif_mutex);
2972 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
2975 * SPDIF sharing with analog output
2977 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2978 struct snd_ctl_elem_value *ucontrol)
2980 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2981 ucontrol->value.integer.value[0] = mout->share_spdif;
2985 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2986 struct snd_ctl_elem_value *ucontrol)
2988 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2989 mout->share_spdif = !!ucontrol->value.integer.value[0];
2993 static struct snd_kcontrol_new spdif_share_sw = {
2994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2995 .name = "IEC958 Default PCM Playback Switch",
2996 .info = snd_ctl_boolean_mono_info,
2997 .get = spdif_share_sw_get,
2998 .put = spdif_share_sw_put,
3002 * snd_hda_create_spdif_share_sw - create Default PCM switch
3003 * @codec: the HDA codec
3004 * @mout: multi-out instance
3006 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3007 struct hda_multi_out *mout)
3009 if (!mout->dig_out_nid)
3011 /* ATTENTION: here mout is passed as private_data, instead of codec */
3012 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3013 snd_ctl_new1(&spdif_share_sw, mout));
3015 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3021 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3023 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3024 struct snd_ctl_elem_value *ucontrol)
3026 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3028 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3032 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3033 struct snd_ctl_elem_value *ucontrol)
3035 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3036 hda_nid_t nid = kcontrol->private_value;
3037 unsigned int val = !!ucontrol->value.integer.value[0];
3040 mutex_lock(&codec->spdif_mutex);
3041 change = codec->spdif_in_enable != val;
3043 codec->spdif_in_enable = val;
3044 snd_hda_codec_write_cache(codec, nid, 0,
3045 AC_VERB_SET_DIGI_CONVERT_1, val);
3047 mutex_unlock(&codec->spdif_mutex);
3051 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3052 struct snd_ctl_elem_value *ucontrol)
3054 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3055 hda_nid_t nid = kcontrol->private_value;
3059 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3060 sbits = convert_to_spdif_status(val);
3061 ucontrol->value.iec958.status[0] = sbits;
3062 ucontrol->value.iec958.status[1] = sbits >> 8;
3063 ucontrol->value.iec958.status[2] = sbits >> 16;
3064 ucontrol->value.iec958.status[3] = sbits >> 24;
3068 static struct snd_kcontrol_new dig_in_ctls[] = {
3070 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3071 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3072 .info = snd_hda_spdif_in_switch_info,
3073 .get = snd_hda_spdif_in_switch_get,
3074 .put = snd_hda_spdif_in_switch_put,
3077 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3078 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3079 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3080 .info = snd_hda_spdif_mask_info,
3081 .get = snd_hda_spdif_in_status_get,
3087 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3088 * @codec: the HDA codec
3089 * @nid: audio in widget NID
3091 * Creates controls related with the SPDIF input.
3092 * Called from each patch supporting the SPDIF in.
3094 * Returns 0 if successful, or a negative error code.
3096 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3099 struct snd_kcontrol *kctl;
3100 struct snd_kcontrol_new *dig_mix;
3103 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3105 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3108 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3109 kctl = snd_ctl_new1(dig_mix, codec);
3112 kctl->private_value = nid;
3113 err = snd_hda_ctl_add(codec, nid, kctl);
3117 codec->spdif_in_enable =
3118 snd_hda_codec_read(codec, nid, 0,
3119 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3123 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3130 /* build a 32bit cache key with the widget id and the command parameter */
3131 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3132 #define get_cmd_cache_nid(key) ((key) & 0xff)
3133 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3136 * snd_hda_codec_write_cache - send a single command with caching
3137 * @codec: the HDA codec
3138 * @nid: NID to send the command
3139 * @direct: direct flag
3140 * @verb: the verb to send
3141 * @parm: the parameter for the verb
3143 * Send a single command without waiting for response.
3145 * Returns 0 if successful, or a negative error code.
3147 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3148 int direct, unsigned int verb, unsigned int parm)
3150 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3151 struct hda_cache_head *c;
3156 /* parm may contain the verb stuff for get/set amp */
3157 verb = verb | (parm >> 8);
3159 key = build_cmd_cache_key(nid, verb);
3160 mutex_lock(&codec->bus->cmd_mutex);
3161 c = get_alloc_hash(&codec->cmd_cache, key);
3164 mutex_unlock(&codec->bus->cmd_mutex);
3167 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3170 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3171 * @codec: the HDA codec
3172 * @nid: NID to send the command
3173 * @direct: direct flag
3174 * @verb: the verb to send
3175 * @parm: the parameter for the verb
3177 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3178 * command if the parameter is already identical with the cached value.
3179 * If not, it sends the command and refreshes the cache.
3181 * Returns 0 if successful, or a negative error code.
3183 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3184 int direct, unsigned int verb, unsigned int parm)
3186 struct hda_cache_head *c;
3189 /* parm may contain the verb stuff for get/set amp */
3190 verb = verb | (parm >> 8);
3192 key = build_cmd_cache_key(nid, verb);
3193 mutex_lock(&codec->bus->cmd_mutex);
3194 c = get_hash(&codec->cmd_cache, key);
3195 if (c && c->val == parm) {
3196 mutex_unlock(&codec->bus->cmd_mutex);
3199 mutex_unlock(&codec->bus->cmd_mutex);
3200 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3202 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3205 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3206 * @codec: HD-audio codec
3208 * Execute all verbs recorded in the command caches to resume.
3210 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3212 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
3215 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
3216 u32 key = buffer->key;
3219 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3220 get_cmd_cache_cmd(key), buffer->val);
3223 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3226 * snd_hda_sequence_write_cache - sequence writes with caching
3227 * @codec: the HDA codec
3228 * @seq: VERB array to send
3230 * Send the commands sequentially from the given array.
3231 * Thte commands are recorded on cache for power-save and resume.
3232 * The array must be terminated with NID=0.
3234 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3235 const struct hda_verb *seq)
3237 for (; seq->nid; seq++)
3238 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3241 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3242 #endif /* CONFIG_PM */
3244 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3245 unsigned int power_state,
3246 bool eapd_workaround)
3248 hda_nid_t nid = codec->start_nid;
3251 for (i = 0; i < codec->num_nodes; i++, nid++) {
3252 unsigned int wcaps = get_wcaps(codec, nid);
3253 if (!(wcaps & AC_WCAP_POWER))
3255 /* don't power down the widget if it controls eapd and
3256 * EAPD_BTLENABLE is set.
3258 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3259 get_wcaps_type(wcaps) == AC_WID_PIN &&
3260 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3261 int eapd = snd_hda_codec_read(codec, nid, 0,
3262 AC_VERB_GET_EAPD_BTLENABLE, 0);
3266 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3270 if (power_state == AC_PWRST_D0) {
3271 unsigned long end_time;
3273 /* wait until the codec reachs to D0 */
3274 end_time = jiffies + msecs_to_jiffies(500);
3276 state = snd_hda_codec_read(codec, fg, 0,
3277 AC_VERB_GET_POWER_STATE, 0);
3278 if (state == power_state)
3281 } while (time_after_eq(end_time, jiffies));
3284 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3287 * set power state of the codec
3289 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3290 unsigned int power_state)
3292 if (codec->patch_ops.set_power_state) {
3293 codec->patch_ops.set_power_state(codec, fg, power_state);
3297 /* this delay seems necessary to avoid click noise at power-down */
3298 if (power_state == AC_PWRST_D3)
3300 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3302 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3305 #ifdef CONFIG_SND_HDA_HWDEP
3306 /* execute additional init verbs */
3307 static void hda_exec_init_verbs(struct hda_codec *codec)
3309 if (codec->init_verbs.list)
3310 snd_hda_sequence_write(codec, codec->init_verbs.list);
3313 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3318 * call suspend and power-down; used both from PM and power-save
3320 static void hda_call_codec_suspend(struct hda_codec *codec)
3322 if (codec->patch_ops.suspend)
3323 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3324 hda_cleanup_all_streams(codec);
3325 hda_set_power_state(codec,
3326 codec->afg ? codec->afg : codec->mfg,
3328 #ifdef CONFIG_SND_HDA_POWER_SAVE
3329 snd_hda_update_power_acct(codec);
3330 cancel_delayed_work(&codec->power_work);
3331 codec->power_on = 0;
3332 codec->power_transition = 0;
3333 codec->power_jiffies = jiffies;
3338 * kick up codec; used both from PM and power-save
3340 static void hda_call_codec_resume(struct hda_codec *codec)
3342 hda_set_power_state(codec,
3343 codec->afg ? codec->afg : codec->mfg,
3345 restore_pincfgs(codec); /* restore all current pin configs */
3346 restore_shutup_pins(codec);
3347 hda_exec_init_verbs(codec);
3348 if (codec->patch_ops.resume)
3349 codec->patch_ops.resume(codec);
3351 if (codec->patch_ops.init)
3352 codec->patch_ops.init(codec);
3353 snd_hda_codec_resume_amp(codec);
3354 snd_hda_codec_resume_cache(codec);
3357 #endif /* CONFIG_PM */
3361 * snd_hda_build_controls - build mixer controls
3364 * Creates mixer controls for each codec included in the bus.
3366 * Returns 0 if successful, otherwise a negative error code.
3368 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3370 struct hda_codec *codec;
3372 list_for_each_entry(codec, &bus->codec_list, list) {
3373 int err = snd_hda_codec_build_controls(codec);
3375 printk(KERN_ERR "hda_codec: cannot build controls "
3376 "for #%d (error %d)\n", codec->addr, err);
3377 err = snd_hda_codec_reset(codec);
3380 "hda_codec: cannot revert codec\n");
3387 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3389 int snd_hda_codec_build_controls(struct hda_codec *codec)
3392 hda_exec_init_verbs(codec);
3393 /* continue to initialize... */
3394 if (codec->patch_ops.init)
3395 err = codec->patch_ops.init(codec);
3396 if (!err && codec->patch_ops.build_controls)
3397 err = codec->patch_ops.build_controls(codec);
3406 struct hda_rate_tbl {
3408 unsigned int alsa_bits;
3409 unsigned int hda_fmt;
3412 /* rate = base * mult / div */
3413 #define HDA_RATE(base, mult, div) \
3414 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3415 (((div) - 1) << AC_FMT_DIV_SHIFT))
3417 static struct hda_rate_tbl rate_bits[] = {
3418 /* rate in Hz, ALSA rate bitmask, HDA format value */
3420 /* autodetected value used in snd_hda_query_supported_pcm */
3421 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3422 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3423 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3424 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3425 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3426 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3427 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3428 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3429 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3430 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3431 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3432 #define AC_PAR_PCM_RATE_BITS 11
3433 /* up to bits 10, 384kHZ isn't supported properly */
3435 /* not autodetected value */
3436 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3438 { 0 } /* terminator */
3442 * snd_hda_calc_stream_format - calculate format bitset
3443 * @rate: the sample rate
3444 * @channels: the number of channels
3445 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3446 * @maxbps: the max. bps
3448 * Calculate the format bitset from the given rate, channels and th PCM format.
3450 * Return zero if invalid.
3452 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3453 unsigned int channels,
3454 unsigned int format,
3455 unsigned int maxbps,
3456 unsigned short spdif_ctls)
3459 unsigned int val = 0;
3461 for (i = 0; rate_bits[i].hz; i++)
3462 if (rate_bits[i].hz == rate) {
3463 val = rate_bits[i].hda_fmt;
3466 if (!rate_bits[i].hz) {
3467 snd_printdd("invalid rate %d\n", rate);
3471 if (channels == 0 || channels > 8) {
3472 snd_printdd("invalid channels %d\n", channels);
3475 val |= channels - 1;
3477 switch (snd_pcm_format_width(format)) {
3479 val |= AC_FMT_BITS_8;
3482 val |= AC_FMT_BITS_16;
3487 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3488 val |= AC_FMT_BITS_32;
3489 else if (maxbps >= 24)
3490 val |= AC_FMT_BITS_24;
3492 val |= AC_FMT_BITS_20;
3495 snd_printdd("invalid format width %d\n",
3496 snd_pcm_format_width(format));
3500 if (spdif_ctls & AC_DIG1_NONAUDIO)
3501 val |= AC_FMT_TYPE_NON_PCM;
3505 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3507 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3509 unsigned int val = 0;
3510 if (nid != codec->afg &&
3511 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3512 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3513 if (!val || val == -1)
3514 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3515 if (!val || val == -1)
3520 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3522 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3526 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3528 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3529 if (!streams || streams == -1)
3530 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3531 if (!streams || streams == -1)
3536 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3538 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3543 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3544 * @codec: the HDA codec
3545 * @nid: NID to query
3546 * @ratesp: the pointer to store the detected rate bitflags
3547 * @formatsp: the pointer to store the detected formats
3548 * @bpsp: the pointer to store the detected format widths
3550 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3551 * or @bsps argument is ignored.
3553 * Returns 0 if successful, otherwise a negative error code.
3555 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3556 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3558 unsigned int i, val, wcaps;
3560 wcaps = get_wcaps(codec, nid);
3561 val = query_pcm_param(codec, nid);
3565 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3567 rates |= rate_bits[i].alsa_bits;
3570 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3571 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3573 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3579 if (formatsp || bpsp) {
3581 unsigned int streams, bps;
3583 streams = query_stream_param(codec, nid);
3588 if (streams & AC_SUPFMT_PCM) {
3589 if (val & AC_SUPPCM_BITS_8) {
3590 formats |= SNDRV_PCM_FMTBIT_U8;
3593 if (val & AC_SUPPCM_BITS_16) {
3594 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3597 if (wcaps & AC_WCAP_DIGITAL) {
3598 if (val & AC_SUPPCM_BITS_32)
3599 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3600 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3601 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3602 if (val & AC_SUPPCM_BITS_24)
3604 else if (val & AC_SUPPCM_BITS_20)
3606 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3607 AC_SUPPCM_BITS_32)) {
3608 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3609 if (val & AC_SUPPCM_BITS_32)
3611 else if (val & AC_SUPPCM_BITS_24)
3613 else if (val & AC_SUPPCM_BITS_20)
3617 if (streams & AC_SUPFMT_FLOAT32) {
3618 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3622 if (streams == AC_SUPFMT_AC3) {
3623 /* should be exclusive */
3624 /* temporary hack: we have still no proper support
3625 * for the direct AC3 stream...
3627 formats |= SNDRV_PCM_FMTBIT_U8;
3631 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3632 "(nid=0x%x, val=0x%x, ovrd=%i, "
3635 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3640 *formatsp = formats;
3647 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
3650 * snd_hda_is_supported_format - Check the validity of the format
3651 * @codec: HD-audio codec
3652 * @nid: NID to check
3653 * @format: the HD-audio format value to check
3655 * Check whether the given node supports the format value.
3657 * Returns 1 if supported, 0 if not.
3659 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3660 unsigned int format)
3663 unsigned int val = 0, rate, stream;
3665 val = query_pcm_param(codec, nid);
3669 rate = format & 0xff00;
3670 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3671 if (rate_bits[i].hda_fmt == rate) {
3676 if (i >= AC_PAR_PCM_RATE_BITS)
3679 stream = query_stream_param(codec, nid);
3683 if (stream & AC_SUPFMT_PCM) {
3684 switch (format & 0xf0) {
3686 if (!(val & AC_SUPPCM_BITS_8))
3690 if (!(val & AC_SUPPCM_BITS_16))
3694 if (!(val & AC_SUPPCM_BITS_20))
3698 if (!(val & AC_SUPPCM_BITS_24))
3702 if (!(val & AC_SUPPCM_BITS_32))
3709 /* FIXME: check for float32 and AC3? */
3714 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3719 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3720 struct hda_codec *codec,
3721 struct snd_pcm_substream *substream)
3726 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3727 struct hda_codec *codec,
3728 unsigned int stream_tag,
3729 unsigned int format,
3730 struct snd_pcm_substream *substream)
3732 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3736 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3737 struct hda_codec *codec,
3738 struct snd_pcm_substream *substream)
3740 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3744 static int set_pcm_default_values(struct hda_codec *codec,
3745 struct hda_pcm_stream *info)
3749 /* query support PCM information from the given NID */
3750 if (info->nid && (!info->rates || !info->formats)) {
3751 err = snd_hda_query_supported_pcm(codec, info->nid,
3752 info->rates ? NULL : &info->rates,
3753 info->formats ? NULL : &info->formats,
3754 info->maxbps ? NULL : &info->maxbps);
3758 if (info->ops.open == NULL)
3759 info->ops.open = hda_pcm_default_open_close;
3760 if (info->ops.close == NULL)
3761 info->ops.close = hda_pcm_default_open_close;
3762 if (info->ops.prepare == NULL) {
3763 if (snd_BUG_ON(!info->nid))
3765 info->ops.prepare = hda_pcm_default_prepare;
3767 if (info->ops.cleanup == NULL) {
3768 if (snd_BUG_ON(!info->nid))
3770 info->ops.cleanup = hda_pcm_default_cleanup;
3776 * codec prepare/cleanup entries
3778 int snd_hda_codec_prepare(struct hda_codec *codec,
3779 struct hda_pcm_stream *hinfo,
3780 unsigned int stream,
3781 unsigned int format,
3782 struct snd_pcm_substream *substream)
3785 mutex_lock(&codec->bus->prepare_mutex);
3786 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3788 purify_inactive_streams(codec);
3789 mutex_unlock(&codec->bus->prepare_mutex);
3792 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3794 void snd_hda_codec_cleanup(struct hda_codec *codec,
3795 struct hda_pcm_stream *hinfo,
3796 struct snd_pcm_substream *substream)
3798 mutex_lock(&codec->bus->prepare_mutex);
3799 hinfo->ops.cleanup(hinfo, codec, substream);
3800 mutex_unlock(&codec->bus->prepare_mutex);
3802 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3805 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3806 "Audio", "SPDIF", "HDMI", "Modem"
3810 * get the empty PCM device number to assign
3812 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3814 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3816 /* audio device indices; not linear to keep compatibility */
3817 static int audio_idx[HDA_PCM_NTYPES][5] = {
3818 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3819 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3820 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3821 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3825 if (type >= HDA_PCM_NTYPES) {
3826 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3830 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3831 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3832 return audio_idx[type][i];
3834 snd_printk(KERN_WARNING "Too many %s devices\n",
3835 snd_hda_pcm_type_name[type]);
3840 * attach a new PCM stream
3842 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3844 struct hda_bus *bus = codec->bus;
3845 struct hda_pcm_stream *info;
3848 if (snd_BUG_ON(!pcm->name))
3850 for (stream = 0; stream < 2; stream++) {
3851 info = &pcm->stream[stream];
3852 if (info->substreams) {
3853 err = set_pcm_default_values(codec, info);
3858 return bus->ops.attach_pcm(bus, codec, pcm);
3861 /* assign all PCMs of the given codec */
3862 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3867 if (!codec->num_pcms) {
3868 if (!codec->patch_ops.build_pcms)
3870 err = codec->patch_ops.build_pcms(codec);
3872 printk(KERN_ERR "hda_codec: cannot build PCMs"
3873 "for #%d (error %d)\n", codec->addr, err);
3874 err = snd_hda_codec_reset(codec);
3877 "hda_codec: cannot revert codec\n");
3882 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3883 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3886 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3887 continue; /* no substreams assigned */
3890 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3892 continue; /* no fatal error */
3894 err = snd_hda_attach_pcm(codec, cpcm);
3896 printk(KERN_ERR "hda_codec: cannot attach "
3897 "PCM stream %d for codec #%d\n",
3899 continue; /* no fatal error */
3907 * snd_hda_build_pcms - build PCM information
3910 * Create PCM information for each codec included in the bus.
3912 * The build_pcms codec patch is requested to set up codec->num_pcms and
3913 * codec->pcm_info properly. The array is referred by the top-level driver
3914 * to create its PCM instances.
3915 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3918 * At least, substreams, channels_min and channels_max must be filled for
3919 * each stream. substreams = 0 indicates that the stream doesn't exist.
3920 * When rates and/or formats are zero, the supported values are queried
3921 * from the given nid. The nid is used also by the default ops.prepare
3922 * and ops.cleanup callbacks.
3924 * The driver needs to call ops.open in its open callback. Similarly,
3925 * ops.close is supposed to be called in the close callback.
3926 * ops.prepare should be called in the prepare or hw_params callback
3927 * with the proper parameters for set up.
3928 * ops.cleanup should be called in hw_free for clean up of streams.
3930 * This function returns 0 if successful, or a negative error code.
3932 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3934 struct hda_codec *codec;
3936 list_for_each_entry(codec, &bus->codec_list, list) {
3937 int err = snd_hda_codec_build_pcms(codec);
3943 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3946 * snd_hda_check_board_config - compare the current codec with the config table
3947 * @codec: the HDA codec
3948 * @num_configs: number of config enums
3949 * @models: array of model name strings
3950 * @tbl: configuration table, terminated by null entries
3952 * Compares the modelname or PCI subsystem id of the current codec with the
3953 * given configuration table. If a matching entry is found, returns its
3954 * config value (supposed to be 0 or positive).
3956 * If no entries are matching, the function returns a negative value.
3958 int snd_hda_check_board_config(struct hda_codec *codec,
3959 int num_configs, const char * const *models,
3960 const struct snd_pci_quirk *tbl)
3962 if (codec->modelname && models) {
3964 for (i = 0; i < num_configs; i++) {
3966 !strcmp(codec->modelname, models[i])) {
3967 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3968 "selected\n", models[i]);
3974 if (!codec->bus->pci || !tbl)
3977 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3980 if (tbl->value >= 0 && tbl->value < num_configs) {
3981 #ifdef CONFIG_SND_DEBUG_VERBOSE
3983 const char *model = NULL;
3985 model = models[tbl->value];
3987 sprintf(tmp, "#%d", tbl->value);
3990 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3991 "for config %x:%x (%s)\n",
3992 model, tbl->subvendor, tbl->subdevice,
3993 (tbl->name ? tbl->name : "Unknown device"));
3999 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4002 * snd_hda_check_board_codec_sid_config - compare the current codec
4003 subsystem ID with the
4006 This is important for Gateway notebooks with SB450 HDA Audio
4007 where the vendor ID of the PCI device is:
4008 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4009 and the vendor/subvendor are found only at the codec.
4011 * @codec: the HDA codec
4012 * @num_configs: number of config enums
4013 * @models: array of model name strings
4014 * @tbl: configuration table, terminated by null entries
4016 * Compares the modelname or PCI subsystem id of the current codec with the
4017 * given configuration table. If a matching entry is found, returns its
4018 * config value (supposed to be 0 or positive).
4020 * If no entries are matching, the function returns a negative value.
4022 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4023 int num_configs, const char * const *models,
4024 const struct snd_pci_quirk *tbl)
4026 const struct snd_pci_quirk *q;
4028 /* Search for codec ID */
4029 for (q = tbl; q->subvendor; q++) {
4030 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
4032 if (vendorid == codec->subsystem_id)
4041 if (tbl->value >= 0 && tbl->value < num_configs) {
4042 #ifdef CONFIG_SND_DEBUG_VERBOSE
4044 const char *model = NULL;
4046 model = models[tbl->value];
4048 sprintf(tmp, "#%d", tbl->value);
4051 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4052 "for config %x:%x (%s)\n",
4053 model, tbl->subvendor, tbl->subdevice,
4054 (tbl->name ? tbl->name : "Unknown device"));
4060 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4063 * snd_hda_add_new_ctls - create controls from the array
4064 * @codec: the HDA codec
4065 * @knew: the array of struct snd_kcontrol_new
4067 * This helper function creates and add new controls in the given array.
4068 * The array must be terminated with an empty entry as terminator.
4070 * Returns 0 if successful, or a negative error code.
4072 int snd_hda_add_new_ctls(struct hda_codec *codec,
4073 const struct snd_kcontrol_new *knew)
4077 for (; knew->name; knew++) {
4078 struct snd_kcontrol *kctl;
4079 int addr = 0, idx = 0;
4080 if (knew->iface == -1) /* skip this codec private value */
4083 kctl = snd_ctl_new1(knew, codec);
4087 kctl->id.device = addr;
4089 kctl->id.index = idx;
4090 err = snd_hda_ctl_add(codec, 0, kctl);
4093 /* try first with another device index corresponding to
4094 * the codec addr; if it still fails (or it's the
4095 * primary codec), then try another control index
4097 if (!addr && codec->addr)
4099 else if (!idx && !knew->index) {
4100 idx = find_empty_mixer_ctl_idx(codec,
4110 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4112 #ifdef CONFIG_SND_HDA_POWER_SAVE
4113 static void hda_power_work(struct work_struct *work)
4115 struct hda_codec *codec =
4116 container_of(work, struct hda_codec, power_work.work);
4117 struct hda_bus *bus = codec->bus;
4119 if (!codec->power_on || codec->power_count) {
4120 codec->power_transition = 0;
4124 trace_hda_power_down(codec);
4125 hda_call_codec_suspend(codec);
4126 if (bus->ops.pm_notify)
4127 bus->ops.pm_notify(bus);
4130 static void hda_keep_power_on(struct hda_codec *codec)
4132 codec->power_count++;
4133 codec->power_on = 1;
4134 codec->power_jiffies = jiffies;
4137 /* update the power on/off account with the current jiffies */
4138 void snd_hda_update_power_acct(struct hda_codec *codec)
4140 unsigned long delta = jiffies - codec->power_jiffies;
4141 if (codec->power_on)
4142 codec->power_on_acct += delta;
4144 codec->power_off_acct += delta;
4145 codec->power_jiffies += delta;
4149 * snd_hda_power_up - Power-up the codec
4150 * @codec: HD-audio codec
4152 * Increment the power-up counter and power up the hardware really when
4153 * not turned on yet.
4155 void snd_hda_power_up(struct hda_codec *codec)
4157 struct hda_bus *bus = codec->bus;
4159 codec->power_count++;
4160 if (codec->power_on || codec->power_transition)
4163 trace_hda_power_up(codec);
4164 snd_hda_update_power_acct(codec);
4165 codec->power_on = 1;
4166 codec->power_jiffies = jiffies;
4167 if (bus->ops.pm_notify)
4168 bus->ops.pm_notify(bus);
4169 hda_call_codec_resume(codec);
4170 cancel_delayed_work(&codec->power_work);
4171 codec->power_transition = 0;
4173 EXPORT_SYMBOL_HDA(snd_hda_power_up);
4175 #define power_save(codec) \
4176 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4179 * snd_hda_power_down - Power-down the codec
4180 * @codec: HD-audio codec
4182 * Decrement the power-up counter and schedules the power-off work if
4183 * the counter rearches to zero.
4185 void snd_hda_power_down(struct hda_codec *codec)
4187 --codec->power_count;
4188 if (!codec->power_on || codec->power_count || codec->power_transition)
4190 if (power_save(codec)) {
4191 codec->power_transition = 1; /* avoid reentrance */
4192 queue_delayed_work(codec->bus->workq, &codec->power_work,
4193 msecs_to_jiffies(power_save(codec) * 1000));
4196 EXPORT_SYMBOL_HDA(snd_hda_power_down);
4199 * snd_hda_check_amp_list_power - Check the amp list and update the power
4200 * @codec: HD-audio codec
4201 * @check: the object containing an AMP list and the status
4202 * @nid: NID to check / update
4204 * Check whether the given NID is in the amp list. If it's in the list,
4205 * check the current AMP status, and update the the power-status according
4206 * to the mute status.
4208 * This function is supposed to be set or called from the check_power_status
4211 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4212 struct hda_loopback_check *check,
4215 const struct hda_amp_list *p;
4218 if (!check->amplist)
4220 for (p = check->amplist; p->nid; p++) {
4225 return 0; /* nothing changed */
4227 for (p = check->amplist; p->nid; p++) {
4228 for (ch = 0; ch < 2; ch++) {
4229 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4231 if (!(v & HDA_AMP_MUTE) && v > 0) {
4232 if (!check->power_on) {
4233 check->power_on = 1;
4234 snd_hda_power_up(codec);
4240 if (check->power_on) {
4241 check->power_on = 0;
4242 snd_hda_power_down(codec);
4246 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4250 * Channel mode helper
4254 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4256 int snd_hda_ch_mode_info(struct hda_codec *codec,
4257 struct snd_ctl_elem_info *uinfo,
4258 const struct hda_channel_mode *chmode,
4261 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4263 uinfo->value.enumerated.items = num_chmodes;
4264 if (uinfo->value.enumerated.item >= num_chmodes)
4265 uinfo->value.enumerated.item = num_chmodes - 1;
4266 sprintf(uinfo->value.enumerated.name, "%dch",
4267 chmode[uinfo->value.enumerated.item].channels);
4270 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4273 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4275 int snd_hda_ch_mode_get(struct hda_codec *codec,
4276 struct snd_ctl_elem_value *ucontrol,
4277 const struct hda_channel_mode *chmode,
4283 for (i = 0; i < num_chmodes; i++) {
4284 if (max_channels == chmode[i].channels) {
4285 ucontrol->value.enumerated.item[0] = i;
4291 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4294 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4296 int snd_hda_ch_mode_put(struct hda_codec *codec,
4297 struct snd_ctl_elem_value *ucontrol,
4298 const struct hda_channel_mode *chmode,
4304 mode = ucontrol->value.enumerated.item[0];
4305 if (mode >= num_chmodes)
4307 if (*max_channelsp == chmode[mode].channels)
4309 /* change the current channel setting */
4310 *max_channelsp = chmode[mode].channels;
4311 if (chmode[mode].sequence)
4312 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4315 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4322 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4324 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4325 struct snd_ctl_elem_info *uinfo)
4329 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4331 uinfo->value.enumerated.items = imux->num_items;
4332 if (!imux->num_items)
4334 index = uinfo->value.enumerated.item;
4335 if (index >= imux->num_items)
4336 index = imux->num_items - 1;
4337 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4340 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4343 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4345 int snd_hda_input_mux_put(struct hda_codec *codec,
4346 const struct hda_input_mux *imux,
4347 struct snd_ctl_elem_value *ucontrol,
4349 unsigned int *cur_val)
4353 if (!imux->num_items)
4355 idx = ucontrol->value.enumerated.item[0];
4356 if (idx >= imux->num_items)
4357 idx = imux->num_items - 1;
4358 if (*cur_val == idx)
4360 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4361 imux->items[idx].index);
4365 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4369 * Multi-channel / digital-out PCM helper functions
4372 /* setup SPDIF output stream */
4373 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4374 unsigned int stream_tag, unsigned int format)
4376 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4378 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4379 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4380 set_dig_out_convert(codec, nid,
4381 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4383 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4384 if (codec->slave_dig_outs) {
4386 for (d = codec->slave_dig_outs; *d; d++)
4387 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4390 /* turn on again (if needed) */
4391 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
4392 set_dig_out_convert(codec, nid,
4393 spdif->ctls & 0xff, -1);
4396 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4398 snd_hda_codec_cleanup_stream(codec, nid);
4399 if (codec->slave_dig_outs) {
4401 for (d = codec->slave_dig_outs; *d; d++)
4402 snd_hda_codec_cleanup_stream(codec, *d);
4407 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4408 * @bus: HD-audio bus
4410 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4412 struct hda_codec *codec;
4416 list_for_each_entry(codec, &bus->codec_list, list) {
4417 if (hda_codec_is_power_on(codec) &&
4418 codec->patch_ops.reboot_notify)
4419 codec->patch_ops.reboot_notify(codec);
4422 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4425 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4427 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4428 struct hda_multi_out *mout)
4430 mutex_lock(&codec->spdif_mutex);
4431 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4432 /* already opened as analog dup; reset it once */
4433 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4434 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4435 mutex_unlock(&codec->spdif_mutex);
4438 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4441 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4443 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4444 struct hda_multi_out *mout,
4445 unsigned int stream_tag,
4446 unsigned int format,
4447 struct snd_pcm_substream *substream)
4449 mutex_lock(&codec->spdif_mutex);
4450 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4451 mutex_unlock(&codec->spdif_mutex);
4454 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4457 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4459 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4460 struct hda_multi_out *mout)
4462 mutex_lock(&codec->spdif_mutex);
4463 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4464 mutex_unlock(&codec->spdif_mutex);
4467 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4470 * snd_hda_multi_out_dig_close - release the digital out stream
4472 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4473 struct hda_multi_out *mout)
4475 mutex_lock(&codec->spdif_mutex);
4476 mout->dig_out_used = 0;
4477 mutex_unlock(&codec->spdif_mutex);
4480 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4483 * snd_hda_multi_out_analog_open - open analog outputs
4485 * Open analog outputs and set up the hw-constraints.
4486 * If the digital outputs can be opened as slave, open the digital
4489 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4490 struct hda_multi_out *mout,
4491 struct snd_pcm_substream *substream,
4492 struct hda_pcm_stream *hinfo)
4494 struct snd_pcm_runtime *runtime = substream->runtime;
4495 runtime->hw.channels_max = mout->max_channels;
4496 if (mout->dig_out_nid) {
4497 if (!mout->analog_rates) {
4498 mout->analog_rates = hinfo->rates;
4499 mout->analog_formats = hinfo->formats;
4500 mout->analog_maxbps = hinfo->maxbps;
4502 runtime->hw.rates = mout->analog_rates;
4503 runtime->hw.formats = mout->analog_formats;
4504 hinfo->maxbps = mout->analog_maxbps;
4506 if (!mout->spdif_rates) {
4507 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4509 &mout->spdif_formats,
4510 &mout->spdif_maxbps);
4512 mutex_lock(&codec->spdif_mutex);
4513 if (mout->share_spdif) {
4514 if ((runtime->hw.rates & mout->spdif_rates) &&
4515 (runtime->hw.formats & mout->spdif_formats)) {
4516 runtime->hw.rates &= mout->spdif_rates;
4517 runtime->hw.formats &= mout->spdif_formats;
4518 if (mout->spdif_maxbps < hinfo->maxbps)
4519 hinfo->maxbps = mout->spdif_maxbps;
4521 mout->share_spdif = 0;
4522 /* FIXME: need notify? */
4525 mutex_unlock(&codec->spdif_mutex);
4527 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4528 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4530 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4533 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4535 * Set up the i/o for analog out.
4536 * When the digital out is available, copy the front out to digital out, too.
4538 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4539 struct hda_multi_out *mout,
4540 unsigned int stream_tag,
4541 unsigned int format,
4542 struct snd_pcm_substream *substream)
4544 const hda_nid_t *nids = mout->dac_nids;
4545 int chs = substream->runtime->channels;
4546 struct hda_spdif_out *spdif =
4547 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
4550 mutex_lock(&codec->spdif_mutex);
4551 if (mout->dig_out_nid && mout->share_spdif &&
4552 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4554 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4556 !(spdif->status & IEC958_AES0_NONAUDIO)) {
4557 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4558 setup_dig_out_stream(codec, mout->dig_out_nid,
4559 stream_tag, format);
4561 mout->dig_out_used = 0;
4562 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4565 mutex_unlock(&codec->spdif_mutex);
4568 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4570 if (!mout->no_share_stream &&
4571 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4572 /* headphone out will just decode front left/right (stereo) */
4573 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4575 /* extra outputs copied from front */
4576 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4577 if (!mout->no_share_stream && mout->hp_out_nid[i])
4578 snd_hda_codec_setup_stream(codec,
4579 mout->hp_out_nid[i],
4580 stream_tag, 0, format);
4581 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4582 if (!mout->no_share_stream && mout->extra_out_nid[i])
4583 snd_hda_codec_setup_stream(codec,
4584 mout->extra_out_nid[i],
4585 stream_tag, 0, format);
4588 for (i = 1; i < mout->num_dacs; i++) {
4589 if (chs >= (i + 1) * 2) /* independent out */
4590 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4592 else if (!mout->no_share_stream) /* copy front */
4593 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4598 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4601 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4603 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4604 struct hda_multi_out *mout)
4606 const hda_nid_t *nids = mout->dac_nids;
4609 for (i = 0; i < mout->num_dacs; i++)
4610 snd_hda_codec_cleanup_stream(codec, nids[i]);
4612 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4613 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4614 if (mout->hp_out_nid[i])
4615 snd_hda_codec_cleanup_stream(codec,
4616 mout->hp_out_nid[i]);
4617 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4618 if (mout->extra_out_nid[i])
4619 snd_hda_codec_cleanup_stream(codec,
4620 mout->extra_out_nid[i]);
4621 mutex_lock(&codec->spdif_mutex);
4622 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4623 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4624 mout->dig_out_used = 0;
4626 mutex_unlock(&codec->spdif_mutex);
4629 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4632 * Helper for automatic pin configuration
4635 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
4637 for (; *list; list++)
4645 * Sort an associated group of pins according to their sequence numbers.
4647 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4654 for (i = 0; i < num_pins; i++) {
4655 for (j = i + 1; j < num_pins; j++) {
4656 if (sequences[i] > sequences[j]) {
4658 sequences[i] = sequences[j];
4669 /* add the found input-pin to the cfg->inputs[] table */
4670 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4673 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4674 cfg->inputs[cfg->num_inputs].pin = nid;
4675 cfg->inputs[cfg->num_inputs].type = type;
4680 /* sort inputs in the order of AUTO_PIN_* type */
4681 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4685 for (i = 0; i < cfg->num_inputs; i++) {
4686 for (j = i + 1; j < cfg->num_inputs; j++) {
4687 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4688 struct auto_pin_cfg_item tmp;
4689 tmp = cfg->inputs[i];
4690 cfg->inputs[i] = cfg->inputs[j];
4691 cfg->inputs[j] = tmp;
4697 /* Reorder the surround channels
4698 * ALSA sequence is front/surr/clfe/side
4700 * 4-ch: front/surr => OK as it is
4701 * 6-ch: front/clfe/surr
4702 * 8-ch: front/clfe/rear/side|fc
4704 static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4719 * Parse all pin widgets and store the useful pin nids to cfg
4721 * The number of line-outs or any primary output is stored in line_outs,
4722 * and the corresponding output pins are assigned to line_out_pins[],
4723 * in the order of front, rear, CLFE, side, ...
4725 * If more extra outputs (speaker and headphone) are found, the pins are
4726 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4727 * is detected, one of speaker of HP pins is assigned as the primary
4728 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4729 * if any analog output exists.
4731 * The analog input pins are assigned to inputs array.
4732 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4735 int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4736 struct auto_pin_cfg *cfg,
4737 const hda_nid_t *ignore_nids,
4738 unsigned int cond_flags)
4740 hda_nid_t nid, end_nid;
4741 short seq, assoc_line_out;
4742 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4743 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4744 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4747 memset(cfg, 0, sizeof(*cfg));
4749 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4750 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4751 memset(sequences_hp, 0, sizeof(sequences_hp));
4754 end_nid = codec->start_nid + codec->num_nodes;
4755 for (nid = codec->start_nid; nid < end_nid; nid++) {
4756 unsigned int wid_caps = get_wcaps(codec, nid);
4757 unsigned int wid_type = get_wcaps_type(wid_caps);
4758 unsigned int def_conf;
4759 short assoc, loc, conn, dev;
4761 /* read all default configuration for pin complex */
4762 if (wid_type != AC_WID_PIN)
4764 /* ignore the given nids (e.g. pc-beep returns error) */
4765 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4768 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4769 conn = get_defcfg_connect(def_conf);
4770 if (conn == AC_JACK_PORT_NONE)
4772 loc = get_defcfg_location(def_conf);
4773 dev = get_defcfg_device(def_conf);
4775 /* workaround for buggy BIOS setups */
4776 if (dev == AC_JACK_LINE_OUT) {
4777 if (conn == AC_JACK_PORT_FIXED)
4778 dev = AC_JACK_SPEAKER;
4782 case AC_JACK_LINE_OUT:
4783 seq = get_defcfg_sequence(def_conf);
4784 assoc = get_defcfg_association(def_conf);
4786 if (!(wid_caps & AC_WCAP_STEREO))
4787 if (!cfg->mono_out_pin)
4788 cfg->mono_out_pin = nid;
4791 if (!assoc_line_out)
4792 assoc_line_out = assoc;
4793 else if (assoc_line_out != assoc)
4795 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4797 cfg->line_out_pins[cfg->line_outs] = nid;
4798 sequences_line_out[cfg->line_outs] = seq;
4801 case AC_JACK_SPEAKER:
4802 seq = get_defcfg_sequence(def_conf);
4803 assoc = get_defcfg_association(def_conf);
4804 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4806 cfg->speaker_pins[cfg->speaker_outs] = nid;
4807 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
4808 cfg->speaker_outs++;
4810 case AC_JACK_HP_OUT:
4811 seq = get_defcfg_sequence(def_conf);
4812 assoc = get_defcfg_association(def_conf);
4813 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4815 cfg->hp_pins[cfg->hp_outs] = nid;
4816 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4819 case AC_JACK_MIC_IN:
4820 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4822 case AC_JACK_LINE_IN:
4823 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4826 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4829 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
4831 case AC_JACK_SPDIF_OUT:
4832 case AC_JACK_DIG_OTHER_OUT:
4833 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4835 cfg->dig_out_pins[cfg->dig_outs] = nid;
4836 cfg->dig_out_type[cfg->dig_outs] =
4837 (loc == AC_JACK_LOC_HDMI) ?
4838 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4841 case AC_JACK_SPDIF_IN:
4842 case AC_JACK_DIG_OTHER_IN:
4843 cfg->dig_in_pin = nid;
4844 if (loc == AC_JACK_LOC_HDMI)
4845 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4847 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4853 * If no line-out is defined but multiple HPs are found,
4854 * some of them might be the real line-outs.
4856 if (!cfg->line_outs && cfg->hp_outs > 1 &&
4857 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
4859 while (i < cfg->hp_outs) {
4860 /* The real HPs should have the sequence 0x0f */
4861 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4865 /* Move it to the line-out table */
4866 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4867 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4870 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4871 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4872 memmove(sequences_hp + i, sequences_hp + i + 1,
4873 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4875 memset(cfg->hp_pins + cfg->hp_outs, 0,
4876 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
4878 cfg->line_out_type = AUTO_PIN_HP_OUT;
4882 /* sort by sequence */
4883 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4885 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4887 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4891 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4892 * as a primary output
4894 if (!cfg->line_outs &&
4895 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
4896 if (cfg->speaker_outs) {
4897 cfg->line_outs = cfg->speaker_outs;
4898 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4899 sizeof(cfg->speaker_pins));
4900 cfg->speaker_outs = 0;
4901 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4902 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4903 } else if (cfg->hp_outs) {
4904 cfg->line_outs = cfg->hp_outs;
4905 memcpy(cfg->line_out_pins, cfg->hp_pins,
4906 sizeof(cfg->hp_pins));
4908 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4909 cfg->line_out_type = AUTO_PIN_HP_OUT;
4913 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
4914 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
4915 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
4917 sort_autocfg_input_pins(cfg);
4920 * debug prints of the parsed results
4922 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
4923 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4924 cfg->line_out_pins[2], cfg->line_out_pins[3],
4925 cfg->line_out_pins[4],
4926 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
4927 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
4928 "speaker" : "line"));
4929 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4930 cfg->speaker_outs, cfg->speaker_pins[0],
4931 cfg->speaker_pins[1], cfg->speaker_pins[2],
4932 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4933 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4934 cfg->hp_outs, cfg->hp_pins[0],
4935 cfg->hp_pins[1], cfg->hp_pins[2],
4936 cfg->hp_pins[3], cfg->hp_pins[4]);
4937 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4939 snd_printd(" dig-out=0x%x/0x%x\n",
4940 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4941 snd_printd(" inputs:");
4942 for (i = 0; i < cfg->num_inputs; i++) {
4943 snd_printd(" %s=0x%x",
4944 hda_get_autocfg_input_label(codec, cfg, i),
4945 cfg->inputs[i].pin);
4948 if (cfg->dig_in_pin)
4949 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4953 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
4955 int snd_hda_get_input_pin_attr(unsigned int def_conf)
4957 unsigned int loc = get_defcfg_location(def_conf);
4958 unsigned int conn = get_defcfg_connect(def_conf);
4959 if (conn == AC_JACK_PORT_NONE)
4960 return INPUT_PIN_ATTR_UNUSED;
4961 /* Windows may claim the internal mic to be BOTH, too */
4962 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
4963 return INPUT_PIN_ATTR_INT;
4964 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
4965 return INPUT_PIN_ATTR_INT;
4966 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
4967 return INPUT_PIN_ATTR_DOCK;
4968 if (loc == AC_JACK_LOC_REAR)
4969 return INPUT_PIN_ATTR_REAR;
4970 if (loc == AC_JACK_LOC_FRONT)
4971 return INPUT_PIN_ATTR_FRONT;
4972 return INPUT_PIN_ATTR_NORMAL;
4974 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
4977 * hda_get_input_pin_label - Give a label for the given input pin
4979 * When check_location is true, the function checks the pin location
4980 * for mic and line-in pins, and set an appropriate prefix like "Front",
4981 * "Rear", "Internal".
4984 const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
4987 unsigned int def_conf;
4988 static const char * const mic_names[] = {
4989 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4993 def_conf = snd_hda_codec_get_pincfg(codec, pin);
4995 switch (get_defcfg_device(def_conf)) {
4996 case AC_JACK_MIC_IN:
4997 if (!check_location)
4999 attr = snd_hda_get_input_pin_attr(def_conf);
5002 return mic_names[attr - 1];
5003 case AC_JACK_LINE_IN:
5004 if (!check_location)
5006 attr = snd_hda_get_input_pin_attr(def_conf);
5009 if (attr == INPUT_PIN_ATTR_DOCK)
5016 case AC_JACK_SPDIF_IN:
5018 case AC_JACK_DIG_OTHER_IN:
5019 return "Digital In";
5024 EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
5026 /* Check whether the location prefix needs to be added to the label.
5027 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5028 * have to put "Front" prefix to each label. In such a case, returns false.
5030 static int check_mic_location_need(struct hda_codec *codec,
5031 const struct auto_pin_cfg *cfg,
5037 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
5038 attr = snd_hda_get_input_pin_attr(defc);
5039 /* for internal or docking mics, we need locations */
5040 if (attr <= INPUT_PIN_ATTR_NORMAL)
5044 for (i = 0; i < cfg->num_inputs; i++) {
5045 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
5046 attr2 = snd_hda_get_input_pin_attr(defc);
5047 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
5048 if (attr && attr != attr2)
5049 return 1; /* different locations found */
5057 * hda_get_autocfg_input_label - Get a label for the given input
5059 * Get a label for the given input pin defined by the autocfg item.
5060 * Unlike hda_get_input_pin_label(), this function checks all inputs
5061 * defined in autocfg and avoids the redundant mic/line prefix as much as
5064 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5065 const struct auto_pin_cfg *cfg,
5068 int type = cfg->inputs[input].type;
5069 int has_multiple_pins = 0;
5071 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5072 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5073 has_multiple_pins = 1;
5074 if (has_multiple_pins && type == AUTO_PIN_MIC)
5075 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
5076 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5079 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5082 * snd_hda_add_imux_item - Add an item to input_mux
5084 * When the same label is used already in the existing items, the number
5085 * suffix is appended to the label. This label index number is stored
5086 * to type_idx when non-NULL pointer is given.
5088 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5089 int index, int *type_idx)
5091 int i, label_idx = 0;
5092 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5093 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5096 for (i = 0; i < imux->num_items; i++) {
5097 if (!strncmp(label, imux->items[i].label, strlen(label)))
5101 *type_idx = label_idx;
5103 snprintf(imux->items[imux->num_items].label,
5104 sizeof(imux->items[imux->num_items].label),
5105 "%s %d", label, label_idx);
5107 strlcpy(imux->items[imux->num_items].label, label,
5108 sizeof(imux->items[imux->num_items].label));
5109 imux->items[imux->num_items].index = index;
5113 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5122 * snd_hda_suspend - suspend the codecs
5125 * Returns 0 if successful.
5127 int snd_hda_suspend(struct hda_bus *bus)
5129 struct hda_codec *codec;
5131 list_for_each_entry(codec, &bus->codec_list, list) {
5132 if (hda_codec_is_power_on(codec))
5133 hda_call_codec_suspend(codec);
5134 if (codec->patch_ops.post_suspend)
5135 codec->patch_ops.post_suspend(codec);
5139 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5142 * snd_hda_resume - resume the codecs
5145 * Returns 0 if successful.
5147 * This function is defined only when POWER_SAVE isn't set.
5148 * In the power-save mode, the codec is resumed dynamically.
5150 int snd_hda_resume(struct hda_bus *bus)
5152 struct hda_codec *codec;
5154 list_for_each_entry(codec, &bus->codec_list, list) {
5155 if (codec->patch_ops.pre_resume)
5156 codec->patch_ops.pre_resume(codec);
5157 if (snd_hda_codec_needs_resume(codec))
5158 hda_call_codec_resume(codec);
5162 EXPORT_SYMBOL_HDA(snd_hda_resume);
5163 #endif /* CONFIG_PM */
5170 * snd_array_new - get a new element from the given array
5171 * @array: the array object
5173 * Get a new element from the given array. If it exceeds the
5174 * pre-allocated array size, re-allocate the array.
5176 * Returns NULL if allocation failed.
5178 void *snd_array_new(struct snd_array *array)
5180 if (array->used >= array->alloced) {
5181 int num = array->alloced + array->alloc_align;
5182 int size = (num + 1) * array->elem_size;
5183 int oldsize = array->alloced * array->elem_size;
5185 if (snd_BUG_ON(num >= 4096))
5187 nlist = krealloc(array->list, size, GFP_KERNEL);
5190 memset(nlist + oldsize, 0, size - oldsize);
5191 array->list = nlist;
5192 array->alloced = num;
5194 return snd_array_elem(array, array->used++);
5196 EXPORT_SYMBOL_HDA(snd_array_new);
5199 * snd_array_free - free the given array elements
5200 * @array: the array object
5202 void snd_array_free(struct snd_array *array)
5209 EXPORT_SYMBOL_HDA(snd_array_free);
5212 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5213 * @pcm: PCM caps bits
5214 * @buf: the string buffer to write
5215 * @buflen: the max buffer length
5217 * used by hda_proc.c and hda_eld.c
5219 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5221 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5224 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5225 if (pcm & (AC_SUPPCM_BITS_8 << i))
5226 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5228 buf[j] = '\0'; /* necessary when j == 0 */
5230 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5232 #ifdef CONFIG_SND_HDA_INPUT_JACK
5234 * Input-jack notification support
5236 struct hda_jack_item {
5239 struct snd_jack *jack;
5242 static const char *get_jack_default_name(struct hda_codec *codec, hda_nid_t nid,
5246 case SND_JACK_HEADPHONE:
5248 case SND_JACK_MICROPHONE:
5250 case SND_JACK_LINEOUT:
5252 case SND_JACK_LINEIN:
5254 case SND_JACK_HEADSET:
5256 case SND_JACK_VIDEOOUT:
5263 static void hda_free_jack_priv(struct snd_jack *jack)
5265 struct hda_jack_item *jacks = jack->private_data;
5270 int snd_hda_input_jack_add(struct hda_codec *codec, hda_nid_t nid, int type,
5273 struct hda_jack_item *jack;
5276 snd_array_init(&codec->jacks, sizeof(*jack), 32);
5277 jack = snd_array_new(&codec->jacks);
5284 name = get_jack_default_name(codec, nid, type);
5285 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
5290 jack->jack->private_data = jack;
5291 jack->jack->private_free = hda_free_jack_priv;
5294 EXPORT_SYMBOL_HDA(snd_hda_input_jack_add);
5296 void snd_hda_input_jack_report(struct hda_codec *codec, hda_nid_t nid)
5298 struct hda_jack_item *jacks = codec->jacks.list;
5304 for (i = 0; i < codec->jacks.used; i++, jacks++) {
5305 unsigned int pin_ctl;
5306 unsigned int present;
5309 if (jacks->nid != nid)
5311 present = snd_hda_jack_detect(codec, nid);
5313 if (type == (SND_JACK_HEADPHONE | SND_JACK_LINEOUT)) {
5314 pin_ctl = snd_hda_codec_read(codec, nid, 0,
5315 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5316 type = (pin_ctl & AC_PINCTL_HP_EN) ?
5317 SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
5319 snd_jack_report(jacks->jack, present ? type : 0);
5322 EXPORT_SYMBOL_HDA(snd_hda_input_jack_report);
5324 /* free jack instances manually when clearing/reconfiguring */
5325 void snd_hda_input_jack_free(struct hda_codec *codec)
5327 if (!codec->bus->shutdown && codec->jacks.list) {
5328 struct hda_jack_item *jacks = codec->jacks.list;
5330 for (i = 0; i < codec->jacks.used; i++, jacks++) {
5332 snd_device_free(codec->bus->card, jacks->jack);
5335 snd_array_free(&codec->jacks);
5337 EXPORT_SYMBOL_HDA(snd_hda_input_jack_free);
5338 #endif /* CONFIG_SND_HDA_INPUT_JACK */
5340 MODULE_DESCRIPTION("HDA codec core");
5341 MODULE_LICENSE("GPL");