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"
33 #include <sound/hda_hwdep.h>
35 #ifdef CONFIG_SND_HDA_POWER_SAVE
36 /* define this option here to hide as static */
37 static int power_save
= CONFIG_SND_HDA_POWER_SAVE_DEFAULT
;
38 module_param(power_save
, int, 0644);
39 MODULE_PARM_DESC(power_save
, "Automatic power-saving timeout "
40 "(in second, 0 = disable).");
44 * vendor / preset table
47 struct hda_vendor_id
{
52 /* codec vendor labels */
53 static struct hda_vendor_id hda_vendor_ids
[] = {
54 { 0x10ec, "Realtek" },
55 { 0x1057, "Motorola" },
58 { 0x11d4, "Analog Devices" },
59 { 0x13f6, "C-Media" },
60 { 0x14f1, "Conexant" },
61 { 0x434d, "C-Media" },
62 { 0x8384, "SigmaTel" },
67 #include "hda_patch.h"
70 #ifdef CONFIG_SND_HDA_POWER_SAVE
71 static void hda_power_work(struct work_struct
*work
);
72 static void hda_keep_power_on(struct hda_codec
*codec
);
74 static inline void hda_keep_power_on(struct hda_codec
*codec
) {}
78 * snd_hda_codec_read - send a command and get the response
79 * @codec: the HDA codec
80 * @nid: NID to send the command
81 * @direct: direct flag
82 * @verb: the verb to send
83 * @parm: the parameter for the verb
85 * Send a single command and read the corresponding response.
87 * Returns the obtained response value, or -1 for an error.
89 unsigned int snd_hda_codec_read(struct hda_codec
*codec
, hda_nid_t nid
,
91 unsigned int verb
, unsigned int parm
)
94 snd_hda_power_up(codec
);
95 mutex_lock(&codec
->bus
->cmd_mutex
);
96 if (!codec
->bus
->ops
.command(codec
, nid
, direct
, verb
, parm
))
97 res
= codec
->bus
->ops
.get_response(codec
);
99 res
= (unsigned int)-1;
100 mutex_unlock(&codec
->bus
->cmd_mutex
);
101 snd_hda_power_down(codec
);
106 * snd_hda_codec_write - send a single command without waiting for response
107 * @codec: the HDA codec
108 * @nid: NID to send the command
109 * @direct: direct flag
110 * @verb: the verb to send
111 * @parm: the parameter for the verb
113 * Send a single command without waiting for response.
115 * Returns 0 if successful, or a negative error code.
117 int snd_hda_codec_write(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
118 unsigned int verb
, unsigned int parm
)
121 snd_hda_power_up(codec
);
122 mutex_lock(&codec
->bus
->cmd_mutex
);
123 err
= codec
->bus
->ops
.command(codec
, nid
, direct
, verb
, parm
);
124 mutex_unlock(&codec
->bus
->cmd_mutex
);
125 snd_hda_power_down(codec
);
130 * snd_hda_sequence_write - sequence writes
131 * @codec: the HDA codec
132 * @seq: VERB array to send
134 * Send the commands sequentially from the given array.
135 * The array must be terminated with NID=0.
137 void snd_hda_sequence_write(struct hda_codec
*codec
, const struct hda_verb
*seq
)
139 for (; seq
->nid
; seq
++)
140 snd_hda_codec_write(codec
, seq
->nid
, 0, seq
->verb
, seq
->param
);
144 * snd_hda_get_sub_nodes - get the range of sub nodes
145 * @codec: the HDA codec
147 * @start_id: the pointer to store the start NID
149 * Parse the NID and store the start NID of its sub-nodes.
150 * Returns the number of sub-nodes.
152 int snd_hda_get_sub_nodes(struct hda_codec
*codec
, hda_nid_t nid
,
157 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_NODE_COUNT
);
160 *start_id
= (parm
>> 16) & 0x7fff;
161 return (int)(parm
& 0x7fff);
165 * snd_hda_get_connections - get connection list
166 * @codec: the HDA codec
168 * @conn_list: connection list array
169 * @max_conns: max. number of connections to store
171 * Parses the connection list of the given widget and stores the list
174 * Returns the number of connections, or a negative error code.
176 int snd_hda_get_connections(struct hda_codec
*codec
, hda_nid_t nid
,
177 hda_nid_t
*conn_list
, int max_conns
)
180 int i
, conn_len
, conns
;
181 unsigned int shift
, num_elems
, mask
;
184 snd_assert(conn_list
&& max_conns
> 0, return -EINVAL
);
186 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_CONNLIST_LEN
);
187 if (parm
& AC_CLIST_LONG
) {
196 conn_len
= parm
& AC_CLIST_LENGTH
;
197 mask
= (1 << (shift
-1)) - 1;
200 return 0; /* no connection */
203 /* single connection */
204 parm
= snd_hda_codec_read(codec
, nid
, 0,
205 AC_VERB_GET_CONNECT_LIST
, 0);
206 conn_list
[0] = parm
& mask
;
210 /* multi connection */
213 for (i
= 0; i
< conn_len
; i
++) {
217 if (i
% num_elems
== 0)
218 parm
= snd_hda_codec_read(codec
, nid
, 0,
219 AC_VERB_GET_CONNECT_LIST
, i
);
220 range_val
= !!(parm
& (1 << (shift
-1))); /* ranges */
224 /* ranges between the previous and this one */
225 if (!prev_nid
|| prev_nid
>= val
) {
226 snd_printk(KERN_WARNING
"hda_codec: "
227 "invalid dep_range_val %x:%x\n",
231 for (n
= prev_nid
+ 1; n
<= val
; n
++) {
232 if (conns
>= max_conns
) {
234 "Too many connections\n");
237 conn_list
[conns
++] = n
;
240 if (conns
>= max_conns
) {
241 snd_printk(KERN_ERR
"Too many connections\n");
244 conn_list
[conns
++] = val
;
253 * snd_hda_queue_unsol_event - add an unsolicited event to queue
255 * @res: unsolicited event (lower 32bit of RIRB entry)
256 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
258 * Adds the given event to the queue. The events are processed in
259 * the workqueue asynchronously. Call this function in the interrupt
260 * hanlder when RIRB receives an unsolicited event.
262 * Returns 0 if successful, or a negative error code.
264 int snd_hda_queue_unsol_event(struct hda_bus
*bus
, u32 res
, u32 res_ex
)
266 struct hda_bus_unsolicited
*unsol
;
273 wp
= (unsol
->wp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
277 unsol
->queue
[wp
] = res
;
278 unsol
->queue
[wp
+ 1] = res_ex
;
280 schedule_work(&unsol
->work
);
286 * process queueud unsolicited events
288 static void process_unsol_events(struct work_struct
*work
)
290 struct hda_bus_unsolicited
*unsol
=
291 container_of(work
, struct hda_bus_unsolicited
, work
);
292 struct hda_bus
*bus
= unsol
->bus
;
293 struct hda_codec
*codec
;
294 unsigned int rp
, caddr
, res
;
296 while (unsol
->rp
!= unsol
->wp
) {
297 rp
= (unsol
->rp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
300 res
= unsol
->queue
[rp
];
301 caddr
= unsol
->queue
[rp
+ 1];
302 if (!(caddr
& (1 << 4))) /* no unsolicited event? */
304 codec
= bus
->caddr_tbl
[caddr
& 0x0f];
305 if (codec
&& codec
->patch_ops
.unsol_event
)
306 codec
->patch_ops
.unsol_event(codec
, res
);
311 * initialize unsolicited queue
313 static int __devinit
init_unsol_queue(struct hda_bus
*bus
)
315 struct hda_bus_unsolicited
*unsol
;
317 if (bus
->unsol
) /* already initialized */
320 unsol
= kzalloc(sizeof(*unsol
), GFP_KERNEL
);
322 snd_printk(KERN_ERR
"hda_codec: "
323 "can't allocate unsolicited queue\n");
326 INIT_WORK(&unsol
->work
, process_unsol_events
);
335 static void snd_hda_codec_free(struct hda_codec
*codec
);
337 static int snd_hda_bus_free(struct hda_bus
*bus
)
339 struct hda_codec
*codec
, *n
;
344 flush_scheduled_work();
347 list_for_each_entry_safe(codec
, n
, &bus
->codec_list
, list
) {
348 snd_hda_codec_free(codec
);
350 if (bus
->ops
.private_free
)
351 bus
->ops
.private_free(bus
);
356 static int snd_hda_bus_dev_free(struct snd_device
*device
)
358 struct hda_bus
*bus
= device
->device_data
;
359 return snd_hda_bus_free(bus
);
363 * snd_hda_bus_new - create a HDA bus
364 * @card: the card entry
365 * @temp: the template for hda_bus information
366 * @busp: the pointer to store the created bus instance
368 * Returns 0 if successful, or a negative error code.
370 int __devinit
snd_hda_bus_new(struct snd_card
*card
,
371 const struct hda_bus_template
*temp
,
372 struct hda_bus
**busp
)
376 static struct snd_device_ops dev_ops
= {
377 .dev_free
= snd_hda_bus_dev_free
,
380 snd_assert(temp
, return -EINVAL
);
381 snd_assert(temp
->ops
.command
&& temp
->ops
.get_response
, return -EINVAL
);
386 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
388 snd_printk(KERN_ERR
"can't allocate struct hda_bus\n");
393 bus
->private_data
= temp
->private_data
;
394 bus
->pci
= temp
->pci
;
395 bus
->modelname
= temp
->modelname
;
396 bus
->ops
= temp
->ops
;
398 mutex_init(&bus
->cmd_mutex
);
399 INIT_LIST_HEAD(&bus
->codec_list
);
401 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
403 snd_hda_bus_free(bus
);
411 #ifdef CONFIG_SND_HDA_GENERIC
412 #define is_generic_config(codec) \
413 (codec->bus->modelname && !strcmp(codec->bus->modelname, "generic"))
415 #define is_generic_config(codec) 0
419 * find a matching codec preset
421 static const struct hda_codec_preset __devinit
*
422 find_codec_preset(struct hda_codec
*codec
)
424 const struct hda_codec_preset
**tbl
, *preset
;
426 if (is_generic_config(codec
))
427 return NULL
; /* use the generic parser */
429 for (tbl
= hda_preset_tables
; *tbl
; tbl
++) {
430 for (preset
= *tbl
; preset
->id
; preset
++) {
431 u32 mask
= preset
->mask
;
432 if (preset
->afg
&& preset
->afg
!= codec
->afg
)
434 if (preset
->mfg
&& preset
->mfg
!= codec
->mfg
)
438 if (preset
->id
== (codec
->vendor_id
& mask
) &&
440 preset
->rev
== codec
->revision_id
))
448 * snd_hda_get_codec_name - store the codec name
450 void snd_hda_get_codec_name(struct hda_codec
*codec
,
451 char *name
, int namelen
)
453 const struct hda_vendor_id
*c
;
454 const char *vendor
= NULL
;
455 u16 vendor_id
= codec
->vendor_id
>> 16;
458 for (c
= hda_vendor_ids
; c
->id
; c
++) {
459 if (c
->id
== vendor_id
) {
465 sprintf(tmp
, "Generic %04x", vendor_id
);
468 if (codec
->preset
&& codec
->preset
->name
)
469 snprintf(name
, namelen
, "%s %s", vendor
, codec
->preset
->name
);
471 snprintf(name
, namelen
, "%s ID %x", vendor
,
472 codec
->vendor_id
& 0xffff);
476 * look for an AFG and MFG nodes
478 static void __devinit
setup_fg_nodes(struct hda_codec
*codec
)
483 total_nodes
= snd_hda_get_sub_nodes(codec
, AC_NODE_ROOT
, &nid
);
484 for (i
= 0; i
< total_nodes
; i
++, nid
++) {
486 func
= snd_hda_param_read(codec
, nid
, AC_PAR_FUNCTION_TYPE
);
487 switch (func
& 0xff) {
488 case AC_GRP_AUDIO_FUNCTION
:
491 case AC_GRP_MODEM_FUNCTION
:
501 * read widget caps for each widget and store in cache
503 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
508 codec
->num_nodes
= snd_hda_get_sub_nodes(codec
, fg_node
,
510 codec
->wcaps
= kmalloc(codec
->num_nodes
* 4, GFP_KERNEL
);
513 nid
= codec
->start_nid
;
514 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++)
515 codec
->wcaps
[i
] = snd_hda_param_read(codec
, nid
,
516 AC_PAR_AUDIO_WIDGET_CAP
);
521 static void init_hda_cache(struct hda_cache_rec
*cache
,
522 unsigned int record_size
);
523 static void free_hda_cache(struct hda_cache_rec
*cache
);
528 static void snd_hda_codec_free(struct hda_codec
*codec
)
532 #ifdef CONFIG_SND_HDA_POWER_SAVE
533 cancel_delayed_work(&codec
->power_work
);
534 flush_scheduled_work();
536 list_del(&codec
->list
);
537 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
538 if (codec
->patch_ops
.free
)
539 codec
->patch_ops
.free(codec
);
540 free_hda_cache(&codec
->amp_cache
);
541 free_hda_cache(&codec
->cmd_cache
);
547 * snd_hda_codec_new - create a HDA codec
548 * @bus: the bus to assign
549 * @codec_addr: the codec address
550 * @codecp: the pointer to store the generated codec
552 * Returns 0 if successful, or a negative error code.
554 int __devinit
snd_hda_codec_new(struct hda_bus
*bus
, unsigned int codec_addr
,
555 struct hda_codec
**codecp
)
557 struct hda_codec
*codec
;
561 snd_assert(bus
, return -EINVAL
);
562 snd_assert(codec_addr
<= HDA_MAX_CODEC_ADDRESS
, return -EINVAL
);
564 if (bus
->caddr_tbl
[codec_addr
]) {
565 snd_printk(KERN_ERR
"hda_codec: "
566 "address 0x%x is already occupied\n", codec_addr
);
570 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
572 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
577 codec
->addr
= codec_addr
;
578 mutex_init(&codec
->spdif_mutex
);
579 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
580 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
582 #ifdef CONFIG_SND_HDA_POWER_SAVE
583 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
584 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
585 * the caller has to power down appropriatley after initialization
588 hda_keep_power_on(codec
);
591 list_add_tail(&codec
->list
, &bus
->codec_list
);
592 bus
->caddr_tbl
[codec_addr
] = codec
;
594 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
596 if (codec
->vendor_id
== -1)
597 /* read again, hopefully the access method was corrected
598 * in the last read...
600 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
602 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
603 AC_PAR_SUBSYSTEM_ID
);
604 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
607 setup_fg_nodes(codec
);
608 if (!codec
->afg
&& !codec
->mfg
) {
609 snd_printdd("hda_codec: no AFG or MFG node found\n");
610 snd_hda_codec_free(codec
);
614 if (read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
) < 0) {
615 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
616 snd_hda_codec_free(codec
);
620 if (!codec
->subsystem_id
) {
621 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
622 codec
->subsystem_id
=
623 snd_hda_codec_read(codec
, nid
, 0,
624 AC_VERB_GET_SUBSYSTEM_ID
, 0);
627 codec
->preset
= find_codec_preset(codec
);
628 /* audio codec should override the mixer name */
629 if (codec
->afg
|| !*bus
->card
->mixername
)
630 snd_hda_get_codec_name(codec
, bus
->card
->mixername
,
631 sizeof(bus
->card
->mixername
));
633 if (is_generic_config(codec
)) {
634 err
= snd_hda_parse_generic_codec(codec
);
637 if (codec
->preset
&& codec
->preset
->patch
) {
638 err
= codec
->preset
->patch(codec
);
642 /* call the default parser */
643 err
= snd_hda_parse_generic_codec(codec
);
645 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
649 snd_hda_codec_free(codec
);
653 if (codec
->patch_ops
.unsol_event
)
654 init_unsol_queue(bus
);
656 snd_hda_codec_proc_new(codec
);
657 #ifdef CONFIG_SND_HDA_HWDEP
658 snd_hda_create_hwdep(codec
);
661 sprintf(component
, "HDA:%08x", codec
->vendor_id
);
662 snd_component_add(codec
->bus
->card
, component
);
670 * snd_hda_codec_setup_stream - set up the codec for streaming
671 * @codec: the CODEC to set up
672 * @nid: the NID to set up
673 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
674 * @channel_id: channel id to pass, zero based.
675 * @format: stream format.
677 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
679 int channel_id
, int format
)
684 snd_printdd("hda_codec_setup_stream: "
685 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
686 nid
, stream_tag
, channel_id
, format
);
687 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
,
688 (stream_tag
<< 4) | channel_id
);
690 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, format
);
694 * amp access functions
697 /* FIXME: more better hash key? */
698 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
699 #define INFO_AMP_CAPS (1<<0)
700 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
702 /* initialize the hash table */
703 static void __devinit
init_hda_cache(struct hda_cache_rec
*cache
,
704 unsigned int record_size
)
706 memset(cache
, 0, sizeof(*cache
));
707 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
708 cache
->record_size
= record_size
;
711 static void free_hda_cache(struct hda_cache_rec
*cache
)
713 kfree(cache
->buffer
);
716 /* query the hash. allocate an entry if not found. */
717 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
720 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
721 u16 cur
= cache
->hash
[idx
];
722 struct hda_cache_head
*info
;
724 while (cur
!= 0xffff) {
725 info
= (struct hda_cache_head
*)(cache
->buffer
+
726 cur
* cache
->record_size
);
727 if (info
->key
== key
)
732 /* add a new hash entry */
733 if (cache
->num_entries
>= cache
->size
) {
734 /* reallocate the array */
735 unsigned int new_size
= cache
->size
+ 64;
737 new_buffer
= kcalloc(new_size
, cache
->record_size
, GFP_KERNEL
);
739 snd_printk(KERN_ERR
"hda_codec: "
740 "can't malloc amp_info\n");
744 memcpy(new_buffer
, cache
->buffer
,
745 cache
->size
* cache
->record_size
);
746 kfree(cache
->buffer
);
748 cache
->size
= new_size
;
749 cache
->buffer
= new_buffer
;
751 cur
= cache
->num_entries
++;
752 info
= (struct hda_cache_head
*)(cache
->buffer
+
753 cur
* cache
->record_size
);
756 info
->next
= cache
->hash
[idx
];
757 cache
->hash
[idx
] = cur
;
762 /* query and allocate an amp hash entry */
763 static inline struct hda_amp_info
*
764 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
766 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
770 * query AMP capabilities for the given widget and direction
772 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
774 struct hda_amp_info
*info
;
776 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
779 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
780 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
782 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
783 direction
== HDA_OUTPUT
?
787 info
->head
.val
|= INFO_AMP_CAPS
;
789 return info
->amp_caps
;
792 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
795 struct hda_amp_info
*info
;
797 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
800 info
->amp_caps
= caps
;
801 info
->head
.val
|= INFO_AMP_CAPS
;
806 * read the current volume to info
807 * if the cache exists, read the cache value.
809 static unsigned int get_vol_mute(struct hda_codec
*codec
,
810 struct hda_amp_info
*info
, hda_nid_t nid
,
811 int ch
, int direction
, int index
)
815 if (info
->head
.val
& INFO_AMP_VOL(ch
))
816 return info
->vol
[ch
];
818 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
819 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
821 val
= snd_hda_codec_read(codec
, nid
, 0,
822 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
823 info
->vol
[ch
] = val
& 0xff;
824 info
->head
.val
|= INFO_AMP_VOL(ch
);
825 return info
->vol
[ch
];
829 * write the current volume in info to the h/w and update the cache
831 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
832 hda_nid_t nid
, int ch
, int direction
, int index
,
837 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
838 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
839 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
841 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
846 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
848 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
849 int direction
, int index
)
851 struct hda_amp_info
*info
;
852 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
855 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
859 * update the AMP value, mask = bit mask to set, val = the value
861 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
862 int direction
, int idx
, int mask
, int val
)
864 struct hda_amp_info
*info
;
866 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
870 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
871 if (info
->vol
[ch
] == val
)
873 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
878 * update the AMP stereo with the same mask and value
880 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
881 int direction
, int idx
, int mask
, int val
)
884 for (ch
= 0; ch
< 2; ch
++)
885 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
890 #ifdef SND_HDA_NEEDS_RESUME
891 /* resume the all amp commands from the cache */
892 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
894 struct hda_amp_info
*buffer
= codec
->amp_cache
.buffer
;
897 for (i
= 0; i
< codec
->amp_cache
.size
; i
++, buffer
++) {
898 u32 key
= buffer
->head
.key
;
900 unsigned int idx
, dir
, ch
;
904 idx
= (key
>> 16) & 0xff;
905 dir
= (key
>> 24) & 0xff;
906 for (ch
= 0; ch
< 2; ch
++) {
907 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
909 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
914 #endif /* SND_HDA_NEEDS_RESUME */
917 * AMP control callbacks
919 /* retrieve parameters from private_value */
920 #define get_amp_nid(kc) ((kc)->private_value & 0xffff)
921 #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3)
922 #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1)
923 #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf)
926 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
927 struct snd_ctl_elem_info
*uinfo
)
929 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
930 u16 nid
= get_amp_nid(kcontrol
);
931 u8 chs
= get_amp_channels(kcontrol
);
932 int dir
= get_amp_direction(kcontrol
);
935 caps
= query_amp_caps(codec
, nid
, dir
);
937 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
939 printk(KERN_WARNING
"hda_codec: "
940 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
944 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
945 uinfo
->count
= chs
== 3 ? 2 : 1;
946 uinfo
->value
.integer
.min
= 0;
947 uinfo
->value
.integer
.max
= caps
;
951 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
952 struct snd_ctl_elem_value
*ucontrol
)
954 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
955 hda_nid_t nid
= get_amp_nid(kcontrol
);
956 int chs
= get_amp_channels(kcontrol
);
957 int dir
= get_amp_direction(kcontrol
);
958 int idx
= get_amp_index(kcontrol
);
959 long *valp
= ucontrol
->value
.integer
.value
;
962 *valp
++ = snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
)
965 *valp
= snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
)
970 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
971 struct snd_ctl_elem_value
*ucontrol
)
973 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
974 hda_nid_t nid
= get_amp_nid(kcontrol
);
975 int chs
= get_amp_channels(kcontrol
);
976 int dir
= get_amp_direction(kcontrol
);
977 int idx
= get_amp_index(kcontrol
);
978 long *valp
= ucontrol
->value
.integer
.value
;
981 snd_hda_power_up(codec
);
983 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
988 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
990 snd_hda_power_down(codec
);
994 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
995 unsigned int size
, unsigned int __user
*_tlv
)
997 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
998 hda_nid_t nid
= get_amp_nid(kcontrol
);
999 int dir
= get_amp_direction(kcontrol
);
1000 u32 caps
, val1
, val2
;
1002 if (size
< 4 * sizeof(unsigned int))
1004 caps
= query_amp_caps(codec
, nid
, dir
);
1005 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1006 val2
= (val2
+ 1) * 25;
1007 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1008 val1
= ((int)val1
) * ((int)val2
);
1009 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1011 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1013 if (put_user(val1
, _tlv
+ 2))
1015 if (put_user(val2
, _tlv
+ 3))
1021 * set (static) TLV for virtual master volume; recalculated as max 0dB
1023 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1029 caps
= query_amp_caps(codec
, nid
, dir
);
1030 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1031 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1032 step
= (step
+ 1) * 25;
1033 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1034 tlv
[1] = 2 * sizeof(unsigned int);
1035 tlv
[2] = -nums
* step
;
1039 /* find a mixer control element with the given name */
1040 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1043 struct snd_ctl_elem_id id
;
1044 memset(&id
, 0, sizeof(id
));
1045 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1046 strcpy(id
.name
, name
);
1047 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1050 /* create a virtual master control and add slaves */
1051 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
1052 unsigned int *tlv
, const char **slaves
)
1054 struct snd_kcontrol
*kctl
;
1058 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1060 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
1063 snd_printdd("No slave found for %s\n", name
);
1066 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1067 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
1070 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1074 for (s
= slaves
; *s
; s
++) {
1075 struct snd_kcontrol
*sctl
;
1077 sctl
= snd_hda_find_mixer_ctl(codec
, *s
);
1079 snd_printdd("Cannot find slave %s, skipped\n", *s
);
1082 err
= snd_ctl_add_slave(kctl
, sctl
);
1090 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
1091 struct snd_ctl_elem_info
*uinfo
)
1093 int chs
= get_amp_channels(kcontrol
);
1095 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1096 uinfo
->count
= chs
== 3 ? 2 : 1;
1097 uinfo
->value
.integer
.min
= 0;
1098 uinfo
->value
.integer
.max
= 1;
1102 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
1103 struct snd_ctl_elem_value
*ucontrol
)
1105 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1106 hda_nid_t nid
= get_amp_nid(kcontrol
);
1107 int chs
= get_amp_channels(kcontrol
);
1108 int dir
= get_amp_direction(kcontrol
);
1109 int idx
= get_amp_index(kcontrol
);
1110 long *valp
= ucontrol
->value
.integer
.value
;
1113 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
1114 HDA_AMP_MUTE
) ? 0 : 1;
1116 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
1117 HDA_AMP_MUTE
) ? 0 : 1;
1121 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
1122 struct snd_ctl_elem_value
*ucontrol
)
1124 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1125 hda_nid_t nid
= get_amp_nid(kcontrol
);
1126 int chs
= get_amp_channels(kcontrol
);
1127 int dir
= get_amp_direction(kcontrol
);
1128 int idx
= get_amp_index(kcontrol
);
1129 long *valp
= ucontrol
->value
.integer
.value
;
1132 snd_hda_power_up(codec
);
1134 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
1136 *valp
? 0 : HDA_AMP_MUTE
);
1140 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
1142 *valp
? 0 : HDA_AMP_MUTE
);
1143 #ifdef CONFIG_SND_HDA_POWER_SAVE
1144 if (codec
->patch_ops
.check_power_status
)
1145 codec
->patch_ops
.check_power_status(codec
, nid
);
1147 snd_hda_power_down(codec
);
1152 * bound volume controls
1154 * bind multiple volumes (# indices, from 0)
1157 #define AMP_VAL_IDX_SHIFT 19
1158 #define AMP_VAL_IDX_MASK (0x0f<<19)
1160 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
1161 struct snd_ctl_elem_value
*ucontrol
)
1163 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1167 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1168 pval
= kcontrol
->private_value
;
1169 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
1170 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
1171 kcontrol
->private_value
= pval
;
1172 mutex_unlock(&codec
->spdif_mutex
);
1176 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
1177 struct snd_ctl_elem_value
*ucontrol
)
1179 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1181 int i
, indices
, err
= 0, change
= 0;
1183 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1184 pval
= kcontrol
->private_value
;
1185 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
1186 for (i
= 0; i
< indices
; i
++) {
1187 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
1188 (i
<< AMP_VAL_IDX_SHIFT
);
1189 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
1194 kcontrol
->private_value
= pval
;
1195 mutex_unlock(&codec
->spdif_mutex
);
1196 return err
< 0 ? err
: change
;
1200 * generic bound volume/swtich controls
1202 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
1203 struct snd_ctl_elem_info
*uinfo
)
1205 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1206 struct hda_bind_ctls
*c
;
1209 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1210 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1212 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1213 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1214 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1216 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1217 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1218 kcontrol
->private_value
= *c
->values
;
1219 err
= c
->ops
->info(kcontrol
, uinfo
);
1220 kcontrol
->private_value
= (long)c
;
1221 mutex_unlock(&codec
->spdif_mutex
);
1225 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
1226 struct snd_ctl_elem_value
*ucontrol
)
1228 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1229 struct hda_bind_ctls
*c
;
1232 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1233 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1235 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1236 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1237 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1239 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1240 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1241 kcontrol
->private_value
= *c
->values
;
1242 err
= c
->ops
->get(kcontrol
, ucontrol
);
1243 kcontrol
->private_value
= (long)c
;
1244 mutex_unlock(&codec
->spdif_mutex
);
1248 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
1249 struct snd_ctl_elem_value
*ucontrol
)
1251 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1252 struct hda_bind_ctls
*c
;
1253 unsigned long *vals
;
1254 int err
= 0, change
= 0;
1256 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1257 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1259 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1260 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1261 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1263 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1264 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1265 for (vals
= c
->values
; *vals
; vals
++) {
1266 kcontrol
->private_value
= *vals
;
1267 err
= c
->ops
->put(kcontrol
, ucontrol
);
1272 kcontrol
->private_value
= (long)c
;
1273 mutex_unlock(&codec
->spdif_mutex
);
1274 return err
< 0 ? err
: change
;
1277 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1278 unsigned int size
, unsigned int __user
*tlv
)
1280 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1281 struct hda_bind_ctls
*c
;
1284 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1285 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1287 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1288 mutex_lock(&codec
->spdif_mutex
); /* reuse spdif_mutex */
1289 <<<<<<< HEAD
:sound
/pci
/hda
/hda_codec
.c
1291 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
1292 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a
:sound
/pci
/hda
/hda_codec
.c
1293 kcontrol
->private_value
= *c
->values
;
1294 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
1295 kcontrol
->private_value
= (long)c
;
1296 mutex_unlock(&codec
->spdif_mutex
);
1300 struct hda_ctl_ops snd_hda_bind_vol
= {
1301 .info
= snd_hda_mixer_amp_volume_info
,
1302 .get
= snd_hda_mixer_amp_volume_get
,
1303 .put
= snd_hda_mixer_amp_volume_put
,
1304 .tlv
= snd_hda_mixer_amp_tlv
1307 struct hda_ctl_ops snd_hda_bind_sw
= {
1308 .info
= snd_hda_mixer_amp_switch_info
,
1309 .get
= snd_hda_mixer_amp_switch_get
,
1310 .put
= snd_hda_mixer_amp_switch_put
,
1311 .tlv
= snd_hda_mixer_amp_tlv
1315 * SPDIF out controls
1318 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
1319 struct snd_ctl_elem_info
*uinfo
)
1321 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
1326 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
1327 struct snd_ctl_elem_value
*ucontrol
)
1329 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1330 IEC958_AES0_NONAUDIO
|
1331 IEC958_AES0_CON_EMPHASIS_5015
|
1332 IEC958_AES0_CON_NOT_COPYRIGHT
;
1333 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
1334 IEC958_AES1_CON_ORIGINAL
;
1338 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
1339 struct snd_ctl_elem_value
*ucontrol
)
1341 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
1342 IEC958_AES0_NONAUDIO
|
1343 IEC958_AES0_PRO_EMPHASIS_5015
;
1347 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
1348 struct snd_ctl_elem_value
*ucontrol
)
1350 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1352 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
1353 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
1354 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
1355 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
1360 /* convert from SPDIF status bits to HDA SPDIF bits
1361 * bit 0 (DigEn) is always set zero (to be filled later)
1363 static unsigned short convert_from_spdif_status(unsigned int sbits
)
1365 unsigned short val
= 0;
1367 if (sbits
& IEC958_AES0_PROFESSIONAL
)
1368 val
|= AC_DIG1_PROFESSIONAL
;
1369 if (sbits
& IEC958_AES0_NONAUDIO
)
1370 val
|= AC_DIG1_NONAUDIO
;
1371 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1372 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
1373 IEC958_AES0_PRO_EMPHASIS_5015
)
1374 val
|= AC_DIG1_EMPHASIS
;
1376 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
1377 IEC958_AES0_CON_EMPHASIS_5015
)
1378 val
|= AC_DIG1_EMPHASIS
;
1379 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
1380 val
|= AC_DIG1_COPYRIGHT
;
1381 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
1382 val
|= AC_DIG1_LEVEL
;
1383 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
1388 /* convert to SPDIF status bits from HDA SPDIF bits
1390 static unsigned int convert_to_spdif_status(unsigned short val
)
1392 unsigned int sbits
= 0;
1394 if (val
& AC_DIG1_NONAUDIO
)
1395 sbits
|= IEC958_AES0_NONAUDIO
;
1396 if (val
& AC_DIG1_PROFESSIONAL
)
1397 sbits
|= IEC958_AES0_PROFESSIONAL
;
1398 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
1399 if (sbits
& AC_DIG1_EMPHASIS
)
1400 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
1402 if (val
& AC_DIG1_EMPHASIS
)
1403 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
1404 if (!(val
& AC_DIG1_COPYRIGHT
))
1405 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
1406 if (val
& AC_DIG1_LEVEL
)
1407 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
1408 sbits
|= val
& (0x7f << 8);
1413 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
1414 struct snd_ctl_elem_value
*ucontrol
)
1416 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1417 hda_nid_t nid
= kcontrol
->private_value
;
1421 mutex_lock(&codec
->spdif_mutex
);
1422 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
1423 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
1424 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
1425 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
1426 val
= convert_from_spdif_status(codec
->spdif_status
);
1427 val
|= codec
->spdif_ctls
& 1;
1428 change
= codec
->spdif_ctls
!= val
;
1429 codec
->spdif_ctls
= val
;
1432 snd_hda_codec_write_cache(codec
, nid
, 0,
1433 AC_VERB_SET_DIGI_CONVERT_1
,
1435 snd_hda_codec_write_cache(codec
, nid
, 0,
1436 AC_VERB_SET_DIGI_CONVERT_2
,
1440 mutex_unlock(&codec
->spdif_mutex
);
1444 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1446 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
1447 struct snd_ctl_elem_value
*ucontrol
)
1449 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1451 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
1455 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
1456 struct snd_ctl_elem_value
*ucontrol
)
1458 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1459 hda_nid_t nid
= kcontrol
->private_value
;
1463 mutex_lock(&codec
->spdif_mutex
);
1464 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
1465 if (ucontrol
->value
.integer
.value
[0])
1466 val
|= AC_DIG1_ENABLE
;
1467 change
= codec
->spdif_ctls
!= val
;
1469 codec
->spdif_ctls
= val
;
1470 snd_hda_codec_write_cache(codec
, nid
, 0,
1471 AC_VERB_SET_DIGI_CONVERT_1
,
1473 /* unmute amp switch (if any) */
1474 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
1475 (val
& AC_DIG1_ENABLE
))
1476 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
1479 mutex_unlock(&codec
->spdif_mutex
);
1483 static struct snd_kcontrol_new dig_mixes
[] = {
1485 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1486 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1487 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,CON_MASK
),
1488 .info
= snd_hda_spdif_mask_info
,
1489 .get
= snd_hda_spdif_cmask_get
,
1492 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1493 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1494 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,PRO_MASK
),
1495 .info
= snd_hda_spdif_mask_info
,
1496 .get
= snd_hda_spdif_pmask_get
,
1499 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1500 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
1501 .info
= snd_hda_spdif_mask_info
,
1502 .get
= snd_hda_spdif_default_get
,
1503 .put
= snd_hda_spdif_default_put
,
1506 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1507 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,SWITCH
),
1508 .info
= snd_hda_spdif_out_switch_info
,
1509 .get
= snd_hda_spdif_out_switch_get
,
1510 .put
= snd_hda_spdif_out_switch_put
,
1516 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1517 * @codec: the HDA codec
1518 * @nid: audio out widget NID
1520 * Creates controls related with the SPDIF output.
1521 * Called from each patch supporting the SPDIF out.
1523 * Returns 0 if successful, or a negative error code.
1525 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
1528 struct snd_kcontrol
*kctl
;
1529 struct snd_kcontrol_new
*dig_mix
;
1531 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
1532 kctl
= snd_ctl_new1(dig_mix
, codec
);
1533 kctl
->private_value
= nid
;
1534 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1539 snd_hda_codec_read(codec
, nid
, 0,
1540 AC_VERB_GET_DIGI_CONVERT_1
, 0);
1541 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
1549 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1551 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
1552 struct snd_ctl_elem_value
*ucontrol
)
1554 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1556 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
1560 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
1561 struct snd_ctl_elem_value
*ucontrol
)
1563 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1564 hda_nid_t nid
= kcontrol
->private_value
;
1565 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
1568 mutex_lock(&codec
->spdif_mutex
);
1569 change
= codec
->spdif_in_enable
!= val
;
1571 codec
->spdif_in_enable
= val
;
1572 snd_hda_codec_write_cache(codec
, nid
, 0,
1573 AC_VERB_SET_DIGI_CONVERT_1
, val
);
1575 mutex_unlock(&codec
->spdif_mutex
);
1579 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
1580 struct snd_ctl_elem_value
*ucontrol
)
1582 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1583 hda_nid_t nid
= kcontrol
->private_value
;
1587 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
1588 sbits
= convert_to_spdif_status(val
);
1589 ucontrol
->value
.iec958
.status
[0] = sbits
;
1590 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
1591 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
1592 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
1596 static struct snd_kcontrol_new dig_in_ctls
[] = {
1598 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1599 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
),
1600 .info
= snd_hda_spdif_in_switch_info
,
1601 .get
= snd_hda_spdif_in_switch_get
,
1602 .put
= snd_hda_spdif_in_switch_put
,
1605 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1606 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1607 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
1608 .info
= snd_hda_spdif_mask_info
,
1609 .get
= snd_hda_spdif_in_status_get
,
1615 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1616 * @codec: the HDA codec
1617 * @nid: audio in widget NID
1619 * Creates controls related with the SPDIF input.
1620 * Called from each patch supporting the SPDIF in.
1622 * Returns 0 if successful, or a negative error code.
1624 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
1627 struct snd_kcontrol
*kctl
;
1628 struct snd_kcontrol_new
*dig_mix
;
1630 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
1631 kctl
= snd_ctl_new1(dig_mix
, codec
);
1632 kctl
->private_value
= nid
;
1633 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1637 codec
->spdif_in_enable
=
1638 snd_hda_codec_read(codec
, nid
, 0,
1639 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
1644 #ifdef SND_HDA_NEEDS_RESUME
1649 /* build a 32bit cache key with the widget id and the command parameter */
1650 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
1651 #define get_cmd_cache_nid(key) ((key) & 0xff)
1652 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
1655 * snd_hda_codec_write_cache - send a single command with caching
1656 * @codec: the HDA codec
1657 * @nid: NID to send the command
1658 * @direct: direct flag
1659 * @verb: the verb to send
1660 * @parm: the parameter for the verb
1662 * Send a single command without waiting for response.
1664 * Returns 0 if successful, or a negative error code.
1666 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
1667 int direct
, unsigned int verb
, unsigned int parm
)
1670 snd_hda_power_up(codec
);
1671 mutex_lock(&codec
->bus
->cmd_mutex
);
1672 err
= codec
->bus
->ops
.command(codec
, nid
, direct
, verb
, parm
);
1674 struct hda_cache_head
*c
;
1675 u32 key
= build_cmd_cache_key(nid
, verb
);
1676 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
1680 mutex_unlock(&codec
->bus
->cmd_mutex
);
1681 snd_hda_power_down(codec
);
1685 /* resume the all commands from the cache */
1686 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
1688 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buffer
;
1691 for (i
= 0; i
< codec
->cmd_cache
.size
; i
++, buffer
++) {
1692 u32 key
= buffer
->key
;
1695 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
1696 get_cmd_cache_cmd(key
), buffer
->val
);
1701 * snd_hda_sequence_write_cache - sequence writes with caching
1702 * @codec: the HDA codec
1703 * @seq: VERB array to send
1705 * Send the commands sequentially from the given array.
1706 * Thte commands are recorded on cache for power-save and resume.
1707 * The array must be terminated with NID=0.
1709 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
1710 const struct hda_verb
*seq
)
1712 for (; seq
->nid
; seq
++)
1713 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
1716 #endif /* SND_HDA_NEEDS_RESUME */
1719 * set power state of the codec
1721 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
1722 unsigned int power_state
)
1727 snd_hda_codec_write(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
1729 msleep(10); /* partial workaround for "azx_get_response timeout" */
1731 nid
= codec
->start_nid
;
1732 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
1733 unsigned int wcaps
= get_wcaps(codec
, nid
);
1734 if (wcaps
& AC_WCAP_POWER
) {
1735 unsigned int wid_type
= (wcaps
& AC_WCAP_TYPE
) >>
1737 if (wid_type
== AC_WID_PIN
) {
1738 unsigned int pincap
;
1740 * don't power down the widget if it controls
1741 * eapd and EAPD_BTLENABLE is set.
1743 pincap
= snd_hda_param_read(codec
, nid
,
1745 if (pincap
& AC_PINCAP_EAPD
) {
1746 int eapd
= snd_hda_codec_read(codec
,
1748 AC_VERB_GET_EAPD_BTLENABLE
, 0);
1750 if (power_state
== AC_PWRST_D3
&& eapd
)
1754 snd_hda_codec_write(codec
, nid
, 0,
1755 AC_VERB_SET_POWER_STATE
,
1760 if (power_state
== AC_PWRST_D0
) {
1761 unsigned long end_time
;
1764 /* wait until the codec reachs to D0 */
1765 end_time
= jiffies
+ msecs_to_jiffies(500);
1767 state
= snd_hda_codec_read(codec
, fg
, 0,
1768 AC_VERB_GET_POWER_STATE
, 0);
1769 if (state
== power_state
)
1772 } while (time_after_eq(end_time
, jiffies
));
1776 #ifdef SND_HDA_NEEDS_RESUME
1778 * call suspend and power-down; used both from PM and power-save
1780 static void hda_call_codec_suspend(struct hda_codec
*codec
)
1782 if (codec
->patch_ops
.suspend
)
1783 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
1784 hda_set_power_state(codec
,
1785 codec
->afg
? codec
->afg
: codec
->mfg
,
1787 #ifdef CONFIG_SND_HDA_POWER_SAVE
1788 cancel_delayed_work(&codec
->power_work
);
1789 codec
->power_on
= 0;
1790 codec
->power_transition
= 0;
1795 * kick up codec; used both from PM and power-save
1797 static void hda_call_codec_resume(struct hda_codec
*codec
)
1799 hda_set_power_state(codec
,
1800 codec
->afg
? codec
->afg
: codec
->mfg
,
1802 if (codec
->patch_ops
.resume
)
1803 codec
->patch_ops
.resume(codec
);
1805 if (codec
->patch_ops
.init
)
1806 codec
->patch_ops
.init(codec
);
1807 snd_hda_codec_resume_amp(codec
);
1808 snd_hda_codec_resume_cache(codec
);
1811 #endif /* SND_HDA_NEEDS_RESUME */
1815 * snd_hda_build_controls - build mixer controls
1818 * Creates mixer controls for each codec included in the bus.
1820 * Returns 0 if successful, otherwise a negative error code.
1822 int __devinit
snd_hda_build_controls(struct hda_bus
*bus
)
1824 struct hda_codec
*codec
;
1826 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
1828 /* fake as if already powered-on */
1829 hda_keep_power_on(codec
);
1831 hda_set_power_state(codec
,
1832 codec
->afg
? codec
->afg
: codec
->mfg
,
1834 /* continue to initialize... */
1835 if (codec
->patch_ops
.init
)
1836 err
= codec
->patch_ops
.init(codec
);
1837 if (!err
&& codec
->patch_ops
.build_controls
)
1838 err
= codec
->patch_ops
.build_controls(codec
);
1839 snd_hda_power_down(codec
);
1850 struct hda_rate_tbl
{
1852 unsigned int alsa_bits
;
1853 unsigned int hda_fmt
;
1856 static struct hda_rate_tbl rate_bits
[] = {
1857 /* rate in Hz, ALSA rate bitmask, HDA format value */
1859 /* autodetected value used in snd_hda_query_supported_pcm */
1860 { 8000, SNDRV_PCM_RATE_8000
, 0x0500 }, /* 1/6 x 48 */
1861 { 11025, SNDRV_PCM_RATE_11025
, 0x4300 }, /* 1/4 x 44 */
1862 { 16000, SNDRV_PCM_RATE_16000
, 0x0200 }, /* 1/3 x 48 */
1863 { 22050, SNDRV_PCM_RATE_22050
, 0x4100 }, /* 1/2 x 44 */
1864 { 32000, SNDRV_PCM_RATE_32000
, 0x0a00 }, /* 2/3 x 48 */
1865 { 44100, SNDRV_PCM_RATE_44100
, 0x4000 }, /* 44 */
1866 { 48000, SNDRV_PCM_RATE_48000
, 0x0000 }, /* 48 */
1867 { 88200, SNDRV_PCM_RATE_88200
, 0x4800 }, /* 2 x 44 */
1868 { 96000, SNDRV_PCM_RATE_96000
, 0x0800 }, /* 2 x 48 */
1869 { 176400, SNDRV_PCM_RATE_176400
, 0x5800 },/* 4 x 44 */
1870 { 192000, SNDRV_PCM_RATE_192000
, 0x1800 }, /* 4 x 48 */
1871 #define AC_PAR_PCM_RATE_BITS 11
1872 /* up to bits 10, 384kHZ isn't supported properly */
1874 /* not autodetected value */
1875 { 9600, SNDRV_PCM_RATE_KNOT
, 0x0400 }, /* 1/5 x 48 */
1877 { 0 } /* terminator */
1881 * snd_hda_calc_stream_format - calculate format bitset
1882 * @rate: the sample rate
1883 * @channels: the number of channels
1884 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
1885 * @maxbps: the max. bps
1887 * Calculate the format bitset from the given rate, channels and th PCM format.
1889 * Return zero if invalid.
1891 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
1892 unsigned int channels
,
1893 unsigned int format
,
1894 unsigned int maxbps
)
1897 unsigned int val
= 0;
1899 for (i
= 0; rate_bits
[i
].hz
; i
++)
1900 if (rate_bits
[i
].hz
== rate
) {
1901 val
= rate_bits
[i
].hda_fmt
;
1904 if (!rate_bits
[i
].hz
) {
1905 snd_printdd("invalid rate %d\n", rate
);
1909 if (channels
== 0 || channels
> 8) {
1910 snd_printdd("invalid channels %d\n", channels
);
1913 val
|= channels
- 1;
1915 switch (snd_pcm_format_width(format
)) {
1916 case 8: val
|= 0x00; break;
1917 case 16: val
|= 0x10; break;
1923 else if (maxbps
>= 24)
1929 snd_printdd("invalid format width %d\n",
1930 snd_pcm_format_width(format
));
1938 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
1939 * @codec: the HDA codec
1940 * @nid: NID to query
1941 * @ratesp: the pointer to store the detected rate bitflags
1942 * @formatsp: the pointer to store the detected formats
1943 * @bpsp: the pointer to store the detected format widths
1945 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
1946 * or @bsps argument is ignored.
1948 * Returns 0 if successful, otherwise a negative error code.
1950 int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
1951 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
1954 unsigned int val
, streams
;
1957 if (nid
!= codec
->afg
&&
1958 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
)) {
1959 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
1964 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
1968 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
1970 rates
|= rate_bits
[i
].alsa_bits
;
1975 if (formatsp
|| bpsp
) {
1980 wcaps
= get_wcaps(codec
, nid
);
1981 streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
1985 streams
= snd_hda_param_read(codec
, codec
->afg
,
1992 if (streams
& AC_SUPFMT_PCM
) {
1993 if (val
& AC_SUPPCM_BITS_8
) {
1994 formats
|= SNDRV_PCM_FMTBIT_U8
;
1997 if (val
& AC_SUPPCM_BITS_16
) {
1998 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
2001 if (wcaps
& AC_WCAP_DIGITAL
) {
2002 if (val
& AC_SUPPCM_BITS_32
)
2003 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
2004 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
2005 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2006 if (val
& AC_SUPPCM_BITS_24
)
2008 else if (val
& AC_SUPPCM_BITS_20
)
2010 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
2011 AC_SUPPCM_BITS_32
)) {
2012 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
2013 if (val
& AC_SUPPCM_BITS_32
)
2015 else if (val
& AC_SUPPCM_BITS_24
)
2017 else if (val
& AC_SUPPCM_BITS_20
)
2021 else if (streams
== AC_SUPFMT_FLOAT32
) {
2022 /* should be exclusive */
2023 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
2025 } else if (streams
== AC_SUPFMT_AC3
) {
2026 /* should be exclusive */
2027 /* temporary hack: we have still no proper support
2028 * for the direct AC3 stream...
2030 formats
|= SNDRV_PCM_FMTBIT_U8
;
2034 *formatsp
= formats
;
2043 * snd_hda_is_supported_format - check whether the given node supports
2046 * Returns 1 if supported, 0 if not.
2048 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
2049 unsigned int format
)
2052 unsigned int val
= 0, rate
, stream
;
2054 if (nid
!= codec
->afg
&&
2055 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
)) {
2056 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
2061 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
2066 rate
= format
& 0xff00;
2067 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
2068 if (rate_bits
[i
].hda_fmt
== rate
) {
2073 if (i
>= AC_PAR_PCM_RATE_BITS
)
2076 stream
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
2079 if (!stream
&& nid
!= codec
->afg
)
2080 stream
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
2081 if (!stream
|| stream
== -1)
2084 if (stream
& AC_SUPFMT_PCM
) {
2085 switch (format
& 0xf0) {
2087 if (!(val
& AC_SUPPCM_BITS_8
))
2091 if (!(val
& AC_SUPPCM_BITS_16
))
2095 if (!(val
& AC_SUPPCM_BITS_20
))
2099 if (!(val
& AC_SUPPCM_BITS_24
))
2103 if (!(val
& AC_SUPPCM_BITS_32
))
2110 /* FIXME: check for float32 and AC3? */
2119 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
2120 struct hda_codec
*codec
,
2121 struct snd_pcm_substream
*substream
)
2126 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
2127 struct hda_codec
*codec
,
2128 unsigned int stream_tag
,
2129 unsigned int format
,
2130 struct snd_pcm_substream
*substream
)
2132 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
2136 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
2137 struct hda_codec
*codec
,
2138 struct snd_pcm_substream
*substream
)
2140 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, 0, 0, 0);
2144 static int __devinit
set_pcm_default_values(struct hda_codec
*codec
,
2145 struct hda_pcm_stream
*info
)
2147 /* query support PCM information from the given NID */
2148 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
2149 snd_hda_query_supported_pcm(codec
, info
->nid
,
2150 info
->rates
? NULL
: &info
->rates
,
2151 info
->formats
? NULL
: &info
->formats
,
2152 info
->maxbps
? NULL
: &info
->maxbps
);
2154 if (info
->ops
.open
== NULL
)
2155 info
->ops
.open
= hda_pcm_default_open_close
;
2156 if (info
->ops
.close
== NULL
)
2157 info
->ops
.close
= hda_pcm_default_open_close
;
2158 if (info
->ops
.prepare
== NULL
) {
2159 snd_assert(info
->nid
, return -EINVAL
);
2160 info
->ops
.prepare
= hda_pcm_default_prepare
;
2162 if (info
->ops
.cleanup
== NULL
) {
2163 snd_assert(info
->nid
, return -EINVAL
);
2164 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
2170 * snd_hda_build_pcms - build PCM information
2173 * Create PCM information for each codec included in the bus.
2175 * The build_pcms codec patch is requested to set up codec->num_pcms and
2176 * codec->pcm_info properly. The array is referred by the top-level driver
2177 * to create its PCM instances.
2178 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2181 * At least, substreams, channels_min and channels_max must be filled for
2182 * each stream. substreams = 0 indicates that the stream doesn't exist.
2183 * When rates and/or formats are zero, the supported values are queried
2184 * from the given nid. The nid is used also by the default ops.prepare
2185 * and ops.cleanup callbacks.
2187 * The driver needs to call ops.open in its open callback. Similarly,
2188 * ops.close is supposed to be called in the close callback.
2189 * ops.prepare should be called in the prepare or hw_params callback
2190 * with the proper parameters for set up.
2191 * ops.cleanup should be called in hw_free for clean up of streams.
2193 * This function returns 0 if successfull, or a negative error code.
2195 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
2197 struct hda_codec
*codec
;
2199 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2200 unsigned int pcm
, s
;
2202 if (!codec
->patch_ops
.build_pcms
)
2204 err
= codec
->patch_ops
.build_pcms(codec
);
2207 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
2208 for (s
= 0; s
< 2; s
++) {
2209 struct hda_pcm_stream
*info
;
2210 info
= &codec
->pcm_info
[pcm
].stream
[s
];
2211 if (!info
->substreams
)
2213 err
= set_pcm_default_values(codec
, info
);
2223 * snd_hda_check_board_config - compare the current codec with the config table
2224 * @codec: the HDA codec
2225 * @num_configs: number of config enums
2226 * @models: array of model name strings
2227 * @tbl: configuration table, terminated by null entries
2229 * Compares the modelname or PCI subsystem id of the current codec with the
2230 * given configuration table. If a matching entry is found, returns its
2231 * config value (supposed to be 0 or positive).
2233 * If no entries are matching, the function returns a negative value.
2235 int snd_hda_check_board_config(struct hda_codec
*codec
,
2236 int num_configs
, const char **models
,
2237 const struct snd_pci_quirk
*tbl
)
2239 if (codec
->bus
->modelname
&& models
) {
2241 for (i
= 0; i
< num_configs
; i
++) {
2243 !strcmp(codec
->bus
->modelname
, models
[i
])) {
2244 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
2245 "selected\n", models
[i
]);
2251 if (!codec
->bus
->pci
|| !tbl
)
2254 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
2257 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
2258 #ifdef CONFIG_SND_DEBUG_DETECT
2260 const char *model
= NULL
;
2262 model
= models
[tbl
->value
];
2264 sprintf(tmp
, "#%d", tbl
->value
);
2267 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
2268 "for config %x:%x (%s)\n",
2269 model
, tbl
->subvendor
, tbl
->subdevice
,
2270 (tbl
->name
? tbl
->name
: "Unknown device"));
2278 * snd_hda_add_new_ctls - create controls from the array
2279 * @codec: the HDA codec
2280 * @knew: the array of struct snd_kcontrol_new
2282 * This helper function creates and add new controls in the given array.
2283 * The array must be terminated with an empty entry as terminator.
2285 * Returns 0 if successful, or a negative error code.
2287 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
2291 for (; knew
->name
; knew
++) {
2292 struct snd_kcontrol
*kctl
;
2293 kctl
= snd_ctl_new1(knew
, codec
);
2296 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
2300 kctl
= snd_ctl_new1(knew
, codec
);
2303 kctl
->id
.device
= codec
->addr
;
2304 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
2312 #ifdef CONFIG_SND_HDA_POWER_SAVE
2313 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2314 unsigned int power_state
);
2316 static void hda_power_work(struct work_struct
*work
)
2318 struct hda_codec
*codec
=
2319 container_of(work
, struct hda_codec
, power_work
.work
);
2321 if (!codec
->power_on
|| codec
->power_count
) {
2322 codec
->power_transition
= 0;
2326 hda_call_codec_suspend(codec
);
2327 if (codec
->bus
->ops
.pm_notify
)
2328 codec
->bus
->ops
.pm_notify(codec
);
2331 static void hda_keep_power_on(struct hda_codec
*codec
)
2333 codec
->power_count
++;
2334 codec
->power_on
= 1;
2337 void snd_hda_power_up(struct hda_codec
*codec
)
2339 codec
->power_count
++;
2340 if (codec
->power_on
|| codec
->power_transition
)
2343 codec
->power_on
= 1;
2344 if (codec
->bus
->ops
.pm_notify
)
2345 codec
->bus
->ops
.pm_notify(codec
);
2346 hda_call_codec_resume(codec
);
2347 cancel_delayed_work(&codec
->power_work
);
2348 codec
->power_transition
= 0;
2351 void snd_hda_power_down(struct hda_codec
*codec
)
2353 --codec
->power_count
;
2354 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
2357 codec
->power_transition
= 1; /* avoid reentrance */
2358 schedule_delayed_work(&codec
->power_work
,
2359 msecs_to_jiffies(power_save
* 1000));
2363 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
2364 struct hda_loopback_check
*check
,
2367 struct hda_amp_list
*p
;
2370 if (!check
->amplist
)
2372 for (p
= check
->amplist
; p
->nid
; p
++) {
2377 return 0; /* nothing changed */
2379 for (p
= check
->amplist
; p
->nid
; p
++) {
2380 for (ch
= 0; ch
< 2; ch
++) {
2381 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
2383 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
2384 if (!check
->power_on
) {
2385 check
->power_on
= 1;
2386 snd_hda_power_up(codec
);
2392 if (check
->power_on
) {
2393 check
->power_on
= 0;
2394 snd_hda_power_down(codec
);
2401 * Channel mode helper
2403 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
2404 struct snd_ctl_elem_info
*uinfo
,
2405 const struct hda_channel_mode
*chmode
,
2408 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2410 uinfo
->value
.enumerated
.items
= num_chmodes
;
2411 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
2412 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
2413 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
2414 chmode
[uinfo
->value
.enumerated
.item
].channels
);
2418 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
2419 struct snd_ctl_elem_value
*ucontrol
,
2420 const struct hda_channel_mode
*chmode
,
2426 for (i
= 0; i
< num_chmodes
; i
++) {
2427 if (max_channels
== chmode
[i
].channels
) {
2428 ucontrol
->value
.enumerated
.item
[0] = i
;
2435 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
2436 struct snd_ctl_elem_value
*ucontrol
,
2437 const struct hda_channel_mode
*chmode
,
2443 mode
= ucontrol
->value
.enumerated
.item
[0];
2444 if (mode
>= num_chmodes
)
2446 if (*max_channelsp
== chmode
[mode
].channels
)
2448 /* change the current channel setting */
2449 *max_channelsp
= chmode
[mode
].channels
;
2450 if (chmode
[mode
].sequence
)
2451 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
2458 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
2459 struct snd_ctl_elem_info
*uinfo
)
2463 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2465 uinfo
->value
.enumerated
.items
= imux
->num_items
;
2466 if (!imux
->num_items
)
2468 index
= uinfo
->value
.enumerated
.item
;
2469 if (index
>= imux
->num_items
)
2470 index
= imux
->num_items
- 1;
2471 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
2475 int snd_hda_input_mux_put(struct hda_codec
*codec
,
2476 const struct hda_input_mux
*imux
,
2477 struct snd_ctl_elem_value
*ucontrol
,
2479 unsigned int *cur_val
)
2483 if (!imux
->num_items
)
2485 idx
= ucontrol
->value
.enumerated
.item
[0];
2486 if (idx
>= imux
->num_items
)
2487 idx
= imux
->num_items
- 1;
2488 if (*cur_val
== idx
)
2490 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
2491 imux
->items
[idx
].index
);
2498 * Multi-channel / digital-out PCM helper functions
2501 /* setup SPDIF output stream */
2502 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
2503 unsigned int stream_tag
, unsigned int format
)
2505 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2506 if (codec
->spdif_ctls
& AC_DIG1_ENABLE
)
2507 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_DIGI_CONVERT_1
,
2508 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff);
2509 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
2510 /* turn on again (if needed) */
2511 if (codec
->spdif_ctls
& AC_DIG1_ENABLE
)
2512 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_DIGI_CONVERT_1
,
2513 codec
->spdif_ctls
& 0xff);
2517 * open the digital out in the exclusive mode
2519 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
2520 struct hda_multi_out
*mout
)
2522 mutex_lock(&codec
->spdif_mutex
);
2523 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
2524 /* already opened as analog dup; reset it once */
2525 snd_hda_codec_setup_stream(codec
, mout
->dig_out_nid
, 0, 0, 0);
2526 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
2527 mutex_unlock(&codec
->spdif_mutex
);
2531 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
2532 struct hda_multi_out
*mout
,
2533 unsigned int stream_tag
,
2534 unsigned int format
,
2535 struct snd_pcm_substream
*substream
)
2537 mutex_lock(&codec
->spdif_mutex
);
2538 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
2539 mutex_unlock(&codec
->spdif_mutex
);
2544 * release the digital out
2546 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
2547 struct hda_multi_out
*mout
)
2549 mutex_lock(&codec
->spdif_mutex
);
2550 mout
->dig_out_used
= 0;
2551 mutex_unlock(&codec
->spdif_mutex
);
2556 * set up more restrictions for analog out
2558 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
2559 struct hda_multi_out
*mout
,
2560 struct snd_pcm_substream
*substream
)
2562 substream
->runtime
->hw
.channels_max
= mout
->max_channels
;
2563 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
2564 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
2568 * set up the i/o for analog out
2569 * when the digital out is available, copy the front out to digital out, too.
2571 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
2572 struct hda_multi_out
*mout
,
2573 unsigned int stream_tag
,
2574 unsigned int format
,
2575 struct snd_pcm_substream
*substream
)
2577 hda_nid_t
*nids
= mout
->dac_nids
;
2578 int chs
= substream
->runtime
->channels
;
2581 mutex_lock(&codec
->spdif_mutex
);
2582 if (mout
->dig_out_nid
&& mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
2584 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
2586 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
2587 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
2588 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
2589 stream_tag
, format
);
2591 mout
->dig_out_used
= 0;
2592 snd_hda_codec_setup_stream(codec
, mout
->dig_out_nid
,
2596 mutex_unlock(&codec
->spdif_mutex
);
2599 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
2601 if (!mout
->no_share_stream
&&
2602 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
2603 /* headphone out will just decode front left/right (stereo) */
2604 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
2606 /* extra outputs copied from front */
2607 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
2608 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
2609 snd_hda_codec_setup_stream(codec
,
2610 mout
->extra_out_nid
[i
],
2611 stream_tag
, 0, format
);
2614 for (i
= 1; i
< mout
->num_dacs
; i
++) {
2615 if (chs
>= (i
+ 1) * 2) /* independent out */
2616 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
2618 else if (!mout
->no_share_stream
) /* copy front */
2619 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
2626 * clean up the setting for analog out
2628 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
2629 struct hda_multi_out
*mout
)
2631 hda_nid_t
*nids
= mout
->dac_nids
;
2634 for (i
= 0; i
< mout
->num_dacs
; i
++)
2635 snd_hda_codec_setup_stream(codec
, nids
[i
], 0, 0, 0);
2637 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, 0, 0, 0);
2638 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
2639 if (mout
->extra_out_nid
[i
])
2640 snd_hda_codec_setup_stream(codec
,
2641 mout
->extra_out_nid
[i
],
2643 mutex_lock(&codec
->spdif_mutex
);
2644 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
2645 snd_hda_codec_setup_stream(codec
, mout
->dig_out_nid
, 0, 0, 0);
2646 mout
->dig_out_used
= 0;
2648 mutex_unlock(&codec
->spdif_mutex
);
2653 * Helper for automatic ping configuration
2656 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
2658 for (; *list
; list
++)
2666 * Sort an associated group of pins according to their sequence numbers.
2668 static void sort_pins_by_sequence(hda_nid_t
* pins
, short * sequences
,
2675 for (i
= 0; i
< num_pins
; i
++) {
2676 for (j
= i
+ 1; j
< num_pins
; j
++) {
2677 if (sequences
[i
] > sequences
[j
]) {
2679 sequences
[i
] = sequences
[j
];
2691 * Parse all pin widgets and store the useful pin nids to cfg
2693 * The number of line-outs or any primary output is stored in line_outs,
2694 * and the corresponding output pins are assigned to line_out_pins[],
2695 * in the order of front, rear, CLFE, side, ...
2697 * If more extra outputs (speaker and headphone) are found, the pins are
2698 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
2699 * is detected, one of speaker of HP pins is assigned as the primary
2700 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
2701 * if any analog output exists.
2703 * The analog input pins are assigned to input_pins array.
2704 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
2707 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
2708 struct auto_pin_cfg
*cfg
,
2709 hda_nid_t
*ignore_nids
)
2711 hda_nid_t nid
, end_nid
;
2712 short seq
, assoc_line_out
, assoc_speaker
;
2713 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
2714 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
2715 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
2717 memset(cfg
, 0, sizeof(*cfg
));
2719 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
2720 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
2721 memset(sequences_hp
, 0, sizeof(sequences_hp
));
2722 assoc_line_out
= assoc_speaker
= 0;
2724 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
2725 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
2726 unsigned int wid_caps
= get_wcaps(codec
, nid
);
2727 unsigned int wid_type
=
2728 (wid_caps
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
2729 unsigned int def_conf
;
2732 /* read all default configuration for pin complex */
2733 if (wid_type
!= AC_WID_PIN
)
2735 /* ignore the given nids (e.g. pc-beep returns error) */
2736 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
2739 def_conf
= snd_hda_codec_read(codec
, nid
, 0,
2740 AC_VERB_GET_CONFIG_DEFAULT
, 0);
2741 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
2743 loc
= get_defcfg_location(def_conf
);
2744 switch (get_defcfg_device(def_conf
)) {
2745 case AC_JACK_LINE_OUT
:
2746 seq
= get_defcfg_sequence(def_conf
);
2747 assoc
= get_defcfg_association(def_conf
);
2749 if (!(wid_caps
& AC_WCAP_STEREO
))
2750 if (!cfg
->mono_out_pin
)
2751 cfg
->mono_out_pin
= nid
;
2754 if (!assoc_line_out
)
2755 assoc_line_out
= assoc
;
2756 else if (assoc_line_out
!= assoc
)
2758 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
2760 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
2761 sequences_line_out
[cfg
->line_outs
] = seq
;
2764 case AC_JACK_SPEAKER
:
2765 seq
= get_defcfg_sequence(def_conf
);
2766 assoc
= get_defcfg_association(def_conf
);
2769 if (! assoc_speaker
)
2770 assoc_speaker
= assoc
;
2771 else if (assoc_speaker
!= assoc
)
2773 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
2775 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
2776 sequences_speaker
[cfg
->speaker_outs
] = seq
;
2777 cfg
->speaker_outs
++;
2779 case AC_JACK_HP_OUT
:
2780 seq
= get_defcfg_sequence(def_conf
);
2781 assoc
= get_defcfg_association(def_conf
);
2782 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
2784 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
2785 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
2788 case AC_JACK_MIC_IN
: {
2790 if (loc
== AC_JACK_LOC_FRONT
) {
2791 preferred
= AUTO_PIN_FRONT_MIC
;
2794 preferred
= AUTO_PIN_MIC
;
2795 alt
= AUTO_PIN_FRONT_MIC
;
2797 if (!cfg
->input_pins
[preferred
])
2798 cfg
->input_pins
[preferred
] = nid
;
2799 else if (!cfg
->input_pins
[alt
])
2800 cfg
->input_pins
[alt
] = nid
;
2803 case AC_JACK_LINE_IN
:
2804 if (loc
== AC_JACK_LOC_FRONT
)
2805 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
2807 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
2810 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
2813 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
2815 case AC_JACK_SPDIF_OUT
:
2816 cfg
->dig_out_pin
= nid
;
2818 case AC_JACK_SPDIF_IN
:
2819 cfg
->dig_in_pin
= nid
;
2824 /* sort by sequence */
2825 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
2827 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
2829 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
2832 /* if we have only one mic, make it AUTO_PIN_MIC */
2833 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
2834 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
2835 cfg
->input_pins
[AUTO_PIN_MIC
] =
2836 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
2837 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
2839 /* ditto for line-in */
2840 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
2841 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
2842 cfg
->input_pins
[AUTO_PIN_LINE
] =
2843 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
2844 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
2848 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
2849 * as a primary output
2851 if (!cfg
->line_outs
) {
2852 if (cfg
->speaker_outs
) {
2853 cfg
->line_outs
= cfg
->speaker_outs
;
2854 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
2855 sizeof(cfg
->speaker_pins
));
2856 cfg
->speaker_outs
= 0;
2857 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
2858 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
2859 } else if (cfg
->hp_outs
) {
2860 cfg
->line_outs
= cfg
->hp_outs
;
2861 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
2862 sizeof(cfg
->hp_pins
));
2864 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
2865 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
2869 /* Reorder the surround channels
2870 * ALSA sequence is front/surr/clfe/side
2872 * 4-ch: front/surr => OK as it is
2873 * 6-ch: front/clfe/surr
2874 * 8-ch: front/clfe/rear/side|fc
2876 switch (cfg
->line_outs
) {
2879 nid
= cfg
->line_out_pins
[1];
2880 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
2881 cfg
->line_out_pins
[2] = nid
;
2886 * debug prints of the parsed results
2888 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2889 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
2890 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
2891 cfg
->line_out_pins
[4]);
2892 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2893 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
2894 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
2895 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
2896 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2897 cfg
->hp_outs
, cfg
->hp_pins
[0],
2898 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
2899 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
2900 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
2901 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
2902 " cd=0x%x, aux=0x%x\n",
2903 cfg
->input_pins
[AUTO_PIN_MIC
],
2904 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
2905 cfg
->input_pins
[AUTO_PIN_LINE
],
2906 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
2907 cfg
->input_pins
[AUTO_PIN_CD
],
2908 cfg
->input_pins
[AUTO_PIN_AUX
]);
2913 /* labels for input pins */
2914 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
2915 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
2925 * snd_hda_suspend - suspend the codecs
2927 * @state: suspsend state
2929 * Returns 0 if successful.
2931 int snd_hda_suspend(struct hda_bus
*bus
, pm_message_t state
)
2933 struct hda_codec
*codec
;
2935 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2936 #ifdef CONFIG_SND_HDA_POWER_SAVE
2937 if (!codec
->power_on
)
2940 hda_call_codec_suspend(codec
);
2946 * snd_hda_resume - resume the codecs
2948 * @state: resume state
2950 * Returns 0 if successful.
2952 * This fucntion is defined only when POWER_SAVE isn't set.
2953 * In the power-save mode, the codec is resumed dynamically.
2955 int snd_hda_resume(struct hda_bus
*bus
)
2957 struct hda_codec
*codec
;
2959 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2960 if (snd_hda_codec_needs_resume(codec
))
2961 hda_call_codec_resume(codec
);
2965 #ifdef CONFIG_SND_HDA_POWER_SAVE
2966 int snd_hda_codecs_inuse(struct hda_bus
*bus
)
2968 struct hda_codec
*codec
;
2970 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2971 if (snd_hda_codec_needs_resume(codec
))