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
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
34 #include <sound/hda_hwdep.h>
37 * vendor / preset table
40 struct hda_vendor_id {
45 /* codec vendor labels */
46 static struct hda_vendor_id hda_vendor_ids[] = {
48 { 0x1013, "Cirrus Logic" },
49 { 0x1057, "Motorola" },
50 { 0x1095, "Silicon Image" },
52 { 0x10ec, "Realtek" },
53 { 0x1102, "Creative" },
57 { 0x11d4, "Analog Devices" },
58 { 0x13f6, "C-Media" },
59 { 0x14f1, "Conexant" },
60 { 0x17e8, "Chrontel" },
62 { 0x1aec, "Wolfson Microelectronics" },
63 { 0x434d, "C-Media" },
65 { 0x8384, "SigmaTel" },
69 static DEFINE_MUTEX(preset_mutex);
70 static LIST_HEAD(hda_preset_tables);
72 int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
74 mutex_lock(&preset_mutex);
75 list_add_tail(&preset->list, &hda_preset_tables);
76 mutex_unlock(&preset_mutex);
79 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
81 int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
83 mutex_lock(&preset_mutex);
84 list_del(&preset->list);
85 mutex_unlock(&preset_mutex);
88 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
90 #ifdef CONFIG_SND_HDA_POWER_SAVE
91 static void hda_power_work(struct work_struct *work);
92 static void hda_keep_power_on(struct hda_codec *codec);
94 static inline void hda_keep_power_on(struct hda_codec *codec) {}
98 * snd_hda_get_jack_location - Give a location string of the jack
99 * @cfg: pin default config value
101 * Parse the pin default config value and returns the string of the
102 * jack location, e.g. "Rear", "Front", etc.
104 const char *snd_hda_get_jack_location(u32 cfg)
106 static char *bases[7] = {
107 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
109 static unsigned char specials_idx[] = {
114 static char *specials[] = {
115 "Rear Panel", "Drive Bar",
116 "Riser", "HDMI", "ATAPI",
117 "Mobile-In", "Mobile-Out"
120 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
121 if ((cfg & 0x0f) < 7)
122 return bases[cfg & 0x0f];
123 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
124 if (cfg == specials_idx[i])
129 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
132 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
133 * @cfg: pin default config value
135 * Parse the pin default config value and returns the string of the
136 * jack connectivity, i.e. external or internal connection.
138 const char *snd_hda_get_jack_connectivity(u32 cfg)
140 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
142 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
144 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
147 * snd_hda_get_jack_type - Give a type string of the jack
148 * @cfg: pin default config value
150 * Parse the pin default config value and returns the string of the
151 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
153 const char *snd_hda_get_jack_type(u32 cfg)
155 static char *jack_types[16] = {
156 "Line Out", "Speaker", "HP Out", "CD",
157 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
158 "Line In", "Aux", "Mic", "Telephony",
159 "SPDIF In", "Digitial In", "Reserved", "Other"
162 return jack_types[(cfg & AC_DEFCFG_DEVICE)
163 >> AC_DEFCFG_DEVICE_SHIFT];
165 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
168 * Compose a 32bit command word to be sent to the HD-audio controller
170 static inline unsigned int
171 make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
172 unsigned int verb, unsigned int parm)
176 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
177 (verb & ~0xfff) || (parm & ~0xffff)) {
178 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
179 codec->addr, direct, nid, verb, parm);
183 val = (u32)codec->addr << 28;
184 val |= (u32)direct << 27;
185 val |= (u32)nid << 20;
192 * Send and receive a verb
194 static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
197 struct hda_bus *bus = codec->bus;
206 snd_hda_power_up(codec);
207 mutex_lock(&bus->cmd_mutex);
208 err = bus->ops.command(bus, cmd);
210 *res = bus->ops.get_response(bus, codec->addr);
211 mutex_unlock(&bus->cmd_mutex);
212 snd_hda_power_down(codec);
213 if (res && *res == -1 && bus->rirb_error) {
214 if (bus->response_reset) {
215 snd_printd("hda_codec: resetting BUS due to "
216 "fatal communication error\n");
217 bus->ops.bus_reset(bus);
221 /* clear reset-flag when the communication gets recovered */
223 bus->response_reset = 0;
228 * snd_hda_codec_read - send a command and get the response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
235 * Send a single command and read the corresponding response.
237 * Returns the obtained response value, or -1 for an error.
239 unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
241 unsigned int verb, unsigned int parm)
243 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
245 codec_exec_verb(codec, cmd, &res);
248 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
251 * snd_hda_codec_write - send a single command without waiting for response
252 * @codec: the HDA codec
253 * @nid: NID to send the command
254 * @direct: direct flag
255 * @verb: the verb to send
256 * @parm: the parameter for the verb
258 * Send a single command without waiting for response.
260 * Returns 0 if successful, or a negative error code.
262 int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
263 unsigned int verb, unsigned int parm)
265 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
267 return codec_exec_verb(codec, cmd,
268 codec->bus->sync_write ? &res : NULL);
270 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
273 * snd_hda_sequence_write - sequence writes
274 * @codec: the HDA codec
275 * @seq: VERB array to send
277 * Send the commands sequentially from the given array.
278 * The array must be terminated with NID=0.
280 void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
282 for (; seq->nid; seq++)
283 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
285 EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
288 * snd_hda_get_sub_nodes - get the range of sub nodes
289 * @codec: the HDA codec
291 * @start_id: the pointer to store the start NID
293 * Parse the NID and store the start NID of its sub-nodes.
294 * Returns the number of sub-nodes.
296 int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
301 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
304 *start_id = (parm >> 16) & 0x7fff;
305 return (int)(parm & 0x7fff);
307 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
310 * snd_hda_get_connections - get connection list
311 * @codec: the HDA codec
313 * @conn_list: connection list array
314 * @max_conns: max. number of connections to store
316 * Parses the connection list of the given widget and stores the list
319 * Returns the number of connections, or a negative error code.
321 int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
322 hda_nid_t *conn_list, int max_conns)
325 int i, conn_len, conns;
326 unsigned int shift, num_elems, mask;
330 if (snd_BUG_ON(!conn_list || max_conns <= 0))
333 wcaps = get_wcaps(codec, nid);
334 if (!(wcaps & AC_WCAP_CONN_LIST) &&
335 get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
336 snd_printk(KERN_WARNING "hda_codec: "
337 "connection list not available for 0x%x\n", nid);
341 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
342 if (parm & AC_CLIST_LONG) {
351 conn_len = parm & AC_CLIST_LENGTH;
352 mask = (1 << (shift-1)) - 1;
355 return 0; /* no connection */
358 /* single connection */
359 parm = snd_hda_codec_read(codec, nid, 0,
360 AC_VERB_GET_CONNECT_LIST, 0);
361 if (parm == -1 && codec->bus->rirb_error)
363 conn_list[0] = parm & mask;
367 /* multi connection */
370 for (i = 0; i < conn_len; i++) {
374 if (i % num_elems == 0) {
375 parm = snd_hda_codec_read(codec, nid, 0,
376 AC_VERB_GET_CONNECT_LIST, i);
377 if (parm == -1 && codec->bus->rirb_error)
380 range_val = !!(parm & (1 << (shift-1))); /* ranges */
383 snd_printk(KERN_WARNING "hda_codec: "
384 "invalid CONNECT_LIST verb %x[%i]:%x\n",
390 /* ranges between the previous and this one */
391 if (!prev_nid || prev_nid >= val) {
392 snd_printk(KERN_WARNING "hda_codec: "
393 "invalid dep_range_val %x:%x\n",
397 for (n = prev_nid + 1; n <= val; n++) {
398 if (conns >= max_conns) {
399 snd_printk(KERN_ERR "hda_codec: "
400 "Too many connections %d for NID 0x%x\n",
404 conn_list[conns++] = n;
407 if (conns >= max_conns) {
408 snd_printk(KERN_ERR "hda_codec: "
409 "Too many connections %d for NID 0x%x\n",
413 conn_list[conns++] = val;
419 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
423 * snd_hda_queue_unsol_event - add an unsolicited event to queue
425 * @res: unsolicited event (lower 32bit of RIRB entry)
426 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
428 * Adds the given event to the queue. The events are processed in
429 * the workqueue asynchronously. Call this function in the interrupt
430 * hanlder when RIRB receives an unsolicited event.
432 * Returns 0 if successful, or a negative error code.
434 int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
436 struct hda_bus_unsolicited *unsol;
443 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
447 unsol->queue[wp] = res;
448 unsol->queue[wp + 1] = res_ex;
450 queue_work(bus->workq, &unsol->work);
454 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
457 * process queued unsolicited events
459 static void process_unsol_events(struct work_struct *work)
461 struct hda_bus_unsolicited *unsol =
462 container_of(work, struct hda_bus_unsolicited, work);
463 struct hda_bus *bus = unsol->bus;
464 struct hda_codec *codec;
465 unsigned int rp, caddr, res;
467 while (unsol->rp != unsol->wp) {
468 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
471 res = unsol->queue[rp];
472 caddr = unsol->queue[rp + 1];
473 if (!(caddr & (1 << 4))) /* no unsolicited event? */
475 codec = bus->caddr_tbl[caddr & 0x0f];
476 if (codec && codec->patch_ops.unsol_event)
477 codec->patch_ops.unsol_event(codec, res);
482 * initialize unsolicited queue
484 static int init_unsol_queue(struct hda_bus *bus)
486 struct hda_bus_unsolicited *unsol;
488 if (bus->unsol) /* already initialized */
491 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
493 snd_printk(KERN_ERR "hda_codec: "
494 "can't allocate unsolicited queue\n");
497 INIT_WORK(&unsol->work, process_unsol_events);
506 static void snd_hda_codec_free(struct hda_codec *codec);
508 static int snd_hda_bus_free(struct hda_bus *bus)
510 struct hda_codec *codec, *n;
515 flush_workqueue(bus->workq);
518 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
519 snd_hda_codec_free(codec);
521 if (bus->ops.private_free)
522 bus->ops.private_free(bus);
524 destroy_workqueue(bus->workq);
529 static int snd_hda_bus_dev_free(struct snd_device *device)
531 struct hda_bus *bus = device->device_data;
533 return snd_hda_bus_free(bus);
536 #ifdef CONFIG_SND_HDA_HWDEP
537 static int snd_hda_bus_dev_register(struct snd_device *device)
539 struct hda_bus *bus = device->device_data;
540 struct hda_codec *codec;
541 list_for_each_entry(codec, &bus->codec_list, list) {
542 snd_hda_hwdep_add_sysfs(codec);
543 snd_hda_hwdep_add_power_sysfs(codec);
548 #define snd_hda_bus_dev_register NULL
552 * snd_hda_bus_new - create a HDA bus
553 * @card: the card entry
554 * @temp: the template for hda_bus information
555 * @busp: the pointer to store the created bus instance
557 * Returns 0 if successful, or a negative error code.
559 int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
560 const struct hda_bus_template *temp,
561 struct hda_bus **busp)
565 static struct snd_device_ops dev_ops = {
566 .dev_register = snd_hda_bus_dev_register,
567 .dev_free = snd_hda_bus_dev_free,
570 if (snd_BUG_ON(!temp))
572 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
578 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
580 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
585 bus->private_data = temp->private_data;
586 bus->pci = temp->pci;
587 bus->modelname = temp->modelname;
588 bus->power_save = temp->power_save;
589 bus->ops = temp->ops;
591 mutex_init(&bus->cmd_mutex);
592 mutex_init(&bus->prepare_mutex);
593 INIT_LIST_HEAD(&bus->codec_list);
595 snprintf(bus->workq_name, sizeof(bus->workq_name),
596 "hd-audio%d", card->number);
597 bus->workq = create_singlethread_workqueue(bus->workq_name);
599 snd_printk(KERN_ERR "cannot create workqueue %s\n",
605 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
607 snd_hda_bus_free(bus);
614 EXPORT_SYMBOL_HDA(snd_hda_bus_new);
616 #ifdef CONFIG_SND_HDA_GENERIC
617 #define is_generic_config(codec) \
618 (codec->modelname && !strcmp(codec->modelname, "generic"))
620 #define is_generic_config(codec) 0
624 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
626 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
630 * find a matching codec preset
632 static const struct hda_codec_preset *
633 find_codec_preset(struct hda_codec *codec)
635 struct hda_codec_preset_list *tbl;
636 const struct hda_codec_preset *preset;
637 int mod_requested = 0;
639 if (is_generic_config(codec))
640 return NULL; /* use the generic parser */
643 mutex_lock(&preset_mutex);
644 list_for_each_entry(tbl, &hda_preset_tables, list) {
645 if (!try_module_get(tbl->owner)) {
646 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
649 for (preset = tbl->preset; preset->id; preset++) {
650 u32 mask = preset->mask;
651 if (preset->afg && preset->afg != codec->afg)
653 if (preset->mfg && preset->mfg != codec->mfg)
657 if (preset->id == (codec->vendor_id & mask) &&
659 preset->rev == codec->revision_id)) {
660 mutex_unlock(&preset_mutex);
661 codec->owner = tbl->owner;
665 module_put(tbl->owner);
667 mutex_unlock(&preset_mutex);
669 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
672 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
675 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
676 (codec->vendor_id >> 16) & 0xffff);
677 request_module(name);
685 * get_codec_name - store the codec name
687 static int get_codec_name(struct hda_codec *codec)
689 const struct hda_vendor_id *c;
690 const char *vendor = NULL;
691 u16 vendor_id = codec->vendor_id >> 16;
694 if (codec->vendor_name)
697 for (c = hda_vendor_ids; c->id; c++) {
698 if (c->id == vendor_id) {
704 sprintf(tmp, "Generic %04x", vendor_id);
707 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
708 if (!codec->vendor_name)
712 if (codec->chip_name)
715 if (codec->preset && codec->preset->name)
716 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
718 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
719 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
721 if (!codec->chip_name)
727 * look for an AFG and MFG nodes
729 static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
731 int i, total_nodes, function_id;
734 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
735 for (i = 0; i < total_nodes; i++, nid++) {
736 function_id = snd_hda_param_read(codec, nid,
737 AC_PAR_FUNCTION_TYPE);
738 switch (function_id & 0xff) {
739 case AC_GRP_AUDIO_FUNCTION:
741 codec->afg_function_id = function_id & 0xff;
742 codec->afg_unsol = (function_id >> 8) & 1;
744 case AC_GRP_MODEM_FUNCTION:
746 codec->mfg_function_id = function_id & 0xff;
747 codec->mfg_unsol = (function_id >> 8) & 1;
756 * read widget caps for each widget and store in cache
758 static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
763 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
765 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
768 nid = codec->start_nid;
769 for (i = 0; i < codec->num_nodes; i++, nid++)
770 codec->wcaps[i] = snd_hda_param_read(codec, nid,
771 AC_PAR_AUDIO_WIDGET_CAP);
775 /* read all pin default configurations and save codec->init_pins */
776 static int read_pin_defaults(struct hda_codec *codec)
779 hda_nid_t nid = codec->start_nid;
781 for (i = 0; i < codec->num_nodes; i++, nid++) {
782 struct hda_pincfg *pin;
783 unsigned int wcaps = get_wcaps(codec, nid);
784 unsigned int wid_type = get_wcaps_type(wcaps);
785 if (wid_type != AC_WID_PIN)
787 pin = snd_array_new(&codec->init_pins);
791 pin->cfg = snd_hda_codec_read(codec, nid, 0,
792 AC_VERB_GET_CONFIG_DEFAULT, 0);
793 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
794 AC_VERB_GET_PIN_WIDGET_CONTROL,
800 /* look up the given pin config list and return the item matching with NID */
801 static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
802 struct snd_array *array,
806 for (i = 0; i < array->used; i++) {
807 struct hda_pincfg *pin = snd_array_elem(array, i);
814 /* write a config value for the given NID */
815 static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
819 for (i = 0; i < 4; i++) {
820 snd_hda_codec_write(codec, nid, 0,
821 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
827 /* set the current pin config value for the given NID.
828 * the value is cached, and read via snd_hda_codec_get_pincfg()
830 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
831 hda_nid_t nid, unsigned int cfg)
833 struct hda_pincfg *pin;
836 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
839 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
840 pin = look_up_pincfg(codec, list, nid);
842 pin = snd_array_new(list);
849 /* change only when needed; e.g. if the pincfg is already present
850 * in user_pins[], don't write it
852 cfg = snd_hda_codec_get_pincfg(codec, nid);
854 set_pincfg(codec, nid, cfg);
859 * snd_hda_codec_set_pincfg - Override a pin default configuration
860 * @codec: the HDA codec
861 * @nid: NID to set the pin config
862 * @cfg: the pin default config value
864 * Override a pin default configuration value in the cache.
865 * This value can be read by snd_hda_codec_get_pincfg() in a higher
866 * priority than the real hardware value.
868 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
869 hda_nid_t nid, unsigned int cfg)
871 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
873 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
876 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
877 * @codec: the HDA codec
878 * @nid: NID to get the pin config
880 * Get the current pin config value of the given pin NID.
881 * If the pincfg value is cached or overridden via sysfs or driver,
882 * returns the cached value.
884 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
886 struct hda_pincfg *pin;
888 #ifdef CONFIG_SND_HDA_HWDEP
889 pin = look_up_pincfg(codec, &codec->user_pins, nid);
893 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
896 pin = look_up_pincfg(codec, &codec->init_pins, nid);
901 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
903 /* restore all current pin configs */
904 static void restore_pincfgs(struct hda_codec *codec)
907 for (i = 0; i < codec->init_pins.used; i++) {
908 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
909 set_pincfg(codec, pin->nid,
910 snd_hda_codec_get_pincfg(codec, pin->nid));
915 * snd_hda_shutup_pins - Shut up all pins
916 * @codec: the HDA codec
918 * Clear all pin controls to shup up before suspend for avoiding click noise.
919 * The controls aren't cached so that they can be resumed properly.
921 void snd_hda_shutup_pins(struct hda_codec *codec)
924 /* don't shut up pins when unloading the driver; otherwise it breaks
925 * the default pin setup at the next load of the driver
927 if (codec->bus->shutdown)
929 for (i = 0; i < codec->init_pins.used; i++) {
930 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
931 /* use read here for syncing after issuing each verb */
932 snd_hda_codec_read(codec, pin->nid, 0,
933 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
935 codec->pins_shutup = 1;
937 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
939 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
940 static void restore_shutup_pins(struct hda_codec *codec)
943 if (!codec->pins_shutup)
945 if (codec->bus->shutdown)
947 for (i = 0; i < codec->init_pins.used; i++) {
948 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
949 snd_hda_codec_write(codec, pin->nid, 0,
950 AC_VERB_SET_PIN_WIDGET_CONTROL,
953 codec->pins_shutup = 0;
956 static void init_hda_cache(struct hda_cache_rec *cache,
957 unsigned int record_size);
958 static void free_hda_cache(struct hda_cache_rec *cache);
960 /* restore the initial pin cfgs and release all pincfg lists */
961 static void restore_init_pincfgs(struct hda_codec *codec)
963 /* first free driver_pins and user_pins, then call restore_pincfg
964 * so that only the values in init_pins are restored
966 snd_array_free(&codec->driver_pins);
967 #ifdef CONFIG_SND_HDA_HWDEP
968 snd_array_free(&codec->user_pins);
970 restore_pincfgs(codec);
971 snd_array_free(&codec->init_pins);
975 * audio-converter setup caches
977 struct hda_cvt_setup {
982 unsigned char active; /* cvt is currently used */
983 unsigned char dirty; /* setups should be cleared */
986 /* get or create a cache entry for the given audio converter NID */
987 static struct hda_cvt_setup *
988 get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
990 struct hda_cvt_setup *p;
993 for (i = 0; i < codec->cvt_setups.used; i++) {
994 p = snd_array_elem(&codec->cvt_setups, i);
998 p = snd_array_new(&codec->cvt_setups);
1007 static void snd_hda_codec_free(struct hda_codec *codec)
1011 restore_init_pincfgs(codec);
1012 #ifdef CONFIG_SND_HDA_POWER_SAVE
1013 cancel_delayed_work(&codec->power_work);
1014 flush_workqueue(codec->bus->workq);
1016 list_del(&codec->list);
1017 snd_array_free(&codec->mixers);
1018 snd_array_free(&codec->nids);
1019 codec->bus->caddr_tbl[codec->addr] = NULL;
1020 if (codec->patch_ops.free)
1021 codec->patch_ops.free(codec);
1022 module_put(codec->owner);
1023 free_hda_cache(&codec->amp_cache);
1024 free_hda_cache(&codec->cmd_cache);
1025 kfree(codec->vendor_name);
1026 kfree(codec->chip_name);
1027 kfree(codec->modelname);
1028 kfree(codec->wcaps);
1032 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1033 unsigned int power_state);
1036 * snd_hda_codec_new - create a HDA codec
1037 * @bus: the bus to assign
1038 * @codec_addr: the codec address
1039 * @codecp: the pointer to store the generated codec
1041 * Returns 0 if successful, or a negative error code.
1043 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1044 unsigned int codec_addr,
1045 struct hda_codec **codecp)
1047 struct hda_codec *codec;
1051 if (snd_BUG_ON(!bus))
1053 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1056 if (bus->caddr_tbl[codec_addr]) {
1057 snd_printk(KERN_ERR "hda_codec: "
1058 "address 0x%x is already occupied\n", codec_addr);
1062 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1063 if (codec == NULL) {
1064 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1069 codec->addr = codec_addr;
1070 mutex_init(&codec->spdif_mutex);
1071 mutex_init(&codec->control_mutex);
1072 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1073 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
1074 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1075 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
1076 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
1077 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
1078 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
1079 if (codec->bus->modelname) {
1080 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1081 if (!codec->modelname) {
1082 snd_hda_codec_free(codec);
1087 #ifdef CONFIG_SND_HDA_POWER_SAVE
1088 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1089 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1090 * the caller has to power down appropriatley after initialization
1093 hda_keep_power_on(codec);
1096 list_add_tail(&codec->list, &bus->codec_list);
1097 bus->caddr_tbl[codec_addr] = codec;
1099 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1101 if (codec->vendor_id == -1)
1102 /* read again, hopefully the access method was corrected
1103 * in the last read...
1105 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1107 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1108 AC_PAR_SUBSYSTEM_ID);
1109 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1112 setup_fg_nodes(codec);
1113 if (!codec->afg && !codec->mfg) {
1114 snd_printdd("hda_codec: no AFG or MFG node found\n");
1119 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1121 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
1124 err = read_pin_defaults(codec);
1128 if (!codec->subsystem_id) {
1129 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
1130 codec->subsystem_id =
1131 snd_hda_codec_read(codec, nid, 0,
1132 AC_VERB_GET_SUBSYSTEM_ID, 0);
1135 /* power-up all before initialization */
1136 hda_set_power_state(codec,
1137 codec->afg ? codec->afg : codec->mfg,
1140 snd_hda_codec_proc_new(codec);
1142 snd_hda_create_hwdep(codec);
1144 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1145 codec->subsystem_id, codec->revision_id);
1146 snd_component_add(codec->bus->card, component);
1153 snd_hda_codec_free(codec);
1156 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
1159 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1160 * @codec: the HDA codec
1162 * Start parsing of the given codec tree and (re-)initialize the whole
1165 * Returns 0 if successful or a negative error code.
1167 int snd_hda_codec_configure(struct hda_codec *codec)
1171 codec->preset = find_codec_preset(codec);
1172 if (!codec->vendor_name || !codec->chip_name) {
1173 err = get_codec_name(codec);
1178 if (is_generic_config(codec)) {
1179 err = snd_hda_parse_generic_codec(codec);
1182 if (codec->preset && codec->preset->patch) {
1183 err = codec->preset->patch(codec);
1187 /* call the default parser */
1188 err = snd_hda_parse_generic_codec(codec);
1190 printk(KERN_ERR "hda-codec: No codec parser is available\n");
1193 if (!err && codec->patch_ops.unsol_event)
1194 err = init_unsol_queue(codec->bus);
1195 /* audio codec should override the mixer name */
1196 if (!err && (codec->afg || !*codec->bus->card->mixername))
1197 snprintf(codec->bus->card->mixername,
1198 sizeof(codec->bus->card->mixername),
1199 "%s %s", codec->vendor_name, codec->chip_name);
1202 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1205 * snd_hda_codec_setup_stream - set up the codec for streaming
1206 * @codec: the CODEC to set up
1207 * @nid: the NID to set up
1208 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1209 * @channel_id: channel id to pass, zero based.
1210 * @format: stream format.
1212 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1214 int channel_id, int format)
1216 struct hda_codec *c;
1217 struct hda_cvt_setup *p;
1218 unsigned int oldval, newval;
1224 snd_printdd("hda_codec_setup_stream: "
1225 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1226 nid, stream_tag, channel_id, format);
1227 p = get_hda_cvt_setup(codec, nid);
1230 /* update the stream-id if changed */
1231 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1232 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1233 newval = (stream_tag << 4) | channel_id;
1234 if (oldval != newval)
1235 snd_hda_codec_write(codec, nid, 0,
1236 AC_VERB_SET_CHANNEL_STREAMID,
1238 p->stream_tag = stream_tag;
1239 p->channel_id = channel_id;
1241 /* update the format-id if changed */
1242 if (p->format_id != format) {
1243 oldval = snd_hda_codec_read(codec, nid, 0,
1244 AC_VERB_GET_STREAM_FORMAT, 0);
1245 if (oldval != format) {
1247 snd_hda_codec_write(codec, nid, 0,
1248 AC_VERB_SET_STREAM_FORMAT,
1251 p->format_id = format;
1256 /* make other inactive cvts with the same stream-tag dirty */
1257 list_for_each_entry(c, &codec->bus->codec_list, list) {
1258 for (i = 0; i < c->cvt_setups.used; i++) {
1259 p = snd_array_elem(&c->cvt_setups, i);
1260 if (!p->active && p->stream_tag == stream_tag)
1265 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1267 static void really_cleanup_stream(struct hda_codec *codec,
1268 struct hda_cvt_setup *q);
1271 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1272 * @codec: the CODEC to clean up
1273 * @nid: the NID to clean up
1274 * @do_now: really clean up the stream instead of clearing the active flag
1276 void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1279 struct hda_cvt_setup *p;
1284 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1285 p = get_hda_cvt_setup(codec, nid);
1287 /* here we just clear the active flag when do_now isn't set;
1288 * actual clean-ups will be done later in
1289 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1292 really_cleanup_stream(codec, p);
1297 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
1299 static void really_cleanup_stream(struct hda_codec *codec,
1300 struct hda_cvt_setup *q)
1302 hda_nid_t nid = q->nid;
1303 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1304 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1305 memset(q, 0, sizeof(*q));
1309 /* clean up the all conflicting obsolete streams */
1310 static void purify_inactive_streams(struct hda_codec *codec)
1312 struct hda_codec *c;
1315 list_for_each_entry(c, &codec->bus->codec_list, list) {
1316 for (i = 0; i < c->cvt_setups.used; i++) {
1317 struct hda_cvt_setup *p;
1318 p = snd_array_elem(&c->cvt_setups, i);
1320 really_cleanup_stream(c, p);
1325 /* clean up all streams; called from suspend */
1326 static void hda_cleanup_all_streams(struct hda_codec *codec)
1330 for (i = 0; i < codec->cvt_setups.used; i++) {
1331 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1333 really_cleanup_stream(codec, p);
1338 * amp access functions
1341 /* FIXME: more better hash key? */
1342 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1343 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1344 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1345 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1346 #define INFO_AMP_CAPS (1<<0)
1347 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1349 /* initialize the hash table */
1350 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
1351 unsigned int record_size)
1353 memset(cache, 0, sizeof(*cache));
1354 memset(cache->hash, 0xff, sizeof(cache->hash));
1355 snd_array_init(&cache->buf, record_size, 64);
1358 static void free_hda_cache(struct hda_cache_rec *cache)
1360 snd_array_free(&cache->buf);
1363 /* query the hash. allocate an entry if not found. */
1364 static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
1366 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1367 u16 cur = cache->hash[idx];
1368 struct hda_cache_head *info;
1370 while (cur != 0xffff) {
1371 info = snd_array_elem(&cache->buf, cur);
1372 if (info->key == key)
1379 /* query the hash. allocate an entry if not found. */
1380 static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1383 struct hda_cache_head *info = get_hash(cache, key);
1386 /* add a new hash entry */
1387 info = snd_array_new(&cache->buf);
1390 cur = snd_array_index(&cache->buf, info);
1393 idx = key % (u16)ARRAY_SIZE(cache->hash);
1394 info->next = cache->hash[idx];
1395 cache->hash[idx] = cur;
1400 /* query and allocate an amp hash entry */
1401 static inline struct hda_amp_info *
1402 get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1404 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1408 * query_amp_caps - query AMP capabilities
1409 * @codec: the HD-auio codec
1410 * @nid: the NID to query
1411 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1413 * Query AMP capabilities for the given widget and direction.
1414 * Returns the obtained capability bits.
1416 * When cap bits have been already read, this doesn't read again but
1417 * returns the cached value.
1419 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1421 struct hda_amp_info *info;
1423 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1426 if (!(info->head.val & INFO_AMP_CAPS)) {
1427 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1429 info->amp_caps = snd_hda_param_read(codec, nid,
1430 direction == HDA_OUTPUT ?
1431 AC_PAR_AMP_OUT_CAP :
1434 info->head.val |= INFO_AMP_CAPS;
1436 return info->amp_caps;
1438 EXPORT_SYMBOL_HDA(query_amp_caps);
1441 * snd_hda_override_amp_caps - Override the AMP capabilities
1442 * @codec: the CODEC to clean up
1443 * @nid: the NID to clean up
1444 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1445 * @caps: the capability bits to set
1447 * Override the cached AMP caps bits value by the given one.
1448 * This function is useful if the driver needs to adjust the AMP ranges,
1449 * e.g. limit to 0dB, etc.
1451 * Returns zero if successful or a negative error code.
1453 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1456 struct hda_amp_info *info;
1458 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1461 info->amp_caps = caps;
1462 info->head.val |= INFO_AMP_CAPS;
1465 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1468 query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1469 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1471 struct hda_amp_info *info;
1473 info = get_alloc_amp_hash(codec, key);
1476 if (!info->head.val) {
1477 info->head.val |= INFO_AMP_CAPS;
1478 info->amp_caps = func(codec, nid);
1480 return info->amp_caps;
1483 static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1485 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1489 * snd_hda_query_pin_caps - Query PIN capabilities
1490 * @codec: the HD-auio codec
1491 * @nid: the NID to query
1493 * Query PIN capabilities for the given widget.
1494 * Returns the obtained capability bits.
1496 * When cap bits have been already read, this doesn't read again but
1497 * returns the cached value.
1499 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1501 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1504 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1507 * snd_hda_pin_sense - execute pin sense measurement
1508 * @codec: the CODEC to sense
1509 * @nid: the pin NID to sense
1511 * Execute necessary pin sense measurement and return its Presence Detect,
1512 * Impedance, ELD Valid etc. status bits.
1514 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
1518 if (!codec->no_trigger_sense) {
1519 pincap = snd_hda_query_pin_caps(codec, nid);
1520 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1521 snd_hda_codec_read(codec, nid, 0,
1522 AC_VERB_SET_PIN_SENSE, 0);
1524 return snd_hda_codec_read(codec, nid, 0,
1525 AC_VERB_GET_PIN_SENSE, 0);
1527 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
1530 * snd_hda_jack_detect - query pin Presence Detect status
1531 * @codec: the CODEC to sense
1532 * @nid: the pin NID to sense
1534 * Query and return the pin's Presence Detect status.
1536 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
1538 u32 sense = snd_hda_pin_sense(codec, nid);
1539 return !!(sense & AC_PINSENSE_PRESENCE);
1541 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
1544 * read the current volume to info
1545 * if the cache exists, read the cache value.
1547 static unsigned int get_vol_mute(struct hda_codec *codec,
1548 struct hda_amp_info *info, hda_nid_t nid,
1549 int ch, int direction, int index)
1553 if (info->head.val & INFO_AMP_VOL(ch))
1554 return info->vol[ch];
1556 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1557 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1559 val = snd_hda_codec_read(codec, nid, 0,
1560 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1561 info->vol[ch] = val & 0xff;
1562 info->head.val |= INFO_AMP_VOL(ch);
1563 return info->vol[ch];
1567 * write the current volume in info to the h/w and update the cache
1569 static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
1570 hda_nid_t nid, int ch, int direction, int index,
1575 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1576 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1577 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1579 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
1580 info->vol[ch] = val;
1584 * snd_hda_codec_amp_read - Read AMP value
1585 * @codec: HD-audio codec
1586 * @nid: NID to read the AMP value
1587 * @ch: channel (left=0 or right=1)
1588 * @direction: #HDA_INPUT or #HDA_OUTPUT
1589 * @index: the index value (only for input direction)
1591 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1593 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1594 int direction, int index)
1596 struct hda_amp_info *info;
1597 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1600 return get_vol_mute(codec, info, nid, ch, direction, index);
1602 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1605 * snd_hda_codec_amp_update - update the AMP value
1606 * @codec: HD-audio codec
1607 * @nid: NID to read the AMP value
1608 * @ch: channel (left=0 or right=1)
1609 * @direction: #HDA_INPUT or #HDA_OUTPUT
1610 * @idx: the index value (only for input direction)
1611 * @mask: bit mask to set
1612 * @val: the bits value to set
1614 * Update the AMP value with a bit mask.
1615 * Returns 0 if the value is unchanged, 1 if changed.
1617 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1618 int direction, int idx, int mask, int val)
1620 struct hda_amp_info *info;
1622 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1625 if (snd_BUG_ON(mask & ~0xff))
1628 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
1629 if (info->vol[ch] == val)
1631 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1634 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1637 * snd_hda_codec_amp_stereo - update the AMP stereo values
1638 * @codec: HD-audio codec
1639 * @nid: NID to read the AMP value
1640 * @direction: #HDA_INPUT or #HDA_OUTPUT
1641 * @idx: the index value (only for input direction)
1642 * @mask: bit mask to set
1643 * @val: the bits value to set
1645 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1646 * stereo widget with the same mask and value.
1648 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1649 int direction, int idx, int mask, int val)
1653 if (snd_BUG_ON(mask & ~0xff))
1655 for (ch = 0; ch < 2; ch++)
1656 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1660 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
1662 #ifdef SND_HDA_NEEDS_RESUME
1664 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1665 * @codec: HD-audio codec
1667 * Resume the all amp commands from the cache.
1669 void snd_hda_codec_resume_amp(struct hda_codec *codec)
1671 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
1674 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
1675 u32 key = buffer->head.key;
1677 unsigned int idx, dir, ch;
1681 idx = (key >> 16) & 0xff;
1682 dir = (key >> 24) & 0xff;
1683 for (ch = 0; ch < 2; ch++) {
1684 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1686 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1691 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
1692 #endif /* SND_HDA_NEEDS_RESUME */
1694 static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1697 u32 caps = query_amp_caps(codec, nid, dir);
1699 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1706 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1708 * The control element is supposed to have the private_value field
1709 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1711 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1712 struct snd_ctl_elem_info *uinfo)
1714 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1715 u16 nid = get_amp_nid(kcontrol);
1716 u8 chs = get_amp_channels(kcontrol);
1717 int dir = get_amp_direction(kcontrol);
1718 unsigned int ofs = get_amp_offset(kcontrol);
1720 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1721 uinfo->count = chs == 3 ? 2 : 1;
1722 uinfo->value.integer.min = 0;
1723 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1724 if (!uinfo->value.integer.max) {
1725 printk(KERN_WARNING "hda_codec: "
1726 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1732 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1735 static inline unsigned int
1736 read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1737 int ch, int dir, int idx, unsigned int ofs)
1740 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1741 val &= HDA_AMP_VOLMASK;
1750 update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1751 int ch, int dir, int idx, unsigned int ofs,
1754 unsigned int maxval;
1758 /* ofs = 0: raw max value */
1759 maxval = get_amp_max_value(codec, nid, dir, 0);
1762 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1763 HDA_AMP_VOLMASK, val);
1767 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1769 * The control element is supposed to have the private_value field
1770 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1772 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1773 struct snd_ctl_elem_value *ucontrol)
1775 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1776 hda_nid_t nid = get_amp_nid(kcontrol);
1777 int chs = get_amp_channels(kcontrol);
1778 int dir = get_amp_direction(kcontrol);
1779 int idx = get_amp_index(kcontrol);
1780 unsigned int ofs = get_amp_offset(kcontrol);
1781 long *valp = ucontrol->value.integer.value;
1784 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1786 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1789 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1792 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1794 * The control element is supposed to have the private_value field
1795 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1797 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1798 struct snd_ctl_elem_value *ucontrol)
1800 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1801 hda_nid_t nid = get_amp_nid(kcontrol);
1802 int chs = get_amp_channels(kcontrol);
1803 int dir = get_amp_direction(kcontrol);
1804 int idx = get_amp_index(kcontrol);
1805 unsigned int ofs = get_amp_offset(kcontrol);
1806 long *valp = ucontrol->value.integer.value;
1809 snd_hda_power_up(codec);
1811 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
1815 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
1816 snd_hda_power_down(codec);
1819 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1822 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1824 * The control element is supposed to have the private_value field
1825 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1827 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1828 unsigned int size, unsigned int __user *_tlv)
1830 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1831 hda_nid_t nid = get_amp_nid(kcontrol);
1832 int dir = get_amp_direction(kcontrol);
1833 unsigned int ofs = get_amp_offset(kcontrol);
1834 u32 caps, val1, val2;
1836 if (size < 4 * sizeof(unsigned int))
1838 caps = query_amp_caps(codec, nid, dir);
1839 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1840 val2 = (val2 + 1) * 25;
1841 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
1843 val1 = ((int)val1) * ((int)val2);
1844 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1846 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1848 if (put_user(val1, _tlv + 2))
1850 if (put_user(val2, _tlv + 3))
1854 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
1857 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1858 * @codec: HD-audio codec
1859 * @nid: NID of a reference widget
1860 * @dir: #HDA_INPUT or #HDA_OUTPUT
1861 * @tlv: TLV data to be stored, at least 4 elements
1863 * Set (static) TLV data for a virtual master volume using the AMP caps
1864 * obtained from the reference NID.
1865 * The volume range is recalculated as if the max volume is 0dB.
1867 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1873 caps = query_amp_caps(codec, nid, dir);
1874 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1875 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1876 step = (step + 1) * 25;
1877 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1878 tlv[1] = 2 * sizeof(unsigned int);
1879 tlv[2] = -nums * step;
1882 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
1884 /* find a mixer control element with the given name */
1885 static struct snd_kcontrol *
1886 _snd_hda_find_mixer_ctl(struct hda_codec *codec,
1887 const char *name, int idx)
1889 struct snd_ctl_elem_id id;
1890 memset(&id, 0, sizeof(id));
1891 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1893 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1895 strcpy(id.name, name);
1896 return snd_ctl_find_id(codec->bus->card, &id);
1900 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1901 * @codec: HD-audio codec
1902 * @name: ctl id name string
1904 * Get the control element with the given id string and IFACE_MIXER.
1906 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1909 return _snd_hda_find_mixer_ctl(codec, name, 0);
1911 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
1914 * snd_hda_ctl_add - Add a control element and assign to the codec
1915 * @codec: HD-audio codec
1916 * @nid: corresponding NID (optional)
1917 * @kctl: the control element to assign
1919 * Add the given control element to an array inside the codec instance.
1920 * All control elements belonging to a codec are supposed to be added
1921 * by this function so that a proper clean-up works at the free or
1922 * reconfiguration time.
1924 * If non-zero @nid is passed, the NID is assigned to the control element.
1925 * The assignment is shown in the codec proc file.
1927 * snd_hda_ctl_add() checks the control subdev id field whether
1928 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1929 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1930 * specifies if kctl->private_value is a HDA amplifier value.
1932 int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1933 struct snd_kcontrol *kctl)
1936 unsigned short flags = 0;
1937 struct hda_nid_item *item;
1939 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
1940 flags |= HDA_NID_ITEM_AMP;
1942 nid = get_amp_nid_(kctl->private_value);
1944 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
1945 nid = kctl->id.subdevice & 0xffff;
1946 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
1947 kctl->id.subdevice = 0;
1948 err = snd_ctl_add(codec->bus->card, kctl);
1951 item = snd_array_new(&codec->mixers);
1956 item->flags = flags;
1959 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
1962 * snd_hda_add_nid - Assign a NID to a control element
1963 * @codec: HD-audio codec
1964 * @nid: corresponding NID (optional)
1965 * @kctl: the control element to assign
1966 * @index: index to kctl
1968 * Add the given control element to an array inside the codec instance.
1969 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1970 * NID:KCTL mapping - for example "Capture Source" selector.
1972 int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
1973 unsigned int index, hda_nid_t nid)
1975 struct hda_nid_item *item;
1978 item = snd_array_new(&codec->nids);
1982 item->index = index;
1986 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
1987 kctl->id.name, kctl->id.index, index);
1990 EXPORT_SYMBOL_HDA(snd_hda_add_nid);
1993 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1994 * @codec: HD-audio codec
1996 void snd_hda_ctls_clear(struct hda_codec *codec)
1999 struct hda_nid_item *items = codec->mixers.list;
2000 for (i = 0; i < codec->mixers.used; i++)
2001 snd_ctl_remove(codec->bus->card, items[i].kctl);
2002 snd_array_free(&codec->mixers);
2003 snd_array_free(&codec->nids);
2006 /* pseudo device locking
2007 * toggle card->shutdown to allow/disallow the device access (as a hack)
2009 static int hda_lock_devices(struct snd_card *card)
2011 spin_lock(&card->files_lock);
2012 if (card->shutdown) {
2013 spin_unlock(&card->files_lock);
2017 spin_unlock(&card->files_lock);
2021 static void hda_unlock_devices(struct snd_card *card)
2023 spin_lock(&card->files_lock);
2025 spin_unlock(&card->files_lock);
2029 * snd_hda_codec_reset - Clear all objects assigned to the codec
2030 * @codec: HD-audio codec
2032 * This frees the all PCM and control elements assigned to the codec, and
2033 * clears the caches and restores the pin default configurations.
2035 * When a device is being used, it returns -EBSY. If successfully freed,
2038 int snd_hda_codec_reset(struct hda_codec *codec)
2040 struct snd_card *card = codec->bus->card;
2043 if (hda_lock_devices(card) < 0)
2045 /* check whether the codec isn't used by any mixer or PCM streams */
2046 if (!list_empty(&card->ctl_files)) {
2047 hda_unlock_devices(card);
2050 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2051 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2054 if (cpcm->pcm->streams[0].substream_opened ||
2055 cpcm->pcm->streams[1].substream_opened) {
2056 hda_unlock_devices(card);
2061 /* OK, let it free */
2063 #ifdef CONFIG_SND_HDA_POWER_SAVE
2064 cancel_delayed_work(&codec->power_work);
2065 flush_workqueue(codec->bus->workq);
2067 snd_hda_ctls_clear(codec);
2069 for (i = 0; i < codec->num_pcms; i++) {
2070 if (codec->pcm_info[i].pcm) {
2071 snd_device_free(card, codec->pcm_info[i].pcm);
2072 clear_bit(codec->pcm_info[i].device,
2073 codec->bus->pcm_dev_bits);
2076 if (codec->patch_ops.free)
2077 codec->patch_ops.free(codec);
2078 codec->proc_widget_hook = NULL;
2080 free_hda_cache(&codec->amp_cache);
2081 free_hda_cache(&codec->cmd_cache);
2082 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2083 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
2084 /* free only driver_pins so that init_pins + user_pins are restored */
2085 snd_array_free(&codec->driver_pins);
2086 restore_pincfgs(codec);
2087 codec->num_pcms = 0;
2088 codec->pcm_info = NULL;
2089 codec->preset = NULL;
2090 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2091 codec->slave_dig_outs = NULL;
2092 codec->spdif_status_reset = 0;
2093 module_put(codec->owner);
2094 codec->owner = NULL;
2096 /* allow device access again */
2097 hda_unlock_devices(card);
2102 * snd_hda_add_vmaster - create a virtual master control and add slaves
2103 * @codec: HD-audio codec
2104 * @name: vmaster control name
2105 * @tlv: TLV data (optional)
2106 * @slaves: slave control names (optional)
2108 * Create a virtual master control with the given name. The TLV data
2109 * must be either NULL or a valid data.
2111 * @slaves is a NULL-terminated array of strings, each of which is a
2112 * slave control name. All controls with these names are assigned to
2113 * the new virtual master control.
2115 * This function returns zero if successful or a negative error code.
2117 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
2118 unsigned int *tlv, const char **slaves)
2120 struct snd_kcontrol *kctl;
2124 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
2127 snd_printdd("No slave found for %s\n", name);
2130 kctl = snd_ctl_make_virtual_master(name, tlv);
2133 err = snd_hda_ctl_add(codec, 0, kctl);
2137 for (s = slaves; *s; s++) {
2138 struct snd_kcontrol *sctl;
2141 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
2144 snd_printdd("Cannot find slave %s, "
2148 err = snd_ctl_add_slave(kctl, sctl);
2156 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2159 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2161 * The control element is supposed to have the private_value field
2162 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2164 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2165 struct snd_ctl_elem_info *uinfo)
2167 int chs = get_amp_channels(kcontrol);
2169 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2170 uinfo->count = chs == 3 ? 2 : 1;
2171 uinfo->value.integer.min = 0;
2172 uinfo->value.integer.max = 1;
2175 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
2178 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2180 * The control element is supposed to have the private_value field
2181 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2183 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2184 struct snd_ctl_elem_value *ucontrol)
2186 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2187 hda_nid_t nid = get_amp_nid(kcontrol);
2188 int chs = get_amp_channels(kcontrol);
2189 int dir = get_amp_direction(kcontrol);
2190 int idx = get_amp_index(kcontrol);
2191 long *valp = ucontrol->value.integer.value;
2194 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
2195 HDA_AMP_MUTE) ? 0 : 1;
2197 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
2198 HDA_AMP_MUTE) ? 0 : 1;
2201 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
2204 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2206 * The control element is supposed to have the private_value field
2207 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2209 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2210 struct snd_ctl_elem_value *ucontrol)
2212 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2213 hda_nid_t nid = get_amp_nid(kcontrol);
2214 int chs = get_amp_channels(kcontrol);
2215 int dir = get_amp_direction(kcontrol);
2216 int idx = get_amp_index(kcontrol);
2217 long *valp = ucontrol->value.integer.value;
2220 snd_hda_power_up(codec);
2222 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
2224 *valp ? 0 : HDA_AMP_MUTE);
2228 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
2230 *valp ? 0 : HDA_AMP_MUTE);
2231 hda_call_check_power_status(codec, nid);
2232 snd_hda_power_down(codec);
2235 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
2237 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2239 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2241 * This function calls snd_hda_enable_beep_device(), which behaves differently
2242 * depending on beep_mode option.
2244 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2245 struct snd_ctl_elem_value *ucontrol)
2247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2248 long *valp = ucontrol->value.integer.value;
2250 snd_hda_enable_beep_device(codec, *valp);
2251 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2253 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
2254 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2257 * bound volume controls
2259 * bind multiple volumes (# indices, from 0)
2262 #define AMP_VAL_IDX_SHIFT 19
2263 #define AMP_VAL_IDX_MASK (0x0f<<19)
2266 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2268 * The control element is supposed to have the private_value field
2269 * set up via HDA_BIND_MUTE*() macros.
2271 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2272 struct snd_ctl_elem_value *ucontrol)
2274 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2278 mutex_lock(&codec->control_mutex);
2279 pval = kcontrol->private_value;
2280 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2281 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2282 kcontrol->private_value = pval;
2283 mutex_unlock(&codec->control_mutex);
2286 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
2289 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2291 * The control element is supposed to have the private_value field
2292 * set up via HDA_BIND_MUTE*() macros.
2294 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2295 struct snd_ctl_elem_value *ucontrol)
2297 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2299 int i, indices, err = 0, change = 0;
2301 mutex_lock(&codec->control_mutex);
2302 pval = kcontrol->private_value;
2303 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2304 for (i = 0; i < indices; i++) {
2305 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2306 (i << AMP_VAL_IDX_SHIFT);
2307 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2312 kcontrol->private_value = pval;
2313 mutex_unlock(&codec->control_mutex);
2314 return err < 0 ? err : change;
2316 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
2319 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2321 * The control element is supposed to have the private_value field
2322 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2324 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2325 struct snd_ctl_elem_info *uinfo)
2327 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2328 struct hda_bind_ctls *c;
2331 mutex_lock(&codec->control_mutex);
2332 c = (struct hda_bind_ctls *)kcontrol->private_value;
2333 kcontrol->private_value = *c->values;
2334 err = c->ops->info(kcontrol, uinfo);
2335 kcontrol->private_value = (long)c;
2336 mutex_unlock(&codec->control_mutex);
2339 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
2342 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2344 * The control element is supposed to have the private_value field
2345 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2347 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2348 struct snd_ctl_elem_value *ucontrol)
2350 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2351 struct hda_bind_ctls *c;
2354 mutex_lock(&codec->control_mutex);
2355 c = (struct hda_bind_ctls *)kcontrol->private_value;
2356 kcontrol->private_value = *c->values;
2357 err = c->ops->get(kcontrol, ucontrol);
2358 kcontrol->private_value = (long)c;
2359 mutex_unlock(&codec->control_mutex);
2362 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
2365 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2367 * The control element is supposed to have the private_value field
2368 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2370 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2371 struct snd_ctl_elem_value *ucontrol)
2373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2374 struct hda_bind_ctls *c;
2375 unsigned long *vals;
2376 int err = 0, change = 0;
2378 mutex_lock(&codec->control_mutex);
2379 c = (struct hda_bind_ctls *)kcontrol->private_value;
2380 for (vals = c->values; *vals; vals++) {
2381 kcontrol->private_value = *vals;
2382 err = c->ops->put(kcontrol, ucontrol);
2387 kcontrol->private_value = (long)c;
2388 mutex_unlock(&codec->control_mutex);
2389 return err < 0 ? err : change;
2391 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
2394 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2396 * The control element is supposed to have the private_value field
2397 * set up via HDA_BIND_VOL() macro.
2399 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2400 unsigned int size, unsigned int __user *tlv)
2402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2403 struct hda_bind_ctls *c;
2406 mutex_lock(&codec->control_mutex);
2407 c = (struct hda_bind_ctls *)kcontrol->private_value;
2408 kcontrol->private_value = *c->values;
2409 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2410 kcontrol->private_value = (long)c;
2411 mutex_unlock(&codec->control_mutex);
2414 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
2416 struct hda_ctl_ops snd_hda_bind_vol = {
2417 .info = snd_hda_mixer_amp_volume_info,
2418 .get = snd_hda_mixer_amp_volume_get,
2419 .put = snd_hda_mixer_amp_volume_put,
2420 .tlv = snd_hda_mixer_amp_tlv
2422 EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
2424 struct hda_ctl_ops snd_hda_bind_sw = {
2425 .info = snd_hda_mixer_amp_switch_info,
2426 .get = snd_hda_mixer_amp_switch_get,
2427 .put = snd_hda_mixer_amp_switch_put,
2428 .tlv = snd_hda_mixer_amp_tlv
2430 EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
2433 * SPDIF out controls
2436 static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2437 struct snd_ctl_elem_info *uinfo)
2439 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2444 static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2445 struct snd_ctl_elem_value *ucontrol)
2447 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2448 IEC958_AES0_NONAUDIO |
2449 IEC958_AES0_CON_EMPHASIS_5015 |
2450 IEC958_AES0_CON_NOT_COPYRIGHT;
2451 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2452 IEC958_AES1_CON_ORIGINAL;
2456 static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2457 struct snd_ctl_elem_value *ucontrol)
2459 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2460 IEC958_AES0_NONAUDIO |
2461 IEC958_AES0_PRO_EMPHASIS_5015;
2465 static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2466 struct snd_ctl_elem_value *ucontrol)
2468 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2470 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2471 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2472 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2473 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2478 /* convert from SPDIF status bits to HDA SPDIF bits
2479 * bit 0 (DigEn) is always set zero (to be filled later)
2481 static unsigned short convert_from_spdif_status(unsigned int sbits)
2483 unsigned short val = 0;
2485 if (sbits & IEC958_AES0_PROFESSIONAL)
2486 val |= AC_DIG1_PROFESSIONAL;
2487 if (sbits & IEC958_AES0_NONAUDIO)
2488 val |= AC_DIG1_NONAUDIO;
2489 if (sbits & IEC958_AES0_PROFESSIONAL) {
2490 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2491 IEC958_AES0_PRO_EMPHASIS_5015)
2492 val |= AC_DIG1_EMPHASIS;
2494 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2495 IEC958_AES0_CON_EMPHASIS_5015)
2496 val |= AC_DIG1_EMPHASIS;
2497 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2498 val |= AC_DIG1_COPYRIGHT;
2499 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
2500 val |= AC_DIG1_LEVEL;
2501 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2506 /* convert to SPDIF status bits from HDA SPDIF bits
2508 static unsigned int convert_to_spdif_status(unsigned short val)
2510 unsigned int sbits = 0;
2512 if (val & AC_DIG1_NONAUDIO)
2513 sbits |= IEC958_AES0_NONAUDIO;
2514 if (val & AC_DIG1_PROFESSIONAL)
2515 sbits |= IEC958_AES0_PROFESSIONAL;
2516 if (sbits & IEC958_AES0_PROFESSIONAL) {
2517 if (sbits & AC_DIG1_EMPHASIS)
2518 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2520 if (val & AC_DIG1_EMPHASIS)
2521 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
2522 if (!(val & AC_DIG1_COPYRIGHT))
2523 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
2524 if (val & AC_DIG1_LEVEL)
2525 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2526 sbits |= val & (0x7f << 8);
2531 /* set digital convert verbs both for the given NID and its slaves */
2532 static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2537 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2538 d = codec->slave_dig_outs;
2542 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2545 static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2549 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2551 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2554 static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2555 struct snd_ctl_elem_value *ucontrol)
2557 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2558 hda_nid_t nid = kcontrol->private_value;
2562 mutex_lock(&codec->spdif_mutex);
2563 codec->spdif_status = ucontrol->value.iec958.status[0] |
2564 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2565 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2566 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2567 val = convert_from_spdif_status(codec->spdif_status);
2568 val |= codec->spdif_ctls & 1;
2569 change = codec->spdif_ctls != val;
2570 codec->spdif_ctls = val;
2573 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
2575 mutex_unlock(&codec->spdif_mutex);
2579 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2581 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2582 struct snd_ctl_elem_value *ucontrol)
2584 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2586 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
2590 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2591 struct snd_ctl_elem_value *ucontrol)
2593 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2594 hda_nid_t nid = kcontrol->private_value;
2598 mutex_lock(&codec->spdif_mutex);
2599 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
2600 if (ucontrol->value.integer.value[0])
2601 val |= AC_DIG1_ENABLE;
2602 change = codec->spdif_ctls != val;
2604 codec->spdif_ctls = val;
2605 set_dig_out_convert(codec, nid, val & 0xff, -1);
2606 /* unmute amp switch (if any) */
2607 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2608 (val & AC_DIG1_ENABLE))
2609 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2612 mutex_unlock(&codec->spdif_mutex);
2616 static struct snd_kcontrol_new dig_mixes[] = {
2618 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2619 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2620 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
2621 .info = snd_hda_spdif_mask_info,
2622 .get = snd_hda_spdif_cmask_get,
2625 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2626 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2627 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
2628 .info = snd_hda_spdif_mask_info,
2629 .get = snd_hda_spdif_pmask_get,
2632 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2633 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
2634 .info = snd_hda_spdif_mask_info,
2635 .get = snd_hda_spdif_default_get,
2636 .put = snd_hda_spdif_default_put,
2639 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2640 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
2641 .info = snd_hda_spdif_out_switch_info,
2642 .get = snd_hda_spdif_out_switch_get,
2643 .put = snd_hda_spdif_out_switch_put,
2648 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2651 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2652 * @codec: the HDA codec
2653 * @nid: audio out widget NID
2655 * Creates controls related with the SPDIF output.
2656 * Called from each patch supporting the SPDIF out.
2658 * Returns 0 if successful, or a negative error code.
2660 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
2663 struct snd_kcontrol *kctl;
2664 struct snd_kcontrol_new *dig_mix;
2667 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2668 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2672 if (idx >= SPDIF_MAX_IDX) {
2673 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2676 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2677 kctl = snd_ctl_new1(dig_mix, codec);
2680 kctl->id.index = idx;
2681 kctl->private_value = nid;
2682 err = snd_hda_ctl_add(codec, nid, kctl);
2687 snd_hda_codec_read(codec, nid, 0,
2688 AC_VERB_GET_DIGI_CONVERT_1, 0);
2689 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2692 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
2695 * SPDIF sharing with analog output
2697 static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2698 struct snd_ctl_elem_value *ucontrol)
2700 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2701 ucontrol->value.integer.value[0] = mout->share_spdif;
2705 static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2706 struct snd_ctl_elem_value *ucontrol)
2708 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2709 mout->share_spdif = !!ucontrol->value.integer.value[0];
2713 static struct snd_kcontrol_new spdif_share_sw = {
2714 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2715 .name = "IEC958 Default PCM Playback Switch",
2716 .info = snd_ctl_boolean_mono_info,
2717 .get = spdif_share_sw_get,
2718 .put = spdif_share_sw_put,
2722 * snd_hda_create_spdif_share_sw - create Default PCM switch
2723 * @codec: the HDA codec
2724 * @mout: multi-out instance
2726 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2727 struct hda_multi_out *mout)
2729 if (!mout->dig_out_nid)
2731 /* ATTENTION: here mout is passed as private_data, instead of codec */
2732 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2733 snd_ctl_new1(&spdif_share_sw, mout));
2735 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
2741 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2743 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2744 struct snd_ctl_elem_value *ucontrol)
2746 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2748 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2752 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2753 struct snd_ctl_elem_value *ucontrol)
2755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2756 hda_nid_t nid = kcontrol->private_value;
2757 unsigned int val = !!ucontrol->value.integer.value[0];
2760 mutex_lock(&codec->spdif_mutex);
2761 change = codec->spdif_in_enable != val;
2763 codec->spdif_in_enable = val;
2764 snd_hda_codec_write_cache(codec, nid, 0,
2765 AC_VERB_SET_DIGI_CONVERT_1, val);
2767 mutex_unlock(&codec->spdif_mutex);
2771 static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2772 struct snd_ctl_elem_value *ucontrol)
2774 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2775 hda_nid_t nid = kcontrol->private_value;
2779 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
2780 sbits = convert_to_spdif_status(val);
2781 ucontrol->value.iec958.status[0] = sbits;
2782 ucontrol->value.iec958.status[1] = sbits >> 8;
2783 ucontrol->value.iec958.status[2] = sbits >> 16;
2784 ucontrol->value.iec958.status[3] = sbits >> 24;
2788 static struct snd_kcontrol_new dig_in_ctls[] = {
2790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2791 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
2792 .info = snd_hda_spdif_in_switch_info,
2793 .get = snd_hda_spdif_in_switch_get,
2794 .put = snd_hda_spdif_in_switch_put,
2797 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2798 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2799 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
2800 .info = snd_hda_spdif_mask_info,
2801 .get = snd_hda_spdif_in_status_get,
2807 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2808 * @codec: the HDA codec
2809 * @nid: audio in widget NID
2811 * Creates controls related with the SPDIF input.
2812 * Called from each patch supporting the SPDIF in.
2814 * Returns 0 if successful, or a negative error code.
2816 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
2819 struct snd_kcontrol *kctl;
2820 struct snd_kcontrol_new *dig_mix;
2823 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2824 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2828 if (idx >= SPDIF_MAX_IDX) {
2829 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2832 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2833 kctl = snd_ctl_new1(dig_mix, codec);
2836 kctl->private_value = nid;
2837 err = snd_hda_ctl_add(codec, nid, kctl);
2841 codec->spdif_in_enable =
2842 snd_hda_codec_read(codec, nid, 0,
2843 AC_VERB_GET_DIGI_CONVERT_1, 0) &
2847 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
2849 #ifdef SND_HDA_NEEDS_RESUME
2854 /* build a 32bit cache key with the widget id and the command parameter */
2855 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2856 #define get_cmd_cache_nid(key) ((key) & 0xff)
2857 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2860 * snd_hda_codec_write_cache - send a single command with caching
2861 * @codec: the HDA codec
2862 * @nid: NID to send the command
2863 * @direct: direct flag
2864 * @verb: the verb to send
2865 * @parm: the parameter for the verb
2867 * Send a single command without waiting for response.
2869 * Returns 0 if successful, or a negative error code.
2871 int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2872 int direct, unsigned int verb, unsigned int parm)
2874 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2875 struct hda_cache_head *c;
2880 /* parm may contain the verb stuff for get/set amp */
2881 verb = verb | (parm >> 8);
2883 key = build_cmd_cache_key(nid, verb);
2884 mutex_lock(&codec->bus->cmd_mutex);
2885 c = get_alloc_hash(&codec->cmd_cache, key);
2888 mutex_unlock(&codec->bus->cmd_mutex);
2891 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
2894 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
2895 * @codec: the HDA codec
2896 * @nid: NID to send the command
2897 * @direct: direct flag
2898 * @verb: the verb to send
2899 * @parm: the parameter for the verb
2901 * This function works like snd_hda_codec_write_cache(), but it doesn't send
2902 * command if the parameter is already identical with the cached value.
2903 * If not, it sends the command and refreshes the cache.
2905 * Returns 0 if successful, or a negative error code.
2907 int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
2908 int direct, unsigned int verb, unsigned int parm)
2910 struct hda_cache_head *c;
2913 /* parm may contain the verb stuff for get/set amp */
2914 verb = verb | (parm >> 8);
2916 key = build_cmd_cache_key(nid, verb);
2917 mutex_lock(&codec->bus->cmd_mutex);
2918 c = get_hash(&codec->cmd_cache, key);
2919 if (c && c->val == parm) {
2920 mutex_unlock(&codec->bus->cmd_mutex);
2923 mutex_unlock(&codec->bus->cmd_mutex);
2924 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
2926 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
2929 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2930 * @codec: HD-audio codec
2932 * Execute all verbs recorded in the command caches to resume.
2934 void snd_hda_codec_resume_cache(struct hda_codec *codec)
2936 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
2939 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
2940 u32 key = buffer->key;
2943 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2944 get_cmd_cache_cmd(key), buffer->val);
2947 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
2950 * snd_hda_sequence_write_cache - sequence writes with caching
2951 * @codec: the HDA codec
2952 * @seq: VERB array to send
2954 * Send the commands sequentially from the given array.
2955 * Thte commands are recorded on cache for power-save and resume.
2956 * The array must be terminated with NID=0.
2958 void snd_hda_sequence_write_cache(struct hda_codec *codec,
2959 const struct hda_verb *seq)
2961 for (; seq->nid; seq++)
2962 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2965 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
2966 #endif /* SND_HDA_NEEDS_RESUME */
2969 * set power state of the codec
2971 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2972 unsigned int power_state)
2977 /* this delay seems necessary to avoid click noise at power-down */
2978 if (power_state == AC_PWRST_D3)
2980 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2982 /* partial workaround for "azx_get_response timeout" */
2983 if (power_state == AC_PWRST_D0 &&
2984 (codec->vendor_id & 0xffff0000) == 0x14f10000)
2987 nid = codec->start_nid;
2988 for (i = 0; i < codec->num_nodes; i++, nid++) {
2989 unsigned int wcaps = get_wcaps(codec, nid);
2990 if (wcaps & AC_WCAP_POWER) {
2991 unsigned int wid_type = get_wcaps_type(wcaps);
2992 if (power_state == AC_PWRST_D3 &&
2993 wid_type == AC_WID_PIN) {
2994 unsigned int pincap;
2996 * don't power down the widget if it controls
2997 * eapd and EAPD_BTLENABLE is set.
2999 pincap = snd_hda_query_pin_caps(codec, nid);
3000 if (pincap & AC_PINCAP_EAPD) {
3001 int eapd = snd_hda_codec_read(codec,
3003 AC_VERB_GET_EAPD_BTLENABLE, 0);
3009 snd_hda_codec_write(codec, nid, 0,
3010 AC_VERB_SET_POWER_STATE,
3015 if (power_state == AC_PWRST_D0) {
3016 unsigned long end_time;
3018 /* wait until the codec reachs to D0 */
3019 end_time = jiffies + msecs_to_jiffies(500);
3021 state = snd_hda_codec_read(codec, fg, 0,
3022 AC_VERB_GET_POWER_STATE, 0);
3023 if (state == power_state)
3026 } while (time_after_eq(end_time, jiffies));
3030 #ifdef CONFIG_SND_HDA_HWDEP
3031 /* execute additional init verbs */
3032 static void hda_exec_init_verbs(struct hda_codec *codec)
3034 if (codec->init_verbs.list)
3035 snd_hda_sequence_write(codec, codec->init_verbs.list);
3038 static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3041 #ifdef SND_HDA_NEEDS_RESUME
3043 * call suspend and power-down; used both from PM and power-save
3045 static void hda_call_codec_suspend(struct hda_codec *codec)
3047 if (codec->patch_ops.suspend)
3048 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
3049 hda_cleanup_all_streams(codec);
3050 hda_set_power_state(codec,
3051 codec->afg ? codec->afg : codec->mfg,
3053 #ifdef CONFIG_SND_HDA_POWER_SAVE
3054 snd_hda_update_power_acct(codec);
3055 cancel_delayed_work(&codec->power_work);
3056 codec->power_on = 0;
3057 codec->power_transition = 0;
3058 codec->power_jiffies = jiffies;
3063 * kick up codec; used both from PM and power-save
3065 static void hda_call_codec_resume(struct hda_codec *codec)
3067 hda_set_power_state(codec,
3068 codec->afg ? codec->afg : codec->mfg,
3070 restore_pincfgs(codec); /* restore all current pin configs */
3071 restore_shutup_pins(codec);
3072 hda_exec_init_verbs(codec);
3073 if (codec->patch_ops.resume)
3074 codec->patch_ops.resume(codec);
3076 if (codec->patch_ops.init)
3077 codec->patch_ops.init(codec);
3078 snd_hda_codec_resume_amp(codec);
3079 snd_hda_codec_resume_cache(codec);
3082 #endif /* SND_HDA_NEEDS_RESUME */
3086 * snd_hda_build_controls - build mixer controls
3089 * Creates mixer controls for each codec included in the bus.
3091 * Returns 0 if successful, otherwise a negative error code.
3093 int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
3095 struct hda_codec *codec;
3097 list_for_each_entry(codec, &bus->codec_list, list) {
3098 int err = snd_hda_codec_build_controls(codec);
3100 printk(KERN_ERR "hda_codec: cannot build controls "
3101 "for #%d (error %d)\n", codec->addr, err);
3102 err = snd_hda_codec_reset(codec);
3105 "hda_codec: cannot revert codec\n");
3112 EXPORT_SYMBOL_HDA(snd_hda_build_controls);
3114 int snd_hda_codec_build_controls(struct hda_codec *codec)
3117 hda_exec_init_verbs(codec);
3118 /* continue to initialize... */
3119 if (codec->patch_ops.init)
3120 err = codec->patch_ops.init(codec);
3121 if (!err && codec->patch_ops.build_controls)
3122 err = codec->patch_ops.build_controls(codec);
3131 struct hda_rate_tbl {
3133 unsigned int alsa_bits;
3134 unsigned int hda_fmt;
3137 /* rate = base * mult / div */
3138 #define HDA_RATE(base, mult, div) \
3139 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3140 (((div) - 1) << AC_FMT_DIV_SHIFT))
3142 static struct hda_rate_tbl rate_bits[] = {
3143 /* rate in Hz, ALSA rate bitmask, HDA format value */
3145 /* autodetected value used in snd_hda_query_supported_pcm */
3146 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3147 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3148 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3149 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3150 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3151 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3152 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3153 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3154 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3155 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3156 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
3157 #define AC_PAR_PCM_RATE_BITS 11
3158 /* up to bits 10, 384kHZ isn't supported properly */
3160 /* not autodetected value */
3161 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
3163 { 0 } /* terminator */
3167 * snd_hda_calc_stream_format - calculate format bitset
3168 * @rate: the sample rate
3169 * @channels: the number of channels
3170 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3171 * @maxbps: the max. bps
3173 * Calculate the format bitset from the given rate, channels and th PCM format.
3175 * Return zero if invalid.
3177 unsigned int snd_hda_calc_stream_format(unsigned int rate,
3178 unsigned int channels,
3179 unsigned int format,
3180 unsigned int maxbps,
3181 unsigned short spdif_ctls)
3184 unsigned int val = 0;
3186 for (i = 0; rate_bits[i].hz; i++)
3187 if (rate_bits[i].hz == rate) {
3188 val = rate_bits[i].hda_fmt;
3191 if (!rate_bits[i].hz) {
3192 snd_printdd("invalid rate %d\n", rate);
3196 if (channels == 0 || channels > 8) {
3197 snd_printdd("invalid channels %d\n", channels);
3200 val |= channels - 1;
3202 switch (snd_pcm_format_width(format)) {
3204 val |= AC_FMT_BITS_8;
3207 val |= AC_FMT_BITS_16;
3212 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
3213 val |= AC_FMT_BITS_32;
3214 else if (maxbps >= 24)
3215 val |= AC_FMT_BITS_24;
3217 val |= AC_FMT_BITS_20;
3220 snd_printdd("invalid format width %d\n",
3221 snd_pcm_format_width(format));
3225 if (spdif_ctls & AC_DIG1_NONAUDIO)
3226 val |= AC_FMT_TYPE_NON_PCM;
3230 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
3232 static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3234 unsigned int val = 0;
3235 if (nid != codec->afg &&
3236 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3237 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3238 if (!val || val == -1)
3239 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3240 if (!val || val == -1)
3245 static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3247 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3251 static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3253 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3254 if (!streams || streams == -1)
3255 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3256 if (!streams || streams == -1)
3261 static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3263 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3268 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3269 * @codec: the HDA codec
3270 * @nid: NID to query
3271 * @ratesp: the pointer to store the detected rate bitflags
3272 * @formatsp: the pointer to store the detected formats
3273 * @bpsp: the pointer to store the detected format widths
3275 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3276 * or @bsps argument is ignored.
3278 * Returns 0 if successful, otherwise a negative error code.
3280 static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
3281 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3283 unsigned int i, val, wcaps;
3285 wcaps = get_wcaps(codec, nid);
3286 val = query_pcm_param(codec, nid);
3290 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
3292 rates |= rate_bits[i].alsa_bits;
3295 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3296 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3298 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3304 if (formatsp || bpsp) {
3306 unsigned int streams, bps;
3308 streams = query_stream_param(codec, nid);
3313 if (streams & AC_SUPFMT_PCM) {
3314 if (val & AC_SUPPCM_BITS_8) {
3315 formats |= SNDRV_PCM_FMTBIT_U8;
3318 if (val & AC_SUPPCM_BITS_16) {
3319 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3322 if (wcaps & AC_WCAP_DIGITAL) {
3323 if (val & AC_SUPPCM_BITS_32)
3324 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3325 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3326 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3327 if (val & AC_SUPPCM_BITS_24)
3329 else if (val & AC_SUPPCM_BITS_20)
3331 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3332 AC_SUPPCM_BITS_32)) {
3333 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3334 if (val & AC_SUPPCM_BITS_32)
3336 else if (val & AC_SUPPCM_BITS_24)
3338 else if (val & AC_SUPPCM_BITS_20)
3342 if (streams & AC_SUPFMT_FLOAT32) {
3343 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
3347 if (streams == AC_SUPFMT_AC3) {
3348 /* should be exclusive */
3349 /* temporary hack: we have still no proper support
3350 * for the direct AC3 stream...
3352 formats |= SNDRV_PCM_FMTBIT_U8;
3356 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3357 "(nid=0x%x, val=0x%x, ovrd=%i, "
3360 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3365 *formatsp = formats;
3374 * snd_hda_is_supported_format - Check the validity of the format
3375 * @codec: HD-audio codec
3376 * @nid: NID to check
3377 * @format: the HD-audio format value to check
3379 * Check whether the given node supports the format value.
3381 * Returns 1 if supported, 0 if not.
3383 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3384 unsigned int format)
3387 unsigned int val = 0, rate, stream;
3389 val = query_pcm_param(codec, nid);
3393 rate = format & 0xff00;
3394 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
3395 if (rate_bits[i].hda_fmt == rate) {
3400 if (i >= AC_PAR_PCM_RATE_BITS)
3403 stream = query_stream_param(codec, nid);
3407 if (stream & AC_SUPFMT_PCM) {
3408 switch (format & 0xf0) {
3410 if (!(val & AC_SUPPCM_BITS_8))
3414 if (!(val & AC_SUPPCM_BITS_16))
3418 if (!(val & AC_SUPPCM_BITS_20))
3422 if (!(val & AC_SUPPCM_BITS_24))
3426 if (!(val & AC_SUPPCM_BITS_32))
3433 /* FIXME: check for float32 and AC3? */
3438 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
3443 static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3444 struct hda_codec *codec,
3445 struct snd_pcm_substream *substream)
3450 static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3451 struct hda_codec *codec,
3452 unsigned int stream_tag,
3453 unsigned int format,
3454 struct snd_pcm_substream *substream)
3456 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3460 static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3461 struct hda_codec *codec,
3462 struct snd_pcm_substream *substream)
3464 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3468 static int set_pcm_default_values(struct hda_codec *codec,
3469 struct hda_pcm_stream *info)
3473 /* query support PCM information from the given NID */
3474 if (info->nid && (!info->rates || !info->formats)) {
3475 err = snd_hda_query_supported_pcm(codec, info->nid,
3476 info->rates ? NULL : &info->rates,
3477 info->formats ? NULL : &info->formats,
3478 info->maxbps ? NULL : &info->maxbps);
3482 if (info->ops.open == NULL)
3483 info->ops.open = hda_pcm_default_open_close;
3484 if (info->ops.close == NULL)
3485 info->ops.close = hda_pcm_default_open_close;
3486 if (info->ops.prepare == NULL) {
3487 if (snd_BUG_ON(!info->nid))
3489 info->ops.prepare = hda_pcm_default_prepare;
3491 if (info->ops.cleanup == NULL) {
3492 if (snd_BUG_ON(!info->nid))
3494 info->ops.cleanup = hda_pcm_default_cleanup;
3500 * codec prepare/cleanup entries
3502 int snd_hda_codec_prepare(struct hda_codec *codec,
3503 struct hda_pcm_stream *hinfo,
3504 unsigned int stream,
3505 unsigned int format,
3506 struct snd_pcm_substream *substream)
3509 mutex_lock(&codec->bus->prepare_mutex);
3510 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3512 purify_inactive_streams(codec);
3513 mutex_unlock(&codec->bus->prepare_mutex);
3516 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3518 void snd_hda_codec_cleanup(struct hda_codec *codec,
3519 struct hda_pcm_stream *hinfo,
3520 struct snd_pcm_substream *substream)
3522 mutex_lock(&codec->bus->prepare_mutex);
3523 hinfo->ops.cleanup(hinfo, codec, substream);
3524 mutex_unlock(&codec->bus->prepare_mutex);
3526 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3529 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3530 "Audio", "SPDIF", "HDMI", "Modem"
3534 * get the empty PCM device number to assign
3536 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3538 static int get_empty_pcm_device(struct hda_bus *bus, int type)
3540 /* audio device indices; not linear to keep compatibility */
3541 static int audio_idx[HDA_PCM_NTYPES][5] = {
3542 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3543 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
3544 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
3545 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
3549 if (type >= HDA_PCM_NTYPES) {
3550 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3554 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3555 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3556 return audio_idx[type][i];
3558 snd_printk(KERN_WARNING "Too many %s devices\n",
3559 snd_hda_pcm_type_name[type]);
3564 * attach a new PCM stream
3566 static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
3568 struct hda_bus *bus = codec->bus;
3569 struct hda_pcm_stream *info;
3572 if (snd_BUG_ON(!pcm->name))
3574 for (stream = 0; stream < 2; stream++) {
3575 info = &pcm->stream[stream];
3576 if (info->substreams) {
3577 err = set_pcm_default_values(codec, info);
3582 return bus->ops.attach_pcm(bus, codec, pcm);
3585 /* assign all PCMs of the given codec */
3586 int snd_hda_codec_build_pcms(struct hda_codec *codec)
3591 if (!codec->num_pcms) {
3592 if (!codec->patch_ops.build_pcms)
3594 err = codec->patch_ops.build_pcms(codec);
3596 printk(KERN_ERR "hda_codec: cannot build PCMs"
3597 "for #%d (error %d)\n", codec->addr, err);
3598 err = snd_hda_codec_reset(codec);
3601 "hda_codec: cannot revert codec\n");
3606 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3607 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3610 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
3611 continue; /* no substreams assigned */
3614 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3616 continue; /* no fatal error */
3618 err = snd_hda_attach_pcm(codec, cpcm);
3620 printk(KERN_ERR "hda_codec: cannot attach "
3621 "PCM stream %d for codec #%d\n",
3623 continue; /* no fatal error */
3631 * snd_hda_build_pcms - build PCM information
3634 * Create PCM information for each codec included in the bus.
3636 * The build_pcms codec patch is requested to set up codec->num_pcms and
3637 * codec->pcm_info properly. The array is referred by the top-level driver
3638 * to create its PCM instances.
3639 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3642 * At least, substreams, channels_min and channels_max must be filled for
3643 * each stream. substreams = 0 indicates that the stream doesn't exist.
3644 * When rates and/or formats are zero, the supported values are queried
3645 * from the given nid. The nid is used also by the default ops.prepare
3646 * and ops.cleanup callbacks.
3648 * The driver needs to call ops.open in its open callback. Similarly,
3649 * ops.close is supposed to be called in the close callback.
3650 * ops.prepare should be called in the prepare or hw_params callback
3651 * with the proper parameters for set up.
3652 * ops.cleanup should be called in hw_free for clean up of streams.
3654 * This function returns 0 if successfull, or a negative error code.
3656 int __devinit snd_hda_build_pcms(struct hda_bus *bus)
3658 struct hda_codec *codec;
3660 list_for_each_entry(codec, &bus->codec_list, list) {
3661 int err = snd_hda_codec_build_pcms(codec);
3667 EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
3670 * snd_hda_check_board_config - compare the current codec with the config table
3671 * @codec: the HDA codec
3672 * @num_configs: number of config enums
3673 * @models: array of model name strings
3674 * @tbl: configuration table, terminated by null entries
3676 * Compares the modelname or PCI subsystem id of the current codec with the
3677 * given configuration table. If a matching entry is found, returns its
3678 * config value (supposed to be 0 or positive).
3680 * If no entries are matching, the function returns a negative value.
3682 int snd_hda_check_board_config(struct hda_codec *codec,
3683 int num_configs, const char **models,
3684 const struct snd_pci_quirk *tbl)
3686 if (codec->modelname && models) {
3688 for (i = 0; i < num_configs; i++) {
3690 !strcmp(codec->modelname, models[i])) {
3691 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3692 "selected\n", models[i]);
3698 if (!codec->bus->pci || !tbl)
3701 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3704 if (tbl->value >= 0 && tbl->value < num_configs) {
3705 #ifdef CONFIG_SND_DEBUG_VERBOSE
3707 const char *model = NULL;
3709 model = models[tbl->value];
3711 sprintf(tmp, "#%d", tbl->value);
3714 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3715 "for config %x:%x (%s)\n",
3716 model, tbl->subvendor, tbl->subdevice,
3717 (tbl->name ? tbl->name : "Unknown device"));
3723 EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
3726 * snd_hda_check_board_codec_sid_config - compare the current codec
3727 subsystem ID with the
3730 This is important for Gateway notebooks with SB450 HDA Audio
3731 where the vendor ID of the PCI device is:
3732 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3733 and the vendor/subvendor are found only at the codec.
3735 * @codec: the HDA codec
3736 * @num_configs: number of config enums
3737 * @models: array of model name strings
3738 * @tbl: configuration table, terminated by null entries
3740 * Compares the modelname or PCI subsystem id of the current codec with the
3741 * given configuration table. If a matching entry is found, returns its
3742 * config value (supposed to be 0 or positive).
3744 * If no entries are matching, the function returns a negative value.
3746 int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3747 int num_configs, const char **models,
3748 const struct snd_pci_quirk *tbl)
3750 const struct snd_pci_quirk *q;
3752 /* Search for codec ID */
3753 for (q = tbl; q->subvendor; q++) {
3754 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3756 if (vendorid == codec->subsystem_id)
3765 if (tbl->value >= 0 && tbl->value < num_configs) {
3766 #ifdef CONFIG_SND_DEBUG_VERBOSE
3768 const char *model = NULL;
3770 model = models[tbl->value];
3772 sprintf(tmp, "#%d", tbl->value);
3775 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3776 "for config %x:%x (%s)\n",
3777 model, tbl->subvendor, tbl->subdevice,
3778 (tbl->name ? tbl->name : "Unknown device"));
3784 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3787 * snd_hda_add_new_ctls - create controls from the array
3788 * @codec: the HDA codec
3789 * @knew: the array of struct snd_kcontrol_new
3791 * This helper function creates and add new controls in the given array.
3792 * The array must be terminated with an empty entry as terminator.
3794 * Returns 0 if successful, or a negative error code.
3796 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
3800 for (; knew->name; knew++) {
3801 struct snd_kcontrol *kctl;
3802 if (knew->iface == -1) /* skip this codec private value */
3804 kctl = snd_ctl_new1(knew, codec);
3807 err = snd_hda_ctl_add(codec, 0, kctl);
3811 kctl = snd_ctl_new1(knew, codec);
3814 kctl->id.device = codec->addr;
3815 err = snd_hda_ctl_add(codec, 0, kctl);
3822 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
3824 #ifdef CONFIG_SND_HDA_POWER_SAVE
3825 static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3826 unsigned int power_state);
3828 static void hda_power_work(struct work_struct *work)
3830 struct hda_codec *codec =
3831 container_of(work, struct hda_codec, power_work.work);
3832 struct hda_bus *bus = codec->bus;
3834 if (!codec->power_on || codec->power_count) {
3835 codec->power_transition = 0;
3839 hda_call_codec_suspend(codec);
3840 if (bus->ops.pm_notify)
3841 bus->ops.pm_notify(bus);
3844 static void hda_keep_power_on(struct hda_codec *codec)
3846 codec->power_count++;
3847 codec->power_on = 1;
3848 codec->power_jiffies = jiffies;
3851 /* update the power on/off account with the current jiffies */
3852 void snd_hda_update_power_acct(struct hda_codec *codec)
3854 unsigned long delta = jiffies - codec->power_jiffies;
3855 if (codec->power_on)
3856 codec->power_on_acct += delta;
3858 codec->power_off_acct += delta;
3859 codec->power_jiffies += delta;
3863 * snd_hda_power_up - Power-up the codec
3864 * @codec: HD-audio codec
3866 * Increment the power-up counter and power up the hardware really when
3867 * not turned on yet.
3869 void snd_hda_power_up(struct hda_codec *codec)
3871 struct hda_bus *bus = codec->bus;
3873 codec->power_count++;
3874 if (codec->power_on || codec->power_transition)
3877 snd_hda_update_power_acct(codec);
3878 codec->power_on = 1;
3879 codec->power_jiffies = jiffies;
3880 if (bus->ops.pm_notify)
3881 bus->ops.pm_notify(bus);
3882 hda_call_codec_resume(codec);
3883 cancel_delayed_work(&codec->power_work);
3884 codec->power_transition = 0;
3886 EXPORT_SYMBOL_HDA(snd_hda_power_up);
3888 #define power_save(codec) \
3889 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3892 * snd_hda_power_down - Power-down the codec
3893 * @codec: HD-audio codec
3895 * Decrement the power-up counter and schedules the power-off work if
3896 * the counter rearches to zero.
3898 void snd_hda_power_down(struct hda_codec *codec)
3900 --codec->power_count;
3901 if (!codec->power_on || codec->power_count || codec->power_transition)
3903 if (power_save(codec)) {
3904 codec->power_transition = 1; /* avoid reentrance */
3905 queue_delayed_work(codec->bus->workq, &codec->power_work,
3906 msecs_to_jiffies(power_save(codec) * 1000));
3909 EXPORT_SYMBOL_HDA(snd_hda_power_down);
3912 * snd_hda_check_amp_list_power - Check the amp list and update the power
3913 * @codec: HD-audio codec
3914 * @check: the object containing an AMP list and the status
3915 * @nid: NID to check / update
3917 * Check whether the given NID is in the amp list. If it's in the list,
3918 * check the current AMP status, and update the the power-status according
3919 * to the mute status.
3921 * This function is supposed to be set or called from the check_power_status
3924 int snd_hda_check_amp_list_power(struct hda_codec *codec,
3925 struct hda_loopback_check *check,
3928 struct hda_amp_list *p;
3931 if (!check->amplist)
3933 for (p = check->amplist; p->nid; p++) {
3938 return 0; /* nothing changed */
3940 for (p = check->amplist; p->nid; p++) {
3941 for (ch = 0; ch < 2; ch++) {
3942 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3944 if (!(v & HDA_AMP_MUTE) && v > 0) {
3945 if (!check->power_on) {
3946 check->power_on = 1;
3947 snd_hda_power_up(codec);
3953 if (check->power_on) {
3954 check->power_on = 0;
3955 snd_hda_power_down(codec);
3959 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
3963 * Channel mode helper
3967 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3969 int snd_hda_ch_mode_info(struct hda_codec *codec,
3970 struct snd_ctl_elem_info *uinfo,
3971 const struct hda_channel_mode *chmode,
3974 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3976 uinfo->value.enumerated.items = num_chmodes;
3977 if (uinfo->value.enumerated.item >= num_chmodes)
3978 uinfo->value.enumerated.item = num_chmodes - 1;
3979 sprintf(uinfo->value.enumerated.name, "%dch",
3980 chmode[uinfo->value.enumerated.item].channels);
3983 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
3986 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3988 int snd_hda_ch_mode_get(struct hda_codec *codec,
3989 struct snd_ctl_elem_value *ucontrol,
3990 const struct hda_channel_mode *chmode,
3996 for (i = 0; i < num_chmodes; i++) {
3997 if (max_channels == chmode[i].channels) {
3998 ucontrol->value.enumerated.item[0] = i;
4004 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
4007 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4009 int snd_hda_ch_mode_put(struct hda_codec *codec,
4010 struct snd_ctl_elem_value *ucontrol,
4011 const struct hda_channel_mode *chmode,
4017 mode = ucontrol->value.enumerated.item[0];
4018 if (mode >= num_chmodes)
4020 if (*max_channelsp == chmode[mode].channels)
4022 /* change the current channel setting */
4023 *max_channelsp = chmode[mode].channels;
4024 if (chmode[mode].sequence)
4025 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
4028 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
4035 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4037 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4038 struct snd_ctl_elem_info *uinfo)
4042 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4044 uinfo->value.enumerated.items = imux->num_items;
4045 if (!imux->num_items)
4047 index = uinfo->value.enumerated.item;
4048 if (index >= imux->num_items)
4049 index = imux->num_items - 1;
4050 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4053 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
4056 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4058 int snd_hda_input_mux_put(struct hda_codec *codec,
4059 const struct hda_input_mux *imux,
4060 struct snd_ctl_elem_value *ucontrol,
4062 unsigned int *cur_val)
4066 if (!imux->num_items)
4068 idx = ucontrol->value.enumerated.item[0];
4069 if (idx >= imux->num_items)
4070 idx = imux->num_items - 1;
4071 if (*cur_val == idx)
4073 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4074 imux->items[idx].index);
4078 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
4082 * Multi-channel / digital-out PCM helper functions
4085 /* setup SPDIF output stream */
4086 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4087 unsigned int stream_tag, unsigned int format)
4089 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4090 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4091 set_dig_out_convert(codec, nid,
4092 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
4094 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
4095 if (codec->slave_dig_outs) {
4097 for (d = codec->slave_dig_outs; *d; d++)
4098 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4101 /* turn on again (if needed) */
4102 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
4103 set_dig_out_convert(codec, nid,
4104 codec->spdif_ctls & 0xff, -1);
4107 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4109 snd_hda_codec_cleanup_stream(codec, nid);
4110 if (codec->slave_dig_outs) {
4112 for (d = codec->slave_dig_outs; *d; d++)
4113 snd_hda_codec_cleanup_stream(codec, *d);
4118 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4119 * @bus: HD-audio bus
4121 void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4123 struct hda_codec *codec;
4127 list_for_each_entry(codec, &bus->codec_list, list) {
4128 #ifdef CONFIG_SND_HDA_POWER_SAVE
4129 if (!codec->power_on)
4132 if (codec->patch_ops.reboot_notify)
4133 codec->patch_ops.reboot_notify(codec);
4136 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
4139 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4141 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4142 struct hda_multi_out *mout)
4144 mutex_lock(&codec->spdif_mutex);
4145 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4146 /* already opened as analog dup; reset it once */
4147 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4148 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
4149 mutex_unlock(&codec->spdif_mutex);
4152 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
4155 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4157 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4158 struct hda_multi_out *mout,
4159 unsigned int stream_tag,
4160 unsigned int format,
4161 struct snd_pcm_substream *substream)
4163 mutex_lock(&codec->spdif_mutex);
4164 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4165 mutex_unlock(&codec->spdif_mutex);
4168 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
4171 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4173 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4174 struct hda_multi_out *mout)
4176 mutex_lock(&codec->spdif_mutex);
4177 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4178 mutex_unlock(&codec->spdif_mutex);
4181 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4184 * snd_hda_multi_out_dig_close - release the digital out stream
4186 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4187 struct hda_multi_out *mout)
4189 mutex_lock(&codec->spdif_mutex);
4190 mout->dig_out_used = 0;
4191 mutex_unlock(&codec->spdif_mutex);
4194 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
4197 * snd_hda_multi_out_analog_open - open analog outputs
4199 * Open analog outputs and set up the hw-constraints.
4200 * If the digital outputs can be opened as slave, open the digital
4203 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4204 struct hda_multi_out *mout,
4205 struct snd_pcm_substream *substream,
4206 struct hda_pcm_stream *hinfo)
4208 struct snd_pcm_runtime *runtime = substream->runtime;
4209 runtime->hw.channels_max = mout->max_channels;
4210 if (mout->dig_out_nid) {
4211 if (!mout->analog_rates) {
4212 mout->analog_rates = hinfo->rates;
4213 mout->analog_formats = hinfo->formats;
4214 mout->analog_maxbps = hinfo->maxbps;
4216 runtime->hw.rates = mout->analog_rates;
4217 runtime->hw.formats = mout->analog_formats;
4218 hinfo->maxbps = mout->analog_maxbps;
4220 if (!mout->spdif_rates) {
4221 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4223 &mout->spdif_formats,
4224 &mout->spdif_maxbps);
4226 mutex_lock(&codec->spdif_mutex);
4227 if (mout->share_spdif) {
4228 if ((runtime->hw.rates & mout->spdif_rates) &&
4229 (runtime->hw.formats & mout->spdif_formats)) {
4230 runtime->hw.rates &= mout->spdif_rates;
4231 runtime->hw.formats &= mout->spdif_formats;
4232 if (mout->spdif_maxbps < hinfo->maxbps)
4233 hinfo->maxbps = mout->spdif_maxbps;
4235 mout->share_spdif = 0;
4236 /* FIXME: need notify? */
4239 mutex_unlock(&codec->spdif_mutex);
4241 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4242 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4244 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
4247 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4249 * Set up the i/o for analog out.
4250 * When the digital out is available, copy the front out to digital out, too.
4252 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4253 struct hda_multi_out *mout,
4254 unsigned int stream_tag,
4255 unsigned int format,
4256 struct snd_pcm_substream *substream)
4258 hda_nid_t *nids = mout->dac_nids;
4259 int chs = substream->runtime->channels;
4262 mutex_lock(&codec->spdif_mutex);
4263 if (mout->dig_out_nid && mout->share_spdif &&
4264 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
4266 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4268 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
4269 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
4270 setup_dig_out_stream(codec, mout->dig_out_nid,
4271 stream_tag, format);
4273 mout->dig_out_used = 0;
4274 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4277 mutex_unlock(&codec->spdif_mutex);
4280 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4282 if (!mout->no_share_stream &&
4283 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
4284 /* headphone out will just decode front left/right (stereo) */
4285 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4287 /* extra outputs copied from front */
4288 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4289 if (!mout->no_share_stream && mout->extra_out_nid[i])
4290 snd_hda_codec_setup_stream(codec,
4291 mout->extra_out_nid[i],
4292 stream_tag, 0, format);
4295 for (i = 1; i < mout->num_dacs; i++) {
4296 if (chs >= (i + 1) * 2) /* independent out */
4297 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4299 else if (!mout->no_share_stream) /* copy front */
4300 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4305 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
4308 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4310 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4311 struct hda_multi_out *mout)
4313 hda_nid_t *nids = mout->dac_nids;
4316 for (i = 0; i < mout->num_dacs; i++)
4317 snd_hda_codec_cleanup_stream(codec, nids[i]);
4319 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
4320 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4321 if (mout->extra_out_nid[i])
4322 snd_hda_codec_cleanup_stream(codec,
4323 mout->extra_out_nid[i]);
4324 mutex_lock(&codec->spdif_mutex);
4325 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
4326 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4327 mout->dig_out_used = 0;
4329 mutex_unlock(&codec->spdif_mutex);
4332 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
4335 * Helper for automatic pin configuration
4338 static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
4340 for (; *list; list++)
4348 * Sort an associated group of pins according to their sequence numbers.
4350 static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
4357 for (i = 0; i < num_pins; i++) {
4358 for (j = i + 1; j < num_pins; j++) {
4359 if (sequences[i] > sequences[j]) {
4361 sequences[i] = sequences[j];
4372 /* add the found input-pin to the cfg->inputs[] table */
4373 static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4376 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4377 cfg->inputs[cfg->num_inputs].pin = nid;
4378 cfg->inputs[cfg->num_inputs].type = type;
4383 /* sort inputs in the order of AUTO_PIN_* type */
4384 static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4388 for (i = 0; i < cfg->num_inputs; i++) {
4389 for (j = i + 1; j < cfg->num_inputs; j++) {
4390 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4391 struct auto_pin_cfg_item tmp;
4392 tmp = cfg->inputs[i];
4393 cfg->inputs[i] = cfg->inputs[j];
4394 cfg->inputs[j] = tmp;
4401 * Parse all pin widgets and store the useful pin nids to cfg
4403 * The number of line-outs or any primary output is stored in line_outs,
4404 * and the corresponding output pins are assigned to line_out_pins[],
4405 * in the order of front, rear, CLFE, side, ...
4407 * If more extra outputs (speaker and headphone) are found, the pins are
4408 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4409 * is detected, one of speaker of HP pins is assigned as the primary
4410 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4411 * if any analog output exists.
4413 * The analog input pins are assigned to inputs array.
4414 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4417 int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4418 struct auto_pin_cfg *cfg,
4419 hda_nid_t *ignore_nids)
4421 hda_nid_t nid, end_nid;
4422 short seq, assoc_line_out, assoc_speaker;
4423 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4424 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
4425 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
4428 memset(cfg, 0, sizeof(*cfg));
4430 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4431 memset(sequences_speaker, 0, sizeof(sequences_speaker));
4432 memset(sequences_hp, 0, sizeof(sequences_hp));
4433 assoc_line_out = assoc_speaker = 0;
4435 end_nid = codec->start_nid + codec->num_nodes;
4436 for (nid = codec->start_nid; nid < end_nid; nid++) {
4437 unsigned int wid_caps = get_wcaps(codec, nid);
4438 unsigned int wid_type = get_wcaps_type(wid_caps);
4439 unsigned int def_conf;
4442 /* read all default configuration for pin complex */
4443 if (wid_type != AC_WID_PIN)
4445 /* ignore the given nids (e.g. pc-beep returns error) */
4446 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4449 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4450 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4452 loc = get_defcfg_location(def_conf);
4453 switch (get_defcfg_device(def_conf)) {
4454 case AC_JACK_LINE_OUT:
4455 seq = get_defcfg_sequence(def_conf);
4456 assoc = get_defcfg_association(def_conf);
4458 if (!(wid_caps & AC_WCAP_STEREO))
4459 if (!cfg->mono_out_pin)
4460 cfg->mono_out_pin = nid;
4463 if (!assoc_line_out)
4464 assoc_line_out = assoc;
4465 else if (assoc_line_out != assoc)
4467 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4469 cfg->line_out_pins[cfg->line_outs] = nid;
4470 sequences_line_out[cfg->line_outs] = seq;
4473 case AC_JACK_SPEAKER:
4474 seq = get_defcfg_sequence(def_conf);
4475 assoc = get_defcfg_association(def_conf);
4479 assoc_speaker = assoc;
4480 else if (assoc_speaker != assoc)
4482 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4484 cfg->speaker_pins[cfg->speaker_outs] = nid;
4485 sequences_speaker[cfg->speaker_outs] = seq;
4486 cfg->speaker_outs++;
4488 case AC_JACK_HP_OUT:
4489 seq = get_defcfg_sequence(def_conf);
4490 assoc = get_defcfg_association(def_conf);
4491 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4493 cfg->hp_pins[cfg->hp_outs] = nid;
4494 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
4497 case AC_JACK_MIC_IN:
4498 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
4500 case AC_JACK_LINE_IN:
4501 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
4504 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
4507 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
4509 case AC_JACK_SPDIF_OUT:
4510 case AC_JACK_DIG_OTHER_OUT:
4511 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4513 cfg->dig_out_pins[cfg->dig_outs] = nid;
4514 cfg->dig_out_type[cfg->dig_outs] =
4515 (loc == AC_JACK_LOC_HDMI) ?
4516 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4519 case AC_JACK_SPDIF_IN:
4520 case AC_JACK_DIG_OTHER_IN:
4521 cfg->dig_in_pin = nid;
4522 if (loc == AC_JACK_LOC_HDMI)
4523 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4525 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4531 * If no line-out is defined but multiple HPs are found,
4532 * some of them might be the real line-outs.
4534 if (!cfg->line_outs && cfg->hp_outs > 1) {
4536 while (i < cfg->hp_outs) {
4537 /* The real HPs should have the sequence 0x0f */
4538 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4542 /* Move it to the line-out table */
4543 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4544 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4547 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4548 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4549 memmove(sequences_hp + i, sequences_hp + i + 1,
4550 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4552 memset(cfg->hp_pins + cfg->hp_outs, 0,
4553 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
4556 /* sort by sequence */
4557 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4559 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4561 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4565 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4566 * as a primary output
4568 if (!cfg->line_outs) {
4569 if (cfg->speaker_outs) {
4570 cfg->line_outs = cfg->speaker_outs;
4571 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4572 sizeof(cfg->speaker_pins));
4573 cfg->speaker_outs = 0;
4574 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4575 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4576 } else if (cfg->hp_outs) {
4577 cfg->line_outs = cfg->hp_outs;
4578 memcpy(cfg->line_out_pins, cfg->hp_pins,
4579 sizeof(cfg->hp_pins));
4581 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4582 cfg->line_out_type = AUTO_PIN_HP_OUT;
4586 /* Reorder the surround channels
4587 * ALSA sequence is front/surr/clfe/side
4589 * 4-ch: front/surr => OK as it is
4590 * 6-ch: front/clfe/surr
4591 * 8-ch: front/clfe/rear/side|fc
4593 switch (cfg->line_outs) {
4596 nid = cfg->line_out_pins[1];
4597 cfg->line_out_pins[1] = cfg->line_out_pins[2];
4598 cfg->line_out_pins[2] = nid;
4602 sort_autocfg_input_pins(cfg);
4605 * debug prints of the parsed results
4607 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4608 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4609 cfg->line_out_pins[2], cfg->line_out_pins[3],
4610 cfg->line_out_pins[4]);
4611 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4612 cfg->speaker_outs, cfg->speaker_pins[0],
4613 cfg->speaker_pins[1], cfg->speaker_pins[2],
4614 cfg->speaker_pins[3], cfg->speaker_pins[4]);
4615 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4616 cfg->hp_outs, cfg->hp_pins[0],
4617 cfg->hp_pins[1], cfg->hp_pins[2],
4618 cfg->hp_pins[3], cfg->hp_pins[4]);
4619 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
4621 snd_printd(" dig-out=0x%x/0x%x\n",
4622 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
4623 snd_printd(" inputs:");
4624 for (i = 0; i < cfg->num_inputs; i++) {
4625 snd_printdd(" %s=0x%x",
4626 hda_get_autocfg_input_label(codec, cfg, i),
4627 cfg->inputs[i].pin);
4630 if (cfg->dig_in_pin)
4631 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
4635 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
4637 int snd_hda_get_input_pin_attr(unsigned int def_conf)
4639 unsigned int loc = get_defcfg_location(def_conf);
4640 unsigned int conn = get_defcfg_connect(def_conf);
4641 if (conn == AC_JACK_PORT_NONE)
4642 return INPUT_PIN_ATTR_UNUSED;
4643 /* Windows may claim the internal mic to be BOTH, too */
4644 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
4645 return INPUT_PIN_ATTR_INT;
4646 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
4647 return INPUT_PIN_ATTR_INT;
4648 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
4649 return INPUT_PIN_ATTR_DOCK;
4650 if (loc == AC_JACK_LOC_REAR)
4651 return INPUT_PIN_ATTR_REAR;
4652 if (loc == AC_JACK_LOC_FRONT)
4653 return INPUT_PIN_ATTR_FRONT;
4654 return INPUT_PIN_ATTR_NORMAL;
4656 EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
4659 * hda_get_input_pin_label - Give a label for the given input pin
4661 * When check_location is true, the function checks the pin location
4662 * for mic and line-in pins, and set an appropriate prefix like "Front",
4663 * "Rear", "Internal".
4666 const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
4669 unsigned int def_conf;
4670 static const char *mic_names[] = {
4671 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4675 def_conf = snd_hda_codec_get_pincfg(codec, pin);
4677 switch (get_defcfg_device(def_conf)) {
4678 case AC_JACK_MIC_IN:
4679 if (!check_location)
4681 attr = snd_hda_get_input_pin_attr(def_conf);
4684 return mic_names[attr - 1];
4685 case AC_JACK_LINE_IN:
4686 if (!check_location)
4688 attr = snd_hda_get_input_pin_attr(def_conf);
4691 if (attr == INPUT_PIN_ATTR_DOCK)
4698 case AC_JACK_SPDIF_IN:
4700 case AC_JACK_DIG_OTHER_IN:
4701 return "Digital In";
4706 EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
4708 /* Check whether the location prefix needs to be added to the label.
4709 * If all mic-jacks are in the same location (e.g. rear panel), we don't
4710 * have to put "Front" prefix to each label. In such a case, returns false.
4712 static int check_mic_location_need(struct hda_codec *codec,
4713 const struct auto_pin_cfg *cfg,
4719 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
4720 attr = snd_hda_get_input_pin_attr(defc);
4721 /* for internal or docking mics, we need locations */
4722 if (attr <= INPUT_PIN_ATTR_NORMAL)
4726 for (i = 0; i < cfg->num_inputs; i++) {
4727 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
4728 attr2 = snd_hda_get_input_pin_attr(defc);
4729 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
4730 if (attr && attr != attr2)
4731 return 1; /* different locations found */
4739 * hda_get_autocfg_input_label - Get a label for the given input
4741 * Get a label for the given input pin defined by the autocfg item.
4742 * Unlike hda_get_input_pin_label(), this function checks all inputs
4743 * defined in autocfg and avoids the redundant mic/line prefix as much as
4746 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
4747 const struct auto_pin_cfg *cfg,
4750 int type = cfg->inputs[input].type;
4751 int has_multiple_pins = 0;
4753 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
4754 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
4755 has_multiple_pins = 1;
4756 if (has_multiple_pins && type == AUTO_PIN_MIC)
4757 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
4758 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
4761 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
4764 * snd_hda_add_imux_item - Add an item to input_mux
4766 * When the same label is used already in the existing items, the number
4767 * suffix is appended to the label. This label index number is stored
4768 * to type_idx when non-NULL pointer is given.
4770 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
4771 int index, int *type_idx)
4773 int i, label_idx = 0;
4774 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
4775 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
4778 for (i = 0; i < imux->num_items; i++) {
4779 if (!strncmp(label, imux->items[i].label, strlen(label)))
4783 *type_idx = label_idx;
4785 snprintf(imux->items[imux->num_items].label,
4786 sizeof(imux->items[imux->num_items].label),
4787 "%s %d", label, label_idx);
4789 strlcpy(imux->items[imux->num_items].label, label,
4790 sizeof(imux->items[imux->num_items].label));
4791 imux->items[imux->num_items].index = index;
4795 EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
4804 * snd_hda_suspend - suspend the codecs
4807 * Returns 0 if successful.
4809 int snd_hda_suspend(struct hda_bus *bus)
4811 struct hda_codec *codec;
4813 list_for_each_entry(codec, &bus->codec_list, list) {
4814 #ifdef CONFIG_SND_HDA_POWER_SAVE
4815 if (!codec->power_on)
4818 hda_call_codec_suspend(codec);
4822 EXPORT_SYMBOL_HDA(snd_hda_suspend);
4825 * snd_hda_resume - resume the codecs
4828 * Returns 0 if successful.
4830 * This fucntion is defined only when POWER_SAVE isn't set.
4831 * In the power-save mode, the codec is resumed dynamically.
4833 int snd_hda_resume(struct hda_bus *bus)
4835 struct hda_codec *codec;
4837 list_for_each_entry(codec, &bus->codec_list, list) {
4838 if (snd_hda_codec_needs_resume(codec))
4839 hda_call_codec_resume(codec);
4843 EXPORT_SYMBOL_HDA(snd_hda_resume);
4844 #endif /* CONFIG_PM */
4851 * snd_array_new - get a new element from the given array
4852 * @array: the array object
4854 * Get a new element from the given array. If it exceeds the
4855 * pre-allocated array size, re-allocate the array.
4857 * Returns NULL if allocation failed.
4859 void *snd_array_new(struct snd_array *array)
4861 if (array->used >= array->alloced) {
4862 int num = array->alloced + array->alloc_align;
4864 if (snd_BUG_ON(num >= 4096))
4866 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
4870 memcpy(nlist, array->list,
4871 array->elem_size * array->alloced);
4874 array->list = nlist;
4875 array->alloced = num;
4877 return snd_array_elem(array, array->used++);
4879 EXPORT_SYMBOL_HDA(snd_array_new);
4882 * snd_array_free - free the given array elements
4883 * @array: the array object
4885 void snd_array_free(struct snd_array *array)
4892 EXPORT_SYMBOL_HDA(snd_array_free);
4895 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4896 * @pcm: PCM caps bits
4897 * @buf: the string buffer to write
4898 * @buflen: the max buffer length
4900 * used by hda_proc.c and hda_eld.c
4902 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4904 static unsigned int rates[] = {
4905 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4906 96000, 176400, 192000, 384000
4910 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4912 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4914 buf[j] = '\0'; /* necessary when j == 0 */
4916 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
4919 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4920 * @pcm: PCM caps bits
4921 * @buf: the string buffer to write
4922 * @buflen: the max buffer length
4924 * used by hda_proc.c and hda_eld.c
4926 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4928 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4931 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4932 if (pcm & (AC_SUPPCM_BITS_8 << i))
4933 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4935 buf[j] = '\0'; /* necessary when j == 0 */
4937 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
4939 MODULE_DESCRIPTION("HDA codec core");
4940 MODULE_LICENSE("GPL");