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);
791 /* look up the given pin config list and return the item matching with NID */
792 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
793 struct snd_array
*array
,
797 for (i
= 0; i
< array
->used
; i
++) {
798 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
805 /* write a config value for the given NID */
806 static void set_pincfg(struct hda_codec
*codec
, hda_nid_t nid
,
810 for (i
= 0; i
< 4; i
++) {
811 snd_hda_codec_write(codec
, nid
, 0,
812 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
+ i
,
818 /* set the current pin config value for the given NID.
819 * the value is cached, and read via snd_hda_codec_get_pincfg()
821 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
822 hda_nid_t nid
, unsigned int cfg
)
824 struct hda_pincfg
*pin
;
827 oldcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
828 pin
= look_up_pincfg(codec
, list
, nid
);
830 pin
= snd_array_new(list
);
837 /* change only when needed; e.g. if the pincfg is already present
838 * in user_pins[], don't write it
840 cfg
= snd_hda_codec_get_pincfg(codec
, nid
);
842 set_pincfg(codec
, nid
, cfg
);
847 * snd_hda_codec_set_pincfg - Override a pin default configuration
848 * @codec: the HDA codec
849 * @nid: NID to set the pin config
850 * @cfg: the pin default config value
852 * Override a pin default configuration value in the cache.
853 * This value can be read by snd_hda_codec_get_pincfg() in a higher
854 * priority than the real hardware value.
856 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
857 hda_nid_t nid
, unsigned int cfg
)
859 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
861 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg
);
864 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
865 * @codec: the HDA codec
866 * @nid: NID to get the pin config
868 * Get the current pin config value of the given pin NID.
869 * If the pincfg value is cached or overridden via sysfs or driver,
870 * returns the cached value.
872 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
874 struct hda_pincfg
*pin
;
876 #ifdef CONFIG_SND_HDA_HWDEP
877 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
881 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
884 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
889 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg
);
891 /* restore all current pin configs */
892 static void restore_pincfgs(struct hda_codec
*codec
)
895 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
896 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
897 set_pincfg(codec
, pin
->nid
,
898 snd_hda_codec_get_pincfg(codec
, pin
->nid
));
902 static void init_hda_cache(struct hda_cache_rec
*cache
,
903 unsigned int record_size
);
904 static void free_hda_cache(struct hda_cache_rec
*cache
);
906 /* restore the initial pin cfgs and release all pincfg lists */
907 static void restore_init_pincfgs(struct hda_codec
*codec
)
909 /* first free driver_pins and user_pins, then call restore_pincfg
910 * so that only the values in init_pins are restored
912 snd_array_free(&codec
->driver_pins
);
913 #ifdef CONFIG_SND_HDA_HWDEP
914 snd_array_free(&codec
->user_pins
);
916 restore_pincfgs(codec
);
917 snd_array_free(&codec
->init_pins
);
923 static void snd_hda_codec_free(struct hda_codec
*codec
)
927 restore_init_pincfgs(codec
);
928 #ifdef CONFIG_SND_HDA_POWER_SAVE
929 cancel_delayed_work(&codec
->power_work
);
930 flush_workqueue(codec
->bus
->workq
);
932 list_del(&codec
->list
);
933 snd_array_free(&codec
->mixers
);
934 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
935 if (codec
->patch_ops
.free
)
936 codec
->patch_ops
.free(codec
);
937 module_put(codec
->owner
);
938 free_hda_cache(&codec
->amp_cache
);
939 free_hda_cache(&codec
->cmd_cache
);
940 kfree(codec
->vendor_name
);
941 kfree(codec
->chip_name
);
942 kfree(codec
->modelname
);
947 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
948 unsigned int power_state
);
951 * snd_hda_codec_new - create a HDA codec
952 * @bus: the bus to assign
953 * @codec_addr: the codec address
954 * @codecp: the pointer to store the generated codec
956 * Returns 0 if successful, or a negative error code.
958 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
, unsigned int codec_addr
,
959 struct hda_codec
**codecp
)
961 struct hda_codec
*codec
;
965 if (snd_BUG_ON(!bus
))
967 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
970 if (bus
->caddr_tbl
[codec_addr
]) {
971 snd_printk(KERN_ERR
"hda_codec: "
972 "address 0x%x is already occupied\n", codec_addr
);
976 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
978 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
983 codec
->addr
= codec_addr
;
984 mutex_init(&codec
->spdif_mutex
);
985 mutex_init(&codec
->control_mutex
);
986 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
987 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
988 snd_array_init(&codec
->mixers
, sizeof(struct hda_nid_item
), 60);
989 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
990 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
991 if (codec
->bus
->modelname
) {
992 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
993 if (!codec
->modelname
) {
994 snd_hda_codec_free(codec
);
999 #ifdef CONFIG_SND_HDA_POWER_SAVE
1000 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
1001 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1002 * the caller has to power down appropriatley after initialization
1005 hda_keep_power_on(codec
);
1008 list_add_tail(&codec
->list
, &bus
->codec_list
);
1009 bus
->caddr_tbl
[codec_addr
] = codec
;
1011 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1013 if (codec
->vendor_id
== -1)
1014 /* read again, hopefully the access method was corrected
1015 * in the last read...
1017 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1019 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1020 AC_PAR_SUBSYSTEM_ID
);
1021 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1024 setup_fg_nodes(codec
);
1025 if (!codec
->afg
&& !codec
->mfg
) {
1026 snd_printdd("hda_codec: no AFG or MFG node found\n");
1031 err
= read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
);
1033 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
1036 err
= read_pin_defaults(codec
);
1040 if (!codec
->subsystem_id
) {
1041 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
1042 codec
->subsystem_id
=
1043 snd_hda_codec_read(codec
, nid
, 0,
1044 AC_VERB_GET_SUBSYSTEM_ID
, 0);
1047 /* power-up all before initialization */
1048 hda_set_power_state(codec
,
1049 codec
->afg
? codec
->afg
: codec
->mfg
,
1052 snd_hda_codec_proc_new(codec
);
1054 snd_hda_create_hwdep(codec
);
1056 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
1057 codec
->subsystem_id
, codec
->revision_id
);
1058 snd_component_add(codec
->bus
->card
, component
);
1065 snd_hda_codec_free(codec
);
1068 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
1071 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1072 * @codec: the HDA codec
1074 * Start parsing of the given codec tree and (re-)initialize the whole
1077 * Returns 0 if successful or a negative error code.
1079 int snd_hda_codec_configure(struct hda_codec
*codec
)
1083 codec
->preset
= find_codec_preset(codec
);
1084 if (!codec
->vendor_name
|| !codec
->chip_name
) {
1085 err
= get_codec_name(codec
);
1089 /* audio codec should override the mixer name */
1090 if (codec
->afg
|| !*codec
->bus
->card
->mixername
)
1091 snprintf(codec
->bus
->card
->mixername
,
1092 sizeof(codec
->bus
->card
->mixername
),
1093 "%s %s", codec
->vendor_name
, codec
->chip_name
);
1095 if (is_generic_config(codec
)) {
1096 err
= snd_hda_parse_generic_codec(codec
);
1099 if (codec
->preset
&& codec
->preset
->patch
) {
1100 err
= codec
->preset
->patch(codec
);
1104 /* call the default parser */
1105 err
= snd_hda_parse_generic_codec(codec
);
1107 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
1110 if (!err
&& codec
->patch_ops
.unsol_event
)
1111 err
= init_unsol_queue(codec
->bus
);
1114 EXPORT_SYMBOL_HDA(snd_hda_codec_configure
);
1117 * snd_hda_codec_setup_stream - set up the codec for streaming
1118 * @codec: the CODEC to set up
1119 * @nid: the NID to set up
1120 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1121 * @channel_id: channel id to pass, zero based.
1122 * @format: stream format.
1124 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1126 int channel_id
, int format
)
1131 snd_printdd("hda_codec_setup_stream: "
1132 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1133 nid
, stream_tag
, channel_id
, format
);
1134 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
,
1135 (stream_tag
<< 4) | channel_id
);
1137 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, format
);
1139 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
1142 * snd_hda_codec_cleanup_stream - clean up the codec for closing
1143 * @codec: the CODEC to clean up
1144 * @nid: the NID to clean up
1146 void snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
)
1151 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1152 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1153 #if 0 /* keep the format */
1155 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
1158 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream
);
1161 * amp access functions
1164 /* FIXME: more better hash key? */
1165 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1166 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1167 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1168 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1169 #define INFO_AMP_CAPS (1<<0)
1170 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1172 /* initialize the hash table */
1173 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
1174 unsigned int record_size
)
1176 memset(cache
, 0, sizeof(*cache
));
1177 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1178 snd_array_init(&cache
->buf
, record_size
, 64);
1181 static void free_hda_cache(struct hda_cache_rec
*cache
)
1183 snd_array_free(&cache
->buf
);
1186 /* query the hash. allocate an entry if not found. */
1187 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1190 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1191 u16 cur
= cache
->hash
[idx
];
1192 struct hda_cache_head
*info
;
1194 while (cur
!= 0xffff) {
1195 info
= snd_array_elem(&cache
->buf
, cur
);
1196 if (info
->key
== key
)
1201 /* add a new hash entry */
1202 info
= snd_array_new(&cache
->buf
);
1205 cur
= snd_array_index(&cache
->buf
, info
);
1208 info
->next
= cache
->hash
[idx
];
1209 cache
->hash
[idx
] = cur
;
1214 /* query and allocate an amp hash entry */
1215 static inline struct hda_amp_info
*
1216 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1218 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1222 * query_amp_caps - query AMP capabilities
1223 * @codec: the HD-auio codec
1224 * @nid: the NID to query
1225 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1227 * Query AMP capabilities for the given widget and direction.
1228 * Returns the obtained capability bits.
1230 * When cap bits have been already read, this doesn't read again but
1231 * returns the cached value.
1233 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1235 struct hda_amp_info
*info
;
1237 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
1240 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1241 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1243 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
1244 direction
== HDA_OUTPUT
?
1245 AC_PAR_AMP_OUT_CAP
:
1248 info
->head
.val
|= INFO_AMP_CAPS
;
1250 return info
->amp_caps
;
1252 EXPORT_SYMBOL_HDA(query_amp_caps
);
1255 * snd_hda_override_amp_caps - Override the AMP capabilities
1256 * @codec: the CODEC to clean up
1257 * @nid: the NID to clean up
1258 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1259 * @caps: the capability bits to set
1261 * Override the cached AMP caps bits value by the given one.
1262 * This function is useful if the driver needs to adjust the AMP ranges,
1263 * e.g. limit to 0dB, etc.
1265 * Returns zero if successful or a negative error code.
1267 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1270 struct hda_amp_info
*info
;
1272 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
1275 info
->amp_caps
= caps
;
1276 info
->head
.val
|= INFO_AMP_CAPS
;
1279 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1282 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, u32 key
,
1283 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
))
1285 struct hda_amp_info
*info
;
1287 info
= get_alloc_amp_hash(codec
, key
);
1290 if (!info
->head
.val
) {
1291 info
->head
.val
|= INFO_AMP_CAPS
;
1292 info
->amp_caps
= func(codec
, nid
);
1294 return info
->amp_caps
;
1297 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
)
1299 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1303 * snd_hda_query_pin_caps - Query PIN capabilities
1304 * @codec: the HD-auio codec
1305 * @nid: the NID to query
1307 * Query PIN capabilities for the given widget.
1308 * Returns the obtained capability bits.
1310 * When cap bits have been already read, this doesn't read again but
1311 * returns the cached value.
1313 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1315 return query_caps_hash(codec
, nid
, HDA_HASH_PINCAP_KEY(nid
),
1318 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps
);
1321 * snd_hda_pin_sense - execute pin sense measurement
1322 * @codec: the CODEC to sense
1323 * @nid: the pin NID to sense
1325 * Execute necessary pin sense measurement and return its Presence Detect,
1326 * Impedance, ELD Valid etc. status bits.
1328 u32
snd_hda_pin_sense(struct hda_codec
*codec
, hda_nid_t nid
)
1330 u32 pincap
= snd_hda_query_pin_caps(codec
, nid
);
1332 if (pincap
& AC_PINCAP_TRIG_REQ
) /* need trigger? */
1333 snd_hda_codec_read(codec
, nid
, 0, AC_VERB_SET_PIN_SENSE
, 0);
1335 return snd_hda_codec_read(codec
, nid
, 0,
1336 AC_VERB_GET_PIN_SENSE
, 0);
1338 EXPORT_SYMBOL_HDA(snd_hda_pin_sense
);
1341 * snd_hda_jack_detect - query pin Presence Detect status
1342 * @codec: the CODEC to sense
1343 * @nid: the pin NID to sense
1345 * Query and return the pin's Presence Detect status.
1347 int snd_hda_jack_detect(struct hda_codec
*codec
, hda_nid_t nid
)
1349 u32 sense
= snd_hda_pin_sense(codec
, nid
);
1350 return !!(sense
& AC_PINSENSE_PRESENCE
);
1352 EXPORT_SYMBOL_HDA(snd_hda_jack_detect
);
1355 * read the current volume to info
1356 * if the cache exists, read the cache value.
1358 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1359 struct hda_amp_info
*info
, hda_nid_t nid
,
1360 int ch
, int direction
, int index
)
1364 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1365 return info
->vol
[ch
];
1367 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1368 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1370 val
= snd_hda_codec_read(codec
, nid
, 0,
1371 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1372 info
->vol
[ch
] = val
& 0xff;
1373 info
->head
.val
|= INFO_AMP_VOL(ch
);
1374 return info
->vol
[ch
];
1378 * write the current volume in info to the h/w and update the cache
1380 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1381 hda_nid_t nid
, int ch
, int direction
, int index
,
1386 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1387 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1388 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1390 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1391 info
->vol
[ch
] = val
;
1395 * snd_hda_codec_amp_read - Read AMP value
1396 * @codec: HD-audio codec
1397 * @nid: NID to read the AMP value
1398 * @ch: channel (left=0 or right=1)
1399 * @direction: #HDA_INPUT or #HDA_OUTPUT
1400 * @index: the index value (only for input direction)
1402 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1404 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1405 int direction
, int index
)
1407 struct hda_amp_info
*info
;
1408 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1411 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1413 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1416 * snd_hda_codec_amp_update - update the AMP value
1417 * @codec: HD-audio codec
1418 * @nid: NID to read the AMP value
1419 * @ch: channel (left=0 or right=1)
1420 * @direction: #HDA_INPUT or #HDA_OUTPUT
1421 * @idx: the index value (only for input direction)
1422 * @mask: bit mask to set
1423 * @val: the bits value to set
1425 * Update the AMP value with a bit mask.
1426 * Returns 0 if the value is unchanged, 1 if changed.
1428 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1429 int direction
, int idx
, int mask
, int val
)
1431 struct hda_amp_info
*info
;
1433 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1437 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1438 if (info
->vol
[ch
] == val
)
1440 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1443 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1446 * snd_hda_codec_amp_stereo - update the AMP stereo values
1447 * @codec: HD-audio codec
1448 * @nid: NID to read the AMP value
1449 * @direction: #HDA_INPUT or #HDA_OUTPUT
1450 * @idx: the index value (only for input direction)
1451 * @mask: bit mask to set
1452 * @val: the bits value to set
1454 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1455 * stereo widget with the same mask and value.
1457 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1458 int direction
, int idx
, int mask
, int val
)
1461 for (ch
= 0; ch
< 2; ch
++)
1462 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1466 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1468 #ifdef SND_HDA_NEEDS_RESUME
1470 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1471 * @codec: HD-audio codec
1473 * Resume the all amp commands from the cache.
1475 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1477 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1480 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1481 u32 key
= buffer
->head
.key
;
1483 unsigned int idx
, dir
, ch
;
1487 idx
= (key
>> 16) & 0xff;
1488 dir
= (key
>> 24) & 0xff;
1489 for (ch
= 0; ch
< 2; ch
++) {
1490 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1492 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1497 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1498 #endif /* SND_HDA_NEEDS_RESUME */
1501 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1503 * The control element is supposed to have the private_value field
1504 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1506 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1507 struct snd_ctl_elem_info
*uinfo
)
1509 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1510 u16 nid
= get_amp_nid(kcontrol
);
1511 u8 chs
= get_amp_channels(kcontrol
);
1512 int dir
= get_amp_direction(kcontrol
);
1513 unsigned int ofs
= get_amp_offset(kcontrol
);
1516 caps
= query_amp_caps(codec
, nid
, dir
);
1518 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1520 printk(KERN_WARNING
"hda_codec: "
1521 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1527 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1528 uinfo
->count
= chs
== 3 ? 2 : 1;
1529 uinfo
->value
.integer
.min
= 0;
1530 uinfo
->value
.integer
.max
= caps
;
1533 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1536 static inline unsigned int
1537 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1538 int ch
, int dir
, int idx
, unsigned int ofs
)
1541 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1542 val
&= HDA_AMP_VOLMASK
;
1551 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1552 int ch
, int dir
, int idx
, unsigned int ofs
,
1557 return snd_hda_codec_amp_update(codec
, nid
, ch
, dir
, idx
,
1558 HDA_AMP_VOLMASK
, val
);
1562 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1564 * The control element is supposed to have the private_value field
1565 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1567 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1568 struct snd_ctl_elem_value
*ucontrol
)
1570 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1571 hda_nid_t nid
= get_amp_nid(kcontrol
);
1572 int chs
= get_amp_channels(kcontrol
);
1573 int dir
= get_amp_direction(kcontrol
);
1574 int idx
= get_amp_index(kcontrol
);
1575 unsigned int ofs
= get_amp_offset(kcontrol
);
1576 long *valp
= ucontrol
->value
.integer
.value
;
1579 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
1581 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
1584 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
1587 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1589 * The control element is supposed to have the private_value field
1590 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1592 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1593 struct snd_ctl_elem_value
*ucontrol
)
1595 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1596 hda_nid_t nid
= get_amp_nid(kcontrol
);
1597 int chs
= get_amp_channels(kcontrol
);
1598 int dir
= get_amp_direction(kcontrol
);
1599 int idx
= get_amp_index(kcontrol
);
1600 unsigned int ofs
= get_amp_offset(kcontrol
);
1601 long *valp
= ucontrol
->value
.integer
.value
;
1604 snd_hda_power_up(codec
);
1606 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
1610 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
1611 snd_hda_power_down(codec
);
1614 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
1617 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1619 * The control element is supposed to have the private_value field
1620 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1622 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1623 unsigned int size
, unsigned int __user
*_tlv
)
1625 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1626 hda_nid_t nid
= get_amp_nid(kcontrol
);
1627 int dir
= get_amp_direction(kcontrol
);
1628 unsigned int ofs
= get_amp_offset(kcontrol
);
1629 u32 caps
, val1
, val2
;
1631 if (size
< 4 * sizeof(unsigned int))
1633 caps
= query_amp_caps(codec
, nid
, dir
);
1634 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1635 val2
= (val2
+ 1) * 25;
1636 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1638 val1
= ((int)val1
) * ((int)val2
);
1639 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1641 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1643 if (put_user(val1
, _tlv
+ 2))
1645 if (put_user(val2
, _tlv
+ 3))
1649 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
1652 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1653 * @codec: HD-audio codec
1654 * @nid: NID of a reference widget
1655 * @dir: #HDA_INPUT or #HDA_OUTPUT
1656 * @tlv: TLV data to be stored, at least 4 elements
1658 * Set (static) TLV data for a virtual master volume using the AMP caps
1659 * obtained from the reference NID.
1660 * The volume range is recalculated as if the max volume is 0dB.
1662 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1668 caps
= query_amp_caps(codec
, nid
, dir
);
1669 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1670 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1671 step
= (step
+ 1) * 25;
1672 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1673 tlv
[1] = 2 * sizeof(unsigned int);
1674 tlv
[2] = -nums
* step
;
1677 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
1679 /* find a mixer control element with the given name */
1680 static struct snd_kcontrol
*
1681 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1682 const char *name
, int idx
)
1684 struct snd_ctl_elem_id id
;
1685 memset(&id
, 0, sizeof(id
));
1686 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1688 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
1690 strcpy(id
.name
, name
);
1691 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1695 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1696 * @codec: HD-audio codec
1697 * @name: ctl id name string
1699 * Get the control element with the given id string and IFACE_MIXER.
1701 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1704 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
1706 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
1709 * snd_hda_ctl-add - Add a control element and assign to the codec
1710 * @codec: HD-audio codec
1711 * @nid: corresponding NID (optional)
1712 * @kctl: the control element to assign
1714 * Add the given control element to an array inside the codec instance.
1715 * All control elements belonging to a codec are supposed to be added
1716 * by this function so that a proper clean-up works at the free or
1717 * reconfiguration time.
1719 * If non-zero @nid is passed, the NID is assigned to the control element.
1720 * The assignment is shown in the codec proc file.
1722 * snd_hda_ctl_add() checks the control subdev id field whether
1723 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1724 * bits value is taken as the NID to assign.
1726 int snd_hda_ctl_add(struct hda_codec
*codec
, hda_nid_t nid
,
1727 struct snd_kcontrol
*kctl
)
1730 struct hda_nid_item
*item
;
1732 if (kctl
->id
.subdevice
& HDA_SUBDEV_NID_FLAG
) {
1734 nid
= kctl
->id
.subdevice
& 0xffff;
1735 kctl
->id
.subdevice
= 0;
1737 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1740 item
= snd_array_new(&codec
->mixers
);
1747 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
1750 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1751 * @codec: HD-audio codec
1753 void snd_hda_ctls_clear(struct hda_codec
*codec
)
1756 struct hda_nid_item
*items
= codec
->mixers
.list
;
1757 for (i
= 0; i
< codec
->mixers
.used
; i
++)
1758 snd_ctl_remove(codec
->bus
->card
, items
[i
].kctl
);
1759 snd_array_free(&codec
->mixers
);
1762 /* pseudo device locking
1763 * toggle card->shutdown to allow/disallow the device access (as a hack)
1765 static int hda_lock_devices(struct snd_card
*card
)
1767 spin_lock(&card
->files_lock
);
1768 if (card
->shutdown
) {
1769 spin_unlock(&card
->files_lock
);
1773 spin_unlock(&card
->files_lock
);
1777 static void hda_unlock_devices(struct snd_card
*card
)
1779 spin_lock(&card
->files_lock
);
1781 spin_unlock(&card
->files_lock
);
1785 * snd_hda_codec_reset - Clear all objects assigned to the codec
1786 * @codec: HD-audio codec
1788 * This frees the all PCM and control elements assigned to the codec, and
1789 * clears the caches and restores the pin default configurations.
1791 * When a device is being used, it returns -EBSY. If successfully freed,
1794 int snd_hda_codec_reset(struct hda_codec
*codec
)
1796 struct snd_card
*card
= codec
->bus
->card
;
1799 if (hda_lock_devices(card
) < 0)
1801 /* check whether the codec isn't used by any mixer or PCM streams */
1802 if (!list_empty(&card
->ctl_files
)) {
1803 hda_unlock_devices(card
);
1806 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
1807 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
1810 if (cpcm
->pcm
->streams
[0].substream_opened
||
1811 cpcm
->pcm
->streams
[1].substream_opened
) {
1812 hda_unlock_devices(card
);
1817 /* OK, let it free */
1819 #ifdef CONFIG_SND_HDA_POWER_SAVE
1820 cancel_delayed_work(&codec
->power_work
);
1821 flush_workqueue(codec
->bus
->workq
);
1823 snd_hda_ctls_clear(codec
);
1825 for (i
= 0; i
< codec
->num_pcms
; i
++) {
1826 if (codec
->pcm_info
[i
].pcm
) {
1827 snd_device_free(card
, codec
->pcm_info
[i
].pcm
);
1828 clear_bit(codec
->pcm_info
[i
].device
,
1829 codec
->bus
->pcm_dev_bits
);
1832 if (codec
->patch_ops
.free
)
1833 codec
->patch_ops
.free(codec
);
1834 codec
->proc_widget_hook
= NULL
;
1836 free_hda_cache(&codec
->amp_cache
);
1837 free_hda_cache(&codec
->cmd_cache
);
1838 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1839 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1840 /* free only driver_pins so that init_pins + user_pins are restored */
1841 snd_array_free(&codec
->driver_pins
);
1842 restore_pincfgs(codec
);
1843 codec
->num_pcms
= 0;
1844 codec
->pcm_info
= NULL
;
1845 codec
->preset
= NULL
;
1846 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
1847 codec
->slave_dig_outs
= NULL
;
1848 codec
->spdif_status_reset
= 0;
1849 module_put(codec
->owner
);
1850 codec
->owner
= NULL
;
1852 /* allow device access again */
1853 hda_unlock_devices(card
);
1858 * snd_hda_add_vmaster - create a virtual master control and add slaves
1859 * @codec: HD-audio codec
1860 * @name: vmaster control name
1861 * @tlv: TLV data (optional)
1862 * @slaves: slave control names (optional)
1864 * Create a virtual master control with the given name. The TLV data
1865 * must be either NULL or a valid data.
1867 * @slaves is a NULL-terminated array of strings, each of which is a
1868 * slave control name. All controls with these names are assigned to
1869 * the new virtual master control.
1871 * This function returns zero if successful or a negative error code.
1873 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
1874 unsigned int *tlv
, const char **slaves
)
1876 struct snd_kcontrol
*kctl
;
1880 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
1883 snd_printdd("No slave found for %s\n", name
);
1886 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
1889 err
= snd_hda_ctl_add(codec
, 0, kctl
);
1893 for (s
= slaves
; *s
; s
++) {
1894 struct snd_kcontrol
*sctl
;
1897 sctl
= _snd_hda_find_mixer_ctl(codec
, *s
, i
);
1900 snd_printdd("Cannot find slave %s, "
1904 err
= snd_ctl_add_slave(kctl
, sctl
);
1912 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
1915 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
1917 * The control element is supposed to have the private_value field
1918 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1920 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
1921 struct snd_ctl_elem_info
*uinfo
)
1923 int chs
= get_amp_channels(kcontrol
);
1925 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1926 uinfo
->count
= chs
== 3 ? 2 : 1;
1927 uinfo
->value
.integer
.min
= 0;
1928 uinfo
->value
.integer
.max
= 1;
1931 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
1934 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
1936 * The control element is supposed to have the private_value field
1937 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1939 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
1940 struct snd_ctl_elem_value
*ucontrol
)
1942 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1943 hda_nid_t nid
= get_amp_nid(kcontrol
);
1944 int chs
= get_amp_channels(kcontrol
);
1945 int dir
= get_amp_direction(kcontrol
);
1946 int idx
= get_amp_index(kcontrol
);
1947 long *valp
= ucontrol
->value
.integer
.value
;
1950 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
1951 HDA_AMP_MUTE
) ? 0 : 1;
1953 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
1954 HDA_AMP_MUTE
) ? 0 : 1;
1957 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
1960 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
1962 * The control element is supposed to have the private_value field
1963 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1965 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
1966 struct snd_ctl_elem_value
*ucontrol
)
1968 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1969 hda_nid_t nid
= get_amp_nid(kcontrol
);
1970 int chs
= get_amp_channels(kcontrol
);
1971 int dir
= get_amp_direction(kcontrol
);
1972 int idx
= get_amp_index(kcontrol
);
1973 long *valp
= ucontrol
->value
.integer
.value
;
1976 snd_hda_power_up(codec
);
1978 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
1980 *valp
? 0 : HDA_AMP_MUTE
);
1984 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
1986 *valp
? 0 : HDA_AMP_MUTE
);
1987 #ifdef CONFIG_SND_HDA_POWER_SAVE
1988 if (codec
->patch_ops
.check_power_status
)
1989 codec
->patch_ops
.check_power_status(codec
, nid
);
1991 snd_hda_power_down(codec
);
1994 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
1996 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1998 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2000 * This function calls snd_hda_enable_beep_device(), which behaves differently
2001 * depending on beep_mode option.
2003 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol
*kcontrol
,
2004 struct snd_ctl_elem_value
*ucontrol
)
2006 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2007 long *valp
= ucontrol
->value
.integer
.value
;
2009 snd_hda_enable_beep_device(codec
, *valp
);
2010 return snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2012 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep
);
2013 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2016 * bound volume controls
2018 * bind multiple volumes (# indices, from 0)
2021 #define AMP_VAL_IDX_SHIFT 19
2022 #define AMP_VAL_IDX_MASK (0x0f<<19)
2025 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2027 * The control element is supposed to have the private_value field
2028 * set up via HDA_BIND_MUTE*() macros.
2030 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
2031 struct snd_ctl_elem_value
*ucontrol
)
2033 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2037 mutex_lock(&codec
->control_mutex
);
2038 pval
= kcontrol
->private_value
;
2039 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
2040 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
2041 kcontrol
->private_value
= pval
;
2042 mutex_unlock(&codec
->control_mutex
);
2045 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
2048 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2050 * The control element is supposed to have the private_value field
2051 * set up via HDA_BIND_MUTE*() macros.
2053 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
2054 struct snd_ctl_elem_value
*ucontrol
)
2056 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2058 int i
, indices
, err
= 0, change
= 0;
2060 mutex_lock(&codec
->control_mutex
);
2061 pval
= kcontrol
->private_value
;
2062 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
2063 for (i
= 0; i
< indices
; i
++) {
2064 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
2065 (i
<< AMP_VAL_IDX_SHIFT
);
2066 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2071 kcontrol
->private_value
= pval
;
2072 mutex_unlock(&codec
->control_mutex
);
2073 return err
< 0 ? err
: change
;
2075 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
2078 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2080 * The control element is supposed to have the private_value field
2081 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2083 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
2084 struct snd_ctl_elem_info
*uinfo
)
2086 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2087 struct hda_bind_ctls
*c
;
2090 mutex_lock(&codec
->control_mutex
);
2091 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2092 kcontrol
->private_value
= *c
->values
;
2093 err
= c
->ops
->info(kcontrol
, uinfo
);
2094 kcontrol
->private_value
= (long)c
;
2095 mutex_unlock(&codec
->control_mutex
);
2098 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
2101 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2103 * The control element is supposed to have the private_value field
2104 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2106 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
2107 struct snd_ctl_elem_value
*ucontrol
)
2109 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2110 struct hda_bind_ctls
*c
;
2113 mutex_lock(&codec
->control_mutex
);
2114 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2115 kcontrol
->private_value
= *c
->values
;
2116 err
= c
->ops
->get(kcontrol
, ucontrol
);
2117 kcontrol
->private_value
= (long)c
;
2118 mutex_unlock(&codec
->control_mutex
);
2121 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
2124 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2126 * The control element is supposed to have the private_value field
2127 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2129 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
2130 struct snd_ctl_elem_value
*ucontrol
)
2132 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2133 struct hda_bind_ctls
*c
;
2134 unsigned long *vals
;
2135 int err
= 0, change
= 0;
2137 mutex_lock(&codec
->control_mutex
);
2138 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2139 for (vals
= c
->values
; *vals
; vals
++) {
2140 kcontrol
->private_value
= *vals
;
2141 err
= c
->ops
->put(kcontrol
, ucontrol
);
2146 kcontrol
->private_value
= (long)c
;
2147 mutex_unlock(&codec
->control_mutex
);
2148 return err
< 0 ? err
: change
;
2150 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
2153 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2155 * The control element is supposed to have the private_value field
2156 * set up via HDA_BIND_VOL() macro.
2158 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2159 unsigned int size
, unsigned int __user
*tlv
)
2161 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2162 struct hda_bind_ctls
*c
;
2165 mutex_lock(&codec
->control_mutex
);
2166 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2167 kcontrol
->private_value
= *c
->values
;
2168 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
2169 kcontrol
->private_value
= (long)c
;
2170 mutex_unlock(&codec
->control_mutex
);
2173 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
2175 struct hda_ctl_ops snd_hda_bind_vol
= {
2176 .info
= snd_hda_mixer_amp_volume_info
,
2177 .get
= snd_hda_mixer_amp_volume_get
,
2178 .put
= snd_hda_mixer_amp_volume_put
,
2179 .tlv
= snd_hda_mixer_amp_tlv
2181 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
2183 struct hda_ctl_ops snd_hda_bind_sw
= {
2184 .info
= snd_hda_mixer_amp_switch_info
,
2185 .get
= snd_hda_mixer_amp_switch_get
,
2186 .put
= snd_hda_mixer_amp_switch_put
,
2187 .tlv
= snd_hda_mixer_amp_tlv
2189 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
2192 * SPDIF out controls
2195 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2196 struct snd_ctl_elem_info
*uinfo
)
2198 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2203 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
2204 struct snd_ctl_elem_value
*ucontrol
)
2206 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2207 IEC958_AES0_NONAUDIO
|
2208 IEC958_AES0_CON_EMPHASIS_5015
|
2209 IEC958_AES0_CON_NOT_COPYRIGHT
;
2210 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
2211 IEC958_AES1_CON_ORIGINAL
;
2215 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
2216 struct snd_ctl_elem_value
*ucontrol
)
2218 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2219 IEC958_AES0_NONAUDIO
|
2220 IEC958_AES0_PRO_EMPHASIS_5015
;
2224 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2225 struct snd_ctl_elem_value
*ucontrol
)
2227 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2229 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
2230 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
2231 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
2232 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
2237 /* convert from SPDIF status bits to HDA SPDIF bits
2238 * bit 0 (DigEn) is always set zero (to be filled later)
2240 static unsigned short convert_from_spdif_status(unsigned int sbits
)
2242 unsigned short val
= 0;
2244 if (sbits
& IEC958_AES0_PROFESSIONAL
)
2245 val
|= AC_DIG1_PROFESSIONAL
;
2246 if (sbits
& IEC958_AES0_NONAUDIO
)
2247 val
|= AC_DIG1_NONAUDIO
;
2248 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2249 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
2250 IEC958_AES0_PRO_EMPHASIS_5015
)
2251 val
|= AC_DIG1_EMPHASIS
;
2253 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
2254 IEC958_AES0_CON_EMPHASIS_5015
)
2255 val
|= AC_DIG1_EMPHASIS
;
2256 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
2257 val
|= AC_DIG1_COPYRIGHT
;
2258 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
2259 val
|= AC_DIG1_LEVEL
;
2260 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
2265 /* convert to SPDIF status bits from HDA SPDIF bits
2267 static unsigned int convert_to_spdif_status(unsigned short val
)
2269 unsigned int sbits
= 0;
2271 if (val
& AC_DIG1_NONAUDIO
)
2272 sbits
|= IEC958_AES0_NONAUDIO
;
2273 if (val
& AC_DIG1_PROFESSIONAL
)
2274 sbits
|= IEC958_AES0_PROFESSIONAL
;
2275 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2276 if (sbits
& AC_DIG1_EMPHASIS
)
2277 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
2279 if (val
& AC_DIG1_EMPHASIS
)
2280 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
2281 if (!(val
& AC_DIG1_COPYRIGHT
))
2282 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
2283 if (val
& AC_DIG1_LEVEL
)
2284 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
2285 sbits
|= val
& (0x7f << 8);
2290 /* set digital convert verbs both for the given NID and its slaves */
2291 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
2296 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
2297 d
= codec
->slave_dig_outs
;
2301 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
2304 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
2308 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
2310 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2313 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2314 struct snd_ctl_elem_value
*ucontrol
)
2316 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2317 hda_nid_t nid
= kcontrol
->private_value
;
2321 mutex_lock(&codec
->spdif_mutex
);
2322 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
2323 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2324 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2325 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2326 val
= convert_from_spdif_status(codec
->spdif_status
);
2327 val
|= codec
->spdif_ctls
& 1;
2328 change
= codec
->spdif_ctls
!= val
;
2329 codec
->spdif_ctls
= val
;
2332 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2334 mutex_unlock(&codec
->spdif_mutex
);
2338 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2340 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2341 struct snd_ctl_elem_value
*ucontrol
)
2343 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2345 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
2349 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2350 struct snd_ctl_elem_value
*ucontrol
)
2352 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2353 hda_nid_t nid
= kcontrol
->private_value
;
2357 mutex_lock(&codec
->spdif_mutex
);
2358 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
2359 if (ucontrol
->value
.integer
.value
[0])
2360 val
|= AC_DIG1_ENABLE
;
2361 change
= codec
->spdif_ctls
!= val
;
2363 codec
->spdif_ctls
= val
;
2364 set_dig_out_convert(codec
, nid
, val
& 0xff, -1);
2365 /* unmute amp switch (if any) */
2366 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2367 (val
& AC_DIG1_ENABLE
))
2368 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2371 mutex_unlock(&codec
->spdif_mutex
);
2375 static struct snd_kcontrol_new dig_mixes
[] = {
2377 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2378 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2379 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,CON_MASK
),
2380 .info
= snd_hda_spdif_mask_info
,
2381 .get
= snd_hda_spdif_cmask_get
,
2384 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2385 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2386 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,PRO_MASK
),
2387 .info
= snd_hda_spdif_mask_info
,
2388 .get
= snd_hda_spdif_pmask_get
,
2391 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2392 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
2393 .info
= snd_hda_spdif_mask_info
,
2394 .get
= snd_hda_spdif_default_get
,
2395 .put
= snd_hda_spdif_default_put
,
2398 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2399 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,SWITCH
),
2400 .info
= snd_hda_spdif_out_switch_info
,
2401 .get
= snd_hda_spdif_out_switch_get
,
2402 .put
= snd_hda_spdif_out_switch_put
,
2407 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2410 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2411 * @codec: the HDA codec
2412 * @nid: audio out widget NID
2414 * Creates controls related with the SPDIF output.
2415 * Called from each patch supporting the SPDIF out.
2417 * Returns 0 if successful, or a negative error code.
2419 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2422 struct snd_kcontrol
*kctl
;
2423 struct snd_kcontrol_new
*dig_mix
;
2426 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2427 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Playback Switch",
2431 if (idx
>= SPDIF_MAX_IDX
) {
2432 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
2435 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
2436 kctl
= snd_ctl_new1(dig_mix
, codec
);
2439 kctl
->id
.index
= idx
;
2440 kctl
->private_value
= nid
;
2441 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2446 snd_hda_codec_read(codec
, nid
, 0,
2447 AC_VERB_GET_DIGI_CONVERT_1
, 0);
2448 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
2451 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
2454 * SPDIF sharing with analog output
2456 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
2457 struct snd_ctl_elem_value
*ucontrol
)
2459 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2460 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
2464 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
2465 struct snd_ctl_elem_value
*ucontrol
)
2467 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2468 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
2472 static struct snd_kcontrol_new spdif_share_sw
= {
2473 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2474 .name
= "IEC958 Default PCM Playback Switch",
2475 .info
= snd_ctl_boolean_mono_info
,
2476 .get
= spdif_share_sw_get
,
2477 .put
= spdif_share_sw_put
,
2481 * snd_hda_create_spdif_share_sw - create Default PCM switch
2482 * @codec: the HDA codec
2483 * @mout: multi-out instance
2485 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
2486 struct hda_multi_out
*mout
)
2488 if (!mout
->dig_out_nid
)
2490 /* ATTENTION: here mout is passed as private_data, instead of codec */
2491 return snd_hda_ctl_add(codec
, mout
->dig_out_nid
,
2492 snd_ctl_new1(&spdif_share_sw
, mout
));
2494 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
2500 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2502 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
2503 struct snd_ctl_elem_value
*ucontrol
)
2505 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2507 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
2511 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
2512 struct snd_ctl_elem_value
*ucontrol
)
2514 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2515 hda_nid_t nid
= kcontrol
->private_value
;
2516 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
2519 mutex_lock(&codec
->spdif_mutex
);
2520 change
= codec
->spdif_in_enable
!= val
;
2522 codec
->spdif_in_enable
= val
;
2523 snd_hda_codec_write_cache(codec
, nid
, 0,
2524 AC_VERB_SET_DIGI_CONVERT_1
, val
);
2526 mutex_unlock(&codec
->spdif_mutex
);
2530 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
2531 struct snd_ctl_elem_value
*ucontrol
)
2533 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2534 hda_nid_t nid
= kcontrol
->private_value
;
2538 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
2539 sbits
= convert_to_spdif_status(val
);
2540 ucontrol
->value
.iec958
.status
[0] = sbits
;
2541 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
2542 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
2543 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
2547 static struct snd_kcontrol_new dig_in_ctls
[] = {
2549 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2550 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
),
2551 .info
= snd_hda_spdif_in_switch_info
,
2552 .get
= snd_hda_spdif_in_switch_get
,
2553 .put
= snd_hda_spdif_in_switch_put
,
2556 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2557 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2558 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
2559 .info
= snd_hda_spdif_mask_info
,
2560 .get
= snd_hda_spdif_in_status_get
,
2566 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2567 * @codec: the HDA codec
2568 * @nid: audio in widget NID
2570 * Creates controls related with the SPDIF input.
2571 * Called from each patch supporting the SPDIF in.
2573 * Returns 0 if successful, or a negative error code.
2575 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2578 struct snd_kcontrol
*kctl
;
2579 struct snd_kcontrol_new
*dig_mix
;
2582 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2583 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Capture Switch",
2587 if (idx
>= SPDIF_MAX_IDX
) {
2588 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
2591 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
2592 kctl
= snd_ctl_new1(dig_mix
, codec
);
2595 kctl
->private_value
= nid
;
2596 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2600 codec
->spdif_in_enable
=
2601 snd_hda_codec_read(codec
, nid
, 0,
2602 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
2606 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
2608 #ifdef SND_HDA_NEEDS_RESUME
2613 /* build a 32bit cache key with the widget id and the command parameter */
2614 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2615 #define get_cmd_cache_nid(key) ((key) & 0xff)
2616 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2619 * snd_hda_codec_write_cache - send a single command with caching
2620 * @codec: the HDA codec
2621 * @nid: NID to send the command
2622 * @direct: direct flag
2623 * @verb: the verb to send
2624 * @parm: the parameter for the verb
2626 * Send a single command without waiting for response.
2628 * Returns 0 if successful, or a negative error code.
2630 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2631 int direct
, unsigned int verb
, unsigned int parm
)
2633 int err
= snd_hda_codec_write(codec
, nid
, direct
, verb
, parm
);
2634 struct hda_cache_head
*c
;
2639 /* parm may contain the verb stuff for get/set amp */
2640 verb
= verb
| (parm
>> 8);
2642 key
= build_cmd_cache_key(nid
, verb
);
2643 mutex_lock(&codec
->bus
->cmd_mutex
);
2644 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
2647 mutex_unlock(&codec
->bus
->cmd_mutex
);
2650 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
2653 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2654 * @codec: HD-audio codec
2656 * Execute all verbs recorded in the command caches to resume.
2658 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
2660 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
2663 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
2664 u32 key
= buffer
->key
;
2667 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
2668 get_cmd_cache_cmd(key
), buffer
->val
);
2671 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
2674 * snd_hda_sequence_write_cache - sequence writes with caching
2675 * @codec: the HDA codec
2676 * @seq: VERB array to send
2678 * Send the commands sequentially from the given array.
2679 * Thte commands are recorded on cache for power-save and resume.
2680 * The array must be terminated with NID=0.
2682 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
2683 const struct hda_verb
*seq
)
2685 for (; seq
->nid
; seq
++)
2686 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
2689 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
2690 #endif /* SND_HDA_NEEDS_RESUME */
2693 * set power state of the codec
2695 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2696 unsigned int power_state
)
2701 /* this delay seems necessary to avoid click noise at power-down */
2702 if (power_state
== AC_PWRST_D3
)
2704 snd_hda_codec_read(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
2706 /* partial workaround for "azx_get_response timeout" */
2707 if (power_state
== AC_PWRST_D0
)
2710 nid
= codec
->start_nid
;
2711 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2712 unsigned int wcaps
= get_wcaps(codec
, nid
);
2713 if (wcaps
& AC_WCAP_POWER
) {
2714 unsigned int wid_type
= get_wcaps_type(wcaps
);
2715 if (power_state
== AC_PWRST_D3
&&
2716 wid_type
== AC_WID_PIN
) {
2717 unsigned int pincap
;
2719 * don't power down the widget if it controls
2720 * eapd and EAPD_BTLENABLE is set.
2722 pincap
= snd_hda_query_pin_caps(codec
, nid
);
2723 if (pincap
& AC_PINCAP_EAPD
) {
2724 int eapd
= snd_hda_codec_read(codec
,
2726 AC_VERB_GET_EAPD_BTLENABLE
, 0);
2732 snd_hda_codec_write(codec
, nid
, 0,
2733 AC_VERB_SET_POWER_STATE
,
2738 if (power_state
== AC_PWRST_D0
) {
2739 unsigned long end_time
;
2742 /* wait until the codec reachs to D0 */
2743 end_time
= jiffies
+ msecs_to_jiffies(500);
2745 state
= snd_hda_codec_read(codec
, fg
, 0,
2746 AC_VERB_GET_POWER_STATE
, 0);
2747 if (state
== power_state
)
2750 } while (time_after_eq(end_time
, jiffies
));
2754 #ifdef CONFIG_SND_HDA_HWDEP
2755 /* execute additional init verbs */
2756 static void hda_exec_init_verbs(struct hda_codec
*codec
)
2758 if (codec
->init_verbs
.list
)
2759 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
2762 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
2765 #ifdef SND_HDA_NEEDS_RESUME
2767 * call suspend and power-down; used both from PM and power-save
2769 static void hda_call_codec_suspend(struct hda_codec
*codec
)
2771 if (codec
->patch_ops
.suspend
)
2772 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
2773 hda_set_power_state(codec
,
2774 codec
->afg
? codec
->afg
: codec
->mfg
,
2776 #ifdef CONFIG_SND_HDA_POWER_SAVE
2777 snd_hda_update_power_acct(codec
);
2778 cancel_delayed_work(&codec
->power_work
);
2779 codec
->power_on
= 0;
2780 codec
->power_transition
= 0;
2781 codec
->power_jiffies
= jiffies
;
2786 * kick up codec; used both from PM and power-save
2788 static void hda_call_codec_resume(struct hda_codec
*codec
)
2790 hda_set_power_state(codec
,
2791 codec
->afg
? codec
->afg
: codec
->mfg
,
2793 restore_pincfgs(codec
); /* restore all current pin configs */
2794 hda_exec_init_verbs(codec
);
2795 if (codec
->patch_ops
.resume
)
2796 codec
->patch_ops
.resume(codec
);
2798 if (codec
->patch_ops
.init
)
2799 codec
->patch_ops
.init(codec
);
2800 snd_hda_codec_resume_amp(codec
);
2801 snd_hda_codec_resume_cache(codec
);
2804 #endif /* SND_HDA_NEEDS_RESUME */
2808 * snd_hda_build_controls - build mixer controls
2811 * Creates mixer controls for each codec included in the bus.
2813 * Returns 0 if successful, otherwise a negative error code.
2815 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
2817 struct hda_codec
*codec
;
2819 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
2820 int err
= snd_hda_codec_build_controls(codec
);
2822 printk(KERN_ERR
"hda_codec: cannot build controls"
2823 "for #%d (error %d)\n", codec
->addr
, err
);
2824 err
= snd_hda_codec_reset(codec
);
2827 "hda_codec: cannot revert codec\n");
2834 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
2836 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
2839 hda_exec_init_verbs(codec
);
2840 /* continue to initialize... */
2841 if (codec
->patch_ops
.init
)
2842 err
= codec
->patch_ops
.init(codec
);
2843 if (!err
&& codec
->patch_ops
.build_controls
)
2844 err
= codec
->patch_ops
.build_controls(codec
);
2853 struct hda_rate_tbl
{
2855 unsigned int alsa_bits
;
2856 unsigned int hda_fmt
;
2859 static struct hda_rate_tbl rate_bits
[] = {
2860 /* rate in Hz, ALSA rate bitmask, HDA format value */
2862 /* autodetected value used in snd_hda_query_supported_pcm */
2863 { 8000, SNDRV_PCM_RATE_8000
, 0x0500 }, /* 1/6 x 48 */
2864 { 11025, SNDRV_PCM_RATE_11025
, 0x4300 }, /* 1/4 x 44 */
2865 { 16000, SNDRV_PCM_RATE_16000
, 0x0200 }, /* 1/3 x 48 */
2866 { 22050, SNDRV_PCM_RATE_22050
, 0x4100 }, /* 1/2 x 44 */
2867 { 32000, SNDRV_PCM_RATE_32000
, 0x0a00 }, /* 2/3 x 48 */
2868 { 44100, SNDRV_PCM_RATE_44100
, 0x4000 }, /* 44 */
2869 { 48000, SNDRV_PCM_RATE_48000
, 0x0000 }, /* 48 */
2870 { 88200, SNDRV_PCM_RATE_88200
, 0x4800 }, /* 2 x 44 */
2871 { 96000, SNDRV_PCM_RATE_96000
, 0x0800 }, /* 2 x 48 */
2872 { 176400, SNDRV_PCM_RATE_176400
, 0x5800 },/* 4 x 44 */
2873 { 192000, SNDRV_PCM_RATE_192000
, 0x1800 }, /* 4 x 48 */
2874 #define AC_PAR_PCM_RATE_BITS 11
2875 /* up to bits 10, 384kHZ isn't supported properly */
2877 /* not autodetected value */
2878 { 9600, SNDRV_PCM_RATE_KNOT
, 0x0400 }, /* 1/5 x 48 */
2880 { 0 } /* terminator */
2884 * snd_hda_calc_stream_format - calculate format bitset
2885 * @rate: the sample rate
2886 * @channels: the number of channels
2887 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2888 * @maxbps: the max. bps
2890 * Calculate the format bitset from the given rate, channels and th PCM format.
2892 * Return zero if invalid.
2894 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
2895 unsigned int channels
,
2896 unsigned int format
,
2897 unsigned int maxbps
)
2900 unsigned int val
= 0;
2902 for (i
= 0; rate_bits
[i
].hz
; i
++)
2903 if (rate_bits
[i
].hz
== rate
) {
2904 val
= rate_bits
[i
].hda_fmt
;
2907 if (!rate_bits
[i
].hz
) {
2908 snd_printdd("invalid rate %d\n", rate
);
2912 if (channels
== 0 || channels
> 8) {
2913 snd_printdd("invalid channels %d\n", channels
);
2916 val
|= channels
- 1;
2918 switch (snd_pcm_format_width(format
)) {
2919 case 8: val
|= 0x00; break;
2920 case 16: val
|= 0x10; break;
2924 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
2926 else if (maxbps
>= 24)
2932 snd_printdd("invalid format width %d\n",
2933 snd_pcm_format_width(format
));
2939 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
2941 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
2943 unsigned int val
= 0;
2944 if (nid
!= codec
->afg
&&
2945 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
2946 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
2947 if (!val
|| val
== -1)
2948 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
2949 if (!val
|| val
== -1)
2954 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
2956 return query_caps_hash(codec
, nid
, HDA_HASH_PARPCM_KEY(nid
),
2960 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
2962 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
2963 if (!streams
|| streams
== -1)
2964 streams
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
2965 if (!streams
|| streams
== -1)
2970 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
2972 return query_caps_hash(codec
, nid
, HDA_HASH_PARSTR_KEY(nid
),
2977 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2978 * @codec: the HDA codec
2979 * @nid: NID to query
2980 * @ratesp: the pointer to store the detected rate bitflags
2981 * @formatsp: the pointer to store the detected formats
2982 * @bpsp: the pointer to store the detected format widths
2984 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2985 * or @bsps argument is ignored.
2987 * Returns 0 if successful, otherwise a negative error code.
2989 static int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
2990 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
2992 unsigned int i
, val
, wcaps
;
2994 wcaps
= get_wcaps(codec
, nid
);
2995 val
= query_pcm_param(codec
, nid
);
2999 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
3001 rates
|= rate_bits
[i
].alsa_bits
;
3004 snd_printk(KERN_ERR
"hda_codec: rates == 0 "
3005 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3007 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
3013 if (formatsp
|| bpsp
) {
3015 unsigned int streams
, bps
;
3017 streams
= query_stream_param(codec
, nid
);
3022 if (streams
& AC_SUPFMT_PCM
) {
3023 if (val
& AC_SUPPCM_BITS_8
) {
3024 formats
|= SNDRV_PCM_FMTBIT_U8
;
3027 if (val
& AC_SUPPCM_BITS_16
) {
3028 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
3031 if (wcaps
& AC_WCAP_DIGITAL
) {
3032 if (val
& AC_SUPPCM_BITS_32
)
3033 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
3034 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
3035 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3036 if (val
& AC_SUPPCM_BITS_24
)
3038 else if (val
& AC_SUPPCM_BITS_20
)
3040 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
3041 AC_SUPPCM_BITS_32
)) {
3042 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3043 if (val
& AC_SUPPCM_BITS_32
)
3045 else if (val
& AC_SUPPCM_BITS_24
)
3047 else if (val
& AC_SUPPCM_BITS_20
)
3051 if (streams
& AC_SUPFMT_FLOAT32
) {
3052 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
3056 if (streams
== AC_SUPFMT_AC3
) {
3057 /* should be exclusive */
3058 /* temporary hack: we have still no proper support
3059 * for the direct AC3 stream...
3061 formats
|= SNDRV_PCM_FMTBIT_U8
;
3065 snd_printk(KERN_ERR
"hda_codec: formats == 0 "
3066 "(nid=0x%x, val=0x%x, ovrd=%i, "
3069 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
3074 *formatsp
= formats
;
3083 * snd_hda_is_supported_format - Check the validity of the format
3084 * @codec: HD-audio codec
3085 * @nid: NID to check
3086 * @format: the HD-audio format value to check
3088 * Check whether the given node supports the format value.
3090 * Returns 1 if supported, 0 if not.
3092 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
3093 unsigned int format
)
3096 unsigned int val
= 0, rate
, stream
;
3098 val
= query_pcm_param(codec
, nid
);
3102 rate
= format
& 0xff00;
3103 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
3104 if (rate_bits
[i
].hda_fmt
== rate
) {
3109 if (i
>= AC_PAR_PCM_RATE_BITS
)
3112 stream
= query_stream_param(codec
, nid
);
3116 if (stream
& AC_SUPFMT_PCM
) {
3117 switch (format
& 0xf0) {
3119 if (!(val
& AC_SUPPCM_BITS_8
))
3123 if (!(val
& AC_SUPPCM_BITS_16
))
3127 if (!(val
& AC_SUPPCM_BITS_20
))
3131 if (!(val
& AC_SUPPCM_BITS_24
))
3135 if (!(val
& AC_SUPPCM_BITS_32
))
3142 /* FIXME: check for float32 and AC3? */
3147 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
3152 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
3153 struct hda_codec
*codec
,
3154 struct snd_pcm_substream
*substream
)
3159 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
3160 struct hda_codec
*codec
,
3161 unsigned int stream_tag
,
3162 unsigned int format
,
3163 struct snd_pcm_substream
*substream
)
3165 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
3169 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
3170 struct hda_codec
*codec
,
3171 struct snd_pcm_substream
*substream
)
3173 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
3177 static int set_pcm_default_values(struct hda_codec
*codec
,
3178 struct hda_pcm_stream
*info
)
3182 /* query support PCM information from the given NID */
3183 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
3184 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
3185 info
->rates
? NULL
: &info
->rates
,
3186 info
->formats
? NULL
: &info
->formats
,
3187 info
->maxbps
? NULL
: &info
->maxbps
);
3191 if (info
->ops
.open
== NULL
)
3192 info
->ops
.open
= hda_pcm_default_open_close
;
3193 if (info
->ops
.close
== NULL
)
3194 info
->ops
.close
= hda_pcm_default_open_close
;
3195 if (info
->ops
.prepare
== NULL
) {
3196 if (snd_BUG_ON(!info
->nid
))
3198 info
->ops
.prepare
= hda_pcm_default_prepare
;
3200 if (info
->ops
.cleanup
== NULL
) {
3201 if (snd_BUG_ON(!info
->nid
))
3203 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
3209 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
3210 "Audio", "SPDIF", "HDMI", "Modem"
3214 * get the empty PCM device number to assign
3216 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
3218 /* audio device indices; not linear to keep compatibility */
3219 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
3220 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
3221 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
3222 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
3223 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
3227 if (type
>= HDA_PCM_NTYPES
) {
3228 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
3232 for (i
= 0; audio_idx
[type
][i
] >= 0 ; i
++)
3233 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
3234 return audio_idx
[type
][i
];
3236 snd_printk(KERN_WARNING
"Too many %s devices\n", snd_hda_pcm_type_name
[type
]);
3241 * attach a new PCM stream
3243 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
3245 struct hda_bus
*bus
= codec
->bus
;
3246 struct hda_pcm_stream
*info
;
3249 if (snd_BUG_ON(!pcm
->name
))
3251 for (stream
= 0; stream
< 2; stream
++) {
3252 info
= &pcm
->stream
[stream
];
3253 if (info
->substreams
) {
3254 err
= set_pcm_default_values(codec
, info
);
3259 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
3262 /* assign all PCMs of the given codec */
3263 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
3268 if (!codec
->num_pcms
) {
3269 if (!codec
->patch_ops
.build_pcms
)
3271 err
= codec
->patch_ops
.build_pcms(codec
);
3273 printk(KERN_ERR
"hda_codec: cannot build PCMs"
3274 "for #%d (error %d)\n", codec
->addr
, err
);
3275 err
= snd_hda_codec_reset(codec
);
3278 "hda_codec: cannot revert codec\n");
3283 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
3284 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
3287 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
3288 continue; /* no substreams assigned */
3291 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
3293 continue; /* no fatal error */
3295 err
= snd_hda_attach_pcm(codec
, cpcm
);
3297 printk(KERN_ERR
"hda_codec: cannot attach "
3298 "PCM stream %d for codec #%d\n",
3300 continue; /* no fatal error */
3308 * snd_hda_build_pcms - build PCM information
3311 * Create PCM information for each codec included in the bus.
3313 * The build_pcms codec patch is requested to set up codec->num_pcms and
3314 * codec->pcm_info properly. The array is referred by the top-level driver
3315 * to create its PCM instances.
3316 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3319 * At least, substreams, channels_min and channels_max must be filled for
3320 * each stream. substreams = 0 indicates that the stream doesn't exist.
3321 * When rates and/or formats are zero, the supported values are queried
3322 * from the given nid. The nid is used also by the default ops.prepare
3323 * and ops.cleanup callbacks.
3325 * The driver needs to call ops.open in its open callback. Similarly,
3326 * ops.close is supposed to be called in the close callback.
3327 * ops.prepare should be called in the prepare or hw_params callback
3328 * with the proper parameters for set up.
3329 * ops.cleanup should be called in hw_free for clean up of streams.
3331 * This function returns 0 if successfull, or a negative error code.
3333 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
3335 struct hda_codec
*codec
;
3337 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3338 int err
= snd_hda_codec_build_pcms(codec
);
3344 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
3347 * snd_hda_check_board_config - compare the current codec with the config table
3348 * @codec: the HDA codec
3349 * @num_configs: number of config enums
3350 * @models: array of model name strings
3351 * @tbl: configuration table, terminated by null entries
3353 * Compares the modelname or PCI subsystem id of the current codec with the
3354 * given configuration table. If a matching entry is found, returns its
3355 * config value (supposed to be 0 or positive).
3357 * If no entries are matching, the function returns a negative value.
3359 int snd_hda_check_board_config(struct hda_codec
*codec
,
3360 int num_configs
, const char **models
,
3361 const struct snd_pci_quirk
*tbl
)
3363 if (codec
->modelname
&& models
) {
3365 for (i
= 0; i
< num_configs
; i
++) {
3367 !strcmp(codec
->modelname
, models
[i
])) {
3368 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
3369 "selected\n", models
[i
]);
3375 if (!codec
->bus
->pci
|| !tbl
)
3378 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
3381 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3382 #ifdef CONFIG_SND_DEBUG_VERBOSE
3384 const char *model
= NULL
;
3386 model
= models
[tbl
->value
];
3388 sprintf(tmp
, "#%d", tbl
->value
);
3391 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3392 "for config %x:%x (%s)\n",
3393 model
, tbl
->subvendor
, tbl
->subdevice
,
3394 (tbl
->name
? tbl
->name
: "Unknown device"));
3400 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
3403 * snd_hda_check_board_codec_sid_config - compare the current codec
3404 subsystem ID with the
3407 This is important for Gateway notebooks with SB450 HDA Audio
3408 where the vendor ID of the PCI device is:
3409 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3410 and the vendor/subvendor are found only at the codec.
3412 * @codec: the HDA codec
3413 * @num_configs: number of config enums
3414 * @models: array of model name strings
3415 * @tbl: configuration table, terminated by null entries
3417 * Compares the modelname or PCI subsystem id of the current codec with the
3418 * given configuration table. If a matching entry is found, returns its
3419 * config value (supposed to be 0 or positive).
3421 * If no entries are matching, the function returns a negative value.
3423 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
3424 int num_configs
, const char **models
,
3425 const struct snd_pci_quirk
*tbl
)
3427 const struct snd_pci_quirk
*q
;
3429 /* Search for codec ID */
3430 for (q
= tbl
; q
->subvendor
; q
++) {
3431 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
3433 if (vendorid
== codec
->subsystem_id
)
3442 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3443 #ifdef CONFIG_SND_DEBUG_VERBOSE
3445 const char *model
= NULL
;
3447 model
= models
[tbl
->value
];
3449 sprintf(tmp
, "#%d", tbl
->value
);
3452 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3453 "for config %x:%x (%s)\n",
3454 model
, tbl
->subvendor
, tbl
->subdevice
,
3455 (tbl
->name
? tbl
->name
: "Unknown device"));
3461 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
3464 * snd_hda_add_new_ctls - create controls from the array
3465 * @codec: the HDA codec
3466 * @knew: the array of struct snd_kcontrol_new
3468 * This helper function creates and add new controls in the given array.
3469 * The array must be terminated with an empty entry as terminator.
3471 * Returns 0 if successful, or a negative error code.
3473 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
3477 for (; knew
->name
; knew
++) {
3478 struct snd_kcontrol
*kctl
;
3479 kctl
= snd_ctl_new1(knew
, codec
);
3482 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3486 kctl
= snd_ctl_new1(knew
, codec
);
3489 kctl
->id
.device
= codec
->addr
;
3490 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3497 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
3499 #ifdef CONFIG_SND_HDA_POWER_SAVE
3500 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
3501 unsigned int power_state
);
3503 static void hda_power_work(struct work_struct
*work
)
3505 struct hda_codec
*codec
=
3506 container_of(work
, struct hda_codec
, power_work
.work
);
3507 struct hda_bus
*bus
= codec
->bus
;
3509 if (!codec
->power_on
|| codec
->power_count
) {
3510 codec
->power_transition
= 0;
3514 hda_call_codec_suspend(codec
);
3515 if (bus
->ops
.pm_notify
)
3516 bus
->ops
.pm_notify(bus
);
3519 static void hda_keep_power_on(struct hda_codec
*codec
)
3521 codec
->power_count
++;
3522 codec
->power_on
= 1;
3523 codec
->power_jiffies
= jiffies
;
3526 /* update the power on/off account with the current jiffies */
3527 void snd_hda_update_power_acct(struct hda_codec
*codec
)
3529 unsigned long delta
= jiffies
- codec
->power_jiffies
;
3530 if (codec
->power_on
)
3531 codec
->power_on_acct
+= delta
;
3533 codec
->power_off_acct
+= delta
;
3534 codec
->power_jiffies
+= delta
;
3538 * snd_hda_power_up - Power-up the codec
3539 * @codec: HD-audio codec
3541 * Increment the power-up counter and power up the hardware really when
3542 * not turned on yet.
3544 void snd_hda_power_up(struct hda_codec
*codec
)
3546 struct hda_bus
*bus
= codec
->bus
;
3548 codec
->power_count
++;
3549 if (codec
->power_on
|| codec
->power_transition
)
3552 snd_hda_update_power_acct(codec
);
3553 codec
->power_on
= 1;
3554 codec
->power_jiffies
= jiffies
;
3555 if (bus
->ops
.pm_notify
)
3556 bus
->ops
.pm_notify(bus
);
3557 hda_call_codec_resume(codec
);
3558 cancel_delayed_work(&codec
->power_work
);
3559 codec
->power_transition
= 0;
3561 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
3563 #define power_save(codec) \
3564 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3567 * snd_hda_power_down - Power-down the codec
3568 * @codec: HD-audio codec
3570 * Decrement the power-up counter and schedules the power-off work if
3571 * the counter rearches to zero.
3573 void snd_hda_power_down(struct hda_codec
*codec
)
3575 --codec
->power_count
;
3576 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
3578 if (power_save(codec
)) {
3579 codec
->power_transition
= 1; /* avoid reentrance */
3580 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
3581 msecs_to_jiffies(power_save(codec
) * 1000));
3584 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
3587 * snd_hda_check_amp_list_power - Check the amp list and update the power
3588 * @codec: HD-audio codec
3589 * @check: the object containing an AMP list and the status
3590 * @nid: NID to check / update
3592 * Check whether the given NID is in the amp list. If it's in the list,
3593 * check the current AMP status, and update the the power-status according
3594 * to the mute status.
3596 * This function is supposed to be set or called from the check_power_status
3599 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
3600 struct hda_loopback_check
*check
,
3603 struct hda_amp_list
*p
;
3606 if (!check
->amplist
)
3608 for (p
= check
->amplist
; p
->nid
; p
++) {
3613 return 0; /* nothing changed */
3615 for (p
= check
->amplist
; p
->nid
; p
++) {
3616 for (ch
= 0; ch
< 2; ch
++) {
3617 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
3619 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
3620 if (!check
->power_on
) {
3621 check
->power_on
= 1;
3622 snd_hda_power_up(codec
);
3628 if (check
->power_on
) {
3629 check
->power_on
= 0;
3630 snd_hda_power_down(codec
);
3634 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
3638 * Channel mode helper
3642 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3644 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
3645 struct snd_ctl_elem_info
*uinfo
,
3646 const struct hda_channel_mode
*chmode
,
3649 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3651 uinfo
->value
.enumerated
.items
= num_chmodes
;
3652 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
3653 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
3654 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
3655 chmode
[uinfo
->value
.enumerated
.item
].channels
);
3658 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
3661 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3663 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
3664 struct snd_ctl_elem_value
*ucontrol
,
3665 const struct hda_channel_mode
*chmode
,
3671 for (i
= 0; i
< num_chmodes
; i
++) {
3672 if (max_channels
== chmode
[i
].channels
) {
3673 ucontrol
->value
.enumerated
.item
[0] = i
;
3679 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
3682 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3684 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
3685 struct snd_ctl_elem_value
*ucontrol
,
3686 const struct hda_channel_mode
*chmode
,
3692 mode
= ucontrol
->value
.enumerated
.item
[0];
3693 if (mode
>= num_chmodes
)
3695 if (*max_channelsp
== chmode
[mode
].channels
)
3697 /* change the current channel setting */
3698 *max_channelsp
= chmode
[mode
].channels
;
3699 if (chmode
[mode
].sequence
)
3700 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
3703 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
3710 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3712 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
3713 struct snd_ctl_elem_info
*uinfo
)
3717 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3719 uinfo
->value
.enumerated
.items
= imux
->num_items
;
3720 if (!imux
->num_items
)
3722 index
= uinfo
->value
.enumerated
.item
;
3723 if (index
>= imux
->num_items
)
3724 index
= imux
->num_items
- 1;
3725 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
3728 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
3731 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3733 int snd_hda_input_mux_put(struct hda_codec
*codec
,
3734 const struct hda_input_mux
*imux
,
3735 struct snd_ctl_elem_value
*ucontrol
,
3737 unsigned int *cur_val
)
3741 if (!imux
->num_items
)
3743 idx
= ucontrol
->value
.enumerated
.item
[0];
3744 if (idx
>= imux
->num_items
)
3745 idx
= imux
->num_items
- 1;
3746 if (*cur_val
== idx
)
3748 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
3749 imux
->items
[idx
].index
);
3753 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
3757 * Multi-channel / digital-out PCM helper functions
3760 /* setup SPDIF output stream */
3761 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
3762 unsigned int stream_tag
, unsigned int format
)
3764 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
3765 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3766 set_dig_out_convert(codec
, nid
,
3767 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff,
3769 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
3770 if (codec
->slave_dig_outs
) {
3772 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3773 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
3776 /* turn on again (if needed) */
3777 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
3778 set_dig_out_convert(codec
, nid
,
3779 codec
->spdif_ctls
& 0xff, -1);
3782 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
3784 snd_hda_codec_cleanup_stream(codec
, nid
);
3785 if (codec
->slave_dig_outs
) {
3787 for (d
= codec
->slave_dig_outs
; *d
; d
++)
3788 snd_hda_codec_cleanup_stream(codec
, *d
);
3793 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3794 * @bus: HD-audio bus
3796 void snd_hda_bus_reboot_notify(struct hda_bus
*bus
)
3798 struct hda_codec
*codec
;
3802 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3803 #ifdef CONFIG_SND_HDA_POWER_SAVE
3804 if (!codec
->power_on
)
3807 if (codec
->patch_ops
.reboot_notify
)
3808 codec
->patch_ops
.reboot_notify(codec
);
3811 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify
);
3814 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
3816 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
3817 struct hda_multi_out
*mout
)
3819 mutex_lock(&codec
->spdif_mutex
);
3820 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
3821 /* already opened as analog dup; reset it once */
3822 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3823 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
3824 mutex_unlock(&codec
->spdif_mutex
);
3827 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
3830 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3832 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
3833 struct hda_multi_out
*mout
,
3834 unsigned int stream_tag
,
3835 unsigned int format
,
3836 struct snd_pcm_substream
*substream
)
3838 mutex_lock(&codec
->spdif_mutex
);
3839 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
3840 mutex_unlock(&codec
->spdif_mutex
);
3843 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
3846 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3848 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
3849 struct hda_multi_out
*mout
)
3851 mutex_lock(&codec
->spdif_mutex
);
3852 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3853 mutex_unlock(&codec
->spdif_mutex
);
3856 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
3859 * snd_hda_multi_out_dig_close - release the digital out stream
3861 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
3862 struct hda_multi_out
*mout
)
3864 mutex_lock(&codec
->spdif_mutex
);
3865 mout
->dig_out_used
= 0;
3866 mutex_unlock(&codec
->spdif_mutex
);
3869 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
3872 * snd_hda_multi_out_analog_open - open analog outputs
3874 * Open analog outputs and set up the hw-constraints.
3875 * If the digital outputs can be opened as slave, open the digital
3878 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
3879 struct hda_multi_out
*mout
,
3880 struct snd_pcm_substream
*substream
,
3881 struct hda_pcm_stream
*hinfo
)
3883 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
3884 runtime
->hw
.channels_max
= mout
->max_channels
;
3885 if (mout
->dig_out_nid
) {
3886 if (!mout
->analog_rates
) {
3887 mout
->analog_rates
= hinfo
->rates
;
3888 mout
->analog_formats
= hinfo
->formats
;
3889 mout
->analog_maxbps
= hinfo
->maxbps
;
3891 runtime
->hw
.rates
= mout
->analog_rates
;
3892 runtime
->hw
.formats
= mout
->analog_formats
;
3893 hinfo
->maxbps
= mout
->analog_maxbps
;
3895 if (!mout
->spdif_rates
) {
3896 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
3898 &mout
->spdif_formats
,
3899 &mout
->spdif_maxbps
);
3901 mutex_lock(&codec
->spdif_mutex
);
3902 if (mout
->share_spdif
) {
3903 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
3904 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
3905 runtime
->hw
.rates
&= mout
->spdif_rates
;
3906 runtime
->hw
.formats
&= mout
->spdif_formats
;
3907 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
3908 hinfo
->maxbps
= mout
->spdif_maxbps
;
3910 mout
->share_spdif
= 0;
3911 /* FIXME: need notify? */
3914 mutex_unlock(&codec
->spdif_mutex
);
3916 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
3917 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
3919 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
3922 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3924 * Set up the i/o for analog out.
3925 * When the digital out is available, copy the front out to digital out, too.
3927 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
3928 struct hda_multi_out
*mout
,
3929 unsigned int stream_tag
,
3930 unsigned int format
,
3931 struct snd_pcm_substream
*substream
)
3933 hda_nid_t
*nids
= mout
->dac_nids
;
3934 int chs
= substream
->runtime
->channels
;
3937 mutex_lock(&codec
->spdif_mutex
);
3938 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
3939 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
3941 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
3943 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
3944 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
3945 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
3946 stream_tag
, format
);
3948 mout
->dig_out_used
= 0;
3949 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
3952 mutex_unlock(&codec
->spdif_mutex
);
3955 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
3957 if (!mout
->no_share_stream
&&
3958 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
3959 /* headphone out will just decode front left/right (stereo) */
3960 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
3962 /* extra outputs copied from front */
3963 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3964 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
3965 snd_hda_codec_setup_stream(codec
,
3966 mout
->extra_out_nid
[i
],
3967 stream_tag
, 0, format
);
3970 for (i
= 1; i
< mout
->num_dacs
; i
++) {
3971 if (chs
>= (i
+ 1) * 2) /* independent out */
3972 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3974 else if (!mout
->no_share_stream
) /* copy front */
3975 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
3980 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
3983 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
3985 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
3986 struct hda_multi_out
*mout
)
3988 hda_nid_t
*nids
= mout
->dac_nids
;
3991 for (i
= 0; i
< mout
->num_dacs
; i
++)
3992 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
3994 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
3995 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
3996 if (mout
->extra_out_nid
[i
])
3997 snd_hda_codec_cleanup_stream(codec
,
3998 mout
->extra_out_nid
[i
]);
3999 mutex_lock(&codec
->spdif_mutex
);
4000 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
4001 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4002 mout
->dig_out_used
= 0;
4004 mutex_unlock(&codec
->spdif_mutex
);
4007 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
4010 * Helper for automatic pin configuration
4013 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
4015 for (; *list
; list
++)
4023 * Sort an associated group of pins according to their sequence numbers.
4025 static void sort_pins_by_sequence(hda_nid_t
* pins
, short * sequences
,
4032 for (i
= 0; i
< num_pins
; i
++) {
4033 for (j
= i
+ 1; j
< num_pins
; j
++) {
4034 if (sequences
[i
] > sequences
[j
]) {
4036 sequences
[i
] = sequences
[j
];
4048 * Parse all pin widgets and store the useful pin nids to cfg
4050 * The number of line-outs or any primary output is stored in line_outs,
4051 * and the corresponding output pins are assigned to line_out_pins[],
4052 * in the order of front, rear, CLFE, side, ...
4054 * If more extra outputs (speaker and headphone) are found, the pins are
4055 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4056 * is detected, one of speaker of HP pins is assigned as the primary
4057 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4058 * if any analog output exists.
4060 * The analog input pins are assigned to input_pins array.
4061 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4064 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
4065 struct auto_pin_cfg
*cfg
,
4066 hda_nid_t
*ignore_nids
)
4068 hda_nid_t nid
, end_nid
;
4069 short seq
, assoc_line_out
, assoc_speaker
;
4070 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
4071 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
4072 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
4074 memset(cfg
, 0, sizeof(*cfg
));
4076 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
4077 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
4078 memset(sequences_hp
, 0, sizeof(sequences_hp
));
4079 assoc_line_out
= assoc_speaker
= 0;
4081 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
4082 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
4083 unsigned int wid_caps
= get_wcaps(codec
, nid
);
4084 unsigned int wid_type
= get_wcaps_type(wid_caps
);
4085 unsigned int def_conf
;
4088 /* read all default configuration for pin complex */
4089 if (wid_type
!= AC_WID_PIN
)
4091 /* ignore the given nids (e.g. pc-beep returns error) */
4092 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
4095 def_conf
= snd_hda_codec_get_pincfg(codec
, nid
);
4096 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
4098 loc
= get_defcfg_location(def_conf
);
4099 switch (get_defcfg_device(def_conf
)) {
4100 case AC_JACK_LINE_OUT
:
4101 seq
= get_defcfg_sequence(def_conf
);
4102 assoc
= get_defcfg_association(def_conf
);
4104 if (!(wid_caps
& AC_WCAP_STEREO
))
4105 if (!cfg
->mono_out_pin
)
4106 cfg
->mono_out_pin
= nid
;
4109 if (!assoc_line_out
)
4110 assoc_line_out
= assoc
;
4111 else if (assoc_line_out
!= assoc
)
4113 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
4115 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
4116 sequences_line_out
[cfg
->line_outs
] = seq
;
4119 case AC_JACK_SPEAKER
:
4120 seq
= get_defcfg_sequence(def_conf
);
4121 assoc
= get_defcfg_association(def_conf
);
4124 if (! assoc_speaker
)
4125 assoc_speaker
= assoc
;
4126 else if (assoc_speaker
!= assoc
)
4128 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
4130 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
4131 sequences_speaker
[cfg
->speaker_outs
] = seq
;
4132 cfg
->speaker_outs
++;
4134 case AC_JACK_HP_OUT
:
4135 seq
= get_defcfg_sequence(def_conf
);
4136 assoc
= get_defcfg_association(def_conf
);
4137 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
4139 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
4140 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
4143 case AC_JACK_MIC_IN
: {
4145 if (loc
== AC_JACK_LOC_FRONT
) {
4146 preferred
= AUTO_PIN_FRONT_MIC
;
4149 preferred
= AUTO_PIN_MIC
;
4150 alt
= AUTO_PIN_FRONT_MIC
;
4152 if (!cfg
->input_pins
[preferred
])
4153 cfg
->input_pins
[preferred
] = nid
;
4154 else if (!cfg
->input_pins
[alt
])
4155 cfg
->input_pins
[alt
] = nid
;
4158 case AC_JACK_LINE_IN
:
4159 if (loc
== AC_JACK_LOC_FRONT
)
4160 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
4162 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
4165 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
4168 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
4170 case AC_JACK_SPDIF_OUT
:
4171 case AC_JACK_DIG_OTHER_OUT
:
4172 if (cfg
->dig_outs
>= ARRAY_SIZE(cfg
->dig_out_pins
))
4174 cfg
->dig_out_pins
[cfg
->dig_outs
] = nid
;
4175 cfg
->dig_out_type
[cfg
->dig_outs
] =
4176 (loc
== AC_JACK_LOC_HDMI
) ?
4177 HDA_PCM_TYPE_HDMI
: HDA_PCM_TYPE_SPDIF
;
4180 case AC_JACK_SPDIF_IN
:
4181 case AC_JACK_DIG_OTHER_IN
:
4182 cfg
->dig_in_pin
= nid
;
4183 if (loc
== AC_JACK_LOC_HDMI
)
4184 cfg
->dig_in_type
= HDA_PCM_TYPE_HDMI
;
4186 cfg
->dig_in_type
= HDA_PCM_TYPE_SPDIF
;
4192 * If no line-out is defined but multiple HPs are found,
4193 * some of them might be the real line-outs.
4195 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1) {
4197 while (i
< cfg
->hp_outs
) {
4198 /* The real HPs should have the sequence 0x0f */
4199 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
4203 /* Move it to the line-out table */
4204 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
4205 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
4208 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
4209 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
4210 memmove(sequences_hp
+ i
- 1, sequences_hp
+ i
,
4211 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
4215 /* sort by sequence */
4216 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
4218 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
4220 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
4223 /* if we have only one mic, make it AUTO_PIN_MIC */
4224 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
4225 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
4226 cfg
->input_pins
[AUTO_PIN_MIC
] =
4227 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
4228 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
4230 /* ditto for line-in */
4231 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
4232 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
4233 cfg
->input_pins
[AUTO_PIN_LINE
] =
4234 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
4235 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
4239 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4240 * as a primary output
4242 if (!cfg
->line_outs
) {
4243 if (cfg
->speaker_outs
) {
4244 cfg
->line_outs
= cfg
->speaker_outs
;
4245 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
4246 sizeof(cfg
->speaker_pins
));
4247 cfg
->speaker_outs
= 0;
4248 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
4249 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
4250 } else if (cfg
->hp_outs
) {
4251 cfg
->line_outs
= cfg
->hp_outs
;
4252 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
4253 sizeof(cfg
->hp_pins
));
4255 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4256 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4260 /* Reorder the surround channels
4261 * ALSA sequence is front/surr/clfe/side
4263 * 4-ch: front/surr => OK as it is
4264 * 6-ch: front/clfe/surr
4265 * 8-ch: front/clfe/rear/side|fc
4267 switch (cfg
->line_outs
) {
4270 nid
= cfg
->line_out_pins
[1];
4271 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
4272 cfg
->line_out_pins
[2] = nid
;
4277 * debug prints of the parsed results
4279 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4280 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
4281 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
4282 cfg
->line_out_pins
[4]);
4283 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4284 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
4285 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
4286 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
4287 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4288 cfg
->hp_outs
, cfg
->hp_pins
[0],
4289 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
4290 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
4291 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
4293 snd_printd(" dig-out=0x%x/0x%x\n",
4294 cfg
->dig_out_pins
[0], cfg
->dig_out_pins
[1]);
4295 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4296 " cd=0x%x, aux=0x%x\n",
4297 cfg
->input_pins
[AUTO_PIN_MIC
],
4298 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
4299 cfg
->input_pins
[AUTO_PIN_LINE
],
4300 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
4301 cfg
->input_pins
[AUTO_PIN_CD
],
4302 cfg
->input_pins
[AUTO_PIN_AUX
]);
4303 if (cfg
->dig_in_pin
)
4304 snd_printd(" dig-in=0x%x\n", cfg
->dig_in_pin
);
4308 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config
);
4310 /* labels for input pins */
4311 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
4312 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4314 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels
);
4323 * snd_hda_suspend - suspend the codecs
4326 * Returns 0 if successful.
4328 int snd_hda_suspend(struct hda_bus
*bus
)
4330 struct hda_codec
*codec
;
4332 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4333 #ifdef CONFIG_SND_HDA_POWER_SAVE
4334 if (!codec
->power_on
)
4337 hda_call_codec_suspend(codec
);
4341 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
4344 * snd_hda_resume - resume the codecs
4347 * Returns 0 if successful.
4349 * This fucntion is defined only when POWER_SAVE isn't set.
4350 * In the power-save mode, the codec is resumed dynamically.
4352 int snd_hda_resume(struct hda_bus
*bus
)
4354 struct hda_codec
*codec
;
4356 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4357 if (snd_hda_codec_needs_resume(codec
))
4358 hda_call_codec_resume(codec
);
4362 EXPORT_SYMBOL_HDA(snd_hda_resume
);
4363 #endif /* CONFIG_PM */
4370 * snd_array_new - get a new element from the given array
4371 * @array: the array object
4373 * Get a new element from the given array. If it exceeds the
4374 * pre-allocated array size, re-allocate the array.
4376 * Returns NULL if allocation failed.
4378 void *snd_array_new(struct snd_array
*array
)
4380 if (array
->used
>= array
->alloced
) {
4381 int num
= array
->alloced
+ array
->alloc_align
;
4383 if (snd_BUG_ON(num
>= 4096))
4385 nlist
= kcalloc(num
+ 1, array
->elem_size
, GFP_KERNEL
);
4389 memcpy(nlist
, array
->list
,
4390 array
->elem_size
* array
->alloced
);
4393 array
->list
= nlist
;
4394 array
->alloced
= num
;
4396 return snd_array_elem(array
, array
->used
++);
4398 EXPORT_SYMBOL_HDA(snd_array_new
);
4401 * snd_array_free - free the given array elements
4402 * @array: the array object
4404 void snd_array_free(struct snd_array
*array
)
4411 EXPORT_SYMBOL_HDA(snd_array_free
);
4414 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4415 * @pcm: PCM caps bits
4416 * @buf: the string buffer to write
4417 * @buflen: the max buffer length
4419 * used by hda_proc.c and hda_eld.c
4421 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
4423 static unsigned int rates
[] = {
4424 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4425 96000, 176400, 192000, 384000
4429 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
4431 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
4433 buf
[j
] = '\0'; /* necessary when j == 0 */
4435 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
4438 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4439 * @pcm: PCM caps bits
4440 * @buf: the string buffer to write
4441 * @buflen: the max buffer length
4443 * used by hda_proc.c and hda_eld.c
4445 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
4447 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
4450 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
4451 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
4452 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
4454 buf
[j
] = '\0'; /* necessary when j == 0 */
4456 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
4458 MODULE_DESCRIPTION("HDA codec core");
4459 MODULE_LICENSE("GPL");