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)
386 hda_nid_t *result = list;
389 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
390 if (len == -ENOSPC) {
391 len = snd_hda_get_num_raw_conns(codec, nid);
392 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
395 len = snd_hda_get_raw_connections(codec, nid, result, len);
398 len = snd_hda_override_conn_list(codec, nid, len, result);
405 * snd_hda_get_conn_list - get connection list
406 * @codec: the HDA codec
408 * @len: number of connection list entries
409 * @listp: the pointer to store NID list
411 * Parses the connection list of the given widget and stores the pointer
412 * to the list of NIDs.
414 * Returns the number of connections, or a negative error code.
416 * Note that the returned pointer isn't protected against the list
417 * modification. If snd_hda_override_conn_list() might be called
418 * concurrently, protect with a mutex appropriately.
420 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
421 const hda_nid_t **listp)
427 const struct hda_conn_list *p;
429 /* if the connection-list is already cached, read it */
430 p = lookup_conn_list(codec, nid);
436 if (snd_BUG_ON(added))
439 err = read_and_add_raw_conns(codec, nid);
445 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
448 * snd_hda_get_connections - copy connection list
449 * @codec: the HDA codec
451 * @conn_list: connection list array; when NULL, checks only the size
452 * @max_conns: max. number of connections to store
454 * Parses the connection list of the given widget and stores the list
457 * Returns the number of connections, or a negative error code.
459 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
460 hda_nid_t *conn_list, int max_conns)
462 const hda_nid_t *list;
463 int len = snd_hda_get_conn_list(codec, nid, &list);
465 if (len > 0 && conn_list) {
466 if (len > max_conns) {
467 snd_printk(KERN_ERR "hda_codec: "
468 "Too many connections %d for NID 0x%x\n",
472 memcpy(conn_list, list, len * sizeof(hda_nid_t));
477 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
479 /* return CONNLIST_LEN parameter of the given widget */
480 static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
482 unsigned int wcaps = get_wcaps(codec, nid);
485 if (!(wcaps & AC_WCAP_CONN_LIST) &&
486 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
489 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
495 int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
497 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
501 * snd_hda_get_raw_connections - copy connection list without cache
502 * @codec: the HDA codec
504 * @conn_list: connection list array
505 * @max_conns: max. number of connections to store
507 * Like snd_hda_get_connections(), copy the connection list but without
508 * checking through the connection-list cache.
509 * Currently called only from hda_proc.c, so not exported.
511 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
512 hda_nid_t *conn_list, int max_conns)
515 int i, conn_len, conns;
516 unsigned int shift, num_elems, mask;
520 parm = get_num_conns(codec, nid);
524 if (parm & AC_CLIST_LONG) {
533 conn_len = parm & AC_CLIST_LENGTH;
534 mask = (1 << (shift-1)) - 1;
537 return 0; /* no connection */
540 /* single connection */
541 parm = snd_hda_codec_read(codec, nid, 0,
542 AC_VERB_GET_CONNECT_LIST, 0);
543 if (parm == -1 && codec->bus->rirb_error)
546 conn_list[0] = parm & mask;
550 /* multi connection */
553 for (i = 0; i < conn_len; i++) {
557 if (i % num_elems == 0) {
558 parm = snd_hda_codec_read(codec, nid, 0,
559 AC_VERB_GET_CONNECT_LIST, i);
560 if (parm == -1 && codec->bus->rirb_error)
563 range_val = !!(parm & (1 << (shift-1))); /* ranges */
565 if (val == 0 && null_count++) { /* no second chance */
566 snd_printk(KERN_WARNING "hda_codec: "
567 "invalid CONNECT_LIST verb %x[%i]:%x\n",
573 /* ranges between the previous and this one */
574 if (!prev_nid || prev_nid >= val) {
575 snd_printk(KERN_WARNING "hda_codec: "
576 "invalid dep_range_val %x:%x\n",
580 for (n = prev_nid + 1; n <= val; n++) {
582 if (conns >= max_conns)
584 conn_list[conns] = n;
590 if (conns >= max_conns)
592 conn_list[conns] = val;
602 * snd_hda_override_conn_list - add/modify the connection-list to cache
603 * @codec: the HDA codec
605 * @len: number of connection list entries
606 * @list: the list of connection entries
608 * Add or modify the given connection-list to the cache. If the corresponding
609 * cache already exists, invalidate it and append a new one.
611 * Returns zero or a negative error code.
613 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
614 const hda_nid_t *list)
616 struct hda_conn_list *p;
618 p = lookup_conn_list(codec, nid);
624 return add_conn_list(codec, nid, len, list);
626 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
629 * snd_hda_get_conn_index - get the connection index of the given NID
630 * @codec: the HDA codec
631 * @mux: NID containing the list
632 * @nid: NID to select
633 * @recursive: 1 when searching NID recursively, otherwise 0
635 * Parses the connection list of the widget @mux and checks whether the
636 * widget @nid is present. If it is, return the connection index.
637 * Otherwise it returns -1.
639 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
640 hda_nid_t nid, int recursive)
642 const hda_nid_t *conn;
645 nums = snd_hda_get_conn_list(codec, mux, &conn);
646 for (i = 0; i < nums; i++)
651 if (recursive > 10) {
652 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
656 for (i = 0; i < nums; i++) {
657 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
658 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
660 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
665 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
668 * snd_hda_queue_unsol_event - add an unsolicited event to queue
670 * @res: unsolicited event (lower 32bit of RIRB entry)
671 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
673 * Adds the given event to the queue. The events are processed in
674 * the workqueue asynchronously. Call this function in the interrupt
675 * hanlder when RIRB receives an unsolicited event.
677 * Returns 0 if successful, or a negative error code.
679 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
681 struct hda_bus_unsolicited *unsol;
684 trace_hda_unsol_event(bus, res, res_ex);
689 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
693 unsol->queue[wp] = res;
694 unsol->queue[wp + 1] = res_ex;
696 queue_work(bus->workq, &unsol->work);
700 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
703 * process queued unsolicited events
705 static void process_unsol_events(struct work_struct *work)
707 struct hda_bus_unsolicited *unsol =
708 container_of(work, struct hda_bus_unsolicited, work);
709 struct hda_bus *bus = unsol->bus;
710 struct hda_codec *codec;
711 unsigned int rp, caddr, res;
713 while (unsol->rp != unsol->wp) {
714 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
717 res = unsol->queue[rp];
718 caddr = unsol->queue[rp + 1];
719 if (!(caddr & (1 << 4))) /* no unsolicited event? */
721 codec = bus->caddr_tbl[caddr & 0x0f];
722 if (codec && codec->patch_ops.unsol_event)
723 codec->patch_ops.unsol_event(codec, res);
728 * initialize unsolicited queue
730 static int init_unsol_queue(struct hda_bus *bus)
732 struct hda_bus_unsolicited *unsol;
734 if (bus->unsol) /* already initialized */
737 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
739 snd_printk(KERN_ERR "hda_codec: "
740 "can't allocate unsolicited queue\n");
743 INIT_WORK(&unsol->work, process_unsol_events);
752 static void snd_hda_codec_free(struct hda_codec *codec);
754 static int snd_hda_bus_free(struct hda_bus *bus)
756 struct hda_codec *codec, *n;
761 flush_workqueue(bus->workq);
764 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
765 snd_hda_codec_free(codec);
767 if (bus->ops.private_free)
768 bus->ops.private_free(bus);
770 destroy_workqueue(bus->workq);
775 static int snd_hda_bus_dev_free(struct snd_device *device)
777 struct hda_bus *bus = device->device_data;
779 return snd_hda_bus_free(bus);
782 #ifdef CONFIG_SND_HDA_HWDEP
783 static int snd_hda_bus_dev_register(struct snd_device *device)
785 struct hda_bus *bus = device->device_data;
786 struct hda_codec *codec;
787 list_for_each_entry(codec, &bus->codec_list, list) {
788 snd_hda_hwdep_add_sysfs(codec);
789 snd_hda_hwdep_add_power_sysfs(codec);
794 #define snd_hda_bus_dev_register NULL
798 * snd_hda_bus_new - create a HDA bus
799 * @card: the card entry
800 * @temp: the template for hda_bus information
801 * @busp: the pointer to store the created bus instance
803 * Returns 0 if successful, or a negative error code.
805 int snd_hda_bus_new(struct snd_card *card,
806 const struct hda_bus_template *temp,
807 struct hda_bus **busp)
811 static struct snd_device_ops dev_ops = {
812 .dev_register = snd_hda_bus_dev_register,
813 .dev_free = snd_hda_bus_dev_free,
816 if (snd_BUG_ON(!temp))
818 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
824 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
826 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
831 bus->private_data = temp->private_data;
832 bus->pci = temp->pci;
833 bus->modelname = temp->modelname;
834 bus->power_save = temp->power_save;
835 bus->ops = temp->ops;
837 mutex_init(&bus->cmd_mutex);
838 mutex_init(&bus->prepare_mutex);
839 INIT_LIST_HEAD(&bus->codec_list);
841 snprintf(bus->workq_name, sizeof(bus->workq_name),
842 "hd-audio%d", card->number);
843 bus->workq = create_singlethread_workqueue(bus->workq_name);
845 snd_printk(KERN_ERR "cannot create workqueue %s\n",
851 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
853 snd_hda_bus_free(bus);
860 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
862 #ifdef CONFIG_SND_HDA_GENERIC
863 #define is_generic_config(codec) \
864 (codec->modelname && !strcmp(codec->modelname, "generic"))
866 #define is_generic_config(codec) 0
870 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
872 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
876 * find a matching codec preset
878 static const struct hda_codec_preset *
879 find_codec_preset(struct hda_codec *codec)
881 struct hda_codec_preset_list *tbl;
882 const struct hda_codec_preset *preset;
883 unsigned int mod_requested = 0;
885 if (is_generic_config(codec))
886 return NULL; /* use the generic parser */
889 mutex_lock(&preset_mutex);
890 list_for_each_entry(tbl, &hda_preset_tables, list) {
891 if (!try_module_get(tbl->owner)) {
892 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
895 for (preset = tbl->preset; preset->id; preset++) {
896 u32 mask = preset->mask;
897 if (preset->afg && preset->afg != codec->afg)
899 if (preset->mfg && preset->mfg != codec->mfg)
903 if (preset->id == (codec->vendor_id & mask) &&
905 preset->rev == codec->revision_id)) {
906 mutex_unlock(&preset_mutex);
907 codec->owner = tbl->owner;
911 module_put(tbl->owner);
913 mutex_unlock(&preset_mutex);
915 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
918 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
921 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
922 (codec->vendor_id >> 16) & 0xffff);
923 request_module(name);
931 * get_codec_name - store the codec name
933 static int get_codec_name(struct hda_codec *codec)
935 const struct hda_vendor_id *c;
936 const char *vendor = NULL;
937 u16 vendor_id = codec->vendor_id >> 16;
940 if (codec->vendor_name)
943 for (c = hda_vendor_ids; c->id; c++) {
944 if (c->id == vendor_id) {
950 sprintf(tmp, "Generic %04x", vendor_id);
953 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
954 if (!codec->vendor_name)
958 if (codec->chip_name)
961 if (codec->preset && codec->preset->name)
962 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
964 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
965 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
967 if (!codec->chip_name)
973 * look for an AFG and MFG nodes
975 static void setup_fg_nodes(struct hda_codec *codec)
977 int i, total_nodes, function_id;
980 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
981 for (i = 0; i < total_nodes; i++, nid++) {
982 function_id = snd_hda_param_read(codec, nid,
983 AC_PAR_FUNCTION_TYPE);
984 switch (function_id & 0xff) {
985 case AC_GRP_AUDIO_FUNCTION:
987 codec->afg_function_id = function_id & 0xff;
988 codec->afg_unsol = (function_id >> 8) & 1;
990 case AC_GRP_MODEM_FUNCTION:
992 codec->mfg_function_id = function_id & 0xff;
993 codec->mfg_unsol = (function_id >> 8) & 1;
1002 * read widget caps for each widget and store in cache
1004 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1009 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1011 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1014 nid = codec->start_nid;
1015 for (i = 0; i < codec->num_nodes; i++, nid++)
1016 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1017 AC_PAR_AUDIO_WIDGET_CAP);
1021 /* read all pin default configurations and save codec->init_pins */
1022 static int read_pin_defaults(struct hda_codec *codec)
1025 hda_nid_t nid = codec->start_nid;
1027 for (i = 0; i < codec->num_nodes; i++, nid++) {
1028 struct hda_pincfg *pin;
1029 unsigned int wcaps = get_wcaps(codec, nid);
1030 unsigned int wid_type = get_wcaps_type(wcaps);
1031 if (wid_type != AC_WID_PIN)
1033 pin = snd_array_new(&codec->init_pins);
1037 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1038 AC_VERB_GET_CONFIG_DEFAULT, 0);
1039 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1040 AC_VERB_GET_PIN_WIDGET_CONTROL,
1046 /* look up the given pin config list and return the item matching with NID */
1047 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1048 struct snd_array *array,
1052 for (i = 0; i < array->used; i++) {
1053 struct hda_pincfg *pin = snd_array_elem(array, i);
1054 if (pin->nid == nid)
1060 /* set the current pin config value for the given NID.
1061 * the value is cached, and read via snd_hda_codec_get_pincfg()
1063 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1064 hda_nid_t nid, unsigned int cfg)
1066 struct hda_pincfg *pin;
1068 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1071 pin = look_up_pincfg(codec, list, nid);
1073 pin = snd_array_new(list);
1083 * snd_hda_codec_set_pincfg - Override a pin default configuration
1084 * @codec: the HDA codec
1085 * @nid: NID to set the pin config
1086 * @cfg: the pin default config value
1088 * Override a pin default configuration value in the cache.
1089 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1090 * priority than the real hardware value.
1092 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1093 hda_nid_t nid, unsigned int cfg)
1095 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1097 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1100 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1101 * @codec: the HDA codec
1102 * @nid: NID to get the pin config
1104 * Get the current pin config value of the given pin NID.
1105 * If the pincfg value is cached or overridden via sysfs or driver,
1106 * returns the cached value.
1108 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1110 struct hda_pincfg *pin;
1112 #ifdef CONFIG_SND_HDA_HWDEP
1114 unsigned int cfg = 0;
1115 mutex_lock(&codec->user_mutex);
1116 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1119 mutex_unlock(&codec->user_mutex);
1124 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1127 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1132 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1134 /* remember the current pinctl target value */
1135 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1138 struct hda_pincfg *pin;
1140 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1146 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target);
1148 /* return the current pinctl target value */
1149 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1151 struct hda_pincfg *pin;
1153 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1158 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target);
1161 * snd_hda_shutup_pins - Shut up all pins
1162 * @codec: the HDA codec
1164 * Clear all pin controls to shup up before suspend for avoiding click noise.
1165 * The controls aren't cached so that they can be resumed properly.
1167 void snd_hda_shutup_pins(struct hda_codec *codec)
1170 /* don't shut up pins when unloading the driver; otherwise it breaks
1171 * the default pin setup at the next load of the driver
1173 if (codec->bus->shutdown)
1175 for (i = 0; i < codec->init_pins.used; i++) {
1176 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1177 /* use read here for syncing after issuing each verb */
1178 snd_hda_codec_read(codec, pin->nid, 0,
1179 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1181 codec->pins_shutup = 1;
1183 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1186 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1187 static void restore_shutup_pins(struct hda_codec *codec)
1190 if (!codec->pins_shutup)
1192 if (codec->bus->shutdown)
1194 for (i = 0; i < codec->init_pins.used; i++) {
1195 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1196 snd_hda_codec_write(codec, pin->nid, 0,
1197 AC_VERB_SET_PIN_WIDGET_CONTROL,
1200 codec->pins_shutup = 0;
1204 static void hda_jackpoll_work(struct work_struct *work)
1206 struct hda_codec *codec =
1207 container_of(work, struct hda_codec, jackpoll_work.work);
1208 if (!codec->jackpoll_interval)
1211 snd_hda_jack_set_dirty_all(codec);
1212 snd_hda_jack_poll_all(codec);
1213 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1214 codec->jackpoll_interval);
1217 static void init_hda_cache(struct hda_cache_rec *cache,
1218 unsigned int record_size);
1219 static void free_hda_cache(struct hda_cache_rec *cache);
1221 /* release all pincfg lists */
1222 static void free_init_pincfgs(struct hda_codec *codec)
1224 snd_array_free(&codec->driver_pins);
1225 #ifdef CONFIG_SND_HDA_HWDEP
1226 snd_array_free(&codec->user_pins);
1228 snd_array_free(&codec->init_pins);
1232 * audio-converter setup caches
1234 struct hda_cvt_setup {
1239 unsigned char active; /* cvt is currently used */
1240 unsigned char dirty; /* setups should be cleared */
1243 /* get or create a cache entry for the given audio converter NID */
1244 static struct hda_cvt_setup *
1245 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1247 struct hda_cvt_setup *p;
1250 for (i = 0; i < codec->cvt_setups.used; i++) {
1251 p = snd_array_elem(&codec->cvt_setups, i);
1255 p = snd_array_new(&codec->cvt_setups);
1264 static void snd_hda_codec_free(struct hda_codec *codec)
1268 cancel_delayed_work_sync(&codec->jackpoll_work);
1269 snd_hda_jack_tbl_clear(codec);
1270 free_init_pincfgs(codec);
1272 cancel_delayed_work(&codec->power_work);
1273 flush_workqueue(codec->bus->workq);
1275 list_del(&codec->list);
1276 snd_array_free(&codec->mixers);
1277 snd_array_free(&codec->nids);
1278 snd_array_free(&codec->cvt_setups);
1279 snd_array_free(&codec->spdif_out);
1280 remove_conn_list(codec);
1281 codec->bus->caddr_tbl[codec->addr] = NULL;
1282 if (codec->patch_ops.free)
1283 codec->patch_ops.free(codec);
1285 if (!codec->pm_down_notified) /* cancel leftover refcounts */
1286 hda_call_pm_notify(codec->bus, false);
1288 module_put(codec->owner);
1289 free_hda_cache(&codec->amp_cache);
1290 free_hda_cache(&codec->cmd_cache);
1291 kfree(codec->vendor_name);
1292 kfree(codec->chip_name);
1293 kfree(codec->modelname);
1294 kfree(codec->wcaps);
1298 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1299 hda_nid_t fg, unsigned int power_state);
1301 static unsigned int hda_set_power_state(struct hda_codec *codec,
1302 unsigned int power_state);
1303 static unsigned int default_power_filter(struct hda_codec *codec, hda_nid_t nid,
1304 unsigned int power_state);
1307 * snd_hda_codec_new - create a HDA codec
1308 * @bus: the bus to assign
1309 * @codec_addr: the codec address
1310 * @codecp: the pointer to store the generated codec
1312 * Returns 0 if successful, or a negative error code.
1314 int snd_hda_codec_new(struct hda_bus *bus,
1315 unsigned int codec_addr,
1316 struct hda_codec **codecp)
1318 struct hda_codec *codec;
1323 if (snd_BUG_ON(!bus))
1325 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1328 if (bus->caddr_tbl[codec_addr]) {
1329 snd_printk(KERN_ERR "hda_codec: "
1330 "address 0x%x is already occupied\n", codec_addr);
1334 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1335 if (codec == NULL) {
1336 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1341 codec->addr = codec_addr;
1342 mutex_init(&codec->spdif_mutex);
1343 mutex_init(&codec->control_mutex);
1344 mutex_init(&codec->hash_mutex);
1345 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1346 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1347 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1348 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1349 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1350 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1351 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1352 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1353 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1354 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1355 INIT_LIST_HEAD(&codec->conn_list);
1357 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1360 spin_lock_init(&codec->power_lock);
1361 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1362 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1363 * the caller has to power down appropriatley after initialization
1366 hda_keep_power_on(codec);
1367 hda_call_pm_notify(bus, true);
1370 if (codec->bus->modelname) {
1371 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1372 if (!codec->modelname) {
1373 snd_hda_codec_free(codec);
1378 list_add_tail(&codec->list, &bus->codec_list);
1379 bus->caddr_tbl[codec_addr] = codec;
1381 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1383 if (codec->vendor_id == -1)
1384 /* read again, hopefully the access method was corrected
1385 * in the last read...
1387 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1389 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1390 AC_PAR_SUBSYSTEM_ID);
1391 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1394 setup_fg_nodes(codec);
1395 if (!codec->afg && !codec->mfg) {
1396 snd_printdd("hda_codec: no AFG or MFG node found\n");
1401 fg = codec->afg ? codec->afg : codec->mfg;
1402 err = read_widget_caps(codec, fg);
1404 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1407 err = read_pin_defaults(codec);
1411 if (!codec->subsystem_id) {
1412 codec->subsystem_id =
1413 snd_hda_codec_read(codec, fg, 0,
1414 AC_VERB_GET_SUBSYSTEM_ID, 0);
1418 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1420 if (!codec->d3_stop_clk)
1421 bus->power_keep_link_on = 1;
1423 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1425 codec->power_filter = default_power_filter;
1427 /* power-up all before initialization */
1428 hda_set_power_state(codec, AC_PWRST_D0);
1430 snd_hda_codec_proc_new(codec);
1432 snd_hda_create_hwdep(codec);
1434 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1435 codec->subsystem_id, codec->revision_id);
1436 snd_component_add(codec->bus->card, component);
1443 snd_hda_codec_free(codec);
1446 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1448 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1453 /* Assume the function group node does not change,
1454 * only the widget nodes may change.
1456 kfree(codec->wcaps);
1457 fg = codec->afg ? codec->afg : codec->mfg;
1458 err = read_widget_caps(codec, fg);
1460 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1464 snd_array_free(&codec->init_pins);
1465 err = read_pin_defaults(codec);
1469 EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets);
1473 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1474 * @codec: the HDA codec
1476 * Start parsing of the given codec tree and (re-)initialize the whole
1479 * Returns 0 if successful or a negative error code.
1481 int snd_hda_codec_configure(struct hda_codec *codec)
1485 codec->preset = find_codec_preset(codec);
1486 if (!codec->vendor_name || !codec->chip_name) {
1487 err = get_codec_name(codec);
1492 if (is_generic_config(codec)) {
1493 err = snd_hda_parse_generic_codec(codec);
1496 if (codec->preset && codec->preset->patch) {
1497 err = codec->preset->patch(codec);
1501 /* call the default parser */
1502 err = snd_hda_parse_generic_codec(codec);
1504 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1507 if (!err && codec->patch_ops.unsol_event)
1508 err = init_unsol_queue(codec->bus);
1509 /* audio codec should override the mixer name */
1510 if (!err && (codec->afg || !*codec->bus->card->mixername))
1511 snprintf(codec->bus->card->mixername,
1512 sizeof(codec->bus->card->mixername),
1513 "%s %s", codec->vendor_name, codec->chip_name);
1516 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1518 /* update the stream-id if changed */
1519 static void update_pcm_stream_id(struct hda_codec *codec,
1520 struct hda_cvt_setup *p, hda_nid_t nid,
1521 u32 stream_tag, int channel_id)
1523 unsigned int oldval, newval;
1525 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1526 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1527 newval = (stream_tag << 4) | channel_id;
1528 if (oldval != newval)
1529 snd_hda_codec_write(codec, nid, 0,
1530 AC_VERB_SET_CHANNEL_STREAMID,
1532 p->stream_tag = stream_tag;
1533 p->channel_id = channel_id;
1537 /* update the format-id if changed */
1538 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1539 hda_nid_t nid, int format)
1541 unsigned int oldval;
1543 if (p->format_id != format) {
1544 oldval = snd_hda_codec_read(codec, nid, 0,
1545 AC_VERB_GET_STREAM_FORMAT, 0);
1546 if (oldval != format) {
1548 snd_hda_codec_write(codec, nid, 0,
1549 AC_VERB_SET_STREAM_FORMAT,
1552 p->format_id = format;
1557 * snd_hda_codec_setup_stream - set up the codec for streaming
1558 * @codec: the CODEC to set up
1559 * @nid: the NID to set up
1560 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1561 * @channel_id: channel id to pass, zero based.
1562 * @format: stream format.
1564 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1566 int channel_id, int format)
1568 struct hda_codec *c;
1569 struct hda_cvt_setup *p;
1576 snd_printdd("hda_codec_setup_stream: "
1577 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1578 nid, stream_tag, channel_id, format);
1579 p = get_hda_cvt_setup(codec, nid);
1580 if (!p || p->active)
1583 if (codec->pcm_format_first)
1584 update_pcm_format(codec, p, nid, format);
1585 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1586 if (!codec->pcm_format_first)
1587 update_pcm_format(codec, p, nid, format);
1592 /* make other inactive cvts with the same stream-tag dirty */
1593 type = get_wcaps_type(get_wcaps(codec, nid));
1594 list_for_each_entry(c, &codec->bus->codec_list, list) {
1595 for (i = 0; i < c->cvt_setups.used; i++) {
1596 p = snd_array_elem(&c->cvt_setups, i);
1597 if (!p->active && p->stream_tag == stream_tag &&
1598 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1603 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1605 static void really_cleanup_stream(struct hda_codec *codec,
1606 struct hda_cvt_setup *q);
1609 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1610 * @codec: the CODEC to clean up
1611 * @nid: the NID to clean up
1612 * @do_now: really clean up the stream instead of clearing the active flag
1614 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1617 struct hda_cvt_setup *p;
1622 if (codec->no_sticky_stream)
1625 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1626 p = get_hda_cvt_setup(codec, nid);
1627 if (p && p->active) {
1628 /* here we just clear the active flag when do_now isn't set;
1629 * actual clean-ups will be done later in
1630 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1633 really_cleanup_stream(codec, p);
1638 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1640 static void really_cleanup_stream(struct hda_codec *codec,
1641 struct hda_cvt_setup *q)
1643 hda_nid_t nid = q->nid;
1644 if (q->stream_tag || q->channel_id)
1645 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1647 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1649 memset(q, 0, sizeof(*q));
1653 /* clean up the all conflicting obsolete streams */
1654 static void purify_inactive_streams(struct hda_codec *codec)
1656 struct hda_codec *c;
1659 list_for_each_entry(c, &codec->bus->codec_list, list) {
1660 for (i = 0; i < c->cvt_setups.used; i++) {
1661 struct hda_cvt_setup *p;
1662 p = snd_array_elem(&c->cvt_setups, i);
1664 really_cleanup_stream(c, p);
1670 /* clean up all streams; called from suspend */
1671 static void hda_cleanup_all_streams(struct hda_codec *codec)
1675 for (i = 0; i < codec->cvt_setups.used; i++) {
1676 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1678 really_cleanup_stream(codec, p);
1684 * amp access functions
1687 /* FIXME: more better hash key? */
1688 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1689 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1690 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1691 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1692 #define INFO_AMP_CAPS (1<<0)
1693 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1695 /* initialize the hash table */
1696 static void init_hda_cache(struct hda_cache_rec *cache,
1697 unsigned int record_size)
1699 memset(cache, 0, sizeof(*cache));
1700 memset(cache->hash, 0xff, sizeof(cache->hash));
1701 snd_array_init(&cache->buf, record_size, 64);
1704 static void free_hda_cache(struct hda_cache_rec *cache)
1706 snd_array_free(&cache->buf);
1709 /* query the hash. allocate an entry if not found. */
1710 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1712 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1713 u16 cur = cache->hash[idx];
1714 struct hda_cache_head *info;
1716 while (cur != 0xffff) {
1717 info = snd_array_elem(&cache->buf, cur);
1718 if (info->key == key)
1725 /* query the hash. allocate an entry if not found. */
1726 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1729 struct hda_cache_head *info = get_hash(cache, key);
1732 /* add a new hash entry */
1733 info = snd_array_new(&cache->buf);
1736 cur = snd_array_index(&cache->buf, info);
1740 idx = key % (u16)ARRAY_SIZE(cache->hash);
1741 info->next = cache->hash[idx];
1742 cache->hash[idx] = cur;
1747 /* query and allocate an amp hash entry */
1748 static inline struct hda_amp_info *
1749 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1751 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1754 /* overwrite the value with the key in the caps hash */
1755 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1757 struct hda_amp_info *info;
1759 mutex_lock(&codec->hash_mutex);
1760 info = get_alloc_amp_hash(codec, key);
1762 mutex_unlock(&codec->hash_mutex);
1765 info->amp_caps = val;
1766 info->head.val |= INFO_AMP_CAPS;
1767 mutex_unlock(&codec->hash_mutex);
1771 /* query the value from the caps hash; if not found, fetch the current
1772 * value from the given function and store in the hash
1775 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1776 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1778 struct hda_amp_info *info;
1781 mutex_lock(&codec->hash_mutex);
1782 info = get_alloc_amp_hash(codec, key);
1784 mutex_unlock(&codec->hash_mutex);
1787 if (!(info->head.val & INFO_AMP_CAPS)) {
1788 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1789 val = func(codec, nid, dir);
1790 write_caps_hash(codec, key, val);
1792 val = info->amp_caps;
1793 mutex_unlock(&codec->hash_mutex);
1798 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1801 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1803 return snd_hda_param_read(codec, nid,
1804 direction == HDA_OUTPUT ?
1805 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1809 * query_amp_caps - query AMP capabilities
1810 * @codec: the HD-auio codec
1811 * @nid: the NID to query
1812 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1814 * Query AMP capabilities for the given widget and direction.
1815 * Returns the obtained capability bits.
1817 * When cap bits have been already read, this doesn't read again but
1818 * returns the cached value.
1820 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1822 return query_caps_hash(codec, nid, direction,
1823 HDA_HASH_KEY(nid, direction, 0),
1826 EXPORT_SYMBOL_HDA(query_amp_caps);
1829 * snd_hda_override_amp_caps - Override the AMP capabilities
1830 * @codec: the CODEC to clean up
1831 * @nid: the NID to clean up
1832 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1833 * @caps: the capability bits to set
1835 * Override the cached AMP caps bits value by the given one.
1836 * This function is useful if the driver needs to adjust the AMP ranges,
1837 * e.g. limit to 0dB, etc.
1839 * Returns zero if successful or a negative error code.
1841 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1844 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1846 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1848 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1851 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1855 * snd_hda_query_pin_caps - Query PIN capabilities
1856 * @codec: the HD-auio codec
1857 * @nid: the NID to query
1859 * Query PIN capabilities for the given widget.
1860 * Returns the obtained capability bits.
1862 * When cap bits have been already read, this doesn't read again but
1863 * returns the cached value.
1865 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1867 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1870 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1873 * snd_hda_override_pin_caps - Override the pin capabilities
1875 * @nid: the NID to override
1876 * @caps: the capability bits to set
1878 * Override the cached PIN capabilitiy bits value by the given one.
1880 * Returns zero if successful or a negative error code.
1882 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1885 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1887 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1889 /* read or sync the hash value with the current value;
1890 * call within hash_mutex
1892 static struct hda_amp_info *
1893 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1894 int direction, int index, bool init_only)
1896 struct hda_amp_info *info;
1897 unsigned int parm, val = 0;
1898 bool val_read = false;
1901 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1904 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1906 mutex_unlock(&codec->hash_mutex);
1907 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1908 parm |= direction == HDA_OUTPUT ?
1909 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1911 val = snd_hda_codec_read(codec, nid, 0,
1912 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1915 mutex_lock(&codec->hash_mutex);
1918 info->vol[ch] = val;
1919 info->head.val |= INFO_AMP_VOL(ch);
1920 } else if (init_only)
1926 * write the current volume in info to the h/w
1928 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
1929 hda_nid_t nid, int ch, int direction, int index,
1934 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1935 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1936 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1937 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
1938 (amp_caps & AC_AMPCAP_MIN_MUTE))
1939 ; /* set the zero value as a fake mute */
1942 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1946 * snd_hda_codec_amp_read - Read AMP value
1947 * @codec: HD-audio codec
1948 * @nid: NID to read the AMP value
1949 * @ch: channel (left=0 or right=1)
1950 * @direction: #HDA_INPUT or #HDA_OUTPUT
1951 * @index: the index value (only for input direction)
1953 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1955 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1956 int direction, int index)
1958 struct hda_amp_info *info;
1959 unsigned int val = 0;
1961 mutex_lock(&codec->hash_mutex);
1962 info = update_amp_hash(codec, nid, ch, direction, index, false);
1964 val = info->vol[ch];
1965 mutex_unlock(&codec->hash_mutex);
1968 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1970 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1971 int direction, int idx, int mask, int val,
1974 struct hda_amp_info *info;
1976 unsigned int cache_only;
1978 if (snd_BUG_ON(mask & ~0xff))
1982 mutex_lock(&codec->hash_mutex);
1983 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
1985 mutex_unlock(&codec->hash_mutex);
1988 val |= info->vol[ch] & ~mask;
1989 if (info->vol[ch] == val) {
1990 mutex_unlock(&codec->hash_mutex);
1993 info->vol[ch] = val;
1994 cache_only = info->head.dirty = codec->cached_write;
1995 caps = info->amp_caps;
1996 mutex_unlock(&codec->hash_mutex);
1998 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2003 * snd_hda_codec_amp_update - update the AMP value
2004 * @codec: HD-audio codec
2005 * @nid: NID to read the AMP value
2006 * @ch: channel (left=0 or right=1)
2007 * @direction: #HDA_INPUT or #HDA_OUTPUT
2008 * @idx: the index value (only for input direction)
2009 * @mask: bit mask to set
2010 * @val: the bits value to set
2012 * Update the AMP value with a bit mask.
2013 * Returns 0 if the value is unchanged, 1 if changed.
2015 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2016 int direction, int idx, int mask, int val)
2018 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2020 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
2023 * snd_hda_codec_amp_stereo - update the AMP stereo values
2024 * @codec: HD-audio codec
2025 * @nid: NID to read the AMP value
2026 * @direction: #HDA_INPUT or #HDA_OUTPUT
2027 * @idx: the index value (only for input direction)
2028 * @mask: bit mask to set
2029 * @val: the bits value to set
2031 * Update the AMP values like snd_hda_codec_amp_update(), but for a
2032 * stereo widget with the same mask and value.
2034 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2035 int direction, int idx, int mask, int val)
2039 if (snd_BUG_ON(mask & ~0xff))
2041 for (ch = 0; ch < 2; ch++)
2042 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2046 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
2048 /* Works like snd_hda_codec_amp_update() but it writes the value only at
2049 * the first access. If the amp was already initialized / updated beforehand,
2050 * this does nothing.
2052 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2053 int dir, int idx, int mask, int val)
2055 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2057 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
2059 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2060 int dir, int idx, int mask, int val)
2064 if (snd_BUG_ON(mask & ~0xff))
2066 for (ch = 0; ch < 2; ch++)
2067 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2071 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
2074 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2075 * @codec: HD-audio codec
2077 * Resume the all amp commands from the cache.
2079 void snd_hda_codec_resume_amp(struct hda_codec *codec)
2083 mutex_lock(&codec->hash_mutex);
2084 codec->cached_write = 0;
2085 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2086 struct hda_amp_info *buffer;
2089 unsigned int idx, dir, ch;
2090 struct hda_amp_info info;
2092 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2093 if (!buffer->head.dirty)
2095 buffer->head.dirty = 0;
2097 key = info.head.key;
2101 idx = (key >> 16) & 0xff;
2102 dir = (key >> 24) & 0xff;
2103 for (ch = 0; ch < 2; ch++) {
2104 if (!(info.head.val & INFO_AMP_VOL(ch)))
2106 mutex_unlock(&codec->hash_mutex);
2107 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2109 mutex_lock(&codec->hash_mutex);
2112 mutex_unlock(&codec->hash_mutex);
2114 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
2116 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2119 u32 caps = query_amp_caps(codec, nid, dir);
2121 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2128 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2130 * The control element is supposed to have the private_value field
2131 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2133 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2134 struct snd_ctl_elem_info *uinfo)
2136 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2137 u16 nid = get_amp_nid(kcontrol);
2138 u8 chs = get_amp_channels(kcontrol);
2139 int dir = get_amp_direction(kcontrol);
2140 unsigned int ofs = get_amp_offset(kcontrol);
2142 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2143 uinfo->count = chs == 3 ? 2 : 1;
2144 uinfo->value.integer.min = 0;
2145 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2146 if (!uinfo->value.integer.max) {
2147 printk(KERN_WARNING "hda_codec: "
2148 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2154 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
2157 static inline unsigned int
2158 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2159 int ch, int dir, int idx, unsigned int ofs)
2162 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2163 val &= HDA_AMP_VOLMASK;
2172 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2173 int ch, int dir, int idx, unsigned int ofs,
2176 unsigned int maxval;
2180 /* ofs = 0: raw max value */
2181 maxval = get_amp_max_value(codec, nid, dir, 0);
2184 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2185 HDA_AMP_VOLMASK, val);
2189 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2191 * The control element is supposed to have the private_value field
2192 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2194 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2195 struct snd_ctl_elem_value *ucontrol)
2197 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2198 hda_nid_t nid = get_amp_nid(kcontrol);
2199 int chs = get_amp_channels(kcontrol);
2200 int dir = get_amp_direction(kcontrol);
2201 int idx = get_amp_index(kcontrol);
2202 unsigned int ofs = get_amp_offset(kcontrol);
2203 long *valp = ucontrol->value.integer.value;
2206 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2208 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2211 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2214 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2216 * The control element is supposed to have the private_value field
2217 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2219 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2220 struct snd_ctl_elem_value *ucontrol)
2222 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2223 hda_nid_t nid = get_amp_nid(kcontrol);
2224 int chs = get_amp_channels(kcontrol);
2225 int dir = get_amp_direction(kcontrol);
2226 int idx = get_amp_index(kcontrol);
2227 unsigned int ofs = get_amp_offset(kcontrol);
2228 long *valp = ucontrol->value.integer.value;
2231 snd_hda_power_up(codec);
2233 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2237 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2238 snd_hda_power_down(codec);
2241 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2244 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2246 * The control element is supposed to have the private_value field
2247 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2249 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2250 unsigned int size, unsigned int __user *_tlv)
2252 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2253 hda_nid_t nid = get_amp_nid(kcontrol);
2254 int dir = get_amp_direction(kcontrol);
2255 unsigned int ofs = get_amp_offset(kcontrol);
2256 bool min_mute = get_amp_min_mute(kcontrol);
2257 u32 caps, val1, val2;
2259 if (size < 4 * sizeof(unsigned int))
2261 caps = query_amp_caps(codec, nid, dir);
2262 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2263 val2 = (val2 + 1) * 25;
2264 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2266 val1 = ((int)val1) * ((int)val2);
2267 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2268 val2 |= TLV_DB_SCALE_MUTE;
2269 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2271 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2273 if (put_user(val1, _tlv + 2))
2275 if (put_user(val2, _tlv + 3))
2279 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2282 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2283 * @codec: HD-audio codec
2284 * @nid: NID of a reference widget
2285 * @dir: #HDA_INPUT or #HDA_OUTPUT
2286 * @tlv: TLV data to be stored, at least 4 elements
2288 * Set (static) TLV data for a virtual master volume using the AMP caps
2289 * obtained from the reference NID.
2290 * The volume range is recalculated as if the max volume is 0dB.
2292 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2298 caps = query_amp_caps(codec, nid, dir);
2299 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2300 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2301 step = (step + 1) * 25;
2302 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2303 tlv[1] = 2 * sizeof(unsigned int);
2304 tlv[2] = -nums * step;
2307 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2309 /* find a mixer control element with the given name */
2310 static struct snd_kcontrol *
2311 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2313 struct snd_ctl_elem_id id;
2314 memset(&id, 0, sizeof(id));
2315 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2318 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2320 strcpy(id.name, name);
2321 return snd_ctl_find_id(codec->bus->card, &id);
2325 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2326 * @codec: HD-audio codec
2327 * @name: ctl id name string
2329 * Get the control element with the given id string and IFACE_MIXER.
2331 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2334 return find_mixer_ctl(codec, name, 0, 0);
2336 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2338 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2342 /* 16 ctlrs should be large enough */
2343 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2344 if (!find_mixer_ctl(codec, name, 0, idx))
2351 * snd_hda_ctl_add - Add a control element and assign to the codec
2352 * @codec: HD-audio codec
2353 * @nid: corresponding NID (optional)
2354 * @kctl: the control element to assign
2356 * Add the given control element to an array inside the codec instance.
2357 * All control elements belonging to a codec are supposed to be added
2358 * by this function so that a proper clean-up works at the free or
2359 * reconfiguration time.
2361 * If non-zero @nid is passed, the NID is assigned to the control element.
2362 * The assignment is shown in the codec proc file.
2364 * snd_hda_ctl_add() checks the control subdev id field whether
2365 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2366 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2367 * specifies if kctl->private_value is a HDA amplifier value.
2369 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2370 struct snd_kcontrol *kctl)
2373 unsigned short flags = 0;
2374 struct hda_nid_item *item;
2376 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2377 flags |= HDA_NID_ITEM_AMP;
2379 nid = get_amp_nid_(kctl->private_value);
2381 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2382 nid = kctl->id.subdevice & 0xffff;
2383 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2384 kctl->id.subdevice = 0;
2385 err = snd_ctl_add(codec->bus->card, kctl);
2388 item = snd_array_new(&codec->mixers);
2393 item->flags = flags;
2396 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2399 * snd_hda_add_nid - Assign a NID to a control element
2400 * @codec: HD-audio codec
2401 * @nid: corresponding NID (optional)
2402 * @kctl: the control element to assign
2403 * @index: index to kctl
2405 * Add the given control element to an array inside the codec instance.
2406 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2407 * NID:KCTL mapping - for example "Capture Source" selector.
2409 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2410 unsigned int index, hda_nid_t nid)
2412 struct hda_nid_item *item;
2415 item = snd_array_new(&codec->nids);
2419 item->index = index;
2423 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2424 kctl->id.name, kctl->id.index, index);
2427 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2430 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2431 * @codec: HD-audio codec
2433 void snd_hda_ctls_clear(struct hda_codec *codec)
2436 struct hda_nid_item *items = codec->mixers.list;
2437 for (i = 0; i < codec->mixers.used; i++)
2438 snd_ctl_remove(codec->bus->card, items[i].kctl);
2439 snd_array_free(&codec->mixers);
2440 snd_array_free(&codec->nids);
2443 /* pseudo device locking
2444 * toggle card->shutdown to allow/disallow the device access (as a hack)
2446 int snd_hda_lock_devices(struct hda_bus *bus)
2448 struct snd_card *card = bus->card;
2449 struct hda_codec *codec;
2451 spin_lock(&card->files_lock);
2455 if (!list_empty(&card->ctl_files))
2458 list_for_each_entry(codec, &bus->codec_list, list) {
2460 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2461 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2464 if (cpcm->pcm->streams[0].substream_opened ||
2465 cpcm->pcm->streams[1].substream_opened)
2469 spin_unlock(&card->files_lock);
2475 spin_unlock(&card->files_lock);
2478 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2480 void snd_hda_unlock_devices(struct hda_bus *bus)
2482 struct snd_card *card = bus->card;
2485 spin_lock(&card->files_lock);
2487 spin_unlock(&card->files_lock);
2489 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2492 * snd_hda_codec_reset - Clear all objects assigned to the codec
2493 * @codec: HD-audio codec
2495 * This frees the all PCM and control elements assigned to the codec, and
2496 * clears the caches and restores the pin default configurations.
2498 * When a device is being used, it returns -EBSY. If successfully freed,
2501 int snd_hda_codec_reset(struct hda_codec *codec)
2503 struct hda_bus *bus = codec->bus;
2504 struct snd_card *card = bus->card;
2507 if (snd_hda_lock_devices(bus) < 0)
2510 /* OK, let it free */
2511 cancel_delayed_work_sync(&codec->jackpoll_work);
2513 cancel_delayed_work_sync(&codec->power_work);
2514 codec->power_on = 0;
2515 codec->power_transition = 0;
2516 codec->power_jiffies = jiffies;
2517 flush_workqueue(bus->workq);
2519 snd_hda_ctls_clear(codec);
2521 for (i = 0; i < codec->num_pcms; i++) {
2522 if (codec->pcm_info[i].pcm) {
2523 snd_device_free(card, codec->pcm_info[i].pcm);
2524 clear_bit(codec->pcm_info[i].device,
2528 if (codec->patch_ops.free)
2529 codec->patch_ops.free(codec);
2530 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2531 snd_hda_jack_tbl_clear(codec);
2532 codec->proc_widget_hook = NULL;
2534 free_hda_cache(&codec->amp_cache);
2535 free_hda_cache(&codec->cmd_cache);
2536 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2537 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2538 /* free only driver_pins so that init_pins + user_pins are restored */
2539 snd_array_free(&codec->driver_pins);
2540 snd_array_free(&codec->cvt_setups);
2541 snd_array_free(&codec->spdif_out);
2542 snd_array_free(&codec->verbs);
2543 codec->num_pcms = 0;
2544 codec->pcm_info = NULL;
2545 codec->preset = NULL;
2546 codec->slave_dig_outs = NULL;
2547 codec->spdif_status_reset = 0;
2548 module_put(codec->owner);
2549 codec->owner = NULL;
2551 /* allow device access again */
2552 snd_hda_unlock_devices(bus);
2556 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2558 /* apply the function to all matching slave ctls in the mixer list */
2559 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2560 const char *suffix, map_slave_func_t func, void *data)
2562 struct hda_nid_item *items;
2563 const char * const *s;
2566 items = codec->mixers.list;
2567 for (i = 0; i < codec->mixers.used; i++) {
2568 struct snd_kcontrol *sctl = items[i].kctl;
2569 if (!sctl || !sctl->id.name ||
2570 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2572 for (s = slaves; *s; s++) {
2573 char tmpname[sizeof(sctl->id.name)];
2574 const char *name = *s;
2576 snprintf(tmpname, sizeof(tmpname), "%s %s",
2580 if (!strcmp(sctl->id.name, name)) {
2581 err = func(data, sctl);
2591 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2596 /* guess the value corresponding to 0dB */
2597 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2600 const int *tlv = NULL;
2603 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2604 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2605 mm_segment_t fs = get_fs();
2607 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2610 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2612 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2613 val = -tlv[2] / tlv[3];
2617 /* call kctl->put with the given value(s) */
2618 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2620 struct snd_ctl_elem_value *ucontrol;
2621 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2624 ucontrol->value.integer.value[0] = val;
2625 ucontrol->value.integer.value[1] = val;
2626 kctl->put(kctl, ucontrol);
2631 /* initialize the slave volume with 0dB */
2632 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2634 int offset = get_kctl_0dB_offset(slave);
2636 put_kctl_with_value(slave, offset);
2640 /* unmute the slave */
2641 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2643 return put_kctl_with_value(slave, 1);
2647 * snd_hda_add_vmaster - create a virtual master control and add slaves
2648 * @codec: HD-audio codec
2649 * @name: vmaster control name
2650 * @tlv: TLV data (optional)
2651 * @slaves: slave control names (optional)
2652 * @suffix: suffix string to each slave name (optional)
2653 * @init_slave_vol: initialize slaves to unmute/0dB
2654 * @ctl_ret: store the vmaster kcontrol in return
2656 * Create a virtual master control with the given name. The TLV data
2657 * must be either NULL or a valid data.
2659 * @slaves is a NULL-terminated array of strings, each of which is a
2660 * slave control name. All controls with these names are assigned to
2661 * the new virtual master control.
2663 * This function returns zero if successful or a negative error code.
2665 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2666 unsigned int *tlv, const char * const *slaves,
2667 const char *suffix, bool init_slave_vol,
2668 struct snd_kcontrol **ctl_ret)
2670 struct snd_kcontrol *kctl;
2676 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2678 snd_printdd("No slave found for %s\n", name);
2681 kctl = snd_ctl_make_virtual_master(name, tlv);
2684 err = snd_hda_ctl_add(codec, 0, kctl);
2688 err = map_slaves(codec, slaves, suffix,
2689 (map_slave_func_t)snd_ctl_add_slave, kctl);
2693 /* init with master mute & zero volume */
2694 put_kctl_with_value(kctl, 0);
2696 map_slaves(codec, slaves, suffix,
2697 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2703 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2706 * mute-LED control using vmaster
2708 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2709 struct snd_ctl_elem_info *uinfo)
2711 static const char * const texts[] = {
2712 "On", "Off", "Follow Master"
2716 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2718 uinfo->value.enumerated.items = 3;
2719 index = uinfo->value.enumerated.item;
2722 strcpy(uinfo->value.enumerated.name, texts[index]);
2726 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2727 struct snd_ctl_elem_value *ucontrol)
2729 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2730 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2734 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2735 struct snd_ctl_elem_value *ucontrol)
2737 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2738 unsigned int old_mode = hook->mute_mode;
2740 hook->mute_mode = ucontrol->value.enumerated.item[0];
2741 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2742 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2743 if (old_mode == hook->mute_mode)
2745 snd_hda_sync_vmaster_hook(hook);
2749 static struct snd_kcontrol_new vmaster_mute_mode = {
2750 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2751 .name = "Mute-LED Mode",
2752 .info = vmaster_mute_mode_info,
2753 .get = vmaster_mute_mode_get,
2754 .put = vmaster_mute_mode_put,
2758 * Add a mute-LED hook with the given vmaster switch kctl
2759 * "Mute-LED Mode" control is automatically created and associated with
2762 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2763 struct hda_vmaster_mute_hook *hook,
2764 bool expose_enum_ctl)
2766 struct snd_kcontrol *kctl;
2768 if (!hook->hook || !hook->sw_kctl)
2770 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2771 hook->codec = codec;
2772 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2773 if (!expose_enum_ctl)
2775 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2778 return snd_hda_ctl_add(codec, 0, kctl);
2780 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2783 * Call the hook with the current value for synchronization
2784 * Should be called in init callback
2786 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2788 if (!hook->hook || !hook->codec)
2790 switch (hook->mute_mode) {
2791 case HDA_VMUTE_FOLLOW_MASTER:
2792 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2795 hook->hook(hook->codec, hook->mute_mode);
2799 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2803 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2805 * The control element is supposed to have the private_value field
2806 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2808 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2809 struct snd_ctl_elem_info *uinfo)
2811 int chs = get_amp_channels(kcontrol);
2813 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2814 uinfo->count = chs == 3 ? 2 : 1;
2815 uinfo->value.integer.min = 0;
2816 uinfo->value.integer.max = 1;
2819 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2822 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2824 * The control element is supposed to have the private_value field
2825 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2827 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2828 struct snd_ctl_elem_value *ucontrol)
2830 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2831 hda_nid_t nid = get_amp_nid(kcontrol);
2832 int chs = get_amp_channels(kcontrol);
2833 int dir = get_amp_direction(kcontrol);
2834 int idx = get_amp_index(kcontrol);
2835 long *valp = ucontrol->value.integer.value;
2838 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2839 HDA_AMP_MUTE) ? 0 : 1;
2841 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2842 HDA_AMP_MUTE) ? 0 : 1;
2845 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2848 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2850 * The control element is supposed to have the private_value field
2851 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2853 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2854 struct snd_ctl_elem_value *ucontrol)
2856 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2857 hda_nid_t nid = get_amp_nid(kcontrol);
2858 int chs = get_amp_channels(kcontrol);
2859 int dir = get_amp_direction(kcontrol);
2860 int idx = get_amp_index(kcontrol);
2861 long *valp = ucontrol->value.integer.value;
2864 snd_hda_power_up(codec);
2866 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2868 *valp ? 0 : HDA_AMP_MUTE);
2872 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2874 *valp ? 0 : HDA_AMP_MUTE);
2875 hda_call_check_power_status(codec, nid);
2876 snd_hda_power_down(codec);
2879 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2882 * bound volume controls
2884 * bind multiple volumes (# indices, from 0)
2887 #define AMP_VAL_IDX_SHIFT 19
2888 #define AMP_VAL_IDX_MASK (0x0f<<19)
2891 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2893 * The control element is supposed to have the private_value field
2894 * set up via HDA_BIND_MUTE*() macros.
2896 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2897 struct snd_ctl_elem_value *ucontrol)
2899 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2903 mutex_lock(&codec->control_mutex);
2904 pval = kcontrol->private_value;
2905 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2906 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2907 kcontrol->private_value = pval;
2908 mutex_unlock(&codec->control_mutex);
2911 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2914 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2916 * The control element is supposed to have the private_value field
2917 * set up via HDA_BIND_MUTE*() macros.
2919 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2920 struct snd_ctl_elem_value *ucontrol)
2922 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2924 int i, indices, err = 0, change = 0;
2926 mutex_lock(&codec->control_mutex);
2927 pval = kcontrol->private_value;
2928 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2929 for (i = 0; i < indices; i++) {
2930 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2931 (i << AMP_VAL_IDX_SHIFT);
2932 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2937 kcontrol->private_value = pval;
2938 mutex_unlock(&codec->control_mutex);
2939 return err < 0 ? err : change;
2941 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2944 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2946 * The control element is supposed to have the private_value field
2947 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2949 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2950 struct snd_ctl_elem_info *uinfo)
2952 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2953 struct hda_bind_ctls *c;
2956 mutex_lock(&codec->control_mutex);
2957 c = (struct hda_bind_ctls *)kcontrol->private_value;
2958 kcontrol->private_value = *c->values;
2959 err = c->ops->info(kcontrol, uinfo);
2960 kcontrol->private_value = (long)c;
2961 mutex_unlock(&codec->control_mutex);
2964 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2967 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2969 * The control element is supposed to have the private_value field
2970 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2972 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2973 struct snd_ctl_elem_value *ucontrol)
2975 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2976 struct hda_bind_ctls *c;
2979 mutex_lock(&codec->control_mutex);
2980 c = (struct hda_bind_ctls *)kcontrol->private_value;
2981 kcontrol->private_value = *c->values;
2982 err = c->ops->get(kcontrol, ucontrol);
2983 kcontrol->private_value = (long)c;
2984 mutex_unlock(&codec->control_mutex);
2987 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2990 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2992 * The control element is supposed to have the private_value field
2993 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2995 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2996 struct snd_ctl_elem_value *ucontrol)
2998 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2999 struct hda_bind_ctls *c;
3000 unsigned long *vals;
3001 int err = 0, change = 0;
3003 mutex_lock(&codec->control_mutex);
3004 c = (struct hda_bind_ctls *)kcontrol->private_value;
3005 for (vals = c->values; *vals; vals++) {
3006 kcontrol->private_value = *vals;
3007 err = c->ops->put(kcontrol, ucontrol);
3012 kcontrol->private_value = (long)c;
3013 mutex_unlock(&codec->control_mutex);
3014 return err < 0 ? err : change;
3016 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
3019 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3021 * The control element is supposed to have the private_value field
3022 * set up via HDA_BIND_VOL() macro.
3024 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3025 unsigned int size, unsigned int __user *tlv)
3027 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3028 struct hda_bind_ctls *c;
3031 mutex_lock(&codec->control_mutex);
3032 c = (struct hda_bind_ctls *)kcontrol->private_value;
3033 kcontrol->private_value = *c->values;
3034 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3035 kcontrol->private_value = (long)c;
3036 mutex_unlock(&codec->control_mutex);
3039 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
3041 struct hda_ctl_ops snd_hda_bind_vol = {
3042 .info = snd_hda_mixer_amp_volume_info,
3043 .get = snd_hda_mixer_amp_volume_get,
3044 .put = snd_hda_mixer_amp_volume_put,
3045 .tlv = snd_hda_mixer_amp_tlv
3047 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
3049 struct hda_ctl_ops snd_hda_bind_sw = {
3050 .info = snd_hda_mixer_amp_switch_info,
3051 .get = snd_hda_mixer_amp_switch_get,
3052 .put = snd_hda_mixer_amp_switch_put,
3053 .tlv = snd_hda_mixer_amp_tlv
3055 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
3058 * SPDIF out controls
3061 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3062 struct snd_ctl_elem_info *uinfo)
3064 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3069 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3070 struct snd_ctl_elem_value *ucontrol)
3072 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3073 IEC958_AES0_NONAUDIO |
3074 IEC958_AES0_CON_EMPHASIS_5015 |
3075 IEC958_AES0_CON_NOT_COPYRIGHT;
3076 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3077 IEC958_AES1_CON_ORIGINAL;
3081 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3082 struct snd_ctl_elem_value *ucontrol)
3084 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3085 IEC958_AES0_NONAUDIO |
3086 IEC958_AES0_PRO_EMPHASIS_5015;
3090 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3091 struct snd_ctl_elem_value *ucontrol)
3093 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3094 int idx = kcontrol->private_value;
3095 struct hda_spdif_out *spdif;
3097 mutex_lock(&codec->spdif_mutex);
3098 spdif = snd_array_elem(&codec->spdif_out, idx);
3099 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3100 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3101 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3102 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3103 mutex_unlock(&codec->spdif_mutex);
3108 /* convert from SPDIF status bits to HDA SPDIF bits
3109 * bit 0 (DigEn) is always set zero (to be filled later)
3111 static unsigned short convert_from_spdif_status(unsigned int sbits)
3113 unsigned short val = 0;
3115 if (sbits & IEC958_AES0_PROFESSIONAL)
3116 val |= AC_DIG1_PROFESSIONAL;
3117 if (sbits & IEC958_AES0_NONAUDIO)
3118 val |= AC_DIG1_NONAUDIO;
3119 if (sbits & IEC958_AES0_PROFESSIONAL) {
3120 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3121 IEC958_AES0_PRO_EMPHASIS_5015)
3122 val |= AC_DIG1_EMPHASIS;
3124 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3125 IEC958_AES0_CON_EMPHASIS_5015)
3126 val |= AC_DIG1_EMPHASIS;
3127 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3128 val |= AC_DIG1_COPYRIGHT;
3129 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3130 val |= AC_DIG1_LEVEL;
3131 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3136 /* convert to SPDIF status bits from HDA SPDIF bits
3138 static unsigned int convert_to_spdif_status(unsigned short val)
3140 unsigned int sbits = 0;
3142 if (val & AC_DIG1_NONAUDIO)
3143 sbits |= IEC958_AES0_NONAUDIO;
3144 if (val & AC_DIG1_PROFESSIONAL)
3145 sbits |= IEC958_AES0_PROFESSIONAL;
3146 if (sbits & IEC958_AES0_PROFESSIONAL) {
3147 if (sbits & AC_DIG1_EMPHASIS)
3148 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3150 if (val & AC_DIG1_EMPHASIS)
3151 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3152 if (!(val & AC_DIG1_COPYRIGHT))
3153 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3154 if (val & AC_DIG1_LEVEL)
3155 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3156 sbits |= val & (0x7f << 8);
3161 /* set digital convert verbs both for the given NID and its slaves */
3162 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3167 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3168 d = codec->slave_dig_outs;
3172 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3175 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3179 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3181 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3184 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3185 struct snd_ctl_elem_value *ucontrol)
3187 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3188 int idx = kcontrol->private_value;
3189 struct hda_spdif_out *spdif;
3194 mutex_lock(&codec->spdif_mutex);
3195 spdif = snd_array_elem(&codec->spdif_out, idx);
3197 spdif->status = ucontrol->value.iec958.status[0] |
3198 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3199 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3200 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3201 val = convert_from_spdif_status(spdif->status);
3202 val |= spdif->ctls & 1;
3203 change = spdif->ctls != val;
3205 if (change && nid != (u16)-1)
3206 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3207 mutex_unlock(&codec->spdif_mutex);
3211 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3213 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3214 struct snd_ctl_elem_value *ucontrol)
3216 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3217 int idx = kcontrol->private_value;
3218 struct hda_spdif_out *spdif;
3220 mutex_lock(&codec->spdif_mutex);
3221 spdif = snd_array_elem(&codec->spdif_out, idx);
3222 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3223 mutex_unlock(&codec->spdif_mutex);
3227 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3230 set_dig_out_convert(codec, nid, dig1, dig2);
3231 /* unmute amp switch (if any) */
3232 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3233 (dig1 & AC_DIG1_ENABLE))
3234 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3238 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3239 struct snd_ctl_elem_value *ucontrol)
3241 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3242 int idx = kcontrol->private_value;
3243 struct hda_spdif_out *spdif;
3248 mutex_lock(&codec->spdif_mutex);
3249 spdif = snd_array_elem(&codec->spdif_out, idx);
3251 val = spdif->ctls & ~AC_DIG1_ENABLE;
3252 if (ucontrol->value.integer.value[0])
3253 val |= AC_DIG1_ENABLE;
3254 change = spdif->ctls != val;
3256 if (change && nid != (u16)-1)
3257 set_spdif_ctls(codec, nid, val & 0xff, -1);
3258 mutex_unlock(&codec->spdif_mutex);
3262 static struct snd_kcontrol_new dig_mixes[] = {
3264 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3265 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3266 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3267 .info = snd_hda_spdif_mask_info,
3268 .get = snd_hda_spdif_cmask_get,
3271 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3272 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3273 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3274 .info = snd_hda_spdif_mask_info,
3275 .get = snd_hda_spdif_pmask_get,
3278 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3279 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3280 .info = snd_hda_spdif_mask_info,
3281 .get = snd_hda_spdif_default_get,
3282 .put = snd_hda_spdif_default_put,
3285 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3286 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3287 .info = snd_hda_spdif_out_switch_info,
3288 .get = snd_hda_spdif_out_switch_get,
3289 .put = snd_hda_spdif_out_switch_put,
3295 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3296 * @codec: the HDA codec
3297 * @associated_nid: NID that new ctls associated with
3298 * @cvt_nid: converter NID
3299 * @type: HDA_PCM_TYPE_*
3300 * Creates controls related with the digital output.
3301 * Called from each patch supporting the digital out.
3303 * Returns 0 if successful, or a negative error code.
3305 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3306 hda_nid_t associated_nid,
3311 struct snd_kcontrol *kctl;
3312 struct snd_kcontrol_new *dig_mix;
3314 const int spdif_index = 16;
3315 struct hda_spdif_out *spdif;
3316 struct hda_bus *bus = codec->bus;
3318 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3319 type == HDA_PCM_TYPE_SPDIF) {
3321 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3322 type == HDA_PCM_TYPE_HDMI) {
3323 /* suppose a single SPDIF device */
3324 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3325 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3328 kctl->id.index = spdif_index;
3330 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3332 if (!bus->primary_dig_out_type)
3333 bus->primary_dig_out_type = type;
3335 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
3337 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3340 spdif = snd_array_new(&codec->spdif_out);
3343 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3344 kctl = snd_ctl_new1(dig_mix, codec);
3347 kctl->id.index = idx;
3348 kctl->private_value = codec->spdif_out.used - 1;
3349 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3353 spdif->nid = cvt_nid;
3354 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3355 AC_VERB_GET_DIGI_CONVERT_1, 0);
3356 spdif->status = convert_to_spdif_status(spdif->ctls);
3359 EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
3361 /* get the hda_spdif_out entry from the given NID
3362 * call within spdif_mutex lock
3364 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3368 for (i = 0; i < codec->spdif_out.used; i++) {
3369 struct hda_spdif_out *spdif =
3370 snd_array_elem(&codec->spdif_out, i);
3371 if (spdif->nid == nid)
3376 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3378 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3380 struct hda_spdif_out *spdif;
3382 mutex_lock(&codec->spdif_mutex);
3383 spdif = snd_array_elem(&codec->spdif_out, idx);
3384 spdif->nid = (u16)-1;
3385 mutex_unlock(&codec->spdif_mutex);
3387 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3389 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3391 struct hda_spdif_out *spdif;
3394 mutex_lock(&codec->spdif_mutex);
3395 spdif = snd_array_elem(&codec->spdif_out, idx);
3396 if (spdif->nid != nid) {
3399 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3401 mutex_unlock(&codec->spdif_mutex);
3403 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3406 * SPDIF sharing with analog output
3408 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3409 struct snd_ctl_elem_value *ucontrol)
3411 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3412 ucontrol->value.integer.value[0] = mout->share_spdif;
3416 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3417 struct snd_ctl_elem_value *ucontrol)
3419 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3420 mout->share_spdif = !!ucontrol->value.integer.value[0];
3424 static struct snd_kcontrol_new spdif_share_sw = {
3425 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3426 .name = "IEC958 Default PCM Playback Switch",
3427 .info = snd_ctl_boolean_mono_info,
3428 .get = spdif_share_sw_get,
3429 .put = spdif_share_sw_put,
3433 * snd_hda_create_spdif_share_sw - create Default PCM switch
3434 * @codec: the HDA codec
3435 * @mout: multi-out instance
3437 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3438 struct hda_multi_out *mout)
3440 struct snd_kcontrol *kctl;
3442 if (!mout->dig_out_nid)
3445 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3448 /* ATTENTION: here mout is passed as private_data, instead of codec */
3449 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3451 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3457 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3459 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3460 struct snd_ctl_elem_value *ucontrol)
3462 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3464 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3468 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3469 struct snd_ctl_elem_value *ucontrol)
3471 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3472 hda_nid_t nid = kcontrol->private_value;
3473 unsigned int val = !!ucontrol->value.integer.value[0];
3476 mutex_lock(&codec->spdif_mutex);
3477 change = codec->spdif_in_enable != val;
3479 codec->spdif_in_enable = val;
3480 snd_hda_codec_write_cache(codec, nid, 0,
3481 AC_VERB_SET_DIGI_CONVERT_1, val);
3483 mutex_unlock(&codec->spdif_mutex);
3487 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3488 struct snd_ctl_elem_value *ucontrol)
3490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3491 hda_nid_t nid = kcontrol->private_value;
3495 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3496 sbits = convert_to_spdif_status(val);
3497 ucontrol->value.iec958.status[0] = sbits;
3498 ucontrol->value.iec958.status[1] = sbits >> 8;
3499 ucontrol->value.iec958.status[2] = sbits >> 16;
3500 ucontrol->value.iec958.status[3] = sbits >> 24;
3504 static struct snd_kcontrol_new dig_in_ctls[] = {
3506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3507 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3508 .info = snd_hda_spdif_in_switch_info,
3509 .get = snd_hda_spdif_in_switch_get,
3510 .put = snd_hda_spdif_in_switch_put,
3513 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3515 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3516 .info = snd_hda_spdif_mask_info,
3517 .get = snd_hda_spdif_in_status_get,
3523 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3524 * @codec: the HDA codec
3525 * @nid: audio in widget NID
3527 * Creates controls related with the SPDIF input.
3528 * Called from each patch supporting the SPDIF in.
3530 * Returns 0 if successful, or a negative error code.
3532 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3535 struct snd_kcontrol *kctl;
3536 struct snd_kcontrol_new *dig_mix;
3539 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3541 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3544 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3545 kctl = snd_ctl_new1(dig_mix, codec);
3548 kctl->private_value = nid;
3549 err = snd_hda_ctl_add(codec, nid, kctl);
3553 codec->spdif_in_enable =
3554 snd_hda_codec_read(codec, nid, 0,
3555 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3559 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3565 /* build a 31bit cache key with the widget id and the command parameter */
3566 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3567 #define get_cmd_cache_nid(key) ((key) & 0xff)
3568 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3571 * snd_hda_codec_write_cache - send a single command with caching
3572 * @codec: the HDA codec
3573 * @nid: NID to send the command
3574 * @direct: direct flag
3575 * @verb: the verb to send
3576 * @parm: the parameter for the verb
3578 * Send a single command without waiting for response.
3580 * Returns 0 if successful, or a negative error code.
3582 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3583 int direct, unsigned int verb, unsigned int parm)
3586 struct hda_cache_head *c;
3588 unsigned int cache_only;
3590 cache_only = codec->cached_write;
3592 err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3597 /* parm may contain the verb stuff for get/set amp */
3598 verb = verb | (parm >> 8);
3600 key = build_cmd_cache_key(nid, verb);
3601 mutex_lock(&codec->bus->cmd_mutex);
3602 c = get_alloc_hash(&codec->cmd_cache, key);
3605 c->dirty = cache_only;
3607 mutex_unlock(&codec->bus->cmd_mutex);
3610 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3613 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3614 * @codec: the HDA codec
3615 * @nid: NID to send the command
3616 * @direct: direct flag
3617 * @verb: the verb to send
3618 * @parm: the parameter for the verb
3620 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3621 * command if the parameter is already identical with the cached value.
3622 * If not, it sends the command and refreshes the cache.
3624 * Returns 0 if successful, or a negative error code.
3626 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3627 int direct, unsigned int verb, unsigned int parm)
3629 struct hda_cache_head *c;
3632 /* parm may contain the verb stuff for get/set amp */
3633 verb = verb | (parm >> 8);
3635 key = build_cmd_cache_key(nid, verb);
3636 mutex_lock(&codec->bus->cmd_mutex);
3637 c = get_hash(&codec->cmd_cache, key);
3638 if (c && c->val == parm) {
3639 mutex_unlock(&codec->bus->cmd_mutex);
3642 mutex_unlock(&codec->bus->cmd_mutex);
3643 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3645 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3648 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3649 * @codec: HD-audio codec
3651 * Execute all verbs recorded in the command caches to resume.
3653 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3657 mutex_lock(&codec->hash_mutex);
3658 codec->cached_write = 0;
3659 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3660 struct hda_cache_head *buffer;
3663 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3670 mutex_unlock(&codec->hash_mutex);
3671 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3672 get_cmd_cache_cmd(key), buffer->val);
3673 mutex_lock(&codec->hash_mutex);
3675 mutex_unlock(&codec->hash_mutex);
3677 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3680 * snd_hda_sequence_write_cache - sequence writes with caching
3681 * @codec: the HDA codec
3682 * @seq: VERB array to send
3684 * Send the commands sequentially from the given array.
3685 * Thte commands are recorded on cache for power-save and resume.
3686 * The array must be terminated with NID=0.
3688 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3689 const struct hda_verb *seq)
3691 for (; seq->nid; seq++)
3692 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3695 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3698 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3699 * @codec: HD-audio codec
3701 void snd_hda_codec_flush_cache(struct hda_codec *codec)
3703 snd_hda_codec_resume_amp(codec);
3704 snd_hda_codec_resume_cache(codec);
3706 EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache);
3708 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3709 unsigned int power_state)
3711 hda_nid_t nid = codec->start_nid;
3714 for (i = 0; i < codec->num_nodes; i++, nid++) {
3715 unsigned int wcaps = get_wcaps(codec, nid);
3716 unsigned int state = power_state;
3717 if (!(wcaps & AC_WCAP_POWER))
3719 if (codec->power_filter) {
3720 state = codec->power_filter(codec, nid, power_state);
3721 if (state != power_state && power_state == AC_PWRST_D3)
3724 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3728 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3731 * supported power states check
3733 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3734 unsigned int power_state)
3736 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3740 if (sup & power_state)
3747 * wait until the state is reached, returns the current state
3749 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3751 unsigned int power_state)
3753 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3754 unsigned int state, actual_state;
3757 state = snd_hda_codec_read(codec, fg, 0,
3758 AC_VERB_GET_POWER_STATE, 0);
3759 if (state & AC_PWRST_ERROR)
3761 actual_state = (state >> 4) & 0x0f;
3762 if (actual_state == power_state)
3764 if (time_after_eq(jiffies, end_time))
3766 /* wait until the codec reachs to the target state */
3772 /* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
3773 static unsigned int default_power_filter(struct hda_codec *codec, hda_nid_t nid,
3774 unsigned int power_state)
3776 if (power_state == AC_PWRST_D3 &&
3777 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3778 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3779 int eapd = snd_hda_codec_read(codec, nid, 0,
3780 AC_VERB_GET_EAPD_BTLENABLE, 0);
3788 * set power state of the codec, and return the power state
3790 static unsigned int hda_set_power_state(struct hda_codec *codec,
3791 unsigned int power_state)
3793 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3797 /* this delay seems necessary to avoid click noise at power-down */
3798 if (power_state == AC_PWRST_D3) {
3799 /* transition time less than 10ms for power down */
3800 msleep(codec->epss ? 10 : 100);
3803 /* repeat power states setting at most 10 times*/
3804 for (count = 0; count < 10; count++) {
3805 if (codec->patch_ops.set_power_state)
3806 codec->patch_ops.set_power_state(codec, fg,
3809 snd_hda_codec_read(codec, fg, 0,
3810 AC_VERB_SET_POWER_STATE,
3812 snd_hda_codec_set_power_to_all(codec, fg, power_state);
3814 state = hda_sync_power_state(codec, fg, power_state);
3815 if (!(state & AC_PWRST_ERROR))
3822 /* sync power states of all widgets;
3823 * this is called at the end of codec parsing
3825 static void sync_power_up_states(struct hda_codec *codec)
3827 hda_nid_t nid = codec->start_nid;
3830 /* don't care if no or standard filter is used */
3831 if (!codec->power_filter || codec->power_filter == default_power_filter)
3834 for (i = 0; i < codec->num_nodes; i++, nid++) {
3835 unsigned int wcaps = get_wcaps(codec, nid);
3836 unsigned int target;
3837 if (!(wcaps & AC_WCAP_POWER))
3839 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3840 if (target == AC_PWRST_D0)
3842 if (!snd_hda_check_power_state(codec, nid, target))
3843 snd_hda_codec_write(codec, nid, 0,
3844 AC_VERB_SET_POWER_STATE, target);
3848 #ifdef CONFIG_SND_HDA_HWDEP
3849 /* execute additional init verbs */
3850 static void hda_exec_init_verbs(struct hda_codec *codec)
3852 if (codec->init_verbs.list)
3853 snd_hda_sequence_write(codec, codec->init_verbs.list);
3856 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3861 * call suspend and power-down; used both from PM and power-save
3862 * this function returns the power state in the end
3864 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
3870 if (codec->patch_ops.suspend)
3871 codec->patch_ops.suspend(codec);
3872 hda_cleanup_all_streams(codec);
3873 state = hda_set_power_state(codec, AC_PWRST_D3);
3874 /* Cancel delayed work if we aren't currently running from it. */
3876 cancel_delayed_work_sync(&codec->power_work);
3877 spin_lock(&codec->power_lock);
3878 snd_hda_update_power_acct(codec);
3879 trace_hda_power_down(codec);
3880 codec->power_on = 0;
3881 codec->power_transition = 0;
3882 codec->power_jiffies = jiffies;
3883 spin_unlock(&codec->power_lock);
3888 /* mark all entries of cmd and amp caches dirty */
3889 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3892 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3893 struct hda_cache_head *cmd;
3894 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3897 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3898 struct hda_amp_info *amp;
3899 amp = snd_array_elem(&codec->amp_cache.buf, i);
3900 amp->head.dirty = 1;
3905 * kick up codec; used both from PM and power-save
3907 static void hda_call_codec_resume(struct hda_codec *codec)
3911 hda_mark_cmd_cache_dirty(codec);
3913 /* set as if powered on for avoiding re-entering the resume
3914 * in the resume / power-save sequence
3916 hda_keep_power_on(codec);
3917 hda_set_power_state(codec, AC_PWRST_D0);
3918 restore_shutup_pins(codec);
3919 hda_exec_init_verbs(codec);
3920 snd_hda_jack_set_dirty_all(codec);
3921 if (codec->patch_ops.resume)
3922 codec->patch_ops.resume(codec);
3924 if (codec->patch_ops.init)
3925 codec->patch_ops.init(codec);
3926 snd_hda_codec_resume_amp(codec);
3927 snd_hda_codec_resume_cache(codec);
3930 if (codec->jackpoll_interval)
3931 hda_jackpoll_work(&codec->jackpoll_work.work);
3933 snd_hda_jack_report_sync(codec);
3936 snd_hda_power_down(codec); /* flag down before returning */
3938 #endif /* CONFIG_PM */
3942 * snd_hda_build_controls - build mixer controls
3945 * Creates mixer controls for each codec included in the bus.
3947 * Returns 0 if successful, otherwise a negative error code.
3949 int snd_hda_build_controls(struct hda_bus *bus)
3951 struct hda_codec *codec;
3953 list_for_each_entry(codec, &bus->codec_list, list) {
3954 int err = snd_hda_codec_build_controls(codec);
3956 printk(KERN_ERR "hda_codec: cannot build controls "
3957 "for #%d (error %d)\n", codec->addr, err);
3958 err = snd_hda_codec_reset(codec);
3961 "hda_codec: cannot revert codec\n");
3968 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3971 * add standard channel maps if not specified
3973 static int add_std_chmaps(struct hda_codec *codec)
3977 for (i = 0; i < codec->num_pcms; i++) {
3978 for (str = 0; str < 2; str++) {
3979 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
3980 struct hda_pcm_stream *hinfo =
3981 &codec->pcm_info[i].stream[str];
3982 struct snd_pcm_chmap *chmap;
3983 const struct snd_pcm_chmap_elem *elem;
3985 if (codec->pcm_info[i].own_chmap)
3987 if (!pcm || !hinfo->substreams)
3989 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
3990 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
3991 hinfo->channels_max,
3995 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4001 /* default channel maps for 2.1 speakers;
4002 * since HD-audio supports only stereo, odd number channels are omitted
4004 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4006 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4008 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4009 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4012 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4014 int snd_hda_codec_build_controls(struct hda_codec *codec)
4017 hda_exec_init_verbs(codec);
4018 /* continue to initialize... */
4019 if (codec->patch_ops.init)
4020 err = codec->patch_ops.init(codec);
4021 if (!err && codec->patch_ops.build_controls)
4022 err = codec->patch_ops.build_controls(codec);
4026 /* we create chmaps here instead of build_pcms */
4027 err = add_std_chmaps(codec);
4031 if (codec->jackpoll_interval)
4032 hda_jackpoll_work(&codec->jackpoll_work.work);
4034 snd_hda_jack_report_sync(codec); /* call at the last init point */
4035 sync_power_up_states(codec);
4042 struct hda_rate_tbl {
4044 unsigned int alsa_bits;
4045 unsigned int hda_fmt;
4048 /* rate = base * mult / div */
4049 #define HDA_RATE(base, mult, div) \
4050 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4051 (((div) - 1) << AC_FMT_DIV_SHIFT))
4053 static struct hda_rate_tbl rate_bits[] = {
4054 /* rate in Hz, ALSA rate bitmask, HDA format value */
4056 /* autodetected value used in snd_hda_query_supported_pcm */
4057 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4058 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4059 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4060 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4061 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4062 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4063 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4064 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4065 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4066 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4067 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
4068 #define AC_PAR_PCM_RATE_BITS 11
4069 /* up to bits 10, 384kHZ isn't supported properly */
4071 /* not autodetected value */
4072 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
4074 { 0 } /* terminator */
4078 * snd_hda_calc_stream_format - calculate format bitset
4079 * @rate: the sample rate
4080 * @channels: the number of channels
4081 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4082 * @maxbps: the max. bps
4084 * Calculate the format bitset from the given rate, channels and th PCM format.
4086 * Return zero if invalid.
4088 unsigned int snd_hda_calc_stream_format(unsigned int rate,
4089 unsigned int channels,
4090 unsigned int format,
4091 unsigned int maxbps,
4092 unsigned short spdif_ctls)
4095 unsigned int val = 0;
4097 for (i = 0; rate_bits[i].hz; i++)
4098 if (rate_bits[i].hz == rate) {
4099 val = rate_bits[i].hda_fmt;
4102 if (!rate_bits[i].hz) {
4103 snd_printdd("invalid rate %d\n", rate);
4107 if (channels == 0 || channels > 8) {
4108 snd_printdd("invalid channels %d\n", channels);
4111 val |= channels - 1;
4113 switch (snd_pcm_format_width(format)) {
4115 val |= AC_FMT_BITS_8;
4118 val |= AC_FMT_BITS_16;
4123 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
4124 val |= AC_FMT_BITS_32;
4125 else if (maxbps >= 24)
4126 val |= AC_FMT_BITS_24;
4128 val |= AC_FMT_BITS_20;
4131 snd_printdd("invalid format width %d\n",
4132 snd_pcm_format_width(format));
4136 if (spdif_ctls & AC_DIG1_NONAUDIO)
4137 val |= AC_FMT_TYPE_NON_PCM;
4141 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
4143 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4146 unsigned int val = 0;
4147 if (nid != codec->afg &&
4148 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4149 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4150 if (!val || val == -1)
4151 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4152 if (!val || val == -1)
4157 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4159 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4163 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4166 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4167 if (!streams || streams == -1)
4168 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4169 if (!streams || streams == -1)
4174 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4176 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4181 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4182 * @codec: the HDA codec
4183 * @nid: NID to query
4184 * @ratesp: the pointer to store the detected rate bitflags
4185 * @formatsp: the pointer to store the detected formats
4186 * @bpsp: the pointer to store the detected format widths
4188 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4189 * or @bsps argument is ignored.
4191 * Returns 0 if successful, otherwise a negative error code.
4193 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4194 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4196 unsigned int i, val, wcaps;
4198 wcaps = get_wcaps(codec, nid);
4199 val = query_pcm_param(codec, nid);
4203 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4205 rates |= rate_bits[i].alsa_bits;
4208 snd_printk(KERN_ERR "hda_codec: rates == 0 "
4209 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4211 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4217 if (formatsp || bpsp) {
4219 unsigned int streams, bps;
4221 streams = query_stream_param(codec, nid);
4226 if (streams & AC_SUPFMT_PCM) {
4227 if (val & AC_SUPPCM_BITS_8) {
4228 formats |= SNDRV_PCM_FMTBIT_U8;
4231 if (val & AC_SUPPCM_BITS_16) {
4232 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4235 if (wcaps & AC_WCAP_DIGITAL) {
4236 if (val & AC_SUPPCM_BITS_32)
4237 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4238 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4239 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4240 if (val & AC_SUPPCM_BITS_24)
4242 else if (val & AC_SUPPCM_BITS_20)
4244 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4245 AC_SUPPCM_BITS_32)) {
4246 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4247 if (val & AC_SUPPCM_BITS_32)
4249 else if (val & AC_SUPPCM_BITS_24)
4251 else if (val & AC_SUPPCM_BITS_20)
4255 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4256 if (streams & AC_SUPFMT_FLOAT32) {
4257 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4262 if (streams == AC_SUPFMT_AC3) {
4263 /* should be exclusive */
4264 /* temporary hack: we have still no proper support
4265 * for the direct AC3 stream...
4267 formats |= SNDRV_PCM_FMTBIT_U8;
4271 snd_printk(KERN_ERR "hda_codec: formats == 0 "
4272 "(nid=0x%x, val=0x%x, ovrd=%i, "
4275 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4280 *formatsp = formats;
4287 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
4290 * snd_hda_is_supported_format - Check the validity of the format
4291 * @codec: HD-audio codec
4292 * @nid: NID to check
4293 * @format: the HD-audio format value to check
4295 * Check whether the given node supports the format value.
4297 * Returns 1 if supported, 0 if not.
4299 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4300 unsigned int format)
4303 unsigned int val = 0, rate, stream;
4305 val = query_pcm_param(codec, nid);
4309 rate = format & 0xff00;
4310 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4311 if (rate_bits[i].hda_fmt == rate) {
4316 if (i >= AC_PAR_PCM_RATE_BITS)
4319 stream = query_stream_param(codec, nid);
4323 if (stream & AC_SUPFMT_PCM) {
4324 switch (format & 0xf0) {
4326 if (!(val & AC_SUPPCM_BITS_8))
4330 if (!(val & AC_SUPPCM_BITS_16))
4334 if (!(val & AC_SUPPCM_BITS_20))
4338 if (!(val & AC_SUPPCM_BITS_24))
4342 if (!(val & AC_SUPPCM_BITS_32))
4349 /* FIXME: check for float32 and AC3? */
4354 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
4359 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4360 struct hda_codec *codec,
4361 struct snd_pcm_substream *substream)
4366 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4367 struct hda_codec *codec,
4368 unsigned int stream_tag,
4369 unsigned int format,
4370 struct snd_pcm_substream *substream)
4372 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4376 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4377 struct hda_codec *codec,
4378 struct snd_pcm_substream *substream)
4380 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4384 static int set_pcm_default_values(struct hda_codec *codec,
4385 struct hda_pcm_stream *info)
4389 /* query support PCM information from the given NID */
4390 if (info->nid && (!info->rates || !info->formats)) {
4391 err = snd_hda_query_supported_pcm(codec, info->nid,
4392 info->rates ? NULL : &info->rates,
4393 info->formats ? NULL : &info->formats,
4394 info->maxbps ? NULL : &info->maxbps);
4398 if (info->ops.open == NULL)
4399 info->ops.open = hda_pcm_default_open_close;
4400 if (info->ops.close == NULL)
4401 info->ops.close = hda_pcm_default_open_close;
4402 if (info->ops.prepare == NULL) {
4403 if (snd_BUG_ON(!info->nid))
4405 info->ops.prepare = hda_pcm_default_prepare;
4407 if (info->ops.cleanup == NULL) {
4408 if (snd_BUG_ON(!info->nid))
4410 info->ops.cleanup = hda_pcm_default_cleanup;
4416 * codec prepare/cleanup entries
4418 int snd_hda_codec_prepare(struct hda_codec *codec,
4419 struct hda_pcm_stream *hinfo,
4420 unsigned int stream,
4421 unsigned int format,
4422 struct snd_pcm_substream *substream)
4425 mutex_lock(&codec->bus->prepare_mutex);
4426 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4428 purify_inactive_streams(codec);
4429 mutex_unlock(&codec->bus->prepare_mutex);
4432 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4434 void snd_hda_codec_cleanup(struct hda_codec *codec,
4435 struct hda_pcm_stream *hinfo,
4436 struct snd_pcm_substream *substream)
4438 mutex_lock(&codec->bus->prepare_mutex);
4439 hinfo->ops.cleanup(hinfo, codec, substream);
4440 mutex_unlock(&codec->bus->prepare_mutex);
4442 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4445 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4446 "Audio", "SPDIF", "HDMI", "Modem"
4450 * get the empty PCM device number to assign
4452 * note the max device number is limited by HDA_MAX_PCMS, currently 10
4454 static int get_empty_pcm_device(struct hda_bus *bus, int type)
4456 /* audio device indices; not linear to keep compatibility */
4457 static int audio_idx[HDA_PCM_NTYPES][5] = {
4458 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4459 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4460 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4461 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4465 if (type >= HDA_PCM_NTYPES) {
4466 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4470 for (i = 0; audio_idx[type][i] >= 0 ; i++)
4471 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4472 return audio_idx[type][i];
4474 /* non-fixed slots starting from 10 */
4475 for (i = 10; i < 32; i++) {
4476 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4480 snd_printk(KERN_WARNING "Too many %s devices\n",
4481 snd_hda_pcm_type_name[type]);
4486 * attach a new PCM stream
4488 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4490 struct hda_bus *bus = codec->bus;
4491 struct hda_pcm_stream *info;
4494 if (snd_BUG_ON(!pcm->name))
4496 for (stream = 0; stream < 2; stream++) {
4497 info = &pcm->stream[stream];
4498 if (info->substreams) {
4499 err = set_pcm_default_values(codec, info);
4504 return bus->ops.attach_pcm(bus, codec, pcm);
4507 /* assign all PCMs of the given codec */
4508 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4513 if (!codec->num_pcms) {
4514 if (!codec->patch_ops.build_pcms)
4516 err = codec->patch_ops.build_pcms(codec);
4518 printk(KERN_ERR "hda_codec: cannot build PCMs"
4519 "for #%d (error %d)\n", codec->addr, err);
4520 err = snd_hda_codec_reset(codec);
4523 "hda_codec: cannot revert codec\n");
4528 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4529 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4532 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4533 continue; /* no substreams assigned */
4536 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4538 continue; /* no fatal error */
4540 err = snd_hda_attach_pcm(codec, cpcm);
4542 printk(KERN_ERR "hda_codec: cannot attach "
4543 "PCM stream %d for codec #%d\n",
4545 continue; /* no fatal error */
4553 * snd_hda_build_pcms - build PCM information
4556 * Create PCM information for each codec included in the bus.
4558 * The build_pcms codec patch is requested to set up codec->num_pcms and
4559 * codec->pcm_info properly. The array is referred by the top-level driver
4560 * to create its PCM instances.
4561 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4564 * At least, substreams, channels_min and channels_max must be filled for
4565 * each stream. substreams = 0 indicates that the stream doesn't exist.
4566 * When rates and/or formats are zero, the supported values are queried
4567 * from the given nid. The nid is used also by the default ops.prepare
4568 * and ops.cleanup callbacks.
4570 * The driver needs to call ops.open in its open callback. Similarly,
4571 * ops.close is supposed to be called in the close callback.
4572 * ops.prepare should be called in the prepare or hw_params callback
4573 * with the proper parameters for set up.
4574 * ops.cleanup should be called in hw_free for clean up of streams.
4576 * This function returns 0 if successful, or a negative error code.
4578 int snd_hda_build_pcms(struct hda_bus *bus)
4580 struct hda_codec *codec;
4582 list_for_each_entry(codec, &bus->codec_list, list) {
4583 int err = snd_hda_codec_build_pcms(codec);
4589 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4592 * snd_hda_check_board_config - compare the current codec with the config table
4593 * @codec: the HDA codec
4594 * @num_configs: number of config enums
4595 * @models: array of model name strings
4596 * @tbl: configuration table, terminated by null entries
4598 * Compares the modelname or PCI subsystem id of the current codec with the
4599 * given configuration table. If a matching entry is found, returns its
4600 * config value (supposed to be 0 or positive).
4602 * If no entries are matching, the function returns a negative value.
4604 int snd_hda_check_board_config(struct hda_codec *codec,
4605 int num_configs, const char * const *models,
4606 const struct snd_pci_quirk *tbl)
4608 if (codec->modelname && models) {
4610 for (i = 0; i < num_configs; i++) {
4612 !strcmp(codec->modelname, models[i])) {
4613 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4614 "selected\n", models[i]);
4620 if (!codec->bus->pci || !tbl)
4623 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4626 if (tbl->value >= 0 && tbl->value < num_configs) {
4627 #ifdef CONFIG_SND_DEBUG_VERBOSE
4629 const char *model = NULL;
4631 model = models[tbl->value];
4633 sprintf(tmp, "#%d", tbl->value);
4636 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4637 "for config %x:%x (%s)\n",
4638 model, tbl->subvendor, tbl->subdevice,
4639 (tbl->name ? tbl->name : "Unknown device"));
4645 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4648 * snd_hda_check_board_codec_sid_config - compare the current codec
4649 subsystem ID with the
4652 This is important for Gateway notebooks with SB450 HDA Audio
4653 where the vendor ID of the PCI device is:
4654 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4655 and the vendor/subvendor are found only at the codec.
4657 * @codec: the HDA codec
4658 * @num_configs: number of config enums
4659 * @models: array of model name strings
4660 * @tbl: configuration table, terminated by null entries
4662 * Compares the modelname or PCI subsystem id of the current codec with the
4663 * given configuration table. If a matching entry is found, returns its
4664 * config value (supposed to be 0 or positive).
4666 * If no entries are matching, the function returns a negative value.
4668 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4669 int num_configs, const char * const *models,
4670 const struct snd_pci_quirk *tbl)
4672 const struct snd_pci_quirk *q;
4674 /* Search for codec ID */
4675 for (q = tbl; q->subvendor; q++) {
4676 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4677 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4678 if ((codec->subsystem_id & mask) == id)
4687 if (tbl->value >= 0 && tbl->value < num_configs) {
4688 #ifdef CONFIG_SND_DEBUG_VERBOSE
4690 const char *model = NULL;
4692 model = models[tbl->value];
4694 sprintf(tmp, "#%d", tbl->value);
4697 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4698 "for config %x:%x (%s)\n",
4699 model, tbl->subvendor, tbl->subdevice,
4700 (tbl->name ? tbl->name : "Unknown device"));
4706 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4709 * snd_hda_add_new_ctls - create controls from the array
4710 * @codec: the HDA codec
4711 * @knew: the array of struct snd_kcontrol_new
4713 * This helper function creates and add new controls in the given array.
4714 * The array must be terminated with an empty entry as terminator.
4716 * Returns 0 if successful, or a negative error code.
4718 int snd_hda_add_new_ctls(struct hda_codec *codec,
4719 const struct snd_kcontrol_new *knew)
4723 for (; knew->name; knew++) {
4724 struct snd_kcontrol *kctl;
4725 int addr = 0, idx = 0;
4726 if (knew->iface == -1) /* skip this codec private value */
4729 kctl = snd_ctl_new1(knew, codec);
4733 kctl->id.device = addr;
4735 kctl->id.index = idx;
4736 err = snd_hda_ctl_add(codec, 0, kctl);
4739 /* try first with another device index corresponding to
4740 * the codec addr; if it still fails (or it's the
4741 * primary codec), then try another control index
4743 if (!addr && codec->addr)
4745 else if (!idx && !knew->index) {
4746 idx = find_empty_mixer_ctl_idx(codec,
4756 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4759 static void hda_power_work(struct work_struct *work)
4761 struct hda_codec *codec =
4762 container_of(work, struct hda_codec, power_work.work);
4763 struct hda_bus *bus = codec->bus;
4766 spin_lock(&codec->power_lock);
4767 if (codec->power_transition > 0) { /* during power-up sequence? */
4768 spin_unlock(&codec->power_lock);
4771 if (!codec->power_on || codec->power_count) {
4772 codec->power_transition = 0;
4773 spin_unlock(&codec->power_lock);
4776 spin_unlock(&codec->power_lock);
4778 state = hda_call_codec_suspend(codec, true);
4779 codec->pm_down_notified = 0;
4780 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
4781 codec->pm_down_notified = 1;
4782 hda_call_pm_notify(bus, false);
4786 static void hda_keep_power_on(struct hda_codec *codec)
4788 spin_lock(&codec->power_lock);
4789 codec->power_count++;
4790 codec->power_on = 1;
4791 codec->power_jiffies = jiffies;
4792 spin_unlock(&codec->power_lock);
4795 /* update the power on/off account with the current jiffies */
4796 void snd_hda_update_power_acct(struct hda_codec *codec)
4798 unsigned long delta = jiffies - codec->power_jiffies;
4799 if (codec->power_on)
4800 codec->power_on_acct += delta;
4802 codec->power_off_acct += delta;
4803 codec->power_jiffies += delta;
4806 /* Transition to powered up, if wait_power_down then wait for a pending
4807 * transition to D3 to complete. A pending D3 transition is indicated
4808 * with power_transition == -1. */
4809 /* call this with codec->power_lock held! */
4810 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4812 struct hda_bus *bus = codec->bus;
4814 /* Return if power_on or transitioning to power_on, unless currently
4816 if ((codec->power_on || codec->power_transition > 0) &&
4817 !(wait_power_down && codec->power_transition < 0))
4819 spin_unlock(&codec->power_lock);
4821 cancel_delayed_work_sync(&codec->power_work);
4823 spin_lock(&codec->power_lock);
4824 /* If the power down delayed work was cancelled above before starting,
4825 * then there is no need to go through power up here.
4827 if (codec->power_on) {
4828 if (codec->power_transition < 0)
4829 codec->power_transition = 0;
4833 trace_hda_power_up(codec);
4834 snd_hda_update_power_acct(codec);
4835 codec->power_on = 1;
4836 codec->power_jiffies = jiffies;
4837 codec->power_transition = 1; /* avoid reentrance */
4838 spin_unlock(&codec->power_lock);
4840 if (codec->pm_down_notified) {
4841 codec->pm_down_notified = 0;
4842 hda_call_pm_notify(bus, true);
4845 hda_call_codec_resume(codec);
4847 spin_lock(&codec->power_lock);
4848 codec->power_transition = 0;
4851 #define power_save(codec) \
4852 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4854 /* Transition to powered down */
4855 static void __snd_hda_power_down(struct hda_codec *codec)
4857 if (!codec->power_on || codec->power_count || codec->power_transition)
4860 if (power_save(codec)) {
4861 codec->power_transition = -1; /* avoid reentrance */
4862 queue_delayed_work(codec->bus->workq, &codec->power_work,
4863 msecs_to_jiffies(power_save(codec) * 1000));
4868 * snd_hda_power_save - Power-up/down/sync the codec
4869 * @codec: HD-audio codec
4870 * @delta: the counter delta to change
4872 * Change the power-up counter via @delta, and power up or down the hardware
4873 * appropriately. For the power-down, queue to the delayed action.
4874 * Passing zero to @delta means to synchronize the power state.
4876 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4878 spin_lock(&codec->power_lock);
4879 codec->power_count += delta;
4880 trace_hda_power_count(codec);
4882 __snd_hda_power_up(codec, d3wait);
4884 __snd_hda_power_down(codec);
4885 spin_unlock(&codec->power_lock);
4887 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4890 * snd_hda_check_amp_list_power - Check the amp list and update the power
4891 * @codec: HD-audio codec
4892 * @check: the object containing an AMP list and the status
4893 * @nid: NID to check / update
4895 * Check whether the given NID is in the amp list. If it's in the list,
4896 * check the current AMP status, and update the the power-status according
4897 * to the mute status.
4899 * This function is supposed to be set or called from the check_power_status
4902 int snd_hda_check_amp_list_power(struct hda_codec *codec,
4903 struct hda_loopback_check *check,
4906 const struct hda_amp_list *p;
4909 if (!check->amplist)
4911 for (p = check->amplist; p->nid; p++) {
4916 return 0; /* nothing changed */
4918 for (p = check->amplist; p->nid; p++) {
4919 for (ch = 0; ch < 2; ch++) {
4920 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4922 if (!(v & HDA_AMP_MUTE) && v > 0) {
4923 if (!check->power_on) {
4924 check->power_on = 1;
4925 snd_hda_power_up(codec);
4931 if (check->power_on) {
4932 check->power_on = 0;
4933 snd_hda_power_down(codec);
4937 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
4941 * Channel mode helper
4945 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4947 int snd_hda_ch_mode_info(struct hda_codec *codec,
4948 struct snd_ctl_elem_info *uinfo,
4949 const struct hda_channel_mode *chmode,
4952 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4954 uinfo->value.enumerated.items = num_chmodes;
4955 if (uinfo->value.enumerated.item >= num_chmodes)
4956 uinfo->value.enumerated.item = num_chmodes - 1;
4957 sprintf(uinfo->value.enumerated.name, "%dch",
4958 chmode[uinfo->value.enumerated.item].channels);
4961 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
4964 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4966 int snd_hda_ch_mode_get(struct hda_codec *codec,
4967 struct snd_ctl_elem_value *ucontrol,
4968 const struct hda_channel_mode *chmode,
4974 for (i = 0; i < num_chmodes; i++) {
4975 if (max_channels == chmode[i].channels) {
4976 ucontrol->value.enumerated.item[0] = i;
4982 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4985 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4987 int snd_hda_ch_mode_put(struct hda_codec *codec,
4988 struct snd_ctl_elem_value *ucontrol,
4989 const struct hda_channel_mode *chmode,
4995 mode = ucontrol->value.enumerated.item[0];
4996 if (mode >= num_chmodes)
4998 if (*max_channelsp == chmode[mode].channels)
5000 /* change the current channel setting */
5001 *max_channelsp = chmode[mode].channels;
5002 if (chmode[mode].sequence)
5003 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5006 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
5013 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5015 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5016 struct snd_ctl_elem_info *uinfo)
5020 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5022 uinfo->value.enumerated.items = imux->num_items;
5023 if (!imux->num_items)
5025 index = uinfo->value.enumerated.item;
5026 if (index >= imux->num_items)
5027 index = imux->num_items - 1;
5028 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5031 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
5034 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5036 int snd_hda_input_mux_put(struct hda_codec *codec,
5037 const struct hda_input_mux *imux,
5038 struct snd_ctl_elem_value *ucontrol,
5040 unsigned int *cur_val)
5044 if (!imux->num_items)
5046 idx = ucontrol->value.enumerated.item[0];
5047 if (idx >= imux->num_items)
5048 idx = imux->num_items - 1;
5049 if (*cur_val == idx)
5051 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5052 imux->items[idx].index);
5056 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
5060 * process kcontrol info callback of a simple string enum array
5061 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5063 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5064 struct snd_ctl_elem_info *uinfo,
5065 int num_items, const char * const *texts)
5067 static const char * const texts_default[] = {
5068 "Disabled", "Enabled"
5071 if (!texts || !num_items) {
5073 texts = texts_default;
5076 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5078 uinfo->value.enumerated.items = num_items;
5079 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5080 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5081 strcpy(uinfo->value.enumerated.name,
5082 texts[uinfo->value.enumerated.item]);
5085 EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
5088 * Multi-channel / digital-out PCM helper functions
5091 /* setup SPDIF output stream */
5092 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5093 unsigned int stream_tag, unsigned int format)
5095 struct hda_spdif_out *spdif;
5096 unsigned int curr_fmt;
5099 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5100 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5101 AC_VERB_GET_STREAM_FORMAT, 0);
5102 reset = codec->spdif_status_reset &&
5103 (spdif->ctls & AC_DIG1_ENABLE) &&
5106 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5109 set_dig_out_convert(codec, nid,
5110 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
5112 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
5113 if (codec->slave_dig_outs) {
5115 for (d = codec->slave_dig_outs; *d; d++)
5116 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5119 /* turn on again (if needed) */
5121 set_dig_out_convert(codec, nid,
5122 spdif->ctls & 0xff, -1);
5125 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5127 snd_hda_codec_cleanup_stream(codec, nid);
5128 if (codec->slave_dig_outs) {
5130 for (d = codec->slave_dig_outs; *d; d++)
5131 snd_hda_codec_cleanup_stream(codec, *d);
5136 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5137 * @bus: HD-audio bus
5139 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5141 struct hda_codec *codec;
5145 list_for_each_entry(codec, &bus->codec_list, list) {
5146 if (hda_codec_is_power_on(codec) &&
5147 codec->patch_ops.reboot_notify)
5148 codec->patch_ops.reboot_notify(codec);
5151 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
5154 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5156 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5157 struct hda_multi_out *mout)
5159 mutex_lock(&codec->spdif_mutex);
5160 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5161 /* already opened as analog dup; reset it once */
5162 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5163 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5164 mutex_unlock(&codec->spdif_mutex);
5167 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
5170 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5172 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5173 struct hda_multi_out *mout,
5174 unsigned int stream_tag,
5175 unsigned int format,
5176 struct snd_pcm_substream *substream)
5178 mutex_lock(&codec->spdif_mutex);
5179 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5180 mutex_unlock(&codec->spdif_mutex);
5183 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
5186 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5188 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5189 struct hda_multi_out *mout)
5191 mutex_lock(&codec->spdif_mutex);
5192 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5193 mutex_unlock(&codec->spdif_mutex);
5196 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
5199 * snd_hda_multi_out_dig_close - release the digital out stream
5201 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5202 struct hda_multi_out *mout)
5204 mutex_lock(&codec->spdif_mutex);
5205 mout->dig_out_used = 0;
5206 mutex_unlock(&codec->spdif_mutex);
5209 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
5212 * snd_hda_multi_out_analog_open - open analog outputs
5214 * Open analog outputs and set up the hw-constraints.
5215 * If the digital outputs can be opened as slave, open the digital
5218 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5219 struct hda_multi_out *mout,
5220 struct snd_pcm_substream *substream,
5221 struct hda_pcm_stream *hinfo)
5223 struct snd_pcm_runtime *runtime = substream->runtime;
5224 runtime->hw.channels_max = mout->max_channels;
5225 if (mout->dig_out_nid) {
5226 if (!mout->analog_rates) {
5227 mout->analog_rates = hinfo->rates;
5228 mout->analog_formats = hinfo->formats;
5229 mout->analog_maxbps = hinfo->maxbps;
5231 runtime->hw.rates = mout->analog_rates;
5232 runtime->hw.formats = mout->analog_formats;
5233 hinfo->maxbps = mout->analog_maxbps;
5235 if (!mout->spdif_rates) {
5236 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5238 &mout->spdif_formats,
5239 &mout->spdif_maxbps);
5241 mutex_lock(&codec->spdif_mutex);
5242 if (mout->share_spdif) {
5243 if ((runtime->hw.rates & mout->spdif_rates) &&
5244 (runtime->hw.formats & mout->spdif_formats)) {
5245 runtime->hw.rates &= mout->spdif_rates;
5246 runtime->hw.formats &= mout->spdif_formats;
5247 if (mout->spdif_maxbps < hinfo->maxbps)
5248 hinfo->maxbps = mout->spdif_maxbps;
5250 mout->share_spdif = 0;
5251 /* FIXME: need notify? */
5254 mutex_unlock(&codec->spdif_mutex);
5256 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5257 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5259 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
5262 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5264 * Set up the i/o for analog out.
5265 * When the digital out is available, copy the front out to digital out, too.
5267 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5268 struct hda_multi_out *mout,
5269 unsigned int stream_tag,
5270 unsigned int format,
5271 struct snd_pcm_substream *substream)
5273 const hda_nid_t *nids = mout->dac_nids;
5274 int chs = substream->runtime->channels;
5275 struct hda_spdif_out *spdif;
5278 mutex_lock(&codec->spdif_mutex);
5279 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5280 if (mout->dig_out_nid && mout->share_spdif &&
5281 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5283 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5285 !(spdif->status & IEC958_AES0_NONAUDIO)) {
5286 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5287 setup_dig_out_stream(codec, mout->dig_out_nid,
5288 stream_tag, format);
5290 mout->dig_out_used = 0;
5291 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5294 mutex_unlock(&codec->spdif_mutex);
5297 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5299 if (!mout->no_share_stream &&
5300 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5301 /* headphone out will just decode front left/right (stereo) */
5302 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5304 /* extra outputs copied from front */
5305 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5306 if (!mout->no_share_stream && mout->hp_out_nid[i])
5307 snd_hda_codec_setup_stream(codec,
5308 mout->hp_out_nid[i],
5309 stream_tag, 0, format);
5310 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5311 if (!mout->no_share_stream && mout->extra_out_nid[i])
5312 snd_hda_codec_setup_stream(codec,
5313 mout->extra_out_nid[i],
5314 stream_tag, 0, format);
5317 for (i = 1; i < mout->num_dacs; i++) {
5318 if (chs >= (i + 1) * 2) /* independent out */
5319 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5321 else if (!mout->no_share_stream) /* copy front */
5322 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5327 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
5330 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5332 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5333 struct hda_multi_out *mout)
5335 const hda_nid_t *nids = mout->dac_nids;
5338 for (i = 0; i < mout->num_dacs; i++)
5339 snd_hda_codec_cleanup_stream(codec, nids[i]);
5341 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5342 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5343 if (mout->hp_out_nid[i])
5344 snd_hda_codec_cleanup_stream(codec,
5345 mout->hp_out_nid[i]);
5346 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5347 if (mout->extra_out_nid[i])
5348 snd_hda_codec_cleanup_stream(codec,
5349 mout->extra_out_nid[i]);
5350 mutex_lock(&codec->spdif_mutex);
5351 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5352 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5353 mout->dig_out_used = 0;
5355 mutex_unlock(&codec->spdif_mutex);
5358 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
5361 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5363 * Guess the suitable VREF pin bits to be set as the pin-control value.
5364 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5366 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5368 unsigned int pincap;
5369 unsigned int oldval;
5370 oldval = snd_hda_codec_read(codec, pin, 0,
5371 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5372 pincap = snd_hda_query_pin_caps(codec, pin);
5373 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5374 /* Exception: if the default pin setup is vref50, we give it priority */
5375 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5376 return AC_PINCTL_VREF_80;
5377 else if (pincap & AC_PINCAP_VREF_50)
5378 return AC_PINCTL_VREF_50;
5379 else if (pincap & AC_PINCAP_VREF_100)
5380 return AC_PINCTL_VREF_100;
5381 else if (pincap & AC_PINCAP_VREF_GRD)
5382 return AC_PINCTL_VREF_GRD;
5383 return AC_PINCTL_VREF_HIZ;
5385 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5387 /* correct the pin ctl value for matching with the pin cap */
5388 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5389 hda_nid_t pin, unsigned int val)
5391 static unsigned int cap_lists[][2] = {
5392 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5393 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5394 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5395 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5401 cap = snd_hda_query_pin_caps(codec, pin);
5403 return val; /* don't know what to do... */
5405 if (val & AC_PINCTL_OUT_EN) {
5406 if (!(cap & AC_PINCAP_OUT))
5407 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5408 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5409 val &= ~AC_PINCTL_HP_EN;
5412 if (val & AC_PINCTL_IN_EN) {
5413 if (!(cap & AC_PINCAP_IN))
5414 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5416 unsigned int vcap, vref;
5418 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5419 vref = val & AC_PINCTL_VREFEN;
5420 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5421 if (vref == cap_lists[i][0] &&
5422 !(vcap & cap_lists[i][1])) {
5423 if (i == ARRAY_SIZE(cap_lists) - 1)
5424 vref = AC_PINCTL_VREF_HIZ;
5426 vref = cap_lists[i + 1][0];
5429 val &= ~AC_PINCTL_VREFEN;
5436 EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl);
5438 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5439 unsigned int val, bool cached)
5441 val = snd_hda_correct_pin_ctl(codec, pin, val);
5442 snd_hda_codec_set_pin_target(codec, pin, val);
5444 return snd_hda_codec_update_cache(codec, pin, 0,
5445 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5447 return snd_hda_codec_write(codec, pin, 0,
5448 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5450 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5453 * snd_hda_add_imux_item - Add an item to input_mux
5455 * When the same label is used already in the existing items, the number
5456 * suffix is appended to the label. This label index number is stored
5457 * to type_idx when non-NULL pointer is given.
5459 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5460 int index, int *type_idx)
5462 int i, label_idx = 0;
5463 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5464 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5467 for (i = 0; i < imux->num_items; i++) {
5468 if (!strncmp(label, imux->items[i].label, strlen(label)))
5472 *type_idx = label_idx;
5474 snprintf(imux->items[imux->num_items].label,
5475 sizeof(imux->items[imux->num_items].label),
5476 "%s %d", label, label_idx);
5478 strlcpy(imux->items[imux->num_items].label, label,
5479 sizeof(imux->items[imux->num_items].label));
5480 imux->items[imux->num_items].index = index;
5484 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5493 * snd_hda_suspend - suspend the codecs
5496 * Returns 0 if successful.
5498 int snd_hda_suspend(struct hda_bus *bus)
5500 struct hda_codec *codec;
5502 list_for_each_entry(codec, &bus->codec_list, list) {
5503 cancel_delayed_work_sync(&codec->jackpoll_work);
5504 if (hda_codec_is_power_on(codec))
5505 hda_call_codec_suspend(codec, false);
5509 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5512 * snd_hda_resume - resume the codecs
5515 * Returns 0 if successful.
5517 int snd_hda_resume(struct hda_bus *bus)
5519 struct hda_codec *codec;
5521 list_for_each_entry(codec, &bus->codec_list, list) {
5522 hda_call_codec_resume(codec);
5526 EXPORT_SYMBOL_HDA(snd_hda_resume);
5527 #endif /* CONFIG_PM */
5534 * snd_array_new - get a new element from the given array
5535 * @array: the array object
5537 * Get a new element from the given array. If it exceeds the
5538 * pre-allocated array size, re-allocate the array.
5540 * Returns NULL if allocation failed.
5542 void *snd_array_new(struct snd_array *array)
5544 if (snd_BUG_ON(!array->elem_size))
5546 if (array->used >= array->alloced) {
5547 int num = array->alloced + array->alloc_align;
5548 int size = (num + 1) * array->elem_size;
5549 int oldsize = array->alloced * array->elem_size;
5551 if (snd_BUG_ON(num >= 4096))
5553 nlist = krealloc(array->list, size, GFP_KERNEL);
5556 memset(nlist + oldsize, 0, size - oldsize);
5557 array->list = nlist;
5558 array->alloced = num;
5560 return snd_array_elem(array, array->used++);
5562 EXPORT_SYMBOL_HDA(snd_array_new);
5565 * snd_array_free - free the given array elements
5566 * @array: the array object
5568 void snd_array_free(struct snd_array *array)
5575 EXPORT_SYMBOL_HDA(snd_array_free);
5578 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5579 * @pcm: PCM caps bits
5580 * @buf: the string buffer to write
5581 * @buflen: the max buffer length
5583 * used by hda_proc.c and hda_eld.c
5585 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5587 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5590 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5591 if (pcm & (AC_SUPPCM_BITS_8 << i))
5592 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5594 buf[j] = '\0'; /* necessary when j == 0 */
5596 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5598 MODULE_DESCRIPTION("HDA codec core");
5599 MODULE_LICENSE("GPL");