blob: e344235da491b2b14bbe06e72e21875005ab58fa [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <sound/core.h>
28#include "hda_codec.h"
29#include <sound/asoundef.h>
Jaroslav Kysela302e9c52006-07-05 17:39:49 +020030#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <sound/initval.h>
32#include "hda_local.h"
Jaroslav Kysela123c07a2009-10-21 14:48:23 +020033#include "hda_beep.h"
Takashi Iwai28073142007-07-27 18:58:06 +020034#include <sound/hda_hwdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Linus Torvalds1da177e2005-04-16 15:20:36 -070036/*
37 * vendor / preset table
38 */
39
40struct hda_vendor_id {
41 unsigned int id;
42 const char *name;
43};
44
45/* codec vendor labels */
46static struct hda_vendor_id hda_vendor_ids[] = {
Takashi Iwaic8cd1282008-02-13 16:59:29 +010047 { 0x1002, "ATI" },
Takashi Iwaie5f14242009-07-01 18:11:44 +020048 { 0x1013, "Cirrus Logic" },
Takashi Iwaia9226252006-09-17 22:05:54 +020049 { 0x1057, "Motorola" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010050 { 0x1095, "Silicon Image" },
Takashi Iwai31117b72008-12-16 14:43:21 +010051 { 0x10de, "Nvidia" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010052 { 0x10ec, "Realtek" },
Takashi Iwai4e01f542009-04-16 08:53:34 +020053 { 0x1102, "Creative" },
Joseph Chanc577b8a2006-11-29 15:29:40 +010054 { 0x1106, "VIA" },
Matthew Ranostay7f168592007-10-18 17:38:17 +020055 { 0x111d, "IDT" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010056 { 0x11c1, "LSI" },
Takashi Iwai54b903e2005-05-15 14:30:10 +020057 { 0x11d4, "Analog Devices" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 { 0x13f6, "C-Media" },
Takashi Iwaia9226252006-09-17 22:05:54 +020059 { 0x14f1, "Conexant" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010060 { 0x17e8, "Chrontel" },
61 { 0x1854, "LG" },
Mark Brown8199de32008-10-28 14:50:13 +000062 { 0x1aec, "Wolfson Microelectronics" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 { 0x434d, "C-Media" },
Takashi Iwai74c61132008-12-18 09:11:33 +010064 { 0x8086, "Intel" },
Matt2f2f4252005-04-13 14:45:30 +020065 { 0x8384, "SigmaTel" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 {} /* terminator */
67};
68
Takashi Iwai1289e9e2008-11-27 15:47:11 +010069static DEFINE_MUTEX(preset_mutex);
70static LIST_HEAD(hda_preset_tables);
71
72int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
73{
74 mutex_lock(&preset_mutex);
75 list_add_tail(&preset->list, &hda_preset_tables);
76 mutex_unlock(&preset_mutex);
77 return 0;
78}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010079EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
Takashi Iwai1289e9e2008-11-27 15:47:11 +010080
81int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
82{
83 mutex_lock(&preset_mutex);
84 list_del(&preset->list);
85 mutex_unlock(&preset_mutex);
86 return 0;
87}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010088EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Takashi Iwaicb53c622007-08-10 17:21:45 +020090#ifdef CONFIG_SND_HDA_POWER_SAVE
91static void hda_power_work(struct work_struct *work);
92static void hda_keep_power_on(struct hda_codec *codec);
93#else
94static inline void hda_keep_power_on(struct hda_codec *codec) {}
95#endif
96
Takashi Iwaid5191e52009-11-16 14:58:17 +010097/**
98 * snd_hda_get_jack_location - Give a location string of the jack
99 * @cfg: pin default config value
100 *
101 * Parse the pin default config value and returns the string of the
102 * jack location, e.g. "Rear", "Front", etc.
103 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400104const char *snd_hda_get_jack_location(u32 cfg)
105{
106 static char *bases[7] = {
107 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
108 };
109 static unsigned char specials_idx[] = {
110 0x07, 0x08,
111 0x17, 0x18, 0x19,
112 0x37, 0x38
113 };
114 static char *specials[] = {
115 "Rear Panel", "Drive Bar",
116 "Riser", "HDMI", "ATAPI",
117 "Mobile-In", "Mobile-Out"
118 };
119 int i;
120 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
121 if ((cfg & 0x0f) < 7)
122 return bases[cfg & 0x0f];
123 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
124 if (cfg == specials_idx[i])
125 return specials[i];
126 }
127 return "UNKNOWN";
128}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100129EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400130
Takashi Iwaid5191e52009-11-16 14:58:17 +0100131/**
132 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
133 * @cfg: pin default config value
134 *
135 * Parse the pin default config value and returns the string of the
136 * jack connectivity, i.e. external or internal connection.
137 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400138const char *snd_hda_get_jack_connectivity(u32 cfg)
139{
140 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
141
142 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
143}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100144EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400145
Takashi Iwaid5191e52009-11-16 14:58:17 +0100146/**
147 * snd_hda_get_jack_type - Give a type string of the jack
148 * @cfg: pin default config value
149 *
150 * Parse the pin default config value and returns the string of the
151 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
152 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400153const char *snd_hda_get_jack_type(u32 cfg)
154{
155 static char *jack_types[16] = {
156 "Line Out", "Speaker", "HP Out", "CD",
157 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
158 "Line In", "Aux", "Mic", "Telephony",
159 "SPDIF In", "Digitial In", "Reserved", "Other"
160 };
161
162 return jack_types[(cfg & AC_DEFCFG_DEVICE)
163 >> AC_DEFCFG_DEVICE_SHIFT];
164}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100165EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400166
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100167/*
168 * Compose a 32bit command word to be sent to the HD-audio controller
169 */
170static inline unsigned int
171make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
172 unsigned int verb, unsigned int parm)
173{
174 u32 val;
175
Takashi Iwai82e1b802009-07-17 12:47:34 +0200176 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
177 (verb & ~0xfff) || (parm & ~0xffff)) {
Wu Fengguang6430aee2009-07-17 16:49:19 +0800178 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
179 codec->addr, direct, nid, verb, parm);
180 return ~0;
181 }
182
183 val = (u32)codec->addr << 28;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100184 val |= (u32)direct << 27;
185 val |= (u32)nid << 20;
186 val |= verb << 8;
187 val |= parm;
188 return val;
189}
190
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200191/*
192 * Send and receive a verb
193 */
194static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
195 unsigned int *res)
196{
197 struct hda_bus *bus = codec->bus;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200198 int err;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200199
Wu Fengguang6430aee2009-07-17 16:49:19 +0800200 if (cmd == ~0)
201 return -1;
202
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200203 if (res)
204 *res = -1;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200205 again:
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200206 snd_hda_power_up(codec);
207 mutex_lock(&bus->cmd_mutex);
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200208 err = bus->ops.command(bus, cmd);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200209 if (!err && res)
Wu Fengguangdeadff12009-08-01 18:45:16 +0800210 *res = bus->ops.get_response(bus, codec->addr);
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200211 mutex_unlock(&bus->cmd_mutex);
212 snd_hda_power_down(codec);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200213 if (res && *res == -1 && bus->rirb_error) {
214 if (bus->response_reset) {
215 snd_printd("hda_codec: resetting BUS due to "
216 "fatal communication error\n");
217 bus->ops.bus_reset(bus);
218 }
219 goto again;
220 }
221 /* clear reset-flag when the communication gets recovered */
222 if (!err)
223 bus->response_reset = 0;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200224 return err;
225}
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227/**
228 * snd_hda_codec_read - send a command and get the response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
234 *
235 * Send a single command and read the corresponding response.
236 *
237 * Returns the obtained response value, or -1 for an error.
238 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200239unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
240 int direct,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 unsigned int verb, unsigned int parm)
242{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200243 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
244 unsigned int res;
245 codec_exec_verb(codec, cmd, &res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return res;
247}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100248EXPORT_SYMBOL_HDA(snd_hda_codec_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250/**
251 * snd_hda_codec_write - send a single command without waiting for response
252 * @codec: the HDA codec
253 * @nid: NID to send the command
254 * @direct: direct flag
255 * @verb: the verb to send
256 * @parm: the parameter for the verb
257 *
258 * Send a single command without waiting for response.
259 *
260 * Returns 0 if successful, or a negative error code.
261 */
262int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
263 unsigned int verb, unsigned int parm)
264{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200265 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100266 unsigned int res;
Takashi Iwaib20f3b82009-06-02 01:20:22 +0200267 return codec_exec_verb(codec, cmd,
268 codec->bus->sync_write ? &res : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100270EXPORT_SYMBOL_HDA(snd_hda_codec_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272/**
273 * snd_hda_sequence_write - sequence writes
274 * @codec: the HDA codec
275 * @seq: VERB array to send
276 *
277 * Send the commands sequentially from the given array.
278 * The array must be terminated with NID=0.
279 */
280void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
281{
282 for (; seq->nid; seq++)
283 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
284}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100285EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287/**
288 * snd_hda_get_sub_nodes - get the range of sub nodes
289 * @codec: the HDA codec
290 * @nid: NID to parse
291 * @start_id: the pointer to store the start NID
292 *
293 * Parse the NID and store the start NID of its sub-nodes.
294 * Returns the number of sub-nodes.
295 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200296int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
297 hda_nid_t *start_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{
299 unsigned int parm;
300
301 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
Danny Tholene8a7f132007-09-11 21:41:56 +0200302 if (parm == -1)
303 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 *start_id = (parm >> 16) & 0x7fff;
305 return (int)(parm & 0x7fff);
306}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100307EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
309/**
310 * snd_hda_get_connections - get connection list
311 * @codec: the HDA codec
312 * @nid: NID to parse
313 * @conn_list: connection list array
314 * @max_conns: max. number of connections to store
315 *
316 * Parses the connection list of the given widget and stores the list
317 * of NIDs.
318 *
319 * Returns the number of connections, or a negative error code.
320 */
321int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
322 hda_nid_t *conn_list, int max_conns)
323{
324 unsigned int parm;
Takashi Iwai54d17402005-11-21 16:33:22 +0100325 int i, conn_len, conns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 unsigned int shift, num_elems, mask;
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200327 unsigned int wcaps;
Takashi Iwai54d17402005-11-21 16:33:22 +0100328 hda_nid_t prev_nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Takashi Iwaida3cec32008-08-08 17:12:14 +0200330 if (snd_BUG_ON(!conn_list || max_conns <= 0))
331 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200333 wcaps = get_wcaps(codec, nid);
334 if (!(wcaps & AC_WCAP_CONN_LIST) &&
335 get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
Jaroslav Kysela16a433d2009-07-22 16:20:40 +0200336 snd_printk(KERN_WARNING "hda_codec: "
337 "connection list not available for 0x%x\n", nid);
338 return -EINVAL;
339 }
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
342 if (parm & AC_CLIST_LONG) {
343 /* long form */
344 shift = 16;
345 num_elems = 2;
346 } else {
347 /* short form */
348 shift = 8;
349 num_elems = 4;
350 }
351 conn_len = parm & AC_CLIST_LENGTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 mask = (1 << (shift-1)) - 1;
353
Takashi Iwai0ba21762007-04-16 11:29:14 +0200354 if (!conn_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return 0; /* no connection */
356
357 if (conn_len == 1) {
358 /* single connection */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200359 parm = snd_hda_codec_read(codec, nid, 0,
360 AC_VERB_GET_CONNECT_LIST, 0);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200361 if (parm == -1 && codec->bus->rirb_error)
362 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 conn_list[0] = parm & mask;
364 return 1;
365 }
366
367 /* multi connection */
368 conns = 0;
Takashi Iwai54d17402005-11-21 16:33:22 +0100369 prev_nid = 0;
370 for (i = 0; i < conn_len; i++) {
371 int range_val;
372 hda_nid_t val, n;
373
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200374 if (i % num_elems == 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +0100375 parm = snd_hda_codec_read(codec, nid, 0,
376 AC_VERB_GET_CONNECT_LIST, i);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200377 if (parm == -1 && codec->bus->rirb_error)
378 return -EIO;
379 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200380 range_val = !!(parm & (1 << (shift-1))); /* ranges */
Takashi Iwai54d17402005-11-21 16:33:22 +0100381 val = parm & mask;
Jaroslav Kysela2e9bf242009-07-18 11:48:19 +0200382 if (val == 0) {
383 snd_printk(KERN_WARNING "hda_codec: "
384 "invalid CONNECT_LIST verb %x[%i]:%x\n",
385 nid, i, parm);
386 return 0;
387 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100388 parm >>= shift;
389 if (range_val) {
390 /* ranges between the previous and this one */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200391 if (!prev_nid || prev_nid >= val) {
392 snd_printk(KERN_WARNING "hda_codec: "
393 "invalid dep_range_val %x:%x\n",
394 prev_nid, val);
Takashi Iwai54d17402005-11-21 16:33:22 +0100395 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100397 for (n = prev_nid + 1; n <= val; n++) {
398 if (conns >= max_conns) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200399 snd_printk(KERN_ERR
400 "Too many connections\n");
Takashi Iwai54d17402005-11-21 16:33:22 +0100401 return -EINVAL;
402 }
403 conn_list[conns++] = n;
404 }
405 } else {
406 if (conns >= max_conns) {
407 snd_printk(KERN_ERR "Too many connections\n");
408 return -EINVAL;
409 }
410 conn_list[conns++] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100412 prev_nid = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 }
414 return conns;
415}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100416EXPORT_SYMBOL_HDA(snd_hda_get_connections);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418
419/**
420 * snd_hda_queue_unsol_event - add an unsolicited event to queue
421 * @bus: the BUS
422 * @res: unsolicited event (lower 32bit of RIRB entry)
423 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
424 *
425 * Adds the given event to the queue. The events are processed in
426 * the workqueue asynchronously. Call this function in the interrupt
427 * hanlder when RIRB receives an unsolicited event.
428 *
429 * Returns 0 if successful, or a negative error code.
430 */
431int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
432{
433 struct hda_bus_unsolicited *unsol;
434 unsigned int wp;
435
Takashi Iwai0ba21762007-04-16 11:29:14 +0200436 unsol = bus->unsol;
437 if (!unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return 0;
439
440 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
441 unsol->wp = wp;
442
443 wp <<= 1;
444 unsol->queue[wp] = res;
445 unsol->queue[wp + 1] = res_ex;
446
Takashi Iwai6acaed32009-01-12 10:09:24 +0100447 queue_work(bus->workq, &unsol->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
449 return 0;
450}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100451EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453/*
Wu Fengguang5c1d1a92008-10-07 14:17:53 +0800454 * process queued unsolicited events
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 */
David Howellsc4028952006-11-22 14:57:56 +0000456static void process_unsol_events(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
David Howellsc4028952006-11-22 14:57:56 +0000458 struct hda_bus_unsolicited *unsol =
459 container_of(work, struct hda_bus_unsolicited, work);
460 struct hda_bus *bus = unsol->bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 struct hda_codec *codec;
462 unsigned int rp, caddr, res;
463
464 while (unsol->rp != unsol->wp) {
465 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
466 unsol->rp = rp;
467 rp <<= 1;
468 res = unsol->queue[rp];
469 caddr = unsol->queue[rp + 1];
Takashi Iwai0ba21762007-04-16 11:29:14 +0200470 if (!(caddr & (1 << 4))) /* no unsolicited event? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 continue;
472 codec = bus->caddr_tbl[caddr & 0x0f];
473 if (codec && codec->patch_ops.unsol_event)
474 codec->patch_ops.unsol_event(codec, res);
475 }
476}
477
478/*
479 * initialize unsolicited queue
480 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200481static int init_unsol_queue(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
483 struct hda_bus_unsolicited *unsol;
484
Takashi Iwai9f146bb2005-11-17 11:07:49 +0100485 if (bus->unsol) /* already initialized */
486 return 0;
487
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200488 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200489 if (!unsol) {
490 snd_printk(KERN_ERR "hda_codec: "
491 "can't allocate unsolicited queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return -ENOMEM;
493 }
David Howellsc4028952006-11-22 14:57:56 +0000494 INIT_WORK(&unsol->work, process_unsol_events);
495 unsol->bus = bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 bus->unsol = unsol;
497 return 0;
498}
499
500/*
501 * destructor
502 */
503static void snd_hda_codec_free(struct hda_codec *codec);
504
505static int snd_hda_bus_free(struct hda_bus *bus)
506{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200507 struct hda_codec *codec, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Takashi Iwai0ba21762007-04-16 11:29:14 +0200509 if (!bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return 0;
Takashi Iwai6acaed32009-01-12 10:09:24 +0100511 if (bus->workq)
512 flush_workqueue(bus->workq);
513 if (bus->unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 kfree(bus->unsol);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200515 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 snd_hda_codec_free(codec);
517 }
518 if (bus->ops.private_free)
519 bus->ops.private_free(bus);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100520 if (bus->workq)
521 destroy_workqueue(bus->workq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 kfree(bus);
523 return 0;
524}
525
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100526static int snd_hda_bus_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 struct hda_bus *bus = device->device_data;
Takashi Iwaib94d35392008-11-21 09:08:06 +0100529 bus->shutdown = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return snd_hda_bus_free(bus);
531}
532
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200533#ifdef CONFIG_SND_HDA_HWDEP
534static int snd_hda_bus_dev_register(struct snd_device *device)
535{
536 struct hda_bus *bus = device->device_data;
537 struct hda_codec *codec;
538 list_for_each_entry(codec, &bus->codec_list, list) {
539 snd_hda_hwdep_add_sysfs(codec);
Takashi Iwaia2f63092009-11-11 09:34:25 +0100540 snd_hda_hwdep_add_power_sysfs(codec);
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200541 }
542 return 0;
543}
544#else
545#define snd_hda_bus_dev_register NULL
546#endif
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548/**
549 * snd_hda_bus_new - create a HDA bus
550 * @card: the card entry
551 * @temp: the template for hda_bus information
552 * @busp: the pointer to store the created bus instance
553 *
554 * Returns 0 if successful, or a negative error code.
555 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100556int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
Takashi Iwai756e2b02007-04-16 11:27:07 +0200557 const struct hda_bus_template *temp,
558 struct hda_bus **busp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 struct hda_bus *bus;
561 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100562 static struct snd_device_ops dev_ops = {
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200563 .dev_register = snd_hda_bus_dev_register,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 .dev_free = snd_hda_bus_dev_free,
565 };
566
Takashi Iwaida3cec32008-08-08 17:12:14 +0200567 if (snd_BUG_ON(!temp))
568 return -EINVAL;
569 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
570 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 if (busp)
573 *busp = NULL;
574
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200575 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 if (bus == NULL) {
577 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
578 return -ENOMEM;
579 }
580
581 bus->card = card;
582 bus->private_data = temp->private_data;
583 bus->pci = temp->pci;
584 bus->modelname = temp->modelname;
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100585 bus->power_save = temp->power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 bus->ops = temp->ops;
587
Ingo Molnar62932df2006-01-16 16:34:20 +0100588 mutex_init(&bus->cmd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 INIT_LIST_HEAD(&bus->codec_list);
590
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100591 snprintf(bus->workq_name, sizeof(bus->workq_name),
592 "hd-audio%d", card->number);
593 bus->workq = create_singlethread_workqueue(bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100594 if (!bus->workq) {
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100595 snd_printk(KERN_ERR "cannot create workqueue %s\n",
596 bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100597 kfree(bus);
598 return -ENOMEM;
599 }
600
Takashi Iwai0ba21762007-04-16 11:29:14 +0200601 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
602 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 snd_hda_bus_free(bus);
604 return err;
605 }
606 if (busp)
607 *busp = bus;
608 return 0;
609}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100610EXPORT_SYMBOL_HDA(snd_hda_bus_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Takashi Iwai82467612007-07-27 19:15:54 +0200612#ifdef CONFIG_SND_HDA_GENERIC
613#define is_generic_config(codec) \
Takashi Iwaif44ac832008-07-30 15:01:45 +0200614 (codec->modelname && !strcmp(codec->modelname, "generic"))
Takashi Iwai82467612007-07-27 19:15:54 +0200615#else
616#define is_generic_config(codec) 0
617#endif
618
Takashi Iwai645f10c2008-11-28 15:07:37 +0100619#ifdef MODULE
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100620#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
621#else
Takashi Iwai645f10c2008-11-28 15:07:37 +0100622#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100623#endif
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625/*
626 * find a matching codec preset
627 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200628static const struct hda_codec_preset *
Takashi Iwai756e2b02007-04-16 11:27:07 +0200629find_codec_preset(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100631 struct hda_codec_preset_list *tbl;
632 const struct hda_codec_preset *preset;
633 int mod_requested = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Takashi Iwai82467612007-07-27 19:15:54 +0200635 if (is_generic_config(codec))
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100636 return NULL; /* use the generic parser */
637
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100638 again:
639 mutex_lock(&preset_mutex);
640 list_for_each_entry(tbl, &hda_preset_tables, list) {
641 if (!try_module_get(tbl->owner)) {
642 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
643 continue;
644 }
645 for (preset = tbl->preset; preset->id; preset++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 u32 mask = preset->mask;
Marc Boucherca7cfae2008-01-22 15:32:25 +0100647 if (preset->afg && preset->afg != codec->afg)
648 continue;
649 if (preset->mfg && preset->mfg != codec->mfg)
650 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200651 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 mask = ~0;
Takashi Iwai9c7f8522006-06-28 15:08:22 +0200653 if (preset->id == (codec->vendor_id & mask) &&
Takashi Iwai0ba21762007-04-16 11:29:14 +0200654 (!preset->rev ||
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100655 preset->rev == codec->revision_id)) {
656 mutex_unlock(&preset_mutex);
657 codec->owner = tbl->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 return preset;
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100659 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 }
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100661 module_put(tbl->owner);
662 }
663 mutex_unlock(&preset_mutex);
664
665 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
666 char name[32];
667 if (!mod_requested)
668 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
669 codec->vendor_id);
670 else
671 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
672 (codec->vendor_id >> 16) & 0xffff);
673 request_module(name);
674 mod_requested++;
675 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 }
677 return NULL;
678}
679
680/*
Takashi Iwaif44ac832008-07-30 15:01:45 +0200681 * get_codec_name - store the codec name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200683static int get_codec_name(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
685 const struct hda_vendor_id *c;
686 const char *vendor = NULL;
687 u16 vendor_id = codec->vendor_id >> 16;
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200688 char tmp[16];
689
690 if (codec->vendor_name)
691 goto get_chip_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 for (c = hda_vendor_ids; c->id; c++) {
694 if (c->id == vendor_id) {
695 vendor = c->name;
696 break;
697 }
698 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200699 if (!vendor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 sprintf(tmp, "Generic %04x", vendor_id);
701 vendor = tmp;
702 }
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200703 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
704 if (!codec->vendor_name)
705 return -ENOMEM;
706
707 get_chip_name:
708 if (codec->chip_name)
709 return 0;
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (codec->preset && codec->preset->name)
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200712 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
713 else {
714 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
715 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
716 }
717 if (!codec->chip_name)
Takashi Iwaif44ac832008-07-30 15:01:45 +0200718 return -ENOMEM;
719 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
722/*
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200723 * look for an AFG and MFG nodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100725static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726{
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200727 int i, total_nodes, function_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 hda_nid_t nid;
729
730 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
731 for (i = 0; i < total_nodes; i++, nid++) {
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200732 function_id = snd_hda_param_read(codec, nid,
Pascal de Bruijn234b4342009-03-23 11:15:59 +0100733 AC_PAR_FUNCTION_TYPE) & 0xff;
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200734 switch (function_id) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200735 case AC_GRP_AUDIO_FUNCTION:
736 codec->afg = nid;
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200737 codec->function_id = function_id;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200738 break;
739 case AC_GRP_MODEM_FUNCTION:
740 codec->mfg = nid;
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200741 codec->function_id = function_id;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200742 break;
743 default:
744 break;
745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747}
748
749/*
Takashi Iwai54d17402005-11-21 16:33:22 +0100750 * read widget caps for each widget and store in cache
751 */
752static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
753{
754 int i;
755 hda_nid_t nid;
756
757 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
758 &codec->start_nid);
759 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200760 if (!codec->wcaps)
Takashi Iwai54d17402005-11-21 16:33:22 +0100761 return -ENOMEM;
762 nid = codec->start_nid;
763 for (i = 0; i < codec->num_nodes; i++, nid++)
764 codec->wcaps[i] = snd_hda_param_read(codec, nid,
765 AC_PAR_AUDIO_WIDGET_CAP);
766 return 0;
767}
768
Takashi Iwai3be14142009-02-20 14:11:16 +0100769/* read all pin default configurations and save codec->init_pins */
770static int read_pin_defaults(struct hda_codec *codec)
771{
772 int i;
773 hda_nid_t nid = codec->start_nid;
774
775 for (i = 0; i < codec->num_nodes; i++, nid++) {
776 struct hda_pincfg *pin;
777 unsigned int wcaps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +0200778 unsigned int wid_type = get_wcaps_type(wcaps);
Takashi Iwai3be14142009-02-20 14:11:16 +0100779 if (wid_type != AC_WID_PIN)
780 continue;
781 pin = snd_array_new(&codec->init_pins);
782 if (!pin)
783 return -ENOMEM;
784 pin->nid = nid;
785 pin->cfg = snd_hda_codec_read(codec, nid, 0,
786 AC_VERB_GET_CONFIG_DEFAULT, 0);
787 }
788 return 0;
789}
790
791/* look up the given pin config list and return the item matching with NID */
792static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
793 struct snd_array *array,
794 hda_nid_t nid)
795{
796 int i;
797 for (i = 0; i < array->used; i++) {
798 struct hda_pincfg *pin = snd_array_elem(array, i);
799 if (pin->nid == nid)
800 return pin;
801 }
802 return NULL;
803}
804
805/* write a config value for the given NID */
806static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
807 unsigned int cfg)
808{
809 int i;
810 for (i = 0; i < 4; i++) {
811 snd_hda_codec_write(codec, nid, 0,
812 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
813 cfg & 0xff);
814 cfg >>= 8;
815 }
816}
817
818/* set the current pin config value for the given NID.
819 * the value is cached, and read via snd_hda_codec_get_pincfg()
820 */
821int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
822 hda_nid_t nid, unsigned int cfg)
823{
824 struct hda_pincfg *pin;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100825 unsigned int oldcfg;
Takashi Iwai3be14142009-02-20 14:11:16 +0100826
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100827 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +0100828 pin = look_up_pincfg(codec, list, nid);
829 if (!pin) {
830 pin = snd_array_new(list);
831 if (!pin)
832 return -ENOMEM;
833 pin->nid = nid;
834 }
835 pin->cfg = cfg;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100836
837 /* change only when needed; e.g. if the pincfg is already present
838 * in user_pins[], don't write it
839 */
840 cfg = snd_hda_codec_get_pincfg(codec, nid);
841 if (oldcfg != cfg)
842 set_pincfg(codec, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +0100843 return 0;
844}
845
Takashi Iwaid5191e52009-11-16 14:58:17 +0100846/**
847 * snd_hda_codec_set_pincfg - Override a pin default configuration
848 * @codec: the HDA codec
849 * @nid: NID to set the pin config
850 * @cfg: the pin default config value
851 *
852 * Override a pin default configuration value in the cache.
853 * This value can be read by snd_hda_codec_get_pincfg() in a higher
854 * priority than the real hardware value.
855 */
Takashi Iwai3be14142009-02-20 14:11:16 +0100856int snd_hda_codec_set_pincfg(struct hda_codec *codec,
857 hda_nid_t nid, unsigned int cfg)
858{
Takashi Iwai346ff702009-02-23 09:42:57 +0100859 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +0100860}
861EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
862
Takashi Iwaid5191e52009-11-16 14:58:17 +0100863/**
864 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
865 * @codec: the HDA codec
866 * @nid: NID to get the pin config
867 *
868 * Get the current pin config value of the given pin NID.
869 * If the pincfg value is cached or overridden via sysfs or driver,
870 * returns the cached value.
871 */
Takashi Iwai3be14142009-02-20 14:11:16 +0100872unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
873{
874 struct hda_pincfg *pin;
875
Takashi Iwai3be14142009-02-20 14:11:16 +0100876#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +0100877 pin = look_up_pincfg(codec, &codec->user_pins, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +0100878 if (pin)
879 return pin->cfg;
880#endif
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100881 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
882 if (pin)
883 return pin->cfg;
Takashi Iwai3be14142009-02-20 14:11:16 +0100884 pin = look_up_pincfg(codec, &codec->init_pins, nid);
885 if (pin)
886 return pin->cfg;
887 return 0;
888}
889EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
890
891/* restore all current pin configs */
892static void restore_pincfgs(struct hda_codec *codec)
893{
894 int i;
895 for (i = 0; i < codec->init_pins.used; i++) {
896 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
897 set_pincfg(codec, pin->nid,
898 snd_hda_codec_get_pincfg(codec, pin->nid));
899 }
900}
Takashi Iwai54d17402005-11-21 16:33:22 +0100901
Takashi Iwai01751f52007-08-10 16:59:39 +0200902static void init_hda_cache(struct hda_cache_rec *cache,
903 unsigned int record_size);
Takashi Iwai1fcaee62007-08-23 00:01:09 +0200904static void free_hda_cache(struct hda_cache_rec *cache);
Takashi Iwai01751f52007-08-10 16:59:39 +0200905
Takashi Iwai3be14142009-02-20 14:11:16 +0100906/* restore the initial pin cfgs and release all pincfg lists */
907static void restore_init_pincfgs(struct hda_codec *codec)
908{
Takashi Iwai346ff702009-02-23 09:42:57 +0100909 /* first free driver_pins and user_pins, then call restore_pincfg
Takashi Iwai3be14142009-02-20 14:11:16 +0100910 * so that only the values in init_pins are restored
911 */
Takashi Iwai346ff702009-02-23 09:42:57 +0100912 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +0100913#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +0100914 snd_array_free(&codec->user_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +0100915#endif
916 restore_pincfgs(codec);
917 snd_array_free(&codec->init_pins);
918}
919
Takashi Iwai54d17402005-11-21 16:33:22 +0100920/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 * codec destructor
922 */
923static void snd_hda_codec_free(struct hda_codec *codec)
924{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200925 if (!codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 return;
Takashi Iwai3be14142009-02-20 14:11:16 +0100927 restore_init_pincfgs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200928#ifdef CONFIG_SND_HDA_POWER_SAVE
929 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100930 flush_workqueue(codec->bus->workq);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200931#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 list_del(&codec->list);
Takashi Iwaid13bd412008-07-30 15:01:45 +0200933 snd_array_free(&codec->mixers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 codec->bus->caddr_tbl[codec->addr] = NULL;
935 if (codec->patch_ops.free)
936 codec->patch_ops.free(codec);
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100937 module_put(codec->owner);
Takashi Iwai01751f52007-08-10 16:59:39 +0200938 free_hda_cache(&codec->amp_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200939 free_hda_cache(&codec->cmd_cache);
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200940 kfree(codec->vendor_name);
941 kfree(codec->chip_name);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200942 kfree(codec->modelname);
Takashi Iwai54d17402005-11-21 16:33:22 +0100943 kfree(codec->wcaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 kfree(codec);
945}
946
Takashi Iwaibb6ac722009-03-13 09:02:42 +0100947static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
948 unsigned int power_state);
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950/**
951 * snd_hda_codec_new - create a HDA codec
952 * @bus: the bus to assign
953 * @codec_addr: the codec address
954 * @codecp: the pointer to store the generated codec
955 *
956 * Returns 0 if successful, or a negative error code.
957 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100958int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
Takashi Iwaia1e21c92009-06-17 09:33:52 +0200959 struct hda_codec **codecp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
961 struct hda_codec *codec;
Jaroslav Kyselaba443682008-08-13 20:55:32 +0200962 char component[31];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 int err;
964
Takashi Iwaida3cec32008-08-08 17:12:14 +0200965 if (snd_BUG_ON(!bus))
966 return -EINVAL;
967 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
968 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
970 if (bus->caddr_tbl[codec_addr]) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200971 snd_printk(KERN_ERR "hda_codec: "
972 "address 0x%x is already occupied\n", codec_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 return -EBUSY;
974 }
975
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200976 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 if (codec == NULL) {
978 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
979 return -ENOMEM;
980 }
981
982 codec->bus = bus;
983 codec->addr = codec_addr;
Ingo Molnar62932df2006-01-16 16:34:20 +0100984 mutex_init(&codec->spdif_mutex);
Wu Fengguang5a9e02e2009-01-09 16:45:24 +0800985 mutex_init(&codec->control_mutex);
Takashi Iwai01751f52007-08-10 16:59:39 +0200986 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200987 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +0100988 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 60);
Takashi Iwai3be14142009-02-20 14:11:16 +0100989 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai346ff702009-02-23 09:42:57 +0100990 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200991 if (codec->bus->modelname) {
992 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
993 if (!codec->modelname) {
994 snd_hda_codec_free(codec);
995 return -ENODEV;
996 }
997 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Takashi Iwaicb53c622007-08-10 17:21:45 +0200999#ifdef CONFIG_SND_HDA_POWER_SAVE
1000 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1001 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1002 * the caller has to power down appropriatley after initialization
1003 * phase.
1004 */
1005 hda_keep_power_on(codec);
1006#endif
1007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 list_add_tail(&codec->list, &bus->codec_list);
1009 bus->caddr_tbl[codec_addr] = codec;
1010
Takashi Iwai0ba21762007-04-16 11:29:14 +02001011 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1012 AC_PAR_VENDOR_ID);
Takashi Iwai111d3af2006-02-16 18:17:58 +01001013 if (codec->vendor_id == -1)
1014 /* read again, hopefully the access method was corrected
1015 * in the last read...
1016 */
1017 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1018 AC_PAR_VENDOR_ID);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001019 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1020 AC_PAR_SUBSYSTEM_ID);
1021 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1022 AC_PAR_REV_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001024 setup_fg_nodes(codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001025 if (!codec->afg && !codec->mfg) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001026 snd_printdd("hda_codec: no AFG or MFG node found\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001027 err = -ENODEV;
1028 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030
Takashi Iwai3be14142009-02-20 14:11:16 +01001031 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1032 if (err < 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +01001033 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001034 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001035 }
Takashi Iwai3be14142009-02-20 14:11:16 +01001036 err = read_pin_defaults(codec);
1037 if (err < 0)
1038 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001039
Takashi Iwai0ba21762007-04-16 11:29:14 +02001040 if (!codec->subsystem_id) {
Takashi Iwai86284e42005-10-11 15:05:54 +02001041 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001042 codec->subsystem_id =
1043 snd_hda_codec_read(codec, nid, 0,
1044 AC_VERB_GET_SUBSYSTEM_ID, 0);
Takashi Iwai86284e42005-10-11 15:05:54 +02001045 }
1046
Takashi Iwaibb6ac722009-03-13 09:02:42 +01001047 /* power-up all before initialization */
1048 hda_set_power_state(codec,
1049 codec->afg ? codec->afg : codec->mfg,
1050 AC_PWRST_D0);
1051
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001052 snd_hda_codec_proc_new(codec);
1053
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001054 snd_hda_create_hwdep(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001055
1056 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1057 codec->subsystem_id, codec->revision_id);
1058 snd_component_add(codec->bus->card, component);
1059
1060 if (codecp)
1061 *codecp = codec;
1062 return 0;
Takashi Iwai3be14142009-02-20 14:11:16 +01001063
1064 error:
1065 snd_hda_codec_free(codec);
1066 return err;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001067}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001068EXPORT_SYMBOL_HDA(snd_hda_codec_new);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001069
Takashi Iwaid5191e52009-11-16 14:58:17 +01001070/**
1071 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1072 * @codec: the HDA codec
1073 *
1074 * Start parsing of the given codec tree and (re-)initialize the whole
1075 * patch instance.
1076 *
1077 * Returns 0 if successful or a negative error code.
1078 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001079int snd_hda_codec_configure(struct hda_codec *codec)
1080{
1081 int err;
1082
Takashi Iwaid5ad6302007-03-07 15:55:59 +01001083 codec->preset = find_codec_preset(codec);
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001084 if (!codec->vendor_name || !codec->chip_name) {
Takashi Iwaif44ac832008-07-30 15:01:45 +02001085 err = get_codec_name(codec);
1086 if (err < 0)
1087 return err;
1088 }
Takashi Iwai43ea1d42007-04-26 19:12:08 +02001089 /* audio codec should override the mixer name */
Takashi Iwaif44ac832008-07-30 15:01:45 +02001090 if (codec->afg || !*codec->bus->card->mixername)
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001091 snprintf(codec->bus->card->mixername,
1092 sizeof(codec->bus->card->mixername),
1093 "%s %s", codec->vendor_name, codec->chip_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Takashi Iwai82467612007-07-27 19:15:54 +02001095 if (is_generic_config(codec)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai82467612007-07-27 19:15:54 +02001097 goto patched;
1098 }
Takashi Iwai82467612007-07-27 19:15:54 +02001099 if (codec->preset && codec->preset->patch) {
1100 err = codec->preset->patch(codec);
1101 goto patched;
1102 }
1103
1104 /* call the default parser */
Takashi Iwai82467612007-07-27 19:15:54 +02001105 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai35a1e0c2007-10-19 08:13:40 +02001106 if (err < 0)
1107 printk(KERN_ERR "hda-codec: No codec parser is available\n");
Takashi Iwai82467612007-07-27 19:15:54 +02001108
1109 patched:
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001110 if (!err && codec->patch_ops.unsol_event)
1111 err = init_unsol_queue(codec->bus);
1112 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113}
Takashi Iwaia1e21c92009-06-17 09:33:52 +02001114EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116/**
1117 * snd_hda_codec_setup_stream - set up the codec for streaming
1118 * @codec: the CODEC to set up
1119 * @nid: the NID to set up
1120 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1121 * @channel_id: channel id to pass, zero based.
1122 * @format: stream format.
1123 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001124void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1125 u32 stream_tag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 int channel_id, int format)
1127{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001128 if (!nid)
Takashi Iwaid21b37e2005-04-20 13:45:55 +02001129 return;
1130
Takashi Iwai0ba21762007-04-16 11:29:14 +02001131 snd_printdd("hda_codec_setup_stream: "
1132 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 nid, stream_tag, channel_id, format);
1134 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1135 (stream_tag << 4) | channel_id);
1136 msleep(1);
1137 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1138}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001139EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Takashi Iwaid5191e52009-11-16 14:58:17 +01001141/**
1142 * snd_hda_codec_cleanup_stream - clean up the codec for closing
1143 * @codec: the CODEC to clean up
1144 * @nid: the NID to clean up
1145 */
Takashi Iwai888afa12008-03-18 09:57:50 +01001146void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1147{
1148 if (!nid)
1149 return;
1150
1151 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1152 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1153#if 0 /* keep the format */
1154 msleep(1);
1155 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1156#endif
1157}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001158EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
Takashi Iwai888afa12008-03-18 09:57:50 +01001159
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160/*
1161 * amp access functions
1162 */
1163
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001164/* FIXME: more better hash key? */
1165#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
Takashi Iwai1327a322009-03-23 13:07:47 +01001166#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001167#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1168#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169#define INFO_AMP_CAPS (1<<0)
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001170#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
1172/* initialize the hash table */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001173static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
Takashi Iwai01751f52007-08-10 16:59:39 +02001174 unsigned int record_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175{
Takashi Iwai01751f52007-08-10 16:59:39 +02001176 memset(cache, 0, sizeof(*cache));
1177 memset(cache->hash, 0xff, sizeof(cache->hash));
Takashi Iwai603c4012008-07-30 15:01:44 +02001178 snd_array_init(&cache->buf, record_size, 64);
Takashi Iwai01751f52007-08-10 16:59:39 +02001179}
1180
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001181static void free_hda_cache(struct hda_cache_rec *cache)
Takashi Iwai01751f52007-08-10 16:59:39 +02001182{
Takashi Iwai603c4012008-07-30 15:01:44 +02001183 snd_array_free(&cache->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184}
1185
1186/* query the hash. allocate an entry if not found. */
Takashi Iwai01751f52007-08-10 16:59:39 +02001187static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1188 u32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189{
Takashi Iwai01751f52007-08-10 16:59:39 +02001190 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1191 u16 cur = cache->hash[idx];
1192 struct hda_cache_head *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
1194 while (cur != 0xffff) {
Takashi Iwaif43aa022008-11-10 16:24:26 +01001195 info = snd_array_elem(&cache->buf, cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 if (info->key == key)
1197 return info;
1198 cur = info->next;
1199 }
1200
1201 /* add a new hash entry */
Takashi Iwai603c4012008-07-30 15:01:44 +02001202 info = snd_array_new(&cache->buf);
Takashi Iwaic2174292008-11-07 00:23:30 +01001203 if (!info)
1204 return NULL;
Takashi Iwaif43aa022008-11-10 16:24:26 +01001205 cur = snd_array_index(&cache->buf, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 info->key = key;
Takashi Iwai01751f52007-08-10 16:59:39 +02001207 info->val = 0;
1208 info->next = cache->hash[idx];
1209 cache->hash[idx] = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
1211 return info;
1212}
1213
Takashi Iwai01751f52007-08-10 16:59:39 +02001214/* query and allocate an amp hash entry */
1215static inline struct hda_amp_info *
1216get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1217{
1218 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1219}
1220
Takashi Iwaid5191e52009-11-16 14:58:17 +01001221/**
1222 * query_amp_caps - query AMP capabilities
1223 * @codec: the HD-auio codec
1224 * @nid: the NID to query
1225 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1226 *
1227 * Query AMP capabilities for the given widget and direction.
1228 * Returns the obtained capability bits.
1229 *
1230 * When cap bits have been already read, this doesn't read again but
1231 * returns the cached value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 */
Matthew Ranostay09a99952008-01-24 11:49:21 +01001233u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001235 struct hda_amp_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
Takashi Iwai0ba21762007-04-16 11:29:14 +02001237 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1238 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 return 0;
Takashi Iwai01751f52007-08-10 16:59:39 +02001240 if (!(info->head.val & INFO_AMP_CAPS)) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001241 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 nid = codec->afg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001243 info->amp_caps = snd_hda_param_read(codec, nid,
1244 direction == HDA_OUTPUT ?
1245 AC_PAR_AMP_OUT_CAP :
1246 AC_PAR_AMP_IN_CAP);
Takashi Iwaib75e53f2007-05-10 16:56:09 +02001247 if (info->amp_caps)
Takashi Iwai01751f52007-08-10 16:59:39 +02001248 info->head.val |= INFO_AMP_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 }
1250 return info->amp_caps;
1251}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001252EXPORT_SYMBOL_HDA(query_amp_caps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Takashi Iwaid5191e52009-11-16 14:58:17 +01001254/**
1255 * snd_hda_override_amp_caps - Override the AMP capabilities
1256 * @codec: the CODEC to clean up
1257 * @nid: the NID to clean up
1258 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1259 * @caps: the capability bits to set
1260 *
1261 * Override the cached AMP caps bits value by the given one.
1262 * This function is useful if the driver needs to adjust the AMP ranges,
1263 * e.g. limit to 0dB, etc.
1264 *
1265 * Returns zero if successful or a negative error code.
1266 */
Takashi Iwai897cc182007-05-29 19:01:37 +02001267int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1268 unsigned int caps)
1269{
1270 struct hda_amp_info *info;
1271
1272 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1273 if (!info)
1274 return -EINVAL;
1275 info->amp_caps = caps;
Takashi Iwai01751f52007-08-10 16:59:39 +02001276 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai897cc182007-05-29 19:01:37 +02001277 return 0;
1278}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001279EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
Takashi Iwai897cc182007-05-29 19:01:37 +02001280
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001281static unsigned int
1282query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1283 unsigned int (*func)(struct hda_codec *, hda_nid_t))
Takashi Iwai1327a322009-03-23 13:07:47 +01001284{
1285 struct hda_amp_info *info;
1286
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001287 info = get_alloc_amp_hash(codec, key);
Takashi Iwai1327a322009-03-23 13:07:47 +01001288 if (!info)
1289 return 0;
1290 if (!info->head.val) {
Takashi Iwai1327a322009-03-23 13:07:47 +01001291 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001292 info->amp_caps = func(codec, nid);
Takashi Iwai1327a322009-03-23 13:07:47 +01001293 }
1294 return info->amp_caps;
1295}
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001296
1297static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1298{
1299 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1300}
1301
Takashi Iwaid5191e52009-11-16 14:58:17 +01001302/**
1303 * snd_hda_query_pin_caps - Query PIN capabilities
1304 * @codec: the HD-auio codec
1305 * @nid: the NID to query
1306 *
1307 * Query PIN capabilities for the given widget.
1308 * Returns the obtained capability bits.
1309 *
1310 * When cap bits have been already read, this doesn't read again but
1311 * returns the cached value.
1312 */
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001313u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1314{
1315 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1316 read_pin_cap);
1317}
Takashi Iwai1327a322009-03-23 13:07:47 +01001318EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320/*
1321 * read the current volume to info
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001322 * if the cache exists, read the cache value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001324static unsigned int get_vol_mute(struct hda_codec *codec,
1325 struct hda_amp_info *info, hda_nid_t nid,
1326 int ch, int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327{
1328 u32 val, parm;
1329
Takashi Iwai01751f52007-08-10 16:59:39 +02001330 if (info->head.val & INFO_AMP_VOL(ch))
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001331 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1334 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1335 parm |= index;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001336 val = snd_hda_codec_read(codec, nid, 0,
1337 AC_VERB_GET_AMP_GAIN_MUTE, parm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 info->vol[ch] = val & 0xff;
Takashi Iwai01751f52007-08-10 16:59:39 +02001339 info->head.val |= INFO_AMP_VOL(ch);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001340 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341}
1342
1343/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001344 * write the current volume in info to the h/w and update the cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 */
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001346static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
Takashi Iwai0ba21762007-04-16 11:29:14 +02001347 hda_nid_t nid, int ch, int direction, int index,
1348 int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
1350 u32 parm;
1351
1352 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1353 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1354 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1355 parm |= val;
1356 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001357 info->vol[ch] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359
Takashi Iwaid5191e52009-11-16 14:58:17 +01001360/**
1361 * snd_hda_codec_amp_read - Read AMP value
1362 * @codec: HD-audio codec
1363 * @nid: NID to read the AMP value
1364 * @ch: channel (left=0 or right=1)
1365 * @direction: #HDA_INPUT or #HDA_OUTPUT
1366 * @index: the index value (only for input direction)
1367 *
1368 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 */
Takashi Iwai834be882006-03-01 14:16:17 +01001370int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1371 int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001373 struct hda_amp_info *info;
1374 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1375 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001377 return get_vol_mute(codec, info, nid, ch, direction, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001379EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Takashi Iwaid5191e52009-11-16 14:58:17 +01001381/**
1382 * snd_hda_codec_amp_update - update the AMP value
1383 * @codec: HD-audio codec
1384 * @nid: NID to read the AMP value
1385 * @ch: channel (left=0 or right=1)
1386 * @direction: #HDA_INPUT or #HDA_OUTPUT
1387 * @idx: the index value (only for input direction)
1388 * @mask: bit mask to set
1389 * @val: the bits value to set
1390 *
1391 * Update the AMP value with a bit mask.
1392 * Returns 0 if the value is unchanged, 1 if changed.
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001393 */
Takashi Iwai834be882006-03-01 14:16:17 +01001394int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1395 int direction, int idx, int mask, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001397 struct hda_amp_info *info;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001398
Takashi Iwai0ba21762007-04-16 11:29:14 +02001399 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1400 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001402 val &= mask;
1403 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001404 if (info->vol[ch] == val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001406 put_vol_mute(codec, info, nid, ch, direction, idx, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 return 1;
1408}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001409EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Takashi Iwaid5191e52009-11-16 14:58:17 +01001411/**
1412 * snd_hda_codec_amp_stereo - update the AMP stereo values
1413 * @codec: HD-audio codec
1414 * @nid: NID to read the AMP value
1415 * @direction: #HDA_INPUT or #HDA_OUTPUT
1416 * @idx: the index value (only for input direction)
1417 * @mask: bit mask to set
1418 * @val: the bits value to set
1419 *
1420 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1421 * stereo widget with the same mask and value.
Takashi Iwai47fd8302007-08-10 17:11:07 +02001422 */
1423int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1424 int direction, int idx, int mask, int val)
1425{
1426 int ch, ret = 0;
1427 for (ch = 0; ch < 2; ch++)
1428 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1429 idx, mask, val);
1430 return ret;
1431}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001432EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
Takashi Iwai47fd8302007-08-10 17:11:07 +02001433
Takashi Iwaicb53c622007-08-10 17:21:45 +02001434#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwaid5191e52009-11-16 14:58:17 +01001435/**
1436 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1437 * @codec: HD-audio codec
1438 *
1439 * Resume the all amp commands from the cache.
1440 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001441void snd_hda_codec_resume_amp(struct hda_codec *codec)
1442{
Takashi Iwai603c4012008-07-30 15:01:44 +02001443 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001444 int i;
1445
Takashi Iwai603c4012008-07-30 15:01:44 +02001446 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001447 u32 key = buffer->head.key;
1448 hda_nid_t nid;
1449 unsigned int idx, dir, ch;
1450 if (!key)
1451 continue;
1452 nid = key & 0xff;
1453 idx = (key >> 16) & 0xff;
1454 dir = (key >> 24) & 0xff;
1455 for (ch = 0; ch < 2; ch++) {
1456 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1457 continue;
1458 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1459 buffer->vol[ch]);
1460 }
1461 }
1462}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001463EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001464#endif /* SND_HDA_NEEDS_RESUME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
Takashi Iwaid5191e52009-11-16 14:58:17 +01001466/**
1467 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1468 *
1469 * The control element is supposed to have the private_value field
1470 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1471 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001472int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1473 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474{
1475 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1476 u16 nid = get_amp_nid(kcontrol);
1477 u8 chs = get_amp_channels(kcontrol);
1478 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001479 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 u32 caps;
1481
1482 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001483 /* num steps */
1484 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1485 if (!caps) {
1486 printk(KERN_WARNING "hda_codec: "
Takashi Iwai9c8f2ab2008-01-11 16:12:23 +01001487 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1488 kcontrol->id.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 return -EINVAL;
1490 }
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001491 if (ofs < caps)
1492 caps -= ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1494 uinfo->count = chs == 3 ? 2 : 1;
1495 uinfo->value.integer.min = 0;
1496 uinfo->value.integer.max = caps;
1497 return 0;
1498}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001499EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001501
1502static inline unsigned int
1503read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1504 int ch, int dir, int idx, unsigned int ofs)
1505{
1506 unsigned int val;
1507 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1508 val &= HDA_AMP_VOLMASK;
1509 if (val >= ofs)
1510 val -= ofs;
1511 else
1512 val = 0;
1513 return val;
1514}
1515
1516static inline int
1517update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1518 int ch, int dir, int idx, unsigned int ofs,
1519 unsigned int val)
1520{
1521 if (val > 0)
1522 val += ofs;
1523 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1524 HDA_AMP_VOLMASK, val);
1525}
1526
Takashi Iwaid5191e52009-11-16 14:58:17 +01001527/**
1528 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1529 *
1530 * The control element is supposed to have the private_value field
1531 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1532 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001533int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1534 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535{
1536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1537 hda_nid_t nid = get_amp_nid(kcontrol);
1538 int chs = get_amp_channels(kcontrol);
1539 int dir = get_amp_direction(kcontrol);
1540 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001541 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 long *valp = ucontrol->value.integer.value;
1543
1544 if (chs & 1)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001545 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001547 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 return 0;
1549}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001550EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Takashi Iwaid5191e52009-11-16 14:58:17 +01001552/**
1553 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1554 *
1555 * The control element is supposed to have the private_value field
1556 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1557 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001558int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1559 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
1561 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1562 hda_nid_t nid = get_amp_nid(kcontrol);
1563 int chs = get_amp_channels(kcontrol);
1564 int dir = get_amp_direction(kcontrol);
1565 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001566 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 long *valp = ucontrol->value.integer.value;
1568 int change = 0;
1569
Takashi Iwaicb53c622007-08-10 17:21:45 +02001570 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001571 if (chs & 1) {
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001572 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001573 valp++;
1574 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001575 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001576 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001577 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 return change;
1579}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001580EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
Takashi Iwaid5191e52009-11-16 14:58:17 +01001582/**
1583 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
1584 *
1585 * The control element is supposed to have the private_value field
1586 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1587 */
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001588int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1589 unsigned int size, unsigned int __user *_tlv)
1590{
1591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1592 hda_nid_t nid = get_amp_nid(kcontrol);
1593 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001594 unsigned int ofs = get_amp_offset(kcontrol);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001595 u32 caps, val1, val2;
1596
1597 if (size < 4 * sizeof(unsigned int))
1598 return -ENOMEM;
1599 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001600 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1601 val2 = (val2 + 1) * 25;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001602 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001603 val1 += ofs;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001604 val1 = ((int)val1) * ((int)val2);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001605 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1606 return -EFAULT;
1607 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1608 return -EFAULT;
1609 if (put_user(val1, _tlv + 2))
1610 return -EFAULT;
1611 if (put_user(val2, _tlv + 3))
1612 return -EFAULT;
1613 return 0;
1614}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001615EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001616
Takashi Iwaid5191e52009-11-16 14:58:17 +01001617/**
1618 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
1619 * @codec: HD-audio codec
1620 * @nid: NID of a reference widget
1621 * @dir: #HDA_INPUT or #HDA_OUTPUT
1622 * @tlv: TLV data to be stored, at least 4 elements
1623 *
1624 * Set (static) TLV data for a virtual master volume using the AMP caps
1625 * obtained from the reference NID.
1626 * The volume range is recalculated as if the max volume is 0dB.
Takashi Iwai2134ea42008-01-10 16:53:55 +01001627 */
1628void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1629 unsigned int *tlv)
1630{
1631 u32 caps;
1632 int nums, step;
1633
1634 caps = query_amp_caps(codec, nid, dir);
1635 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1636 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1637 step = (step + 1) * 25;
1638 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1639 tlv[1] = 2 * sizeof(unsigned int);
1640 tlv[2] = -nums * step;
1641 tlv[3] = step;
1642}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001643EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001644
1645/* find a mixer control element with the given name */
Takashi Iwai09f99702008-02-04 12:31:13 +01001646static struct snd_kcontrol *
1647_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1648 const char *name, int idx)
Takashi Iwai2134ea42008-01-10 16:53:55 +01001649{
1650 struct snd_ctl_elem_id id;
1651 memset(&id, 0, sizeof(id));
1652 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
Takashi Iwai09f99702008-02-04 12:31:13 +01001653 id.index = idx;
Takashi Iwai18cb7102009-04-16 10:22:24 +02001654 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1655 return NULL;
Takashi Iwai2134ea42008-01-10 16:53:55 +01001656 strcpy(id.name, name);
1657 return snd_ctl_find_id(codec->bus->card, &id);
1658}
1659
Takashi Iwaid5191e52009-11-16 14:58:17 +01001660/**
1661 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
1662 * @codec: HD-audio codec
1663 * @name: ctl id name string
1664 *
1665 * Get the control element with the given id string and IFACE_MIXER.
1666 */
Takashi Iwai09f99702008-02-04 12:31:13 +01001667struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1668 const char *name)
1669{
1670 return _snd_hda_find_mixer_ctl(codec, name, 0);
1671}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001672EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
Takashi Iwai09f99702008-02-04 12:31:13 +01001673
Takashi Iwaid5191e52009-11-16 14:58:17 +01001674/**
1675 * snd_hda_ctl-add - Add a control element and assign to the codec
1676 * @codec: HD-audio codec
1677 * @nid: corresponding NID (optional)
1678 * @kctl: the control element to assign
1679 *
1680 * Add the given control element to an array inside the codec instance.
1681 * All control elements belonging to a codec are supposed to be added
1682 * by this function so that a proper clean-up works at the free or
1683 * reconfiguration time.
1684 *
1685 * If non-zero @nid is passed, the NID is assigned to the control element.
1686 * The assignment is shown in the codec proc file.
1687 *
1688 * snd_hda_ctl_add() checks the control subdev id field whether
1689 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
1690 * bits value is taken as the NID to assign.
1691 */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001692int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
1693 struct snd_kcontrol *kctl)
Takashi Iwaid13bd412008-07-30 15:01:45 +02001694{
1695 int err;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001696 struct hda_nid_item *item;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001697
Takashi Iwai9c96fa52009-11-16 11:25:33 +01001698 if (kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) {
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01001699 if (nid == 0)
1700 nid = kctl->id.subdevice & 0xffff;
1701 kctl->id.subdevice = 0;
1702 }
Takashi Iwaid13bd412008-07-30 15:01:45 +02001703 err = snd_ctl_add(codec->bus->card, kctl);
1704 if (err < 0)
1705 return err;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001706 item = snd_array_new(&codec->mixers);
1707 if (!item)
Takashi Iwaid13bd412008-07-30 15:01:45 +02001708 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001709 item->kctl = kctl;
1710 item->nid = nid;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001711 return 0;
1712}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001713EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001714
Takashi Iwaid5191e52009-11-16 14:58:17 +01001715/**
1716 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
1717 * @codec: HD-audio codec
1718 */
Takashi Iwaid13bd412008-07-30 15:01:45 +02001719void snd_hda_ctls_clear(struct hda_codec *codec)
1720{
1721 int i;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001722 struct hda_nid_item *items = codec->mixers.list;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001723 for (i = 0; i < codec->mixers.used; i++)
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001724 snd_ctl_remove(codec->bus->card, items[i].kctl);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001725 snd_array_free(&codec->mixers);
1726}
1727
Takashi Iwaia65d6292009-02-23 16:57:04 +01001728/* pseudo device locking
1729 * toggle card->shutdown to allow/disallow the device access (as a hack)
1730 */
1731static int hda_lock_devices(struct snd_card *card)
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001732{
Takashi Iwaia65d6292009-02-23 16:57:04 +01001733 spin_lock(&card->files_lock);
1734 if (card->shutdown) {
1735 spin_unlock(&card->files_lock);
1736 return -EINVAL;
1737 }
1738 card->shutdown = 1;
1739 spin_unlock(&card->files_lock);
1740 return 0;
1741}
1742
1743static void hda_unlock_devices(struct snd_card *card)
1744{
1745 spin_lock(&card->files_lock);
1746 card->shutdown = 0;
1747 spin_unlock(&card->files_lock);
1748}
1749
Takashi Iwaid5191e52009-11-16 14:58:17 +01001750/**
1751 * snd_hda_codec_reset - Clear all objects assigned to the codec
1752 * @codec: HD-audio codec
1753 *
1754 * This frees the all PCM and control elements assigned to the codec, and
1755 * clears the caches and restores the pin default configurations.
1756 *
1757 * When a device is being used, it returns -EBSY. If successfully freed,
1758 * returns zero.
1759 */
Takashi Iwaia65d6292009-02-23 16:57:04 +01001760int snd_hda_codec_reset(struct hda_codec *codec)
1761{
1762 struct snd_card *card = codec->bus->card;
1763 int i, pcm;
1764
1765 if (hda_lock_devices(card) < 0)
1766 return -EBUSY;
1767 /* check whether the codec isn't used by any mixer or PCM streams */
1768 if (!list_empty(&card->ctl_files)) {
1769 hda_unlock_devices(card);
1770 return -EBUSY;
1771 }
1772 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1773 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1774 if (!cpcm->pcm)
1775 continue;
1776 if (cpcm->pcm->streams[0].substream_opened ||
1777 cpcm->pcm->streams[1].substream_opened) {
1778 hda_unlock_devices(card);
1779 return -EBUSY;
1780 }
1781 }
1782
1783 /* OK, let it free */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001784
1785#ifdef CONFIG_SND_HDA_POWER_SAVE
1786 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01001787 flush_workqueue(codec->bus->workq);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001788#endif
1789 snd_hda_ctls_clear(codec);
1790 /* relase PCMs */
1791 for (i = 0; i < codec->num_pcms; i++) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001792 if (codec->pcm_info[i].pcm) {
Takashi Iwaia65d6292009-02-23 16:57:04 +01001793 snd_device_free(card, codec->pcm_info[i].pcm);
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001794 clear_bit(codec->pcm_info[i].device,
1795 codec->bus->pcm_dev_bits);
1796 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001797 }
1798 if (codec->patch_ops.free)
1799 codec->patch_ops.free(codec);
Takashi Iwai56d17712008-11-28 14:36:23 +01001800 codec->proc_widget_hook = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001801 codec->spec = NULL;
1802 free_hda_cache(&codec->amp_cache);
1803 free_hda_cache(&codec->cmd_cache);
Takashi Iwai827057f2008-12-19 10:12:02 +01001804 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1805 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwai346ff702009-02-23 09:42:57 +01001806 /* free only driver_pins so that init_pins + user_pins are restored */
1807 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001808 restore_pincfgs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001809 codec->num_pcms = 0;
1810 codec->pcm_info = NULL;
1811 codec->preset = NULL;
Takashi Iwaid1f1af22009-03-02 10:35:29 +01001812 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1813 codec->slave_dig_outs = NULL;
1814 codec->spdif_status_reset = 0;
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001815 module_put(codec->owner);
1816 codec->owner = NULL;
Takashi Iwaia65d6292009-02-23 16:57:04 +01001817
1818 /* allow device access again */
1819 hda_unlock_devices(card);
1820 return 0;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001821}
1822
Takashi Iwaid5191e52009-11-16 14:58:17 +01001823/**
1824 * snd_hda_add_vmaster - create a virtual master control and add slaves
1825 * @codec: HD-audio codec
1826 * @name: vmaster control name
1827 * @tlv: TLV data (optional)
1828 * @slaves: slave control names (optional)
1829 *
1830 * Create a virtual master control with the given name. The TLV data
1831 * must be either NULL or a valid data.
1832 *
1833 * @slaves is a NULL-terminated array of strings, each of which is a
1834 * slave control name. All controls with these names are assigned to
1835 * the new virtual master control.
1836 *
1837 * This function returns zero if successful or a negative error code.
1838 */
Takashi Iwai2134ea42008-01-10 16:53:55 +01001839int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1840 unsigned int *tlv, const char **slaves)
1841{
1842 struct snd_kcontrol *kctl;
1843 const char **s;
1844 int err;
1845
Takashi Iwai2f085542008-02-22 18:43:50 +01001846 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1847 ;
1848 if (!*s) {
1849 snd_printdd("No slave found for %s\n", name);
1850 return 0;
1851 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01001852 kctl = snd_ctl_make_virtual_master(name, tlv);
1853 if (!kctl)
1854 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01001855 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001856 if (err < 0)
1857 return err;
1858
1859 for (s = slaves; *s; s++) {
1860 struct snd_kcontrol *sctl;
Takashi Iwai7a411ee2009-03-06 10:08:14 +01001861 int i = 0;
1862 for (;;) {
1863 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1864 if (!sctl) {
1865 if (!i)
1866 snd_printdd("Cannot find slave %s, "
1867 "skipped\n", *s);
1868 break;
1869 }
1870 err = snd_ctl_add_slave(kctl, sctl);
1871 if (err < 0)
1872 return err;
1873 i++;
Takashi Iwai2134ea42008-01-10 16:53:55 +01001874 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01001875 }
1876 return 0;
1877}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001878EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001879
Takashi Iwaid5191e52009-11-16 14:58:17 +01001880/**
1881 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
1882 *
1883 * The control element is supposed to have the private_value field
1884 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1885 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001886int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1887 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888{
1889 int chs = get_amp_channels(kcontrol);
1890
1891 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1892 uinfo->count = chs == 3 ? 2 : 1;
1893 uinfo->value.integer.min = 0;
1894 uinfo->value.integer.max = 1;
1895 return 0;
1896}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001897EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898
Takashi Iwaid5191e52009-11-16 14:58:17 +01001899/**
1900 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
1901 *
1902 * The control element is supposed to have the private_value field
1903 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1904 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001905int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1906 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
1908 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1909 hda_nid_t nid = get_amp_nid(kcontrol);
1910 int chs = get_amp_channels(kcontrol);
1911 int dir = get_amp_direction(kcontrol);
1912 int idx = get_amp_index(kcontrol);
1913 long *valp = ucontrol->value.integer.value;
1914
1915 if (chs & 1)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001916 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001917 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 if (chs & 2)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001919 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001920 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 return 0;
1922}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001923EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924
Takashi Iwaid5191e52009-11-16 14:58:17 +01001925/**
1926 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
1927 *
1928 * The control element is supposed to have the private_value field
1929 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1930 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001931int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1932 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933{
1934 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1935 hda_nid_t nid = get_amp_nid(kcontrol);
1936 int chs = get_amp_channels(kcontrol);
1937 int dir = get_amp_direction(kcontrol);
1938 int idx = get_amp_index(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 long *valp = ucontrol->value.integer.value;
1940 int change = 0;
1941
Takashi Iwaicb53c622007-08-10 17:21:45 +02001942 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001943 if (chs & 1) {
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001944 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001945 HDA_AMP_MUTE,
1946 *valp ? 0 : HDA_AMP_MUTE);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001947 valp++;
1948 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001949 if (chs & 2)
1950 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001951 HDA_AMP_MUTE,
1952 *valp ? 0 : HDA_AMP_MUTE);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001953#ifdef CONFIG_SND_HDA_POWER_SAVE
1954 if (codec->patch_ops.check_power_status)
1955 codec->patch_ops.check_power_status(codec, nid);
1956#endif
1957 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 return change;
1959}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001960EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Takashi Iwaid5191e52009-11-16 14:58:17 +01001962/**
1963 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
1964 *
1965 * This function calls snd_hda_enable_beep_device(), which behaves differently
1966 * depending on beep_mode option.
1967 */
Jaroslav Kysela123c07a2009-10-21 14:48:23 +02001968int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
1969 struct snd_ctl_elem_value *ucontrol)
1970{
1971 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1972 long *valp = ucontrol->value.integer.value;
1973
1974 snd_hda_enable_beep_device(codec, *valp);
1975 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1976}
1977EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
1978
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979/*
Takashi Iwai985be542005-11-02 18:26:49 +01001980 * bound volume controls
1981 *
1982 * bind multiple volumes (# indices, from 0)
1983 */
1984
1985#define AMP_VAL_IDX_SHIFT 19
1986#define AMP_VAL_IDX_MASK (0x0f<<19)
1987
Takashi Iwaid5191e52009-11-16 14:58:17 +01001988/**
1989 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
1990 *
1991 * The control element is supposed to have the private_value field
1992 * set up via HDA_BIND_MUTE*() macros.
1993 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001994int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1995 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01001996{
1997 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1998 unsigned long pval;
1999 int err;
2000
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002001 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002002 pval = kcontrol->private_value;
2003 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2004 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2005 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002006 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002007 return err;
2008}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002009EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
Takashi Iwai985be542005-11-02 18:26:49 +01002010
Takashi Iwaid5191e52009-11-16 14:58:17 +01002011/**
2012 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2013 *
2014 * The control element is supposed to have the private_value field
2015 * set up via HDA_BIND_MUTE*() macros.
2016 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002017int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2018 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01002019{
2020 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2021 unsigned long pval;
2022 int i, indices, err = 0, change = 0;
2023
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002024 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002025 pval = kcontrol->private_value;
2026 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2027 for (i = 0; i < indices; i++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002028 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2029 (i << AMP_VAL_IDX_SHIFT);
Takashi Iwai985be542005-11-02 18:26:49 +01002030 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2031 if (err < 0)
2032 break;
2033 change |= err;
2034 }
2035 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002036 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002037 return err < 0 ? err : change;
2038}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002039EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
Takashi Iwai985be542005-11-02 18:26:49 +01002040
Takashi Iwaid5191e52009-11-16 14:58:17 +01002041/**
2042 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2043 *
2044 * The control element is supposed to have the private_value field
2045 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
Takashi Iwai532d5382007-07-27 19:02:40 +02002046 */
2047int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2048 struct snd_ctl_elem_info *uinfo)
2049{
2050 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2051 struct hda_bind_ctls *c;
2052 int err;
2053
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002054 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002055 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002056 kcontrol->private_value = *c->values;
2057 err = c->ops->info(kcontrol, uinfo);
2058 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002059 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002060 return err;
2061}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002062EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
Takashi Iwai532d5382007-07-27 19:02:40 +02002063
Takashi Iwaid5191e52009-11-16 14:58:17 +01002064/**
2065 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2066 *
2067 * The control element is supposed to have the private_value field
2068 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2069 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002070int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2071 struct snd_ctl_elem_value *ucontrol)
2072{
2073 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2074 struct hda_bind_ctls *c;
2075 int err;
2076
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002077 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002078 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002079 kcontrol->private_value = *c->values;
2080 err = c->ops->get(kcontrol, ucontrol);
2081 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002082 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002083 return err;
2084}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002085EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
Takashi Iwai532d5382007-07-27 19:02:40 +02002086
Takashi Iwaid5191e52009-11-16 14:58:17 +01002087/**
2088 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2089 *
2090 * The control element is supposed to have the private_value field
2091 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2092 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002093int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2094 struct snd_ctl_elem_value *ucontrol)
2095{
2096 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2097 struct hda_bind_ctls *c;
2098 unsigned long *vals;
2099 int err = 0, change = 0;
2100
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002101 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002102 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002103 for (vals = c->values; *vals; vals++) {
2104 kcontrol->private_value = *vals;
2105 err = c->ops->put(kcontrol, ucontrol);
2106 if (err < 0)
2107 break;
2108 change |= err;
2109 }
2110 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002111 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002112 return err < 0 ? err : change;
2113}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002114EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
Takashi Iwai532d5382007-07-27 19:02:40 +02002115
Takashi Iwaid5191e52009-11-16 14:58:17 +01002116/**
2117 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2118 *
2119 * The control element is supposed to have the private_value field
2120 * set up via HDA_BIND_VOL() macro.
2121 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002122int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2123 unsigned int size, unsigned int __user *tlv)
2124{
2125 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2126 struct hda_bind_ctls *c;
2127 int err;
2128
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002129 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002130 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002131 kcontrol->private_value = *c->values;
2132 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2133 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002134 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002135 return err;
2136}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002137EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
Takashi Iwai532d5382007-07-27 19:02:40 +02002138
2139struct hda_ctl_ops snd_hda_bind_vol = {
2140 .info = snd_hda_mixer_amp_volume_info,
2141 .get = snd_hda_mixer_amp_volume_get,
2142 .put = snd_hda_mixer_amp_volume_put,
2143 .tlv = snd_hda_mixer_amp_tlv
2144};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002145EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
Takashi Iwai532d5382007-07-27 19:02:40 +02002146
2147struct hda_ctl_ops snd_hda_bind_sw = {
2148 .info = snd_hda_mixer_amp_switch_info,
2149 .get = snd_hda_mixer_amp_switch_get,
2150 .put = snd_hda_mixer_amp_switch_put,
2151 .tlv = snd_hda_mixer_amp_tlv
2152};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002153EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
Takashi Iwai532d5382007-07-27 19:02:40 +02002154
2155/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 * SPDIF out controls
2157 */
2158
Takashi Iwai0ba21762007-04-16 11:29:14 +02002159static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2160 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161{
2162 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2163 uinfo->count = 1;
2164 return 0;
2165}
2166
Takashi Iwai0ba21762007-04-16 11:29:14 +02002167static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2168 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169{
2170 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2171 IEC958_AES0_NONAUDIO |
2172 IEC958_AES0_CON_EMPHASIS_5015 |
2173 IEC958_AES0_CON_NOT_COPYRIGHT;
2174 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2175 IEC958_AES1_CON_ORIGINAL;
2176 return 0;
2177}
2178
Takashi Iwai0ba21762007-04-16 11:29:14 +02002179static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2180 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181{
2182 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2183 IEC958_AES0_NONAUDIO |
2184 IEC958_AES0_PRO_EMPHASIS_5015;
2185 return 0;
2186}
2187
Takashi Iwai0ba21762007-04-16 11:29:14 +02002188static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2189 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190{
2191 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2192
2193 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
2194 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
2195 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
2196 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
2197
2198 return 0;
2199}
2200
2201/* convert from SPDIF status bits to HDA SPDIF bits
2202 * bit 0 (DigEn) is always set zero (to be filled later)
2203 */
2204static unsigned short convert_from_spdif_status(unsigned int sbits)
2205{
2206 unsigned short val = 0;
2207
2208 if (sbits & IEC958_AES0_PROFESSIONAL)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002209 val |= AC_DIG1_PROFESSIONAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 if (sbits & IEC958_AES0_NONAUDIO)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002211 val |= AC_DIG1_NONAUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002213 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2214 IEC958_AES0_PRO_EMPHASIS_5015)
2215 val |= AC_DIG1_EMPHASIS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002217 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2218 IEC958_AES0_CON_EMPHASIS_5015)
2219 val |= AC_DIG1_EMPHASIS;
2220 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2221 val |= AC_DIG1_COPYRIGHT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
Takashi Iwai0ba21762007-04-16 11:29:14 +02002223 val |= AC_DIG1_LEVEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2225 }
2226 return val;
2227}
2228
2229/* convert to SPDIF status bits from HDA SPDIF bits
2230 */
2231static unsigned int convert_to_spdif_status(unsigned short val)
2232{
2233 unsigned int sbits = 0;
2234
Takashi Iwai0ba21762007-04-16 11:29:14 +02002235 if (val & AC_DIG1_NONAUDIO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 sbits |= IEC958_AES0_NONAUDIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002237 if (val & AC_DIG1_PROFESSIONAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 sbits |= IEC958_AES0_PROFESSIONAL;
2239 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002240 if (sbits & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2242 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002243 if (val & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002245 if (!(val & AC_DIG1_COPYRIGHT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002247 if (val & AC_DIG1_LEVEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2249 sbits |= val & (0x7f << 8);
2250 }
2251 return sbits;
2252}
2253
Takashi Iwai2f728532008-09-25 16:32:41 +02002254/* set digital convert verbs both for the given NID and its slaves */
2255static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2256 int verb, int val)
2257{
2258 hda_nid_t *d;
2259
Takashi Iwai9e976972008-11-25 08:17:20 +01002260 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002261 d = codec->slave_dig_outs;
2262 if (!d)
2263 return;
2264 for (; *d; d++)
Takashi Iwai9e976972008-11-25 08:17:20 +01002265 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002266}
2267
2268static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2269 int dig1, int dig2)
2270{
2271 if (dig1 != -1)
2272 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2273 if (dig2 != -1)
2274 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2275}
2276
Takashi Iwai0ba21762007-04-16 11:29:14 +02002277static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2278 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279{
2280 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2281 hda_nid_t nid = kcontrol->private_value;
2282 unsigned short val;
2283 int change;
2284
Ingo Molnar62932df2006-01-16 16:34:20 +01002285 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 codec->spdif_status = ucontrol->value.iec958.status[0] |
2287 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2288 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2289 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2290 val = convert_from_spdif_status(codec->spdif_status);
2291 val |= codec->spdif_ctls & 1;
2292 change = codec->spdif_ctls != val;
2293 codec->spdif_ctls = val;
2294
Takashi Iwai2f728532008-09-25 16:32:41 +02002295 if (change)
2296 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
Ingo Molnar62932df2006-01-16 16:34:20 +01002298 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 return change;
2300}
2301
Takashi Iwaia5ce8892007-07-23 15:42:26 +02002302#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
Takashi Iwai0ba21762007-04-16 11:29:14 +02002304static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2305 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306{
2307 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2308
Takashi Iwai0ba21762007-04-16 11:29:14 +02002309 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 return 0;
2311}
2312
Takashi Iwai0ba21762007-04-16 11:29:14 +02002313static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2314 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
2316 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2317 hda_nid_t nid = kcontrol->private_value;
2318 unsigned short val;
2319 int change;
2320
Ingo Molnar62932df2006-01-16 16:34:20 +01002321 mutex_lock(&codec->spdif_mutex);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002322 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 if (ucontrol->value.integer.value[0])
Takashi Iwai0ba21762007-04-16 11:29:14 +02002324 val |= AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 change = codec->spdif_ctls != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002326 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 codec->spdif_ctls = val;
Takashi Iwai2f728532008-09-25 16:32:41 +02002328 set_dig_out_convert(codec, nid, val & 0xff, -1);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002329 /* unmute amp switch (if any) */
2330 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
Takashi Iwai47fd8302007-08-10 17:11:07 +02002331 (val & AC_DIG1_ENABLE))
2332 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2333 HDA_AMP_MUTE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 }
Ingo Molnar62932df2006-01-16 16:34:20 +01002335 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 return change;
2337}
2338
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002339static struct snd_kcontrol_new dig_mixes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 {
2341 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2342 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2343 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2344 .info = snd_hda_spdif_mask_info,
2345 .get = snd_hda_spdif_cmask_get,
2346 },
2347 {
2348 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2349 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2350 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2351 .info = snd_hda_spdif_mask_info,
2352 .get = snd_hda_spdif_pmask_get,
2353 },
2354 {
2355 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2356 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2357 .info = snd_hda_spdif_mask_info,
2358 .get = snd_hda_spdif_default_get,
2359 .put = snd_hda_spdif_default_put,
2360 },
2361 {
2362 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2363 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2364 .info = snd_hda_spdif_out_switch_info,
2365 .get = snd_hda_spdif_out_switch_get,
2366 .put = snd_hda_spdif_out_switch_put,
2367 },
2368 { } /* end */
2369};
2370
Takashi Iwai09f99702008-02-04 12:31:13 +01002371#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2372
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373/**
2374 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2375 * @codec: the HDA codec
2376 * @nid: audio out widget NID
2377 *
2378 * Creates controls related with the SPDIF output.
2379 * Called from each patch supporting the SPDIF out.
2380 *
2381 * Returns 0 if successful, or a negative error code.
2382 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002383int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384{
2385 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002386 struct snd_kcontrol *kctl;
2387 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01002388 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389
Takashi Iwai09f99702008-02-04 12:31:13 +01002390 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2391 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2392 idx))
2393 break;
2394 }
2395 if (idx >= SPDIF_MAX_IDX) {
2396 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2397 return -EBUSY;
2398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2400 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaib91f0802008-11-04 08:43:08 +01002401 if (!kctl)
2402 return -ENOMEM;
Takashi Iwai09f99702008-02-04 12:31:13 +01002403 kctl->id.index = idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 kctl->private_value = nid;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002405 err = snd_hda_ctl_add(codec, nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002406 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 return err;
2408 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002409 codec->spdif_ctls =
Andrew Paprocki3982d172007-12-19 12:13:44 +01002410 snd_hda_codec_read(codec, nid, 0,
2411 AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2413 return 0;
2414}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002415EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416
2417/*
Takashi Iwai9a081602008-02-12 18:37:26 +01002418 * SPDIF sharing with analog output
2419 */
2420static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2421 struct snd_ctl_elem_value *ucontrol)
2422{
2423 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2424 ucontrol->value.integer.value[0] = mout->share_spdif;
2425 return 0;
2426}
2427
2428static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2429 struct snd_ctl_elem_value *ucontrol)
2430{
2431 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2432 mout->share_spdif = !!ucontrol->value.integer.value[0];
2433 return 0;
2434}
2435
2436static struct snd_kcontrol_new spdif_share_sw = {
2437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2438 .name = "IEC958 Default PCM Playback Switch",
2439 .info = snd_ctl_boolean_mono_info,
2440 .get = spdif_share_sw_get,
2441 .put = spdif_share_sw_put,
2442};
2443
Takashi Iwaid5191e52009-11-16 14:58:17 +01002444/**
2445 * snd_hda_create_spdif_share_sw - create Default PCM switch
2446 * @codec: the HDA codec
2447 * @mout: multi-out instance
2448 */
Takashi Iwai9a081602008-02-12 18:37:26 +01002449int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2450 struct hda_multi_out *mout)
2451{
2452 if (!mout->dig_out_nid)
2453 return 0;
2454 /* ATTENTION: here mout is passed as private_data, instead of codec */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002455 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2456 snd_ctl_new1(&spdif_share_sw, mout));
Takashi Iwai9a081602008-02-12 18:37:26 +01002457}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002458EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
Takashi Iwai9a081602008-02-12 18:37:26 +01002459
2460/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 * SPDIF input
2462 */
2463
2464#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2465
Takashi Iwai0ba21762007-04-16 11:29:14 +02002466static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468{
2469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2470
2471 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2472 return 0;
2473}
2474
Takashi Iwai0ba21762007-04-16 11:29:14 +02002475static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2476 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477{
2478 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2479 hda_nid_t nid = kcontrol->private_value;
2480 unsigned int val = !!ucontrol->value.integer.value[0];
2481 int change;
2482
Ingo Molnar62932df2006-01-16 16:34:20 +01002483 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 change = codec->spdif_in_enable != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002485 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 codec->spdif_in_enable = val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002487 snd_hda_codec_write_cache(codec, nid, 0,
2488 AC_VERB_SET_DIGI_CONVERT_1, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 }
Ingo Molnar62932df2006-01-16 16:34:20 +01002490 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 return change;
2492}
2493
Takashi Iwai0ba21762007-04-16 11:29:14 +02002494static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2495 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496{
2497 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2498 hda_nid_t nid = kcontrol->private_value;
2499 unsigned short val;
2500 unsigned int sbits;
2501
Andrew Paprocki3982d172007-12-19 12:13:44 +01002502 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 sbits = convert_to_spdif_status(val);
2504 ucontrol->value.iec958.status[0] = sbits;
2505 ucontrol->value.iec958.status[1] = sbits >> 8;
2506 ucontrol->value.iec958.status[2] = sbits >> 16;
2507 ucontrol->value.iec958.status[3] = sbits >> 24;
2508 return 0;
2509}
2510
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002511static struct snd_kcontrol_new dig_in_ctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 {
2513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2514 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2515 .info = snd_hda_spdif_in_switch_info,
2516 .get = snd_hda_spdif_in_switch_get,
2517 .put = snd_hda_spdif_in_switch_put,
2518 },
2519 {
2520 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2521 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2522 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2523 .info = snd_hda_spdif_mask_info,
2524 .get = snd_hda_spdif_in_status_get,
2525 },
2526 { } /* end */
2527};
2528
2529/**
2530 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2531 * @codec: the HDA codec
2532 * @nid: audio in widget NID
2533 *
2534 * Creates controls related with the SPDIF input.
2535 * Called from each patch supporting the SPDIF in.
2536 *
2537 * Returns 0 if successful, or a negative error code.
2538 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002539int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540{
2541 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002542 struct snd_kcontrol *kctl;
2543 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01002544 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545
Takashi Iwai09f99702008-02-04 12:31:13 +01002546 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2547 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2548 idx))
2549 break;
2550 }
2551 if (idx >= SPDIF_MAX_IDX) {
2552 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2553 return -EBUSY;
2554 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2556 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaic8dcdf82009-02-06 16:21:20 +01002557 if (!kctl)
2558 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 kctl->private_value = nid;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002560 err = snd_hda_ctl_add(codec, nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002561 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 return err;
2563 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002564 codec->spdif_in_enable =
Andrew Paprocki3982d172007-12-19 12:13:44 +01002565 snd_hda_codec_read(codec, nid, 0,
2566 AC_VERB_GET_DIGI_CONVERT_1, 0) &
Takashi Iwai0ba21762007-04-16 11:29:14 +02002567 AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 return 0;
2569}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002570EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571
Takashi Iwaicb53c622007-08-10 17:21:45 +02002572#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002573/*
2574 * command cache
2575 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002577/* build a 32bit cache key with the widget id and the command parameter */
2578#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2579#define get_cmd_cache_nid(key) ((key) & 0xff)
2580#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2581
2582/**
2583 * snd_hda_codec_write_cache - send a single command with caching
2584 * @codec: the HDA codec
2585 * @nid: NID to send the command
2586 * @direct: direct flag
2587 * @verb: the verb to send
2588 * @parm: the parameter for the verb
2589 *
2590 * Send a single command without waiting for response.
2591 *
2592 * Returns 0 if successful, or a negative error code.
2593 */
2594int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2595 int direct, unsigned int verb, unsigned int parm)
2596{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02002597 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2598 struct hda_cache_head *c;
2599 u32 key;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002600
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02002601 if (err < 0)
2602 return err;
2603 /* parm may contain the verb stuff for get/set amp */
2604 verb = verb | (parm >> 8);
2605 parm &= 0xff;
2606 key = build_cmd_cache_key(nid, verb);
2607 mutex_lock(&codec->bus->cmd_mutex);
2608 c = get_alloc_hash(&codec->cmd_cache, key);
2609 if (c)
2610 c->val = parm;
2611 mutex_unlock(&codec->bus->cmd_mutex);
2612 return 0;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002613}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002614EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002615
Takashi Iwaid5191e52009-11-16 14:58:17 +01002616/**
2617 * snd_hda_codec_resume_cache - Resume the all commands from the cache
2618 * @codec: HD-audio codec
2619 *
2620 * Execute all verbs recorded in the command caches to resume.
2621 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002622void snd_hda_codec_resume_cache(struct hda_codec *codec)
2623{
Takashi Iwai603c4012008-07-30 15:01:44 +02002624 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002625 int i;
2626
Takashi Iwai603c4012008-07-30 15:01:44 +02002627 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002628 u32 key = buffer->key;
2629 if (!key)
2630 continue;
2631 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2632 get_cmd_cache_cmd(key), buffer->val);
2633 }
2634}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002635EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002636
2637/**
2638 * snd_hda_sequence_write_cache - sequence writes with caching
2639 * @codec: the HDA codec
2640 * @seq: VERB array to send
2641 *
2642 * Send the commands sequentially from the given array.
2643 * Thte commands are recorded on cache for power-save and resume.
2644 * The array must be terminated with NID=0.
2645 */
2646void snd_hda_sequence_write_cache(struct hda_codec *codec,
2647 const struct hda_verb *seq)
2648{
2649 for (; seq->nid; seq++)
2650 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2651 seq->param);
2652}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002653EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002654#endif /* SND_HDA_NEEDS_RESUME */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002655
Takashi Iwai54d17402005-11-21 16:33:22 +01002656/*
2657 * set power state of the codec
2658 */
2659static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2660 unsigned int power_state)
2661{
Takashi Iwaicb53c622007-08-10 17:21:45 +02002662 hda_nid_t nid;
2663 int i;
Takashi Iwai54d17402005-11-21 16:33:22 +01002664
Takashi Iwai05ff7e12009-07-22 12:39:24 +02002665 /* this delay seems necessary to avoid click noise at power-down */
2666 if (power_state == AC_PWRST_D3)
2667 msleep(100);
2668 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
Takashi Iwai54d17402005-11-21 16:33:22 +01002669 power_state);
Takashi Iwai05ff7e12009-07-22 12:39:24 +02002670 /* partial workaround for "azx_get_response timeout" */
2671 if (power_state == AC_PWRST_D0)
2672 msleep(10);
Takashi Iwai54d17402005-11-21 16:33:22 +01002673
Takashi Iwaicb53c622007-08-10 17:21:45 +02002674 nid = codec->start_nid;
2675 for (i = 0; i < codec->num_nodes; i++, nid++) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002676 unsigned int wcaps = get_wcaps(codec, nid);
2677 if (wcaps & AC_WCAP_POWER) {
Takashi Iwaia22d5432009-07-27 12:54:26 +02002678 unsigned int wid_type = get_wcaps_type(wcaps);
Takashi Iwaia3b48c82009-04-21 13:37:29 +02002679 if (power_state == AC_PWRST_D3 &&
2680 wid_type == AC_WID_PIN) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002681 unsigned int pincap;
2682 /*
2683 * don't power down the widget if it controls
2684 * eapd and EAPD_BTLENABLE is set.
2685 */
Takashi Iwai14bafe32009-03-23 16:35:39 +01002686 pincap = snd_hda_query_pin_caps(codec, nid);
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002687 if (pincap & AC_PINCAP_EAPD) {
2688 int eapd = snd_hda_codec_read(codec,
2689 nid, 0,
2690 AC_VERB_GET_EAPD_BTLENABLE, 0);
2691 eapd &= 0x02;
Takashi Iwaia3b48c82009-04-21 13:37:29 +02002692 if (eapd)
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002693 continue;
2694 }
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002695 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002696 snd_hda_codec_write(codec, nid, 0,
2697 AC_VERB_SET_POWER_STATE,
2698 power_state);
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002699 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002700 }
2701
Takashi Iwaicb53c622007-08-10 17:21:45 +02002702 if (power_state == AC_PWRST_D0) {
2703 unsigned long end_time;
2704 int state;
Takashi Iwai54d17402005-11-21 16:33:22 +01002705 msleep(10);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002706 /* wait until the codec reachs to D0 */
2707 end_time = jiffies + msecs_to_jiffies(500);
2708 do {
2709 state = snd_hda_codec_read(codec, fg, 0,
2710 AC_VERB_GET_POWER_STATE, 0);
2711 if (state == power_state)
2712 break;
2713 msleep(1);
2714 } while (time_after_eq(end_time, jiffies));
2715 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002716}
2717
Takashi Iwai11aeff02008-07-30 15:01:46 +02002718#ifdef CONFIG_SND_HDA_HWDEP
2719/* execute additional init verbs */
2720static void hda_exec_init_verbs(struct hda_codec *codec)
2721{
2722 if (codec->init_verbs.list)
2723 snd_hda_sequence_write(codec, codec->init_verbs.list);
2724}
2725#else
2726static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2727#endif
2728
Takashi Iwaicb53c622007-08-10 17:21:45 +02002729#ifdef SND_HDA_NEEDS_RESUME
2730/*
2731 * call suspend and power-down; used both from PM and power-save
2732 */
2733static void hda_call_codec_suspend(struct hda_codec *codec)
2734{
2735 if (codec->patch_ops.suspend)
2736 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2737 hda_set_power_state(codec,
2738 codec->afg ? codec->afg : codec->mfg,
2739 AC_PWRST_D3);
2740#ifdef CONFIG_SND_HDA_POWER_SAVE
Takashi Iwaia2f63092009-11-11 09:34:25 +01002741 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002742 cancel_delayed_work(&codec->power_work);
Takashi Iwai95e99fd2007-08-13 15:29:04 +02002743 codec->power_on = 0;
Takashi Iwaia221e282007-08-16 16:35:33 +02002744 codec->power_transition = 0;
Takashi Iwaia2f63092009-11-11 09:34:25 +01002745 codec->power_jiffies = jiffies;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002746#endif
2747}
2748
2749/*
2750 * kick up codec; used both from PM and power-save
2751 */
2752static void hda_call_codec_resume(struct hda_codec *codec)
2753{
2754 hda_set_power_state(codec,
2755 codec->afg ? codec->afg : codec->mfg,
2756 AC_PWRST_D0);
Takashi Iwai3be14142009-02-20 14:11:16 +01002757 restore_pincfgs(codec); /* restore all current pin configs */
Takashi Iwai11aeff02008-07-30 15:01:46 +02002758 hda_exec_init_verbs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002759 if (codec->patch_ops.resume)
2760 codec->patch_ops.resume(codec);
2761 else {
Takashi Iwai9d99f312007-08-14 15:15:52 +02002762 if (codec->patch_ops.init)
2763 codec->patch_ops.init(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002764 snd_hda_codec_resume_amp(codec);
2765 snd_hda_codec_resume_cache(codec);
2766 }
2767}
2768#endif /* SND_HDA_NEEDS_RESUME */
2769
Takashi Iwai54d17402005-11-21 16:33:22 +01002770
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771/**
2772 * snd_hda_build_controls - build mixer controls
2773 * @bus: the BUS
2774 *
2775 * Creates mixer controls for each codec included in the bus.
2776 *
2777 * Returns 0 if successful, otherwise a negative error code.
2778 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002779int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002781 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782
Takashi Iwai0ba21762007-04-16 11:29:14 +02002783 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002784 int err = snd_hda_codec_build_controls(codec);
Takashi Iwaif93d4612009-03-02 10:44:15 +01002785 if (err < 0) {
2786 printk(KERN_ERR "hda_codec: cannot build controls"
2787 "for #%d (error %d)\n", codec->addr, err);
2788 err = snd_hda_codec_reset(codec);
2789 if (err < 0) {
2790 printk(KERN_ERR
2791 "hda_codec: cannot revert codec\n");
2792 return err;
2793 }
2794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002796 return 0;
2797}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002798EXPORT_SYMBOL_HDA(snd_hda_build_controls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002800int snd_hda_codec_build_controls(struct hda_codec *codec)
2801{
2802 int err = 0;
Takashi Iwai11aeff02008-07-30 15:01:46 +02002803 hda_exec_init_verbs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002804 /* continue to initialize... */
2805 if (codec->patch_ops.init)
2806 err = codec->patch_ops.init(codec);
2807 if (!err && codec->patch_ops.build_controls)
2808 err = codec->patch_ops.build_controls(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002809 if (err < 0)
2810 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 return 0;
2812}
2813
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814/*
2815 * stream formats
2816 */
Takashi Iwaibefdf312005-08-22 13:57:55 +02002817struct hda_rate_tbl {
2818 unsigned int hz;
2819 unsigned int alsa_bits;
2820 unsigned int hda_fmt;
2821};
2822
2823static struct hda_rate_tbl rate_bits[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 /* rate in Hz, ALSA rate bitmask, HDA format value */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002825
2826 /* autodetected value used in snd_hda_query_supported_pcm */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2828 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2829 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2830 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2831 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2832 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2833 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2834 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2835 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2836 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2837 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002838#define AC_PAR_PCM_RATE_BITS 11
2839 /* up to bits 10, 384kHZ isn't supported properly */
2840
2841 /* not autodetected value */
2842 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002843
Takashi Iwaibefdf312005-08-22 13:57:55 +02002844 { 0 } /* terminator */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845};
2846
2847/**
2848 * snd_hda_calc_stream_format - calculate format bitset
2849 * @rate: the sample rate
2850 * @channels: the number of channels
2851 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2852 * @maxbps: the max. bps
2853 *
2854 * Calculate the format bitset from the given rate, channels and th PCM format.
2855 *
2856 * Return zero if invalid.
2857 */
2858unsigned int snd_hda_calc_stream_format(unsigned int rate,
2859 unsigned int channels,
2860 unsigned int format,
2861 unsigned int maxbps)
2862{
2863 int i;
2864 unsigned int val = 0;
2865
Takashi Iwaibefdf312005-08-22 13:57:55 +02002866 for (i = 0; rate_bits[i].hz; i++)
2867 if (rate_bits[i].hz == rate) {
2868 val = rate_bits[i].hda_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 break;
2870 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002871 if (!rate_bits[i].hz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 snd_printdd("invalid rate %d\n", rate);
2873 return 0;
2874 }
2875
2876 if (channels == 0 || channels > 8) {
2877 snd_printdd("invalid channels %d\n", channels);
2878 return 0;
2879 }
2880 val |= channels - 1;
2881
2882 switch (snd_pcm_format_width(format)) {
2883 case 8: val |= 0x00; break;
2884 case 16: val |= 0x10; break;
2885 case 20:
2886 case 24:
2887 case 32:
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02002888 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 val |= 0x40;
2890 else if (maxbps >= 24)
2891 val |= 0x30;
2892 else
2893 val |= 0x20;
2894 break;
2895 default:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002896 snd_printdd("invalid format width %d\n",
2897 snd_pcm_format_width(format));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 return 0;
2899 }
2900
2901 return val;
2902}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002903EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01002905static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2906{
2907 unsigned int val = 0;
2908 if (nid != codec->afg &&
2909 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2910 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2911 if (!val || val == -1)
2912 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2913 if (!val || val == -1)
2914 return 0;
2915 return val;
2916}
2917
2918static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2919{
2920 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2921 get_pcm_param);
2922}
2923
2924static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2925{
2926 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2927 if (!streams || streams == -1)
2928 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2929 if (!streams || streams == -1)
2930 return 0;
2931 return streams;
2932}
2933
2934static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2935{
2936 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2937 get_stream_param);
2938}
2939
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940/**
2941 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2942 * @codec: the HDA codec
2943 * @nid: NID to query
2944 * @ratesp: the pointer to store the detected rate bitflags
2945 * @formatsp: the pointer to store the detected formats
2946 * @bpsp: the pointer to store the detected format widths
2947 *
2948 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2949 * or @bsps argument is ignored.
2950 *
2951 * Returns 0 if successful, otherwise a negative error code.
2952 */
Takashi Iwai986862bd2008-11-27 12:40:13 +01002953static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2955{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002956 unsigned int i, val, wcaps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002958 wcaps = get_wcaps(codec, nid);
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01002959 val = query_pcm_param(codec, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960
2961 if (ratesp) {
2962 u32 rates = 0;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002963 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 if (val & (1 << i))
Takashi Iwaibefdf312005-08-22 13:57:55 +02002965 rates |= rate_bits[i].alsa_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002967 if (rates == 0) {
2968 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2969 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2970 nid, val,
2971 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2972 return -EIO;
2973 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 *ratesp = rates;
2975 }
2976
2977 if (formatsp || bpsp) {
2978 u64 formats = 0;
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002979 unsigned int streams, bps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01002981 streams = query_stream_param(codec, nid);
2982 if (!streams)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984
2985 bps = 0;
2986 if (streams & AC_SUPFMT_PCM) {
2987 if (val & AC_SUPPCM_BITS_8) {
2988 formats |= SNDRV_PCM_FMTBIT_U8;
2989 bps = 8;
2990 }
2991 if (val & AC_SUPPCM_BITS_16) {
2992 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2993 bps = 16;
2994 }
2995 if (wcaps & AC_WCAP_DIGITAL) {
2996 if (val & AC_SUPPCM_BITS_32)
2997 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2998 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2999 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3000 if (val & AC_SUPPCM_BITS_24)
3001 bps = 24;
3002 else if (val & AC_SUPPCM_BITS_20)
3003 bps = 20;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003004 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3005 AC_SUPPCM_BITS_32)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3007 if (val & AC_SUPPCM_BITS_32)
3008 bps = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 else if (val & AC_SUPPCM_BITS_24)
3010 bps = 24;
Nicolas Graziano33ef76512006-09-19 14:23:14 +02003011 else if (val & AC_SUPPCM_BITS_20)
3012 bps = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 }
3014 }
Takashi Iwaib5025c52009-07-01 18:05:27 +02003015 if (streams & AC_SUPFMT_FLOAT32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02003017 if (!bps)
3018 bps = 32;
Takashi Iwaib5025c52009-07-01 18:05:27 +02003019 }
3020 if (streams == AC_SUPFMT_AC3) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02003021 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 /* temporary hack: we have still no proper support
3023 * for the direct AC3 stream...
3024 */
3025 formats |= SNDRV_PCM_FMTBIT_U8;
3026 bps = 8;
3027 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003028 if (formats == 0) {
3029 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3030 "(nid=0x%x, val=0x%x, ovrd=%i, "
3031 "streams=0x%x)\n",
3032 nid, val,
3033 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3034 streams);
3035 return -EIO;
3036 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 if (formatsp)
3038 *formatsp = formats;
3039 if (bpsp)
3040 *bpsp = bps;
3041 }
3042
3043 return 0;
3044}
3045
3046/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01003047 * snd_hda_is_supported_format - Check the validity of the format
3048 * @codec: HD-audio codec
3049 * @nid: NID to check
3050 * @format: the HD-audio format value to check
3051 *
3052 * Check whether the given node supports the format value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053 *
3054 * Returns 1 if supported, 0 if not.
3055 */
3056int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3057 unsigned int format)
3058{
3059 int i;
3060 unsigned int val = 0, rate, stream;
3061
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003062 val = query_pcm_param(codec, nid);
3063 if (!val)
3064 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065
3066 rate = format & 0xff00;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003067 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
Takashi Iwaibefdf312005-08-22 13:57:55 +02003068 if (rate_bits[i].hda_fmt == rate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003069 if (val & (1 << i))
3070 break;
3071 return 0;
3072 }
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003073 if (i >= AC_PAR_PCM_RATE_BITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 return 0;
3075
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003076 stream = query_stream_param(codec, nid);
3077 if (!stream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 return 0;
3079
3080 if (stream & AC_SUPFMT_PCM) {
3081 switch (format & 0xf0) {
3082 case 0x00:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003083 if (!(val & AC_SUPPCM_BITS_8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 return 0;
3085 break;
3086 case 0x10:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003087 if (!(val & AC_SUPPCM_BITS_16))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088 return 0;
3089 break;
3090 case 0x20:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003091 if (!(val & AC_SUPPCM_BITS_20))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 return 0;
3093 break;
3094 case 0x30:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003095 if (!(val & AC_SUPPCM_BITS_24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 return 0;
3097 break;
3098 case 0x40:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003099 if (!(val & AC_SUPPCM_BITS_32))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 return 0;
3101 break;
3102 default:
3103 return 0;
3104 }
3105 } else {
3106 /* FIXME: check for float32 and AC3? */
3107 }
3108
3109 return 1;
3110}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003111EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112
3113/*
3114 * PCM stuff
3115 */
3116static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3117 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003118 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119{
3120 return 0;
3121}
3122
3123static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3124 struct hda_codec *codec,
3125 unsigned int stream_tag,
3126 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003127 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128{
3129 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3130 return 0;
3131}
3132
3133static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3134 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003135 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003136{
Takashi Iwai888afa12008-03-18 09:57:50 +01003137 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138 return 0;
3139}
3140
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003141static int set_pcm_default_values(struct hda_codec *codec,
3142 struct hda_pcm_stream *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003144 int err;
3145
Takashi Iwai0ba21762007-04-16 11:29:14 +02003146 /* query support PCM information from the given NID */
3147 if (info->nid && (!info->rates || !info->formats)) {
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003148 err = snd_hda_query_supported_pcm(codec, info->nid,
Takashi Iwai0ba21762007-04-16 11:29:14 +02003149 info->rates ? NULL : &info->rates,
3150 info->formats ? NULL : &info->formats,
3151 info->maxbps ? NULL : &info->maxbps);
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003152 if (err < 0)
3153 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 }
3155 if (info->ops.open == NULL)
3156 info->ops.open = hda_pcm_default_open_close;
3157 if (info->ops.close == NULL)
3158 info->ops.close = hda_pcm_default_open_close;
3159 if (info->ops.prepare == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003160 if (snd_BUG_ON(!info->nid))
3161 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162 info->ops.prepare = hda_pcm_default_prepare;
3163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 if (info->ops.cleanup == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003165 if (snd_BUG_ON(!info->nid))
3166 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 info->ops.cleanup = hda_pcm_default_cleanup;
3168 }
3169 return 0;
3170}
3171
Takashi Iwaid5191e52009-11-16 14:58:17 +01003172/* global */
Jaroslav Kyselae3303232009-11-10 14:53:02 +01003173const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3174 "Audio", "SPDIF", "HDMI", "Modem"
3175};
3176
Takashi Iwai176d5332008-07-30 15:01:44 +02003177/*
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003178 * get the empty PCM device number to assign
3179 */
3180static int get_empty_pcm_device(struct hda_bus *bus, int type)
3181{
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003182 /* audio device indices; not linear to keep compatibility */
3183 static int audio_idx[HDA_PCM_NTYPES][5] = {
3184 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3185 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
Wu Fengguang92608ba2009-10-30 11:40:03 +01003186 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003187 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003188 };
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003189 int i;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003190
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003191 if (type >= HDA_PCM_NTYPES) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003192 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3193 return -EINVAL;
3194 }
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003195
3196 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3197 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3198 return audio_idx[type][i];
3199
Jaroslav Kyselae3303232009-11-10 14:53:02 +01003200 snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]);
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003201 return -EAGAIN;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003202}
3203
3204/*
Takashi Iwai176d5332008-07-30 15:01:44 +02003205 * attach a new PCM stream
3206 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003207static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
Takashi Iwai176d5332008-07-30 15:01:44 +02003208{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003209 struct hda_bus *bus = codec->bus;
Takashi Iwai176d5332008-07-30 15:01:44 +02003210 struct hda_pcm_stream *info;
3211 int stream, err;
3212
Takashi Iwaib91f0802008-11-04 08:43:08 +01003213 if (snd_BUG_ON(!pcm->name))
Takashi Iwai176d5332008-07-30 15:01:44 +02003214 return -EINVAL;
3215 for (stream = 0; stream < 2; stream++) {
3216 info = &pcm->stream[stream];
3217 if (info->substreams) {
3218 err = set_pcm_default_values(codec, info);
3219 if (err < 0)
3220 return err;
3221 }
3222 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003223 return bus->ops.attach_pcm(bus, codec, pcm);
Takashi Iwai176d5332008-07-30 15:01:44 +02003224}
3225
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003226/* assign all PCMs of the given codec */
3227int snd_hda_codec_build_pcms(struct hda_codec *codec)
3228{
3229 unsigned int pcm;
3230 int err;
3231
3232 if (!codec->num_pcms) {
3233 if (!codec->patch_ops.build_pcms)
3234 return 0;
3235 err = codec->patch_ops.build_pcms(codec);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003236 if (err < 0) {
3237 printk(KERN_ERR "hda_codec: cannot build PCMs"
3238 "for #%d (error %d)\n", codec->addr, err);
3239 err = snd_hda_codec_reset(codec);
3240 if (err < 0) {
3241 printk(KERN_ERR
3242 "hda_codec: cannot revert codec\n");
3243 return err;
3244 }
3245 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003246 }
3247 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
3248 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
3249 int dev;
3250
3251 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
Takashi Iwai41b5b012009-01-20 18:21:23 +01003252 continue; /* no substreams assigned */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003253
3254 if (!cpcm->pcm) {
3255 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
3256 if (dev < 0)
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003257 continue; /* no fatal error */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003258 cpcm->device = dev;
3259 err = snd_hda_attach_pcm(codec, cpcm);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01003260 if (err < 0) {
3261 printk(KERN_ERR "hda_codec: cannot attach "
3262 "PCM stream %d for codec #%d\n",
3263 dev, codec->addr);
3264 continue; /* no fatal error */
3265 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003266 }
3267 }
3268 return 0;
3269}
3270
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271/**
3272 * snd_hda_build_pcms - build PCM information
3273 * @bus: the BUS
3274 *
3275 * Create PCM information for each codec included in the bus.
3276 *
3277 * The build_pcms codec patch is requested to set up codec->num_pcms and
3278 * codec->pcm_info properly. The array is referred by the top-level driver
3279 * to create its PCM instances.
3280 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3281 * callback.
3282 *
3283 * At least, substreams, channels_min and channels_max must be filled for
3284 * each stream. substreams = 0 indicates that the stream doesn't exist.
3285 * When rates and/or formats are zero, the supported values are queried
3286 * from the given nid. The nid is used also by the default ops.prepare
3287 * and ops.cleanup callbacks.
3288 *
3289 * The driver needs to call ops.open in its open callback. Similarly,
3290 * ops.close is supposed to be called in the close callback.
3291 * ops.prepare should be called in the prepare or hw_params callback
3292 * with the proper parameters for set up.
3293 * ops.cleanup should be called in hw_free for clean up of streams.
3294 *
3295 * This function returns 0 if successfull, or a negative error code.
3296 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003297int __devinit snd_hda_build_pcms(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003299 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300
Takashi Iwai0ba21762007-04-16 11:29:14 +02003301 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003302 int err = snd_hda_codec_build_pcms(codec);
3303 if (err < 0)
3304 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 }
3306 return 0;
3307}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003308EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310/**
3311 * snd_hda_check_board_config - compare the current codec with the config table
3312 * @codec: the HDA codec
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003313 * @num_configs: number of config enums
3314 * @models: array of model name strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 * @tbl: configuration table, terminated by null entries
3316 *
3317 * Compares the modelname or PCI subsystem id of the current codec with the
3318 * given configuration table. If a matching entry is found, returns its
3319 * config value (supposed to be 0 or positive).
3320 *
3321 * If no entries are matching, the function returns a negative value.
3322 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003323int snd_hda_check_board_config(struct hda_codec *codec,
3324 int num_configs, const char **models,
3325 const struct snd_pci_quirk *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326{
Takashi Iwaif44ac832008-07-30 15:01:45 +02003327 if (codec->modelname && models) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003328 int i;
3329 for (i = 0; i < num_configs; i++) {
3330 if (models[i] &&
Takashi Iwaif44ac832008-07-30 15:01:45 +02003331 !strcmp(codec->modelname, models[i])) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003332 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3333 "selected\n", models[i]);
3334 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 }
3336 }
3337 }
3338
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003339 if (!codec->bus->pci || !tbl)
3340 return -1;
3341
3342 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3343 if (!tbl)
3344 return -1;
3345 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwai62cf8722008-05-20 12:15:15 +02003346#ifdef CONFIG_SND_DEBUG_VERBOSE
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003347 char tmp[10];
3348 const char *model = NULL;
3349 if (models)
3350 model = models[tbl->value];
3351 if (!model) {
3352 sprintf(tmp, "#%d", tbl->value);
3353 model = tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 }
Takashi Iwaif5fcc132006-11-24 17:07:44 +01003355 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3356 "for config %x:%x (%s)\n",
3357 model, tbl->subvendor, tbl->subdevice,
3358 (tbl->name ? tbl->name : "Unknown device"));
3359#endif
3360 return tbl->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 }
3362 return -1;
3363}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003364EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365
3366/**
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02003367 * snd_hda_check_board_codec_sid_config - compare the current codec
3368 subsystem ID with the
3369 config table
3370
3371 This is important for Gateway notebooks with SB450 HDA Audio
3372 where the vendor ID of the PCI device is:
3373 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3374 and the vendor/subvendor are found only at the codec.
3375
3376 * @codec: the HDA codec
3377 * @num_configs: number of config enums
3378 * @models: array of model name strings
3379 * @tbl: configuration table, terminated by null entries
3380 *
3381 * Compares the modelname or PCI subsystem id of the current codec with the
3382 * given configuration table. If a matching entry is found, returns its
3383 * config value (supposed to be 0 or positive).
3384 *
3385 * If no entries are matching, the function returns a negative value.
3386 */
3387int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3388 int num_configs, const char **models,
3389 const struct snd_pci_quirk *tbl)
3390{
3391 const struct snd_pci_quirk *q;
3392
3393 /* Search for codec ID */
3394 for (q = tbl; q->subvendor; q++) {
3395 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3396
3397 if (vendorid == codec->subsystem_id)
3398 break;
3399 }
3400
3401 if (!q->subvendor)
3402 return -1;
3403
3404 tbl = q;
3405
3406 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwaid94ff6b2009-09-02 00:20:21 +02003407#ifdef CONFIG_SND_DEBUG_VERBOSE
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02003408 char tmp[10];
3409 const char *model = NULL;
3410 if (models)
3411 model = models[tbl->value];
3412 if (!model) {
3413 sprintf(tmp, "#%d", tbl->value);
3414 model = tmp;
3415 }
3416 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3417 "for config %x:%x (%s)\n",
3418 model, tbl->subvendor, tbl->subdevice,
3419 (tbl->name ? tbl->name : "Unknown device"));
3420#endif
3421 return tbl->value;
3422 }
3423 return -1;
3424}
3425EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3426
3427/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 * snd_hda_add_new_ctls - create controls from the array
3429 * @codec: the HDA codec
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003430 * @knew: the array of struct snd_kcontrol_new
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431 *
3432 * This helper function creates and add new controls in the given array.
3433 * The array must be terminated with an empty entry as terminator.
3434 *
3435 * Returns 0 if successful, or a negative error code.
3436 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003437int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438{
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01003439 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440
3441 for (; knew->name; knew++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01003442 struct snd_kcontrol *kctl;
3443 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003444 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01003445 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01003446 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai54d17402005-11-21 16:33:22 +01003447 if (err < 0) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02003448 if (!codec->addr)
Takashi Iwai54d17402005-11-21 16:33:22 +01003449 return err;
3450 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003451 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01003452 return -ENOMEM;
3453 kctl->id.device = codec->addr;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01003454 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003455 if (err < 0)
Takashi Iwai54d17402005-11-21 16:33:22 +01003456 return err;
3457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003458 }
3459 return 0;
3460}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003461EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462
Takashi Iwaicb53c622007-08-10 17:21:45 +02003463#ifdef CONFIG_SND_HDA_POWER_SAVE
3464static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3465 unsigned int power_state);
3466
3467static void hda_power_work(struct work_struct *work)
3468{
3469 struct hda_codec *codec =
3470 container_of(work, struct hda_codec, power_work.work);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003471 struct hda_bus *bus = codec->bus;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003472
Maxim Levitsky2e492462007-09-03 15:26:57 +02003473 if (!codec->power_on || codec->power_count) {
3474 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003475 return;
Maxim Levitsky2e492462007-09-03 15:26:57 +02003476 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02003477
3478 hda_call_codec_suspend(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003479 if (bus->ops.pm_notify)
3480 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003481}
3482
3483static void hda_keep_power_on(struct hda_codec *codec)
3484{
3485 codec->power_count++;
3486 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01003487 codec->power_jiffies = jiffies;
3488}
3489
Takashi Iwaid5191e52009-11-16 14:58:17 +01003490/* update the power on/off account with the current jiffies */
Takashi Iwaia2f63092009-11-11 09:34:25 +01003491void snd_hda_update_power_acct(struct hda_codec *codec)
3492{
3493 unsigned long delta = jiffies - codec->power_jiffies;
3494 if (codec->power_on)
3495 codec->power_on_acct += delta;
3496 else
3497 codec->power_off_acct += delta;
3498 codec->power_jiffies += delta;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003499}
3500
Takashi Iwaid5191e52009-11-16 14:58:17 +01003501/**
3502 * snd_hda_power_up - Power-up the codec
3503 * @codec: HD-audio codec
3504 *
3505 * Increment the power-up counter and power up the hardware really when
3506 * not turned on yet.
3507 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02003508void snd_hda_power_up(struct hda_codec *codec)
3509{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003510 struct hda_bus *bus = codec->bus;
3511
Takashi Iwaicb53c622007-08-10 17:21:45 +02003512 codec->power_count++;
Takashi Iwaia221e282007-08-16 16:35:33 +02003513 if (codec->power_on || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003514 return;
3515
Takashi Iwaia2f63092009-11-11 09:34:25 +01003516 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003517 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01003518 codec->power_jiffies = jiffies;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003519 if (bus->ops.pm_notify)
3520 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003521 hda_call_codec_resume(codec);
3522 cancel_delayed_work(&codec->power_work);
Takashi Iwaia221e282007-08-16 16:35:33 +02003523 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003524}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003525EXPORT_SYMBOL_HDA(snd_hda_power_up);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003526
3527#define power_save(codec) \
3528 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003529
Takashi Iwaid5191e52009-11-16 14:58:17 +01003530/**
3531 * snd_hda_power_down - Power-down the codec
3532 * @codec: HD-audio codec
3533 *
3534 * Decrement the power-up counter and schedules the power-off work if
3535 * the counter rearches to zero.
3536 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02003537void snd_hda_power_down(struct hda_codec *codec)
3538{
3539 --codec->power_count;
Takashi Iwaia221e282007-08-16 16:35:33 +02003540 if (!codec->power_on || codec->power_count || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003541 return;
Takashi Iwaifee2fba2008-11-27 12:43:28 +01003542 if (power_save(codec)) {
Takashi Iwaia221e282007-08-16 16:35:33 +02003543 codec->power_transition = 1; /* avoid reentrance */
Takashi Iwaic107b412009-01-13 17:46:37 +01003544 queue_delayed_work(codec->bus->workq, &codec->power_work,
Takashi Iwaifee2fba2008-11-27 12:43:28 +01003545 msecs_to_jiffies(power_save(codec) * 1000));
Takashi Iwaia221e282007-08-16 16:35:33 +02003546 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02003547}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003548EXPORT_SYMBOL_HDA(snd_hda_power_down);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003549
Takashi Iwaid5191e52009-11-16 14:58:17 +01003550/**
3551 * snd_hda_check_amp_list_power - Check the amp list and update the power
3552 * @codec: HD-audio codec
3553 * @check: the object containing an AMP list and the status
3554 * @nid: NID to check / update
3555 *
3556 * Check whether the given NID is in the amp list. If it's in the list,
3557 * check the current AMP status, and update the the power-status according
3558 * to the mute status.
3559 *
3560 * This function is supposed to be set or called from the check_power_status
3561 * patch ops.
3562 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02003563int snd_hda_check_amp_list_power(struct hda_codec *codec,
3564 struct hda_loopback_check *check,
3565 hda_nid_t nid)
3566{
3567 struct hda_amp_list *p;
3568 int ch, v;
3569
3570 if (!check->amplist)
3571 return 0;
3572 for (p = check->amplist; p->nid; p++) {
3573 if (p->nid == nid)
3574 break;
3575 }
3576 if (!p->nid)
3577 return 0; /* nothing changed */
3578
3579 for (p = check->amplist; p->nid; p++) {
3580 for (ch = 0; ch < 2; ch++) {
3581 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3582 p->idx);
3583 if (!(v & HDA_AMP_MUTE) && v > 0) {
3584 if (!check->power_on) {
3585 check->power_on = 1;
3586 snd_hda_power_up(codec);
3587 }
3588 return 1;
3589 }
3590 }
3591 }
3592 if (check->power_on) {
3593 check->power_on = 0;
3594 snd_hda_power_down(codec);
3595 }
3596 return 0;
3597}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003598EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003599#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003601/*
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003602 * Channel mode helper
3603 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01003604
3605/**
3606 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
3607 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003608int snd_hda_ch_mode_info(struct hda_codec *codec,
3609 struct snd_ctl_elem_info *uinfo,
3610 const struct hda_channel_mode *chmode,
3611 int num_chmodes)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003612{
3613 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3614 uinfo->count = 1;
3615 uinfo->value.enumerated.items = num_chmodes;
3616 if (uinfo->value.enumerated.item >= num_chmodes)
3617 uinfo->value.enumerated.item = num_chmodes - 1;
3618 sprintf(uinfo->value.enumerated.name, "%dch",
3619 chmode[uinfo->value.enumerated.item].channels);
3620 return 0;
3621}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003622EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003623
Takashi Iwaid5191e52009-11-16 14:58:17 +01003624/**
3625 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
3626 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003627int snd_hda_ch_mode_get(struct hda_codec *codec,
3628 struct snd_ctl_elem_value *ucontrol,
3629 const struct hda_channel_mode *chmode,
3630 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003631 int max_channels)
3632{
3633 int i;
3634
3635 for (i = 0; i < num_chmodes; i++) {
3636 if (max_channels == chmode[i].channels) {
3637 ucontrol->value.enumerated.item[0] = i;
3638 break;
3639 }
3640 }
3641 return 0;
3642}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003643EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003644
Takashi Iwaid5191e52009-11-16 14:58:17 +01003645/**
3646 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
3647 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003648int snd_hda_ch_mode_put(struct hda_codec *codec,
3649 struct snd_ctl_elem_value *ucontrol,
3650 const struct hda_channel_mode *chmode,
3651 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003652 int *max_channelsp)
3653{
3654 unsigned int mode;
3655
3656 mode = ucontrol->value.enumerated.item[0];
Takashi Iwai68ea7b22007-11-15 15:54:38 +01003657 if (mode >= num_chmodes)
3658 return -EINVAL;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003659 if (*max_channelsp == chmode[mode].channels)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003660 return 0;
3661 /* change the current channel setting */
3662 *max_channelsp = chmode[mode].channels;
3663 if (chmode[mode].sequence)
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003664 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003665 return 1;
3666}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003667EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003668
Linus Torvalds1da177e2005-04-16 15:20:36 -07003669/*
3670 * input MUX helper
3671 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01003672
3673/**
3674 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
3675 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003676int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3677 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003678{
3679 unsigned int index;
3680
3681 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3682 uinfo->count = 1;
3683 uinfo->value.enumerated.items = imux->num_items;
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003684 if (!imux->num_items)
3685 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 index = uinfo->value.enumerated.item;
3687 if (index >= imux->num_items)
3688 index = imux->num_items - 1;
3689 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3690 return 0;
3691}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003692EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693
Takashi Iwaid5191e52009-11-16 14:58:17 +01003694/**
3695 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
3696 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003697int snd_hda_input_mux_put(struct hda_codec *codec,
3698 const struct hda_input_mux *imux,
3699 struct snd_ctl_elem_value *ucontrol,
3700 hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701 unsigned int *cur_val)
3702{
3703 unsigned int idx;
3704
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003705 if (!imux->num_items)
3706 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707 idx = ucontrol->value.enumerated.item[0];
3708 if (idx >= imux->num_items)
3709 idx = imux->num_items - 1;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003710 if (*cur_val == idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711 return 0;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003712 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3713 imux->items[idx].index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003714 *cur_val = idx;
3715 return 1;
3716}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003717EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003718
3719
3720/*
3721 * Multi-channel / digital-out PCM helper functions
3722 */
3723
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003724/* setup SPDIF output stream */
3725static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3726 unsigned int stream_tag, unsigned int format)
3727{
3728 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
Takashi Iwai2f728532008-09-25 16:32:41 +02003729 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3730 set_dig_out_convert(codec, nid,
3731 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3732 -1);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003733 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
Takashi Iwai2f728532008-09-25 16:32:41 +02003734 if (codec->slave_dig_outs) {
3735 hda_nid_t *d;
3736 for (d = codec->slave_dig_outs; *d; d++)
3737 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3738 format);
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003739 }
Takashi Iwai2f728532008-09-25 16:32:41 +02003740 /* turn on again (if needed) */
3741 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3742 set_dig_out_convert(codec, nid,
3743 codec->spdif_ctls & 0xff, -1);
3744}
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003745
Takashi Iwai2f728532008-09-25 16:32:41 +02003746static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3747{
3748 snd_hda_codec_cleanup_stream(codec, nid);
3749 if (codec->slave_dig_outs) {
3750 hda_nid_t *d;
3751 for (d = codec->slave_dig_outs; *d; d++)
3752 snd_hda_codec_cleanup_stream(codec, *d);
3753 }
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003754}
3755
Takashi Iwaid5191e52009-11-16 14:58:17 +01003756/**
3757 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
3758 * @bus: HD-audio bus
3759 */
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01003760void snd_hda_bus_reboot_notify(struct hda_bus *bus)
3761{
3762 struct hda_codec *codec;
3763
3764 if (!bus)
3765 return;
3766 list_for_each_entry(codec, &bus->codec_list, list) {
3767#ifdef CONFIG_SND_HDA_POWER_SAVE
3768 if (!codec->power_on)
3769 continue;
3770#endif
3771 if (codec->patch_ops.reboot_notify)
3772 codec->patch_ops.reboot_notify(codec);
3773 }
3774}
Takashi Iwai8f217a22009-11-10 18:26:12 +01003775EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01003776
Takashi Iwaid5191e52009-11-16 14:58:17 +01003777/**
3778 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
Linus Torvalds1da177e2005-04-16 15:20:36 -07003779 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003780int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3781 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003782{
Ingo Molnar62932df2006-01-16 16:34:20 +01003783 mutex_lock(&codec->spdif_mutex);
Takashi Iwai5930ca42007-04-16 11:23:56 +02003784 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3785 /* already opened as analog dup; reset it once */
Takashi Iwai2f728532008-09-25 16:32:41 +02003786 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003787 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
Ingo Molnar62932df2006-01-16 16:34:20 +01003788 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789 return 0;
3790}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003791EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792
Takashi Iwaid5191e52009-11-16 14:58:17 +01003793/**
3794 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
3795 */
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003796int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3797 struct hda_multi_out *mout,
3798 unsigned int stream_tag,
3799 unsigned int format,
3800 struct snd_pcm_substream *substream)
3801{
3802 mutex_lock(&codec->spdif_mutex);
3803 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3804 mutex_unlock(&codec->spdif_mutex);
3805 return 0;
3806}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003807EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003808
Takashi Iwaid5191e52009-11-16 14:58:17 +01003809/**
3810 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
3811 */
Takashi Iwai9411e212009-02-13 11:32:28 +01003812int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3813 struct hda_multi_out *mout)
3814{
3815 mutex_lock(&codec->spdif_mutex);
3816 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3817 mutex_unlock(&codec->spdif_mutex);
3818 return 0;
3819}
3820EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3821
Takashi Iwaid5191e52009-11-16 14:58:17 +01003822/**
3823 * snd_hda_multi_out_dig_close - release the digital out stream
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003825int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3826 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003827{
Ingo Molnar62932df2006-01-16 16:34:20 +01003828 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829 mout->dig_out_used = 0;
Ingo Molnar62932df2006-01-16 16:34:20 +01003830 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831 return 0;
3832}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003833EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003834
Takashi Iwaid5191e52009-11-16 14:58:17 +01003835/**
3836 * snd_hda_multi_out_analog_open - open analog outputs
3837 *
3838 * Open analog outputs and set up the hw-constraints.
3839 * If the digital outputs can be opened as slave, open the digital
3840 * outputs, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003842int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3843 struct hda_multi_out *mout,
Takashi Iwai9a081602008-02-12 18:37:26 +01003844 struct snd_pcm_substream *substream,
3845 struct hda_pcm_stream *hinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846{
Takashi Iwai9a081602008-02-12 18:37:26 +01003847 struct snd_pcm_runtime *runtime = substream->runtime;
3848 runtime->hw.channels_max = mout->max_channels;
3849 if (mout->dig_out_nid) {
3850 if (!mout->analog_rates) {
3851 mout->analog_rates = hinfo->rates;
3852 mout->analog_formats = hinfo->formats;
3853 mout->analog_maxbps = hinfo->maxbps;
3854 } else {
3855 runtime->hw.rates = mout->analog_rates;
3856 runtime->hw.formats = mout->analog_formats;
3857 hinfo->maxbps = mout->analog_maxbps;
3858 }
3859 if (!mout->spdif_rates) {
3860 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3861 &mout->spdif_rates,
3862 &mout->spdif_formats,
3863 &mout->spdif_maxbps);
3864 }
3865 mutex_lock(&codec->spdif_mutex);
3866 if (mout->share_spdif) {
Takashi Iwai022b4662009-07-03 23:03:30 +02003867 if ((runtime->hw.rates & mout->spdif_rates) &&
3868 (runtime->hw.formats & mout->spdif_formats)) {
3869 runtime->hw.rates &= mout->spdif_rates;
3870 runtime->hw.formats &= mout->spdif_formats;
3871 if (mout->spdif_maxbps < hinfo->maxbps)
3872 hinfo->maxbps = mout->spdif_maxbps;
3873 } else {
3874 mout->share_spdif = 0;
3875 /* FIXME: need notify? */
3876 }
Takashi Iwai9a081602008-02-12 18:37:26 +01003877 }
Frederik Deweerdteaa99852008-04-14 13:11:44 +02003878 mutex_unlock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003879 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003880 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3881 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3882}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003883EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884
Takashi Iwaid5191e52009-11-16 14:58:17 +01003885/**
3886 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
3887 *
3888 * Set up the i/o for analog out.
3889 * When the digital out is available, copy the front out to digital out, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003891int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3892 struct hda_multi_out *mout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003893 unsigned int stream_tag,
3894 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003895 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896{
3897 hda_nid_t *nids = mout->dac_nids;
3898 int chs = substream->runtime->channels;
3899 int i;
3900
Ingo Molnar62932df2006-01-16 16:34:20 +01003901 mutex_lock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003902 if (mout->dig_out_nid && mout->share_spdif &&
3903 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003904 if (chs == 2 &&
Takashi Iwai0ba21762007-04-16 11:29:14 +02003905 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3906 format) &&
3907 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003908 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003909 setup_dig_out_stream(codec, mout->dig_out_nid,
3910 stream_tag, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003911 } else {
3912 mout->dig_out_used = 0;
Takashi Iwai2f728532008-09-25 16:32:41 +02003913 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003914 }
3915 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003916 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917
3918 /* front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003919 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3920 0, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003921 if (!mout->no_share_stream &&
3922 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
Linus Torvalds1da177e2005-04-16 15:20:36 -07003923 /* headphone out will just decode front left/right (stereo) */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003924 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3925 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003926 /* extra outputs copied from front */
3927 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
Takashi Iwaid29240c2007-10-26 12:35:56 +02003928 if (!mout->no_share_stream && mout->extra_out_nid[i])
Takashi Iwai82bc9552006-03-21 11:24:42 +01003929 snd_hda_codec_setup_stream(codec,
3930 mout->extra_out_nid[i],
3931 stream_tag, 0, format);
3932
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933 /* surrounds */
3934 for (i = 1; i < mout->num_dacs; i++) {
Takashi Iwai4b3acaf2005-06-10 19:48:10 +02003935 if (chs >= (i + 1) * 2) /* independent out */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003936 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3937 i * 2, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003938 else if (!mout->no_share_stream) /* copy front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003939 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3940 0, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 }
3942 return 0;
3943}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003944EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945
Takashi Iwaid5191e52009-11-16 14:58:17 +01003946/**
3947 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
Linus Torvalds1da177e2005-04-16 15:20:36 -07003948 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003949int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3950 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951{
3952 hda_nid_t *nids = mout->dac_nids;
3953 int i;
3954
3955 for (i = 0; i < mout->num_dacs; i++)
Takashi Iwai888afa12008-03-18 09:57:50 +01003956 snd_hda_codec_cleanup_stream(codec, nids[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003957 if (mout->hp_nid)
Takashi Iwai888afa12008-03-18 09:57:50 +01003958 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003959 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3960 if (mout->extra_out_nid[i])
Takashi Iwai888afa12008-03-18 09:57:50 +01003961 snd_hda_codec_cleanup_stream(codec,
3962 mout->extra_out_nid[i]);
Ingo Molnar62932df2006-01-16 16:34:20 +01003963 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003964 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
Takashi Iwai2f728532008-09-25 16:32:41 +02003965 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003966 mout->dig_out_used = 0;
3967 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003968 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 return 0;
3970}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003971EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003973/*
Wu Fengguang6b345002008-10-07 14:21:41 +08003974 * Helper for automatic pin configuration
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003975 */
Kailang Yangdf694da2005-12-05 19:42:22 +01003976
Takashi Iwai12f288b2007-08-02 15:51:59 +02003977static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
Kailang Yangdf694da2005-12-05 19:42:22 +01003978{
3979 for (; *list; list++)
3980 if (*list == nid)
3981 return 1;
3982 return 0;
3983}
3984
Steve Longerbeam81937d32007-05-08 15:33:03 +02003985
3986/*
3987 * Sort an associated group of pins according to their sequence numbers.
3988 */
3989static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3990 int num_pins)
3991{
3992 int i, j;
3993 short seq;
3994 hda_nid_t nid;
3995
3996 for (i = 0; i < num_pins; i++) {
3997 for (j = i + 1; j < num_pins; j++) {
3998 if (sequences[i] > sequences[j]) {
3999 seq = sequences[i];
4000 sequences[i] = sequences[j];
4001 sequences[j] = seq;
4002 nid = pins[i];
4003 pins[i] = pins[j];
4004 pins[j] = nid;
4005 }
4006 }
4007 }
4008}
4009
4010
Takashi Iwai82bc9552006-03-21 11:24:42 +01004011/*
4012 * Parse all pin widgets and store the useful pin nids to cfg
4013 *
4014 * The number of line-outs or any primary output is stored in line_outs,
4015 * and the corresponding output pins are assigned to line_out_pins[],
4016 * in the order of front, rear, CLFE, side, ...
4017 *
4018 * If more extra outputs (speaker and headphone) are found, the pins are
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004019 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
Takashi Iwai82bc9552006-03-21 11:24:42 +01004020 * is detected, one of speaker of HP pins is assigned as the primary
4021 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4022 * if any analog output exists.
4023 *
4024 * The analog input pins are assigned to input_pins array.
4025 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4026 * respectively.
4027 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02004028int snd_hda_parse_pin_def_config(struct hda_codec *codec,
4029 struct auto_pin_cfg *cfg,
4030 hda_nid_t *ignore_nids)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004031{
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004032 hda_nid_t nid, end_nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004033 short seq, assoc_line_out, assoc_speaker;
4034 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4035 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
Takashi Iwaif889fa92007-10-31 15:49:32 +01004036 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004037
4038 memset(cfg, 0, sizeof(*cfg));
4039
Steve Longerbeam81937d32007-05-08 15:33:03 +02004040 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4041 memset(sequences_speaker, 0, sizeof(sequences_speaker));
Takashi Iwaif889fa92007-10-31 15:49:32 +01004042 memset(sequences_hp, 0, sizeof(sequences_hp));
Steve Longerbeam81937d32007-05-08 15:33:03 +02004043 assoc_line_out = assoc_speaker = 0;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004044
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004045 end_nid = codec->start_nid + codec->num_nodes;
4046 for (nid = codec->start_nid; nid < end_nid; nid++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004047 unsigned int wid_caps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +02004048 unsigned int wid_type = get_wcaps_type(wid_caps);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004049 unsigned int def_conf;
4050 short assoc, loc;
4051
4052 /* read all default configuration for pin complex */
4053 if (wid_type != AC_WID_PIN)
4054 continue;
Kailang Yangdf694da2005-12-05 19:42:22 +01004055 /* ignore the given nids (e.g. pc-beep returns error) */
4056 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4057 continue;
4058
Takashi Iwaic17a1ab2009-02-23 09:28:12 +01004059 def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004060 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
4061 continue;
4062 loc = get_defcfg_location(def_conf);
4063 switch (get_defcfg_device(def_conf)) {
4064 case AC_JACK_LINE_OUT:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004065 seq = get_defcfg_sequence(def_conf);
4066 assoc = get_defcfg_association(def_conf);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01004067
4068 if (!(wid_caps & AC_WCAP_STEREO))
4069 if (!cfg->mono_out_pin)
4070 cfg->mono_out_pin = nid;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004071 if (!assoc)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004072 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004073 if (!assoc_line_out)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004074 assoc_line_out = assoc;
4075 else if (assoc_line_out != assoc)
4076 continue;
4077 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4078 continue;
4079 cfg->line_out_pins[cfg->line_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004080 sequences_line_out[cfg->line_outs] = seq;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004081 cfg->line_outs++;
4082 break;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004083 case AC_JACK_SPEAKER:
Steve Longerbeam81937d32007-05-08 15:33:03 +02004084 seq = get_defcfg_sequence(def_conf);
4085 assoc = get_defcfg_association(def_conf);
4086 if (! assoc)
4087 continue;
4088 if (! assoc_speaker)
4089 assoc_speaker = assoc;
4090 else if (assoc_speaker != assoc)
4091 continue;
Takashi Iwai82bc9552006-03-21 11:24:42 +01004092 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4093 continue;
4094 cfg->speaker_pins[cfg->speaker_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004095 sequences_speaker[cfg->speaker_outs] = seq;
Takashi Iwai82bc9552006-03-21 11:24:42 +01004096 cfg->speaker_outs++;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004097 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004098 case AC_JACK_HP_OUT:
Takashi Iwaif889fa92007-10-31 15:49:32 +01004099 seq = get_defcfg_sequence(def_conf);
4100 assoc = get_defcfg_association(def_conf);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004101 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4102 continue;
4103 cfg->hp_pins[cfg->hp_outs] = nid;
Takashi Iwaif889fa92007-10-31 15:49:32 +01004104 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004105 cfg->hp_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004106 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02004107 case AC_JACK_MIC_IN: {
4108 int preferred, alt;
4109 if (loc == AC_JACK_LOC_FRONT) {
4110 preferred = AUTO_PIN_FRONT_MIC;
4111 alt = AUTO_PIN_MIC;
4112 } else {
4113 preferred = AUTO_PIN_MIC;
4114 alt = AUTO_PIN_FRONT_MIC;
4115 }
4116 if (!cfg->input_pins[preferred])
4117 cfg->input_pins[preferred] = nid;
4118 else if (!cfg->input_pins[alt])
4119 cfg->input_pins[alt] = nid;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004120 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02004121 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004122 case AC_JACK_LINE_IN:
4123 if (loc == AC_JACK_LOC_FRONT)
4124 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
4125 else
4126 cfg->input_pins[AUTO_PIN_LINE] = nid;
4127 break;
4128 case AC_JACK_CD:
4129 cfg->input_pins[AUTO_PIN_CD] = nid;
4130 break;
4131 case AC_JACK_AUX:
4132 cfg->input_pins[AUTO_PIN_AUX] = nid;
4133 break;
4134 case AC_JACK_SPDIF_OUT:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01004135 case AC_JACK_DIG_OTHER_OUT:
Takashi Iwai0852d7a2009-02-11 11:35:15 +01004136 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
4137 continue;
4138 cfg->dig_out_pins[cfg->dig_outs] = nid;
4139 cfg->dig_out_type[cfg->dig_outs] =
4140 (loc == AC_JACK_LOC_HDMI) ?
4141 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
4142 cfg->dig_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004143 break;
4144 case AC_JACK_SPDIF_IN:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01004145 case AC_JACK_DIG_OTHER_IN:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004146 cfg->dig_in_pin = nid;
Takashi Iwai2297bd62009-01-20 18:24:13 +01004147 if (loc == AC_JACK_LOC_HDMI)
4148 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
4149 else
4150 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004151 break;
4152 }
4153 }
4154
Takashi Iwai5832fcf2008-02-12 18:30:12 +01004155 /* FIX-UP:
4156 * If no line-out is defined but multiple HPs are found,
4157 * some of them might be the real line-outs.
4158 */
4159 if (!cfg->line_outs && cfg->hp_outs > 1) {
4160 int i = 0;
4161 while (i < cfg->hp_outs) {
4162 /* The real HPs should have the sequence 0x0f */
4163 if ((sequences_hp[i] & 0x0f) == 0x0f) {
4164 i++;
4165 continue;
4166 }
4167 /* Move it to the line-out table */
4168 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
4169 sequences_line_out[cfg->line_outs] = sequences_hp[i];
4170 cfg->line_outs++;
4171 cfg->hp_outs--;
4172 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
4173 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
4174 memmove(sequences_hp + i - 1, sequences_hp + i,
4175 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
4176 }
4177 }
4178
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004179 /* sort by sequence */
Steve Longerbeam81937d32007-05-08 15:33:03 +02004180 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
4181 cfg->line_outs);
4182 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
4183 cfg->speaker_outs);
Takashi Iwaif889fa92007-10-31 15:49:32 +01004184 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
4185 cfg->hp_outs);
Steve Longerbeam81937d32007-05-08 15:33:03 +02004186
Takashi Iwaif889fa92007-10-31 15:49:32 +01004187 /* if we have only one mic, make it AUTO_PIN_MIC */
4188 if (!cfg->input_pins[AUTO_PIN_MIC] &&
4189 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
4190 cfg->input_pins[AUTO_PIN_MIC] =
4191 cfg->input_pins[AUTO_PIN_FRONT_MIC];
4192 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
4193 }
4194 /* ditto for line-in */
4195 if (!cfg->input_pins[AUTO_PIN_LINE] &&
4196 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
4197 cfg->input_pins[AUTO_PIN_LINE] =
4198 cfg->input_pins[AUTO_PIN_FRONT_LINE];
4199 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
4200 }
4201
Steve Longerbeam81937d32007-05-08 15:33:03 +02004202 /*
4203 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
4204 * as a primary output
4205 */
4206 if (!cfg->line_outs) {
4207 if (cfg->speaker_outs) {
4208 cfg->line_outs = cfg->speaker_outs;
4209 memcpy(cfg->line_out_pins, cfg->speaker_pins,
4210 sizeof(cfg->speaker_pins));
4211 cfg->speaker_outs = 0;
4212 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
4213 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
4214 } else if (cfg->hp_outs) {
4215 cfg->line_outs = cfg->hp_outs;
4216 memcpy(cfg->line_out_pins, cfg->hp_pins,
4217 sizeof(cfg->hp_pins));
4218 cfg->hp_outs = 0;
4219 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4220 cfg->line_out_type = AUTO_PIN_HP_OUT;
4221 }
4222 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004223
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02004224 /* Reorder the surround channels
4225 * ALSA sequence is front/surr/clfe/side
4226 * HDA sequence is:
4227 * 4-ch: front/surr => OK as it is
4228 * 6-ch: front/clfe/surr
Takashi Iwai9422db42007-04-20 16:11:43 +02004229 * 8-ch: front/clfe/rear/side|fc
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02004230 */
4231 switch (cfg->line_outs) {
4232 case 3:
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02004233 case 4:
4234 nid = cfg->line_out_pins[1];
Takashi Iwai9422db42007-04-20 16:11:43 +02004235 cfg->line_out_pins[1] = cfg->line_out_pins[2];
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02004236 cfg->line_out_pins[2] = nid;
4237 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004238 }
4239
Takashi Iwai82bc9552006-03-21 11:24:42 +01004240 /*
4241 * debug prints of the parsed results
4242 */
4243 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4244 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
4245 cfg->line_out_pins[2], cfg->line_out_pins[3],
4246 cfg->line_out_pins[4]);
4247 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4248 cfg->speaker_outs, cfg->speaker_pins[0],
4249 cfg->speaker_pins[1], cfg->speaker_pins[2],
4250 cfg->speaker_pins[3], cfg->speaker_pins[4]);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004251 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
4252 cfg->hp_outs, cfg->hp_pins[0],
4253 cfg->hp_pins[1], cfg->hp_pins[2],
4254 cfg->hp_pins[3], cfg->hp_pins[4]);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01004255 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
Takashi Iwai0852d7a2009-02-11 11:35:15 +01004256 if (cfg->dig_outs)
4257 snd_printd(" dig-out=0x%x/0x%x\n",
4258 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004259 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
4260 " cd=0x%x, aux=0x%x\n",
4261 cfg->input_pins[AUTO_PIN_MIC],
4262 cfg->input_pins[AUTO_PIN_FRONT_MIC],
4263 cfg->input_pins[AUTO_PIN_LINE],
4264 cfg->input_pins[AUTO_PIN_FRONT_LINE],
4265 cfg->input_pins[AUTO_PIN_CD],
4266 cfg->input_pins[AUTO_PIN_AUX]);
Takashi Iwai32d2c7f2009-02-11 11:33:13 +01004267 if (cfg->dig_in_pin)
Takashi Iwai89ce9e82009-01-20 17:15:57 +01004268 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004269
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004270 return 0;
4271}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004272EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004273
Takashi Iwai4a471b72005-12-07 13:56:29 +01004274/* labels for input pins */
4275const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
4276 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
4277};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004278EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
Takashi Iwai4a471b72005-12-07 13:56:29 +01004279
4280
Linus Torvalds1da177e2005-04-16 15:20:36 -07004281#ifdef CONFIG_PM
4282/*
4283 * power management
4284 */
4285
4286/**
4287 * snd_hda_suspend - suspend the codecs
4288 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07004289 *
4290 * Returns 0 if successful.
4291 */
Takashi Iwai8dd78332009-06-02 01:16:07 +02004292int snd_hda_suspend(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004293{
Takashi Iwai0ba21762007-04-16 11:29:14 +02004294 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004295
Takashi Iwai0ba21762007-04-16 11:29:14 +02004296 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai0b7a2e92007-08-14 15:18:26 +02004297#ifdef CONFIG_SND_HDA_POWER_SAVE
4298 if (!codec->power_on)
4299 continue;
4300#endif
Takashi Iwaicb53c622007-08-10 17:21:45 +02004301 hda_call_codec_suspend(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004302 }
4303 return 0;
4304}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004305EXPORT_SYMBOL_HDA(snd_hda_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004306
4307/**
4308 * snd_hda_resume - resume the codecs
4309 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07004310 *
4311 * Returns 0 if successful.
Takashi Iwaicb53c622007-08-10 17:21:45 +02004312 *
4313 * This fucntion is defined only when POWER_SAVE isn't set.
4314 * In the power-save mode, the codec is resumed dynamically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004315 */
4316int snd_hda_resume(struct hda_bus *bus)
4317{
Takashi Iwai0ba21762007-04-16 11:29:14 +02004318 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004319
Takashi Iwai0ba21762007-04-16 11:29:14 +02004320 list_for_each_entry(codec, &bus->codec_list, list) {
Maxim Levitskyd804ad92007-09-03 15:28:04 +02004321 if (snd_hda_codec_needs_resume(codec))
4322 hda_call_codec_resume(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004323 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004324 return 0;
4325}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004326EXPORT_SYMBOL_HDA(snd_hda_resume);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01004327#endif /* CONFIG_PM */
Takashi Iwaib2e18592008-07-30 15:01:44 +02004328
4329/*
4330 * generic arrays
4331 */
4332
Takashi Iwaid5191e52009-11-16 14:58:17 +01004333/**
4334 * snd_array_new - get a new element from the given array
4335 * @array: the array object
4336 *
4337 * Get a new element from the given array. If it exceeds the
4338 * pre-allocated array size, re-allocate the array.
4339 *
4340 * Returns NULL if allocation failed.
Takashi Iwaib2e18592008-07-30 15:01:44 +02004341 */
4342void *snd_array_new(struct snd_array *array)
4343{
4344 if (array->used >= array->alloced) {
4345 int num = array->alloced + array->alloc_align;
Takashi Iwaib910d9a2008-11-07 00:26:52 +01004346 void *nlist;
4347 if (snd_BUG_ON(num >= 4096))
4348 return NULL;
4349 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
Takashi Iwaib2e18592008-07-30 15:01:44 +02004350 if (!nlist)
4351 return NULL;
4352 if (array->list) {
4353 memcpy(nlist, array->list,
4354 array->elem_size * array->alloced);
4355 kfree(array->list);
4356 }
4357 array->list = nlist;
4358 array->alloced = num;
4359 }
Takashi Iwaif43aa022008-11-10 16:24:26 +01004360 return snd_array_elem(array, array->used++);
Takashi Iwaib2e18592008-07-30 15:01:44 +02004361}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004362EXPORT_SYMBOL_HDA(snd_array_new);
Takashi Iwaib2e18592008-07-30 15:01:44 +02004363
Takashi Iwaid5191e52009-11-16 14:58:17 +01004364/**
4365 * snd_array_free - free the given array elements
4366 * @array: the array object
4367 */
Takashi Iwaib2e18592008-07-30 15:01:44 +02004368void snd_array_free(struct snd_array *array)
4369{
4370 kfree(array->list);
4371 array->used = 0;
4372 array->alloced = 0;
4373 array->list = NULL;
4374}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004375EXPORT_SYMBOL_HDA(snd_array_free);
Takashi Iwaib2022262008-11-21 21:24:03 +01004376
Takashi Iwaid5191e52009-11-16 14:58:17 +01004377/**
4378 * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
4379 * @pcm: PCM caps bits
4380 * @buf: the string buffer to write
4381 * @buflen: the max buffer length
4382 *
Takashi Iwaib2022262008-11-21 21:24:03 +01004383 * used by hda_proc.c and hda_eld.c
4384 */
4385void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4386{
4387 static unsigned int rates[] = {
4388 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4389 96000, 176400, 192000, 384000
4390 };
4391 int i, j;
4392
4393 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4394 if (pcm & (1 << i))
4395 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4396
4397 buf[j] = '\0'; /* necessary when j == 0 */
4398}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004399EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
Takashi Iwaib2022262008-11-21 21:24:03 +01004400
Takashi Iwaid5191e52009-11-16 14:58:17 +01004401/**
4402 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
4403 * @pcm: PCM caps bits
4404 * @buf: the string buffer to write
4405 * @buflen: the max buffer length
4406 *
4407 * used by hda_proc.c and hda_eld.c
4408 */
Takashi Iwaib2022262008-11-21 21:24:03 +01004409void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4410{
4411 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4412 int i, j;
4413
4414 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4415 if (pcm & (AC_SUPPCM_BITS_8 << i))
4416 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4417
4418 buf[j] = '\0'; /* necessary when j == 0 */
4419}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004420EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01004421
4422MODULE_DESCRIPTION("HDA codec core");
4423MODULE_LICENSE("GPL");