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/mutex.h>
27 #include <linux/module.h>
28 #include <linux/async.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" },
71 { 0x434d, "C-Media" },
73 { 0x8384, "SigmaTel" },
77 static DEFINE_MUTEX(preset_mutex);
78 static LIST_HEAD(hda_preset_tables);
80 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
82 mutex_lock(&preset_mutex);
83 list_add_tail(&preset->list, &hda_preset_tables);
84 mutex_unlock(&preset_mutex);
87 EXPORT_SYMBOL_GPL(snd_hda_add_codec_preset);
89 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
91 mutex_lock(&preset_mutex);
92 list_del(&preset->list);
93 mutex_unlock(&preset_mutex);
96 EXPORT_SYMBOL_GPL(snd_hda_delete_codec_preset);
99 #define codec_in_pm(codec) ((codec)->in_pm)
100 static void hda_power_work(struct work_struct *work);
101 static void hda_keep_power_on(struct hda_codec *codec);
102 #define hda_codec_is_power_on(codec) ((codec)->power_on)
104 static void hda_call_pm_notify(struct hda_codec *codec, bool power_up)
106 struct hda_bus *bus = codec->bus;
108 if ((power_up && codec->pm_up_notified) ||
109 (!power_up && !codec->pm_up_notified))
111 if (bus->ops.pm_notify)
112 bus->ops.pm_notify(bus, power_up);
113 codec->pm_up_notified = power_up;
117 #define codec_in_pm(codec) 0
118 static inline void hda_keep_power_on(struct hda_codec *codec) {}
119 #define hda_codec_is_power_on(codec) 1
120 #define hda_call_pm_notify(codec, state) {}
124 * snd_hda_get_jack_location - Give a location string of the jack
125 * @cfg: pin default config value
127 * Parse the pin default config value and returns the string of the
128 * jack location, e.g. "Rear", "Front", etc.
130 const char *snd_hda_get_jack_location(u32 cfg)
132 static char *bases[7] = {
133 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
135 static unsigned char specials_idx[] = {
140 static char *specials[] = {
141 "Rear Panel", "Drive Bar",
142 "Riser", "HDMI", "ATAPI",
143 "Mobile-In", "Mobile-Out"
146 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
147 if ((cfg & 0x0f) < 7)
148 return bases[cfg & 0x0f];
149 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
150 if (cfg == specials_idx[i])
155 EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
158 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
159 * @cfg: pin default config value
161 * Parse the pin default config value and returns the string of the
162 * jack connectivity, i.e. external or internal connection.
164 const char *snd_hda_get_jack_connectivity(u32 cfg)
166 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
168 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
170 EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
173 * snd_hda_get_jack_type - Give a type string of the jack
174 * @cfg: pin default config value
176 * Parse the pin default config value and returns the string of the
177 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
179 const char *snd_hda_get_jack_type(u32 cfg)
181 static char *jack_types[16] = {
182 "Line Out", "Speaker", "HP Out", "CD",
183 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
184 "Line In", "Aux", "Mic", "Telephony",
185 "SPDIF In", "Digital In", "Reserved", "Other"
188 return jack_types[(cfg & AC_DEFCFG_DEVICE)
189 >> AC_DEFCFG_DEVICE_SHIFT];
191 EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
194 * Compose a 32bit command word to be sent to the HD-audio controller
196 static inline unsigned int
197 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int flags,
198 unsigned int verb, unsigned int parm)
202 if ((codec->addr & ~0xf) || (nid & ~0x7f) ||
203 (verb & ~0xfff) || (parm & ~0xffff)) {
204 codec_err(codec, "hda-codec: out of range cmd %x:%x:%x:%x\n",
205 codec->addr, nid, verb, parm);
209 val = (u32)codec->addr << 28;
210 val |= (u32)nid << 20;
217 * Send and receive a verb
219 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
220 int flags, unsigned int *res)
222 struct hda_bus *bus = codec->bus;
231 snd_hda_power_up(codec);
232 mutex_lock(&bus->cmd_mutex);
233 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
234 bus->no_response_fallback = 1;
236 trace_hda_send_cmd(codec, cmd);
237 err = bus->ops.command(bus, cmd);
240 /* process pending verbs */
241 bus->ops.get_response(bus, codec->addr);
244 *res = bus->ops.get_response(bus, codec->addr);
245 trace_hda_get_response(codec, *res);
247 bus->no_response_fallback = 0;
248 mutex_unlock(&bus->cmd_mutex);
249 snd_hda_power_down(codec);
250 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
251 if (bus->response_reset) {
253 "resetting BUS due to fatal communication error\n");
254 trace_hda_bus_reset(bus);
255 bus->ops.bus_reset(bus);
259 /* clear reset-flag when the communication gets recovered */
260 if (!err || codec_in_pm(codec))
261 bus->response_reset = 0;
266 * snd_hda_codec_read - send a command and get the response
267 * @codec: the HDA codec
268 * @nid: NID to send the command
269 * @flags: optional bit flags
270 * @verb: the verb to send
271 * @parm: the parameter for the verb
273 * Send a single command and read the corresponding response.
275 * Returns the obtained response value, or -1 for an error.
277 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
279 unsigned int verb, unsigned int parm)
281 unsigned cmd = make_codec_cmd(codec, nid, flags, verb, parm);
283 if (codec_exec_verb(codec, cmd, flags, &res))
287 EXPORT_SYMBOL_GPL(snd_hda_codec_read);
290 * snd_hda_codec_write - send a single command without waiting for response
291 * @codec: the HDA codec
292 * @nid: NID to send the command
293 * @flags: optional bit flags
294 * @verb: the verb to send
295 * @parm: the parameter for the verb
297 * Send a single command without waiting for response.
299 * Returns 0 if successful, or a negative error code.
301 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
302 unsigned int verb, unsigned int parm)
304 unsigned int cmd = make_codec_cmd(codec, nid, flags, verb, parm);
306 return codec_exec_verb(codec, cmd, flags,
307 codec->bus->sync_write ? &res : NULL);
309 EXPORT_SYMBOL_GPL(snd_hda_codec_write);
312 * snd_hda_sequence_write - sequence writes
313 * @codec: the HDA codec
314 * @seq: VERB array to send
316 * Send the commands sequentially from the given array.
317 * The array must be terminated with NID=0.
319 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
321 for (; seq->nid; seq++)
322 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
324 EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
327 * snd_hda_get_sub_nodes - get the range of sub nodes
328 * @codec: the HDA codec
330 * @start_id: the pointer to store the start NID
332 * Parse the NID and store the start NID of its sub-nodes.
333 * Returns the number of sub-nodes.
335 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
340 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
343 *start_id = (parm >> 16) & 0x7fff;
344 return (int)(parm & 0x7fff);
346 EXPORT_SYMBOL_GPL(snd_hda_get_sub_nodes);
348 /* connection list element */
349 struct hda_conn_list {
350 struct list_head list;
356 /* look up the cached results */
357 static struct hda_conn_list *
358 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
360 struct hda_conn_list *p;
361 list_for_each_entry(p, &codec->conn_list, list) {
368 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
369 const hda_nid_t *list)
371 struct hda_conn_list *p;
373 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
378 memcpy(p->conns, list, len * sizeof(hda_nid_t));
379 list_add(&p->list, &codec->conn_list);
383 static void remove_conn_list(struct hda_codec *codec)
385 while (!list_empty(&codec->conn_list)) {
386 struct hda_conn_list *p;
387 p = list_first_entry(&codec->conn_list, typeof(*p), list);
393 /* read the connection and add to the cache */
394 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
397 hda_nid_t *result = list;
400 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
401 if (len == -ENOSPC) {
402 len = snd_hda_get_num_raw_conns(codec, nid);
403 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
406 len = snd_hda_get_raw_connections(codec, nid, result, len);
409 len = snd_hda_override_conn_list(codec, nid, len, result);
416 * snd_hda_get_conn_list - get connection list
417 * @codec: the HDA codec
419 * @len: number of connection list entries
420 * @listp: the pointer to store NID list
422 * Parses the connection list of the given widget and stores the pointer
423 * to the list of NIDs.
425 * Returns the number of connections, or a negative error code.
427 * Note that the returned pointer isn't protected against the list
428 * modification. If snd_hda_override_conn_list() might be called
429 * concurrently, protect with a mutex appropriately.
431 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
432 const hda_nid_t **listp)
438 const struct hda_conn_list *p;
440 /* if the connection-list is already cached, read it */
441 p = lookup_conn_list(codec, nid);
447 if (snd_BUG_ON(added))
450 err = read_and_add_raw_conns(codec, nid);
456 EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
459 * snd_hda_get_connections - copy connection list
460 * @codec: the HDA codec
462 * @conn_list: connection list array; when NULL, checks only the size
463 * @max_conns: max. number of connections to store
465 * Parses the connection list of the given widget and stores the list
468 * Returns the number of connections, or a negative error code.
470 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
471 hda_nid_t *conn_list, int max_conns)
473 const hda_nid_t *list;
474 int len = snd_hda_get_conn_list(codec, nid, &list);
476 if (len > 0 && conn_list) {
477 if (len > max_conns) {
478 codec_err(codec, "Too many connections %d for NID 0x%x\n",
482 memcpy(conn_list, list, len * sizeof(hda_nid_t));
487 EXPORT_SYMBOL_GPL(snd_hda_get_connections);
489 /* return CONNLIST_LEN parameter of the given widget */
490 static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
492 unsigned int wcaps = get_wcaps(codec, nid);
495 if (!(wcaps & AC_WCAP_CONN_LIST) &&
496 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
499 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
505 int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
507 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
511 * snd_hda_get_raw_connections - copy connection list without cache
512 * @codec: the HDA codec
514 * @conn_list: connection list array
515 * @max_conns: max. number of connections to store
517 * Like snd_hda_get_connections(), copy the connection list but without
518 * checking through the connection-list cache.
519 * Currently called only from hda_proc.c, so not exported.
521 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
522 hda_nid_t *conn_list, int max_conns)
525 int i, conn_len, conns;
526 unsigned int shift, num_elems, mask;
530 parm = get_num_conns(codec, nid);
534 if (parm & AC_CLIST_LONG) {
543 conn_len = parm & AC_CLIST_LENGTH;
544 mask = (1 << (shift-1)) - 1;
547 return 0; /* no connection */
550 /* single connection */
551 parm = snd_hda_codec_read(codec, nid, 0,
552 AC_VERB_GET_CONNECT_LIST, 0);
553 if (parm == -1 && codec->bus->rirb_error)
556 conn_list[0] = parm & mask;
560 /* multi connection */
563 for (i = 0; i < conn_len; i++) {
567 if (i % num_elems == 0) {
568 parm = snd_hda_codec_read(codec, nid, 0,
569 AC_VERB_GET_CONNECT_LIST, i);
570 if (parm == -1 && codec->bus->rirb_error)
573 range_val = !!(parm & (1 << (shift-1))); /* ranges */
575 if (val == 0 && null_count++) { /* no second chance */
577 "invalid CONNECT_LIST verb %x[%i]:%x\n",
583 /* ranges between the previous and this one */
584 if (!prev_nid || prev_nid >= val) {
586 "invalid dep_range_val %x:%x\n",
590 for (n = prev_nid + 1; n <= val; n++) {
592 if (conns >= max_conns)
594 conn_list[conns] = n;
600 if (conns >= max_conns)
602 conn_list[conns] = val;
612 * snd_hda_override_conn_list - add/modify the connection-list to cache
613 * @codec: the HDA codec
615 * @len: number of connection list entries
616 * @list: the list of connection entries
618 * Add or modify the given connection-list to the cache. If the corresponding
619 * cache already exists, invalidate it and append a new one.
621 * Returns zero or a negative error code.
623 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
624 const hda_nid_t *list)
626 struct hda_conn_list *p;
628 p = lookup_conn_list(codec, nid);
634 return add_conn_list(codec, nid, len, list);
636 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
639 * snd_hda_get_conn_index - get the connection index of the given NID
640 * @codec: the HDA codec
641 * @mux: NID containing the list
642 * @nid: NID to select
643 * @recursive: 1 when searching NID recursively, otherwise 0
645 * Parses the connection list of the widget @mux and checks whether the
646 * widget @nid is present. If it is, return the connection index.
647 * Otherwise it returns -1.
649 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
650 hda_nid_t nid, int recursive)
652 const hda_nid_t *conn;
655 nums = snd_hda_get_conn_list(codec, mux, &conn);
656 for (i = 0; i < nums; i++)
661 if (recursive > 10) {
662 codec_dbg(codec, "too deep connection for 0x%x\n", nid);
666 for (i = 0; i < nums; i++) {
667 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
668 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
670 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
675 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
678 /* return DEVLIST_LEN parameter of the given widget */
679 static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
681 unsigned int wcaps = get_wcaps(codec, nid);
684 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
685 get_wcaps_type(wcaps) != AC_WID_PIN)
688 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
689 if (parm == -1 && codec->bus->rirb_error)
691 return parm & AC_DEV_LIST_LEN_MASK;
695 * snd_hda_get_devices - copy device list without cache
696 * @codec: the HDA codec
697 * @nid: NID of the pin to parse
698 * @dev_list: device list array
699 * @max_devices: max. number of devices to store
701 * Copy the device list. This info is dynamic and so not cached.
702 * Currently called only from hda_proc.c, so not exported.
704 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
705 u8 *dev_list, int max_devices)
708 int i, dev_len, devices;
710 parm = get_num_devices(codec, nid);
711 if (!parm) /* not multi-stream capable */
715 dev_len = dev_len < max_devices ? dev_len : max_devices;
718 while (devices < dev_len) {
719 parm = snd_hda_codec_read(codec, nid, 0,
720 AC_VERB_GET_DEVICE_LIST, devices);
721 if (parm == -1 && codec->bus->rirb_error)
724 for (i = 0; i < 8; i++) {
725 dev_list[devices] = (u8)parm;
728 if (devices >= dev_len)
736 * snd_hda_queue_unsol_event - add an unsolicited event to queue
738 * @res: unsolicited event (lower 32bit of RIRB entry)
739 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
741 * Adds the given event to the queue. The events are processed in
742 * the workqueue asynchronously. Call this function in the interrupt
743 * hanlder when RIRB receives an unsolicited event.
745 * Returns 0 if successful, or a negative error code.
747 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
749 struct hda_bus_unsolicited *unsol;
752 if (!bus || !bus->workq)
755 trace_hda_unsol_event(bus, res, res_ex);
760 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
764 unsol->queue[wp] = res;
765 unsol->queue[wp + 1] = res_ex;
767 queue_work(bus->workq, &unsol->work);
771 EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
774 * process queued unsolicited events
776 static void process_unsol_events(struct work_struct *work)
778 struct hda_bus_unsolicited *unsol =
779 container_of(work, struct hda_bus_unsolicited, work);
780 struct hda_bus *bus = unsol->bus;
781 struct hda_codec *codec;
782 unsigned int rp, caddr, res;
784 while (unsol->rp != unsol->wp) {
785 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
788 res = unsol->queue[rp];
789 caddr = unsol->queue[rp + 1];
790 if (!(caddr & (1 << 4))) /* no unsolicited event? */
792 codec = bus->caddr_tbl[caddr & 0x0f];
793 if (codec && codec->patch_ops.unsol_event)
794 codec->patch_ops.unsol_event(codec, res);
799 * initialize unsolicited queue
801 static int init_unsol_queue(struct hda_bus *bus)
803 struct hda_bus_unsolicited *unsol;
805 if (bus->unsol) /* already initialized */
808 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
810 dev_err(bus->card->dev, "can't allocate unsolicited queue\n");
813 INIT_WORK(&unsol->work, process_unsol_events);
822 static void snd_hda_bus_free(struct hda_bus *bus)
827 WARN_ON(!list_empty(&bus->codec_list));
829 flush_workqueue(bus->workq);
832 if (bus->ops.private_free)
833 bus->ops.private_free(bus);
835 destroy_workqueue(bus->workq);
840 static int snd_hda_bus_dev_free(struct snd_device *device)
842 snd_hda_bus_free(device->device_data);
846 static int snd_hda_bus_dev_disconnect(struct snd_device *device)
848 struct hda_bus *bus = device->device_data;
854 * snd_hda_bus_new - create a HDA bus
855 * @card: the card entry
856 * @temp: the template for hda_bus information
857 * @busp: the pointer to store the created bus instance
859 * Returns 0 if successful, or a negative error code.
861 int snd_hda_bus_new(struct snd_card *card,
862 const struct hda_bus_template *temp,
863 struct hda_bus **busp)
867 static struct snd_device_ops dev_ops = {
868 .dev_disconnect = snd_hda_bus_dev_disconnect,
869 .dev_free = snd_hda_bus_dev_free,
872 if (snd_BUG_ON(!temp))
874 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
880 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
882 dev_err(card->dev, "can't allocate struct hda_bus\n");
887 bus->private_data = temp->private_data;
888 bus->pci = temp->pci;
889 bus->modelname = temp->modelname;
890 bus->power_save = temp->power_save;
891 bus->ops = temp->ops;
893 mutex_init(&bus->cmd_mutex);
894 mutex_init(&bus->prepare_mutex);
895 INIT_LIST_HEAD(&bus->codec_list);
897 snprintf(bus->workq_name, sizeof(bus->workq_name),
898 "hd-audio%d", card->number);
899 bus->workq = create_singlethread_workqueue(bus->workq_name);
901 dev_err(card->dev, "cannot create workqueue %s\n",
907 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
909 snd_hda_bus_free(bus);
916 EXPORT_SYMBOL_GPL(snd_hda_bus_new);
918 #if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
919 #define is_generic_config(codec) \
920 (codec->modelname && !strcmp(codec->modelname, "generic"))
922 #define is_generic_config(codec) 0
926 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
928 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
932 * find a matching codec preset
934 static const struct hda_codec_preset *
935 find_codec_preset(struct hda_codec *codec)
937 struct hda_codec_preset_list *tbl;
938 const struct hda_codec_preset *preset;
939 unsigned int mod_requested = 0;
942 mutex_lock(&preset_mutex);
943 list_for_each_entry(tbl, &hda_preset_tables, list) {
944 if (!try_module_get(tbl->owner)) {
945 codec_err(codec, "cannot module_get\n");
948 for (preset = tbl->preset; preset->id; preset++) {
949 u32 mask = preset->mask;
950 if (preset->afg && preset->afg != codec->afg)
952 if (preset->mfg && preset->mfg != codec->mfg)
956 if (preset->id == (codec->vendor_id & mask) &&
958 preset->rev == codec->revision_id)) {
959 mutex_unlock(&preset_mutex);
960 codec->owner = tbl->owner;
964 module_put(tbl->owner);
966 mutex_unlock(&preset_mutex);
968 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
971 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
974 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
975 (codec->vendor_id >> 16) & 0xffff);
976 request_module(name);
984 * get_codec_name - store the codec name
986 static int get_codec_name(struct hda_codec *codec)
988 const struct hda_vendor_id *c;
989 const char *vendor = NULL;
990 u16 vendor_id = codec->vendor_id >> 16;
993 if (codec->vendor_name)
996 for (c = hda_vendor_ids; c->id; c++) {
997 if (c->id == vendor_id) {
1003 sprintf(tmp, "Generic %04x", vendor_id);
1006 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
1007 if (!codec->vendor_name)
1011 if (codec->chip_name)
1014 if (codec->preset && codec->preset->name)
1015 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
1017 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
1018 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
1020 if (!codec->chip_name)
1026 * look for an AFG and MFG nodes
1028 static void setup_fg_nodes(struct hda_codec *codec)
1030 int i, total_nodes, function_id;
1033 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
1034 for (i = 0; i < total_nodes; i++, nid++) {
1035 function_id = snd_hda_param_read(codec, nid,
1036 AC_PAR_FUNCTION_TYPE);
1037 switch (function_id & 0xff) {
1038 case AC_GRP_AUDIO_FUNCTION:
1040 codec->afg_function_id = function_id & 0xff;
1041 codec->afg_unsol = (function_id >> 8) & 1;
1043 case AC_GRP_MODEM_FUNCTION:
1045 codec->mfg_function_id = function_id & 0xff;
1046 codec->mfg_unsol = (function_id >> 8) & 1;
1055 * read widget caps for each widget and store in cache
1057 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1062 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1064 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1067 nid = codec->start_nid;
1068 for (i = 0; i < codec->num_nodes; i++, nid++)
1069 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1070 AC_PAR_AUDIO_WIDGET_CAP);
1074 /* read all pin default configurations and save codec->init_pins */
1075 static int read_pin_defaults(struct hda_codec *codec)
1078 hda_nid_t nid = codec->start_nid;
1080 for (i = 0; i < codec->num_nodes; i++, nid++) {
1081 struct hda_pincfg *pin;
1082 unsigned int wcaps = get_wcaps(codec, nid);
1083 unsigned int wid_type = get_wcaps_type(wcaps);
1084 if (wid_type != AC_WID_PIN)
1086 pin = snd_array_new(&codec->init_pins);
1090 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1091 AC_VERB_GET_CONFIG_DEFAULT, 0);
1092 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1093 AC_VERB_GET_PIN_WIDGET_CONTROL,
1099 /* look up the given pin config list and return the item matching with NID */
1100 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1101 struct snd_array *array,
1105 for (i = 0; i < array->used; i++) {
1106 struct hda_pincfg *pin = snd_array_elem(array, i);
1107 if (pin->nid == nid)
1113 /* set the current pin config value for the given NID.
1114 * the value is cached, and read via snd_hda_codec_get_pincfg()
1116 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1117 hda_nid_t nid, unsigned int cfg)
1119 struct hda_pincfg *pin;
1121 /* the check below may be invalid when pins are added by a fixup
1122 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
1126 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1130 pin = look_up_pincfg(codec, list, nid);
1132 pin = snd_array_new(list);
1142 * snd_hda_codec_set_pincfg - Override a pin default configuration
1143 * @codec: the HDA codec
1144 * @nid: NID to set the pin config
1145 * @cfg: the pin default config value
1147 * Override a pin default configuration value in the cache.
1148 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1149 * priority than the real hardware value.
1151 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1152 hda_nid_t nid, unsigned int cfg)
1154 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1156 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
1159 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1160 * @codec: the HDA codec
1161 * @nid: NID to get the pin config
1163 * Get the current pin config value of the given pin NID.
1164 * If the pincfg value is cached or overridden via sysfs or driver,
1165 * returns the cached value.
1167 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1169 struct hda_pincfg *pin;
1171 #ifdef CONFIG_SND_HDA_RECONFIG
1173 unsigned int cfg = 0;
1174 mutex_lock(&codec->user_mutex);
1175 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1178 mutex_unlock(&codec->user_mutex);
1183 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1186 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1191 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
1193 /* remember the current pinctl target value */
1194 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1197 struct hda_pincfg *pin;
1199 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1205 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
1207 /* return the current pinctl target value */
1208 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1210 struct hda_pincfg *pin;
1212 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1217 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
1220 * snd_hda_shutup_pins - Shut up all pins
1221 * @codec: the HDA codec
1223 * Clear all pin controls to shup up before suspend for avoiding click noise.
1224 * The controls aren't cached so that they can be resumed properly.
1226 void snd_hda_shutup_pins(struct hda_codec *codec)
1229 /* don't shut up pins when unloading the driver; otherwise it breaks
1230 * the default pin setup at the next load of the driver
1232 if (codec->bus->shutdown)
1234 for (i = 0; i < codec->init_pins.used; i++) {
1235 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1236 /* use read here for syncing after issuing each verb */
1237 snd_hda_codec_read(codec, pin->nid, 0,
1238 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1240 codec->pins_shutup = 1;
1242 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
1245 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1246 static void restore_shutup_pins(struct hda_codec *codec)
1249 if (!codec->pins_shutup)
1251 if (codec->bus->shutdown)
1253 for (i = 0; i < codec->init_pins.used; i++) {
1254 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1255 snd_hda_codec_write(codec, pin->nid, 0,
1256 AC_VERB_SET_PIN_WIDGET_CONTROL,
1259 codec->pins_shutup = 0;
1263 static void hda_jackpoll_work(struct work_struct *work)
1265 struct hda_codec *codec =
1266 container_of(work, struct hda_codec, jackpoll_work.work);
1268 snd_hda_jack_set_dirty_all(codec);
1269 snd_hda_jack_poll_all(codec);
1271 if (!codec->jackpoll_interval)
1274 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1275 codec->jackpoll_interval);
1278 static void init_hda_cache(struct hda_cache_rec *cache,
1279 unsigned int record_size);
1280 static void free_hda_cache(struct hda_cache_rec *cache);
1282 /* release all pincfg lists */
1283 static void free_init_pincfgs(struct hda_codec *codec)
1285 snd_array_free(&codec->driver_pins);
1286 #ifdef CONFIG_SND_HDA_RECONFIG
1287 snd_array_free(&codec->user_pins);
1289 snd_array_free(&codec->init_pins);
1293 * audio-converter setup caches
1295 struct hda_cvt_setup {
1300 unsigned char active; /* cvt is currently used */
1301 unsigned char dirty; /* setups should be cleared */
1304 /* get or create a cache entry for the given audio converter NID */
1305 static struct hda_cvt_setup *
1306 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1308 struct hda_cvt_setup *p;
1311 for (i = 0; i < codec->cvt_setups.used; i++) {
1312 p = snd_array_elem(&codec->cvt_setups, i);
1316 p = snd_array_new(&codec->cvt_setups);
1323 * Dynamic symbol binding for the codec parsers
1326 #define load_parser(codec, sym) \
1327 ((codec)->parser = (int (*)(struct hda_codec *))symbol_request(sym))
1329 static void unload_parser(struct hda_codec *codec)
1332 symbol_put_addr(codec->parser);
1333 codec->parser = NULL;
1339 static void snd_hda_codec_free(struct hda_codec *codec)
1343 cancel_delayed_work_sync(&codec->jackpoll_work);
1344 snd_hda_jack_tbl_clear(codec);
1345 free_init_pincfgs(codec);
1347 cancel_delayed_work(&codec->power_work);
1348 flush_workqueue(codec->bus->workq);
1350 list_del(&codec->list);
1351 snd_array_free(&codec->mixers);
1352 snd_array_free(&codec->nids);
1353 snd_array_free(&codec->cvt_setups);
1354 snd_array_free(&codec->spdif_out);
1355 remove_conn_list(codec);
1356 codec->bus->caddr_tbl[codec->addr] = NULL;
1357 if (codec->patch_ops.free)
1358 codec->patch_ops.free(codec);
1359 hda_call_pm_notify(codec, false); /* cancel leftover refcounts */
1360 snd_hda_sysfs_clear(codec);
1361 unload_parser(codec);
1362 module_put(codec->owner);
1363 free_hda_cache(&codec->amp_cache);
1364 free_hda_cache(&codec->cmd_cache);
1365 kfree(codec->vendor_name);
1366 kfree(codec->chip_name);
1367 kfree(codec->modelname);
1368 kfree(codec->wcaps);
1369 codec->bus->num_codecs--;
1370 put_device(&codec->dev);
1373 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1374 hda_nid_t fg, unsigned int power_state);
1376 static unsigned int hda_set_power_state(struct hda_codec *codec,
1377 unsigned int power_state);
1379 static int snd_hda_codec_dev_register(struct snd_device *device)
1381 struct hda_codec *codec = device->device_data;
1382 int err = device_add(&codec->dev);
1386 snd_hda_register_beep_device(codec);
1390 static int snd_hda_codec_dev_disconnect(struct snd_device *device)
1392 struct hda_codec *codec = device->device_data;
1394 snd_hda_detach_beep_device(codec);
1395 device_del(&codec->dev);
1399 static int snd_hda_codec_dev_free(struct snd_device *device)
1401 snd_hda_codec_free(device->device_data);
1405 /* just free the container */
1406 static void snd_hda_codec_dev_release(struct device *dev)
1408 kfree(container_of(dev, struct hda_codec, dev));
1412 * snd_hda_codec_new - create a HDA codec
1413 * @bus: the bus to assign
1414 * @codec_addr: the codec address
1415 * @codecp: the pointer to store the generated codec
1417 * Returns 0 if successful, or a negative error code.
1419 int snd_hda_codec_new(struct hda_bus *bus,
1420 unsigned int codec_addr,
1421 struct hda_codec **codecp)
1423 struct hda_codec *codec;
1427 static struct snd_device_ops dev_ops = {
1428 .dev_register = snd_hda_codec_dev_register,
1429 .dev_disconnect = snd_hda_codec_dev_disconnect,
1430 .dev_free = snd_hda_codec_dev_free,
1433 if (snd_BUG_ON(!bus))
1435 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1438 if (bus->caddr_tbl[codec_addr]) {
1439 dev_err(bus->card->dev,
1440 "address 0x%x is already occupied\n",
1445 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1446 if (codec == NULL) {
1447 dev_err(bus->card->dev, "can't allocate struct hda_codec\n");
1451 device_initialize(&codec->dev);
1452 codec->dev.parent = &bus->card->card_dev;
1453 codec->dev.class = sound_class;
1454 codec->dev.release = snd_hda_codec_dev_release;
1455 codec->dev.groups = snd_hda_dev_attr_groups;
1456 dev_set_name(&codec->dev, "hdaudioC%dD%d", bus->card->number,
1458 dev_set_drvdata(&codec->dev, codec); /* for sysfs */
1461 codec->addr = codec_addr;
1462 mutex_init(&codec->spdif_mutex);
1463 mutex_init(&codec->control_mutex);
1464 mutex_init(&codec->hash_mutex);
1465 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1466 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1467 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1468 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1469 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1470 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1471 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1472 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1473 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1474 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1475 INIT_LIST_HEAD(&codec->conn_list);
1477 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1478 codec->depop_delay = -1;
1481 spin_lock_init(&codec->power_lock);
1482 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1483 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1484 * the caller has to power down appropriatley after initialization
1487 hda_keep_power_on(codec);
1490 snd_hda_sysfs_init(codec);
1492 if (codec->bus->modelname) {
1493 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1494 if (!codec->modelname) {
1500 list_add_tail(&codec->list, &bus->codec_list);
1503 bus->caddr_tbl[codec_addr] = codec;
1505 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1507 if (codec->vendor_id == -1)
1508 /* read again, hopefully the access method was corrected
1509 * in the last read...
1511 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1513 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1514 AC_PAR_SUBSYSTEM_ID);
1515 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1518 setup_fg_nodes(codec);
1519 if (!codec->afg && !codec->mfg) {
1520 dev_err(bus->card->dev, "no AFG or MFG node found\n");
1525 fg = codec->afg ? codec->afg : codec->mfg;
1526 err = read_widget_caps(codec, fg);
1528 dev_err(bus->card->dev, "cannot malloc\n");
1531 err = read_pin_defaults(codec);
1535 if (!codec->subsystem_id) {
1536 codec->subsystem_id =
1537 snd_hda_codec_read(codec, fg, 0,
1538 AC_VERB_GET_SUBSYSTEM_ID, 0);
1542 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1545 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1548 if (!codec->d3_stop_clk || !codec->epss)
1549 bus->power_keep_link_on = 1;
1553 /* power-up all before initialization */
1554 hda_set_power_state(codec, AC_PWRST_D0);
1556 snd_hda_codec_proc_new(codec);
1558 snd_hda_create_hwdep(codec);
1560 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1561 codec->subsystem_id, codec->revision_id);
1562 snd_component_add(codec->bus->card, component);
1564 err = snd_device_new(bus->card, SNDRV_DEV_CODEC, codec, &dev_ops);
1573 snd_hda_codec_free(codec);
1576 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
1578 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1583 /* Assume the function group node does not change,
1584 * only the widget nodes may change.
1586 kfree(codec->wcaps);
1587 fg = codec->afg ? codec->afg : codec->mfg;
1588 err = read_widget_caps(codec, fg);
1590 codec_err(codec, "cannot malloc\n");
1594 snd_array_free(&codec->init_pins);
1595 err = read_pin_defaults(codec);
1599 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1602 #if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
1603 /* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
1604 static bool is_likely_hdmi_codec(struct hda_codec *codec)
1606 hda_nid_t nid = codec->start_nid;
1609 for (i = 0; i < codec->num_nodes; i++, nid++) {
1610 unsigned int wcaps = get_wcaps(codec, nid);
1611 switch (get_wcaps_type(wcaps)) {
1613 return false; /* HDMI parser supports only HDMI out */
1614 case AC_WID_AUD_OUT:
1615 if (!(wcaps & AC_WCAP_DIGITAL))
1623 /* no HDMI codec parser support */
1624 #define is_likely_hdmi_codec(codec) false
1625 #endif /* CONFIG_SND_HDA_CODEC_HDMI */
1628 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1629 * @codec: the HDA codec
1631 * Start parsing of the given codec tree and (re-)initialize the whole
1634 * Returns 0 if successful or a negative error code.
1636 int snd_hda_codec_configure(struct hda_codec *codec)
1638 int (*patch)(struct hda_codec *) = NULL;
1641 codec->preset = find_codec_preset(codec);
1642 if (!codec->vendor_name || !codec->chip_name) {
1643 err = get_codec_name(codec);
1648 if (!is_generic_config(codec) && codec->preset)
1649 patch = codec->preset->patch;
1651 unload_parser(codec); /* to be sure */
1652 if (is_likely_hdmi_codec(codec)) {
1653 #if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
1654 patch = load_parser(codec, snd_hda_parse_hdmi_codec);
1655 #elif IS_BUILTIN(CONFIG_SND_HDA_CODEC_HDMI)
1656 patch = snd_hda_parse_hdmi_codec;
1660 #if IS_MODULE(CONFIG_SND_HDA_GENERIC)
1661 patch = load_parser(codec, snd_hda_parse_generic_codec);
1662 #elif IS_BUILTIN(CONFIG_SND_HDA_GENERIC)
1663 patch = snd_hda_parse_generic_codec;
1667 codec_err(codec, "No codec parser is available\n");
1674 unload_parser(codec);
1678 if (codec->patch_ops.unsol_event) {
1679 err = init_unsol_queue(codec->bus);
1684 /* audio codec should override the mixer name */
1685 if (codec->afg || !*codec->bus->card->mixername)
1686 snprintf(codec->bus->card->mixername,
1687 sizeof(codec->bus->card->mixername),
1688 "%s %s", codec->vendor_name, codec->chip_name);
1691 EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
1693 /* update the stream-id if changed */
1694 static void update_pcm_stream_id(struct hda_codec *codec,
1695 struct hda_cvt_setup *p, hda_nid_t nid,
1696 u32 stream_tag, int channel_id)
1698 unsigned int oldval, newval;
1700 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1701 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1702 newval = (stream_tag << 4) | channel_id;
1703 if (oldval != newval)
1704 snd_hda_codec_write(codec, nid, 0,
1705 AC_VERB_SET_CHANNEL_STREAMID,
1707 p->stream_tag = stream_tag;
1708 p->channel_id = channel_id;
1712 /* update the format-id if changed */
1713 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1714 hda_nid_t nid, int format)
1716 unsigned int oldval;
1718 if (p->format_id != format) {
1719 oldval = snd_hda_codec_read(codec, nid, 0,
1720 AC_VERB_GET_STREAM_FORMAT, 0);
1721 if (oldval != format) {
1723 snd_hda_codec_write(codec, nid, 0,
1724 AC_VERB_SET_STREAM_FORMAT,
1727 p->format_id = format;
1732 * snd_hda_codec_setup_stream - set up the codec for streaming
1733 * @codec: the CODEC to set up
1734 * @nid: the NID to set up
1735 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1736 * @channel_id: channel id to pass, zero based.
1737 * @format: stream format.
1739 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1741 int channel_id, int format)
1743 struct hda_codec *c;
1744 struct hda_cvt_setup *p;
1752 "hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1753 nid, stream_tag, channel_id, format);
1754 p = get_hda_cvt_setup(codec, nid);
1758 if (codec->pcm_format_first)
1759 update_pcm_format(codec, p, nid, format);
1760 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1761 if (!codec->pcm_format_first)
1762 update_pcm_format(codec, p, nid, format);
1767 /* make other inactive cvts with the same stream-tag dirty */
1768 type = get_wcaps_type(get_wcaps(codec, nid));
1769 list_for_each_entry(c, &codec->bus->codec_list, list) {
1770 for (i = 0; i < c->cvt_setups.used; i++) {
1771 p = snd_array_elem(&c->cvt_setups, i);
1772 if (!p->active && p->stream_tag == stream_tag &&
1773 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1778 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1780 static void really_cleanup_stream(struct hda_codec *codec,
1781 struct hda_cvt_setup *q);
1784 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1785 * @codec: the CODEC to clean up
1786 * @nid: the NID to clean up
1787 * @do_now: really clean up the stream instead of clearing the active flag
1789 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1792 struct hda_cvt_setup *p;
1797 if (codec->no_sticky_stream)
1800 codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
1801 p = get_hda_cvt_setup(codec, nid);
1803 /* here we just clear the active flag when do_now isn't set;
1804 * actual clean-ups will be done later in
1805 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1808 really_cleanup_stream(codec, p);
1813 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1815 static void really_cleanup_stream(struct hda_codec *codec,
1816 struct hda_cvt_setup *q)
1818 hda_nid_t nid = q->nid;
1819 if (q->stream_tag || q->channel_id)
1820 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1822 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1824 memset(q, 0, sizeof(*q));
1828 /* clean up the all conflicting obsolete streams */
1829 static void purify_inactive_streams(struct hda_codec *codec)
1831 struct hda_codec *c;
1834 list_for_each_entry(c, &codec->bus->codec_list, list) {
1835 for (i = 0; i < c->cvt_setups.used; i++) {
1836 struct hda_cvt_setup *p;
1837 p = snd_array_elem(&c->cvt_setups, i);
1839 really_cleanup_stream(c, p);
1845 /* clean up all streams; called from suspend */
1846 static void hda_cleanup_all_streams(struct hda_codec *codec)
1850 for (i = 0; i < codec->cvt_setups.used; i++) {
1851 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1853 really_cleanup_stream(codec, p);
1859 * amp access functions
1862 /* FIXME: more better hash key? */
1863 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1864 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1865 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1866 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1867 #define INFO_AMP_CAPS (1<<0)
1868 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1870 /* initialize the hash table */
1871 static void init_hda_cache(struct hda_cache_rec *cache,
1872 unsigned int record_size)
1874 memset(cache, 0, sizeof(*cache));
1875 memset(cache->hash, 0xff, sizeof(cache->hash));
1876 snd_array_init(&cache->buf, record_size, 64);
1879 static void free_hda_cache(struct hda_cache_rec *cache)
1881 snd_array_free(&cache->buf);
1884 /* query the hash. allocate an entry if not found. */
1885 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1887 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1888 u16 cur = cache->hash[idx];
1889 struct hda_cache_head *info;
1891 while (cur != 0xffff) {
1892 info = snd_array_elem(&cache->buf, cur);
1893 if (info->key == key)
1900 /* query the hash. allocate an entry if not found. */
1901 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1904 struct hda_cache_head *info = get_hash(cache, key);
1907 /* add a new hash entry */
1908 info = snd_array_new(&cache->buf);
1911 cur = snd_array_index(&cache->buf, info);
1915 idx = key % (u16)ARRAY_SIZE(cache->hash);
1916 info->next = cache->hash[idx];
1917 cache->hash[idx] = cur;
1922 /* query and allocate an amp hash entry */
1923 static inline struct hda_amp_info *
1924 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1926 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1929 /* overwrite the value with the key in the caps hash */
1930 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1932 struct hda_amp_info *info;
1934 mutex_lock(&codec->hash_mutex);
1935 info = get_alloc_amp_hash(codec, key);
1937 mutex_unlock(&codec->hash_mutex);
1940 info->amp_caps = val;
1941 info->head.val |= INFO_AMP_CAPS;
1942 mutex_unlock(&codec->hash_mutex);
1946 /* query the value from the caps hash; if not found, fetch the current
1947 * value from the given function and store in the hash
1950 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1951 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1953 struct hda_amp_info *info;
1956 mutex_lock(&codec->hash_mutex);
1957 info = get_alloc_amp_hash(codec, key);
1959 mutex_unlock(&codec->hash_mutex);
1962 if (!(info->head.val & INFO_AMP_CAPS)) {
1963 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1964 val = func(codec, nid, dir);
1965 write_caps_hash(codec, key, val);
1967 val = info->amp_caps;
1968 mutex_unlock(&codec->hash_mutex);
1973 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1976 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1978 return snd_hda_param_read(codec, nid,
1979 direction == HDA_OUTPUT ?
1980 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1984 * query_amp_caps - query AMP capabilities
1985 * @codec: the HD-auio codec
1986 * @nid: the NID to query
1987 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1989 * Query AMP capabilities for the given widget and direction.
1990 * Returns the obtained capability bits.
1992 * When cap bits have been already read, this doesn't read again but
1993 * returns the cached value.
1995 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1997 return query_caps_hash(codec, nid, direction,
1998 HDA_HASH_KEY(nid, direction, 0),
2001 EXPORT_SYMBOL_GPL(query_amp_caps);
2004 * snd_hda_override_amp_caps - Override the AMP capabilities
2005 * @codec: the CODEC to clean up
2006 * @nid: the NID to clean up
2007 * @direction: either #HDA_INPUT or #HDA_OUTPUT
2008 * @caps: the capability bits to set
2010 * Override the cached AMP caps bits value by the given one.
2011 * This function is useful if the driver needs to adjust the AMP ranges,
2012 * e.g. limit to 0dB, etc.
2014 * Returns zero if successful or a negative error code.
2016 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
2019 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
2021 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
2023 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
2026 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2030 * snd_hda_query_pin_caps - Query PIN capabilities
2031 * @codec: the HD-auio codec
2032 * @nid: the NID to query
2034 * Query PIN capabilities for the given widget.
2035 * Returns the obtained capability bits.
2037 * When cap bits have been already read, this doesn't read again but
2038 * returns the cached value.
2040 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
2042 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
2045 EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
2048 * snd_hda_override_pin_caps - Override the pin capabilities
2050 * @nid: the NID to override
2051 * @caps: the capability bits to set
2053 * Override the cached PIN capabilitiy bits value by the given one.
2055 * Returns zero if successful or a negative error code.
2057 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
2060 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
2062 EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
2064 /* read or sync the hash value with the current value;
2065 * call within hash_mutex
2067 static struct hda_amp_info *
2068 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
2069 int direction, int index, bool init_only)
2071 struct hda_amp_info *info;
2072 unsigned int parm, val = 0;
2073 bool val_read = false;
2076 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
2079 if (!(info->head.val & INFO_AMP_VOL(ch))) {
2081 mutex_unlock(&codec->hash_mutex);
2082 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
2083 parm |= direction == HDA_OUTPUT ?
2084 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
2086 val = snd_hda_codec_read(codec, nid, 0,
2087 AC_VERB_GET_AMP_GAIN_MUTE, parm);
2090 mutex_lock(&codec->hash_mutex);
2093 info->vol[ch] = val;
2094 info->head.val |= INFO_AMP_VOL(ch);
2095 } else if (init_only)
2101 * write the current volume in info to the h/w
2103 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
2104 hda_nid_t nid, int ch, int direction, int index,
2109 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
2110 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
2111 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2112 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
2113 (amp_caps & AC_AMPCAP_MIN_MUTE))
2114 ; /* set the zero value as a fake mute */
2117 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
2121 * snd_hda_codec_amp_read - Read AMP value
2122 * @codec: HD-audio codec
2123 * @nid: NID to read the AMP value
2124 * @ch: channel (left=0 or right=1)
2125 * @direction: #HDA_INPUT or #HDA_OUTPUT
2126 * @index: the index value (only for input direction)
2128 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
2130 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2131 int direction, int index)
2133 struct hda_amp_info *info;
2134 unsigned int val = 0;
2136 mutex_lock(&codec->hash_mutex);
2137 info = update_amp_hash(codec, nid, ch, direction, index, false);
2139 val = info->vol[ch];
2140 mutex_unlock(&codec->hash_mutex);
2143 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
2145 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2146 int direction, int idx, int mask, int val,
2149 struct hda_amp_info *info;
2151 unsigned int cache_only;
2153 if (snd_BUG_ON(mask & ~0xff))
2157 mutex_lock(&codec->hash_mutex);
2158 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
2160 mutex_unlock(&codec->hash_mutex);
2163 val |= info->vol[ch] & ~mask;
2164 if (info->vol[ch] == val) {
2165 mutex_unlock(&codec->hash_mutex);
2168 info->vol[ch] = val;
2169 cache_only = info->head.dirty = codec->cached_write;
2170 caps = info->amp_caps;
2171 mutex_unlock(&codec->hash_mutex);
2173 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2178 * snd_hda_codec_amp_update - update the AMP value
2179 * @codec: HD-audio codec
2180 * @nid: NID to read the AMP value
2181 * @ch: channel (left=0 or right=1)
2182 * @direction: #HDA_INPUT or #HDA_OUTPUT
2183 * @idx: the index value (only for input direction)
2184 * @mask: bit mask to set
2185 * @val: the bits value to set
2187 * Update the AMP value with a bit mask.
2188 * Returns 0 if the value is unchanged, 1 if changed.
2190 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2191 int direction, int idx, int mask, int val)
2193 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2195 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
2198 * snd_hda_codec_amp_stereo - update the AMP stereo values
2199 * @codec: HD-audio codec
2200 * @nid: NID to read the AMP value
2201 * @direction: #HDA_INPUT or #HDA_OUTPUT
2202 * @idx: the index value (only for input direction)
2203 * @mask: bit mask to set
2204 * @val: the bits value to set
2206 * Update the AMP values like snd_hda_codec_amp_update(), but for a
2207 * stereo widget with the same mask and value.
2209 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2210 int direction, int idx, int mask, int val)
2214 if (snd_BUG_ON(mask & ~0xff))
2216 for (ch = 0; ch < 2; ch++)
2217 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2221 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
2223 /* Works like snd_hda_codec_amp_update() but it writes the value only at
2224 * the first access. If the amp was already initialized / updated beforehand,
2225 * this does nothing.
2227 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2228 int dir, int idx, int mask, int val)
2230 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2232 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
2234 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2235 int dir, int idx, int mask, int val)
2239 if (snd_BUG_ON(mask & ~0xff))
2241 for (ch = 0; ch < 2; ch++)
2242 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2246 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
2249 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2250 * @codec: HD-audio codec
2252 * Resume the all amp commands from the cache.
2254 void snd_hda_codec_resume_amp(struct hda_codec *codec)
2258 mutex_lock(&codec->hash_mutex);
2259 codec->cached_write = 0;
2260 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2261 struct hda_amp_info *buffer;
2264 unsigned int idx, dir, ch;
2265 struct hda_amp_info info;
2267 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2268 if (!buffer->head.dirty)
2270 buffer->head.dirty = 0;
2272 key = info.head.key;
2276 idx = (key >> 16) & 0xff;
2277 dir = (key >> 24) & 0xff;
2278 for (ch = 0; ch < 2; ch++) {
2279 if (!(info.head.val & INFO_AMP_VOL(ch)))
2281 mutex_unlock(&codec->hash_mutex);
2282 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2284 mutex_lock(&codec->hash_mutex);
2287 mutex_unlock(&codec->hash_mutex);
2289 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
2291 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2294 u32 caps = query_amp_caps(codec, nid, dir);
2296 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2303 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2305 * The control element is supposed to have the private_value field
2306 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2308 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2309 struct snd_ctl_elem_info *uinfo)
2311 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2312 u16 nid = get_amp_nid(kcontrol);
2313 u8 chs = get_amp_channels(kcontrol);
2314 int dir = get_amp_direction(kcontrol);
2315 unsigned int ofs = get_amp_offset(kcontrol);
2317 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2318 uinfo->count = chs == 3 ? 2 : 1;
2319 uinfo->value.integer.min = 0;
2320 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2321 if (!uinfo->value.integer.max) {
2323 "num_steps = 0 for NID=0x%x (ctl = %s)\n",
2324 nid, kcontrol->id.name);
2329 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
2332 static inline unsigned int
2333 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2334 int ch, int dir, int idx, unsigned int ofs)
2337 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2338 val &= HDA_AMP_VOLMASK;
2347 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2348 int ch, int dir, int idx, unsigned int ofs,
2351 unsigned int maxval;
2355 /* ofs = 0: raw max value */
2356 maxval = get_amp_max_value(codec, nid, dir, 0);
2359 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2360 HDA_AMP_VOLMASK, val);
2364 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2366 * The control element is supposed to have the private_value field
2367 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2369 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2370 struct snd_ctl_elem_value *ucontrol)
2372 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2373 hda_nid_t nid = get_amp_nid(kcontrol);
2374 int chs = get_amp_channels(kcontrol);
2375 int dir = get_amp_direction(kcontrol);
2376 int idx = get_amp_index(kcontrol);
2377 unsigned int ofs = get_amp_offset(kcontrol);
2378 long *valp = ucontrol->value.integer.value;
2381 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2383 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2386 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
2389 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2391 * The control element is supposed to have the private_value field
2392 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2394 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2395 struct snd_ctl_elem_value *ucontrol)
2397 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2398 hda_nid_t nid = get_amp_nid(kcontrol);
2399 int chs = get_amp_channels(kcontrol);
2400 int dir = get_amp_direction(kcontrol);
2401 int idx = get_amp_index(kcontrol);
2402 unsigned int ofs = get_amp_offset(kcontrol);
2403 long *valp = ucontrol->value.integer.value;
2406 snd_hda_power_up(codec);
2408 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2412 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2413 snd_hda_power_down(codec);
2416 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
2419 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2421 * The control element is supposed to have the private_value field
2422 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2424 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2425 unsigned int size, unsigned int __user *_tlv)
2427 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2428 hda_nid_t nid = get_amp_nid(kcontrol);
2429 int dir = get_amp_direction(kcontrol);
2430 unsigned int ofs = get_amp_offset(kcontrol);
2431 bool min_mute = get_amp_min_mute(kcontrol);
2432 u32 caps, val1, val2;
2434 if (size < 4 * sizeof(unsigned int))
2436 caps = query_amp_caps(codec, nid, dir);
2437 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2438 val2 = (val2 + 1) * 25;
2439 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2441 val1 = ((int)val1) * ((int)val2);
2442 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2443 val2 |= TLV_DB_SCALE_MUTE;
2444 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2446 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2448 if (put_user(val1, _tlv + 2))
2450 if (put_user(val2, _tlv + 3))
2454 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
2457 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2458 * @codec: HD-audio codec
2459 * @nid: NID of a reference widget
2460 * @dir: #HDA_INPUT or #HDA_OUTPUT
2461 * @tlv: TLV data to be stored, at least 4 elements
2463 * Set (static) TLV data for a virtual master volume using the AMP caps
2464 * obtained from the reference NID.
2465 * The volume range is recalculated as if the max volume is 0dB.
2467 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2473 caps = query_amp_caps(codec, nid, dir);
2474 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2475 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2476 step = (step + 1) * 25;
2477 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2478 tlv[1] = 2 * sizeof(unsigned int);
2479 tlv[2] = -nums * step;
2482 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
2484 /* find a mixer control element with the given name */
2485 static struct snd_kcontrol *
2486 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2488 struct snd_ctl_elem_id id;
2489 memset(&id, 0, sizeof(id));
2490 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2493 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2495 strcpy(id.name, name);
2496 return snd_ctl_find_id(codec->bus->card, &id);
2500 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2501 * @codec: HD-audio codec
2502 * @name: ctl id name string
2504 * Get the control element with the given id string and IFACE_MIXER.
2506 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2509 return find_mixer_ctl(codec, name, 0, 0);
2511 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
2513 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2517 /* 16 ctlrs should be large enough */
2518 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2519 if (!find_mixer_ctl(codec, name, 0, idx))
2526 * snd_hda_ctl_add - Add a control element and assign to the codec
2527 * @codec: HD-audio codec
2528 * @nid: corresponding NID (optional)
2529 * @kctl: the control element to assign
2531 * Add the given control element to an array inside the codec instance.
2532 * All control elements belonging to a codec are supposed to be added
2533 * by this function so that a proper clean-up works at the free or
2534 * reconfiguration time.
2536 * If non-zero @nid is passed, the NID is assigned to the control element.
2537 * The assignment is shown in the codec proc file.
2539 * snd_hda_ctl_add() checks the control subdev id field whether
2540 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2541 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2542 * specifies if kctl->private_value is a HDA amplifier value.
2544 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2545 struct snd_kcontrol *kctl)
2548 unsigned short flags = 0;
2549 struct hda_nid_item *item;
2551 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2552 flags |= HDA_NID_ITEM_AMP;
2554 nid = get_amp_nid_(kctl->private_value);
2556 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2557 nid = kctl->id.subdevice & 0xffff;
2558 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2559 kctl->id.subdevice = 0;
2560 err = snd_ctl_add(codec->bus->card, kctl);
2563 item = snd_array_new(&codec->mixers);
2568 item->flags = flags;
2571 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
2574 * snd_hda_add_nid - Assign a NID to a control element
2575 * @codec: HD-audio codec
2576 * @nid: corresponding NID (optional)
2577 * @kctl: the control element to assign
2578 * @index: index to kctl
2580 * Add the given control element to an array inside the codec instance.
2581 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2582 * NID:KCTL mapping - for example "Capture Source" selector.
2584 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2585 unsigned int index, hda_nid_t nid)
2587 struct hda_nid_item *item;
2590 item = snd_array_new(&codec->nids);
2594 item->index = index;
2598 codec_err(codec, "no NID for mapping control %s:%d:%d\n",
2599 kctl->id.name, kctl->id.index, index);
2602 EXPORT_SYMBOL_GPL(snd_hda_add_nid);
2605 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2606 * @codec: HD-audio codec
2608 void snd_hda_ctls_clear(struct hda_codec *codec)
2611 struct hda_nid_item *items = codec->mixers.list;
2612 for (i = 0; i < codec->mixers.used; i++)
2613 snd_ctl_remove(codec->bus->card, items[i].kctl);
2614 snd_array_free(&codec->mixers);
2615 snd_array_free(&codec->nids);
2618 /* pseudo device locking
2619 * toggle card->shutdown to allow/disallow the device access (as a hack)
2621 int snd_hda_lock_devices(struct hda_bus *bus)
2623 struct snd_card *card = bus->card;
2624 struct hda_codec *codec;
2626 spin_lock(&card->files_lock);
2630 if (!list_empty(&card->ctl_files))
2633 list_for_each_entry(codec, &bus->codec_list, list) {
2635 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2636 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2639 if (cpcm->pcm->streams[0].substream_opened ||
2640 cpcm->pcm->streams[1].substream_opened)
2644 spin_unlock(&card->files_lock);
2650 spin_unlock(&card->files_lock);
2653 EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
2655 void snd_hda_unlock_devices(struct hda_bus *bus)
2657 struct snd_card *card = bus->card;
2660 spin_lock(&card->files_lock);
2662 spin_unlock(&card->files_lock);
2664 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
2667 * snd_hda_codec_reset - Clear all objects assigned to the codec
2668 * @codec: HD-audio codec
2670 * This frees the all PCM and control elements assigned to the codec, and
2671 * clears the caches and restores the pin default configurations.
2673 * When a device is being used, it returns -EBSY. If successfully freed,
2676 int snd_hda_codec_reset(struct hda_codec *codec)
2678 struct hda_bus *bus = codec->bus;
2679 struct snd_card *card = bus->card;
2682 if (snd_hda_lock_devices(bus) < 0)
2685 /* OK, let it free */
2686 cancel_delayed_work_sync(&codec->jackpoll_work);
2688 cancel_delayed_work_sync(&codec->power_work);
2689 flush_workqueue(bus->workq);
2691 snd_hda_ctls_clear(codec);
2693 for (i = 0; i < codec->num_pcms; i++) {
2694 if (codec->pcm_info[i].pcm) {
2695 snd_device_free(card, codec->pcm_info[i].pcm);
2696 clear_bit(codec->pcm_info[i].device,
2700 snd_hda_detach_beep_device(codec);
2701 if (codec->patch_ops.free)
2702 codec->patch_ops.free(codec);
2703 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2704 snd_hda_jack_tbl_clear(codec);
2705 codec->proc_widget_hook = NULL;
2707 free_hda_cache(&codec->amp_cache);
2708 free_hda_cache(&codec->cmd_cache);
2709 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2710 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2711 /* free only driver_pins so that init_pins + user_pins are restored */
2712 snd_array_free(&codec->driver_pins);
2713 snd_array_free(&codec->cvt_setups);
2714 snd_array_free(&codec->spdif_out);
2715 snd_array_free(&codec->verbs);
2716 codec->num_pcms = 0;
2717 codec->pcm_info = NULL;
2718 codec->preset = NULL;
2719 codec->slave_dig_outs = NULL;
2720 codec->spdif_status_reset = 0;
2721 unload_parser(codec);
2722 module_put(codec->owner);
2723 codec->owner = NULL;
2725 /* allow device access again */
2726 snd_hda_unlock_devices(bus);
2730 typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
2732 /* apply the function to all matching slave ctls in the mixer list */
2733 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2734 const char *suffix, map_slave_func_t func, void *data)
2736 struct hda_nid_item *items;
2737 const char * const *s;
2740 items = codec->mixers.list;
2741 for (i = 0; i < codec->mixers.used; i++) {
2742 struct snd_kcontrol *sctl = items[i].kctl;
2743 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2745 for (s = slaves; *s; s++) {
2746 char tmpname[sizeof(sctl->id.name)];
2747 const char *name = *s;
2749 snprintf(tmpname, sizeof(tmpname), "%s %s",
2753 if (!strcmp(sctl->id.name, name)) {
2754 err = func(codec, data, sctl);
2764 static int check_slave_present(struct hda_codec *codec,
2765 void *data, struct snd_kcontrol *sctl)
2770 /* guess the value corresponding to 0dB */
2771 static int get_kctl_0dB_offset(struct hda_codec *codec,
2772 struct snd_kcontrol *kctl, int *step_to_check)
2775 const int *tlv = NULL;
2778 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2779 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2780 mm_segment_t fs = get_fs();
2782 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2785 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2787 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
2789 step &= ~TLV_DB_SCALE_MUTE;
2792 if (*step_to_check && *step_to_check != step) {
2793 codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
2794 - *step_to_check, step);
2797 *step_to_check = step;
2798 val = -tlv[2] / step;
2803 /* call kctl->put with the given value(s) */
2804 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2806 struct snd_ctl_elem_value *ucontrol;
2807 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2810 ucontrol->value.integer.value[0] = val;
2811 ucontrol->value.integer.value[1] = val;
2812 kctl->put(kctl, ucontrol);
2817 /* initialize the slave volume with 0dB */
2818 static int init_slave_0dB(struct hda_codec *codec,
2819 void *data, struct snd_kcontrol *slave)
2821 int offset = get_kctl_0dB_offset(codec, slave, data);
2823 put_kctl_with_value(slave, offset);
2827 /* unmute the slave */
2828 static int init_slave_unmute(struct hda_codec *codec,
2829 void *data, struct snd_kcontrol *slave)
2831 return put_kctl_with_value(slave, 1);
2834 static int add_slave(struct hda_codec *codec,
2835 void *data, struct snd_kcontrol *slave)
2837 return snd_ctl_add_slave(data, slave);
2841 * snd_hda_add_vmaster - create a virtual master control and add slaves
2842 * @codec: HD-audio codec
2843 * @name: vmaster control name
2844 * @tlv: TLV data (optional)
2845 * @slaves: slave control names (optional)
2846 * @suffix: suffix string to each slave name (optional)
2847 * @init_slave_vol: initialize slaves to unmute/0dB
2848 * @ctl_ret: store the vmaster kcontrol in return
2850 * Create a virtual master control with the given name. The TLV data
2851 * must be either NULL or a valid data.
2853 * @slaves is a NULL-terminated array of strings, each of which is a
2854 * slave control name. All controls with these names are assigned to
2855 * the new virtual master control.
2857 * This function returns zero if successful or a negative error code.
2859 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2860 unsigned int *tlv, const char * const *slaves,
2861 const char *suffix, bool init_slave_vol,
2862 struct snd_kcontrol **ctl_ret)
2864 struct snd_kcontrol *kctl;
2870 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2872 codec_dbg(codec, "No slave found for %s\n", name);
2875 kctl = snd_ctl_make_virtual_master(name, tlv);
2878 err = snd_hda_ctl_add(codec, 0, kctl);
2882 err = map_slaves(codec, slaves, suffix, add_slave, kctl);
2886 /* init with master mute & zero volume */
2887 put_kctl_with_value(kctl, 0);
2888 if (init_slave_vol) {
2890 map_slaves(codec, slaves, suffix,
2891 tlv ? init_slave_0dB : init_slave_unmute, &step);
2898 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2901 * mute-LED control using vmaster
2903 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2904 struct snd_ctl_elem_info *uinfo)
2906 static const char * const texts[] = {
2907 "On", "Off", "Follow Master"
2911 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2913 uinfo->value.enumerated.items = 3;
2914 index = uinfo->value.enumerated.item;
2917 strcpy(uinfo->value.enumerated.name, texts[index]);
2921 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2922 struct snd_ctl_elem_value *ucontrol)
2924 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2925 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2929 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2930 struct snd_ctl_elem_value *ucontrol)
2932 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2933 unsigned int old_mode = hook->mute_mode;
2935 hook->mute_mode = ucontrol->value.enumerated.item[0];
2936 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2937 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2938 if (old_mode == hook->mute_mode)
2940 snd_hda_sync_vmaster_hook(hook);
2944 static struct snd_kcontrol_new vmaster_mute_mode = {
2945 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2946 .name = "Mute-LED Mode",
2947 .info = vmaster_mute_mode_info,
2948 .get = vmaster_mute_mode_get,
2949 .put = vmaster_mute_mode_put,
2953 * Add a mute-LED hook with the given vmaster switch kctl
2954 * "Mute-LED Mode" control is automatically created and associated with
2957 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2958 struct hda_vmaster_mute_hook *hook,
2959 bool expose_enum_ctl)
2961 struct snd_kcontrol *kctl;
2963 if (!hook->hook || !hook->sw_kctl)
2965 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2966 hook->codec = codec;
2967 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2968 if (!expose_enum_ctl)
2970 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2973 return snd_hda_ctl_add(codec, 0, kctl);
2975 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2978 * Call the hook with the current value for synchronization
2979 * Should be called in init callback
2981 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2983 if (!hook->hook || !hook->codec)
2985 /* don't call vmaster hook in the destructor since it might have
2986 * been already destroyed
2988 if (hook->codec->bus->shutdown)
2990 switch (hook->mute_mode) {
2991 case HDA_VMUTE_FOLLOW_MASTER:
2992 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2995 hook->hook(hook->codec, hook->mute_mode);
2999 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
3003 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
3005 * The control element is supposed to have the private_value field
3006 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
3008 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
3009 struct snd_ctl_elem_info *uinfo)
3011 int chs = get_amp_channels(kcontrol);
3013 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3014 uinfo->count = chs == 3 ? 2 : 1;
3015 uinfo->value.integer.min = 0;
3016 uinfo->value.integer.max = 1;
3019 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
3022 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
3024 * The control element is supposed to have the private_value field
3025 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
3027 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
3028 struct snd_ctl_elem_value *ucontrol)
3030 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3031 hda_nid_t nid = get_amp_nid(kcontrol);
3032 int chs = get_amp_channels(kcontrol);
3033 int dir = get_amp_direction(kcontrol);
3034 int idx = get_amp_index(kcontrol);
3035 long *valp = ucontrol->value.integer.value;
3038 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
3039 HDA_AMP_MUTE) ? 0 : 1;
3041 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
3042 HDA_AMP_MUTE) ? 0 : 1;
3045 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
3048 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
3050 * The control element is supposed to have the private_value field
3051 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
3053 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
3054 struct snd_ctl_elem_value *ucontrol)
3056 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3057 hda_nid_t nid = get_amp_nid(kcontrol);
3058 int chs = get_amp_channels(kcontrol);
3059 int dir = get_amp_direction(kcontrol);
3060 int idx = get_amp_index(kcontrol);
3061 long *valp = ucontrol->value.integer.value;
3064 snd_hda_power_up(codec);
3066 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
3068 *valp ? 0 : HDA_AMP_MUTE);
3072 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
3074 *valp ? 0 : HDA_AMP_MUTE);
3075 hda_call_check_power_status(codec, nid);
3076 snd_hda_power_down(codec);
3079 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
3082 * bound volume controls
3084 * bind multiple volumes (# indices, from 0)
3087 #define AMP_VAL_IDX_SHIFT 19
3088 #define AMP_VAL_IDX_MASK (0x0f<<19)
3091 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
3093 * The control element is supposed to have the private_value field
3094 * set up via HDA_BIND_MUTE*() macros.
3096 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
3097 struct snd_ctl_elem_value *ucontrol)
3099 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3103 mutex_lock(&codec->control_mutex);
3104 pval = kcontrol->private_value;
3105 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
3106 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
3107 kcontrol->private_value = pval;
3108 mutex_unlock(&codec->control_mutex);
3111 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
3114 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
3116 * The control element is supposed to have the private_value field
3117 * set up via HDA_BIND_MUTE*() macros.
3119 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
3120 struct snd_ctl_elem_value *ucontrol)
3122 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3124 int i, indices, err = 0, change = 0;
3126 mutex_lock(&codec->control_mutex);
3127 pval = kcontrol->private_value;
3128 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
3129 for (i = 0; i < indices; i++) {
3130 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
3131 (i << AMP_VAL_IDX_SHIFT);
3132 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3137 kcontrol->private_value = pval;
3138 mutex_unlock(&codec->control_mutex);
3139 return err < 0 ? err : change;
3141 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
3144 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
3146 * The control element is supposed to have the private_value field
3147 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3149 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
3150 struct snd_ctl_elem_info *uinfo)
3152 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3153 struct hda_bind_ctls *c;
3156 mutex_lock(&codec->control_mutex);
3157 c = (struct hda_bind_ctls *)kcontrol->private_value;
3158 kcontrol->private_value = *c->values;
3159 err = c->ops->info(kcontrol, uinfo);
3160 kcontrol->private_value = (long)c;
3161 mutex_unlock(&codec->control_mutex);
3164 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
3167 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
3169 * The control element is supposed to have the private_value field
3170 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3172 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
3173 struct snd_ctl_elem_value *ucontrol)
3175 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3176 struct hda_bind_ctls *c;
3179 mutex_lock(&codec->control_mutex);
3180 c = (struct hda_bind_ctls *)kcontrol->private_value;
3181 kcontrol->private_value = *c->values;
3182 err = c->ops->get(kcontrol, ucontrol);
3183 kcontrol->private_value = (long)c;
3184 mutex_unlock(&codec->control_mutex);
3187 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
3190 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
3192 * The control element is supposed to have the private_value field
3193 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3195 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
3196 struct snd_ctl_elem_value *ucontrol)
3198 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3199 struct hda_bind_ctls *c;
3200 unsigned long *vals;
3201 int err = 0, change = 0;
3203 mutex_lock(&codec->control_mutex);
3204 c = (struct hda_bind_ctls *)kcontrol->private_value;
3205 for (vals = c->values; *vals; vals++) {
3206 kcontrol->private_value = *vals;
3207 err = c->ops->put(kcontrol, ucontrol);
3212 kcontrol->private_value = (long)c;
3213 mutex_unlock(&codec->control_mutex);
3214 return err < 0 ? err : change;
3216 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
3219 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3221 * The control element is supposed to have the private_value field
3222 * set up via HDA_BIND_VOL() macro.
3224 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3225 unsigned int size, unsigned int __user *tlv)
3227 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3228 struct hda_bind_ctls *c;
3231 mutex_lock(&codec->control_mutex);
3232 c = (struct hda_bind_ctls *)kcontrol->private_value;
3233 kcontrol->private_value = *c->values;
3234 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3235 kcontrol->private_value = (long)c;
3236 mutex_unlock(&codec->control_mutex);
3239 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
3241 struct hda_ctl_ops snd_hda_bind_vol = {
3242 .info = snd_hda_mixer_amp_volume_info,
3243 .get = snd_hda_mixer_amp_volume_get,
3244 .put = snd_hda_mixer_amp_volume_put,
3245 .tlv = snd_hda_mixer_amp_tlv
3247 EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
3249 struct hda_ctl_ops snd_hda_bind_sw = {
3250 .info = snd_hda_mixer_amp_switch_info,
3251 .get = snd_hda_mixer_amp_switch_get,
3252 .put = snd_hda_mixer_amp_switch_put,
3253 .tlv = snd_hda_mixer_amp_tlv
3255 EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
3258 * SPDIF out controls
3261 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3262 struct snd_ctl_elem_info *uinfo)
3264 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3269 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3270 struct snd_ctl_elem_value *ucontrol)
3272 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3273 IEC958_AES0_NONAUDIO |
3274 IEC958_AES0_CON_EMPHASIS_5015 |
3275 IEC958_AES0_CON_NOT_COPYRIGHT;
3276 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3277 IEC958_AES1_CON_ORIGINAL;
3281 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3282 struct snd_ctl_elem_value *ucontrol)
3284 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3285 IEC958_AES0_NONAUDIO |
3286 IEC958_AES0_PRO_EMPHASIS_5015;
3290 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3291 struct snd_ctl_elem_value *ucontrol)
3293 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3294 int idx = kcontrol->private_value;
3295 struct hda_spdif_out *spdif;
3297 mutex_lock(&codec->spdif_mutex);
3298 spdif = snd_array_elem(&codec->spdif_out, idx);
3299 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3300 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3301 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3302 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3303 mutex_unlock(&codec->spdif_mutex);
3308 /* convert from SPDIF status bits to HDA SPDIF bits
3309 * bit 0 (DigEn) is always set zero (to be filled later)
3311 static unsigned short convert_from_spdif_status(unsigned int sbits)
3313 unsigned short val = 0;
3315 if (sbits & IEC958_AES0_PROFESSIONAL)
3316 val |= AC_DIG1_PROFESSIONAL;
3317 if (sbits & IEC958_AES0_NONAUDIO)
3318 val |= AC_DIG1_NONAUDIO;
3319 if (sbits & IEC958_AES0_PROFESSIONAL) {
3320 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3321 IEC958_AES0_PRO_EMPHASIS_5015)
3322 val |= AC_DIG1_EMPHASIS;
3324 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3325 IEC958_AES0_CON_EMPHASIS_5015)
3326 val |= AC_DIG1_EMPHASIS;
3327 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3328 val |= AC_DIG1_COPYRIGHT;
3329 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3330 val |= AC_DIG1_LEVEL;
3331 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3336 /* convert to SPDIF status bits from HDA SPDIF bits
3338 static unsigned int convert_to_spdif_status(unsigned short val)
3340 unsigned int sbits = 0;
3342 if (val & AC_DIG1_NONAUDIO)
3343 sbits |= IEC958_AES0_NONAUDIO;
3344 if (val & AC_DIG1_PROFESSIONAL)
3345 sbits |= IEC958_AES0_PROFESSIONAL;
3346 if (sbits & IEC958_AES0_PROFESSIONAL) {
3347 if (val & AC_DIG1_EMPHASIS)
3348 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3350 if (val & AC_DIG1_EMPHASIS)
3351 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3352 if (!(val & AC_DIG1_COPYRIGHT))
3353 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3354 if (val & AC_DIG1_LEVEL)
3355 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3356 sbits |= val & (0x7f << 8);
3361 /* set digital convert verbs both for the given NID and its slaves */
3362 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3367 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3368 d = codec->slave_dig_outs;
3372 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3375 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3379 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3381 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3384 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3385 struct snd_ctl_elem_value *ucontrol)
3387 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3388 int idx = kcontrol->private_value;
3389 struct hda_spdif_out *spdif;
3394 mutex_lock(&codec->spdif_mutex);
3395 spdif = snd_array_elem(&codec->spdif_out, idx);
3397 spdif->status = ucontrol->value.iec958.status[0] |
3398 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3399 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3400 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3401 val = convert_from_spdif_status(spdif->status);
3402 val |= spdif->ctls & 1;
3403 change = spdif->ctls != val;
3405 if (change && nid != (u16)-1)
3406 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3407 mutex_unlock(&codec->spdif_mutex);
3411 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3413 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3414 struct snd_ctl_elem_value *ucontrol)
3416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3417 int idx = kcontrol->private_value;
3418 struct hda_spdif_out *spdif;
3420 mutex_lock(&codec->spdif_mutex);
3421 spdif = snd_array_elem(&codec->spdif_out, idx);
3422 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3423 mutex_unlock(&codec->spdif_mutex);
3427 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3430 set_dig_out_convert(codec, nid, dig1, dig2);
3431 /* unmute amp switch (if any) */
3432 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3433 (dig1 & AC_DIG1_ENABLE))
3434 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3438 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3439 struct snd_ctl_elem_value *ucontrol)
3441 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3442 int idx = kcontrol->private_value;
3443 struct hda_spdif_out *spdif;
3448 mutex_lock(&codec->spdif_mutex);
3449 spdif = snd_array_elem(&codec->spdif_out, idx);
3451 val = spdif->ctls & ~AC_DIG1_ENABLE;
3452 if (ucontrol->value.integer.value[0])
3453 val |= AC_DIG1_ENABLE;
3454 change = spdif->ctls != val;
3456 if (change && nid != (u16)-1)
3457 set_spdif_ctls(codec, nid, val & 0xff, -1);
3458 mutex_unlock(&codec->spdif_mutex);
3462 static struct snd_kcontrol_new dig_mixes[] = {
3464 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3465 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3466 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3467 .info = snd_hda_spdif_mask_info,
3468 .get = snd_hda_spdif_cmask_get,
3471 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3472 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3473 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3474 .info = snd_hda_spdif_mask_info,
3475 .get = snd_hda_spdif_pmask_get,
3478 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3479 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3480 .info = snd_hda_spdif_mask_info,
3481 .get = snd_hda_spdif_default_get,
3482 .put = snd_hda_spdif_default_put,
3485 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3486 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3487 .info = snd_hda_spdif_out_switch_info,
3488 .get = snd_hda_spdif_out_switch_get,
3489 .put = snd_hda_spdif_out_switch_put,
3495 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3496 * @codec: the HDA codec
3497 * @associated_nid: NID that new ctls associated with
3498 * @cvt_nid: converter NID
3499 * @type: HDA_PCM_TYPE_*
3500 * Creates controls related with the digital output.
3501 * Called from each patch supporting the digital out.
3503 * Returns 0 if successful, or a negative error code.
3505 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3506 hda_nid_t associated_nid,
3511 struct snd_kcontrol *kctl;
3512 struct snd_kcontrol_new *dig_mix;
3514 const int spdif_index = 16;
3515 struct hda_spdif_out *spdif;
3516 struct hda_bus *bus = codec->bus;
3518 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3519 type == HDA_PCM_TYPE_SPDIF) {
3521 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3522 type == HDA_PCM_TYPE_HDMI) {
3523 /* suppose a single SPDIF device */
3524 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3525 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3528 kctl->id.index = spdif_index;
3530 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3532 if (!bus->primary_dig_out_type)
3533 bus->primary_dig_out_type = type;
3535 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
3537 codec_err(codec, "too many IEC958 outputs\n");
3540 spdif = snd_array_new(&codec->spdif_out);
3543 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3544 kctl = snd_ctl_new1(dig_mix, codec);
3547 kctl->id.index = idx;
3548 kctl->private_value = codec->spdif_out.used - 1;
3549 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3553 spdif->nid = cvt_nid;
3554 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3555 AC_VERB_GET_DIGI_CONVERT_1, 0);
3556 spdif->status = convert_to_spdif_status(spdif->ctls);
3559 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
3561 /* get the hda_spdif_out entry from the given NID
3562 * call within spdif_mutex lock
3564 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3568 for (i = 0; i < codec->spdif_out.used; i++) {
3569 struct hda_spdif_out *spdif =
3570 snd_array_elem(&codec->spdif_out, i);
3571 if (spdif->nid == nid)
3576 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
3578 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3580 struct hda_spdif_out *spdif;
3582 mutex_lock(&codec->spdif_mutex);
3583 spdif = snd_array_elem(&codec->spdif_out, idx);
3584 spdif->nid = (u16)-1;
3585 mutex_unlock(&codec->spdif_mutex);
3587 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
3589 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3591 struct hda_spdif_out *spdif;
3594 mutex_lock(&codec->spdif_mutex);
3595 spdif = snd_array_elem(&codec->spdif_out, idx);
3596 if (spdif->nid != nid) {
3599 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3601 mutex_unlock(&codec->spdif_mutex);
3603 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
3606 * SPDIF sharing with analog output
3608 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3609 struct snd_ctl_elem_value *ucontrol)
3611 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3612 ucontrol->value.integer.value[0] = mout->share_spdif;
3616 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3617 struct snd_ctl_elem_value *ucontrol)
3619 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3620 mout->share_spdif = !!ucontrol->value.integer.value[0];
3624 static struct snd_kcontrol_new spdif_share_sw = {
3625 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3626 .name = "IEC958 Default PCM Playback Switch",
3627 .info = snd_ctl_boolean_mono_info,
3628 .get = spdif_share_sw_get,
3629 .put = spdif_share_sw_put,
3633 * snd_hda_create_spdif_share_sw - create Default PCM switch
3634 * @codec: the HDA codec
3635 * @mout: multi-out instance
3637 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3638 struct hda_multi_out *mout)
3640 struct snd_kcontrol *kctl;
3642 if (!mout->dig_out_nid)
3645 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3648 /* ATTENTION: here mout is passed as private_data, instead of codec */
3649 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3651 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
3657 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3659 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3660 struct snd_ctl_elem_value *ucontrol)
3662 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3664 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3668 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3669 struct snd_ctl_elem_value *ucontrol)
3671 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3672 hda_nid_t nid = kcontrol->private_value;
3673 unsigned int val = !!ucontrol->value.integer.value[0];
3676 mutex_lock(&codec->spdif_mutex);
3677 change = codec->spdif_in_enable != val;
3679 codec->spdif_in_enable = val;
3680 snd_hda_codec_write_cache(codec, nid, 0,
3681 AC_VERB_SET_DIGI_CONVERT_1, val);
3683 mutex_unlock(&codec->spdif_mutex);
3687 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3688 struct snd_ctl_elem_value *ucontrol)
3690 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3691 hda_nid_t nid = kcontrol->private_value;
3695 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3696 sbits = convert_to_spdif_status(val);
3697 ucontrol->value.iec958.status[0] = sbits;
3698 ucontrol->value.iec958.status[1] = sbits >> 8;
3699 ucontrol->value.iec958.status[2] = sbits >> 16;
3700 ucontrol->value.iec958.status[3] = sbits >> 24;
3704 static struct snd_kcontrol_new dig_in_ctls[] = {
3706 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3707 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3708 .info = snd_hda_spdif_in_switch_info,
3709 .get = snd_hda_spdif_in_switch_get,
3710 .put = snd_hda_spdif_in_switch_put,
3713 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3714 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3715 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3716 .info = snd_hda_spdif_mask_info,
3717 .get = snd_hda_spdif_in_status_get,
3723 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3724 * @codec: the HDA codec
3725 * @nid: audio in widget NID
3727 * Creates controls related with the SPDIF input.
3728 * Called from each patch supporting the SPDIF in.
3730 * Returns 0 if successful, or a negative error code.
3732 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3735 struct snd_kcontrol *kctl;
3736 struct snd_kcontrol_new *dig_mix;
3739 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3741 codec_err(codec, "too many IEC958 inputs\n");
3744 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3745 kctl = snd_ctl_new1(dig_mix, codec);
3748 kctl->private_value = nid;
3749 err = snd_hda_ctl_add(codec, nid, kctl);
3753 codec->spdif_in_enable =
3754 snd_hda_codec_read(codec, nid, 0,
3755 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3759 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
3765 /* build a 31bit cache key with the widget id and the command parameter */
3766 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3767 #define get_cmd_cache_nid(key) ((key) & 0xff)
3768 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3771 * snd_hda_codec_write_cache - send a single command with caching
3772 * @codec: the HDA codec
3773 * @nid: NID to send the command
3774 * @flags: optional bit flags
3775 * @verb: the verb to send
3776 * @parm: the parameter for the verb
3778 * Send a single command without waiting for response.
3780 * Returns 0 if successful, or a negative error code.
3782 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3783 int flags, unsigned int verb, unsigned int parm)
3786 struct hda_cache_head *c;
3788 unsigned int cache_only;
3790 cache_only = codec->cached_write;
3792 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
3797 /* parm may contain the verb stuff for get/set amp */
3798 verb = verb | (parm >> 8);
3800 key = build_cmd_cache_key(nid, verb);
3801 mutex_lock(&codec->bus->cmd_mutex);
3802 c = get_alloc_hash(&codec->cmd_cache, key);
3805 c->dirty = cache_only;
3807 mutex_unlock(&codec->bus->cmd_mutex);
3810 EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
3813 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3814 * @codec: the HDA codec
3815 * @nid: NID to send the command
3816 * @flags: optional bit flags
3817 * @verb: the verb to send
3818 * @parm: the parameter for the verb
3820 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3821 * command if the parameter is already identical with the cached value.
3822 * If not, it sends the command and refreshes the cache.
3824 * Returns 0 if successful, or a negative error code.
3826 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3827 int flags, unsigned int verb, unsigned int parm)
3829 struct hda_cache_head *c;
3832 /* parm may contain the verb stuff for get/set amp */
3833 verb = verb | (parm >> 8);
3835 key = build_cmd_cache_key(nid, verb);
3836 mutex_lock(&codec->bus->cmd_mutex);
3837 c = get_hash(&codec->cmd_cache, key);
3838 if (c && c->val == parm) {
3839 mutex_unlock(&codec->bus->cmd_mutex);
3842 mutex_unlock(&codec->bus->cmd_mutex);
3843 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
3845 EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
3848 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3849 * @codec: HD-audio codec
3851 * Execute all verbs recorded in the command caches to resume.
3853 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3857 mutex_lock(&codec->hash_mutex);
3858 codec->cached_write = 0;
3859 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3860 struct hda_cache_head *buffer;
3863 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3870 mutex_unlock(&codec->hash_mutex);
3871 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3872 get_cmd_cache_cmd(key), buffer->val);
3873 mutex_lock(&codec->hash_mutex);
3875 mutex_unlock(&codec->hash_mutex);
3877 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
3880 * snd_hda_sequence_write_cache - sequence writes with caching
3881 * @codec: the HDA codec
3882 * @seq: VERB array to send
3884 * Send the commands sequentially from the given array.
3885 * Thte commands are recorded on cache for power-save and resume.
3886 * The array must be terminated with NID=0.
3888 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3889 const struct hda_verb *seq)
3891 for (; seq->nid; seq++)
3892 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3895 EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
3898 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3899 * @codec: HD-audio codec
3901 void snd_hda_codec_flush_cache(struct hda_codec *codec)
3903 snd_hda_codec_resume_amp(codec);
3904 snd_hda_codec_resume_cache(codec);
3906 EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
3908 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3909 unsigned int power_state)
3911 hda_nid_t nid = codec->start_nid;
3914 for (i = 0; i < codec->num_nodes; i++, nid++) {
3915 unsigned int wcaps = get_wcaps(codec, nid);
3916 unsigned int state = power_state;
3917 if (!(wcaps & AC_WCAP_POWER))
3919 if (codec->power_filter) {
3920 state = codec->power_filter(codec, nid, power_state);
3921 if (state != power_state && power_state == AC_PWRST_D3)
3924 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3928 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
3931 * supported power states check
3933 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3934 unsigned int power_state)
3936 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3940 if (sup & power_state)
3947 * wait until the state is reached, returns the current state
3949 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3951 unsigned int power_state)
3953 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3954 unsigned int state, actual_state;
3957 state = snd_hda_codec_read(codec, fg, 0,
3958 AC_VERB_GET_POWER_STATE, 0);
3959 if (state & AC_PWRST_ERROR)
3961 actual_state = (state >> 4) & 0x0f;
3962 if (actual_state == power_state)
3964 if (time_after_eq(jiffies, end_time))
3966 /* wait until the codec reachs to the target state */
3972 /* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
3973 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3975 unsigned int power_state)
3977 if (nid == codec->afg || nid == codec->mfg)
3979 if (power_state == AC_PWRST_D3 &&
3980 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3981 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3982 int eapd = snd_hda_codec_read(codec, nid, 0,
3983 AC_VERB_GET_EAPD_BTLENABLE, 0);
3989 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
3992 * set power state of the codec, and return the power state
3994 static unsigned int hda_set_power_state(struct hda_codec *codec,
3995 unsigned int power_state)
3997 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
4002 /* this delay seems necessary to avoid click noise at power-down */
4003 if (power_state == AC_PWRST_D3) {
4004 if (codec->depop_delay < 0)
4005 msleep(codec->epss ? 10 : 100);
4006 else if (codec->depop_delay > 0)
4007 msleep(codec->depop_delay);
4008 flags = HDA_RW_NO_RESPONSE_FALLBACK;
4011 /* repeat power states setting at most 10 times*/
4012 for (count = 0; count < 10; count++) {
4013 if (codec->patch_ops.set_power_state)
4014 codec->patch_ops.set_power_state(codec, fg,
4017 state = power_state;
4018 if (codec->power_filter)
4019 state = codec->power_filter(codec, fg, state);
4020 if (state == power_state || power_state != AC_PWRST_D3)
4021 snd_hda_codec_read(codec, fg, flags,
4022 AC_VERB_SET_POWER_STATE,
4024 snd_hda_codec_set_power_to_all(codec, fg, power_state);
4026 state = hda_sync_power_state(codec, fg, power_state);
4027 if (!(state & AC_PWRST_ERROR))
4034 /* sync power states of all widgets;
4035 * this is called at the end of codec parsing
4037 static void sync_power_up_states(struct hda_codec *codec)
4039 hda_nid_t nid = codec->start_nid;
4042 /* don't care if no filter is used */
4043 if (!codec->power_filter)
4046 for (i = 0; i < codec->num_nodes; i++, nid++) {
4047 unsigned int wcaps = get_wcaps(codec, nid);
4048 unsigned int target;
4049 if (!(wcaps & AC_WCAP_POWER))
4051 target = codec->power_filter(codec, nid, AC_PWRST_D0);
4052 if (target == AC_PWRST_D0)
4054 if (!snd_hda_check_power_state(codec, nid, target))
4055 snd_hda_codec_write(codec, nid, 0,
4056 AC_VERB_SET_POWER_STATE, target);
4060 #ifdef CONFIG_SND_HDA_RECONFIG
4061 /* execute additional init verbs */
4062 static void hda_exec_init_verbs(struct hda_codec *codec)
4064 if (codec->init_verbs.list)
4065 snd_hda_sequence_write(codec, codec->init_verbs.list);
4068 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
4073 * call suspend and power-down; used both from PM and power-save
4074 * this function returns the power state in the end
4076 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
4082 if (codec->patch_ops.suspend)
4083 codec->patch_ops.suspend(codec);
4084 hda_cleanup_all_streams(codec);
4085 state = hda_set_power_state(codec, AC_PWRST_D3);
4086 /* Cancel delayed work if we aren't currently running from it. */
4088 cancel_delayed_work_sync(&codec->power_work);
4089 spin_lock(&codec->power_lock);
4090 snd_hda_update_power_acct(codec);
4091 trace_hda_power_down(codec);
4092 codec->power_on = 0;
4093 codec->power_transition = 0;
4094 codec->power_jiffies = jiffies;
4095 spin_unlock(&codec->power_lock);
4100 /* mark all entries of cmd and amp caches dirty */
4101 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
4104 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
4105 struct hda_cache_head *cmd;
4106 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
4109 for (i = 0; i < codec->amp_cache.buf.used; i++) {
4110 struct hda_amp_info *amp;
4111 amp = snd_array_elem(&codec->amp_cache.buf, i);
4112 amp->head.dirty = 1;
4117 * kick up codec; used both from PM and power-save
4119 static void hda_call_codec_resume(struct hda_codec *codec)
4123 hda_mark_cmd_cache_dirty(codec);
4125 /* set as if powered on for avoiding re-entering the resume
4126 * in the resume / power-save sequence
4128 hda_keep_power_on(codec);
4129 hda_set_power_state(codec, AC_PWRST_D0);
4130 restore_shutup_pins(codec);
4131 hda_exec_init_verbs(codec);
4132 snd_hda_jack_set_dirty_all(codec);
4133 if (codec->patch_ops.resume)
4134 codec->patch_ops.resume(codec);
4136 if (codec->patch_ops.init)
4137 codec->patch_ops.init(codec);
4138 snd_hda_codec_resume_amp(codec);
4139 snd_hda_codec_resume_cache(codec);
4142 if (codec->jackpoll_interval)
4143 hda_jackpoll_work(&codec->jackpoll_work.work);
4145 snd_hda_jack_report_sync(codec);
4148 snd_hda_power_down(codec); /* flag down before returning */
4150 #endif /* CONFIG_PM */
4154 * snd_hda_build_controls - build mixer controls
4157 * Creates mixer controls for each codec included in the bus.
4159 * Returns 0 if successful, otherwise a negative error code.
4161 int snd_hda_build_controls(struct hda_bus *bus)
4163 struct hda_codec *codec;
4165 list_for_each_entry(codec, &bus->codec_list, list) {
4166 int err = snd_hda_codec_build_controls(codec);
4169 "cannot build controls for #%d (error %d)\n",
4171 err = snd_hda_codec_reset(codec);
4174 "cannot revert codec\n");
4181 EXPORT_SYMBOL_GPL(snd_hda_build_controls);
4184 * add standard channel maps if not specified
4186 static int add_std_chmaps(struct hda_codec *codec)
4190 for (i = 0; i < codec->num_pcms; i++) {
4191 for (str = 0; str < 2; str++) {
4192 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4193 struct hda_pcm_stream *hinfo =
4194 &codec->pcm_info[i].stream[str];
4195 struct snd_pcm_chmap *chmap;
4196 const struct snd_pcm_chmap_elem *elem;
4198 if (codec->pcm_info[i].own_chmap)
4200 if (!pcm || !hinfo->substreams)
4202 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4203 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
4204 hinfo->channels_max,
4208 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4214 /* default channel maps for 2.1 speakers;
4215 * since HD-audio supports only stereo, odd number channels are omitted
4217 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4219 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4221 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4222 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4225 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4227 int snd_hda_codec_build_controls(struct hda_codec *codec)
4230 hda_exec_init_verbs(codec);
4231 /* continue to initialize... */
4232 if (codec->patch_ops.init)
4233 err = codec->patch_ops.init(codec);
4234 if (!err && codec->patch_ops.build_controls)
4235 err = codec->patch_ops.build_controls(codec);
4239 /* we create chmaps here instead of build_pcms */
4240 err = add_std_chmaps(codec);
4244 if (codec->jackpoll_interval)
4245 hda_jackpoll_work(&codec->jackpoll_work.work);
4247 snd_hda_jack_report_sync(codec); /* call at the last init point */
4248 sync_power_up_states(codec);
4255 struct hda_rate_tbl {
4257 unsigned int alsa_bits;
4258 unsigned int hda_fmt;
4261 /* rate = base * mult / div */
4262 #define HDA_RATE(base, mult, div) \
4263 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4264 (((div) - 1) << AC_FMT_DIV_SHIFT))
4266 static struct hda_rate_tbl rate_bits[] = {
4267 /* rate in Hz, ALSA rate bitmask, HDA format value */
4269 /* autodetected value used in snd_hda_query_supported_pcm */
4270 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4271 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4272 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4273 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4274 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4275 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4276 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4277 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4278 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4279 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4280 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
4281 #define AC_PAR_PCM_RATE_BITS 11
4282 /* up to bits 10, 384kHZ isn't supported properly */
4284 /* not autodetected value */
4285 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
4287 { 0 } /* terminator */
4291 * snd_hda_calc_stream_format - calculate format bitset
4292 * @codec: HD-audio codec
4293 * @rate: the sample rate
4294 * @channels: the number of channels
4295 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4296 * @maxbps: the max. bps
4298 * Calculate the format bitset from the given rate, channels and th PCM format.
4300 * Return zero if invalid.
4302 unsigned int snd_hda_calc_stream_format(struct hda_codec *codec,
4304 unsigned int channels,
4305 unsigned int format,
4306 unsigned int maxbps,
4307 unsigned short spdif_ctls)
4310 unsigned int val = 0;
4312 for (i = 0; rate_bits[i].hz; i++)
4313 if (rate_bits[i].hz == rate) {
4314 val = rate_bits[i].hda_fmt;
4317 if (!rate_bits[i].hz) {
4318 codec_dbg(codec, "invalid rate %d\n", rate);
4322 if (channels == 0 || channels > 8) {
4323 codec_dbg(codec, "invalid channels %d\n", channels);
4326 val |= channels - 1;
4328 switch (snd_pcm_format_width(format)) {
4330 val |= AC_FMT_BITS_8;
4333 val |= AC_FMT_BITS_16;
4338 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
4339 val |= AC_FMT_BITS_32;
4340 else if (maxbps >= 24)
4341 val |= AC_FMT_BITS_24;
4343 val |= AC_FMT_BITS_20;
4346 codec_dbg(codec, "invalid format width %d\n",
4347 snd_pcm_format_width(format));
4351 if (spdif_ctls & AC_DIG1_NONAUDIO)
4352 val |= AC_FMT_TYPE_NON_PCM;
4356 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
4358 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4361 unsigned int val = 0;
4362 if (nid != codec->afg &&
4363 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4364 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4365 if (!val || val == -1)
4366 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4367 if (!val || val == -1)
4372 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4374 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4378 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4381 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4382 if (!streams || streams == -1)
4383 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4384 if (!streams || streams == -1)
4389 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4391 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4396 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4397 * @codec: the HDA codec
4398 * @nid: NID to query
4399 * @ratesp: the pointer to store the detected rate bitflags
4400 * @formatsp: the pointer to store the detected formats
4401 * @bpsp: the pointer to store the detected format widths
4403 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4404 * or @bsps argument is ignored.
4406 * Returns 0 if successful, otherwise a negative error code.
4408 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4409 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4411 unsigned int i, val, wcaps;
4413 wcaps = get_wcaps(codec, nid);
4414 val = query_pcm_param(codec, nid);
4418 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4420 rates |= rate_bits[i].alsa_bits;
4424 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",
4426 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4432 if (formatsp || bpsp) {
4434 unsigned int streams, bps;
4436 streams = query_stream_param(codec, nid);
4441 if (streams & AC_SUPFMT_PCM) {
4442 if (val & AC_SUPPCM_BITS_8) {
4443 formats |= SNDRV_PCM_FMTBIT_U8;
4446 if (val & AC_SUPPCM_BITS_16) {
4447 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4450 if (wcaps & AC_WCAP_DIGITAL) {
4451 if (val & AC_SUPPCM_BITS_32)
4452 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4453 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4454 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4455 if (val & AC_SUPPCM_BITS_24)
4457 else if (val & AC_SUPPCM_BITS_20)
4459 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4460 AC_SUPPCM_BITS_32)) {
4461 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4462 if (val & AC_SUPPCM_BITS_32)
4464 else if (val & AC_SUPPCM_BITS_24)
4466 else if (val & AC_SUPPCM_BITS_20)
4470 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4471 if (streams & AC_SUPFMT_FLOAT32) {
4472 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4477 if (streams == AC_SUPFMT_AC3) {
4478 /* should be exclusive */
4479 /* temporary hack: we have still no proper support
4480 * for the direct AC3 stream...
4482 formats |= SNDRV_PCM_FMTBIT_U8;
4487 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",
4489 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4494 *formatsp = formats;
4501 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
4504 * snd_hda_is_supported_format - Check the validity of the format
4505 * @codec: HD-audio codec
4506 * @nid: NID to check
4507 * @format: the HD-audio format value to check
4509 * Check whether the given node supports the format value.
4511 * Returns 1 if supported, 0 if not.
4513 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4514 unsigned int format)
4517 unsigned int val = 0, rate, stream;
4519 val = query_pcm_param(codec, nid);
4523 rate = format & 0xff00;
4524 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4525 if (rate_bits[i].hda_fmt == rate) {
4530 if (i >= AC_PAR_PCM_RATE_BITS)
4533 stream = query_stream_param(codec, nid);
4537 if (stream & AC_SUPFMT_PCM) {
4538 switch (format & 0xf0) {
4540 if (!(val & AC_SUPPCM_BITS_8))
4544 if (!(val & AC_SUPPCM_BITS_16))
4548 if (!(val & AC_SUPPCM_BITS_20))
4552 if (!(val & AC_SUPPCM_BITS_24))
4556 if (!(val & AC_SUPPCM_BITS_32))
4563 /* FIXME: check for float32 and AC3? */
4568 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
4573 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4574 struct hda_codec *codec,
4575 struct snd_pcm_substream *substream)
4580 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4581 struct hda_codec *codec,
4582 unsigned int stream_tag,
4583 unsigned int format,
4584 struct snd_pcm_substream *substream)
4586 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4590 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4591 struct hda_codec *codec,
4592 struct snd_pcm_substream *substream)
4594 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4598 static int set_pcm_default_values(struct hda_codec *codec,
4599 struct hda_pcm_stream *info)
4603 /* query support PCM information from the given NID */
4604 if (info->nid && (!info->rates || !info->formats)) {
4605 err = snd_hda_query_supported_pcm(codec, info->nid,
4606 info->rates ? NULL : &info->rates,
4607 info->formats ? NULL : &info->formats,
4608 info->maxbps ? NULL : &info->maxbps);
4612 if (info->ops.open == NULL)
4613 info->ops.open = hda_pcm_default_open_close;
4614 if (info->ops.close == NULL)
4615 info->ops.close = hda_pcm_default_open_close;
4616 if (info->ops.prepare == NULL) {
4617 if (snd_BUG_ON(!info->nid))
4619 info->ops.prepare = hda_pcm_default_prepare;
4621 if (info->ops.cleanup == NULL) {
4622 if (snd_BUG_ON(!info->nid))
4624 info->ops.cleanup = hda_pcm_default_cleanup;
4630 * codec prepare/cleanup entries
4632 int snd_hda_codec_prepare(struct hda_codec *codec,
4633 struct hda_pcm_stream *hinfo,
4634 unsigned int stream,
4635 unsigned int format,
4636 struct snd_pcm_substream *substream)
4639 mutex_lock(&codec->bus->prepare_mutex);
4640 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4642 purify_inactive_streams(codec);
4643 mutex_unlock(&codec->bus->prepare_mutex);
4646 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
4648 void snd_hda_codec_cleanup(struct hda_codec *codec,
4649 struct hda_pcm_stream *hinfo,
4650 struct snd_pcm_substream *substream)
4652 mutex_lock(&codec->bus->prepare_mutex);
4653 hinfo->ops.cleanup(hinfo, codec, substream);
4654 mutex_unlock(&codec->bus->prepare_mutex);
4656 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
4659 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4660 "Audio", "SPDIF", "HDMI", "Modem"
4664 * get the empty PCM device number to assign
4666 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
4668 /* audio device indices; not linear to keep compatibility */
4669 /* assigned to static slots up to dev#10; if more needed, assign
4670 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4672 static int audio_idx[HDA_PCM_NTYPES][5] = {
4673 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4674 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4675 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4676 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4680 if (type >= HDA_PCM_NTYPES) {
4681 dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
4685 for (i = 0; audio_idx[type][i] >= 0; i++) {
4686 #ifndef CONFIG_SND_DYNAMIC_MINORS
4687 if (audio_idx[type][i] >= 8)
4690 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4691 return audio_idx[type][i];
4694 #ifdef CONFIG_SND_DYNAMIC_MINORS
4695 /* non-fixed slots starting from 10 */
4696 for (i = 10; i < 32; i++) {
4697 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4702 dev_warn(bus->card->dev, "Too many %s devices\n",
4703 snd_hda_pcm_type_name[type]);
4704 #ifndef CONFIG_SND_DYNAMIC_MINORS
4705 dev_warn(bus->card->dev,
4706 "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
4712 * attach a new PCM stream
4714 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4716 struct hda_bus *bus = codec->bus;
4717 struct hda_pcm_stream *info;
4720 if (snd_BUG_ON(!pcm->name))
4722 for (stream = 0; stream < 2; stream++) {
4723 info = &pcm->stream[stream];
4724 if (info->substreams) {
4725 err = set_pcm_default_values(codec, info);
4730 return bus->ops.attach_pcm(bus, codec, pcm);
4733 /* assign all PCMs of the given codec */
4734 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4739 if (!codec->num_pcms) {
4740 if (!codec->patch_ops.build_pcms)
4742 err = codec->patch_ops.build_pcms(codec);
4745 "cannot build PCMs for #%d (error %d)\n",
4747 err = snd_hda_codec_reset(codec);
4750 "cannot revert codec\n");
4755 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4756 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4759 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4760 continue; /* no substreams assigned */
4763 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4765 continue; /* no fatal error */
4767 err = snd_hda_attach_pcm(codec, cpcm);
4770 "cannot attach PCM stream %d for codec #%d\n",
4772 continue; /* no fatal error */
4780 * snd_hda_build_pcms - build PCM information
4783 * Create PCM information for each codec included in the bus.
4785 * The build_pcms codec patch is requested to set up codec->num_pcms and
4786 * codec->pcm_info properly. The array is referred by the top-level driver
4787 * to create its PCM instances.
4788 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4791 * At least, substreams, channels_min and channels_max must be filled for
4792 * each stream. substreams = 0 indicates that the stream doesn't exist.
4793 * When rates and/or formats are zero, the supported values are queried
4794 * from the given nid. The nid is used also by the default ops.prepare
4795 * and ops.cleanup callbacks.
4797 * The driver needs to call ops.open in its open callback. Similarly,
4798 * ops.close is supposed to be called in the close callback.
4799 * ops.prepare should be called in the prepare or hw_params callback
4800 * with the proper parameters for set up.
4801 * ops.cleanup should be called in hw_free for clean up of streams.
4803 * This function returns 0 if successful, or a negative error code.
4805 int snd_hda_build_pcms(struct hda_bus *bus)
4807 struct hda_codec *codec;
4809 list_for_each_entry(codec, &bus->codec_list, list) {
4810 int err = snd_hda_codec_build_pcms(codec);
4816 EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
4819 * snd_hda_check_board_config - compare the current codec with the config table
4820 * @codec: the HDA codec
4821 * @num_configs: number of config enums
4822 * @models: array of model name strings
4823 * @tbl: configuration table, terminated by null entries
4825 * Compares the modelname or PCI subsystem id of the current codec with the
4826 * given configuration table. If a matching entry is found, returns its
4827 * config value (supposed to be 0 or positive).
4829 * If no entries are matching, the function returns a negative value.
4831 int snd_hda_check_board_config(struct hda_codec *codec,
4832 int num_configs, const char * const *models,
4833 const struct snd_pci_quirk *tbl)
4835 if (codec->modelname && models) {
4837 for (i = 0; i < num_configs; i++) {
4839 !strcmp(codec->modelname, models[i])) {
4840 codec_info(codec, "model '%s' is selected\n",
4847 if (!codec->bus->pci || !tbl)
4850 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4853 if (tbl->value >= 0 && tbl->value < num_configs) {
4854 #ifdef CONFIG_SND_DEBUG_VERBOSE
4856 const char *model = NULL;
4858 model = models[tbl->value];
4860 sprintf(tmp, "#%d", tbl->value);
4863 codec_info(codec, "model '%s' is selected for config %x:%x (%s)\n",
4864 model, tbl->subvendor, tbl->subdevice,
4865 (tbl->name ? tbl->name : "Unknown device"));
4871 EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
4874 * snd_hda_check_board_codec_sid_config - compare the current codec
4875 subsystem ID with the
4878 This is important for Gateway notebooks with SB450 HDA Audio
4879 where the vendor ID of the PCI device is:
4880 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4881 and the vendor/subvendor are found only at the codec.
4883 * @codec: the HDA codec
4884 * @num_configs: number of config enums
4885 * @models: array of model name strings
4886 * @tbl: configuration table, terminated by null entries
4888 * Compares the modelname or PCI subsystem id of the current codec with the
4889 * given configuration table. If a matching entry is found, returns its
4890 * config value (supposed to be 0 or positive).
4892 * If no entries are matching, the function returns a negative value.
4894 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4895 int num_configs, const char * const *models,
4896 const struct snd_pci_quirk *tbl)
4898 const struct snd_pci_quirk *q;
4900 /* Search for codec ID */
4901 for (q = tbl; q->subvendor; q++) {
4902 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4903 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4904 if ((codec->subsystem_id & mask) == id)
4913 if (tbl->value >= 0 && tbl->value < num_configs) {
4914 #ifdef CONFIG_SND_DEBUG_VERBOSE
4916 const char *model = NULL;
4918 model = models[tbl->value];
4920 sprintf(tmp, "#%d", tbl->value);
4923 codec_info(codec, "model '%s' is selected for config %x:%x (%s)\n",
4924 model, tbl->subvendor, tbl->subdevice,
4925 (tbl->name ? tbl->name : "Unknown device"));
4931 EXPORT_SYMBOL_GPL(snd_hda_check_board_codec_sid_config);
4934 * snd_hda_add_new_ctls - create controls from the array
4935 * @codec: the HDA codec
4936 * @knew: the array of struct snd_kcontrol_new
4938 * This helper function creates and add new controls in the given array.
4939 * The array must be terminated with an empty entry as terminator.
4941 * Returns 0 if successful, or a negative error code.
4943 int snd_hda_add_new_ctls(struct hda_codec *codec,
4944 const struct snd_kcontrol_new *knew)
4948 for (; knew->name; knew++) {
4949 struct snd_kcontrol *kctl;
4950 int addr = 0, idx = 0;
4951 if (knew->iface == -1) /* skip this codec private value */
4954 kctl = snd_ctl_new1(knew, codec);
4958 kctl->id.device = addr;
4960 kctl->id.index = idx;
4961 err = snd_hda_ctl_add(codec, 0, kctl);
4964 /* try first with another device index corresponding to
4965 * the codec addr; if it still fails (or it's the
4966 * primary codec), then try another control index
4968 if (!addr && codec->addr)
4970 else if (!idx && !knew->index) {
4971 idx = find_empty_mixer_ctl_idx(codec,
4981 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
4984 static void hda_power_work(struct work_struct *work)
4986 struct hda_codec *codec =
4987 container_of(work, struct hda_codec, power_work.work);
4988 struct hda_bus *bus = codec->bus;
4991 spin_lock(&codec->power_lock);
4992 if (codec->power_transition > 0) { /* during power-up sequence? */
4993 spin_unlock(&codec->power_lock);
4996 if (!codec->power_on || codec->power_count) {
4997 codec->power_transition = 0;
4998 spin_unlock(&codec->power_lock);
5001 spin_unlock(&codec->power_lock);
5003 state = hda_call_codec_suspend(codec, true);
5004 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK))
5005 hda_call_pm_notify(codec, false);
5008 static void hda_keep_power_on(struct hda_codec *codec)
5010 spin_lock(&codec->power_lock);
5011 codec->power_count++;
5012 codec->power_on = 1;
5013 codec->power_jiffies = jiffies;
5014 spin_unlock(&codec->power_lock);
5015 hda_call_pm_notify(codec, true);
5018 /* update the power on/off account with the current jiffies */
5019 void snd_hda_update_power_acct(struct hda_codec *codec)
5021 unsigned long delta = jiffies - codec->power_jiffies;
5022 if (codec->power_on)
5023 codec->power_on_acct += delta;
5025 codec->power_off_acct += delta;
5026 codec->power_jiffies += delta;
5029 /* Transition to powered up, if wait_power_down then wait for a pending
5030 * transition to D3 to complete. A pending D3 transition is indicated
5031 * with power_transition == -1. */
5032 /* call this with codec->power_lock held! */
5033 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
5035 /* Return if power_on or transitioning to power_on, unless currently
5037 if ((codec->power_on || codec->power_transition > 0) &&
5038 !(wait_power_down && codec->power_transition < 0))
5040 spin_unlock(&codec->power_lock);
5042 cancel_delayed_work_sync(&codec->power_work);
5044 spin_lock(&codec->power_lock);
5045 /* If the power down delayed work was cancelled above before starting,
5046 * then there is no need to go through power up here.
5048 if (codec->power_on) {
5049 if (codec->power_transition < 0)
5050 codec->power_transition = 0;
5054 trace_hda_power_up(codec);
5055 snd_hda_update_power_acct(codec);
5056 codec->power_on = 1;
5057 codec->power_jiffies = jiffies;
5058 codec->power_transition = 1; /* avoid reentrance */
5059 spin_unlock(&codec->power_lock);
5061 hda_call_codec_resume(codec);
5063 spin_lock(&codec->power_lock);
5064 codec->power_transition = 0;
5067 #define power_save(codec) \
5068 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
5070 /* Transition to powered down */
5071 static void __snd_hda_power_down(struct hda_codec *codec)
5073 if (!codec->power_on || codec->power_count || codec->power_transition)
5076 if (power_save(codec)) {
5077 codec->power_transition = -1; /* avoid reentrance */
5078 queue_delayed_work(codec->bus->workq, &codec->power_work,
5079 msecs_to_jiffies(power_save(codec) * 1000));
5084 * snd_hda_power_save - Power-up/down/sync the codec
5085 * @codec: HD-audio codec
5086 * @delta: the counter delta to change
5088 * Change the power-up counter via @delta, and power up or down the hardware
5089 * appropriately. For the power-down, queue to the delayed action.
5090 * Passing zero to @delta means to synchronize the power state.
5092 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
5094 spin_lock(&codec->power_lock);
5095 codec->power_count += delta;
5096 trace_hda_power_count(codec);
5098 __snd_hda_power_up(codec, d3wait);
5100 __snd_hda_power_down(codec);
5101 spin_unlock(&codec->power_lock);
5103 EXPORT_SYMBOL_GPL(snd_hda_power_save);
5106 * snd_hda_check_amp_list_power - Check the amp list and update the power
5107 * @codec: HD-audio codec
5108 * @check: the object containing an AMP list and the status
5109 * @nid: NID to check / update
5111 * Check whether the given NID is in the amp list. If it's in the list,
5112 * check the current AMP status, and update the the power-status according
5113 * to the mute status.
5115 * This function is supposed to be set or called from the check_power_status
5118 int snd_hda_check_amp_list_power(struct hda_codec *codec,
5119 struct hda_loopback_check *check,
5122 const struct hda_amp_list *p;
5125 if (!check->amplist)
5127 for (p = check->amplist; p->nid; p++) {
5132 return 0; /* nothing changed */
5134 for (p = check->amplist; p->nid; p++) {
5135 for (ch = 0; ch < 2; ch++) {
5136 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
5138 if (!(v & HDA_AMP_MUTE) && v > 0) {
5139 if (!check->power_on) {
5140 check->power_on = 1;
5141 snd_hda_power_up(codec);
5147 if (check->power_on) {
5148 check->power_on = 0;
5149 snd_hda_power_down(codec);
5153 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
5157 * Channel mode helper
5161 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5163 int snd_hda_ch_mode_info(struct hda_codec *codec,
5164 struct snd_ctl_elem_info *uinfo,
5165 const struct hda_channel_mode *chmode,
5168 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5170 uinfo->value.enumerated.items = num_chmodes;
5171 if (uinfo->value.enumerated.item >= num_chmodes)
5172 uinfo->value.enumerated.item = num_chmodes - 1;
5173 sprintf(uinfo->value.enumerated.name, "%dch",
5174 chmode[uinfo->value.enumerated.item].channels);
5177 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
5180 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5182 int snd_hda_ch_mode_get(struct hda_codec *codec,
5183 struct snd_ctl_elem_value *ucontrol,
5184 const struct hda_channel_mode *chmode,
5190 for (i = 0; i < num_chmodes; i++) {
5191 if (max_channels == chmode[i].channels) {
5192 ucontrol->value.enumerated.item[0] = i;
5198 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
5201 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5203 int snd_hda_ch_mode_put(struct hda_codec *codec,
5204 struct snd_ctl_elem_value *ucontrol,
5205 const struct hda_channel_mode *chmode,
5211 mode = ucontrol->value.enumerated.item[0];
5212 if (mode >= num_chmodes)
5214 if (*max_channelsp == chmode[mode].channels)
5216 /* change the current channel setting */
5217 *max_channelsp = chmode[mode].channels;
5218 if (chmode[mode].sequence)
5219 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5222 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
5229 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5231 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5232 struct snd_ctl_elem_info *uinfo)
5236 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5238 uinfo->value.enumerated.items = imux->num_items;
5239 if (!imux->num_items)
5241 index = uinfo->value.enumerated.item;
5242 if (index >= imux->num_items)
5243 index = imux->num_items - 1;
5244 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5247 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
5250 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5252 int snd_hda_input_mux_put(struct hda_codec *codec,
5253 const struct hda_input_mux *imux,
5254 struct snd_ctl_elem_value *ucontrol,
5256 unsigned int *cur_val)
5260 if (!imux->num_items)
5262 idx = ucontrol->value.enumerated.item[0];
5263 if (idx >= imux->num_items)
5264 idx = imux->num_items - 1;
5265 if (*cur_val == idx)
5267 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5268 imux->items[idx].index);
5272 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
5276 * process kcontrol info callback of a simple string enum array
5277 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5279 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5280 struct snd_ctl_elem_info *uinfo,
5281 int num_items, const char * const *texts)
5283 static const char * const texts_default[] = {
5284 "Disabled", "Enabled"
5287 if (!texts || !num_items) {
5289 texts = texts_default;
5292 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5294 uinfo->value.enumerated.items = num_items;
5295 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5296 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5297 strcpy(uinfo->value.enumerated.name,
5298 texts[uinfo->value.enumerated.item]);
5301 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
5304 * Multi-channel / digital-out PCM helper functions
5307 /* setup SPDIF output stream */
5308 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5309 unsigned int stream_tag, unsigned int format)
5311 struct hda_spdif_out *spdif;
5312 unsigned int curr_fmt;
5315 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5316 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5317 AC_VERB_GET_STREAM_FORMAT, 0);
5318 reset = codec->spdif_status_reset &&
5319 (spdif->ctls & AC_DIG1_ENABLE) &&
5322 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5325 set_dig_out_convert(codec, nid,
5326 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
5328 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
5329 if (codec->slave_dig_outs) {
5331 for (d = codec->slave_dig_outs; *d; d++)
5332 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5335 /* turn on again (if needed) */
5337 set_dig_out_convert(codec, nid,
5338 spdif->ctls & 0xff, -1);
5341 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5343 snd_hda_codec_cleanup_stream(codec, nid);
5344 if (codec->slave_dig_outs) {
5346 for (d = codec->slave_dig_outs; *d; d++)
5347 snd_hda_codec_cleanup_stream(codec, *d);
5352 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5353 * @bus: HD-audio bus
5355 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5357 struct hda_codec *codec;
5361 list_for_each_entry(codec, &bus->codec_list, list) {
5362 if (hda_codec_is_power_on(codec) &&
5363 codec->patch_ops.reboot_notify)
5364 codec->patch_ops.reboot_notify(codec);
5367 EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
5370 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5372 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5373 struct hda_multi_out *mout)
5375 mutex_lock(&codec->spdif_mutex);
5376 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5377 /* already opened as analog dup; reset it once */
5378 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5379 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5380 mutex_unlock(&codec->spdif_mutex);
5383 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
5386 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5388 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5389 struct hda_multi_out *mout,
5390 unsigned int stream_tag,
5391 unsigned int format,
5392 struct snd_pcm_substream *substream)
5394 mutex_lock(&codec->spdif_mutex);
5395 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5396 mutex_unlock(&codec->spdif_mutex);
5399 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
5402 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5404 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5405 struct hda_multi_out *mout)
5407 mutex_lock(&codec->spdif_mutex);
5408 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5409 mutex_unlock(&codec->spdif_mutex);
5412 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
5415 * snd_hda_multi_out_dig_close - release the digital out stream
5417 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5418 struct hda_multi_out *mout)
5420 mutex_lock(&codec->spdif_mutex);
5421 mout->dig_out_used = 0;
5422 mutex_unlock(&codec->spdif_mutex);
5425 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
5428 * snd_hda_multi_out_analog_open - open analog outputs
5430 * Open analog outputs and set up the hw-constraints.
5431 * If the digital outputs can be opened as slave, open the digital
5434 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5435 struct hda_multi_out *mout,
5436 struct snd_pcm_substream *substream,
5437 struct hda_pcm_stream *hinfo)
5439 struct snd_pcm_runtime *runtime = substream->runtime;
5440 runtime->hw.channels_max = mout->max_channels;
5441 if (mout->dig_out_nid) {
5442 if (!mout->analog_rates) {
5443 mout->analog_rates = hinfo->rates;
5444 mout->analog_formats = hinfo->formats;
5445 mout->analog_maxbps = hinfo->maxbps;
5447 runtime->hw.rates = mout->analog_rates;
5448 runtime->hw.formats = mout->analog_formats;
5449 hinfo->maxbps = mout->analog_maxbps;
5451 if (!mout->spdif_rates) {
5452 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5454 &mout->spdif_formats,
5455 &mout->spdif_maxbps);
5457 mutex_lock(&codec->spdif_mutex);
5458 if (mout->share_spdif) {
5459 if ((runtime->hw.rates & mout->spdif_rates) &&
5460 (runtime->hw.formats & mout->spdif_formats)) {
5461 runtime->hw.rates &= mout->spdif_rates;
5462 runtime->hw.formats &= mout->spdif_formats;
5463 if (mout->spdif_maxbps < hinfo->maxbps)
5464 hinfo->maxbps = mout->spdif_maxbps;
5466 mout->share_spdif = 0;
5467 /* FIXME: need notify? */
5470 mutex_unlock(&codec->spdif_mutex);
5472 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5473 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5475 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
5478 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5480 * Set up the i/o for analog out.
5481 * When the digital out is available, copy the front out to digital out, too.
5483 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5484 struct hda_multi_out *mout,
5485 unsigned int stream_tag,
5486 unsigned int format,
5487 struct snd_pcm_substream *substream)
5489 const hda_nid_t *nids = mout->dac_nids;
5490 int chs = substream->runtime->channels;
5491 struct hda_spdif_out *spdif;
5494 mutex_lock(&codec->spdif_mutex);
5495 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5496 if (mout->dig_out_nid && mout->share_spdif &&
5497 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5499 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5501 !(spdif->status & IEC958_AES0_NONAUDIO)) {
5502 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5503 setup_dig_out_stream(codec, mout->dig_out_nid,
5504 stream_tag, format);
5506 mout->dig_out_used = 0;
5507 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5510 mutex_unlock(&codec->spdif_mutex);
5513 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5515 if (!mout->no_share_stream &&
5516 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5517 /* headphone out will just decode front left/right (stereo) */
5518 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5520 /* extra outputs copied from front */
5521 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5522 if (!mout->no_share_stream && mout->hp_out_nid[i])
5523 snd_hda_codec_setup_stream(codec,
5524 mout->hp_out_nid[i],
5525 stream_tag, 0, format);
5528 for (i = 1; i < mout->num_dacs; i++) {
5529 if (chs >= (i + 1) * 2) /* independent out */
5530 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5532 else if (!mout->no_share_stream) /* copy front */
5533 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5537 /* extra surrounds */
5538 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
5540 if (!mout->extra_out_nid[i])
5542 if (chs >= (i + 1) * 2)
5544 else if (!mout->no_share_stream)
5546 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
5547 stream_tag, ch, format);
5552 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
5555 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5557 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5558 struct hda_multi_out *mout)
5560 const hda_nid_t *nids = mout->dac_nids;
5563 for (i = 0; i < mout->num_dacs; i++)
5564 snd_hda_codec_cleanup_stream(codec, nids[i]);
5566 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5567 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5568 if (mout->hp_out_nid[i])
5569 snd_hda_codec_cleanup_stream(codec,
5570 mout->hp_out_nid[i]);
5571 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5572 if (mout->extra_out_nid[i])
5573 snd_hda_codec_cleanup_stream(codec,
5574 mout->extra_out_nid[i]);
5575 mutex_lock(&codec->spdif_mutex);
5576 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5577 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5578 mout->dig_out_used = 0;
5580 mutex_unlock(&codec->spdif_mutex);
5583 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
5586 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5588 * Guess the suitable VREF pin bits to be set as the pin-control value.
5589 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5591 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5593 unsigned int pincap;
5594 unsigned int oldval;
5595 oldval = snd_hda_codec_read(codec, pin, 0,
5596 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5597 pincap = snd_hda_query_pin_caps(codec, pin);
5598 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5599 /* Exception: if the default pin setup is vref50, we give it priority */
5600 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5601 return AC_PINCTL_VREF_80;
5602 else if (pincap & AC_PINCAP_VREF_50)
5603 return AC_PINCTL_VREF_50;
5604 else if (pincap & AC_PINCAP_VREF_100)
5605 return AC_PINCTL_VREF_100;
5606 else if (pincap & AC_PINCAP_VREF_GRD)
5607 return AC_PINCTL_VREF_GRD;
5608 return AC_PINCTL_VREF_HIZ;
5610 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
5612 /* correct the pin ctl value for matching with the pin cap */
5613 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5614 hda_nid_t pin, unsigned int val)
5616 static unsigned int cap_lists[][2] = {
5617 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5618 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5619 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5620 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5626 cap = snd_hda_query_pin_caps(codec, pin);
5628 return val; /* don't know what to do... */
5630 if (val & AC_PINCTL_OUT_EN) {
5631 if (!(cap & AC_PINCAP_OUT))
5632 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5633 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5634 val &= ~AC_PINCTL_HP_EN;
5637 if (val & AC_PINCTL_IN_EN) {
5638 if (!(cap & AC_PINCAP_IN))
5639 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5641 unsigned int vcap, vref;
5643 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5644 vref = val & AC_PINCTL_VREFEN;
5645 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5646 if (vref == cap_lists[i][0] &&
5647 !(vcap & cap_lists[i][1])) {
5648 if (i == ARRAY_SIZE(cap_lists) - 1)
5649 vref = AC_PINCTL_VREF_HIZ;
5651 vref = cap_lists[i + 1][0];
5654 val &= ~AC_PINCTL_VREFEN;
5661 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
5663 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5664 unsigned int val, bool cached)
5666 val = snd_hda_correct_pin_ctl(codec, pin, val);
5667 snd_hda_codec_set_pin_target(codec, pin, val);
5669 return snd_hda_codec_update_cache(codec, pin, 0,
5670 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5672 return snd_hda_codec_write(codec, pin, 0,
5673 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5675 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
5678 * snd_hda_add_imux_item - Add an item to input_mux
5680 * When the same label is used already in the existing items, the number
5681 * suffix is appended to the label. This label index number is stored
5682 * to type_idx when non-NULL pointer is given.
5684 int snd_hda_add_imux_item(struct hda_codec *codec,
5685 struct hda_input_mux *imux, const char *label,
5686 int index, int *type_idx)
5688 int i, label_idx = 0;
5689 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5690 codec_err(codec, "hda_codec: Too many imux items!\n");
5693 for (i = 0; i < imux->num_items; i++) {
5694 if (!strncmp(label, imux->items[i].label, strlen(label)))
5698 *type_idx = label_idx;
5700 snprintf(imux->items[imux->num_items].label,
5701 sizeof(imux->items[imux->num_items].label),
5702 "%s %d", label, label_idx);
5704 strlcpy(imux->items[imux->num_items].label, label,
5705 sizeof(imux->items[imux->num_items].label));
5706 imux->items[imux->num_items].index = index;
5710 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
5719 static void hda_async_suspend(void *data, async_cookie_t cookie)
5721 hda_call_codec_suspend(data, false);
5724 static void hda_async_resume(void *data, async_cookie_t cookie)
5726 hda_call_codec_resume(data);
5730 * snd_hda_suspend - suspend the codecs
5733 * Returns 0 if successful.
5735 int snd_hda_suspend(struct hda_bus *bus)
5737 struct hda_codec *codec;
5738 ASYNC_DOMAIN_EXCLUSIVE(domain);
5740 list_for_each_entry(codec, &bus->codec_list, list) {
5741 cancel_delayed_work_sync(&codec->jackpoll_work);
5742 if (hda_codec_is_power_on(codec)) {
5743 if (bus->num_codecs > 1)
5744 async_schedule_domain(hda_async_suspend, codec,
5747 hda_call_codec_suspend(codec, false);
5751 if (bus->num_codecs > 1)
5752 async_synchronize_full_domain(&domain);
5756 EXPORT_SYMBOL_GPL(snd_hda_suspend);
5759 * snd_hda_resume - resume the codecs
5762 * Returns 0 if successful.
5764 int snd_hda_resume(struct hda_bus *bus)
5766 struct hda_codec *codec;
5767 ASYNC_DOMAIN_EXCLUSIVE(domain);
5769 list_for_each_entry(codec, &bus->codec_list, list) {
5770 if (bus->num_codecs > 1)
5771 async_schedule_domain(hda_async_resume, codec, &domain);
5773 hda_call_codec_resume(codec);
5776 if (bus->num_codecs > 1)
5777 async_synchronize_full_domain(&domain);
5781 EXPORT_SYMBOL_GPL(snd_hda_resume);
5782 #endif /* CONFIG_PM */
5789 * snd_array_new - get a new element from the given array
5790 * @array: the array object
5792 * Get a new element from the given array. If it exceeds the
5793 * pre-allocated array size, re-allocate the array.
5795 * Returns NULL if allocation failed.
5797 void *snd_array_new(struct snd_array *array)
5799 if (snd_BUG_ON(!array->elem_size))
5801 if (array->used >= array->alloced) {
5802 int num = array->alloced + array->alloc_align;
5803 int size = (num + 1) * array->elem_size;
5805 if (snd_BUG_ON(num >= 4096))
5807 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
5810 array->list = nlist;
5811 array->alloced = num;
5813 return snd_array_elem(array, array->used++);
5815 EXPORT_SYMBOL_GPL(snd_array_new);
5818 * snd_array_free - free the given array elements
5819 * @array: the array object
5821 void snd_array_free(struct snd_array *array)
5828 EXPORT_SYMBOL_GPL(snd_array_free);
5831 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5832 * @pcm: PCM caps bits
5833 * @buf: the string buffer to write
5834 * @buflen: the max buffer length
5836 * used by hda_proc.c and hda_eld.c
5838 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5840 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5843 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5844 if (pcm & (AC_SUPPCM_BITS_8 << i))
5845 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5847 buf[j] = '\0'; /* necessary when j == 0 */
5849 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
5851 MODULE_DESCRIPTION("HDA codec core");
5852 MODULE_LICENSE("GPL");