2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <sound/core.h>
30 #include "hda_codec.h"
31 #include <sound/asoundef.h>
32 #include <sound/tlv.h>
33 #include <sound/initval.h>
34 #include <sound/jack.h>
35 #include "hda_local.h"
38 #include <sound/hda_hwdep.h>
40 #define CREATE_TRACE_POINTS
41 #include "hda_trace.h"
44 * vendor / preset table
47 struct hda_vendor_id {
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids[] = {
55 { 0x1013, "Cirrus Logic" },
56 { 0x1057, "Motorola" },
57 { 0x1095, "Silicon Image" },
59 { 0x10ec, "Realtek" },
60 { 0x1102, "Creative" },
64 { 0x11d4, "Analog Devices" },
65 { 0x13f6, "C-Media" },
66 { 0x14f1, "Conexant" },
67 { 0x17e8, "Chrontel" },
69 { 0x1aec, "Wolfson Microelectronics" },
70 { 0x434d, "C-Media" },
72 { 0x8384, "SigmaTel" },
76 static DEFINE_MUTEX(preset_mutex);
77 static LIST_HEAD(hda_preset_tables);
79 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
86 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
88 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
95 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
98 #define codec_in_pm(codec) ((codec)->in_pm)
99 static void hda_power_work(struct work_struct *work);
100 static void hda_keep_power_on(struct hda_codec *codec);
101 #define hda_codec_is_power_on(codec) ((codec)->power_on)
102 static inline void hda_call_pm_notify(struct hda_bus *bus, bool power_up)
104 if (bus->ops.pm_notify)
105 bus->ops.pm_notify(bus, power_up);
108 #define codec_in_pm(codec) 0
109 static inline void hda_keep_power_on(struct hda_codec *codec) {}
110 #define hda_codec_is_power_on(codec) 1
111 #define hda_call_pm_notify(bus, state) {}
115 * snd_hda_get_jack_location - Give a location string of the jack
116 * @cfg: pin default config value
118 * Parse the pin default config value and returns the string of the
119 * jack location, e.g. "Rear", "Front", etc.
121 const char *snd_hda_get_jack_location(u32 cfg)
123 static char *bases[7] = {
124 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
126 static unsigned char specials_idx[] = {
131 static char *specials[] = {
132 "Rear Panel", "Drive Bar",
133 "Riser", "HDMI", "ATAPI",
134 "Mobile-In", "Mobile-Out"
137 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
138 if ((cfg & 0x0f) < 7)
139 return bases[cfg & 0x0f];
140 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
141 if (cfg == specials_idx[i])
146 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
149 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
150 * @cfg: pin default config value
152 * Parse the pin default config value and returns the string of the
153 * jack connectivity, i.e. external or internal connection.
155 const char *snd_hda_get_jack_connectivity(u32 cfg)
157 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
159 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
161 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
164 * snd_hda_get_jack_type - Give a type string of the jack
165 * @cfg: pin default config value
167 * Parse the pin default config value and returns the string of the
168 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
170 const char *snd_hda_get_jack_type(u32 cfg)
172 static char *jack_types[16] = {
173 "Line Out", "Speaker", "HP Out", "CD",
174 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
175 "Line In", "Aux", "Mic", "Telephony",
176 "SPDIF In", "Digital In", "Reserved", "Other"
179 return jack_types[(cfg & AC_DEFCFG_DEVICE)
180 >> AC_DEFCFG_DEVICE_SHIFT];
182 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
185 * Compose a 32bit command word to be sent to the HD-audio controller
187 static inline unsigned int
188 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int flags,
189 unsigned int verb, unsigned int parm)
193 if ((codec->addr & ~0xf) || (nid & ~0x7f) ||
194 (verb & ~0xfff) || (parm & ~0xffff)) {
195 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x\n",
196 codec->addr, nid, verb, parm);
200 val = (u32)codec->addr << 28;
201 val |= (u32)nid << 20;
208 * Send and receive a verb
210 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
211 int flags, unsigned int *res)
213 struct hda_bus *bus = codec->bus;
222 snd_hda_power_up(codec);
223 mutex_lock(&bus->cmd_mutex);
224 if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
225 bus->no_response_fallback = 1;
227 trace_hda_send_cmd(codec, cmd);
228 err = bus->ops.command(bus, cmd);
231 /* process pending verbs */
232 bus->ops.get_response(bus, codec->addr);
235 *res = bus->ops.get_response(bus, codec->addr);
236 trace_hda_get_response(codec, *res);
238 bus->no_response_fallback = 0;
239 mutex_unlock(&bus->cmd_mutex);
240 snd_hda_power_down(codec);
241 if (!codec_in_pm(codec) && res && *res == -1 && bus->rirb_error) {
242 if (bus->response_reset) {
243 snd_printd("hda_codec: resetting BUS due to "
244 "fatal communication error\n");
245 trace_hda_bus_reset(bus);
246 bus->ops.bus_reset(bus);
250 /* clear reset-flag when the communication gets recovered */
251 if (!err || codec_in_pm(codec))
252 bus->response_reset = 0;
257 * snd_hda_codec_read - send a command and get the response
258 * @codec: the HDA codec
259 * @nid: NID to send the command
260 * @flags: optional bit flags
261 * @verb: the verb to send
262 * @parm: the parameter for the verb
264 * Send a single command and read the corresponding response.
266 * Returns the obtained response value, or -1 for an error.
268 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
270 unsigned int verb, unsigned int parm)
272 unsigned cmd = make_codec_cmd(codec, nid, flags, verb, parm);
274 if (codec_exec_verb(codec, cmd, flags, &res))
278 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
281 * snd_hda_codec_write - send a single command without waiting for response
282 * @codec: the HDA codec
283 * @nid: NID to send the command
284 * @flags: optional bit flags
285 * @verb: the verb to send
286 * @parm: the parameter for the verb
288 * Send a single command without waiting for response.
290 * Returns 0 if successful, or a negative error code.
292 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
293 unsigned int verb, unsigned int parm)
295 unsigned int cmd = make_codec_cmd(codec, nid, flags, verb, parm);
297 return codec_exec_verb(codec, cmd, flags,
298 codec->bus->sync_write ? &res : NULL);
300 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
303 * snd_hda_sequence_write - sequence writes
304 * @codec: the HDA codec
305 * @seq: VERB array to send
307 * Send the commands sequentially from the given array.
308 * The array must be terminated with NID=0.
310 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
312 for (; seq->nid; seq++)
313 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
315 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
318 * snd_hda_get_sub_nodes - get the range of sub nodes
319 * @codec: the HDA codec
321 * @start_id: the pointer to store the start NID
323 * Parse the NID and store the start NID of its sub-nodes.
324 * Returns the number of sub-nodes.
326 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
331 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
334 *start_id = (parm >> 16) & 0x7fff;
335 return (int)(parm & 0x7fff);
337 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
339 /* connection list element */
340 struct hda_conn_list {
341 struct list_head list;
347 /* look up the cached results */
348 static struct hda_conn_list *
349 lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
351 struct hda_conn_list *p;
352 list_for_each_entry(p, &codec->conn_list, list) {
359 static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
360 const hda_nid_t *list)
362 struct hda_conn_list *p;
364 p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
369 memcpy(p->conns, list, len * sizeof(hda_nid_t));
370 list_add(&p->list, &codec->conn_list);
374 static void remove_conn_list(struct hda_codec *codec)
376 while (!list_empty(&codec->conn_list)) {
377 struct hda_conn_list *p;
378 p = list_first_entry(&codec->conn_list, typeof(*p), list);
384 /* read the connection and add to the cache */
385 static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
388 hda_nid_t *result = list;
391 len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
392 if (len == -ENOSPC) {
393 len = snd_hda_get_num_raw_conns(codec, nid);
394 result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
397 len = snd_hda_get_raw_connections(codec, nid, result, len);
400 len = snd_hda_override_conn_list(codec, nid, len, result);
407 * snd_hda_get_conn_list - get connection list
408 * @codec: the HDA codec
410 * @len: number of connection list entries
411 * @listp: the pointer to store NID list
413 * Parses the connection list of the given widget and stores the pointer
414 * to the list of NIDs.
416 * Returns the number of connections, or a negative error code.
418 * Note that the returned pointer isn't protected against the list
419 * modification. If snd_hda_override_conn_list() might be called
420 * concurrently, protect with a mutex appropriately.
422 int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
423 const hda_nid_t **listp)
429 const struct hda_conn_list *p;
431 /* if the connection-list is already cached, read it */
432 p = lookup_conn_list(codec, nid);
438 if (snd_BUG_ON(added))
441 err = read_and_add_raw_conns(codec, nid);
447 EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
450 * snd_hda_get_connections - copy connection list
451 * @codec: the HDA codec
453 * @conn_list: connection list array; when NULL, checks only the size
454 * @max_conns: max. number of connections to store
456 * Parses the connection list of the given widget and stores the list
459 * Returns the number of connections, or a negative error code.
461 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
462 hda_nid_t *conn_list, int max_conns)
464 const hda_nid_t *list;
465 int len = snd_hda_get_conn_list(codec, nid, &list);
467 if (len > 0 && conn_list) {
468 if (len > max_conns) {
469 snd_printk(KERN_ERR "hda_codec: "
470 "Too many connections %d for NID 0x%x\n",
474 memcpy(conn_list, list, len * sizeof(hda_nid_t));
479 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
481 /* return CONNLIST_LEN parameter of the given widget */
482 static unsigned int get_num_conns(struct hda_codec *codec, hda_nid_t nid)
484 unsigned int wcaps = get_wcaps(codec, nid);
487 if (!(wcaps & AC_WCAP_CONN_LIST) &&
488 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
491 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
497 int snd_hda_get_num_raw_conns(struct hda_codec *codec, hda_nid_t nid)
499 return snd_hda_get_raw_connections(codec, nid, NULL, 0);
503 * snd_hda_get_raw_connections - copy connection list without cache
504 * @codec: the HDA codec
506 * @conn_list: connection list array
507 * @max_conns: max. number of connections to store
509 * Like snd_hda_get_connections(), copy the connection list but without
510 * checking through the connection-list cache.
511 * Currently called only from hda_proc.c, so not exported.
513 int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
514 hda_nid_t *conn_list, int max_conns)
517 int i, conn_len, conns;
518 unsigned int shift, num_elems, mask;
522 parm = get_num_conns(codec, nid);
526 if (parm & AC_CLIST_LONG) {
535 conn_len = parm & AC_CLIST_LENGTH;
536 mask = (1 << (shift-1)) - 1;
539 return 0; /* no connection */
542 /* single connection */
543 parm = snd_hda_codec_read(codec, nid, 0,
544 AC_VERB_GET_CONNECT_LIST, 0);
545 if (parm == -1 && codec->bus->rirb_error)
548 conn_list[0] = parm & mask;
552 /* multi connection */
555 for (i = 0; i < conn_len; i++) {
559 if (i % num_elems == 0) {
560 parm = snd_hda_codec_read(codec, nid, 0,
561 AC_VERB_GET_CONNECT_LIST, i);
562 if (parm == -1 && codec->bus->rirb_error)
565 range_val = !!(parm & (1 << (shift-1))); /* ranges */
567 if (val == 0 && null_count++) { /* no second chance */
568 snd_printdd("hda_codec: "
569 "invalid CONNECT_LIST verb %x[%i]:%x\n",
575 /* ranges between the previous and this one */
576 if (!prev_nid || prev_nid >= val) {
577 snd_printk(KERN_WARNING "hda_codec: "
578 "invalid dep_range_val %x:%x\n",
582 for (n = prev_nid + 1; n <= val; n++) {
584 if (conns >= max_conns)
586 conn_list[conns] = n;
592 if (conns >= max_conns)
594 conn_list[conns] = val;
604 * snd_hda_override_conn_list - add/modify the connection-list to cache
605 * @codec: the HDA codec
607 * @len: number of connection list entries
608 * @list: the list of connection entries
610 * Add or modify the given connection-list to the cache. If the corresponding
611 * cache already exists, invalidate it and append a new one.
613 * Returns zero or a negative error code.
615 int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
616 const hda_nid_t *list)
618 struct hda_conn_list *p;
620 p = lookup_conn_list(codec, nid);
626 return add_conn_list(codec, nid, len, list);
628 EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
631 * snd_hda_get_conn_index - get the connection index of the given NID
632 * @codec: the HDA codec
633 * @mux: NID containing the list
634 * @nid: NID to select
635 * @recursive: 1 when searching NID recursively, otherwise 0
637 * Parses the connection list of the widget @mux and checks whether the
638 * widget @nid is present. If it is, return the connection index.
639 * Otherwise it returns -1.
641 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
642 hda_nid_t nid, int recursive)
644 const hda_nid_t *conn;
647 nums = snd_hda_get_conn_list(codec, mux, &conn);
648 for (i = 0; i < nums; i++)
653 if (recursive > 10) {
654 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
658 for (i = 0; i < nums; i++) {
659 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
660 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
662 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
667 EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
670 /* return DEVLIST_LEN parameter of the given widget */
671 static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
673 unsigned int wcaps = get_wcaps(codec, nid);
676 if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
677 get_wcaps_type(wcaps) != AC_WID_PIN)
680 parm = snd_hda_param_read(codec, nid, AC_PAR_DEVLIST_LEN);
681 if (parm == -1 && codec->bus->rirb_error)
683 return parm & AC_DEV_LIST_LEN_MASK;
687 * snd_hda_get_devices - copy device list without cache
688 * @codec: the HDA codec
689 * @nid: NID of the pin to parse
690 * @dev_list: device list array
691 * @max_devices: max. number of devices to store
693 * Copy the device list. This info is dynamic and so not cached.
694 * Currently called only from hda_proc.c, so not exported.
696 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
697 u8 *dev_list, int max_devices)
700 int i, dev_len, devices;
702 parm = get_num_devices(codec, nid);
703 if (!parm) /* not multi-stream capable */
707 dev_len = dev_len < max_devices ? dev_len : max_devices;
710 while (devices < dev_len) {
711 parm = snd_hda_codec_read(codec, nid, 0,
712 AC_VERB_GET_DEVICE_LIST, devices);
713 if (parm == -1 && codec->bus->rirb_error)
716 for (i = 0; i < 8; i++) {
717 dev_list[devices] = (u8)parm;
720 if (devices >= dev_len)
728 * snd_hda_queue_unsol_event - add an unsolicited event to queue
730 * @res: unsolicited event (lower 32bit of RIRB entry)
731 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
733 * Adds the given event to the queue. The events are processed in
734 * the workqueue asynchronously. Call this function in the interrupt
735 * hanlder when RIRB receives an unsolicited event.
737 * Returns 0 if successful, or a negative error code.
739 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
741 struct hda_bus_unsolicited *unsol;
744 if (!bus || !bus->workq)
747 trace_hda_unsol_event(bus, res, res_ex);
752 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
756 unsol->queue[wp] = res;
757 unsol->queue[wp + 1] = res_ex;
759 queue_work(bus->workq, &unsol->work);
763 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
766 * process queued unsolicited events
768 static void process_unsol_events(struct work_struct *work)
770 struct hda_bus_unsolicited *unsol =
771 container_of(work, struct hda_bus_unsolicited, work);
772 struct hda_bus *bus = unsol->bus;
773 struct hda_codec *codec;
774 unsigned int rp, caddr, res;
776 while (unsol->rp != unsol->wp) {
777 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
780 res = unsol->queue[rp];
781 caddr = unsol->queue[rp + 1];
782 if (!(caddr & (1 << 4))) /* no unsolicited event? */
784 codec = bus->caddr_tbl[caddr & 0x0f];
785 if (codec && codec->patch_ops.unsol_event)
786 codec->patch_ops.unsol_event(codec, res);
791 * initialize unsolicited queue
793 static int init_unsol_queue(struct hda_bus *bus)
795 struct hda_bus_unsolicited *unsol;
797 if (bus->unsol) /* already initialized */
800 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
802 snd_printk(KERN_ERR "hda_codec: "
803 "can't allocate unsolicited queue\n");
806 INIT_WORK(&unsol->work, process_unsol_events);
815 static void snd_hda_codec_free(struct hda_codec *codec);
817 static int snd_hda_bus_free(struct hda_bus *bus)
819 struct hda_codec *codec, *n;
824 flush_workqueue(bus->workq);
827 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
828 snd_hda_codec_free(codec);
830 if (bus->ops.private_free)
831 bus->ops.private_free(bus);
833 destroy_workqueue(bus->workq);
838 static int snd_hda_bus_dev_free(struct snd_device *device)
840 struct hda_bus *bus = device->device_data;
842 return snd_hda_bus_free(bus);
845 #ifdef CONFIG_SND_HDA_HWDEP
846 static int snd_hda_bus_dev_register(struct snd_device *device)
848 struct hda_bus *bus = device->device_data;
849 struct hda_codec *codec;
850 list_for_each_entry(codec, &bus->codec_list, list) {
851 snd_hda_hwdep_add_sysfs(codec);
852 snd_hda_hwdep_add_power_sysfs(codec);
857 #define snd_hda_bus_dev_register NULL
861 * snd_hda_bus_new - create a HDA bus
862 * @card: the card entry
863 * @temp: the template for hda_bus information
864 * @busp: the pointer to store the created bus instance
866 * Returns 0 if successful, or a negative error code.
868 int snd_hda_bus_new(struct snd_card *card,
869 const struct hda_bus_template *temp,
870 struct hda_bus **busp)
874 static struct snd_device_ops dev_ops = {
875 .dev_register = snd_hda_bus_dev_register,
876 .dev_free = snd_hda_bus_dev_free,
879 if (snd_BUG_ON(!temp))
881 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
887 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
889 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
894 bus->private_data = temp->private_data;
895 bus->pci = temp->pci;
896 bus->modelname = temp->modelname;
897 bus->power_save = temp->power_save;
898 bus->ops = temp->ops;
900 mutex_init(&bus->cmd_mutex);
901 mutex_init(&bus->prepare_mutex);
902 INIT_LIST_HEAD(&bus->codec_list);
904 snprintf(bus->workq_name, sizeof(bus->workq_name),
905 "hd-audio%d", card->number);
906 bus->workq = create_singlethread_workqueue(bus->workq_name);
908 snd_printk(KERN_ERR "cannot create workqueue %s\n",
914 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
916 snd_hda_bus_free(bus);
923 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
925 #ifdef CONFIG_SND_HDA_GENERIC
926 #define is_generic_config(codec) \
927 (codec->modelname && !strcmp(codec->modelname, "generic"))
929 #define is_generic_config(codec) 0
933 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
935 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
939 * find a matching codec preset
941 static const struct hda_codec_preset *
942 find_codec_preset(struct hda_codec *codec)
944 struct hda_codec_preset_list *tbl;
945 const struct hda_codec_preset *preset;
946 unsigned int mod_requested = 0;
948 if (is_generic_config(codec))
949 return NULL; /* use the generic parser */
952 mutex_lock(&preset_mutex);
953 list_for_each_entry(tbl, &hda_preset_tables, list) {
954 if (!try_module_get(tbl->owner)) {
955 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
958 for (preset = tbl->preset; preset->id; preset++) {
959 u32 mask = preset->mask;
960 if (preset->afg && preset->afg != codec->afg)
962 if (preset->mfg && preset->mfg != codec->mfg)
966 if (preset->id == (codec->vendor_id & mask) &&
968 preset->rev == codec->revision_id)) {
969 mutex_unlock(&preset_mutex);
970 codec->owner = tbl->owner;
974 module_put(tbl->owner);
976 mutex_unlock(&preset_mutex);
978 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
981 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
984 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
985 (codec->vendor_id >> 16) & 0xffff);
986 request_module(name);
994 * get_codec_name - store the codec name
996 static int get_codec_name(struct hda_codec *codec)
998 const struct hda_vendor_id *c;
999 const char *vendor = NULL;
1000 u16 vendor_id = codec->vendor_id >> 16;
1003 if (codec->vendor_name)
1006 for (c = hda_vendor_ids; c->id; c++) {
1007 if (c->id == vendor_id) {
1013 sprintf(tmp, "Generic %04x", vendor_id);
1016 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
1017 if (!codec->vendor_name)
1021 if (codec->chip_name)
1024 if (codec->preset && codec->preset->name)
1025 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
1027 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
1028 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
1030 if (!codec->chip_name)
1036 * look for an AFG and MFG nodes
1038 static void setup_fg_nodes(struct hda_codec *codec)
1040 int i, total_nodes, function_id;
1043 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
1044 for (i = 0; i < total_nodes; i++, nid++) {
1045 function_id = snd_hda_param_read(codec, nid,
1046 AC_PAR_FUNCTION_TYPE);
1047 switch (function_id & 0xff) {
1048 case AC_GRP_AUDIO_FUNCTION:
1050 codec->afg_function_id = function_id & 0xff;
1051 codec->afg_unsol = (function_id >> 8) & 1;
1053 case AC_GRP_MODEM_FUNCTION:
1055 codec->mfg_function_id = function_id & 0xff;
1056 codec->mfg_unsol = (function_id >> 8) & 1;
1065 * read widget caps for each widget and store in cache
1067 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
1072 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
1074 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
1077 nid = codec->start_nid;
1078 for (i = 0; i < codec->num_nodes; i++, nid++)
1079 codec->wcaps[i] = snd_hda_param_read(codec, nid,
1080 AC_PAR_AUDIO_WIDGET_CAP);
1084 /* read all pin default configurations and save codec->init_pins */
1085 static int read_pin_defaults(struct hda_codec *codec)
1088 hda_nid_t nid = codec->start_nid;
1090 for (i = 0; i < codec->num_nodes; i++, nid++) {
1091 struct hda_pincfg *pin;
1092 unsigned int wcaps = get_wcaps(codec, nid);
1093 unsigned int wid_type = get_wcaps_type(wcaps);
1094 if (wid_type != AC_WID_PIN)
1096 pin = snd_array_new(&codec->init_pins);
1100 pin->cfg = snd_hda_codec_read(codec, nid, 0,
1101 AC_VERB_GET_CONFIG_DEFAULT, 0);
1102 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
1103 AC_VERB_GET_PIN_WIDGET_CONTROL,
1109 /* look up the given pin config list and return the item matching with NID */
1110 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
1111 struct snd_array *array,
1115 for (i = 0; i < array->used; i++) {
1116 struct hda_pincfg *pin = snd_array_elem(array, i);
1117 if (pin->nid == nid)
1123 /* set the current pin config value for the given NID.
1124 * the value is cached, and read via snd_hda_codec_get_pincfg()
1126 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1127 hda_nid_t nid, unsigned int cfg)
1129 struct hda_pincfg *pin;
1131 /* the check below may be invalid when pins are added by a fixup
1132 * dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
1136 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1140 pin = look_up_pincfg(codec, list, nid);
1142 pin = snd_array_new(list);
1152 * snd_hda_codec_set_pincfg - Override a pin default configuration
1153 * @codec: the HDA codec
1154 * @nid: NID to set the pin config
1155 * @cfg: the pin default config value
1157 * Override a pin default configuration value in the cache.
1158 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1159 * priority than the real hardware value.
1161 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1162 hda_nid_t nid, unsigned int cfg)
1164 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
1166 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1169 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1170 * @codec: the HDA codec
1171 * @nid: NID to get the pin config
1173 * Get the current pin config value of the given pin NID.
1174 * If the pincfg value is cached or overridden via sysfs or driver,
1175 * returns the cached value.
1177 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1179 struct hda_pincfg *pin;
1181 #ifdef CONFIG_SND_HDA_HWDEP
1183 unsigned int cfg = 0;
1184 mutex_lock(&codec->user_mutex);
1185 pin = look_up_pincfg(codec, &codec->user_pins, nid);
1188 mutex_unlock(&codec->user_mutex);
1193 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1196 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1201 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1203 /* remember the current pinctl target value */
1204 int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
1207 struct hda_pincfg *pin;
1209 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1215 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pin_target);
1217 /* return the current pinctl target value */
1218 int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
1220 struct hda_pincfg *pin;
1222 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1227 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pin_target);
1230 * snd_hda_shutup_pins - Shut up all pins
1231 * @codec: the HDA codec
1233 * Clear all pin controls to shup up before suspend for avoiding click noise.
1234 * The controls aren't cached so that they can be resumed properly.
1236 void snd_hda_shutup_pins(struct hda_codec *codec)
1239 /* don't shut up pins when unloading the driver; otherwise it breaks
1240 * the default pin setup at the next load of the driver
1242 if (codec->bus->shutdown)
1244 for (i = 0; i < codec->init_pins.used; i++) {
1245 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1246 /* use read here for syncing after issuing each verb */
1247 snd_hda_codec_read(codec, pin->nid, 0,
1248 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1250 codec->pins_shutup = 1;
1252 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1255 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1256 static void restore_shutup_pins(struct hda_codec *codec)
1259 if (!codec->pins_shutup)
1261 if (codec->bus->shutdown)
1263 for (i = 0; i < codec->init_pins.used; i++) {
1264 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1265 snd_hda_codec_write(codec, pin->nid, 0,
1266 AC_VERB_SET_PIN_WIDGET_CONTROL,
1269 codec->pins_shutup = 0;
1273 static void hda_jackpoll_work(struct work_struct *work)
1275 struct hda_codec *codec =
1276 container_of(work, struct hda_codec, jackpoll_work.work);
1278 snd_hda_jack_set_dirty_all(codec);
1279 snd_hda_jack_poll_all(codec);
1281 if (!codec->jackpoll_interval)
1284 queue_delayed_work(codec->bus->workq, &codec->jackpoll_work,
1285 codec->jackpoll_interval);
1288 static void init_hda_cache(struct hda_cache_rec *cache,
1289 unsigned int record_size);
1290 static void free_hda_cache(struct hda_cache_rec *cache);
1292 /* release all pincfg lists */
1293 static void free_init_pincfgs(struct hda_codec *codec)
1295 snd_array_free(&codec->driver_pins);
1296 #ifdef CONFIG_SND_HDA_HWDEP
1297 snd_array_free(&codec->user_pins);
1299 snd_array_free(&codec->init_pins);
1303 * audio-converter setup caches
1305 struct hda_cvt_setup {
1310 unsigned char active; /* cvt is currently used */
1311 unsigned char dirty; /* setups should be cleared */
1314 /* get or create a cache entry for the given audio converter NID */
1315 static struct hda_cvt_setup *
1316 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1318 struct hda_cvt_setup *p;
1321 for (i = 0; i < codec->cvt_setups.used; i++) {
1322 p = snd_array_elem(&codec->cvt_setups, i);
1326 p = snd_array_new(&codec->cvt_setups);
1335 static void snd_hda_codec_free(struct hda_codec *codec)
1339 cancel_delayed_work_sync(&codec->jackpoll_work);
1340 snd_hda_jack_tbl_clear(codec);
1341 free_init_pincfgs(codec);
1343 cancel_delayed_work(&codec->power_work);
1344 flush_workqueue(codec->bus->workq);
1346 list_del(&codec->list);
1347 snd_array_free(&codec->mixers);
1348 snd_array_free(&codec->nids);
1349 snd_array_free(&codec->cvt_setups);
1350 snd_array_free(&codec->spdif_out);
1351 remove_conn_list(codec);
1352 codec->bus->caddr_tbl[codec->addr] = NULL;
1353 if (codec->patch_ops.free)
1354 codec->patch_ops.free(codec);
1356 if (!codec->pm_down_notified) /* cancel leftover refcounts */
1357 hda_call_pm_notify(codec->bus, false);
1359 module_put(codec->owner);
1360 free_hda_cache(&codec->amp_cache);
1361 free_hda_cache(&codec->cmd_cache);
1362 kfree(codec->vendor_name);
1363 kfree(codec->chip_name);
1364 kfree(codec->modelname);
1365 kfree(codec->wcaps);
1369 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec,
1370 hda_nid_t fg, unsigned int power_state);
1372 static unsigned int hda_set_power_state(struct hda_codec *codec,
1373 unsigned int power_state);
1376 * snd_hda_codec_new - create a HDA codec
1377 * @bus: the bus to assign
1378 * @codec_addr: the codec address
1379 * @codecp: the pointer to store the generated codec
1381 * Returns 0 if successful, or a negative error code.
1383 int snd_hda_codec_new(struct hda_bus *bus,
1384 unsigned int codec_addr,
1385 struct hda_codec **codecp)
1387 struct hda_codec *codec;
1392 if (snd_BUG_ON(!bus))
1394 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1397 if (bus->caddr_tbl[codec_addr]) {
1398 snd_printk(KERN_ERR "hda_codec: "
1399 "address 0x%x is already occupied\n", codec_addr);
1403 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1404 if (codec == NULL) {
1405 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1410 codec->addr = codec_addr;
1411 mutex_init(&codec->spdif_mutex);
1412 mutex_init(&codec->control_mutex);
1413 mutex_init(&codec->hash_mutex);
1414 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1415 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1416 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1417 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1418 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1419 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1420 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1421 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
1422 snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
1423 snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
1424 INIT_LIST_HEAD(&codec->conn_list);
1426 INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
1429 spin_lock_init(&codec->power_lock);
1430 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1431 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1432 * the caller has to power down appropriatley after initialization
1435 hda_keep_power_on(codec);
1436 hda_call_pm_notify(bus, true);
1439 if (codec->bus->modelname) {
1440 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1441 if (!codec->modelname) {
1442 snd_hda_codec_free(codec);
1447 list_add_tail(&codec->list, &bus->codec_list);
1448 bus->caddr_tbl[codec_addr] = codec;
1450 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1452 if (codec->vendor_id == -1)
1453 /* read again, hopefully the access method was corrected
1454 * in the last read...
1456 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1458 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1459 AC_PAR_SUBSYSTEM_ID);
1460 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1463 setup_fg_nodes(codec);
1464 if (!codec->afg && !codec->mfg) {
1465 snd_printdd("hda_codec: no AFG or MFG node found\n");
1470 fg = codec->afg ? codec->afg : codec->mfg;
1471 err = read_widget_caps(codec, fg);
1473 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1476 err = read_pin_defaults(codec);
1480 if (!codec->subsystem_id) {
1481 codec->subsystem_id =
1482 snd_hda_codec_read(codec, fg, 0,
1483 AC_VERB_GET_SUBSYSTEM_ID, 0);
1487 codec->d3_stop_clk = snd_hda_codec_get_supported_ps(codec, fg,
1489 if (!codec->d3_stop_clk)
1490 bus->power_keep_link_on = 1;
1492 codec->epss = snd_hda_codec_get_supported_ps(codec, fg,
1495 /* power-up all before initialization */
1496 hda_set_power_state(codec, AC_PWRST_D0);
1498 snd_hda_codec_proc_new(codec);
1500 snd_hda_create_hwdep(codec);
1502 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1503 codec->subsystem_id, codec->revision_id);
1504 snd_component_add(codec->bus->card, component);
1511 snd_hda_codec_free(codec);
1514 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1516 int snd_hda_codec_update_widgets(struct hda_codec *codec)
1521 /* Assume the function group node does not change,
1522 * only the widget nodes may change.
1524 kfree(codec->wcaps);
1525 fg = codec->afg ? codec->afg : codec->mfg;
1526 err = read_widget_caps(codec, fg);
1528 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1532 snd_array_free(&codec->init_pins);
1533 err = read_pin_defaults(codec);
1537 EXPORT_SYMBOL_HDA(snd_hda_codec_update_widgets);
1541 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1542 * @codec: the HDA codec
1544 * Start parsing of the given codec tree and (re-)initialize the whole
1547 * Returns 0 if successful or a negative error code.
1549 int snd_hda_codec_configure(struct hda_codec *codec)
1553 codec->preset = find_codec_preset(codec);
1554 if (!codec->vendor_name || !codec->chip_name) {
1555 err = get_codec_name(codec);
1560 if (is_generic_config(codec)) {
1561 err = snd_hda_parse_generic_codec(codec);
1564 if (codec->preset && codec->preset->patch) {
1565 err = codec->preset->patch(codec);
1569 /* call the default parser */
1570 err = snd_hda_parse_generic_codec(codec);
1572 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1575 if (!err && codec->patch_ops.unsol_event)
1576 err = init_unsol_queue(codec->bus);
1577 /* audio codec should override the mixer name */
1578 if (!err && (codec->afg || !*codec->bus->card->mixername))
1579 snprintf(codec->bus->card->mixername,
1580 sizeof(codec->bus->card->mixername),
1581 "%s %s", codec->vendor_name, codec->chip_name);
1584 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1586 /* update the stream-id if changed */
1587 static void update_pcm_stream_id(struct hda_codec *codec,
1588 struct hda_cvt_setup *p, hda_nid_t nid,
1589 u32 stream_tag, int channel_id)
1591 unsigned int oldval, newval;
1593 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1594 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1595 newval = (stream_tag << 4) | channel_id;
1596 if (oldval != newval)
1597 snd_hda_codec_write(codec, nid, 0,
1598 AC_VERB_SET_CHANNEL_STREAMID,
1600 p->stream_tag = stream_tag;
1601 p->channel_id = channel_id;
1605 /* update the format-id if changed */
1606 static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
1607 hda_nid_t nid, int format)
1609 unsigned int oldval;
1611 if (p->format_id != format) {
1612 oldval = snd_hda_codec_read(codec, nid, 0,
1613 AC_VERB_GET_STREAM_FORMAT, 0);
1614 if (oldval != format) {
1616 snd_hda_codec_write(codec, nid, 0,
1617 AC_VERB_SET_STREAM_FORMAT,
1620 p->format_id = format;
1625 * snd_hda_codec_setup_stream - set up the codec for streaming
1626 * @codec: the CODEC to set up
1627 * @nid: the NID to set up
1628 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1629 * @channel_id: channel id to pass, zero based.
1630 * @format: stream format.
1632 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1634 int channel_id, int format)
1636 struct hda_codec *c;
1637 struct hda_cvt_setup *p;
1644 snd_printdd("hda_codec_setup_stream: "
1645 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1646 nid, stream_tag, channel_id, format);
1647 p = get_hda_cvt_setup(codec, nid);
1651 if (codec->pcm_format_first)
1652 update_pcm_format(codec, p, nid, format);
1653 update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
1654 if (!codec->pcm_format_first)
1655 update_pcm_format(codec, p, nid, format);
1660 /* make other inactive cvts with the same stream-tag dirty */
1661 type = get_wcaps_type(get_wcaps(codec, nid));
1662 list_for_each_entry(c, &codec->bus->codec_list, list) {
1663 for (i = 0; i < c->cvt_setups.used; i++) {
1664 p = snd_array_elem(&c->cvt_setups, i);
1665 if (!p->active && p->stream_tag == stream_tag &&
1666 get_wcaps_type(get_wcaps(c, p->nid)) == type)
1671 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1673 static void really_cleanup_stream(struct hda_codec *codec,
1674 struct hda_cvt_setup *q);
1677 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1678 * @codec: the CODEC to clean up
1679 * @nid: the NID to clean up
1680 * @do_now: really clean up the stream instead of clearing the active flag
1682 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1685 struct hda_cvt_setup *p;
1690 if (codec->no_sticky_stream)
1693 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1694 p = get_hda_cvt_setup(codec, nid);
1696 /* here we just clear the active flag when do_now isn't set;
1697 * actual clean-ups will be done later in
1698 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1701 really_cleanup_stream(codec, p);
1706 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1708 static void really_cleanup_stream(struct hda_codec *codec,
1709 struct hda_cvt_setup *q)
1711 hda_nid_t nid = q->nid;
1712 if (q->stream_tag || q->channel_id)
1713 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1715 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1717 memset(q, 0, sizeof(*q));
1721 /* clean up the all conflicting obsolete streams */
1722 static void purify_inactive_streams(struct hda_codec *codec)
1724 struct hda_codec *c;
1727 list_for_each_entry(c, &codec->bus->codec_list, list) {
1728 for (i = 0; i < c->cvt_setups.used; i++) {
1729 struct hda_cvt_setup *p;
1730 p = snd_array_elem(&c->cvt_setups, i);
1732 really_cleanup_stream(c, p);
1738 /* clean up all streams; called from suspend */
1739 static void hda_cleanup_all_streams(struct hda_codec *codec)
1743 for (i = 0; i < codec->cvt_setups.used; i++) {
1744 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1746 really_cleanup_stream(codec, p);
1752 * amp access functions
1755 /* FIXME: more better hash key? */
1756 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1757 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1758 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1759 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1760 #define INFO_AMP_CAPS (1<<0)
1761 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1763 /* initialize the hash table */
1764 static void init_hda_cache(struct hda_cache_rec *cache,
1765 unsigned int record_size)
1767 memset(cache, 0, sizeof(*cache));
1768 memset(cache->hash, 0xff, sizeof(cache->hash));
1769 snd_array_init(&cache->buf, record_size, 64);
1772 static void free_hda_cache(struct hda_cache_rec *cache)
1774 snd_array_free(&cache->buf);
1777 /* query the hash. allocate an entry if not found. */
1778 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1780 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1781 u16 cur = cache->hash[idx];
1782 struct hda_cache_head *info;
1784 while (cur != 0xffff) {
1785 info = snd_array_elem(&cache->buf, cur);
1786 if (info->key == key)
1793 /* query the hash. allocate an entry if not found. */
1794 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1797 struct hda_cache_head *info = get_hash(cache, key);
1800 /* add a new hash entry */
1801 info = snd_array_new(&cache->buf);
1804 cur = snd_array_index(&cache->buf, info);
1808 idx = key % (u16)ARRAY_SIZE(cache->hash);
1809 info->next = cache->hash[idx];
1810 cache->hash[idx] = cur;
1815 /* query and allocate an amp hash entry */
1816 static inline struct hda_amp_info *
1817 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1819 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1822 /* overwrite the value with the key in the caps hash */
1823 static int write_caps_hash(struct hda_codec *codec, u32 key, unsigned int val)
1825 struct hda_amp_info *info;
1827 mutex_lock(&codec->hash_mutex);
1828 info = get_alloc_amp_hash(codec, key);
1830 mutex_unlock(&codec->hash_mutex);
1833 info->amp_caps = val;
1834 info->head.val |= INFO_AMP_CAPS;
1835 mutex_unlock(&codec->hash_mutex);
1839 /* query the value from the caps hash; if not found, fetch the current
1840 * value from the given function and store in the hash
1843 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, int dir, u32 key,
1844 unsigned int (*func)(struct hda_codec *, hda_nid_t, int))
1846 struct hda_amp_info *info;
1849 mutex_lock(&codec->hash_mutex);
1850 info = get_alloc_amp_hash(codec, key);
1852 mutex_unlock(&codec->hash_mutex);
1855 if (!(info->head.val & INFO_AMP_CAPS)) {
1856 mutex_unlock(&codec->hash_mutex); /* for reentrance */
1857 val = func(codec, nid, dir);
1858 write_caps_hash(codec, key, val);
1860 val = info->amp_caps;
1861 mutex_unlock(&codec->hash_mutex);
1866 static unsigned int read_amp_cap(struct hda_codec *codec, hda_nid_t nid,
1869 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1871 return snd_hda_param_read(codec, nid,
1872 direction == HDA_OUTPUT ?
1873 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
1877 * query_amp_caps - query AMP capabilities
1878 * @codec: the HD-auio codec
1879 * @nid: the NID to query
1880 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1882 * Query AMP capabilities for the given widget and direction.
1883 * Returns the obtained capability bits.
1885 * When cap bits have been already read, this doesn't read again but
1886 * returns the cached value.
1888 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1890 return query_caps_hash(codec, nid, direction,
1891 HDA_HASH_KEY(nid, direction, 0),
1894 EXPORT_SYMBOL_HDA(query_amp_caps);
1897 * snd_hda_override_amp_caps - Override the AMP capabilities
1898 * @codec: the CODEC to clean up
1899 * @nid: the NID to clean up
1900 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1901 * @caps: the capability bits to set
1903 * Override the cached AMP caps bits value by the given one.
1904 * This function is useful if the driver needs to adjust the AMP ranges,
1905 * e.g. limit to 0dB, etc.
1907 * Returns zero if successful or a negative error code.
1909 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1912 return write_caps_hash(codec, HDA_HASH_KEY(nid, dir, 0), caps);
1914 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1916 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid,
1919 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1923 * snd_hda_query_pin_caps - Query PIN capabilities
1924 * @codec: the HD-auio codec
1925 * @nid: the NID to query
1927 * Query PIN capabilities for the given widget.
1928 * Returns the obtained capability bits.
1930 * When cap bits have been already read, this doesn't read again but
1931 * returns the cached value.
1933 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1935 return query_caps_hash(codec, nid, 0, HDA_HASH_PINCAP_KEY(nid),
1938 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1941 * snd_hda_override_pin_caps - Override the pin capabilities
1943 * @nid: the NID to override
1944 * @caps: the capability bits to set
1946 * Override the cached PIN capabilitiy bits value by the given one.
1948 * Returns zero if successful or a negative error code.
1950 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1953 return write_caps_hash(codec, HDA_HASH_PINCAP_KEY(nid), caps);
1955 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1957 /* read or sync the hash value with the current value;
1958 * call within hash_mutex
1960 static struct hda_amp_info *
1961 update_amp_hash(struct hda_codec *codec, hda_nid_t nid, int ch,
1962 int direction, int index, bool init_only)
1964 struct hda_amp_info *info;
1965 unsigned int parm, val = 0;
1966 bool val_read = false;
1969 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1972 if (!(info->head.val & INFO_AMP_VOL(ch))) {
1974 mutex_unlock(&codec->hash_mutex);
1975 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1976 parm |= direction == HDA_OUTPUT ?
1977 AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1979 val = snd_hda_codec_read(codec, nid, 0,
1980 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1983 mutex_lock(&codec->hash_mutex);
1986 info->vol[ch] = val;
1987 info->head.val |= INFO_AMP_VOL(ch);
1988 } else if (init_only)
1994 * write the current volume in info to the h/w
1996 static void put_vol_mute(struct hda_codec *codec, unsigned int amp_caps,
1997 hda_nid_t nid, int ch, int direction, int index,
2002 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
2003 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
2004 parm |= index << AC_AMP_SET_INDEX_SHIFT;
2005 if ((val & HDA_AMP_MUTE) && !(amp_caps & AC_AMPCAP_MUTE) &&
2006 (amp_caps & AC_AMPCAP_MIN_MUTE))
2007 ; /* set the zero value as a fake mute */
2010 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
2014 * snd_hda_codec_amp_read - Read AMP value
2015 * @codec: HD-audio codec
2016 * @nid: NID to read the AMP value
2017 * @ch: channel (left=0 or right=1)
2018 * @direction: #HDA_INPUT or #HDA_OUTPUT
2019 * @index: the index value (only for input direction)
2021 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
2023 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
2024 int direction, int index)
2026 struct hda_amp_info *info;
2027 unsigned int val = 0;
2029 mutex_lock(&codec->hash_mutex);
2030 info = update_amp_hash(codec, nid, ch, direction, index, false);
2032 val = info->vol[ch];
2033 mutex_unlock(&codec->hash_mutex);
2036 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
2038 static int codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2039 int direction, int idx, int mask, int val,
2042 struct hda_amp_info *info;
2044 unsigned int cache_only;
2046 if (snd_BUG_ON(mask & ~0xff))
2050 mutex_lock(&codec->hash_mutex);
2051 info = update_amp_hash(codec, nid, ch, direction, idx, init_only);
2053 mutex_unlock(&codec->hash_mutex);
2056 val |= info->vol[ch] & ~mask;
2057 if (info->vol[ch] == val) {
2058 mutex_unlock(&codec->hash_mutex);
2061 info->vol[ch] = val;
2062 cache_only = info->head.dirty = codec->cached_write;
2063 caps = info->amp_caps;
2064 mutex_unlock(&codec->hash_mutex);
2066 put_vol_mute(codec, caps, nid, ch, direction, idx, val);
2071 * snd_hda_codec_amp_update - update the AMP value
2072 * @codec: HD-audio codec
2073 * @nid: NID to read the AMP value
2074 * @ch: channel (left=0 or right=1)
2075 * @direction: #HDA_INPUT or #HDA_OUTPUT
2076 * @idx: the index value (only for input direction)
2077 * @mask: bit mask to set
2078 * @val: the bits value to set
2080 * Update the AMP value with a bit mask.
2081 * Returns 0 if the value is unchanged, 1 if changed.
2083 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
2084 int direction, int idx, int mask, int val)
2086 return codec_amp_update(codec, nid, ch, direction, idx, mask, val, false);
2088 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
2091 * snd_hda_codec_amp_stereo - update the AMP stereo values
2092 * @codec: HD-audio codec
2093 * @nid: NID to read the AMP value
2094 * @direction: #HDA_INPUT or #HDA_OUTPUT
2095 * @idx: the index value (only for input direction)
2096 * @mask: bit mask to set
2097 * @val: the bits value to set
2099 * Update the AMP values like snd_hda_codec_amp_update(), but for a
2100 * stereo widget with the same mask and value.
2102 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
2103 int direction, int idx, int mask, int val)
2107 if (snd_BUG_ON(mask & ~0xff))
2109 for (ch = 0; ch < 2; ch++)
2110 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
2114 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
2116 /* Works like snd_hda_codec_amp_update() but it writes the value only at
2117 * the first access. If the amp was already initialized / updated beforehand,
2118 * this does nothing.
2120 int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
2121 int dir, int idx, int mask, int val)
2123 return codec_amp_update(codec, nid, ch, dir, idx, mask, val, true);
2125 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init);
2127 int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
2128 int dir, int idx, int mask, int val)
2132 if (snd_BUG_ON(mask & ~0xff))
2134 for (ch = 0; ch < 2; ch++)
2135 ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
2139 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_init_stereo);
2142 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
2143 * @codec: HD-audio codec
2145 * Resume the all amp commands from the cache.
2147 void snd_hda_codec_resume_amp(struct hda_codec *codec)
2151 mutex_lock(&codec->hash_mutex);
2152 codec->cached_write = 0;
2153 for (i = 0; i < codec->amp_cache.buf.used; i++) {
2154 struct hda_amp_info *buffer;
2157 unsigned int idx, dir, ch;
2158 struct hda_amp_info info;
2160 buffer = snd_array_elem(&codec->amp_cache.buf, i);
2161 if (!buffer->head.dirty)
2163 buffer->head.dirty = 0;
2165 key = info.head.key;
2169 idx = (key >> 16) & 0xff;
2170 dir = (key >> 24) & 0xff;
2171 for (ch = 0; ch < 2; ch++) {
2172 if (!(info.head.val & INFO_AMP_VOL(ch)))
2174 mutex_unlock(&codec->hash_mutex);
2175 put_vol_mute(codec, info.amp_caps, nid, ch, dir, idx,
2177 mutex_lock(&codec->hash_mutex);
2180 mutex_unlock(&codec->hash_mutex);
2182 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
2184 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
2187 u32 caps = query_amp_caps(codec, nid, dir);
2189 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2196 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
2198 * The control element is supposed to have the private_value field
2199 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2201 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
2202 struct snd_ctl_elem_info *uinfo)
2204 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2205 u16 nid = get_amp_nid(kcontrol);
2206 u8 chs = get_amp_channels(kcontrol);
2207 int dir = get_amp_direction(kcontrol);
2208 unsigned int ofs = get_amp_offset(kcontrol);
2210 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2211 uinfo->count = chs == 3 ? 2 : 1;
2212 uinfo->value.integer.min = 0;
2213 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
2214 if (!uinfo->value.integer.max) {
2215 printk(KERN_WARNING "hda_codec: "
2216 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
2222 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
2225 static inline unsigned int
2226 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
2227 int ch, int dir, int idx, unsigned int ofs)
2230 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
2231 val &= HDA_AMP_VOLMASK;
2240 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
2241 int ch, int dir, int idx, unsigned int ofs,
2244 unsigned int maxval;
2248 /* ofs = 0: raw max value */
2249 maxval = get_amp_max_value(codec, nid, dir, 0);
2252 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
2253 HDA_AMP_VOLMASK, val);
2257 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
2259 * The control element is supposed to have the private_value field
2260 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2262 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
2263 struct snd_ctl_elem_value *ucontrol)
2265 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2266 hda_nid_t nid = get_amp_nid(kcontrol);
2267 int chs = get_amp_channels(kcontrol);
2268 int dir = get_amp_direction(kcontrol);
2269 int idx = get_amp_index(kcontrol);
2270 unsigned int ofs = get_amp_offset(kcontrol);
2271 long *valp = ucontrol->value.integer.value;
2274 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
2276 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
2279 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
2282 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
2284 * The control element is supposed to have the private_value field
2285 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2287 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
2288 struct snd_ctl_elem_value *ucontrol)
2290 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2291 hda_nid_t nid = get_amp_nid(kcontrol);
2292 int chs = get_amp_channels(kcontrol);
2293 int dir = get_amp_direction(kcontrol);
2294 int idx = get_amp_index(kcontrol);
2295 unsigned int ofs = get_amp_offset(kcontrol);
2296 long *valp = ucontrol->value.integer.value;
2299 snd_hda_power_up(codec);
2301 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
2305 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
2306 snd_hda_power_down(codec);
2309 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
2312 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2314 * The control element is supposed to have the private_value field
2315 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2317 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2318 unsigned int size, unsigned int __user *_tlv)
2320 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2321 hda_nid_t nid = get_amp_nid(kcontrol);
2322 int dir = get_amp_direction(kcontrol);
2323 unsigned int ofs = get_amp_offset(kcontrol);
2324 bool min_mute = get_amp_min_mute(kcontrol);
2325 u32 caps, val1, val2;
2327 if (size < 4 * sizeof(unsigned int))
2329 caps = query_amp_caps(codec, nid, dir);
2330 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2331 val2 = (val2 + 1) * 25;
2332 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
2334 val1 = ((int)val1) * ((int)val2);
2335 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
2336 val2 |= TLV_DB_SCALE_MUTE;
2337 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2339 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2341 if (put_user(val1, _tlv + 2))
2343 if (put_user(val2, _tlv + 3))
2347 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
2350 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2351 * @codec: HD-audio codec
2352 * @nid: NID of a reference widget
2353 * @dir: #HDA_INPUT or #HDA_OUTPUT
2354 * @tlv: TLV data to be stored, at least 4 elements
2356 * Set (static) TLV data for a virtual master volume using the AMP caps
2357 * obtained from the reference NID.
2358 * The volume range is recalculated as if the max volume is 0dB.
2360 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2366 caps = query_amp_caps(codec, nid, dir);
2367 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2368 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2369 step = (step + 1) * 25;
2370 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2371 tlv[1] = 2 * sizeof(unsigned int);
2372 tlv[2] = -nums * step;
2375 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2377 /* find a mixer control element with the given name */
2378 static struct snd_kcontrol *
2379 find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
2381 struct snd_ctl_elem_id id;
2382 memset(&id, 0, sizeof(id));
2383 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2386 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2388 strcpy(id.name, name);
2389 return snd_ctl_find_id(codec->bus->card, &id);
2393 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2394 * @codec: HD-audio codec
2395 * @name: ctl id name string
2397 * Get the control element with the given id string and IFACE_MIXER.
2399 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2402 return find_mixer_ctl(codec, name, 0, 0);
2404 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
2406 static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
2410 /* 16 ctlrs should be large enough */
2411 for (i = 0, idx = start_idx; i < 16; i++, idx++) {
2412 if (!find_mixer_ctl(codec, name, 0, idx))
2419 * snd_hda_ctl_add - Add a control element and assign to the codec
2420 * @codec: HD-audio codec
2421 * @nid: corresponding NID (optional)
2422 * @kctl: the control element to assign
2424 * Add the given control element to an array inside the codec instance.
2425 * All control elements belonging to a codec are supposed to be added
2426 * by this function so that a proper clean-up works at the free or
2427 * reconfiguration time.
2429 * If non-zero @nid is passed, the NID is assigned to the control element.
2430 * The assignment is shown in the codec proc file.
2432 * snd_hda_ctl_add() checks the control subdev id field whether
2433 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
2434 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2435 * specifies if kctl->private_value is a HDA amplifier value.
2437 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2438 struct snd_kcontrol *kctl)
2441 unsigned short flags = 0;
2442 struct hda_nid_item *item;
2444 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
2445 flags |= HDA_NID_ITEM_AMP;
2447 nid = get_amp_nid_(kctl->private_value);
2449 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2450 nid = kctl->id.subdevice & 0xffff;
2451 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
2452 kctl->id.subdevice = 0;
2453 err = snd_ctl_add(codec->bus->card, kctl);
2456 item = snd_array_new(&codec->mixers);
2461 item->flags = flags;
2464 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
2467 * snd_hda_add_nid - Assign a NID to a control element
2468 * @codec: HD-audio codec
2469 * @nid: corresponding NID (optional)
2470 * @kctl: the control element to assign
2471 * @index: index to kctl
2473 * Add the given control element to an array inside the codec instance.
2474 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2475 * NID:KCTL mapping - for example "Capture Source" selector.
2477 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2478 unsigned int index, hda_nid_t nid)
2480 struct hda_nid_item *item;
2483 item = snd_array_new(&codec->nids);
2487 item->index = index;
2491 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2492 kctl->id.name, kctl->id.index, index);
2495 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2498 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2499 * @codec: HD-audio codec
2501 void snd_hda_ctls_clear(struct hda_codec *codec)
2504 struct hda_nid_item *items = codec->mixers.list;
2505 for (i = 0; i < codec->mixers.used; i++)
2506 snd_ctl_remove(codec->bus->card, items[i].kctl);
2507 snd_array_free(&codec->mixers);
2508 snd_array_free(&codec->nids);
2511 /* pseudo device locking
2512 * toggle card->shutdown to allow/disallow the device access (as a hack)
2514 int snd_hda_lock_devices(struct hda_bus *bus)
2516 struct snd_card *card = bus->card;
2517 struct hda_codec *codec;
2519 spin_lock(&card->files_lock);
2523 if (!list_empty(&card->ctl_files))
2526 list_for_each_entry(codec, &bus->codec_list, list) {
2528 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2529 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2532 if (cpcm->pcm->streams[0].substream_opened ||
2533 cpcm->pcm->streams[1].substream_opened)
2537 spin_unlock(&card->files_lock);
2543 spin_unlock(&card->files_lock);
2546 EXPORT_SYMBOL_HDA(snd_hda_lock_devices);
2548 void snd_hda_unlock_devices(struct hda_bus *bus)
2550 struct snd_card *card = bus->card;
2553 spin_lock(&card->files_lock);
2555 spin_unlock(&card->files_lock);
2557 EXPORT_SYMBOL_HDA(snd_hda_unlock_devices);
2560 * snd_hda_codec_reset - Clear all objects assigned to the codec
2561 * @codec: HD-audio codec
2563 * This frees the all PCM and control elements assigned to the codec, and
2564 * clears the caches and restores the pin default configurations.
2566 * When a device is being used, it returns -EBSY. If successfully freed,
2569 int snd_hda_codec_reset(struct hda_codec *codec)
2571 struct hda_bus *bus = codec->bus;
2572 struct snd_card *card = bus->card;
2575 if (snd_hda_lock_devices(bus) < 0)
2578 /* OK, let it free */
2579 cancel_delayed_work_sync(&codec->jackpoll_work);
2581 cancel_delayed_work_sync(&codec->power_work);
2582 codec->power_on = 0;
2583 codec->power_transition = 0;
2584 codec->power_jiffies = jiffies;
2585 flush_workqueue(bus->workq);
2587 snd_hda_ctls_clear(codec);
2589 for (i = 0; i < codec->num_pcms; i++) {
2590 if (codec->pcm_info[i].pcm) {
2591 snd_device_free(card, codec->pcm_info[i].pcm);
2592 clear_bit(codec->pcm_info[i].device,
2596 if (codec->patch_ops.free)
2597 codec->patch_ops.free(codec);
2598 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2599 snd_hda_jack_tbl_clear(codec);
2600 codec->proc_widget_hook = NULL;
2602 free_hda_cache(&codec->amp_cache);
2603 free_hda_cache(&codec->cmd_cache);
2604 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2605 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2606 /* free only driver_pins so that init_pins + user_pins are restored */
2607 snd_array_free(&codec->driver_pins);
2608 snd_array_free(&codec->cvt_setups);
2609 snd_array_free(&codec->spdif_out);
2610 snd_array_free(&codec->verbs);
2611 codec->num_pcms = 0;
2612 codec->pcm_info = NULL;
2613 codec->preset = NULL;
2614 codec->slave_dig_outs = NULL;
2615 codec->spdif_status_reset = 0;
2616 module_put(codec->owner);
2617 codec->owner = NULL;
2619 /* allow device access again */
2620 snd_hda_unlock_devices(bus);
2624 typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2626 /* apply the function to all matching slave ctls in the mixer list */
2627 static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2628 const char *suffix, map_slave_func_t func, void *data)
2630 struct hda_nid_item *items;
2631 const char * const *s;
2634 items = codec->mixers.list;
2635 for (i = 0; i < codec->mixers.used; i++) {
2636 struct snd_kcontrol *sctl = items[i].kctl;
2637 if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2639 for (s = slaves; *s; s++) {
2640 char tmpname[sizeof(sctl->id.name)];
2641 const char *name = *s;
2643 snprintf(tmpname, sizeof(tmpname), "%s %s",
2647 if (!strcmp(sctl->id.name, name)) {
2648 err = func(data, sctl);
2658 static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2663 /* guess the value corresponding to 0dB */
2664 static int get_kctl_0dB_offset(struct snd_kcontrol *kctl, int *step_to_check)
2667 const int *tlv = NULL;
2670 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2671 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2672 mm_segment_t fs = get_fs();
2674 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2677 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2679 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
2681 step &= ~TLV_DB_SCALE_MUTE;
2684 if (*step_to_check && *step_to_check != step) {
2685 snd_printk(KERN_ERR "hda_codec: Mismatching dB step for vmaster slave (%d!=%d)\n",
2686 *step_to_check, step);
2689 *step_to_check = step;
2690 val = -tlv[2] / step;
2695 /* call kctl->put with the given value(s) */
2696 static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2698 struct snd_ctl_elem_value *ucontrol;
2699 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2702 ucontrol->value.integer.value[0] = val;
2703 ucontrol->value.integer.value[1] = val;
2704 kctl->put(kctl, ucontrol);
2709 /* initialize the slave volume with 0dB */
2710 static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2712 int offset = get_kctl_0dB_offset(slave, data);
2714 put_kctl_with_value(slave, offset);
2718 /* unmute the slave */
2719 static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2721 return put_kctl_with_value(slave, 1);
2725 * snd_hda_add_vmaster - create a virtual master control and add slaves
2726 * @codec: HD-audio codec
2727 * @name: vmaster control name
2728 * @tlv: TLV data (optional)
2729 * @slaves: slave control names (optional)
2730 * @suffix: suffix string to each slave name (optional)
2731 * @init_slave_vol: initialize slaves to unmute/0dB
2732 * @ctl_ret: store the vmaster kcontrol in return
2734 * Create a virtual master control with the given name. The TLV data
2735 * must be either NULL or a valid data.
2737 * @slaves is a NULL-terminated array of strings, each of which is a
2738 * slave control name. All controls with these names are assigned to
2739 * the new virtual master control.
2741 * This function returns zero if successful or a negative error code.
2743 int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2744 unsigned int *tlv, const char * const *slaves,
2745 const char *suffix, bool init_slave_vol,
2746 struct snd_kcontrol **ctl_ret)
2748 struct snd_kcontrol *kctl;
2754 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
2756 snd_printdd("No slave found for %s\n", name);
2759 kctl = snd_ctl_make_virtual_master(name, tlv);
2762 err = snd_hda_ctl_add(codec, 0, kctl);
2766 err = map_slaves(codec, slaves, suffix,
2767 (map_slave_func_t)snd_ctl_add_slave, kctl);
2771 /* init with master mute & zero volume */
2772 put_kctl_with_value(kctl, 0);
2773 if (init_slave_vol) {
2775 map_slaves(codec, slaves, suffix,
2776 tlv ? init_slave_0dB : init_slave_unmute, &step);
2783 EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
2786 * mute-LED control using vmaster
2788 static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2789 struct snd_ctl_elem_info *uinfo)
2791 static const char * const texts[] = {
2792 "On", "Off", "Follow Master"
2796 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2798 uinfo->value.enumerated.items = 3;
2799 index = uinfo->value.enumerated.item;
2802 strcpy(uinfo->value.enumerated.name, texts[index]);
2806 static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2807 struct snd_ctl_elem_value *ucontrol)
2809 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2810 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2814 static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2815 struct snd_ctl_elem_value *ucontrol)
2817 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2818 unsigned int old_mode = hook->mute_mode;
2820 hook->mute_mode = ucontrol->value.enumerated.item[0];
2821 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2822 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2823 if (old_mode == hook->mute_mode)
2825 snd_hda_sync_vmaster_hook(hook);
2829 static struct snd_kcontrol_new vmaster_mute_mode = {
2830 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2831 .name = "Mute-LED Mode",
2832 .info = vmaster_mute_mode_info,
2833 .get = vmaster_mute_mode_get,
2834 .put = vmaster_mute_mode_put,
2838 * Add a mute-LED hook with the given vmaster switch kctl
2839 * "Mute-LED Mode" control is automatically created and associated with
2842 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
2843 struct hda_vmaster_mute_hook *hook,
2844 bool expose_enum_ctl)
2846 struct snd_kcontrol *kctl;
2848 if (!hook->hook || !hook->sw_kctl)
2850 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2851 hook->codec = codec;
2852 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2853 if (!expose_enum_ctl)
2855 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2858 return snd_hda_ctl_add(codec, 0, kctl);
2860 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2863 * Call the hook with the current value for synchronization
2864 * Should be called in init callback
2866 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2868 if (!hook->hook || !hook->codec)
2870 /* don't call vmaster hook in the destructor since it might have
2871 * been already destroyed
2873 if (hook->codec->bus->shutdown)
2875 switch (hook->mute_mode) {
2876 case HDA_VMUTE_FOLLOW_MASTER:
2877 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2880 hook->hook(hook->codec, hook->mute_mode);
2884 EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2888 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2890 * The control element is supposed to have the private_value field
2891 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2893 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2894 struct snd_ctl_elem_info *uinfo)
2896 int chs = get_amp_channels(kcontrol);
2898 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2899 uinfo->count = chs == 3 ? 2 : 1;
2900 uinfo->value.integer.min = 0;
2901 uinfo->value.integer.max = 1;
2904 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2907 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2909 * The control element is supposed to have the private_value field
2910 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2912 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2913 struct snd_ctl_elem_value *ucontrol)
2915 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2916 hda_nid_t nid = get_amp_nid(kcontrol);
2917 int chs = get_amp_channels(kcontrol);
2918 int dir = get_amp_direction(kcontrol);
2919 int idx = get_amp_index(kcontrol);
2920 long *valp = ucontrol->value.integer.value;
2923 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2924 HDA_AMP_MUTE) ? 0 : 1;
2926 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2927 HDA_AMP_MUTE) ? 0 : 1;
2930 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2933 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2935 * The control element is supposed to have the private_value field
2936 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2938 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2939 struct snd_ctl_elem_value *ucontrol)
2941 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2942 hda_nid_t nid = get_amp_nid(kcontrol);
2943 int chs = get_amp_channels(kcontrol);
2944 int dir = get_amp_direction(kcontrol);
2945 int idx = get_amp_index(kcontrol);
2946 long *valp = ucontrol->value.integer.value;
2949 snd_hda_power_up(codec);
2951 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2953 *valp ? 0 : HDA_AMP_MUTE);
2957 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2959 *valp ? 0 : HDA_AMP_MUTE);
2960 hda_call_check_power_status(codec, nid);
2961 snd_hda_power_down(codec);
2964 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2967 * bound volume controls
2969 * bind multiple volumes (# indices, from 0)
2972 #define AMP_VAL_IDX_SHIFT 19
2973 #define AMP_VAL_IDX_MASK (0x0f<<19)
2976 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2978 * The control element is supposed to have the private_value field
2979 * set up via HDA_BIND_MUTE*() macros.
2981 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2982 struct snd_ctl_elem_value *ucontrol)
2984 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2988 mutex_lock(&codec->control_mutex);
2989 pval = kcontrol->private_value;
2990 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2991 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2992 kcontrol->private_value = pval;
2993 mutex_unlock(&codec->control_mutex);
2996 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2999 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
3001 * The control element is supposed to have the private_value field
3002 * set up via HDA_BIND_MUTE*() macros.
3004 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
3005 struct snd_ctl_elem_value *ucontrol)
3007 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3009 int i, indices, err = 0, change = 0;
3011 mutex_lock(&codec->control_mutex);
3012 pval = kcontrol->private_value;
3013 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
3014 for (i = 0; i < indices; i++) {
3015 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
3016 (i << AMP_VAL_IDX_SHIFT);
3017 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3022 kcontrol->private_value = pval;
3023 mutex_unlock(&codec->control_mutex);
3024 return err < 0 ? err : change;
3026 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
3029 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
3031 * The control element is supposed to have the private_value field
3032 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3034 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
3035 struct snd_ctl_elem_info *uinfo)
3037 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3038 struct hda_bind_ctls *c;
3041 mutex_lock(&codec->control_mutex);
3042 c = (struct hda_bind_ctls *)kcontrol->private_value;
3043 kcontrol->private_value = *c->values;
3044 err = c->ops->info(kcontrol, uinfo);
3045 kcontrol->private_value = (long)c;
3046 mutex_unlock(&codec->control_mutex);
3049 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
3052 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
3054 * The control element is supposed to have the private_value field
3055 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3057 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
3058 struct snd_ctl_elem_value *ucontrol)
3060 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3061 struct hda_bind_ctls *c;
3064 mutex_lock(&codec->control_mutex);
3065 c = (struct hda_bind_ctls *)kcontrol->private_value;
3066 kcontrol->private_value = *c->values;
3067 err = c->ops->get(kcontrol, ucontrol);
3068 kcontrol->private_value = (long)c;
3069 mutex_unlock(&codec->control_mutex);
3072 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
3075 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
3077 * The control element is supposed to have the private_value field
3078 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
3080 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
3081 struct snd_ctl_elem_value *ucontrol)
3083 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3084 struct hda_bind_ctls *c;
3085 unsigned long *vals;
3086 int err = 0, change = 0;
3088 mutex_lock(&codec->control_mutex);
3089 c = (struct hda_bind_ctls *)kcontrol->private_value;
3090 for (vals = c->values; *vals; vals++) {
3091 kcontrol->private_value = *vals;
3092 err = c->ops->put(kcontrol, ucontrol);
3097 kcontrol->private_value = (long)c;
3098 mutex_unlock(&codec->control_mutex);
3099 return err < 0 ? err : change;
3101 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
3104 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
3106 * The control element is supposed to have the private_value field
3107 * set up via HDA_BIND_VOL() macro.
3109 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3110 unsigned int size, unsigned int __user *tlv)
3112 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3113 struct hda_bind_ctls *c;
3116 mutex_lock(&codec->control_mutex);
3117 c = (struct hda_bind_ctls *)kcontrol->private_value;
3118 kcontrol->private_value = *c->values;
3119 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
3120 kcontrol->private_value = (long)c;
3121 mutex_unlock(&codec->control_mutex);
3124 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
3126 struct hda_ctl_ops snd_hda_bind_vol = {
3127 .info = snd_hda_mixer_amp_volume_info,
3128 .get = snd_hda_mixer_amp_volume_get,
3129 .put = snd_hda_mixer_amp_volume_put,
3130 .tlv = snd_hda_mixer_amp_tlv
3132 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
3134 struct hda_ctl_ops snd_hda_bind_sw = {
3135 .info = snd_hda_mixer_amp_switch_info,
3136 .get = snd_hda_mixer_amp_switch_get,
3137 .put = snd_hda_mixer_amp_switch_put,
3138 .tlv = snd_hda_mixer_amp_tlv
3140 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
3143 * SPDIF out controls
3146 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
3147 struct snd_ctl_elem_info *uinfo)
3149 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
3154 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
3155 struct snd_ctl_elem_value *ucontrol)
3157 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3158 IEC958_AES0_NONAUDIO |
3159 IEC958_AES0_CON_EMPHASIS_5015 |
3160 IEC958_AES0_CON_NOT_COPYRIGHT;
3161 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
3162 IEC958_AES1_CON_ORIGINAL;
3166 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
3167 struct snd_ctl_elem_value *ucontrol)
3169 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
3170 IEC958_AES0_NONAUDIO |
3171 IEC958_AES0_PRO_EMPHASIS_5015;
3175 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
3176 struct snd_ctl_elem_value *ucontrol)
3178 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3179 int idx = kcontrol->private_value;
3180 struct hda_spdif_out *spdif;
3182 mutex_lock(&codec->spdif_mutex);
3183 spdif = snd_array_elem(&codec->spdif_out, idx);
3184 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
3185 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
3186 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
3187 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
3188 mutex_unlock(&codec->spdif_mutex);
3193 /* convert from SPDIF status bits to HDA SPDIF bits
3194 * bit 0 (DigEn) is always set zero (to be filled later)
3196 static unsigned short convert_from_spdif_status(unsigned int sbits)
3198 unsigned short val = 0;
3200 if (sbits & IEC958_AES0_PROFESSIONAL)
3201 val |= AC_DIG1_PROFESSIONAL;
3202 if (sbits & IEC958_AES0_NONAUDIO)
3203 val |= AC_DIG1_NONAUDIO;
3204 if (sbits & IEC958_AES0_PROFESSIONAL) {
3205 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
3206 IEC958_AES0_PRO_EMPHASIS_5015)
3207 val |= AC_DIG1_EMPHASIS;
3209 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
3210 IEC958_AES0_CON_EMPHASIS_5015)
3211 val |= AC_DIG1_EMPHASIS;
3212 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
3213 val |= AC_DIG1_COPYRIGHT;
3214 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
3215 val |= AC_DIG1_LEVEL;
3216 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
3221 /* convert to SPDIF status bits from HDA SPDIF bits
3223 static unsigned int convert_to_spdif_status(unsigned short val)
3225 unsigned int sbits = 0;
3227 if (val & AC_DIG1_NONAUDIO)
3228 sbits |= IEC958_AES0_NONAUDIO;
3229 if (val & AC_DIG1_PROFESSIONAL)
3230 sbits |= IEC958_AES0_PROFESSIONAL;
3231 if (sbits & IEC958_AES0_PROFESSIONAL) {
3232 if (val & AC_DIG1_EMPHASIS)
3233 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
3235 if (val & AC_DIG1_EMPHASIS)
3236 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
3237 if (!(val & AC_DIG1_COPYRIGHT))
3238 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
3239 if (val & AC_DIG1_LEVEL)
3240 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
3241 sbits |= val & (0x7f << 8);
3246 /* set digital convert verbs both for the given NID and its slaves */
3247 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
3252 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
3253 d = codec->slave_dig_outs;
3257 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
3260 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
3264 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
3266 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
3269 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
3270 struct snd_ctl_elem_value *ucontrol)
3272 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3273 int idx = kcontrol->private_value;
3274 struct hda_spdif_out *spdif;
3279 mutex_lock(&codec->spdif_mutex);
3280 spdif = snd_array_elem(&codec->spdif_out, idx);
3282 spdif->status = ucontrol->value.iec958.status[0] |
3283 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
3284 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
3285 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
3286 val = convert_from_spdif_status(spdif->status);
3287 val |= spdif->ctls & 1;
3288 change = spdif->ctls != val;
3290 if (change && nid != (u16)-1)
3291 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
3292 mutex_unlock(&codec->spdif_mutex);
3296 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
3298 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
3299 struct snd_ctl_elem_value *ucontrol)
3301 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3302 int idx = kcontrol->private_value;
3303 struct hda_spdif_out *spdif;
3305 mutex_lock(&codec->spdif_mutex);
3306 spdif = snd_array_elem(&codec->spdif_out, idx);
3307 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
3308 mutex_unlock(&codec->spdif_mutex);
3312 static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
3315 set_dig_out_convert(codec, nid, dig1, dig2);
3316 /* unmute amp switch (if any) */
3317 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
3318 (dig1 & AC_DIG1_ENABLE))
3319 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3323 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
3324 struct snd_ctl_elem_value *ucontrol)
3326 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3327 int idx = kcontrol->private_value;
3328 struct hda_spdif_out *spdif;
3333 mutex_lock(&codec->spdif_mutex);
3334 spdif = snd_array_elem(&codec->spdif_out, idx);
3336 val = spdif->ctls & ~AC_DIG1_ENABLE;
3337 if (ucontrol->value.integer.value[0])
3338 val |= AC_DIG1_ENABLE;
3339 change = spdif->ctls != val;
3341 if (change && nid != (u16)-1)
3342 set_spdif_ctls(codec, nid, val & 0xff, -1);
3343 mutex_unlock(&codec->spdif_mutex);
3347 static struct snd_kcontrol_new dig_mixes[] = {
3349 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3351 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
3352 .info = snd_hda_spdif_mask_info,
3353 .get = snd_hda_spdif_cmask_get,
3356 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3358 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
3359 .info = snd_hda_spdif_mask_info,
3360 .get = snd_hda_spdif_pmask_get,
3363 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3364 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
3365 .info = snd_hda_spdif_mask_info,
3366 .get = snd_hda_spdif_default_get,
3367 .put = snd_hda_spdif_default_put,
3370 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3371 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
3372 .info = snd_hda_spdif_out_switch_info,
3373 .get = snd_hda_spdif_out_switch_get,
3374 .put = snd_hda_spdif_out_switch_put,
3380 * snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
3381 * @codec: the HDA codec
3382 * @associated_nid: NID that new ctls associated with
3383 * @cvt_nid: converter NID
3384 * @type: HDA_PCM_TYPE_*
3385 * Creates controls related with the digital output.
3386 * Called from each patch supporting the digital out.
3388 * Returns 0 if successful, or a negative error code.
3390 int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
3391 hda_nid_t associated_nid,
3396 struct snd_kcontrol *kctl;
3397 struct snd_kcontrol_new *dig_mix;
3399 const int spdif_index = 16;
3400 struct hda_spdif_out *spdif;
3401 struct hda_bus *bus = codec->bus;
3403 if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
3404 type == HDA_PCM_TYPE_SPDIF) {
3406 } else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
3407 type == HDA_PCM_TYPE_HDMI) {
3408 /* suppose a single SPDIF device */
3409 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3410 kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
3413 kctl->id.index = spdif_index;
3415 bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
3417 if (!bus->primary_dig_out_type)
3418 bus->primary_dig_out_type = type;
3420 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
3422 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3425 spdif = snd_array_new(&codec->spdif_out);
3428 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3429 kctl = snd_ctl_new1(dig_mix, codec);
3432 kctl->id.index = idx;
3433 kctl->private_value = codec->spdif_out.used - 1;
3434 err = snd_hda_ctl_add(codec, associated_nid, kctl);
3438 spdif->nid = cvt_nid;
3439 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
3440 AC_VERB_GET_DIGI_CONVERT_1, 0);
3441 spdif->status = convert_to_spdif_status(spdif->ctls);
3444 EXPORT_SYMBOL_HDA(snd_hda_create_dig_out_ctls);
3446 /* get the hda_spdif_out entry from the given NID
3447 * call within spdif_mutex lock
3449 struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3453 for (i = 0; i < codec->spdif_out.used; i++) {
3454 struct hda_spdif_out *spdif =
3455 snd_array_elem(&codec->spdif_out, i);
3456 if (spdif->nid == nid)
3461 EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3463 void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3465 struct hda_spdif_out *spdif;
3467 mutex_lock(&codec->spdif_mutex);
3468 spdif = snd_array_elem(&codec->spdif_out, idx);
3469 spdif->nid = (u16)-1;
3470 mutex_unlock(&codec->spdif_mutex);
3472 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3474 void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3476 struct hda_spdif_out *spdif;
3479 mutex_lock(&codec->spdif_mutex);
3480 spdif = snd_array_elem(&codec->spdif_out, idx);
3481 if (spdif->nid != nid) {
3484 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3486 mutex_unlock(&codec->spdif_mutex);
3488 EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3491 * SPDIF sharing with analog output
3493 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3494 struct snd_ctl_elem_value *ucontrol)
3496 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3497 ucontrol->value.integer.value[0] = mout->share_spdif;
3501 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3502 struct snd_ctl_elem_value *ucontrol)
3504 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3505 mout->share_spdif = !!ucontrol->value.integer.value[0];
3509 static struct snd_kcontrol_new spdif_share_sw = {
3510 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3511 .name = "IEC958 Default PCM Playback Switch",
3512 .info = snd_ctl_boolean_mono_info,
3513 .get = spdif_share_sw_get,
3514 .put = spdif_share_sw_put,
3518 * snd_hda_create_spdif_share_sw - create Default PCM switch
3519 * @codec: the HDA codec
3520 * @mout: multi-out instance
3522 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3523 struct hda_multi_out *mout)
3525 struct snd_kcontrol *kctl;
3527 if (!mout->dig_out_nid)
3530 kctl = snd_ctl_new1(&spdif_share_sw, mout);
3533 /* ATTENTION: here mout is passed as private_data, instead of codec */
3534 return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
3536 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
3542 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3544 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3545 struct snd_ctl_elem_value *ucontrol)
3547 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3549 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3553 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3554 struct snd_ctl_elem_value *ucontrol)
3556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3557 hda_nid_t nid = kcontrol->private_value;
3558 unsigned int val = !!ucontrol->value.integer.value[0];
3561 mutex_lock(&codec->spdif_mutex);
3562 change = codec->spdif_in_enable != val;
3564 codec->spdif_in_enable = val;
3565 snd_hda_codec_write_cache(codec, nid, 0,
3566 AC_VERB_SET_DIGI_CONVERT_1, val);
3568 mutex_unlock(&codec->spdif_mutex);
3572 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3573 struct snd_ctl_elem_value *ucontrol)
3575 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3576 hda_nid_t nid = kcontrol->private_value;
3580 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
3581 sbits = convert_to_spdif_status(val);
3582 ucontrol->value.iec958.status[0] = sbits;
3583 ucontrol->value.iec958.status[1] = sbits >> 8;
3584 ucontrol->value.iec958.status[2] = sbits >> 16;
3585 ucontrol->value.iec958.status[3] = sbits >> 24;
3589 static struct snd_kcontrol_new dig_in_ctls[] = {
3591 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3592 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
3593 .info = snd_hda_spdif_in_switch_info,
3594 .get = snd_hda_spdif_in_switch_get,
3595 .put = snd_hda_spdif_in_switch_put,
3598 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3599 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3600 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
3601 .info = snd_hda_spdif_mask_info,
3602 .get = snd_hda_spdif_in_status_get,
3608 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3609 * @codec: the HDA codec
3610 * @nid: audio in widget NID
3612 * Creates controls related with the SPDIF input.
3613 * Called from each patch supporting the SPDIF in.
3615 * Returns 0 if successful, or a negative error code.
3617 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
3620 struct snd_kcontrol *kctl;
3621 struct snd_kcontrol_new *dig_mix;
3624 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
3626 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3629 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3630 kctl = snd_ctl_new1(dig_mix, codec);
3633 kctl->private_value = nid;
3634 err = snd_hda_ctl_add(codec, nid, kctl);
3638 codec->spdif_in_enable =
3639 snd_hda_codec_read(codec, nid, 0,
3640 AC_VERB_GET_DIGI_CONVERT_1, 0) &
3644 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
3650 /* build a 31bit cache key with the widget id and the command parameter */
3651 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3652 #define get_cmd_cache_nid(key) ((key) & 0xff)
3653 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3656 * snd_hda_codec_write_cache - send a single command with caching
3657 * @codec: the HDA codec
3658 * @nid: NID to send the command
3659 * @flags: optional bit flags
3660 * @verb: the verb to send
3661 * @parm: the parameter for the verb
3663 * Send a single command without waiting for response.
3665 * Returns 0 if successful, or a negative error code.
3667 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3668 int flags, unsigned int verb, unsigned int parm)
3671 struct hda_cache_head *c;
3673 unsigned int cache_only;
3675 cache_only = codec->cached_write;
3677 err = snd_hda_codec_write(codec, nid, flags, verb, parm);
3682 /* parm may contain the verb stuff for get/set amp */
3683 verb = verb | (parm >> 8);
3685 key = build_cmd_cache_key(nid, verb);
3686 mutex_lock(&codec->bus->cmd_mutex);
3687 c = get_alloc_hash(&codec->cmd_cache, key);
3690 c->dirty = cache_only;
3692 mutex_unlock(&codec->bus->cmd_mutex);
3695 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
3698 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3699 * @codec: the HDA codec
3700 * @nid: NID to send the command
3701 * @flags: optional bit flags
3702 * @verb: the verb to send
3703 * @parm: the parameter for the verb
3705 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3706 * command if the parameter is already identical with the cached value.
3707 * If not, it sends the command and refreshes the cache.
3709 * Returns 0 if successful, or a negative error code.
3711 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3712 int flags, unsigned int verb, unsigned int parm)
3714 struct hda_cache_head *c;
3717 /* parm may contain the verb stuff for get/set amp */
3718 verb = verb | (parm >> 8);
3720 key = build_cmd_cache_key(nid, verb);
3721 mutex_lock(&codec->bus->cmd_mutex);
3722 c = get_hash(&codec->cmd_cache, key);
3723 if (c && c->val == parm) {
3724 mutex_unlock(&codec->bus->cmd_mutex);
3727 mutex_unlock(&codec->bus->cmd_mutex);
3728 return snd_hda_codec_write_cache(codec, nid, flags, verb, parm);
3730 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3733 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3734 * @codec: HD-audio codec
3736 * Execute all verbs recorded in the command caches to resume.
3738 void snd_hda_codec_resume_cache(struct hda_codec *codec)
3742 mutex_lock(&codec->hash_mutex);
3743 codec->cached_write = 0;
3744 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3745 struct hda_cache_head *buffer;
3748 buffer = snd_array_elem(&codec->cmd_cache.buf, i);
3755 mutex_unlock(&codec->hash_mutex);
3756 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3757 get_cmd_cache_cmd(key), buffer->val);
3758 mutex_lock(&codec->hash_mutex);
3760 mutex_unlock(&codec->hash_mutex);
3762 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
3765 * snd_hda_sequence_write_cache - sequence writes with caching
3766 * @codec: the HDA codec
3767 * @seq: VERB array to send
3769 * Send the commands sequentially from the given array.
3770 * Thte commands are recorded on cache for power-save and resume.
3771 * The array must be terminated with NID=0.
3773 void snd_hda_sequence_write_cache(struct hda_codec *codec,
3774 const struct hda_verb *seq)
3776 for (; seq->nid; seq++)
3777 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3780 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
3783 * snd_hda_codec_flush_cache - Execute all pending (cached) amps / verbs
3784 * @codec: HD-audio codec
3786 void snd_hda_codec_flush_cache(struct hda_codec *codec)
3788 snd_hda_codec_resume_amp(codec);
3789 snd_hda_codec_resume_cache(codec);
3791 EXPORT_SYMBOL_HDA(snd_hda_codec_flush_cache);
3793 void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3794 unsigned int power_state)
3796 hda_nid_t nid = codec->start_nid;
3799 for (i = 0; i < codec->num_nodes; i++, nid++) {
3800 unsigned int wcaps = get_wcaps(codec, nid);
3801 unsigned int state = power_state;
3802 if (!(wcaps & AC_WCAP_POWER))
3804 if (codec->power_filter) {
3805 state = codec->power_filter(codec, nid, power_state);
3806 if (state != power_state && power_state == AC_PWRST_D3)
3809 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3813 EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3816 * supported power states check
3818 static bool snd_hda_codec_get_supported_ps(struct hda_codec *codec, hda_nid_t fg,
3819 unsigned int power_state)
3821 int sup = snd_hda_param_read(codec, fg, AC_PAR_POWER_STATE);
3825 if (sup & power_state)
3832 * wait until the state is reached, returns the current state
3834 static unsigned int hda_sync_power_state(struct hda_codec *codec,
3836 unsigned int power_state)
3838 unsigned long end_time = jiffies + msecs_to_jiffies(500);
3839 unsigned int state, actual_state;
3842 state = snd_hda_codec_read(codec, fg, 0,
3843 AC_VERB_GET_POWER_STATE, 0);
3844 if (state & AC_PWRST_ERROR)
3846 actual_state = (state >> 4) & 0x0f;
3847 if (actual_state == power_state)
3849 if (time_after_eq(jiffies, end_time))
3851 /* wait until the codec reachs to the target state */
3857 /* don't power down the widget if it controls eapd and EAPD_BTLENABLE is set */
3858 unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
3860 unsigned int power_state)
3862 if (power_state == AC_PWRST_D3 &&
3863 get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
3864 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3865 int eapd = snd_hda_codec_read(codec, nid, 0,
3866 AC_VERB_GET_EAPD_BTLENABLE, 0);
3872 EXPORT_SYMBOL_HDA(snd_hda_codec_eapd_power_filter);
3875 * set power state of the codec, and return the power state
3877 static unsigned int hda_set_power_state(struct hda_codec *codec,
3878 unsigned int power_state)
3880 hda_nid_t fg = codec->afg ? codec->afg : codec->mfg;
3885 /* this delay seems necessary to avoid click noise at power-down */
3886 if (power_state == AC_PWRST_D3) {
3887 /* transition time less than 10ms for power down */
3888 msleep(codec->epss ? 10 : 100);
3889 flags = HDA_RW_NO_RESPONSE_FALLBACK;
3892 /* repeat power states setting at most 10 times*/
3893 for (count = 0; count < 10; count++) {
3894 if (codec->patch_ops.set_power_state)
3895 codec->patch_ops.set_power_state(codec, fg,
3898 snd_hda_codec_read(codec, fg, flags,
3899 AC_VERB_SET_POWER_STATE,
3901 snd_hda_codec_set_power_to_all(codec, fg, power_state);
3903 state = hda_sync_power_state(codec, fg, power_state);
3904 if (!(state & AC_PWRST_ERROR))
3911 /* sync power states of all widgets;
3912 * this is called at the end of codec parsing
3914 static void sync_power_up_states(struct hda_codec *codec)
3916 hda_nid_t nid = codec->start_nid;
3919 /* don't care if no filter is used */
3920 if (!codec->power_filter)
3923 for (i = 0; i < codec->num_nodes; i++, nid++) {
3924 unsigned int wcaps = get_wcaps(codec, nid);
3925 unsigned int target;
3926 if (!(wcaps & AC_WCAP_POWER))
3928 target = codec->power_filter(codec, nid, AC_PWRST_D0);
3929 if (target == AC_PWRST_D0)
3931 if (!snd_hda_check_power_state(codec, nid, target))
3932 snd_hda_codec_write(codec, nid, 0,
3933 AC_VERB_SET_POWER_STATE, target);
3937 #ifdef CONFIG_SND_HDA_HWDEP
3938 /* execute additional init verbs */
3939 static void hda_exec_init_verbs(struct hda_codec *codec)
3941 if (codec->init_verbs.list)
3942 snd_hda_sequence_write(codec, codec->init_verbs.list);
3945 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3950 * call suspend and power-down; used both from PM and power-save
3951 * this function returns the power state in the end
3953 static unsigned int hda_call_codec_suspend(struct hda_codec *codec, bool in_wq)
3959 if (codec->patch_ops.suspend)
3960 codec->patch_ops.suspend(codec);
3961 hda_cleanup_all_streams(codec);
3962 state = hda_set_power_state(codec, AC_PWRST_D3);
3963 /* Cancel delayed work if we aren't currently running from it. */
3965 cancel_delayed_work_sync(&codec->power_work);
3966 spin_lock(&codec->power_lock);
3967 snd_hda_update_power_acct(codec);
3968 trace_hda_power_down(codec);
3969 codec->power_on = 0;
3970 codec->power_transition = 0;
3971 codec->power_jiffies = jiffies;
3972 spin_unlock(&codec->power_lock);
3977 /* mark all entries of cmd and amp caches dirty */
3978 static void hda_mark_cmd_cache_dirty(struct hda_codec *codec)
3981 for (i = 0; i < codec->cmd_cache.buf.used; i++) {
3982 struct hda_cache_head *cmd;
3983 cmd = snd_array_elem(&codec->cmd_cache.buf, i);
3986 for (i = 0; i < codec->amp_cache.buf.used; i++) {
3987 struct hda_amp_info *amp;
3988 amp = snd_array_elem(&codec->amp_cache.buf, i);
3989 amp->head.dirty = 1;
3994 * kick up codec; used both from PM and power-save
3996 static void hda_call_codec_resume(struct hda_codec *codec)
4000 hda_mark_cmd_cache_dirty(codec);
4002 /* set as if powered on for avoiding re-entering the resume
4003 * in the resume / power-save sequence
4005 hda_keep_power_on(codec);
4006 hda_set_power_state(codec, AC_PWRST_D0);
4007 restore_shutup_pins(codec);
4008 hda_exec_init_verbs(codec);
4009 snd_hda_jack_set_dirty_all(codec);
4010 if (codec->patch_ops.resume)
4011 codec->patch_ops.resume(codec);
4013 if (codec->patch_ops.init)
4014 codec->patch_ops.init(codec);
4015 snd_hda_codec_resume_amp(codec);
4016 snd_hda_codec_resume_cache(codec);
4019 if (codec->jackpoll_interval)
4020 hda_jackpoll_work(&codec->jackpoll_work.work);
4022 snd_hda_jack_report_sync(codec);
4025 snd_hda_power_down(codec); /* flag down before returning */
4027 #endif /* CONFIG_PM */
4031 * snd_hda_build_controls - build mixer controls
4034 * Creates mixer controls for each codec included in the bus.
4036 * Returns 0 if successful, otherwise a negative error code.
4038 int snd_hda_build_controls(struct hda_bus *bus)
4040 struct hda_codec *codec;
4042 list_for_each_entry(codec, &bus->codec_list, list) {
4043 int err = snd_hda_codec_build_controls(codec);
4045 printk(KERN_ERR "hda_codec: cannot build controls "
4046 "for #%d (error %d)\n", codec->addr, err);
4047 err = snd_hda_codec_reset(codec);
4050 "hda_codec: cannot revert codec\n");
4057 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
4060 * add standard channel maps if not specified
4062 static int add_std_chmaps(struct hda_codec *codec)
4066 for (i = 0; i < codec->num_pcms; i++) {
4067 for (str = 0; str < 2; str++) {
4068 struct snd_pcm *pcm = codec->pcm_info[i].pcm;
4069 struct hda_pcm_stream *hinfo =
4070 &codec->pcm_info[i].stream[str];
4071 struct snd_pcm_chmap *chmap;
4072 const struct snd_pcm_chmap_elem *elem;
4074 if (codec->pcm_info[i].own_chmap)
4076 if (!pcm || !hinfo->substreams)
4078 elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
4079 err = snd_pcm_add_chmap_ctls(pcm, str, elem,
4080 hinfo->channels_max,
4084 chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
4090 /* default channel maps for 2.1 speakers;
4091 * since HD-audio supports only stereo, odd number channels are omitted
4093 const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
4095 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
4097 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
4098 SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
4101 EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
4103 int snd_hda_codec_build_controls(struct hda_codec *codec)
4106 hda_exec_init_verbs(codec);
4107 /* continue to initialize... */
4108 if (codec->patch_ops.init)
4109 err = codec->patch_ops.init(codec);
4110 if (!err && codec->patch_ops.build_controls)
4111 err = codec->patch_ops.build_controls(codec);
4115 /* we create chmaps here instead of build_pcms */
4116 err = add_std_chmaps(codec);
4120 if (codec->jackpoll_interval)
4121 hda_jackpoll_work(&codec->jackpoll_work.work);
4123 snd_hda_jack_report_sync(codec); /* call at the last init point */
4124 sync_power_up_states(codec);
4131 struct hda_rate_tbl {
4133 unsigned int alsa_bits;
4134 unsigned int hda_fmt;
4137 /* rate = base * mult / div */
4138 #define HDA_RATE(base, mult, div) \
4139 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
4140 (((div) - 1) << AC_FMT_DIV_SHIFT))
4142 static struct hda_rate_tbl rate_bits[] = {
4143 /* rate in Hz, ALSA rate bitmask, HDA format value */
4145 /* autodetected value used in snd_hda_query_supported_pcm */
4146 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
4147 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
4148 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
4149 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
4150 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
4151 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
4152 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
4153 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
4154 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
4155 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
4156 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
4157 #define AC_PAR_PCM_RATE_BITS 11
4158 /* up to bits 10, 384kHZ isn't supported properly */
4160 /* not autodetected value */
4161 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
4163 { 0 } /* terminator */
4167 * snd_hda_calc_stream_format - calculate format bitset
4168 * @rate: the sample rate
4169 * @channels: the number of channels
4170 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
4171 * @maxbps: the max. bps
4173 * Calculate the format bitset from the given rate, channels and th PCM format.
4175 * Return zero if invalid.
4177 unsigned int snd_hda_calc_stream_format(unsigned int rate,
4178 unsigned int channels,
4179 unsigned int format,
4180 unsigned int maxbps,
4181 unsigned short spdif_ctls)
4184 unsigned int val = 0;
4186 for (i = 0; rate_bits[i].hz; i++)
4187 if (rate_bits[i].hz == rate) {
4188 val = rate_bits[i].hda_fmt;
4191 if (!rate_bits[i].hz) {
4192 snd_printdd("invalid rate %d\n", rate);
4196 if (channels == 0 || channels > 8) {
4197 snd_printdd("invalid channels %d\n", channels);
4200 val |= channels - 1;
4202 switch (snd_pcm_format_width(format)) {
4204 val |= AC_FMT_BITS_8;
4207 val |= AC_FMT_BITS_16;
4212 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
4213 val |= AC_FMT_BITS_32;
4214 else if (maxbps >= 24)
4215 val |= AC_FMT_BITS_24;
4217 val |= AC_FMT_BITS_20;
4220 snd_printdd("invalid format width %d\n",
4221 snd_pcm_format_width(format));
4225 if (spdif_ctls & AC_DIG1_NONAUDIO)
4226 val |= AC_FMT_TYPE_NON_PCM;
4230 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
4232 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid,
4235 unsigned int val = 0;
4236 if (nid != codec->afg &&
4237 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
4238 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
4239 if (!val || val == -1)
4240 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
4241 if (!val || val == -1)
4246 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
4248 return query_caps_hash(codec, nid, 0, HDA_HASH_PARPCM_KEY(nid),
4252 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid,
4255 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
4256 if (!streams || streams == -1)
4257 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
4258 if (!streams || streams == -1)
4263 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
4265 return query_caps_hash(codec, nid, 0, HDA_HASH_PARSTR_KEY(nid),
4270 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
4271 * @codec: the HDA codec
4272 * @nid: NID to query
4273 * @ratesp: the pointer to store the detected rate bitflags
4274 * @formatsp: the pointer to store the detected formats
4275 * @bpsp: the pointer to store the detected format widths
4277 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
4278 * or @bsps argument is ignored.
4280 * Returns 0 if successful, otherwise a negative error code.
4282 int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
4283 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
4285 unsigned int i, val, wcaps;
4287 wcaps = get_wcaps(codec, nid);
4288 val = query_pcm_param(codec, nid);
4292 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
4294 rates |= rate_bits[i].alsa_bits;
4297 snd_printk(KERN_ERR "hda_codec: rates == 0 "
4298 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
4300 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
4306 if (formatsp || bpsp) {
4308 unsigned int streams, bps;
4310 streams = query_stream_param(codec, nid);
4315 if (streams & AC_SUPFMT_PCM) {
4316 if (val & AC_SUPPCM_BITS_8) {
4317 formats |= SNDRV_PCM_FMTBIT_U8;
4320 if (val & AC_SUPPCM_BITS_16) {
4321 formats |= SNDRV_PCM_FMTBIT_S16_LE;
4324 if (wcaps & AC_WCAP_DIGITAL) {
4325 if (val & AC_SUPPCM_BITS_32)
4326 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
4327 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
4328 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4329 if (val & AC_SUPPCM_BITS_24)
4331 else if (val & AC_SUPPCM_BITS_20)
4333 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
4334 AC_SUPPCM_BITS_32)) {
4335 formats |= SNDRV_PCM_FMTBIT_S32_LE;
4336 if (val & AC_SUPPCM_BITS_32)
4338 else if (val & AC_SUPPCM_BITS_24)
4340 else if (val & AC_SUPPCM_BITS_20)
4344 #if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */
4345 if (streams & AC_SUPFMT_FLOAT32) {
4346 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
4351 if (streams == AC_SUPFMT_AC3) {
4352 /* should be exclusive */
4353 /* temporary hack: we have still no proper support
4354 * for the direct AC3 stream...
4356 formats |= SNDRV_PCM_FMTBIT_U8;
4360 snd_printk(KERN_ERR "hda_codec: formats == 0 "
4361 "(nid=0x%x, val=0x%x, ovrd=%i, "
4364 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
4369 *formatsp = formats;
4376 EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
4379 * snd_hda_is_supported_format - Check the validity of the format
4380 * @codec: HD-audio codec
4381 * @nid: NID to check
4382 * @format: the HD-audio format value to check
4384 * Check whether the given node supports the format value.
4386 * Returns 1 if supported, 0 if not.
4388 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
4389 unsigned int format)
4392 unsigned int val = 0, rate, stream;
4394 val = query_pcm_param(codec, nid);
4398 rate = format & 0xff00;
4399 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
4400 if (rate_bits[i].hda_fmt == rate) {
4405 if (i >= AC_PAR_PCM_RATE_BITS)
4408 stream = query_stream_param(codec, nid);
4412 if (stream & AC_SUPFMT_PCM) {
4413 switch (format & 0xf0) {
4415 if (!(val & AC_SUPPCM_BITS_8))
4419 if (!(val & AC_SUPPCM_BITS_16))
4423 if (!(val & AC_SUPPCM_BITS_20))
4427 if (!(val & AC_SUPPCM_BITS_24))
4431 if (!(val & AC_SUPPCM_BITS_32))
4438 /* FIXME: check for float32 and AC3? */
4443 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
4448 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
4449 struct hda_codec *codec,
4450 struct snd_pcm_substream *substream)
4455 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
4456 struct hda_codec *codec,
4457 unsigned int stream_tag,
4458 unsigned int format,
4459 struct snd_pcm_substream *substream)
4461 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4465 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
4466 struct hda_codec *codec,
4467 struct snd_pcm_substream *substream)
4469 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4473 static int set_pcm_default_values(struct hda_codec *codec,
4474 struct hda_pcm_stream *info)
4478 /* query support PCM information from the given NID */
4479 if (info->nid && (!info->rates || !info->formats)) {
4480 err = snd_hda_query_supported_pcm(codec, info->nid,
4481 info->rates ? NULL : &info->rates,
4482 info->formats ? NULL : &info->formats,
4483 info->maxbps ? NULL : &info->maxbps);
4487 if (info->ops.open == NULL)
4488 info->ops.open = hda_pcm_default_open_close;
4489 if (info->ops.close == NULL)
4490 info->ops.close = hda_pcm_default_open_close;
4491 if (info->ops.prepare == NULL) {
4492 if (snd_BUG_ON(!info->nid))
4494 info->ops.prepare = hda_pcm_default_prepare;
4496 if (info->ops.cleanup == NULL) {
4497 if (snd_BUG_ON(!info->nid))
4499 info->ops.cleanup = hda_pcm_default_cleanup;
4505 * codec prepare/cleanup entries
4507 int snd_hda_codec_prepare(struct hda_codec *codec,
4508 struct hda_pcm_stream *hinfo,
4509 unsigned int stream,
4510 unsigned int format,
4511 struct snd_pcm_substream *substream)
4514 mutex_lock(&codec->bus->prepare_mutex);
4515 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
4517 purify_inactive_streams(codec);
4518 mutex_unlock(&codec->bus->prepare_mutex);
4521 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
4523 void snd_hda_codec_cleanup(struct hda_codec *codec,
4524 struct hda_pcm_stream *hinfo,
4525 struct snd_pcm_substream *substream)
4527 mutex_lock(&codec->bus->prepare_mutex);
4528 hinfo->ops.cleanup(hinfo, codec, substream);
4529 mutex_unlock(&codec->bus->prepare_mutex);
4531 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
4534 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
4535 "Audio", "SPDIF", "HDMI", "Modem"
4539 * get the empty PCM device number to assign
4541 static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
4543 /* audio device indices; not linear to keep compatibility */
4544 /* assigned to static slots up to dev#10; if more needed, assign
4545 * the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
4547 static int audio_idx[HDA_PCM_NTYPES][5] = {
4548 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
4549 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
4550 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
4551 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
4555 if (type >= HDA_PCM_NTYPES) {
4556 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
4560 for (i = 0; audio_idx[type][i] >= 0; i++) {
4561 #ifndef CONFIG_SND_DYNAMIC_MINORS
4562 if (audio_idx[type][i] >= 8)
4565 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
4566 return audio_idx[type][i];
4569 #ifdef CONFIG_SND_DYNAMIC_MINORS
4570 /* non-fixed slots starting from 10 */
4571 for (i = 10; i < 32; i++) {
4572 if (!test_and_set_bit(i, bus->pcm_dev_bits))
4577 snd_printk(KERN_WARNING "Too many %s devices\n",
4578 snd_hda_pcm_type_name[type]);
4579 #ifndef CONFIG_SND_DYNAMIC_MINORS
4580 snd_printk(KERN_WARNING "Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
4586 * attach a new PCM stream
4588 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
4590 struct hda_bus *bus = codec->bus;
4591 struct hda_pcm_stream *info;
4594 if (snd_BUG_ON(!pcm->name))
4596 for (stream = 0; stream < 2; stream++) {
4597 info = &pcm->stream[stream];
4598 if (info->substreams) {
4599 err = set_pcm_default_values(codec, info);
4604 return bus->ops.attach_pcm(bus, codec, pcm);
4607 /* assign all PCMs of the given codec */
4608 int snd_hda_codec_build_pcms(struct hda_codec *codec)
4613 if (!codec->num_pcms) {
4614 if (!codec->patch_ops.build_pcms)
4616 err = codec->patch_ops.build_pcms(codec);
4618 printk(KERN_ERR "hda_codec: cannot build PCMs"
4619 "for #%d (error %d)\n", codec->addr, err);
4620 err = snd_hda_codec_reset(codec);
4623 "hda_codec: cannot revert codec\n");
4628 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4629 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4632 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
4633 continue; /* no substreams assigned */
4636 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4638 continue; /* no fatal error */
4640 err = snd_hda_attach_pcm(codec, cpcm);
4642 printk(KERN_ERR "hda_codec: cannot attach "
4643 "PCM stream %d for codec #%d\n",
4645 continue; /* no fatal error */
4653 * snd_hda_build_pcms - build PCM information
4656 * Create PCM information for each codec included in the bus.
4658 * The build_pcms codec patch is requested to set up codec->num_pcms and
4659 * codec->pcm_info properly. The array is referred by the top-level driver
4660 * to create its PCM instances.
4661 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4664 * At least, substreams, channels_min and channels_max must be filled for
4665 * each stream. substreams = 0 indicates that the stream doesn't exist.
4666 * When rates and/or formats are zero, the supported values are queried
4667 * from the given nid. The nid is used also by the default ops.prepare
4668 * and ops.cleanup callbacks.
4670 * The driver needs to call ops.open in its open callback. Similarly,
4671 * ops.close is supposed to be called in the close callback.
4672 * ops.prepare should be called in the prepare or hw_params callback
4673 * with the proper parameters for set up.
4674 * ops.cleanup should be called in hw_free for clean up of streams.
4676 * This function returns 0 if successful, or a negative error code.
4678 int snd_hda_build_pcms(struct hda_bus *bus)
4680 struct hda_codec *codec;
4682 list_for_each_entry(codec, &bus->codec_list, list) {
4683 int err = snd_hda_codec_build_pcms(codec);
4689 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
4692 * snd_hda_check_board_config - compare the current codec with the config table
4693 * @codec: the HDA codec
4694 * @num_configs: number of config enums
4695 * @models: array of model name strings
4696 * @tbl: configuration table, terminated by null entries
4698 * Compares the modelname or PCI subsystem id of the current codec with the
4699 * given configuration table. If a matching entry is found, returns its
4700 * config value (supposed to be 0 or positive).
4702 * If no entries are matching, the function returns a negative value.
4704 int snd_hda_check_board_config(struct hda_codec *codec,
4705 int num_configs, const char * const *models,
4706 const struct snd_pci_quirk *tbl)
4708 if (codec->modelname && models) {
4710 for (i = 0; i < num_configs; i++) {
4712 !strcmp(codec->modelname, models[i])) {
4713 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4714 "selected\n", models[i]);
4720 if (!codec->bus->pci || !tbl)
4723 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4726 if (tbl->value >= 0 && tbl->value < num_configs) {
4727 #ifdef CONFIG_SND_DEBUG_VERBOSE
4729 const char *model = NULL;
4731 model = models[tbl->value];
4733 sprintf(tmp, "#%d", tbl->value);
4736 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4737 "for config %x:%x (%s)\n",
4738 model, tbl->subvendor, tbl->subdevice,
4739 (tbl->name ? tbl->name : "Unknown device"));
4745 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
4748 * snd_hda_check_board_codec_sid_config - compare the current codec
4749 subsystem ID with the
4752 This is important for Gateway notebooks with SB450 HDA Audio
4753 where the vendor ID of the PCI device is:
4754 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4755 and the vendor/subvendor are found only at the codec.
4757 * @codec: the HDA codec
4758 * @num_configs: number of config enums
4759 * @models: array of model name strings
4760 * @tbl: configuration table, terminated by null entries
4762 * Compares the modelname or PCI subsystem id of the current codec with the
4763 * given configuration table. If a matching entry is found, returns its
4764 * config value (supposed to be 0 or positive).
4766 * If no entries are matching, the function returns a negative value.
4768 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
4769 int num_configs, const char * const *models,
4770 const struct snd_pci_quirk *tbl)
4772 const struct snd_pci_quirk *q;
4774 /* Search for codec ID */
4775 for (q = tbl; q->subvendor; q++) {
4776 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4777 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4778 if ((codec->subsystem_id & mask) == id)
4787 if (tbl->value >= 0 && tbl->value < num_configs) {
4788 #ifdef CONFIG_SND_DEBUG_VERBOSE
4790 const char *model = NULL;
4792 model = models[tbl->value];
4794 sprintf(tmp, "#%d", tbl->value);
4797 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4798 "for config %x:%x (%s)\n",
4799 model, tbl->subvendor, tbl->subdevice,
4800 (tbl->name ? tbl->name : "Unknown device"));
4806 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4809 * snd_hda_add_new_ctls - create controls from the array
4810 * @codec: the HDA codec
4811 * @knew: the array of struct snd_kcontrol_new
4813 * This helper function creates and add new controls in the given array.
4814 * The array must be terminated with an empty entry as terminator.
4816 * Returns 0 if successful, or a negative error code.
4818 int snd_hda_add_new_ctls(struct hda_codec *codec,
4819 const struct snd_kcontrol_new *knew)
4823 for (; knew->name; knew++) {
4824 struct snd_kcontrol *kctl;
4825 int addr = 0, idx = 0;
4826 if (knew->iface == -1) /* skip this codec private value */
4829 kctl = snd_ctl_new1(knew, codec);
4833 kctl->id.device = addr;
4835 kctl->id.index = idx;
4836 err = snd_hda_ctl_add(codec, 0, kctl);
4839 /* try first with another device index corresponding to
4840 * the codec addr; if it still fails (or it's the
4841 * primary codec), then try another control index
4843 if (!addr && codec->addr)
4845 else if (!idx && !knew->index) {
4846 idx = find_empty_mixer_ctl_idx(codec,
4856 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
4859 static void hda_power_work(struct work_struct *work)
4861 struct hda_codec *codec =
4862 container_of(work, struct hda_codec, power_work.work);
4863 struct hda_bus *bus = codec->bus;
4866 spin_lock(&codec->power_lock);
4867 if (codec->power_transition > 0) { /* during power-up sequence? */
4868 spin_unlock(&codec->power_lock);
4871 if (!codec->power_on || codec->power_count) {
4872 codec->power_transition = 0;
4873 spin_unlock(&codec->power_lock);
4876 spin_unlock(&codec->power_lock);
4878 state = hda_call_codec_suspend(codec, true);
4879 if (!codec->pm_down_notified &&
4880 !bus->power_keep_link_on && (state & AC_PWRST_CLK_STOP_OK)) {
4881 codec->pm_down_notified = 1;
4882 hda_call_pm_notify(bus, false);
4886 static void hda_keep_power_on(struct hda_codec *codec)
4888 spin_lock(&codec->power_lock);
4889 codec->power_count++;
4890 codec->power_on = 1;
4891 codec->power_jiffies = jiffies;
4892 spin_unlock(&codec->power_lock);
4895 /* update the power on/off account with the current jiffies */
4896 void snd_hda_update_power_acct(struct hda_codec *codec)
4898 unsigned long delta = jiffies - codec->power_jiffies;
4899 if (codec->power_on)
4900 codec->power_on_acct += delta;
4902 codec->power_off_acct += delta;
4903 codec->power_jiffies += delta;
4906 /* Transition to powered up, if wait_power_down then wait for a pending
4907 * transition to D3 to complete. A pending D3 transition is indicated
4908 * with power_transition == -1. */
4909 /* call this with codec->power_lock held! */
4910 static void __snd_hda_power_up(struct hda_codec *codec, bool wait_power_down)
4912 struct hda_bus *bus = codec->bus;
4914 /* Return if power_on or transitioning to power_on, unless currently
4916 if ((codec->power_on || codec->power_transition > 0) &&
4917 !(wait_power_down && codec->power_transition < 0))
4919 spin_unlock(&codec->power_lock);
4921 cancel_delayed_work_sync(&codec->power_work);
4923 spin_lock(&codec->power_lock);
4924 /* If the power down delayed work was cancelled above before starting,
4925 * then there is no need to go through power up here.
4927 if (codec->power_on) {
4928 if (codec->power_transition < 0)
4929 codec->power_transition = 0;
4933 trace_hda_power_up(codec);
4934 snd_hda_update_power_acct(codec);
4935 codec->power_on = 1;
4936 codec->power_jiffies = jiffies;
4937 codec->power_transition = 1; /* avoid reentrance */
4938 spin_unlock(&codec->power_lock);
4940 if (codec->pm_down_notified) {
4941 codec->pm_down_notified = 0;
4942 hda_call_pm_notify(bus, true);
4945 hda_call_codec_resume(codec);
4947 spin_lock(&codec->power_lock);
4948 codec->power_transition = 0;
4951 #define power_save(codec) \
4952 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
4954 /* Transition to powered down */
4955 static void __snd_hda_power_down(struct hda_codec *codec)
4957 if (!codec->power_on || codec->power_count || codec->power_transition)
4960 if (power_save(codec)) {
4961 codec->power_transition = -1; /* avoid reentrance */
4962 queue_delayed_work(codec->bus->workq, &codec->power_work,
4963 msecs_to_jiffies(power_save(codec) * 1000));
4968 * snd_hda_power_save - Power-up/down/sync the codec
4969 * @codec: HD-audio codec
4970 * @delta: the counter delta to change
4972 * Change the power-up counter via @delta, and power up or down the hardware
4973 * appropriately. For the power-down, queue to the delayed action.
4974 * Passing zero to @delta means to synchronize the power state.
4976 void snd_hda_power_save(struct hda_codec *codec, int delta, bool d3wait)
4978 spin_lock(&codec->power_lock);
4979 codec->power_count += delta;
4980 trace_hda_power_count(codec);
4982 __snd_hda_power_up(codec, d3wait);
4984 __snd_hda_power_down(codec);
4985 spin_unlock(&codec->power_lock);
4987 EXPORT_SYMBOL_HDA(snd_hda_power_save);
4990 * snd_hda_check_amp_list_power - Check the amp list and update the power
4991 * @codec: HD-audio codec
4992 * @check: the object containing an AMP list and the status
4993 * @nid: NID to check / update
4995 * Check whether the given NID is in the amp list. If it's in the list,
4996 * check the current AMP status, and update the the power-status according
4997 * to the mute status.
4999 * This function is supposed to be set or called from the check_power_status
5002 int snd_hda_check_amp_list_power(struct hda_codec *codec,
5003 struct hda_loopback_check *check,
5006 const struct hda_amp_list *p;
5009 if (!check->amplist)
5011 for (p = check->amplist; p->nid; p++) {
5016 return 0; /* nothing changed */
5018 for (p = check->amplist; p->nid; p++) {
5019 for (ch = 0; ch < 2; ch++) {
5020 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
5022 if (!(v & HDA_AMP_MUTE) && v > 0) {
5023 if (!check->power_on) {
5024 check->power_on = 1;
5025 snd_hda_power_up(codec);
5031 if (check->power_on) {
5032 check->power_on = 0;
5033 snd_hda_power_down(codec);
5037 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
5041 * Channel mode helper
5045 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
5047 int snd_hda_ch_mode_info(struct hda_codec *codec,
5048 struct snd_ctl_elem_info *uinfo,
5049 const struct hda_channel_mode *chmode,
5052 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5054 uinfo->value.enumerated.items = num_chmodes;
5055 if (uinfo->value.enumerated.item >= num_chmodes)
5056 uinfo->value.enumerated.item = num_chmodes - 1;
5057 sprintf(uinfo->value.enumerated.name, "%dch",
5058 chmode[uinfo->value.enumerated.item].channels);
5061 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
5064 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
5066 int snd_hda_ch_mode_get(struct hda_codec *codec,
5067 struct snd_ctl_elem_value *ucontrol,
5068 const struct hda_channel_mode *chmode,
5074 for (i = 0; i < num_chmodes; i++) {
5075 if (max_channels == chmode[i].channels) {
5076 ucontrol->value.enumerated.item[0] = i;
5082 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
5085 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
5087 int snd_hda_ch_mode_put(struct hda_codec *codec,
5088 struct snd_ctl_elem_value *ucontrol,
5089 const struct hda_channel_mode *chmode,
5095 mode = ucontrol->value.enumerated.item[0];
5096 if (mode >= num_chmodes)
5098 if (*max_channelsp == chmode[mode].channels)
5100 /* change the current channel setting */
5101 *max_channelsp = chmode[mode].channels;
5102 if (chmode[mode].sequence)
5103 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
5106 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
5113 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
5115 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
5116 struct snd_ctl_elem_info *uinfo)
5120 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5122 uinfo->value.enumerated.items = imux->num_items;
5123 if (!imux->num_items)
5125 index = uinfo->value.enumerated.item;
5126 if (index >= imux->num_items)
5127 index = imux->num_items - 1;
5128 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
5131 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
5134 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
5136 int snd_hda_input_mux_put(struct hda_codec *codec,
5137 const struct hda_input_mux *imux,
5138 struct snd_ctl_elem_value *ucontrol,
5140 unsigned int *cur_val)
5144 if (!imux->num_items)
5146 idx = ucontrol->value.enumerated.item[0];
5147 if (idx >= imux->num_items)
5148 idx = imux->num_items - 1;
5149 if (*cur_val == idx)
5151 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
5152 imux->items[idx].index);
5156 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
5160 * process kcontrol info callback of a simple string enum array
5161 * when @num_items is 0 or @texts is NULL, assume a boolean enum array
5163 int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
5164 struct snd_ctl_elem_info *uinfo,
5165 int num_items, const char * const *texts)
5167 static const char * const texts_default[] = {
5168 "Disabled", "Enabled"
5171 if (!texts || !num_items) {
5173 texts = texts_default;
5176 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5178 uinfo->value.enumerated.items = num_items;
5179 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
5180 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
5181 strcpy(uinfo->value.enumerated.name,
5182 texts[uinfo->value.enumerated.item]);
5185 EXPORT_SYMBOL_HDA(snd_hda_enum_helper_info);
5188 * Multi-channel / digital-out PCM helper functions
5191 /* setup SPDIF output stream */
5192 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
5193 unsigned int stream_tag, unsigned int format)
5195 struct hda_spdif_out *spdif;
5196 unsigned int curr_fmt;
5199 spdif = snd_hda_spdif_out_of_nid(codec, nid);
5200 curr_fmt = snd_hda_codec_read(codec, nid, 0,
5201 AC_VERB_GET_STREAM_FORMAT, 0);
5202 reset = codec->spdif_status_reset &&
5203 (spdif->ctls & AC_DIG1_ENABLE) &&
5206 /* turn off SPDIF if needed; otherwise the IEC958 bits won't be
5209 set_dig_out_convert(codec, nid,
5210 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
5212 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
5213 if (codec->slave_dig_outs) {
5215 for (d = codec->slave_dig_outs; *d; d++)
5216 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
5219 /* turn on again (if needed) */
5221 set_dig_out_convert(codec, nid,
5222 spdif->ctls & 0xff, -1);
5225 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
5227 snd_hda_codec_cleanup_stream(codec, nid);
5228 if (codec->slave_dig_outs) {
5230 for (d = codec->slave_dig_outs; *d; d++)
5231 snd_hda_codec_cleanup_stream(codec, *d);
5236 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
5237 * @bus: HD-audio bus
5239 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
5241 struct hda_codec *codec;
5245 list_for_each_entry(codec, &bus->codec_list, list) {
5246 if (hda_codec_is_power_on(codec) &&
5247 codec->patch_ops.reboot_notify)
5248 codec->patch_ops.reboot_notify(codec);
5251 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
5254 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
5256 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
5257 struct hda_multi_out *mout)
5259 mutex_lock(&codec->spdif_mutex);
5260 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
5261 /* already opened as analog dup; reset it once */
5262 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5263 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
5264 mutex_unlock(&codec->spdif_mutex);
5267 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
5270 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
5272 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
5273 struct hda_multi_out *mout,
5274 unsigned int stream_tag,
5275 unsigned int format,
5276 struct snd_pcm_substream *substream)
5278 mutex_lock(&codec->spdif_mutex);
5279 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
5280 mutex_unlock(&codec->spdif_mutex);
5283 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
5286 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
5288 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
5289 struct hda_multi_out *mout)
5291 mutex_lock(&codec->spdif_mutex);
5292 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5293 mutex_unlock(&codec->spdif_mutex);
5296 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
5299 * snd_hda_multi_out_dig_close - release the digital out stream
5301 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
5302 struct hda_multi_out *mout)
5304 mutex_lock(&codec->spdif_mutex);
5305 mout->dig_out_used = 0;
5306 mutex_unlock(&codec->spdif_mutex);
5309 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
5312 * snd_hda_multi_out_analog_open - open analog outputs
5314 * Open analog outputs and set up the hw-constraints.
5315 * If the digital outputs can be opened as slave, open the digital
5318 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
5319 struct hda_multi_out *mout,
5320 struct snd_pcm_substream *substream,
5321 struct hda_pcm_stream *hinfo)
5323 struct snd_pcm_runtime *runtime = substream->runtime;
5324 runtime->hw.channels_max = mout->max_channels;
5325 if (mout->dig_out_nid) {
5326 if (!mout->analog_rates) {
5327 mout->analog_rates = hinfo->rates;
5328 mout->analog_formats = hinfo->formats;
5329 mout->analog_maxbps = hinfo->maxbps;
5331 runtime->hw.rates = mout->analog_rates;
5332 runtime->hw.formats = mout->analog_formats;
5333 hinfo->maxbps = mout->analog_maxbps;
5335 if (!mout->spdif_rates) {
5336 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
5338 &mout->spdif_formats,
5339 &mout->spdif_maxbps);
5341 mutex_lock(&codec->spdif_mutex);
5342 if (mout->share_spdif) {
5343 if ((runtime->hw.rates & mout->spdif_rates) &&
5344 (runtime->hw.formats & mout->spdif_formats)) {
5345 runtime->hw.rates &= mout->spdif_rates;
5346 runtime->hw.formats &= mout->spdif_formats;
5347 if (mout->spdif_maxbps < hinfo->maxbps)
5348 hinfo->maxbps = mout->spdif_maxbps;
5350 mout->share_spdif = 0;
5351 /* FIXME: need notify? */
5354 mutex_unlock(&codec->spdif_mutex);
5356 return snd_pcm_hw_constraint_step(substream->runtime, 0,
5357 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
5359 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
5362 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
5364 * Set up the i/o for analog out.
5365 * When the digital out is available, copy the front out to digital out, too.
5367 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
5368 struct hda_multi_out *mout,
5369 unsigned int stream_tag,
5370 unsigned int format,
5371 struct snd_pcm_substream *substream)
5373 const hda_nid_t *nids = mout->dac_nids;
5374 int chs = substream->runtime->channels;
5375 struct hda_spdif_out *spdif;
5378 mutex_lock(&codec->spdif_mutex);
5379 spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
5380 if (mout->dig_out_nid && mout->share_spdif &&
5381 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
5383 snd_hda_is_supported_format(codec, mout->dig_out_nid,
5385 !(spdif->status & IEC958_AES0_NONAUDIO)) {
5386 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
5387 setup_dig_out_stream(codec, mout->dig_out_nid,
5388 stream_tag, format);
5390 mout->dig_out_used = 0;
5391 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5394 mutex_unlock(&codec->spdif_mutex);
5397 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
5399 if (!mout->no_share_stream &&
5400 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
5401 /* headphone out will just decode front left/right (stereo) */
5402 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
5404 /* extra outputs copied from front */
5405 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5406 if (!mout->no_share_stream && mout->hp_out_nid[i])
5407 snd_hda_codec_setup_stream(codec,
5408 mout->hp_out_nid[i],
5409 stream_tag, 0, format);
5412 for (i = 1; i < mout->num_dacs; i++) {
5413 if (chs >= (i + 1) * 2) /* independent out */
5414 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5416 else if (!mout->no_share_stream) /* copy front */
5417 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
5421 /* extra surrounds */
5422 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
5424 if (!mout->extra_out_nid[i])
5426 if (chs >= (i + 1) * 2)
5428 else if (!mout->no_share_stream)
5430 snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
5431 stream_tag, ch, format);
5436 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
5439 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
5441 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
5442 struct hda_multi_out *mout)
5444 const hda_nid_t *nids = mout->dac_nids;
5447 for (i = 0; i < mout->num_dacs; i++)
5448 snd_hda_codec_cleanup_stream(codec, nids[i]);
5450 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
5451 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
5452 if (mout->hp_out_nid[i])
5453 snd_hda_codec_cleanup_stream(codec,
5454 mout->hp_out_nid[i]);
5455 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
5456 if (mout->extra_out_nid[i])
5457 snd_hda_codec_cleanup_stream(codec,
5458 mout->extra_out_nid[i]);
5459 mutex_lock(&codec->spdif_mutex);
5460 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
5461 cleanup_dig_out_stream(codec, mout->dig_out_nid);
5462 mout->dig_out_used = 0;
5464 mutex_unlock(&codec->spdif_mutex);
5467 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
5470 * snd_hda_get_default_vref - Get the default (mic) VREF pin bits
5472 * Guess the suitable VREF pin bits to be set as the pin-control value.
5473 * Note: the function doesn't set the AC_PINCTL_IN_EN bit.
5475 unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
5477 unsigned int pincap;
5478 unsigned int oldval;
5479 oldval = snd_hda_codec_read(codec, pin, 0,
5480 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5481 pincap = snd_hda_query_pin_caps(codec, pin);
5482 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5483 /* Exception: if the default pin setup is vref50, we give it priority */
5484 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
5485 return AC_PINCTL_VREF_80;
5486 else if (pincap & AC_PINCAP_VREF_50)
5487 return AC_PINCTL_VREF_50;
5488 else if (pincap & AC_PINCAP_VREF_100)
5489 return AC_PINCTL_VREF_100;
5490 else if (pincap & AC_PINCAP_VREF_GRD)
5491 return AC_PINCTL_VREF_GRD;
5492 return AC_PINCTL_VREF_HIZ;
5494 EXPORT_SYMBOL_HDA(snd_hda_get_default_vref);
5496 /* correct the pin ctl value for matching with the pin cap */
5497 unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
5498 hda_nid_t pin, unsigned int val)
5500 static unsigned int cap_lists[][2] = {
5501 { AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
5502 { AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
5503 { AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
5504 { AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
5510 cap = snd_hda_query_pin_caps(codec, pin);
5512 return val; /* don't know what to do... */
5514 if (val & AC_PINCTL_OUT_EN) {
5515 if (!(cap & AC_PINCAP_OUT))
5516 val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5517 else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
5518 val &= ~AC_PINCTL_HP_EN;
5521 if (val & AC_PINCTL_IN_EN) {
5522 if (!(cap & AC_PINCAP_IN))
5523 val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
5525 unsigned int vcap, vref;
5527 vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
5528 vref = val & AC_PINCTL_VREFEN;
5529 for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
5530 if (vref == cap_lists[i][0] &&
5531 !(vcap & cap_lists[i][1])) {
5532 if (i == ARRAY_SIZE(cap_lists) - 1)
5533 vref = AC_PINCTL_VREF_HIZ;
5535 vref = cap_lists[i + 1][0];
5538 val &= ~AC_PINCTL_VREFEN;
5545 EXPORT_SYMBOL_HDA(snd_hda_correct_pin_ctl);
5547 int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
5548 unsigned int val, bool cached)
5550 val = snd_hda_correct_pin_ctl(codec, pin, val);
5551 snd_hda_codec_set_pin_target(codec, pin, val);
5553 return snd_hda_codec_update_cache(codec, pin, 0,
5554 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5556 return snd_hda_codec_write(codec, pin, 0,
5557 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5559 EXPORT_SYMBOL_HDA(_snd_hda_set_pin_ctl);
5562 * snd_hda_add_imux_item - Add an item to input_mux
5564 * When the same label is used already in the existing items, the number
5565 * suffix is appended to the label. This label index number is stored
5566 * to type_idx when non-NULL pointer is given.
5568 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5569 int index, int *type_idx)
5571 int i, label_idx = 0;
5572 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5573 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5576 for (i = 0; i < imux->num_items; i++) {
5577 if (!strncmp(label, imux->items[i].label, strlen(label)))
5581 *type_idx = label_idx;
5583 snprintf(imux->items[imux->num_items].label,
5584 sizeof(imux->items[imux->num_items].label),
5585 "%s %d", label, label_idx);
5587 strlcpy(imux->items[imux->num_items].label, label,
5588 sizeof(imux->items[imux->num_items].label));
5589 imux->items[imux->num_items].index = index;
5593 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
5602 * snd_hda_suspend - suspend the codecs
5605 * Returns 0 if successful.
5607 int snd_hda_suspend(struct hda_bus *bus)
5609 struct hda_codec *codec;
5611 list_for_each_entry(codec, &bus->codec_list, list) {
5612 cancel_delayed_work_sync(&codec->jackpoll_work);
5613 if (hda_codec_is_power_on(codec))
5614 hda_call_codec_suspend(codec, false);
5618 EXPORT_SYMBOL_HDA(snd_hda_suspend);
5621 * snd_hda_resume - resume the codecs
5624 * Returns 0 if successful.
5626 int snd_hda_resume(struct hda_bus *bus)
5628 struct hda_codec *codec;
5630 list_for_each_entry(codec, &bus->codec_list, list) {
5631 hda_call_codec_resume(codec);
5635 EXPORT_SYMBOL_HDA(snd_hda_resume);
5636 #endif /* CONFIG_PM */
5643 * snd_array_new - get a new element from the given array
5644 * @array: the array object
5646 * Get a new element from the given array. If it exceeds the
5647 * pre-allocated array size, re-allocate the array.
5649 * Returns NULL if allocation failed.
5651 void *snd_array_new(struct snd_array *array)
5653 if (snd_BUG_ON(!array->elem_size))
5655 if (array->used >= array->alloced) {
5656 int num = array->alloced + array->alloc_align;
5657 int size = (num + 1) * array->elem_size;
5659 if (snd_BUG_ON(num >= 4096))
5661 nlist = krealloc(array->list, size, GFP_KERNEL | __GFP_ZERO);
5664 array->list = nlist;
5665 array->alloced = num;
5667 return snd_array_elem(array, array->used++);
5669 EXPORT_SYMBOL_HDA(snd_array_new);
5672 * snd_array_free - free the given array elements
5673 * @array: the array object
5675 void snd_array_free(struct snd_array *array)
5682 EXPORT_SYMBOL_HDA(snd_array_free);
5685 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5686 * @pcm: PCM caps bits
5687 * @buf: the string buffer to write
5688 * @buflen: the max buffer length
5690 * used by hda_proc.c and hda_eld.c
5692 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5694 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5697 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5698 if (pcm & (AC_SUPPCM_BITS_8 << i))
5699 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5701 buf[j] = '\0'; /* necessary when j == 0 */
5703 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
5705 MODULE_DESCRIPTION("HDA codec core");
5706 MODULE_LICENSE("GPL");