2 * Universal Interface for Intel High Definition Audio Codec
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include <sound/asoundef.h>
30 #include <sound/tlv.h>
31 #include <sound/initval.h>
32 #include "hda_local.h"
34 #include <sound/hda_hwdep.h>
37 * vendor / preset table
40 struct hda_vendor_id
{
45 /* codec vendor labels */
46 static struct hda_vendor_id hda_vendor_ids
[] = {
48 { 0x1013, "Cirrus Logic" },
49 { 0x1057, "Motorola" },
50 { 0x1095, "Silicon Image" },
52 { 0x10ec, "Realtek" },
53 { 0x1102, "Creative" },
57 { 0x11d4, "Analog Devices" },
58 { 0x13f6, "C-Media" },
59 { 0x14f1, "Conexant" },
60 { 0x17e8, "Chrontel" },
62 { 0x1aec, "Wolfson Microelectronics" },
63 { 0x434d, "C-Media" },
65 { 0x8384, "SigmaTel" },
69 static DEFINE_MUTEX(preset_mutex
);
70 static LIST_HEAD(hda_preset_tables
);
72 int snd_hda_add_codec_preset(struct hda_codec_preset_list
*preset
)
74 mutex_lock(&preset_mutex
);
75 list_add_tail(&preset
->list
, &hda_preset_tables
);
76 mutex_unlock(&preset_mutex
);
79 EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset
);
81 int snd_hda_delete_codec_preset(struct hda_codec_preset_list
*preset
)
83 mutex_lock(&preset_mutex
);
84 list_del(&preset
->list
);
85 mutex_unlock(&preset_mutex
);
88 EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset
);
90 #ifdef CONFIG_SND_HDA_POWER_SAVE
91 static void hda_power_work(struct work_struct
*work
);
92 static void hda_keep_power_on(struct hda_codec
*codec
);
94 static inline void hda_keep_power_on(struct hda_codec
*codec
) {}
98 * snd_hda_get_jack_location - Give a location string of the jack
99 * @cfg: pin default config value
101 * Parse the pin default config value and returns the string of the
102 * jack location, e.g. "Rear", "Front", etc.
104 const char *snd_hda_get_jack_location(u32 cfg
)
106 static char *bases
[7] = {
107 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
109 static unsigned char specials_idx
[] = {
114 static char *specials
[] = {
115 "Rear Panel", "Drive Bar",
116 "Riser", "HDMI", "ATAPI",
117 "Mobile-In", "Mobile-Out"
120 cfg
= (cfg
& AC_DEFCFG_LOCATION
) >> AC_DEFCFG_LOCATION_SHIFT
;
121 if ((cfg
& 0x0f) < 7)
122 return bases
[cfg
& 0x0f];
123 for (i
= 0; i
< ARRAY_SIZE(specials_idx
); i
++) {
124 if (cfg
== specials_idx
[i
])
129 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location
);
132 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
133 * @cfg: pin default config value
135 * Parse the pin default config value and returns the string of the
136 * jack connectivity, i.e. external or internal connection.
138 const char *snd_hda_get_jack_connectivity(u32 cfg
)
140 static char *jack_locations
[4] = { "Ext", "Int", "Sep", "Oth" };
142 return jack_locations
[(cfg
>> (AC_DEFCFG_LOCATION_SHIFT
+ 4)) & 3];
144 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity
);
147 * snd_hda_get_jack_type - Give a type string of the jack
148 * @cfg: pin default config value
150 * Parse the pin default config value and returns the string of the
151 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
153 const char *snd_hda_get_jack_type(u32 cfg
)
155 static char *jack_types
[16] = {
156 "Line Out", "Speaker", "HP Out", "CD",
157 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
158 "Line In", "Aux", "Mic", "Telephony",
159 "SPDIF In", "Digitial In", "Reserved", "Other"
162 return jack_types
[(cfg
& AC_DEFCFG_DEVICE
)
163 >> AC_DEFCFG_DEVICE_SHIFT
];
165 EXPORT_SYMBOL_HDA(snd_hda_get_jack_type
);
168 * Compose a 32bit command word to be sent to the HD-audio controller
170 static inline unsigned int
171 make_codec_cmd(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
172 unsigned int verb
, unsigned int parm
)
176 if ((codec
->addr
& ~0xf) || (direct
& ~1) || (nid
& ~0x7f) ||
177 (verb
& ~0xfff) || (parm
& ~0xffff)) {
178 printk(KERN_ERR
"hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
179 codec
->addr
, direct
, nid
, verb
, parm
);
183 val
= (u32
)codec
->addr
<< 28;
184 val
|= (u32
)direct
<< 27;
185 val
|= (u32
)nid
<< 20;
192 * Send and receive a verb
194 static int codec_exec_verb(struct hda_codec
*codec
, unsigned int cmd
,
197 struct hda_bus
*bus
= codec
->bus
;
206 snd_hda_power_up(codec
);
207 mutex_lock(&bus
->cmd_mutex
);
208 err
= bus
->ops
.command(bus
, cmd
);
210 *res
= bus
->ops
.get_response(bus
, codec
->addr
);
211 mutex_unlock(&bus
->cmd_mutex
);
212 snd_hda_power_down(codec
);
213 if (res
&& *res
== -1 && bus
->rirb_error
) {
214 if (bus
->response_reset
) {
215 snd_printd("hda_codec: resetting BUS due to "
216 "fatal communication error\n");
217 bus
->ops
.bus_reset(bus
);
221 /* clear reset-flag when the communication gets recovered */
223 bus
->response_reset
= 0;
228 * snd_hda_codec_read - send a command and get the response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
235 * Send a single command and read the corresponding response.
237 * Returns the obtained response value, or -1 for an error.
239 unsigned int snd_hda_codec_read(struct hda_codec
*codec
, hda_nid_t nid
,
241 unsigned int verb
, unsigned int parm
)
243 unsigned cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
245 codec_exec_verb(codec
, cmd
, &res
);
248 EXPORT_SYMBOL_HDA(snd_hda_codec_read
);
251 * snd_hda_codec_write - send a single command without waiting for response
252 * @codec: the HDA codec
253 * @nid: NID to send the command
254 * @direct: direct flag
255 * @verb: the verb to send
256 * @parm: the parameter for the verb
258 * Send a single command without waiting for response.
260 * Returns 0 if successful, or a negative error code.
262 int snd_hda_codec_write(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
263 unsigned int verb
, unsigned int parm
)
265 unsigned int cmd
= make_codec_cmd(codec
, nid
, direct
, verb
, parm
);
267 return codec_exec_verb(codec
, cmd
,
268 codec
->bus
->sync_write
? &res
: NULL
);
270 EXPORT_SYMBOL_HDA(snd_hda_codec_write
);
273 * snd_hda_sequence_write - sequence writes
274 * @codec: the HDA codec
275 * @seq: VERB array to send
277 * Send the commands sequentially from the given array.
278 * The array must be terminated with NID=0.
280 void snd_hda_sequence_write(struct hda_codec
*codec
, const struct hda_verb
*seq
)
282 for (; seq
->nid
; seq
++)
283 snd_hda_codec_write(codec
, seq
->nid
, 0, seq
->verb
, seq
->param
);
285 EXPORT_SYMBOL_HDA(snd_hda_sequence_write
);
288 * snd_hda_get_sub_nodes - get the range of sub nodes
289 * @codec: the HDA codec
291 * @start_id: the pointer to store the start NID
293 * Parse the NID and store the start NID of its sub-nodes.
294 * Returns the number of sub-nodes.
296 int snd_hda_get_sub_nodes(struct hda_codec
*codec
, hda_nid_t nid
,
301 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_NODE_COUNT
);
304 *start_id
= (parm
>> 16) & 0x7fff;
305 return (int)(parm
& 0x7fff);
307 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes
);
310 * snd_hda_get_connections - get connection list
311 * @codec: the HDA codec
313 * @conn_list: connection list array
314 * @max_conns: max. number of connections to store
316 * Parses the connection list of the given widget and stores the list
319 * Returns the number of connections, or a negative error code.
321 int snd_hda_get_connections(struct hda_codec
*codec
, hda_nid_t nid
,
322 hda_nid_t
*conn_list
, int max_conns
)
325 int i
, conn_len
, conns
;
326 unsigned int shift
, num_elems
, mask
;
330 if (snd_BUG_ON(!conn_list
|| max_conns
<= 0))
333 wcaps
= get_wcaps(codec
, nid
);
334 if (!(wcaps
& AC_WCAP_CONN_LIST
) &&
335 get_wcaps_type(wcaps
) != AC_WID_VOL_KNB
) {
336 snd_printk(KERN_WARNING
"hda_codec: "
337 "connection list not available for 0x%x\n", nid
);
341 parm
= snd_hda_param_read(codec
, nid
, AC_PAR_CONNLIST_LEN
);
342 if (parm
& AC_CLIST_LONG
) {
351 conn_len
= parm
& AC_CLIST_LENGTH
;
352 mask
= (1 << (shift
-1)) - 1;
355 return 0; /* no connection */
358 /* single connection */
359 parm
= snd_hda_codec_read(codec
, nid
, 0,
360 AC_VERB_GET_CONNECT_LIST
, 0);
361 if (parm
== -1 && codec
->bus
->rirb_error
)
363 conn_list
[0] = parm
& mask
;
367 /* multi connection */
370 for (i
= 0; i
< conn_len
; i
++) {
374 if (i
% num_elems
== 0) {
375 parm
= snd_hda_codec_read(codec
, nid
, 0,
376 AC_VERB_GET_CONNECT_LIST
, i
);
377 if (parm
== -1 && codec
->bus
->rirb_error
)
380 range_val
= !!(parm
& (1 << (shift
-1))); /* ranges */
383 snd_printk(KERN_WARNING
"hda_codec: "
384 "invalid CONNECT_LIST verb %x[%i]:%x\n",
390 /* ranges between the previous and this one */
391 if (!prev_nid
|| prev_nid
>= val
) {
392 snd_printk(KERN_WARNING
"hda_codec: "
393 "invalid dep_range_val %x:%x\n",
397 for (n
= prev_nid
+ 1; n
<= val
; n
++) {
398 if (conns
>= max_conns
) {
399 snd_printk(KERN_ERR
"hda_codec: "
400 "Too many connections %d for NID 0x%x\n",
404 conn_list
[conns
++] = n
;
407 if (conns
>= max_conns
) {
408 snd_printk(KERN_ERR
"hda_codec: "
409 "Too many connections %d for NID 0x%x\n",
413 conn_list
[conns
++] = val
;
419 EXPORT_SYMBOL_HDA(snd_hda_get_connections
);
423 * snd_hda_queue_unsol_event - add an unsolicited event to queue
425 * @res: unsolicited event (lower 32bit of RIRB entry)
426 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
428 * Adds the given event to the queue. The events are processed in
429 * the workqueue asynchronously. Call this function in the interrupt
430 * hanlder when RIRB receives an unsolicited event.
432 * Returns 0 if successful, or a negative error code.
434 int snd_hda_queue_unsol_event(struct hda_bus
*bus
, u32 res
, u32 res_ex
)
436 struct hda_bus_unsolicited
*unsol
;
443 wp
= (unsol
->wp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
447 unsol
->queue
[wp
] = res
;
448 unsol
->queue
[wp
+ 1] = res_ex
;
450 queue_work(bus
->workq
, &unsol
->work
);
454 EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event
);
457 * process queued unsolicited events
459 static void process_unsol_events(struct work_struct
*work
)
461 struct hda_bus_unsolicited
*unsol
=
462 container_of(work
, struct hda_bus_unsolicited
, work
);
463 struct hda_bus
*bus
= unsol
->bus
;
464 struct hda_codec
*codec
;
465 unsigned int rp
, caddr
, res
;
467 while (unsol
->rp
!= unsol
->wp
) {
468 rp
= (unsol
->rp
+ 1) % HDA_UNSOL_QUEUE_SIZE
;
471 res
= unsol
->queue
[rp
];
472 caddr
= unsol
->queue
[rp
+ 1];
473 if (!(caddr
& (1 << 4))) /* no unsolicited event? */
475 codec
= bus
->caddr_tbl
[caddr
& 0x0f];
476 if (codec
&& codec
->patch_ops
.unsol_event
)
477 codec
->patch_ops
.unsol_event(codec
, res
);
482 * initialize unsolicited queue
484 static int init_unsol_queue(struct hda_bus
*bus
)
486 struct hda_bus_unsolicited
*unsol
;
488 if (bus
->unsol
) /* already initialized */
491 unsol
= kzalloc(sizeof(*unsol
), GFP_KERNEL
);
493 snd_printk(KERN_ERR
"hda_codec: "
494 "can't allocate unsolicited queue\n");
497 INIT_WORK(&unsol
->work
, process_unsol_events
);
506 static void snd_hda_codec_free(struct hda_codec
*codec
);
508 static int snd_hda_bus_free(struct hda_bus
*bus
)
510 struct hda_codec
*codec
, *n
;
515 flush_workqueue(bus
->workq
);
518 list_for_each_entry_safe(codec
, n
, &bus
->codec_list
, list
) {
519 snd_hda_codec_free(codec
);
521 if (bus
->ops
.private_free
)
522 bus
->ops
.private_free(bus
);
524 destroy_workqueue(bus
->workq
);
529 static int snd_hda_bus_dev_free(struct snd_device
*device
)
531 struct hda_bus
*bus
= device
->device_data
;
533 return snd_hda_bus_free(bus
);
536 #ifdef CONFIG_SND_HDA_HWDEP
537 static int snd_hda_bus_dev_register(struct snd_device
*device
)
539 struct hda_bus
*bus
= device
->device_data
;
540 struct hda_codec
*codec
;
541 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
542 snd_hda_hwdep_add_sysfs(codec
);
543 snd_hda_hwdep_add_power_sysfs(codec
);
548 #define snd_hda_bus_dev_register NULL
552 * snd_hda_bus_new - create a HDA bus
553 * @card: the card entry
554 * @temp: the template for hda_bus information
555 * @busp: the pointer to store the created bus instance
557 * Returns 0 if successful, or a negative error code.
559 int /*__devinit*/ snd_hda_bus_new(struct snd_card
*card
,
560 const struct hda_bus_template
*temp
,
561 struct hda_bus
**busp
)
565 static struct snd_device_ops dev_ops
= {
566 .dev_register
= snd_hda_bus_dev_register
,
567 .dev_free
= snd_hda_bus_dev_free
,
570 if (snd_BUG_ON(!temp
))
572 if (snd_BUG_ON(!temp
->ops
.command
|| !temp
->ops
.get_response
))
578 bus
= kzalloc(sizeof(*bus
), GFP_KERNEL
);
580 snd_printk(KERN_ERR
"can't allocate struct hda_bus\n");
585 bus
->private_data
= temp
->private_data
;
586 bus
->pci
= temp
->pci
;
587 bus
->modelname
= temp
->modelname
;
588 bus
->power_save
= temp
->power_save
;
589 bus
->ops
= temp
->ops
;
591 mutex_init(&bus
->cmd_mutex
);
592 INIT_LIST_HEAD(&bus
->codec_list
);
594 snprintf(bus
->workq_name
, sizeof(bus
->workq_name
),
595 "hd-audio%d", card
->number
);
596 bus
->workq
= create_singlethread_workqueue(bus
->workq_name
);
598 snd_printk(KERN_ERR
"cannot create workqueue %s\n",
604 err
= snd_device_new(card
, SNDRV_DEV_BUS
, bus
, &dev_ops
);
606 snd_hda_bus_free(bus
);
613 EXPORT_SYMBOL_HDA(snd_hda_bus_new
);
615 #ifdef CONFIG_SND_HDA_GENERIC
616 #define is_generic_config(codec) \
617 (codec->modelname && !strcmp(codec->modelname, "generic"))
619 #define is_generic_config(codec) 0
623 #define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
625 #define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
629 * find a matching codec preset
631 static const struct hda_codec_preset
*
632 find_codec_preset(struct hda_codec
*codec
)
634 struct hda_codec_preset_list
*tbl
;
635 const struct hda_codec_preset
*preset
;
636 int mod_requested
= 0;
638 if (is_generic_config(codec
))
639 return NULL
; /* use the generic parser */
642 mutex_lock(&preset_mutex
);
643 list_for_each_entry(tbl
, &hda_preset_tables
, list
) {
644 if (!try_module_get(tbl
->owner
)) {
645 snd_printk(KERN_ERR
"hda_codec: cannot module_get\n");
648 for (preset
= tbl
->preset
; preset
->id
; preset
++) {
649 u32 mask
= preset
->mask
;
650 if (preset
->afg
&& preset
->afg
!= codec
->afg
)
652 if (preset
->mfg
&& preset
->mfg
!= codec
->mfg
)
656 if (preset
->id
== (codec
->vendor_id
& mask
) &&
658 preset
->rev
== codec
->revision_id
)) {
659 mutex_unlock(&preset_mutex
);
660 codec
->owner
= tbl
->owner
;
664 module_put(tbl
->owner
);
666 mutex_unlock(&preset_mutex
);
668 if (mod_requested
< HDA_MODREQ_MAX_COUNT
) {
671 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%08x",
674 snprintf(name
, sizeof(name
), "snd-hda-codec-id:%04x*",
675 (codec
->vendor_id
>> 16) & 0xffff);
676 request_module(name
);
684 * get_codec_name - store the codec name
686 static int get_codec_name(struct hda_codec
*codec
)
688 const struct hda_vendor_id
*c
;
689 const char *vendor
= NULL
;
690 u16 vendor_id
= codec
->vendor_id
>> 16;
693 if (codec
->vendor_name
)
696 for (c
= hda_vendor_ids
; c
->id
; c
++) {
697 if (c
->id
== vendor_id
) {
703 sprintf(tmp
, "Generic %04x", vendor_id
);
706 codec
->vendor_name
= kstrdup(vendor
, GFP_KERNEL
);
707 if (!codec
->vendor_name
)
711 if (codec
->chip_name
)
714 if (codec
->preset
&& codec
->preset
->name
)
715 codec
->chip_name
= kstrdup(codec
->preset
->name
, GFP_KERNEL
);
717 sprintf(tmp
, "ID %x", codec
->vendor_id
& 0xffff);
718 codec
->chip_name
= kstrdup(tmp
, GFP_KERNEL
);
720 if (!codec
->chip_name
)
726 * look for an AFG and MFG nodes
728 static void /*__devinit*/ setup_fg_nodes(struct hda_codec
*codec
)
730 int i
, total_nodes
, function_id
;
733 total_nodes
= snd_hda_get_sub_nodes(codec
, AC_NODE_ROOT
, &nid
);
734 for (i
= 0; i
< total_nodes
; i
++, nid
++) {
735 function_id
= snd_hda_param_read(codec
, nid
,
736 AC_PAR_FUNCTION_TYPE
);
737 switch (function_id
& 0xff) {
738 case AC_GRP_AUDIO_FUNCTION
:
740 codec
->afg_function_id
= function_id
& 0xff;
741 codec
->afg_unsol
= (function_id
>> 8) & 1;
743 case AC_GRP_MODEM_FUNCTION
:
745 codec
->mfg_function_id
= function_id
& 0xff;
746 codec
->mfg_unsol
= (function_id
>> 8) & 1;
755 * read widget caps for each widget and store in cache
757 static int read_widget_caps(struct hda_codec
*codec
, hda_nid_t fg_node
)
762 codec
->num_nodes
= snd_hda_get_sub_nodes(codec
, fg_node
,
764 codec
->wcaps
= kmalloc(codec
->num_nodes
* 4, GFP_KERNEL
);
767 nid
= codec
->start_nid
;
768 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++)
769 codec
->wcaps
[i
] = snd_hda_param_read(codec
, nid
,
770 AC_PAR_AUDIO_WIDGET_CAP
);
774 /* read all pin default configurations and save codec->init_pins */
775 static int read_pin_defaults(struct hda_codec
*codec
)
778 hda_nid_t nid
= codec
->start_nid
;
780 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
781 struct hda_pincfg
*pin
;
782 unsigned int wcaps
= get_wcaps(codec
, nid
);
783 unsigned int wid_type
= get_wcaps_type(wcaps
);
784 if (wid_type
!= AC_WID_PIN
)
786 pin
= snd_array_new(&codec
->init_pins
);
790 pin
->cfg
= snd_hda_codec_read(codec
, nid
, 0,
791 AC_VERB_GET_CONFIG_DEFAULT
, 0);
792 pin
->ctrl
= snd_hda_codec_read(codec
, nid
, 0,
793 AC_VERB_GET_PIN_WIDGET_CONTROL
,
799 /* look up the given pin config list and return the item matching with NID */
800 static struct hda_pincfg
*look_up_pincfg(struct hda_codec
*codec
,
801 struct snd_array
*array
,
805 for (i
= 0; i
< array
->used
; i
++) {
806 struct hda_pincfg
*pin
= snd_array_elem(array
, i
);
813 /* write a config value for the given NID */
814 static void set_pincfg(struct hda_codec
*codec
, hda_nid_t nid
,
818 for (i
= 0; i
< 4; i
++) {
819 snd_hda_codec_write(codec
, nid
, 0,
820 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
+ i
,
826 /* set the current pin config value for the given NID.
827 * the value is cached, and read via snd_hda_codec_get_pincfg()
829 int snd_hda_add_pincfg(struct hda_codec
*codec
, struct snd_array
*list
,
830 hda_nid_t nid
, unsigned int cfg
)
832 struct hda_pincfg
*pin
;
835 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_PIN
)
838 oldcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
839 pin
= look_up_pincfg(codec
, list
, nid
);
841 pin
= snd_array_new(list
);
848 /* change only when needed; e.g. if the pincfg is already present
849 * in user_pins[], don't write it
851 cfg
= snd_hda_codec_get_pincfg(codec
, nid
);
853 set_pincfg(codec
, nid
, cfg
);
858 * snd_hda_codec_set_pincfg - Override a pin default configuration
859 * @codec: the HDA codec
860 * @nid: NID to set the pin config
861 * @cfg: the pin default config value
863 * Override a pin default configuration value in the cache.
864 * This value can be read by snd_hda_codec_get_pincfg() in a higher
865 * priority than the real hardware value.
867 int snd_hda_codec_set_pincfg(struct hda_codec
*codec
,
868 hda_nid_t nid
, unsigned int cfg
)
870 return snd_hda_add_pincfg(codec
, &codec
->driver_pins
, nid
, cfg
);
872 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg
);
875 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
876 * @codec: the HDA codec
877 * @nid: NID to get the pin config
879 * Get the current pin config value of the given pin NID.
880 * If the pincfg value is cached or overridden via sysfs or driver,
881 * returns the cached value.
883 unsigned int snd_hda_codec_get_pincfg(struct hda_codec
*codec
, hda_nid_t nid
)
885 struct hda_pincfg
*pin
;
887 #ifdef CONFIG_SND_HDA_HWDEP
888 pin
= look_up_pincfg(codec
, &codec
->user_pins
, nid
);
892 pin
= look_up_pincfg(codec
, &codec
->driver_pins
, nid
);
895 pin
= look_up_pincfg(codec
, &codec
->init_pins
, nid
);
900 EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg
);
902 /* restore all current pin configs */
903 static void restore_pincfgs(struct hda_codec
*codec
)
906 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
907 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
908 set_pincfg(codec
, pin
->nid
,
909 snd_hda_codec_get_pincfg(codec
, pin
->nid
));
914 * snd_hda_shutup_pins - Shut up all pins
915 * @codec: the HDA codec
917 * Clear all pin controls to shup up before suspend for avoiding click noise.
918 * The controls aren't cached so that they can be resumed properly.
920 void snd_hda_shutup_pins(struct hda_codec
*codec
)
923 /* don't shut up pins when unloading the driver; otherwise it breaks
924 * the default pin setup at the next load of the driver
926 if (codec
->bus
->shutdown
)
928 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
929 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
930 /* use read here for syncing after issuing each verb */
931 snd_hda_codec_read(codec
, pin
->nid
, 0,
932 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
934 codec
->pins_shutup
= 1;
936 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins
);
938 /* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
939 static void restore_shutup_pins(struct hda_codec
*codec
)
942 if (!codec
->pins_shutup
)
944 if (codec
->bus
->shutdown
)
946 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
947 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
948 snd_hda_codec_write(codec
, pin
->nid
, 0,
949 AC_VERB_SET_PIN_WIDGET_CONTROL
,
952 codec
->pins_shutup
= 0;
955 static void init_hda_cache(struct hda_cache_rec
*cache
,
956 unsigned int record_size
);
957 static void free_hda_cache(struct hda_cache_rec
*cache
);
959 /* restore the initial pin cfgs and release all pincfg lists */
960 static void restore_init_pincfgs(struct hda_codec
*codec
)
962 /* first free driver_pins and user_pins, then call restore_pincfg
963 * so that only the values in init_pins are restored
965 snd_array_free(&codec
->driver_pins
);
966 #ifdef CONFIG_SND_HDA_HWDEP
967 snd_array_free(&codec
->user_pins
);
969 restore_pincfgs(codec
);
970 snd_array_free(&codec
->init_pins
);
974 * audio-converter setup caches
976 struct hda_cvt_setup
{
981 unsigned char active
; /* cvt is currently used */
982 unsigned char dirty
; /* setups should be cleared */
985 /* get or create a cache entry for the given audio converter NID */
986 static struct hda_cvt_setup
*
987 get_hda_cvt_setup(struct hda_codec
*codec
, hda_nid_t nid
)
989 struct hda_cvt_setup
*p
;
992 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
993 p
= snd_array_elem(&codec
->cvt_setups
, i
);
997 p
= snd_array_new(&codec
->cvt_setups
);
1006 static void snd_hda_codec_free(struct hda_codec
*codec
)
1010 restore_init_pincfgs(codec
);
1011 #ifdef CONFIG_SND_HDA_POWER_SAVE
1012 cancel_delayed_work(&codec
->power_work
);
1013 flush_workqueue(codec
->bus
->workq
);
1015 list_del(&codec
->list
);
1016 snd_array_free(&codec
->mixers
);
1017 snd_array_free(&codec
->nids
);
1018 codec
->bus
->caddr_tbl
[codec
->addr
] = NULL
;
1019 if (codec
->patch_ops
.free
)
1020 codec
->patch_ops
.free(codec
);
1021 module_put(codec
->owner
);
1022 free_hda_cache(&codec
->amp_cache
);
1023 free_hda_cache(&codec
->cmd_cache
);
1024 kfree(codec
->vendor_name
);
1025 kfree(codec
->chip_name
);
1026 kfree(codec
->modelname
);
1027 kfree(codec
->wcaps
);
1031 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
1032 unsigned int power_state
);
1035 * snd_hda_codec_new - create a HDA codec
1036 * @bus: the bus to assign
1037 * @codec_addr: the codec address
1038 * @codecp: the pointer to store the generated codec
1040 * Returns 0 if successful, or a negative error code.
1042 int /*__devinit*/ snd_hda_codec_new(struct hda_bus
*bus
,
1043 unsigned int codec_addr
,
1044 struct hda_codec
**codecp
)
1046 struct hda_codec
*codec
;
1050 if (snd_BUG_ON(!bus
))
1052 if (snd_BUG_ON(codec_addr
> HDA_MAX_CODEC_ADDRESS
))
1055 if (bus
->caddr_tbl
[codec_addr
]) {
1056 snd_printk(KERN_ERR
"hda_codec: "
1057 "address 0x%x is already occupied\n", codec_addr
);
1061 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
1062 if (codec
== NULL
) {
1063 snd_printk(KERN_ERR
"can't allocate struct hda_codec\n");
1068 codec
->addr
= codec_addr
;
1069 mutex_init(&codec
->spdif_mutex
);
1070 mutex_init(&codec
->control_mutex
);
1071 mutex_init(&codec
->prepare_mutex
);
1072 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
1073 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
1074 snd_array_init(&codec
->mixers
, sizeof(struct hda_nid_item
), 32);
1075 snd_array_init(&codec
->nids
, sizeof(struct hda_nid_item
), 32);
1076 snd_array_init(&codec
->init_pins
, sizeof(struct hda_pincfg
), 16);
1077 snd_array_init(&codec
->driver_pins
, sizeof(struct hda_pincfg
), 16);
1078 snd_array_init(&codec
->cvt_setups
, sizeof(struct hda_cvt_setup
), 8);
1079 if (codec
->bus
->modelname
) {
1080 codec
->modelname
= kstrdup(codec
->bus
->modelname
, GFP_KERNEL
);
1081 if (!codec
->modelname
) {
1082 snd_hda_codec_free(codec
);
1087 #ifdef CONFIG_SND_HDA_POWER_SAVE
1088 INIT_DELAYED_WORK(&codec
->power_work
, hda_power_work
);
1089 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1090 * the caller has to power down appropriatley after initialization
1093 hda_keep_power_on(codec
);
1096 list_add_tail(&codec
->list
, &bus
->codec_list
);
1097 bus
->caddr_tbl
[codec_addr
] = codec
;
1099 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1101 if (codec
->vendor_id
== -1)
1102 /* read again, hopefully the access method was corrected
1103 * in the last read...
1105 codec
->vendor_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1107 codec
->subsystem_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1108 AC_PAR_SUBSYSTEM_ID
);
1109 codec
->revision_id
= snd_hda_param_read(codec
, AC_NODE_ROOT
,
1112 setup_fg_nodes(codec
);
1113 if (!codec
->afg
&& !codec
->mfg
) {
1114 snd_printdd("hda_codec: no AFG or MFG node found\n");
1119 err
= read_widget_caps(codec
, codec
->afg
? codec
->afg
: codec
->mfg
);
1121 snd_printk(KERN_ERR
"hda_codec: cannot malloc\n");
1124 err
= read_pin_defaults(codec
);
1128 if (!codec
->subsystem_id
) {
1129 hda_nid_t nid
= codec
->afg
? codec
->afg
: codec
->mfg
;
1130 codec
->subsystem_id
=
1131 snd_hda_codec_read(codec
, nid
, 0,
1132 AC_VERB_GET_SUBSYSTEM_ID
, 0);
1135 /* power-up all before initialization */
1136 hda_set_power_state(codec
,
1137 codec
->afg
? codec
->afg
: codec
->mfg
,
1140 snd_hda_codec_proc_new(codec
);
1142 snd_hda_create_hwdep(codec
);
1144 sprintf(component
, "HDA:%08x,%08x,%08x", codec
->vendor_id
,
1145 codec
->subsystem_id
, codec
->revision_id
);
1146 snd_component_add(codec
->bus
->card
, component
);
1153 snd_hda_codec_free(codec
);
1156 EXPORT_SYMBOL_HDA(snd_hda_codec_new
);
1159 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1160 * @codec: the HDA codec
1162 * Start parsing of the given codec tree and (re-)initialize the whole
1165 * Returns 0 if successful or a negative error code.
1167 int snd_hda_codec_configure(struct hda_codec
*codec
)
1171 codec
->preset
= find_codec_preset(codec
);
1172 if (!codec
->vendor_name
|| !codec
->chip_name
) {
1173 err
= get_codec_name(codec
);
1178 if (is_generic_config(codec
)) {
1179 err
= snd_hda_parse_generic_codec(codec
);
1182 if (codec
->preset
&& codec
->preset
->patch
) {
1183 err
= codec
->preset
->patch(codec
);
1187 /* call the default parser */
1188 err
= snd_hda_parse_generic_codec(codec
);
1190 printk(KERN_ERR
"hda-codec: No codec parser is available\n");
1193 if (!err
&& codec
->patch_ops
.unsol_event
)
1194 err
= init_unsol_queue(codec
->bus
);
1195 /* audio codec should override the mixer name */
1196 if (!err
&& (codec
->afg
|| !*codec
->bus
->card
->mixername
))
1197 snprintf(codec
->bus
->card
->mixername
,
1198 sizeof(codec
->bus
->card
->mixername
),
1199 "%s %s", codec
->vendor_name
, codec
->chip_name
);
1202 EXPORT_SYMBOL_HDA(snd_hda_codec_configure
);
1205 * snd_hda_codec_setup_stream - set up the codec for streaming
1206 * @codec: the CODEC to set up
1207 * @nid: the NID to set up
1208 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1209 * @channel_id: channel id to pass, zero based.
1210 * @format: stream format.
1212 void snd_hda_codec_setup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1214 int channel_id
, int format
)
1216 struct hda_cvt_setup
*p
;
1217 unsigned int oldval
, newval
;
1223 snd_printdd("hda_codec_setup_stream: "
1224 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1225 nid
, stream_tag
, channel_id
, format
);
1226 p
= get_hda_cvt_setup(codec
, nid
);
1229 /* update the stream-id if changed */
1230 if (p
->stream_tag
!= stream_tag
|| p
->channel_id
!= channel_id
) {
1231 oldval
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONV
, 0);
1232 newval
= (stream_tag
<< 4) | channel_id
;
1233 if (oldval
!= newval
)
1234 snd_hda_codec_write(codec
, nid
, 0,
1235 AC_VERB_SET_CHANNEL_STREAMID
,
1237 p
->stream_tag
= stream_tag
;
1238 p
->channel_id
= channel_id
;
1240 /* update the format-id if changed */
1241 if (p
->format_id
!= format
) {
1242 oldval
= snd_hda_codec_read(codec
, nid
, 0,
1243 AC_VERB_GET_STREAM_FORMAT
, 0);
1244 if (oldval
!= format
) {
1246 snd_hda_codec_write(codec
, nid
, 0,
1247 AC_VERB_SET_STREAM_FORMAT
,
1250 p
->format_id
= format
;
1255 /* make other inactive cvts with the same stream-tag dirty */
1256 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1257 p
= snd_array_elem(&codec
->cvt_setups
, i
);
1258 if (!p
->active
&& p
->stream_tag
== stream_tag
)
1262 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream
);
1264 static void really_cleanup_stream(struct hda_codec
*codec
,
1265 struct hda_cvt_setup
*q
);
1268 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
1269 * @codec: the CODEC to clean up
1270 * @nid: the NID to clean up
1271 * @do_now: really clean up the stream instead of clearing the active flag
1273 void __snd_hda_codec_cleanup_stream(struct hda_codec
*codec
, hda_nid_t nid
,
1276 struct hda_cvt_setup
*p
;
1281 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid
);
1282 p
= get_hda_cvt_setup(codec
, nid
);
1284 /* here we just clear the active flag when do_now isn't set;
1285 * actual clean-ups will be done later in
1286 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1289 really_cleanup_stream(codec
, p
);
1294 EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream
);
1296 static void really_cleanup_stream(struct hda_codec
*codec
,
1297 struct hda_cvt_setup
*q
)
1299 hda_nid_t nid
= q
->nid
;
1300 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1301 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_STREAM_FORMAT
, 0);
1302 memset(q
, 0, sizeof(*q
));
1306 /* clean up the all conflicting obsolete streams */
1307 static void purify_inactive_streams(struct hda_codec
*codec
)
1311 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1312 struct hda_cvt_setup
*p
= snd_array_elem(&codec
->cvt_setups
, i
);
1314 really_cleanup_stream(codec
, p
);
1318 /* clean up all streams; called from suspend */
1319 static void hda_cleanup_all_streams(struct hda_codec
*codec
)
1323 for (i
= 0; i
< codec
->cvt_setups
.used
; i
++) {
1324 struct hda_cvt_setup
*p
= snd_array_elem(&codec
->cvt_setups
, i
);
1326 really_cleanup_stream(codec
, p
);
1331 * amp access functions
1334 /* FIXME: more better hash key? */
1335 #define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1336 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
1337 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1338 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1339 #define INFO_AMP_CAPS (1<<0)
1340 #define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1342 /* initialize the hash table */
1343 static void /*__devinit*/ init_hda_cache(struct hda_cache_rec
*cache
,
1344 unsigned int record_size
)
1346 memset(cache
, 0, sizeof(*cache
));
1347 memset(cache
->hash
, 0xff, sizeof(cache
->hash
));
1348 snd_array_init(&cache
->buf
, record_size
, 64);
1351 static void free_hda_cache(struct hda_cache_rec
*cache
)
1353 snd_array_free(&cache
->buf
);
1356 /* query the hash. allocate an entry if not found. */
1357 static struct hda_cache_head
*get_hash(struct hda_cache_rec
*cache
, u32 key
)
1359 u16 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1360 u16 cur
= cache
->hash
[idx
];
1361 struct hda_cache_head
*info
;
1363 while (cur
!= 0xffff) {
1364 info
= snd_array_elem(&cache
->buf
, cur
);
1365 if (info
->key
== key
)
1372 /* query the hash. allocate an entry if not found. */
1373 static struct hda_cache_head
*get_alloc_hash(struct hda_cache_rec
*cache
,
1376 struct hda_cache_head
*info
= get_hash(cache
, key
);
1379 /* add a new hash entry */
1380 info
= snd_array_new(&cache
->buf
);
1383 cur
= snd_array_index(&cache
->buf
, info
);
1386 idx
= key
% (u16
)ARRAY_SIZE(cache
->hash
);
1387 info
->next
= cache
->hash
[idx
];
1388 cache
->hash
[idx
] = cur
;
1393 /* query and allocate an amp hash entry */
1394 static inline struct hda_amp_info
*
1395 get_alloc_amp_hash(struct hda_codec
*codec
, u32 key
)
1397 return (struct hda_amp_info
*)get_alloc_hash(&codec
->amp_cache
, key
);
1401 * query_amp_caps - query AMP capabilities
1402 * @codec: the HD-auio codec
1403 * @nid: the NID to query
1404 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1406 * Query AMP capabilities for the given widget and direction.
1407 * Returns the obtained capability bits.
1409 * When cap bits have been already read, this doesn't read again but
1410 * returns the cached value.
1412 u32
query_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int direction
)
1414 struct hda_amp_info
*info
;
1416 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, 0));
1419 if (!(info
->head
.val
& INFO_AMP_CAPS
)) {
1420 if (!(get_wcaps(codec
, nid
) & AC_WCAP_AMP_OVRD
))
1422 info
->amp_caps
= snd_hda_param_read(codec
, nid
,
1423 direction
== HDA_OUTPUT
?
1424 AC_PAR_AMP_OUT_CAP
:
1427 info
->head
.val
|= INFO_AMP_CAPS
;
1429 return info
->amp_caps
;
1431 EXPORT_SYMBOL_HDA(query_amp_caps
);
1434 * snd_hda_override_amp_caps - Override the AMP capabilities
1435 * @codec: the CODEC to clean up
1436 * @nid: the NID to clean up
1437 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1438 * @caps: the capability bits to set
1440 * Override the cached AMP caps bits value by the given one.
1441 * This function is useful if the driver needs to adjust the AMP ranges,
1442 * e.g. limit to 0dB, etc.
1444 * Returns zero if successful or a negative error code.
1446 int snd_hda_override_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1449 struct hda_amp_info
*info
;
1451 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, dir
, 0));
1454 info
->amp_caps
= caps
;
1455 info
->head
.val
|= INFO_AMP_CAPS
;
1458 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps
);
1461 query_caps_hash(struct hda_codec
*codec
, hda_nid_t nid
, u32 key
,
1462 unsigned int (*func
)(struct hda_codec
*, hda_nid_t
))
1464 struct hda_amp_info
*info
;
1466 info
= get_alloc_amp_hash(codec
, key
);
1469 if (!info
->head
.val
) {
1470 info
->head
.val
|= INFO_AMP_CAPS
;
1471 info
->amp_caps
= func(codec
, nid
);
1473 return info
->amp_caps
;
1476 static unsigned int read_pin_cap(struct hda_codec
*codec
, hda_nid_t nid
)
1478 return snd_hda_param_read(codec
, nid
, AC_PAR_PIN_CAP
);
1482 * snd_hda_query_pin_caps - Query PIN capabilities
1483 * @codec: the HD-auio codec
1484 * @nid: the NID to query
1486 * Query PIN capabilities for the given widget.
1487 * Returns the obtained capability bits.
1489 * When cap bits have been already read, this doesn't read again but
1490 * returns the cached value.
1492 u32
snd_hda_query_pin_caps(struct hda_codec
*codec
, hda_nid_t nid
)
1494 return query_caps_hash(codec
, nid
, HDA_HASH_PINCAP_KEY(nid
),
1497 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps
);
1500 * snd_hda_pin_sense - execute pin sense measurement
1501 * @codec: the CODEC to sense
1502 * @nid: the pin NID to sense
1504 * Execute necessary pin sense measurement and return its Presence Detect,
1505 * Impedance, ELD Valid etc. status bits.
1507 u32
snd_hda_pin_sense(struct hda_codec
*codec
, hda_nid_t nid
)
1511 if (!codec
->no_trigger_sense
) {
1512 pincap
= snd_hda_query_pin_caps(codec
, nid
);
1513 if (pincap
& AC_PINCAP_TRIG_REQ
) /* need trigger? */
1514 snd_hda_codec_read(codec
, nid
, 0,
1515 AC_VERB_SET_PIN_SENSE
, 0);
1517 return snd_hda_codec_read(codec
, nid
, 0,
1518 AC_VERB_GET_PIN_SENSE
, 0);
1520 EXPORT_SYMBOL_HDA(snd_hda_pin_sense
);
1523 * snd_hda_jack_detect - query pin Presence Detect status
1524 * @codec: the CODEC to sense
1525 * @nid: the pin NID to sense
1527 * Query and return the pin's Presence Detect status.
1529 int snd_hda_jack_detect(struct hda_codec
*codec
, hda_nid_t nid
)
1531 u32 sense
= snd_hda_pin_sense(codec
, nid
);
1532 return !!(sense
& AC_PINSENSE_PRESENCE
);
1534 EXPORT_SYMBOL_HDA(snd_hda_jack_detect
);
1537 * read the current volume to info
1538 * if the cache exists, read the cache value.
1540 static unsigned int get_vol_mute(struct hda_codec
*codec
,
1541 struct hda_amp_info
*info
, hda_nid_t nid
,
1542 int ch
, int direction
, int index
)
1546 if (info
->head
.val
& INFO_AMP_VOL(ch
))
1547 return info
->vol
[ch
];
1549 parm
= ch
? AC_AMP_GET_RIGHT
: AC_AMP_GET_LEFT
;
1550 parm
|= direction
== HDA_OUTPUT
? AC_AMP_GET_OUTPUT
: AC_AMP_GET_INPUT
;
1552 val
= snd_hda_codec_read(codec
, nid
, 0,
1553 AC_VERB_GET_AMP_GAIN_MUTE
, parm
);
1554 info
->vol
[ch
] = val
& 0xff;
1555 info
->head
.val
|= INFO_AMP_VOL(ch
);
1556 return info
->vol
[ch
];
1560 * write the current volume in info to the h/w and update the cache
1562 static void put_vol_mute(struct hda_codec
*codec
, struct hda_amp_info
*info
,
1563 hda_nid_t nid
, int ch
, int direction
, int index
,
1568 parm
= ch
? AC_AMP_SET_RIGHT
: AC_AMP_SET_LEFT
;
1569 parm
|= direction
== HDA_OUTPUT
? AC_AMP_SET_OUTPUT
: AC_AMP_SET_INPUT
;
1570 parm
|= index
<< AC_AMP_SET_INDEX_SHIFT
;
1572 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, parm
);
1573 info
->vol
[ch
] = val
;
1577 * snd_hda_codec_amp_read - Read AMP value
1578 * @codec: HD-audio codec
1579 * @nid: NID to read the AMP value
1580 * @ch: channel (left=0 or right=1)
1581 * @direction: #HDA_INPUT or #HDA_OUTPUT
1582 * @index: the index value (only for input direction)
1584 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1586 int snd_hda_codec_amp_read(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1587 int direction
, int index
)
1589 struct hda_amp_info
*info
;
1590 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, index
));
1593 return get_vol_mute(codec
, info
, nid
, ch
, direction
, index
);
1595 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read
);
1598 * snd_hda_codec_amp_update - update the AMP value
1599 * @codec: HD-audio codec
1600 * @nid: NID to read the AMP value
1601 * @ch: channel (left=0 or right=1)
1602 * @direction: #HDA_INPUT or #HDA_OUTPUT
1603 * @idx: the index value (only for input direction)
1604 * @mask: bit mask to set
1605 * @val: the bits value to set
1607 * Update the AMP value with a bit mask.
1608 * Returns 0 if the value is unchanged, 1 if changed.
1610 int snd_hda_codec_amp_update(struct hda_codec
*codec
, hda_nid_t nid
, int ch
,
1611 int direction
, int idx
, int mask
, int val
)
1613 struct hda_amp_info
*info
;
1615 info
= get_alloc_amp_hash(codec
, HDA_HASH_KEY(nid
, direction
, idx
));
1618 if (snd_BUG_ON(mask
& ~0xff))
1621 val
|= get_vol_mute(codec
, info
, nid
, ch
, direction
, idx
) & ~mask
;
1622 if (info
->vol
[ch
] == val
)
1624 put_vol_mute(codec
, info
, nid
, ch
, direction
, idx
, val
);
1627 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update
);
1630 * snd_hda_codec_amp_stereo - update the AMP stereo values
1631 * @codec: HD-audio codec
1632 * @nid: NID to read the AMP value
1633 * @direction: #HDA_INPUT or #HDA_OUTPUT
1634 * @idx: the index value (only for input direction)
1635 * @mask: bit mask to set
1636 * @val: the bits value to set
1638 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1639 * stereo widget with the same mask and value.
1641 int snd_hda_codec_amp_stereo(struct hda_codec
*codec
, hda_nid_t nid
,
1642 int direction
, int idx
, int mask
, int val
)
1646 if (snd_BUG_ON(mask
& ~0xff))
1648 for (ch
= 0; ch
< 2; ch
++)
1649 ret
|= snd_hda_codec_amp_update(codec
, nid
, ch
, direction
,
1653 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo
);
1655 #ifdef SND_HDA_NEEDS_RESUME
1657 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1658 * @codec: HD-audio codec
1660 * Resume the all amp commands from the cache.
1662 void snd_hda_codec_resume_amp(struct hda_codec
*codec
)
1664 struct hda_amp_info
*buffer
= codec
->amp_cache
.buf
.list
;
1667 for (i
= 0; i
< codec
->amp_cache
.buf
.used
; i
++, buffer
++) {
1668 u32 key
= buffer
->head
.key
;
1670 unsigned int idx
, dir
, ch
;
1674 idx
= (key
>> 16) & 0xff;
1675 dir
= (key
>> 24) & 0xff;
1676 for (ch
= 0; ch
< 2; ch
++) {
1677 if (!(buffer
->head
.val
& INFO_AMP_VOL(ch
)))
1679 put_vol_mute(codec
, buffer
, nid
, ch
, dir
, idx
,
1684 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp
);
1685 #endif /* SND_HDA_NEEDS_RESUME */
1687 static u32
get_amp_max_value(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1690 u32 caps
= query_amp_caps(codec
, nid
, dir
);
1692 caps
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1699 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1701 * The control element is supposed to have the private_value field
1702 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1704 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol
*kcontrol
,
1705 struct snd_ctl_elem_info
*uinfo
)
1707 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1708 u16 nid
= get_amp_nid(kcontrol
);
1709 u8 chs
= get_amp_channels(kcontrol
);
1710 int dir
= get_amp_direction(kcontrol
);
1711 unsigned int ofs
= get_amp_offset(kcontrol
);
1713 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1714 uinfo
->count
= chs
== 3 ? 2 : 1;
1715 uinfo
->value
.integer
.min
= 0;
1716 uinfo
->value
.integer
.max
= get_amp_max_value(codec
, nid
, dir
, ofs
);
1717 if (!uinfo
->value
.integer
.max
) {
1718 printk(KERN_WARNING
"hda_codec: "
1719 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid
,
1725 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info
);
1728 static inline unsigned int
1729 read_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1730 int ch
, int dir
, int idx
, unsigned int ofs
)
1733 val
= snd_hda_codec_amp_read(codec
, nid
, ch
, dir
, idx
);
1734 val
&= HDA_AMP_VOLMASK
;
1743 update_amp_value(struct hda_codec
*codec
, hda_nid_t nid
,
1744 int ch
, int dir
, int idx
, unsigned int ofs
,
1747 unsigned int maxval
;
1751 /* ofs = 0: raw max value */
1752 maxval
= get_amp_max_value(codec
, nid
, dir
, 0);
1755 return snd_hda_codec_amp_update(codec
, nid
, ch
, dir
, idx
,
1756 HDA_AMP_VOLMASK
, val
);
1760 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1762 * The control element is supposed to have the private_value field
1763 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1765 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol
*kcontrol
,
1766 struct snd_ctl_elem_value
*ucontrol
)
1768 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1769 hda_nid_t nid
= get_amp_nid(kcontrol
);
1770 int chs
= get_amp_channels(kcontrol
);
1771 int dir
= get_amp_direction(kcontrol
);
1772 int idx
= get_amp_index(kcontrol
);
1773 unsigned int ofs
= get_amp_offset(kcontrol
);
1774 long *valp
= ucontrol
->value
.integer
.value
;
1777 *valp
++ = read_amp_value(codec
, nid
, 0, dir
, idx
, ofs
);
1779 *valp
= read_amp_value(codec
, nid
, 1, dir
, idx
, ofs
);
1782 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get
);
1785 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1787 * The control element is supposed to have the private_value field
1788 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1790 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol
*kcontrol
,
1791 struct snd_ctl_elem_value
*ucontrol
)
1793 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1794 hda_nid_t nid
= get_amp_nid(kcontrol
);
1795 int chs
= get_amp_channels(kcontrol
);
1796 int dir
= get_amp_direction(kcontrol
);
1797 int idx
= get_amp_index(kcontrol
);
1798 unsigned int ofs
= get_amp_offset(kcontrol
);
1799 long *valp
= ucontrol
->value
.integer
.value
;
1802 snd_hda_power_up(codec
);
1804 change
= update_amp_value(codec
, nid
, 0, dir
, idx
, ofs
, *valp
);
1808 change
|= update_amp_value(codec
, nid
, 1, dir
, idx
, ofs
, *valp
);
1809 snd_hda_power_down(codec
);
1812 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put
);
1815 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1817 * The control element is supposed to have the private_value field
1818 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1820 int snd_hda_mixer_amp_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1821 unsigned int size
, unsigned int __user
*_tlv
)
1823 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1824 hda_nid_t nid
= get_amp_nid(kcontrol
);
1825 int dir
= get_amp_direction(kcontrol
);
1826 unsigned int ofs
= get_amp_offset(kcontrol
);
1827 u32 caps
, val1
, val2
;
1829 if (size
< 4 * sizeof(unsigned int))
1831 caps
= query_amp_caps(codec
, nid
, dir
);
1832 val2
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1833 val2
= (val2
+ 1) * 25;
1834 val1
= -((caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
);
1836 val1
= ((int)val1
) * ((int)val2
);
1837 if (put_user(SNDRV_CTL_TLVT_DB_SCALE
, _tlv
))
1839 if (put_user(2 * sizeof(unsigned int), _tlv
+ 1))
1841 if (put_user(val1
, _tlv
+ 2))
1843 if (put_user(val2
, _tlv
+ 3))
1847 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv
);
1850 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1851 * @codec: HD-audio codec
1852 * @nid: NID of a reference widget
1853 * @dir: #HDA_INPUT or #HDA_OUTPUT
1854 * @tlv: TLV data to be stored, at least 4 elements
1856 * Set (static) TLV data for a virtual master volume using the AMP caps
1857 * obtained from the reference NID.
1858 * The volume range is recalculated as if the max volume is 0dB.
1860 void snd_hda_set_vmaster_tlv(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
1866 caps
= query_amp_caps(codec
, nid
, dir
);
1867 nums
= (caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
;
1868 step
= (caps
& AC_AMPCAP_STEP_SIZE
) >> AC_AMPCAP_STEP_SIZE_SHIFT
;
1869 step
= (step
+ 1) * 25;
1870 tlv
[0] = SNDRV_CTL_TLVT_DB_SCALE
;
1871 tlv
[1] = 2 * sizeof(unsigned int);
1872 tlv
[2] = -nums
* step
;
1875 EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv
);
1877 /* find a mixer control element with the given name */
1878 static struct snd_kcontrol
*
1879 _snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1880 const char *name
, int idx
)
1882 struct snd_ctl_elem_id id
;
1883 memset(&id
, 0, sizeof(id
));
1884 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1886 if (snd_BUG_ON(strlen(name
) >= sizeof(id
.name
)))
1888 strcpy(id
.name
, name
);
1889 return snd_ctl_find_id(codec
->bus
->card
, &id
);
1893 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1894 * @codec: HD-audio codec
1895 * @name: ctl id name string
1897 * Get the control element with the given id string and IFACE_MIXER.
1899 struct snd_kcontrol
*snd_hda_find_mixer_ctl(struct hda_codec
*codec
,
1902 return _snd_hda_find_mixer_ctl(codec
, name
, 0);
1904 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl
);
1907 * snd_hda_ctl_add - Add a control element and assign to the codec
1908 * @codec: HD-audio codec
1909 * @nid: corresponding NID (optional)
1910 * @kctl: the control element to assign
1912 * Add the given control element to an array inside the codec instance.
1913 * All control elements belonging to a codec are supposed to be added
1914 * by this function so that a proper clean-up works at the free or
1915 * reconfiguration time.
1917 * If non-zero @nid is passed, the NID is assigned to the control element.
1918 * The assignment is shown in the codec proc file.
1920 * snd_hda_ctl_add() checks the control subdev id field whether
1921 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1922 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
1923 * specifies if kctl->private_value is a HDA amplifier value.
1925 int snd_hda_ctl_add(struct hda_codec
*codec
, hda_nid_t nid
,
1926 struct snd_kcontrol
*kctl
)
1929 unsigned short flags
= 0;
1930 struct hda_nid_item
*item
;
1932 if (kctl
->id
.subdevice
& HDA_SUBDEV_AMP_FLAG
) {
1933 flags
|= HDA_NID_ITEM_AMP
;
1935 nid
= get_amp_nid_(kctl
->private_value
);
1937 if ((kctl
->id
.subdevice
& HDA_SUBDEV_NID_FLAG
) != 0 && nid
== 0)
1938 nid
= kctl
->id
.subdevice
& 0xffff;
1939 if (kctl
->id
.subdevice
& (HDA_SUBDEV_NID_FLAG
|HDA_SUBDEV_AMP_FLAG
))
1940 kctl
->id
.subdevice
= 0;
1941 err
= snd_ctl_add(codec
->bus
->card
, kctl
);
1944 item
= snd_array_new(&codec
->mixers
);
1949 item
->flags
= flags
;
1952 EXPORT_SYMBOL_HDA(snd_hda_ctl_add
);
1955 * snd_hda_add_nid - Assign a NID to a control element
1956 * @codec: HD-audio codec
1957 * @nid: corresponding NID (optional)
1958 * @kctl: the control element to assign
1959 * @index: index to kctl
1961 * Add the given control element to an array inside the codec instance.
1962 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
1963 * NID:KCTL mapping - for example "Capture Source" selector.
1965 int snd_hda_add_nid(struct hda_codec
*codec
, struct snd_kcontrol
*kctl
,
1966 unsigned int index
, hda_nid_t nid
)
1968 struct hda_nid_item
*item
;
1971 item
= snd_array_new(&codec
->nids
);
1975 item
->index
= index
;
1979 printk(KERN_ERR
"hda-codec: no NID for mapping control %s:%d:%d\n",
1980 kctl
->id
.name
, kctl
->id
.index
, index
);
1983 EXPORT_SYMBOL_HDA(snd_hda_add_nid
);
1986 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1987 * @codec: HD-audio codec
1989 void snd_hda_ctls_clear(struct hda_codec
*codec
)
1992 struct hda_nid_item
*items
= codec
->mixers
.list
;
1993 for (i
= 0; i
< codec
->mixers
.used
; i
++)
1994 snd_ctl_remove(codec
->bus
->card
, items
[i
].kctl
);
1995 snd_array_free(&codec
->mixers
);
1996 snd_array_free(&codec
->nids
);
1999 /* pseudo device locking
2000 * toggle card->shutdown to allow/disallow the device access (as a hack)
2002 static int hda_lock_devices(struct snd_card
*card
)
2004 spin_lock(&card
->files_lock
);
2005 if (card
->shutdown
) {
2006 spin_unlock(&card
->files_lock
);
2010 spin_unlock(&card
->files_lock
);
2014 static void hda_unlock_devices(struct snd_card
*card
)
2016 spin_lock(&card
->files_lock
);
2018 spin_unlock(&card
->files_lock
);
2022 * snd_hda_codec_reset - Clear all objects assigned to the codec
2023 * @codec: HD-audio codec
2025 * This frees the all PCM and control elements assigned to the codec, and
2026 * clears the caches and restores the pin default configurations.
2028 * When a device is being used, it returns -EBSY. If successfully freed,
2031 int snd_hda_codec_reset(struct hda_codec
*codec
)
2033 struct snd_card
*card
= codec
->bus
->card
;
2036 if (hda_lock_devices(card
) < 0)
2038 /* check whether the codec isn't used by any mixer or PCM streams */
2039 if (!list_empty(&card
->ctl_files
)) {
2040 hda_unlock_devices(card
);
2043 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
2044 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
2047 if (cpcm
->pcm
->streams
[0].substream_opened
||
2048 cpcm
->pcm
->streams
[1].substream_opened
) {
2049 hda_unlock_devices(card
);
2054 /* OK, let it free */
2056 #ifdef CONFIG_SND_HDA_POWER_SAVE
2057 cancel_delayed_work(&codec
->power_work
);
2058 flush_workqueue(codec
->bus
->workq
);
2060 snd_hda_ctls_clear(codec
);
2062 for (i
= 0; i
< codec
->num_pcms
; i
++) {
2063 if (codec
->pcm_info
[i
].pcm
) {
2064 snd_device_free(card
, codec
->pcm_info
[i
].pcm
);
2065 clear_bit(codec
->pcm_info
[i
].device
,
2066 codec
->bus
->pcm_dev_bits
);
2069 if (codec
->patch_ops
.free
)
2070 codec
->patch_ops
.free(codec
);
2071 codec
->proc_widget_hook
= NULL
;
2073 free_hda_cache(&codec
->amp_cache
);
2074 free_hda_cache(&codec
->cmd_cache
);
2075 init_hda_cache(&codec
->amp_cache
, sizeof(struct hda_amp_info
));
2076 init_hda_cache(&codec
->cmd_cache
, sizeof(struct hda_cache_head
));
2077 /* free only driver_pins so that init_pins + user_pins are restored */
2078 snd_array_free(&codec
->driver_pins
);
2079 restore_pincfgs(codec
);
2080 codec
->num_pcms
= 0;
2081 codec
->pcm_info
= NULL
;
2082 codec
->preset
= NULL
;
2083 memset(&codec
->patch_ops
, 0, sizeof(codec
->patch_ops
));
2084 codec
->slave_dig_outs
= NULL
;
2085 codec
->spdif_status_reset
= 0;
2086 module_put(codec
->owner
);
2087 codec
->owner
= NULL
;
2089 /* allow device access again */
2090 hda_unlock_devices(card
);
2095 * snd_hda_add_vmaster - create a virtual master control and add slaves
2096 * @codec: HD-audio codec
2097 * @name: vmaster control name
2098 * @tlv: TLV data (optional)
2099 * @slaves: slave control names (optional)
2101 * Create a virtual master control with the given name. The TLV data
2102 * must be either NULL or a valid data.
2104 * @slaves is a NULL-terminated array of strings, each of which is a
2105 * slave control name. All controls with these names are assigned to
2106 * the new virtual master control.
2108 * This function returns zero if successful or a negative error code.
2110 int snd_hda_add_vmaster(struct hda_codec
*codec
, char *name
,
2111 unsigned int *tlv
, const char **slaves
)
2113 struct snd_kcontrol
*kctl
;
2117 for (s
= slaves
; *s
&& !snd_hda_find_mixer_ctl(codec
, *s
); s
++)
2120 snd_printdd("No slave found for %s\n", name
);
2123 kctl
= snd_ctl_make_virtual_master(name
, tlv
);
2126 err
= snd_hda_ctl_add(codec
, 0, kctl
);
2130 for (s
= slaves
; *s
; s
++) {
2131 struct snd_kcontrol
*sctl
;
2134 sctl
= _snd_hda_find_mixer_ctl(codec
, *s
, i
);
2137 snd_printdd("Cannot find slave %s, "
2141 err
= snd_ctl_add_slave(kctl
, sctl
);
2149 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster
);
2152 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2154 * The control element is supposed to have the private_value field
2155 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2157 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol
*kcontrol
,
2158 struct snd_ctl_elem_info
*uinfo
)
2160 int chs
= get_amp_channels(kcontrol
);
2162 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2163 uinfo
->count
= chs
== 3 ? 2 : 1;
2164 uinfo
->value
.integer
.min
= 0;
2165 uinfo
->value
.integer
.max
= 1;
2168 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info
);
2171 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2173 * The control element is supposed to have the private_value field
2174 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2176 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol
*kcontrol
,
2177 struct snd_ctl_elem_value
*ucontrol
)
2179 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2180 hda_nid_t nid
= get_amp_nid(kcontrol
);
2181 int chs
= get_amp_channels(kcontrol
);
2182 int dir
= get_amp_direction(kcontrol
);
2183 int idx
= get_amp_index(kcontrol
);
2184 long *valp
= ucontrol
->value
.integer
.value
;
2187 *valp
++ = (snd_hda_codec_amp_read(codec
, nid
, 0, dir
, idx
) &
2188 HDA_AMP_MUTE
) ? 0 : 1;
2190 *valp
= (snd_hda_codec_amp_read(codec
, nid
, 1, dir
, idx
) &
2191 HDA_AMP_MUTE
) ? 0 : 1;
2194 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get
);
2197 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2199 * The control element is supposed to have the private_value field
2200 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2202 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol
*kcontrol
,
2203 struct snd_ctl_elem_value
*ucontrol
)
2205 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2206 hda_nid_t nid
= get_amp_nid(kcontrol
);
2207 int chs
= get_amp_channels(kcontrol
);
2208 int dir
= get_amp_direction(kcontrol
);
2209 int idx
= get_amp_index(kcontrol
);
2210 long *valp
= ucontrol
->value
.integer
.value
;
2213 snd_hda_power_up(codec
);
2215 change
= snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
2217 *valp
? 0 : HDA_AMP_MUTE
);
2221 change
|= snd_hda_codec_amp_update(codec
, nid
, 1, dir
, idx
,
2223 *valp
? 0 : HDA_AMP_MUTE
);
2224 #ifdef CONFIG_SND_HDA_POWER_SAVE
2225 if (codec
->patch_ops
.check_power_status
)
2226 codec
->patch_ops
.check_power_status(codec
, nid
);
2228 snd_hda_power_down(codec
);
2231 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put
);
2233 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2235 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2237 * This function calls snd_hda_enable_beep_device(), which behaves differently
2238 * depending on beep_mode option.
2240 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol
*kcontrol
,
2241 struct snd_ctl_elem_value
*ucontrol
)
2243 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2244 long *valp
= ucontrol
->value
.integer
.value
;
2246 snd_hda_enable_beep_device(codec
, *valp
);
2247 return snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2249 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep
);
2250 #endif /* CONFIG_SND_HDA_INPUT_BEEP */
2253 * bound volume controls
2255 * bind multiple volumes (# indices, from 0)
2258 #define AMP_VAL_IDX_SHIFT 19
2259 #define AMP_VAL_IDX_MASK (0x0f<<19)
2262 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2264 * The control element is supposed to have the private_value field
2265 * set up via HDA_BIND_MUTE*() macros.
2267 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol
*kcontrol
,
2268 struct snd_ctl_elem_value
*ucontrol
)
2270 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2274 mutex_lock(&codec
->control_mutex
);
2275 pval
= kcontrol
->private_value
;
2276 kcontrol
->private_value
= pval
& ~AMP_VAL_IDX_MASK
; /* index 0 */
2277 err
= snd_hda_mixer_amp_switch_get(kcontrol
, ucontrol
);
2278 kcontrol
->private_value
= pval
;
2279 mutex_unlock(&codec
->control_mutex
);
2282 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get
);
2285 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2287 * The control element is supposed to have the private_value field
2288 * set up via HDA_BIND_MUTE*() macros.
2290 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol
*kcontrol
,
2291 struct snd_ctl_elem_value
*ucontrol
)
2293 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2295 int i
, indices
, err
= 0, change
= 0;
2297 mutex_lock(&codec
->control_mutex
);
2298 pval
= kcontrol
->private_value
;
2299 indices
= (pval
& AMP_VAL_IDX_MASK
) >> AMP_VAL_IDX_SHIFT
;
2300 for (i
= 0; i
< indices
; i
++) {
2301 kcontrol
->private_value
= (pval
& ~AMP_VAL_IDX_MASK
) |
2302 (i
<< AMP_VAL_IDX_SHIFT
);
2303 err
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
2308 kcontrol
->private_value
= pval
;
2309 mutex_unlock(&codec
->control_mutex
);
2310 return err
< 0 ? err
: change
;
2312 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put
);
2315 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2317 * The control element is supposed to have the private_value field
2318 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2320 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol
*kcontrol
,
2321 struct snd_ctl_elem_info
*uinfo
)
2323 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2324 struct hda_bind_ctls
*c
;
2327 mutex_lock(&codec
->control_mutex
);
2328 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2329 kcontrol
->private_value
= *c
->values
;
2330 err
= c
->ops
->info(kcontrol
, uinfo
);
2331 kcontrol
->private_value
= (long)c
;
2332 mutex_unlock(&codec
->control_mutex
);
2335 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info
);
2338 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2340 * The control element is supposed to have the private_value field
2341 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2343 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol
*kcontrol
,
2344 struct snd_ctl_elem_value
*ucontrol
)
2346 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2347 struct hda_bind_ctls
*c
;
2350 mutex_lock(&codec
->control_mutex
);
2351 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2352 kcontrol
->private_value
= *c
->values
;
2353 err
= c
->ops
->get(kcontrol
, ucontrol
);
2354 kcontrol
->private_value
= (long)c
;
2355 mutex_unlock(&codec
->control_mutex
);
2358 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get
);
2361 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2363 * The control element is supposed to have the private_value field
2364 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2366 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol
*kcontrol
,
2367 struct snd_ctl_elem_value
*ucontrol
)
2369 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2370 struct hda_bind_ctls
*c
;
2371 unsigned long *vals
;
2372 int err
= 0, change
= 0;
2374 mutex_lock(&codec
->control_mutex
);
2375 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2376 for (vals
= c
->values
; *vals
; vals
++) {
2377 kcontrol
->private_value
= *vals
;
2378 err
= c
->ops
->put(kcontrol
, ucontrol
);
2383 kcontrol
->private_value
= (long)c
;
2384 mutex_unlock(&codec
->control_mutex
);
2385 return err
< 0 ? err
: change
;
2387 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put
);
2390 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2392 * The control element is supposed to have the private_value field
2393 * set up via HDA_BIND_VOL() macro.
2395 int snd_hda_mixer_bind_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
2396 unsigned int size
, unsigned int __user
*tlv
)
2398 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2399 struct hda_bind_ctls
*c
;
2402 mutex_lock(&codec
->control_mutex
);
2403 c
= (struct hda_bind_ctls
*)kcontrol
->private_value
;
2404 kcontrol
->private_value
= *c
->values
;
2405 err
= c
->ops
->tlv(kcontrol
, op_flag
, size
, tlv
);
2406 kcontrol
->private_value
= (long)c
;
2407 mutex_unlock(&codec
->control_mutex
);
2410 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv
);
2412 struct hda_ctl_ops snd_hda_bind_vol
= {
2413 .info
= snd_hda_mixer_amp_volume_info
,
2414 .get
= snd_hda_mixer_amp_volume_get
,
2415 .put
= snd_hda_mixer_amp_volume_put
,
2416 .tlv
= snd_hda_mixer_amp_tlv
2418 EXPORT_SYMBOL_HDA(snd_hda_bind_vol
);
2420 struct hda_ctl_ops snd_hda_bind_sw
= {
2421 .info
= snd_hda_mixer_amp_switch_info
,
2422 .get
= snd_hda_mixer_amp_switch_get
,
2423 .put
= snd_hda_mixer_amp_switch_put
,
2424 .tlv
= snd_hda_mixer_amp_tlv
2426 EXPORT_SYMBOL_HDA(snd_hda_bind_sw
);
2429 * SPDIF out controls
2432 static int snd_hda_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2433 struct snd_ctl_elem_info
*uinfo
)
2435 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2440 static int snd_hda_spdif_cmask_get(struct snd_kcontrol
*kcontrol
,
2441 struct snd_ctl_elem_value
*ucontrol
)
2443 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2444 IEC958_AES0_NONAUDIO
|
2445 IEC958_AES0_CON_EMPHASIS_5015
|
2446 IEC958_AES0_CON_NOT_COPYRIGHT
;
2447 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_CATEGORY
|
2448 IEC958_AES1_CON_ORIGINAL
;
2452 static int snd_hda_spdif_pmask_get(struct snd_kcontrol
*kcontrol
,
2453 struct snd_ctl_elem_value
*ucontrol
)
2455 ucontrol
->value
.iec958
.status
[0] = IEC958_AES0_PROFESSIONAL
|
2456 IEC958_AES0_NONAUDIO
|
2457 IEC958_AES0_PRO_EMPHASIS_5015
;
2461 static int snd_hda_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2462 struct snd_ctl_elem_value
*ucontrol
)
2464 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2466 ucontrol
->value
.iec958
.status
[0] = codec
->spdif_status
& 0xff;
2467 ucontrol
->value
.iec958
.status
[1] = (codec
->spdif_status
>> 8) & 0xff;
2468 ucontrol
->value
.iec958
.status
[2] = (codec
->spdif_status
>> 16) & 0xff;
2469 ucontrol
->value
.iec958
.status
[3] = (codec
->spdif_status
>> 24) & 0xff;
2474 /* convert from SPDIF status bits to HDA SPDIF bits
2475 * bit 0 (DigEn) is always set zero (to be filled later)
2477 static unsigned short convert_from_spdif_status(unsigned int sbits
)
2479 unsigned short val
= 0;
2481 if (sbits
& IEC958_AES0_PROFESSIONAL
)
2482 val
|= AC_DIG1_PROFESSIONAL
;
2483 if (sbits
& IEC958_AES0_NONAUDIO
)
2484 val
|= AC_DIG1_NONAUDIO
;
2485 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2486 if ((sbits
& IEC958_AES0_PRO_EMPHASIS
) ==
2487 IEC958_AES0_PRO_EMPHASIS_5015
)
2488 val
|= AC_DIG1_EMPHASIS
;
2490 if ((sbits
& IEC958_AES0_CON_EMPHASIS
) ==
2491 IEC958_AES0_CON_EMPHASIS_5015
)
2492 val
|= AC_DIG1_EMPHASIS
;
2493 if (!(sbits
& IEC958_AES0_CON_NOT_COPYRIGHT
))
2494 val
|= AC_DIG1_COPYRIGHT
;
2495 if (sbits
& (IEC958_AES1_CON_ORIGINAL
<< 8))
2496 val
|= AC_DIG1_LEVEL
;
2497 val
|= sbits
& (IEC958_AES1_CON_CATEGORY
<< 8);
2502 /* convert to SPDIF status bits from HDA SPDIF bits
2504 static unsigned int convert_to_spdif_status(unsigned short val
)
2506 unsigned int sbits
= 0;
2508 if (val
& AC_DIG1_NONAUDIO
)
2509 sbits
|= IEC958_AES0_NONAUDIO
;
2510 if (val
& AC_DIG1_PROFESSIONAL
)
2511 sbits
|= IEC958_AES0_PROFESSIONAL
;
2512 if (sbits
& IEC958_AES0_PROFESSIONAL
) {
2513 if (sbits
& AC_DIG1_EMPHASIS
)
2514 sbits
|= IEC958_AES0_PRO_EMPHASIS_5015
;
2516 if (val
& AC_DIG1_EMPHASIS
)
2517 sbits
|= IEC958_AES0_CON_EMPHASIS_5015
;
2518 if (!(val
& AC_DIG1_COPYRIGHT
))
2519 sbits
|= IEC958_AES0_CON_NOT_COPYRIGHT
;
2520 if (val
& AC_DIG1_LEVEL
)
2521 sbits
|= (IEC958_AES1_CON_ORIGINAL
<< 8);
2522 sbits
|= val
& (0x7f << 8);
2527 /* set digital convert verbs both for the given NID and its slaves */
2528 static void set_dig_out(struct hda_codec
*codec
, hda_nid_t nid
,
2533 snd_hda_codec_write_cache(codec
, nid
, 0, verb
, val
);
2534 d
= codec
->slave_dig_outs
;
2538 snd_hda_codec_write_cache(codec
, *d
, 0, verb
, val
);
2541 static inline void set_dig_out_convert(struct hda_codec
*codec
, hda_nid_t nid
,
2545 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_1
, dig1
);
2547 set_dig_out(codec
, nid
, AC_VERB_SET_DIGI_CONVERT_2
, dig2
);
2550 static int snd_hda_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2551 struct snd_ctl_elem_value
*ucontrol
)
2553 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2554 hda_nid_t nid
= kcontrol
->private_value
;
2558 mutex_lock(&codec
->spdif_mutex
);
2559 codec
->spdif_status
= ucontrol
->value
.iec958
.status
[0] |
2560 ((unsigned int)ucontrol
->value
.iec958
.status
[1] << 8) |
2561 ((unsigned int)ucontrol
->value
.iec958
.status
[2] << 16) |
2562 ((unsigned int)ucontrol
->value
.iec958
.status
[3] << 24);
2563 val
= convert_from_spdif_status(codec
->spdif_status
);
2564 val
|= codec
->spdif_ctls
& 1;
2565 change
= codec
->spdif_ctls
!= val
;
2566 codec
->spdif_ctls
= val
;
2569 set_dig_out_convert(codec
, nid
, val
& 0xff, (val
>> 8) & 0xff);
2571 mutex_unlock(&codec
->spdif_mutex
);
2575 #define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
2577 static int snd_hda_spdif_out_switch_get(struct snd_kcontrol
*kcontrol
,
2578 struct snd_ctl_elem_value
*ucontrol
)
2580 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2582 ucontrol
->value
.integer
.value
[0] = codec
->spdif_ctls
& AC_DIG1_ENABLE
;
2586 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol
*kcontrol
,
2587 struct snd_ctl_elem_value
*ucontrol
)
2589 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2590 hda_nid_t nid
= kcontrol
->private_value
;
2594 mutex_lock(&codec
->spdif_mutex
);
2595 val
= codec
->spdif_ctls
& ~AC_DIG1_ENABLE
;
2596 if (ucontrol
->value
.integer
.value
[0])
2597 val
|= AC_DIG1_ENABLE
;
2598 change
= codec
->spdif_ctls
!= val
;
2600 codec
->spdif_ctls
= val
;
2601 set_dig_out_convert(codec
, nid
, val
& 0xff, -1);
2602 /* unmute amp switch (if any) */
2603 if ((get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
) &&
2604 (val
& AC_DIG1_ENABLE
))
2605 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
2608 mutex_unlock(&codec
->spdif_mutex
);
2612 static struct snd_kcontrol_new dig_mixes
[] = {
2614 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2615 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2616 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, CON_MASK
),
2617 .info
= snd_hda_spdif_mask_info
,
2618 .get
= snd_hda_spdif_cmask_get
,
2621 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2622 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2623 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, PRO_MASK
),
2624 .info
= snd_hda_spdif_mask_info
,
2625 .get
= snd_hda_spdif_pmask_get
,
2628 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2629 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, DEFAULT
),
2630 .info
= snd_hda_spdif_mask_info
,
2631 .get
= snd_hda_spdif_default_get
,
2632 .put
= snd_hda_spdif_default_put
,
2635 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2636 .name
= SNDRV_CTL_NAME_IEC958("", PLAYBACK
, SWITCH
),
2637 .info
= snd_hda_spdif_out_switch_info
,
2638 .get
= snd_hda_spdif_out_switch_get
,
2639 .put
= snd_hda_spdif_out_switch_put
,
2644 #define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2647 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2648 * @codec: the HDA codec
2649 * @nid: audio out widget NID
2651 * Creates controls related with the SPDIF output.
2652 * Called from each patch supporting the SPDIF out.
2654 * Returns 0 if successful, or a negative error code.
2656 int snd_hda_create_spdif_out_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2659 struct snd_kcontrol
*kctl
;
2660 struct snd_kcontrol_new
*dig_mix
;
2663 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2664 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Playback Switch",
2668 if (idx
>= SPDIF_MAX_IDX
) {
2669 printk(KERN_ERR
"hda_codec: too many IEC958 outputs\n");
2672 for (dig_mix
= dig_mixes
; dig_mix
->name
; dig_mix
++) {
2673 kctl
= snd_ctl_new1(dig_mix
, codec
);
2676 kctl
->id
.index
= idx
;
2677 kctl
->private_value
= nid
;
2678 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2683 snd_hda_codec_read(codec
, nid
, 0,
2684 AC_VERB_GET_DIGI_CONVERT_1
, 0);
2685 codec
->spdif_status
= convert_to_spdif_status(codec
->spdif_ctls
);
2688 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls
);
2691 * SPDIF sharing with analog output
2693 static int spdif_share_sw_get(struct snd_kcontrol
*kcontrol
,
2694 struct snd_ctl_elem_value
*ucontrol
)
2696 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2697 ucontrol
->value
.integer
.value
[0] = mout
->share_spdif
;
2701 static int spdif_share_sw_put(struct snd_kcontrol
*kcontrol
,
2702 struct snd_ctl_elem_value
*ucontrol
)
2704 struct hda_multi_out
*mout
= snd_kcontrol_chip(kcontrol
);
2705 mout
->share_spdif
= !!ucontrol
->value
.integer
.value
[0];
2709 static struct snd_kcontrol_new spdif_share_sw
= {
2710 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2711 .name
= "IEC958 Default PCM Playback Switch",
2712 .info
= snd_ctl_boolean_mono_info
,
2713 .get
= spdif_share_sw_get
,
2714 .put
= spdif_share_sw_put
,
2718 * snd_hda_create_spdif_share_sw - create Default PCM switch
2719 * @codec: the HDA codec
2720 * @mout: multi-out instance
2722 int snd_hda_create_spdif_share_sw(struct hda_codec
*codec
,
2723 struct hda_multi_out
*mout
)
2725 if (!mout
->dig_out_nid
)
2727 /* ATTENTION: here mout is passed as private_data, instead of codec */
2728 return snd_hda_ctl_add(codec
, mout
->dig_out_nid
,
2729 snd_ctl_new1(&spdif_share_sw
, mout
));
2731 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw
);
2737 #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2739 static int snd_hda_spdif_in_switch_get(struct snd_kcontrol
*kcontrol
,
2740 struct snd_ctl_elem_value
*ucontrol
)
2742 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2744 ucontrol
->value
.integer
.value
[0] = codec
->spdif_in_enable
;
2748 static int snd_hda_spdif_in_switch_put(struct snd_kcontrol
*kcontrol
,
2749 struct snd_ctl_elem_value
*ucontrol
)
2751 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2752 hda_nid_t nid
= kcontrol
->private_value
;
2753 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
2756 mutex_lock(&codec
->spdif_mutex
);
2757 change
= codec
->spdif_in_enable
!= val
;
2759 codec
->spdif_in_enable
= val
;
2760 snd_hda_codec_write_cache(codec
, nid
, 0,
2761 AC_VERB_SET_DIGI_CONVERT_1
, val
);
2763 mutex_unlock(&codec
->spdif_mutex
);
2767 static int snd_hda_spdif_in_status_get(struct snd_kcontrol
*kcontrol
,
2768 struct snd_ctl_elem_value
*ucontrol
)
2770 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2771 hda_nid_t nid
= kcontrol
->private_value
;
2775 val
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_DIGI_CONVERT_1
, 0);
2776 sbits
= convert_to_spdif_status(val
);
2777 ucontrol
->value
.iec958
.status
[0] = sbits
;
2778 ucontrol
->value
.iec958
.status
[1] = sbits
>> 8;
2779 ucontrol
->value
.iec958
.status
[2] = sbits
>> 16;
2780 ucontrol
->value
.iec958
.status
[3] = sbits
>> 24;
2784 static struct snd_kcontrol_new dig_in_ctls
[] = {
2786 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2787 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, SWITCH
),
2788 .info
= snd_hda_spdif_in_switch_info
,
2789 .get
= snd_hda_spdif_in_switch_get
,
2790 .put
= snd_hda_spdif_in_switch_put
,
2793 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2794 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2795 .name
= SNDRV_CTL_NAME_IEC958("", CAPTURE
, DEFAULT
),
2796 .info
= snd_hda_spdif_mask_info
,
2797 .get
= snd_hda_spdif_in_status_get
,
2803 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2804 * @codec: the HDA codec
2805 * @nid: audio in widget NID
2807 * Creates controls related with the SPDIF input.
2808 * Called from each patch supporting the SPDIF in.
2810 * Returns 0 if successful, or a negative error code.
2812 int snd_hda_create_spdif_in_ctls(struct hda_codec
*codec
, hda_nid_t nid
)
2815 struct snd_kcontrol
*kctl
;
2816 struct snd_kcontrol_new
*dig_mix
;
2819 for (idx
= 0; idx
< SPDIF_MAX_IDX
; idx
++) {
2820 if (!_snd_hda_find_mixer_ctl(codec
, "IEC958 Capture Switch",
2824 if (idx
>= SPDIF_MAX_IDX
) {
2825 printk(KERN_ERR
"hda_codec: too many IEC958 inputs\n");
2828 for (dig_mix
= dig_in_ctls
; dig_mix
->name
; dig_mix
++) {
2829 kctl
= snd_ctl_new1(dig_mix
, codec
);
2832 kctl
->private_value
= nid
;
2833 err
= snd_hda_ctl_add(codec
, nid
, kctl
);
2837 codec
->spdif_in_enable
=
2838 snd_hda_codec_read(codec
, nid
, 0,
2839 AC_VERB_GET_DIGI_CONVERT_1
, 0) &
2843 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls
);
2845 #ifdef SND_HDA_NEEDS_RESUME
2850 /* build a 32bit cache key with the widget id and the command parameter */
2851 #define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2852 #define get_cmd_cache_nid(key) ((key) & 0xff)
2853 #define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2856 * snd_hda_codec_write_cache - send a single command with caching
2857 * @codec: the HDA codec
2858 * @nid: NID to send the command
2859 * @direct: direct flag
2860 * @verb: the verb to send
2861 * @parm: the parameter for the verb
2863 * Send a single command without waiting for response.
2865 * Returns 0 if successful, or a negative error code.
2867 int snd_hda_codec_write_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2868 int direct
, unsigned int verb
, unsigned int parm
)
2870 int err
= snd_hda_codec_write(codec
, nid
, direct
, verb
, parm
);
2871 struct hda_cache_head
*c
;
2876 /* parm may contain the verb stuff for get/set amp */
2877 verb
= verb
| (parm
>> 8);
2879 key
= build_cmd_cache_key(nid
, verb
);
2880 mutex_lock(&codec
->bus
->cmd_mutex
);
2881 c
= get_alloc_hash(&codec
->cmd_cache
, key
);
2884 mutex_unlock(&codec
->bus
->cmd_mutex
);
2887 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache
);
2890 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
2891 * @codec: the HDA codec
2892 * @nid: NID to send the command
2893 * @direct: direct flag
2894 * @verb: the verb to send
2895 * @parm: the parameter for the verb
2897 * This function works like snd_hda_codec_write_cache(), but it doesn't send
2898 * command if the parameter is already identical with the cached value.
2899 * If not, it sends the command and refreshes the cache.
2901 * Returns 0 if successful, or a negative error code.
2903 int snd_hda_codec_update_cache(struct hda_codec
*codec
, hda_nid_t nid
,
2904 int direct
, unsigned int verb
, unsigned int parm
)
2906 struct hda_cache_head
*c
;
2909 /* parm may contain the verb stuff for get/set amp */
2910 verb
= verb
| (parm
>> 8);
2912 key
= build_cmd_cache_key(nid
, verb
);
2913 mutex_lock(&codec
->bus
->cmd_mutex
);
2914 c
= get_hash(&codec
->cmd_cache
, key
);
2915 if (c
&& c
->val
== parm
) {
2916 mutex_unlock(&codec
->bus
->cmd_mutex
);
2919 mutex_unlock(&codec
->bus
->cmd_mutex
);
2920 return snd_hda_codec_write_cache(codec
, nid
, direct
, verb
, parm
);
2922 EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache
);
2925 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2926 * @codec: HD-audio codec
2928 * Execute all verbs recorded in the command caches to resume.
2930 void snd_hda_codec_resume_cache(struct hda_codec
*codec
)
2932 struct hda_cache_head
*buffer
= codec
->cmd_cache
.buf
.list
;
2935 for (i
= 0; i
< codec
->cmd_cache
.buf
.used
; i
++, buffer
++) {
2936 u32 key
= buffer
->key
;
2939 snd_hda_codec_write(codec
, get_cmd_cache_nid(key
), 0,
2940 get_cmd_cache_cmd(key
), buffer
->val
);
2943 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache
);
2946 * snd_hda_sequence_write_cache - sequence writes with caching
2947 * @codec: the HDA codec
2948 * @seq: VERB array to send
2950 * Send the commands sequentially from the given array.
2951 * Thte commands are recorded on cache for power-save and resume.
2952 * The array must be terminated with NID=0.
2954 void snd_hda_sequence_write_cache(struct hda_codec
*codec
,
2955 const struct hda_verb
*seq
)
2957 for (; seq
->nid
; seq
++)
2958 snd_hda_codec_write_cache(codec
, seq
->nid
, 0, seq
->verb
,
2961 EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache
);
2962 #endif /* SND_HDA_NEEDS_RESUME */
2965 * set power state of the codec
2967 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
2968 unsigned int power_state
)
2973 /* this delay seems necessary to avoid click noise at power-down */
2974 if (power_state
== AC_PWRST_D3
)
2976 snd_hda_codec_read(codec
, fg
, 0, AC_VERB_SET_POWER_STATE
,
2978 /* partial workaround for "azx_get_response timeout" */
2979 if (power_state
== AC_PWRST_D0
&&
2980 (codec
->vendor_id
& 0xffff0000) == 0x14f10000)
2983 nid
= codec
->start_nid
;
2984 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2985 unsigned int wcaps
= get_wcaps(codec
, nid
);
2986 if (wcaps
& AC_WCAP_POWER
) {
2987 unsigned int wid_type
= get_wcaps_type(wcaps
);
2988 if (power_state
== AC_PWRST_D3
&&
2989 wid_type
== AC_WID_PIN
) {
2990 unsigned int pincap
;
2992 * don't power down the widget if it controls
2993 * eapd and EAPD_BTLENABLE is set.
2995 pincap
= snd_hda_query_pin_caps(codec
, nid
);
2996 if (pincap
& AC_PINCAP_EAPD
) {
2997 int eapd
= snd_hda_codec_read(codec
,
2999 AC_VERB_GET_EAPD_BTLENABLE
, 0);
3005 snd_hda_codec_write(codec
, nid
, 0,
3006 AC_VERB_SET_POWER_STATE
,
3011 if (power_state
== AC_PWRST_D0
) {
3012 unsigned long end_time
;
3014 /* wait until the codec reachs to D0 */
3015 end_time
= jiffies
+ msecs_to_jiffies(500);
3017 state
= snd_hda_codec_read(codec
, fg
, 0,
3018 AC_VERB_GET_POWER_STATE
, 0);
3019 if (state
== power_state
)
3022 } while (time_after_eq(end_time
, jiffies
));
3026 #ifdef CONFIG_SND_HDA_HWDEP
3027 /* execute additional init verbs */
3028 static void hda_exec_init_verbs(struct hda_codec
*codec
)
3030 if (codec
->init_verbs
.list
)
3031 snd_hda_sequence_write(codec
, codec
->init_verbs
.list
);
3034 static inline void hda_exec_init_verbs(struct hda_codec
*codec
) {}
3037 #ifdef SND_HDA_NEEDS_RESUME
3039 * call suspend and power-down; used both from PM and power-save
3041 static void hda_call_codec_suspend(struct hda_codec
*codec
)
3043 if (codec
->patch_ops
.suspend
)
3044 codec
->patch_ops
.suspend(codec
, PMSG_SUSPEND
);
3045 hda_cleanup_all_streams(codec
);
3046 hda_set_power_state(codec
,
3047 codec
->afg
? codec
->afg
: codec
->mfg
,
3049 #ifdef CONFIG_SND_HDA_POWER_SAVE
3050 snd_hda_update_power_acct(codec
);
3051 cancel_delayed_work(&codec
->power_work
);
3052 codec
->power_on
= 0;
3053 codec
->power_transition
= 0;
3054 codec
->power_jiffies
= jiffies
;
3059 * kick up codec; used both from PM and power-save
3061 static void hda_call_codec_resume(struct hda_codec
*codec
)
3063 hda_set_power_state(codec
,
3064 codec
->afg
? codec
->afg
: codec
->mfg
,
3066 restore_pincfgs(codec
); /* restore all current pin configs */
3067 restore_shutup_pins(codec
);
3068 hda_exec_init_verbs(codec
);
3069 if (codec
->patch_ops
.resume
)
3070 codec
->patch_ops
.resume(codec
);
3072 if (codec
->patch_ops
.init
)
3073 codec
->patch_ops
.init(codec
);
3074 snd_hda_codec_resume_amp(codec
);
3075 snd_hda_codec_resume_cache(codec
);
3078 #endif /* SND_HDA_NEEDS_RESUME */
3082 * snd_hda_build_controls - build mixer controls
3085 * Creates mixer controls for each codec included in the bus.
3087 * Returns 0 if successful, otherwise a negative error code.
3089 int /*__devinit*/ snd_hda_build_controls(struct hda_bus
*bus
)
3091 struct hda_codec
*codec
;
3093 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3094 int err
= snd_hda_codec_build_controls(codec
);
3096 printk(KERN_ERR
"hda_codec: cannot build controls "
3097 "for #%d (error %d)\n", codec
->addr
, err
);
3098 err
= snd_hda_codec_reset(codec
);
3101 "hda_codec: cannot revert codec\n");
3108 EXPORT_SYMBOL_HDA(snd_hda_build_controls
);
3110 int snd_hda_codec_build_controls(struct hda_codec
*codec
)
3113 hda_exec_init_verbs(codec
);
3114 /* continue to initialize... */
3115 if (codec
->patch_ops
.init
)
3116 err
= codec
->patch_ops
.init(codec
);
3117 if (!err
&& codec
->patch_ops
.build_controls
)
3118 err
= codec
->patch_ops
.build_controls(codec
);
3127 struct hda_rate_tbl
{
3129 unsigned int alsa_bits
;
3130 unsigned int hda_fmt
;
3133 /* rate = base * mult / div */
3134 #define HDA_RATE(base, mult, div) \
3135 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3136 (((div) - 1) << AC_FMT_DIV_SHIFT))
3138 static struct hda_rate_tbl rate_bits
[] = {
3139 /* rate in Hz, ALSA rate bitmask, HDA format value */
3141 /* autodetected value used in snd_hda_query_supported_pcm */
3142 { 8000, SNDRV_PCM_RATE_8000
, HDA_RATE(48, 1, 6) },
3143 { 11025, SNDRV_PCM_RATE_11025
, HDA_RATE(44, 1, 4) },
3144 { 16000, SNDRV_PCM_RATE_16000
, HDA_RATE(48, 1, 3) },
3145 { 22050, SNDRV_PCM_RATE_22050
, HDA_RATE(44, 1, 2) },
3146 { 32000, SNDRV_PCM_RATE_32000
, HDA_RATE(48, 2, 3) },
3147 { 44100, SNDRV_PCM_RATE_44100
, HDA_RATE(44, 1, 1) },
3148 { 48000, SNDRV_PCM_RATE_48000
, HDA_RATE(48, 1, 1) },
3149 { 88200, SNDRV_PCM_RATE_88200
, HDA_RATE(44, 2, 1) },
3150 { 96000, SNDRV_PCM_RATE_96000
, HDA_RATE(48, 2, 1) },
3151 { 176400, SNDRV_PCM_RATE_176400
, HDA_RATE(44, 4, 1) },
3152 { 192000, SNDRV_PCM_RATE_192000
, HDA_RATE(48, 4, 1) },
3153 #define AC_PAR_PCM_RATE_BITS 11
3154 /* up to bits 10, 384kHZ isn't supported properly */
3156 /* not autodetected value */
3157 { 9600, SNDRV_PCM_RATE_KNOT
, HDA_RATE(48, 1, 5) },
3159 { 0 } /* terminator */
3163 * snd_hda_calc_stream_format - calculate format bitset
3164 * @rate: the sample rate
3165 * @channels: the number of channels
3166 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3167 * @maxbps: the max. bps
3169 * Calculate the format bitset from the given rate, channels and th PCM format.
3171 * Return zero if invalid.
3173 unsigned int snd_hda_calc_stream_format(unsigned int rate
,
3174 unsigned int channels
,
3175 unsigned int format
,
3176 unsigned int maxbps
,
3177 unsigned short spdif_ctls
)
3180 unsigned int val
= 0;
3182 for (i
= 0; rate_bits
[i
].hz
; i
++)
3183 if (rate_bits
[i
].hz
== rate
) {
3184 val
= rate_bits
[i
].hda_fmt
;
3187 if (!rate_bits
[i
].hz
) {
3188 snd_printdd("invalid rate %d\n", rate
);
3192 if (channels
== 0 || channels
> 8) {
3193 snd_printdd("invalid channels %d\n", channels
);
3196 val
|= channels
- 1;
3198 switch (snd_pcm_format_width(format
)) {
3200 val
|= AC_FMT_BITS_8
;
3203 val
|= AC_FMT_BITS_16
;
3208 if (maxbps
>= 32 || format
== SNDRV_PCM_FORMAT_FLOAT_LE
)
3209 val
|= AC_FMT_BITS_32
;
3210 else if (maxbps
>= 24)
3211 val
|= AC_FMT_BITS_24
;
3213 val
|= AC_FMT_BITS_20
;
3216 snd_printdd("invalid format width %d\n",
3217 snd_pcm_format_width(format
));
3221 if (spdif_ctls
& AC_DIG1_NONAUDIO
)
3222 val
|= AC_FMT_TYPE_NON_PCM
;
3226 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format
);
3228 static unsigned int get_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3230 unsigned int val
= 0;
3231 if (nid
!= codec
->afg
&&
3232 (get_wcaps(codec
, nid
) & AC_WCAP_FORMAT_OVRD
))
3233 val
= snd_hda_param_read(codec
, nid
, AC_PAR_PCM
);
3234 if (!val
|| val
== -1)
3235 val
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_PCM
);
3236 if (!val
|| val
== -1)
3241 static unsigned int query_pcm_param(struct hda_codec
*codec
, hda_nid_t nid
)
3243 return query_caps_hash(codec
, nid
, HDA_HASH_PARPCM_KEY(nid
),
3247 static unsigned int get_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3249 unsigned int streams
= snd_hda_param_read(codec
, nid
, AC_PAR_STREAM
);
3250 if (!streams
|| streams
== -1)
3251 streams
= snd_hda_param_read(codec
, codec
->afg
, AC_PAR_STREAM
);
3252 if (!streams
|| streams
== -1)
3257 static unsigned int query_stream_param(struct hda_codec
*codec
, hda_nid_t nid
)
3259 return query_caps_hash(codec
, nid
, HDA_HASH_PARSTR_KEY(nid
),
3264 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3265 * @codec: the HDA codec
3266 * @nid: NID to query
3267 * @ratesp: the pointer to store the detected rate bitflags
3268 * @formatsp: the pointer to store the detected formats
3269 * @bpsp: the pointer to store the detected format widths
3271 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3272 * or @bsps argument is ignored.
3274 * Returns 0 if successful, otherwise a negative error code.
3276 static int snd_hda_query_supported_pcm(struct hda_codec
*codec
, hda_nid_t nid
,
3277 u32
*ratesp
, u64
*formatsp
, unsigned int *bpsp
)
3279 unsigned int i
, val
, wcaps
;
3281 wcaps
= get_wcaps(codec
, nid
);
3282 val
= query_pcm_param(codec
, nid
);
3286 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++) {
3288 rates
|= rate_bits
[i
].alsa_bits
;
3291 snd_printk(KERN_ERR
"hda_codec: rates == 0 "
3292 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3294 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0);
3300 if (formatsp
|| bpsp
) {
3302 unsigned int streams
, bps
;
3304 streams
= query_stream_param(codec
, nid
);
3309 if (streams
& AC_SUPFMT_PCM
) {
3310 if (val
& AC_SUPPCM_BITS_8
) {
3311 formats
|= SNDRV_PCM_FMTBIT_U8
;
3314 if (val
& AC_SUPPCM_BITS_16
) {
3315 formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
3318 if (wcaps
& AC_WCAP_DIGITAL
) {
3319 if (val
& AC_SUPPCM_BITS_32
)
3320 formats
|= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
;
3321 if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
))
3322 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3323 if (val
& AC_SUPPCM_BITS_24
)
3325 else if (val
& AC_SUPPCM_BITS_20
)
3327 } else if (val
& (AC_SUPPCM_BITS_20
|AC_SUPPCM_BITS_24
|
3328 AC_SUPPCM_BITS_32
)) {
3329 formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
3330 if (val
& AC_SUPPCM_BITS_32
)
3332 else if (val
& AC_SUPPCM_BITS_24
)
3334 else if (val
& AC_SUPPCM_BITS_20
)
3338 if (streams
& AC_SUPFMT_FLOAT32
) {
3339 formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
3343 if (streams
== AC_SUPFMT_AC3
) {
3344 /* should be exclusive */
3345 /* temporary hack: we have still no proper support
3346 * for the direct AC3 stream...
3348 formats
|= SNDRV_PCM_FMTBIT_U8
;
3352 snd_printk(KERN_ERR
"hda_codec: formats == 0 "
3353 "(nid=0x%x, val=0x%x, ovrd=%i, "
3356 (wcaps
& AC_WCAP_FORMAT_OVRD
) ? 1 : 0,
3361 *formatsp
= formats
;
3370 * snd_hda_is_supported_format - Check the validity of the format
3371 * @codec: HD-audio codec
3372 * @nid: NID to check
3373 * @format: the HD-audio format value to check
3375 * Check whether the given node supports the format value.
3377 * Returns 1 if supported, 0 if not.
3379 int snd_hda_is_supported_format(struct hda_codec
*codec
, hda_nid_t nid
,
3380 unsigned int format
)
3383 unsigned int val
= 0, rate
, stream
;
3385 val
= query_pcm_param(codec
, nid
);
3389 rate
= format
& 0xff00;
3390 for (i
= 0; i
< AC_PAR_PCM_RATE_BITS
; i
++)
3391 if (rate_bits
[i
].hda_fmt
== rate
) {
3396 if (i
>= AC_PAR_PCM_RATE_BITS
)
3399 stream
= query_stream_param(codec
, nid
);
3403 if (stream
& AC_SUPFMT_PCM
) {
3404 switch (format
& 0xf0) {
3406 if (!(val
& AC_SUPPCM_BITS_8
))
3410 if (!(val
& AC_SUPPCM_BITS_16
))
3414 if (!(val
& AC_SUPPCM_BITS_20
))
3418 if (!(val
& AC_SUPPCM_BITS_24
))
3422 if (!(val
& AC_SUPPCM_BITS_32
))
3429 /* FIXME: check for float32 and AC3? */
3434 EXPORT_SYMBOL_HDA(snd_hda_is_supported_format
);
3439 static int hda_pcm_default_open_close(struct hda_pcm_stream
*hinfo
,
3440 struct hda_codec
*codec
,
3441 struct snd_pcm_substream
*substream
)
3446 static int hda_pcm_default_prepare(struct hda_pcm_stream
*hinfo
,
3447 struct hda_codec
*codec
,
3448 unsigned int stream_tag
,
3449 unsigned int format
,
3450 struct snd_pcm_substream
*substream
)
3452 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
3456 static int hda_pcm_default_cleanup(struct hda_pcm_stream
*hinfo
,
3457 struct hda_codec
*codec
,
3458 struct snd_pcm_substream
*substream
)
3460 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
3464 static int set_pcm_default_values(struct hda_codec
*codec
,
3465 struct hda_pcm_stream
*info
)
3469 /* query support PCM information from the given NID */
3470 if (info
->nid
&& (!info
->rates
|| !info
->formats
)) {
3471 err
= snd_hda_query_supported_pcm(codec
, info
->nid
,
3472 info
->rates
? NULL
: &info
->rates
,
3473 info
->formats
? NULL
: &info
->formats
,
3474 info
->maxbps
? NULL
: &info
->maxbps
);
3478 if (info
->ops
.open
== NULL
)
3479 info
->ops
.open
= hda_pcm_default_open_close
;
3480 if (info
->ops
.close
== NULL
)
3481 info
->ops
.close
= hda_pcm_default_open_close
;
3482 if (info
->ops
.prepare
== NULL
) {
3483 if (snd_BUG_ON(!info
->nid
))
3485 info
->ops
.prepare
= hda_pcm_default_prepare
;
3487 if (info
->ops
.cleanup
== NULL
) {
3488 if (snd_BUG_ON(!info
->nid
))
3490 info
->ops
.cleanup
= hda_pcm_default_cleanup
;
3496 * codec prepare/cleanup entries
3498 int snd_hda_codec_prepare(struct hda_codec
*codec
,
3499 struct hda_pcm_stream
*hinfo
,
3500 unsigned int stream
,
3501 unsigned int format
,
3502 struct snd_pcm_substream
*substream
)
3505 mutex_lock(&codec
->prepare_mutex
);
3506 ret
= hinfo
->ops
.prepare(hinfo
, codec
, stream
, format
, substream
);
3508 purify_inactive_streams(codec
);
3509 mutex_unlock(&codec
->prepare_mutex
);
3512 EXPORT_SYMBOL_HDA(snd_hda_codec_prepare
);
3514 void snd_hda_codec_cleanup(struct hda_codec
*codec
,
3515 struct hda_pcm_stream
*hinfo
,
3516 struct snd_pcm_substream
*substream
)
3518 mutex_lock(&codec
->prepare_mutex
);
3519 hinfo
->ops
.cleanup(hinfo
, codec
, substream
);
3520 mutex_unlock(&codec
->prepare_mutex
);
3522 EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup
);
3525 const char *snd_hda_pcm_type_name
[HDA_PCM_NTYPES
] = {
3526 "Audio", "SPDIF", "HDMI", "Modem"
3530 * get the empty PCM device number to assign
3532 * note the max device number is limited by HDA_MAX_PCMS, currently 10
3534 static int get_empty_pcm_device(struct hda_bus
*bus
, int type
)
3536 /* audio device indices; not linear to keep compatibility */
3537 static int audio_idx
[HDA_PCM_NTYPES
][5] = {
3538 [HDA_PCM_TYPE_AUDIO
] = { 0, 2, 4, 5, -1 },
3539 [HDA_PCM_TYPE_SPDIF
] = { 1, -1 },
3540 [HDA_PCM_TYPE_HDMI
] = { 3, 7, 8, 9, -1 },
3541 [HDA_PCM_TYPE_MODEM
] = { 6, -1 },
3545 if (type
>= HDA_PCM_NTYPES
) {
3546 snd_printk(KERN_WARNING
"Invalid PCM type %d\n", type
);
3550 for (i
= 0; audio_idx
[type
][i
] >= 0 ; i
++)
3551 if (!test_and_set_bit(audio_idx
[type
][i
], bus
->pcm_dev_bits
))
3552 return audio_idx
[type
][i
];
3554 snd_printk(KERN_WARNING
"Too many %s devices\n",
3555 snd_hda_pcm_type_name
[type
]);
3560 * attach a new PCM stream
3562 static int snd_hda_attach_pcm(struct hda_codec
*codec
, struct hda_pcm
*pcm
)
3564 struct hda_bus
*bus
= codec
->bus
;
3565 struct hda_pcm_stream
*info
;
3568 if (snd_BUG_ON(!pcm
->name
))
3570 for (stream
= 0; stream
< 2; stream
++) {
3571 info
= &pcm
->stream
[stream
];
3572 if (info
->substreams
) {
3573 err
= set_pcm_default_values(codec
, info
);
3578 return bus
->ops
.attach_pcm(bus
, codec
, pcm
);
3581 /* assign all PCMs of the given codec */
3582 int snd_hda_codec_build_pcms(struct hda_codec
*codec
)
3587 if (!codec
->num_pcms
) {
3588 if (!codec
->patch_ops
.build_pcms
)
3590 err
= codec
->patch_ops
.build_pcms(codec
);
3592 printk(KERN_ERR
"hda_codec: cannot build PCMs"
3593 "for #%d (error %d)\n", codec
->addr
, err
);
3594 err
= snd_hda_codec_reset(codec
);
3597 "hda_codec: cannot revert codec\n");
3602 for (pcm
= 0; pcm
< codec
->num_pcms
; pcm
++) {
3603 struct hda_pcm
*cpcm
= &codec
->pcm_info
[pcm
];
3606 if (!cpcm
->stream
[0].substreams
&& !cpcm
->stream
[1].substreams
)
3607 continue; /* no substreams assigned */
3610 dev
= get_empty_pcm_device(codec
->bus
, cpcm
->pcm_type
);
3612 continue; /* no fatal error */
3614 err
= snd_hda_attach_pcm(codec
, cpcm
);
3616 printk(KERN_ERR
"hda_codec: cannot attach "
3617 "PCM stream %d for codec #%d\n",
3619 continue; /* no fatal error */
3627 * snd_hda_build_pcms - build PCM information
3630 * Create PCM information for each codec included in the bus.
3632 * The build_pcms codec patch is requested to set up codec->num_pcms and
3633 * codec->pcm_info properly. The array is referred by the top-level driver
3634 * to create its PCM instances.
3635 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3638 * At least, substreams, channels_min and channels_max must be filled for
3639 * each stream. substreams = 0 indicates that the stream doesn't exist.
3640 * When rates and/or formats are zero, the supported values are queried
3641 * from the given nid. The nid is used also by the default ops.prepare
3642 * and ops.cleanup callbacks.
3644 * The driver needs to call ops.open in its open callback. Similarly,
3645 * ops.close is supposed to be called in the close callback.
3646 * ops.prepare should be called in the prepare or hw_params callback
3647 * with the proper parameters for set up.
3648 * ops.cleanup should be called in hw_free for clean up of streams.
3650 * This function returns 0 if successfull, or a negative error code.
3652 int __devinit
snd_hda_build_pcms(struct hda_bus
*bus
)
3654 struct hda_codec
*codec
;
3656 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
3657 int err
= snd_hda_codec_build_pcms(codec
);
3663 EXPORT_SYMBOL_HDA(snd_hda_build_pcms
);
3666 * snd_hda_check_board_config - compare the current codec with the config table
3667 * @codec: the HDA codec
3668 * @num_configs: number of config enums
3669 * @models: array of model name strings
3670 * @tbl: configuration table, terminated by null entries
3672 * Compares the modelname or PCI subsystem id of the current codec with the
3673 * given configuration table. If a matching entry is found, returns its
3674 * config value (supposed to be 0 or positive).
3676 * If no entries are matching, the function returns a negative value.
3678 int snd_hda_check_board_config(struct hda_codec
*codec
,
3679 int num_configs
, const char **models
,
3680 const struct snd_pci_quirk
*tbl
)
3682 if (codec
->modelname
&& models
) {
3684 for (i
= 0; i
< num_configs
; i
++) {
3686 !strcmp(codec
->modelname
, models
[i
])) {
3687 snd_printd(KERN_INFO
"hda_codec: model '%s' is "
3688 "selected\n", models
[i
]);
3694 if (!codec
->bus
->pci
|| !tbl
)
3697 tbl
= snd_pci_quirk_lookup(codec
->bus
->pci
, tbl
);
3700 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3701 #ifdef CONFIG_SND_DEBUG_VERBOSE
3703 const char *model
= NULL
;
3705 model
= models
[tbl
->value
];
3707 sprintf(tmp
, "#%d", tbl
->value
);
3710 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3711 "for config %x:%x (%s)\n",
3712 model
, tbl
->subvendor
, tbl
->subdevice
,
3713 (tbl
->name
? tbl
->name
: "Unknown device"));
3719 EXPORT_SYMBOL_HDA(snd_hda_check_board_config
);
3722 * snd_hda_check_board_codec_sid_config - compare the current codec
3723 subsystem ID with the
3726 This is important for Gateway notebooks with SB450 HDA Audio
3727 where the vendor ID of the PCI device is:
3728 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3729 and the vendor/subvendor are found only at the codec.
3731 * @codec: the HDA codec
3732 * @num_configs: number of config enums
3733 * @models: array of model name strings
3734 * @tbl: configuration table, terminated by null entries
3736 * Compares the modelname or PCI subsystem id of the current codec with the
3737 * given configuration table. If a matching entry is found, returns its
3738 * config value (supposed to be 0 or positive).
3740 * If no entries are matching, the function returns a negative value.
3742 int snd_hda_check_board_codec_sid_config(struct hda_codec
*codec
,
3743 int num_configs
, const char **models
,
3744 const struct snd_pci_quirk
*tbl
)
3746 const struct snd_pci_quirk
*q
;
3748 /* Search for codec ID */
3749 for (q
= tbl
; q
->subvendor
; q
++) {
3750 unsigned long vendorid
= (q
->subdevice
) | (q
->subvendor
<< 16);
3752 if (vendorid
== codec
->subsystem_id
)
3761 if (tbl
->value
>= 0 && tbl
->value
< num_configs
) {
3762 #ifdef CONFIG_SND_DEBUG_VERBOSE
3764 const char *model
= NULL
;
3766 model
= models
[tbl
->value
];
3768 sprintf(tmp
, "#%d", tbl
->value
);
3771 snd_printdd(KERN_INFO
"hda_codec: model '%s' is selected "
3772 "for config %x:%x (%s)\n",
3773 model
, tbl
->subvendor
, tbl
->subdevice
,
3774 (tbl
->name
? tbl
->name
: "Unknown device"));
3780 EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config
);
3783 * snd_hda_add_new_ctls - create controls from the array
3784 * @codec: the HDA codec
3785 * @knew: the array of struct snd_kcontrol_new
3787 * This helper function creates and add new controls in the given array.
3788 * The array must be terminated with an empty entry as terminator.
3790 * Returns 0 if successful, or a negative error code.
3792 int snd_hda_add_new_ctls(struct hda_codec
*codec
, struct snd_kcontrol_new
*knew
)
3796 for (; knew
->name
; knew
++) {
3797 struct snd_kcontrol
*kctl
;
3798 if (knew
->iface
== -1) /* skip this codec private value */
3800 kctl
= snd_ctl_new1(knew
, codec
);
3803 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3807 kctl
= snd_ctl_new1(knew
, codec
);
3810 kctl
->id
.device
= codec
->addr
;
3811 err
= snd_hda_ctl_add(codec
, 0, kctl
);
3818 EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls
);
3820 #ifdef CONFIG_SND_HDA_POWER_SAVE
3821 static void hda_set_power_state(struct hda_codec
*codec
, hda_nid_t fg
,
3822 unsigned int power_state
);
3824 static void hda_power_work(struct work_struct
*work
)
3826 struct hda_codec
*codec
=
3827 container_of(work
, struct hda_codec
, power_work
.work
);
3828 struct hda_bus
*bus
= codec
->bus
;
3830 if (!codec
->power_on
|| codec
->power_count
) {
3831 codec
->power_transition
= 0;
3835 hda_call_codec_suspend(codec
);
3836 if (bus
->ops
.pm_notify
)
3837 bus
->ops
.pm_notify(bus
);
3840 static void hda_keep_power_on(struct hda_codec
*codec
)
3842 codec
->power_count
++;
3843 codec
->power_on
= 1;
3844 codec
->power_jiffies
= jiffies
;
3847 /* update the power on/off account with the current jiffies */
3848 void snd_hda_update_power_acct(struct hda_codec
*codec
)
3850 unsigned long delta
= jiffies
- codec
->power_jiffies
;
3851 if (codec
->power_on
)
3852 codec
->power_on_acct
+= delta
;
3854 codec
->power_off_acct
+= delta
;
3855 codec
->power_jiffies
+= delta
;
3859 * snd_hda_power_up - Power-up the codec
3860 * @codec: HD-audio codec
3862 * Increment the power-up counter and power up the hardware really when
3863 * not turned on yet.
3865 void snd_hda_power_up(struct hda_codec
*codec
)
3867 struct hda_bus
*bus
= codec
->bus
;
3869 codec
->power_count
++;
3870 if (codec
->power_on
|| codec
->power_transition
)
3873 snd_hda_update_power_acct(codec
);
3874 codec
->power_on
= 1;
3875 codec
->power_jiffies
= jiffies
;
3876 if (bus
->ops
.pm_notify
)
3877 bus
->ops
.pm_notify(bus
);
3878 hda_call_codec_resume(codec
);
3879 cancel_delayed_work(&codec
->power_work
);
3880 codec
->power_transition
= 0;
3882 EXPORT_SYMBOL_HDA(snd_hda_power_up
);
3884 #define power_save(codec) \
3885 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3888 * snd_hda_power_down - Power-down the codec
3889 * @codec: HD-audio codec
3891 * Decrement the power-up counter and schedules the power-off work if
3892 * the counter rearches to zero.
3894 void snd_hda_power_down(struct hda_codec
*codec
)
3896 --codec
->power_count
;
3897 if (!codec
->power_on
|| codec
->power_count
|| codec
->power_transition
)
3899 if (power_save(codec
)) {
3900 codec
->power_transition
= 1; /* avoid reentrance */
3901 queue_delayed_work(codec
->bus
->workq
, &codec
->power_work
,
3902 msecs_to_jiffies(power_save(codec
) * 1000));
3905 EXPORT_SYMBOL_HDA(snd_hda_power_down
);
3908 * snd_hda_check_amp_list_power - Check the amp list and update the power
3909 * @codec: HD-audio codec
3910 * @check: the object containing an AMP list and the status
3911 * @nid: NID to check / update
3913 * Check whether the given NID is in the amp list. If it's in the list,
3914 * check the current AMP status, and update the the power-status according
3915 * to the mute status.
3917 * This function is supposed to be set or called from the check_power_status
3920 int snd_hda_check_amp_list_power(struct hda_codec
*codec
,
3921 struct hda_loopback_check
*check
,
3924 struct hda_amp_list
*p
;
3927 if (!check
->amplist
)
3929 for (p
= check
->amplist
; p
->nid
; p
++) {
3934 return 0; /* nothing changed */
3936 for (p
= check
->amplist
; p
->nid
; p
++) {
3937 for (ch
= 0; ch
< 2; ch
++) {
3938 v
= snd_hda_codec_amp_read(codec
, p
->nid
, ch
, p
->dir
,
3940 if (!(v
& HDA_AMP_MUTE
) && v
> 0) {
3941 if (!check
->power_on
) {
3942 check
->power_on
= 1;
3943 snd_hda_power_up(codec
);
3949 if (check
->power_on
) {
3950 check
->power_on
= 0;
3951 snd_hda_power_down(codec
);
3955 EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power
);
3959 * Channel mode helper
3963 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3965 int snd_hda_ch_mode_info(struct hda_codec
*codec
,
3966 struct snd_ctl_elem_info
*uinfo
,
3967 const struct hda_channel_mode
*chmode
,
3970 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3972 uinfo
->value
.enumerated
.items
= num_chmodes
;
3973 if (uinfo
->value
.enumerated
.item
>= num_chmodes
)
3974 uinfo
->value
.enumerated
.item
= num_chmodes
- 1;
3975 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
3976 chmode
[uinfo
->value
.enumerated
.item
].channels
);
3979 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info
);
3982 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3984 int snd_hda_ch_mode_get(struct hda_codec
*codec
,
3985 struct snd_ctl_elem_value
*ucontrol
,
3986 const struct hda_channel_mode
*chmode
,
3992 for (i
= 0; i
< num_chmodes
; i
++) {
3993 if (max_channels
== chmode
[i
].channels
) {
3994 ucontrol
->value
.enumerated
.item
[0] = i
;
4000 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get
);
4003 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4005 int snd_hda_ch_mode_put(struct hda_codec
*codec
,
4006 struct snd_ctl_elem_value
*ucontrol
,
4007 const struct hda_channel_mode
*chmode
,
4013 mode
= ucontrol
->value
.enumerated
.item
[0];
4014 if (mode
>= num_chmodes
)
4016 if (*max_channelsp
== chmode
[mode
].channels
)
4018 /* change the current channel setting */
4019 *max_channelsp
= chmode
[mode
].channels
;
4020 if (chmode
[mode
].sequence
)
4021 snd_hda_sequence_write_cache(codec
, chmode
[mode
].sequence
);
4024 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put
);
4031 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4033 int snd_hda_input_mux_info(const struct hda_input_mux
*imux
,
4034 struct snd_ctl_elem_info
*uinfo
)
4038 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
4040 uinfo
->value
.enumerated
.items
= imux
->num_items
;
4041 if (!imux
->num_items
)
4043 index
= uinfo
->value
.enumerated
.item
;
4044 if (index
>= imux
->num_items
)
4045 index
= imux
->num_items
- 1;
4046 strcpy(uinfo
->value
.enumerated
.name
, imux
->items
[index
].label
);
4049 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info
);
4052 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4054 int snd_hda_input_mux_put(struct hda_codec
*codec
,
4055 const struct hda_input_mux
*imux
,
4056 struct snd_ctl_elem_value
*ucontrol
,
4058 unsigned int *cur_val
)
4062 if (!imux
->num_items
)
4064 idx
= ucontrol
->value
.enumerated
.item
[0];
4065 if (idx
>= imux
->num_items
)
4066 idx
= imux
->num_items
- 1;
4067 if (*cur_val
== idx
)
4069 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
,
4070 imux
->items
[idx
].index
);
4074 EXPORT_SYMBOL_HDA(snd_hda_input_mux_put
);
4078 * Multi-channel / digital-out PCM helper functions
4081 /* setup SPDIF output stream */
4082 static void setup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
,
4083 unsigned int stream_tag
, unsigned int format
)
4085 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
4086 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
4087 set_dig_out_convert(codec
, nid
,
4088 codec
->spdif_ctls
& ~AC_DIG1_ENABLE
& 0xff,
4090 snd_hda_codec_setup_stream(codec
, nid
, stream_tag
, 0, format
);
4091 if (codec
->slave_dig_outs
) {
4093 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4094 snd_hda_codec_setup_stream(codec
, *d
, stream_tag
, 0,
4097 /* turn on again (if needed) */
4098 if (codec
->spdif_status_reset
&& (codec
->spdif_ctls
& AC_DIG1_ENABLE
))
4099 set_dig_out_convert(codec
, nid
,
4100 codec
->spdif_ctls
& 0xff, -1);
4103 static void cleanup_dig_out_stream(struct hda_codec
*codec
, hda_nid_t nid
)
4105 snd_hda_codec_cleanup_stream(codec
, nid
);
4106 if (codec
->slave_dig_outs
) {
4108 for (d
= codec
->slave_dig_outs
; *d
; d
++)
4109 snd_hda_codec_cleanup_stream(codec
, *d
);
4114 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4115 * @bus: HD-audio bus
4117 void snd_hda_bus_reboot_notify(struct hda_bus
*bus
)
4119 struct hda_codec
*codec
;
4123 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4124 #ifdef CONFIG_SND_HDA_POWER_SAVE
4125 if (!codec
->power_on
)
4128 if (codec
->patch_ops
.reboot_notify
)
4129 codec
->patch_ops
.reboot_notify(codec
);
4132 EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify
);
4135 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
4137 int snd_hda_multi_out_dig_open(struct hda_codec
*codec
,
4138 struct hda_multi_out
*mout
)
4140 mutex_lock(&codec
->spdif_mutex
);
4141 if (mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
)
4142 /* already opened as analog dup; reset it once */
4143 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4144 mout
->dig_out_used
= HDA_DIG_EXCLUSIVE
;
4145 mutex_unlock(&codec
->spdif_mutex
);
4148 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open
);
4151 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4153 int snd_hda_multi_out_dig_prepare(struct hda_codec
*codec
,
4154 struct hda_multi_out
*mout
,
4155 unsigned int stream_tag
,
4156 unsigned int format
,
4157 struct snd_pcm_substream
*substream
)
4159 mutex_lock(&codec
->spdif_mutex
);
4160 setup_dig_out_stream(codec
, mout
->dig_out_nid
, stream_tag
, format
);
4161 mutex_unlock(&codec
->spdif_mutex
);
4164 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare
);
4167 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4169 int snd_hda_multi_out_dig_cleanup(struct hda_codec
*codec
,
4170 struct hda_multi_out
*mout
)
4172 mutex_lock(&codec
->spdif_mutex
);
4173 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4174 mutex_unlock(&codec
->spdif_mutex
);
4177 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup
);
4180 * snd_hda_multi_out_dig_close - release the digital out stream
4182 int snd_hda_multi_out_dig_close(struct hda_codec
*codec
,
4183 struct hda_multi_out
*mout
)
4185 mutex_lock(&codec
->spdif_mutex
);
4186 mout
->dig_out_used
= 0;
4187 mutex_unlock(&codec
->spdif_mutex
);
4190 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close
);
4193 * snd_hda_multi_out_analog_open - open analog outputs
4195 * Open analog outputs and set up the hw-constraints.
4196 * If the digital outputs can be opened as slave, open the digital
4199 int snd_hda_multi_out_analog_open(struct hda_codec
*codec
,
4200 struct hda_multi_out
*mout
,
4201 struct snd_pcm_substream
*substream
,
4202 struct hda_pcm_stream
*hinfo
)
4204 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
4205 runtime
->hw
.channels_max
= mout
->max_channels
;
4206 if (mout
->dig_out_nid
) {
4207 if (!mout
->analog_rates
) {
4208 mout
->analog_rates
= hinfo
->rates
;
4209 mout
->analog_formats
= hinfo
->formats
;
4210 mout
->analog_maxbps
= hinfo
->maxbps
;
4212 runtime
->hw
.rates
= mout
->analog_rates
;
4213 runtime
->hw
.formats
= mout
->analog_formats
;
4214 hinfo
->maxbps
= mout
->analog_maxbps
;
4216 if (!mout
->spdif_rates
) {
4217 snd_hda_query_supported_pcm(codec
, mout
->dig_out_nid
,
4219 &mout
->spdif_formats
,
4220 &mout
->spdif_maxbps
);
4222 mutex_lock(&codec
->spdif_mutex
);
4223 if (mout
->share_spdif
) {
4224 if ((runtime
->hw
.rates
& mout
->spdif_rates
) &&
4225 (runtime
->hw
.formats
& mout
->spdif_formats
)) {
4226 runtime
->hw
.rates
&= mout
->spdif_rates
;
4227 runtime
->hw
.formats
&= mout
->spdif_formats
;
4228 if (mout
->spdif_maxbps
< hinfo
->maxbps
)
4229 hinfo
->maxbps
= mout
->spdif_maxbps
;
4231 mout
->share_spdif
= 0;
4232 /* FIXME: need notify? */
4235 mutex_unlock(&codec
->spdif_mutex
);
4237 return snd_pcm_hw_constraint_step(substream
->runtime
, 0,
4238 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
4240 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open
);
4243 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4245 * Set up the i/o for analog out.
4246 * When the digital out is available, copy the front out to digital out, too.
4248 int snd_hda_multi_out_analog_prepare(struct hda_codec
*codec
,
4249 struct hda_multi_out
*mout
,
4250 unsigned int stream_tag
,
4251 unsigned int format
,
4252 struct snd_pcm_substream
*substream
)
4254 hda_nid_t
*nids
= mout
->dac_nids
;
4255 int chs
= substream
->runtime
->channels
;
4258 mutex_lock(&codec
->spdif_mutex
);
4259 if (mout
->dig_out_nid
&& mout
->share_spdif
&&
4260 mout
->dig_out_used
!= HDA_DIG_EXCLUSIVE
) {
4262 snd_hda_is_supported_format(codec
, mout
->dig_out_nid
,
4264 !(codec
->spdif_status
& IEC958_AES0_NONAUDIO
)) {
4265 mout
->dig_out_used
= HDA_DIG_ANALOG_DUP
;
4266 setup_dig_out_stream(codec
, mout
->dig_out_nid
,
4267 stream_tag
, format
);
4269 mout
->dig_out_used
= 0;
4270 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4273 mutex_unlock(&codec
->spdif_mutex
);
4276 snd_hda_codec_setup_stream(codec
, nids
[HDA_FRONT
], stream_tag
,
4278 if (!mout
->no_share_stream
&&
4279 mout
->hp_nid
&& mout
->hp_nid
!= nids
[HDA_FRONT
])
4280 /* headphone out will just decode front left/right (stereo) */
4281 snd_hda_codec_setup_stream(codec
, mout
->hp_nid
, stream_tag
,
4283 /* extra outputs copied from front */
4284 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4285 if (!mout
->no_share_stream
&& mout
->extra_out_nid
[i
])
4286 snd_hda_codec_setup_stream(codec
,
4287 mout
->extra_out_nid
[i
],
4288 stream_tag
, 0, format
);
4291 for (i
= 1; i
< mout
->num_dacs
; i
++) {
4292 if (chs
>= (i
+ 1) * 2) /* independent out */
4293 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4295 else if (!mout
->no_share_stream
) /* copy front */
4296 snd_hda_codec_setup_stream(codec
, nids
[i
], stream_tag
,
4301 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare
);
4304 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
4306 int snd_hda_multi_out_analog_cleanup(struct hda_codec
*codec
,
4307 struct hda_multi_out
*mout
)
4309 hda_nid_t
*nids
= mout
->dac_nids
;
4312 for (i
= 0; i
< mout
->num_dacs
; i
++)
4313 snd_hda_codec_cleanup_stream(codec
, nids
[i
]);
4315 snd_hda_codec_cleanup_stream(codec
, mout
->hp_nid
);
4316 for (i
= 0; i
< ARRAY_SIZE(mout
->extra_out_nid
); i
++)
4317 if (mout
->extra_out_nid
[i
])
4318 snd_hda_codec_cleanup_stream(codec
,
4319 mout
->extra_out_nid
[i
]);
4320 mutex_lock(&codec
->spdif_mutex
);
4321 if (mout
->dig_out_nid
&& mout
->dig_out_used
== HDA_DIG_ANALOG_DUP
) {
4322 cleanup_dig_out_stream(codec
, mout
->dig_out_nid
);
4323 mout
->dig_out_used
= 0;
4325 mutex_unlock(&codec
->spdif_mutex
);
4328 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup
);
4331 * Helper for automatic pin configuration
4334 static int is_in_nid_list(hda_nid_t nid
, hda_nid_t
*list
)
4336 for (; *list
; list
++)
4344 * Sort an associated group of pins according to their sequence numbers.
4346 static void sort_pins_by_sequence(hda_nid_t
*pins
, short *sequences
,
4353 for (i
= 0; i
< num_pins
; i
++) {
4354 for (j
= i
+ 1; j
< num_pins
; j
++) {
4355 if (sequences
[i
] > sequences
[j
]) {
4357 sequences
[i
] = sequences
[j
];
4369 * Parse all pin widgets and store the useful pin nids to cfg
4371 * The number of line-outs or any primary output is stored in line_outs,
4372 * and the corresponding output pins are assigned to line_out_pins[],
4373 * in the order of front, rear, CLFE, side, ...
4375 * If more extra outputs (speaker and headphone) are found, the pins are
4376 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
4377 * is detected, one of speaker of HP pins is assigned as the primary
4378 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4379 * if any analog output exists.
4381 * The analog input pins are assigned to input_pins array.
4382 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4385 int snd_hda_parse_pin_def_config(struct hda_codec
*codec
,
4386 struct auto_pin_cfg
*cfg
,
4387 hda_nid_t
*ignore_nids
)
4389 hda_nid_t nid
, end_nid
;
4390 short seq
, assoc_line_out
, assoc_speaker
;
4391 short sequences_line_out
[ARRAY_SIZE(cfg
->line_out_pins
)];
4392 short sequences_speaker
[ARRAY_SIZE(cfg
->speaker_pins
)];
4393 short sequences_hp
[ARRAY_SIZE(cfg
->hp_pins
)];
4395 memset(cfg
, 0, sizeof(*cfg
));
4397 memset(sequences_line_out
, 0, sizeof(sequences_line_out
));
4398 memset(sequences_speaker
, 0, sizeof(sequences_speaker
));
4399 memset(sequences_hp
, 0, sizeof(sequences_hp
));
4400 assoc_line_out
= assoc_speaker
= 0;
4402 end_nid
= codec
->start_nid
+ codec
->num_nodes
;
4403 for (nid
= codec
->start_nid
; nid
< end_nid
; nid
++) {
4404 unsigned int wid_caps
= get_wcaps(codec
, nid
);
4405 unsigned int wid_type
= get_wcaps_type(wid_caps
);
4406 unsigned int def_conf
;
4409 /* read all default configuration for pin complex */
4410 if (wid_type
!= AC_WID_PIN
)
4412 /* ignore the given nids (e.g. pc-beep returns error) */
4413 if (ignore_nids
&& is_in_nid_list(nid
, ignore_nids
))
4416 def_conf
= snd_hda_codec_get_pincfg(codec
, nid
);
4417 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
4419 loc
= get_defcfg_location(def_conf
);
4420 switch (get_defcfg_device(def_conf
)) {
4421 case AC_JACK_LINE_OUT
:
4422 seq
= get_defcfg_sequence(def_conf
);
4423 assoc
= get_defcfg_association(def_conf
);
4425 if (!(wid_caps
& AC_WCAP_STEREO
))
4426 if (!cfg
->mono_out_pin
)
4427 cfg
->mono_out_pin
= nid
;
4430 if (!assoc_line_out
)
4431 assoc_line_out
= assoc
;
4432 else if (assoc_line_out
!= assoc
)
4434 if (cfg
->line_outs
>= ARRAY_SIZE(cfg
->line_out_pins
))
4436 cfg
->line_out_pins
[cfg
->line_outs
] = nid
;
4437 sequences_line_out
[cfg
->line_outs
] = seq
;
4440 case AC_JACK_SPEAKER
:
4441 seq
= get_defcfg_sequence(def_conf
);
4442 assoc
= get_defcfg_association(def_conf
);
4446 assoc_speaker
= assoc
;
4447 else if (assoc_speaker
!= assoc
)
4449 if (cfg
->speaker_outs
>= ARRAY_SIZE(cfg
->speaker_pins
))
4451 cfg
->speaker_pins
[cfg
->speaker_outs
] = nid
;
4452 sequences_speaker
[cfg
->speaker_outs
] = seq
;
4453 cfg
->speaker_outs
++;
4455 case AC_JACK_HP_OUT
:
4456 seq
= get_defcfg_sequence(def_conf
);
4457 assoc
= get_defcfg_association(def_conf
);
4458 if (cfg
->hp_outs
>= ARRAY_SIZE(cfg
->hp_pins
))
4460 cfg
->hp_pins
[cfg
->hp_outs
] = nid
;
4461 sequences_hp
[cfg
->hp_outs
] = (assoc
<< 4) | seq
;
4464 case AC_JACK_MIC_IN
: {
4466 if (loc
== AC_JACK_LOC_FRONT
||
4467 (loc
& 0x30) == AC_JACK_LOC_INTERNAL
) {
4468 preferred
= AUTO_PIN_FRONT_MIC
;
4471 preferred
= AUTO_PIN_MIC
;
4472 alt
= AUTO_PIN_FRONT_MIC
;
4474 if (!cfg
->input_pins
[preferred
])
4475 cfg
->input_pins
[preferred
] = nid
;
4476 else if (!cfg
->input_pins
[alt
])
4477 cfg
->input_pins
[alt
] = nid
;
4480 case AC_JACK_LINE_IN
:
4481 if (loc
== AC_JACK_LOC_FRONT
)
4482 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = nid
;
4484 cfg
->input_pins
[AUTO_PIN_LINE
] = nid
;
4487 cfg
->input_pins
[AUTO_PIN_CD
] = nid
;
4490 cfg
->input_pins
[AUTO_PIN_AUX
] = nid
;
4492 case AC_JACK_SPDIF_OUT
:
4493 case AC_JACK_DIG_OTHER_OUT
:
4494 if (cfg
->dig_outs
>= ARRAY_SIZE(cfg
->dig_out_pins
))
4496 cfg
->dig_out_pins
[cfg
->dig_outs
] = nid
;
4497 cfg
->dig_out_type
[cfg
->dig_outs
] =
4498 (loc
== AC_JACK_LOC_HDMI
) ?
4499 HDA_PCM_TYPE_HDMI
: HDA_PCM_TYPE_SPDIF
;
4502 case AC_JACK_SPDIF_IN
:
4503 case AC_JACK_DIG_OTHER_IN
:
4504 cfg
->dig_in_pin
= nid
;
4505 if (loc
== AC_JACK_LOC_HDMI
)
4506 cfg
->dig_in_type
= HDA_PCM_TYPE_HDMI
;
4508 cfg
->dig_in_type
= HDA_PCM_TYPE_SPDIF
;
4514 * If no line-out is defined but multiple HPs are found,
4515 * some of them might be the real line-outs.
4517 if (!cfg
->line_outs
&& cfg
->hp_outs
> 1) {
4519 while (i
< cfg
->hp_outs
) {
4520 /* The real HPs should have the sequence 0x0f */
4521 if ((sequences_hp
[i
] & 0x0f) == 0x0f) {
4525 /* Move it to the line-out table */
4526 cfg
->line_out_pins
[cfg
->line_outs
] = cfg
->hp_pins
[i
];
4527 sequences_line_out
[cfg
->line_outs
] = sequences_hp
[i
];
4530 memmove(cfg
->hp_pins
+ i
, cfg
->hp_pins
+ i
+ 1,
4531 sizeof(cfg
->hp_pins
[0]) * (cfg
->hp_outs
- i
));
4532 memmove(sequences_hp
+ i
- 1, sequences_hp
+ i
,
4533 sizeof(sequences_hp
[0]) * (cfg
->hp_outs
- i
));
4537 /* sort by sequence */
4538 sort_pins_by_sequence(cfg
->line_out_pins
, sequences_line_out
,
4540 sort_pins_by_sequence(cfg
->speaker_pins
, sequences_speaker
,
4542 sort_pins_by_sequence(cfg
->hp_pins
, sequences_hp
,
4545 /* if we have only one mic, make it AUTO_PIN_MIC */
4546 if (!cfg
->input_pins
[AUTO_PIN_MIC
] &&
4547 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
]) {
4548 cfg
->input_pins
[AUTO_PIN_MIC
] =
4549 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
];
4550 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
] = 0;
4552 /* ditto for line-in */
4553 if (!cfg
->input_pins
[AUTO_PIN_LINE
] &&
4554 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
]) {
4555 cfg
->input_pins
[AUTO_PIN_LINE
] =
4556 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
];
4557 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
] = 0;
4561 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4562 * as a primary output
4564 if (!cfg
->line_outs
) {
4565 if (cfg
->speaker_outs
) {
4566 cfg
->line_outs
= cfg
->speaker_outs
;
4567 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
4568 sizeof(cfg
->speaker_pins
));
4569 cfg
->speaker_outs
= 0;
4570 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
4571 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
4572 } else if (cfg
->hp_outs
) {
4573 cfg
->line_outs
= cfg
->hp_outs
;
4574 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
4575 sizeof(cfg
->hp_pins
));
4577 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4578 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4582 /* Reorder the surround channels
4583 * ALSA sequence is front/surr/clfe/side
4585 * 4-ch: front/surr => OK as it is
4586 * 6-ch: front/clfe/surr
4587 * 8-ch: front/clfe/rear/side|fc
4589 switch (cfg
->line_outs
) {
4592 nid
= cfg
->line_out_pins
[1];
4593 cfg
->line_out_pins
[1] = cfg
->line_out_pins
[2];
4594 cfg
->line_out_pins
[2] = nid
;
4599 * debug prints of the parsed results
4601 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4602 cfg
->line_outs
, cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
4603 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
4604 cfg
->line_out_pins
[4]);
4605 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4606 cfg
->speaker_outs
, cfg
->speaker_pins
[0],
4607 cfg
->speaker_pins
[1], cfg
->speaker_pins
[2],
4608 cfg
->speaker_pins
[3], cfg
->speaker_pins
[4]);
4609 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4610 cfg
->hp_outs
, cfg
->hp_pins
[0],
4611 cfg
->hp_pins
[1], cfg
->hp_pins
[2],
4612 cfg
->hp_pins
[3], cfg
->hp_pins
[4]);
4613 snd_printd(" mono: mono_out=0x%x\n", cfg
->mono_out_pin
);
4615 snd_printd(" dig-out=0x%x/0x%x\n",
4616 cfg
->dig_out_pins
[0], cfg
->dig_out_pins
[1]);
4617 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4618 " cd=0x%x, aux=0x%x\n",
4619 cfg
->input_pins
[AUTO_PIN_MIC
],
4620 cfg
->input_pins
[AUTO_PIN_FRONT_MIC
],
4621 cfg
->input_pins
[AUTO_PIN_LINE
],
4622 cfg
->input_pins
[AUTO_PIN_FRONT_LINE
],
4623 cfg
->input_pins
[AUTO_PIN_CD
],
4624 cfg
->input_pins
[AUTO_PIN_AUX
]);
4625 if (cfg
->dig_in_pin
)
4626 snd_printd(" dig-in=0x%x\n", cfg
->dig_in_pin
);
4630 EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config
);
4632 /* labels for input pins */
4633 const char *auto_pin_cfg_labels
[AUTO_PIN_LAST
] = {
4634 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4636 EXPORT_SYMBOL_HDA(auto_pin_cfg_labels
);
4645 * snd_hda_suspend - suspend the codecs
4648 * Returns 0 if successful.
4650 int snd_hda_suspend(struct hda_bus
*bus
)
4652 struct hda_codec
*codec
;
4654 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4655 #ifdef CONFIG_SND_HDA_POWER_SAVE
4656 if (!codec
->power_on
)
4659 hda_call_codec_suspend(codec
);
4663 EXPORT_SYMBOL_HDA(snd_hda_suspend
);
4666 * snd_hda_resume - resume the codecs
4669 * Returns 0 if successful.
4671 * This fucntion is defined only when POWER_SAVE isn't set.
4672 * In the power-save mode, the codec is resumed dynamically.
4674 int snd_hda_resume(struct hda_bus
*bus
)
4676 struct hda_codec
*codec
;
4678 list_for_each_entry(codec
, &bus
->codec_list
, list
) {
4679 if (snd_hda_codec_needs_resume(codec
))
4680 hda_call_codec_resume(codec
);
4684 EXPORT_SYMBOL_HDA(snd_hda_resume
);
4685 #endif /* CONFIG_PM */
4692 * snd_array_new - get a new element from the given array
4693 * @array: the array object
4695 * Get a new element from the given array. If it exceeds the
4696 * pre-allocated array size, re-allocate the array.
4698 * Returns NULL if allocation failed.
4700 void *snd_array_new(struct snd_array
*array
)
4702 if (array
->used
>= array
->alloced
) {
4703 int num
= array
->alloced
+ array
->alloc_align
;
4705 if (snd_BUG_ON(num
>= 4096))
4707 nlist
= kcalloc(num
+ 1, array
->elem_size
, GFP_KERNEL
);
4711 memcpy(nlist
, array
->list
,
4712 array
->elem_size
* array
->alloced
);
4715 array
->list
= nlist
;
4716 array
->alloced
= num
;
4718 return snd_array_elem(array
, array
->used
++);
4720 EXPORT_SYMBOL_HDA(snd_array_new
);
4723 * snd_array_free - free the given array elements
4724 * @array: the array object
4726 void snd_array_free(struct snd_array
*array
)
4733 EXPORT_SYMBOL_HDA(snd_array_free
);
4736 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4737 * @pcm: PCM caps bits
4738 * @buf: the string buffer to write
4739 * @buflen: the max buffer length
4741 * used by hda_proc.c and hda_eld.c
4743 void snd_print_pcm_rates(int pcm
, char *buf
, int buflen
)
4745 static unsigned int rates
[] = {
4746 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4747 96000, 176400, 192000, 384000
4751 for (i
= 0, j
= 0; i
< ARRAY_SIZE(rates
); i
++)
4753 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", rates
[i
]);
4755 buf
[j
] = '\0'; /* necessary when j == 0 */
4757 EXPORT_SYMBOL_HDA(snd_print_pcm_rates
);
4760 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4761 * @pcm: PCM caps bits
4762 * @buf: the string buffer to write
4763 * @buflen: the max buffer length
4765 * used by hda_proc.c and hda_eld.c
4767 void snd_print_pcm_bits(int pcm
, char *buf
, int buflen
)
4769 static unsigned int bits
[] = { 8, 16, 20, 24, 32 };
4772 for (i
= 0, j
= 0; i
< ARRAY_SIZE(bits
); i
++)
4773 if (pcm
& (AC_SUPPCM_BITS_8
<< i
))
4774 j
+= snprintf(buf
+ j
, buflen
- j
, " %d", bits
[i
]);
4776 buf
[j
] = '\0'; /* necessary when j == 0 */
4778 EXPORT_SYMBOL_HDA(snd_print_pcm_bits
);
4780 MODULE_DESCRIPTION("HDA codec core");
4781 MODULE_LICENSE("GPL");