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 printk(KERN_ERR "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) {
252 snd_printd("hda_codec: resetting BUS due to "
253 "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 snd_printk(KERN_ERR "hda_codec: "
479 "Too many connections %d for NID 0x%x\n",
483 memcpy(conn_list, list, len * sizeof(hda_nid_t));
488 EXPORT_SYMBOL_GPL(snd_hda_get_connections);
490 /* return CONNLIST_LEN parameter of the given widget */
491 static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
493 unsigned int wcaps = get_wcaps(codec, nid);
496 if (!(wcaps & AC_WCAP_CONN_LIST) &&
497 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
500 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
506 int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
508 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
512 * snd_hda_get_raw_connections - copy connection list without cache
513 * @codec: the HDA codec
515 * @conn_list: connection list array
516 * @max_conns: max. number of connections to store
518 * Like snd_hda_get_connections(), copy the connection list but without
519 * checking through the connection-list cache.
520 * Currently called only from hda_proc.c, so not exported.
522 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
523 hda_nid_t *conn_list, int max_conns)
526 int i, conn_len, conns;
527 unsigned int shift, num_elems, mask;
531 parm = get_num_conns(codec, nid);
535 if (parm & AC_CLIST_LONG) {
544 conn_len = parm & AC_CLIST_LENGTH;
545 mask = (1 << (shift-1)) - 1;
548 return 0; /* no connection */
551 /* single connection */
552 parm = snd_hda_codec_read(codec, nid, 0,
553 AC_VERB_GET_CONNECT_LIST, 0);
554 if (parm == -1 && codec->bus->rirb_error)
557 conn_list[0] = parm & mask;
561 /* multi connection */
564 for (i = 0; i < conn_len; i++) {
568 if (i % num_elems == 0) {
569 parm = snd_hda_codec_read(codec, nid, 0,
570 AC_VERB_GET_CONNECT_LIST, i);
571 if (parm == -1 && codec->bus->rirb_error)
574 range_val = !!(parm & (1 << (shift-1))); /* ranges */
576 if (val == 0 && null_count++) { /* no second chance */
577 snd_printdd("hda_codec: "
578 "invalid CONNECT_LIST verb %x[%i]:%x\n",
584 /* ranges between the previous and this one */
585 if (!prev_nid || prev_nid >= val) {
586 snd_printk(KERN_WARNING "hda_codec: "
587 "invalid dep_range_val %x:%x\n",
591 for (n = prev_nid + 1; n <= val; n++) {
593 if (conns >= max_conns)
595 conn_list[conns] = n;
601 if (conns >= max_conns)
603 conn_list[conns] = val;
613 * snd_hda_override_conn_list - add/modify the connection-list to cache
614 * @codec: the HDA codec
616 * @len: number of connection list entries
617 * @list: the list of connection entries
619 * Add or modify the given connection-list to the cache. If the corresponding
620 * cache already exists, invalidate it and append a new one.
622 * Returns zero or a negative error code.
624 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
625 const hda_nid_t *list)
627 struct hda_conn_list *p;
629 p = lookup_conn_list(codec, nid);
635 return add_conn_list(codec, nid, len, list);
637 EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
640 * snd_hda_get_conn_index - get the connection index of the given NID
641 * @codec: the HDA codec
642 * @mux: NID containing the list
643 * @nid: NID to select
644 * @recursive: 1 when searching NID recursively, otherwise 0
646 * Parses the connection list of the widget @mux and checks whether the
647 * widget @nid is present. If it is, return the connection index.
648 * Otherwise it returns -1.
650 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
651 hda_nid_t nid, int recursive)
653 const hda_nid_t *conn;
656 nums = snd_hda_get_conn_list(codec, mux, &conn);
657 for (i = 0; i < nums; i++)
662 if (recursive > 10) {
663 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
667 for (i = 0; i < nums; i++) {
668 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
669 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
671 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
676 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
679 /* return DEVLIST_LEN parameter of the given widget */
680 static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
682 unsigned int wcaps = get_wcaps(codec, nid);
685 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
686 get_wcaps_type(wcaps) != AC_WID_PIN)
689 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
690 if (parm == -1 && codec->bus->rirb_error)
692 return parm & AC_DEV_LIST_LEN_MASK;
696 * snd_hda_get_devices - copy device list without cache
697 * @codec: the HDA codec
698 * @nid: NID of the pin to parse
699 * @dev_list: device list array
700 * @max_devices: max. number of devices to store
702 * Copy the device list. This info is dynamic and so not cached.
703 * Currently called only from hda_proc.c, so not exported.
705 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
706 u8 *dev_list, int max_devices)
709 int i, dev_len, devices;
711 parm = get_num_devices(codec, nid);
712 if (!parm) /* not multi-stream capable */
716 dev_len = dev_len < max_devices ? dev_len : max_devices;
719 while (devices < dev_len) {
720 parm = snd_hda_codec_read(codec, nid, 0,
721 AC_VERB_GET_DEVICE_LIST, devices);
722 if (parm == -1 && codec->bus->rirb_error)
725 for (i = 0; i < 8; i++) {
726 dev_list[devices] = (u8)parm;
729 if (devices >= dev_len)
737 * snd_hda_queue_unsol_event - add an unsolicited event to queue
739 * @res: unsolicited event (lower 32bit of RIRB entry)
740 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
742 * Adds the given event to the queue. The events are processed in
743 * the workqueue asynchronously. Call this function in the interrupt
744 * hanlder when RIRB receives an unsolicited event.
746 * Returns 0 if successful, or a negative error code.
748 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
750 struct hda_bus_unsolicited *unsol;
753 if (!bus || !bus->workq)
756 trace_hda_unsol_event(bus, res, res_ex);
761 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
765 unsol->queue[wp] = res;
766 unsol->queue[wp + 1] = res_ex;
768 queue_work(bus->workq, &unsol->work);
772 EXPORT_SYMBOL_GPL(snd_hda_queue_unsol_event);
775 * process queued unsolicited events
777 static void process_unsol_events(struct work_struct *work)
779 struct hda_bus_unsolicited *unsol =
780 container_of(work, struct hda_bus_unsolicited, work);
781 struct hda_bus *bus = unsol->bus;
782 struct hda_codec *codec;
783 unsigned int rp, caddr, res;
785 while (unsol->rp != unsol->wp) {
786 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
789 res = unsol->queue[rp];
790 caddr = unsol->queue[rp + 1];
791 if (!(caddr & (1 << 4))) /* no unsolicited event? */
793 codec = bus->caddr_tbl[caddr & 0x0f];
794 if (codec && codec->patch_ops.unsol_event)
795 codec->patch_ops.unsol_event(codec, res);
800 * initialize unsolicited queue
802 static int init_unsol_queue(struct hda_bus *bus)
804 struct hda_bus_unsolicited *unsol;
806 if (bus->unsol) /* already initialized */
809 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
811 snd_printk(KERN_ERR "hda_codec: "
812 "can't allocate unsolicited queue\n");
815 INIT_WORK(&unsol->work, process_unsol_events);
824 static void snd_hda_codec_free(struct hda_codec *codec);
826 static int snd_hda_bus_free(struct hda_bus *bus)
828 struct hda_codec *codec, *n;
833 flush_workqueue(bus->workq);
836 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
837 snd_hda_codec_free(codec);
839 if (bus->ops.private_free)
840 bus->ops.private_free(bus);
842 destroy_workqueue(bus->workq);
848 static int snd_hda_bus_dev_free(struct snd_device *device)
850 struct hda_bus *bus = device->device_data;
852 return snd_hda_bus_free(bus);
855 #ifdef CONFIG_SND_HDA_HWDEP
856 static int snd_hda_bus_dev_register(struct snd_device *device)
858 struct hda_bus *bus = device->device_data;
859 struct hda_codec *codec;
860 list_for_each_entry(codec, &bus->codec_list, list) {
861 snd_hda_hwdep_add_sysfs(codec);
862 snd_hda_hwdep_add_power_sysfs(codec);
867 #define snd_hda_bus_dev_register NULL
871 * snd_hda_bus_new - create a HDA bus
872 * @card: the card entry
873 * @temp: the template for hda_bus information
874 * @busp: the pointer to store the created bus instance
876 * Returns 0 if successful, or a negative error code.
878 int snd_hda_bus_new(struct snd_card *card,
879 const struct hda_bus_template *temp,
880 struct hda_bus **busp)
884 static struct snd_device_ops dev_ops = {
885 .dev_register = snd_hda_bus_dev_register,
886 .dev_free = snd_hda_bus_dev_free,
889 if (snd_BUG_ON(!temp))
891 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
897 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
899 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
904 bus->private_data = temp->private_data;
905 bus->pci = temp->pci;
906 bus->modelname = temp->modelname;
907 bus->power_save = temp->power_save;
908 bus->ops = temp->ops;
910 mutex_init(&bus->cmd_mutex);
911 mutex_init(&bus->prepare_mutex);
912 INIT_LIST_HEAD(&bus->codec_list);
914 snprintf(bus->workq_name, sizeof(bus->workq_name),
915 "hd-audio%d", card->number);
916 bus->workq = create_singlethread_workqueue(bus->workq_name);
918 snd_printk(KERN_ERR "cannot create workqueue %s\n",
924 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
926 snd_hda_bus_free(bus);
933 EXPORT_SYMBOL_GPL(snd_hda_bus_new);
935 #if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
936 #define is_generic_config(codec) \
937 (codec->modelname && !strcmp(codec->modelname, "generic"))
939 #define is_generic_config(codec) 0
943 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
945 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
949 * find a matching codec preset
951 static const struct hda_codec_preset *
952 find_codec_preset(struct hda_codec *codec)
954 struct hda_codec_preset_list *tbl;
955 const struct hda_codec_preset *preset;
956 unsigned int mod_requested = 0;
959 mutex_lock(&preset_mutex);
960 list_for_each_entry(tbl, &hda_preset_tables, list) {
961 if (!try_module_get(tbl->owner)) {
962 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
965 for (preset = tbl->preset; preset->id; preset++) {
966 u32 mask = preset->mask;
967 if (preset->afg && preset->afg != codec->afg)
969 if (preset->mfg && preset->mfg != codec->mfg)
973 if (preset->id == (codec->vendor_id & mask) &&
975 preset->rev == codec->revision_id)) {
976 mutex_unlock(&preset_mutex);
977 codec->owner = tbl->owner;
981 module_put(tbl->owner);
983 mutex_unlock(&preset_mutex);
985 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
988 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
991 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
992 (codec->vendor_id >> 16) & 0xffff);
993 request_module(name);
1001 * get_codec_name - store the codec name
1003 static int get_codec_name(struct hda_codec *codec)
1005 const struct hda_vendor_id *c;
1006 const char *vendor = NULL;
1007 u16 vendor_id = codec->vendor_id >> 16;
1010 if (codec->vendor_name)
1013 for (c = hda_vendor_ids; c->id; c++) {
1014 if (c->id == vendor_id) {
1020 sprintf(tmp, "Generic %04x", vendor_id);
1023 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
1024 if (!codec->vendor_name)
1028 if (codec->chip_name)
1031 if (codec->preset && codec->preset->name)
1032 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
1034 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
1035 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
1037 if (!codec->chip_name)
1043 * look for an AFG and MFG nodes
1045 static void setup_fg_nodes(struct hda_codec *codec)
1047 int i, total_nodes, function_id;
1050 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
1051 for (i = 0; i < total_nodes; i++, nid++) {
1052 function_id = snd_hda_param_read(codec, nid,
1053 AC_PAR_FUNCTION_TYPE);
1054 switch (function_id & 0xff) {
1055 case AC_GRP_AUDIO_FUNCTION:
1057 codec->afg_function_id = function_id & 0xff;
1058 codec->afg_unsol = (function_id >> 8) & 1;
1060 case AC_GRP_MODEM_FUNCTION:
1062 codec->mfg_function_id = function_id & 0xff;
1063 codec->mfg_unsol = (function_id >> 8) & 1;
1072 * read widget caps for each widget and store in cache
1074 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1079 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1081 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1084 nid = codec->start_nid;
1085 for (i = 0; i < codec->num_nodes; i++, nid++)
1086 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1087 AC_PAR_AUDIO_WIDGET_CAP);
1091 /* read all pin default configurations and save codec->init_pins */
1092 static int read_pin_defaults(struct hda_codec *codec)
1095 hda_nid_t nid = codec->start_nid;
1097 for (i = 0; i < codec->num_nodes; i++, nid++) {
1098 struct hda_pincfg *pin;
1099 unsigned int wcaps = get_wcaps(codec, nid);
1100 unsigned int wid_type = get_wcaps_type(wcaps);
1101 if (wid_type != AC_WID_PIN)
1103 pin = snd_array_new(&codec->init_pins);
1107 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1108 AC_VERB_GET_CONFIG_DEFAULT, 0);
1109 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1110 AC_VERB_GET_PIN_WIDGET_CONTROL,
1116 /* look up the given pin config list and return the item matching with NID */
1117 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1118 struct snd_array *array,
1122 for (i = 0; i < array->used; i++) {
1123 struct hda_pincfg *pin = snd_array_elem(array, i);
1124 if (pin->nid == nid)
1130 /* set the current pin config value for the given NID.
1131 * the value is cached, and read via snd_hda_codec_get_pincfg()
1133 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1134 hda_nid_t nid, unsigned int cfg)
1136 struct hda_pincfg *pin;
1138 /* the check below may be invalid when pins are added by a fixup
1139 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
1143 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1147 pin = look_up_pincfg(codec, list, nid);
1149 pin = snd_array_new(list);
1159 * snd_hda_codec_set_pincfg - Override a pin default configuration
1160 * @codec: the HDA codec
1161 * @nid: NID to set the pin config
1162 * @cfg: the pin default config value
1164 * Override a pin default configuration value in the cache.
1165 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1166 * priority than the real hardware value.
1168 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1169 hda_nid_t nid, unsigned int cfg)
1171 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1173 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
1176 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1177 * @codec: the HDA codec
1178 * @nid: NID to get the pin config
1180 * Get the current pin config value of the given pin NID.
1181 * If the pincfg value is cached or overridden via sysfs or driver,
1182 * returns the cached value.
1184 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1186 struct hda_pincfg *pin;
1188 #ifdef CONFIG_SND_HDA_HWDEP
1190 unsigned int cfg = 0;
1191 mutex_lock(&codec->user_mutex);
1192 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1195 mutex_unlock(&codec->user_mutex);
1200 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1203 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1208 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
1210 /* remember the current pinctl target value */
1211 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1214 struct hda_pincfg *pin;
1216 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1222 EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
1224 /* return the current pinctl target value */
1225 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1227 struct hda_pincfg *pin;
1229 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1234 EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
1237 * snd_hda_shutup_pins - Shut up all pins
1238 * @codec: the HDA codec
1240 * Clear all pin controls to shup up before suspend for avoiding click noise.
1241 * The controls aren't cached so that they can be resumed properly.
1243 void snd_hda_shutup_pins(struct hda_codec *codec)
1246 /* don't shut up pins when unloading the driver; otherwise it breaks
1247 * the default pin setup at the next load of the driver
1249 if (codec->bus->shutdown)
1251 for (i = 0; i < codec->init_pins.used; i++) {
1252 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1253 /* use read here for syncing after issuing each verb */
1254 snd_hda_codec_read(codec, pin->nid, 0,
1255 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1257 codec->pins_shutup = 1;
1259 EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
1262 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1263 static void restore_shutup_pins(struct hda_codec *codec)
1266 if (!codec->pins_shutup)
1268 if (codec->bus->shutdown)
1270 for (i = 0; i < codec->init_pins.used; i++) {
1271 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1272 snd_hda_codec_write(codec, pin->nid, 0,
1273 AC_VERB_SET_PIN_WIDGET_CONTROL,
1276 codec->pins_shutup = 0;
1280 static void hda_jackpoll_work(struct work_struct *work)
1282 struct hda_codec *codec =
1283 container_of(work, struct hda_codec, jackpoll_work.work);
1285 snd_hda_jack_set_dirty_all(codec);
1286 snd_hda_jack_poll_all(codec);
1288 if (!codec->jackpoll_interval)
1291 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1292 codec->jackpoll_interval);
1295 static void init_hda_cache(struct hda_cache_rec *cache,
1296 unsigned int record_size);
1297 static void free_hda_cache(struct hda_cache_rec *cache);
1299 /* release all pincfg lists */
1300 static void free_init_pincfgs(struct hda_codec *codec)
1302 snd_array_free(&codec->driver_pins);
1303 #ifdef CONFIG_SND_HDA_HWDEP
1304 snd_array_free(&codec->user_pins);
1306 snd_array_free(&codec->init_pins);
1310 * audio-converter setup caches
1312 struct hda_cvt_setup {
1317 unsigned char active; /* cvt is currently used */
1318 unsigned char dirty; /* setups should be cleared */
1321 /* get or create a cache entry for the given audio converter NID */
1322 static struct hda_cvt_setup *
1323 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1325 struct hda_cvt_setup *p;
1328 for (i = 0; i < codec->cvt_setups.used; i++) {
1329 p = snd_array_elem(&codec->cvt_setups, i);
1333 p = snd_array_new(&codec->cvt_setups);
1340 * Dynamic symbol binding for the codec parsers
1343 #define load_parser(codec, sym) \
1344 ((codec)->parser = (int (*)(struct hda_codec *))symbol_request(sym))
1346 static void unload_parser(struct hda_codec *codec)
1349 symbol_put_addr(codec->parser);
1350 codec->parser = NULL;
1356 static void snd_hda_codec_free(struct hda_codec *codec)
1360 cancel_delayed_work_sync(&codec->jackpoll_work);
1361 snd_hda_jack_tbl_clear(codec);
1362 free_init_pincfgs(codec);
1364 cancel_delayed_work(&codec->power_work);
1365 flush_workqueue(codec->bus->workq);
1367 list_del(&codec->list);
1368 snd_array_free(&codec->mixers);
1369 snd_array_free(&codec->nids);
1370 snd_array_free(&codec->cvt_setups);
1371 snd_array_free(&codec->spdif_out);
1372 remove_conn_list(codec);
1373 codec->bus->caddr_tbl[codec->addr] = NULL;
1374 if (codec->patch_ops.free)
1375 codec->patch_ops.free(codec);
1376 hda_call_pm_notify(codec, false); /* cancel leftover refcounts */
1377 unload_parser(codec);
1378 module_put(codec->owner);
1379 free_hda_cache(&codec->amp_cache);
1380 free_hda_cache(&codec->cmd_cache);
1381 kfree(codec->vendor_name);
1382 kfree(codec->chip_name);
1383 kfree(codec->modelname);
1384 kfree(codec->wcaps);
1385 codec->bus->num_codecs--;
1389 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1390 hda_nid_t fg, unsigned int power_state);
1392 static unsigned int hda_set_power_state(struct hda_codec *codec,
1393 unsigned int power_state);
1396 * snd_hda_codec_new - create a HDA codec
1397 * @bus: the bus to assign
1398 * @codec_addr: the codec address
1399 * @codecp: the pointer to store the generated codec
1401 * Returns 0 if successful, or a negative error code.
1403 int snd_hda_codec_new(struct hda_bus *bus,
1404 unsigned int codec_addr,
1405 struct hda_codec **codecp)
1407 struct hda_codec *codec;
1412 if (snd_BUG_ON(!bus))
1414 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1417 if (bus->caddr_tbl[codec_addr]) {
1418 snd_printk(KERN_ERR "hda_codec: "
1419 "address 0x%x is already occupied\n", codec_addr);
1423 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1424 if (codec == NULL) {
1425 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1430 codec->addr = codec_addr;
1431 mutex_init(&codec->spdif_mutex);
1432 mutex_init(&codec->control_mutex);
1433 mutex_init(&codec->hash_mutex);
1434 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1435 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1436 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1437 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1438 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1439 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1440 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1441 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1442 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1443 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1444 INIT_LIST_HEAD(&codec->conn_list);
1446 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1447 codec->depop_delay = -1;
1450 spin_lock_init(&codec->power_lock);
1451 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1452 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1453 * the caller has to power down appropriatley after initialization
1456 hda_keep_power_on(codec);
1459 if (codec->bus->modelname) {
1460 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1461 if (!codec->modelname) {
1462 snd_hda_codec_free(codec);
1467 list_add_tail(&codec->list, &bus->codec_list);
1470 bus->caddr_tbl[codec_addr] = codec;
1472 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1474 if (codec->vendor_id == -1)
1475 /* read again, hopefully the access method was corrected
1476 * in the last read...
1478 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1480 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1481 AC_PAR_SUBSYSTEM_ID);
1482 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1485 setup_fg_nodes(codec);
1486 if (!codec->afg && !codec->mfg) {
1487 snd_printdd("hda_codec: no AFG or MFG node found\n");
1492 fg = codec->afg ? codec->afg : codec->mfg;
1493 err = read_widget_caps(codec, fg);
1495 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1498 err = read_pin_defaults(codec);
1502 if (!codec->subsystem_id) {
1503 codec->subsystem_id =
1504 snd_hda_codec_read(codec, fg, 0,
1505 AC_VERB_GET_SUBSYSTEM_ID, 0);
1509 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1512 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1515 if (!codec->d3_stop_clk || !codec->epss)
1516 bus->power_keep_link_on = 1;
1520 /* power-up all before initialization */
1521 hda_set_power_state(codec, AC_PWRST_D0);
1523 snd_hda_codec_proc_new(codec);
1525 snd_hda_create_hwdep(codec);
1527 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1528 codec->subsystem_id, codec->revision_id);
1529 snd_component_add(codec->bus->card, component);
1536 snd_hda_codec_free(codec);
1539 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
1541 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1546 /* Assume the function group node does not change,
1547 * only the widget nodes may change.
1549 kfree(codec->wcaps);
1550 fg = codec->afg ? codec->afg : codec->mfg;
1551 err = read_widget_caps(codec, fg);
1553 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1557 snd_array_free(&codec->init_pins);
1558 err = read_pin_defaults(codec);
1562 EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
1565 #if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
1566 /* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
1567 static bool is_likely_hdmi_codec(struct hda_codec *codec)
1569 hda_nid_t nid = codec->start_nid;
1572 for (i = 0; i < codec->num_nodes; i++, nid++) {
1573 unsigned int wcaps = get_wcaps(codec, nid);
1574 switch (get_wcaps_type(wcaps)) {
1576 return false; /* HDMI parser supports only HDMI out */
1577 case AC_WID_AUD_OUT:
1578 if (!(wcaps & AC_WCAP_DIGITAL))
1586 /* no HDMI codec parser support */
1587 #define is_likely_hdmi_codec(codec) false
1588 #endif /* CONFIG_SND_HDA_CODEC_HDMI */
1591 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1592 * @codec: the HDA codec
1594 * Start parsing of the given codec tree and (re-)initialize the whole
1597 * Returns 0 if successful or a negative error code.
1599 int snd_hda_codec_configure(struct hda_codec *codec)
1601 int (*patch)(struct hda_codec *) = NULL;
1604 codec->preset = find_codec_preset(codec);
1605 if (!codec->vendor_name || !codec->chip_name) {
1606 err = get_codec_name(codec);
1611 if (!is_generic_config(codec) && codec->preset)
1612 patch = codec->preset->patch;
1614 unload_parser(codec); /* to be sure */
1615 if (is_likely_hdmi_codec(codec)) {
1616 #if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
1617 patch = load_parser(codec, snd_hda_parse_hdmi_codec);
1618 #elif IS_BUILTIN(CONFIG_SND_HDA_CODEC_HDMI)
1619 patch = snd_hda_parse_hdmi_codec;
1623 #if IS_MODULE(CONFIG_SND_HDA_GENERIC)
1624 patch = load_parser(codec, snd_hda_parse_generic_codec);
1625 #elif IS_BUILTIN(CONFIG_SND_HDA_GENERIC)
1626 patch = snd_hda_parse_generic_codec;
1630 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1637 unload_parser(codec);
1641 if (codec->patch_ops.unsol_event) {
1642 err = init_unsol_queue(codec->bus);
1647 /* audio codec should override the mixer name */
1648 if (codec->afg || !*codec->bus->card->mixername)
1649 snprintf(codec->bus->card->mixername,
1650 sizeof(codec->bus->card->mixername),
1651 "%s %s", codec->vendor_name, codec->chip_name);
1654 EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
1656 /* update the stream-id if changed */
1657 static void update_pcm_stream_id(struct hda_codec *codec,
1658 struct hda_cvt_setup *p, hda_nid_t nid,
1659 u32 stream_tag, int channel_id)
1661 unsigned int oldval, newval;
1663 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1664 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1665 newval = (stream_tag << 4) | channel_id;
1666 if (oldval != newval)
1667 snd_hda_codec_write(codec, nid, 0,
1668 AC_VERB_SET_CHANNEL_STREAMID,
1670 p->stream_tag = stream_tag;
1671 p->channel_id = channel_id;
1675 /* update the format-id if changed */
1676 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1677 hda_nid_t nid, int format)
1679 unsigned int oldval;
1681 if (p->format_id != format) {
1682 oldval = snd_hda_codec_read(codec, nid, 0,
1683 AC_VERB_GET_STREAM_FORMAT, 0);
1684 if (oldval != format) {
1686 snd_hda_codec_write(codec, nid, 0,
1687 AC_VERB_SET_STREAM_FORMAT,
1690 p->format_id = format;
1695 * snd_hda_codec_setup_stream - set up the codec for streaming
1696 * @codec: the CODEC to set up
1697 * @nid: the NID to set up
1698 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1699 * @channel_id: channel id to pass, zero based.
1700 * @format: stream format.
1702 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1704 int channel_id, int format)
1706 struct hda_codec *c;
1707 struct hda_cvt_setup *p;
1714 snd_printdd("hda_codec_setup_stream: "
1715 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1716 nid, stream_tag, channel_id, format);
1717 p = get_hda_cvt_setup(codec, nid);
1721 if (codec->pcm_format_first)
1722 update_pcm_format(codec, p, nid, format);
1723 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1724 if (!codec->pcm_format_first)
1725 update_pcm_format(codec, p, nid, format);
1730 /* make other inactive cvts with the same stream-tag dirty */
1731 type = get_wcaps_type(get_wcaps(codec, nid));
1732 list_for_each_entry(c, &codec->bus->codec_list, list) {
1733 for (i = 0; i < c->cvt_setups.used; i++) {
1734 p = snd_array_elem(&c->cvt_setups, i);
1735 if (!p->active && p->stream_tag == stream_tag &&
1736 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1741 EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
1743 static void really_cleanup_stream(struct hda_codec *codec,
1744 struct hda_cvt_setup *q);
1747 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1748 * @codec: the CODEC to clean up
1749 * @nid: the NID to clean up
1750 * @do_now: really clean up the stream instead of clearing the active flag
1752 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1755 struct hda_cvt_setup *p;
1760 if (codec->no_sticky_stream)
1763 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1764 p = get_hda_cvt_setup(codec, nid);
1766 /* here we just clear the active flag when do_now isn't set;
1767 * actual clean-ups will be done later in
1768 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1771 really_cleanup_stream(codec, p);
1776 EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
1778 static void really_cleanup_stream(struct hda_codec *codec,
1779 struct hda_cvt_setup *q)
1781 hda_nid_t nid = q->nid;
1782 if (q->stream_tag || q->channel_id)
1783 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1785 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1787 memset(q, 0, sizeof(*q));
1791 /* clean up the all conflicting obsolete streams */
1792 static void purify_inactive_streams(struct hda_codec *codec)
1794 struct hda_codec *c;
1797 list_for_each_entry(c, &codec->bus->codec_list, list) {
1798 for (i = 0; i < c->cvt_setups.used; i++) {
1799 struct hda_cvt_setup *p;
1800 p = snd_array_elem(&c->cvt_setups, i);
1802 really_cleanup_stream(c, p);
1808 /* clean up all streams; called from suspend */
1809 static void hda_cleanup_all_streams(struct hda_codec *codec)
1813 for (i = 0; i < codec->cvt_setups.used; i++) {
1814 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1816 really_cleanup_stream(codec, p);
1822 * amp access functions
1825 /* FIXME: more better hash key? */
1826 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1827 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1828 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1829 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1830 #define INFO_AMP_CAPS (1<<0)
1831 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1833 /* initialize the hash table */
1834 static void init_hda_cache(struct hda_cache_rec *cache,
1835 unsigned int record_size)
1837 memset(cache, 0, sizeof(*cache));
1838 memset(cache->hash, 0xff, sizeof(cache->hash));
1839 snd_array_init(&cache->buf, record_size, 64);
1842 static void free_hda_cache(struct hda_cache_rec *cache)
1844 snd_array_free(&cache->buf);
1847 /* query the hash. allocate an entry if not found. */
1848 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1850 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1851 u16 cur = cache->hash[idx];
1852 struct hda_cache_head *info;
1854 while (cur != 0xffff) {
1855 info = snd_array_elem(&cache->buf, cur);
1856 if (info->key == key)
1863 /* query the hash. allocate an entry if not found. */
1864 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1867 struct hda_cache_head *info = get_hash(cache, key);
1870 /* add a new hash entry */
1871 info = snd_array_new(&cache->buf);
1874 cur = snd_array_index(&cache->buf, info);
1878 idx = key % (u16)ARRAY_SIZE(cache->hash);
1879 info->next = cache->hash[idx];
1880 cache->hash[idx] = cur;
1885 /* query and allocate an amp hash entry */
1886 static inline struct hda_amp_info *
1887 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1889 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1892 /* overwrite the value with the key in the caps hash */
1893 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1895 struct hda_amp_info *info;
1897 mutex_lock(&codec->hash_mutex);
1898 info = get_alloc_amp_hash(codec, key);
1900 mutex_unlock(&codec->hash_mutex);
1903 info->amp_caps = val;
1904 info->head.val |= INFO_AMP_CAPS;
1905 mutex_unlock(&codec->hash_mutex);
1909 /* query the value from the caps hash; if not found, fetch the current
1910 * value from the given function and store in the hash
1913 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1914 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1916 struct hda_amp_info *info;
1919 mutex_lock(&codec->hash_mutex);
1920 info = get_alloc_amp_hash(codec, key);
1922 mutex_unlock(&codec->hash_mutex);
1925 if (!(info->head.val & INFO_AMP_CAPS)) {
1926 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1927 val = func(codec, nid, dir);
1928 write_caps_hash(codec, key, val);
1930 val = info->amp_caps;
1931 mutex_unlock(&codec->hash_mutex);
1936 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1939 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1941 return snd_hda_param_read(codec, nid,
1942 direction == HDA_OUTPUT ?
1943 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1947 * query_amp_caps - query AMP capabilities
1948 * @codec: the HD-auio codec
1949 * @nid: the NID to query
1950 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1952 * Query AMP capabilities for the given widget and direction.
1953 * Returns the obtained capability bits.
1955 * When cap bits have been already read, this doesn't read again but
1956 * returns the cached value.
1958 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1960 return query_caps_hash(codec, nid, direction,
1961 HDA_HASH_KEY(nid, direction, 0),
1964 EXPORT_SYMBOL_GPL(query_amp_caps);
1967 * snd_hda_override_amp_caps - Override the AMP capabilities
1968 * @codec: the CODEC to clean up
1969 * @nid: the NID to clean up
1970 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1971 * @caps: the capability bits to set
1973 * Override the cached AMP caps bits value by the given one.
1974 * This function is useful if the driver needs to adjust the AMP ranges,
1975 * e.g. limit to 0dB, etc.
1977 * Returns zero if successful or a negative error code.
1979 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1982 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1984 EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
1986 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1989 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1993 * snd_hda_query_pin_caps - Query PIN capabilities
1994 * @codec: the HD-auio codec
1995 * @nid: the NID to query
1997 * Query PIN capabilities for the given widget.
1998 * Returns the obtained capability bits.
2000 * When cap bits have been already read, this doesn't read again but
2001 * returns the cached value.
2003 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
2005 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
2008 EXPORT_SYMBOL_GPL(snd_hda_query_pin_caps);
2011 * snd_hda_override_pin_caps - Override the pin capabilities
2013 * @nid: the NID to override
2014 * @caps: the capability bits to set
2016 * Override the cached PIN capabilitiy bits value by the given one.
2018 * Returns zero if successful or a negative error code.
2020 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
2023 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
2025 EXPORT_SYMBOL_GPL(snd_hda_override_pin_caps);
2027 /* read or sync the hash value with the current value;
2028 * call within hash_mutex
2030 static struct hda_amp_info *
2031 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
2032 int direction, int index, bool init_only)
2034 struct hda_amp_info *info;
2035 unsigned int parm, val = 0;
2036 bool val_read = false;
2039 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
2042 if (!(info->head.val & INFO_AMP_VOL(ch))) {
2044 mutex_unlock(&codec->hash_mutex);
2045 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
2046 parm |= direction == HDA_OUTPUT ?
2047 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
2049 val = snd_hda_codec_read(codec, nid, 0,
2050 AC_VERB_GET_AMP_GAIN_MUTE, parm);
2053 mutex_lock(&codec->hash_mutex);
2056 info->vol[ch] = val;
2057 info->head.val |= INFO_AMP_VOL(ch);
2058 } else if (init_only)
2064 * write the current volume in info to the h/w
2066 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
2067 hda_nid_t nid, int ch, int direction, int index,
2072 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
2073 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
2074 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2075 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
2076 (amp_caps & AC_AMPCAP_MIN_MUTE))
2077 ; /* set the zero value as a fake mute */
2080 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
2084 * snd_hda_codec_amp_read - Read AMP value
2085 * @codec: HD-audio codec
2086 * @nid: NID to read the AMP value
2087 * @ch: channel (left=0 or right=1)
2088 * @direction: #HDA_INPUT or #HDA_OUTPUT
2089 * @index: the index value (only for input direction)
2091 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
2093 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2094 int direction, int index)
2096 struct hda_amp_info *info;
2097 unsigned int val = 0;
2099 mutex_lock(&codec->hash_mutex);
2100 info = update_amp_hash(codec, nid, ch, direction, index, false);
2102 val = info->vol[ch];
2103 mutex_unlock(&codec->hash_mutex);
2106 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_read);
2108 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2109 int direction, int idx, int mask, int val,
2112 struct hda_amp_info *info;
2114 unsigned int cache_only;
2116 if (snd_BUG_ON(mask & ~0xff))
2120 mutex_lock(&codec->hash_mutex);
2121 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
2123 mutex_unlock(&codec->hash_mutex);
2126 val |= info->vol[ch] & ~mask;
2127 if (info->vol[ch] == val) {
2128 mutex_unlock(&codec->hash_mutex);
2131 info->vol[ch] = val;
2132 cache_only = info->head.dirty = codec->cached_write;
2133 caps = info->amp_caps;
2134 mutex_unlock(&codec->hash_mutex);
2136 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2141 * snd_hda_codec_amp_update - update the AMP value
2142 * @codec: HD-audio codec
2143 * @nid: NID to read the AMP value
2144 * @ch: channel (left=0 or right=1)
2145 * @direction: #HDA_INPUT or #HDA_OUTPUT
2146 * @idx: the index value (only for input direction)
2147 * @mask: bit mask to set
2148 * @val: the bits value to set
2150 * Update the AMP value with a bit mask.
2151 * Returns 0 if the value is unchanged, 1 if changed.
2153 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2154 int direction, int idx, int mask, int val)
2156 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2158 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_update);
2161 * snd_hda_codec_amp_stereo - update the AMP stereo values
2162 * @codec: HD-audio codec
2163 * @nid: NID to read the AMP value
2164 * @direction: #HDA_INPUT or #HDA_OUTPUT
2165 * @idx: the index value (only for input direction)
2166 * @mask: bit mask to set
2167 * @val: the bits value to set
2169 * Update the AMP values like snd_hda_codec_amp_update(), but for a
2170 * stereo widget with the same mask and value.
2172 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2173 int direction, int idx, int mask, int val)
2177 if (snd_BUG_ON(mask & ~0xff))
2179 for (ch = 0; ch < 2; ch++)
2180 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2184 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
2186 /* Works like snd_hda_codec_amp_update() but it writes the value only at
2187 * the first access. If the amp was already initialized / updated beforehand,
2188 * this does nothing.
2190 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2191 int dir, int idx, int mask, int val)
2193 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2195 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
2197 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2198 int dir, int idx, int mask, int val)
2202 if (snd_BUG_ON(mask & ~0xff))
2204 for (ch = 0; ch < 2; ch++)
2205 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2209 EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
2212 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2213 * @codec: HD-audio codec
2215 * Resume the all amp commands from the cache.
2217 void snd_hda_codec_resume_amp(struct hda_codec *codec)
2221 mutex_lock(&codec->hash_mutex);
2222 codec->cached_write = 0;
2223 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2224 struct hda_amp_info *buffer;
2227 unsigned int idx, dir, ch;
2228 struct hda_amp_info info;
2230 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2231 if (!buffer->head.dirty)
2233 buffer->head.dirty = 0;
2235 key = info.head.key;
2239 idx = (key >> 16) & 0xff;
2240 dir = (key >> 24) & 0xff;
2241 for (ch = 0; ch < 2; ch++) {
2242 if (!(info.head.val & INFO_AMP_VOL(ch)))
2244 mutex_unlock(&codec->hash_mutex);
2245 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2247 mutex_lock(&codec->hash_mutex);
2250 mutex_unlock(&codec->hash_mutex);
2252 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_amp);
2254 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2257 u32 caps = query_amp_caps(codec, nid, dir);
2259 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2266 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2268 * The control element is supposed to have the private_value field
2269 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2271 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2272 struct snd_ctl_elem_info *uinfo)
2274 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2275 u16 nid = get_amp_nid(kcontrol);
2276 u8 chs = get_amp_channels(kcontrol);
2277 int dir = get_amp_direction(kcontrol);
2278 unsigned int ofs = get_amp_offset(kcontrol);
2280 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2281 uinfo->count = chs == 3 ? 2 : 1;
2282 uinfo->value.integer.min = 0;
2283 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2284 if (!uinfo->value.integer.max) {
2285 printk(KERN_WARNING "hda_codec: "
2286 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2292 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
2295 static inline unsigned int
2296 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2297 int ch, int dir, int idx, unsigned int ofs)
2300 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2301 val &= HDA_AMP_VOLMASK;
2310 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2311 int ch, int dir, int idx, unsigned int ofs,
2314 unsigned int maxval;
2318 /* ofs = 0: raw max value */
2319 maxval = get_amp_max_value(codec, nid, dir, 0);
2322 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2323 HDA_AMP_VOLMASK, val);
2327 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2329 * The control element is supposed to have the private_value field
2330 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2332 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2333 struct snd_ctl_elem_value *ucontrol)
2335 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2336 hda_nid_t nid = get_amp_nid(kcontrol);
2337 int chs = get_amp_channels(kcontrol);
2338 int dir = get_amp_direction(kcontrol);
2339 int idx = get_amp_index(kcontrol);
2340 unsigned int ofs = get_amp_offset(kcontrol);
2341 long *valp = ucontrol->value.integer.value;
2344 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2346 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2349 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
2352 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2354 * The control element is supposed to have the private_value field
2355 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2357 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2358 struct snd_ctl_elem_value *ucontrol)
2360 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2361 hda_nid_t nid = get_amp_nid(kcontrol);
2362 int chs = get_amp_channels(kcontrol);
2363 int dir = get_amp_direction(kcontrol);
2364 int idx = get_amp_index(kcontrol);
2365 unsigned int ofs = get_amp_offset(kcontrol);
2366 long *valp = ucontrol->value.integer.value;
2369 snd_hda_power_up(codec);
2371 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2375 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2376 snd_hda_power_down(codec);
2379 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
2382 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2384 * The control element is supposed to have the private_value field
2385 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2387 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2388 unsigned int size, unsigned int __user *_tlv)
2390 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2391 hda_nid_t nid = get_amp_nid(kcontrol);
2392 int dir = get_amp_direction(kcontrol);
2393 unsigned int ofs = get_amp_offset(kcontrol);
2394 bool min_mute = get_amp_min_mute(kcontrol);
2395 u32 caps, val1, val2;
2397 if (size < 4 * sizeof(unsigned int))
2399 caps = query_amp_caps(codec, nid, dir);
2400 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2401 val2 = (val2 + 1) * 25;
2402 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2404 val1 = ((int)val1) * ((int)val2);
2405 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2406 val2 |= TLV_DB_SCALE_MUTE;
2407 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2409 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2411 if (put_user(val1, _tlv + 2))
2413 if (put_user(val2, _tlv + 3))
2417 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
2420 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2421 * @codec: HD-audio codec
2422 * @nid: NID of a reference widget
2423 * @dir: #HDA_INPUT or #HDA_OUTPUT
2424 * @tlv: TLV data to be stored, at least 4 elements
2426 * Set (static) TLV data for a virtual master volume using the AMP caps
2427 * obtained from the reference NID.
2428 * The volume range is recalculated as if the max volume is 0dB.
2430 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2436 caps = query_amp_caps(codec, nid, dir);
2437 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2438 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2439 step = (step + 1) * 25;
2440 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2441 tlv[1] = 2 * sizeof(unsigned int);
2442 tlv[2] = -nums * step;
2445 EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
2447 /* find a mixer control element with the given name */
2448 static struct snd_kcontrol *
2449 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2451 struct snd_ctl_elem_id id;
2452 memset(&id, 0, sizeof(id));
2453 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2456 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2458 strcpy(id.name, name);
2459 return snd_ctl_find_id(codec->bus->card, &id);
2463 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2464 * @codec: HD-audio codec
2465 * @name: ctl id name string
2467 * Get the control element with the given id string and IFACE_MIXER.
2469 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2472 return find_mixer_ctl(codec, name, 0, 0);
2474 EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
2476 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2480 /* 16 ctlrs should be large enough */
2481 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2482 if (!find_mixer_ctl(codec, name, 0, idx))
2489 * snd_hda_ctl_add - Add a control element and assign to the codec
2490 * @codec: HD-audio codec
2491 * @nid: corresponding NID (optional)
2492 * @kctl: the control element to assign
2494 * Add the given control element to an array inside the codec instance.
2495 * All control elements belonging to a codec are supposed to be added
2496 * by this function so that a proper clean-up works at the free or
2497 * reconfiguration time.
2499 * If non-zero @nid is passed, the NID is assigned to the control element.
2500 * The assignment is shown in the codec proc file.
2502 * snd_hda_ctl_add() checks the control subdev id field whether
2503 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2504 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2505 * specifies if kctl->private_value is a HDA amplifier value.
2507 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2508 struct snd_kcontrol *kctl)
2511 unsigned short flags = 0;
2512 struct hda_nid_item *item;
2514 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2515 flags |= HDA_NID_ITEM_AMP;
2517 nid = get_amp_nid_(kctl->private_value);
2519 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2520 nid = kctl->id.subdevice & 0xffff;
2521 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2522 kctl->id.subdevice = 0;
2523 err = snd_ctl_add(codec->bus->card, kctl);
2526 item = snd_array_new(&codec->mixers);
2531 item->flags = flags;
2534 EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
2537 * snd_hda_add_nid - Assign a NID to a control element
2538 * @codec: HD-audio codec
2539 * @nid: corresponding NID (optional)
2540 * @kctl: the control element to assign
2541 * @index: index to kctl
2543 * Add the given control element to an array inside the codec instance.
2544 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2545 * NID:KCTL mapping - for example "Capture Source" selector.
2547 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2548 unsigned int index, hda_nid_t nid)
2550 struct hda_nid_item *item;
2553 item = snd_array_new(&codec->nids);
2557 item->index = index;
2561 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2562 kctl->id.name, kctl->id.index, index);
2565 EXPORT_SYMBOL_GPL(snd_hda_add_nid);
2568 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2569 * @codec: HD-audio codec
2571 void snd_hda_ctls_clear(struct hda_codec *codec)
2574 struct hda_nid_item *items = codec->mixers.list;
2575 for (i = 0; i < codec->mixers.used; i++)
2576 snd_ctl_remove(codec->bus->card, items[i].kctl);
2577 snd_array_free(&codec->mixers);
2578 snd_array_free(&codec->nids);
2581 /* pseudo device locking
2582 * toggle card->shutdown to allow/disallow the device access (as a hack)
2584 int snd_hda_lock_devices(struct hda_bus *bus)
2586 struct snd_card *card = bus->card;
2587 struct hda_codec *codec;
2589 spin_lock(&card->files_lock);
2593 if (!list_empty(&card->ctl_files))
2596 list_for_each_entry(codec, &bus->codec_list, list) {
2598 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2599 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2602 if (cpcm->pcm->streams[0].substream_opened ||
2603 cpcm->pcm->streams[1].substream_opened)
2607 spin_unlock(&card->files_lock);
2613 spin_unlock(&card->files_lock);
2616 EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
2618 void snd_hda_unlock_devices(struct hda_bus *bus)
2620 struct snd_card *card = bus->card;
2623 spin_lock(&card->files_lock);
2625 spin_unlock(&card->files_lock);
2627 EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
2630 * snd_hda_codec_reset - Clear all objects assigned to the codec
2631 * @codec: HD-audio codec
2633 * This frees the all PCM and control elements assigned to the codec, and
2634 * clears the caches and restores the pin default configurations.
2636 * When a device is being used, it returns -EBSY. If successfully freed,
2639 int snd_hda_codec_reset(struct hda_codec *codec)
2641 struct hda_bus *bus = codec->bus;
2642 struct snd_card *card = bus->card;
2645 if (snd_hda_lock_devices(bus) < 0)
2648 /* OK, let it free */
2649 cancel_delayed_work_sync(&codec->jackpoll_work);
2651 cancel_delayed_work_sync(&codec->power_work);
2652 flush_workqueue(bus->workq);
2654 snd_hda_ctls_clear(codec);
2656 for (i = 0; i < codec->num_pcms; i++) {
2657 if (codec->pcm_info[i].pcm) {
2658 snd_device_free(card, codec->pcm_info[i].pcm);
2659 clear_bit(codec->pcm_info[i].device,
2663 if (codec->patch_ops.free)
2664 codec->patch_ops.free(codec);
2665 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2666 snd_hda_jack_tbl_clear(codec);
2667 codec->proc_widget_hook = NULL;
2669 free_hda_cache(&codec->amp_cache);
2670 free_hda_cache(&codec->cmd_cache);
2671 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2672 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2673 /* free only driver_pins so that init_pins + user_pins are restored */
2674 snd_array_free(&codec->driver_pins);
2675 snd_array_free(&codec->cvt_setups);
2676 snd_array_free(&codec->spdif_out);
2677 snd_array_free(&codec->verbs);
2678 codec->num_pcms = 0;
2679 codec->pcm_info = NULL;
2680 codec->preset = NULL;
2681 codec->slave_dig_outs = NULL;
2682 codec->spdif_status_reset = 0;
2683 unload_parser(codec);
2684 module_put(codec->owner);
2685 codec->owner = NULL;
2687 /* allow device access again */
2688 snd_hda_unlock_devices(bus);
2692 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2694 /* apply the function to all matching slave ctls in the mixer list */
2695 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2696 const char *suffix, map_slave_func_t func, void *data)
2698 struct hda_nid_item *items;
2699 const char * const *s;
2702 items = codec->mixers.list;
2703 for (i = 0; i < codec->mixers.used; i++) {
2704 struct snd_kcontrol *sctl = items[i].kctl;
2705 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2707 for (s = slaves; *s; s++) {
2708 char tmpname[sizeof(sctl->id.name)];
2709 const char *name = *s;
2711 snprintf(tmpname, sizeof(tmpname), "%s %s",
2715 if (!strcmp(sctl->id.name, name)) {
2716 err = func(data, sctl);
2726 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2731 /* guess the value corresponding to 0dB */
2732 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl, int *step_to_check)
2735 const int *tlv = NULL;
2738 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2739 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2740 mm_segment_t fs = get_fs();
2742 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2745 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2747 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
2749 step &= ~TLV_DB_SCALE_MUTE;
2752 if (*step_to_check && *step_to_check != step) {
2753 snd_printk(KERN_ERR "hda_codec: Mismatching dB step for vmaster slave (%d!=%d)\n",
2754 *step_to_check, step);
2757 *step_to_check = step;
2758 val = -tlv[2] / step;
2763 /* call kctl->put with the given value(s) */
2764 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2766 struct snd_ctl_elem_value *ucontrol;
2767 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2770 ucontrol->value.integer.value[0] = val;
2771 ucontrol->value.integer.value[1] = val;
2772 kctl->put(kctl, ucontrol);
2777 /* initialize the slave volume with 0dB */
2778 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2780 int offset = get_kctl_0dB_offset(slave, data);
2782 put_kctl_with_value(slave, offset);
2786 /* unmute the slave */
2787 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2789 return put_kctl_with_value(slave, 1);
2793 * snd_hda_add_vmaster - create a virtual master control and add slaves
2794 * @codec: HD-audio codec
2795 * @name: vmaster control name
2796 * @tlv: TLV data (optional)
2797 * @slaves: slave control names (optional)
2798 * @suffix: suffix string to each slave name (optional)
2799 * @init_slave_vol: initialize slaves to unmute/0dB
2800 * @ctl_ret: store the vmaster kcontrol in return
2802 * Create a virtual master control with the given name. The TLV data
2803 * must be either NULL or a valid data.
2805 * @slaves is a NULL-terminated array of strings, each of which is a
2806 * slave control name. All controls with these names are assigned to
2807 * the new virtual master control.
2809 * This function returns zero if successful or a negative error code.
2811 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2812 unsigned int *tlv, const char * const *slaves,
2813 const char *suffix, bool init_slave_vol,
2814 struct snd_kcontrol **ctl_ret)
2816 struct snd_kcontrol *kctl;
2822 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2824 snd_printdd("No slave found for %s\n", name);
2827 kctl = snd_ctl_make_virtual_master(name, tlv);
2830 err = snd_hda_ctl_add(codec, 0, kctl);
2834 err = map_slaves(codec, slaves, suffix,
2835 (map_slave_func_t)snd_ctl_add_slave, kctl);
2839 /* init with master mute & zero volume */
2840 put_kctl_with_value(kctl, 0);
2841 if (init_slave_vol) {
2843 map_slaves(codec, slaves, suffix,
2844 tlv ? init_slave_0dB : init_slave_unmute, &step);
2851 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
2854 * mute-LED control using vmaster
2856 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2857 struct snd_ctl_elem_info *uinfo)
2859 static const char * const texts[] = {
2860 "On", "Off", "Follow Master"
2864 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2866 uinfo->value.enumerated.items = 3;
2867 index = uinfo->value.enumerated.item;
2870 strcpy(uinfo->value.enumerated.name, texts[index]);
2874 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2875 struct snd_ctl_elem_value *ucontrol)
2877 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2878 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2882 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2883 struct snd_ctl_elem_value *ucontrol)
2885 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2886 unsigned int old_mode = hook->mute_mode;
2888 hook->mute_mode = ucontrol->value.enumerated.item[0];
2889 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2890 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2891 if (old_mode == hook->mute_mode)
2893 snd_hda_sync_vmaster_hook(hook);
2897 static struct snd_kcontrol_new vmaster_mute_mode = {
2898 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2899 .name = "Mute-LED Mode",
2900 .info = vmaster_mute_mode_info,
2901 .get = vmaster_mute_mode_get,
2902 .put = vmaster_mute_mode_put,
2906 * Add a mute-LED hook with the given vmaster switch kctl
2907 * "Mute-LED Mode" control is automatically created and associated with
2910 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2911 struct hda_vmaster_mute_hook *hook,
2912 bool expose_enum_ctl)
2914 struct snd_kcontrol *kctl;
2916 if (!hook->hook || !hook->sw_kctl)
2918 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2919 hook->codec = codec;
2920 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2921 if (!expose_enum_ctl)
2923 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2926 return snd_hda_ctl_add(codec, 0, kctl);
2928 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
2931 * Call the hook with the current value for synchronization
2932 * Should be called in init callback
2934 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2936 if (!hook->hook || !hook->codec)
2938 /* don't call vmaster hook in the destructor since it might have
2939 * been already destroyed
2941 if (hook->codec->bus->shutdown)
2943 switch (hook->mute_mode) {
2944 case HDA_VMUTE_FOLLOW_MASTER:
2945 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2948 hook->hook(hook->codec, hook->mute_mode);
2952 EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
2956 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2958 * The control element is supposed to have the private_value field
2959 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2961 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2962 struct snd_ctl_elem_info *uinfo)
2964 int chs = get_amp_channels(kcontrol);
2966 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2967 uinfo->count = chs == 3 ? 2 : 1;
2968 uinfo->value.integer.min = 0;
2969 uinfo->value.integer.max = 1;
2972 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
2975 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2977 * The control element is supposed to have the private_value field
2978 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2980 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2981 struct snd_ctl_elem_value *ucontrol)
2983 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2984 hda_nid_t nid = get_amp_nid(kcontrol);
2985 int chs = get_amp_channels(kcontrol);
2986 int dir = get_amp_direction(kcontrol);
2987 int idx = get_amp_index(kcontrol);
2988 long *valp = ucontrol->value.integer.value;
2991 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2992 HDA_AMP_MUTE) ? 0 : 1;
2994 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2995 HDA_AMP_MUTE) ? 0 : 1;
2998 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
3001 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
3003 * The control element is supposed to have the private_value field
3004 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
3006 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
3007 struct snd_ctl_elem_value *ucontrol)
3009 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3010 hda_nid_t nid = get_amp_nid(kcontrol);
3011 int chs = get_amp_channels(kcontrol);
3012 int dir = get_amp_direction(kcontrol);
3013 int idx = get_amp_index(kcontrol);
3014 long *valp = ucontrol->value.integer.value;
3017 snd_hda_power_up(codec);
3019 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
3021 *valp ? 0 : HDA_AMP_MUTE);
3025 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
3027 *valp ? 0 : HDA_AMP_MUTE);
3028 hda_call_check_power_status(codec, nid);
3029 snd_hda_power_down(codec);
3032 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
3035 * bound volume controls
3037 * bind multiple volumes (# indices, from 0)
3040 #define AMP_VAL_IDX_SHIFT 19
3041 #define AMP_VAL_IDX_MASK (0x0f<<19)
3044 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
3046 * The control element is supposed to have the private_value field
3047 * set up via HDA_BIND_MUTE*() macros.
3049 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
3050 struct snd_ctl_elem_value *ucontrol)
3052 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3056 mutex_lock(&codec->control_mutex);
3057 pval = kcontrol->private_value;
3058 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
3059 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
3060 kcontrol->private_value = pval;
3061 mutex_unlock(&codec->control_mutex);
3064 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
3067 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
3069 * The control element is supposed to have the private_value field
3070 * set up via HDA_BIND_MUTE*() macros.
3072 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
3073 struct snd_ctl_elem_value *ucontrol)
3075 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3077 int i, indices, err = 0, change = 0;
3079 mutex_lock(&codec->control_mutex);
3080 pval = kcontrol->private_value;
3081 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
3082 for (i = 0; i < indices; i++) {
3083 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
3084 (i << AMP_VAL_IDX_SHIFT);
3085 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3090 kcontrol->private_value = pval;
3091 mutex_unlock(&codec->control_mutex);
3092 return err < 0 ? err : change;
3094 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
3097 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
3099 * The control element is supposed to have the private_value field
3100 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3102 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
3103 struct snd_ctl_elem_info *uinfo)
3105 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3106 struct hda_bind_ctls *c;
3109 mutex_lock(&codec->control_mutex);
3110 c = (struct hda_bind_ctls *)kcontrol->private_value;
3111 kcontrol->private_value = *c->values;
3112 err = c->ops->info(kcontrol, uinfo);
3113 kcontrol->private_value = (long)c;
3114 mutex_unlock(&codec->control_mutex);
3117 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
3120 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
3122 * The control element is supposed to have the private_value field
3123 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3125 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
3126 struct snd_ctl_elem_value *ucontrol)
3128 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3129 struct hda_bind_ctls *c;
3132 mutex_lock(&codec->control_mutex);
3133 c = (struct hda_bind_ctls *)kcontrol->private_value;
3134 kcontrol->private_value = *c->values;
3135 err = c->ops->get(kcontrol, ucontrol);
3136 kcontrol->private_value = (long)c;
3137 mutex_unlock(&codec->control_mutex);
3140 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
3143 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
3145 * The control element is supposed to have the private_value field
3146 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3148 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
3149 struct snd_ctl_elem_value *ucontrol)
3151 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3152 struct hda_bind_ctls *c;
3153 unsigned long *vals;
3154 int err = 0, change = 0;
3156 mutex_lock(&codec->control_mutex);
3157 c = (struct hda_bind_ctls *)kcontrol->private_value;
3158 for (vals = c->values; *vals; vals++) {
3159 kcontrol->private_value = *vals;
3160 err = c->ops->put(kcontrol, ucontrol);
3165 kcontrol->private_value = (long)c;
3166 mutex_unlock(&codec->control_mutex);
3167 return err < 0 ? err : change;
3169 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
3172 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3174 * The control element is supposed to have the private_value field
3175 * set up via HDA_BIND_VOL() macro.
3177 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3178 unsigned int size, unsigned int __user *tlv)
3180 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3181 struct hda_bind_ctls *c;
3184 mutex_lock(&codec->control_mutex);
3185 c = (struct hda_bind_ctls *)kcontrol->private_value;
3186 kcontrol->private_value = *c->values;
3187 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3188 kcontrol->private_value = (long)c;
3189 mutex_unlock(&codec->control_mutex);
3192 EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
3194 struct hda_ctl_ops snd_hda_bind_vol = {
3195 .info = snd_hda_mixer_amp_volume_info,
3196 .get = snd_hda_mixer_amp_volume_get,
3197 .put = snd_hda_mixer_amp_volume_put,
3198 .tlv = snd_hda_mixer_amp_tlv
3200 EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
3202 struct hda_ctl_ops snd_hda_bind_sw = {
3203 .info = snd_hda_mixer_amp_switch_info,
3204 .get = snd_hda_mixer_amp_switch_get,
3205 .put = snd_hda_mixer_amp_switch_put,
3206 .tlv = snd_hda_mixer_amp_tlv
3208 EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
3211 * SPDIF out controls
3214 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3215 struct snd_ctl_elem_info *uinfo)
3217 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3222 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3223 struct snd_ctl_elem_value *ucontrol)
3225 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3226 IEC958_AES0_NONAUDIO |
3227 IEC958_AES0_CON_EMPHASIS_5015 |
3228 IEC958_AES0_CON_NOT_COPYRIGHT;
3229 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3230 IEC958_AES1_CON_ORIGINAL;
3234 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3235 struct snd_ctl_elem_value *ucontrol)
3237 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3238 IEC958_AES0_NONAUDIO |
3239 IEC958_AES0_PRO_EMPHASIS_5015;
3243 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3244 struct snd_ctl_elem_value *ucontrol)
3246 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3247 int idx = kcontrol->private_value;
3248 struct hda_spdif_out *spdif;
3250 mutex_lock(&codec->spdif_mutex);
3251 spdif = snd_array_elem(&codec->spdif_out, idx);
3252 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3253 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3254 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3255 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3256 mutex_unlock(&codec->spdif_mutex);
3261 /* convert from SPDIF status bits to HDA SPDIF bits
3262 * bit 0 (DigEn) is always set zero (to be filled later)
3264 static unsigned short convert_from_spdif_status(unsigned int sbits)
3266 unsigned short val = 0;
3268 if (sbits & IEC958_AES0_PROFESSIONAL)
3269 val |= AC_DIG1_PROFESSIONAL;
3270 if (sbits & IEC958_AES0_NONAUDIO)
3271 val |= AC_DIG1_NONAUDIO;
3272 if (sbits & IEC958_AES0_PROFESSIONAL) {
3273 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3274 IEC958_AES0_PRO_EMPHASIS_5015)
3275 val |= AC_DIG1_EMPHASIS;
3277 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3278 IEC958_AES0_CON_EMPHASIS_5015)
3279 val |= AC_DIG1_EMPHASIS;
3280 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3281 val |= AC_DIG1_COPYRIGHT;
3282 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3283 val |= AC_DIG1_LEVEL;
3284 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3289 /* convert to SPDIF status bits from HDA SPDIF bits
3291 static unsigned int convert_to_spdif_status(unsigned short val)
3293 unsigned int sbits = 0;
3295 if (val & AC_DIG1_NONAUDIO)
3296 sbits |= IEC958_AES0_NONAUDIO;
3297 if (val & AC_DIG1_PROFESSIONAL)
3298 sbits |= IEC958_AES0_PROFESSIONAL;
3299 if (sbits & IEC958_AES0_PROFESSIONAL) {
3300 if (val & AC_DIG1_EMPHASIS)
3301 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3303 if (val & AC_DIG1_EMPHASIS)
3304 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3305 if (!(val & AC_DIG1_COPYRIGHT))
3306 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3307 if (val & AC_DIG1_LEVEL)
3308 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3309 sbits |= val & (0x7f << 8);
3314 /* set digital convert verbs both for the given NID and its slaves */
3315 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3320 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3321 d = codec->slave_dig_outs;
3325 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3328 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3332 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3334 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3337 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3338 struct snd_ctl_elem_value *ucontrol)
3340 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3341 int idx = kcontrol->private_value;
3342 struct hda_spdif_out *spdif;
3347 mutex_lock(&codec->spdif_mutex);
3348 spdif = snd_array_elem(&codec->spdif_out, idx);
3350 spdif->status = ucontrol->value.iec958.status[0] |
3351 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3352 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3353 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3354 val = convert_from_spdif_status(spdif->status);
3355 val |= spdif->ctls & 1;
3356 change = spdif->ctls != val;
3358 if (change && nid != (u16)-1)
3359 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3360 mutex_unlock(&codec->spdif_mutex);
3364 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3366 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3367 struct snd_ctl_elem_value *ucontrol)
3369 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3370 int idx = kcontrol->private_value;
3371 struct hda_spdif_out *spdif;
3373 mutex_lock(&codec->spdif_mutex);
3374 spdif = snd_array_elem(&codec->spdif_out, idx);
3375 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3376 mutex_unlock(&codec->spdif_mutex);
3380 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3383 set_dig_out_convert(codec, nid, dig1, dig2);
3384 /* unmute amp switch (if any) */
3385 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3386 (dig1 & AC_DIG1_ENABLE))
3387 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3391 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3392 struct snd_ctl_elem_value *ucontrol)
3394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3395 int idx = kcontrol->private_value;
3396 struct hda_spdif_out *spdif;
3401 mutex_lock(&codec->spdif_mutex);
3402 spdif = snd_array_elem(&codec->spdif_out, idx);
3404 val = spdif->ctls & ~AC_DIG1_ENABLE;
3405 if (ucontrol->value.integer.value[0])
3406 val |= AC_DIG1_ENABLE;
3407 change = spdif->ctls != val;
3409 if (change && nid != (u16)-1)
3410 set_spdif_ctls(codec, nid, val & 0xff, -1);
3411 mutex_unlock(&codec->spdif_mutex);
3415 static struct snd_kcontrol_new dig_mixes[] = {
3417 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3418 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3419 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3420 .info = snd_hda_spdif_mask_info,
3421 .get = snd_hda_spdif_cmask_get,
3424 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3425 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3426 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3427 .info = snd_hda_spdif_mask_info,
3428 .get = snd_hda_spdif_pmask_get,
3431 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3432 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3433 .info = snd_hda_spdif_mask_info,
3434 .get = snd_hda_spdif_default_get,
3435 .put = snd_hda_spdif_default_put,
3438 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3439 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3440 .info = snd_hda_spdif_out_switch_info,
3441 .get = snd_hda_spdif_out_switch_get,
3442 .put = snd_hda_spdif_out_switch_put,
3448 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3449 * @codec: the HDA codec
3450 * @associated_nid: NID that new ctls associated with
3451 * @cvt_nid: converter NID
3452 * @type: HDA_PCM_TYPE_*
3453 * Creates controls related with the digital output.
3454 * Called from each patch supporting the digital out.
3456 * Returns 0 if successful, or a negative error code.
3458 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3459 hda_nid_t associated_nid,
3464 struct snd_kcontrol *kctl;
3465 struct snd_kcontrol_new *dig_mix;
3467 const int spdif_index = 16;
3468 struct hda_spdif_out *spdif;
3469 struct hda_bus *bus = codec->bus;
3471 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3472 type == HDA_PCM_TYPE_SPDIF) {
3474 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3475 type == HDA_PCM_TYPE_HDMI) {
3476 /* suppose a single SPDIF device */
3477 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3478 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3481 kctl->id.index = spdif_index;
3483 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3485 if (!bus->primary_dig_out_type)
3486 bus->primary_dig_out_type = type;
3488 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
3490 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3493 spdif = snd_array_new(&codec->spdif_out);
3496 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3497 kctl = snd_ctl_new1(dig_mix, codec);
3500 kctl->id.index = idx;
3501 kctl->private_value = codec->spdif_out.used - 1;
3502 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3506 spdif->nid = cvt_nid;
3507 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3508 AC_VERB_GET_DIGI_CONVERT_1, 0);
3509 spdif->status = convert_to_spdif_status(spdif->ctls);
3512 EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
3514 /* get the hda_spdif_out entry from the given NID
3515 * call within spdif_mutex lock
3517 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3521 for (i = 0; i < codec->spdif_out.used; i++) {
3522 struct hda_spdif_out *spdif =
3523 snd_array_elem(&codec->spdif_out, i);
3524 if (spdif->nid == nid)
3529 EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_nid);
3531 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3533 struct hda_spdif_out *spdif;
3535 mutex_lock(&codec->spdif_mutex);
3536 spdif = snd_array_elem(&codec->spdif_out, idx);
3537 spdif->nid = (u16)-1;
3538 mutex_unlock(&codec->spdif_mutex);
3540 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
3542 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3544 struct hda_spdif_out *spdif;
3547 mutex_lock(&codec->spdif_mutex);
3548 spdif = snd_array_elem(&codec->spdif_out, idx);
3549 if (spdif->nid != nid) {
3552 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3554 mutex_unlock(&codec->spdif_mutex);
3556 EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
3559 * SPDIF sharing with analog output
3561 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3562 struct snd_ctl_elem_value *ucontrol)
3564 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3565 ucontrol->value.integer.value[0] = mout->share_spdif;
3569 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3570 struct snd_ctl_elem_value *ucontrol)
3572 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3573 mout->share_spdif = !!ucontrol->value.integer.value[0];
3577 static struct snd_kcontrol_new spdif_share_sw = {
3578 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3579 .name = "IEC958 Default PCM Playback Switch",
3580 .info = snd_ctl_boolean_mono_info,
3581 .get = spdif_share_sw_get,
3582 .put = spdif_share_sw_put,
3586 * snd_hda_create_spdif_share_sw - create Default PCM switch
3587 * @codec: the HDA codec
3588 * @mout: multi-out instance
3590 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3591 struct hda_multi_out *mout)
3593 struct snd_kcontrol *kctl;
3595 if (!mout->dig_out_nid)
3598 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3601 /* ATTENTION: here mout is passed as private_data, instead of codec */
3602 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3604 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
3610 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3612 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3613 struct snd_ctl_elem_value *ucontrol)
3615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3617 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3621 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3622 struct snd_ctl_elem_value *ucontrol)
3624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3625 hda_nid_t nid = kcontrol->private_value;
3626 unsigned int val = !!ucontrol->value.integer.value[0];
3629 mutex_lock(&codec->spdif_mutex);
3630 change = codec->spdif_in_enable != val;
3632 codec->spdif_in_enable = val;
3633 snd_hda_codec_write_cache(codec, nid, 0,
3634 AC_VERB_SET_DIGI_CONVERT_1, val);
3636 mutex_unlock(&codec->spdif_mutex);
3640 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3641 struct snd_ctl_elem_value *ucontrol)
3643 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3644 hda_nid_t nid = kcontrol->private_value;
3648 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3649 sbits = convert_to_spdif_status(val);
3650 ucontrol->value.iec958.status[0] = sbits;
3651 ucontrol->value.iec958.status[1] = sbits >> 8;
3652 ucontrol->value.iec958.status[2] = sbits >> 16;
3653 ucontrol->value.iec958.status[3] = sbits >> 24;
3657 static struct snd_kcontrol_new dig_in_ctls[] = {
3659 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3660 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3661 .info = snd_hda_spdif_in_switch_info,
3662 .get = snd_hda_spdif_in_switch_get,
3663 .put = snd_hda_spdif_in_switch_put,
3666 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3667 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3668 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3669 .info = snd_hda_spdif_mask_info,
3670 .get = snd_hda_spdif_in_status_get,
3676 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3677 * @codec: the HDA codec
3678 * @nid: audio in widget NID
3680 * Creates controls related with the SPDIF input.
3681 * Called from each patch supporting the SPDIF in.
3683 * Returns 0 if successful, or a negative error code.
3685 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3688 struct snd_kcontrol *kctl;
3689 struct snd_kcontrol_new *dig_mix;
3692 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3694 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3697 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3698 kctl = snd_ctl_new1(dig_mix, codec);
3701 kctl->private_value = nid;
3702 err = snd_hda_ctl_add(codec, nid, kctl);
3706 codec->spdif_in_enable =
3707 snd_hda_codec_read(codec, nid, 0,
3708 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3712 EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
3718 /* build a 31bit cache key with the widget id and the command parameter */
3719 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3720 #define get_cmd_cache_nid(key) ((key) & 0xff)
3721 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3724 * snd_hda_codec_write_cache - send a single command with caching
3725 * @codec: the HDA codec
3726 * @nid: NID to send the command
3727 * @flags: optional bit flags
3728 * @verb: the verb to send
3729 * @parm: the parameter for the verb
3731 * Send a single command without waiting for response.
3733 * Returns 0 if successful, or a negative error code.
3735 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3736 int flags, unsigned int verb, unsigned int parm)
3739 struct hda_cache_head *c;
3741 unsigned int cache_only;
3743 cache_only = codec->cached_write;
3745 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
3750 /* parm may contain the verb stuff for get/set amp */
3751 verb = verb | (parm >> 8);
3753 key = build_cmd_cache_key(nid, verb);
3754 mutex_lock(&codec->bus->cmd_mutex);
3755 c = get_alloc_hash(&codec->cmd_cache, key);
3758 c->dirty = cache_only;
3760 mutex_unlock(&codec->bus->cmd_mutex);
3763 EXPORT_SYMBOL_GPL(snd_hda_codec_write_cache);
3766 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3767 * @codec: the HDA codec
3768 * @nid: NID to send the command
3769 * @flags: optional bit flags
3770 * @verb: the verb to send
3771 * @parm: the parameter for the verb
3773 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3774 * command if the parameter is already identical with the cached value.
3775 * If not, it sends the command and refreshes the cache.
3777 * Returns 0 if successful, or a negative error code.
3779 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3780 int flags, unsigned int verb, unsigned int parm)
3782 struct hda_cache_head *c;
3785 /* parm may contain the verb stuff for get/set amp */
3786 verb = verb | (parm >> 8);
3788 key = build_cmd_cache_key(nid, verb);
3789 mutex_lock(&codec->bus->cmd_mutex);
3790 c = get_hash(&codec->cmd_cache, key);
3791 if (c && c->val == parm) {
3792 mutex_unlock(&codec->bus->cmd_mutex);
3795 mutex_unlock(&codec->bus->cmd_mutex);
3796 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
3798 EXPORT_SYMBOL_GPL(snd_hda_codec_update_cache);
3801 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3802 * @codec: HD-audio codec
3804 * Execute all verbs recorded in the command caches to resume.
3806 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3810 mutex_lock(&codec->hash_mutex);
3811 codec->cached_write = 0;
3812 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3813 struct hda_cache_head *buffer;
3816 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3823 mutex_unlock(&codec->hash_mutex);
3824 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3825 get_cmd_cache_cmd(key), buffer->val);
3826 mutex_lock(&codec->hash_mutex);
3828 mutex_unlock(&codec->hash_mutex);
3830 EXPORT_SYMBOL_GPL(snd_hda_codec_resume_cache);
3833 * snd_hda_sequence_write_cache - sequence writes with caching
3834 * @codec: the HDA codec
3835 * @seq: VERB array to send
3837 * Send the commands sequentially from the given array.
3838 * Thte commands are recorded on cache for power-save and resume.
3839 * The array must be terminated with NID=0.
3841 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3842 const struct hda_verb *seq)
3844 for (; seq->nid; seq++)
3845 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3848 EXPORT_SYMBOL_GPL(snd_hda_sequence_write_cache);
3851 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3852 * @codec: HD-audio codec
3854 void snd_hda_codec_flush_cache(struct hda_codec *codec)
3856 snd_hda_codec_resume_amp(codec);
3857 snd_hda_codec_resume_cache(codec);
3859 EXPORT_SYMBOL_GPL(snd_hda_codec_flush_cache);
3861 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3862 unsigned int power_state)
3864 hda_nid_t nid = codec->start_nid;
3867 for (i = 0; i < codec->num_nodes; i++, nid++) {
3868 unsigned int wcaps = get_wcaps(codec, nid);
3869 unsigned int state = power_state;
3870 if (!(wcaps & AC_WCAP_POWER))
3872 if (codec->power_filter) {
3873 state = codec->power_filter(codec, nid, power_state);
3874 if (state != power_state && power_state == AC_PWRST_D3)
3877 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3881 EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
3884 * supported power states check
3886 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3887 unsigned int power_state)
3889 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3893 if (sup & power_state)
3900 * wait until the state is reached, returns the current state
3902 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3904 unsigned int power_state)
3906 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3907 unsigned int state, actual_state;
3910 state = snd_hda_codec_read(codec, fg, 0,
3911 AC_VERB_GET_POWER_STATE, 0);
3912 if (state & AC_PWRST_ERROR)
3914 actual_state = (state >> 4) & 0x0f;
3915 if (actual_state == power_state)
3917 if (time_after_eq(jiffies, end_time))
3919 /* wait until the codec reachs to the target state */
3925 /* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
3926 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3928 unsigned int power_state)
3930 if (nid == codec->afg || nid == codec->mfg)
3932 if (power_state == AC_PWRST_D3 &&
3933 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3934 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3935 int eapd = snd_hda_codec_read(codec, nid, 0,
3936 AC_VERB_GET_EAPD_BTLENABLE, 0);
3942 EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
3945 * set power state of the codec, and return the power state
3947 static unsigned int hda_set_power_state(struct hda_codec *codec,
3948 unsigned int power_state)
3950 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3955 /* this delay seems necessary to avoid click noise at power-down */
3956 if (power_state == AC_PWRST_D3) {
3957 if (codec->depop_delay < 0)
3958 msleep(codec->epss ? 10 : 100);
3959 else if (codec->depop_delay > 0)
3960 msleep(codec->depop_delay);
3961 flags = HDA_RW_NO_RESPONSE_FALLBACK;
3964 /* repeat power states setting at most 10 times*/
3965 for (count = 0; count < 10; count++) {
3966 if (codec->patch_ops.set_power_state)
3967 codec->patch_ops.set_power_state(codec, fg,
3970 state = power_state;
3971 if (codec->power_filter)
3972 state = codec->power_filter(codec, fg, state);
3973 if (state == power_state || power_state != AC_PWRST_D3)
3974 snd_hda_codec_read(codec, fg, flags,
3975 AC_VERB_SET_POWER_STATE,
3977 snd_hda_codec_set_power_to_all(codec, fg, power_state);
3979 state = hda_sync_power_state(codec, fg, power_state);
3980 if (!(state & AC_PWRST_ERROR))
3987 /* sync power states of all widgets;
3988 * this is called at the end of codec parsing
3990 static void sync_power_up_states(struct hda_codec *codec)
3992 hda_nid_t nid = codec->start_nid;
3995 /* don't care if no filter is used */
3996 if (!codec->power_filter)
3999 for (i = 0; i < codec->num_nodes; i++, nid++) {
4000 unsigned int wcaps = get_wcaps(codec, nid);
4001 unsigned int target;
4002 if (!(wcaps & AC_WCAP_POWER))
4004 target = codec->power_filter(codec, nid, AC_PWRST_D0);
4005 if (target == AC_PWRST_D0)
4007 if (!snd_hda_check_power_state(codec, nid, target))
4008 snd_hda_codec_write(codec, nid, 0,
4009 AC_VERB_SET_POWER_STATE, target);
4013 #ifdef CONFIG_SND_HDA_HWDEP
4014 /* execute additional init verbs */
4015 static void hda_exec_init_verbs(struct hda_codec *codec)
4017 if (codec->init_verbs.list)
4018 snd_hda_sequence_write(codec, codec->init_verbs.list);
4021 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
4026 * call suspend and power-down; used both from PM and power-save
4027 * this function returns the power state in the end
4029 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
4035 if (codec->patch_ops.suspend)
4036 codec->patch_ops.suspend(codec);
4037 hda_cleanup_all_streams(codec);
4038 state = hda_set_power_state(codec, AC_PWRST_D3);
4039 /* Cancel delayed work if we aren't currently running from it. */
4041 cancel_delayed_work_sync(&codec->power_work);
4042 spin_lock(&codec->power_lock);
4043 snd_hda_update_power_acct(codec);
4044 trace_hda_power_down(codec);
4045 codec->power_on = 0;
4046 codec->power_transition = 0;
4047 codec->power_jiffies = jiffies;
4048 spin_unlock(&codec->power_lock);
4053 /* mark all entries of cmd and amp caches dirty */
4054 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
4057 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
4058 struct hda_cache_head *cmd;
4059 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
4062 for (i = 0; i < codec->amp_cache.buf.used; i++) {
4063 struct hda_amp_info *amp;
4064 amp = snd_array_elem(&codec->amp_cache.buf, i);
4065 amp->head.dirty = 1;
4070 * kick up codec; used both from PM and power-save
4072 static void hda_call_codec_resume(struct hda_codec *codec)
4076 hda_mark_cmd_cache_dirty(codec);
4078 /* set as if powered on for avoiding re-entering the resume
4079 * in the resume / power-save sequence
4081 hda_keep_power_on(codec);
4082 hda_set_power_state(codec, AC_PWRST_D0);
4083 restore_shutup_pins(codec);
4084 hda_exec_init_verbs(codec);
4085 snd_hda_jack_set_dirty_all(codec);
4086 if (codec->patch_ops.resume)
4087 codec->patch_ops.resume(codec);
4089 if (codec->patch_ops.init)
4090 codec->patch_ops.init(codec);
4091 snd_hda_codec_resume_amp(codec);
4092 snd_hda_codec_resume_cache(codec);
4095 if (codec->jackpoll_interval)
4096 hda_jackpoll_work(&codec->jackpoll_work.work);
4098 snd_hda_jack_report_sync(codec);
4101 snd_hda_power_down(codec); /* flag down before returning */
4103 #endif /* CONFIG_PM */
4107 * snd_hda_build_controls - build mixer controls
4110 * Creates mixer controls for each codec included in the bus.
4112 * Returns 0 if successful, otherwise a negative error code.
4114 int snd_hda_build_controls(struct hda_bus *bus)
4116 struct hda_codec *codec;
4118 list_for_each_entry(codec, &bus->codec_list, list) {
4119 int err = snd_hda_codec_build_controls(codec);
4121 printk(KERN_ERR "hda_codec: cannot build controls "
4122 "for #%d (error %d)\n", codec->addr, err);
4123 err = snd_hda_codec_reset(codec);
4126 "hda_codec: cannot revert codec\n");
4133 EXPORT_SYMBOL_GPL(snd_hda_build_controls);
4136 * add standard channel maps if not specified
4138 static int add_std_chmaps(struct hda_codec *codec)
4142 for (i = 0; i < codec->num_pcms; i++) {
4143 for (str = 0; str < 2; str++) {
4144 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4145 struct hda_pcm_stream *hinfo =
4146 &codec->pcm_info[i].stream[str];
4147 struct snd_pcm_chmap *chmap;
4148 const struct snd_pcm_chmap_elem *elem;
4150 if (codec->pcm_info[i].own_chmap)
4152 if (!pcm || !hinfo->substreams)
4154 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4155 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
4156 hinfo->channels_max,
4160 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4166 /* default channel maps for 2.1 speakers;
4167 * since HD-audio supports only stereo, odd number channels are omitted
4169 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4171 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4173 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4174 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4177 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4179 int snd_hda_codec_build_controls(struct hda_codec *codec)
4182 hda_exec_init_verbs(codec);
4183 /* continue to initialize... */
4184 if (codec->patch_ops.init)
4185 err = codec->patch_ops.init(codec);
4186 if (!err && codec->patch_ops.build_controls)
4187 err = codec->patch_ops.build_controls(codec);
4191 /* we create chmaps here instead of build_pcms */
4192 err = add_std_chmaps(codec);
4196 if (codec->jackpoll_interval)
4197 hda_jackpoll_work(&codec->jackpoll_work.work);
4199 snd_hda_jack_report_sync(codec); /* call at the last init point */
4200 sync_power_up_states(codec);
4207 struct hda_rate_tbl {
4209 unsigned int alsa_bits;
4210 unsigned int hda_fmt;
4213 /* rate = base * mult / div */
4214 #define HDA_RATE(base, mult, div) \
4215 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4216 (((div) - 1) << AC_FMT_DIV_SHIFT))
4218 static struct hda_rate_tbl rate_bits[] = {
4219 /* rate in Hz, ALSA rate bitmask, HDA format value */
4221 /* autodetected value used in snd_hda_query_supported_pcm */
4222 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4223 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4224 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4225 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4226 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4227 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4228 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4229 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4230 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4231 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4232 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
4233 #define AC_PAR_PCM_RATE_BITS 11
4234 /* up to bits 10, 384kHZ isn't supported properly */
4236 /* not autodetected value */
4237 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
4239 { 0 } /* terminator */
4243 * snd_hda_calc_stream_format - calculate format bitset
4244 * @rate: the sample rate
4245 * @channels: the number of channels
4246 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4247 * @maxbps: the max. bps
4249 * Calculate the format bitset from the given rate, channels and th PCM format.
4251 * Return zero if invalid.
4253 unsigned int snd_hda_calc_stream_format(unsigned int rate,
4254 unsigned int channels,
4255 unsigned int format,
4256 unsigned int maxbps,
4257 unsigned short spdif_ctls)
4260 unsigned int val = 0;
4262 for (i = 0; rate_bits[i].hz; i++)
4263 if (rate_bits[i].hz == rate) {
4264 val = rate_bits[i].hda_fmt;
4267 if (!rate_bits[i].hz) {
4268 snd_printdd("invalid rate %d\n", rate);
4272 if (channels == 0 || channels > 8) {
4273 snd_printdd("invalid channels %d\n", channels);
4276 val |= channels - 1;
4278 switch (snd_pcm_format_width(format)) {
4280 val |= AC_FMT_BITS_8;
4283 val |= AC_FMT_BITS_16;
4288 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
4289 val |= AC_FMT_BITS_32;
4290 else if (maxbps >= 24)
4291 val |= AC_FMT_BITS_24;
4293 val |= AC_FMT_BITS_20;
4296 snd_printdd("invalid format width %d\n",
4297 snd_pcm_format_width(format));
4301 if (spdif_ctls & AC_DIG1_NONAUDIO)
4302 val |= AC_FMT_TYPE_NON_PCM;
4306 EXPORT_SYMBOL_GPL(snd_hda_calc_stream_format);
4308 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4311 unsigned int val = 0;
4312 if (nid != codec->afg &&
4313 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4314 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4315 if (!val || val == -1)
4316 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4317 if (!val || val == -1)
4322 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4324 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4328 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4331 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4332 if (!streams || streams == -1)
4333 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4334 if (!streams || streams == -1)
4339 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4341 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4346 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4347 * @codec: the HDA codec
4348 * @nid: NID to query
4349 * @ratesp: the pointer to store the detected rate bitflags
4350 * @formatsp: the pointer to store the detected formats
4351 * @bpsp: the pointer to store the detected format widths
4353 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4354 * or @bsps argument is ignored.
4356 * Returns 0 if successful, otherwise a negative error code.
4358 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4359 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4361 unsigned int i, val, wcaps;
4363 wcaps = get_wcaps(codec, nid);
4364 val = query_pcm_param(codec, nid);
4368 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4370 rates |= rate_bits[i].alsa_bits;
4373 snd_printk(KERN_ERR "hda_codec: rates == 0 "
4374 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4376 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4382 if (formatsp || bpsp) {
4384 unsigned int streams, bps;
4386 streams = query_stream_param(codec, nid);
4391 if (streams & AC_SUPFMT_PCM) {
4392 if (val & AC_SUPPCM_BITS_8) {
4393 formats |= SNDRV_PCM_FMTBIT_U8;
4396 if (val & AC_SUPPCM_BITS_16) {
4397 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4400 if (wcaps & AC_WCAP_DIGITAL) {
4401 if (val & AC_SUPPCM_BITS_32)
4402 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4403 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4404 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4405 if (val & AC_SUPPCM_BITS_24)
4407 else if (val & AC_SUPPCM_BITS_20)
4409 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4410 AC_SUPPCM_BITS_32)) {
4411 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4412 if (val & AC_SUPPCM_BITS_32)
4414 else if (val & AC_SUPPCM_BITS_24)
4416 else if (val & AC_SUPPCM_BITS_20)
4420 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4421 if (streams & AC_SUPFMT_FLOAT32) {
4422 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4427 if (streams == AC_SUPFMT_AC3) {
4428 /* should be exclusive */
4429 /* temporary hack: we have still no proper support
4430 * for the direct AC3 stream...
4432 formats |= SNDRV_PCM_FMTBIT_U8;
4436 snd_printk(KERN_ERR "hda_codec: formats == 0 "
4437 "(nid=0x%x, val=0x%x, ovrd=%i, "
4440 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4445 *formatsp = formats;
4452 EXPORT_SYMBOL_GPL(snd_hda_query_supported_pcm);
4455 * snd_hda_is_supported_format - Check the validity of the format
4456 * @codec: HD-audio codec
4457 * @nid: NID to check
4458 * @format: the HD-audio format value to check
4460 * Check whether the given node supports the format value.
4462 * Returns 1 if supported, 0 if not.
4464 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4465 unsigned int format)
4468 unsigned int val = 0, rate, stream;
4470 val = query_pcm_param(codec, nid);
4474 rate = format & 0xff00;
4475 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4476 if (rate_bits[i].hda_fmt == rate) {
4481 if (i >= AC_PAR_PCM_RATE_BITS)
4484 stream = query_stream_param(codec, nid);
4488 if (stream & AC_SUPFMT_PCM) {
4489 switch (format & 0xf0) {
4491 if (!(val & AC_SUPPCM_BITS_8))
4495 if (!(val & AC_SUPPCM_BITS_16))
4499 if (!(val & AC_SUPPCM_BITS_20))
4503 if (!(val & AC_SUPPCM_BITS_24))
4507 if (!(val & AC_SUPPCM_BITS_32))
4514 /* FIXME: check for float32 and AC3? */
4519 EXPORT_SYMBOL_GPL(snd_hda_is_supported_format);
4524 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4525 struct hda_codec *codec,
4526 struct snd_pcm_substream *substream)
4531 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4532 struct hda_codec *codec,
4533 unsigned int stream_tag,
4534 unsigned int format,
4535 struct snd_pcm_substream *substream)
4537 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4541 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4542 struct hda_codec *codec,
4543 struct snd_pcm_substream *substream)
4545 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4549 static int set_pcm_default_values(struct hda_codec *codec,
4550 struct hda_pcm_stream *info)
4554 /* query support PCM information from the given NID */
4555 if (info->nid && (!info->rates || !info->formats)) {
4556 err = snd_hda_query_supported_pcm(codec, info->nid,
4557 info->rates ? NULL : &info->rates,
4558 info->formats ? NULL : &info->formats,
4559 info->maxbps ? NULL : &info->maxbps);
4563 if (info->ops.open == NULL)
4564 info->ops.open = hda_pcm_default_open_close;
4565 if (info->ops.close == NULL)
4566 info->ops.close = hda_pcm_default_open_close;
4567 if (info->ops.prepare == NULL) {
4568 if (snd_BUG_ON(!info->nid))
4570 info->ops.prepare = hda_pcm_default_prepare;
4572 if (info->ops.cleanup == NULL) {
4573 if (snd_BUG_ON(!info->nid))
4575 info->ops.cleanup = hda_pcm_default_cleanup;
4581 * codec prepare/cleanup entries
4583 int snd_hda_codec_prepare(struct hda_codec *codec,
4584 struct hda_pcm_stream *hinfo,
4585 unsigned int stream,
4586 unsigned int format,
4587 struct snd_pcm_substream *substream)
4590 mutex_lock(&codec->bus->prepare_mutex);
4591 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4593 purify_inactive_streams(codec);
4594 mutex_unlock(&codec->bus->prepare_mutex);
4597 EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
4599 void snd_hda_codec_cleanup(struct hda_codec *codec,
4600 struct hda_pcm_stream *hinfo,
4601 struct snd_pcm_substream *substream)
4603 mutex_lock(&codec->bus->prepare_mutex);
4604 hinfo->ops.cleanup(hinfo, codec, substream);
4605 mutex_unlock(&codec->bus->prepare_mutex);
4607 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
4610 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4611 "Audio", "SPDIF", "HDMI", "Modem"
4615 * get the empty PCM device number to assign
4617 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
4619 /* audio device indices; not linear to keep compatibility */
4620 /* assigned to static slots up to dev#10; if more needed, assign
4621 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4623 static int audio_idx[HDA_PCM_NTYPES][5] = {
4624 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4625 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4626 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4627 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4631 if (type >= HDA_PCM_NTYPES) {
4632 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4636 for (i = 0; audio_idx[type][i] >= 0; i++) {
4637 #ifndef CONFIG_SND_DYNAMIC_MINORS
4638 if (audio_idx[type][i] >= 8)
4641 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4642 return audio_idx[type][i];
4645 #ifdef CONFIG_SND_DYNAMIC_MINORS
4646 /* non-fixed slots starting from 10 */
4647 for (i = 10; i < 32; i++) {
4648 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4653 snd_printk(KERN_WARNING "Too many %s devices\n",
4654 snd_hda_pcm_type_name[type]);
4655 #ifndef CONFIG_SND_DYNAMIC_MINORS
4656 snd_printk(KERN_WARNING "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
4662 * attach a new PCM stream
4664 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4666 struct hda_bus *bus = codec->bus;
4667 struct hda_pcm_stream *info;
4670 if (snd_BUG_ON(!pcm->name))
4672 for (stream = 0; stream < 2; stream++) {
4673 info = &pcm->stream[stream];
4674 if (info->substreams) {
4675 err = set_pcm_default_values(codec, info);
4680 return bus->ops.attach_pcm(bus, codec, pcm);
4683 /* assign all PCMs of the given codec */
4684 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4689 if (!codec->num_pcms) {
4690 if (!codec->patch_ops.build_pcms)
4692 err = codec->patch_ops.build_pcms(codec);
4694 printk(KERN_ERR "hda_codec: cannot build PCMs"
4695 "for #%d (error %d)\n", codec->addr, err);
4696 err = snd_hda_codec_reset(codec);
4699 "hda_codec: cannot revert codec\n");
4704 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4705 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4708 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4709 continue; /* no substreams assigned */
4712 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4714 continue; /* no fatal error */
4716 err = snd_hda_attach_pcm(codec, cpcm);
4718 printk(KERN_ERR "hda_codec: cannot attach "
4719 "PCM stream %d for codec #%d\n",
4721 continue; /* no fatal error */
4729 * snd_hda_build_pcms - build PCM information
4732 * Create PCM information for each codec included in the bus.
4734 * The build_pcms codec patch is requested to set up codec->num_pcms and
4735 * codec->pcm_info properly. The array is referred by the top-level driver
4736 * to create its PCM instances.
4737 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4740 * At least, substreams, channels_min and channels_max must be filled for
4741 * each stream. substreams = 0 indicates that the stream doesn't exist.
4742 * When rates and/or formats are zero, the supported values are queried
4743 * from the given nid. The nid is used also by the default ops.prepare
4744 * and ops.cleanup callbacks.
4746 * The driver needs to call ops.open in its open callback. Similarly,
4747 * ops.close is supposed to be called in the close callback.
4748 * ops.prepare should be called in the prepare or hw_params callback
4749 * with the proper parameters for set up.
4750 * ops.cleanup should be called in hw_free for clean up of streams.
4752 * This function returns 0 if successful, or a negative error code.
4754 int snd_hda_build_pcms(struct hda_bus *bus)
4756 struct hda_codec *codec;
4758 list_for_each_entry(codec, &bus->codec_list, list) {
4759 int err = snd_hda_codec_build_pcms(codec);
4765 EXPORT_SYMBOL_GPL(snd_hda_build_pcms);
4768 * snd_hda_check_board_config - compare the current codec with the config table
4769 * @codec: the HDA codec
4770 * @num_configs: number of config enums
4771 * @models: array of model name strings
4772 * @tbl: configuration table, terminated by null entries
4774 * Compares the modelname or PCI subsystem id of the current codec with the
4775 * given configuration table. If a matching entry is found, returns its
4776 * config value (supposed to be 0 or positive).
4778 * If no entries are matching, the function returns a negative value.
4780 int snd_hda_check_board_config(struct hda_codec *codec,
4781 int num_configs, const char * const *models,
4782 const struct snd_pci_quirk *tbl)
4784 if (codec->modelname && models) {
4786 for (i = 0; i < num_configs; i++) {
4788 !strcmp(codec->modelname, models[i])) {
4789 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4790 "selected\n", models[i]);
4796 if (!codec->bus->pci || !tbl)
4799 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4802 if (tbl->value >= 0 && tbl->value < num_configs) {
4803 #ifdef CONFIG_SND_DEBUG_VERBOSE
4805 const char *model = NULL;
4807 model = models[tbl->value];
4809 sprintf(tmp, "#%d", tbl->value);
4812 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4813 "for config %x:%x (%s)\n",
4814 model, tbl->subvendor, tbl->subdevice,
4815 (tbl->name ? tbl->name : "Unknown device"));
4821 EXPORT_SYMBOL_GPL(snd_hda_check_board_config);
4824 * snd_hda_check_board_codec_sid_config - compare the current codec
4825 subsystem ID with the
4828 This is important for Gateway notebooks with SB450 HDA Audio
4829 where the vendor ID of the PCI device is:
4830 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4831 and the vendor/subvendor are found only at the codec.
4833 * @codec: the HDA codec
4834 * @num_configs: number of config enums
4835 * @models: array of model name strings
4836 * @tbl: configuration table, terminated by null entries
4838 * Compares the modelname or PCI subsystem id of the current codec with the
4839 * given configuration table. If a matching entry is found, returns its
4840 * config value (supposed to be 0 or positive).
4842 * If no entries are matching, the function returns a negative value.
4844 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4845 int num_configs, const char * const *models,
4846 const struct snd_pci_quirk *tbl)
4848 const struct snd_pci_quirk *q;
4850 /* Search for codec ID */
4851 for (q = tbl; q->subvendor; q++) {
4852 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4853 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4854 if ((codec->subsystem_id & mask) == id)
4863 if (tbl->value >= 0 && tbl->value < num_configs) {
4864 #ifdef CONFIG_SND_DEBUG_VERBOSE
4866 const char *model = NULL;
4868 model = models[tbl->value];
4870 sprintf(tmp, "#%d", tbl->value);
4873 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4874 "for config %x:%x (%s)\n",
4875 model, tbl->subvendor, tbl->subdevice,
4876 (tbl->name ? tbl->name : "Unknown device"));
4882 EXPORT_SYMBOL_GPL(snd_hda_check_board_codec_sid_config);
4885 * snd_hda_add_new_ctls - create controls from the array
4886 * @codec: the HDA codec
4887 * @knew: the array of struct snd_kcontrol_new
4889 * This helper function creates and add new controls in the given array.
4890 * The array must be terminated with an empty entry as terminator.
4892 * Returns 0 if successful, or a negative error code.
4894 int snd_hda_add_new_ctls(struct hda_codec *codec,
4895 const struct snd_kcontrol_new *knew)
4899 for (; knew->name; knew++) {
4900 struct snd_kcontrol *kctl;
4901 int addr = 0, idx = 0;
4902 if (knew->iface == -1) /* skip this codec private value */
4905 kctl = snd_ctl_new1(knew, codec);
4909 kctl->id.device = addr;
4911 kctl->id.index = idx;
4912 err = snd_hda_ctl_add(codec, 0, kctl);
4915 /* try first with another device index corresponding to
4916 * the codec addr; if it still fails (or it's the
4917 * primary codec), then try another control index
4919 if (!addr && codec->addr)
4921 else if (!idx && !knew->index) {
4922 idx = find_empty_mixer_ctl_idx(codec,
4932 EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
4935 static void hda_power_work(struct work_struct *work)
4937 struct hda_codec *codec =
4938 container_of(work, struct hda_codec, power_work.work);
4939 struct hda_bus *bus = codec->bus;
4942 spin_lock(&codec->power_lock);
4943 if (codec->power_transition > 0) { /* during power-up sequence? */
4944 spin_unlock(&codec->power_lock);
4947 if (!codec->power_on || codec->power_count) {
4948 codec->power_transition = 0;
4949 spin_unlock(&codec->power_lock);
4952 spin_unlock(&codec->power_lock);
4954 state = hda_call_codec_suspend(codec, true);
4955 if (!bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK))
4956 hda_call_pm_notify(codec, false);
4959 static void hda_keep_power_on(struct hda_codec *codec)
4961 spin_lock(&codec->power_lock);
4962 codec->power_count++;
4963 codec->power_on = 1;
4964 codec->power_jiffies = jiffies;
4965 spin_unlock(&codec->power_lock);
4966 hda_call_pm_notify(codec, true);
4969 /* update the power on/off account with the current jiffies */
4970 void snd_hda_update_power_acct(struct hda_codec *codec)
4972 unsigned long delta = jiffies - codec->power_jiffies;
4973 if (codec->power_on)
4974 codec->power_on_acct += delta;
4976 codec->power_off_acct += delta;
4977 codec->power_jiffies += delta;
4980 /* Transition to powered up, if wait_power_down then wait for a pending
4981 * transition to D3 to complete. A pending D3 transition is indicated
4982 * with power_transition == -1. */
4983 /* call this with codec->power_lock held! */
4984 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4986 /* Return if power_on or transitioning to power_on, unless currently
4988 if ((codec->power_on || codec->power_transition > 0) &&
4989 !(wait_power_down && codec->power_transition < 0))
4991 spin_unlock(&codec->power_lock);
4993 cancel_delayed_work_sync(&codec->power_work);
4995 spin_lock(&codec->power_lock);
4996 /* If the power down delayed work was cancelled above before starting,
4997 * then there is no need to go through power up here.
4999 if (codec->power_on) {
5000 if (codec->power_transition < 0)
5001 codec->power_transition = 0;
5005 trace_hda_power_up(codec);
5006 snd_hda_update_power_acct(codec);
5007 codec->power_on = 1;
5008 codec->power_jiffies = jiffies;
5009 codec->power_transition = 1; /* avoid reentrance */
5010 spin_unlock(&codec->power_lock);
5012 hda_call_codec_resume(codec);
5014 spin_lock(&codec->power_lock);
5015 codec->power_transition = 0;
5018 #define power_save(codec) \
5019 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
5021 /* Transition to powered down */
5022 static void __snd_hda_power_down(struct hda_codec *codec)
5024 if (!codec->power_on || codec->power_count || codec->power_transition)
5027 if (power_save(codec)) {
5028 codec->power_transition = -1; /* avoid reentrance */
5029 queue_delayed_work(codec->bus->workq, &codec->power_work,
5030 msecs_to_jiffies(power_save(codec) * 1000));
5035 * snd_hda_power_save - Power-up/down/sync the codec
5036 * @codec: HD-audio codec
5037 * @delta: the counter delta to change
5039 * Change the power-up counter via @delta, and power up or down the hardware
5040 * appropriately. For the power-down, queue to the delayed action.
5041 * Passing zero to @delta means to synchronize the power state.
5043 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
5045 spin_lock(&codec->power_lock);
5046 codec->power_count += delta;
5047 trace_hda_power_count(codec);
5049 __snd_hda_power_up(codec, d3wait);
5051 __snd_hda_power_down(codec);
5052 spin_unlock(&codec->power_lock);
5054 EXPORT_SYMBOL_GPL(snd_hda_power_save);
5057 * snd_hda_check_amp_list_power - Check the amp list and update the power
5058 * @codec: HD-audio codec
5059 * @check: the object containing an AMP list and the status
5060 * @nid: NID to check / update
5062 * Check whether the given NID is in the amp list. If it's in the list,
5063 * check the current AMP status, and update the the power-status according
5064 * to the mute status.
5066 * This function is supposed to be set or called from the check_power_status
5069 int snd_hda_check_amp_list_power(struct hda_codec *codec,
5070 struct hda_loopback_check *check,
5073 const struct hda_amp_list *p;
5076 if (!check->amplist)
5078 for (p = check->amplist; p->nid; p++) {
5083 return 0; /* nothing changed */
5085 for (p = check->amplist; p->nid; p++) {
5086 for (ch = 0; ch < 2; ch++) {
5087 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
5089 if (!(v & HDA_AMP_MUTE) && v > 0) {
5090 if (!check->power_on) {
5091 check->power_on = 1;
5092 snd_hda_power_up(codec);
5098 if (check->power_on) {
5099 check->power_on = 0;
5100 snd_hda_power_down(codec);
5104 EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
5108 * Channel mode helper
5112 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5114 int snd_hda_ch_mode_info(struct hda_codec *codec,
5115 struct snd_ctl_elem_info *uinfo,
5116 const struct hda_channel_mode *chmode,
5119 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5121 uinfo->value.enumerated.items = num_chmodes;
5122 if (uinfo->value.enumerated.item >= num_chmodes)
5123 uinfo->value.enumerated.item = num_chmodes - 1;
5124 sprintf(uinfo->value.enumerated.name, "%dch",
5125 chmode[uinfo->value.enumerated.item].channels);
5128 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_info);
5131 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5133 int snd_hda_ch_mode_get(struct hda_codec *codec,
5134 struct snd_ctl_elem_value *ucontrol,
5135 const struct hda_channel_mode *chmode,
5141 for (i = 0; i < num_chmodes; i++) {
5142 if (max_channels == chmode[i].channels) {
5143 ucontrol->value.enumerated.item[0] = i;
5149 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_get);
5152 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5154 int snd_hda_ch_mode_put(struct hda_codec *codec,
5155 struct snd_ctl_elem_value *ucontrol,
5156 const struct hda_channel_mode *chmode,
5162 mode = ucontrol->value.enumerated.item[0];
5163 if (mode >= num_chmodes)
5165 if (*max_channelsp == chmode[mode].channels)
5167 /* change the current channel setting */
5168 *max_channelsp = chmode[mode].channels;
5169 if (chmode[mode].sequence)
5170 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5173 EXPORT_SYMBOL_GPL(snd_hda_ch_mode_put);
5180 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5182 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5183 struct snd_ctl_elem_info *uinfo)
5187 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5189 uinfo->value.enumerated.items = imux->num_items;
5190 if (!imux->num_items)
5192 index = uinfo->value.enumerated.item;
5193 if (index >= imux->num_items)
5194 index = imux->num_items - 1;
5195 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5198 EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
5201 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5203 int snd_hda_input_mux_put(struct hda_codec *codec,
5204 const struct hda_input_mux *imux,
5205 struct snd_ctl_elem_value *ucontrol,
5207 unsigned int *cur_val)
5211 if (!imux->num_items)
5213 idx = ucontrol->value.enumerated.item[0];
5214 if (idx >= imux->num_items)
5215 idx = imux->num_items - 1;
5216 if (*cur_val == idx)
5218 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5219 imux->items[idx].index);
5223 EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
5227 * process kcontrol info callback of a simple string enum array
5228 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5230 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5231 struct snd_ctl_elem_info *uinfo,
5232 int num_items, const char * const *texts)
5234 static const char * const texts_default[] = {
5235 "Disabled", "Enabled"
5238 if (!texts || !num_items) {
5240 texts = texts_default;
5243 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5245 uinfo->value.enumerated.items = num_items;
5246 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5247 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5248 strcpy(uinfo->value.enumerated.name,
5249 texts[uinfo->value.enumerated.item]);
5252 EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
5255 * Multi-channel / digital-out PCM helper functions
5258 /* setup SPDIF output stream */
5259 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5260 unsigned int stream_tag, unsigned int format)
5262 struct hda_spdif_out *spdif;
5263 unsigned int curr_fmt;
5266 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5267 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5268 AC_VERB_GET_STREAM_FORMAT, 0);
5269 reset = codec->spdif_status_reset &&
5270 (spdif->ctls & AC_DIG1_ENABLE) &&
5273 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5276 set_dig_out_convert(codec, nid,
5277 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
5279 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
5280 if (codec->slave_dig_outs) {
5282 for (d = codec->slave_dig_outs; *d; d++)
5283 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5286 /* turn on again (if needed) */
5288 set_dig_out_convert(codec, nid,
5289 spdif->ctls & 0xff, -1);
5292 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5294 snd_hda_codec_cleanup_stream(codec, nid);
5295 if (codec->slave_dig_outs) {
5297 for (d = codec->slave_dig_outs; *d; d++)
5298 snd_hda_codec_cleanup_stream(codec, *d);
5303 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5304 * @bus: HD-audio bus
5306 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5308 struct hda_codec *codec;
5312 list_for_each_entry(codec, &bus->codec_list, list) {
5313 if (hda_codec_is_power_on(codec) &&
5314 codec->patch_ops.reboot_notify)
5315 codec->patch_ops.reboot_notify(codec);
5318 EXPORT_SYMBOL_GPL(snd_hda_bus_reboot_notify);
5321 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5323 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5324 struct hda_multi_out *mout)
5326 mutex_lock(&codec->spdif_mutex);
5327 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5328 /* already opened as analog dup; reset it once */
5329 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5330 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5331 mutex_unlock(&codec->spdif_mutex);
5334 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
5337 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5339 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5340 struct hda_multi_out *mout,
5341 unsigned int stream_tag,
5342 unsigned int format,
5343 struct snd_pcm_substream *substream)
5345 mutex_lock(&codec->spdif_mutex);
5346 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5347 mutex_unlock(&codec->spdif_mutex);
5350 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
5353 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5355 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5356 struct hda_multi_out *mout)
5358 mutex_lock(&codec->spdif_mutex);
5359 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5360 mutex_unlock(&codec->spdif_mutex);
5363 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
5366 * snd_hda_multi_out_dig_close - release the digital out stream
5368 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5369 struct hda_multi_out *mout)
5371 mutex_lock(&codec->spdif_mutex);
5372 mout->dig_out_used = 0;
5373 mutex_unlock(&codec->spdif_mutex);
5376 EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
5379 * snd_hda_multi_out_analog_open - open analog outputs
5381 * Open analog outputs and set up the hw-constraints.
5382 * If the digital outputs can be opened as slave, open the digital
5385 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5386 struct hda_multi_out *mout,
5387 struct snd_pcm_substream *substream,
5388 struct hda_pcm_stream *hinfo)
5390 struct snd_pcm_runtime *runtime = substream->runtime;
5391 runtime->hw.channels_max = mout->max_channels;
5392 if (mout->dig_out_nid) {
5393 if (!mout->analog_rates) {
5394 mout->analog_rates = hinfo->rates;
5395 mout->analog_formats = hinfo->formats;
5396 mout->analog_maxbps = hinfo->maxbps;
5398 runtime->hw.rates = mout->analog_rates;
5399 runtime->hw.formats = mout->analog_formats;
5400 hinfo->maxbps = mout->analog_maxbps;
5402 if (!mout->spdif_rates) {
5403 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5405 &mout->spdif_formats,
5406 &mout->spdif_maxbps);
5408 mutex_lock(&codec->spdif_mutex);
5409 if (mout->share_spdif) {
5410 if ((runtime->hw.rates & mout->spdif_rates) &&
5411 (runtime->hw.formats & mout->spdif_formats)) {
5412 runtime->hw.rates &= mout->spdif_rates;
5413 runtime->hw.formats &= mout->spdif_formats;
5414 if (mout->spdif_maxbps < hinfo->maxbps)
5415 hinfo->maxbps = mout->spdif_maxbps;
5417 mout->share_spdif = 0;
5418 /* FIXME: need notify? */
5421 mutex_unlock(&codec->spdif_mutex);
5423 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5424 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5426 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
5429 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5431 * Set up the i/o for analog out.
5432 * When the digital out is available, copy the front out to digital out, too.
5434 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5435 struct hda_multi_out *mout,
5436 unsigned int stream_tag,
5437 unsigned int format,
5438 struct snd_pcm_substream *substream)
5440 const hda_nid_t *nids = mout->dac_nids;
5441 int chs = substream->runtime->channels;
5442 struct hda_spdif_out *spdif;
5445 mutex_lock(&codec->spdif_mutex);
5446 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5447 if (mout->dig_out_nid && mout->share_spdif &&
5448 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5450 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5452 !(spdif->status & IEC958_AES0_NONAUDIO)) {
5453 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5454 setup_dig_out_stream(codec, mout->dig_out_nid,
5455 stream_tag, format);
5457 mout->dig_out_used = 0;
5458 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5461 mutex_unlock(&codec->spdif_mutex);
5464 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5466 if (!mout->no_share_stream &&
5467 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5468 /* headphone out will just decode front left/right (stereo) */
5469 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5471 /* extra outputs copied from front */
5472 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5473 if (!mout->no_share_stream && mout->hp_out_nid[i])
5474 snd_hda_codec_setup_stream(codec,
5475 mout->hp_out_nid[i],
5476 stream_tag, 0, format);
5479 for (i = 1; i < mout->num_dacs; i++) {
5480 if (chs >= (i + 1) * 2) /* independent out */
5481 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5483 else if (!mout->no_share_stream) /* copy front */
5484 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5488 /* extra surrounds */
5489 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
5491 if (!mout->extra_out_nid[i])
5493 if (chs >= (i + 1) * 2)
5495 else if (!mout->no_share_stream)
5497 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
5498 stream_tag, ch, format);
5503 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
5506 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5508 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5509 struct hda_multi_out *mout)
5511 const hda_nid_t *nids = mout->dac_nids;
5514 for (i = 0; i < mout->num_dacs; i++)
5515 snd_hda_codec_cleanup_stream(codec, nids[i]);
5517 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5518 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5519 if (mout->hp_out_nid[i])
5520 snd_hda_codec_cleanup_stream(codec,
5521 mout->hp_out_nid[i]);
5522 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5523 if (mout->extra_out_nid[i])
5524 snd_hda_codec_cleanup_stream(codec,
5525 mout->extra_out_nid[i]);
5526 mutex_lock(&codec->spdif_mutex);
5527 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5528 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5529 mout->dig_out_used = 0;
5531 mutex_unlock(&codec->spdif_mutex);
5534 EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
5537 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5539 * Guess the suitable VREF pin bits to be set as the pin-control value.
5540 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5542 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5544 unsigned int pincap;
5545 unsigned int oldval;
5546 oldval = snd_hda_codec_read(codec, pin, 0,
5547 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5548 pincap = snd_hda_query_pin_caps(codec, pin);
5549 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5550 /* Exception: if the default pin setup is vref50, we give it priority */
5551 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5552 return AC_PINCTL_VREF_80;
5553 else if (pincap & AC_PINCAP_VREF_50)
5554 return AC_PINCTL_VREF_50;
5555 else if (pincap & AC_PINCAP_VREF_100)
5556 return AC_PINCTL_VREF_100;
5557 else if (pincap & AC_PINCAP_VREF_GRD)
5558 return AC_PINCTL_VREF_GRD;
5559 return AC_PINCTL_VREF_HIZ;
5561 EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
5563 /* correct the pin ctl value for matching with the pin cap */
5564 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5565 hda_nid_t pin, unsigned int val)
5567 static unsigned int cap_lists[][2] = {
5568 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5569 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5570 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5571 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5577 cap = snd_hda_query_pin_caps(codec, pin);
5579 return val; /* don't know what to do... */
5581 if (val & AC_PINCTL_OUT_EN) {
5582 if (!(cap & AC_PINCAP_OUT))
5583 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5584 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5585 val &= ~AC_PINCTL_HP_EN;
5588 if (val & AC_PINCTL_IN_EN) {
5589 if (!(cap & AC_PINCAP_IN))
5590 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5592 unsigned int vcap, vref;
5594 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5595 vref = val & AC_PINCTL_VREFEN;
5596 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5597 if (vref == cap_lists[i][0] &&
5598 !(vcap & cap_lists[i][1])) {
5599 if (i == ARRAY_SIZE(cap_lists) - 1)
5600 vref = AC_PINCTL_VREF_HIZ;
5602 vref = cap_lists[i + 1][0];
5605 val &= ~AC_PINCTL_VREFEN;
5612 EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
5614 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5615 unsigned int val, bool cached)
5617 val = snd_hda_correct_pin_ctl(codec, pin, val);
5618 snd_hda_codec_set_pin_target(codec, pin, val);
5620 return snd_hda_codec_update_cache(codec, pin, 0,
5621 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5623 return snd_hda_codec_write(codec, pin, 0,
5624 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5626 EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
5629 * snd_hda_add_imux_item - Add an item to input_mux
5631 * When the same label is used already in the existing items, the number
5632 * suffix is appended to the label. This label index number is stored
5633 * to type_idx when non-NULL pointer is given.
5635 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5636 int index, int *type_idx)
5638 int i, label_idx = 0;
5639 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5640 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5643 for (i = 0; i < imux->num_items; i++) {
5644 if (!strncmp(label, imux->items[i].label, strlen(label)))
5648 *type_idx = label_idx;
5650 snprintf(imux->items[imux->num_items].label,
5651 sizeof(imux->items[imux->num_items].label),
5652 "%s %d", label, label_idx);
5654 strlcpy(imux->items[imux->num_items].label, label,
5655 sizeof(imux->items[imux->num_items].label));
5656 imux->items[imux->num_items].index = index;
5660 EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
5669 static void hda_async_suspend(void *data, async_cookie_t cookie)
5671 hda_call_codec_suspend(data, false);
5674 static void hda_async_resume(void *data, async_cookie_t cookie)
5676 hda_call_codec_resume(data);
5680 * snd_hda_suspend - suspend the codecs
5683 * Returns 0 if successful.
5685 int snd_hda_suspend(struct hda_bus *bus)
5687 struct hda_codec *codec;
5688 ASYNC_DOMAIN_EXCLUSIVE(domain);
5690 list_for_each_entry(codec, &bus->codec_list, list) {
5691 cancel_delayed_work_sync(&codec->jackpoll_work);
5692 if (hda_codec_is_power_on(codec)) {
5693 if (bus->num_codecs > 1)
5694 async_schedule_domain(hda_async_suspend, codec,
5697 hda_call_codec_suspend(codec, false);
5701 if (bus->num_codecs > 1)
5702 async_synchronize_full_domain(&domain);
5706 EXPORT_SYMBOL_GPL(snd_hda_suspend);
5709 * snd_hda_resume - resume the codecs
5712 * Returns 0 if successful.
5714 int snd_hda_resume(struct hda_bus *bus)
5716 struct hda_codec *codec;
5717 ASYNC_DOMAIN_EXCLUSIVE(domain);
5719 list_for_each_entry(codec, &bus->codec_list, list) {
5720 if (bus->num_codecs > 1)
5721 async_schedule_domain(hda_async_resume, codec, &domain);
5723 hda_call_codec_resume(codec);
5726 if (bus->num_codecs > 1)
5727 async_synchronize_full_domain(&domain);
5731 EXPORT_SYMBOL_GPL(snd_hda_resume);
5732 #endif /* CONFIG_PM */
5739 * snd_array_new - get a new element from the given array
5740 * @array: the array object
5742 * Get a new element from the given array. If it exceeds the
5743 * pre-allocated array size, re-allocate the array.
5745 * Returns NULL if allocation failed.
5747 void *snd_array_new(struct snd_array *array)
5749 if (snd_BUG_ON(!array->elem_size))
5751 if (array->used >= array->alloced) {
5752 int num = array->alloced + array->alloc_align;
5753 int size = (num + 1) * array->elem_size;
5755 if (snd_BUG_ON(num >= 4096))
5757 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
5760 array->list = nlist;
5761 array->alloced = num;
5763 return snd_array_elem(array, array->used++);
5765 EXPORT_SYMBOL_GPL(snd_array_new);
5768 * snd_array_free - free the given array elements
5769 * @array: the array object
5771 void snd_array_free(struct snd_array *array)
5778 EXPORT_SYMBOL_GPL(snd_array_free);
5781 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5782 * @pcm: PCM caps bits
5783 * @buf: the string buffer to write
5784 * @buflen: the max buffer length
5786 * used by hda_proc.c and hda_eld.c
5788 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5790 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5793 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5794 if (pcm & (AC_SUPPCM_BITS_8 << i))
5795 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5797 buf[j] = '\0'; /* necessary when j == 0 */
5799 EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
5801 MODULE_DESCRIPTION("HDA codec core");
5802 MODULE_LICENSE("GPL");