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
) {
400 "Too many connections\n");
403 conn_list
[conns
++] = n
;
406 if (conns
>= max_conns
) {
407 snd_printk(KERN_ERR
"Too many connections\n");
410 conn_list
[conns
++] = val
;
416 EXPORT_SYMBOL_HDA(snd_hda_get_connections
);
420 * snd_hda_queue_unsol_event - add an unsolicited event to queue
422 * @res: unsolicited event (lower 32bit of RIRB entry)
423 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
425 * Adds the given event to the queue. The events are processed in
426 * the workqueue asynchronously. Call this function in the interrupt
427 * hanlder when RIRB receives an unsolicited event.
429 * Returns 0 if successful, or a negative error code.
431 int snd_hda_queue_unsol_event(struct hda_bus
*bus
, u32 res
, u32 res_ex
)
433 struct hda_bus_unsolicited
*unsol
;
440 wp
= (unsol
->wp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
444 unsol
->queue
[wp
] = res
;
445 unsol
->queue
[wp
+ 1] = res_ex
;
447 queue_work(bus
->workq
, &unsol
->work
);
451 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event
);
454 * process queued unsolicited events
456 static void process_unsol_events(struct work_struct
*work
)
458 struct hda_bus_unsolicited
*unsol
=
459 container_of(work
, struct hda_bus_unsolicited
, work
);
460 struct hda_bus
*bus
= unsol
->bus
;
461 struct hda_codec
*codec
;
462 unsigned int rp
, caddr
, res
;
464 while (unsol
->rp
!= unsol
->wp
) {
465 rp
= (unsol
->rp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
468 res
= unsol
->queue
[rp
];
469 caddr
= unsol
->queue
[rp
+ 1];
470 if (!(caddr
& (1 << 4))) /* no unsolicited event? */
472 codec
= bus
->caddr_tbl
[caddr
& 0x0f];
473 if (codec
&& codec
->patch_ops
.unsol_event
)
474 codec
->patch_ops
.unsol_event(codec
, res
);
479 * initialize unsolicited queue
481 static int init_unsol_queue(struct hda_bus
*bus
)
483 struct hda_bus_unsolicited
*unsol
;
485 if (bus
->unsol
) /* already initialized */
488 unsol
= kzalloc(sizeof(*unsol
), GFP_KERNEL
);
490 snd_printk(KERN_ERR
"hda_codec: "
491 "can't allocate unsolicited queue\n");
494 INIT_WORK(&unsol
->work
, process_unsol_events
);
503 static void snd_hda_codec_free(struct hda_codec
*codec
);
505 static int snd_hda_bus_free(struct hda_bus
*bus
)
507 struct hda_codec
*codec
, *n
;
512 flush_workqueue(bus
->workq
);
515 list_for_each_entry_safe(codec
, n
, &bus
->codec_list
, list
) {
516 snd_hda_codec_free(codec
);
518 if (bus
->ops
.private_free
)
519 bus
->ops
.private_free(bus
);
521 destroy_workqueue(bus
->workq
);
526 static int snd_hda_bus_dev_free(struct snd_device
*device
)
528 struct hda_bus
*bus
= device
->device_data
;
530 return snd_hda_bus_free(bus
);
533 #ifdef CONFIG_SND_HDA_HWDEP
534 static int snd_hda_bus_dev_register(struct snd_device
*device
)
536 struct hda_bus
*bus
= device
->device_data
;
537 struct hda_codec
*codec
;
538 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
539 snd_hda_hwdep_add_sysfs(codec
);
540 snd_hda_hwdep_add_power_sysfs(codec
);
545 #define snd_hda_bus_dev_register NULL
549 * snd_hda_bus_new - create a HDA bus
550 * @card: the card entry
551 * @temp: the template for hda_bus information
552 * @busp: the pointer to store the created bus instance
554 * Returns 0 if successful, or a negative error code.
556 int /*__devinit*/ snd_hda_bus_new(struct snd_card
*card
,
557 const struct hda_bus_template
*temp
,
558 struct hda_bus
**busp
)
562 static struct snd_device_ops dev_ops
= {
563 .dev_register
= snd_hda_bus_dev_register
,
564 .dev_free
= snd_hda_bus_dev_free
,
567 if (snd_BUG_ON(!temp
))
569 if (snd_BUG_ON(!temp
->ops
.command
|| !temp
->ops
.get_response
))
575 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
577 snd_printk(KERN_ERR
"can't allocate struct hda_bus\n");
582 bus
->private_data
= temp
->private_data
;
583 bus
->pci
= temp
->pci
;
584 bus
->modelname
= temp
->modelname
;
585 bus
->power_save
= temp
->power_save
;
586 bus
->ops
= temp
->ops
;
588 mutex_init(&bus
->cmd_mutex
);
589 INIT_LIST_HEAD(&bus
->codec_list
);
591 snprintf(bus
->workq_name
, sizeof(bus
->workq_name
),
592 "hd-audio%d", card
->number
);
593 bus
->workq
= create_singlethread_workqueue(bus
->workq_name
);
595 snd_printk(KERN_ERR
"cannot create workqueue %s\n",
601 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
603 snd_hda_bus_free(bus
);
610 EXPORT_SYMBOL_HDA(snd_hda_bus_new
);
612 #ifdef CONFIG_SND_HDA_GENERIC
613 #define is_generic_config(codec) \
614 (codec->modelname && !strcmp(codec->modelname, "generic"))
616 #define is_generic_config(codec) 0
620 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
622 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
626 * find a matching codec preset
628 static const struct hda_codec_preset
*
629 find_codec_preset(struct hda_codec
*codec
)
631 struct hda_codec_preset_list
*tbl
;
632 const struct hda_codec_preset
*preset
;
633 int mod_requested
= 0;
635 if (is_generic_config(codec
))
636 return NULL
; /* use the generic parser */
639 mutex_lock(&preset_mutex
);
640 list_for_each_entry(tbl
, &hda_preset_tables
, list
) {
641 if (!try_module_get(tbl
->owner
)) {
642 snd_printk(KERN_ERR
"hda_codec: cannot module_get\n");
645 for (preset
= tbl
->preset
; preset
->id
; preset
++) {
646 u32 mask
= preset
->mask
;
647 if (preset
->afg
&& preset
->afg
!= codec
->afg
)
649 if (preset
->mfg
&& preset
->mfg
!= codec
->mfg
)
653 if (preset
->id
== (codec
->vendor_id
& mask
) &&
655 preset
->rev
== codec
->revision_id
)) {
656 mutex_unlock(&preset_mutex
);
657 codec
->owner
= tbl
->owner
;
661 module_put(tbl
->owner
);
663 mutex_unlock(&preset_mutex
);
665 if (mod_requested
< HDA_MODREQ_MAX_COUNT
) {
668 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%08x",
671 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%04x*",
672 (codec
->vendor_id
>> 16) & 0xffff);
673 request_module(name
);
681 * get_codec_name - store the codec name
683 static int get_codec_name(struct hda_codec
*codec
)
685 const struct hda_vendor_id
*c
;
686 const char *vendor
= NULL
;
687 u16 vendor_id
= codec
->vendor_id
>> 16;
690 if (codec
->vendor_name
)
693 for (c
= hda_vendor_ids
; c
->id
; c
++) {
694 if (c
->id
== vendor_id
) {
700 sprintf(tmp
, "Generic %04x", vendor_id
);
703 codec
->vendor_name
= kstrdup(vendor
, GFP_KERNEL
);
704 if (!codec
->vendor_name
)
708 if (codec
->chip_name
)
711 if (codec
->preset
&& codec
->preset
->name
)
712 codec
->chip_name
= kstrdup(codec
->preset
->name
, GFP_KERNEL
);
714 sprintf(tmp
, "ID %x", codec
->vendor_id
& 0xffff);
715 codec
->chip_name
= kstrdup(tmp
, GFP_KERNEL
);
717 if (!codec
->chip_name
)
723 * look for an AFG and MFG nodes
725 static void /*__devinit*/ setup_fg_nodes(struct hda_codec
*codec
)
727 int i
, total_nodes
, function_id
;
730 total_nodes
= snd_hda_get_sub_nodes(codec
, AC_NODE_ROOT
, &nid
);
731 for (i
= 0; i
< total_nodes
; i
++, nid
++) {
732 function_id
= snd_hda_param_read(codec
, nid
,
733 AC_PAR_FUNCTION_TYPE
) & 0xff;
734 switch (function_id
) {
735 case AC_GRP_AUDIO_FUNCTION
:
737 codec
->function_id
= function_id
;
739 case AC_GRP_MODEM_FUNCTION
:
741 codec
->function_id
= function_id
;
750 * read widget caps for each widget and store in cache
752 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
757 codec
->num_nodes
= snd_hda_get_sub_nodes(codec
, fg_node
,
759 codec
->wcaps
= kmalloc(codec
->num_nodes
* 4, GFP_KERNEL
);
762 nid
= codec
->start_nid
;
763 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++)
764 codec
->wcaps
[i
] = snd_hda_param_read(codec
, nid
,
765 AC_PAR_AUDIO_WIDGET_CAP
);
769 /* read all pin default configurations and save codec->init_pins */
770 static int read_pin_defaults(struct hda_codec
*codec
)
773 hda_nid_t nid
= codec
->start_nid
;
775 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
776 struct hda_pincfg
*pin
;
777 unsigned int wcaps
= get_wcaps(codec
, nid
);
778 unsigned int wid_type
= get_wcaps_type(wcaps
);
779 if (wid_type
!= AC_WID_PIN
)
781 pin
= snd_array_new(&codec
->init_pins
);
785 pin
->cfg
= snd_hda_codec_read(codec
, nid
, 0,
786 AC_VERB_GET_CONFIG_DEFAULT
, 0);
787 pin
->ctrl
= snd_hda_codec_read(codec
, nid
, 0,
788 AC_VERB_GET_PIN_WIDGET_CONTROL
,
794 /* look up the given pin config list and return the item matching with NID */
795 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
796 struct snd_array
*array
,
800 for (i
= 0; i
< array
->used
; i
++) {
801 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
808 /* write a config value for the given NID */
809 static void set_pincfg(struct hda_codec
*codec
, hda_nid_t nid
,
813 for (i
= 0; i
< 4; i
++) {
814 snd_hda_codec_write(codec
, nid
, 0,
815 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
+ i
,
821 /* set the current pin config value for the given NID.
822 * the value is cached, and read via snd_hda_codec_get_pincfg()
824 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
825 hda_nid_t nid
, unsigned int cfg
)
827 struct hda_pincfg
*pin
;
830 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_PIN
)
833 oldcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
834 pin
= look_up_pincfg(codec
, list
, nid
);
836 pin
= snd_array_new(list
);
843 /* change only when needed; e.g. if the pincfg is already present
844 * in user_pins[], don't write it
846 cfg
= snd_hda_codec_get_pincfg(codec
, nid
);
848 set_pincfg(codec
, nid
, cfg
);
853 * snd_hda_codec_set_pincfg - Override a pin default configuration
854 * @codec: the HDA codec
855 * @nid: NID to set the pin config
856 * @cfg: the pin default config value
858 * Override a pin default configuration value in the cache.
859 * This value can be read by snd_hda_codec_get_pincfg() in a higher
860 * priority than the real hardware value.
862 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
863 hda_nid_t nid
, unsigned int cfg
)
865 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
867 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg
);
870 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
871 * @codec: the HDA codec
872 * @nid: NID to get the pin config
874 * Get the current pin config value of the given pin NID.
875 * If the pincfg value is cached or overridden via sysfs or driver,
876 * returns the cached value.
878 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
880 struct hda_pincfg
*pin
;
882 #ifdef CONFIG_SND_HDA_HWDEP
883 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
887 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
890 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
895 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg
);
897 /* restore all current pin configs */
898 static void restore_pincfgs(struct hda_codec
*codec
)
901 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
902 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
903 set_pincfg(codec
, pin
->nid
,
904 snd_hda_codec_get_pincfg(codec
, pin
->nid
));
909 * snd_hda_shutup_pins - Shut up all pins
910 * @codec: the HDA codec
912 * Clear all pin controls to shup up before suspend for avoiding click noise.
913 * The controls aren't cached so that they can be resumed properly.
915 void snd_hda_shutup_pins(struct hda_codec
*codec
)
918 /* don't shut up pins when unloading the driver; otherwise it breaks
919 * the default pin setup at the next load of the driver
921 if (codec
->bus
->shutdown
)
923 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
924 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
925 /* use read here for syncing after issuing each verb */
926 snd_hda_codec_read(codec
, pin
->nid
, 0,
927 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
929 codec
->pins_shutup
= 1;
931 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins
);
933 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
934 static void restore_shutup_pins(struct hda_codec
*codec
)
937 if (!codec
->pins_shutup
)
939 if (codec
->bus
->shutdown
)
941 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
942 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
943 snd_hda_codec_write(codec
, pin
->nid
, 0,
944 AC_VERB_SET_PIN_WIDGET_CONTROL
,
947 codec
->pins_shutup
= 0;
950 static void init_hda_cache(struct hda_cache_rec
*cache
,
951 unsigned int record_size
);
952 static void free_hda_cache(struct hda_cache_rec
*cache
);
954 /* restore the initial pin cfgs and release all pincfg lists */
955 static void restore_init_pincfgs(struct hda_codec
*codec
)
957 /* first free driver_pins and user_pins, then call restore_pincfg
958 * so that only the values in init_pins are restored
960 snd_array_free(&codec
->driver_pins
);
961 #ifdef CONFIG_SND_HDA_HWDEP
962 snd_array_free(&codec
->user_pins
);
964 restore_pincfgs(codec
);
965 snd_array_free(&codec
->init_pins
);
971 static void snd_hda_codec_free(struct hda_codec
*codec
)
975 restore_init_pincfgs(codec
);
976 #ifdef CONFIG_SND_HDA_POWER_SAVE
977 cancel_delayed_work(&codec
->power_work
);
978 flush_workqueue(codec
->bus
->workq
);
980 list_del(&codec
->list
);
981 snd_array_free(&codec
->mixers
);
982 snd_array_free(&codec
->nids
);
983 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
984 if (codec
->patch_ops
.free
)
985 codec
->patch_ops
.free(codec
);
986 module_put(codec
->owner
);
987 free_hda_cache(&codec
->amp_cache
);
988 free_hda_cache(&codec
->cmd_cache
);
989 kfree(codec
->vendor_name
);
990 kfree(codec
->chip_name
);
991 kfree(codec
->modelname
);
996 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
997 unsigned int power_state
);
1000 * snd_hda_codec_new - create a HDA codec
1001 * @bus: the bus to assign
1002 * @codec_addr: the codec address
1003 * @codecp: the pointer to store the generated codec
1005 * Returns 0 if successful, or a negative error code.
1007 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
,
1008 unsigned int codec_addr
,
1009 struct hda_codec
**codecp
)
1011 struct hda_codec
*codec
;
1015 if (snd_BUG_ON(!bus
))
1017 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
1020 if (bus
->caddr_tbl
[codec_addr
]) {
1021 snd_printk(KERN_ERR
"hda_codec: "
1022 "address 0x%x is already occupied\n", codec_addr
);
1026 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1027 if (codec
== NULL
) {
1028 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
1033 codec
->addr
= codec_addr
;
1034 mutex_init(&codec
->spdif_mutex
);
1035 mutex_init(&codec
->control_mutex
);
1036 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1037 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1038 snd_array_init(&codec
->mixers
, sizeof(struct hda_nid_item
), 32);
1039 snd_array_init(&codec
->nids
, sizeof(struct hda_nid_item
), 32);
1040 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
1041 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
1042 if (codec
->bus
->modelname
) {
1043 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
1044 if (!codec
->modelname
) {
1045 snd_hda_codec_free(codec
);
1050 #ifdef CONFIG_SND_HDA_POWER_SAVE
1051 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
1052 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1053 * the caller has to power down appropriatley after initialization
1056 hda_keep_power_on(codec
);
1059 list_add_tail(&codec
->list
, &bus
->codec_list
);
1060 bus
->caddr_tbl
[codec_addr
] = codec
;
1062 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1064 if (codec
->vendor_id
== -1)
1065 /* read again, hopefully the access method was corrected
1066 * in the last read...
1068 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1070 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1071 AC_PAR_SUBSYSTEM_ID
);
1072 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1075 setup_fg_nodes(codec
);
1076 if (!codec
->afg
&& !codec
->mfg
) {
1077 snd_printdd("hda_codec: no AFG or MFG node found\n");
1082 err
= read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
);
1084 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
1087 err
= read_pin_defaults(codec
);
1091 if (!codec
->subsystem_id
) {
1092 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
1093 codec
->subsystem_id
=
1094 snd_hda_codec_read(codec
, nid
, 0,
1095 AC_VERB_GET_SUBSYSTEM_ID
, 0);
1098 /* power-up all before initialization */
1099 hda_set_power_state(codec
,
1100 codec
->afg
? codec
->afg
: codec
->mfg
,
1103 snd_hda_codec_proc_new(codec
);
1105 snd_hda_create_hwdep(codec
);
1107 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
1108 codec
->subsystem_id
, codec
->revision_id
);
1109 snd_component_add(codec
->bus
->card
, component
);
1116 snd_hda_codec_free(codec
);
1119 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
1122 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1123 * @codec: the HDA codec
1125 * Start parsing of the given codec tree and (re-)initialize the whole
1128 * Returns 0 if successful or a negative error code.
1130 int snd_hda_codec_configure(struct hda_codec
*codec
)
1134 codec
->preset
= find_codec_preset(codec
);
1135 if (!codec
->vendor_name
|| !codec
->chip_name
) {
1136 err
= get_codec_name(codec
);
1141 if (is_generic_config(codec
)) {
1142 err
= snd_hda_parse_generic_codec(codec
);
1145 if (codec
->preset
&& codec
->preset
->patch
) {
1146 err
= codec
->preset
->patch(codec
);
1150 /* call the default parser */
1151 err
= snd_hda_parse_generic_codec(codec
);
1153 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
1156 if (!err
&& codec
->patch_ops
.unsol_event
)
1157 err
= init_unsol_queue(codec
->bus
);
1158 /* audio codec should override the mixer name */
1159 if (!err
&& (codec
->afg
|| !*codec
->bus
->card
->mixername
))
1160 snprintf(codec
->bus
->card
->mixername
,
1161 sizeof(codec
->bus
->card
->mixername
),
1162 "%s %s", codec
->vendor_name
, codec
->chip_name
);
1165 EXPORT_SYMBOL_HDA(snd_hda_codec_configure
);
1168 * snd_hda_codec_setup_stream - set up the codec for streaming
1169 * @codec: the CODEC to set up
1170 * @nid: the NID to set up
1171 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1172 * @channel_id: channel id to pass, zero based.
1173 * @format: stream format.
1175 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1177 int channel_id
, int format
)
1182 snd_printdd("hda_codec_setup_stream: "
1183 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1184 nid
, stream_tag
, channel_id
, format
);
1185 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
,
1186 (stream_tag
<< 4) | channel_id
);
1188 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, format
);
1190 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
1193 * snd_hda_codec_cleanup_stream - clean up the codec for closing
1194 * @codec: the CODEC to clean up
1195 * @nid: the NID to clean up
1197 void snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
)
1202 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1203 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1204 #if 0 /* keep the format */
1206 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
1209 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream
);
1212 * amp access functions
1215 /* FIXME: more better hash key? */
1216 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1217 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1218 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1219 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1220 #define INFO_AMP_CAPS (1<<0)
1221 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1223 /* initialize the hash table */
1224 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
1225 unsigned int record_size
)
1227 memset(cache
, 0, sizeof(*cache
));
1228 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1229 snd_array_init(&cache
->buf
, record_size
, 64);
1232 static void free_hda_cache(struct hda_cache_rec
*cache
)
1234 snd_array_free(&cache
->buf
);
1237 /* query the hash. allocate an entry if not found. */
1238 static struct hda_cache_head
*get_hash(struct hda_cache_rec
*cache
, u32 key
)
1240 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1241 u16 cur
= cache
->hash
[idx
];
1242 struct hda_cache_head
*info
;
1244 while (cur
!= 0xffff) {
1245 info
= snd_array_elem(&cache
->buf
, cur
);
1246 if (info
->key
== key
)
1253 /* query the hash. allocate an entry if not found. */
1254 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1257 struct hda_cache_head
*info
= get_hash(cache
, key
);
1260 /* add a new hash entry */
1261 info
= snd_array_new(&cache
->buf
);
1264 cur
= snd_array_index(&cache
->buf
, info
);
1267 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1268 info
->next
= cache
->hash
[idx
];
1269 cache
->hash
[idx
] = cur
;
1274 /* query and allocate an amp hash entry */
1275 static inline struct hda_amp_info
*
1276 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1278 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1282 * query_amp_caps - query AMP capabilities
1283 * @codec: the HD-auio codec
1284 * @nid: the NID to query
1285 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1287 * Query AMP capabilities for the given widget and direction.
1288 * Returns the obtained capability bits.
1290 * When cap bits have been already read, this doesn't read again but
1291 * returns the cached value.
1293 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1295 struct hda_amp_info
*info
;
1297 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
1300 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1301 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1303 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
1304 direction
== HDA_OUTPUT
?
1305 AC_PAR_AMP_OUT_CAP
:
1308 info
->head
.val
|= INFO_AMP_CAPS
;
1310 return info
->amp_caps
;
1312 EXPORT_SYMBOL_HDA(query_amp_caps
);
1315 * snd_hda_override_amp_caps - Override the AMP capabilities
1316 * @codec: the CODEC to clean up
1317 * @nid: the NID to clean up
1318 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1319 * @caps: the capability bits to set
1321 * Override the cached AMP caps bits value by the given one.
1322 * This function is useful if the driver needs to adjust the AMP ranges,
1323 * e.g. limit to 0dB, etc.
1325 * Returns zero if successful or a negative error code.
1327 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1330 struct hda_amp_info
*info
;
1332 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
1335 info
->amp_caps
= caps
;
1336 info
->head
.val
|= INFO_AMP_CAPS
;
1339 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1342 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, u32 key
,
1343 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
))
1345 struct hda_amp_info
*info
;
1347 info
= get_alloc_amp_hash(codec
, key
);
1350 if (!info
->head
.val
) {
1351 info
->head
.val
|= INFO_AMP_CAPS
;
1352 info
->amp_caps
= func(codec
, nid
);
1354 return info
->amp_caps
;
1357 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
)
1359 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1363 * snd_hda_query_pin_caps - Query PIN capabilities
1364 * @codec: the HD-auio codec
1365 * @nid: the NID to query
1367 * Query PIN capabilities for the given widget.
1368 * Returns the obtained capability bits.
1370 * When cap bits have been already read, this doesn't read again but
1371 * returns the cached value.
1373 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1375 return query_caps_hash(codec
, nid
, HDA_HASH_PINCAP_KEY(nid
),
1378 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps
);
1381 * snd_hda_pin_sense - execute pin sense measurement
1382 * @codec: the CODEC to sense
1383 * @nid: the pin NID to sense
1385 * Execute necessary pin sense measurement and return its Presence Detect,
1386 * Impedance, ELD Valid etc. status bits.
1388 u32
snd_hda_pin_sense(struct hda_codec
*codec
, hda_nid_t nid
)
1392 if (!codec
->no_trigger_sense
) {
1393 pincap
= snd_hda_query_pin_caps(codec
, nid
);
1394 if (pincap
& AC_PINCAP_TRIG_REQ
) /* need trigger? */
1395 snd_hda_codec_read(codec
, nid
, 0,
1396 AC_VERB_SET_PIN_SENSE
, 0);
1398 return snd_hda_codec_read(codec
, nid
, 0,
1399 AC_VERB_GET_PIN_SENSE
, 0);
1401 EXPORT_SYMBOL_HDA(snd_hda_pin_sense
);
1404 * snd_hda_jack_detect - query pin Presence Detect status
1405 * @codec: the CODEC to sense
1406 * @nid: the pin NID to sense
1408 * Query and return the pin's Presence Detect status.
1410 int snd_hda_jack_detect(struct hda_codec
*codec
, hda_nid_t nid
)
1412 u32 sense
= snd_hda_pin_sense(codec
, nid
);
1413 return !!(sense
& AC_PINSENSE_PRESENCE
);
1415 EXPORT_SYMBOL_HDA(snd_hda_jack_detect
);
1418 * read the current volume to info
1419 * if the cache exists, read the cache value.
1421 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1422 struct hda_amp_info
*info
, hda_nid_t nid
,
1423 int ch
, int direction
, int index
)
1427 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1428 return info
->vol
[ch
];
1430 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1431 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1433 val
= snd_hda_codec_read(codec
, nid
, 0,
1434 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1435 info
->vol
[ch
] = val
& 0xff;
1436 info
->head
.val
|= INFO_AMP_VOL(ch
);
1437 return info
->vol
[ch
];
1441 * write the current volume in info to the h/w and update the cache
1443 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1444 hda_nid_t nid
, int ch
, int direction
, int index
,
1449 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1450 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1451 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1453 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1454 info
->vol
[ch
] = val
;
1458 * snd_hda_codec_amp_read - Read AMP value
1459 * @codec: HD-audio codec
1460 * @nid: NID to read the AMP value
1461 * @ch: channel (left=0 or right=1)
1462 * @direction: #HDA_INPUT or #HDA_OUTPUT
1463 * @index: the index value (only for input direction)
1465 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1467 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1468 int direction
, int index
)
1470 struct hda_amp_info
*info
;
1471 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1474 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1476 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1479 * snd_hda_codec_amp_update - update the AMP value
1480 * @codec: HD-audio codec
1481 * @nid: NID to read the AMP value
1482 * @ch: channel (left=0 or right=1)
1483 * @direction: #HDA_INPUT or #HDA_OUTPUT
1484 * @idx: the index value (only for input direction)
1485 * @mask: bit mask to set
1486 * @val: the bits value to set
1488 * Update the AMP value with a bit mask.
1489 * Returns 0 if the value is unchanged, 1 if changed.
1491 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1492 int direction
, int idx
, int mask
, int val
)
1494 struct hda_amp_info
*info
;
1496 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1499 if (snd_BUG_ON(mask
& ~0xff))
1502 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1503 if (info
->vol
[ch
] == val
)
1505 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1508 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1511 * snd_hda_codec_amp_stereo - update the AMP stereo values
1512 * @codec: HD-audio codec
1513 * @nid: NID to read the AMP value
1514 * @direction: #HDA_INPUT or #HDA_OUTPUT
1515 * @idx: the index value (only for input direction)
1516 * @mask: bit mask to set
1517 * @val: the bits value to set
1519 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1520 * stereo widget with the same mask and value.
1522 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1523 int direction
, int idx
, int mask
, int val
)
1527 if (snd_BUG_ON(mask
& ~0xff))
1529 for (ch
= 0; ch
< 2; ch
++)
1530 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1534 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1536 #ifdef SND_HDA_NEEDS_RESUME
1538 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1539 * @codec: HD-audio codec
1541 * Resume the all amp commands from the cache.
1543 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1545 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1548 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1549 u32 key
= buffer
->head
.key
;
1551 unsigned int idx
, dir
, ch
;
1555 idx
= (key
>> 16) & 0xff;
1556 dir
= (key
>> 24) & 0xff;
1557 for (ch
= 0; ch
< 2; ch
++) {
1558 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1560 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1565 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1566 #endif /* SND_HDA_NEEDS_RESUME */
1568 static u32
get_amp_max_value(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1571 u32 caps
= query_amp_caps(codec
, nid
, dir
);
1573 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1580 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1582 * The control element is supposed to have the private_value field
1583 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1585 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1586 struct snd_ctl_elem_info
*uinfo
)
1588 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1589 u16 nid
= get_amp_nid(kcontrol
);
1590 u8 chs
= get_amp_channels(kcontrol
);
1591 int dir
= get_amp_direction(kcontrol
);
1592 unsigned int ofs
= get_amp_offset(kcontrol
);
1594 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1595 uinfo
->count
= chs
== 3 ? 2 : 1;
1596 uinfo
->value
.integer
.min
= 0;
1597 uinfo
->value
.integer
.max
= get_amp_max_value(codec
, nid
, dir
, ofs
);
1598 if (!uinfo
->value
.integer
.max
) {
1599 printk(KERN_WARNING
"hda_codec: "
1600 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1606 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1609 static inline unsigned int
1610 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1611 int ch
, int dir
, int idx
, unsigned int ofs
)
1614 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1615 val
&= HDA_AMP_VOLMASK
;
1624 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1625 int ch
, int dir
, int idx
, unsigned int ofs
,
1628 unsigned int maxval
;
1632 maxval
= get_amp_max_value(codec
, nid
, dir
, ofs
);
1635 return snd_hda_codec_amp_update(codec
, nid
, ch
, dir
, idx
,
1636 HDA_AMP_VOLMASK
, val
);
1640 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1642 * The control element is supposed to have the private_value field
1643 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1645 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1646 struct snd_ctl_elem_value
*ucontrol
)
1648 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1649 hda_nid_t nid
= get_amp_nid(kcontrol
);
1650 int chs
= get_amp_channels(kcontrol
);
1651 int dir
= get_amp_direction(kcontrol
);
1652 int idx
= get_amp_index(kcontrol
);
1653 unsigned int ofs
= get_amp_offset(kcontrol
);
1654 long *valp
= ucontrol
->value
.integer
.value
;
1657 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
1659 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
1662 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
1665 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1667 * The control element is supposed to have the private_value field
1668 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1670 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1671 struct snd_ctl_elem_value
*ucontrol
)
1673 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1674 hda_nid_t nid
= get_amp_nid(kcontrol
);
1675 int chs
= get_amp_channels(kcontrol
);
1676 int dir
= get_amp_direction(kcontrol
);
1677 int idx
= get_amp_index(kcontrol
);
1678 unsigned int ofs
= get_amp_offset(kcontrol
);
1679 long *valp
= ucontrol
->value
.integer
.value
;
1682 snd_hda_power_up(codec
);
1684 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
1688 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
1689 snd_hda_power_down(codec
);
1692 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
1695 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1697 * The control element is supposed to have the private_value field
1698 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1700 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1701 unsigned int size
, unsigned int __user
*_tlv
)
1703 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1704 hda_nid_t nid
= get_amp_nid(kcontrol
);
1705 int dir
= get_amp_direction(kcontrol
);
1706 unsigned int ofs
= get_amp_offset(kcontrol
);
1707 u32 caps
, val1
, val2
;
1709 if (size
< 4 * sizeof(unsigned int))
1711 caps
= query_amp_caps(codec
, nid
, dir
);
1712 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1713 val2
= (val2
+ 1) * 25;
1714 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1716 val1
= ((int)val1
) * ((int)val2
);
1717 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1719 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1721 if (put_user(val1
, _tlv
+ 2))
1723 if (put_user(val2
, _tlv
+ 3))
1727 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
1730 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1731 * @codec: HD-audio codec
1732 * @nid: NID of a reference widget
1733 * @dir: #HDA_INPUT or #HDA_OUTPUT
1734 * @tlv: TLV data to be stored, at least 4 elements
1736 * Set (static) TLV data for a virtual master volume using the AMP caps
1737 * obtained from the reference NID.
1738 * The volume range is recalculated as if the max volume is 0dB.
1740 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1746 caps
= query_amp_caps(codec
, nid
, dir
);
1747 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1748 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1749 step
= (step
+ 1) * 25;
1750 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1751 tlv
[1] = 2 * sizeof(unsigned int);
1752 tlv
[2] = -nums
* step
;
1755 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
1757 /* find a mixer control element with the given name */
1758 static struct snd_kcontrol
*
1759 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1760 const char *name
, int idx
)
1762 struct snd_ctl_elem_id id
;
1763 memset(&id
, 0, sizeof(id
));
1764 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1766 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
1768 strcpy(id
.name
, name
);
1769 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1773 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1774 * @codec: HD-audio codec
1775 * @name: ctl id name string
1777 * Get the control element with the given id string and IFACE_MIXER.
1779 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1782 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
1784 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
1787 * snd_hda_ctl_add - Add a control element and assign to the codec
1788 * @codec: HD-audio codec
1789 * @nid: corresponding NID (optional)
1790 * @kctl: the control element to assign
1792 * Add the given control element to an array inside the codec instance.
1793 * All control elements belonging to a codec are supposed to be added
1794 * by this function so that a proper clean-up works at the free or
1795 * reconfiguration time.
1797 * If non-zero @nid is passed, the NID is assigned to the control element.
1798 * The assignment is shown in the codec proc file.
1800 * snd_hda_ctl_add() checks the control subdev id field whether
1801 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1802 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1803 * specifies if kctl->private_value is a HDA amplifier value.
1805 int snd_hda_ctl_add(struct hda_codec
*codec
, hda_nid_t nid
,
1806 struct snd_kcontrol
*kctl
)
1809 unsigned short flags
= 0;
1810 struct hda_nid_item
*item
;
1812 if (kctl
->id
.subdevice
& HDA_SUBDEV_AMP_FLAG
) {
1813 flags
|= HDA_NID_ITEM_AMP
;
1815 nid
= get_amp_nid_(kctl
->private_value
);
1817 if ((kctl
->id
.subdevice
& HDA_SUBDEV_NID_FLAG
) != 0 && nid
== 0)
1818 nid
= kctl
->id
.subdevice
& 0xffff;
1819 if (kctl
->id
.subdevice
& (HDA_SUBDEV_NID_FLAG
|HDA_SUBDEV_AMP_FLAG
))
1820 kctl
->id
.subdevice
= 0;
1821 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1824 item
= snd_array_new(&codec
->mixers
);
1829 item
->flags
= flags
;
1832 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
1835 * snd_hda_add_nid - Assign a NID to a control element
1836 * @codec: HD-audio codec
1837 * @nid: corresponding NID (optional)
1838 * @kctl: the control element to assign
1839 * @index: index to kctl
1841 * Add the given control element to an array inside the codec instance.
1842 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1843 * NID:KCTL mapping - for example "Capture Source" selector.
1845 int snd_hda_add_nid(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
,
1846 unsigned int index
, hda_nid_t nid
)
1848 struct hda_nid_item
*item
;
1851 item
= snd_array_new(&codec
->nids
);
1855 item
->index
= index
;
1859 printk(KERN_ERR
"hda-codec: no NID for mapping control %s:%d:%d\n",
1860 kctl
->id
.name
, kctl
->id
.index
, index
);
1863 EXPORT_SYMBOL_HDA(snd_hda_add_nid
);
1866 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1867 * @codec: HD-audio codec
1869 void snd_hda_ctls_clear(struct hda_codec
*codec
)
1872 struct hda_nid_item
*items
= codec
->mixers
.list
;
1873 for (i
= 0; i
< codec
->mixers
.used
; i
++)
1874 snd_ctl_remove(codec
->bus
->card
, items
[i
].kctl
);
1875 snd_array_free(&codec
->mixers
);
1876 snd_array_free(&codec
->nids
);
1879 /* pseudo device locking
1880 * toggle card->shutdown to allow/disallow the device access (as a hack)
1882 static int hda_lock_devices(struct snd_card
*card
)
1884 spin_lock(&card
->files_lock
);
1885 if (card
->shutdown
) {
1886 spin_unlock(&card
->files_lock
);
1890 spin_unlock(&card
->files_lock
);
1894 static void hda_unlock_devices(struct snd_card
*card
)
1896 spin_lock(&card
->files_lock
);
1898 spin_unlock(&card
->files_lock
);
1902 * snd_hda_codec_reset - Clear all objects assigned to the codec
1903 * @codec: HD-audio codec
1905 * This frees the all PCM and control elements assigned to the codec, and
1906 * clears the caches and restores the pin default configurations.
1908 * When a device is being used, it returns -EBSY. If successfully freed,
1911 int snd_hda_codec_reset(struct hda_codec
*codec
)
1913 struct snd_card
*card
= codec
->bus
->card
;
1916 if (hda_lock_devices(card
) < 0)
1918 /* check whether the codec isn't used by any mixer or PCM streams */
1919 if (!list_empty(&card
->ctl_files
)) {
1920 hda_unlock_devices(card
);
1923 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
1924 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
1927 if (cpcm
->pcm
->streams
[0].substream_opened
||
1928 cpcm
->pcm
->streams
[1].substream_opened
) {
1929 hda_unlock_devices(card
);
1934 /* OK, let it free */
1936 #ifdef CONFIG_SND_HDA_POWER_SAVE
1937 cancel_delayed_work(&codec
->power_work
);
1938 flush_workqueue(codec
->bus
->workq
);
1940 snd_hda_ctls_clear(codec
);
1942 for (i
= 0; i
< codec
->num_pcms
; i
++) {
1943 if (codec
->pcm_info
[i
].pcm
) {
1944 snd_device_free(card
, codec
->pcm_info
[i
].pcm
);
1945 clear_bit(codec
->pcm_info
[i
].device
,
1946 codec
->bus
->pcm_dev_bits
);
1949 if (codec
->patch_ops
.free
)
1950 codec
->patch_ops
.free(codec
);
1951 codec
->proc_widget_hook
= NULL
;
1953 free_hda_cache(&codec
->amp_cache
);
1954 free_hda_cache(&codec
->cmd_cache
);
1955 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1956 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1957 /* free only driver_pins so that init_pins + user_pins are restored */
1958 snd_array_free(&codec
->driver_pins
);
1959 restore_pincfgs(codec
);
1960 codec
->num_pcms
= 0;
1961 codec
->pcm_info
= NULL
;
1962 codec
->preset
= NULL
;
1963 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
1964 codec
->slave_dig_outs
= NULL
;
1965 codec
->spdif_status_reset
= 0;
1966 module_put(codec
->owner
);
1967 codec
->owner
= NULL
;
1969 /* allow device access again */
1970 hda_unlock_devices(card
);
1975 * snd_hda_add_vmaster - create a virtual master control and add slaves
1976 * @codec: HD-audio codec
1977 * @name: vmaster control name
1978 * @tlv: TLV data (optional)
1979 * @slaves: slave control names (optional)
1981 * Create a virtual master control with the given name. The TLV data
1982 * must be either NULL or a valid data.
1984 * @slaves is a NULL-terminated array of strings, each of which is a
1985 * slave control name. All controls with these names are assigned to
1986 * the new virtual master control.
1988 * This function returns zero if successful or a negative error code.
1990 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
1991 unsigned int *tlv
, const char **slaves
)
1993 struct snd_kcontrol
*kctl
;
1997 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
2000 snd_printdd("No slave found for %s\n", name
);
2003 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
2006 err
= snd_hda_ctl_add(codec
, 0, kctl
);
2010 for (s
= slaves
; *s
; s
++) {
2011 struct snd_kcontrol
*sctl
;
2014 sctl
= _snd_hda_find_mixer_ctl(codec
, *s
, i
);
2017 snd_printdd("Cannot find slave %s, "
2021 err
= snd_ctl_add_slave(kctl
, sctl
);
2029 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
2032 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2034 * The control element is supposed to have the private_value field
2035 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2037 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
2038 struct snd_ctl_elem_info
*uinfo
)
2040 int chs
= get_amp_channels(kcontrol
);
2042 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2043 uinfo
->count
= chs
== 3 ? 2 : 1;
2044 uinfo
->value
.integer
.min
= 0;
2045 uinfo
->value
.integer
.max
= 1;
2048 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
2051 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2053 * The control element is supposed to have the private_value field
2054 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2056 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
2057 struct snd_ctl_elem_value
*ucontrol
)
2059 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2060 hda_nid_t nid
= get_amp_nid(kcontrol
);
2061 int chs
= get_amp_channels(kcontrol
);
2062 int dir
= get_amp_direction(kcontrol
);
2063 int idx
= get_amp_index(kcontrol
);
2064 long *valp
= ucontrol
->value
.integer
.value
;
2067 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
2068 HDA_AMP_MUTE
) ? 0 : 1;
2070 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
2071 HDA_AMP_MUTE
) ? 0 : 1;
2074 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
2077 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2079 * The control element is supposed to have the private_value field
2080 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2082 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
2083 struct snd_ctl_elem_value
*ucontrol
)
2085 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2086 hda_nid_t nid
= get_amp_nid(kcontrol
);
2087 int chs
= get_amp_channels(kcontrol
);
2088 int dir
= get_amp_direction(kcontrol
);
2089 int idx
= get_amp_index(kcontrol
);
2090 long *valp
= ucontrol
->value
.integer
.value
;
2093 snd_hda_power_up(codec
);
2095 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
2097 *valp
? 0 : HDA_AMP_MUTE
);
2101 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
2103 *valp
? 0 : HDA_AMP_MUTE
);
2104 #ifdef CONFIG_SND_HDA_POWER_SAVE
2105 if (codec
->patch_ops
.check_power_status
)
2106 codec
->patch_ops
.check_power_status(codec
, nid
);
2108 snd_hda_power_down(codec
);
2111 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
2113 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2115 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2117 * This function calls snd_hda_enable_beep_device(), which behaves differently
2118 * depending on beep_mode option.
2120 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol
*kcontrol
,
2121 struct snd_ctl_elem_value
*ucontrol
)
2123 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2124 long *valp
= ucontrol
->value
.integer
.value
;
2126 snd_hda_enable_beep_device(codec
, *valp
);
2127 return snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2129 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep
);
2130 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2133 * bound volume controls
2135 * bind multiple volumes (# indices, from 0)
2138 #define AMP_VAL_IDX_SHIFT 19
2139 #define AMP_VAL_IDX_MASK (0x0f<<19)
2142 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2144 * The control element is supposed to have the private_value field
2145 * set up via HDA_BIND_MUTE*() macros.
2147 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
2148 struct snd_ctl_elem_value
*ucontrol
)
2150 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2154 mutex_lock(&codec
->control_mutex
);
2155 pval
= kcontrol
->private_value
;
2156 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
2157 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
2158 kcontrol
->private_value
= pval
;
2159 mutex_unlock(&codec
->control_mutex
);
2162 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
2165 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2167 * The control element is supposed to have the private_value field
2168 * set up via HDA_BIND_MUTE*() macros.
2170 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
2171 struct snd_ctl_elem_value
*ucontrol
)
2173 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2175 int i
, indices
, err
= 0, change
= 0;
2177 mutex_lock(&codec
->control_mutex
);
2178 pval
= kcontrol
->private_value
;
2179 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
2180 for (i
= 0; i
< indices
; i
++) {
2181 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
2182 (i
<< AMP_VAL_IDX_SHIFT
);
2183 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2188 kcontrol
->private_value
= pval
;
2189 mutex_unlock(&codec
->control_mutex
);
2190 return err
< 0 ? err
: change
;
2192 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
2195 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2197 * The control element is supposed to have the private_value field
2198 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2200 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
2201 struct snd_ctl_elem_info
*uinfo
)
2203 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2204 struct hda_bind_ctls
*c
;
2207 mutex_lock(&codec
->control_mutex
);
2208 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2209 kcontrol
->private_value
= *c
->values
;
2210 err
= c
->ops
->info(kcontrol
, uinfo
);
2211 kcontrol
->private_value
= (long)c
;
2212 mutex_unlock(&codec
->control_mutex
);
2215 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
2218 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2220 * The control element is supposed to have the private_value field
2221 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2223 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
2224 struct snd_ctl_elem_value
*ucontrol
)
2226 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2227 struct hda_bind_ctls
*c
;
2230 mutex_lock(&codec
->control_mutex
);
2231 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2232 kcontrol
->private_value
= *c
->values
;
2233 err
= c
->ops
->get(kcontrol
, ucontrol
);
2234 kcontrol
->private_value
= (long)c
;
2235 mutex_unlock(&codec
->control_mutex
);
2238 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
2241 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2243 * The control element is supposed to have the private_value field
2244 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2246 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
2247 struct snd_ctl_elem_value
*ucontrol
)
2249 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2250 struct hda_bind_ctls
*c
;
2251 unsigned long *vals
;
2252 int err
= 0, change
= 0;
2254 mutex_lock(&codec
->control_mutex
);
2255 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2256 for (vals
= c
->values
; *vals
; vals
++) {
2257 kcontrol
->private_value
= *vals
;
2258 err
= c
->ops
->put(kcontrol
, ucontrol
);
2263 kcontrol
->private_value
= (long)c
;
2264 mutex_unlock(&codec
->control_mutex
);
2265 return err
< 0 ? err
: change
;
2267 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
2270 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2272 * The control element is supposed to have the private_value field
2273 * set up via HDA_BIND_VOL() macro.
2275 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2276 unsigned int size
, unsigned int __user
*tlv
)
2278 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2279 struct hda_bind_ctls
*c
;
2282 mutex_lock(&codec
->control_mutex
);
2283 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2284 kcontrol
->private_value
= *c
->values
;
2285 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
2286 kcontrol
->private_value
= (long)c
;
2287 mutex_unlock(&codec
->control_mutex
);
2290 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
2292 struct hda_ctl_ops snd_hda_bind_vol
= {
2293 .info
= snd_hda_mixer_amp_volume_info
,
2294 .get
= snd_hda_mixer_amp_volume_get
,
2295 .put
= snd_hda_mixer_amp_volume_put
,
2296 .tlv
= snd_hda_mixer_amp_tlv
2298 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
2300 struct hda_ctl_ops snd_hda_bind_sw
= {
2301 .info
= snd_hda_mixer_amp_switch_info
,
2302 .get
= snd_hda_mixer_amp_switch_get
,
2303 .put
= snd_hda_mixer_amp_switch_put
,
2304 .tlv
= snd_hda_mixer_amp_tlv
2306 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
2309 * SPDIF out controls
2312 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2313 struct snd_ctl_elem_info
*uinfo
)
2315 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2320 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
2321 struct snd_ctl_elem_value
*ucontrol
)
2323 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2324 IEC958_AES0_NONAUDIO
|
2325 IEC958_AES0_CON_EMPHASIS_5015
|
2326 IEC958_AES0_CON_NOT_COPYRIGHT
;
2327 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
2328 IEC958_AES1_CON_ORIGINAL
;
2332 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
2333 struct snd_ctl_elem_value
*ucontrol
)
2335 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2336 IEC958_AES0_NONAUDIO
|
2337 IEC958_AES0_PRO_EMPHASIS_5015
;
2341 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2342 struct snd_ctl_elem_value
*ucontrol
)
2344 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2346 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
2347 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
2348 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
2349 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
2354 /* convert from SPDIF status bits to HDA SPDIF bits
2355 * bit 0 (DigEn) is always set zero (to be filled later)
2357 static unsigned short convert_from_spdif_status(unsigned int sbits
)
2359 unsigned short val
= 0;
2361 if (sbits
& IEC958_AES0_PROFESSIONAL
)
2362 val
|= AC_DIG1_PROFESSIONAL
;
2363 if (sbits
& IEC958_AES0_NONAUDIO
)
2364 val
|= AC_DIG1_NONAUDIO
;
2365 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2366 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
2367 IEC958_AES0_PRO_EMPHASIS_5015
)
2368 val
|= AC_DIG1_EMPHASIS
;
2370 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
2371 IEC958_AES0_CON_EMPHASIS_5015
)
2372 val
|= AC_DIG1_EMPHASIS
;
2373 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
2374 val
|= AC_DIG1_COPYRIGHT
;
2375 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
2376 val
|= AC_DIG1_LEVEL
;
2377 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
2382 /* convert to SPDIF status bits from HDA SPDIF bits
2384 static unsigned int convert_to_spdif_status(unsigned short val
)
2386 unsigned int sbits
= 0;
2388 if (val
& AC_DIG1_NONAUDIO
)
2389 sbits
|= IEC958_AES0_NONAUDIO
;
2390 if (val
& AC_DIG1_PROFESSIONAL
)
2391 sbits
|= IEC958_AES0_PROFESSIONAL
;
2392 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2393 if (sbits
& AC_DIG1_EMPHASIS
)
2394 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
2396 if (val
& AC_DIG1_EMPHASIS
)
2397 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
2398 if (!(val
& AC_DIG1_COPYRIGHT
))
2399 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
2400 if (val
& AC_DIG1_LEVEL
)
2401 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
2402 sbits
|= val
& (0x7f << 8);
2407 /* set digital convert verbs both for the given NID and its slaves */
2408 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
2413 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
2414 d
= codec
->slave_dig_outs
;
2418 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
2421 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
2425 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
2427 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2430 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2431 struct snd_ctl_elem_value
*ucontrol
)
2433 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2434 hda_nid_t nid
= kcontrol
->private_value
;
2438 mutex_lock(&codec
->spdif_mutex
);
2439 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
2440 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2441 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2442 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2443 val
= convert_from_spdif_status(codec
->spdif_status
);
2444 val
|= codec
->spdif_ctls
& 1;
2445 change
= codec
->spdif_ctls
!= val
;
2446 codec
->spdif_ctls
= val
;
2449 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2451 mutex_unlock(&codec
->spdif_mutex
);
2455 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2457 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2458 struct snd_ctl_elem_value
*ucontrol
)
2460 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2462 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
2466 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2467 struct snd_ctl_elem_value
*ucontrol
)
2469 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2470 hda_nid_t nid
= kcontrol
->private_value
;
2474 mutex_lock(&codec
->spdif_mutex
);
2475 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
2476 if (ucontrol
->value
.integer
.value
[0])
2477 val
|= AC_DIG1_ENABLE
;
2478 change
= codec
->spdif_ctls
!= val
;
2480 codec
->spdif_ctls
= val
;
2481 set_dig_out_convert(codec
, nid
, val
& 0xff, -1);
2482 /* unmute amp switch (if any) */
2483 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2484 (val
& AC_DIG1_ENABLE
))
2485 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2488 mutex_unlock(&codec
->spdif_mutex
);
2492 static struct snd_kcontrol_new dig_mixes
[] = {
2494 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2495 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2496 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, CON_MASK
),
2497 .info
= snd_hda_spdif_mask_info
,
2498 .get
= snd_hda_spdif_cmask_get
,
2501 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2502 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2503 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, PRO_MASK
),
2504 .info
= snd_hda_spdif_mask_info
,
2505 .get
= snd_hda_spdif_pmask_get
,
2508 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2509 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, DEFAULT
),
2510 .info
= snd_hda_spdif_mask_info
,
2511 .get
= snd_hda_spdif_default_get
,
2512 .put
= snd_hda_spdif_default_put
,
2515 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2516 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, SWITCH
),
2517 .info
= snd_hda_spdif_out_switch_info
,
2518 .get
= snd_hda_spdif_out_switch_get
,
2519 .put
= snd_hda_spdif_out_switch_put
,
2524 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2527 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2528 * @codec: the HDA codec
2529 * @nid: audio out widget NID
2531 * Creates controls related with the SPDIF output.
2532 * Called from each patch supporting the SPDIF out.
2534 * Returns 0 if successful, or a negative error code.
2536 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2539 struct snd_kcontrol
*kctl
;
2540 struct snd_kcontrol_new
*dig_mix
;
2543 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2544 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Playback Switch",
2548 if (idx
>= SPDIF_MAX_IDX
) {
2549 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
2552 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
2553 kctl
= snd_ctl_new1(dig_mix
, codec
);
2556 kctl
->id
.index
= idx
;
2557 kctl
->private_value
= nid
;
2558 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2563 snd_hda_codec_read(codec
, nid
, 0,
2564 AC_VERB_GET_DIGI_CONVERT_1
, 0);
2565 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
2568 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
2571 * SPDIF sharing with analog output
2573 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
2574 struct snd_ctl_elem_value
*ucontrol
)
2576 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2577 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
2581 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
2582 struct snd_ctl_elem_value
*ucontrol
)
2584 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2585 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
2589 static struct snd_kcontrol_new spdif_share_sw
= {
2590 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2591 .name
= "IEC958 Default PCM Playback Switch",
2592 .info
= snd_ctl_boolean_mono_info
,
2593 .get
= spdif_share_sw_get
,
2594 .put
= spdif_share_sw_put
,
2598 * snd_hda_create_spdif_share_sw - create Default PCM switch
2599 * @codec: the HDA codec
2600 * @mout: multi-out instance
2602 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
2603 struct hda_multi_out
*mout
)
2605 if (!mout
->dig_out_nid
)
2607 /* ATTENTION: here mout is passed as private_data, instead of codec */
2608 return snd_hda_ctl_add(codec
, mout
->dig_out_nid
,
2609 snd_ctl_new1(&spdif_share_sw
, mout
));
2611 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
2617 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2619 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
2620 struct snd_ctl_elem_value
*ucontrol
)
2622 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2624 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
2628 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
2629 struct snd_ctl_elem_value
*ucontrol
)
2631 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2632 hda_nid_t nid
= kcontrol
->private_value
;
2633 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
2636 mutex_lock(&codec
->spdif_mutex
);
2637 change
= codec
->spdif_in_enable
!= val
;
2639 codec
->spdif_in_enable
= val
;
2640 snd_hda_codec_write_cache(codec
, nid
, 0,
2641 AC_VERB_SET_DIGI_CONVERT_1
, val
);
2643 mutex_unlock(&codec
->spdif_mutex
);
2647 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
2648 struct snd_ctl_elem_value
*ucontrol
)
2650 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2651 hda_nid_t nid
= kcontrol
->private_value
;
2655 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
2656 sbits
= convert_to_spdif_status(val
);
2657 ucontrol
->value
.iec958
.status
[0] = sbits
;
2658 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
2659 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
2660 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
2664 static struct snd_kcontrol_new dig_in_ctls
[] = {
2666 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2667 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, SWITCH
),
2668 .info
= snd_hda_spdif_in_switch_info
,
2669 .get
= snd_hda_spdif_in_switch_get
,
2670 .put
= snd_hda_spdif_in_switch_put
,
2673 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2674 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2675 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, DEFAULT
),
2676 .info
= snd_hda_spdif_mask_info
,
2677 .get
= snd_hda_spdif_in_status_get
,
2683 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2684 * @codec: the HDA codec
2685 * @nid: audio in widget NID
2687 * Creates controls related with the SPDIF input.
2688 * Called from each patch supporting the SPDIF in.
2690 * Returns 0 if successful, or a negative error code.
2692 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2695 struct snd_kcontrol
*kctl
;
2696 struct snd_kcontrol_new
*dig_mix
;
2699 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2700 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Capture Switch",
2704 if (idx
>= SPDIF_MAX_IDX
) {
2705 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
2708 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
2709 kctl
= snd_ctl_new1(dig_mix
, codec
);
2712 kctl
->private_value
= nid
;
2713 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2717 codec
->spdif_in_enable
=
2718 snd_hda_codec_read(codec
, nid
, 0,
2719 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
2723 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
2725 #ifdef SND_HDA_NEEDS_RESUME
2730 /* build a 32bit cache key with the widget id and the command parameter */
2731 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2732 #define get_cmd_cache_nid(key) ((key) & 0xff)
2733 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2736 * snd_hda_codec_write_cache - send a single command with caching
2737 * @codec: the HDA codec
2738 * @nid: NID to send the command
2739 * @direct: direct flag
2740 * @verb: the verb to send
2741 * @parm: the parameter for the verb
2743 * Send a single command without waiting for response.
2745 * Returns 0 if successful, or a negative error code.
2747 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2748 int direct
, unsigned int verb
, unsigned int parm
)
2750 int err
= snd_hda_codec_write(codec
, nid
, direct
, verb
, parm
);
2751 struct hda_cache_head
*c
;
2756 /* parm may contain the verb stuff for get/set amp */
2757 verb
= verb
| (parm
>> 8);
2759 key
= build_cmd_cache_key(nid
, verb
);
2760 mutex_lock(&codec
->bus
->cmd_mutex
);
2761 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
2764 mutex_unlock(&codec
->bus
->cmd_mutex
);
2767 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
2770 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
2771 * @codec: the HDA codec
2772 * @nid: NID to send the command
2773 * @direct: direct flag
2774 * @verb: the verb to send
2775 * @parm: the parameter for the verb
2777 * This function works like snd_hda_codec_write_cache(), but it doesn't send
2778 * command if the parameter is already identical with the cached value.
2779 * If not, it sends the command and refreshes the cache.
2781 * Returns 0 if successful, or a negative error code.
2783 int snd_hda_codec_update_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2784 int direct
, unsigned int verb
, unsigned int parm
)
2786 struct hda_cache_head
*c
;
2789 /* parm may contain the verb stuff for get/set amp */
2790 verb
= verb
| (parm
>> 8);
2792 key
= build_cmd_cache_key(nid
, verb
);
2793 mutex_lock(&codec
->bus
->cmd_mutex
);
2794 c
= get_hash(&codec
->cmd_cache
, key
);
2795 if (c
&& c
->val
== parm
) {
2796 mutex_unlock(&codec
->bus
->cmd_mutex
);
2799 mutex_unlock(&codec
->bus
->cmd_mutex
);
2800 return snd_hda_codec_write_cache(codec
, nid
, direct
, verb
, parm
);
2802 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache
);
2805 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2806 * @codec: HD-audio codec
2808 * Execute all verbs recorded in the command caches to resume.
2810 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
2812 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
2815 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
2816 u32 key
= buffer
->key
;
2819 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
2820 get_cmd_cache_cmd(key
), buffer
->val
);
2823 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
2826 * snd_hda_sequence_write_cache - sequence writes with caching
2827 * @codec: the HDA codec
2828 * @seq: VERB array to send
2830 * Send the commands sequentially from the given array.
2831 * Thte commands are recorded on cache for power-save and resume.
2832 * The array must be terminated with NID=0.
2834 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
2835 const struct hda_verb
*seq
)
2837 for (; seq
->nid
; seq
++)
2838 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
2841 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
2842 #endif /* SND_HDA_NEEDS_RESUME */
2845 * set power state of the codec
2847 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2848 unsigned int power_state
)
2853 /* this delay seems necessary to avoid click noise at power-down */
2854 if (power_state
== AC_PWRST_D3
)
2856 snd_hda_codec_read(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
2858 /* partial workaround for "azx_get_response timeout" */
2859 if (power_state
== AC_PWRST_D0
&&
2860 (codec
->vendor_id
& 0xffff0000) == 0x14f10000)
2863 nid
= codec
->start_nid
;
2864 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2865 unsigned int wcaps
= get_wcaps(codec
, nid
);
2866 if (wcaps
& AC_WCAP_POWER
) {
2867 unsigned int wid_type
= get_wcaps_type(wcaps
);
2868 if (power_state
== AC_PWRST_D3
&&
2869 wid_type
== AC_WID_PIN
) {
2870 unsigned int pincap
;
2872 * don't power down the widget if it controls
2873 * eapd and EAPD_BTLENABLE is set.
2875 pincap
= snd_hda_query_pin_caps(codec
, nid
);
2876 if (pincap
& AC_PINCAP_EAPD
) {
2877 int eapd
= snd_hda_codec_read(codec
,
2879 AC_VERB_GET_EAPD_BTLENABLE
, 0);
2885 snd_hda_codec_write(codec
, nid
, 0,
2886 AC_VERB_SET_POWER_STATE
,
2891 if (power_state
== AC_PWRST_D0
) {
2892 unsigned long end_time
;
2894 /* wait until the codec reachs to D0 */
2895 end_time
= jiffies
+ msecs_to_jiffies(500);
2897 state
= snd_hda_codec_read(codec
, fg
, 0,
2898 AC_VERB_GET_POWER_STATE
, 0);
2899 if (state
== power_state
)
2902 } while (time_after_eq(end_time
, jiffies
));
2906 #ifdef CONFIG_SND_HDA_HWDEP
2907 /* execute additional init verbs */
2908 static void hda_exec_init_verbs(struct hda_codec
*codec
)
2910 if (codec
->init_verbs
.list
)
2911 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
2914 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
2917 #ifdef SND_HDA_NEEDS_RESUME
2919 * call suspend and power-down; used both from PM and power-save
2921 static void hda_call_codec_suspend(struct hda_codec
*codec
)
2923 if (codec
->patch_ops
.suspend
)
2924 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
2925 hda_set_power_state(codec
,
2926 codec
->afg
? codec
->afg
: codec
->mfg
,
2928 #ifdef CONFIG_SND_HDA_POWER_SAVE
2929 snd_hda_update_power_acct(codec
);
2930 cancel_delayed_work(&codec
->power_work
);
2931 codec
->power_on
= 0;
2932 codec
->power_transition
= 0;
2933 codec
->power_jiffies
= jiffies
;
2938 * kick up codec; used both from PM and power-save
2940 static void hda_call_codec_resume(struct hda_codec
*codec
)
2942 hda_set_power_state(codec
,
2943 codec
->afg
? codec
->afg
: codec
->mfg
,
2945 restore_pincfgs(codec
); /* restore all current pin configs */
2946 restore_shutup_pins(codec
);
2947 hda_exec_init_verbs(codec
);
2948 if (codec
->patch_ops
.resume
)
2949 codec
->patch_ops
.resume(codec
);
2951 if (codec
->patch_ops
.init
)
2952 codec
->patch_ops
.init(codec
);
2953 snd_hda_codec_resume_amp(codec
);
2954 snd_hda_codec_resume_cache(codec
);
2957 #endif /* SND_HDA_NEEDS_RESUME */
2961 * snd_hda_build_controls - build mixer controls
2964 * Creates mixer controls for each codec included in the bus.
2966 * Returns 0 if successful, otherwise a negative error code.
2968 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
2970 struct hda_codec
*codec
;
2972 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2973 int err
= snd_hda_codec_build_controls(codec
);
2975 printk(KERN_ERR
"hda_codec: cannot build controls "
2976 "for #%d (error %d)\n", codec
->addr
, err
);
2977 err
= snd_hda_codec_reset(codec
);
2980 "hda_codec: cannot revert codec\n");
2987 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
2989 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
2992 hda_exec_init_verbs(codec
);
2993 /* continue to initialize... */
2994 if (codec
->patch_ops
.init
)
2995 err
= codec
->patch_ops
.init(codec
);
2996 if (!err
&& codec
->patch_ops
.build_controls
)
2997 err
= codec
->patch_ops
.build_controls(codec
);
3006 struct hda_rate_tbl
{
3008 unsigned int alsa_bits
;
3009 unsigned int hda_fmt
;
3012 static struct hda_rate_tbl rate_bits
[] = {
3013 /* rate in Hz, ALSA rate bitmask, HDA format value */
3015 /* autodetected value used in snd_hda_query_supported_pcm */
3016 { 8000, SNDRV_PCM_RATE_8000
, 0x0500 }, /* 1/6 x 48 */
3017 { 11025, SNDRV_PCM_RATE_11025
, 0x4300 }, /* 1/4 x 44 */
3018 { 16000, SNDRV_PCM_RATE_16000
, 0x0200 }, /* 1/3 x 48 */
3019 { 22050, SNDRV_PCM_RATE_22050
, 0x4100 }, /* 1/2 x 44 */
3020 { 32000, SNDRV_PCM_RATE_32000
, 0x0a00 }, /* 2/3 x 48 */
3021 { 44100, SNDRV_PCM_RATE_44100
, 0x4000 }, /* 44 */
3022 { 48000, SNDRV_PCM_RATE_48000
, 0x0000 }, /* 48 */
3023 { 88200, SNDRV_PCM_RATE_88200
, 0x4800 }, /* 2 x 44 */
3024 { 96000, SNDRV_PCM_RATE_96000
, 0x0800 }, /* 2 x 48 */
3025 { 176400, SNDRV_PCM_RATE_176400
, 0x5800 },/* 4 x 44 */
3026 { 192000, SNDRV_PCM_RATE_192000
, 0x1800 }, /* 4 x 48 */
3027 #define AC_PAR_PCM_RATE_BITS 11
3028 /* up to bits 10, 384kHZ isn't supported properly */
3030 /* not autodetected value */
3031 { 9600, SNDRV_PCM_RATE_KNOT
, 0x0400 }, /* 1/5 x 48 */
3033 { 0 } /* terminator */
3037 * snd_hda_calc_stream_format - calculate format bitset
3038 * @rate: the sample rate
3039 * @channels: the number of channels
3040 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3041 * @maxbps: the max. bps
3043 * Calculate the format bitset from the given rate, channels and th PCM format.
3045 * Return zero if invalid.
3047 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
3048 unsigned int channels
,
3049 unsigned int format
,
3050 unsigned int maxbps
)
3053 unsigned int val
= 0;
3055 for (i
= 0; rate_bits
[i
].hz
; i
++)
3056 if (rate_bits
[i
].hz
== rate
) {
3057 val
= rate_bits
[i
].hda_fmt
;
3060 if (!rate_bits
[i
].hz
) {
3061 snd_printdd("invalid rate %d\n", rate
);
3065 if (channels
== 0 || channels
> 8) {
3066 snd_printdd("invalid channels %d\n", channels
);
3069 val
|= channels
- 1;
3071 switch (snd_pcm_format_width(format
)) {
3081 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
3083 else if (maxbps
>= 24)
3089 snd_printdd("invalid format width %d\n",
3090 snd_pcm_format_width(format
));
3096 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
3098 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3100 unsigned int val
= 0;
3101 if (nid
!= codec
->afg
&&
3102 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
3103 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
3104 if (!val
|| val
== -1)
3105 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
3106 if (!val
|| val
== -1)
3111 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3113 return query_caps_hash(codec
, nid
, HDA_HASH_PARPCM_KEY(nid
),
3117 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3119 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
3120 if (!streams
|| streams
== -1)
3121 streams
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
3122 if (!streams
|| streams
== -1)
3127 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3129 return query_caps_hash(codec
, nid
, HDA_HASH_PARSTR_KEY(nid
),
3134 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3135 * @codec: the HDA codec
3136 * @nid: NID to query
3137 * @ratesp: the pointer to store the detected rate bitflags
3138 * @formatsp: the pointer to store the detected formats
3139 * @bpsp: the pointer to store the detected format widths
3141 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3142 * or @bsps argument is ignored.
3144 * Returns 0 if successful, otherwise a negative error code.
3146 static int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
3147 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
3149 unsigned int i
, val
, wcaps
;
3151 wcaps
= get_wcaps(codec
, nid
);
3152 val
= query_pcm_param(codec
, nid
);
3156 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
3158 rates
|= rate_bits
[i
].alsa_bits
;
3161 snd_printk(KERN_ERR
"hda_codec: rates == 0 "
3162 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3164 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
3170 if (formatsp
|| bpsp
) {
3172 unsigned int streams
, bps
;
3174 streams
= query_stream_param(codec
, nid
);
3179 if (streams
& AC_SUPFMT_PCM
) {
3180 if (val
& AC_SUPPCM_BITS_8
) {
3181 formats
|= SNDRV_PCM_FMTBIT_U8
;
3184 if (val
& AC_SUPPCM_BITS_16
) {
3185 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
3188 if (wcaps
& AC_WCAP_DIGITAL
) {
3189 if (val
& AC_SUPPCM_BITS_32
)
3190 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
3191 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
3192 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3193 if (val
& AC_SUPPCM_BITS_24
)
3195 else if (val
& AC_SUPPCM_BITS_20
)
3197 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
3198 AC_SUPPCM_BITS_32
)) {
3199 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3200 if (val
& AC_SUPPCM_BITS_32
)
3202 else if (val
& AC_SUPPCM_BITS_24
)
3204 else if (val
& AC_SUPPCM_BITS_20
)
3208 if (streams
& AC_SUPFMT_FLOAT32
) {
3209 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
3213 if (streams
== AC_SUPFMT_AC3
) {
3214 /* should be exclusive */
3215 /* temporary hack: we have still no proper support
3216 * for the direct AC3 stream...
3218 formats
|= SNDRV_PCM_FMTBIT_U8
;
3222 snd_printk(KERN_ERR
"hda_codec: formats == 0 "
3223 "(nid=0x%x, val=0x%x, ovrd=%i, "
3226 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
3231 *formatsp
= formats
;
3240 * snd_hda_is_supported_format - Check the validity of the format
3241 * @codec: HD-audio codec
3242 * @nid: NID to check
3243 * @format: the HD-audio format value to check
3245 * Check whether the given node supports the format value.
3247 * Returns 1 if supported, 0 if not.
3249 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
3250 unsigned int format
)
3253 unsigned int val
= 0, rate
, stream
;
3255 val
= query_pcm_param(codec
, nid
);
3259 rate
= format
& 0xff00;
3260 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
3261 if (rate_bits
[i
].hda_fmt
== rate
) {
3266 if (i
>= AC_PAR_PCM_RATE_BITS
)
3269 stream
= query_stream_param(codec
, nid
);
3273 if (stream
& AC_SUPFMT_PCM
) {
3274 switch (format
& 0xf0) {
3276 if (!(val
& AC_SUPPCM_BITS_8
))
3280 if (!(val
& AC_SUPPCM_BITS_16
))
3284 if (!(val
& AC_SUPPCM_BITS_20
))
3288 if (!(val
& AC_SUPPCM_BITS_24
))
3292 if (!(val
& AC_SUPPCM_BITS_32
))
3299 /* FIXME: check for float32 and AC3? */
3304 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
3309 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
3310 struct hda_codec
*codec
,
3311 struct snd_pcm_substream
*substream
)
3316 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
3317 struct hda_codec
*codec
,
3318 unsigned int stream_tag
,
3319 unsigned int format
,
3320 struct snd_pcm_substream
*substream
)
3322 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
3326 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
3327 struct hda_codec
*codec
,
3328 struct snd_pcm_substream
*substream
)
3330 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
3334 static int set_pcm_default_values(struct hda_codec
*codec
,
3335 struct hda_pcm_stream
*info
)
3339 /* query support PCM information from the given NID */
3340 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
3341 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
3342 info
->rates
? NULL
: &info
->rates
,
3343 info
->formats
? NULL
: &info
->formats
,
3344 info
->maxbps
? NULL
: &info
->maxbps
);
3348 if (info
->ops
.open
== NULL
)
3349 info
->ops
.open
= hda_pcm_default_open_close
;
3350 if (info
->ops
.close
== NULL
)
3351 info
->ops
.close
= hda_pcm_default_open_close
;
3352 if (info
->ops
.prepare
== NULL
) {
3353 if (snd_BUG_ON(!info
->nid
))
3355 info
->ops
.prepare
= hda_pcm_default_prepare
;
3357 if (info
->ops
.cleanup
== NULL
) {
3358 if (snd_BUG_ON(!info
->nid
))
3360 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
3366 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
3367 "Audio", "SPDIF", "HDMI", "Modem"
3371 * get the empty PCM device number to assign
3373 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3375 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
3377 /* audio device indices; not linear to keep compatibility */
3378 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
3379 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
3380 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
3381 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
3382 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
3386 if (type
>= HDA_PCM_NTYPES
) {
3387 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
3391 for (i
= 0; audio_idx
[type
][i
] >= 0 ; i
++)
3392 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
3393 return audio_idx
[type
][i
];
3395 snd_printk(KERN_WARNING
"Too many %s devices\n",
3396 snd_hda_pcm_type_name
[type
]);
3401 * attach a new PCM stream
3403 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
3405 struct hda_bus
*bus
= codec
->bus
;
3406 struct hda_pcm_stream
*info
;
3409 if (snd_BUG_ON(!pcm
->name
))
3411 for (stream
= 0; stream
< 2; stream
++) {
3412 info
= &pcm
->stream
[stream
];
3413 if (info
->substreams
) {
3414 err
= set_pcm_default_values(codec
, info
);
3419 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
3422 /* assign all PCMs of the given codec */
3423 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
3428 if (!codec
->num_pcms
) {
3429 if (!codec
->patch_ops
.build_pcms
)
3431 err
= codec
->patch_ops
.build_pcms(codec
);
3433 printk(KERN_ERR
"hda_codec: cannot build PCMs"
3434 "for #%d (error %d)\n", codec
->addr
, err
);
3435 err
= snd_hda_codec_reset(codec
);
3438 "hda_codec: cannot revert codec\n");
3443 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
3444 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
3447 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
3448 continue; /* no substreams assigned */
3451 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
3453 continue; /* no fatal error */
3455 err
= snd_hda_attach_pcm(codec
, cpcm
);
3457 printk(KERN_ERR
"hda_codec: cannot attach "
3458 "PCM stream %d for codec #%d\n",
3460 continue; /* no fatal error */
3468 * snd_hda_build_pcms - build PCM information
3471 * Create PCM information for each codec included in the bus.
3473 * The build_pcms codec patch is requested to set up codec->num_pcms and
3474 * codec->pcm_info properly. The array is referred by the top-level driver
3475 * to create its PCM instances.
3476 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3479 * At least, substreams, channels_min and channels_max must be filled for
3480 * each stream. substreams = 0 indicates that the stream doesn't exist.
3481 * When rates and/or formats are zero, the supported values are queried
3482 * from the given nid. The nid is used also by the default ops.prepare
3483 * and ops.cleanup callbacks.
3485 * The driver needs to call ops.open in its open callback. Similarly,
3486 * ops.close is supposed to be called in the close callback.
3487 * ops.prepare should be called in the prepare or hw_params callback
3488 * with the proper parameters for set up.
3489 * ops.cleanup should be called in hw_free for clean up of streams.
3491 * This function returns 0 if successfull, or a negative error code.
3493 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
3495 struct hda_codec
*codec
;
3497 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3498 int err
= snd_hda_codec_build_pcms(codec
);
3504 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
3507 * snd_hda_check_board_config - compare the current codec with the config table
3508 * @codec: the HDA codec
3509 * @num_configs: number of config enums
3510 * @models: array of model name strings
3511 * @tbl: configuration table, terminated by null entries
3513 * Compares the modelname or PCI subsystem id of the current codec with the
3514 * given configuration table. If a matching entry is found, returns its
3515 * config value (supposed to be 0 or positive).
3517 * If no entries are matching, the function returns a negative value.
3519 int snd_hda_check_board_config(struct hda_codec
*codec
,
3520 int num_configs
, const char **models
,
3521 const struct snd_pci_quirk
*tbl
)
3523 if (codec
->modelname
&& models
) {
3525 for (i
= 0; i
< num_configs
; i
++) {
3527 !strcmp(codec
->modelname
, models
[i
])) {
3528 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
3529 "selected\n", models
[i
]);
3535 if (!codec
->bus
->pci
|| !tbl
)
3538 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
3541 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3542 #ifdef CONFIG_SND_DEBUG_VERBOSE
3544 const char *model
= NULL
;
3546 model
= models
[tbl
->value
];
3548 sprintf(tmp
, "#%d", tbl
->value
);
3551 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3552 "for config %x:%x (%s)\n",
3553 model
, tbl
->subvendor
, tbl
->subdevice
,
3554 (tbl
->name
? tbl
->name
: "Unknown device"));
3560 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
3563 * snd_hda_check_board_codec_sid_config - compare the current codec
3564 subsystem ID with the
3567 This is important for Gateway notebooks with SB450 HDA Audio
3568 where the vendor ID of the PCI device is:
3569 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3570 and the vendor/subvendor are found only at the codec.
3572 * @codec: the HDA codec
3573 * @num_configs: number of config enums
3574 * @models: array of model name strings
3575 * @tbl: configuration table, terminated by null entries
3577 * Compares the modelname or PCI subsystem id of the current codec with the
3578 * given configuration table. If a matching entry is found, returns its
3579 * config value (supposed to be 0 or positive).
3581 * If no entries are matching, the function returns a negative value.
3583 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
3584 int num_configs
, const char **models
,
3585 const struct snd_pci_quirk
*tbl
)
3587 const struct snd_pci_quirk
*q
;
3589 /* Search for codec ID */
3590 for (q
= tbl
; q
->subvendor
; q
++) {
3591 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
3593 if (vendorid
== codec
->subsystem_id
)
3602 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3603 #ifdef CONFIG_SND_DEBUG_VERBOSE
3605 const char *model
= NULL
;
3607 model
= models
[tbl
->value
];
3609 sprintf(tmp
, "#%d", tbl
->value
);
3612 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3613 "for config %x:%x (%s)\n",
3614 model
, tbl
->subvendor
, tbl
->subdevice
,
3615 (tbl
->name
? tbl
->name
: "Unknown device"));
3621 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
3624 * snd_hda_add_new_ctls - create controls from the array
3625 * @codec: the HDA codec
3626 * @knew: the array of struct snd_kcontrol_new
3628 * This helper function creates and add new controls in the given array.
3629 * The array must be terminated with an empty entry as terminator.
3631 * Returns 0 if successful, or a negative error code.
3633 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
3637 for (; knew
->name
; knew
++) {
3638 struct snd_kcontrol
*kctl
;
3639 if (knew
->iface
== -1) /* skip this codec private value */
3641 kctl
= snd_ctl_new1(knew
, codec
);
3644 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3648 kctl
= snd_ctl_new1(knew
, codec
);
3651 kctl
->id
.device
= codec
->addr
;
3652 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3659 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
3661 #ifdef CONFIG_SND_HDA_POWER_SAVE
3662 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
3663 unsigned int power_state
);
3665 static void hda_power_work(struct work_struct
*work
)
3667 struct hda_codec
*codec
=
3668 container_of(work
, struct hda_codec
, power_work
.work
);
3669 struct hda_bus
*bus
= codec
->bus
;
3671 if (!codec
->power_on
|| codec
->power_count
) {
3672 codec
->power_transition
= 0;
3676 hda_call_codec_suspend(codec
);
3677 if (bus
->ops
.pm_notify
)
3678 bus
->ops
.pm_notify(bus
);
3681 static void hda_keep_power_on(struct hda_codec
*codec
)
3683 codec
->power_count
++;
3684 codec
->power_on
= 1;
3685 codec
->power_jiffies
= jiffies
;
3688 /* update the power on/off account with the current jiffies */
3689 void snd_hda_update_power_acct(struct hda_codec
*codec
)
3691 unsigned long delta
= jiffies
- codec
->power_jiffies
;
3692 if (codec
->power_on
)
3693 codec
->power_on_acct
+= delta
;
3695 codec
->power_off_acct
+= delta
;
3696 codec
->power_jiffies
+= delta
;
3700 * snd_hda_power_up - Power-up the codec
3701 * @codec: HD-audio codec
3703 * Increment the power-up counter and power up the hardware really when
3704 * not turned on yet.
3706 void snd_hda_power_up(struct hda_codec
*codec
)
3708 struct hda_bus
*bus
= codec
->bus
;
3710 codec
->power_count
++;
3711 if (codec
->power_on
|| codec
->power_transition
)
3714 snd_hda_update_power_acct(codec
);
3715 codec
->power_on
= 1;
3716 codec
->power_jiffies
= jiffies
;
3717 if (bus
->ops
.pm_notify
)
3718 bus
->ops
.pm_notify(bus
);
3719 hda_call_codec_resume(codec
);
3720 cancel_delayed_work(&codec
->power_work
);
3721 codec
->power_transition
= 0;
3723 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
3725 #define power_save(codec) \
3726 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3729 * snd_hda_power_down - Power-down the codec
3730 * @codec: HD-audio codec
3732 * Decrement the power-up counter and schedules the power-off work if
3733 * the counter rearches to zero.
3735 void snd_hda_power_down(struct hda_codec
*codec
)
3737 --codec
->power_count
;
3738 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
3740 if (power_save(codec
)) {
3741 codec
->power_transition
= 1; /* avoid reentrance */
3742 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
3743 msecs_to_jiffies(power_save(codec
) * 1000));
3746 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
3749 * snd_hda_check_amp_list_power - Check the amp list and update the power
3750 * @codec: HD-audio codec
3751 * @check: the object containing an AMP list and the status
3752 * @nid: NID to check / update
3754 * Check whether the given NID is in the amp list. If it's in the list,
3755 * check the current AMP status, and update the the power-status according
3756 * to the mute status.
3758 * This function is supposed to be set or called from the check_power_status
3761 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
3762 struct hda_loopback_check
*check
,
3765 struct hda_amp_list
*p
;
3768 if (!check
->amplist
)
3770 for (p
= check
->amplist
; p
->nid
; p
++) {
3775 return 0; /* nothing changed */
3777 for (p
= check
->amplist
; p
->nid
; p
++) {
3778 for (ch
= 0; ch
< 2; ch
++) {
3779 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
3781 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
3782 if (!check
->power_on
) {
3783 check
->power_on
= 1;
3784 snd_hda_power_up(codec
);
3790 if (check
->power_on
) {
3791 check
->power_on
= 0;
3792 snd_hda_power_down(codec
);
3796 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
3800 * Channel mode helper
3804 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3806 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
3807 struct snd_ctl_elem_info
*uinfo
,
3808 const struct hda_channel_mode
*chmode
,
3811 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3813 uinfo
->value
.enumerated
.items
= num_chmodes
;
3814 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
3815 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
3816 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
3817 chmode
[uinfo
->value
.enumerated
.item
].channels
);
3820 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
3823 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3825 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
3826 struct snd_ctl_elem_value
*ucontrol
,
3827 const struct hda_channel_mode
*chmode
,
3833 for (i
= 0; i
< num_chmodes
; i
++) {
3834 if (max_channels
== chmode
[i
].channels
) {
3835 ucontrol
->value
.enumerated
.item
[0] = i
;
3841 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
3844 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3846 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
3847 struct snd_ctl_elem_value
*ucontrol
,
3848 const struct hda_channel_mode
*chmode
,
3854 mode
= ucontrol
->value
.enumerated
.item
[0];
3855 if (mode
>= num_chmodes
)
3857 if (*max_channelsp
== chmode
[mode
].channels
)
3859 /* change the current channel setting */
3860 *max_channelsp
= chmode
[mode
].channels
;
3861 if (chmode
[mode
].sequence
)
3862 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
3865 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
3872 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3874 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
3875 struct snd_ctl_elem_info
*uinfo
)
3879 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3881 uinfo
->value
.enumerated
.items
= imux
->num_items
;
3882 if (!imux
->num_items
)
3884 index
= uinfo
->value
.enumerated
.item
;
3885 if (index
>= imux
->num_items
)
3886 index
= imux
->num_items
- 1;
3887 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
3890 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
3893 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3895 int snd_hda_input_mux_put(struct hda_codec
*codec
,
3896 const struct hda_input_mux
*imux
,
3897 struct snd_ctl_elem_value
*ucontrol
,
3899 unsigned int *cur_val
)
3903 if (!imux
->num_items
)
3905 idx
= ucontrol
->value
.enumerated
.item
[0];
3906 if (idx
>= imux
->num_items
)
3907 idx
= imux
->num_items
- 1;
3908 if (*cur_val
== idx
)
3910 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
3911 imux
->items
[idx
].index
);
3915 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
3919 * Multi-channel / digital-out PCM helper functions
3922 /* setup SPDIF output stream */
3923 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
3924 unsigned int stream_tag
, unsigned int format
)
3926 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3927 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3928 set_dig_out_convert(codec
, nid
,
3929 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff,
3931 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
3932 if (codec
->slave_dig_outs
) {
3934 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3935 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
3938 /* turn on again (if needed) */
3939 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3940 set_dig_out_convert(codec
, nid
,
3941 codec
->spdif_ctls
& 0xff, -1);
3944 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
3946 snd_hda_codec_cleanup_stream(codec
, nid
);
3947 if (codec
->slave_dig_outs
) {
3949 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3950 snd_hda_codec_cleanup_stream(codec
, *d
);
3955 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3956 * @bus: HD-audio bus
3958 void snd_hda_bus_reboot_notify(struct hda_bus
*bus
)
3960 struct hda_codec
*codec
;
3964 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3965 #ifdef CONFIG_SND_HDA_POWER_SAVE
3966 if (!codec
->power_on
)
3969 if (codec
->patch_ops
.reboot_notify
)
3970 codec
->patch_ops
.reboot_notify(codec
);
3973 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify
);
3976 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3978 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
3979 struct hda_multi_out
*mout
)
3981 mutex_lock(&codec
->spdif_mutex
);
3982 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
3983 /* already opened as analog dup; reset it once */
3984 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3985 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
3986 mutex_unlock(&codec
->spdif_mutex
);
3989 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
3992 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3994 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
3995 struct hda_multi_out
*mout
,
3996 unsigned int stream_tag
,
3997 unsigned int format
,
3998 struct snd_pcm_substream
*substream
)
4000 mutex_lock(&codec
->spdif_mutex
);
4001 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
4002 mutex_unlock(&codec
->spdif_mutex
);
4005 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
4008 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4010 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
4011 struct hda_multi_out
*mout
)
4013 mutex_lock(&codec
->spdif_mutex
);
4014 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4015 mutex_unlock(&codec
->spdif_mutex
);
4018 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
4021 * snd_hda_multi_out_dig_close - release the digital out stream
4023 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
4024 struct hda_multi_out
*mout
)
4026 mutex_lock(&codec
->spdif_mutex
);
4027 mout
->dig_out_used
= 0;
4028 mutex_unlock(&codec
->spdif_mutex
);
4031 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
4034 * snd_hda_multi_out_analog_open - open analog outputs
4036 * Open analog outputs and set up the hw-constraints.
4037 * If the digital outputs can be opened as slave, open the digital
4040 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
4041 struct hda_multi_out
*mout
,
4042 struct snd_pcm_substream
*substream
,
4043 struct hda_pcm_stream
*hinfo
)
4045 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
4046 runtime
->hw
.channels_max
= mout
->max_channels
;
4047 if (mout
->dig_out_nid
) {
4048 if (!mout
->analog_rates
) {
4049 mout
->analog_rates
= hinfo
->rates
;
4050 mout
->analog_formats
= hinfo
->formats
;
4051 mout
->analog_maxbps
= hinfo
->maxbps
;
4053 runtime
->hw
.rates
= mout
->analog_rates
;
4054 runtime
->hw
.formats
= mout
->analog_formats
;
4055 hinfo
->maxbps
= mout
->analog_maxbps
;
4057 if (!mout
->spdif_rates
) {
4058 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
4060 &mout
->spdif_formats
,
4061 &mout
->spdif_maxbps
);
4063 mutex_lock(&codec
->spdif_mutex
);
4064 if (mout
->share_spdif
) {
4065 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
4066 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
4067 runtime
->hw
.rates
&= mout
->spdif_rates
;
4068 runtime
->hw
.formats
&= mout
->spdif_formats
;
4069 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
4070 hinfo
->maxbps
= mout
->spdif_maxbps
;
4072 mout
->share_spdif
= 0;
4073 /* FIXME: need notify? */
4076 mutex_unlock(&codec
->spdif_mutex
);
4078 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
4079 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
4081 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
4084 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4086 * Set up the i/o for analog out.
4087 * When the digital out is available, copy the front out to digital out, too.
4089 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
4090 struct hda_multi_out
*mout
,
4091 unsigned int stream_tag
,
4092 unsigned int format
,
4093 struct snd_pcm_substream
*substream
)
4095 hda_nid_t
*nids
= mout
->dac_nids
;
4096 int chs
= substream
->runtime
->channels
;
4099 mutex_lock(&codec
->spdif_mutex
);
4100 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
4101 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
4103 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
4105 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
4106 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
4107 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
4108 stream_tag
, format
);
4110 mout
->dig_out_used
= 0;
4111 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4114 mutex_unlock(&codec
->spdif_mutex
);
4117 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
4119 if (!mout
->no_share_stream
&&
4120 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
4121 /* headphone out will just decode front left/right (stereo) */
4122 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
4124 /* extra outputs copied from front */
4125 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4126 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
4127 snd_hda_codec_setup_stream(codec
,
4128 mout
->extra_out_nid
[i
],
4129 stream_tag
, 0, format
);
4132 for (i
= 1; i
< mout
->num_dacs
; i
++) {
4133 if (chs
>= (i
+ 1) * 2) /* independent out */
4134 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4136 else if (!mout
->no_share_stream
) /* copy front */
4137 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4142 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
4145 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4147 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
4148 struct hda_multi_out
*mout
)
4150 hda_nid_t
*nids
= mout
->dac_nids
;
4153 for (i
= 0; i
< mout
->num_dacs
; i
++)
4154 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
4156 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
4157 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4158 if (mout
->extra_out_nid
[i
])
4159 snd_hda_codec_cleanup_stream(codec
,
4160 mout
->extra_out_nid
[i
]);
4161 mutex_lock(&codec
->spdif_mutex
);
4162 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
4163 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4164 mout
->dig_out_used
= 0;
4166 mutex_unlock(&codec
->spdif_mutex
);
4169 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
4172 * Helper for automatic pin configuration
4175 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
4177 for (; *list
; list
++)
4185 * Sort an associated group of pins according to their sequence numbers.
4187 static void sort_pins_by_sequence(hda_nid_t
*pins
, short *sequences
,
4194 for (i
= 0; i
< num_pins
; i
++) {
4195 for (j
= i
+ 1; j
< num_pins
; j
++) {
4196 if (sequences
[i
] > sequences
[j
]) {
4198 sequences
[i
] = sequences
[j
];
4210 * Parse all pin widgets and store the useful pin nids to cfg
4212 * The number of line-outs or any primary output is stored in line_outs,
4213 * and the corresponding output pins are assigned to line_out_pins[],
4214 * in the order of front, rear, CLFE, side, ...
4216 * If more extra outputs (speaker and headphone) are found, the pins are
4217 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4218 * is detected, one of speaker of HP pins is assigned as the primary
4219 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4220 * if any analog output exists.
4222 * The analog input pins are assigned to input_pins array.
4223 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4226 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
4227 struct auto_pin_cfg
*cfg
,
4228 hda_nid_t
*ignore_nids
)
4230 hda_nid_t nid
, end_nid
;
4231 short seq
, assoc_line_out
, assoc_speaker
;
4232 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
4233 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
4234 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
4236 memset(cfg
, 0, sizeof(*cfg
));
4238 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
4239 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
4240 memset(sequences_hp
, 0, sizeof(sequences_hp
));
4241 assoc_line_out
= assoc_speaker
= 0;
4243 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
4244 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
4245 unsigned int wid_caps
= get_wcaps(codec
, nid
);
4246 unsigned int wid_type
= get_wcaps_type(wid_caps
);
4247 unsigned int def_conf
;
4250 /* read all default configuration for pin complex */
4251 if (wid_type
!= AC_WID_PIN
)
4253 /* ignore the given nids (e.g. pc-beep returns error) */
4254 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
4257 def_conf
= snd_hda_codec_get_pincfg(codec
, nid
);
4258 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
4260 loc
= get_defcfg_location(def_conf
);
4261 switch (get_defcfg_device(def_conf
)) {
4262 case AC_JACK_LINE_OUT
:
4263 seq
= get_defcfg_sequence(def_conf
);
4264 assoc
= get_defcfg_association(def_conf
);
4266 if (!(wid_caps
& AC_WCAP_STEREO
))
4267 if (!cfg
->mono_out_pin
)
4268 cfg
->mono_out_pin
= nid
;
4271 if (!assoc_line_out
)
4272 assoc_line_out
= assoc
;
4273 else if (assoc_line_out
!= assoc
)
4275 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
4277 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
4278 sequences_line_out
[cfg
->line_outs
] = seq
;
4281 case AC_JACK_SPEAKER
:
4282 seq
= get_defcfg_sequence(def_conf
);
4283 assoc
= get_defcfg_association(def_conf
);
4287 assoc_speaker
= assoc
;
4288 else if (assoc_speaker
!= assoc
)
4290 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
4292 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
4293 sequences_speaker
[cfg
->speaker_outs
] = seq
;
4294 cfg
->speaker_outs
++;
4296 case AC_JACK_HP_OUT
:
4297 seq
= get_defcfg_sequence(def_conf
);
4298 assoc
= get_defcfg_association(def_conf
);
4299 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
4301 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
4302 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
4305 case AC_JACK_MIC_IN
: {
4307 if (loc
== AC_JACK_LOC_FRONT
||
4308 (loc
& 0x30) == AC_JACK_LOC_INTERNAL
) {
4309 preferred
= AUTO_PIN_FRONT_MIC
;
4312 preferred
= AUTO_PIN_MIC
;
4313 alt
= AUTO_PIN_FRONT_MIC
;
4315 if (!cfg
->input_pins
[preferred
])
4316 cfg
->input_pins
[preferred
] = nid
;
4317 else if (!cfg
->input_pins
[alt
])
4318 cfg
->input_pins
[alt
] = nid
;
4321 case AC_JACK_LINE_IN
:
4322 if (loc
== AC_JACK_LOC_FRONT
)
4323 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
4325 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
4328 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
4331 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
4333 case AC_JACK_SPDIF_OUT
:
4334 case AC_JACK_DIG_OTHER_OUT
:
4335 if (cfg
->dig_outs
>= ARRAY_SIZE(cfg
->dig_out_pins
))
4337 cfg
->dig_out_pins
[cfg
->dig_outs
] = nid
;
4338 cfg
->dig_out_type
[cfg
->dig_outs
] =
4339 (loc
== AC_JACK_LOC_HDMI
) ?
4340 HDA_PCM_TYPE_HDMI
: HDA_PCM_TYPE_SPDIF
;
4343 case AC_JACK_SPDIF_IN
:
4344 case AC_JACK_DIG_OTHER_IN
:
4345 cfg
->dig_in_pin
= nid
;
4346 if (loc
== AC_JACK_LOC_HDMI
)
4347 cfg
->dig_in_type
= HDA_PCM_TYPE_HDMI
;
4349 cfg
->dig_in_type
= HDA_PCM_TYPE_SPDIF
;
4355 * If no line-out is defined but multiple HPs are found,
4356 * some of them might be the real line-outs.
4358 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1) {
4360 while (i
< cfg
->hp_outs
) {
4361 /* The real HPs should have the sequence 0x0f */
4362 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
4366 /* Move it to the line-out table */
4367 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
4368 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
4371 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
4372 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
4373 memmove(sequences_hp
+ i
- 1, sequences_hp
+ i
,
4374 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
4378 /* sort by sequence */
4379 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
4381 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
4383 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
4386 /* if we have only one mic, make it AUTO_PIN_MIC */
4387 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
4388 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
4389 cfg
->input_pins
[AUTO_PIN_MIC
] =
4390 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
4391 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
4393 /* ditto for line-in */
4394 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
4395 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
4396 cfg
->input_pins
[AUTO_PIN_LINE
] =
4397 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
4398 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
4402 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4403 * as a primary output
4405 if (!cfg
->line_outs
) {
4406 if (cfg
->speaker_outs
) {
4407 cfg
->line_outs
= cfg
->speaker_outs
;
4408 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
4409 sizeof(cfg
->speaker_pins
));
4410 cfg
->speaker_outs
= 0;
4411 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
4412 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
4413 } else if (cfg
->hp_outs
) {
4414 cfg
->line_outs
= cfg
->hp_outs
;
4415 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
4416 sizeof(cfg
->hp_pins
));
4418 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4419 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4423 /* Reorder the surround channels
4424 * ALSA sequence is front/surr/clfe/side
4426 * 4-ch: front/surr => OK as it is
4427 * 6-ch: front/clfe/surr
4428 * 8-ch: front/clfe/rear/side|fc
4430 switch (cfg
->line_outs
) {
4433 nid
= cfg
->line_out_pins
[1];
4434 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
4435 cfg
->line_out_pins
[2] = nid
;
4440 * debug prints of the parsed results
4442 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4443 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
4444 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
4445 cfg
->line_out_pins
[4]);
4446 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4447 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
4448 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
4449 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
4450 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4451 cfg
->hp_outs
, cfg
->hp_pins
[0],
4452 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
4453 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
4454 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
4456 snd_printd(" dig-out=0x%x/0x%x\n",
4457 cfg
->dig_out_pins
[0], cfg
->dig_out_pins
[1]);
4458 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4459 " cd=0x%x, aux=0x%x\n",
4460 cfg
->input_pins
[AUTO_PIN_MIC
],
4461 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
4462 cfg
->input_pins
[AUTO_PIN_LINE
],
4463 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
4464 cfg
->input_pins
[AUTO_PIN_CD
],
4465 cfg
->input_pins
[AUTO_PIN_AUX
]);
4466 if (cfg
->dig_in_pin
)
4467 snd_printd(" dig-in=0x%x\n", cfg
->dig_in_pin
);
4471 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config
);
4473 /* labels for input pins */
4474 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
4475 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4477 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels
);
4486 * snd_hda_suspend - suspend the codecs
4489 * Returns 0 if successful.
4491 int snd_hda_suspend(struct hda_bus
*bus
)
4493 struct hda_codec
*codec
;
4495 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4496 #ifdef CONFIG_SND_HDA_POWER_SAVE
4497 if (!codec
->power_on
)
4500 hda_call_codec_suspend(codec
);
4504 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
4507 * snd_hda_resume - resume the codecs
4510 * Returns 0 if successful.
4512 * This fucntion is defined only when POWER_SAVE isn't set.
4513 * In the power-save mode, the codec is resumed dynamically.
4515 int snd_hda_resume(struct hda_bus
*bus
)
4517 struct hda_codec
*codec
;
4519 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4520 if (snd_hda_codec_needs_resume(codec
))
4521 hda_call_codec_resume(codec
);
4525 EXPORT_SYMBOL_HDA(snd_hda_resume
);
4526 #endif /* CONFIG_PM */
4533 * snd_array_new - get a new element from the given array
4534 * @array: the array object
4536 * Get a new element from the given array. If it exceeds the
4537 * pre-allocated array size, re-allocate the array.
4539 * Returns NULL if allocation failed.
4541 void *snd_array_new(struct snd_array
*array
)
4543 if (array
->used
>= array
->alloced
) {
4544 int num
= array
->alloced
+ array
->alloc_align
;
4546 if (snd_BUG_ON(num
>= 4096))
4548 nlist
= kcalloc(num
+ 1, array
->elem_size
, GFP_KERNEL
);
4552 memcpy(nlist
, array
->list
,
4553 array
->elem_size
* array
->alloced
);
4556 array
->list
= nlist
;
4557 array
->alloced
= num
;
4559 return snd_array_elem(array
, array
->used
++);
4561 EXPORT_SYMBOL_HDA(snd_array_new
);
4564 * snd_array_free - free the given array elements
4565 * @array: the array object
4567 void snd_array_free(struct snd_array
*array
)
4574 EXPORT_SYMBOL_HDA(snd_array_free
);
4577 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4578 * @pcm: PCM caps bits
4579 * @buf: the string buffer to write
4580 * @buflen: the max buffer length
4582 * used by hda_proc.c and hda_eld.c
4584 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
4586 static unsigned int rates
[] = {
4587 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4588 96000, 176400, 192000, 384000
4592 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
4594 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
4596 buf
[j
] = '\0'; /* necessary when j == 0 */
4598 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
4601 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4602 * @pcm: PCM caps bits
4603 * @buf: the string buffer to write
4604 * @buflen: the max buffer length
4606 * used by hda_proc.c and hda_eld.c
4608 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
4610 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
4613 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
4614 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
4615 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
4617 buf
[j
] = '\0'; /* necessary when j == 0 */
4619 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
4621 MODULE_DESCRIPTION("HDA codec core");
4622 MODULE_LICENSE("GPL");