blob: 4df72c0e8c37c9011cecff85cca8e834d74260de [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
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.
11 *
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.
16 *
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
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/slab.h>
25#include <linux/pci.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010026#include <linux/mutex.h>
Paul Gortmakerda155d52011-07-15 12:38:28 -040027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <sound/core.h>
29#include "hda_codec.h"
30#include <sound/asoundef.h>
Jaroslav Kysela302e9c52006-07-05 17:39:49 +020031#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <sound/initval.h>
Takashi Iwaicd372fb2011-03-03 14:40:14 +010033#include <sound/jack.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "hda_local.h"
Jaroslav Kysela123c07a2009-10-21 14:48:23 +020035#include "hda_beep.h"
Takashi Iwai1835a0f2011-10-27 22:12:46 +020036#include "hda_jack.h"
Takashi Iwai28073142007-07-27 18:58:06 +020037#include <sound/hda_hwdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Takashi Iwaid66fee52011-08-02 15:39:31 +020039#define CREATE_TRACE_POINTS
40#include "hda_trace.h"
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042/*
43 * vendor / preset table
44 */
45
46struct hda_vendor_id {
47 unsigned int id;
48 const char *name;
49};
50
51/* codec vendor labels */
52static struct hda_vendor_id hda_vendor_ids[] = {
Takashi Iwaic8cd1282008-02-13 16:59:29 +010053 { 0x1002, "ATI" },
Takashi Iwaie5f14242009-07-01 18:11:44 +020054 { 0x1013, "Cirrus Logic" },
Takashi Iwaia9226252006-09-17 22:05:54 +020055 { 0x1057, "Motorola" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010056 { 0x1095, "Silicon Image" },
Takashi Iwai31117b72008-12-16 14:43:21 +010057 { 0x10de, "Nvidia" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010058 { 0x10ec, "Realtek" },
Takashi Iwai4e01f542009-04-16 08:53:34 +020059 { 0x1102, "Creative" },
Joseph Chanc577b8a2006-11-29 15:29:40 +010060 { 0x1106, "VIA" },
Matthew Ranostay7f168592007-10-18 17:38:17 +020061 { 0x111d, "IDT" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010062 { 0x11c1, "LSI" },
Takashi Iwai54b903e2005-05-15 14:30:10 +020063 { 0x11d4, "Analog Devices" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 { 0x13f6, "C-Media" },
Takashi Iwaia9226252006-09-17 22:05:54 +020065 { 0x14f1, "Conexant" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010066 { 0x17e8, "Chrontel" },
67 { 0x1854, "LG" },
Mark Brown8199de32008-10-28 14:50:13 +000068 { 0x1aec, "Wolfson Microelectronics" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 { 0x434d, "C-Media" },
Takashi Iwai74c61132008-12-18 09:11:33 +010070 { 0x8086, "Intel" },
Matt2f2f4252005-04-13 14:45:30 +020071 { 0x8384, "SigmaTel" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 {} /* terminator */
73};
74
Takashi Iwai1289e9e2008-11-27 15:47:11 +010075static DEFINE_MUTEX(preset_mutex);
76static LIST_HEAD(hda_preset_tables);
77
78int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
79{
80 mutex_lock(&preset_mutex);
81 list_add_tail(&preset->list, &hda_preset_tables);
82 mutex_unlock(&preset_mutex);
83 return 0;
84}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010085EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
Takashi Iwai1289e9e2008-11-27 15:47:11 +010086
87int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
88{
89 mutex_lock(&preset_mutex);
90 list_del(&preset->list);
91 mutex_unlock(&preset_mutex);
92 return 0;
93}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010094EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Takashi Iwaicb53c622007-08-10 17:21:45 +020096#ifdef CONFIG_SND_HDA_POWER_SAVE
97static void hda_power_work(struct work_struct *work);
98static void hda_keep_power_on(struct hda_codec *codec);
Takashi Iwaie581f3d2011-07-26 10:19:20 +020099#define hda_codec_is_power_on(codec) ((codec)->power_on)
Takashi Iwaicb53c622007-08-10 17:21:45 +0200100#else
101static inline void hda_keep_power_on(struct hda_codec *codec) {}
Takashi Iwaie581f3d2011-07-26 10:19:20 +0200102#define hda_codec_is_power_on(codec) 1
Takashi Iwaicb53c622007-08-10 17:21:45 +0200103#endif
104
Takashi Iwaid5191e52009-11-16 14:58:17 +0100105/**
106 * snd_hda_get_jack_location - Give a location string of the jack
107 * @cfg: pin default config value
108 *
109 * Parse the pin default config value and returns the string of the
110 * jack location, e.g. "Rear", "Front", etc.
111 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400112const char *snd_hda_get_jack_location(u32 cfg)
113{
114 static char *bases[7] = {
115 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
116 };
117 static unsigned char specials_idx[] = {
118 0x07, 0x08,
119 0x17, 0x18, 0x19,
120 0x37, 0x38
121 };
122 static char *specials[] = {
123 "Rear Panel", "Drive Bar",
124 "Riser", "HDMI", "ATAPI",
125 "Mobile-In", "Mobile-Out"
126 };
127 int i;
128 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
129 if ((cfg & 0x0f) < 7)
130 return bases[cfg & 0x0f];
131 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
132 if (cfg == specials_idx[i])
133 return specials[i];
134 }
135 return "UNKNOWN";
136}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100137EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400138
Takashi Iwaid5191e52009-11-16 14:58:17 +0100139/**
140 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
141 * @cfg: pin default config value
142 *
143 * Parse the pin default config value and returns the string of the
144 * jack connectivity, i.e. external or internal connection.
145 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400146const char *snd_hda_get_jack_connectivity(u32 cfg)
147{
148 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
149
150 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
151}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100152EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400153
Takashi Iwaid5191e52009-11-16 14:58:17 +0100154/**
155 * snd_hda_get_jack_type - Give a type string of the jack
156 * @cfg: pin default config value
157 *
158 * Parse the pin default config value and returns the string of the
159 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
160 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400161const char *snd_hda_get_jack_type(u32 cfg)
162{
163 static char *jack_types[16] = {
164 "Line Out", "Speaker", "HP Out", "CD",
165 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
166 "Line In", "Aux", "Mic", "Telephony",
167 "SPDIF In", "Digitial In", "Reserved", "Other"
168 };
169
170 return jack_types[(cfg & AC_DEFCFG_DEVICE)
171 >> AC_DEFCFG_DEVICE_SHIFT];
172}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100173EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400174
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100175/*
176 * Compose a 32bit command word to be sent to the HD-audio controller
177 */
178static inline unsigned int
179make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
180 unsigned int verb, unsigned int parm)
181{
182 u32 val;
183
Takashi Iwai82e1b802009-07-17 12:47:34 +0200184 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
185 (verb & ~0xfff) || (parm & ~0xffff)) {
Wu Fengguang6430aee2009-07-17 16:49:19 +0800186 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
187 codec->addr, direct, nid, verb, parm);
188 return ~0;
189 }
190
191 val = (u32)codec->addr << 28;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100192 val |= (u32)direct << 27;
193 val |= (u32)nid << 20;
194 val |= verb << 8;
195 val |= parm;
196 return val;
197}
198
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200199/*
200 * Send and receive a verb
201 */
202static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
203 unsigned int *res)
204{
205 struct hda_bus *bus = codec->bus;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200206 int err;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200207
Wu Fengguang6430aee2009-07-17 16:49:19 +0800208 if (cmd == ~0)
209 return -1;
210
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200211 if (res)
212 *res = -1;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200213 again:
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200214 snd_hda_power_up(codec);
215 mutex_lock(&bus->cmd_mutex);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200216 trace_hda_send_cmd(codec, cmd);
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200217 err = bus->ops.command(bus, cmd);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200218 if (!err && res) {
Wu Fengguangdeadff12009-08-01 18:45:16 +0800219 *res = bus->ops.get_response(bus, codec->addr);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200220 trace_hda_get_response(codec, *res);
221 }
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200222 mutex_unlock(&bus->cmd_mutex);
223 snd_hda_power_down(codec);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200224 if (res && *res == -1 && bus->rirb_error) {
225 if (bus->response_reset) {
226 snd_printd("hda_codec: resetting BUS due to "
227 "fatal communication error\n");
Takashi Iwaid66fee52011-08-02 15:39:31 +0200228 trace_hda_bus_reset(bus);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200229 bus->ops.bus_reset(bus);
230 }
231 goto again;
232 }
233 /* clear reset-flag when the communication gets recovered */
234 if (!err)
235 bus->response_reset = 0;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200236 return err;
237}
238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239/**
240 * snd_hda_codec_read - send a command and get the response
241 * @codec: the HDA codec
242 * @nid: NID to send the command
243 * @direct: direct flag
244 * @verb: the verb to send
245 * @parm: the parameter for the verb
246 *
247 * Send a single command and read the corresponding response.
248 *
249 * Returns the obtained response value, or -1 for an error.
250 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200251unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
252 int direct,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 unsigned int verb, unsigned int parm)
254{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200255 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
256 unsigned int res;
Greg Thelen9857edf2011-06-13 07:45:45 -0700257 if (codec_exec_verb(codec, cmd, &res))
258 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return res;
260}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100261EXPORT_SYMBOL_HDA(snd_hda_codec_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263/**
264 * snd_hda_codec_write - send a single command without waiting for response
265 * @codec: the HDA codec
266 * @nid: NID to send the command
267 * @direct: direct flag
268 * @verb: the verb to send
269 * @parm: the parameter for the verb
270 *
271 * Send a single command without waiting for response.
272 *
273 * Returns 0 if successful, or a negative error code.
274 */
275int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
276 unsigned int verb, unsigned int parm)
277{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200278 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100279 unsigned int res;
Takashi Iwaib20f3b82009-06-02 01:20:22 +0200280 return codec_exec_verb(codec, cmd,
281 codec->bus->sync_write ? &res : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100283EXPORT_SYMBOL_HDA(snd_hda_codec_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285/**
286 * snd_hda_sequence_write - sequence writes
287 * @codec: the HDA codec
288 * @seq: VERB array to send
289 *
290 * Send the commands sequentially from the given array.
291 * The array must be terminated with NID=0.
292 */
293void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
294{
295 for (; seq->nid; seq++)
296 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
297}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100298EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300/**
301 * snd_hda_get_sub_nodes - get the range of sub nodes
302 * @codec: the HDA codec
303 * @nid: NID to parse
304 * @start_id: the pointer to store the start NID
305 *
306 * Parse the NID and store the start NID of its sub-nodes.
307 * Returns the number of sub-nodes.
308 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200309int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
310 hda_nid_t *start_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
312 unsigned int parm;
313
314 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
Danny Tholene8a7f132007-09-11 21:41:56 +0200315 if (parm == -1)
316 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 *start_id = (parm >> 16) & 0x7fff;
318 return (int)(parm & 0x7fff);
319}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100320EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200322/* look up the cached results */
323static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
324{
325 int i, len;
326 for (i = 0; i < array->used; ) {
327 hda_nid_t *p = snd_array_elem(array, i);
328 if (nid == *p)
329 return p;
330 len = p[1];
331 i += len + 2;
332 }
333 return NULL;
334}
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336/**
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200337 * snd_hda_get_conn_list - get connection list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 * @codec: the HDA codec
339 * @nid: NID to parse
Takashi Iwaidce20792011-06-24 14:10:28 +0200340 * @listp: the pointer to store NID list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 *
342 * Parses the connection list of the given widget and stores the list
343 * of NIDs.
344 *
345 * Returns the number of connections, or a negative error code.
346 */
Takashi Iwaidce20792011-06-24 14:10:28 +0200347int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
348 const hda_nid_t **listp)
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200349{
350 struct snd_array *array = &codec->conn_lists;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200351 int len, err;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200352 hda_nid_t list[HDA_MAX_CONNECTIONS];
Takashi Iwaidce20792011-06-24 14:10:28 +0200353 hda_nid_t *p;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200354 bool added = false;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200355
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200356 again:
357 /* if the connection-list is already cached, read it */
358 p = lookup_conn_list(array, nid);
359 if (p) {
360 if (listp)
361 *listp = p + 2;
362 return p[1];
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200363 }
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200364 if (snd_BUG_ON(added))
365 return -EINVAL;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200366
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200367 /* read the connection and add to the cache */
Takashi Iwai9e7717c2011-07-11 15:42:52 +0200368 len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200369 if (len < 0)
370 return len;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200371 err = snd_hda_override_conn_list(codec, nid, len, list);
372 if (err < 0)
373 return err;
374 added = true;
375 goto again;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200376}
Takashi Iwaidce20792011-06-24 14:10:28 +0200377EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
378
379/**
380 * snd_hda_get_connections - copy connection list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 * @codec: the HDA codec
382 * @nid: NID to parse
383 * @conn_list: connection list array
384 * @max_conns: max. number of connections to store
385 *
386 * Parses the connection list of the given widget and stores the list
387 * of NIDs.
388 *
389 * Returns the number of connections, or a negative error code.
390 */
391int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200392 hda_nid_t *conn_list, int max_conns)
393{
Takashi Iwaidce20792011-06-24 14:10:28 +0200394 const hda_nid_t *list;
395 int len = snd_hda_get_conn_list(codec, nid, &list);
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200396
Takashi Iwaidce20792011-06-24 14:10:28 +0200397 if (len <= 0)
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200398 return len;
Takashi Iwaidce20792011-06-24 14:10:28 +0200399 if (len > max_conns) {
400 snd_printk(KERN_ERR "hda_codec: "
401 "Too many connections %d for NID 0x%x\n",
402 len, nid);
403 return -EINVAL;
404 }
405 memcpy(conn_list, list, len * sizeof(hda_nid_t));
406 return len;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200407}
408EXPORT_SYMBOL_HDA(snd_hda_get_connections);
409
Takashi Iwai9e7717c2011-07-11 15:42:52 +0200410/**
411 * snd_hda_get_raw_connections - copy connection list without cache
412 * @codec: the HDA codec
413 * @nid: NID to parse
414 * @conn_list: connection list array
415 * @max_conns: max. number of connections to store
416 *
417 * Like snd_hda_get_connections(), copy the connection list but without
418 * checking through the connection-list cache.
419 * Currently called only from hda_proc.c, so not exported.
420 */
421int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
422 hda_nid_t *conn_list, int max_conns)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
424 unsigned int parm;
Takashi Iwai54d17402005-11-21 16:33:22 +0100425 int i, conn_len, conns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 unsigned int shift, num_elems, mask;
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200427 unsigned int wcaps;
Takashi Iwai54d17402005-11-21 16:33:22 +0100428 hda_nid_t prev_nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Takashi Iwaida3cec32008-08-08 17:12:14 +0200430 if (snd_BUG_ON(!conn_list || max_conns <= 0))
431 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200433 wcaps = get_wcaps(codec, nid);
434 if (!(wcaps & AC_WCAP_CONN_LIST) &&
Takashi Iwai8d087c72011-06-28 12:45:47 +0200435 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
436 return 0;
Jaroslav Kysela16a433d2009-07-22 16:20:40 +0200437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
439 if (parm & AC_CLIST_LONG) {
440 /* long form */
441 shift = 16;
442 num_elems = 2;
443 } else {
444 /* short form */
445 shift = 8;
446 num_elems = 4;
447 }
448 conn_len = parm & AC_CLIST_LENGTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 mask = (1 << (shift-1)) - 1;
450
Takashi Iwai0ba21762007-04-16 11:29:14 +0200451 if (!conn_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return 0; /* no connection */
453
454 if (conn_len == 1) {
455 /* single connection */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200456 parm = snd_hda_codec_read(codec, nid, 0,
457 AC_VERB_GET_CONNECT_LIST, 0);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200458 if (parm == -1 && codec->bus->rirb_error)
459 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 conn_list[0] = parm & mask;
461 return 1;
462 }
463
464 /* multi connection */
465 conns = 0;
Takashi Iwai54d17402005-11-21 16:33:22 +0100466 prev_nid = 0;
467 for (i = 0; i < conn_len; i++) {
468 int range_val;
469 hda_nid_t val, n;
470
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200471 if (i % num_elems == 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +0100472 parm = snd_hda_codec_read(codec, nid, 0,
473 AC_VERB_GET_CONNECT_LIST, i);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200474 if (parm == -1 && codec->bus->rirb_error)
475 return -EIO;
476 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200477 range_val = !!(parm & (1 << (shift-1))); /* ranges */
Takashi Iwai54d17402005-11-21 16:33:22 +0100478 val = parm & mask;
Jaroslav Kysela2e9bf242009-07-18 11:48:19 +0200479 if (val == 0) {
480 snd_printk(KERN_WARNING "hda_codec: "
481 "invalid CONNECT_LIST verb %x[%i]:%x\n",
482 nid, i, parm);
483 return 0;
484 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100485 parm >>= shift;
486 if (range_val) {
487 /* ranges between the previous and this one */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200488 if (!prev_nid || prev_nid >= val) {
489 snd_printk(KERN_WARNING "hda_codec: "
490 "invalid dep_range_val %x:%x\n",
491 prev_nid, val);
Takashi Iwai54d17402005-11-21 16:33:22 +0100492 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100494 for (n = prev_nid + 1; n <= val; n++) {
495 if (conns >= max_conns) {
Takashi Iwai5aacc212010-07-30 10:36:29 +0200496 snd_printk(KERN_ERR "hda_codec: "
497 "Too many connections %d for NID 0x%x\n",
498 conns, nid);
Takashi Iwai54d17402005-11-21 16:33:22 +0100499 return -EINVAL;
500 }
501 conn_list[conns++] = n;
502 }
503 } else {
504 if (conns >= max_conns) {
Takashi Iwai5aacc212010-07-30 10:36:29 +0200505 snd_printk(KERN_ERR "hda_codec: "
506 "Too many connections %d for NID 0x%x\n",
507 conns, nid);
Takashi Iwai54d17402005-11-21 16:33:22 +0100508 return -EINVAL;
509 }
510 conn_list[conns++] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100512 prev_nid = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514 return conns;
515}
516
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200517static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
518{
519 hda_nid_t *p = snd_array_new(array);
520 if (!p)
521 return false;
522 *p = nid;
523 return true;
524}
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526/**
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200527 * snd_hda_override_conn_list - add/modify the connection-list to cache
528 * @codec: the HDA codec
529 * @nid: NID to parse
530 * @len: number of connection list entries
531 * @list: the list of connection entries
532 *
533 * Add or modify the given connection-list to the cache. If the corresponding
534 * cache already exists, invalidate it and append a new one.
535 *
536 * Returns zero or a negative error code.
537 */
538int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
539 const hda_nid_t *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200541 struct snd_array *array = &codec->conn_lists;
542 hda_nid_t *p;
543 int i, old_used;
544
545 p = lookup_conn_list(array, nid);
546 if (p)
547 *p = -1; /* invalidate the old entry */
548
549 old_used = array->used;
550 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
551 goto error_add;
552 for (i = 0; i < len; i++)
553 if (!add_conn_list(array, list[i]))
554 goto error_add;
555 return 0;
556
557 error_add:
558 array->used = old_used;
559 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560}
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200561EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
562
563/**
Takashi Iwai8d087c72011-06-28 12:45:47 +0200564 * snd_hda_get_conn_index - get the connection index of the given NID
565 * @codec: the HDA codec
566 * @mux: NID containing the list
567 * @nid: NID to select
568 * @recursive: 1 when searching NID recursively, otherwise 0
569 *
570 * Parses the connection list of the widget @mux and checks whether the
571 * widget @nid is present. If it is, return the connection index.
572 * Otherwise it returns -1.
573 */
574int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
575 hda_nid_t nid, int recursive)
576{
577 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
578 int i, nums;
579
580 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
581 for (i = 0; i < nums; i++)
582 if (conn[i] == nid)
583 return i;
584 if (!recursive)
585 return -1;
586 if (recursive > 5) {
587 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
588 return -1;
589 }
590 recursive++;
Takashi Iwai99e14c92011-09-13 10:33:16 +0200591 for (i = 0; i < nums; i++) {
592 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
593 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
594 continue;
Takashi Iwai8d087c72011-06-28 12:45:47 +0200595 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
596 return i;
Takashi Iwai99e14c92011-09-13 10:33:16 +0200597 }
Takashi Iwai8d087c72011-06-28 12:45:47 +0200598 return -1;
599}
600EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602/**
603 * snd_hda_queue_unsol_event - add an unsolicited event to queue
604 * @bus: the BUS
605 * @res: unsolicited event (lower 32bit of RIRB entry)
606 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
607 *
608 * Adds the given event to the queue. The events are processed in
609 * the workqueue asynchronously. Call this function in the interrupt
610 * hanlder when RIRB receives an unsolicited event.
611 *
612 * Returns 0 if successful, or a negative error code.
613 */
614int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
615{
616 struct hda_bus_unsolicited *unsol;
617 unsigned int wp;
618
Takashi Iwaiecf726f2011-08-09 14:22:44 +0200619 trace_hda_unsol_event(bus, res, res_ex);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200620 unsol = bus->unsol;
621 if (!unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return 0;
623
624 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
625 unsol->wp = wp;
626
627 wp <<= 1;
628 unsol->queue[wp] = res;
629 unsol->queue[wp + 1] = res_ex;
630
Takashi Iwai6acaed32009-01-12 10:09:24 +0100631 queue_work(bus->workq, &unsol->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
633 return 0;
634}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100635EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637/*
Wu Fengguang5c1d1a92008-10-07 14:17:53 +0800638 * process queued unsolicited events
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 */
David Howellsc4028952006-11-22 14:57:56 +0000640static void process_unsol_events(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
David Howellsc4028952006-11-22 14:57:56 +0000642 struct hda_bus_unsolicited *unsol =
643 container_of(work, struct hda_bus_unsolicited, work);
644 struct hda_bus *bus = unsol->bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 struct hda_codec *codec;
646 unsigned int rp, caddr, res;
647
648 while (unsol->rp != unsol->wp) {
649 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
650 unsol->rp = rp;
651 rp <<= 1;
652 res = unsol->queue[rp];
653 caddr = unsol->queue[rp + 1];
Takashi Iwai0ba21762007-04-16 11:29:14 +0200654 if (!(caddr & (1 << 4))) /* no unsolicited event? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 continue;
656 codec = bus->caddr_tbl[caddr & 0x0f];
657 if (codec && codec->patch_ops.unsol_event)
658 codec->patch_ops.unsol_event(codec, res);
659 }
660}
661
662/*
663 * initialize unsolicited queue
664 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200665static int init_unsol_queue(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666{
667 struct hda_bus_unsolicited *unsol;
668
Takashi Iwai9f146bb2005-11-17 11:07:49 +0100669 if (bus->unsol) /* already initialized */
670 return 0;
671
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200672 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200673 if (!unsol) {
674 snd_printk(KERN_ERR "hda_codec: "
675 "can't allocate unsolicited queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return -ENOMEM;
677 }
David Howellsc4028952006-11-22 14:57:56 +0000678 INIT_WORK(&unsol->work, process_unsol_events);
679 unsol->bus = bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 bus->unsol = unsol;
681 return 0;
682}
683
684/*
685 * destructor
686 */
687static void snd_hda_codec_free(struct hda_codec *codec);
688
689static int snd_hda_bus_free(struct hda_bus *bus)
690{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200691 struct hda_codec *codec, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
Takashi Iwai0ba21762007-04-16 11:29:14 +0200693 if (!bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 return 0;
Takashi Iwai6acaed32009-01-12 10:09:24 +0100695 if (bus->workq)
696 flush_workqueue(bus->workq);
697 if (bus->unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 kfree(bus->unsol);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200699 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 snd_hda_codec_free(codec);
701 }
702 if (bus->ops.private_free)
703 bus->ops.private_free(bus);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100704 if (bus->workq)
705 destroy_workqueue(bus->workq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 kfree(bus);
707 return 0;
708}
709
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +0100710static int snd_hda_bus_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
712 struct hda_bus *bus = device->device_data;
Takashi Iwaib94d3532008-11-21 09:08:06 +0100713 bus->shutdown = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return snd_hda_bus_free(bus);
715}
716
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200717#ifdef CONFIG_SND_HDA_HWDEP
718static int snd_hda_bus_dev_register(struct snd_device *device)
719{
720 struct hda_bus *bus = device->device_data;
721 struct hda_codec *codec;
722 list_for_each_entry(codec, &bus->codec_list, list) {
723 snd_hda_hwdep_add_sysfs(codec);
Takashi Iwaia2f63092009-11-11 09:34:25 +0100724 snd_hda_hwdep_add_power_sysfs(codec);
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200725 }
726 return 0;
727}
728#else
729#define snd_hda_bus_dev_register NULL
730#endif
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732/**
733 * snd_hda_bus_new - create a HDA bus
734 * @card: the card entry
735 * @temp: the template for hda_bus information
736 * @busp: the pointer to store the created bus instance
737 *
738 * Returns 0 if successful, or a negative error code.
739 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100740int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
Takashi Iwai756e2b02007-04-16 11:27:07 +0200741 const struct hda_bus_template *temp,
742 struct hda_bus **busp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 struct hda_bus *bus;
745 int err;
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +0100746 static struct snd_device_ops dev_ops = {
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200747 .dev_register = snd_hda_bus_dev_register,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 .dev_free = snd_hda_bus_dev_free,
749 };
750
Takashi Iwaida3cec32008-08-08 17:12:14 +0200751 if (snd_BUG_ON(!temp))
752 return -EINVAL;
753 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
754 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
756 if (busp)
757 *busp = NULL;
758
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200759 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 if (bus == NULL) {
761 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
762 return -ENOMEM;
763 }
764
765 bus->card = card;
766 bus->private_data = temp->private_data;
767 bus->pci = temp->pci;
768 bus->modelname = temp->modelname;
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100769 bus->power_save = temp->power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 bus->ops = temp->ops;
771
Ingo Molnar62932df2006-01-16 16:34:20 +0100772 mutex_init(&bus->cmd_mutex);
Takashi Iwai3f50ac62010-08-20 09:44:36 +0200773 mutex_init(&bus->prepare_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 INIT_LIST_HEAD(&bus->codec_list);
775
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100776 snprintf(bus->workq_name, sizeof(bus->workq_name),
777 "hd-audio%d", card->number);
778 bus->workq = create_singlethread_workqueue(bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100779 if (!bus->workq) {
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100780 snd_printk(KERN_ERR "cannot create workqueue %s\n",
781 bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100782 kfree(bus);
783 return -ENOMEM;
784 }
785
Takashi Iwai0ba21762007-04-16 11:29:14 +0200786 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
787 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 snd_hda_bus_free(bus);
789 return err;
790 }
791 if (busp)
792 *busp = bus;
793 return 0;
794}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100795EXPORT_SYMBOL_HDA(snd_hda_bus_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Takashi Iwai82467612007-07-27 19:15:54 +0200797#ifdef CONFIG_SND_HDA_GENERIC
798#define is_generic_config(codec) \
Takashi Iwaif44ac832008-07-30 15:01:45 +0200799 (codec->modelname && !strcmp(codec->modelname, "generic"))
Takashi Iwai82467612007-07-27 19:15:54 +0200800#else
801#define is_generic_config(codec) 0
802#endif
803
Takashi Iwai645f10c2008-11-28 15:07:37 +0100804#ifdef MODULE
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100805#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
806#else
Takashi Iwai645f10c2008-11-28 15:07:37 +0100807#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100808#endif
809
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810/*
811 * find a matching codec preset
812 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200813static const struct hda_codec_preset *
Takashi Iwai756e2b02007-04-16 11:27:07 +0200814find_codec_preset(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100816 struct hda_codec_preset_list *tbl;
817 const struct hda_codec_preset *preset;
818 int mod_requested = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Takashi Iwai82467612007-07-27 19:15:54 +0200820 if (is_generic_config(codec))
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100821 return NULL; /* use the generic parser */
822
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100823 again:
824 mutex_lock(&preset_mutex);
825 list_for_each_entry(tbl, &hda_preset_tables, list) {
826 if (!try_module_get(tbl->owner)) {
827 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
828 continue;
829 }
830 for (preset = tbl->preset; preset->id; preset++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 u32 mask = preset->mask;
Marc Boucherca7cfae2008-01-22 15:32:25 +0100832 if (preset->afg && preset->afg != codec->afg)
833 continue;
834 if (preset->mfg && preset->mfg != codec->mfg)
835 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200836 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 mask = ~0;
Takashi Iwai9c7f8522006-06-28 15:08:22 +0200838 if (preset->id == (codec->vendor_id & mask) &&
Takashi Iwai0ba21762007-04-16 11:29:14 +0200839 (!preset->rev ||
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100840 preset->rev == codec->revision_id)) {
841 mutex_unlock(&preset_mutex);
842 codec->owner = tbl->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 return preset;
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100844 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100846 module_put(tbl->owner);
847 }
848 mutex_unlock(&preset_mutex);
849
850 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
851 char name[32];
852 if (!mod_requested)
853 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
854 codec->vendor_id);
855 else
856 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
857 (codec->vendor_id >> 16) & 0xffff);
858 request_module(name);
859 mod_requested++;
860 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
862 return NULL;
863}
864
865/*
Takashi Iwaif44ac832008-07-30 15:01:45 +0200866 * get_codec_name - store the codec name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200868static int get_codec_name(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
870 const struct hda_vendor_id *c;
871 const char *vendor = NULL;
872 u16 vendor_id = codec->vendor_id >> 16;
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200873 char tmp[16];
874
875 if (codec->vendor_name)
876 goto get_chip_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
878 for (c = hda_vendor_ids; c->id; c++) {
879 if (c->id == vendor_id) {
880 vendor = c->name;
881 break;
882 }
883 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200884 if (!vendor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 sprintf(tmp, "Generic %04x", vendor_id);
886 vendor = tmp;
887 }
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200888 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
889 if (!codec->vendor_name)
890 return -ENOMEM;
891
892 get_chip_name:
893 if (codec->chip_name)
894 return 0;
895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 if (codec->preset && codec->preset->name)
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200897 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
898 else {
899 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
900 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
901 }
902 if (!codec->chip_name)
Takashi Iwaif44ac832008-07-30 15:01:45 +0200903 return -ENOMEM;
904 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
907/*
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200908 * look for an AFG and MFG nodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100910static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911{
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200912 int i, total_nodes, function_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 hda_nid_t nid;
914
915 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
916 for (i = 0; i < total_nodes; i++, nid++) {
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200917 function_id = snd_hda_param_read(codec, nid,
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200918 AC_PAR_FUNCTION_TYPE);
Jaroslav Kyselacd7643b2010-07-20 12:11:25 +0200919 switch (function_id & 0xff) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200920 case AC_GRP_AUDIO_FUNCTION:
921 codec->afg = nid;
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200922 codec->afg_function_id = function_id & 0xff;
923 codec->afg_unsol = (function_id >> 8) & 1;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200924 break;
925 case AC_GRP_MODEM_FUNCTION:
926 codec->mfg = nid;
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200927 codec->mfg_function_id = function_id & 0xff;
928 codec->mfg_unsol = (function_id >> 8) & 1;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200929 break;
930 default:
931 break;
932 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934}
935
936/*
Takashi Iwai54d17402005-11-21 16:33:22 +0100937 * read widget caps for each widget and store in cache
938 */
939static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
940{
941 int i;
942 hda_nid_t nid;
943
944 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
945 &codec->start_nid);
946 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200947 if (!codec->wcaps)
Takashi Iwai54d17402005-11-21 16:33:22 +0100948 return -ENOMEM;
949 nid = codec->start_nid;
950 for (i = 0; i < codec->num_nodes; i++, nid++)
951 codec->wcaps[i] = snd_hda_param_read(codec, nid,
952 AC_PAR_AUDIO_WIDGET_CAP);
953 return 0;
954}
955
Takashi Iwai3be14142009-02-20 14:11:16 +0100956/* read all pin default configurations and save codec->init_pins */
957static int read_pin_defaults(struct hda_codec *codec)
958{
959 int i;
960 hda_nid_t nid = codec->start_nid;
961
962 for (i = 0; i < codec->num_nodes; i++, nid++) {
963 struct hda_pincfg *pin;
964 unsigned int wcaps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +0200965 unsigned int wid_type = get_wcaps_type(wcaps);
Takashi Iwai3be14142009-02-20 14:11:16 +0100966 if (wid_type != AC_WID_PIN)
967 continue;
968 pin = snd_array_new(&codec->init_pins);
969 if (!pin)
970 return -ENOMEM;
971 pin->nid = nid;
972 pin->cfg = snd_hda_codec_read(codec, nid, 0,
973 AC_VERB_GET_CONFIG_DEFAULT, 0);
Takashi Iwaiac0547d2010-07-05 16:50:13 +0200974 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
975 AC_VERB_GET_PIN_WIDGET_CONTROL,
976 0);
Takashi Iwai3be14142009-02-20 14:11:16 +0100977 }
978 return 0;
979}
980
981/* look up the given pin config list and return the item matching with NID */
982static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
983 struct snd_array *array,
984 hda_nid_t nid)
985{
986 int i;
987 for (i = 0; i < array->used; i++) {
988 struct hda_pincfg *pin = snd_array_elem(array, i);
989 if (pin->nid == nid)
990 return pin;
991 }
992 return NULL;
993}
994
995/* write a config value for the given NID */
996static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
997 unsigned int cfg)
998{
999 int i;
1000 for (i = 0; i < 4; i++) {
1001 snd_hda_codec_write(codec, nid, 0,
1002 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1003 cfg & 0xff);
1004 cfg >>= 8;
1005 }
1006}
1007
1008/* set the current pin config value for the given NID.
1009 * the value is cached, and read via snd_hda_codec_get_pincfg()
1010 */
1011int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1012 hda_nid_t nid, unsigned int cfg)
1013{
1014 struct hda_pincfg *pin;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001015 unsigned int oldcfg;
Takashi Iwai3be14142009-02-20 14:11:16 +01001016
Takashi Iwaib82855a2009-12-27 11:24:56 +01001017 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1018 return -EINVAL;
1019
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001020 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +01001021 pin = look_up_pincfg(codec, list, nid);
1022 if (!pin) {
1023 pin = snd_array_new(list);
1024 if (!pin)
1025 return -ENOMEM;
1026 pin->nid = nid;
1027 }
1028 pin->cfg = cfg;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001029
1030 /* change only when needed; e.g. if the pincfg is already present
1031 * in user_pins[], don't write it
1032 */
1033 cfg = snd_hda_codec_get_pincfg(codec, nid);
1034 if (oldcfg != cfg)
1035 set_pincfg(codec, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +01001036 return 0;
1037}
1038
Takashi Iwaid5191e52009-11-16 14:58:17 +01001039/**
1040 * snd_hda_codec_set_pincfg - Override a pin default configuration
1041 * @codec: the HDA codec
1042 * @nid: NID to set the pin config
1043 * @cfg: the pin default config value
1044 *
1045 * Override a pin default configuration value in the cache.
1046 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1047 * priority than the real hardware value.
1048 */
Takashi Iwai3be14142009-02-20 14:11:16 +01001049int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1050 hda_nid_t nid, unsigned int cfg)
1051{
Takashi Iwai346ff702009-02-23 09:42:57 +01001052 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +01001053}
1054EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1055
Takashi Iwaid5191e52009-11-16 14:58:17 +01001056/**
1057 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1058 * @codec: the HDA codec
1059 * @nid: NID to get the pin config
1060 *
1061 * Get the current pin config value of the given pin NID.
1062 * If the pincfg value is cached or overridden via sysfs or driver,
1063 * returns the cached value.
1064 */
Takashi Iwai3be14142009-02-20 14:11:16 +01001065unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1066{
1067 struct hda_pincfg *pin;
1068
Takashi Iwai3be14142009-02-20 14:11:16 +01001069#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +01001070 pin = look_up_pincfg(codec, &codec->user_pins, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +01001071 if (pin)
1072 return pin->cfg;
1073#endif
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001074 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1075 if (pin)
1076 return pin->cfg;
Takashi Iwai3be14142009-02-20 14:11:16 +01001077 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1078 if (pin)
1079 return pin->cfg;
1080 return 0;
1081}
1082EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1083
1084/* restore all current pin configs */
1085static void restore_pincfgs(struct hda_codec *codec)
1086{
1087 int i;
1088 for (i = 0; i < codec->init_pins.used; i++) {
1089 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1090 set_pincfg(codec, pin->nid,
1091 snd_hda_codec_get_pincfg(codec, pin->nid));
1092 }
1093}
Takashi Iwai54d17402005-11-21 16:33:22 +01001094
Takashi Iwai92ee6162009-12-27 11:18:59 +01001095/**
1096 * snd_hda_shutup_pins - Shut up all pins
1097 * @codec: the HDA codec
1098 *
1099 * Clear all pin controls to shup up before suspend for avoiding click noise.
1100 * The controls aren't cached so that they can be resumed properly.
1101 */
1102void snd_hda_shutup_pins(struct hda_codec *codec)
1103{
1104 int i;
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001105 /* don't shut up pins when unloading the driver; otherwise it breaks
1106 * the default pin setup at the next load of the driver
1107 */
1108 if (codec->bus->shutdown)
1109 return;
Takashi Iwai92ee6162009-12-27 11:18:59 +01001110 for (i = 0; i < codec->init_pins.used; i++) {
1111 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1112 /* use read here for syncing after issuing each verb */
1113 snd_hda_codec_read(codec, pin->nid, 0,
1114 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1115 }
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001116 codec->pins_shutup = 1;
Takashi Iwai92ee6162009-12-27 11:18:59 +01001117}
1118EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1119
Takashi Iwai2a439522011-07-26 09:52:50 +02001120#ifdef CONFIG_PM
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001121/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1122static void restore_shutup_pins(struct hda_codec *codec)
1123{
1124 int i;
1125 if (!codec->pins_shutup)
1126 return;
1127 if (codec->bus->shutdown)
1128 return;
1129 for (i = 0; i < codec->init_pins.used; i++) {
1130 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1131 snd_hda_codec_write(codec, pin->nid, 0,
1132 AC_VERB_SET_PIN_WIDGET_CONTROL,
1133 pin->ctrl);
1134 }
1135 codec->pins_shutup = 0;
1136}
Mike Waychison1c7276c2011-04-20 12:04:36 -07001137#endif
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001138
Takashi Iwai01751f52007-08-10 16:59:39 +02001139static void init_hda_cache(struct hda_cache_rec *cache,
1140 unsigned int record_size);
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001141static void free_hda_cache(struct hda_cache_rec *cache);
Takashi Iwai01751f52007-08-10 16:59:39 +02001142
Takashi Iwai3be14142009-02-20 14:11:16 +01001143/* restore the initial pin cfgs and release all pincfg lists */
1144static void restore_init_pincfgs(struct hda_codec *codec)
1145{
Takashi Iwai346ff702009-02-23 09:42:57 +01001146 /* first free driver_pins and user_pins, then call restore_pincfg
Takashi Iwai3be14142009-02-20 14:11:16 +01001147 * so that only the values in init_pins are restored
1148 */
Takashi Iwai346ff702009-02-23 09:42:57 +01001149 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001150#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +01001151 snd_array_free(&codec->user_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001152#endif
1153 restore_pincfgs(codec);
1154 snd_array_free(&codec->init_pins);
1155}
1156
Takashi Iwai54d17402005-11-21 16:33:22 +01001157/*
Takashi Iwaieb541332010-08-06 13:48:11 +02001158 * audio-converter setup caches
1159 */
1160struct hda_cvt_setup {
1161 hda_nid_t nid;
1162 u8 stream_tag;
1163 u8 channel_id;
1164 u16 format_id;
1165 unsigned char active; /* cvt is currently used */
1166 unsigned char dirty; /* setups should be cleared */
1167};
1168
1169/* get or create a cache entry for the given audio converter NID */
1170static struct hda_cvt_setup *
1171get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1172{
1173 struct hda_cvt_setup *p;
1174 int i;
1175
1176 for (i = 0; i < codec->cvt_setups.used; i++) {
1177 p = snd_array_elem(&codec->cvt_setups, i);
1178 if (p->nid == nid)
1179 return p;
1180 }
1181 p = snd_array_new(&codec->cvt_setups);
1182 if (p)
1183 p->nid = nid;
1184 return p;
1185}
1186
1187/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 * codec destructor
1189 */
1190static void snd_hda_codec_free(struct hda_codec *codec)
1191{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001192 if (!codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 return;
Takashi Iwai3be14142009-02-20 14:11:16 +01001194 restore_init_pincfgs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001195#ifdef CONFIG_SND_HDA_POWER_SAVE
1196 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01001197 flush_workqueue(codec->bus->workq);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001198#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 list_del(&codec->list);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001200 snd_array_free(&codec->mixers);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01001201 snd_array_free(&codec->nids);
Takashi Iwaia12d3e12011-04-07 15:55:15 +02001202 snd_array_free(&codec->conn_lists);
Stephen Warren7c935972011-06-01 11:14:17 -06001203 snd_array_free(&codec->spdif_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 codec->bus->caddr_tbl[codec->addr] = NULL;
1205 if (codec->patch_ops.free)
1206 codec->patch_ops.free(codec);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001207 module_put(codec->owner);
Takashi Iwai01751f52007-08-10 16:59:39 +02001208 free_hda_cache(&codec->amp_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001209 free_hda_cache(&codec->cmd_cache);
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001210 kfree(codec->vendor_name);
1211 kfree(codec->chip_name);
Takashi Iwaif44ac832008-07-30 15:01:45 +02001212 kfree(codec->modelname);
Takashi Iwai54d17402005-11-21 16:33:22 +01001213 kfree(codec->wcaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 kfree(codec);
1215}
1216
Takashi Iwaibb6ac722009-03-13 09:02:42 +01001217static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1218 unsigned int power_state);
1219
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220/**
1221 * snd_hda_codec_new - create a HDA codec
1222 * @bus: the bus to assign
1223 * @codec_addr: the codec address
1224 * @codecp: the pointer to store the generated codec
1225 *
1226 * Returns 0 if successful, or a negative error code.
1227 */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01001228int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1229 unsigned int codec_addr,
1230 struct hda_codec **codecp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231{
1232 struct hda_codec *codec;
Jaroslav Kyselaba443682008-08-13 20:55:32 +02001233 char component[31];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 int err;
1235
Takashi Iwaida3cec32008-08-08 17:12:14 +02001236 if (snd_BUG_ON(!bus))
1237 return -EINVAL;
1238 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1239 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
1241 if (bus->caddr_tbl[codec_addr]) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001242 snd_printk(KERN_ERR "hda_codec: "
1243 "address 0x%x is already occupied\n", codec_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 return -EBUSY;
1245 }
1246
Takashi Iwaie560d8d2005-09-09 14:21:46 +02001247 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 if (codec == NULL) {
1249 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1250 return -ENOMEM;
1251 }
1252
1253 codec->bus = bus;
1254 codec->addr = codec_addr;
Ingo Molnar62932df2006-01-16 16:34:20 +01001255 mutex_init(&codec->spdif_mutex);
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001256 mutex_init(&codec->control_mutex);
Takashi Iwai01751f52007-08-10 16:59:39 +02001257 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001258 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01001259 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1260 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
Takashi Iwai3be14142009-02-20 14:11:16 +01001261 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai346ff702009-02-23 09:42:57 +01001262 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwaieb541332010-08-06 13:48:11 +02001263 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
Takashi Iwaia12d3e12011-04-07 15:55:15 +02001264 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
Stephen Warren7c935972011-06-01 11:14:17 -06001265 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001266 if (codec->bus->modelname) {
1267 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1268 if (!codec->modelname) {
1269 snd_hda_codec_free(codec);
1270 return -ENODEV;
1271 }
1272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Takashi Iwaicb53c622007-08-10 17:21:45 +02001274#ifdef CONFIG_SND_HDA_POWER_SAVE
1275 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1276 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1277 * the caller has to power down appropriatley after initialization
1278 * phase.
1279 */
1280 hda_keep_power_on(codec);
1281#endif
1282
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 list_add_tail(&codec->list, &bus->codec_list);
1284 bus->caddr_tbl[codec_addr] = codec;
1285
Takashi Iwai0ba21762007-04-16 11:29:14 +02001286 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1287 AC_PAR_VENDOR_ID);
Takashi Iwai111d3af2006-02-16 18:17:58 +01001288 if (codec->vendor_id == -1)
1289 /* read again, hopefully the access method was corrected
1290 * in the last read...
1291 */
1292 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1293 AC_PAR_VENDOR_ID);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001294 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1295 AC_PAR_SUBSYSTEM_ID);
1296 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1297 AC_PAR_REV_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001299 setup_fg_nodes(codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001300 if (!codec->afg && !codec->mfg) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001301 snd_printdd("hda_codec: no AFG or MFG node found\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001302 err = -ENODEV;
1303 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 }
1305
Takashi Iwai3be14142009-02-20 14:11:16 +01001306 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1307 if (err < 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +01001308 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001309 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001310 }
Takashi Iwai3be14142009-02-20 14:11:16 +01001311 err = read_pin_defaults(codec);
1312 if (err < 0)
1313 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001314
Takashi Iwai0ba21762007-04-16 11:29:14 +02001315 if (!codec->subsystem_id) {
Takashi Iwai86284e42005-10-11 15:05:54 +02001316 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001317 codec->subsystem_id =
1318 snd_hda_codec_read(codec, nid, 0,
1319 AC_VERB_GET_SUBSYSTEM_ID, 0);
Takashi Iwai86284e42005-10-11 15:05:54 +02001320 }
1321
Takashi Iwaibb6ac722009-03-13 09:02:42 +01001322 /* power-up all before initialization */
1323 hda_set_power_state(codec,
1324 codec->afg ? codec->afg : codec->mfg,
1325 AC_PWRST_D0);
1326
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001327 snd_hda_codec_proc_new(codec);
1328
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001329 snd_hda_create_hwdep(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001330
1331 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1332 codec->subsystem_id, codec->revision_id);
1333 snd_component_add(codec->bus->card, component);
1334
1335 if (codecp)
1336 *codecp = codec;
1337 return 0;
Takashi Iwai3be14142009-02-20 14:11:16 +01001338
1339 error:
1340 snd_hda_codec_free(codec);
1341 return err;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001342}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001343EXPORT_SYMBOL_HDA(snd_hda_codec_new);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001344
Takashi Iwaid5191e52009-11-16 14:58:17 +01001345/**
1346 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1347 * @codec: the HDA codec
1348 *
1349 * Start parsing of the given codec tree and (re-)initialize the whole
1350 * patch instance.
1351 *
1352 * Returns 0 if successful or a negative error code.
1353 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001354int snd_hda_codec_configure(struct hda_codec *codec)
1355{
1356 int err;
1357
Takashi Iwaid5ad6302007-03-07 15:55:59 +01001358 codec->preset = find_codec_preset(codec);
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001359 if (!codec->vendor_name || !codec->chip_name) {
Takashi Iwaif44ac832008-07-30 15:01:45 +02001360 err = get_codec_name(codec);
1361 if (err < 0)
1362 return err;
1363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Takashi Iwai82467612007-07-27 19:15:54 +02001365 if (is_generic_config(codec)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai82467612007-07-27 19:15:54 +02001367 goto patched;
1368 }
Takashi Iwai82467612007-07-27 19:15:54 +02001369 if (codec->preset && codec->preset->patch) {
1370 err = codec->preset->patch(codec);
1371 goto patched;
1372 }
1373
1374 /* call the default parser */
Takashi Iwai82467612007-07-27 19:15:54 +02001375 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai35a1e0c2007-10-19 08:13:40 +02001376 if (err < 0)
1377 printk(KERN_ERR "hda-codec: No codec parser is available\n");
Takashi Iwai82467612007-07-27 19:15:54 +02001378
1379 patched:
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001380 if (!err && codec->patch_ops.unsol_event)
1381 err = init_unsol_queue(codec->bus);
Takashi Iwaif62faed2009-12-23 09:27:51 +01001382 /* audio codec should override the mixer name */
1383 if (!err && (codec->afg || !*codec->bus->card->mixername))
1384 snprintf(codec->bus->card->mixername,
1385 sizeof(codec->bus->card->mixername),
1386 "%s %s", codec->vendor_name, codec->chip_name);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001387 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388}
Takashi Iwaia1e21c92009-06-17 09:33:52 +02001389EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390
1391/**
1392 * snd_hda_codec_setup_stream - set up the codec for streaming
1393 * @codec: the CODEC to set up
1394 * @nid: the NID to set up
1395 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1396 * @channel_id: channel id to pass, zero based.
1397 * @format: stream format.
1398 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001399void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1400 u32 stream_tag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 int channel_id, int format)
1402{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001403 struct hda_codec *c;
Takashi Iwaieb541332010-08-06 13:48:11 +02001404 struct hda_cvt_setup *p;
1405 unsigned int oldval, newval;
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001406 int type;
Takashi Iwaieb541332010-08-06 13:48:11 +02001407 int i;
1408
Takashi Iwai0ba21762007-04-16 11:29:14 +02001409 if (!nid)
Takashi Iwaid21b37e2005-04-20 13:45:55 +02001410 return;
1411
Takashi Iwai0ba21762007-04-16 11:29:14 +02001412 snd_printdd("hda_codec_setup_stream: "
1413 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 nid, stream_tag, channel_id, format);
Takashi Iwaieb541332010-08-06 13:48:11 +02001415 p = get_hda_cvt_setup(codec, nid);
1416 if (!p)
1417 return;
1418 /* update the stream-id if changed */
1419 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1420 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1421 newval = (stream_tag << 4) | channel_id;
1422 if (oldval != newval)
1423 snd_hda_codec_write(codec, nid, 0,
1424 AC_VERB_SET_CHANNEL_STREAMID,
1425 newval);
1426 p->stream_tag = stream_tag;
1427 p->channel_id = channel_id;
1428 }
1429 /* update the format-id if changed */
1430 if (p->format_id != format) {
1431 oldval = snd_hda_codec_read(codec, nid, 0,
1432 AC_VERB_GET_STREAM_FORMAT, 0);
1433 if (oldval != format) {
1434 msleep(1);
1435 snd_hda_codec_write(codec, nid, 0,
1436 AC_VERB_SET_STREAM_FORMAT,
1437 format);
1438 }
1439 p->format_id = format;
1440 }
1441 p->active = 1;
1442 p->dirty = 0;
1443
1444 /* make other inactive cvts with the same stream-tag dirty */
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001445 type = get_wcaps_type(get_wcaps(codec, nid));
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001446 list_for_each_entry(c, &codec->bus->codec_list, list) {
1447 for (i = 0; i < c->cvt_setups.used; i++) {
1448 p = snd_array_elem(&c->cvt_setups, i);
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001449 if (!p->active && p->stream_tag == stream_tag &&
1450 get_wcaps_type(get_wcaps(codec, p->nid)) == type)
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001451 p->dirty = 1;
1452 }
Takashi Iwaieb541332010-08-06 13:48:11 +02001453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001455EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
Takashi Iwaif0cea792010-08-13 11:56:53 +02001457static void really_cleanup_stream(struct hda_codec *codec,
1458 struct hda_cvt_setup *q);
1459
Takashi Iwaid5191e52009-11-16 14:58:17 +01001460/**
Takashi Iwaif0cea792010-08-13 11:56:53 +02001461 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
Takashi Iwaid5191e52009-11-16 14:58:17 +01001462 * @codec: the CODEC to clean up
1463 * @nid: the NID to clean up
Takashi Iwaif0cea792010-08-13 11:56:53 +02001464 * @do_now: really clean up the stream instead of clearing the active flag
Takashi Iwaid5191e52009-11-16 14:58:17 +01001465 */
Takashi Iwaif0cea792010-08-13 11:56:53 +02001466void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1467 int do_now)
Takashi Iwai888afa12008-03-18 09:57:50 +01001468{
Takashi Iwaieb541332010-08-06 13:48:11 +02001469 struct hda_cvt_setup *p;
1470
Takashi Iwai888afa12008-03-18 09:57:50 +01001471 if (!nid)
1472 return;
1473
Takashi Iwai0e7adbe2010-10-25 10:37:11 +02001474 if (codec->no_sticky_stream)
1475 do_now = 1;
1476
Takashi Iwai888afa12008-03-18 09:57:50 +01001477 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
Takashi Iwaieb541332010-08-06 13:48:11 +02001478 p = get_hda_cvt_setup(codec, nid);
Takashi Iwaif0cea792010-08-13 11:56:53 +02001479 if (p) {
1480 /* here we just clear the active flag when do_now isn't set;
1481 * actual clean-ups will be done later in
1482 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1483 */
1484 if (do_now)
1485 really_cleanup_stream(codec, p);
1486 else
1487 p->active = 0;
1488 }
Takashi Iwai888afa12008-03-18 09:57:50 +01001489}
Takashi Iwaif0cea792010-08-13 11:56:53 +02001490EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
Takashi Iwai888afa12008-03-18 09:57:50 +01001491
Takashi Iwaieb541332010-08-06 13:48:11 +02001492static void really_cleanup_stream(struct hda_codec *codec,
1493 struct hda_cvt_setup *q)
1494{
1495 hda_nid_t nid = q->nid;
Takashi Iwai218264a2011-09-27 17:33:45 +02001496 if (q->stream_tag || q->channel_id)
1497 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1498 if (q->format_id)
1499 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1500);
Takashi Iwaieb541332010-08-06 13:48:11 +02001501 memset(q, 0, sizeof(*q));
1502 q->nid = nid;
1503}
1504
1505/* clean up the all conflicting obsolete streams */
1506static void purify_inactive_streams(struct hda_codec *codec)
1507{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001508 struct hda_codec *c;
Takashi Iwaieb541332010-08-06 13:48:11 +02001509 int i;
1510
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001511 list_for_each_entry(c, &codec->bus->codec_list, list) {
1512 for (i = 0; i < c->cvt_setups.used; i++) {
1513 struct hda_cvt_setup *p;
1514 p = snd_array_elem(&c->cvt_setups, i);
1515 if (p->dirty)
1516 really_cleanup_stream(c, p);
1517 }
Takashi Iwaieb541332010-08-06 13:48:11 +02001518 }
1519}
1520
Takashi Iwai2a439522011-07-26 09:52:50 +02001521#ifdef CONFIG_PM
Takashi Iwaieb541332010-08-06 13:48:11 +02001522/* clean up all streams; called from suspend */
1523static void hda_cleanup_all_streams(struct hda_codec *codec)
1524{
1525 int i;
1526
1527 for (i = 0; i < codec->cvt_setups.used; i++) {
1528 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1529 if (p->stream_tag)
1530 really_cleanup_stream(codec, p);
1531 }
1532}
Mike Waychison1c7276c2011-04-20 12:04:36 -07001533#endif
Takashi Iwaieb541332010-08-06 13:48:11 +02001534
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535/*
1536 * amp access functions
1537 */
1538
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001539/* FIXME: more better hash key? */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01001540#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
Takashi Iwai1327a322009-03-23 13:07:47 +01001541#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001542#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1543#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544#define INFO_AMP_CAPS (1<<0)
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001545#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
1547/* initialize the hash table */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001548static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
Takashi Iwai01751f52007-08-10 16:59:39 +02001549 unsigned int record_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550{
Takashi Iwai01751f52007-08-10 16:59:39 +02001551 memset(cache, 0, sizeof(*cache));
1552 memset(cache->hash, 0xff, sizeof(cache->hash));
Takashi Iwai603c4012008-07-30 15:01:44 +02001553 snd_array_init(&cache->buf, record_size, 64);
Takashi Iwai01751f52007-08-10 16:59:39 +02001554}
1555
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001556static void free_hda_cache(struct hda_cache_rec *cache)
Takashi Iwai01751f52007-08-10 16:59:39 +02001557{
Takashi Iwai603c4012008-07-30 15:01:44 +02001558 snd_array_free(&cache->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559}
1560
1561/* query the hash. allocate an entry if not found. */
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001562static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563{
Takashi Iwai01751f52007-08-10 16:59:39 +02001564 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1565 u16 cur = cache->hash[idx];
1566 struct hda_cache_head *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
1568 while (cur != 0xffff) {
Takashi Iwaif43aa022008-11-10 16:24:26 +01001569 info = snd_array_elem(&cache->buf, cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 if (info->key == key)
1571 return info;
1572 cur = info->next;
1573 }
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001574 return NULL;
1575}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001577/* query the hash. allocate an entry if not found. */
1578static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1579 u32 key)
1580{
1581 struct hda_cache_head *info = get_hash(cache, key);
1582 if (!info) {
1583 u16 idx, cur;
1584 /* add a new hash entry */
1585 info = snd_array_new(&cache->buf);
1586 if (!info)
1587 return NULL;
1588 cur = snd_array_index(&cache->buf, info);
1589 info->key = key;
1590 info->val = 0;
1591 idx = key % (u16)ARRAY_SIZE(cache->hash);
1592 info->next = cache->hash[idx];
1593 cache->hash[idx] = cur;
1594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 return info;
1596}
1597
Takashi Iwai01751f52007-08-10 16:59:39 +02001598/* query and allocate an amp hash entry */
1599static inline struct hda_amp_info *
1600get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1601{
1602 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1603}
1604
Takashi Iwaid5191e52009-11-16 14:58:17 +01001605/**
1606 * query_amp_caps - query AMP capabilities
1607 * @codec: the HD-auio codec
1608 * @nid: the NID to query
1609 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1610 *
1611 * Query AMP capabilities for the given widget and direction.
1612 * Returns the obtained capability bits.
1613 *
1614 * When cap bits have been already read, this doesn't read again but
1615 * returns the cached value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 */
Matthew Ranostay09a99952008-01-24 11:49:21 +01001617u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001619 struct hda_amp_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
Takashi Iwai0ba21762007-04-16 11:29:14 +02001621 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1622 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 return 0;
Takashi Iwai01751f52007-08-10 16:59:39 +02001624 if (!(info->head.val & INFO_AMP_CAPS)) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001625 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 nid = codec->afg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001627 info->amp_caps = snd_hda_param_read(codec, nid,
1628 direction == HDA_OUTPUT ?
1629 AC_PAR_AMP_OUT_CAP :
1630 AC_PAR_AMP_IN_CAP);
Takashi Iwaib75e53f2007-05-10 16:56:09 +02001631 if (info->amp_caps)
Takashi Iwai01751f52007-08-10 16:59:39 +02001632 info->head.val |= INFO_AMP_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 }
1634 return info->amp_caps;
1635}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001636EXPORT_SYMBOL_HDA(query_amp_caps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Takashi Iwaid5191e52009-11-16 14:58:17 +01001638/**
1639 * snd_hda_override_amp_caps - Override the AMP capabilities
1640 * @codec: the CODEC to clean up
1641 * @nid: the NID to clean up
1642 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1643 * @caps: the capability bits to set
1644 *
1645 * Override the cached AMP caps bits value by the given one.
1646 * This function is useful if the driver needs to adjust the AMP ranges,
1647 * e.g. limit to 0dB, etc.
1648 *
1649 * Returns zero if successful or a negative error code.
1650 */
Takashi Iwai897cc182007-05-29 19:01:37 +02001651int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1652 unsigned int caps)
1653{
1654 struct hda_amp_info *info;
1655
1656 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1657 if (!info)
1658 return -EINVAL;
1659 info->amp_caps = caps;
Takashi Iwai01751f52007-08-10 16:59:39 +02001660 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai897cc182007-05-29 19:01:37 +02001661 return 0;
1662}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001663EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
Takashi Iwai897cc182007-05-29 19:01:37 +02001664
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001665static unsigned int
1666query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1667 unsigned int (*func)(struct hda_codec *, hda_nid_t))
Takashi Iwai1327a322009-03-23 13:07:47 +01001668{
1669 struct hda_amp_info *info;
1670
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001671 info = get_alloc_amp_hash(codec, key);
Takashi Iwai1327a322009-03-23 13:07:47 +01001672 if (!info)
1673 return 0;
1674 if (!info->head.val) {
Takashi Iwai1327a322009-03-23 13:07:47 +01001675 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001676 info->amp_caps = func(codec, nid);
Takashi Iwai1327a322009-03-23 13:07:47 +01001677 }
1678 return info->amp_caps;
1679}
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001680
1681static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1682{
1683 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1684}
1685
Takashi Iwaid5191e52009-11-16 14:58:17 +01001686/**
1687 * snd_hda_query_pin_caps - Query PIN capabilities
1688 * @codec: the HD-auio codec
1689 * @nid: the NID to query
1690 *
1691 * Query PIN capabilities for the given widget.
1692 * Returns the obtained capability bits.
1693 *
1694 * When cap bits have been already read, this doesn't read again but
1695 * returns the cached value.
1696 */
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001697u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1698{
1699 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1700 read_pin_cap);
1701}
Takashi Iwai1327a322009-03-23 13:07:47 +01001702EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1703
Wu Fengguang864f92b2009-11-18 12:38:02 +08001704/**
Takashi Iwaif57c2562011-08-15 12:49:07 +02001705 * snd_hda_override_pin_caps - Override the pin capabilities
1706 * @codec: the CODEC
1707 * @nid: the NID to override
1708 * @caps: the capability bits to set
1709 *
1710 * Override the cached PIN capabilitiy bits value by the given one.
1711 *
1712 * Returns zero if successful or a negative error code.
1713 */
1714int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1715 unsigned int caps)
1716{
1717 struct hda_amp_info *info;
1718 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1719 if (!info)
1720 return -ENOMEM;
1721 info->amp_caps = caps;
1722 info->head.val |= INFO_AMP_CAPS;
1723 return 0;
1724}
1725EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1726
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727/*
1728 * read the current volume to info
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001729 * if the cache exists, read the cache value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001731static unsigned int get_vol_mute(struct hda_codec *codec,
1732 struct hda_amp_info *info, hda_nid_t nid,
1733 int ch, int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734{
1735 u32 val, parm;
1736
Takashi Iwai01751f52007-08-10 16:59:39 +02001737 if (info->head.val & INFO_AMP_VOL(ch))
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001738 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739
1740 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1741 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1742 parm |= index;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001743 val = snd_hda_codec_read(codec, nid, 0,
1744 AC_VERB_GET_AMP_GAIN_MUTE, parm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 info->vol[ch] = val & 0xff;
Takashi Iwai01751f52007-08-10 16:59:39 +02001746 info->head.val |= INFO_AMP_VOL(ch);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001747 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748}
1749
1750/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001751 * write the current volume in info to the h/w and update the cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 */
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001753static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
Takashi Iwai0ba21762007-04-16 11:29:14 +02001754 hda_nid_t nid, int ch, int direction, int index,
1755 int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756{
1757 u32 parm;
1758
1759 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1760 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1761 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1762 parm |= val;
1763 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001764 info->vol[ch] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765}
1766
Takashi Iwaid5191e52009-11-16 14:58:17 +01001767/**
1768 * snd_hda_codec_amp_read - Read AMP value
1769 * @codec: HD-audio codec
1770 * @nid: NID to read the AMP value
1771 * @ch: channel (left=0 or right=1)
1772 * @direction: #HDA_INPUT or #HDA_OUTPUT
1773 * @index: the index value (only for input direction)
1774 *
1775 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 */
Takashi Iwai834be882006-03-01 14:16:17 +01001777int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1778 int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001780 struct hda_amp_info *info;
1781 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1782 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001784 return get_vol_mute(codec, info, nid, ch, direction, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001786EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787
Takashi Iwaid5191e52009-11-16 14:58:17 +01001788/**
1789 * snd_hda_codec_amp_update - update the AMP value
1790 * @codec: HD-audio codec
1791 * @nid: NID to read the AMP value
1792 * @ch: channel (left=0 or right=1)
1793 * @direction: #HDA_INPUT or #HDA_OUTPUT
1794 * @idx: the index value (only for input direction)
1795 * @mask: bit mask to set
1796 * @val: the bits value to set
1797 *
1798 * Update the AMP value with a bit mask.
1799 * Returns 0 if the value is unchanged, 1 if changed.
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001800 */
Takashi Iwai834be882006-03-01 14:16:17 +01001801int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1802 int direction, int idx, int mask, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001804 struct hda_amp_info *info;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001805
Takashi Iwai0ba21762007-04-16 11:29:14 +02001806 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1807 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 return 0;
Takashi Iwai46712642010-03-29 09:19:38 +02001809 if (snd_BUG_ON(mask & ~0xff))
1810 mask &= 0xff;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001811 val &= mask;
1812 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001813 if (info->vol[ch] == val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001815 put_vol_mute(codec, info, nid, ch, direction, idx, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 return 1;
1817}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001818EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819
Takashi Iwaid5191e52009-11-16 14:58:17 +01001820/**
1821 * snd_hda_codec_amp_stereo - update the AMP stereo values
1822 * @codec: HD-audio codec
1823 * @nid: NID to read the AMP value
1824 * @direction: #HDA_INPUT or #HDA_OUTPUT
1825 * @idx: the index value (only for input direction)
1826 * @mask: bit mask to set
1827 * @val: the bits value to set
1828 *
1829 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1830 * stereo widget with the same mask and value.
Takashi Iwai47fd8302007-08-10 17:11:07 +02001831 */
1832int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1833 int direction, int idx, int mask, int val)
1834{
1835 int ch, ret = 0;
Takashi Iwai46712642010-03-29 09:19:38 +02001836
1837 if (snd_BUG_ON(mask & ~0xff))
1838 mask &= 0xff;
Takashi Iwai47fd8302007-08-10 17:11:07 +02001839 for (ch = 0; ch < 2; ch++)
1840 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1841 idx, mask, val);
1842 return ret;
1843}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001844EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
Takashi Iwai47fd8302007-08-10 17:11:07 +02001845
Takashi Iwai2a439522011-07-26 09:52:50 +02001846#ifdef CONFIG_PM
Takashi Iwaid5191e52009-11-16 14:58:17 +01001847/**
1848 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1849 * @codec: HD-audio codec
1850 *
1851 * Resume the all amp commands from the cache.
1852 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001853void snd_hda_codec_resume_amp(struct hda_codec *codec)
1854{
Takashi Iwai603c4012008-07-30 15:01:44 +02001855 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001856 int i;
1857
Takashi Iwai603c4012008-07-30 15:01:44 +02001858 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001859 u32 key = buffer->head.key;
1860 hda_nid_t nid;
1861 unsigned int idx, dir, ch;
1862 if (!key)
1863 continue;
1864 nid = key & 0xff;
1865 idx = (key >> 16) & 0xff;
1866 dir = (key >> 24) & 0xff;
1867 for (ch = 0; ch < 2; ch++) {
1868 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1869 continue;
1870 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1871 buffer->vol[ch]);
1872 }
1873 }
1874}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001875EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
Takashi Iwai2a439522011-07-26 09:52:50 +02001876#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001878static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1879 unsigned int ofs)
1880{
1881 u32 caps = query_amp_caps(codec, nid, dir);
1882 /* get num steps */
1883 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1884 if (ofs < caps)
1885 caps -= ofs;
1886 return caps;
1887}
1888
Takashi Iwaid5191e52009-11-16 14:58:17 +01001889/**
1890 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1891 *
1892 * The control element is supposed to have the private_value field
1893 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1894 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001895int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1899 u16 nid = get_amp_nid(kcontrol);
1900 u8 chs = get_amp_channels(kcontrol);
1901 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001902 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001904 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1905 uinfo->count = chs == 3 ? 2 : 1;
1906 uinfo->value.integer.min = 0;
1907 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1908 if (!uinfo->value.integer.max) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001909 printk(KERN_WARNING "hda_codec: "
Takashi Iwai9c8f2ab2008-01-11 16:12:23 +01001910 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1911 kcontrol->id.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 return -EINVAL;
1913 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 return 0;
1915}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001916EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001918
1919static inline unsigned int
1920read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1921 int ch, int dir, int idx, unsigned int ofs)
1922{
1923 unsigned int val;
1924 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1925 val &= HDA_AMP_VOLMASK;
1926 if (val >= ofs)
1927 val -= ofs;
1928 else
1929 val = 0;
1930 return val;
1931}
1932
1933static inline int
1934update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1935 int ch, int dir, int idx, unsigned int ofs,
1936 unsigned int val)
1937{
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001938 unsigned int maxval;
1939
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001940 if (val > 0)
1941 val += ofs;
Takashi Iwai7ccc3ef2010-07-26 17:00:15 +02001942 /* ofs = 0: raw max value */
1943 maxval = get_amp_max_value(codec, nid, dir, 0);
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001944 if (val > maxval)
1945 val = maxval;
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001946 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1947 HDA_AMP_VOLMASK, val);
1948}
1949
Takashi Iwaid5191e52009-11-16 14:58:17 +01001950/**
1951 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1952 *
1953 * The control element is supposed to have the private_value field
1954 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1955 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001956int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1957 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958{
1959 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1960 hda_nid_t nid = get_amp_nid(kcontrol);
1961 int chs = get_amp_channels(kcontrol);
1962 int dir = get_amp_direction(kcontrol);
1963 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001964 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 long *valp = ucontrol->value.integer.value;
1966
1967 if (chs & 1)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001968 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001970 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 return 0;
1972}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001973EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974
Takashi Iwaid5191e52009-11-16 14:58:17 +01001975/**
1976 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1977 *
1978 * The control element is supposed to have the private_value field
1979 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1980 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001981int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1982 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983{
1984 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1985 hda_nid_t nid = get_amp_nid(kcontrol);
1986 int chs = get_amp_channels(kcontrol);
1987 int dir = get_amp_direction(kcontrol);
1988 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001989 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 long *valp = ucontrol->value.integer.value;
1991 int change = 0;
1992
Takashi Iwaicb53c622007-08-10 17:21:45 +02001993 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001994 if (chs & 1) {
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001995 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001996 valp++;
1997 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001998 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001999 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002000 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 return change;
2002}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002003EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
Takashi Iwaid5191e52009-11-16 14:58:17 +01002005/**
2006 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2007 *
2008 * The control element is supposed to have the private_value field
2009 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2010 */
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002011int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2012 unsigned int size, unsigned int __user *_tlv)
2013{
2014 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2015 hda_nid_t nid = get_amp_nid(kcontrol);
2016 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002017 unsigned int ofs = get_amp_offset(kcontrol);
Clemens Ladischde8c85f2010-10-15 10:32:50 +02002018 bool min_mute = get_amp_min_mute(kcontrol);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002019 u32 caps, val1, val2;
2020
2021 if (size < 4 * sizeof(unsigned int))
2022 return -ENOMEM;
2023 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002024 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2025 val2 = (val2 + 1) * 25;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002026 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002027 val1 += ofs;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002028 val1 = ((int)val1) * ((int)val2);
Clemens Ladischde8c85f2010-10-15 10:32:50 +02002029 if (min_mute)
Takashi Iwaic08d9162010-10-17 10:40:53 +02002030 val2 |= TLV_DB_SCALE_MUTE;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002031 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2032 return -EFAULT;
2033 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2034 return -EFAULT;
2035 if (put_user(val1, _tlv + 2))
2036 return -EFAULT;
2037 if (put_user(val2, _tlv + 3))
2038 return -EFAULT;
2039 return 0;
2040}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002041EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002042
Takashi Iwaid5191e52009-11-16 14:58:17 +01002043/**
2044 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2045 * @codec: HD-audio codec
2046 * @nid: NID of a reference widget
2047 * @dir: #HDA_INPUT or #HDA_OUTPUT
2048 * @tlv: TLV data to be stored, at least 4 elements
2049 *
2050 * Set (static) TLV data for a virtual master volume using the AMP caps
2051 * obtained from the reference NID.
2052 * The volume range is recalculated as if the max volume is 0dB.
Takashi Iwai2134ea42008-01-10 16:53:55 +01002053 */
2054void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2055 unsigned int *tlv)
2056{
2057 u32 caps;
2058 int nums, step;
2059
2060 caps = query_amp_caps(codec, nid, dir);
2061 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2062 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2063 step = (step + 1) * 25;
2064 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2065 tlv[1] = 2 * sizeof(unsigned int);
2066 tlv[2] = -nums * step;
2067 tlv[3] = step;
2068}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002069EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002070
2071/* find a mixer control element with the given name */
Takashi Iwai09f99702008-02-04 12:31:13 +01002072static struct snd_kcontrol *
2073_snd_hda_find_mixer_ctl(struct hda_codec *codec,
2074 const char *name, int idx)
Takashi Iwai2134ea42008-01-10 16:53:55 +01002075{
2076 struct snd_ctl_elem_id id;
2077 memset(&id, 0, sizeof(id));
2078 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
Takashi Iwai09f99702008-02-04 12:31:13 +01002079 id.index = idx;
Takashi Iwai18cb7102009-04-16 10:22:24 +02002080 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2081 return NULL;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002082 strcpy(id.name, name);
2083 return snd_ctl_find_id(codec->bus->card, &id);
2084}
2085
Takashi Iwaid5191e52009-11-16 14:58:17 +01002086/**
2087 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2088 * @codec: HD-audio codec
2089 * @name: ctl id name string
2090 *
2091 * Get the control element with the given id string and IFACE_MIXER.
2092 */
Takashi Iwai09f99702008-02-04 12:31:13 +01002093struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2094 const char *name)
2095{
2096 return _snd_hda_find_mixer_ctl(codec, name, 0);
2097}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002098EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
Takashi Iwai09f99702008-02-04 12:31:13 +01002099
Takashi Iwai1afe2062010-12-23 10:17:52 +01002100static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2101{
2102 int idx;
2103 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2104 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2105 return idx;
2106 }
2107 return -EBUSY;
2108}
2109
Takashi Iwaid5191e52009-11-16 14:58:17 +01002110/**
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002111 * snd_hda_ctl_add - Add a control element and assign to the codec
Takashi Iwaid5191e52009-11-16 14:58:17 +01002112 * @codec: HD-audio codec
2113 * @nid: corresponding NID (optional)
2114 * @kctl: the control element to assign
2115 *
2116 * Add the given control element to an array inside the codec instance.
2117 * All control elements belonging to a codec are supposed to be added
2118 * by this function so that a proper clean-up works at the free or
2119 * reconfiguration time.
2120 *
2121 * If non-zero @nid is passed, the NID is assigned to the control element.
2122 * The assignment is shown in the codec proc file.
2123 *
2124 * snd_hda_ctl_add() checks the control subdev id field whether
2125 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002126 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2127 * specifies if kctl->private_value is a HDA amplifier value.
Takashi Iwaid5191e52009-11-16 14:58:17 +01002128 */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002129int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2130 struct snd_kcontrol *kctl)
Takashi Iwaid13bd412008-07-30 15:01:45 +02002131{
2132 int err;
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002133 unsigned short flags = 0;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002134 struct hda_nid_item *item;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002135
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002136 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002137 flags |= HDA_NID_ITEM_AMP;
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002138 if (nid == 0)
2139 nid = get_amp_nid_(kctl->private_value);
2140 }
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002141 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2142 nid = kctl->id.subdevice & 0xffff;
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002143 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01002144 kctl->id.subdevice = 0;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002145 err = snd_ctl_add(codec->bus->card, kctl);
2146 if (err < 0)
2147 return err;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002148 item = snd_array_new(&codec->mixers);
2149 if (!item)
Takashi Iwaid13bd412008-07-30 15:01:45 +02002150 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002151 item->kctl = kctl;
2152 item->nid = nid;
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002153 item->flags = flags;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002154 return 0;
2155}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002156EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002157
Takashi Iwaid5191e52009-11-16 14:58:17 +01002158/**
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002159 * snd_hda_add_nid - Assign a NID to a control element
2160 * @codec: HD-audio codec
2161 * @nid: corresponding NID (optional)
2162 * @kctl: the control element to assign
2163 * @index: index to kctl
2164 *
2165 * Add the given control element to an array inside the codec instance.
2166 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2167 * NID:KCTL mapping - for example "Capture Source" selector.
2168 */
2169int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2170 unsigned int index, hda_nid_t nid)
2171{
2172 struct hda_nid_item *item;
2173
2174 if (nid > 0) {
2175 item = snd_array_new(&codec->nids);
2176 if (!item)
2177 return -ENOMEM;
2178 item->kctl = kctl;
2179 item->index = index;
2180 item->nid = nid;
2181 return 0;
2182 }
Takashi Iwai28d1a852010-03-15 09:05:46 +01002183 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2184 kctl->id.name, kctl->id.index, index);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002185 return -EINVAL;
2186}
2187EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2188
2189/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01002190 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2191 * @codec: HD-audio codec
2192 */
Takashi Iwaid13bd412008-07-30 15:01:45 +02002193void snd_hda_ctls_clear(struct hda_codec *codec)
2194{
2195 int i;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002196 struct hda_nid_item *items = codec->mixers.list;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002197 for (i = 0; i < codec->mixers.used; i++)
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002198 snd_ctl_remove(codec->bus->card, items[i].kctl);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002199 snd_array_free(&codec->mixers);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002200 snd_array_free(&codec->nids);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002201}
2202
Takashi Iwaia65d6292009-02-23 16:57:04 +01002203/* pseudo device locking
2204 * toggle card->shutdown to allow/disallow the device access (as a hack)
2205 */
2206static int hda_lock_devices(struct snd_card *card)
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002207{
Takashi Iwaia65d6292009-02-23 16:57:04 +01002208 spin_lock(&card->files_lock);
2209 if (card->shutdown) {
2210 spin_unlock(&card->files_lock);
2211 return -EINVAL;
2212 }
2213 card->shutdown = 1;
2214 spin_unlock(&card->files_lock);
2215 return 0;
2216}
2217
2218static void hda_unlock_devices(struct snd_card *card)
2219{
2220 spin_lock(&card->files_lock);
2221 card->shutdown = 0;
2222 spin_unlock(&card->files_lock);
2223}
2224
Takashi Iwaid5191e52009-11-16 14:58:17 +01002225/**
2226 * snd_hda_codec_reset - Clear all objects assigned to the codec
2227 * @codec: HD-audio codec
2228 *
2229 * This frees the all PCM and control elements assigned to the codec, and
2230 * clears the caches and restores the pin default configurations.
2231 *
2232 * When a device is being used, it returns -EBSY. If successfully freed,
2233 * returns zero.
2234 */
Takashi Iwaia65d6292009-02-23 16:57:04 +01002235int snd_hda_codec_reset(struct hda_codec *codec)
2236{
2237 struct snd_card *card = codec->bus->card;
2238 int i, pcm;
2239
2240 if (hda_lock_devices(card) < 0)
2241 return -EBUSY;
2242 /* check whether the codec isn't used by any mixer or PCM streams */
2243 if (!list_empty(&card->ctl_files)) {
2244 hda_unlock_devices(card);
2245 return -EBUSY;
2246 }
2247 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2248 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2249 if (!cpcm->pcm)
2250 continue;
2251 if (cpcm->pcm->streams[0].substream_opened ||
2252 cpcm->pcm->streams[1].substream_opened) {
2253 hda_unlock_devices(card);
2254 return -EBUSY;
2255 }
2256 }
2257
2258 /* OK, let it free */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002259
2260#ifdef CONFIG_SND_HDA_POWER_SAVE
2261 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01002262 flush_workqueue(codec->bus->workq);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002263#endif
2264 snd_hda_ctls_clear(codec);
2265 /* relase PCMs */
2266 for (i = 0; i < codec->num_pcms; i++) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002267 if (codec->pcm_info[i].pcm) {
Takashi Iwaia65d6292009-02-23 16:57:04 +01002268 snd_device_free(card, codec->pcm_info[i].pcm);
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002269 clear_bit(codec->pcm_info[i].device,
2270 codec->bus->pcm_dev_bits);
2271 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002272 }
2273 if (codec->patch_ops.free)
2274 codec->patch_ops.free(codec);
Takashi Iwai1835a0f2011-10-27 22:12:46 +02002275 snd_hda_jack_tbl_clear(codec);
Takashi Iwai56d17712008-11-28 14:36:23 +01002276 codec->proc_widget_hook = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002277 codec->spec = NULL;
2278 free_hda_cache(&codec->amp_cache);
2279 free_hda_cache(&codec->cmd_cache);
Takashi Iwai827057f2008-12-19 10:12:02 +01002280 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2281 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwai346ff702009-02-23 09:42:57 +01002282 /* free only driver_pins so that init_pins + user_pins are restored */
2283 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01002284 restore_pincfgs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002285 codec->num_pcms = 0;
2286 codec->pcm_info = NULL;
2287 codec->preset = NULL;
Takashi Iwaid1f1af22009-03-02 10:35:29 +01002288 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2289 codec->slave_dig_outs = NULL;
2290 codec->spdif_status_reset = 0;
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002291 module_put(codec->owner);
2292 codec->owner = NULL;
Takashi Iwaia65d6292009-02-23 16:57:04 +01002293
2294 /* allow device access again */
2295 hda_unlock_devices(card);
2296 return 0;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002297}
2298
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002299typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2300
2301/* apply the function to all matching slave ctls in the mixer list */
2302static int map_slaves(struct hda_codec *codec, const char * const *slaves,
2303 map_slave_func_t func, void *data)
2304{
2305 struct hda_nid_item *items;
2306 const char * const *s;
2307 int i, err;
2308
2309 items = codec->mixers.list;
2310 for (i = 0; i < codec->mixers.used; i++) {
2311 struct snd_kcontrol *sctl = items[i].kctl;
2312 if (!sctl || !sctl->id.name ||
2313 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2314 continue;
2315 for (s = slaves; *s; s++) {
2316 if (!strcmp(sctl->id.name, *s)) {
2317 err = func(data, sctl);
2318 if (err)
2319 return err;
2320 break;
2321 }
2322 }
2323 }
2324 return 0;
2325}
2326
2327static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2328{
2329 return 1;
2330}
2331
Takashi Iwaid5191e52009-11-16 14:58:17 +01002332/**
2333 * snd_hda_add_vmaster - create a virtual master control and add slaves
2334 * @codec: HD-audio codec
2335 * @name: vmaster control name
2336 * @tlv: TLV data (optional)
2337 * @slaves: slave control names (optional)
2338 *
2339 * Create a virtual master control with the given name. The TLV data
2340 * must be either NULL or a valid data.
2341 *
2342 * @slaves is a NULL-terminated array of strings, each of which is a
2343 * slave control name. All controls with these names are assigned to
2344 * the new virtual master control.
2345 *
2346 * This function returns zero if successful or a negative error code.
2347 */
Takashi Iwai2134ea42008-01-10 16:53:55 +01002348int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
Takashi Iwaiea734962011-01-17 11:29:34 +01002349 unsigned int *tlv, const char * const *slaves)
Takashi Iwai2134ea42008-01-10 16:53:55 +01002350{
2351 struct snd_kcontrol *kctl;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002352 int err;
2353
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002354 err = map_slaves(codec, slaves, check_slave_present, NULL);
2355 if (err != 1) {
Takashi Iwai2f085542008-02-22 18:43:50 +01002356 snd_printdd("No slave found for %s\n", name);
2357 return 0;
2358 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01002359 kctl = snd_ctl_make_virtual_master(name, tlv);
2360 if (!kctl)
2361 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002362 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002363 if (err < 0)
2364 return err;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002365
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002366 err = map_slaves(codec, slaves, (map_slave_func_t)snd_ctl_add_slave,
2367 kctl);
2368 if (err < 0)
2369 return err;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002370 return 0;
2371}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002372EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002373
Takashi Iwaid5191e52009-11-16 14:58:17 +01002374/**
2375 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2376 *
2377 * The control element is supposed to have the private_value field
2378 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2379 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002380int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2381 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382{
2383 int chs = get_amp_channels(kcontrol);
2384
2385 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2386 uinfo->count = chs == 3 ? 2 : 1;
2387 uinfo->value.integer.min = 0;
2388 uinfo->value.integer.max = 1;
2389 return 0;
2390}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002391EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Takashi Iwaid5191e52009-11-16 14:58:17 +01002393/**
2394 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2395 *
2396 * The control element is supposed to have the private_value field
2397 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2398 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002399int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2400 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401{
2402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2403 hda_nid_t nid = get_amp_nid(kcontrol);
2404 int chs = get_amp_channels(kcontrol);
2405 int dir = get_amp_direction(kcontrol);
2406 int idx = get_amp_index(kcontrol);
2407 long *valp = ucontrol->value.integer.value;
2408
2409 if (chs & 1)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002410 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02002411 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 if (chs & 2)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002413 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02002414 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 return 0;
2416}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002417EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418
Takashi Iwaid5191e52009-11-16 14:58:17 +01002419/**
2420 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2421 *
2422 * The control element is supposed to have the private_value field
2423 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2424 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002425int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2426 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427{
2428 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2429 hda_nid_t nid = get_amp_nid(kcontrol);
2430 int chs = get_amp_channels(kcontrol);
2431 int dir = get_amp_direction(kcontrol);
2432 int idx = get_amp_index(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 long *valp = ucontrol->value.integer.value;
2434 int change = 0;
2435
Takashi Iwaicb53c622007-08-10 17:21:45 +02002436 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02002437 if (chs & 1) {
Takashi Iwai4a19fae2005-06-08 14:43:58 +02002438 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02002439 HDA_AMP_MUTE,
2440 *valp ? 0 : HDA_AMP_MUTE);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02002441 valp++;
2442 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02002443 if (chs & 2)
2444 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02002445 HDA_AMP_MUTE,
2446 *valp ? 0 : HDA_AMP_MUTE);
Takashi Iwai9e5341b2010-09-21 09:57:06 +02002447 hda_call_check_power_status(codec, nid);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002448 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 return change;
2450}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002451EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452
Takashi Iwai67d634c2009-11-16 15:35:59 +01002453#ifdef CONFIG_SND_HDA_INPUT_BEEP
Takashi Iwaid5191e52009-11-16 14:58:17 +01002454/**
2455 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2456 *
2457 * This function calls snd_hda_enable_beep_device(), which behaves differently
2458 * depending on beep_mode option.
2459 */
Jaroslav Kysela123c07a2009-10-21 14:48:23 +02002460int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2461 struct snd_ctl_elem_value *ucontrol)
2462{
2463 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2464 long *valp = ucontrol->value.integer.value;
2465
2466 snd_hda_enable_beep_device(codec, *valp);
2467 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2468}
2469EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
Takashi Iwai67d634c2009-11-16 15:35:59 +01002470#endif /* CONFIG_SND_HDA_INPUT_BEEP */
Jaroslav Kysela123c07a2009-10-21 14:48:23 +02002471
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472/*
Takashi Iwai985be542005-11-02 18:26:49 +01002473 * bound volume controls
2474 *
2475 * bind multiple volumes (# indices, from 0)
2476 */
2477
2478#define AMP_VAL_IDX_SHIFT 19
2479#define AMP_VAL_IDX_MASK (0x0f<<19)
2480
Takashi Iwaid5191e52009-11-16 14:58:17 +01002481/**
2482 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2483 *
2484 * The control element is supposed to have the private_value field
2485 * set up via HDA_BIND_MUTE*() macros.
2486 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002487int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2488 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01002489{
2490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2491 unsigned long pval;
2492 int err;
2493
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002494 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002495 pval = kcontrol->private_value;
2496 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2497 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2498 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002499 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002500 return err;
2501}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002502EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
Takashi Iwai985be542005-11-02 18:26:49 +01002503
Takashi Iwaid5191e52009-11-16 14:58:17 +01002504/**
2505 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2506 *
2507 * The control element is supposed to have the private_value field
2508 * set up via HDA_BIND_MUTE*() macros.
2509 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002510int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2511 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01002512{
2513 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2514 unsigned long pval;
2515 int i, indices, err = 0, change = 0;
2516
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002517 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002518 pval = kcontrol->private_value;
2519 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2520 for (i = 0; i < indices; i++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002521 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2522 (i << AMP_VAL_IDX_SHIFT);
Takashi Iwai985be542005-11-02 18:26:49 +01002523 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2524 if (err < 0)
2525 break;
2526 change |= err;
2527 }
2528 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002529 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002530 return err < 0 ? err : change;
2531}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002532EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
Takashi Iwai985be542005-11-02 18:26:49 +01002533
Takashi Iwaid5191e52009-11-16 14:58:17 +01002534/**
2535 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2536 *
2537 * The control element is supposed to have the private_value field
2538 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
Takashi Iwai532d5382007-07-27 19:02:40 +02002539 */
2540int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2541 struct snd_ctl_elem_info *uinfo)
2542{
2543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2544 struct hda_bind_ctls *c;
2545 int err;
2546
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002547 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002548 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002549 kcontrol->private_value = *c->values;
2550 err = c->ops->info(kcontrol, uinfo);
2551 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002552 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002553 return err;
2554}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002555EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
Takashi Iwai532d5382007-07-27 19:02:40 +02002556
Takashi Iwaid5191e52009-11-16 14:58:17 +01002557/**
2558 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2559 *
2560 * The control element is supposed to have the private_value field
2561 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2562 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002563int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2564 struct snd_ctl_elem_value *ucontrol)
2565{
2566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2567 struct hda_bind_ctls *c;
2568 int err;
2569
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002570 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002571 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002572 kcontrol->private_value = *c->values;
2573 err = c->ops->get(kcontrol, ucontrol);
2574 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002575 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002576 return err;
2577}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002578EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
Takashi Iwai532d5382007-07-27 19:02:40 +02002579
Takashi Iwaid5191e52009-11-16 14:58:17 +01002580/**
2581 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2582 *
2583 * The control element is supposed to have the private_value field
2584 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2585 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002586int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2587 struct snd_ctl_elem_value *ucontrol)
2588{
2589 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2590 struct hda_bind_ctls *c;
2591 unsigned long *vals;
2592 int err = 0, change = 0;
2593
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002594 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002595 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002596 for (vals = c->values; *vals; vals++) {
2597 kcontrol->private_value = *vals;
2598 err = c->ops->put(kcontrol, ucontrol);
2599 if (err < 0)
2600 break;
2601 change |= err;
2602 }
2603 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002604 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002605 return err < 0 ? err : change;
2606}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002607EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
Takashi Iwai532d5382007-07-27 19:02:40 +02002608
Takashi Iwaid5191e52009-11-16 14:58:17 +01002609/**
2610 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2611 *
2612 * The control element is supposed to have the private_value field
2613 * set up via HDA_BIND_VOL() macro.
2614 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002615int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2616 unsigned int size, unsigned int __user *tlv)
2617{
2618 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2619 struct hda_bind_ctls *c;
2620 int err;
2621
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002622 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002623 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002624 kcontrol->private_value = *c->values;
2625 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2626 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002627 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002628 return err;
2629}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002630EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
Takashi Iwai532d5382007-07-27 19:02:40 +02002631
2632struct hda_ctl_ops snd_hda_bind_vol = {
2633 .info = snd_hda_mixer_amp_volume_info,
2634 .get = snd_hda_mixer_amp_volume_get,
2635 .put = snd_hda_mixer_amp_volume_put,
2636 .tlv = snd_hda_mixer_amp_tlv
2637};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002638EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
Takashi Iwai532d5382007-07-27 19:02:40 +02002639
2640struct hda_ctl_ops snd_hda_bind_sw = {
2641 .info = snd_hda_mixer_amp_switch_info,
2642 .get = snd_hda_mixer_amp_switch_get,
2643 .put = snd_hda_mixer_amp_switch_put,
2644 .tlv = snd_hda_mixer_amp_tlv
2645};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002646EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
Takashi Iwai532d5382007-07-27 19:02:40 +02002647
2648/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 * SPDIF out controls
2650 */
2651
Takashi Iwai0ba21762007-04-16 11:29:14 +02002652static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2653 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654{
2655 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2656 uinfo->count = 1;
2657 return 0;
2658}
2659
Takashi Iwai0ba21762007-04-16 11:29:14 +02002660static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2661 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662{
2663 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2664 IEC958_AES0_NONAUDIO |
2665 IEC958_AES0_CON_EMPHASIS_5015 |
2666 IEC958_AES0_CON_NOT_COPYRIGHT;
2667 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2668 IEC958_AES1_CON_ORIGINAL;
2669 return 0;
2670}
2671
Takashi Iwai0ba21762007-04-16 11:29:14 +02002672static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2673 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674{
2675 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2676 IEC958_AES0_NONAUDIO |
2677 IEC958_AES0_PRO_EMPHASIS_5015;
2678 return 0;
2679}
2680
Takashi Iwai0ba21762007-04-16 11:29:14 +02002681static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2682 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683{
2684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c935972011-06-01 11:14:17 -06002685 int idx = kcontrol->private_value;
2686 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687
Stephen Warren7c935972011-06-01 11:14:17 -06002688 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2689 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2690 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2691 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692
2693 return 0;
2694}
2695
2696/* convert from SPDIF status bits to HDA SPDIF bits
2697 * bit 0 (DigEn) is always set zero (to be filled later)
2698 */
2699static unsigned short convert_from_spdif_status(unsigned int sbits)
2700{
2701 unsigned short val = 0;
2702
2703 if (sbits & IEC958_AES0_PROFESSIONAL)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002704 val |= AC_DIG1_PROFESSIONAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 if (sbits & IEC958_AES0_NONAUDIO)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002706 val |= AC_DIG1_NONAUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002708 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2709 IEC958_AES0_PRO_EMPHASIS_5015)
2710 val |= AC_DIG1_EMPHASIS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002712 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2713 IEC958_AES0_CON_EMPHASIS_5015)
2714 val |= AC_DIG1_EMPHASIS;
2715 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2716 val |= AC_DIG1_COPYRIGHT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
Takashi Iwai0ba21762007-04-16 11:29:14 +02002718 val |= AC_DIG1_LEVEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2720 }
2721 return val;
2722}
2723
2724/* convert to SPDIF status bits from HDA SPDIF bits
2725 */
2726static unsigned int convert_to_spdif_status(unsigned short val)
2727{
2728 unsigned int sbits = 0;
2729
Takashi Iwai0ba21762007-04-16 11:29:14 +02002730 if (val & AC_DIG1_NONAUDIO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 sbits |= IEC958_AES0_NONAUDIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002732 if (val & AC_DIG1_PROFESSIONAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 sbits |= IEC958_AES0_PROFESSIONAL;
2734 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002735 if (sbits & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2737 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002738 if (val & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002740 if (!(val & AC_DIG1_COPYRIGHT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002742 if (val & AC_DIG1_LEVEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2744 sbits |= val & (0x7f << 8);
2745 }
2746 return sbits;
2747}
2748
Takashi Iwai2f728532008-09-25 16:32:41 +02002749/* set digital convert verbs both for the given NID and its slaves */
2750static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2751 int verb, int val)
2752{
Takashi Iwaidda14412011-05-02 11:29:30 +02002753 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02002754
Takashi Iwai9e976972008-11-25 08:17:20 +01002755 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002756 d = codec->slave_dig_outs;
2757 if (!d)
2758 return;
2759 for (; *d; d++)
Takashi Iwai9e976972008-11-25 08:17:20 +01002760 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002761}
2762
2763static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2764 int dig1, int dig2)
2765{
2766 if (dig1 != -1)
2767 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2768 if (dig2 != -1)
2769 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2770}
2771
Takashi Iwai0ba21762007-04-16 11:29:14 +02002772static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2773 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774{
2775 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c935972011-06-01 11:14:17 -06002776 int idx = kcontrol->private_value;
2777 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2778 hda_nid_t nid = spdif->nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 unsigned short val;
2780 int change;
2781
Ingo Molnar62932df2006-01-16 16:34:20 +01002782 mutex_lock(&codec->spdif_mutex);
Stephen Warren7c935972011-06-01 11:14:17 -06002783 spdif->status = ucontrol->value.iec958.status[0] |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2785 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2786 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
Stephen Warren7c935972011-06-01 11:14:17 -06002787 val = convert_from_spdif_status(spdif->status);
2788 val |= spdif->ctls & 1;
2789 change = spdif->ctls != val;
2790 spdif->ctls = val;
Stephen Warren74b654c2011-06-01 11:14:18 -06002791 if (change && nid != (u16)-1)
Takashi Iwai2f728532008-09-25 16:32:41 +02002792 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
Ingo Molnar62932df2006-01-16 16:34:20 +01002793 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794 return change;
2795}
2796
Takashi Iwaia5ce8892007-07-23 15:42:26 +02002797#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798
Takashi Iwai0ba21762007-04-16 11:29:14 +02002799static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2800 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801{
2802 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c935972011-06-01 11:14:17 -06002803 int idx = kcontrol->private_value;
2804 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805
Stephen Warren7c935972011-06-01 11:14:17 -06002806 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 return 0;
2808}
2809
Stephen Warren74b654c2011-06-01 11:14:18 -06002810static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2811 int dig1, int dig2)
2812{
2813 set_dig_out_convert(codec, nid, dig1, dig2);
2814 /* unmute amp switch (if any) */
2815 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2816 (dig1 & AC_DIG1_ENABLE))
2817 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2818 HDA_AMP_MUTE, 0);
2819}
2820
Takashi Iwai0ba21762007-04-16 11:29:14 +02002821static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2822 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823{
2824 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c935972011-06-01 11:14:17 -06002825 int idx = kcontrol->private_value;
2826 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2827 hda_nid_t nid = spdif->nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 unsigned short val;
2829 int change;
2830
Ingo Molnar62932df2006-01-16 16:34:20 +01002831 mutex_lock(&codec->spdif_mutex);
Stephen Warren7c935972011-06-01 11:14:17 -06002832 val = spdif->ctls & ~AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 if (ucontrol->value.integer.value[0])
Takashi Iwai0ba21762007-04-16 11:29:14 +02002834 val |= AC_DIG1_ENABLE;
Stephen Warren7c935972011-06-01 11:14:17 -06002835 change = spdif->ctls != val;
Stephen Warren74b654c2011-06-01 11:14:18 -06002836 spdif->ctls = val;
2837 if (change && nid != (u16)-1)
2838 set_spdif_ctls(codec, nid, val & 0xff, -1);
Ingo Molnar62932df2006-01-16 16:34:20 +01002839 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 return change;
2841}
2842
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01002843static struct snd_kcontrol_new dig_mixes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 {
2845 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002847 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 .info = snd_hda_spdif_mask_info,
2849 .get = snd_hda_spdif_cmask_get,
2850 },
2851 {
2852 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002854 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 .info = snd_hda_spdif_mask_info,
2856 .get = snd_hda_spdif_pmask_get,
2857 },
2858 {
2859 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002860 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 .info = snd_hda_spdif_mask_info,
2862 .get = snd_hda_spdif_default_get,
2863 .put = snd_hda_spdif_default_put,
2864 },
2865 {
2866 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002867 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 .info = snd_hda_spdif_out_switch_info,
2869 .get = snd_hda_spdif_out_switch_get,
2870 .put = snd_hda_spdif_out_switch_put,
2871 },
2872 { } /* end */
2873};
2874
2875/**
2876 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2877 * @codec: the HDA codec
2878 * @nid: audio out widget NID
2879 *
2880 * Creates controls related with the SPDIF output.
2881 * Called from each patch supporting the SPDIF out.
2882 *
2883 * Returns 0 if successful, or a negative error code.
2884 */
Stephen Warren74b654c2011-06-01 11:14:18 -06002885int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
2886 hda_nid_t associated_nid,
2887 hda_nid_t cvt_nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888{
2889 int err;
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01002890 struct snd_kcontrol *kctl;
2891 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01002892 int idx;
Stephen Warren7c935972011-06-01 11:14:17 -06002893 struct hda_spdif_out *spdif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894
Takashi Iwai1afe2062010-12-23 10:17:52 +01002895 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
2896 if (idx < 0) {
Takashi Iwai09f99702008-02-04 12:31:13 +01002897 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2898 return -EBUSY;
2899 }
Stephen Warren7c935972011-06-01 11:14:17 -06002900 spdif = snd_array_new(&codec->spdif_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2902 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaib91f0802008-11-04 08:43:08 +01002903 if (!kctl)
2904 return -ENOMEM;
Takashi Iwai09f99702008-02-04 12:31:13 +01002905 kctl->id.index = idx;
Stephen Warren7c935972011-06-01 11:14:17 -06002906 kctl->private_value = codec->spdif_out.used - 1;
Stephen Warren74b654c2011-06-01 11:14:18 -06002907 err = snd_hda_ctl_add(codec, associated_nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002908 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 return err;
2910 }
Stephen Warren74b654c2011-06-01 11:14:18 -06002911 spdif->nid = cvt_nid;
2912 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
Stephen Warren7c935972011-06-01 11:14:17 -06002913 AC_VERB_GET_DIGI_CONVERT_1, 0);
2914 spdif->status = convert_to_spdif_status(spdif->ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 return 0;
2916}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002917EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918
Stephen Warren7c935972011-06-01 11:14:17 -06002919struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
2920 hda_nid_t nid)
2921{
2922 int i;
2923 for (i = 0; i < codec->spdif_out.used; i++) {
2924 struct hda_spdif_out *spdif =
2925 snd_array_elem(&codec->spdif_out, i);
2926 if (spdif->nid == nid)
2927 return spdif;
2928 }
2929 return NULL;
2930}
2931EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
2932
Stephen Warren74b654c2011-06-01 11:14:18 -06002933void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
2934{
2935 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2936
2937 mutex_lock(&codec->spdif_mutex);
2938 spdif->nid = (u16)-1;
2939 mutex_unlock(&codec->spdif_mutex);
2940}
2941EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
2942
2943void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
2944{
2945 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2946 unsigned short val;
2947
2948 mutex_lock(&codec->spdif_mutex);
2949 if (spdif->nid != nid) {
2950 spdif->nid = nid;
2951 val = spdif->ctls;
2952 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
2953 }
2954 mutex_unlock(&codec->spdif_mutex);
2955}
2956EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
2957
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958/*
Takashi Iwai9a081602008-02-12 18:37:26 +01002959 * SPDIF sharing with analog output
2960 */
2961static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2962 struct snd_ctl_elem_value *ucontrol)
2963{
2964 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2965 ucontrol->value.integer.value[0] = mout->share_spdif;
2966 return 0;
2967}
2968
2969static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2970 struct snd_ctl_elem_value *ucontrol)
2971{
2972 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2973 mout->share_spdif = !!ucontrol->value.integer.value[0];
2974 return 0;
2975}
2976
2977static struct snd_kcontrol_new spdif_share_sw = {
2978 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2979 .name = "IEC958 Default PCM Playback Switch",
2980 .info = snd_ctl_boolean_mono_info,
2981 .get = spdif_share_sw_get,
2982 .put = spdif_share_sw_put,
2983};
2984
Takashi Iwaid5191e52009-11-16 14:58:17 +01002985/**
2986 * snd_hda_create_spdif_share_sw - create Default PCM switch
2987 * @codec: the HDA codec
2988 * @mout: multi-out instance
2989 */
Takashi Iwai9a081602008-02-12 18:37:26 +01002990int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2991 struct hda_multi_out *mout)
2992{
2993 if (!mout->dig_out_nid)
2994 return 0;
2995 /* ATTENTION: here mout is passed as private_data, instead of codec */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002996 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2997 snd_ctl_new1(&spdif_share_sw, mout));
Takashi Iwai9a081602008-02-12 18:37:26 +01002998}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002999EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
Takashi Iwai9a081602008-02-12 18:37:26 +01003000
3001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 * SPDIF input
3003 */
3004
3005#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3006
Takashi Iwai0ba21762007-04-16 11:29:14 +02003007static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3008 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009{
3010 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3011
3012 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3013 return 0;
3014}
3015
Takashi Iwai0ba21762007-04-16 11:29:14 +02003016static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3017 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018{
3019 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3020 hda_nid_t nid = kcontrol->private_value;
3021 unsigned int val = !!ucontrol->value.integer.value[0];
3022 int change;
3023
Ingo Molnar62932df2006-01-16 16:34:20 +01003024 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 change = codec->spdif_in_enable != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003026 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 codec->spdif_in_enable = val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003028 snd_hda_codec_write_cache(codec, nid, 0,
3029 AC_VERB_SET_DIGI_CONVERT_1, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003031 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 return change;
3033}
3034
Takashi Iwai0ba21762007-04-16 11:29:14 +02003035static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3036 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037{
3038 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3039 hda_nid_t nid = kcontrol->private_value;
3040 unsigned short val;
3041 unsigned int sbits;
3042
Andrew Paprocki3982d172007-12-19 12:13:44 +01003043 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 sbits = convert_to_spdif_status(val);
3045 ucontrol->value.iec958.status[0] = sbits;
3046 ucontrol->value.iec958.status[1] = sbits >> 8;
3047 ucontrol->value.iec958.status[2] = sbits >> 16;
3048 ucontrol->value.iec958.status[3] = sbits >> 24;
3049 return 0;
3050}
3051
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01003052static struct snd_kcontrol_new dig_in_ctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 {
3054 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003055 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 .info = snd_hda_spdif_in_switch_info,
3057 .get = snd_hda_spdif_in_switch_get,
3058 .put = snd_hda_spdif_in_switch_put,
3059 },
3060 {
3061 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3062 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003063 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064 .info = snd_hda_spdif_mask_info,
3065 .get = snd_hda_spdif_in_status_get,
3066 },
3067 { } /* end */
3068};
3069
3070/**
3071 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3072 * @codec: the HDA codec
3073 * @nid: audio in widget NID
3074 *
3075 * Creates controls related with the SPDIF input.
3076 * Called from each patch supporting the SPDIF in.
3077 *
3078 * Returns 0 if successful, or a negative error code.
3079 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003080int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081{
3082 int err;
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01003083 struct snd_kcontrol *kctl;
3084 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01003085 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086
Takashi Iwai1afe2062010-12-23 10:17:52 +01003087 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3088 if (idx < 0) {
Takashi Iwai09f99702008-02-04 12:31:13 +01003089 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3090 return -EBUSY;
3091 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3093 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaic8dcdf82009-02-06 16:21:20 +01003094 if (!kctl)
3095 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 kctl->private_value = nid;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01003097 err = snd_hda_ctl_add(codec, nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003098 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 return err;
3100 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02003101 codec->spdif_in_enable =
Andrew Paprocki3982d172007-12-19 12:13:44 +01003102 snd_hda_codec_read(codec, nid, 0,
3103 AC_VERB_GET_DIGI_CONVERT_1, 0) &
Takashi Iwai0ba21762007-04-16 11:29:14 +02003104 AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 return 0;
3106}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003107EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108
Takashi Iwai2a439522011-07-26 09:52:50 +02003109#ifdef CONFIG_PM
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003110/*
3111 * command cache
3112 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003114/* build a 32bit cache key with the widget id and the command parameter */
3115#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3116#define get_cmd_cache_nid(key) ((key) & 0xff)
3117#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3118
3119/**
3120 * snd_hda_codec_write_cache - send a single command with caching
3121 * @codec: the HDA codec
3122 * @nid: NID to send the command
3123 * @direct: direct flag
3124 * @verb: the verb to send
3125 * @parm: the parameter for the verb
3126 *
3127 * Send a single command without waiting for response.
3128 *
3129 * Returns 0 if successful, or a negative error code.
3130 */
3131int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3132 int direct, unsigned int verb, unsigned int parm)
3133{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02003134 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3135 struct hda_cache_head *c;
3136 u32 key;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003137
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02003138 if (err < 0)
3139 return err;
3140 /* parm may contain the verb stuff for get/set amp */
3141 verb = verb | (parm >> 8);
3142 parm &= 0xff;
3143 key = build_cmd_cache_key(nid, verb);
3144 mutex_lock(&codec->bus->cmd_mutex);
3145 c = get_alloc_hash(&codec->cmd_cache, key);
3146 if (c)
3147 c->val = parm;
3148 mutex_unlock(&codec->bus->cmd_mutex);
3149 return 0;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003150}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003151EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003152
Takashi Iwaid5191e52009-11-16 14:58:17 +01003153/**
Takashi Iwaia68d5a52010-03-30 18:03:44 +02003154 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3155 * @codec: the HDA codec
3156 * @nid: NID to send the command
3157 * @direct: direct flag
3158 * @verb: the verb to send
3159 * @parm: the parameter for the verb
3160 *
3161 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3162 * command if the parameter is already identical with the cached value.
3163 * If not, it sends the command and refreshes the cache.
3164 *
3165 * Returns 0 if successful, or a negative error code.
3166 */
3167int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3168 int direct, unsigned int verb, unsigned int parm)
3169{
3170 struct hda_cache_head *c;
3171 u32 key;
3172
3173 /* parm may contain the verb stuff for get/set amp */
3174 verb = verb | (parm >> 8);
3175 parm &= 0xff;
3176 key = build_cmd_cache_key(nid, verb);
3177 mutex_lock(&codec->bus->cmd_mutex);
3178 c = get_hash(&codec->cmd_cache, key);
3179 if (c && c->val == parm) {
3180 mutex_unlock(&codec->bus->cmd_mutex);
3181 return 0;
3182 }
3183 mutex_unlock(&codec->bus->cmd_mutex);
3184 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3185}
3186EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3187
3188/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01003189 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3190 * @codec: HD-audio codec
3191 *
3192 * Execute all verbs recorded in the command caches to resume.
3193 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003194void snd_hda_codec_resume_cache(struct hda_codec *codec)
3195{
Takashi Iwai603c4012008-07-30 15:01:44 +02003196 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003197 int i;
3198
Takashi Iwai603c4012008-07-30 15:01:44 +02003199 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003200 u32 key = buffer->key;
3201 if (!key)
3202 continue;
3203 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3204 get_cmd_cache_cmd(key), buffer->val);
3205 }
3206}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003207EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003208
3209/**
3210 * snd_hda_sequence_write_cache - sequence writes with caching
3211 * @codec: the HDA codec
3212 * @seq: VERB array to send
3213 *
3214 * Send the commands sequentially from the given array.
3215 * Thte commands are recorded on cache for power-save and resume.
3216 * The array must be terminated with NID=0.
3217 */
3218void snd_hda_sequence_write_cache(struct hda_codec *codec,
3219 const struct hda_verb *seq)
3220{
3221 for (; seq->nid; seq++)
3222 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3223 seq->param);
3224}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003225EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
Takashi Iwai2a439522011-07-26 09:52:50 +02003226#endif /* CONFIG_PM */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003227
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003228void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3229 unsigned int power_state,
3230 bool eapd_workaround)
Takashi Iwai54d17402005-11-21 16:33:22 +01003231{
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003232 hda_nid_t nid = codec->start_nid;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003233 int i;
Takashi Iwai54d17402005-11-21 16:33:22 +01003234
Takashi Iwaicb53c622007-08-10 17:21:45 +02003235 for (i = 0; i < codec->num_nodes; i++, nid++) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01003236 unsigned int wcaps = get_wcaps(codec, nid);
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003237 if (!(wcaps & AC_WCAP_POWER))
3238 continue;
3239 /* don't power down the widget if it controls eapd and
3240 * EAPD_BTLENABLE is set.
3241 */
3242 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3243 get_wcaps_type(wcaps) == AC_WID_PIN &&
3244 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3245 int eapd = snd_hda_codec_read(codec, nid, 0,
Takashi Iwai7eba5c92007-11-14 14:53:42 +01003246 AC_VERB_GET_EAPD_BTLENABLE, 0);
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003247 if (eapd & 0x02)
3248 continue;
Takashi Iwai1194b5b2007-10-10 10:04:26 +02003249 }
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003250 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3251 power_state);
Takashi Iwai54d17402005-11-21 16:33:22 +01003252 }
3253
Takashi Iwaicb53c622007-08-10 17:21:45 +02003254 if (power_state == AC_PWRST_D0) {
3255 unsigned long end_time;
3256 int state;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003257 /* wait until the codec reachs to D0 */
3258 end_time = jiffies + msecs_to_jiffies(500);
3259 do {
3260 state = snd_hda_codec_read(codec, fg, 0,
3261 AC_VERB_GET_POWER_STATE, 0);
3262 if (state == power_state)
3263 break;
3264 msleep(1);
3265 } while (time_after_eq(end_time, jiffies));
3266 }
Takashi Iwai54d17402005-11-21 16:33:22 +01003267}
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003268EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3269
3270/*
3271 * set power state of the codec
3272 */
3273static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3274 unsigned int power_state)
3275{
3276 if (codec->patch_ops.set_power_state) {
3277 codec->patch_ops.set_power_state(codec, fg, power_state);
3278 return;
3279 }
3280
3281 /* this delay seems necessary to avoid click noise at power-down */
3282 if (power_state == AC_PWRST_D3)
3283 msleep(100);
3284 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3285 power_state);
3286 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3287}
Takashi Iwai54d17402005-11-21 16:33:22 +01003288
Takashi Iwai11aeff02008-07-30 15:01:46 +02003289#ifdef CONFIG_SND_HDA_HWDEP
3290/* execute additional init verbs */
3291static void hda_exec_init_verbs(struct hda_codec *codec)
3292{
3293 if (codec->init_verbs.list)
3294 snd_hda_sequence_write(codec, codec->init_verbs.list);
3295}
3296#else
3297static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3298#endif
3299
Takashi Iwai2a439522011-07-26 09:52:50 +02003300#ifdef CONFIG_PM
Takashi Iwaicb53c622007-08-10 17:21:45 +02003301/*
3302 * call suspend and power-down; used both from PM and power-save
3303 */
3304static void hda_call_codec_suspend(struct hda_codec *codec)
3305{
3306 if (codec->patch_ops.suspend)
3307 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
Takashi Iwaieb541332010-08-06 13:48:11 +02003308 hda_cleanup_all_streams(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003309 hda_set_power_state(codec,
3310 codec->afg ? codec->afg : codec->mfg,
3311 AC_PWRST_D3);
3312#ifdef CONFIG_SND_HDA_POWER_SAVE
Takashi Iwaia2f63092009-11-11 09:34:25 +01003313 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003314 cancel_delayed_work(&codec->power_work);
Takashi Iwai95e99fd2007-08-13 15:29:04 +02003315 codec->power_on = 0;
Takashi Iwaia221e282007-08-16 16:35:33 +02003316 codec->power_transition = 0;
Takashi Iwaia2f63092009-11-11 09:34:25 +01003317 codec->power_jiffies = jiffies;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003318#endif
3319}
3320
3321/*
3322 * kick up codec; used both from PM and power-save
3323 */
3324static void hda_call_codec_resume(struct hda_codec *codec)
3325{
3326 hda_set_power_state(codec,
3327 codec->afg ? codec->afg : codec->mfg,
3328 AC_PWRST_D0);
Takashi Iwai3be14142009-02-20 14:11:16 +01003329 restore_pincfgs(codec); /* restore all current pin configs */
Takashi Iwaiac0547d2010-07-05 16:50:13 +02003330 restore_shutup_pins(codec);
Takashi Iwai11aeff02008-07-30 15:01:46 +02003331 hda_exec_init_verbs(codec);
Takashi Iwai1835a0f2011-10-27 22:12:46 +02003332 snd_hda_jack_set_dirty_all(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003333 if (codec->patch_ops.resume)
3334 codec->patch_ops.resume(codec);
3335 else {
Takashi Iwai9d99f312007-08-14 15:15:52 +02003336 if (codec->patch_ops.init)
3337 codec->patch_ops.init(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003338 snd_hda_codec_resume_amp(codec);
3339 snd_hda_codec_resume_cache(codec);
3340 }
3341}
Takashi Iwai2a439522011-07-26 09:52:50 +02003342#endif /* CONFIG_PM */
Takashi Iwaicb53c622007-08-10 17:21:45 +02003343
Takashi Iwai54d17402005-11-21 16:33:22 +01003344
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345/**
3346 * snd_hda_build_controls - build mixer controls
3347 * @bus: the BUS
3348 *
3349 * Creates mixer controls for each codec included in the bus.
3350 *
3351 * Returns 0 if successful, otherwise a negative error code.
3352 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003353int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003355 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356
Takashi Iwai0ba21762007-04-16 11:29:14 +02003357 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003358 int err = snd_hda_codec_build_controls(codec);
Takashi Iwaif93d4612009-03-02 10:44:15 +01003359 if (err < 0) {
Takashi Iwai28d1a852010-03-15 09:05:46 +01003360 printk(KERN_ERR "hda_codec: cannot build controls "
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003361 "for #%d (error %d)\n", codec->addr, err);
Takashi Iwaif93d4612009-03-02 10:44:15 +01003362 err = snd_hda_codec_reset(codec);
3363 if (err < 0) {
3364 printk(KERN_ERR
3365 "hda_codec: cannot revert codec\n");
3366 return err;
3367 }
3368 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003370 return 0;
3371}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003372EXPORT_SYMBOL_HDA(snd_hda_build_controls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003374int snd_hda_codec_build_controls(struct hda_codec *codec)
3375{
3376 int err = 0;
Takashi Iwai11aeff02008-07-30 15:01:46 +02003377 hda_exec_init_verbs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003378 /* continue to initialize... */
3379 if (codec->patch_ops.init)
3380 err = codec->patch_ops.init(codec);
3381 if (!err && codec->patch_ops.build_controls)
3382 err = codec->patch_ops.build_controls(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003383 if (err < 0)
3384 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385 return 0;
3386}
3387
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388/*
3389 * stream formats
3390 */
Takashi Iwaibefdf312005-08-22 13:57:55 +02003391struct hda_rate_tbl {
3392 unsigned int hz;
3393 unsigned int alsa_bits;
3394 unsigned int hda_fmt;
3395};
3396
Takashi Iwai92f10b32010-08-03 14:21:00 +02003397/* rate = base * mult / div */
3398#define HDA_RATE(base, mult, div) \
3399 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3400 (((div) - 1) << AC_FMT_DIV_SHIFT))
3401
Takashi Iwaibefdf312005-08-22 13:57:55 +02003402static struct hda_rate_tbl rate_bits[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 /* rate in Hz, ALSA rate bitmask, HDA format value */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02003404
3405 /* autodetected value used in snd_hda_query_supported_pcm */
Takashi Iwai92f10b32010-08-03 14:21:00 +02003406 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3407 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3408 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3409 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3410 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3411 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3412 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3413 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3414 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3415 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3416 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003417#define AC_PAR_PCM_RATE_BITS 11
3418 /* up to bits 10, 384kHZ isn't supported properly */
3419
3420 /* not autodetected value */
Takashi Iwai92f10b32010-08-03 14:21:00 +02003421 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02003422
Takashi Iwaibefdf312005-08-22 13:57:55 +02003423 { 0 } /* terminator */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424};
3425
3426/**
3427 * snd_hda_calc_stream_format - calculate format bitset
3428 * @rate: the sample rate
3429 * @channels: the number of channels
3430 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3431 * @maxbps: the max. bps
3432 *
3433 * Calculate the format bitset from the given rate, channels and th PCM format.
3434 *
3435 * Return zero if invalid.
3436 */
3437unsigned int snd_hda_calc_stream_format(unsigned int rate,
3438 unsigned int channels,
3439 unsigned int format,
Anssi Hannula32c168c2010-08-03 13:28:57 +03003440 unsigned int maxbps,
3441 unsigned short spdif_ctls)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442{
3443 int i;
3444 unsigned int val = 0;
3445
Takashi Iwaibefdf312005-08-22 13:57:55 +02003446 for (i = 0; rate_bits[i].hz; i++)
3447 if (rate_bits[i].hz == rate) {
3448 val = rate_bits[i].hda_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 break;
3450 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02003451 if (!rate_bits[i].hz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452 snd_printdd("invalid rate %d\n", rate);
3453 return 0;
3454 }
3455
3456 if (channels == 0 || channels > 8) {
3457 snd_printdd("invalid channels %d\n", channels);
3458 return 0;
3459 }
3460 val |= channels - 1;
3461
3462 switch (snd_pcm_format_width(format)) {
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003463 case 8:
Takashi Iwai92f10b32010-08-03 14:21:00 +02003464 val |= AC_FMT_BITS_8;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003465 break;
3466 case 16:
Takashi Iwai92f10b32010-08-03 14:21:00 +02003467 val |= AC_FMT_BITS_16;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003468 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469 case 20:
3470 case 24:
3471 case 32:
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02003472 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003473 val |= AC_FMT_BITS_32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 else if (maxbps >= 24)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003475 val |= AC_FMT_BITS_24;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476 else
Takashi Iwai92f10b32010-08-03 14:21:00 +02003477 val |= AC_FMT_BITS_20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003478 break;
3479 default:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003480 snd_printdd("invalid format width %d\n",
3481 snd_pcm_format_width(format));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482 return 0;
3483 }
3484
Anssi Hannula32c168c2010-08-03 13:28:57 +03003485 if (spdif_ctls & AC_DIG1_NONAUDIO)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003486 val |= AC_FMT_TYPE_NON_PCM;
Anssi Hannula32c168c2010-08-03 13:28:57 +03003487
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 return val;
3489}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003490EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003492static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3493{
3494 unsigned int val = 0;
3495 if (nid != codec->afg &&
3496 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3497 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3498 if (!val || val == -1)
3499 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3500 if (!val || val == -1)
3501 return 0;
3502 return val;
3503}
3504
3505static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3506{
3507 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3508 get_pcm_param);
3509}
3510
3511static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3512{
3513 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3514 if (!streams || streams == -1)
3515 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3516 if (!streams || streams == -1)
3517 return 0;
3518 return streams;
3519}
3520
3521static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3522{
3523 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3524 get_stream_param);
3525}
3526
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527/**
3528 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3529 * @codec: the HDA codec
3530 * @nid: NID to query
3531 * @ratesp: the pointer to store the detected rate bitflags
3532 * @formatsp: the pointer to store the detected formats
3533 * @bpsp: the pointer to store the detected format widths
3534 *
3535 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3536 * or @bsps argument is ignored.
3537 *
3538 * Returns 0 if successful, otherwise a negative error code.
3539 */
Stephen Warren384a48d2011-06-01 11:14:21 -06003540int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3542{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003543 unsigned int i, val, wcaps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003545 wcaps = get_wcaps(codec, nid);
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003546 val = query_pcm_param(codec, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547
3548 if (ratesp) {
3549 u32 rates = 0;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003550 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 if (val & (1 << i))
Takashi Iwaibefdf312005-08-22 13:57:55 +02003552 rates |= rate_bits[i].alsa_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003554 if (rates == 0) {
3555 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3556 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3557 nid, val,
3558 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3559 return -EIO;
3560 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561 *ratesp = rates;
3562 }
3563
3564 if (formatsp || bpsp) {
3565 u64 formats = 0;
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003566 unsigned int streams, bps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003568 streams = query_stream_param(codec, nid);
3569 if (!streams)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003570 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571
3572 bps = 0;
3573 if (streams & AC_SUPFMT_PCM) {
3574 if (val & AC_SUPPCM_BITS_8) {
3575 formats |= SNDRV_PCM_FMTBIT_U8;
3576 bps = 8;
3577 }
3578 if (val & AC_SUPPCM_BITS_16) {
3579 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3580 bps = 16;
3581 }
3582 if (wcaps & AC_WCAP_DIGITAL) {
3583 if (val & AC_SUPPCM_BITS_32)
3584 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3585 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3586 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3587 if (val & AC_SUPPCM_BITS_24)
3588 bps = 24;
3589 else if (val & AC_SUPPCM_BITS_20)
3590 bps = 20;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003591 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3592 AC_SUPPCM_BITS_32)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3594 if (val & AC_SUPPCM_BITS_32)
3595 bps = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 else if (val & AC_SUPPCM_BITS_24)
3597 bps = 24;
Nicolas Graziano33ef7652006-09-19 14:23:14 +02003598 else if (val & AC_SUPPCM_BITS_20)
3599 bps = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600 }
3601 }
Takashi Iwaib5025c52009-07-01 18:05:27 +02003602 if (streams & AC_SUPFMT_FLOAT32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02003604 if (!bps)
3605 bps = 32;
Takashi Iwaib5025c52009-07-01 18:05:27 +02003606 }
3607 if (streams == AC_SUPFMT_AC3) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02003608 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609 /* temporary hack: we have still no proper support
3610 * for the direct AC3 stream...
3611 */
3612 formats |= SNDRV_PCM_FMTBIT_U8;
3613 bps = 8;
3614 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003615 if (formats == 0) {
3616 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3617 "(nid=0x%x, val=0x%x, ovrd=%i, "
3618 "streams=0x%x)\n",
3619 nid, val,
3620 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3621 streams);
3622 return -EIO;
3623 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 if (formatsp)
3625 *formatsp = formats;
3626 if (bpsp)
3627 *bpsp = bps;
3628 }
3629
3630 return 0;
3631}
Stephen Warren384a48d2011-06-01 11:14:21 -06003632EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633
3634/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01003635 * snd_hda_is_supported_format - Check the validity of the format
3636 * @codec: HD-audio codec
3637 * @nid: NID to check
3638 * @format: the HD-audio format value to check
3639 *
3640 * Check whether the given node supports the format value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641 *
3642 * Returns 1 if supported, 0 if not.
3643 */
3644int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3645 unsigned int format)
3646{
3647 int i;
3648 unsigned int val = 0, rate, stream;
3649
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003650 val = query_pcm_param(codec, nid);
3651 if (!val)
3652 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653
3654 rate = format & 0xff00;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003655 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
Takashi Iwaibefdf312005-08-22 13:57:55 +02003656 if (rate_bits[i].hda_fmt == rate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003657 if (val & (1 << i))
3658 break;
3659 return 0;
3660 }
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003661 if (i >= AC_PAR_PCM_RATE_BITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662 return 0;
3663
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003664 stream = query_stream_param(codec, nid);
3665 if (!stream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666 return 0;
3667
3668 if (stream & AC_SUPFMT_PCM) {
3669 switch (format & 0xf0) {
3670 case 0x00:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003671 if (!(val & AC_SUPPCM_BITS_8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672 return 0;
3673 break;
3674 case 0x10:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003675 if (!(val & AC_SUPPCM_BITS_16))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003676 return 0;
3677 break;
3678 case 0x20:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003679 if (!(val & AC_SUPPCM_BITS_20))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680 return 0;
3681 break;
3682 case 0x30:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003683 if (!(val & AC_SUPPCM_BITS_24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684 return 0;
3685 break;
3686 case 0x40:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003687 if (!(val & AC_SUPPCM_BITS_32))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003688 return 0;
3689 break;
3690 default:
3691 return 0;
3692 }
3693 } else {
3694 /* FIXME: check for float32 and AC3? */
3695 }
3696
3697 return 1;
3698}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003699EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700
3701/*
3702 * PCM stuff
3703 */
3704static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3705 struct hda_codec *codec,
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01003706 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707{
3708 return 0;
3709}
3710
3711static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3712 struct hda_codec *codec,
3713 unsigned int stream_tag,
3714 unsigned int format,
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01003715 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003716{
3717 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3718 return 0;
3719}
3720
3721static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3722 struct hda_codec *codec,
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01003723 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724{
Takashi Iwai888afa12008-03-18 09:57:50 +01003725 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726 return 0;
3727}
3728
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003729static int set_pcm_default_values(struct hda_codec *codec,
3730 struct hda_pcm_stream *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003731{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003732 int err;
3733
Takashi Iwai0ba21762007-04-16 11:29:14 +02003734 /* query support PCM information from the given NID */
3735 if (info->nid && (!info->rates || !info->formats)) {
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003736 err = snd_hda_query_supported_pcm(codec, info->nid,
Takashi Iwai0ba21762007-04-16 11:29:14 +02003737 info->rates ? NULL : &info->rates,
3738 info->formats ? NULL : &info->formats,
3739 info->maxbps ? NULL : &info->maxbps);
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003740 if (err < 0)
3741 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 }
3743 if (info->ops.open == NULL)
3744 info->ops.open = hda_pcm_default_open_close;
3745 if (info->ops.close == NULL)
3746 info->ops.close = hda_pcm_default_open_close;
3747 if (info->ops.prepare == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003748 if (snd_BUG_ON(!info->nid))
3749 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750 info->ops.prepare = hda_pcm_default_prepare;
3751 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 if (info->ops.cleanup == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003753 if (snd_BUG_ON(!info->nid))
3754 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003755 info->ops.cleanup = hda_pcm_default_cleanup;
3756 }
3757 return 0;
3758}
3759
Takashi Iwaieb541332010-08-06 13:48:11 +02003760/*
3761 * codec prepare/cleanup entries
3762 */
3763int snd_hda_codec_prepare(struct hda_codec *codec,
3764 struct hda_pcm_stream *hinfo,
3765 unsigned int stream,
3766 unsigned int format,
3767 struct snd_pcm_substream *substream)
3768{
3769 int ret;
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003770 mutex_lock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003771 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3772 if (ret >= 0)
3773 purify_inactive_streams(codec);
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003774 mutex_unlock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003775 return ret;
3776}
3777EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3778
3779void snd_hda_codec_cleanup(struct hda_codec *codec,
3780 struct hda_pcm_stream *hinfo,
3781 struct snd_pcm_substream *substream)
3782{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003783 mutex_lock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003784 hinfo->ops.cleanup(hinfo, codec, substream);
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003785 mutex_unlock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003786}
3787EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3788
Takashi Iwaid5191e52009-11-16 14:58:17 +01003789/* global */
Jaroslav Kyselae3303232009-11-10 14:53:02 +01003790const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3791 "Audio", "SPDIF", "HDMI", "Modem"
3792};
3793
Takashi Iwai176d5332008-07-30 15:01:44 +02003794/*
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003795 * get the empty PCM device number to assign
Takashi Iwaic8936222010-01-28 17:08:53 +01003796 *
3797 * note the max device number is limited by HDA_MAX_PCMS, currently 10
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003798 */
3799static int get_empty_pcm_device(struct hda_bus *bus, int type)
3800{
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003801 /* audio device indices; not linear to keep compatibility */
3802 static int audio_idx[HDA_PCM_NTYPES][5] = {
3803 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3804 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
Wu Fengguang92608ba2009-10-30 11:40:03 +01003805 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003806 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003807 };
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003808 int i;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003809
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003810 if (type >= HDA_PCM_NTYPES) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003811 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3812 return -EINVAL;
3813 }
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003814
3815 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3816 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3817 return audio_idx[type][i];
3818
Takashi Iwai01b65bf2011-11-24 14:31:46 +01003819 /* non-fixed slots starting from 10 */
3820 for (i = 10; i < 32; i++) {
3821 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3822 return i;
3823 }
3824
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003825 snd_printk(KERN_WARNING "Too many %s devices\n",
3826 snd_hda_pcm_type_name[type]);
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003827 return -EAGAIN;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003828}
3829
3830/*
Takashi Iwai176d5332008-07-30 15:01:44 +02003831 * attach a new PCM stream
3832 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003833static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
Takashi Iwai176d5332008-07-30 15:01:44 +02003834{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003835 struct hda_bus *bus = codec->bus;
Takashi Iwai176d5332008-07-30 15:01:44 +02003836 struct hda_pcm_stream *info;
3837 int stream, err;
3838
Takashi Iwaib91f0802008-11-04 08:43:08 +01003839 if (snd_BUG_ON(!pcm->name))
Takashi Iwai176d5332008-07-30 15:01:44 +02003840 return -EINVAL;
3841 for (stream = 0; stream < 2; stream++) {
3842 info = &pcm->stream[stream];
3843 if (info->substreams) {
3844 err = set_pcm_default_values(codec, info);
3845 if (err < 0)
3846 return err;
3847 }
3848 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003849 return bus->ops.attach_pcm(bus, codec, pcm);
Takashi Iwai176d5332008-07-30 15:01:44 +02003850}
3851
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003852/* assign all PCMs of the given codec */
3853int snd_hda_codec_build_pcms(struct hda_codec *codec)
3854{
3855 unsigned int pcm;
3856 int err;
3857
3858 if (!codec->num_pcms) {
3859 if (!codec->patch_ops.build_pcms)
3860 return 0;
3861 err = codec->patch_ops.build_pcms(codec);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003862 if (err < 0) {
3863 printk(KERN_ERR "hda_codec: cannot build PCMs"
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003864 "for #%d (error %d)\n", codec->addr, err);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003865 err = snd_hda_codec_reset(codec);
3866 if (err < 0) {
3867 printk(KERN_ERR
3868 "hda_codec: cannot revert codec\n");
3869 return err;
3870 }
3871 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003872 }
3873 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3874 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3875 int dev;
3876
3877 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
Takashi Iwai41b5b012009-01-20 18:21:23 +01003878 continue; /* no substreams assigned */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003879
3880 if (!cpcm->pcm) {
3881 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3882 if (dev < 0)
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003883 continue; /* no fatal error */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003884 cpcm->device = dev;
3885 err = snd_hda_attach_pcm(codec, cpcm);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003886 if (err < 0) {
3887 printk(KERN_ERR "hda_codec: cannot attach "
3888 "PCM stream %d for codec #%d\n",
3889 dev, codec->addr);
3890 continue; /* no fatal error */
3891 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003892 }
3893 }
3894 return 0;
3895}
3896
Linus Torvalds1da177e2005-04-16 15:20:36 -07003897/**
3898 * snd_hda_build_pcms - build PCM information
3899 * @bus: the BUS
3900 *
3901 * Create PCM information for each codec included in the bus.
3902 *
3903 * The build_pcms codec patch is requested to set up codec->num_pcms and
3904 * codec->pcm_info properly. The array is referred by the top-level driver
3905 * to create its PCM instances.
3906 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3907 * callback.
3908 *
3909 * At least, substreams, channels_min and channels_max must be filled for
3910 * each stream. substreams = 0 indicates that the stream doesn't exist.
3911 * When rates and/or formats are zero, the supported values are queried
3912 * from the given nid. The nid is used also by the default ops.prepare
3913 * and ops.cleanup callbacks.
3914 *
3915 * The driver needs to call ops.open in its open callback. Similarly,
3916 * ops.close is supposed to be called in the close callback.
3917 * ops.prepare should be called in the prepare or hw_params callback
3918 * with the proper parameters for set up.
3919 * ops.cleanup should be called in hw_free for clean up of streams.
3920 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003921 * This function returns 0 if successful, or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003923int __devinit snd_hda_build_pcms(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003925 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926
Takashi Iwai0ba21762007-04-16 11:29:14 +02003927 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003928 int err = snd_hda_codec_build_pcms(codec);
3929 if (err < 0)
3930 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003931 }
3932 return 0;
3933}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003934EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935
Linus Torvalds1da177e2005-04-16 15:20:36 -07003936/**
3937 * snd_hda_check_board_config - compare the current codec with the config table
3938 * @codec: the HDA codec
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003939 * @num_configs: number of config enums
3940 * @models: array of model name strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 * @tbl: configuration table, terminated by null entries
3942 *
3943 * Compares the modelname or PCI subsystem id of the current codec with the
3944 * given configuration table. If a matching entry is found, returns its
3945 * config value (supposed to be 0 or positive).
3946 *
3947 * If no entries are matching, the function returns a negative value.
3948 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003949int snd_hda_check_board_config(struct hda_codec *codec,
Takashi Iwaiea734962011-01-17 11:29:34 +01003950 int num_configs, const char * const *models,
Takashi Iwai12f288b2007-08-02 15:51:59 +02003951 const struct snd_pci_quirk *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952{
Takashi Iwaif44ac832008-07-30 15:01:45 +02003953 if (codec->modelname && models) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003954 int i;
3955 for (i = 0; i < num_configs; i++) {
3956 if (models[i] &&
Takashi Iwaif44ac832008-07-30 15:01:45 +02003957 !strcmp(codec->modelname, models[i])) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003958 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3959 "selected\n", models[i]);
3960 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961 }
3962 }
3963 }
3964
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003965 if (!codec->bus->pci || !tbl)
3966 return -1;
3967
3968 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3969 if (!tbl)
3970 return -1;
3971 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwai62cf8722008-05-20 12:15:15 +02003972#ifdef CONFIG_SND_DEBUG_VERBOSE
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003973 char tmp[10];
3974 const char *model = NULL;
3975 if (models)
3976 model = models[tbl->value];
3977 if (!model) {
3978 sprintf(tmp, "#%d", tbl->value);
3979 model = tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003980 }
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003981 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3982 "for config %x:%x (%s)\n",
3983 model, tbl->subvendor, tbl->subdevice,
3984 (tbl->name ? tbl->name : "Unknown device"));
3985#endif
3986 return tbl->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003987 }
3988 return -1;
3989}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003990EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991
3992/**
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02003993 * snd_hda_check_board_codec_sid_config - compare the current codec
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003994 subsystem ID with the
3995 config table
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02003996
3997 This is important for Gateway notebooks with SB450 HDA Audio
3998 where the vendor ID of the PCI device is:
3999 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4000 and the vendor/subvendor are found only at the codec.
4001
4002 * @codec: the HDA codec
4003 * @num_configs: number of config enums
4004 * @models: array of model name strings
4005 * @tbl: configuration table, terminated by null entries
4006 *
4007 * Compares the modelname or PCI subsystem id of the current codec with the
4008 * given configuration table. If a matching entry is found, returns its
4009 * config value (supposed to be 0 or positive).
4010 *
4011 * If no entries are matching, the function returns a negative value.
4012 */
4013int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
Takashi Iwaiea734962011-01-17 11:29:34 +01004014 int num_configs, const char * const *models,
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004015 const struct snd_pci_quirk *tbl)
4016{
4017 const struct snd_pci_quirk *q;
4018
4019 /* Search for codec ID */
4020 for (q = tbl; q->subvendor; q++) {
Takashi Iwaie2301a42011-11-22 19:58:56 +01004021 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4022 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4023 if ((codec->subsystem_id & mask) == id)
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004024 break;
4025 }
4026
4027 if (!q->subvendor)
4028 return -1;
4029
4030 tbl = q;
4031
4032 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwaid94ff6b2009-09-02 00:20:21 +02004033#ifdef CONFIG_SND_DEBUG_VERBOSE
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004034 char tmp[10];
4035 const char *model = NULL;
4036 if (models)
4037 model = models[tbl->value];
4038 if (!model) {
4039 sprintf(tmp, "#%d", tbl->value);
4040 model = tmp;
4041 }
4042 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4043 "for config %x:%x (%s)\n",
4044 model, tbl->subvendor, tbl->subdevice,
4045 (tbl->name ? tbl->name : "Unknown device"));
4046#endif
4047 return tbl->value;
4048 }
4049 return -1;
4050}
4051EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4052
4053/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004054 * snd_hda_add_new_ctls - create controls from the array
4055 * @codec: the HDA codec
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01004056 * @knew: the array of struct snd_kcontrol_new
Linus Torvalds1da177e2005-04-16 15:20:36 -07004057 *
4058 * This helper function creates and add new controls in the given array.
4059 * The array must be terminated with an empty entry as terminator.
4060 *
4061 * Returns 0 if successful, or a negative error code.
4062 */
Takashi Iwai031024e2011-05-02 11:29:30 +02004063int snd_hda_add_new_ctls(struct hda_codec *codec,
4064 const struct snd_kcontrol_new *knew)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004065{
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01004066 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004067
4068 for (; knew->name; knew++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004069 struct snd_kcontrol *kctl;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004070 int addr = 0, idx = 0;
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01004071 if (knew->iface == -1) /* skip this codec private value */
4072 continue;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004073 for (;;) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004074 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02004075 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01004076 return -ENOMEM;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004077 if (addr > 0)
4078 kctl->id.device = addr;
4079 if (idx > 0)
4080 kctl->id.index = idx;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01004081 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai1afe2062010-12-23 10:17:52 +01004082 if (!err)
4083 break;
4084 /* try first with another device index corresponding to
4085 * the codec addr; if it still fails (or it's the
4086 * primary codec), then try another control index
4087 */
4088 if (!addr && codec->addr)
4089 addr = codec->addr;
4090 else if (!idx && !knew->index) {
4091 idx = find_empty_mixer_ctl_idx(codec,
4092 knew->name);
4093 if (idx <= 0)
4094 return err;
4095 } else
Takashi Iwai54d17402005-11-21 16:33:22 +01004096 return err;
4097 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098 }
4099 return 0;
4100}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004101EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102
Takashi Iwaicb53c622007-08-10 17:21:45 +02004103#ifdef CONFIG_SND_HDA_POWER_SAVE
Takashi Iwaicb53c622007-08-10 17:21:45 +02004104static void hda_power_work(struct work_struct *work)
4105{
4106 struct hda_codec *codec =
4107 container_of(work, struct hda_codec, power_work.work);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004108 struct hda_bus *bus = codec->bus;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004109
Maxim Levitsky2e492462007-09-03 15:26:57 +02004110 if (!codec->power_on || codec->power_count) {
4111 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004112 return;
Maxim Levitsky2e492462007-09-03 15:26:57 +02004113 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02004114
Takashi Iwaid66fee52011-08-02 15:39:31 +02004115 trace_hda_power_down(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004116 hda_call_codec_suspend(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004117 if (bus->ops.pm_notify)
4118 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004119}
4120
4121static void hda_keep_power_on(struct hda_codec *codec)
4122{
4123 codec->power_count++;
4124 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01004125 codec->power_jiffies = jiffies;
4126}
4127
Takashi Iwaid5191e52009-11-16 14:58:17 +01004128/* update the power on/off account with the current jiffies */
Takashi Iwaia2f63092009-11-11 09:34:25 +01004129void snd_hda_update_power_acct(struct hda_codec *codec)
4130{
4131 unsigned long delta = jiffies - codec->power_jiffies;
4132 if (codec->power_on)
4133 codec->power_on_acct += delta;
4134 else
4135 codec->power_off_acct += delta;
4136 codec->power_jiffies += delta;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004137}
4138
Takashi Iwaid5191e52009-11-16 14:58:17 +01004139/**
4140 * snd_hda_power_up - Power-up the codec
4141 * @codec: HD-audio codec
4142 *
4143 * Increment the power-up counter and power up the hardware really when
4144 * not turned on yet.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004145 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004146void snd_hda_power_up(struct hda_codec *codec)
4147{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004148 struct hda_bus *bus = codec->bus;
4149
Takashi Iwaicb53c622007-08-10 17:21:45 +02004150 codec->power_count++;
Takashi Iwaia221e282007-08-16 16:35:33 +02004151 if (codec->power_on || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004152 return;
4153
Takashi Iwaid66fee52011-08-02 15:39:31 +02004154 trace_hda_power_up(codec);
Takashi Iwaia2f63092009-11-11 09:34:25 +01004155 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004156 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01004157 codec->power_jiffies = jiffies;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004158 if (bus->ops.pm_notify)
4159 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004160 hda_call_codec_resume(codec);
4161 cancel_delayed_work(&codec->power_work);
Takashi Iwaia221e282007-08-16 16:35:33 +02004162 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004163}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004164EXPORT_SYMBOL_HDA(snd_hda_power_up);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01004165
4166#define power_save(codec) \
4167 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004168
Takashi Iwaid5191e52009-11-16 14:58:17 +01004169/**
4170 * snd_hda_power_down - Power-down the codec
4171 * @codec: HD-audio codec
4172 *
4173 * Decrement the power-up counter and schedules the power-off work if
4174 * the counter rearches to zero.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004175 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004176void snd_hda_power_down(struct hda_codec *codec)
4177{
4178 --codec->power_count;
Takashi Iwaia221e282007-08-16 16:35:33 +02004179 if (!codec->power_on || codec->power_count || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004180 return;
Takashi Iwaifee2fba2008-11-27 12:43:28 +01004181 if (power_save(codec)) {
Takashi Iwaia221e282007-08-16 16:35:33 +02004182 codec->power_transition = 1; /* avoid reentrance */
Takashi Iwaic107b412009-01-13 17:46:37 +01004183 queue_delayed_work(codec->bus->workq, &codec->power_work,
Takashi Iwaifee2fba2008-11-27 12:43:28 +01004184 msecs_to_jiffies(power_save(codec) * 1000));
Takashi Iwaia221e282007-08-16 16:35:33 +02004185 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02004186}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004187EXPORT_SYMBOL_HDA(snd_hda_power_down);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004188
Takashi Iwaid5191e52009-11-16 14:58:17 +01004189/**
4190 * snd_hda_check_amp_list_power - Check the amp list and update the power
4191 * @codec: HD-audio codec
4192 * @check: the object containing an AMP list and the status
4193 * @nid: NID to check / update
4194 *
4195 * Check whether the given NID is in the amp list. If it's in the list,
4196 * check the current AMP status, and update the the power-status according
4197 * to the mute status.
4198 *
4199 * This function is supposed to be set or called from the check_power_status
4200 * patch ops.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004201 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004202int snd_hda_check_amp_list_power(struct hda_codec *codec,
4203 struct hda_loopback_check *check,
4204 hda_nid_t nid)
4205{
Takashi Iwai031024e2011-05-02 11:29:30 +02004206 const struct hda_amp_list *p;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004207 int ch, v;
4208
4209 if (!check->amplist)
4210 return 0;
4211 for (p = check->amplist; p->nid; p++) {
4212 if (p->nid == nid)
4213 break;
4214 }
4215 if (!p->nid)
4216 return 0; /* nothing changed */
4217
4218 for (p = check->amplist; p->nid; p++) {
4219 for (ch = 0; ch < 2; ch++) {
4220 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4221 p->idx);
4222 if (!(v & HDA_AMP_MUTE) && v > 0) {
4223 if (!check->power_on) {
4224 check->power_on = 1;
4225 snd_hda_power_up(codec);
4226 }
4227 return 1;
4228 }
4229 }
4230 }
4231 if (check->power_on) {
4232 check->power_on = 0;
4233 snd_hda_power_down(codec);
4234 }
4235 return 0;
4236}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004237EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004238#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07004239
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01004240/*
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004241 * Channel mode helper
4242 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01004243
4244/**
4245 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4246 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004247int snd_hda_ch_mode_info(struct hda_codec *codec,
4248 struct snd_ctl_elem_info *uinfo,
4249 const struct hda_channel_mode *chmode,
4250 int num_chmodes)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004251{
4252 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4253 uinfo->count = 1;
4254 uinfo->value.enumerated.items = num_chmodes;
4255 if (uinfo->value.enumerated.item >= num_chmodes)
4256 uinfo->value.enumerated.item = num_chmodes - 1;
4257 sprintf(uinfo->value.enumerated.name, "%dch",
4258 chmode[uinfo->value.enumerated.item].channels);
4259 return 0;
4260}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004261EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004262
Takashi Iwaid5191e52009-11-16 14:58:17 +01004263/**
4264 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4265 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004266int snd_hda_ch_mode_get(struct hda_codec *codec,
4267 struct snd_ctl_elem_value *ucontrol,
4268 const struct hda_channel_mode *chmode,
4269 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004270 int max_channels)
4271{
4272 int i;
4273
4274 for (i = 0; i < num_chmodes; i++) {
4275 if (max_channels == chmode[i].channels) {
4276 ucontrol->value.enumerated.item[0] = i;
4277 break;
4278 }
4279 }
4280 return 0;
4281}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004282EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004283
Takashi Iwaid5191e52009-11-16 14:58:17 +01004284/**
4285 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4286 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004287int snd_hda_ch_mode_put(struct hda_codec *codec,
4288 struct snd_ctl_elem_value *ucontrol,
4289 const struct hda_channel_mode *chmode,
4290 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004291 int *max_channelsp)
4292{
4293 unsigned int mode;
4294
4295 mode = ucontrol->value.enumerated.item[0];
Takashi Iwai68ea7b22007-11-15 15:54:38 +01004296 if (mode >= num_chmodes)
4297 return -EINVAL;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004298 if (*max_channelsp == chmode[mode].channels)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004299 return 0;
4300 /* change the current channel setting */
4301 *max_channelsp = chmode[mode].channels;
4302 if (chmode[mode].sequence)
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004303 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004304 return 1;
4305}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004306EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004307
Linus Torvalds1da177e2005-04-16 15:20:36 -07004308/*
4309 * input MUX helper
4310 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01004311
4312/**
4313 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4314 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004315int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4316 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317{
4318 unsigned int index;
4319
4320 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4321 uinfo->count = 1;
4322 uinfo->value.enumerated.items = imux->num_items;
Takashi Iwai5513b0c2007-10-09 11:58:41 +02004323 if (!imux->num_items)
4324 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 index = uinfo->value.enumerated.item;
4326 if (index >= imux->num_items)
4327 index = imux->num_items - 1;
4328 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4329 return 0;
4330}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004331EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332
Takashi Iwaid5191e52009-11-16 14:58:17 +01004333/**
4334 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4335 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004336int snd_hda_input_mux_put(struct hda_codec *codec,
4337 const struct hda_input_mux *imux,
4338 struct snd_ctl_elem_value *ucontrol,
4339 hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004340 unsigned int *cur_val)
4341{
4342 unsigned int idx;
4343
Takashi Iwai5513b0c2007-10-09 11:58:41 +02004344 if (!imux->num_items)
4345 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004346 idx = ucontrol->value.enumerated.item[0];
4347 if (idx >= imux->num_items)
4348 idx = imux->num_items - 1;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004349 if (*cur_val == idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350 return 0;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004351 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4352 imux->items[idx].index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004353 *cur_val = idx;
4354 return 1;
4355}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004356EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004357
4358
4359/*
4360 * Multi-channel / digital-out PCM helper functions
4361 */
4362
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004363/* setup SPDIF output stream */
4364static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4365 unsigned int stream_tag, unsigned int format)
4366{
Stephen Warren7c935972011-06-01 11:14:17 -06004367 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4368
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004369 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
Stephen Warren7c935972011-06-01 11:14:17 -06004370 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004371 set_dig_out_convert(codec, nid,
Stephen Warren7c935972011-06-01 11:14:17 -06004372 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
Takashi Iwai2f728532008-09-25 16:32:41 +02004373 -1);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004374 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
Takashi Iwai2f728532008-09-25 16:32:41 +02004375 if (codec->slave_dig_outs) {
Takashi Iwaidda14412011-05-02 11:29:30 +02004376 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02004377 for (d = codec->slave_dig_outs; *d; d++)
4378 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4379 format);
Matthew Ranostayde51ca12008-09-07 14:31:40 -04004380 }
Takashi Iwai2f728532008-09-25 16:32:41 +02004381 /* turn on again (if needed) */
Stephen Warren7c935972011-06-01 11:14:17 -06004382 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
Takashi Iwai2f728532008-09-25 16:32:41 +02004383 set_dig_out_convert(codec, nid,
Stephen Warren7c935972011-06-01 11:14:17 -06004384 spdif->ctls & 0xff, -1);
Takashi Iwai2f728532008-09-25 16:32:41 +02004385}
Matthew Ranostayde51ca12008-09-07 14:31:40 -04004386
Takashi Iwai2f728532008-09-25 16:32:41 +02004387static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4388{
4389 snd_hda_codec_cleanup_stream(codec, nid);
4390 if (codec->slave_dig_outs) {
Takashi Iwaidda14412011-05-02 11:29:30 +02004391 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02004392 for (d = codec->slave_dig_outs; *d; d++)
4393 snd_hda_codec_cleanup_stream(codec, *d);
4394 }
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004395}
4396
Takashi Iwaid5191e52009-11-16 14:58:17 +01004397/**
4398 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4399 * @bus: HD-audio bus
4400 */
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004401void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4402{
4403 struct hda_codec *codec;
4404
4405 if (!bus)
4406 return;
4407 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwaie581f3d2011-07-26 10:19:20 +02004408 if (hda_codec_is_power_on(codec) &&
4409 codec->patch_ops.reboot_notify)
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004410 codec->patch_ops.reboot_notify(codec);
4411 }
4412}
Takashi Iwai8f217a22009-11-10 18:26:12 +01004413EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004414
Takashi Iwaid5191e52009-11-16 14:58:17 +01004415/**
4416 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
Linus Torvalds1da177e2005-04-16 15:20:36 -07004417 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004418int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4419 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004420{
Ingo Molnar62932df2006-01-16 16:34:20 +01004421 mutex_lock(&codec->spdif_mutex);
Takashi Iwai5930ca42007-04-16 11:23:56 +02004422 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4423 /* already opened as analog dup; reset it once */
Takashi Iwai2f728532008-09-25 16:32:41 +02004424 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004425 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
Ingo Molnar62932df2006-01-16 16:34:20 +01004426 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 return 0;
4428}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004429EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004430
Takashi Iwaid5191e52009-11-16 14:58:17 +01004431/**
4432 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4433 */
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004434int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4435 struct hda_multi_out *mout,
4436 unsigned int stream_tag,
4437 unsigned int format,
4438 struct snd_pcm_substream *substream)
4439{
4440 mutex_lock(&codec->spdif_mutex);
4441 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4442 mutex_unlock(&codec->spdif_mutex);
4443 return 0;
4444}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004445EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004446
Takashi Iwaid5191e52009-11-16 14:58:17 +01004447/**
4448 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4449 */
Takashi Iwai9411e212009-02-13 11:32:28 +01004450int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4451 struct hda_multi_out *mout)
4452{
4453 mutex_lock(&codec->spdif_mutex);
4454 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4455 mutex_unlock(&codec->spdif_mutex);
4456 return 0;
4457}
4458EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4459
Takashi Iwaid5191e52009-11-16 14:58:17 +01004460/**
4461 * snd_hda_multi_out_dig_close - release the digital out stream
Linus Torvalds1da177e2005-04-16 15:20:36 -07004462 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004463int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4464 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004465{
Ingo Molnar62932df2006-01-16 16:34:20 +01004466 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467 mout->dig_out_used = 0;
Ingo Molnar62932df2006-01-16 16:34:20 +01004468 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004469 return 0;
4470}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004471EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472
Takashi Iwaid5191e52009-11-16 14:58:17 +01004473/**
4474 * snd_hda_multi_out_analog_open - open analog outputs
4475 *
4476 * Open analog outputs and set up the hw-constraints.
4477 * If the digital outputs can be opened as slave, open the digital
4478 * outputs, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004479 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004480int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4481 struct hda_multi_out *mout,
Takashi Iwai9a081602008-02-12 18:37:26 +01004482 struct snd_pcm_substream *substream,
4483 struct hda_pcm_stream *hinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484{
Takashi Iwai9a081602008-02-12 18:37:26 +01004485 struct snd_pcm_runtime *runtime = substream->runtime;
4486 runtime->hw.channels_max = mout->max_channels;
4487 if (mout->dig_out_nid) {
4488 if (!mout->analog_rates) {
4489 mout->analog_rates = hinfo->rates;
4490 mout->analog_formats = hinfo->formats;
4491 mout->analog_maxbps = hinfo->maxbps;
4492 } else {
4493 runtime->hw.rates = mout->analog_rates;
4494 runtime->hw.formats = mout->analog_formats;
4495 hinfo->maxbps = mout->analog_maxbps;
4496 }
4497 if (!mout->spdif_rates) {
4498 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4499 &mout->spdif_rates,
4500 &mout->spdif_formats,
4501 &mout->spdif_maxbps);
4502 }
4503 mutex_lock(&codec->spdif_mutex);
4504 if (mout->share_spdif) {
Takashi Iwai022b4662009-07-03 23:03:30 +02004505 if ((runtime->hw.rates & mout->spdif_rates) &&
4506 (runtime->hw.formats & mout->spdif_formats)) {
4507 runtime->hw.rates &= mout->spdif_rates;
4508 runtime->hw.formats &= mout->spdif_formats;
4509 if (mout->spdif_maxbps < hinfo->maxbps)
4510 hinfo->maxbps = mout->spdif_maxbps;
4511 } else {
4512 mout->share_spdif = 0;
4513 /* FIXME: need notify? */
4514 }
Takashi Iwai9a081602008-02-12 18:37:26 +01004515 }
Frederik Deweerdteaa99852008-04-14 13:11:44 +02004516 mutex_unlock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01004517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4519 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4520}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004521EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004522
Takashi Iwaid5191e52009-11-16 14:58:17 +01004523/**
4524 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4525 *
4526 * Set up the i/o for analog out.
4527 * When the digital out is available, copy the front out to digital out, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004528 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004529int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4530 struct hda_multi_out *mout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004531 unsigned int stream_tag,
4532 unsigned int format,
Takashi Iwaic8b6bf9b2005-11-17 14:57:47 +01004533 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004534{
Takashi Iwaidda14412011-05-02 11:29:30 +02004535 const hda_nid_t *nids = mout->dac_nids;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004536 int chs = substream->runtime->channels;
Stephen Warren7c935972011-06-01 11:14:17 -06004537 struct hda_spdif_out *spdif =
4538 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539 int i;
4540
Ingo Molnar62932df2006-01-16 16:34:20 +01004541 mutex_lock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01004542 if (mout->dig_out_nid && mout->share_spdif &&
4543 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004544 if (chs == 2 &&
Takashi Iwai0ba21762007-04-16 11:29:14 +02004545 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4546 format) &&
Stephen Warren7c935972011-06-01 11:14:17 -06004547 !(spdif->status & IEC958_AES0_NONAUDIO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004548 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004549 setup_dig_out_stream(codec, mout->dig_out_nid,
4550 stream_tag, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004551 } else {
4552 mout->dig_out_used = 0;
Takashi Iwai2f728532008-09-25 16:32:41 +02004553 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004554 }
4555 }
Ingo Molnar62932df2006-01-16 16:34:20 +01004556 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004557
4558 /* front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004559 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4560 0, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02004561 if (!mout->no_share_stream &&
4562 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
Linus Torvalds1da177e2005-04-16 15:20:36 -07004563 /* headphone out will just decode front left/right (stereo) */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004564 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4565 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004566 /* extra outputs copied from front */
Takashi Iwaia06dbfc2011-08-23 18:16:13 +02004567 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4568 if (!mout->no_share_stream && mout->hp_out_nid[i])
4569 snd_hda_codec_setup_stream(codec,
4570 mout->hp_out_nid[i],
4571 stream_tag, 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004572 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
Takashi Iwaid29240c2007-10-26 12:35:56 +02004573 if (!mout->no_share_stream && mout->extra_out_nid[i])
Takashi Iwai82bc9552006-03-21 11:24:42 +01004574 snd_hda_codec_setup_stream(codec,
4575 mout->extra_out_nid[i],
4576 stream_tag, 0, format);
4577
Linus Torvalds1da177e2005-04-16 15:20:36 -07004578 /* surrounds */
4579 for (i = 1; i < mout->num_dacs; i++) {
Takashi Iwai4b3acaf2005-06-10 19:48:10 +02004580 if (chs >= (i + 1) * 2) /* independent out */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004581 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4582 i * 2, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02004583 else if (!mout->no_share_stream) /* copy front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004584 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4585 0, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 }
4587 return 0;
4588}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004589EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004590
Takashi Iwaid5191e52009-11-16 14:58:17 +01004591/**
4592 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004594int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4595 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596{
Takashi Iwaidda14412011-05-02 11:29:30 +02004597 const hda_nid_t *nids = mout->dac_nids;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004598 int i;
4599
4600 for (i = 0; i < mout->num_dacs; i++)
Takashi Iwai888afa12008-03-18 09:57:50 +01004601 snd_hda_codec_cleanup_stream(codec, nids[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004602 if (mout->hp_nid)
Takashi Iwai888afa12008-03-18 09:57:50 +01004603 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
Takashi Iwaia06dbfc2011-08-23 18:16:13 +02004604 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4605 if (mout->hp_out_nid[i])
4606 snd_hda_codec_cleanup_stream(codec,
4607 mout->hp_out_nid[i]);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004608 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4609 if (mout->extra_out_nid[i])
Takashi Iwai888afa12008-03-18 09:57:50 +01004610 snd_hda_codec_cleanup_stream(codec,
4611 mout->extra_out_nid[i]);
Ingo Molnar62932df2006-01-16 16:34:20 +01004612 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004613 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
Takashi Iwai2f728532008-09-25 16:32:41 +02004614 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004615 mout->dig_out_used = 0;
4616 }
Ingo Molnar62932df2006-01-16 16:34:20 +01004617 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004618 return 0;
4619}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004620EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004621
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004622/*
Wu Fengguang6b345002008-10-07 14:21:41 +08004623 * Helper for automatic pin configuration
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004624 */
Kailang Yangdf694da2005-12-05 19:42:22 +01004625
Takashi Iwaidda14412011-05-02 11:29:30 +02004626static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
Kailang Yangdf694da2005-12-05 19:42:22 +01004627{
4628 for (; *list; list++)
4629 if (*list == nid)
4630 return 1;
4631 return 0;
4632}
4633
Steve Longerbeam81937d32007-05-08 15:33:03 +02004634
4635/*
4636 * Sort an associated group of pins according to their sequence numbers.
4637 */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004638static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
Steve Longerbeam81937d32007-05-08 15:33:03 +02004639 int num_pins)
4640{
4641 int i, j;
4642 short seq;
4643 hda_nid_t nid;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004644
Steve Longerbeam81937d32007-05-08 15:33:03 +02004645 for (i = 0; i < num_pins; i++) {
4646 for (j = i + 1; j < num_pins; j++) {
4647 if (sequences[i] > sequences[j]) {
4648 seq = sequences[i];
4649 sequences[i] = sequences[j];
4650 sequences[j] = seq;
4651 nid = pins[i];
4652 pins[i] = pins[j];
4653 pins[j] = nid;
4654 }
4655 }
4656 }
4657}
4658
4659
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004660/* add the found input-pin to the cfg->inputs[] table */
4661static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4662 int type)
4663{
4664 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4665 cfg->inputs[cfg->num_inputs].pin = nid;
4666 cfg->inputs[cfg->num_inputs].type = type;
4667 cfg->num_inputs++;
4668 }
4669}
4670
Takashi Iwai4a4d4a62010-09-09 22:22:02 +02004671/* sort inputs in the order of AUTO_PIN_* type */
4672static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4673{
4674 int i, j;
4675
4676 for (i = 0; i < cfg->num_inputs; i++) {
4677 for (j = i + 1; j < cfg->num_inputs; j++) {
4678 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4679 struct auto_pin_cfg_item tmp;
4680 tmp = cfg->inputs[i];
4681 cfg->inputs[i] = cfg->inputs[j];
4682 cfg->inputs[j] = tmp;
4683 }
4684 }
4685 }
4686}
4687
Takashi Iwai8fa7ab42011-10-26 16:06:27 +02004688/* Reorder the surround channels
4689 * ALSA sequence is front/surr/clfe/side
4690 * HDA sequence is:
4691 * 4-ch: front/surr => OK as it is
4692 * 6-ch: front/clfe/surr
4693 * 8-ch: front/clfe/rear/side|fc
4694 */
4695static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4696{
4697 hda_nid_t nid;
4698
4699 switch (nums) {
4700 case 3:
4701 case 4:
4702 nid = pins[1];
4703 pins[1] = pins[2];
4704 pins[2] = nid;
4705 break;
4706 }
4707}
4708
Takashi Iwai82bc9552006-03-21 11:24:42 +01004709/*
4710 * Parse all pin widgets and store the useful pin nids to cfg
4711 *
4712 * The number of line-outs or any primary output is stored in line_outs,
4713 * and the corresponding output pins are assigned to line_out_pins[],
4714 * in the order of front, rear, CLFE, side, ...
4715 *
4716 * If more extra outputs (speaker and headphone) are found, the pins are
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004717 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
Takashi Iwai82bc9552006-03-21 11:24:42 +01004718 * is detected, one of speaker of HP pins is assigned as the primary
4719 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4720 * if any analog output exists.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004721 *
Takashi Iwai86e29592010-09-09 14:50:17 +02004722 * The analog input pins are assigned to inputs array.
Takashi Iwai82bc9552006-03-21 11:24:42 +01004723 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4724 * respectively.
4725 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02004726int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4727 struct auto_pin_cfg *cfg,
4728 const hda_nid_t *ignore_nids,
4729 unsigned int cond_flags)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004730{
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004731 hda_nid_t nid, end_nid;
Takashi Iwai965f1b22011-08-19 09:10:29 +02004732 short seq, assoc_line_out;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004733 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4734 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
Takashi Iwaif889fa92007-10-31 15:49:32 +01004735 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004736 int i;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004737
4738 memset(cfg, 0, sizeof(*cfg));
4739
Steve Longerbeam81937d32007-05-08 15:33:03 +02004740 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4741 memset(sequences_speaker, 0, sizeof(sequences_speaker));
Takashi Iwaif889fa92007-10-31 15:49:32 +01004742 memset(sequences_hp, 0, sizeof(sequences_hp));
Takashi Iwai965f1b22011-08-19 09:10:29 +02004743 assoc_line_out = 0;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004744
Takashi Iwai2f451d22011-11-10 12:36:46 +01004745 codec->ignore_misc_bit = true;
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004746 end_nid = codec->start_nid + codec->num_nodes;
4747 for (nid = codec->start_nid; nid < end_nid; nid++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004748 unsigned int wid_caps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +02004749 unsigned int wid_type = get_wcaps_type(wid_caps);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004750 unsigned int def_conf;
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004751 short assoc, loc, conn, dev;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004752
4753 /* read all default configuration for pin complex */
4754 if (wid_type != AC_WID_PIN)
4755 continue;
Kailang Yangdf694da2005-12-05 19:42:22 +01004756 /* ignore the given nids (e.g. pc-beep returns error) */
4757 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4758 continue;
4759
Takashi Iwaic17a1ab2009-02-23 09:28:12 +01004760 def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai2f451d22011-11-10 12:36:46 +01004761 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4762 AC_DEFCFG_MISC_NO_PRESENCE))
4763 codec->ignore_misc_bit = false;
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004764 conn = get_defcfg_connect(def_conf);
4765 if (conn == AC_JACK_PORT_NONE)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004766 continue;
4767 loc = get_defcfg_location(def_conf);
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004768 dev = get_defcfg_device(def_conf);
4769
4770 /* workaround for buggy BIOS setups */
4771 if (dev == AC_JACK_LINE_OUT) {
4772 if (conn == AC_JACK_PORT_FIXED)
4773 dev = AC_JACK_SPEAKER;
4774 }
4775
4776 switch (dev) {
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004777 case AC_JACK_LINE_OUT:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004778 seq = get_defcfg_sequence(def_conf);
4779 assoc = get_defcfg_association(def_conf);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01004780
4781 if (!(wid_caps & AC_WCAP_STEREO))
4782 if (!cfg->mono_out_pin)
4783 cfg->mono_out_pin = nid;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004784 if (!assoc)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004785 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004786 if (!assoc_line_out)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004787 assoc_line_out = assoc;
4788 else if (assoc_line_out != assoc)
4789 continue;
4790 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4791 continue;
4792 cfg->line_out_pins[cfg->line_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004793 sequences_line_out[cfg->line_outs] = seq;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004794 cfg->line_outs++;
4795 break;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004796 case AC_JACK_SPEAKER:
Steve Longerbeam81937d32007-05-08 15:33:03 +02004797 seq = get_defcfg_sequence(def_conf);
4798 assoc = get_defcfg_association(def_conf);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004799 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4800 continue;
4801 cfg->speaker_pins[cfg->speaker_outs] = nid;
Takashi Iwai965f1b22011-08-19 09:10:29 +02004802 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
Takashi Iwai82bc9552006-03-21 11:24:42 +01004803 cfg->speaker_outs++;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004804 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004805 case AC_JACK_HP_OUT:
Takashi Iwaif889fa92007-10-31 15:49:32 +01004806 seq = get_defcfg_sequence(def_conf);
4807 assoc = get_defcfg_association(def_conf);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004808 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4809 continue;
4810 cfg->hp_pins[cfg->hp_outs] = nid;
Takashi Iwaif889fa92007-10-31 15:49:32 +01004811 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004812 cfg->hp_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004813 break;
Takashi Iwai86e29592010-09-09 14:50:17 +02004814 case AC_JACK_MIC_IN:
4815 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004816 break;
Takashi Iwai86e29592010-09-09 14:50:17 +02004817 case AC_JACK_LINE_IN:
4818 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004819 break;
4820 case AC_JACK_CD:
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004821 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004822 break;
4823 case AC_JACK_AUX:
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004824 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004825 break;
4826 case AC_JACK_SPDIF_OUT:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01004827 case AC_JACK_DIG_OTHER_OUT:
Takashi Iwai0852d7a2009-02-11 11:35:15 +01004828 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4829 continue;
4830 cfg->dig_out_pins[cfg->dig_outs] = nid;
4831 cfg->dig_out_type[cfg->dig_outs] =
4832 (loc == AC_JACK_LOC_HDMI) ?
4833 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4834 cfg->dig_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004835 break;
4836 case AC_JACK_SPDIF_IN:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01004837 case AC_JACK_DIG_OTHER_IN:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004838 cfg->dig_in_pin = nid;
Takashi Iwai2297bd62009-01-20 18:24:13 +01004839 if (loc == AC_JACK_LOC_HDMI)
4840 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4841 else
4842 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004843 break;
4844 }
4845 }
4846
Takashi Iwai5832fcf2008-02-12 18:30:12 +01004847 /* FIX-UP:
4848 * If no line-out is defined but multiple HPs are found,
4849 * some of them might be the real line-outs.
4850 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02004851 if (!cfg->line_outs && cfg->hp_outs > 1 &&
4852 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
Takashi Iwai5832fcf2008-02-12 18:30:12 +01004853 int i = 0;
4854 while (i < cfg->hp_outs) {
4855 /* The real HPs should have the sequence 0x0f */
4856 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4857 i++;
4858 continue;
4859 }
4860 /* Move it to the line-out table */
4861 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4862 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4863 cfg->line_outs++;
4864 cfg->hp_outs--;
4865 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4866 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
Takashi Iwai122661b2010-09-08 14:57:04 +02004867 memmove(sequences_hp + i, sequences_hp + i + 1,
Takashi Iwai5832fcf2008-02-12 18:30:12 +01004868 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4869 }
Takashi Iwai03642c92010-09-08 15:28:19 +02004870 memset(cfg->hp_pins + cfg->hp_outs, 0,
4871 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
Takashi Iwaib2d05762011-01-10 14:47:35 +01004872 if (!cfg->hp_outs)
4873 cfg->line_out_type = AUTO_PIN_HP_OUT;
4874
Takashi Iwai5832fcf2008-02-12 18:30:12 +01004875 }
4876
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004877 /* sort by sequence */
Steve Longerbeam81937d32007-05-08 15:33:03 +02004878 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4879 cfg->line_outs);
4880 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4881 cfg->speaker_outs);
Takashi Iwaif889fa92007-10-31 15:49:32 +01004882 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4883 cfg->hp_outs);
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004884
Steve Longerbeam81937d32007-05-08 15:33:03 +02004885 /*
4886 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4887 * as a primary output
4888 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02004889 if (!cfg->line_outs &&
4890 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
Steve Longerbeam81937d32007-05-08 15:33:03 +02004891 if (cfg->speaker_outs) {
4892 cfg->line_outs = cfg->speaker_outs;
4893 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4894 sizeof(cfg->speaker_pins));
4895 cfg->speaker_outs = 0;
4896 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4897 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4898 } else if (cfg->hp_outs) {
4899 cfg->line_outs = cfg->hp_outs;
4900 memcpy(cfg->line_out_pins, cfg->hp_pins,
4901 sizeof(cfg->hp_pins));
4902 cfg->hp_outs = 0;
4903 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4904 cfg->line_out_type = AUTO_PIN_HP_OUT;
4905 }
4906 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004907
Takashi Iwai8fa7ab42011-10-26 16:06:27 +02004908 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
4909 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
4910 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004911
Takashi Iwai4a4d4a62010-09-09 22:22:02 +02004912 sort_autocfg_input_pins(cfg);
4913
Takashi Iwai82bc9552006-03-21 11:24:42 +01004914 /*
4915 * debug prints of the parsed results
4916 */
Takashi Iwaic2de1872011-04-29 13:00:40 +02004917 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
Takashi Iwai82bc9552006-03-21 11:24:42 +01004918 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4919 cfg->line_out_pins[2], cfg->line_out_pins[3],
Takashi Iwaic2de1872011-04-29 13:00:40 +02004920 cfg->line_out_pins[4],
4921 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
4922 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
4923 "speaker" : "line"));
Takashi Iwai82bc9552006-03-21 11:24:42 +01004924 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4925 cfg->speaker_outs, cfg->speaker_pins[0],
4926 cfg->speaker_pins[1], cfg->speaker_pins[2],
4927 cfg->speaker_pins[3], cfg->speaker_pins[4]);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004928 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4929 cfg->hp_outs, cfg->hp_pins[0],
4930 cfg->hp_pins[1], cfg->hp_pins[2],
4931 cfg->hp_pins[3], cfg->hp_pins[4]);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01004932 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
Takashi Iwai0852d7a2009-02-11 11:35:15 +01004933 if (cfg->dig_outs)
4934 snd_printd(" dig-out=0x%x/0x%x\n",
4935 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004936 snd_printd(" inputs:");
4937 for (i = 0; i < cfg->num_inputs; i++) {
Takashi Iwai0b626732011-05-26 14:10:44 +02004938 snd_printd(" %s=0x%x",
Takashi Iwai10a20af2010-09-09 16:28:02 +02004939 hda_get_autocfg_input_label(codec, cfg, i),
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004940 cfg->inputs[i].pin);
4941 }
4942 snd_printd("\n");
Takashi Iwai32d2c7f2009-02-11 11:33:13 +01004943 if (cfg->dig_in_pin)
Takashi Iwai89ce9e82009-01-20 17:15:57 +01004944 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004945
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004946 return 0;
4947}
Takashi Iwaid025feb2011-08-23 15:24:39 +02004948EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004949
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004950int snd_hda_get_input_pin_attr(unsigned int def_conf)
Takashi Iwaia1c98512010-09-09 21:36:27 +02004951{
4952 unsigned int loc = get_defcfg_location(def_conf);
Takashi Iwai41c89ef2010-09-17 10:26:37 +02004953 unsigned int conn = get_defcfg_connect(def_conf);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004954 if (conn == AC_JACK_PORT_NONE)
4955 return INPUT_PIN_ATTR_UNUSED;
Takashi Iwai41c89ef2010-09-17 10:26:37 +02004956 /* Windows may claim the internal mic to be BOTH, too */
4957 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004958 return INPUT_PIN_ATTR_INT;
Takashi Iwai41c89ef2010-09-17 10:26:37 +02004959 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004960 return INPUT_PIN_ATTR_INT;
Takashi Iwaia1c98512010-09-09 21:36:27 +02004961 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004962 return INPUT_PIN_ATTR_DOCK;
Takashi Iwaia1c98512010-09-09 21:36:27 +02004963 if (loc == AC_JACK_LOC_REAR)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004964 return INPUT_PIN_ATTR_REAR;
Takashi Iwaia1c98512010-09-09 21:36:27 +02004965 if (loc == AC_JACK_LOC_FRONT)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004966 return INPUT_PIN_ATTR_FRONT;
4967 return INPUT_PIN_ATTR_NORMAL;
Takashi Iwaia1c98512010-09-09 21:36:27 +02004968}
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004969EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
Takashi Iwaia1c98512010-09-09 21:36:27 +02004970
Takashi Iwai990061c2010-09-09 22:08:44 +02004971/**
4972 * hda_get_input_pin_label - Give a label for the given input pin
4973 *
4974 * When check_location is true, the function checks the pin location
4975 * for mic and line-in pins, and set an appropriate prefix like "Front",
4976 * "Rear", "Internal".
4977 */
4978
Takashi Iwai04f5ade2011-10-27 20:47:07 +02004979static const char *hda_get_input_pin_label(struct hda_codec *codec,
4980 hda_nid_t pin, bool check_location)
Takashi Iwai10a20af2010-09-09 16:28:02 +02004981{
Takashi Iwaia1c98512010-09-09 21:36:27 +02004982 unsigned int def_conf;
Takashi Iwaiea734962011-01-17 11:29:34 +01004983 static const char * const mic_names[] = {
Takashi Iwaia1c98512010-09-09 21:36:27 +02004984 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
4985 };
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004986 int attr;
Takashi Iwai4a471b72005-12-07 13:56:29 +01004987
Takashi Iwai10a20af2010-09-09 16:28:02 +02004988 def_conf = snd_hda_codec_get_pincfg(codec, pin);
Takashi Iwai10a20af2010-09-09 16:28:02 +02004989
4990 switch (get_defcfg_device(def_conf)) {
4991 case AC_JACK_MIC_IN:
4992 if (!check_location)
4993 return "Mic";
Takashi Iwai99ae28b2010-09-17 14:42:34 +02004994 attr = snd_hda_get_input_pin_attr(def_conf);
4995 if (!attr)
4996 return "None";
4997 return mic_names[attr - 1];
Takashi Iwai10a20af2010-09-09 16:28:02 +02004998 case AC_JACK_LINE_IN:
4999 if (!check_location)
5000 return "Line";
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005001 attr = snd_hda_get_input_pin_attr(def_conf);
5002 if (!attr)
5003 return "None";
5004 if (attr == INPUT_PIN_ATTR_DOCK)
5005 return "Dock Line";
5006 return "Line";
Takashi Iwai10a20af2010-09-09 16:28:02 +02005007 case AC_JACK_AUX:
5008 return "Aux";
5009 case AC_JACK_CD:
5010 return "CD";
5011 case AC_JACK_SPDIF_IN:
5012 return "SPDIF In";
5013 case AC_JACK_DIG_OTHER_IN:
5014 return "Digital In";
5015 default:
5016 return "Misc";
5017 }
5018}
Takashi Iwai10a20af2010-09-09 16:28:02 +02005019
Takashi Iwaia1c98512010-09-09 21:36:27 +02005020/* Check whether the location prefix needs to be added to the label.
5021 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5022 * have to put "Front" prefix to each label. In such a case, returns false.
5023 */
5024static int check_mic_location_need(struct hda_codec *codec,
5025 const struct auto_pin_cfg *cfg,
5026 int input)
5027{
5028 unsigned int defc;
5029 int i, attr, attr2;
5030
5031 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005032 attr = snd_hda_get_input_pin_attr(defc);
Takashi Iwaia1c98512010-09-09 21:36:27 +02005033 /* for internal or docking mics, we need locations */
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005034 if (attr <= INPUT_PIN_ATTR_NORMAL)
Takashi Iwaia1c98512010-09-09 21:36:27 +02005035 return 1;
5036
5037 attr = 0;
5038 for (i = 0; i < cfg->num_inputs; i++) {
5039 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005040 attr2 = snd_hda_get_input_pin_attr(defc);
5041 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
Takashi Iwaia1c98512010-09-09 21:36:27 +02005042 if (attr && attr != attr2)
5043 return 1; /* different locations found */
5044 attr = attr2;
5045 }
5046 }
5047 return 0;
5048}
5049
Takashi Iwai990061c2010-09-09 22:08:44 +02005050/**
5051 * hda_get_autocfg_input_label - Get a label for the given input
5052 *
5053 * Get a label for the given input pin defined by the autocfg item.
5054 * Unlike hda_get_input_pin_label(), this function checks all inputs
5055 * defined in autocfg and avoids the redundant mic/line prefix as much as
5056 * possible.
5057 */
Takashi Iwai10a20af2010-09-09 16:28:02 +02005058const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5059 const struct auto_pin_cfg *cfg,
5060 int input)
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005061{
5062 int type = cfg->inputs[input].type;
Takashi Iwai10a20af2010-09-09 16:28:02 +02005063 int has_multiple_pins = 0;
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005064
Takashi Iwai10a20af2010-09-09 16:28:02 +02005065 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5066 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5067 has_multiple_pins = 1;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005068 if (has_multiple_pins && type == AUTO_PIN_MIC)
5069 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
Takashi Iwai10a20af2010-09-09 16:28:02 +02005070 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5071 has_multiple_pins);
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005072}
Takashi Iwai10a20af2010-09-09 16:28:02 +02005073EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5074
Takashi Iwai358b6e62011-11-21 14:34:20 +01005075/* return the position of NID in the list, or -1 if not found */
5076static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5077{
5078 int i;
5079 for (i = 0; i < nums; i++)
5080 if (list[i] == nid)
5081 return i;
5082 return -1;
5083}
5084
Takashi Iwai201e06f2011-11-16 15:33:26 +01005085/* get a unique suffix or an index number */
5086static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5087 int num_pins, int *indexp)
5088{
5089 static const char * const channel_sfx[] = {
Takashi Iwaid6018bb2011-11-21 14:17:16 +01005090 " Front", " Surround", " CLFE", " Side"
Takashi Iwai201e06f2011-11-16 15:33:26 +01005091 };
5092 int i;
5093
Takashi Iwai358b6e62011-11-21 14:34:20 +01005094 i = find_idx_in_nid_list(nid, pins, num_pins);
5095 if (i < 0)
5096 return NULL;
5097 if (num_pins == 1)
5098 return "";
5099 if (num_pins > ARRAY_SIZE(channel_sfx)) {
5100 if (indexp)
5101 *indexp = i;
5102 return "";
Takashi Iwai201e06f2011-11-16 15:33:26 +01005103 }
Takashi Iwai358b6e62011-11-21 14:34:20 +01005104 return channel_sfx[i];
Takashi Iwai201e06f2011-11-16 15:33:26 +01005105}
5106
5107static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5108 const struct auto_pin_cfg *cfg,
5109 const char *name, char *label, int maxlen,
5110 int *indexp)
5111{
5112 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5113 int attr = snd_hda_get_input_pin_attr(def_conf);
5114 const char *pfx = "", *sfx = "";
5115
5116 /* handle as a speaker if it's a fixed line-out */
5117 if (!strcmp(name, "Line-Out") && attr == INPUT_PIN_ATTR_INT)
5118 name = "Speaker";
5119 /* check the location */
5120 switch (attr) {
5121 case INPUT_PIN_ATTR_DOCK:
5122 pfx = "Dock ";
5123 break;
5124 case INPUT_PIN_ATTR_FRONT:
5125 pfx = "Front ";
5126 break;
5127 }
5128 if (cfg) {
5129 /* try to give a unique suffix if needed */
5130 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5131 indexp);
5132 if (!sfx)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005133 sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5134 indexp);
Takashi Iwai358b6e62011-11-21 14:34:20 +01005135 if (!sfx) {
5136 /* don't add channel suffix for Headphone controls */
5137 int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5138 cfg->hp_outs);
5139 if (idx >= 0)
5140 *indexp = idx;
Takashi Iwai201e06f2011-11-16 15:33:26 +01005141 sfx = "";
Takashi Iwai358b6e62011-11-21 14:34:20 +01005142 }
Takashi Iwai201e06f2011-11-16 15:33:26 +01005143 }
5144 snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5145 return 1;
5146}
5147
Takashi Iwai990061c2010-09-09 22:08:44 +02005148/**
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005149 * snd_hda_get_pin_label - Get a label for the given I/O pin
5150 *
5151 * Get a label for the given pin. This function works for both input and
5152 * output pins. When @cfg is given as non-NULL, the function tries to get
5153 * an optimized label using hda_get_autocfg_input_label().
Takashi Iwai201e06f2011-11-16 15:33:26 +01005154 *
5155 * This function tries to give a unique label string for the pin as much as
5156 * possible. For example, when the multiple line-outs are present, it adds
5157 * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5158 * If no unique name with a suffix is available and @indexp is non-NULL, the
5159 * index number is stored in the pointer.
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005160 */
Takashi Iwai201e06f2011-11-16 15:33:26 +01005161int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5162 const struct auto_pin_cfg *cfg,
5163 char *label, int maxlen, int *indexp)
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005164{
5165 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai201e06f2011-11-16 15:33:26 +01005166 const char *name = NULL;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005167 int i;
5168
Takashi Iwai201e06f2011-11-16 15:33:26 +01005169 if (indexp)
5170 *indexp = 0;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005171 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005172 return 0;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005173
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005174 switch (get_defcfg_device(def_conf)) {
5175 case AC_JACK_LINE_OUT:
Takashi Iwai201e06f2011-11-16 15:33:26 +01005176 return fill_audio_out_name(codec, nid, cfg, "Line-Out",
5177 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005178 case AC_JACK_SPEAKER:
Takashi Iwai201e06f2011-11-16 15:33:26 +01005179 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5180 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005181 case AC_JACK_HP_OUT:
Takashi Iwai201e06f2011-11-16 15:33:26 +01005182 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5183 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005184 case AC_JACK_SPDIF_OUT:
5185 case AC_JACK_DIG_OTHER_OUT:
5186 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005187 name = "HDMI";
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005188 else
Takashi Iwai201e06f2011-11-16 15:33:26 +01005189 name = "SPDIF";
5190 if (cfg && indexp) {
Takashi Iwai358b6e62011-11-21 14:34:20 +01005191 i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5192 cfg->dig_outs);
5193 if (i >= 0)
5194 *indexp = i;
Takashi Iwai201e06f2011-11-16 15:33:26 +01005195 }
5196 break;
5197 default:
5198 if (cfg) {
5199 for (i = 0; i < cfg->num_inputs; i++) {
5200 if (cfg->inputs[i].pin != nid)
5201 continue;
5202 name = hda_get_autocfg_input_label(codec, cfg, i);
5203 if (name)
5204 break;
5205 }
5206 }
5207 if (!name)
5208 name = hda_get_input_pin_label(codec, nid, true);
5209 break;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005210 }
Takashi Iwai201e06f2011-11-16 15:33:26 +01005211 if (!name)
5212 return 0;
5213 strlcpy(label, name, maxlen);
5214 return 1;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005215}
5216EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5217
Takashi Iwai990061c2010-09-09 22:08:44 +02005218/**
5219 * snd_hda_add_imux_item - Add an item to input_mux
5220 *
5221 * When the same label is used already in the existing items, the number
5222 * suffix is appended to the label. This label index number is stored
5223 * to type_idx when non-NULL pointer is given.
5224 */
Takashi Iwai10a20af2010-09-09 16:28:02 +02005225int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5226 int index, int *type_idx)
5227{
5228 int i, label_idx = 0;
5229 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5230 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5231 return -EINVAL;
5232 }
5233 for (i = 0; i < imux->num_items; i++) {
5234 if (!strncmp(label, imux->items[i].label, strlen(label)))
5235 label_idx++;
5236 }
5237 if (type_idx)
5238 *type_idx = label_idx;
5239 if (label_idx > 0)
5240 snprintf(imux->items[imux->num_items].label,
5241 sizeof(imux->items[imux->num_items].label),
5242 "%s %d", label, label_idx);
5243 else
5244 strlcpy(imux->items[imux->num_items].label, label,
5245 sizeof(imux->items[imux->num_items].label));
5246 imux->items[imux->num_items].index = index;
5247 imux->num_items++;
5248 return 0;
5249}
5250EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005251
Takashi Iwai4a471b72005-12-07 13:56:29 +01005252
Linus Torvalds1da177e2005-04-16 15:20:36 -07005253#ifdef CONFIG_PM
5254/*
5255 * power management
5256 */
5257
5258/**
5259 * snd_hda_suspend - suspend the codecs
5260 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07005261 *
5262 * Returns 0 if successful.
5263 */
Takashi Iwai8dd78332009-06-02 01:16:07 +02005264int snd_hda_suspend(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005265{
Takashi Iwai0ba21762007-04-16 11:29:14 +02005266 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005267
Takashi Iwai0ba21762007-04-16 11:29:14 +02005268 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwaie581f3d2011-07-26 10:19:20 +02005269 if (hda_codec_is_power_on(codec))
5270 hda_call_codec_suspend(codec);
5271 if (codec->patch_ops.post_suspend)
5272 codec->patch_ops.post_suspend(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005273 }
5274 return 0;
5275}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005276EXPORT_SYMBOL_HDA(snd_hda_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005277
5278/**
5279 * snd_hda_resume - resume the codecs
5280 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07005281 *
5282 * Returns 0 if successful.
Takashi Iwaicb53c622007-08-10 17:21:45 +02005283 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005284 * This function is defined only when POWER_SAVE isn't set.
Takashi Iwaicb53c622007-08-10 17:21:45 +02005285 * In the power-save mode, the codec is resumed dynamically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005286 */
5287int snd_hda_resume(struct hda_bus *bus)
5288{
Takashi Iwai0ba21762007-04-16 11:29:14 +02005289 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005290
Takashi Iwai0ba21762007-04-16 11:29:14 +02005291 list_for_each_entry(codec, &bus->codec_list, list) {
Vitaliy Kulikovd02667e2011-07-22 18:18:15 -05005292 if (codec->patch_ops.pre_resume)
5293 codec->patch_ops.pre_resume(codec);
Maxim Levitskyd804ad92007-09-03 15:28:04 +02005294 if (snd_hda_codec_needs_resume(codec))
5295 hda_call_codec_resume(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005297 return 0;
5298}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005299EXPORT_SYMBOL_HDA(snd_hda_resume);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01005300#endif /* CONFIG_PM */
Takashi Iwaib2e18592008-07-30 15:01:44 +02005301
5302/*
5303 * generic arrays
5304 */
5305
Takashi Iwaid5191e52009-11-16 14:58:17 +01005306/**
5307 * snd_array_new - get a new element from the given array
5308 * @array: the array object
Norberto Lopes28aedaf2010-02-28 20:16:53 +01005309 *
Takashi Iwaid5191e52009-11-16 14:58:17 +01005310 * Get a new element from the given array. If it exceeds the
5311 * pre-allocated array size, re-allocate the array.
5312 *
5313 * Returns NULL if allocation failed.
Takashi Iwaib2e18592008-07-30 15:01:44 +02005314 */
5315void *snd_array_new(struct snd_array *array)
5316{
5317 if (array->used >= array->alloced) {
5318 int num = array->alloced + array->alloc_align;
Takashi Iwai3101ba02011-07-12 08:05:16 +02005319 int size = (num + 1) * array->elem_size;
Takashi Iwai00ef9612011-07-14 15:57:27 +02005320 int oldsize = array->alloced * array->elem_size;
Takashi Iwaib910d9a2008-11-07 00:26:52 +01005321 void *nlist;
5322 if (snd_BUG_ON(num >= 4096))
5323 return NULL;
Takashi Iwai3101ba02011-07-12 08:05:16 +02005324 nlist = krealloc(array->list, size, GFP_KERNEL);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005325 if (!nlist)
5326 return NULL;
Takashi Iwai00ef9612011-07-14 15:57:27 +02005327 memset(nlist + oldsize, 0, size - oldsize);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005328 array->list = nlist;
5329 array->alloced = num;
5330 }
Takashi Iwaif43aa022008-11-10 16:24:26 +01005331 return snd_array_elem(array, array->used++);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005332}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005333EXPORT_SYMBOL_HDA(snd_array_new);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005334
Takashi Iwaid5191e52009-11-16 14:58:17 +01005335/**
5336 * snd_array_free - free the given array elements
5337 * @array: the array object
5338 */
Takashi Iwaib2e18592008-07-30 15:01:44 +02005339void snd_array_free(struct snd_array *array)
5340{
5341 kfree(array->list);
5342 array->used = 0;
5343 array->alloced = 0;
5344 array->list = NULL;
5345}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005346EXPORT_SYMBOL_HDA(snd_array_free);
Takashi Iwaib2022262008-11-21 21:24:03 +01005347
Takashi Iwaid5191e52009-11-16 14:58:17 +01005348/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01005349 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5350 * @pcm: PCM caps bits
5351 * @buf: the string buffer to write
5352 * @buflen: the max buffer length
5353 *
5354 * used by hda_proc.c and hda_eld.c
5355 */
Takashi Iwaib2022262008-11-21 21:24:03 +01005356void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5357{
5358 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5359 int i, j;
5360
5361 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5362 if (pcm & (AC_SUPPCM_BITS_8 << i))
5363 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5364
5365 buf[j] = '\0'; /* necessary when j == 0 */
5366}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005367EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01005368
5369MODULE_DESCRIPTION("HDA codec core");
5370MODULE_LICENSE("GPL");