2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
38 #include <sound/hda_hwdep.h>
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
44 * vendor / preset table
47 struct hda_vendor_id {
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
55 { 0x1013, "Cirrus Logic" },
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
59 { 0x10ec, "Realtek" },
60 { 0x1102, "Creative" },
64 { 0x11d4, "Analog Devices" },
65 { 0x13f6, "C-Media" },
66 { 0x14f1, "Conexant" },
67 { 0x17e8, "Chrontel" },
69 { 0x1aec, "Wolfson Microelectronics" },
70 { 0x434d, "C-Media" },
72 { 0x8384, "SigmaTel" },
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
98 #define codec_in_pm(codec) ((codec)->in_pm)
99 static void hda_power_work(struct work_struct *work);
100 static void hda_keep_power_on(struct hda_codec *codec);
101 #define hda_codec_is_power_on(codec) ((codec)->power_on)
102 static inline void hda_call_pm_notify(struct hda_bus *bus, bool power_up)
104 if (bus->ops.pm_notify)
105 bus->ops.pm_notify(bus, power_up);
108 #define codec_in_pm(codec) 0
109 static inline void hda_keep_power_on(struct hda_codec *codec) {}
110 #define hda_codec_is_power_on(codec) 1
111 #define hda_call_pm_notify(bus, state) {}
115 * snd_hda_get_jack_location - Give a location string of the jack
116 * @cfg: pin default config value
118 * Parse the pin default config value and returns the string of the
119 * jack location, e.g. "Rear", "Front", etc.
121 const char *snd_hda_get_jack_location(u32 cfg)
123 static char *bases[7] = {
124 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
126 static unsigned char specials_idx[] = {
131 static char *specials[] = {
132 "Rear Panel", "Drive Bar",
133 "Riser", "HDMI", "ATAPI",
134 "Mobile-In", "Mobile-Out"
137 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
138 if ((cfg & 0x0f) < 7)
139 return bases[cfg & 0x0f];
140 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
141 if (cfg == specials_idx[i])
146 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
149 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
150 * @cfg: pin default config value
152 * Parse the pin default config value and returns the string of the
153 * jack connectivity, i.e. external or internal connection.
155 const char *snd_hda_get_jack_connectivity(u32 cfg)
157 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
159 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
161 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
164 * snd_hda_get_jack_type - Give a type string of the jack
165 * @cfg: pin default config value
167 * Parse the pin default config value and returns the string of the
168 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
170 const char *snd_hda_get_jack_type(u32 cfg)
172 static char *jack_types[16] = {
173 "Line Out", "Speaker", "HP Out", "CD",
174 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
175 "Line In", "Aux", "Mic", "Telephony",
176 "SPDIF In", "Digitial In", "Reserved", "Other"
179 return jack_types[(cfg & AC_DEFCFG_DEVICE)
180 >> AC_DEFCFG_DEVICE_SHIFT];
182 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
185 * Compose a 32bit command word to be sent to the HD-audio controller
187 static inline unsigned int
188 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
189 unsigned int verb, unsigned int parm)
193 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
194 (verb & ~0xfff) || (parm & ~0xffff)) {
195 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
196 codec->addr, direct, nid, verb, parm);
200 val = (u32)codec->addr << 28;
201 val |= (u32)direct << 27;
202 val |= (u32)nid << 20;
209 * Send and receive a verb
211 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
214 struct hda_bus *bus = codec->bus;
223 snd_hda_power_up(codec);
224 mutex_lock(&bus->cmd_mutex);
226 trace_hda_send_cmd(codec, cmd);
227 err = bus->ops.command(bus, cmd);
230 /* process pending verbs */
231 bus->ops.get_response(bus, codec->addr);
234 *res = bus->ops.get_response(bus, codec->addr);
235 trace_hda_get_response(codec, *res);
237 mutex_unlock(&bus->cmd_mutex);
238 snd_hda_power_down(codec);
239 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
240 if (bus->response_reset) {
241 snd_printd("hda_codec: resetting BUS due to "
242 "fatal communication error\n");
243 trace_hda_bus_reset(bus);
244 bus->ops.bus_reset(bus);
248 /* clear reset-flag when the communication gets recovered */
249 if (!err || codec_in_pm(codec))
250 bus->response_reset = 0;
255 * snd_hda_codec_read - send a command and get the response
256 * @codec: the HDA codec
257 * @nid: NID to send the command
258 * @direct: direct flag
259 * @verb: the verb to send
260 * @parm: the parameter for the verb
262 * Send a single command and read the corresponding response.
264 * Returns the obtained response value, or -1 for an error.
266 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
268 unsigned int verb, unsigned int parm)
270 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
272 if (codec_exec_verb(codec, cmd, &res))
276 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
279 * snd_hda_codec_write - send a single command without waiting for response
280 * @codec: the HDA codec
281 * @nid: NID to send the command
282 * @direct: direct flag
283 * @verb: the verb to send
284 * @parm: the parameter for the verb
286 * Send a single command without waiting for response.
288 * Returns 0 if successful, or a negative error code.
290 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
291 unsigned int verb, unsigned int parm)
293 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
295 return codec_exec_verb(codec, cmd,
296 codec->bus->sync_write ? &res : NULL);
298 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
301 * snd_hda_sequence_write - sequence writes
302 * @codec: the HDA codec
303 * @seq: VERB array to send
305 * Send the commands sequentially from the given array.
306 * The array must be terminated with NID=0.
308 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
310 for (; seq->nid; seq++)
311 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
313 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
316 * snd_hda_get_sub_nodes - get the range of sub nodes
317 * @codec: the HDA codec
319 * @start_id: the pointer to store the start NID
321 * Parse the NID and store the start NID of its sub-nodes.
322 * Returns the number of sub-nodes.
324 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
329 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
332 *start_id = (parm >> 16) & 0x7fff;
333 return (int)(parm & 0x7fff);
335 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
337 /* connection list element */
338 struct hda_conn_list {
339 struct list_head list;
345 /* look up the cached results */
346 static struct hda_conn_list *
347 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
349 struct hda_conn_list *p;
350 list_for_each_entry(p, &codec->conn_list, list) {
357 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
358 const hda_nid_t *list)
360 struct hda_conn_list *p;
362 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
367 memcpy(p->conns, list, len * sizeof(hda_nid_t));
368 list_add(&p->list, &codec->conn_list);
372 static void remove_conn_list(struct hda_codec *codec)
374 while (!list_empty(&codec->conn_list)) {
375 struct hda_conn_list *p;
376 p = list_first_entry(&codec->conn_list, typeof(*p), list);
382 /* read the connection and add to the cache */
383 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
385 hda_nid_t list[HDA_MAX_CONNECTIONS];
388 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
391 return snd_hda_override_conn_list(codec, nid, len, list);
395 * snd_hda_get_conn_list - get connection list
396 * @codec: the HDA codec
398 * @len: number of connection list entries
399 * @listp: the pointer to store NID list
401 * Parses the connection list of the given widget and stores the pointer
402 * to the list of NIDs.
404 * Returns the number of connections, or a negative error code.
406 * Note that the returned pointer isn't protected against the list
407 * modification. If snd_hda_override_conn_list() might be called
408 * concurrently, protect with a mutex appropriately.
410 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
411 const hda_nid_t **listp)
417 const struct hda_conn_list *p;
419 /* if the connection-list is already cached, read it */
420 p = lookup_conn_list(codec, nid);
426 if (snd_BUG_ON(added))
429 err = read_and_add_raw_conns(codec, nid);
435 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
438 * snd_hda_get_connections - copy connection list
439 * @codec: the HDA codec
441 * @conn_list: connection list array; when NULL, checks only the size
442 * @max_conns: max. number of connections to store
444 * Parses the connection list of the given widget and stores the list
447 * Returns the number of connections, or a negative error code.
449 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
450 hda_nid_t *conn_list, int max_conns)
452 const hda_nid_t *list;
453 int len = snd_hda_get_conn_list(codec, nid, &list);
455 if (len > 0 && conn_list) {
456 if (len > max_conns) {
457 snd_printk(KERN_ERR "hda_codec: "
458 "Too many connections %d for NID 0x%x\n",
462 memcpy(conn_list, list, len * sizeof(hda_nid_t));
467 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
470 * snd_hda_get_raw_connections - copy connection list without cache
471 * @codec: the HDA codec
473 * @conn_list: connection list array
474 * @max_conns: max. number of connections to store
476 * Like snd_hda_get_connections(), copy the connection list but without
477 * checking through the connection-list cache.
478 * Currently called only from hda_proc.c, so not exported.
480 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
481 hda_nid_t *conn_list, int max_conns)
484 int i, conn_len, conns;
485 unsigned int shift, num_elems, mask;
490 if (snd_BUG_ON(!conn_list || max_conns <= 0))
493 wcaps = get_wcaps(codec, nid);
494 if (!(wcaps & AC_WCAP_CONN_LIST) &&
495 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
498 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
499 if (parm & AC_CLIST_LONG) {
508 conn_len = parm & AC_CLIST_LENGTH;
509 mask = (1 << (shift-1)) - 1;
512 return 0; /* no connection */
515 /* single connection */
516 parm = snd_hda_codec_read(codec, nid, 0,
517 AC_VERB_GET_CONNECT_LIST, 0);
518 if (parm == -1 && codec->bus->rirb_error)
520 conn_list[0] = parm & mask;
524 /* multi connection */
527 for (i = 0; i < conn_len; i++) {
531 if (i % num_elems == 0) {
532 parm = snd_hda_codec_read(codec, nid, 0,
533 AC_VERB_GET_CONNECT_LIST, i);
534 if (parm == -1 && codec->bus->rirb_error)
537 range_val = !!(parm & (1 << (shift-1))); /* ranges */
539 if (val == 0 && null_count++) { /* no second chance */
540 snd_printk(KERN_WARNING "hda_codec: "
541 "invalid CONNECT_LIST verb %x[%i]:%x\n",
547 /* ranges between the previous and this one */
548 if (!prev_nid || prev_nid >= val) {
549 snd_printk(KERN_WARNING "hda_codec: "
550 "invalid dep_range_val %x:%x\n",
554 for (n = prev_nid + 1; n <= val; n++) {
555 if (conns >= max_conns) {
556 snd_printk(KERN_ERR "hda_codec: "
557 "Too many connections %d for NID 0x%x\n",
561 conn_list[conns++] = n;
564 if (conns >= max_conns) {
565 snd_printk(KERN_ERR "hda_codec: "
566 "Too many connections %d for NID 0x%x\n",
570 conn_list[conns++] = val;
578 * snd_hda_override_conn_list - add/modify the connection-list to cache
579 * @codec: the HDA codec
581 * @len: number of connection list entries
582 * @list: the list of connection entries
584 * Add or modify the given connection-list to the cache. If the corresponding
585 * cache already exists, invalidate it and append a new one.
587 * Returns zero or a negative error code.
589 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
590 const hda_nid_t *list)
592 struct hda_conn_list *p;
594 p = lookup_conn_list(codec, nid);
600 return add_conn_list(codec, nid, len, list);
602 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
605 * snd_hda_get_conn_index - get the connection index of the given NID
606 * @codec: the HDA codec
607 * @mux: NID containing the list
608 * @nid: NID to select
609 * @recursive: 1 when searching NID recursively, otherwise 0
611 * Parses the connection list of the widget @mux and checks whether the
612 * widget @nid is present. If it is, return the connection index.
613 * Otherwise it returns -1.
615 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
616 hda_nid_t nid, int recursive)
618 const hda_nid_t *conn;
621 nums = snd_hda_get_conn_list(codec, mux, &conn);
622 for (i = 0; i < nums; i++)
627 if (recursive > 10) {
628 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
632 for (i = 0; i < nums; i++) {
633 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
634 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
636 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
641 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
644 * snd_hda_queue_unsol_event - add an unsolicited event to queue
646 * @res: unsolicited event (lower 32bit of RIRB entry)
647 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
649 * Adds the given event to the queue. The events are processed in
650 * the workqueue asynchronously. Call this function in the interrupt
651 * hanlder when RIRB receives an unsolicited event.
653 * Returns 0 if successful, or a negative error code.
655 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
657 struct hda_bus_unsolicited *unsol;
660 trace_hda_unsol_event(bus, res, res_ex);
665 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
669 unsol->queue[wp] = res;
670 unsol->queue[wp + 1] = res_ex;
672 queue_work(bus->workq, &unsol->work);
676 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
679 * process queued unsolicited events
681 static void process_unsol_events(struct work_struct *work)
683 struct hda_bus_unsolicited *unsol =
684 container_of(work, struct hda_bus_unsolicited, work);
685 struct hda_bus *bus = unsol->bus;
686 struct hda_codec *codec;
687 unsigned int rp, caddr, res;
689 while (unsol->rp != unsol->wp) {
690 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
693 res = unsol->queue[rp];
694 caddr = unsol->queue[rp + 1];
695 if (!(caddr & (1 << 4))) /* no unsolicited event? */
697 codec = bus->caddr_tbl[caddr & 0x0f];
698 if (codec && codec->patch_ops.unsol_event)
699 codec->patch_ops.unsol_event(codec, res);
704 * initialize unsolicited queue
706 static int init_unsol_queue(struct hda_bus *bus)
708 struct hda_bus_unsolicited *unsol;
710 if (bus->unsol) /* already initialized */
713 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
715 snd_printk(KERN_ERR "hda_codec: "
716 "can't allocate unsolicited queue\n");
719 INIT_WORK(&unsol->work, process_unsol_events);
728 static void snd_hda_codec_free(struct hda_codec *codec);
730 static int snd_hda_bus_free(struct hda_bus *bus)
732 struct hda_codec *codec, *n;
737 flush_workqueue(bus->workq);
740 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
741 snd_hda_codec_free(codec);
743 if (bus->ops.private_free)
744 bus->ops.private_free(bus);
746 destroy_workqueue(bus->workq);
751 static int snd_hda_bus_dev_free(struct snd_device *device)
753 struct hda_bus *bus = device->device_data;
755 return snd_hda_bus_free(bus);
758 #ifdef CONFIG_SND_HDA_HWDEP
759 static int snd_hda_bus_dev_register(struct snd_device *device)
761 struct hda_bus *bus = device->device_data;
762 struct hda_codec *codec;
763 list_for_each_entry(codec, &bus->codec_list, list) {
764 snd_hda_hwdep_add_sysfs(codec);
765 snd_hda_hwdep_add_power_sysfs(codec);
770 #define snd_hda_bus_dev_register NULL
774 * snd_hda_bus_new - create a HDA bus
775 * @card: the card entry
776 * @temp: the template for hda_bus information
777 * @busp: the pointer to store the created bus instance
779 * Returns 0 if successful, or a negative error code.
781 int snd_hda_bus_new(struct snd_card *card,
782 const struct hda_bus_template *temp,
783 struct hda_bus **busp)
787 static struct snd_device_ops dev_ops = {
788 .dev_register = snd_hda_bus_dev_register,
789 .dev_free = snd_hda_bus_dev_free,
792 if (snd_BUG_ON(!temp))
794 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
800 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
802 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
807 bus->private_data = temp->private_data;
808 bus->pci = temp->pci;
809 bus->modelname = temp->modelname;
810 bus->power_save = temp->power_save;
811 bus->ops = temp->ops;
813 mutex_init(&bus->cmd_mutex);
814 mutex_init(&bus->prepare_mutex);
815 INIT_LIST_HEAD(&bus->codec_list);
817 snprintf(bus->workq_name, sizeof(bus->workq_name),
818 "hd-audio%d", card->number);
819 bus->workq = create_singlethread_workqueue(bus->workq_name);
821 snd_printk(KERN_ERR "cannot create workqueue %s\n",
827 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
829 snd_hda_bus_free(bus);
836 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
838 #ifdef CONFIG_SND_HDA_GENERIC
839 #define is_generic_config(codec) \
840 (codec->modelname && !strcmp(codec->modelname, "generic"))
842 #define is_generic_config(codec) 0
846 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
848 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
852 * find a matching codec preset
854 static const struct hda_codec_preset *
855 find_codec_preset(struct hda_codec *codec)
857 struct hda_codec_preset_list *tbl;
858 const struct hda_codec_preset *preset;
859 unsigned int mod_requested = 0;
861 if (is_generic_config(codec))
862 return NULL; /* use the generic parser */
865 mutex_lock(&preset_mutex);
866 list_for_each_entry(tbl, &hda_preset_tables, list) {
867 if (!try_module_get(tbl->owner)) {
868 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
871 for (preset = tbl->preset; preset->id; preset++) {
872 u32 mask = preset->mask;
873 if (preset->afg && preset->afg != codec->afg)
875 if (preset->mfg && preset->mfg != codec->mfg)
879 if (preset->id == (codec->vendor_id & mask) &&
881 preset->rev == codec->revision_id)) {
882 mutex_unlock(&preset_mutex);
883 codec->owner = tbl->owner;
887 module_put(tbl->owner);
889 mutex_unlock(&preset_mutex);
891 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
894 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
897 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
898 (codec->vendor_id >> 16) & 0xffff);
899 request_module(name);
907 * get_codec_name - store the codec name
909 static int get_codec_name(struct hda_codec *codec)
911 const struct hda_vendor_id *c;
912 const char *vendor = NULL;
913 u16 vendor_id = codec->vendor_id >> 16;
916 if (codec->vendor_name)
919 for (c = hda_vendor_ids; c->id; c++) {
920 if (c->id == vendor_id) {
926 sprintf(tmp, "Generic %04x", vendor_id);
929 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
930 if (!codec->vendor_name)
934 if (codec->chip_name)
937 if (codec->preset && codec->preset->name)
938 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
940 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
941 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
943 if (!codec->chip_name)
949 * look for an AFG and MFG nodes
951 static void setup_fg_nodes(struct hda_codec *codec)
953 int i, total_nodes, function_id;
956 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
957 for (i = 0; i < total_nodes; i++, nid++) {
958 function_id = snd_hda_param_read(codec, nid,
959 AC_PAR_FUNCTION_TYPE);
960 switch (function_id & 0xff) {
961 case AC_GRP_AUDIO_FUNCTION:
963 codec->afg_function_id = function_id & 0xff;
964 codec->afg_unsol = (function_id >> 8) & 1;
966 case AC_GRP_MODEM_FUNCTION:
968 codec->mfg_function_id = function_id & 0xff;
969 codec->mfg_unsol = (function_id >> 8) & 1;
978 * read widget caps for each widget and store in cache
980 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
985 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
987 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
990 nid = codec->start_nid;
991 for (i = 0; i < codec->num_nodes; i++, nid++)
992 codec->wcaps[i] = snd_hda_param_read(codec, nid,
993 AC_PAR_AUDIO_WIDGET_CAP);
997 /* read all pin default configurations and save codec->init_pins */
998 static int read_pin_defaults(struct hda_codec *codec)
1001 hda_nid_t nid = codec->start_nid;
1003 for (i = 0; i < codec->num_nodes; i++, nid++) {
1004 struct hda_pincfg *pin;
1005 unsigned int wcaps = get_wcaps(codec, nid);
1006 unsigned int wid_type = get_wcaps_type(wcaps);
1007 if (wid_type != AC_WID_PIN)
1009 pin = snd_array_new(&codec->init_pins);
1013 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1014 AC_VERB_GET_CONFIG_DEFAULT, 0);
1015 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1016 AC_VERB_GET_PIN_WIDGET_CONTROL,
1022 /* look up the given pin config list and return the item matching with NID */
1023 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1024 struct snd_array *array,
1028 for (i = 0; i < array->used; i++) {
1029 struct hda_pincfg *pin = snd_array_elem(array, i);
1030 if (pin->nid == nid)
1036 /* set the current pin config value for the given NID.
1037 * the value is cached, and read via snd_hda_codec_get_pincfg()
1039 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1040 hda_nid_t nid, unsigned int cfg)
1042 struct hda_pincfg *pin;
1044 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1047 pin = look_up_pincfg(codec, list, nid);
1049 pin = snd_array_new(list);
1059 * snd_hda_codec_set_pincfg - Override a pin default configuration
1060 * @codec: the HDA codec
1061 * @nid: NID to set the pin config
1062 * @cfg: the pin default config value
1064 * Override a pin default configuration value in the cache.
1065 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1066 * priority than the real hardware value.
1068 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1069 hda_nid_t nid, unsigned int cfg)
1071 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1073 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1076 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1077 * @codec: the HDA codec
1078 * @nid: NID to get the pin config
1080 * Get the current pin config value of the given pin NID.
1081 * If the pincfg value is cached or overridden via sysfs or driver,
1082 * returns the cached value.
1084 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1086 struct hda_pincfg *pin;
1088 #ifdef CONFIG_SND_HDA_HWDEP
1089 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1093 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1096 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1101 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1104 * snd_hda_shutup_pins - Shut up all pins
1105 * @codec: the HDA codec
1107 * Clear all pin controls to shup up before suspend for avoiding click noise.
1108 * The controls aren't cached so that they can be resumed properly.
1110 void snd_hda_shutup_pins(struct hda_codec *codec)
1113 /* don't shut up pins when unloading the driver; otherwise it breaks
1114 * the default pin setup at the next load of the driver
1116 if (codec->bus->shutdown)
1118 for (i = 0; i < codec->init_pins.used; i++) {
1119 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1120 /* use read here for syncing after issuing each verb */
1121 snd_hda_codec_read(codec, pin->nid, 0,
1122 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1124 codec->pins_shutup = 1;
1126 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1129 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1130 static void restore_shutup_pins(struct hda_codec *codec)
1133 if (!codec->pins_shutup)
1135 if (codec->bus->shutdown)
1137 for (i = 0; i < codec->init_pins.used; i++) {
1138 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1139 snd_hda_codec_write(codec, pin->nid, 0,
1140 AC_VERB_SET_PIN_WIDGET_CONTROL,
1143 codec->pins_shutup = 0;
1147 static void hda_jackpoll_work(struct work_struct *work)
1149 struct hda_codec *codec =
1150 container_of(work, struct hda_codec, jackpoll_work.work);
1151 if (!codec->jackpoll_interval)
1154 snd_hda_jack_set_dirty_all(codec);
1155 snd_hda_jack_poll_all(codec);
1156 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1157 codec->jackpoll_interval);
1160 static void init_hda_cache(struct hda_cache_rec *cache,
1161 unsigned int record_size);
1162 static void free_hda_cache(struct hda_cache_rec *cache);
1164 /* release all pincfg lists */
1165 static void free_init_pincfgs(struct hda_codec *codec)
1167 snd_array_free(&codec->driver_pins);
1168 #ifdef CONFIG_SND_HDA_HWDEP
1169 snd_array_free(&codec->user_pins);
1171 snd_array_free(&codec->init_pins);
1175 * audio-converter setup caches
1177 struct hda_cvt_setup {
1182 unsigned char active; /* cvt is currently used */
1183 unsigned char dirty; /* setups should be cleared */
1186 /* get or create a cache entry for the given audio converter NID */
1187 static struct hda_cvt_setup *
1188 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1190 struct hda_cvt_setup *p;
1193 for (i = 0; i < codec->cvt_setups.used; i++) {
1194 p = snd_array_elem(&codec->cvt_setups, i);
1198 p = snd_array_new(&codec->cvt_setups);
1207 static void snd_hda_codec_free(struct hda_codec *codec)
1211 cancel_delayed_work_sync(&codec->jackpoll_work);
1212 snd_hda_jack_tbl_clear(codec);
1213 free_init_pincfgs(codec);
1215 cancel_delayed_work(&codec->power_work);
1216 flush_workqueue(codec->bus->workq);
1218 list_del(&codec->list);
1219 snd_array_free(&codec->mixers);
1220 snd_array_free(&codec->nids);
1221 snd_array_free(&codec->cvt_setups);
1222 snd_array_free(&codec->spdif_out);
1223 remove_conn_list(codec);
1224 codec->bus->caddr_tbl[codec->addr] = NULL;
1225 if (codec->patch_ops.free)
1226 codec->patch_ops.free(codec);
1228 if (!codec->pm_down_notified) /* cancel leftover refcounts */
1229 hda_call_pm_notify(codec->bus, false);
1231 module_put(codec->owner);
1232 free_hda_cache(&codec->amp_cache);
1233 free_hda_cache(&codec->cmd_cache);
1234 kfree(codec->vendor_name);
1235 kfree(codec->chip_name);
1236 kfree(codec->modelname);
1237 kfree(codec->wcaps);
1241 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1242 hda_nid_t fg, unsigned int power_state);
1244 static unsigned int hda_set_power_state(struct hda_codec *codec,
1245 unsigned int power_state);
1248 * snd_hda_codec_new - create a HDA codec
1249 * @bus: the bus to assign
1250 * @codec_addr: the codec address
1251 * @codecp: the pointer to store the generated codec
1253 * Returns 0 if successful, or a negative error code.
1255 int snd_hda_codec_new(struct hda_bus *bus,
1256 unsigned int codec_addr,
1257 struct hda_codec **codecp)
1259 struct hda_codec *codec;
1264 if (snd_BUG_ON(!bus))
1266 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1269 if (bus->caddr_tbl[codec_addr]) {
1270 snd_printk(KERN_ERR "hda_codec: "
1271 "address 0x%x is already occupied\n", codec_addr);
1275 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1276 if (codec == NULL) {
1277 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1282 codec->addr = codec_addr;
1283 mutex_init(&codec->spdif_mutex);
1284 mutex_init(&codec->control_mutex);
1285 mutex_init(&codec->hash_mutex);
1286 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1287 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1288 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1289 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1290 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1291 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1292 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1293 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1294 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1295 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1296 INIT_LIST_HEAD(&codec->conn_list);
1298 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1301 spin_lock_init(&codec->power_lock);
1302 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1303 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1304 * the caller has to power down appropriatley after initialization
1307 hda_keep_power_on(codec);
1308 hda_call_pm_notify(bus, true);
1311 if (codec->bus->modelname) {
1312 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1313 if (!codec->modelname) {
1314 snd_hda_codec_free(codec);
1319 list_add_tail(&codec->list, &bus->codec_list);
1320 bus->caddr_tbl[codec_addr] = codec;
1322 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1324 if (codec->vendor_id == -1)
1325 /* read again, hopefully the access method was corrected
1326 * in the last read...
1328 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1330 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1331 AC_PAR_SUBSYSTEM_ID);
1332 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1335 setup_fg_nodes(codec);
1336 if (!codec->afg && !codec->mfg) {
1337 snd_printdd("hda_codec: no AFG or MFG node found\n");
1342 fg = codec->afg ? codec->afg : codec->mfg;
1343 err = read_widget_caps(codec, fg);
1345 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1348 err = read_pin_defaults(codec);
1352 if (!codec->subsystem_id) {
1353 codec->subsystem_id =
1354 snd_hda_codec_read(codec, fg, 0,
1355 AC_VERB_GET_SUBSYSTEM_ID, 0);
1359 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1361 if (!codec->d3_stop_clk)
1362 bus->power_keep_link_on = 1;
1364 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1367 /* power-up all before initialization */
1368 hda_set_power_state(codec, AC_PWRST_D0);
1370 snd_hda_codec_proc_new(codec);
1372 snd_hda_create_hwdep(codec);
1374 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1375 codec->subsystem_id, codec->revision_id);
1376 snd_component_add(codec->bus->card, component);
1383 snd_hda_codec_free(codec);
1386 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1389 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1390 * @codec: the HDA codec
1392 * Start parsing of the given codec tree and (re-)initialize the whole
1395 * Returns 0 if successful or a negative error code.
1397 int snd_hda_codec_configure(struct hda_codec *codec)
1401 codec->preset = find_codec_preset(codec);
1402 if (!codec->vendor_name || !codec->chip_name) {
1403 err = get_codec_name(codec);
1408 if (is_generic_config(codec)) {
1409 err = snd_hda_parse_generic_codec(codec);
1412 if (codec->preset && codec->preset->patch) {
1413 err = codec->preset->patch(codec);
1417 /* call the default parser */
1418 err = snd_hda_parse_generic_codec(codec);
1420 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1423 if (!err && codec->patch_ops.unsol_event)
1424 err = init_unsol_queue(codec->bus);
1425 /* audio codec should override the mixer name */
1426 if (!err && (codec->afg || !*codec->bus->card->mixername))
1427 snprintf(codec->bus->card->mixername,
1428 sizeof(codec->bus->card->mixername),
1429 "%s %s", codec->vendor_name, codec->chip_name);
1432 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1434 /* update the stream-id if changed */
1435 static void update_pcm_stream_id(struct hda_codec *codec,
1436 struct hda_cvt_setup *p, hda_nid_t nid,
1437 u32 stream_tag, int channel_id)
1439 unsigned int oldval, newval;
1441 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1442 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1443 newval = (stream_tag << 4) | channel_id;
1444 if (oldval != newval)
1445 snd_hda_codec_write(codec, nid, 0,
1446 AC_VERB_SET_CHANNEL_STREAMID,
1448 p->stream_tag = stream_tag;
1449 p->channel_id = channel_id;
1453 /* update the format-id if changed */
1454 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1455 hda_nid_t nid, int format)
1457 unsigned int oldval;
1459 if (p->format_id != format) {
1460 oldval = snd_hda_codec_read(codec, nid, 0,
1461 AC_VERB_GET_STREAM_FORMAT, 0);
1462 if (oldval != format) {
1464 snd_hda_codec_write(codec, nid, 0,
1465 AC_VERB_SET_STREAM_FORMAT,
1468 p->format_id = format;
1473 * snd_hda_codec_setup_stream - set up the codec for streaming
1474 * @codec: the CODEC to set up
1475 * @nid: the NID to set up
1476 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1477 * @channel_id: channel id to pass, zero based.
1478 * @format: stream format.
1480 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1482 int channel_id, int format)
1484 struct hda_codec *c;
1485 struct hda_cvt_setup *p;
1492 snd_printdd("hda_codec_setup_stream: "
1493 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1494 nid, stream_tag, channel_id, format);
1495 p = get_hda_cvt_setup(codec, nid);
1499 if (codec->pcm_format_first)
1500 update_pcm_format(codec, p, nid, format);
1501 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1502 if (!codec->pcm_format_first)
1503 update_pcm_format(codec, p, nid, format);
1508 /* make other inactive cvts with the same stream-tag dirty */
1509 type = get_wcaps_type(get_wcaps(codec, nid));
1510 list_for_each_entry(c, &codec->bus->codec_list, list) {
1511 for (i = 0; i < c->cvt_setups.used; i++) {
1512 p = snd_array_elem(&c->cvt_setups, i);
1513 if (!p->active && p->stream_tag == stream_tag &&
1514 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1519 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1521 static void really_cleanup_stream(struct hda_codec *codec,
1522 struct hda_cvt_setup *q);
1525 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1526 * @codec: the CODEC to clean up
1527 * @nid: the NID to clean up
1528 * @do_now: really clean up the stream instead of clearing the active flag
1530 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1533 struct hda_cvt_setup *p;
1538 if (codec->no_sticky_stream)
1541 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1542 p = get_hda_cvt_setup(codec, nid);
1544 /* here we just clear the active flag when do_now isn't set;
1545 * actual clean-ups will be done later in
1546 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1549 really_cleanup_stream(codec, p);
1554 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1556 static void really_cleanup_stream(struct hda_codec *codec,
1557 struct hda_cvt_setup *q)
1559 hda_nid_t nid = q->nid;
1560 if (q->stream_tag || q->channel_id)
1561 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1563 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1565 memset(q, 0, sizeof(*q));
1569 /* clean up the all conflicting obsolete streams */
1570 static void purify_inactive_streams(struct hda_codec *codec)
1572 struct hda_codec *c;
1575 list_for_each_entry(c, &codec->bus->codec_list, list) {
1576 for (i = 0; i < c->cvt_setups.used; i++) {
1577 struct hda_cvt_setup *p;
1578 p = snd_array_elem(&c->cvt_setups, i);
1580 really_cleanup_stream(c, p);
1586 /* clean up all streams; called from suspend */
1587 static void hda_cleanup_all_streams(struct hda_codec *codec)
1591 for (i = 0; i < codec->cvt_setups.used; i++) {
1592 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1594 really_cleanup_stream(codec, p);
1600 * amp access functions
1603 /* FIXME: more better hash key? */
1604 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1605 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1606 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1607 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1608 #define INFO_AMP_CAPS (1<<0)
1609 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1611 /* initialize the hash table */
1612 static void init_hda_cache(struct hda_cache_rec *cache,
1613 unsigned int record_size)
1615 memset(cache, 0, sizeof(*cache));
1616 memset(cache->hash, 0xff, sizeof(cache->hash));
1617 snd_array_init(&cache->buf, record_size, 64);
1620 static void free_hda_cache(struct hda_cache_rec *cache)
1622 snd_array_free(&cache->buf);
1625 /* query the hash. allocate an entry if not found. */
1626 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1628 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1629 u16 cur = cache->hash[idx];
1630 struct hda_cache_head *info;
1632 while (cur != 0xffff) {
1633 info = snd_array_elem(&cache->buf, cur);
1634 if (info->key == key)
1641 /* query the hash. allocate an entry if not found. */
1642 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1645 struct hda_cache_head *info = get_hash(cache, key);
1648 /* add a new hash entry */
1649 info = snd_array_new(&cache->buf);
1652 cur = snd_array_index(&cache->buf, info);
1656 idx = key % (u16)ARRAY_SIZE(cache->hash);
1657 info->next = cache->hash[idx];
1658 cache->hash[idx] = cur;
1663 /* query and allocate an amp hash entry */
1664 static inline struct hda_amp_info *
1665 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1667 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1670 /* overwrite the value with the key in the caps hash */
1671 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1673 struct hda_amp_info *info;
1675 mutex_lock(&codec->hash_mutex);
1676 info = get_alloc_amp_hash(codec, key);
1678 mutex_unlock(&codec->hash_mutex);
1681 info->amp_caps = val;
1682 info->head.val |= INFO_AMP_CAPS;
1683 mutex_unlock(&codec->hash_mutex);
1687 /* query the value from the caps hash; if not found, fetch the current
1688 * value from the given function and store in the hash
1691 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1692 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1694 struct hda_amp_info *info;
1697 mutex_lock(&codec->hash_mutex);
1698 info = get_alloc_amp_hash(codec, key);
1700 mutex_unlock(&codec->hash_mutex);
1703 if (!(info->head.val & INFO_AMP_CAPS)) {
1704 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1705 val = func(codec, nid, dir);
1706 write_caps_hash(codec, key, val);
1708 val = info->amp_caps;
1709 mutex_unlock(&codec->hash_mutex);
1714 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1717 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1719 return snd_hda_param_read(codec, nid,
1720 direction == HDA_OUTPUT ?
1721 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1725 * query_amp_caps - query AMP capabilities
1726 * @codec: the HD-auio codec
1727 * @nid: the NID to query
1728 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1730 * Query AMP capabilities for the given widget and direction.
1731 * Returns the obtained capability bits.
1733 * When cap bits have been already read, this doesn't read again but
1734 * returns the cached value.
1736 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1738 return query_caps_hash(codec, nid, direction,
1739 HDA_HASH_KEY(nid, direction, 0),
1742 EXPORT_SYMBOL_HDA(query_amp_caps);
1745 * snd_hda_override_amp_caps - Override the AMP capabilities
1746 * @codec: the CODEC to clean up
1747 * @nid: the NID to clean up
1748 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1749 * @caps: the capability bits to set
1751 * Override the cached AMP caps bits value by the given one.
1752 * This function is useful if the driver needs to adjust the AMP ranges,
1753 * e.g. limit to 0dB, etc.
1755 * Returns zero if successful or a negative error code.
1757 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1760 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1762 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1764 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1767 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1771 * snd_hda_query_pin_caps - Query PIN capabilities
1772 * @codec: the HD-auio codec
1773 * @nid: the NID to query
1775 * Query PIN capabilities for the given widget.
1776 * Returns the obtained capability bits.
1778 * When cap bits have been already read, this doesn't read again but
1779 * returns the cached value.
1781 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1783 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1786 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1789 * snd_hda_override_pin_caps - Override the pin capabilities
1791 * @nid: the NID to override
1792 * @caps: the capability bits to set
1794 * Override the cached PIN capabilitiy bits value by the given one.
1796 * Returns zero if successful or a negative error code.
1798 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1801 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1803 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1805 /* read or sync the hash value with the current value;
1806 * call within hash_mutex
1808 static struct hda_amp_info *
1809 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1810 int direction, int index, bool init_only)
1812 struct hda_amp_info *info;
1813 unsigned int parm, val = 0;
1814 bool val_read = false;
1817 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1820 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1822 mutex_unlock(&codec->hash_mutex);
1823 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1824 parm |= direction == HDA_OUTPUT ?
1825 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1827 val = snd_hda_codec_read(codec, nid, 0,
1828 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1831 mutex_lock(&codec->hash_mutex);
1834 info->vol[ch] = val;
1835 info->head.val |= INFO_AMP_VOL(ch);
1836 } else if (init_only)
1842 * write the current volume in info to the h/w
1844 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
1845 hda_nid_t nid, int ch, int direction, int index,
1850 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1851 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1852 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1853 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
1854 (amp_caps & AC_AMPCAP_MIN_MUTE))
1855 ; /* set the zero value as a fake mute */
1858 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1862 * snd_hda_codec_amp_read - Read AMP value
1863 * @codec: HD-audio codec
1864 * @nid: NID to read the AMP value
1865 * @ch: channel (left=0 or right=1)
1866 * @direction: #HDA_INPUT or #HDA_OUTPUT
1867 * @index: the index value (only for input direction)
1869 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1871 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1872 int direction, int index)
1874 struct hda_amp_info *info;
1875 unsigned int val = 0;
1877 mutex_lock(&codec->hash_mutex);
1878 info = update_amp_hash(codec, nid, ch, direction, index, false);
1880 val = info->vol[ch];
1881 mutex_unlock(&codec->hash_mutex);
1884 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1886 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1887 int direction, int idx, int mask, int val,
1890 struct hda_amp_info *info;
1892 unsigned int cache_only;
1894 if (snd_BUG_ON(mask & ~0xff))
1898 mutex_lock(&codec->hash_mutex);
1899 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
1901 mutex_unlock(&codec->hash_mutex);
1904 val |= info->vol[ch] & ~mask;
1905 if (info->vol[ch] == val) {
1906 mutex_unlock(&codec->hash_mutex);
1909 info->vol[ch] = val;
1910 cache_only = info->head.dirty = codec->cached_write;
1911 caps = info->amp_caps;
1912 mutex_unlock(&codec->hash_mutex);
1914 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
1919 * snd_hda_codec_amp_update - update the AMP value
1920 * @codec: HD-audio codec
1921 * @nid: NID to read the AMP value
1922 * @ch: channel (left=0 or right=1)
1923 * @direction: #HDA_INPUT or #HDA_OUTPUT
1924 * @idx: the index value (only for input direction)
1925 * @mask: bit mask to set
1926 * @val: the bits value to set
1928 * Update the AMP value with a bit mask.
1929 * Returns 0 if the value is unchanged, 1 if changed.
1931 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1932 int direction, int idx, int mask, int val)
1934 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
1936 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1939 * snd_hda_codec_amp_stereo - update the AMP stereo values
1940 * @codec: HD-audio codec
1941 * @nid: NID to read the AMP value
1942 * @direction: #HDA_INPUT or #HDA_OUTPUT
1943 * @idx: the index value (only for input direction)
1944 * @mask: bit mask to set
1945 * @val: the bits value to set
1947 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1948 * stereo widget with the same mask and value.
1950 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1951 int direction, int idx, int mask, int val)
1955 if (snd_BUG_ON(mask & ~0xff))
1957 for (ch = 0; ch < 2; ch++)
1958 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1962 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1964 /* Works like snd_hda_codec_amp_update() but it writes the value only at
1965 * the first access. If the amp was already initialized / updated beforehand,
1966 * this does nothing.
1968 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
1969 int dir, int idx, int mask, int val)
1971 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
1973 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
1975 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
1976 int dir, int idx, int mask, int val)
1980 if (snd_BUG_ON(mask & ~0xff))
1982 for (ch = 0; ch < 2; ch++)
1983 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
1987 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
1990 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1991 * @codec: HD-audio codec
1993 * Resume the all amp commands from the cache.
1995 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1999 mutex_lock(&codec->hash_mutex);
2000 codec->cached_write = 0;
2001 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2002 struct hda_amp_info *buffer;
2005 unsigned int idx, dir, ch;
2006 struct hda_amp_info info;
2008 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2009 if (!buffer->head.dirty)
2011 buffer->head.dirty = 0;
2013 key = info.head.key;
2017 idx = (key >> 16) & 0xff;
2018 dir = (key >> 24) & 0xff;
2019 for (ch = 0; ch < 2; ch++) {
2020 if (!(info.head.val & INFO_AMP_VOL(ch)))
2022 mutex_unlock(&codec->hash_mutex);
2023 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2025 mutex_lock(&codec->hash_mutex);
2028 mutex_unlock(&codec->hash_mutex);
2030 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
2032 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2035 u32 caps = query_amp_caps(codec, nid, dir);
2037 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2044 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2046 * The control element is supposed to have the private_value field
2047 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2049 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2050 struct snd_ctl_elem_info *uinfo)
2052 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2053 u16 nid = get_amp_nid(kcontrol);
2054 u8 chs = get_amp_channels(kcontrol);
2055 int dir = get_amp_direction(kcontrol);
2056 unsigned int ofs = get_amp_offset(kcontrol);
2058 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2059 uinfo->count = chs == 3 ? 2 : 1;
2060 uinfo->value.integer.min = 0;
2061 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2062 if (!uinfo->value.integer.max) {
2063 printk(KERN_WARNING "hda_codec: "
2064 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2070 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
2073 static inline unsigned int
2074 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2075 int ch, int dir, int idx, unsigned int ofs)
2078 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2079 val &= HDA_AMP_VOLMASK;
2088 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2089 int ch, int dir, int idx, unsigned int ofs,
2092 unsigned int maxval;
2096 /* ofs = 0: raw max value */
2097 maxval = get_amp_max_value(codec, nid, dir, 0);
2100 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2101 HDA_AMP_VOLMASK, val);
2105 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2107 * The control element is supposed to have the private_value field
2108 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2110 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2111 struct snd_ctl_elem_value *ucontrol)
2113 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2114 hda_nid_t nid = get_amp_nid(kcontrol);
2115 int chs = get_amp_channels(kcontrol);
2116 int dir = get_amp_direction(kcontrol);
2117 int idx = get_amp_index(kcontrol);
2118 unsigned int ofs = get_amp_offset(kcontrol);
2119 long *valp = ucontrol->value.integer.value;
2122 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2124 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2127 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2130 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2132 * The control element is supposed to have the private_value field
2133 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2135 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2136 struct snd_ctl_elem_value *ucontrol)
2138 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2139 hda_nid_t nid = get_amp_nid(kcontrol);
2140 int chs = get_amp_channels(kcontrol);
2141 int dir = get_amp_direction(kcontrol);
2142 int idx = get_amp_index(kcontrol);
2143 unsigned int ofs = get_amp_offset(kcontrol);
2144 long *valp = ucontrol->value.integer.value;
2147 snd_hda_power_up(codec);
2149 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2153 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2154 snd_hda_power_down(codec);
2157 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2160 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2162 * The control element is supposed to have the private_value field
2163 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2165 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2166 unsigned int size, unsigned int __user *_tlv)
2168 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2169 hda_nid_t nid = get_amp_nid(kcontrol);
2170 int dir = get_amp_direction(kcontrol);
2171 unsigned int ofs = get_amp_offset(kcontrol);
2172 bool min_mute = get_amp_min_mute(kcontrol);
2173 u32 caps, val1, val2;
2175 if (size < 4 * sizeof(unsigned int))
2177 caps = query_amp_caps(codec, nid, dir);
2178 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2179 val2 = (val2 + 1) * 25;
2180 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2182 val1 = ((int)val1) * ((int)val2);
2183 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2184 val2 |= TLV_DB_SCALE_MUTE;
2185 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2187 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2189 if (put_user(val1, _tlv + 2))
2191 if (put_user(val2, _tlv + 3))
2195 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2198 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2199 * @codec: HD-audio codec
2200 * @nid: NID of a reference widget
2201 * @dir: #HDA_INPUT or #HDA_OUTPUT
2202 * @tlv: TLV data to be stored, at least 4 elements
2204 * Set (static) TLV data for a virtual master volume using the AMP caps
2205 * obtained from the reference NID.
2206 * The volume range is recalculated as if the max volume is 0dB.
2208 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2214 caps = query_amp_caps(codec, nid, dir);
2215 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2216 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2217 step = (step + 1) * 25;
2218 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2219 tlv[1] = 2 * sizeof(unsigned int);
2220 tlv[2] = -nums * step;
2223 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2225 /* find a mixer control element with the given name */
2226 static struct snd_kcontrol *
2227 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2229 struct snd_ctl_elem_id id;
2230 memset(&id, 0, sizeof(id));
2231 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2234 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2236 strcpy(id.name, name);
2237 return snd_ctl_find_id(codec->bus->card, &id);
2241 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2242 * @codec: HD-audio codec
2243 * @name: ctl id name string
2245 * Get the control element with the given id string and IFACE_MIXER.
2247 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2250 return find_mixer_ctl(codec, name, 0, 0);
2252 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2254 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2258 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2259 if (!find_mixer_ctl(codec, name, dev, idx))
2266 * snd_hda_ctl_add - Add a control element and assign to the codec
2267 * @codec: HD-audio codec
2268 * @nid: corresponding NID (optional)
2269 * @kctl: the control element to assign
2271 * Add the given control element to an array inside the codec instance.
2272 * All control elements belonging to a codec are supposed to be added
2273 * by this function so that a proper clean-up works at the free or
2274 * reconfiguration time.
2276 * If non-zero @nid is passed, the NID is assigned to the control element.
2277 * The assignment is shown in the codec proc file.
2279 * snd_hda_ctl_add() checks the control subdev id field whether
2280 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2281 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2282 * specifies if kctl->private_value is a HDA amplifier value.
2284 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2285 struct snd_kcontrol *kctl)
2288 unsigned short flags = 0;
2289 struct hda_nid_item *item;
2291 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2292 flags |= HDA_NID_ITEM_AMP;
2294 nid = get_amp_nid_(kctl->private_value);
2296 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2297 nid = kctl->id.subdevice & 0xffff;
2298 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2299 kctl->id.subdevice = 0;
2300 err = snd_ctl_add(codec->bus->card, kctl);
2303 item = snd_array_new(&codec->mixers);
2308 item->flags = flags;
2311 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2314 * snd_hda_add_nid - Assign a NID to a control element
2315 * @codec: HD-audio codec
2316 * @nid: corresponding NID (optional)
2317 * @kctl: the control element to assign
2318 * @index: index to kctl
2320 * Add the given control element to an array inside the codec instance.
2321 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2322 * NID:KCTL mapping - for example "Capture Source" selector.
2324 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2325 unsigned int index, hda_nid_t nid)
2327 struct hda_nid_item *item;
2330 item = snd_array_new(&codec->nids);
2334 item->index = index;
2338 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2339 kctl->id.name, kctl->id.index, index);
2342 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2345 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2346 * @codec: HD-audio codec
2348 void snd_hda_ctls_clear(struct hda_codec *codec)
2351 struct hda_nid_item *items = codec->mixers.list;
2352 for (i = 0; i < codec->mixers.used; i++)
2353 snd_ctl_remove(codec->bus->card, items[i].kctl);
2354 snd_array_free(&codec->mixers);
2355 snd_array_free(&codec->nids);
2358 /* pseudo device locking
2359 * toggle card->shutdown to allow/disallow the device access (as a hack)
2361 int snd_hda_lock_devices(struct hda_bus *bus)
2363 struct snd_card *card = bus->card;
2364 struct hda_codec *codec;
2366 spin_lock(&card->files_lock);
2370 if (!list_empty(&card->ctl_files))
2373 list_for_each_entry(codec, &bus->codec_list, list) {
2375 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2376 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2379 if (cpcm->pcm->streams[0].substream_opened ||
2380 cpcm->pcm->streams[1].substream_opened)
2384 spin_unlock(&card->files_lock);
2390 spin_unlock(&card->files_lock);
2393 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2395 void snd_hda_unlock_devices(struct hda_bus *bus)
2397 struct snd_card *card = bus->card;
2400 spin_lock(&card->files_lock);
2402 spin_unlock(&card->files_lock);
2404 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2407 * snd_hda_codec_reset - Clear all objects assigned to the codec
2408 * @codec: HD-audio codec
2410 * This frees the all PCM and control elements assigned to the codec, and
2411 * clears the caches and restores the pin default configurations.
2413 * When a device is being used, it returns -EBSY. If successfully freed,
2416 int snd_hda_codec_reset(struct hda_codec *codec)
2418 struct hda_bus *bus = codec->bus;
2419 struct snd_card *card = bus->card;
2422 if (snd_hda_lock_devices(bus) < 0)
2425 /* OK, let it free */
2426 cancel_delayed_work_sync(&codec->jackpoll_work);
2428 cancel_delayed_work_sync(&codec->power_work);
2429 codec->power_on = 0;
2430 codec->power_transition = 0;
2431 codec->power_jiffies = jiffies;
2432 flush_workqueue(bus->workq);
2434 snd_hda_ctls_clear(codec);
2436 for (i = 0; i < codec->num_pcms; i++) {
2437 if (codec->pcm_info[i].pcm) {
2438 snd_device_free(card, codec->pcm_info[i].pcm);
2439 clear_bit(codec->pcm_info[i].device,
2443 if (codec->patch_ops.free)
2444 codec->patch_ops.free(codec);
2445 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2446 snd_hda_jack_tbl_clear(codec);
2447 codec->proc_widget_hook = NULL;
2449 free_hda_cache(&codec->amp_cache);
2450 free_hda_cache(&codec->cmd_cache);
2451 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2452 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2453 /* free only driver_pins so that init_pins + user_pins are restored */
2454 snd_array_free(&codec->driver_pins);
2455 snd_array_free(&codec->cvt_setups);
2456 snd_array_free(&codec->spdif_out);
2457 snd_array_free(&codec->verbs);
2458 codec->num_pcms = 0;
2459 codec->pcm_info = NULL;
2460 codec->preset = NULL;
2461 codec->slave_dig_outs = NULL;
2462 codec->spdif_status_reset = 0;
2463 module_put(codec->owner);
2464 codec->owner = NULL;
2466 /* allow device access again */
2467 snd_hda_unlock_devices(bus);
2471 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2473 /* apply the function to all matching slave ctls in the mixer list */
2474 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2475 const char *suffix, map_slave_func_t func, void *data)
2477 struct hda_nid_item *items;
2478 const char * const *s;
2481 items = codec->mixers.list;
2482 for (i = 0; i < codec->mixers.used; i++) {
2483 struct snd_kcontrol *sctl = items[i].kctl;
2484 if (!sctl || !sctl->id.name ||
2485 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2487 for (s = slaves; *s; s++) {
2488 char tmpname[sizeof(sctl->id.name)];
2489 const char *name = *s;
2491 snprintf(tmpname, sizeof(tmpname), "%s %s",
2495 if (!strcmp(sctl->id.name, name)) {
2496 err = func(data, sctl);
2506 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2511 /* guess the value corresponding to 0dB */
2512 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2515 const int *tlv = NULL;
2518 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2519 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2520 mm_segment_t fs = get_fs();
2522 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2525 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2527 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2528 val = -tlv[2] / tlv[3];
2532 /* call kctl->put with the given value(s) */
2533 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2535 struct snd_ctl_elem_value *ucontrol;
2536 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2539 ucontrol->value.integer.value[0] = val;
2540 ucontrol->value.integer.value[1] = val;
2541 kctl->put(kctl, ucontrol);
2546 /* initialize the slave volume with 0dB */
2547 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2549 int offset = get_kctl_0dB_offset(slave);
2551 put_kctl_with_value(slave, offset);
2555 /* unmute the slave */
2556 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2558 return put_kctl_with_value(slave, 1);
2562 * snd_hda_add_vmaster - create a virtual master control and add slaves
2563 * @codec: HD-audio codec
2564 * @name: vmaster control name
2565 * @tlv: TLV data (optional)
2566 * @slaves: slave control names (optional)
2567 * @suffix: suffix string to each slave name (optional)
2568 * @init_slave_vol: initialize slaves to unmute/0dB
2569 * @ctl_ret: store the vmaster kcontrol in return
2571 * Create a virtual master control with the given name. The TLV data
2572 * must be either NULL or a valid data.
2574 * @slaves is a NULL-terminated array of strings, each of which is a
2575 * slave control name. All controls with these names are assigned to
2576 * the new virtual master control.
2578 * This function returns zero if successful or a negative error code.
2580 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2581 unsigned int *tlv, const char * const *slaves,
2582 const char *suffix, bool init_slave_vol,
2583 struct snd_kcontrol **ctl_ret)
2585 struct snd_kcontrol *kctl;
2591 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2593 snd_printdd("No slave found for %s\n", name);
2596 kctl = snd_ctl_make_virtual_master(name, tlv);
2599 err = snd_hda_ctl_add(codec, 0, kctl);
2603 err = map_slaves(codec, slaves, suffix,
2604 (map_slave_func_t)snd_ctl_add_slave, kctl);
2608 /* init with master mute & zero volume */
2609 put_kctl_with_value(kctl, 0);
2611 map_slaves(codec, slaves, suffix,
2612 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2618 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2621 * mute-LED control using vmaster
2623 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2624 struct snd_ctl_elem_info *uinfo)
2626 static const char * const texts[] = {
2627 "On", "Off", "Follow Master"
2631 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2633 uinfo->value.enumerated.items = 3;
2634 index = uinfo->value.enumerated.item;
2637 strcpy(uinfo->value.enumerated.name, texts[index]);
2641 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2642 struct snd_ctl_elem_value *ucontrol)
2644 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2645 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2649 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2650 struct snd_ctl_elem_value *ucontrol)
2652 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2653 unsigned int old_mode = hook->mute_mode;
2655 hook->mute_mode = ucontrol->value.enumerated.item[0];
2656 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2657 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2658 if (old_mode == hook->mute_mode)
2660 snd_hda_sync_vmaster_hook(hook);
2664 static struct snd_kcontrol_new vmaster_mute_mode = {
2665 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2666 .name = "Mute-LED Mode",
2667 .info = vmaster_mute_mode_info,
2668 .get = vmaster_mute_mode_get,
2669 .put = vmaster_mute_mode_put,
2673 * Add a mute-LED hook with the given vmaster switch kctl
2674 * "Mute-LED Mode" control is automatically created and associated with
2677 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2678 struct hda_vmaster_mute_hook *hook,
2679 bool expose_enum_ctl)
2681 struct snd_kcontrol *kctl;
2683 if (!hook->hook || !hook->sw_kctl)
2685 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2686 hook->codec = codec;
2687 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2688 if (!expose_enum_ctl)
2690 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2693 return snd_hda_ctl_add(codec, 0, kctl);
2695 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2698 * Call the hook with the current value for synchronization
2699 * Should be called in init callback
2701 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2703 if (!hook->hook || !hook->codec)
2705 switch (hook->mute_mode) {
2706 case HDA_VMUTE_FOLLOW_MASTER:
2707 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2710 hook->hook(hook->codec, hook->mute_mode);
2714 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2718 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2720 * The control element is supposed to have the private_value field
2721 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2723 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2724 struct snd_ctl_elem_info *uinfo)
2726 int chs = get_amp_channels(kcontrol);
2728 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2729 uinfo->count = chs == 3 ? 2 : 1;
2730 uinfo->value.integer.min = 0;
2731 uinfo->value.integer.max = 1;
2734 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2737 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2739 * The control element is supposed to have the private_value field
2740 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2742 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2743 struct snd_ctl_elem_value *ucontrol)
2745 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2746 hda_nid_t nid = get_amp_nid(kcontrol);
2747 int chs = get_amp_channels(kcontrol);
2748 int dir = get_amp_direction(kcontrol);
2749 int idx = get_amp_index(kcontrol);
2750 long *valp = ucontrol->value.integer.value;
2753 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2754 HDA_AMP_MUTE) ? 0 : 1;
2756 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2757 HDA_AMP_MUTE) ? 0 : 1;
2760 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2763 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2765 * The control element is supposed to have the private_value field
2766 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2768 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2769 struct snd_ctl_elem_value *ucontrol)
2771 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2772 hda_nid_t nid = get_amp_nid(kcontrol);
2773 int chs = get_amp_channels(kcontrol);
2774 int dir = get_amp_direction(kcontrol);
2775 int idx = get_amp_index(kcontrol);
2776 long *valp = ucontrol->value.integer.value;
2779 snd_hda_power_up(codec);
2781 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2783 *valp ? 0 : HDA_AMP_MUTE);
2787 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2789 *valp ? 0 : HDA_AMP_MUTE);
2790 hda_call_check_power_status(codec, nid);
2791 snd_hda_power_down(codec);
2794 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2797 * bound volume controls
2799 * bind multiple volumes (# indices, from 0)
2802 #define AMP_VAL_IDX_SHIFT 19
2803 #define AMP_VAL_IDX_MASK (0x0f<<19)
2806 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2808 * The control element is supposed to have the private_value field
2809 * set up via HDA_BIND_MUTE*() macros.
2811 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2812 struct snd_ctl_elem_value *ucontrol)
2814 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2818 mutex_lock(&codec->control_mutex);
2819 pval = kcontrol->private_value;
2820 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2821 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2822 kcontrol->private_value = pval;
2823 mutex_unlock(&codec->control_mutex);
2826 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2829 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2831 * The control element is supposed to have the private_value field
2832 * set up via HDA_BIND_MUTE*() macros.
2834 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2835 struct snd_ctl_elem_value *ucontrol)
2837 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2839 int i, indices, err = 0, change = 0;
2841 mutex_lock(&codec->control_mutex);
2842 pval = kcontrol->private_value;
2843 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2844 for (i = 0; i < indices; i++) {
2845 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2846 (i << AMP_VAL_IDX_SHIFT);
2847 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2852 kcontrol->private_value = pval;
2853 mutex_unlock(&codec->control_mutex);
2854 return err < 0 ? err : change;
2856 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2859 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2861 * The control element is supposed to have the private_value field
2862 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2864 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2865 struct snd_ctl_elem_info *uinfo)
2867 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2868 struct hda_bind_ctls *c;
2871 mutex_lock(&codec->control_mutex);
2872 c = (struct hda_bind_ctls *)kcontrol->private_value;
2873 kcontrol->private_value = *c->values;
2874 err = c->ops->info(kcontrol, uinfo);
2875 kcontrol->private_value = (long)c;
2876 mutex_unlock(&codec->control_mutex);
2879 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2882 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2884 * The control element is supposed to have the private_value field
2885 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2887 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2888 struct snd_ctl_elem_value *ucontrol)
2890 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2891 struct hda_bind_ctls *c;
2894 mutex_lock(&codec->control_mutex);
2895 c = (struct hda_bind_ctls *)kcontrol->private_value;
2896 kcontrol->private_value = *c->values;
2897 err = c->ops->get(kcontrol, ucontrol);
2898 kcontrol->private_value = (long)c;
2899 mutex_unlock(&codec->control_mutex);
2902 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2905 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2907 * The control element is supposed to have the private_value field
2908 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2910 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2911 struct snd_ctl_elem_value *ucontrol)
2913 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2914 struct hda_bind_ctls *c;
2915 unsigned long *vals;
2916 int err = 0, change = 0;
2918 mutex_lock(&codec->control_mutex);
2919 c = (struct hda_bind_ctls *)kcontrol->private_value;
2920 for (vals = c->values; *vals; vals++) {
2921 kcontrol->private_value = *vals;
2922 err = c->ops->put(kcontrol, ucontrol);
2927 kcontrol->private_value = (long)c;
2928 mutex_unlock(&codec->control_mutex);
2929 return err < 0 ? err : change;
2931 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2934 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2936 * The control element is supposed to have the private_value field
2937 * set up via HDA_BIND_VOL() macro.
2939 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2940 unsigned int size, unsigned int __user *tlv)
2942 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2943 struct hda_bind_ctls *c;
2946 mutex_lock(&codec->control_mutex);
2947 c = (struct hda_bind_ctls *)kcontrol->private_value;
2948 kcontrol->private_value = *c->values;
2949 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2950 kcontrol->private_value = (long)c;
2951 mutex_unlock(&codec->control_mutex);
2954 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2956 struct hda_ctl_ops snd_hda_bind_vol = {
2957 .info = snd_hda_mixer_amp_volume_info,
2958 .get = snd_hda_mixer_amp_volume_get,
2959 .put = snd_hda_mixer_amp_volume_put,
2960 .tlv = snd_hda_mixer_amp_tlv
2962 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2964 struct hda_ctl_ops snd_hda_bind_sw = {
2965 .info = snd_hda_mixer_amp_switch_info,
2966 .get = snd_hda_mixer_amp_switch_get,
2967 .put = snd_hda_mixer_amp_switch_put,
2968 .tlv = snd_hda_mixer_amp_tlv
2970 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2973 * SPDIF out controls
2976 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2977 struct snd_ctl_elem_info *uinfo)
2979 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2984 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2985 struct snd_ctl_elem_value *ucontrol)
2987 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2988 IEC958_AES0_NONAUDIO |
2989 IEC958_AES0_CON_EMPHASIS_5015 |
2990 IEC958_AES0_CON_NOT_COPYRIGHT;
2991 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2992 IEC958_AES1_CON_ORIGINAL;
2996 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2997 struct snd_ctl_elem_value *ucontrol)
2999 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3000 IEC958_AES0_NONAUDIO |
3001 IEC958_AES0_PRO_EMPHASIS_5015;
3005 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3006 struct snd_ctl_elem_value *ucontrol)
3008 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3009 int idx = kcontrol->private_value;
3010 struct hda_spdif_out *spdif;
3012 mutex_lock(&codec->spdif_mutex);
3013 spdif = snd_array_elem(&codec->spdif_out, idx);
3014 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3015 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3016 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3017 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3018 mutex_unlock(&codec->spdif_mutex);
3023 /* convert from SPDIF status bits to HDA SPDIF bits
3024 * bit 0 (DigEn) is always set zero (to be filled later)
3026 static unsigned short convert_from_spdif_status(unsigned int sbits)
3028 unsigned short val = 0;
3030 if (sbits & IEC958_AES0_PROFESSIONAL)
3031 val |= AC_DIG1_PROFESSIONAL;
3032 if (sbits & IEC958_AES0_NONAUDIO)
3033 val |= AC_DIG1_NONAUDIO;
3034 if (sbits & IEC958_AES0_PROFESSIONAL) {
3035 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3036 IEC958_AES0_PRO_EMPHASIS_5015)
3037 val |= AC_DIG1_EMPHASIS;
3039 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3040 IEC958_AES0_CON_EMPHASIS_5015)
3041 val |= AC_DIG1_EMPHASIS;
3042 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3043 val |= AC_DIG1_COPYRIGHT;
3044 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3045 val |= AC_DIG1_LEVEL;
3046 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3051 /* convert to SPDIF status bits from HDA SPDIF bits
3053 static unsigned int convert_to_spdif_status(unsigned short val)
3055 unsigned int sbits = 0;
3057 if (val & AC_DIG1_NONAUDIO)
3058 sbits |= IEC958_AES0_NONAUDIO;
3059 if (val & AC_DIG1_PROFESSIONAL)
3060 sbits |= IEC958_AES0_PROFESSIONAL;
3061 if (sbits & IEC958_AES0_PROFESSIONAL) {
3062 if (sbits & AC_DIG1_EMPHASIS)
3063 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3065 if (val & AC_DIG1_EMPHASIS)
3066 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3067 if (!(val & AC_DIG1_COPYRIGHT))
3068 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3069 if (val & AC_DIG1_LEVEL)
3070 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3071 sbits |= val & (0x7f << 8);
3076 /* set digital convert verbs both for the given NID and its slaves */
3077 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3082 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3083 d = codec->slave_dig_outs;
3087 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3090 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3094 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3096 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3099 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3100 struct snd_ctl_elem_value *ucontrol)
3102 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3103 int idx = kcontrol->private_value;
3104 struct hda_spdif_out *spdif;
3109 mutex_lock(&codec->spdif_mutex);
3110 spdif = snd_array_elem(&codec->spdif_out, idx);
3112 spdif->status = ucontrol->value.iec958.status[0] |
3113 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3114 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3115 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3116 val = convert_from_spdif_status(spdif->status);
3117 val |= spdif->ctls & 1;
3118 change = spdif->ctls != val;
3120 if (change && nid != (u16)-1)
3121 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3122 mutex_unlock(&codec->spdif_mutex);
3126 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3128 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3129 struct snd_ctl_elem_value *ucontrol)
3131 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3132 int idx = kcontrol->private_value;
3133 struct hda_spdif_out *spdif;
3135 mutex_lock(&codec->spdif_mutex);
3136 spdif = snd_array_elem(&codec->spdif_out, idx);
3137 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3138 mutex_unlock(&codec->spdif_mutex);
3142 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3145 set_dig_out_convert(codec, nid, dig1, dig2);
3146 /* unmute amp switch (if any) */
3147 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3148 (dig1 & AC_DIG1_ENABLE))
3149 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3153 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3154 struct snd_ctl_elem_value *ucontrol)
3156 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3157 int idx = kcontrol->private_value;
3158 struct hda_spdif_out *spdif;
3163 mutex_lock(&codec->spdif_mutex);
3164 spdif = snd_array_elem(&codec->spdif_out, idx);
3166 val = spdif->ctls & ~AC_DIG1_ENABLE;
3167 if (ucontrol->value.integer.value[0])
3168 val |= AC_DIG1_ENABLE;
3169 change = spdif->ctls != val;
3171 if (change && nid != (u16)-1)
3172 set_spdif_ctls(codec, nid, val & 0xff, -1);
3173 mutex_unlock(&codec->spdif_mutex);
3177 static struct snd_kcontrol_new dig_mixes[] = {
3179 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3180 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3181 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3182 .info = snd_hda_spdif_mask_info,
3183 .get = snd_hda_spdif_cmask_get,
3186 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3187 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3188 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3189 .info = snd_hda_spdif_mask_info,
3190 .get = snd_hda_spdif_pmask_get,
3193 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3194 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3195 .info = snd_hda_spdif_mask_info,
3196 .get = snd_hda_spdif_default_get,
3197 .put = snd_hda_spdif_default_put,
3200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3201 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3202 .info = snd_hda_spdif_out_switch_info,
3203 .get = snd_hda_spdif_out_switch_get,
3204 .put = snd_hda_spdif_out_switch_put,
3210 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3211 * @codec: the HDA codec
3212 * @associated_nid: NID that new ctls associated with
3213 * @cvt_nid: converter NID
3214 * @type: HDA_PCM_TYPE_*
3215 * Creates controls related with the digital output.
3216 * Called from each patch supporting the digital out.
3218 * Returns 0 if successful, or a negative error code.
3220 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3221 hda_nid_t associated_nid,
3226 struct snd_kcontrol *kctl;
3227 struct snd_kcontrol_new *dig_mix;
3229 const int spdif_pcm_dev = 1;
3230 struct hda_spdif_out *spdif;
3232 if (codec->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3233 type == HDA_PCM_TYPE_SPDIF) {
3234 dev = spdif_pcm_dev;
3235 } else if (codec->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3236 type == HDA_PCM_TYPE_HDMI) {
3237 for (idx = 0; idx < codec->spdif_out.used; idx++) {
3238 spdif = snd_array_elem(&codec->spdif_out, idx);
3239 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3240 kctl = find_mixer_ctl(codec, dig_mix->name, 0, idx);
3243 kctl->id.device = spdif_pcm_dev;
3246 codec->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3248 if (!codec->primary_dig_out_type)
3249 codec->primary_dig_out_type = type;
3251 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", dev);
3253 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3256 spdif = snd_array_new(&codec->spdif_out);
3257 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3258 kctl = snd_ctl_new1(dig_mix, codec);
3261 kctl->id.device = dev;
3262 kctl->id.index = idx;
3263 kctl->private_value = codec->spdif_out.used - 1;
3264 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3268 spdif->nid = cvt_nid;
3269 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3270 AC_VERB_GET_DIGI_CONVERT_1, 0);
3271 spdif->status = convert_to_spdif_status(spdif->ctls);
3274 EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
3276 /* get the hda_spdif_out entry from the given NID
3277 * call within spdif_mutex lock
3279 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3283 for (i = 0; i < codec->spdif_out.used; i++) {
3284 struct hda_spdif_out *spdif =
3285 snd_array_elem(&codec->spdif_out, i);
3286 if (spdif->nid == nid)
3291 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3293 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3295 struct hda_spdif_out *spdif;
3297 mutex_lock(&codec->spdif_mutex);
3298 spdif = snd_array_elem(&codec->spdif_out, idx);
3299 spdif->nid = (u16)-1;
3300 mutex_unlock(&codec->spdif_mutex);
3302 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3304 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3306 struct hda_spdif_out *spdif;
3309 mutex_lock(&codec->spdif_mutex);
3310 spdif = snd_array_elem(&codec->spdif_out, idx);
3311 if (spdif->nid != nid) {
3314 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3316 mutex_unlock(&codec->spdif_mutex);
3318 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3321 * SPDIF sharing with analog output
3323 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3324 struct snd_ctl_elem_value *ucontrol)
3326 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3327 ucontrol->value.integer.value[0] = mout->share_spdif;
3331 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3332 struct snd_ctl_elem_value *ucontrol)
3334 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3335 mout->share_spdif = !!ucontrol->value.integer.value[0];
3339 static struct snd_kcontrol_new spdif_share_sw = {
3340 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3341 .name = "IEC958 Default PCM Playback Switch",
3342 .info = snd_ctl_boolean_mono_info,
3343 .get = spdif_share_sw_get,
3344 .put = spdif_share_sw_put,
3348 * snd_hda_create_spdif_share_sw - create Default PCM switch
3349 * @codec: the HDA codec
3350 * @mout: multi-out instance
3352 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3353 struct hda_multi_out *mout)
3355 if (!mout->dig_out_nid)
3357 /* ATTENTION: here mout is passed as private_data, instead of codec */
3358 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3359 snd_ctl_new1(&spdif_share_sw, mout));
3361 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3367 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3369 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3370 struct snd_ctl_elem_value *ucontrol)
3372 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3374 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3378 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3379 struct snd_ctl_elem_value *ucontrol)
3381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3382 hda_nid_t nid = kcontrol->private_value;
3383 unsigned int val = !!ucontrol->value.integer.value[0];
3386 mutex_lock(&codec->spdif_mutex);
3387 change = codec->spdif_in_enable != val;
3389 codec->spdif_in_enable = val;
3390 snd_hda_codec_write_cache(codec, nid, 0,
3391 AC_VERB_SET_DIGI_CONVERT_1, val);
3393 mutex_unlock(&codec->spdif_mutex);
3397 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3398 struct snd_ctl_elem_value *ucontrol)
3400 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3401 hda_nid_t nid = kcontrol->private_value;
3405 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3406 sbits = convert_to_spdif_status(val);
3407 ucontrol->value.iec958.status[0] = sbits;
3408 ucontrol->value.iec958.status[1] = sbits >> 8;
3409 ucontrol->value.iec958.status[2] = sbits >> 16;
3410 ucontrol->value.iec958.status[3] = sbits >> 24;
3414 static struct snd_kcontrol_new dig_in_ctls[] = {
3416 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3417 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3418 .info = snd_hda_spdif_in_switch_info,
3419 .get = snd_hda_spdif_in_switch_get,
3420 .put = snd_hda_spdif_in_switch_put,
3423 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3424 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3425 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3426 .info = snd_hda_spdif_mask_info,
3427 .get = snd_hda_spdif_in_status_get,
3433 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3434 * @codec: the HDA codec
3435 * @nid: audio in widget NID
3437 * Creates controls related with the SPDIF input.
3438 * Called from each patch supporting the SPDIF in.
3440 * Returns 0 if successful, or a negative error code.
3442 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3445 struct snd_kcontrol *kctl;
3446 struct snd_kcontrol_new *dig_mix;
3449 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3451 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3454 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3455 kctl = snd_ctl_new1(dig_mix, codec);
3458 kctl->private_value = nid;
3459 err = snd_hda_ctl_add(codec, nid, kctl);
3463 codec->spdif_in_enable =
3464 snd_hda_codec_read(codec, nid, 0,
3465 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3469 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3475 /* build a 31bit cache key with the widget id and the command parameter */
3476 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3477 #define get_cmd_cache_nid(key) ((key) & 0xff)
3478 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3481 * snd_hda_codec_write_cache - send a single command with caching
3482 * @codec: the HDA codec
3483 * @nid: NID to send the command
3484 * @direct: direct flag
3485 * @verb: the verb to send
3486 * @parm: the parameter for the verb
3488 * Send a single command without waiting for response.
3490 * Returns 0 if successful, or a negative error code.
3492 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3493 int direct, unsigned int verb, unsigned int parm)
3496 struct hda_cache_head *c;
3498 unsigned int cache_only;
3500 cache_only = codec->cached_write;
3502 err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3507 /* parm may contain the verb stuff for get/set amp */
3508 verb = verb | (parm >> 8);
3510 key = build_cmd_cache_key(nid, verb);
3511 mutex_lock(&codec->bus->cmd_mutex);
3512 c = get_alloc_hash(&codec->cmd_cache, key);
3515 c->dirty = cache_only;
3517 mutex_unlock(&codec->bus->cmd_mutex);
3520 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3523 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3524 * @codec: the HDA codec
3525 * @nid: NID to send the command
3526 * @direct: direct flag
3527 * @verb: the verb to send
3528 * @parm: the parameter for the verb
3530 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3531 * command if the parameter is already identical with the cached value.
3532 * If not, it sends the command and refreshes the cache.
3534 * Returns 0 if successful, or a negative error code.
3536 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3537 int direct, unsigned int verb, unsigned int parm)
3539 struct hda_cache_head *c;
3542 /* parm may contain the verb stuff for get/set amp */
3543 verb = verb | (parm >> 8);
3545 key = build_cmd_cache_key(nid, verb);
3546 mutex_lock(&codec->bus->cmd_mutex);
3547 c = get_hash(&codec->cmd_cache, key);
3548 if (c && c->val == parm) {
3549 mutex_unlock(&codec->bus->cmd_mutex);
3552 mutex_unlock(&codec->bus->cmd_mutex);
3553 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3555 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3558 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3559 * @codec: HD-audio codec
3561 * Execute all verbs recorded in the command caches to resume.
3563 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3567 mutex_lock(&codec->hash_mutex);
3568 codec->cached_write = 0;
3569 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3570 struct hda_cache_head *buffer;
3573 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3580 mutex_unlock(&codec->hash_mutex);
3581 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3582 get_cmd_cache_cmd(key), buffer->val);
3583 mutex_lock(&codec->hash_mutex);
3585 mutex_unlock(&codec->hash_mutex);
3587 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3590 * snd_hda_sequence_write_cache - sequence writes with caching
3591 * @codec: the HDA codec
3592 * @seq: VERB array to send
3594 * Send the commands sequentially from the given array.
3595 * Thte commands are recorded on cache for power-save and resume.
3596 * The array must be terminated with NID=0.
3598 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3599 const struct hda_verb *seq)
3601 for (; seq->nid; seq++)
3602 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3605 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3607 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3608 unsigned int power_state,
3609 bool eapd_workaround)
3611 hda_nid_t nid = codec->start_nid;
3614 for (i = 0; i < codec->num_nodes; i++, nid++) {
3615 unsigned int wcaps = get_wcaps(codec, nid);
3616 if (!(wcaps & AC_WCAP_POWER))
3618 /* don't power down the widget if it controls eapd and
3619 * EAPD_BTLENABLE is set.
3621 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3622 get_wcaps_type(wcaps) == AC_WID_PIN &&
3623 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3624 int eapd = snd_hda_codec_read(codec, nid, 0,
3625 AC_VERB_GET_EAPD_BTLENABLE, 0);
3629 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3633 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3636 * supported power states check
3638 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3639 unsigned int power_state)
3641 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3645 if (sup & power_state)
3652 * wait until the state is reached, returns the current state
3654 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3656 unsigned int power_state)
3658 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3659 unsigned int state, actual_state;
3662 state = snd_hda_codec_read(codec, fg, 0,
3663 AC_VERB_GET_POWER_STATE, 0);
3664 if (state & AC_PWRST_ERROR)
3666 actual_state = (state >> 4) & 0x0f;
3667 if (actual_state == power_state)
3669 if (time_after_eq(jiffies, end_time))
3671 /* wait until the codec reachs to the target state */
3678 * set power state of the codec, and return the power state
3680 static unsigned int hda_set_power_state(struct hda_codec *codec,
3681 unsigned int power_state)
3683 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3687 /* this delay seems necessary to avoid click noise at power-down */
3688 if (power_state == AC_PWRST_D3) {
3689 /* transition time less than 10ms for power down */
3690 msleep(codec->epss ? 10 : 100);
3693 /* repeat power states setting at most 10 times*/
3694 for (count = 0; count < 10; count++) {
3695 if (codec->patch_ops.set_power_state)
3696 codec->patch_ops.set_power_state(codec, fg,
3699 snd_hda_codec_read(codec, fg, 0,
3700 AC_VERB_SET_POWER_STATE,
3702 snd_hda_codec_set_power_to_all(codec, fg, power_state,
3705 state = hda_sync_power_state(codec, fg, power_state);
3706 if (!(state & AC_PWRST_ERROR))
3713 #ifdef CONFIG_SND_HDA_HWDEP
3714 /* execute additional init verbs */
3715 static void hda_exec_init_verbs(struct hda_codec *codec)
3717 if (codec->init_verbs.list)
3718 snd_hda_sequence_write(codec, codec->init_verbs.list);
3721 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3726 * call suspend and power-down; used both from PM and power-save
3727 * this function returns the power state in the end
3729 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
3735 if (codec->patch_ops.suspend)
3736 codec->patch_ops.suspend(codec);
3737 hda_cleanup_all_streams(codec);
3738 state = hda_set_power_state(codec, AC_PWRST_D3);
3739 /* Cancel delayed work if we aren't currently running from it. */
3741 cancel_delayed_work_sync(&codec->power_work);
3742 spin_lock(&codec->power_lock);
3743 snd_hda_update_power_acct(codec);
3744 trace_hda_power_down(codec);
3745 codec->power_on = 0;
3746 codec->power_transition = 0;
3747 codec->power_jiffies = jiffies;
3748 spin_unlock(&codec->power_lock);
3753 /* mark all entries of cmd and amp caches dirty */
3754 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3757 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3758 struct hda_cache_head *cmd;
3759 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3762 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3763 struct hda_amp_info *amp;
3764 amp = snd_array_elem(&codec->cmd_cache.buf, i);
3765 amp->head.dirty = 1;
3770 * kick up codec; used both from PM and power-save
3772 static void hda_call_codec_resume(struct hda_codec *codec)
3776 hda_mark_cmd_cache_dirty(codec);
3778 /* set as if powered on for avoiding re-entering the resume
3779 * in the resume / power-save sequence
3781 hda_keep_power_on(codec);
3782 hda_set_power_state(codec, AC_PWRST_D0);
3783 restore_shutup_pins(codec);
3784 hda_exec_init_verbs(codec);
3785 if (codec->patch_ops.resume)
3786 codec->patch_ops.resume(codec);
3788 if (codec->patch_ops.init)
3789 codec->patch_ops.init(codec);
3790 snd_hda_codec_resume_amp(codec);
3791 snd_hda_codec_resume_cache(codec);
3794 if (codec->jackpoll_interval)
3795 hda_jackpoll_work(&codec->jackpoll_work.work);
3797 snd_hda_jack_set_dirty_all(codec);
3798 snd_hda_jack_report_sync(codec);
3802 snd_hda_power_down(codec); /* flag down before returning */
3804 #endif /* CONFIG_PM */
3808 * snd_hda_build_controls - build mixer controls
3811 * Creates mixer controls for each codec included in the bus.
3813 * Returns 0 if successful, otherwise a negative error code.
3815 int snd_hda_build_controls(struct hda_bus *bus)
3817 struct hda_codec *codec;
3819 list_for_each_entry(codec, &bus->codec_list, list) {
3820 int err = snd_hda_codec_build_controls(codec);
3822 printk(KERN_ERR "hda_codec: cannot build controls "
3823 "for #%d (error %d)\n", codec->addr, err);
3824 err = snd_hda_codec_reset(codec);
3827 "hda_codec: cannot revert codec\n");
3834 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3837 * add standard channel maps if not specified
3839 static int add_std_chmaps(struct hda_codec *codec)
3843 for (i = 0; i < codec->num_pcms; i++) {
3844 for (str = 0; str < 2; str++) {
3845 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
3846 struct hda_pcm_stream *hinfo =
3847 &codec->pcm_info[i].stream[str];
3848 struct snd_pcm_chmap *chmap;
3849 const struct snd_pcm_chmap_elem *elem;
3851 if (codec->pcm_info[i].own_chmap)
3853 if (!pcm || !hinfo->substreams)
3855 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3856 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
3857 hinfo->channels_max,
3861 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
3867 /* default channel maps for 2.1 speakers;
3868 * since HD-audio supports only stereo, odd number channels are omitted
3870 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
3872 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
3874 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
3875 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
3878 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
3880 int snd_hda_codec_build_controls(struct hda_codec *codec)
3883 hda_exec_init_verbs(codec);
3884 /* continue to initialize... */
3885 if (codec->patch_ops.init)
3886 err = codec->patch_ops.init(codec);
3887 if (!err && codec->patch_ops.build_controls)
3888 err = codec->patch_ops.build_controls(codec);
3892 /* we create chmaps here instead of build_pcms */
3893 err = add_std_chmaps(codec);
3897 if (codec->jackpoll_interval)
3898 hda_jackpoll_work(&codec->jackpoll_work.work);
3900 snd_hda_jack_report_sync(codec); /* call at the last init point */
3907 struct hda_rate_tbl {
3909 unsigned int alsa_bits;
3910 unsigned int hda_fmt;
3913 /* rate = base * mult / div */
3914 #define HDA_RATE(base, mult, div) \
3915 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3916 (((div) - 1) << AC_FMT_DIV_SHIFT))
3918 static struct hda_rate_tbl rate_bits[] = {
3919 /* rate in Hz, ALSA rate bitmask, HDA format value */
3921 /* autodetected value used in snd_hda_query_supported_pcm */
3922 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3923 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3924 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3925 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3926 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3927 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3928 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3929 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3930 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3931 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3932 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3933 #define AC_PAR_PCM_RATE_BITS 11
3934 /* up to bits 10, 384kHZ isn't supported properly */
3936 /* not autodetected value */
3937 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3939 { 0 } /* terminator */
3943 * snd_hda_calc_stream_format - calculate format bitset
3944 * @rate: the sample rate
3945 * @channels: the number of channels
3946 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3947 * @maxbps: the max. bps
3949 * Calculate the format bitset from the given rate, channels and th PCM format.
3951 * Return zero if invalid.
3953 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3954 unsigned int channels,
3955 unsigned int format,
3956 unsigned int maxbps,
3957 unsigned short spdif_ctls)
3960 unsigned int val = 0;
3962 for (i = 0; rate_bits[i].hz; i++)
3963 if (rate_bits[i].hz == rate) {
3964 val = rate_bits[i].hda_fmt;
3967 if (!rate_bits[i].hz) {
3968 snd_printdd("invalid rate %d\n", rate);
3972 if (channels == 0 || channels > 8) {
3973 snd_printdd("invalid channels %d\n", channels);
3976 val |= channels - 1;
3978 switch (snd_pcm_format_width(format)) {
3980 val |= AC_FMT_BITS_8;
3983 val |= AC_FMT_BITS_16;
3988 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3989 val |= AC_FMT_BITS_32;
3990 else if (maxbps >= 24)
3991 val |= AC_FMT_BITS_24;
3993 val |= AC_FMT_BITS_20;
3996 snd_printdd("invalid format width %d\n",
3997 snd_pcm_format_width(format));
4001 if (spdif_ctls & AC_DIG1_NONAUDIO)
4002 val |= AC_FMT_TYPE_NON_PCM;
4006 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
4008 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4011 unsigned int val = 0;
4012 if (nid != codec->afg &&
4013 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4014 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4015 if (!val || val == -1)
4016 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4017 if (!val || val == -1)
4022 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4024 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4028 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4031 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4032 if (!streams || streams == -1)
4033 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4034 if (!streams || streams == -1)
4039 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4041 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4046 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4047 * @codec: the HDA codec
4048 * @nid: NID to query
4049 * @ratesp: the pointer to store the detected rate bitflags
4050 * @formatsp: the pointer to store the detected formats
4051 * @bpsp: the pointer to store the detected format widths
4053 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4054 * or @bsps argument is ignored.
4056 * Returns 0 if successful, otherwise a negative error code.
4058 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4059 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4061 unsigned int i, val, wcaps;
4063 wcaps = get_wcaps(codec, nid);
4064 val = query_pcm_param(codec, nid);
4068 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4070 rates |= rate_bits[i].alsa_bits;
4073 snd_printk(KERN_ERR "hda_codec: rates == 0 "
4074 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4076 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4082 if (formatsp || bpsp) {
4084 unsigned int streams, bps;
4086 streams = query_stream_param(codec, nid);
4091 if (streams & AC_SUPFMT_PCM) {
4092 if (val & AC_SUPPCM_BITS_8) {
4093 formats |= SNDRV_PCM_FMTBIT_U8;
4096 if (val & AC_SUPPCM_BITS_16) {
4097 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4100 if (wcaps & AC_WCAP_DIGITAL) {
4101 if (val & AC_SUPPCM_BITS_32)
4102 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4103 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4104 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4105 if (val & AC_SUPPCM_BITS_24)
4107 else if (val & AC_SUPPCM_BITS_20)
4109 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4110 AC_SUPPCM_BITS_32)) {
4111 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4112 if (val & AC_SUPPCM_BITS_32)
4114 else if (val & AC_SUPPCM_BITS_24)
4116 else if (val & AC_SUPPCM_BITS_20)
4120 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4121 if (streams & AC_SUPFMT_FLOAT32) {
4122 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4127 if (streams == AC_SUPFMT_AC3) {
4128 /* should be exclusive */
4129 /* temporary hack: we have still no proper support
4130 * for the direct AC3 stream...
4132 formats |= SNDRV_PCM_FMTBIT_U8;
4136 snd_printk(KERN_ERR "hda_codec: formats == 0 "
4137 "(nid=0x%x, val=0x%x, ovrd=%i, "
4140 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4145 *formatsp = formats;
4152 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
4155 * snd_hda_is_supported_format - Check the validity of the format
4156 * @codec: HD-audio codec
4157 * @nid: NID to check
4158 * @format: the HD-audio format value to check
4160 * Check whether the given node supports the format value.
4162 * Returns 1 if supported, 0 if not.
4164 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4165 unsigned int format)
4168 unsigned int val = 0, rate, stream;
4170 val = query_pcm_param(codec, nid);
4174 rate = format & 0xff00;
4175 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4176 if (rate_bits[i].hda_fmt == rate) {
4181 if (i >= AC_PAR_PCM_RATE_BITS)
4184 stream = query_stream_param(codec, nid);
4188 if (stream & AC_SUPFMT_PCM) {
4189 switch (format & 0xf0) {
4191 if (!(val & AC_SUPPCM_BITS_8))
4195 if (!(val & AC_SUPPCM_BITS_16))
4199 if (!(val & AC_SUPPCM_BITS_20))
4203 if (!(val & AC_SUPPCM_BITS_24))
4207 if (!(val & AC_SUPPCM_BITS_32))
4214 /* FIXME: check for float32 and AC3? */
4219 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
4224 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4225 struct hda_codec *codec,
4226 struct snd_pcm_substream *substream)
4231 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4232 struct hda_codec *codec,
4233 unsigned int stream_tag,
4234 unsigned int format,
4235 struct snd_pcm_substream *substream)
4237 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4241 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4242 struct hda_codec *codec,
4243 struct snd_pcm_substream *substream)
4245 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4249 static int set_pcm_default_values(struct hda_codec *codec,
4250 struct hda_pcm_stream *info)
4254 /* query support PCM information from the given NID */
4255 if (info->nid && (!info->rates || !info->formats)) {
4256 err = snd_hda_query_supported_pcm(codec, info->nid,
4257 info->rates ? NULL : &info->rates,
4258 info->formats ? NULL : &info->formats,
4259 info->maxbps ? NULL : &info->maxbps);
4263 if (info->ops.open == NULL)
4264 info->ops.open = hda_pcm_default_open_close;
4265 if (info->ops.close == NULL)
4266 info->ops.close = hda_pcm_default_open_close;
4267 if (info->ops.prepare == NULL) {
4268 if (snd_BUG_ON(!info->nid))
4270 info->ops.prepare = hda_pcm_default_prepare;
4272 if (info->ops.cleanup == NULL) {
4273 if (snd_BUG_ON(!info->nid))
4275 info->ops.cleanup = hda_pcm_default_cleanup;
4281 * codec prepare/cleanup entries
4283 int snd_hda_codec_prepare(struct hda_codec *codec,
4284 struct hda_pcm_stream *hinfo,
4285 unsigned int stream,
4286 unsigned int format,
4287 struct snd_pcm_substream *substream)
4290 mutex_lock(&codec->bus->prepare_mutex);
4291 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4293 purify_inactive_streams(codec);
4294 mutex_unlock(&codec->bus->prepare_mutex);
4297 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4299 void snd_hda_codec_cleanup(struct hda_codec *codec,
4300 struct hda_pcm_stream *hinfo,
4301 struct snd_pcm_substream *substream)
4303 mutex_lock(&codec->bus->prepare_mutex);
4304 hinfo->ops.cleanup(hinfo, codec, substream);
4305 mutex_unlock(&codec->bus->prepare_mutex);
4307 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4310 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4311 "Audio", "SPDIF", "HDMI", "Modem"
4315 * get the empty PCM device number to assign
4317 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4319 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4321 /* audio device indices; not linear to keep compatibility */
4322 static int audio_idx[HDA_PCM_NTYPES][5] = {
4323 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4324 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4325 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4326 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4330 if (type >= HDA_PCM_NTYPES) {
4331 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4335 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4336 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4337 return audio_idx[type][i];
4339 /* non-fixed slots starting from 10 */
4340 for (i = 10; i < 32; i++) {
4341 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4345 snd_printk(KERN_WARNING "Too many %s devices\n",
4346 snd_hda_pcm_type_name[type]);
4351 * attach a new PCM stream
4353 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4355 struct hda_bus *bus = codec->bus;
4356 struct hda_pcm_stream *info;
4359 if (snd_BUG_ON(!pcm->name))
4361 for (stream = 0; stream < 2; stream++) {
4362 info = &pcm->stream[stream];
4363 if (info->substreams) {
4364 err = set_pcm_default_values(codec, info);
4369 return bus->ops.attach_pcm(bus, codec, pcm);
4372 /* assign all PCMs of the given codec */
4373 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4378 if (!codec->num_pcms) {
4379 if (!codec->patch_ops.build_pcms)
4381 err = codec->patch_ops.build_pcms(codec);
4383 printk(KERN_ERR "hda_codec: cannot build PCMs"
4384 "for #%d (error %d)\n", codec->addr, err);
4385 err = snd_hda_codec_reset(codec);
4388 "hda_codec: cannot revert codec\n");
4393 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4394 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4397 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4398 continue; /* no substreams assigned */
4401 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4403 continue; /* no fatal error */
4405 err = snd_hda_attach_pcm(codec, cpcm);
4407 printk(KERN_ERR "hda_codec: cannot attach "
4408 "PCM stream %d for codec #%d\n",
4410 continue; /* no fatal error */
4418 * snd_hda_build_pcms - build PCM information
4421 * Create PCM information for each codec included in the bus.
4423 * The build_pcms codec patch is requested to set up codec->num_pcms and
4424 * codec->pcm_info properly. The array is referred by the top-level driver
4425 * to create its PCM instances.
4426 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4429 * At least, substreams, channels_min and channels_max must be filled for
4430 * each stream. substreams = 0 indicates that the stream doesn't exist.
4431 * When rates and/or formats are zero, the supported values are queried
4432 * from the given nid. The nid is used also by the default ops.prepare
4433 * and ops.cleanup callbacks.
4435 * The driver needs to call ops.open in its open callback. Similarly,
4436 * ops.close is supposed to be called in the close callback.
4437 * ops.prepare should be called in the prepare or hw_params callback
4438 * with the proper parameters for set up.
4439 * ops.cleanup should be called in hw_free for clean up of streams.
4441 * This function returns 0 if successful, or a negative error code.
4443 int snd_hda_build_pcms(struct hda_bus *bus)
4445 struct hda_codec *codec;
4447 list_for_each_entry(codec, &bus->codec_list, list) {
4448 int err = snd_hda_codec_build_pcms(codec);
4454 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4457 * snd_hda_check_board_config - compare the current codec with the config table
4458 * @codec: the HDA codec
4459 * @num_configs: number of config enums
4460 * @models: array of model name strings
4461 * @tbl: configuration table, terminated by null entries
4463 * Compares the modelname or PCI subsystem id of the current codec with the
4464 * given configuration table. If a matching entry is found, returns its
4465 * config value (supposed to be 0 or positive).
4467 * If no entries are matching, the function returns a negative value.
4469 int snd_hda_check_board_config(struct hda_codec *codec,
4470 int num_configs, const char * const *models,
4471 const struct snd_pci_quirk *tbl)
4473 if (codec->modelname && models) {
4475 for (i = 0; i < num_configs; i++) {
4477 !strcmp(codec->modelname, models[i])) {
4478 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4479 "selected\n", models[i]);
4485 if (!codec->bus->pci || !tbl)
4488 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4491 if (tbl->value >= 0 && tbl->value < num_configs) {
4492 #ifdef CONFIG_SND_DEBUG_VERBOSE
4494 const char *model = NULL;
4496 model = models[tbl->value];
4498 sprintf(tmp, "#%d", tbl->value);
4501 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4502 "for config %x:%x (%s)\n",
4503 model, tbl->subvendor, tbl->subdevice,
4504 (tbl->name ? tbl->name : "Unknown device"));
4510 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4513 * snd_hda_check_board_codec_sid_config - compare the current codec
4514 subsystem ID with the
4517 This is important for Gateway notebooks with SB450 HDA Audio
4518 where the vendor ID of the PCI device is:
4519 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4520 and the vendor/subvendor are found only at the codec.
4522 * @codec: the HDA codec
4523 * @num_configs: number of config enums
4524 * @models: array of model name strings
4525 * @tbl: configuration table, terminated by null entries
4527 * Compares the modelname or PCI subsystem id of the current codec with the
4528 * given configuration table. If a matching entry is found, returns its
4529 * config value (supposed to be 0 or positive).
4531 * If no entries are matching, the function returns a negative value.
4533 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4534 int num_configs, const char * const *models,
4535 const struct snd_pci_quirk *tbl)
4537 const struct snd_pci_quirk *q;
4539 /* Search for codec ID */
4540 for (q = tbl; q->subvendor; q++) {
4541 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4542 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4543 if ((codec->subsystem_id & mask) == id)
4552 if (tbl->value >= 0 && tbl->value < num_configs) {
4553 #ifdef CONFIG_SND_DEBUG_VERBOSE
4555 const char *model = NULL;
4557 model = models[tbl->value];
4559 sprintf(tmp, "#%d", tbl->value);
4562 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4563 "for config %x:%x (%s)\n",
4564 model, tbl->subvendor, tbl->subdevice,
4565 (tbl->name ? tbl->name : "Unknown device"));
4571 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4574 * snd_hda_add_new_ctls - create controls from the array
4575 * @codec: the HDA codec
4576 * @knew: the array of struct snd_kcontrol_new
4578 * This helper function creates and add new controls in the given array.
4579 * The array must be terminated with an empty entry as terminator.
4581 * Returns 0 if successful, or a negative error code.
4583 int snd_hda_add_new_ctls(struct hda_codec *codec,
4584 const struct snd_kcontrol_new *knew)
4588 for (; knew->name; knew++) {
4589 struct snd_kcontrol *kctl;
4590 int addr = 0, idx = 0;
4591 if (knew->iface == -1) /* skip this codec private value */
4594 kctl = snd_ctl_new1(knew, codec);
4598 kctl->id.device = addr;
4600 kctl->id.index = idx;
4601 err = snd_hda_ctl_add(codec, 0, kctl);
4604 /* try first with another device index corresponding to
4605 * the codec addr; if it still fails (or it's the
4606 * primary codec), then try another control index
4608 if (!addr && codec->addr)
4610 else if (!idx && !knew->index) {
4611 idx = find_empty_mixer_ctl_idx(codec,
4621 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4624 static void hda_power_work(struct work_struct *work)
4626 struct hda_codec *codec =
4627 container_of(work, struct hda_codec, power_work.work);
4628 struct hda_bus *bus = codec->bus;
4631 spin_lock(&codec->power_lock);
4632 if (codec->power_transition > 0) { /* during power-up sequence? */
4633 spin_unlock(&codec->power_lock);
4636 if (!codec->power_on || codec->power_count) {
4637 codec->power_transition = 0;
4638 spin_unlock(&codec->power_lock);
4641 spin_unlock(&codec->power_lock);
4643 state = hda_call_codec_suspend(codec, true);
4644 codec->pm_down_notified = 0;
4645 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
4646 codec->pm_down_notified = 1;
4647 hda_call_pm_notify(bus, false);
4651 static void hda_keep_power_on(struct hda_codec *codec)
4653 spin_lock(&codec->power_lock);
4654 codec->power_count++;
4655 codec->power_on = 1;
4656 codec->power_jiffies = jiffies;
4657 spin_unlock(&codec->power_lock);
4660 /* update the power on/off account with the current jiffies */
4661 void snd_hda_update_power_acct(struct hda_codec *codec)
4663 unsigned long delta = jiffies - codec->power_jiffies;
4664 if (codec->power_on)
4665 codec->power_on_acct += delta;
4667 codec->power_off_acct += delta;
4668 codec->power_jiffies += delta;
4671 /* Transition to powered up, if wait_power_down then wait for a pending
4672 * transition to D3 to complete. A pending D3 transition is indicated
4673 * with power_transition == -1. */
4674 /* call this with codec->power_lock held! */
4675 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4677 struct hda_bus *bus = codec->bus;
4679 /* Return if power_on or transitioning to power_on, unless currently
4681 if ((codec->power_on || codec->power_transition > 0) &&
4682 !(wait_power_down && codec->power_transition < 0))
4684 spin_unlock(&codec->power_lock);
4686 cancel_delayed_work_sync(&codec->power_work);
4688 spin_lock(&codec->power_lock);
4689 /* If the power down delayed work was cancelled above before starting,
4690 * then there is no need to go through power up here.
4692 if (codec->power_on) {
4693 if (codec->power_transition < 0)
4694 codec->power_transition = 0;
4698 trace_hda_power_up(codec);
4699 snd_hda_update_power_acct(codec);
4700 codec->power_on = 1;
4701 codec->power_jiffies = jiffies;
4702 codec->power_transition = 1; /* avoid reentrance */
4703 spin_unlock(&codec->power_lock);
4705 if (codec->pm_down_notified) {
4706 codec->pm_down_notified = 0;
4707 hda_call_pm_notify(bus, true);
4710 hda_call_codec_resume(codec);
4712 spin_lock(&codec->power_lock);
4713 codec->power_transition = 0;
4716 #define power_save(codec) \
4717 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4719 /* Transition to powered down */
4720 static void __snd_hda_power_down(struct hda_codec *codec)
4722 if (!codec->power_on || codec->power_count || codec->power_transition)
4725 if (power_save(codec)) {
4726 codec->power_transition = -1; /* avoid reentrance */
4727 queue_delayed_work(codec->bus->workq, &codec->power_work,
4728 msecs_to_jiffies(power_save(codec) * 1000));
4733 * snd_hda_power_save - Power-up/down/sync the codec
4734 * @codec: HD-audio codec
4735 * @delta: the counter delta to change
4737 * Change the power-up counter via @delta, and power up or down the hardware
4738 * appropriately. For the power-down, queue to the delayed action.
4739 * Passing zero to @delta means to synchronize the power state.
4741 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4743 spin_lock(&codec->power_lock);
4744 codec->power_count += delta;
4745 trace_hda_power_count(codec);
4747 __snd_hda_power_up(codec, d3wait);
4749 __snd_hda_power_down(codec);
4750 spin_unlock(&codec->power_lock);
4752 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4755 * snd_hda_check_amp_list_power - Check the amp list and update the power
4756 * @codec: HD-audio codec
4757 * @check: the object containing an AMP list and the status
4758 * @nid: NID to check / update
4760 * Check whether the given NID is in the amp list. If it's in the list,
4761 * check the current AMP status, and update the the power-status according
4762 * to the mute status.
4764 * This function is supposed to be set or called from the check_power_status
4767 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4768 struct hda_loopback_check *check,
4771 const struct hda_amp_list *p;
4774 if (!check->amplist)
4776 for (p = check->amplist; p->nid; p++) {
4781 return 0; /* nothing changed */
4783 for (p = check->amplist; p->nid; p++) {
4784 for (ch = 0; ch < 2; ch++) {
4785 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4787 if (!(v & HDA_AMP_MUTE) && v > 0) {
4788 if (!check->power_on) {
4789 check->power_on = 1;
4790 snd_hda_power_up(codec);
4796 if (check->power_on) {
4797 check->power_on = 0;
4798 snd_hda_power_down(codec);
4802 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4806 * Channel mode helper
4810 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4812 int snd_hda_ch_mode_info(struct hda_codec *codec,
4813 struct snd_ctl_elem_info *uinfo,
4814 const struct hda_channel_mode *chmode,
4817 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4819 uinfo->value.enumerated.items = num_chmodes;
4820 if (uinfo->value.enumerated.item >= num_chmodes)
4821 uinfo->value.enumerated.item = num_chmodes - 1;
4822 sprintf(uinfo->value.enumerated.name, "%dch",
4823 chmode[uinfo->value.enumerated.item].channels);
4826 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4829 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4831 int snd_hda_ch_mode_get(struct hda_codec *codec,
4832 struct snd_ctl_elem_value *ucontrol,
4833 const struct hda_channel_mode *chmode,
4839 for (i = 0; i < num_chmodes; i++) {
4840 if (max_channels == chmode[i].channels) {
4841 ucontrol->value.enumerated.item[0] = i;
4847 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4850 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4852 int snd_hda_ch_mode_put(struct hda_codec *codec,
4853 struct snd_ctl_elem_value *ucontrol,
4854 const struct hda_channel_mode *chmode,
4860 mode = ucontrol->value.enumerated.item[0];
4861 if (mode >= num_chmodes)
4863 if (*max_channelsp == chmode[mode].channels)
4865 /* change the current channel setting */
4866 *max_channelsp = chmode[mode].channels;
4867 if (chmode[mode].sequence)
4868 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4871 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4878 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4880 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4881 struct snd_ctl_elem_info *uinfo)
4885 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4887 uinfo->value.enumerated.items = imux->num_items;
4888 if (!imux->num_items)
4890 index = uinfo->value.enumerated.item;
4891 if (index >= imux->num_items)
4892 index = imux->num_items - 1;
4893 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4896 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4899 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4901 int snd_hda_input_mux_put(struct hda_codec *codec,
4902 const struct hda_input_mux *imux,
4903 struct snd_ctl_elem_value *ucontrol,
4905 unsigned int *cur_val)
4909 if (!imux->num_items)
4911 idx = ucontrol->value.enumerated.item[0];
4912 if (idx >= imux->num_items)
4913 idx = imux->num_items - 1;
4914 if (*cur_val == idx)
4916 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4917 imux->items[idx].index);
4921 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4925 * process kcontrol info callback of a simple string enum array
4926 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
4928 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
4929 struct snd_ctl_elem_info *uinfo,
4930 int num_items, const char * const *texts)
4932 static const char * const texts_default[] = {
4933 "Disabled", "Enabled"
4936 if (!texts || !num_items) {
4938 texts = texts_default;
4941 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4943 uinfo->value.enumerated.items = num_items;
4944 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
4945 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
4946 strcpy(uinfo->value.enumerated.name,
4947 texts[uinfo->value.enumerated.item]);
4950 EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
4953 * Multi-channel / digital-out PCM helper functions
4956 /* setup SPDIF output stream */
4957 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4958 unsigned int stream_tag, unsigned int format)
4960 struct hda_spdif_out *spdif;
4961 unsigned int curr_fmt;
4964 spdif = snd_hda_spdif_out_of_nid(codec, nid);
4965 curr_fmt = snd_hda_codec_read(codec, nid, 0,
4966 AC_VERB_GET_STREAM_FORMAT, 0);
4967 reset = codec->spdif_status_reset &&
4968 (spdif->ctls & AC_DIG1_ENABLE) &&
4971 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
4974 set_dig_out_convert(codec, nid,
4975 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
4977 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4978 if (codec->slave_dig_outs) {
4980 for (d = codec->slave_dig_outs; *d; d++)
4981 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4984 /* turn on again (if needed) */
4986 set_dig_out_convert(codec, nid,
4987 spdif->ctls & 0xff, -1);
4990 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4992 snd_hda_codec_cleanup_stream(codec, nid);
4993 if (codec->slave_dig_outs) {
4995 for (d = codec->slave_dig_outs; *d; d++)
4996 snd_hda_codec_cleanup_stream(codec, *d);
5001 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5002 * @bus: HD-audio bus
5004 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5006 struct hda_codec *codec;
5010 list_for_each_entry(codec, &bus->codec_list, list) {
5011 if (hda_codec_is_power_on(codec) &&
5012 codec->patch_ops.reboot_notify)
5013 codec->patch_ops.reboot_notify(codec);
5016 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
5019 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5021 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5022 struct hda_multi_out *mout)
5024 mutex_lock(&codec->spdif_mutex);
5025 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5026 /* already opened as analog dup; reset it once */
5027 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5028 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5029 mutex_unlock(&codec->spdif_mutex);
5032 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
5035 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5037 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5038 struct hda_multi_out *mout,
5039 unsigned int stream_tag,
5040 unsigned int format,
5041 struct snd_pcm_substream *substream)
5043 mutex_lock(&codec->spdif_mutex);
5044 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5045 mutex_unlock(&codec->spdif_mutex);
5048 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
5051 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5053 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5054 struct hda_multi_out *mout)
5056 mutex_lock(&codec->spdif_mutex);
5057 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5058 mutex_unlock(&codec->spdif_mutex);
5061 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
5064 * snd_hda_multi_out_dig_close - release the digital out stream
5066 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5067 struct hda_multi_out *mout)
5069 mutex_lock(&codec->spdif_mutex);
5070 mout->dig_out_used = 0;
5071 mutex_unlock(&codec->spdif_mutex);
5074 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
5077 * snd_hda_multi_out_analog_open - open analog outputs
5079 * Open analog outputs and set up the hw-constraints.
5080 * If the digital outputs can be opened as slave, open the digital
5083 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5084 struct hda_multi_out *mout,
5085 struct snd_pcm_substream *substream,
5086 struct hda_pcm_stream *hinfo)
5088 struct snd_pcm_runtime *runtime = substream->runtime;
5089 runtime->hw.channels_max = mout->max_channels;
5090 if (mout->dig_out_nid) {
5091 if (!mout->analog_rates) {
5092 mout->analog_rates = hinfo->rates;
5093 mout->analog_formats = hinfo->formats;
5094 mout->analog_maxbps = hinfo->maxbps;
5096 runtime->hw.rates = mout->analog_rates;
5097 runtime->hw.formats = mout->analog_formats;
5098 hinfo->maxbps = mout->analog_maxbps;
5100 if (!mout->spdif_rates) {
5101 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5103 &mout->spdif_formats,
5104 &mout->spdif_maxbps);
5106 mutex_lock(&codec->spdif_mutex);
5107 if (mout->share_spdif) {
5108 if ((runtime->hw.rates & mout->spdif_rates) &&
5109 (runtime->hw.formats & mout->spdif_formats)) {
5110 runtime->hw.rates &= mout->spdif_rates;
5111 runtime->hw.formats &= mout->spdif_formats;
5112 if (mout->spdif_maxbps < hinfo->maxbps)
5113 hinfo->maxbps = mout->spdif_maxbps;
5115 mout->share_spdif = 0;
5116 /* FIXME: need notify? */
5119 mutex_unlock(&codec->spdif_mutex);
5121 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5122 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5124 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
5127 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5129 * Set up the i/o for analog out.
5130 * When the digital out is available, copy the front out to digital out, too.
5132 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5133 struct hda_multi_out *mout,
5134 unsigned int stream_tag,
5135 unsigned int format,
5136 struct snd_pcm_substream *substream)
5138 const hda_nid_t *nids = mout->dac_nids;
5139 int chs = substream->runtime->channels;
5140 struct hda_spdif_out *spdif;
5143 mutex_lock(&codec->spdif_mutex);
5144 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5145 if (mout->dig_out_nid && mout->share_spdif &&
5146 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5148 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5150 !(spdif->status & IEC958_AES0_NONAUDIO)) {
5151 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5152 setup_dig_out_stream(codec, mout->dig_out_nid,
5153 stream_tag, format);
5155 mout->dig_out_used = 0;
5156 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5159 mutex_unlock(&codec->spdif_mutex);
5162 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5164 if (!mout->no_share_stream &&
5165 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5166 /* headphone out will just decode front left/right (stereo) */
5167 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5169 /* extra outputs copied from front */
5170 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5171 if (!mout->no_share_stream && mout->hp_out_nid[i])
5172 snd_hda_codec_setup_stream(codec,
5173 mout->hp_out_nid[i],
5174 stream_tag, 0, format);
5175 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5176 if (!mout->no_share_stream && mout->extra_out_nid[i])
5177 snd_hda_codec_setup_stream(codec,
5178 mout->extra_out_nid[i],
5179 stream_tag, 0, format);
5182 for (i = 1; i < mout->num_dacs; i++) {
5183 if (chs >= (i + 1) * 2) /* independent out */
5184 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5186 else if (!mout->no_share_stream) /* copy front */
5187 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5192 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
5195 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5197 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5198 struct hda_multi_out *mout)
5200 const hda_nid_t *nids = mout->dac_nids;
5203 for (i = 0; i < mout->num_dacs; i++)
5204 snd_hda_codec_cleanup_stream(codec, nids[i]);
5206 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5207 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5208 if (mout->hp_out_nid[i])
5209 snd_hda_codec_cleanup_stream(codec,
5210 mout->hp_out_nid[i]);
5211 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5212 if (mout->extra_out_nid[i])
5213 snd_hda_codec_cleanup_stream(codec,
5214 mout->extra_out_nid[i]);
5215 mutex_lock(&codec->spdif_mutex);
5216 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5217 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5218 mout->dig_out_used = 0;
5220 mutex_unlock(&codec->spdif_mutex);
5223 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
5226 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5228 * Guess the suitable VREF pin bits to be set as the pin-control value.
5229 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5231 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5233 unsigned int pincap;
5234 unsigned int oldval;
5235 oldval = snd_hda_codec_read(codec, pin, 0,
5236 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5237 pincap = snd_hda_query_pin_caps(codec, pin);
5238 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5239 /* Exception: if the default pin setup is vref50, we give it priority */
5240 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5241 return AC_PINCTL_VREF_80;
5242 else if (pincap & AC_PINCAP_VREF_50)
5243 return AC_PINCTL_VREF_50;
5244 else if (pincap & AC_PINCAP_VREF_100)
5245 return AC_PINCTL_VREF_100;
5246 else if (pincap & AC_PINCAP_VREF_GRD)
5247 return AC_PINCTL_VREF_GRD;
5248 return AC_PINCTL_VREF_HIZ;
5250 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5252 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5253 unsigned int val, bool cached)
5256 unsigned int cap = snd_hda_query_pin_caps(codec, pin);
5257 if (cap && (val & AC_PINCTL_OUT_EN)) {
5258 if (!(cap & AC_PINCAP_OUT))
5259 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5260 else if ((val & AC_PINCTL_HP_EN) &&
5261 !(cap & AC_PINCAP_HP_DRV))
5262 val &= ~AC_PINCTL_HP_EN;
5264 if (cap && (val & AC_PINCTL_IN_EN)) {
5265 if (!(cap & AC_PINCAP_IN))
5266 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5270 return snd_hda_codec_update_cache(codec, pin, 0,
5271 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5273 return snd_hda_codec_write(codec, pin, 0,
5274 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5276 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5279 * snd_hda_add_imux_item - Add an item to input_mux
5281 * When the same label is used already in the existing items, the number
5282 * suffix is appended to the label. This label index number is stored
5283 * to type_idx when non-NULL pointer is given.
5285 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5286 int index, int *type_idx)
5288 int i, label_idx = 0;
5289 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5290 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5293 for (i = 0; i < imux->num_items; i++) {
5294 if (!strncmp(label, imux->items[i].label, strlen(label)))
5298 *type_idx = label_idx;
5300 snprintf(imux->items[imux->num_items].label,
5301 sizeof(imux->items[imux->num_items].label),
5302 "%s %d", label, label_idx);
5304 strlcpy(imux->items[imux->num_items].label, label,
5305 sizeof(imux->items[imux->num_items].label));
5306 imux->items[imux->num_items].index = index;
5310 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5319 * snd_hda_suspend - suspend the codecs
5322 * Returns 0 if successful.
5324 int snd_hda_suspend(struct hda_bus *bus)
5326 struct hda_codec *codec;
5328 list_for_each_entry(codec, &bus->codec_list, list) {
5329 cancel_delayed_work_sync(&codec->jackpoll_work);
5330 if (hda_codec_is_power_on(codec))
5331 hda_call_codec_suspend(codec, false);
5335 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5338 * snd_hda_resume - resume the codecs
5341 * Returns 0 if successful.
5343 int snd_hda_resume(struct hda_bus *bus)
5345 struct hda_codec *codec;
5347 list_for_each_entry(codec, &bus->codec_list, list) {
5348 hda_call_codec_resume(codec);
5352 EXPORT_SYMBOL_HDA(snd_hda_resume);
5353 #endif /* CONFIG_PM */
5360 * snd_array_new - get a new element from the given array
5361 * @array: the array object
5363 * Get a new element from the given array. If it exceeds the
5364 * pre-allocated array size, re-allocate the array.
5366 * Returns NULL if allocation failed.
5368 void *snd_array_new(struct snd_array *array)
5370 if (snd_BUG_ON(!array->elem_size))
5372 if (array->used >= array->alloced) {
5373 int num = array->alloced + array->alloc_align;
5374 int size = (num + 1) * array->elem_size;
5375 int oldsize = array->alloced * array->elem_size;
5377 if (snd_BUG_ON(num >= 4096))
5379 nlist = krealloc(array->list, size, GFP_KERNEL);
5382 memset(nlist + oldsize, 0, size - oldsize);
5383 array->list = nlist;
5384 array->alloced = num;
5386 return snd_array_elem(array, array->used++);
5388 EXPORT_SYMBOL_HDA(snd_array_new);
5391 * snd_array_free - free the given array elements
5392 * @array: the array object
5394 void snd_array_free(struct snd_array *array)
5401 EXPORT_SYMBOL_HDA(snd_array_free);
5404 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5405 * @pcm: PCM caps bits
5406 * @buf: the string buffer to write
5407 * @buflen: the max buffer length
5409 * used by hda_proc.c and hda_eld.c
5411 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5413 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5416 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5417 if (pcm & (AC_SUPPCM_BITS_8 << i))
5418 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5420 buf[j] = '\0'; /* necessary when j == 0 */
5422 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5424 MODULE_DESCRIPTION("HDA codec core");
5425 MODULE_LICENSE("GPL");