blob: 7a8fcc4c15f84acf5baab4ec9301f35f84a75049 [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
Takashi Iwai18478e82012-03-09 17:51:10 +010022#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/slab.h>
26#include <linux/pci.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010027#include <linux/mutex.h>
Paul Gortmakerda155d52011-07-15 12:38:28 -040028#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <sound/core.h>
30#include "hda_codec.h"
31#include <sound/asoundef.h>
Jaroslav Kysela302e9c52006-07-05 17:39:49 +020032#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <sound/initval.h>
Takashi Iwaicd372fb2011-03-03 14:40:14 +010034#include <sound/jack.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "hda_local.h"
Jaroslav Kysela123c07a2009-10-21 14:48:23 +020036#include "hda_beep.h"
Takashi Iwai1835a0f2011-10-27 22:12:46 +020037#include "hda_jack.h"
Takashi Iwai28073142007-07-27 18:58:06 +020038#include <sound/hda_hwdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Takashi Iwaid66fee52011-08-02 15:39:31 +020040#define CREATE_TRACE_POINTS
41#include "hda_trace.h"
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043/*
44 * vendor / preset table
45 */
46
47struct hda_vendor_id {
48 unsigned int id;
49 const char *name;
50};
51
52/* codec vendor labels */
53static struct hda_vendor_id hda_vendor_ids[] = {
Takashi Iwaic8cd1282008-02-13 16:59:29 +010054 { 0x1002, "ATI" },
Takashi Iwaie5f14242009-07-01 18:11:44 +020055 { 0x1013, "Cirrus Logic" },
Takashi Iwaia9226252006-09-17 22:05:54 +020056 { 0x1057, "Motorola" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010057 { 0x1095, "Silicon Image" },
Takashi Iwai31117b72008-12-16 14:43:21 +010058 { 0x10de, "Nvidia" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010059 { 0x10ec, "Realtek" },
Takashi Iwai4e01f542009-04-16 08:53:34 +020060 { 0x1102, "Creative" },
Joseph Chanc577b8a2006-11-29 15:29:40 +010061 { 0x1106, "VIA" },
Matthew Ranostay7f168592007-10-18 17:38:17 +020062 { 0x111d, "IDT" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010063 { 0x11c1, "LSI" },
Takashi Iwai54b903e2005-05-15 14:30:10 +020064 { 0x11d4, "Analog Devices" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 { 0x13f6, "C-Media" },
Takashi Iwaia9226252006-09-17 22:05:54 +020066 { 0x14f1, "Conexant" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010067 { 0x17e8, "Chrontel" },
68 { 0x1854, "LG" },
Mark Brown8199de32008-10-28 14:50:13 +000069 { 0x1aec, "Wolfson Microelectronics" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 { 0x434d, "C-Media" },
Takashi Iwai74c61132008-12-18 09:11:33 +010071 { 0x8086, "Intel" },
Matt2f2f4252005-04-13 14:45:30 +020072 { 0x8384, "SigmaTel" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 {} /* terminator */
74};
75
Takashi Iwai1289e9e2008-11-27 15:47:11 +010076static DEFINE_MUTEX(preset_mutex);
77static LIST_HEAD(hda_preset_tables);
78
79int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
80{
81 mutex_lock(&preset_mutex);
82 list_add_tail(&preset->list, &hda_preset_tables);
83 mutex_unlock(&preset_mutex);
84 return 0;
85}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010086EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
Takashi Iwai1289e9e2008-11-27 15:47:11 +010087
88int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
89{
90 mutex_lock(&preset_mutex);
91 list_del(&preset->list);
92 mutex_unlock(&preset_mutex);
93 return 0;
94}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010095EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Takashi Iwaicb53c622007-08-10 17:21:45 +020097#ifdef CONFIG_SND_HDA_POWER_SAVE
98static void hda_power_work(struct work_struct *work);
99static void hda_keep_power_on(struct hda_codec *codec);
Takashi Iwaie581f3d2011-07-26 10:19:20 +0200100#define hda_codec_is_power_on(codec) ((codec)->power_on)
Takashi Iwaicb53c622007-08-10 17:21:45 +0200101#else
102static inline void hda_keep_power_on(struct hda_codec *codec) {}
Takashi Iwaie581f3d2011-07-26 10:19:20 +0200103#define hda_codec_is_power_on(codec) 1
Takashi Iwaicb53c622007-08-10 17:21:45 +0200104#endif
105
Takashi Iwaid5191e52009-11-16 14:58:17 +0100106/**
107 * snd_hda_get_jack_location - Give a location string of the jack
108 * @cfg: pin default config value
109 *
110 * Parse the pin default config value and returns the string of the
111 * jack location, e.g. "Rear", "Front", etc.
112 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400113const char *snd_hda_get_jack_location(u32 cfg)
114{
115 static char *bases[7] = {
116 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
117 };
118 static unsigned char specials_idx[] = {
119 0x07, 0x08,
120 0x17, 0x18, 0x19,
121 0x37, 0x38
122 };
123 static char *specials[] = {
124 "Rear Panel", "Drive Bar",
125 "Riser", "HDMI", "ATAPI",
126 "Mobile-In", "Mobile-Out"
127 };
128 int i;
129 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
130 if ((cfg & 0x0f) < 7)
131 return bases[cfg & 0x0f];
132 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
133 if (cfg == specials_idx[i])
134 return specials[i];
135 }
136 return "UNKNOWN";
137}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100138EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400139
Takashi Iwaid5191e52009-11-16 14:58:17 +0100140/**
141 * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
142 * @cfg: pin default config value
143 *
144 * Parse the pin default config value and returns the string of the
145 * jack connectivity, i.e. external or internal connection.
146 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400147const char *snd_hda_get_jack_connectivity(u32 cfg)
148{
149 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
150
151 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
152}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100153EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400154
Takashi Iwaid5191e52009-11-16 14:58:17 +0100155/**
156 * snd_hda_get_jack_type - Give a type string of the jack
157 * @cfg: pin default config value
158 *
159 * Parse the pin default config value and returns the string of the
160 * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
161 */
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400162const char *snd_hda_get_jack_type(u32 cfg)
163{
164 static char *jack_types[16] = {
165 "Line Out", "Speaker", "HP Out", "CD",
166 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
167 "Line In", "Aux", "Mic", "Telephony",
168 "SPDIF In", "Digitial In", "Reserved", "Other"
169 };
170
171 return jack_types[(cfg & AC_DEFCFG_DEVICE)
172 >> AC_DEFCFG_DEVICE_SHIFT];
173}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100174EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400175
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100176/*
177 * Compose a 32bit command word to be sent to the HD-audio controller
178 */
179static inline unsigned int
180make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
181 unsigned int verb, unsigned int parm)
182{
183 u32 val;
184
Takashi Iwai82e1b802009-07-17 12:47:34 +0200185 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
186 (verb & ~0xfff) || (parm & ~0xffff)) {
Wu Fengguang6430aee2009-07-17 16:49:19 +0800187 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
188 codec->addr, direct, nid, verb, parm);
189 return ~0;
190 }
191
192 val = (u32)codec->addr << 28;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100193 val |= (u32)direct << 27;
194 val |= (u32)nid << 20;
195 val |= verb << 8;
196 val |= parm;
197 return val;
198}
199
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200200/*
201 * Send and receive a verb
202 */
203static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
204 unsigned int *res)
205{
206 struct hda_bus *bus = codec->bus;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200207 int err;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200208
Wu Fengguang6430aee2009-07-17 16:49:19 +0800209 if (cmd == ~0)
210 return -1;
211
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200212 if (res)
213 *res = -1;
Takashi Iwai8dd78332009-06-02 01:16:07 +0200214 again:
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200215 snd_hda_power_up(codec);
216 mutex_lock(&bus->cmd_mutex);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200217 trace_hda_send_cmd(codec, cmd);
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200218 err = bus->ops.command(bus, cmd);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200219 if (!err && res) {
Wu Fengguangdeadff12009-08-01 18:45:16 +0800220 *res = bus->ops.get_response(bus, codec->addr);
Takashi Iwaid66fee52011-08-02 15:39:31 +0200221 trace_hda_get_response(codec, *res);
222 }
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200223 mutex_unlock(&bus->cmd_mutex);
224 snd_hda_power_down(codec);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200225 if (res && *res == -1 && bus->rirb_error) {
226 if (bus->response_reset) {
227 snd_printd("hda_codec: resetting BUS due to "
228 "fatal communication error\n");
Takashi Iwaid66fee52011-08-02 15:39:31 +0200229 trace_hda_bus_reset(bus);
Takashi Iwai8dd78332009-06-02 01:16:07 +0200230 bus->ops.bus_reset(bus);
231 }
232 goto again;
233 }
234 /* clear reset-flag when the communication gets recovered */
235 if (!err)
236 bus->response_reset = 0;
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200237 return err;
238}
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240/**
241 * snd_hda_codec_read - send a command and get the response
242 * @codec: the HDA codec
243 * @nid: NID to send the command
244 * @direct: direct flag
245 * @verb: the verb to send
246 * @parm: the parameter for the verb
247 *
248 * Send a single command and read the corresponding response.
249 *
250 * Returns the obtained response value, or -1 for an error.
251 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200252unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
253 int direct,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 unsigned int verb, unsigned int parm)
255{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200256 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
257 unsigned int res;
Greg Thelen9857edf2011-06-13 07:45:45 -0700258 if (codec_exec_verb(codec, cmd, &res))
259 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 return res;
261}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100262EXPORT_SYMBOL_HDA(snd_hda_codec_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264/**
265 * snd_hda_codec_write - send a single command without waiting for response
266 * @codec: the HDA codec
267 * @nid: NID to send the command
268 * @direct: direct flag
269 * @verb: the verb to send
270 * @parm: the parameter for the verb
271 *
272 * Send a single command without waiting for response.
273 *
274 * Returns 0 if successful, or a negative error code.
275 */
276int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
277 unsigned int verb, unsigned int parm)
278{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +0200279 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100280 unsigned int res;
Takashi Iwaib20f3b82009-06-02 01:20:22 +0200281 return codec_exec_verb(codec, cmd,
282 codec->bus->sync_write ? &res : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100284EXPORT_SYMBOL_HDA(snd_hda_codec_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286/**
287 * snd_hda_sequence_write - sequence writes
288 * @codec: the HDA codec
289 * @seq: VERB array to send
290 *
291 * Send the commands sequentially from the given array.
292 * The array must be terminated with NID=0.
293 */
294void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
295{
296 for (; seq->nid; seq++)
297 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
298}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100299EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301/**
302 * snd_hda_get_sub_nodes - get the range of sub nodes
303 * @codec: the HDA codec
304 * @nid: NID to parse
305 * @start_id: the pointer to store the start NID
306 *
307 * Parse the NID and store the start NID of its sub-nodes.
308 * Returns the number of sub-nodes.
309 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200310int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
311 hda_nid_t *start_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 unsigned int parm;
314
315 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
Danny Tholene8a7f132007-09-11 21:41:56 +0200316 if (parm == -1)
317 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 *start_id = (parm >> 16) & 0x7fff;
319 return (int)(parm & 0x7fff);
320}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100321EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200323/* look up the cached results */
324static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
325{
326 int i, len;
327 for (i = 0; i < array->used; ) {
328 hda_nid_t *p = snd_array_elem(array, i);
329 if (nid == *p)
330 return p;
331 len = p[1];
332 i += len + 2;
333 }
334 return NULL;
335}
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337/**
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200338 * snd_hda_get_conn_list - get connection list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 * @codec: the HDA codec
340 * @nid: NID to parse
Takashi Iwaidce20792011-06-24 14:10:28 +0200341 * @listp: the pointer to store NID list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 *
343 * Parses the connection list of the given widget and stores the list
344 * of NIDs.
345 *
346 * Returns the number of connections, or a negative error code.
347 */
Takashi Iwaidce20792011-06-24 14:10:28 +0200348int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
349 const hda_nid_t **listp)
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200350{
351 struct snd_array *array = &codec->conn_lists;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200352 int len, err;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200353 hda_nid_t list[HDA_MAX_CONNECTIONS];
Takashi Iwaidce20792011-06-24 14:10:28 +0200354 hda_nid_t *p;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200355 bool added = false;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200356
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200357 again:
358 /* if the connection-list is already cached, read it */
359 p = lookup_conn_list(array, nid);
360 if (p) {
361 if (listp)
362 *listp = p + 2;
363 return p[1];
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200364 }
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200365 if (snd_BUG_ON(added))
366 return -EINVAL;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200367
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200368 /* read the connection and add to the cache */
Takashi Iwai9e7717c2011-07-11 15:42:52 +0200369 len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200370 if (len < 0)
371 return len;
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200372 err = snd_hda_override_conn_list(codec, nid, len, list);
373 if (err < 0)
374 return err;
375 added = true;
376 goto again;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200377}
Takashi Iwaidce20792011-06-24 14:10:28 +0200378EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
379
380/**
381 * snd_hda_get_connections - copy connection list
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 * @codec: the HDA codec
383 * @nid: NID to parse
384 * @conn_list: connection list array
385 * @max_conns: max. number of connections to store
386 *
387 * Parses the connection list of the given widget and stores the list
388 * of NIDs.
389 *
390 * Returns the number of connections, or a negative error code.
391 */
392int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200393 hda_nid_t *conn_list, int max_conns)
394{
Takashi Iwaidce20792011-06-24 14:10:28 +0200395 const hda_nid_t *list;
396 int len = snd_hda_get_conn_list(codec, nid, &list);
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200397
Takashi Iwaidce20792011-06-24 14:10:28 +0200398 if (len <= 0)
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200399 return len;
Takashi Iwaidce20792011-06-24 14:10:28 +0200400 if (len > max_conns) {
401 snd_printk(KERN_ERR "hda_codec: "
402 "Too many connections %d for NID 0x%x\n",
403 len, nid);
404 return -EINVAL;
405 }
406 memcpy(conn_list, list, len * sizeof(hda_nid_t));
407 return len;
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200408}
409EXPORT_SYMBOL_HDA(snd_hda_get_connections);
410
Takashi Iwai9e7717c2011-07-11 15:42:52 +0200411/**
412 * snd_hda_get_raw_connections - copy connection list without cache
413 * @codec: the HDA codec
414 * @nid: NID to parse
415 * @conn_list: connection list array
416 * @max_conns: max. number of connections to store
417 *
418 * Like snd_hda_get_connections(), copy the connection list but without
419 * checking through the connection-list cache.
420 * Currently called only from hda_proc.c, so not exported.
421 */
422int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
423 hda_nid_t *conn_list, int max_conns)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
425 unsigned int parm;
Takashi Iwai54d17402005-11-21 16:33:22 +0100426 int i, conn_len, conns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 unsigned int shift, num_elems, mask;
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200428 unsigned int wcaps;
Takashi Iwai54d17402005-11-21 16:33:22 +0100429 hda_nid_t prev_nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
Takashi Iwaida3cec32008-08-08 17:12:14 +0200431 if (snd_BUG_ON(!conn_list || max_conns <= 0))
432 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Takashi Iwai1ba7a7c2009-07-27 12:56:26 +0200434 wcaps = get_wcaps(codec, nid);
435 if (!(wcaps & AC_WCAP_CONN_LIST) &&
Takashi Iwai8d087c72011-06-28 12:45:47 +0200436 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
437 return 0;
Jaroslav Kysela16a433d2009-07-22 16:20:40 +0200438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
440 if (parm & AC_CLIST_LONG) {
441 /* long form */
442 shift = 16;
443 num_elems = 2;
444 } else {
445 /* short form */
446 shift = 8;
447 num_elems = 4;
448 }
449 conn_len = parm & AC_CLIST_LENGTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 mask = (1 << (shift-1)) - 1;
451
Takashi Iwai0ba21762007-04-16 11:29:14 +0200452 if (!conn_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return 0; /* no connection */
454
455 if (conn_len == 1) {
456 /* single connection */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200457 parm = snd_hda_codec_read(codec, nid, 0,
458 AC_VERB_GET_CONNECT_LIST, 0);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200459 if (parm == -1 && codec->bus->rirb_error)
460 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 conn_list[0] = parm & mask;
462 return 1;
463 }
464
465 /* multi connection */
466 conns = 0;
Takashi Iwai54d17402005-11-21 16:33:22 +0100467 prev_nid = 0;
468 for (i = 0; i < conn_len; i++) {
469 int range_val;
470 hda_nid_t val, n;
471
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200472 if (i % num_elems == 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +0100473 parm = snd_hda_codec_read(codec, nid, 0,
474 AC_VERB_GET_CONNECT_LIST, i);
Takashi Iwai3c6aae42009-07-10 12:52:27 +0200475 if (parm == -1 && codec->bus->rirb_error)
476 return -EIO;
477 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200478 range_val = !!(parm & (1 << (shift-1))); /* ranges */
Takashi Iwai54d17402005-11-21 16:33:22 +0100479 val = parm & mask;
Jaroslav Kysela2e9bf242009-07-18 11:48:19 +0200480 if (val == 0) {
481 snd_printk(KERN_WARNING "hda_codec: "
482 "invalid CONNECT_LIST verb %x[%i]:%x\n",
483 nid, i, parm);
484 return 0;
485 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100486 parm >>= shift;
487 if (range_val) {
488 /* ranges between the previous and this one */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200489 if (!prev_nid || prev_nid >= val) {
490 snd_printk(KERN_WARNING "hda_codec: "
491 "invalid dep_range_val %x:%x\n",
492 prev_nid, val);
Takashi Iwai54d17402005-11-21 16:33:22 +0100493 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100495 for (n = prev_nid + 1; n <= val; n++) {
496 if (conns >= max_conns) {
Takashi Iwai5aacc212010-07-30 10:36:29 +0200497 snd_printk(KERN_ERR "hda_codec: "
498 "Too many connections %d for NID 0x%x\n",
499 conns, nid);
Takashi Iwai54d17402005-11-21 16:33:22 +0100500 return -EINVAL;
501 }
502 conn_list[conns++] = n;
503 }
504 } else {
505 if (conns >= max_conns) {
Takashi Iwai5aacc212010-07-30 10:36:29 +0200506 snd_printk(KERN_ERR "hda_codec: "
507 "Too many connections %d for NID 0x%x\n",
508 conns, nid);
Takashi Iwai54d17402005-11-21 16:33:22 +0100509 return -EINVAL;
510 }
511 conn_list[conns++] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100513 prev_nid = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 }
515 return conns;
516}
517
Takashi Iwaia12d3e12011-04-07 15:55:15 +0200518static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
519{
520 hda_nid_t *p = snd_array_new(array);
521 if (!p)
522 return false;
523 *p = nid;
524 return true;
525}
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527/**
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200528 * snd_hda_override_conn_list - add/modify the connection-list to cache
529 * @codec: the HDA codec
530 * @nid: NID to parse
531 * @len: number of connection list entries
532 * @list: the list of connection entries
533 *
534 * Add or modify the given connection-list to the cache. If the corresponding
535 * cache already exists, invalidate it and append a new one.
536 *
537 * Returns zero or a negative error code.
538 */
539int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
540 const hda_nid_t *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200542 struct snd_array *array = &codec->conn_lists;
543 hda_nid_t *p;
544 int i, old_used;
545
546 p = lookup_conn_list(array, nid);
547 if (p)
548 *p = -1; /* invalidate the old entry */
549
550 old_used = array->used;
551 if (!add_conn_list(array, nid) || !add_conn_list(array, len))
552 goto error_add;
553 for (i = 0; i < len; i++)
554 if (!add_conn_list(array, list[i]))
555 goto error_add;
556 return 0;
557
558 error_add:
559 array->used = old_used;
560 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
Takashi Iwaib2f934a2011-07-04 16:23:26 +0200562EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
563
564/**
Takashi Iwai8d087c72011-06-28 12:45:47 +0200565 * snd_hda_get_conn_index - get the connection index of the given NID
566 * @codec: the HDA codec
567 * @mux: NID containing the list
568 * @nid: NID to select
569 * @recursive: 1 when searching NID recursively, otherwise 0
570 *
571 * Parses the connection list of the widget @mux and checks whether the
572 * widget @nid is present. If it is, return the connection index.
573 * Otherwise it returns -1.
574 */
575int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
576 hda_nid_t nid, int recursive)
577{
578 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
579 int i, nums;
580
581 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
582 for (i = 0; i < nums; i++)
583 if (conn[i] == nid)
584 return i;
585 if (!recursive)
586 return -1;
587 if (recursive > 5) {
588 snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
589 return -1;
590 }
591 recursive++;
Takashi Iwai99e14c92011-09-13 10:33:16 +0200592 for (i = 0; i < nums; i++) {
593 unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
594 if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
595 continue;
Takashi Iwai8d087c72011-06-28 12:45:47 +0200596 if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
597 return i;
Takashi Iwai99e14c92011-09-13 10:33:16 +0200598 }
Takashi Iwai8d087c72011-06-28 12:45:47 +0200599 return -1;
600}
601EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603/**
604 * snd_hda_queue_unsol_event - add an unsolicited event to queue
605 * @bus: the BUS
606 * @res: unsolicited event (lower 32bit of RIRB entry)
607 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
608 *
609 * Adds the given event to the queue. The events are processed in
610 * the workqueue asynchronously. Call this function in the interrupt
611 * hanlder when RIRB receives an unsolicited event.
612 *
613 * Returns 0 if successful, or a negative error code.
614 */
615int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
616{
617 struct hda_bus_unsolicited *unsol;
618 unsigned int wp;
619
Takashi Iwaiecf726f2011-08-09 14:22:44 +0200620 trace_hda_unsol_event(bus, res, res_ex);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200621 unsol = bus->unsol;
622 if (!unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 return 0;
624
625 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
626 unsol->wp = wp;
627
628 wp <<= 1;
629 unsol->queue[wp] = res;
630 unsol->queue[wp + 1] = res_ex;
631
Takashi Iwai6acaed32009-01-12 10:09:24 +0100632 queue_work(bus->workq, &unsol->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634 return 0;
635}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100636EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
638/*
Wu Fengguang5c1d1a92008-10-07 14:17:53 +0800639 * process queued unsolicited events
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 */
David Howellsc4028952006-11-22 14:57:56 +0000641static void process_unsol_events(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
David Howellsc4028952006-11-22 14:57:56 +0000643 struct hda_bus_unsolicited *unsol =
644 container_of(work, struct hda_bus_unsolicited, work);
645 struct hda_bus *bus = unsol->bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 struct hda_codec *codec;
647 unsigned int rp, caddr, res;
648
649 while (unsol->rp != unsol->wp) {
650 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
651 unsol->rp = rp;
652 rp <<= 1;
653 res = unsol->queue[rp];
654 caddr = unsol->queue[rp + 1];
Takashi Iwai0ba21762007-04-16 11:29:14 +0200655 if (!(caddr & (1 << 4))) /* no unsolicited event? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 continue;
657 codec = bus->caddr_tbl[caddr & 0x0f];
658 if (codec && codec->patch_ops.unsol_event)
659 codec->patch_ops.unsol_event(codec, res);
660 }
661}
662
663/*
664 * initialize unsolicited queue
665 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200666static int init_unsol_queue(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
668 struct hda_bus_unsolicited *unsol;
669
Takashi Iwai9f146bb2005-11-17 11:07:49 +0100670 if (bus->unsol) /* already initialized */
671 return 0;
672
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200673 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200674 if (!unsol) {
675 snd_printk(KERN_ERR "hda_codec: "
676 "can't allocate unsolicited queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return -ENOMEM;
678 }
David Howellsc4028952006-11-22 14:57:56 +0000679 INIT_WORK(&unsol->work, process_unsol_events);
680 unsol->bus = bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 bus->unsol = unsol;
682 return 0;
683}
684
685/*
686 * destructor
687 */
688static void snd_hda_codec_free(struct hda_codec *codec);
689
690static int snd_hda_bus_free(struct hda_bus *bus)
691{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200692 struct hda_codec *codec, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Takashi Iwai0ba21762007-04-16 11:29:14 +0200694 if (!bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 return 0;
Takashi Iwai6acaed32009-01-12 10:09:24 +0100696 if (bus->workq)
697 flush_workqueue(bus->workq);
698 if (bus->unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 kfree(bus->unsol);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200700 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 snd_hda_codec_free(codec);
702 }
703 if (bus->ops.private_free)
704 bus->ops.private_free(bus);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100705 if (bus->workq)
706 destroy_workqueue(bus->workq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 kfree(bus);
708 return 0;
709}
710
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100711static int snd_hda_bus_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
713 struct hda_bus *bus = device->device_data;
Takashi Iwaib94d35392008-11-21 09:08:06 +0100714 bus->shutdown = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 return snd_hda_bus_free(bus);
716}
717
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200718#ifdef CONFIG_SND_HDA_HWDEP
719static int snd_hda_bus_dev_register(struct snd_device *device)
720{
721 struct hda_bus *bus = device->device_data;
722 struct hda_codec *codec;
723 list_for_each_entry(codec, &bus->codec_list, list) {
724 snd_hda_hwdep_add_sysfs(codec);
Takashi Iwaia2f63092009-11-11 09:34:25 +0100725 snd_hda_hwdep_add_power_sysfs(codec);
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200726 }
727 return 0;
728}
729#else
730#define snd_hda_bus_dev_register NULL
731#endif
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733/**
734 * snd_hda_bus_new - create a HDA bus
735 * @card: the card entry
736 * @temp: the template for hda_bus information
737 * @busp: the pointer to store the created bus instance
738 *
739 * Returns 0 if successful, or a negative error code.
740 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100741int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
Takashi Iwai756e2b02007-04-16 11:27:07 +0200742 const struct hda_bus_template *temp,
743 struct hda_bus **busp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 struct hda_bus *bus;
746 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100747 static struct snd_device_ops dev_ops = {
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200748 .dev_register = snd_hda_bus_dev_register,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 .dev_free = snd_hda_bus_dev_free,
750 };
751
Takashi Iwaida3cec32008-08-08 17:12:14 +0200752 if (snd_BUG_ON(!temp))
753 return -EINVAL;
754 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
755 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 if (busp)
758 *busp = NULL;
759
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200760 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 if (bus == NULL) {
762 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
763 return -ENOMEM;
764 }
765
766 bus->card = card;
767 bus->private_data = temp->private_data;
768 bus->pci = temp->pci;
769 bus->modelname = temp->modelname;
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100770 bus->power_save = temp->power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 bus->ops = temp->ops;
772
Ingo Molnar62932df2006-01-16 16:34:20 +0100773 mutex_init(&bus->cmd_mutex);
Takashi Iwai3f50ac62010-08-20 09:44:36 +0200774 mutex_init(&bus->prepare_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 INIT_LIST_HEAD(&bus->codec_list);
776
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100777 snprintf(bus->workq_name, sizeof(bus->workq_name),
778 "hd-audio%d", card->number);
779 bus->workq = create_singlethread_workqueue(bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100780 if (!bus->workq) {
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100781 snd_printk(KERN_ERR "cannot create workqueue %s\n",
782 bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100783 kfree(bus);
784 return -ENOMEM;
785 }
786
Takashi Iwai0ba21762007-04-16 11:29:14 +0200787 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
788 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 snd_hda_bus_free(bus);
790 return err;
791 }
792 if (busp)
793 *busp = bus;
794 return 0;
795}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100796EXPORT_SYMBOL_HDA(snd_hda_bus_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Takashi Iwai82467612007-07-27 19:15:54 +0200798#ifdef CONFIG_SND_HDA_GENERIC
799#define is_generic_config(codec) \
Takashi Iwaif44ac832008-07-30 15:01:45 +0200800 (codec->modelname && !strcmp(codec->modelname, "generic"))
Takashi Iwai82467612007-07-27 19:15:54 +0200801#else
802#define is_generic_config(codec) 0
803#endif
804
Takashi Iwai645f10c2008-11-28 15:07:37 +0100805#ifdef MODULE
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100806#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
807#else
Takashi Iwai645f10c2008-11-28 15:07:37 +0100808#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100809#endif
810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811/*
812 * find a matching codec preset
813 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200814static const struct hda_codec_preset *
Takashi Iwai756e2b02007-04-16 11:27:07 +0200815find_codec_preset(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816{
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100817 struct hda_codec_preset_list *tbl;
818 const struct hda_codec_preset *preset;
819 int mod_requested = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
Takashi Iwai82467612007-07-27 19:15:54 +0200821 if (is_generic_config(codec))
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100822 return NULL; /* use the generic parser */
823
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100824 again:
825 mutex_lock(&preset_mutex);
826 list_for_each_entry(tbl, &hda_preset_tables, list) {
827 if (!try_module_get(tbl->owner)) {
828 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
829 continue;
830 }
831 for (preset = tbl->preset; preset->id; preset++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 u32 mask = preset->mask;
Marc Boucherca7cfae2008-01-22 15:32:25 +0100833 if (preset->afg && preset->afg != codec->afg)
834 continue;
835 if (preset->mfg && preset->mfg != codec->mfg)
836 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200837 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 mask = ~0;
Takashi Iwai9c7f8522006-06-28 15:08:22 +0200839 if (preset->id == (codec->vendor_id & mask) &&
Takashi Iwai0ba21762007-04-16 11:29:14 +0200840 (!preset->rev ||
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100841 preset->rev == codec->revision_id)) {
842 mutex_unlock(&preset_mutex);
843 codec->owner = tbl->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 return preset;
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 }
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100847 module_put(tbl->owner);
848 }
849 mutex_unlock(&preset_mutex);
850
851 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
852 char name[32];
853 if (!mod_requested)
854 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
855 codec->vendor_id);
856 else
857 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
858 (codec->vendor_id >> 16) & 0xffff);
859 request_module(name);
860 mod_requested++;
861 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 }
863 return NULL;
864}
865
866/*
Takashi Iwaif44ac832008-07-30 15:01:45 +0200867 * get_codec_name - store the codec name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200869static int get_codec_name(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
871 const struct hda_vendor_id *c;
872 const char *vendor = NULL;
873 u16 vendor_id = codec->vendor_id >> 16;
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200874 char tmp[16];
875
876 if (codec->vendor_name)
877 goto get_chip_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 for (c = hda_vendor_ids; c->id; c++) {
880 if (c->id == vendor_id) {
881 vendor = c->name;
882 break;
883 }
884 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200885 if (!vendor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 sprintf(tmp, "Generic %04x", vendor_id);
887 vendor = tmp;
888 }
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200889 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
890 if (!codec->vendor_name)
891 return -ENOMEM;
892
893 get_chip_name:
894 if (codec->chip_name)
895 return 0;
896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 if (codec->preset && codec->preset->name)
Takashi Iwai812a2cc2009-05-16 10:00:49 +0200898 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
899 else {
900 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
901 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
902 }
903 if (!codec->chip_name)
Takashi Iwaif44ac832008-07-30 15:01:45 +0200904 return -ENOMEM;
905 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
908/*
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200909 * look for an AFG and MFG nodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100911static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912{
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200913 int i, total_nodes, function_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 hda_nid_t nid;
915
916 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
917 for (i = 0; i < total_nodes; i++, nid++) {
Takashi Iwai93e82ae2009-04-17 18:04:41 +0200918 function_id = snd_hda_param_read(codec, nid,
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200919 AC_PAR_FUNCTION_TYPE);
Jaroslav Kyselacd7643b2010-07-20 12:11:25 +0200920 switch (function_id & 0xff) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200921 case AC_GRP_AUDIO_FUNCTION:
922 codec->afg = nid;
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200923 codec->afg_function_id = function_id & 0xff;
924 codec->afg_unsol = (function_id >> 8) & 1;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200925 break;
926 case AC_GRP_MODEM_FUNCTION:
927 codec->mfg = nid;
Jaroslav Kysela79c944a2010-07-19 15:52:39 +0200928 codec->mfg_function_id = function_id & 0xff;
929 codec->mfg_unsol = (function_id >> 8) & 1;
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200930 break;
931 default:
932 break;
933 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935}
936
937/*
Takashi Iwai54d17402005-11-21 16:33:22 +0100938 * read widget caps for each widget and store in cache
939 */
940static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
941{
942 int i;
943 hda_nid_t nid;
944
945 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
946 &codec->start_nid);
947 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200948 if (!codec->wcaps)
Takashi Iwai54d17402005-11-21 16:33:22 +0100949 return -ENOMEM;
950 nid = codec->start_nid;
951 for (i = 0; i < codec->num_nodes; i++, nid++)
952 codec->wcaps[i] = snd_hda_param_read(codec, nid,
953 AC_PAR_AUDIO_WIDGET_CAP);
954 return 0;
955}
956
Takashi Iwai3be14142009-02-20 14:11:16 +0100957/* read all pin default configurations and save codec->init_pins */
958static int read_pin_defaults(struct hda_codec *codec)
959{
960 int i;
961 hda_nid_t nid = codec->start_nid;
962
963 for (i = 0; i < codec->num_nodes; i++, nid++) {
964 struct hda_pincfg *pin;
965 unsigned int wcaps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +0200966 unsigned int wid_type = get_wcaps_type(wcaps);
Takashi Iwai3be14142009-02-20 14:11:16 +0100967 if (wid_type != AC_WID_PIN)
968 continue;
969 pin = snd_array_new(&codec->init_pins);
970 if (!pin)
971 return -ENOMEM;
972 pin->nid = nid;
973 pin->cfg = snd_hda_codec_read(codec, nid, 0,
974 AC_VERB_GET_CONFIG_DEFAULT, 0);
Takashi Iwaiac0547d2010-07-05 16:50:13 +0200975 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
976 AC_VERB_GET_PIN_WIDGET_CONTROL,
977 0);
Takashi Iwai3be14142009-02-20 14:11:16 +0100978 }
979 return 0;
980}
981
982/* look up the given pin config list and return the item matching with NID */
983static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
984 struct snd_array *array,
985 hda_nid_t nid)
986{
987 int i;
988 for (i = 0; i < array->used; i++) {
989 struct hda_pincfg *pin = snd_array_elem(array, i);
990 if (pin->nid == nid)
991 return pin;
992 }
993 return NULL;
994}
995
996/* write a config value for the given NID */
997static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
998 unsigned int cfg)
999{
1000 int i;
1001 for (i = 0; i < 4; i++) {
1002 snd_hda_codec_write(codec, nid, 0,
1003 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1004 cfg & 0xff);
1005 cfg >>= 8;
1006 }
1007}
1008
1009/* set the current pin config value for the given NID.
1010 * the value is cached, and read via snd_hda_codec_get_pincfg()
1011 */
1012int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
1013 hda_nid_t nid, unsigned int cfg)
1014{
1015 struct hda_pincfg *pin;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001016 unsigned int oldcfg;
Takashi Iwai3be14142009-02-20 14:11:16 +01001017
Takashi Iwaib82855a2009-12-27 11:24:56 +01001018 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1019 return -EINVAL;
1020
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001021 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +01001022 pin = look_up_pincfg(codec, list, nid);
1023 if (!pin) {
1024 pin = snd_array_new(list);
1025 if (!pin)
1026 return -ENOMEM;
1027 pin->nid = nid;
1028 }
1029 pin->cfg = cfg;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001030
1031 /* change only when needed; e.g. if the pincfg is already present
1032 * in user_pins[], don't write it
1033 */
1034 cfg = snd_hda_codec_get_pincfg(codec, nid);
1035 if (oldcfg != cfg)
1036 set_pincfg(codec, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +01001037 return 0;
1038}
1039
Takashi Iwaid5191e52009-11-16 14:58:17 +01001040/**
1041 * snd_hda_codec_set_pincfg - Override a pin default configuration
1042 * @codec: the HDA codec
1043 * @nid: NID to set the pin config
1044 * @cfg: the pin default config value
1045 *
1046 * Override a pin default configuration value in the cache.
1047 * This value can be read by snd_hda_codec_get_pincfg() in a higher
1048 * priority than the real hardware value.
1049 */
Takashi Iwai3be14142009-02-20 14:11:16 +01001050int snd_hda_codec_set_pincfg(struct hda_codec *codec,
1051 hda_nid_t nid, unsigned int cfg)
1052{
Takashi Iwai346ff702009-02-23 09:42:57 +01001053 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +01001054}
1055EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
1056
Takashi Iwaid5191e52009-11-16 14:58:17 +01001057/**
1058 * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
1059 * @codec: the HDA codec
1060 * @nid: NID to get the pin config
1061 *
1062 * Get the current pin config value of the given pin NID.
1063 * If the pincfg value is cached or overridden via sysfs or driver,
1064 * returns the cached value.
1065 */
Takashi Iwai3be14142009-02-20 14:11:16 +01001066unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
1067{
1068 struct hda_pincfg *pin;
1069
Takashi Iwai3be14142009-02-20 14:11:16 +01001070#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +01001071 pin = look_up_pincfg(codec, &codec->user_pins, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +01001072 if (pin)
1073 return pin->cfg;
1074#endif
Takashi Iwai5e7b8e02009-02-23 09:45:59 +01001075 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
1076 if (pin)
1077 return pin->cfg;
Takashi Iwai3be14142009-02-20 14:11:16 +01001078 pin = look_up_pincfg(codec, &codec->init_pins, nid);
1079 if (pin)
1080 return pin->cfg;
1081 return 0;
1082}
1083EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
1084
1085/* restore all current pin configs */
1086static void restore_pincfgs(struct hda_codec *codec)
1087{
1088 int i;
1089 for (i = 0; i < codec->init_pins.used; i++) {
1090 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1091 set_pincfg(codec, pin->nid,
1092 snd_hda_codec_get_pincfg(codec, pin->nid));
1093 }
1094}
Takashi Iwai54d17402005-11-21 16:33:22 +01001095
Takashi Iwai92ee6162009-12-27 11:18:59 +01001096/**
1097 * snd_hda_shutup_pins - Shut up all pins
1098 * @codec: the HDA codec
1099 *
1100 * Clear all pin controls to shup up before suspend for avoiding click noise.
1101 * The controls aren't cached so that they can be resumed properly.
1102 */
1103void snd_hda_shutup_pins(struct hda_codec *codec)
1104{
1105 int i;
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001106 /* don't shut up pins when unloading the driver; otherwise it breaks
1107 * the default pin setup at the next load of the driver
1108 */
1109 if (codec->bus->shutdown)
1110 return;
Takashi Iwai92ee6162009-12-27 11:18:59 +01001111 for (i = 0; i < codec->init_pins.used; i++) {
1112 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1113 /* use read here for syncing after issuing each verb */
1114 snd_hda_codec_read(codec, pin->nid, 0,
1115 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
1116 }
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001117 codec->pins_shutup = 1;
Takashi Iwai92ee6162009-12-27 11:18:59 +01001118}
1119EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
1120
Takashi Iwai2a439522011-07-26 09:52:50 +02001121#ifdef CONFIG_PM
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001122/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
1123static void restore_shutup_pins(struct hda_codec *codec)
1124{
1125 int i;
1126 if (!codec->pins_shutup)
1127 return;
1128 if (codec->bus->shutdown)
1129 return;
1130 for (i = 0; i < codec->init_pins.used; i++) {
1131 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
1132 snd_hda_codec_write(codec, pin->nid, 0,
1133 AC_VERB_SET_PIN_WIDGET_CONTROL,
1134 pin->ctrl);
1135 }
1136 codec->pins_shutup = 0;
1137}
Mike Waychison1c7276c2011-04-20 12:04:36 -07001138#endif
Takashi Iwaiac0547d2010-07-05 16:50:13 +02001139
Takashi Iwai01751f52007-08-10 16:59:39 +02001140static void init_hda_cache(struct hda_cache_rec *cache,
1141 unsigned int record_size);
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001142static void free_hda_cache(struct hda_cache_rec *cache);
Takashi Iwai01751f52007-08-10 16:59:39 +02001143
Takashi Iwai3be14142009-02-20 14:11:16 +01001144/* restore the initial pin cfgs and release all pincfg lists */
1145static void restore_init_pincfgs(struct hda_codec *codec)
1146{
Takashi Iwai346ff702009-02-23 09:42:57 +01001147 /* first free driver_pins and user_pins, then call restore_pincfg
Takashi Iwai3be14142009-02-20 14:11:16 +01001148 * so that only the values in init_pins are restored
1149 */
Takashi Iwai346ff702009-02-23 09:42:57 +01001150 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001151#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +01001152 snd_array_free(&codec->user_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001153#endif
1154 restore_pincfgs(codec);
1155 snd_array_free(&codec->init_pins);
1156}
1157
Takashi Iwai54d17402005-11-21 16:33:22 +01001158/*
Takashi Iwaieb541332010-08-06 13:48:11 +02001159 * audio-converter setup caches
1160 */
1161struct hda_cvt_setup {
1162 hda_nid_t nid;
1163 u8 stream_tag;
1164 u8 channel_id;
1165 u16 format_id;
1166 unsigned char active; /* cvt is currently used */
1167 unsigned char dirty; /* setups should be cleared */
1168};
1169
1170/* get or create a cache entry for the given audio converter NID */
1171static struct hda_cvt_setup *
1172get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
1173{
1174 struct hda_cvt_setup *p;
1175 int i;
1176
1177 for (i = 0; i < codec->cvt_setups.used; i++) {
1178 p = snd_array_elem(&codec->cvt_setups, i);
1179 if (p->nid == nid)
1180 return p;
1181 }
1182 p = snd_array_new(&codec->cvt_setups);
1183 if (p)
1184 p->nid = nid;
1185 return p;
1186}
1187
1188/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 * codec destructor
1190 */
1191static void snd_hda_codec_free(struct hda_codec *codec)
1192{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001193 if (!codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 return;
Takashi Iwai3be14142009-02-20 14:11:16 +01001195 restore_init_pincfgs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001196#ifdef CONFIG_SND_HDA_POWER_SAVE
1197 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01001198 flush_workqueue(codec->bus->workq);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001199#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 list_del(&codec->list);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001201 snd_array_free(&codec->mixers);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01001202 snd_array_free(&codec->nids);
Takashi Iwaia12d3e12011-04-07 15:55:15 +02001203 snd_array_free(&codec->conn_lists);
Stephen Warren7c9359762011-06-01 11:14:17 -06001204 snd_array_free(&codec->spdif_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 codec->bus->caddr_tbl[codec->addr] = NULL;
1206 if (codec->patch_ops.free)
1207 codec->patch_ops.free(codec);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001208 module_put(codec->owner);
Takashi Iwai01751f52007-08-10 16:59:39 +02001209 free_hda_cache(&codec->amp_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001210 free_hda_cache(&codec->cmd_cache);
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001211 kfree(codec->vendor_name);
1212 kfree(codec->chip_name);
Takashi Iwaif44ac832008-07-30 15:01:45 +02001213 kfree(codec->modelname);
Takashi Iwai54d17402005-11-21 16:33:22 +01001214 kfree(codec->wcaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 kfree(codec);
1216}
1217
Takashi Iwaibb6ac722009-03-13 09:02:42 +01001218static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
1219 unsigned int power_state);
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221/**
1222 * snd_hda_codec_new - create a HDA codec
1223 * @bus: the bus to assign
1224 * @codec_addr: the codec address
1225 * @codecp: the pointer to store the generated codec
1226 *
1227 * Returns 0 if successful, or a negative error code.
1228 */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01001229int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
1230 unsigned int codec_addr,
1231 struct hda_codec **codecp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 struct hda_codec *codec;
Jaroslav Kyselaba443682008-08-13 20:55:32 +02001234 char component[31];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 int err;
1236
Takashi Iwaida3cec32008-08-08 17:12:14 +02001237 if (snd_BUG_ON(!bus))
1238 return -EINVAL;
1239 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
1240 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242 if (bus->caddr_tbl[codec_addr]) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001243 snd_printk(KERN_ERR "hda_codec: "
1244 "address 0x%x is already occupied\n", codec_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 return -EBUSY;
1246 }
1247
Takashi Iwaie560d8d2005-09-09 14:21:46 +02001248 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 if (codec == NULL) {
1250 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
1251 return -ENOMEM;
1252 }
1253
1254 codec->bus = bus;
1255 codec->addr = codec_addr;
Ingo Molnar62932df2006-01-16 16:34:20 +01001256 mutex_init(&codec->spdif_mutex);
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001257 mutex_init(&codec->control_mutex);
Takashi Iwai01751f52007-08-10 16:59:39 +02001258 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001259 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01001260 snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
1261 snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
Takashi Iwai3be14142009-02-20 14:11:16 +01001262 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai346ff702009-02-23 09:42:57 +01001263 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwaieb541332010-08-06 13:48:11 +02001264 snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
Takashi Iwaia12d3e12011-04-07 15:55:15 +02001265 snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
Stephen Warren7c9359762011-06-01 11:14:17 -06001266 snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001267 if (codec->bus->modelname) {
1268 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
1269 if (!codec->modelname) {
1270 snd_hda_codec_free(codec);
1271 return -ENODEV;
1272 }
1273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Takashi Iwaicb53c622007-08-10 17:21:45 +02001275#ifdef CONFIG_SND_HDA_POWER_SAVE
1276 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
1277 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
1278 * the caller has to power down appropriatley after initialization
1279 * phase.
1280 */
1281 hda_keep_power_on(codec);
1282#endif
1283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 list_add_tail(&codec->list, &bus->codec_list);
1285 bus->caddr_tbl[codec_addr] = codec;
1286
Takashi Iwai0ba21762007-04-16 11:29:14 +02001287 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1288 AC_PAR_VENDOR_ID);
Takashi Iwai111d3af2006-02-16 18:17:58 +01001289 if (codec->vendor_id == -1)
1290 /* read again, hopefully the access method was corrected
1291 * in the last read...
1292 */
1293 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1294 AC_PAR_VENDOR_ID);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001295 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1296 AC_PAR_SUBSYSTEM_ID);
1297 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
1298 AC_PAR_REV_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001300 setup_fg_nodes(codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001301 if (!codec->afg && !codec->mfg) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +02001302 snd_printdd("hda_codec: no AFG or MFG node found\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001303 err = -ENODEV;
1304 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
1306
Takashi Iwai3be14142009-02-20 14:11:16 +01001307 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
1308 if (err < 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +01001309 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
Takashi Iwai3be14142009-02-20 14:11:16 +01001310 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001311 }
Takashi Iwai3be14142009-02-20 14:11:16 +01001312 err = read_pin_defaults(codec);
1313 if (err < 0)
1314 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +01001315
Takashi Iwai0ba21762007-04-16 11:29:14 +02001316 if (!codec->subsystem_id) {
Takashi Iwai86284e42005-10-11 15:05:54 +02001317 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001318 codec->subsystem_id =
1319 snd_hda_codec_read(codec, nid, 0,
1320 AC_VERB_GET_SUBSYSTEM_ID, 0);
Takashi Iwai86284e42005-10-11 15:05:54 +02001321 }
1322
Takashi Iwaibb6ac722009-03-13 09:02:42 +01001323 /* power-up all before initialization */
1324 hda_set_power_state(codec,
1325 codec->afg ? codec->afg : codec->mfg,
1326 AC_PWRST_D0);
1327
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001328 snd_hda_codec_proc_new(codec);
1329
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001330 snd_hda_create_hwdep(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001331
1332 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1333 codec->subsystem_id, codec->revision_id);
1334 snd_component_add(codec->bus->card, component);
1335
1336 if (codecp)
1337 *codecp = codec;
1338 return 0;
Takashi Iwai3be14142009-02-20 14:11:16 +01001339
1340 error:
1341 snd_hda_codec_free(codec);
1342 return err;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001343}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001344EXPORT_SYMBOL_HDA(snd_hda_codec_new);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001345
Takashi Iwaid5191e52009-11-16 14:58:17 +01001346/**
1347 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
1348 * @codec: the HDA codec
1349 *
1350 * Start parsing of the given codec tree and (re-)initialize the whole
1351 * patch instance.
1352 *
1353 * Returns 0 if successful or a negative error code.
1354 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001355int snd_hda_codec_configure(struct hda_codec *codec)
1356{
1357 int err;
1358
Takashi Iwaid5ad6302007-03-07 15:55:59 +01001359 codec->preset = find_codec_preset(codec);
Takashi Iwai812a2cc2009-05-16 10:00:49 +02001360 if (!codec->vendor_name || !codec->chip_name) {
Takashi Iwaif44ac832008-07-30 15:01:45 +02001361 err = get_codec_name(codec);
1362 if (err < 0)
1363 return err;
1364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365
Takashi Iwai82467612007-07-27 19:15:54 +02001366 if (is_generic_config(codec)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai82467612007-07-27 19:15:54 +02001368 goto patched;
1369 }
Takashi Iwai82467612007-07-27 19:15:54 +02001370 if (codec->preset && codec->preset->patch) {
1371 err = codec->preset->patch(codec);
1372 goto patched;
1373 }
1374
1375 /* call the default parser */
Takashi Iwai82467612007-07-27 19:15:54 +02001376 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai35a1e0c2007-10-19 08:13:40 +02001377 if (err < 0)
1378 printk(KERN_ERR "hda-codec: No codec parser is available\n");
Takashi Iwai82467612007-07-27 19:15:54 +02001379
1380 patched:
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001381 if (!err && codec->patch_ops.unsol_event)
1382 err = init_unsol_queue(codec->bus);
Takashi Iwaif62faed2009-12-23 09:27:51 +01001383 /* audio codec should override the mixer name */
1384 if (!err && (codec->afg || !*codec->bus->card->mixername))
1385 snprintf(codec->bus->card->mixername,
1386 sizeof(codec->bus->card->mixername),
1387 "%s %s", codec->vendor_name, codec->chip_name);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001388 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389}
Takashi Iwaia1e21c92009-06-17 09:33:52 +02001390EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392/**
1393 * snd_hda_codec_setup_stream - set up the codec for streaming
1394 * @codec: the CODEC to set up
1395 * @nid: the NID to set up
1396 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1397 * @channel_id: channel id to pass, zero based.
1398 * @format: stream format.
1399 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001400void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1401 u32 stream_tag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 int channel_id, int format)
1403{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001404 struct hda_codec *c;
Takashi Iwaieb541332010-08-06 13:48:11 +02001405 struct hda_cvt_setup *p;
1406 unsigned int oldval, newval;
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001407 int type;
Takashi Iwaieb541332010-08-06 13:48:11 +02001408 int i;
1409
Takashi Iwai0ba21762007-04-16 11:29:14 +02001410 if (!nid)
Takashi Iwaid21b37e2005-04-20 13:45:55 +02001411 return;
1412
Takashi Iwai0ba21762007-04-16 11:29:14 +02001413 snd_printdd("hda_codec_setup_stream: "
1414 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 nid, stream_tag, channel_id, format);
Takashi Iwaieb541332010-08-06 13:48:11 +02001416 p = get_hda_cvt_setup(codec, nid);
1417 if (!p)
1418 return;
1419 /* update the stream-id if changed */
1420 if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
1421 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
1422 newval = (stream_tag << 4) | channel_id;
1423 if (oldval != newval)
1424 snd_hda_codec_write(codec, nid, 0,
1425 AC_VERB_SET_CHANNEL_STREAMID,
1426 newval);
1427 p->stream_tag = stream_tag;
1428 p->channel_id = channel_id;
1429 }
1430 /* update the format-id if changed */
1431 if (p->format_id != format) {
1432 oldval = snd_hda_codec_read(codec, nid, 0,
1433 AC_VERB_GET_STREAM_FORMAT, 0);
1434 if (oldval != format) {
1435 msleep(1);
1436 snd_hda_codec_write(codec, nid, 0,
1437 AC_VERB_SET_STREAM_FORMAT,
1438 format);
1439 }
1440 p->format_id = format;
1441 }
1442 p->active = 1;
1443 p->dirty = 0;
1444
1445 /* make other inactive cvts with the same stream-tag dirty */
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001446 type = get_wcaps_type(get_wcaps(codec, nid));
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001447 list_for_each_entry(c, &codec->bus->codec_list, list) {
1448 for (i = 0; i < c->cvt_setups.used; i++) {
1449 p = snd_array_elem(&c->cvt_setups, i);
Takashi Iwai62b7e5e2010-10-22 17:15:47 +02001450 if (!p->active && p->stream_tag == stream_tag &&
David Henningsson54c2a892012-02-01 12:05:41 +01001451 get_wcaps_type(get_wcaps(c, p->nid)) == type)
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001452 p->dirty = 1;
1453 }
Takashi Iwaieb541332010-08-06 13:48:11 +02001454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001456EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Takashi Iwaif0cea792010-08-13 11:56:53 +02001458static void really_cleanup_stream(struct hda_codec *codec,
1459 struct hda_cvt_setup *q);
1460
Takashi Iwaid5191e52009-11-16 14:58:17 +01001461/**
Takashi Iwaif0cea792010-08-13 11:56:53 +02001462 * __snd_hda_codec_cleanup_stream - clean up the codec for closing
Takashi Iwaid5191e52009-11-16 14:58:17 +01001463 * @codec: the CODEC to clean up
1464 * @nid: the NID to clean up
Takashi Iwaif0cea792010-08-13 11:56:53 +02001465 * @do_now: really clean up the stream instead of clearing the active flag
Takashi Iwaid5191e52009-11-16 14:58:17 +01001466 */
Takashi Iwaif0cea792010-08-13 11:56:53 +02001467void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
1468 int do_now)
Takashi Iwai888afa12008-03-18 09:57:50 +01001469{
Takashi Iwaieb541332010-08-06 13:48:11 +02001470 struct hda_cvt_setup *p;
1471
Takashi Iwai888afa12008-03-18 09:57:50 +01001472 if (!nid)
1473 return;
1474
Takashi Iwai0e7adbe2010-10-25 10:37:11 +02001475 if (codec->no_sticky_stream)
1476 do_now = 1;
1477
Takashi Iwai888afa12008-03-18 09:57:50 +01001478 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
Takashi Iwaieb541332010-08-06 13:48:11 +02001479 p = get_hda_cvt_setup(codec, nid);
Takashi Iwaif0cea792010-08-13 11:56:53 +02001480 if (p) {
1481 /* here we just clear the active flag when do_now isn't set;
1482 * actual clean-ups will be done later in
1483 * purify_inactive_streams() called from snd_hda_codec_prpapre()
1484 */
1485 if (do_now)
1486 really_cleanup_stream(codec, p);
1487 else
1488 p->active = 0;
1489 }
Takashi Iwai888afa12008-03-18 09:57:50 +01001490}
Takashi Iwaif0cea792010-08-13 11:56:53 +02001491EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
Takashi Iwai888afa12008-03-18 09:57:50 +01001492
Takashi Iwaieb541332010-08-06 13:48:11 +02001493static void really_cleanup_stream(struct hda_codec *codec,
1494 struct hda_cvt_setup *q)
1495{
1496 hda_nid_t nid = q->nid;
Takashi Iwai218264a2011-09-27 17:33:45 +02001497 if (q->stream_tag || q->channel_id)
1498 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1499 if (q->format_id)
1500 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
1501);
Takashi Iwaieb541332010-08-06 13:48:11 +02001502 memset(q, 0, sizeof(*q));
1503 q->nid = nid;
1504}
1505
1506/* clean up the all conflicting obsolete streams */
1507static void purify_inactive_streams(struct hda_codec *codec)
1508{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001509 struct hda_codec *c;
Takashi Iwaieb541332010-08-06 13:48:11 +02001510 int i;
1511
Takashi Iwai3f50ac62010-08-20 09:44:36 +02001512 list_for_each_entry(c, &codec->bus->codec_list, list) {
1513 for (i = 0; i < c->cvt_setups.used; i++) {
1514 struct hda_cvt_setup *p;
1515 p = snd_array_elem(&c->cvt_setups, i);
1516 if (p->dirty)
1517 really_cleanup_stream(c, p);
1518 }
Takashi Iwaieb541332010-08-06 13:48:11 +02001519 }
1520}
1521
Takashi Iwai2a439522011-07-26 09:52:50 +02001522#ifdef CONFIG_PM
Takashi Iwaieb541332010-08-06 13:48:11 +02001523/* clean up all streams; called from suspend */
1524static void hda_cleanup_all_streams(struct hda_codec *codec)
1525{
1526 int i;
1527
1528 for (i = 0; i < codec->cvt_setups.used; i++) {
1529 struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
1530 if (p->stream_tag)
1531 really_cleanup_stream(codec, p);
1532 }
1533}
Mike Waychison1c7276c2011-04-20 12:04:36 -07001534#endif
Takashi Iwaieb541332010-08-06 13:48:11 +02001535
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536/*
1537 * amp access functions
1538 */
1539
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001540/* FIXME: more better hash key? */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01001541#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
Takashi Iwai1327a322009-03-23 13:07:47 +01001542#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001543#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1544#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545#define INFO_AMP_CAPS (1<<0)
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001546#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
1548/* initialize the hash table */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001549static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
Takashi Iwai01751f52007-08-10 16:59:39 +02001550 unsigned int record_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551{
Takashi Iwai01751f52007-08-10 16:59:39 +02001552 memset(cache, 0, sizeof(*cache));
1553 memset(cache->hash, 0xff, sizeof(cache->hash));
Takashi Iwai603c4012008-07-30 15:01:44 +02001554 snd_array_init(&cache->buf, record_size, 64);
Takashi Iwai01751f52007-08-10 16:59:39 +02001555}
1556
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001557static void free_hda_cache(struct hda_cache_rec *cache)
Takashi Iwai01751f52007-08-10 16:59:39 +02001558{
Takashi Iwai603c4012008-07-30 15:01:44 +02001559 snd_array_free(&cache->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560}
1561
1562/* query the hash. allocate an entry if not found. */
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001563static struct hda_cache_head *get_hash(struct hda_cache_rec *cache, u32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564{
Takashi Iwai01751f52007-08-10 16:59:39 +02001565 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1566 u16 cur = cache->hash[idx];
1567 struct hda_cache_head *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
1569 while (cur != 0xffff) {
Takashi Iwaif43aa022008-11-10 16:24:26 +01001570 info = snd_array_elem(&cache->buf, cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 if (info->key == key)
1572 return info;
1573 cur = info->next;
1574 }
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001575 return NULL;
1576}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Takashi Iwaia68d5a52010-03-30 18:03:44 +02001578/* query the hash. allocate an entry if not found. */
1579static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1580 u32 key)
1581{
1582 struct hda_cache_head *info = get_hash(cache, key);
1583 if (!info) {
1584 u16 idx, cur;
1585 /* add a new hash entry */
1586 info = snd_array_new(&cache->buf);
1587 if (!info)
1588 return NULL;
1589 cur = snd_array_index(&cache->buf, info);
1590 info->key = key;
1591 info->val = 0;
1592 idx = key % (u16)ARRAY_SIZE(cache->hash);
1593 info->next = cache->hash[idx];
1594 cache->hash[idx] = cur;
1595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 return info;
1597}
1598
Takashi Iwai01751f52007-08-10 16:59:39 +02001599/* query and allocate an amp hash entry */
1600static inline struct hda_amp_info *
1601get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1602{
1603 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1604}
1605
Takashi Iwaid5191e52009-11-16 14:58:17 +01001606/**
1607 * query_amp_caps - query AMP capabilities
1608 * @codec: the HD-auio codec
1609 * @nid: the NID to query
1610 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1611 *
1612 * Query AMP capabilities for the given widget and direction.
1613 * Returns the obtained capability bits.
1614 *
1615 * When cap bits have been already read, this doesn't read again but
1616 * returns the cached value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 */
Matthew Ranostay09a99952008-01-24 11:49:21 +01001618u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001620 struct hda_amp_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621
Takashi Iwai0ba21762007-04-16 11:29:14 +02001622 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1623 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 return 0;
Takashi Iwai01751f52007-08-10 16:59:39 +02001625 if (!(info->head.val & INFO_AMP_CAPS)) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001626 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 nid = codec->afg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001628 info->amp_caps = snd_hda_param_read(codec, nid,
1629 direction == HDA_OUTPUT ?
1630 AC_PAR_AMP_OUT_CAP :
1631 AC_PAR_AMP_IN_CAP);
Takashi Iwaib75e53f2007-05-10 16:56:09 +02001632 if (info->amp_caps)
Takashi Iwai01751f52007-08-10 16:59:39 +02001633 info->head.val |= INFO_AMP_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 }
1635 return info->amp_caps;
1636}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001637EXPORT_SYMBOL_HDA(query_amp_caps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638
Takashi Iwaid5191e52009-11-16 14:58:17 +01001639/**
1640 * snd_hda_override_amp_caps - Override the AMP capabilities
1641 * @codec: the CODEC to clean up
1642 * @nid: the NID to clean up
1643 * @direction: either #HDA_INPUT or #HDA_OUTPUT
1644 * @caps: the capability bits to set
1645 *
1646 * Override the cached AMP caps bits value by the given one.
1647 * This function is useful if the driver needs to adjust the AMP ranges,
1648 * e.g. limit to 0dB, etc.
1649 *
1650 * Returns zero if successful or a negative error code.
1651 */
Takashi Iwai897cc182007-05-29 19:01:37 +02001652int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1653 unsigned int caps)
1654{
1655 struct hda_amp_info *info;
1656
1657 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1658 if (!info)
1659 return -EINVAL;
1660 info->amp_caps = caps;
Takashi Iwai01751f52007-08-10 16:59:39 +02001661 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai897cc182007-05-29 19:01:37 +02001662 return 0;
1663}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001664EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
Takashi Iwai897cc182007-05-29 19:01:37 +02001665
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001666static unsigned int
1667query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1668 unsigned int (*func)(struct hda_codec *, hda_nid_t))
Takashi Iwai1327a322009-03-23 13:07:47 +01001669{
1670 struct hda_amp_info *info;
1671
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001672 info = get_alloc_amp_hash(codec, key);
Takashi Iwai1327a322009-03-23 13:07:47 +01001673 if (!info)
1674 return 0;
1675 if (!info->head.val) {
Takashi Iwai1327a322009-03-23 13:07:47 +01001676 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001677 info->amp_caps = func(codec, nid);
Takashi Iwai1327a322009-03-23 13:07:47 +01001678 }
1679 return info->amp_caps;
1680}
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001681
1682static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1683{
1684 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1685}
1686
Takashi Iwaid5191e52009-11-16 14:58:17 +01001687/**
1688 * snd_hda_query_pin_caps - Query PIN capabilities
1689 * @codec: the HD-auio codec
1690 * @nid: the NID to query
1691 *
1692 * Query PIN capabilities for the given widget.
1693 * Returns the obtained capability bits.
1694 *
1695 * When cap bits have been already read, this doesn't read again but
1696 * returns the cached value.
1697 */
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01001698u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1699{
1700 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1701 read_pin_cap);
1702}
Takashi Iwai1327a322009-03-23 13:07:47 +01001703EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
1704
Wu Fengguang864f92b2009-11-18 12:38:02 +08001705/**
Takashi Iwaif57c2562011-08-15 12:49:07 +02001706 * snd_hda_override_pin_caps - Override the pin capabilities
1707 * @codec: the CODEC
1708 * @nid: the NID to override
1709 * @caps: the capability bits to set
1710 *
1711 * Override the cached PIN capabilitiy bits value by the given one.
1712 *
1713 * Returns zero if successful or a negative error code.
1714 */
1715int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
1716 unsigned int caps)
1717{
1718 struct hda_amp_info *info;
1719 info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
1720 if (!info)
1721 return -ENOMEM;
1722 info->amp_caps = caps;
1723 info->head.val |= INFO_AMP_CAPS;
1724 return 0;
1725}
1726EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
1727
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728/*
1729 * read the current volume to info
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001730 * if the cache exists, read the cache value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001732static unsigned int get_vol_mute(struct hda_codec *codec,
1733 struct hda_amp_info *info, hda_nid_t nid,
1734 int ch, int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735{
1736 u32 val, parm;
1737
Takashi Iwai01751f52007-08-10 16:59:39 +02001738 if (info->head.val & INFO_AMP_VOL(ch))
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001739 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740
1741 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1742 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1743 parm |= index;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001744 val = snd_hda_codec_read(codec, nid, 0,
1745 AC_VERB_GET_AMP_GAIN_MUTE, parm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 info->vol[ch] = val & 0xff;
Takashi Iwai01751f52007-08-10 16:59:39 +02001747 info->head.val |= INFO_AMP_VOL(ch);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001748 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749}
1750
1751/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001752 * write the current volume in info to the h/w and update the cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 */
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001754static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
Takashi Iwai0ba21762007-04-16 11:29:14 +02001755 hda_nid_t nid, int ch, int direction, int index,
1756 int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757{
1758 u32 parm;
1759
1760 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1761 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1762 parm |= index << AC_AMP_SET_INDEX_SHIFT;
Takashi Iwai38681372012-02-27 15:00:58 +01001763 if ((val & HDA_AMP_MUTE) && !(info->amp_caps & AC_AMPCAP_MUTE) &&
1764 (info->amp_caps & AC_AMPCAP_MIN_MUTE))
1765 ; /* set the zero value as a fake mute */
1766 else
1767 parm |= val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001769 info->vol[ch] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770}
1771
Takashi Iwaid5191e52009-11-16 14:58:17 +01001772/**
1773 * snd_hda_codec_amp_read - Read AMP value
1774 * @codec: HD-audio codec
1775 * @nid: NID to read the AMP value
1776 * @ch: channel (left=0 or right=1)
1777 * @direction: #HDA_INPUT or #HDA_OUTPUT
1778 * @index: the index value (only for input direction)
1779 *
1780 * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 */
Takashi Iwai834be882006-03-01 14:16:17 +01001782int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1783 int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001785 struct hda_amp_info *info;
1786 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1787 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001789 return get_vol_mute(codec, info, nid, ch, direction, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001791EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
Takashi Iwaid5191e52009-11-16 14:58:17 +01001793/**
1794 * snd_hda_codec_amp_update - update the AMP value
1795 * @codec: HD-audio codec
1796 * @nid: NID to read the AMP value
1797 * @ch: channel (left=0 or right=1)
1798 * @direction: #HDA_INPUT or #HDA_OUTPUT
1799 * @idx: the index value (only for input direction)
1800 * @mask: bit mask to set
1801 * @val: the bits value to set
1802 *
1803 * Update the AMP value with a bit mask.
1804 * Returns 0 if the value is unchanged, 1 if changed.
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001805 */
Takashi Iwai834be882006-03-01 14:16:17 +01001806int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1807 int direction, int idx, int mask, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001809 struct hda_amp_info *info;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001810
Takashi Iwai0ba21762007-04-16 11:29:14 +02001811 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1812 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 return 0;
Takashi Iwai467126462010-03-29 09:19:38 +02001814 if (snd_BUG_ON(mask & ~0xff))
1815 mask &= 0xff;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001816 val &= mask;
1817 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001818 if (info->vol[ch] == val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001820 put_vol_mute(codec, info, nid, ch, direction, idx, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 return 1;
1822}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001823EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
Takashi Iwaid5191e52009-11-16 14:58:17 +01001825/**
1826 * snd_hda_codec_amp_stereo - update the AMP stereo values
1827 * @codec: HD-audio codec
1828 * @nid: NID to read the AMP value
1829 * @direction: #HDA_INPUT or #HDA_OUTPUT
1830 * @idx: the index value (only for input direction)
1831 * @mask: bit mask to set
1832 * @val: the bits value to set
1833 *
1834 * Update the AMP values like snd_hda_codec_amp_update(), but for a
1835 * stereo widget with the same mask and value.
Takashi Iwai47fd8302007-08-10 17:11:07 +02001836 */
1837int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1838 int direction, int idx, int mask, int val)
1839{
1840 int ch, ret = 0;
Takashi Iwai467126462010-03-29 09:19:38 +02001841
1842 if (snd_BUG_ON(mask & ~0xff))
1843 mask &= 0xff;
Takashi Iwai47fd8302007-08-10 17:11:07 +02001844 for (ch = 0; ch < 2; ch++)
1845 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1846 idx, mask, val);
1847 return ret;
1848}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001849EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
Takashi Iwai47fd8302007-08-10 17:11:07 +02001850
Takashi Iwai2a439522011-07-26 09:52:50 +02001851#ifdef CONFIG_PM
Takashi Iwaid5191e52009-11-16 14:58:17 +01001852/**
1853 * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
1854 * @codec: HD-audio codec
1855 *
1856 * Resume the all amp commands from the cache.
1857 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001858void snd_hda_codec_resume_amp(struct hda_codec *codec)
1859{
Takashi Iwai603c4012008-07-30 15:01:44 +02001860 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001861 int i;
1862
Takashi Iwai603c4012008-07-30 15:01:44 +02001863 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001864 u32 key = buffer->head.key;
1865 hda_nid_t nid;
1866 unsigned int idx, dir, ch;
1867 if (!key)
1868 continue;
1869 nid = key & 0xff;
1870 idx = (key >> 16) & 0xff;
1871 dir = (key >> 24) & 0xff;
1872 for (ch = 0; ch < 2; ch++) {
1873 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1874 continue;
1875 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1876 buffer->vol[ch]);
1877 }
1878 }
1879}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001880EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
Takashi Iwai2a439522011-07-26 09:52:50 +02001881#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001883static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
1884 unsigned int ofs)
1885{
1886 u32 caps = query_amp_caps(codec, nid, dir);
1887 /* get num steps */
1888 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1889 if (ofs < caps)
1890 caps -= ofs;
1891 return caps;
1892}
1893
Takashi Iwaid5191e52009-11-16 14:58:17 +01001894/**
1895 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
1896 *
1897 * The control element is supposed to have the private_value field
1898 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1899 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001900int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1901 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902{
1903 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1904 u16 nid = get_amp_nid(kcontrol);
1905 u8 chs = get_amp_channels(kcontrol);
1906 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001907 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001909 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1910 uinfo->count = chs == 3 ? 2 : 1;
1911 uinfo->value.integer.min = 0;
1912 uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
1913 if (!uinfo->value.integer.max) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001914 printk(KERN_WARNING "hda_codec: "
Takashi Iwai9c8f2ab2008-01-11 16:12:23 +01001915 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1916 kcontrol->id.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 return -EINVAL;
1918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 return 0;
1920}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001921EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001923
1924static inline unsigned int
1925read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1926 int ch, int dir, int idx, unsigned int ofs)
1927{
1928 unsigned int val;
1929 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1930 val &= HDA_AMP_VOLMASK;
1931 if (val >= ofs)
1932 val -= ofs;
1933 else
1934 val = 0;
1935 return val;
1936}
1937
1938static inline int
1939update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1940 int ch, int dir, int idx, unsigned int ofs,
1941 unsigned int val)
1942{
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001943 unsigned int maxval;
1944
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001945 if (val > 0)
1946 val += ofs;
Takashi Iwai7ccc3ef2010-07-26 17:00:15 +02001947 /* ofs = 0: raw max value */
1948 maxval = get_amp_max_value(codec, nid, dir, 0);
Takashi Iwaiafbd9b82010-07-08 18:40:37 +02001949 if (val > maxval)
1950 val = maxval;
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001951 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1952 HDA_AMP_VOLMASK, val);
1953}
1954
Takashi Iwaid5191e52009-11-16 14:58:17 +01001955/**
1956 * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
1957 *
1958 * The control element is supposed to have the private_value field
1959 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1960 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001961int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1962 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963{
1964 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1965 hda_nid_t nid = get_amp_nid(kcontrol);
1966 int chs = get_amp_channels(kcontrol);
1967 int dir = get_amp_direction(kcontrol);
1968 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001969 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 long *valp = ucontrol->value.integer.value;
1971
1972 if (chs & 1)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001973 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001975 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 return 0;
1977}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001978EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Takashi Iwaid5191e52009-11-16 14:58:17 +01001980/**
1981 * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
1982 *
1983 * The control element is supposed to have the private_value field
1984 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
1985 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001986int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1987 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988{
1989 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1990 hda_nid_t nid = get_amp_nid(kcontrol);
1991 int chs = get_amp_channels(kcontrol);
1992 int dir = get_amp_direction(kcontrol);
1993 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001994 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 long *valp = ucontrol->value.integer.value;
1996 int change = 0;
1997
Takashi Iwaicb53c622007-08-10 17:21:45 +02001998 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001999 if (chs & 1) {
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002000 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02002001 valp++;
2002 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02002003 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002004 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002005 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 return change;
2007}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002008EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009
Takashi Iwaid5191e52009-11-16 14:58:17 +01002010/**
2011 * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
2012 *
2013 * The control element is supposed to have the private_value field
2014 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2015 */
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002016int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2017 unsigned int size, unsigned int __user *_tlv)
2018{
2019 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2020 hda_nid_t nid = get_amp_nid(kcontrol);
2021 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002022 unsigned int ofs = get_amp_offset(kcontrol);
Clemens Ladischde8c85f2010-10-15 10:32:50 +02002023 bool min_mute = get_amp_min_mute(kcontrol);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002024 u32 caps, val1, val2;
2025
2026 if (size < 4 * sizeof(unsigned int))
2027 return -ENOMEM;
2028 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002029 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2030 val2 = (val2 + 1) * 25;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002031 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01002032 val1 += ofs;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002033 val1 = ((int)val1) * ((int)val2);
Takashi Iwai38681372012-02-27 15:00:58 +01002034 if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
Takashi Iwaic08d9162010-10-17 10:40:53 +02002035 val2 |= TLV_DB_SCALE_MUTE;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002036 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
2037 return -EFAULT;
2038 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
2039 return -EFAULT;
2040 if (put_user(val1, _tlv + 2))
2041 return -EFAULT;
2042 if (put_user(val2, _tlv + 3))
2043 return -EFAULT;
2044 return 0;
2045}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002046EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02002047
Takashi Iwaid5191e52009-11-16 14:58:17 +01002048/**
2049 * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
2050 * @codec: HD-audio codec
2051 * @nid: NID of a reference widget
2052 * @dir: #HDA_INPUT or #HDA_OUTPUT
2053 * @tlv: TLV data to be stored, at least 4 elements
2054 *
2055 * Set (static) TLV data for a virtual master volume using the AMP caps
2056 * obtained from the reference NID.
2057 * The volume range is recalculated as if the max volume is 0dB.
Takashi Iwai2134ea42008-01-10 16:53:55 +01002058 */
2059void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
2060 unsigned int *tlv)
2061{
2062 u32 caps;
2063 int nums, step;
2064
2065 caps = query_amp_caps(codec, nid, dir);
2066 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
2067 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
2068 step = (step + 1) * 25;
2069 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
2070 tlv[1] = 2 * sizeof(unsigned int);
2071 tlv[2] = -nums * step;
2072 tlv[3] = step;
2073}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002074EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002075
2076/* find a mixer control element with the given name */
Takashi Iwai09f99702008-02-04 12:31:13 +01002077static struct snd_kcontrol *
2078_snd_hda_find_mixer_ctl(struct hda_codec *codec,
2079 const char *name, int idx)
Takashi Iwai2134ea42008-01-10 16:53:55 +01002080{
2081 struct snd_ctl_elem_id id;
2082 memset(&id, 0, sizeof(id));
2083 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
Takashi Iwai09f99702008-02-04 12:31:13 +01002084 id.index = idx;
Takashi Iwai18cb7102009-04-16 10:22:24 +02002085 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
2086 return NULL;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002087 strcpy(id.name, name);
2088 return snd_ctl_find_id(codec->bus->card, &id);
2089}
2090
Takashi Iwaid5191e52009-11-16 14:58:17 +01002091/**
2092 * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
2093 * @codec: HD-audio codec
2094 * @name: ctl id name string
2095 *
2096 * Get the control element with the given id string and IFACE_MIXER.
2097 */
Takashi Iwai09f99702008-02-04 12:31:13 +01002098struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
2099 const char *name)
2100{
2101 return _snd_hda_find_mixer_ctl(codec, name, 0);
2102}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002103EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
Takashi Iwai09f99702008-02-04 12:31:13 +01002104
Takashi Iwai1afe2062010-12-23 10:17:52 +01002105static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name)
2106{
2107 int idx;
2108 for (idx = 0; idx < 16; idx++) { /* 16 ctlrs should be large enough */
2109 if (!_snd_hda_find_mixer_ctl(codec, name, idx))
2110 return idx;
2111 }
2112 return -EBUSY;
2113}
2114
Takashi Iwaid5191e52009-11-16 14:58:17 +01002115/**
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002116 * snd_hda_ctl_add - Add a control element and assign to the codec
Takashi Iwaid5191e52009-11-16 14:58:17 +01002117 * @codec: HD-audio codec
2118 * @nid: corresponding NID (optional)
2119 * @kctl: the control element to assign
2120 *
2121 * Add the given control element to an array inside the codec instance.
2122 * All control elements belonging to a codec are supposed to be added
2123 * by this function so that a proper clean-up works at the free or
2124 * reconfiguration time.
2125 *
2126 * If non-zero @nid is passed, the NID is assigned to the control element.
2127 * The assignment is shown in the codec proc file.
2128 *
2129 * snd_hda_ctl_add() checks the control subdev id field whether
2130 * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002131 * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
2132 * specifies if kctl->private_value is a HDA amplifier value.
Takashi Iwaid5191e52009-11-16 14:58:17 +01002133 */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002134int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
2135 struct snd_kcontrol *kctl)
Takashi Iwaid13bd412008-07-30 15:01:45 +02002136{
2137 int err;
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002138 unsigned short flags = 0;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002139 struct hda_nid_item *item;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002140
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002141 if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002142 flags |= HDA_NID_ITEM_AMP;
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002143 if (nid == 0)
2144 nid = get_amp_nid_(kctl->private_value);
2145 }
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002146 if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
2147 nid = kctl->id.subdevice & 0xffff;
Jaroslav Kysela5e26dfd2009-12-10 13:57:01 +01002148 if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01002149 kctl->id.subdevice = 0;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002150 err = snd_ctl_add(codec->bus->card, kctl);
2151 if (err < 0)
2152 return err;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002153 item = snd_array_new(&codec->mixers);
2154 if (!item)
Takashi Iwaid13bd412008-07-30 15:01:45 +02002155 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002156 item->kctl = kctl;
2157 item->nid = nid;
Jaroslav Kysela9e3fd872009-12-08 17:45:25 +01002158 item->flags = flags;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002159 return 0;
2160}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002161EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002162
Takashi Iwaid5191e52009-11-16 14:58:17 +01002163/**
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002164 * snd_hda_add_nid - Assign a NID to a control element
2165 * @codec: HD-audio codec
2166 * @nid: corresponding NID (optional)
2167 * @kctl: the control element to assign
2168 * @index: index to kctl
2169 *
2170 * Add the given control element to an array inside the codec instance.
2171 * This function is used when #snd_hda_ctl_add cannot be used for 1:1
2172 * NID:KCTL mapping - for example "Capture Source" selector.
2173 */
2174int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
2175 unsigned int index, hda_nid_t nid)
2176{
2177 struct hda_nid_item *item;
2178
2179 if (nid > 0) {
2180 item = snd_array_new(&codec->nids);
2181 if (!item)
2182 return -ENOMEM;
2183 item->kctl = kctl;
2184 item->index = index;
2185 item->nid = nid;
2186 return 0;
2187 }
Takashi Iwai28d1a852010-03-15 09:05:46 +01002188 printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
2189 kctl->id.name, kctl->id.index, index);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002190 return -EINVAL;
2191}
2192EXPORT_SYMBOL_HDA(snd_hda_add_nid);
2193
2194/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01002195 * snd_hda_ctls_clear - Clear all controls assigned to the given codec
2196 * @codec: HD-audio codec
2197 */
Takashi Iwaid13bd412008-07-30 15:01:45 +02002198void snd_hda_ctls_clear(struct hda_codec *codec)
2199{
2200 int i;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002201 struct hda_nid_item *items = codec->mixers.list;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002202 for (i = 0; i < codec->mixers.used; i++)
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002203 snd_ctl_remove(codec->bus->card, items[i].kctl);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002204 snd_array_free(&codec->mixers);
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01002205 snd_array_free(&codec->nids);
Takashi Iwaid13bd412008-07-30 15:01:45 +02002206}
2207
Takashi Iwaia65d6292009-02-23 16:57:04 +01002208/* pseudo device locking
2209 * toggle card->shutdown to allow/disallow the device access (as a hack)
2210 */
2211static int hda_lock_devices(struct snd_card *card)
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002212{
Takashi Iwaia65d6292009-02-23 16:57:04 +01002213 spin_lock(&card->files_lock);
2214 if (card->shutdown) {
2215 spin_unlock(&card->files_lock);
2216 return -EINVAL;
2217 }
2218 card->shutdown = 1;
2219 spin_unlock(&card->files_lock);
2220 return 0;
2221}
2222
2223static void hda_unlock_devices(struct snd_card *card)
2224{
2225 spin_lock(&card->files_lock);
2226 card->shutdown = 0;
2227 spin_unlock(&card->files_lock);
2228}
2229
Takashi Iwaid5191e52009-11-16 14:58:17 +01002230/**
2231 * snd_hda_codec_reset - Clear all objects assigned to the codec
2232 * @codec: HD-audio codec
2233 *
2234 * This frees the all PCM and control elements assigned to the codec, and
2235 * clears the caches and restores the pin default configurations.
2236 *
2237 * When a device is being used, it returns -EBSY. If successfully freed,
2238 * returns zero.
2239 */
Takashi Iwaia65d6292009-02-23 16:57:04 +01002240int snd_hda_codec_reset(struct hda_codec *codec)
2241{
2242 struct snd_card *card = codec->bus->card;
2243 int i, pcm;
2244
2245 if (hda_lock_devices(card) < 0)
2246 return -EBUSY;
2247 /* check whether the codec isn't used by any mixer or PCM streams */
2248 if (!list_empty(&card->ctl_files)) {
2249 hda_unlock_devices(card);
2250 return -EBUSY;
2251 }
2252 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2253 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2254 if (!cpcm->pcm)
2255 continue;
2256 if (cpcm->pcm->streams[0].substream_opened ||
2257 cpcm->pcm->streams[1].substream_opened) {
2258 hda_unlock_devices(card);
2259 return -EBUSY;
2260 }
2261 }
2262
2263 /* OK, let it free */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002264
2265#ifdef CONFIG_SND_HDA_POWER_SAVE
2266 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01002267 flush_workqueue(codec->bus->workq);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002268#endif
2269 snd_hda_ctls_clear(codec);
2270 /* relase PCMs */
2271 for (i = 0; i < codec->num_pcms; i++) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002272 if (codec->pcm_info[i].pcm) {
Takashi Iwaia65d6292009-02-23 16:57:04 +01002273 snd_device_free(card, codec->pcm_info[i].pcm);
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002274 clear_bit(codec->pcm_info[i].device,
2275 codec->bus->pcm_dev_bits);
2276 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002277 }
2278 if (codec->patch_ops.free)
2279 codec->patch_ops.free(codec);
Takashi Iwai1835a0f2011-10-27 22:12:46 +02002280 snd_hda_jack_tbl_clear(codec);
Takashi Iwai56d17712008-11-28 14:36:23 +01002281 codec->proc_widget_hook = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002282 codec->spec = NULL;
2283 free_hda_cache(&codec->amp_cache);
2284 free_hda_cache(&codec->cmd_cache);
Takashi Iwai827057f2008-12-19 10:12:02 +01002285 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
2286 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwai346ff702009-02-23 09:42:57 +01002287 /* free only driver_pins so that init_pins + user_pins are restored */
2288 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01002289 restore_pincfgs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002290 codec->num_pcms = 0;
2291 codec->pcm_info = NULL;
2292 codec->preset = NULL;
Takashi Iwaid1f1af22009-03-02 10:35:29 +01002293 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
2294 codec->slave_dig_outs = NULL;
2295 codec->spdif_status_reset = 0;
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002296 module_put(codec->owner);
2297 codec->owner = NULL;
Takashi Iwaia65d6292009-02-23 16:57:04 +01002298
2299 /* allow device access again */
2300 hda_unlock_devices(card);
2301 return 0;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002302}
2303
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002304typedef int (*map_slave_func_t)(void *, struct snd_kcontrol *);
2305
2306/* apply the function to all matching slave ctls in the mixer list */
2307static int map_slaves(struct hda_codec *codec, const char * const *slaves,
Takashi Iwai9322ca52012-02-03 14:28:01 +01002308 const char *suffix, map_slave_func_t func, void *data)
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002309{
2310 struct hda_nid_item *items;
2311 const char * const *s;
2312 int i, err;
2313
2314 items = codec->mixers.list;
2315 for (i = 0; i < codec->mixers.used; i++) {
2316 struct snd_kcontrol *sctl = items[i].kctl;
2317 if (!sctl || !sctl->id.name ||
2318 sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
2319 continue;
2320 for (s = slaves; *s; s++) {
Takashi Iwai9322ca52012-02-03 14:28:01 +01002321 char tmpname[sizeof(sctl->id.name)];
2322 const char *name = *s;
2323 if (suffix) {
2324 snprintf(tmpname, sizeof(tmpname), "%s %s",
2325 name, suffix);
2326 name = tmpname;
2327 }
Takashi Iwai9322ca52012-02-03 14:28:01 +01002328 if (!strcmp(sctl->id.name, name)) {
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002329 err = func(data, sctl);
2330 if (err)
2331 return err;
2332 break;
2333 }
2334 }
2335 }
2336 return 0;
2337}
2338
2339static int check_slave_present(void *data, struct snd_kcontrol *sctl)
2340{
2341 return 1;
2342}
2343
Takashi Iwai18478e82012-03-09 17:51:10 +01002344/* guess the value corresponding to 0dB */
2345static int get_kctl_0dB_offset(struct snd_kcontrol *kctl)
2346{
2347 int _tlv[4];
2348 const int *tlv = NULL;
2349 int val = -1;
2350
2351 if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
2352 /* FIXME: set_fs() hack for obtaining user-space TLV data */
2353 mm_segment_t fs = get_fs();
2354 set_fs(get_ds());
2355 if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
2356 tlv = _tlv;
2357 set_fs(fs);
2358 } else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
2359 tlv = kctl->tlv.p;
2360 if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE)
2361 val = -tlv[2] / tlv[3];
2362 return val;
2363}
2364
2365/* call kctl->put with the given value(s) */
2366static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
2367{
2368 struct snd_ctl_elem_value *ucontrol;
2369 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
2370 if (!ucontrol)
2371 return -ENOMEM;
2372 ucontrol->value.integer.value[0] = val;
2373 ucontrol->value.integer.value[1] = val;
2374 kctl->put(kctl, ucontrol);
2375 kfree(ucontrol);
2376 return 0;
2377}
2378
2379/* initialize the slave volume with 0dB */
2380static int init_slave_0dB(void *data, struct snd_kcontrol *slave)
2381{
2382 int offset = get_kctl_0dB_offset(slave);
2383 if (offset > 0)
2384 put_kctl_with_value(slave, offset);
2385 return 0;
2386}
2387
2388/* unmute the slave */
2389static int init_slave_unmute(void *data, struct snd_kcontrol *slave)
2390{
2391 return put_kctl_with_value(slave, 1);
2392}
2393
Takashi Iwaid5191e52009-11-16 14:58:17 +01002394/**
2395 * snd_hda_add_vmaster - create a virtual master control and add slaves
2396 * @codec: HD-audio codec
2397 * @name: vmaster control name
2398 * @tlv: TLV data (optional)
2399 * @slaves: slave control names (optional)
Takashi Iwai9322ca52012-02-03 14:28:01 +01002400 * @suffix: suffix string to each slave name (optional)
Takashi Iwai18478e82012-03-09 17:51:10 +01002401 * @init_slave_vol: initialize slaves to unmute/0dB
Takashi Iwai29e58532012-03-12 12:25:03 +01002402 * @ctl_ret: store the vmaster kcontrol in return
Takashi Iwaid5191e52009-11-16 14:58:17 +01002403 *
2404 * Create a virtual master control with the given name. The TLV data
2405 * must be either NULL or a valid data.
2406 *
2407 * @slaves is a NULL-terminated array of strings, each of which is a
2408 * slave control name. All controls with these names are assigned to
2409 * the new virtual master control.
2410 *
2411 * This function returns zero if successful or a negative error code.
2412 */
Takashi Iwai18478e82012-03-09 17:51:10 +01002413int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
Takashi Iwai9322ca52012-02-03 14:28:01 +01002414 unsigned int *tlv, const char * const *slaves,
Takashi Iwai29e58532012-03-12 12:25:03 +01002415 const char *suffix, bool init_slave_vol,
2416 struct snd_kcontrol **ctl_ret)
Takashi Iwai2134ea42008-01-10 16:53:55 +01002417{
2418 struct snd_kcontrol *kctl;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002419 int err;
2420
Takashi Iwai29e58532012-03-12 12:25:03 +01002421 if (ctl_ret)
2422 *ctl_ret = NULL;
2423
Takashi Iwai9322ca52012-02-03 14:28:01 +01002424 err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002425 if (err != 1) {
Takashi Iwai2f085542008-02-22 18:43:50 +01002426 snd_printdd("No slave found for %s\n", name);
2427 return 0;
2428 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01002429 kctl = snd_ctl_make_virtual_master(name, tlv);
2430 if (!kctl)
2431 return -ENOMEM;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01002432 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002433 if (err < 0)
2434 return err;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01002435
Takashi Iwai9322ca52012-02-03 14:28:01 +01002436 err = map_slaves(codec, slaves, suffix,
2437 (map_slave_func_t)snd_ctl_add_slave, kctl);
Takashi Iwaiaeb4b882011-11-10 12:28:38 +01002438 if (err < 0)
2439 return err;
Takashi Iwai18478e82012-03-09 17:51:10 +01002440
2441 /* init with master mute & zero volume */
2442 put_kctl_with_value(kctl, 0);
2443 if (init_slave_vol)
2444 map_slaves(codec, slaves, suffix,
2445 tlv ? init_slave_0dB : init_slave_unmute, kctl);
2446
Takashi Iwai29e58532012-03-12 12:25:03 +01002447 if (ctl_ret)
2448 *ctl_ret = kctl;
Takashi Iwai2134ea42008-01-10 16:53:55 +01002449 return 0;
2450}
Takashi Iwai18478e82012-03-09 17:51:10 +01002451EXPORT_SYMBOL_HDA(__snd_hda_add_vmaster);
Takashi Iwai2134ea42008-01-10 16:53:55 +01002452
Takashi Iwaid2f344b2012-03-12 16:59:58 +01002453/*
2454 * mute-LED control using vmaster
2455 */
2456static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
2457 struct snd_ctl_elem_info *uinfo)
2458{
2459 static const char * const texts[] = {
2460 "Off", "On", "Follow Master"
2461 };
2462 unsigned int index;
2463
2464 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2465 uinfo->count = 1;
2466 uinfo->value.enumerated.items = 3;
2467 index = uinfo->value.enumerated.item;
2468 if (index >= 3)
2469 index = 2;
2470 strcpy(uinfo->value.enumerated.name, texts[index]);
2471 return 0;
2472}
2473
2474static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
2475 struct snd_ctl_elem_value *ucontrol)
2476{
2477 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2478 ucontrol->value.enumerated.item[0] = hook->mute_mode;
2479 return 0;
2480}
2481
2482static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
2483 struct snd_ctl_elem_value *ucontrol)
2484{
2485 struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
2486 unsigned int old_mode = hook->mute_mode;
2487
2488 hook->mute_mode = ucontrol->value.enumerated.item[0];
2489 if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
2490 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
2491 if (old_mode == hook->mute_mode)
2492 return 0;
2493 snd_hda_sync_vmaster_hook(hook);
2494 return 1;
2495}
2496
2497static struct snd_kcontrol_new vmaster_mute_mode = {
2498 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2499 .name = "Mute-LED Mode",
2500 .info = vmaster_mute_mode_info,
2501 .get = vmaster_mute_mode_get,
2502 .put = vmaster_mute_mode_put,
2503};
2504
2505/*
2506 * Add a mute-LED hook with the given vmaster switch kctl
2507 * "Mute-LED Mode" control is automatically created and associated with
2508 * the given hook.
2509 */
2510int snd_hda_add_vmaster_hook(struct hda_codec *codec,
Takashi Iwaif29735c2012-03-13 07:55:10 +01002511 struct hda_vmaster_mute_hook *hook,
2512 bool expose_enum_ctl)
Takashi Iwaid2f344b2012-03-12 16:59:58 +01002513{
2514 struct snd_kcontrol *kctl;
2515
2516 if (!hook->hook || !hook->sw_kctl)
2517 return 0;
2518 snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
2519 hook->codec = codec;
2520 hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
Takashi Iwaif29735c2012-03-13 07:55:10 +01002521 if (!expose_enum_ctl)
2522 return 0;
Takashi Iwaid2f344b2012-03-12 16:59:58 +01002523 kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
2524 if (!kctl)
2525 return -ENOMEM;
2526 return snd_hda_ctl_add(codec, 0, kctl);
2527}
2528EXPORT_SYMBOL_HDA(snd_hda_add_vmaster_hook);
2529
2530/*
2531 * Call the hook with the current value for synchronization
2532 * Should be called in init callback
2533 */
2534void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
2535{
2536 if (!hook->hook || !hook->codec)
2537 return;
2538 switch (hook->mute_mode) {
2539 case HDA_VMUTE_FOLLOW_MASTER:
2540 snd_ctl_sync_vmaster_hook(hook->sw_kctl);
2541 break;
2542 default:
2543 hook->hook(hook->codec, hook->mute_mode);
2544 break;
2545 }
2546}
2547EXPORT_SYMBOL_HDA(snd_hda_sync_vmaster_hook);
2548
2549
Takashi Iwaid5191e52009-11-16 14:58:17 +01002550/**
2551 * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
2552 *
2553 * The control element is supposed to have the private_value field
2554 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2555 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002556int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
2557 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558{
2559 int chs = get_amp_channels(kcontrol);
2560
2561 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2562 uinfo->count = chs == 3 ? 2 : 1;
2563 uinfo->value.integer.min = 0;
2564 uinfo->value.integer.max = 1;
2565 return 0;
2566}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002567EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568
Takashi Iwaid5191e52009-11-16 14:58:17 +01002569/**
2570 * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
2571 *
2572 * The control element is supposed to have the private_value field
2573 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2574 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002575int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
2576 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577{
2578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2579 hda_nid_t nid = get_amp_nid(kcontrol);
2580 int chs = get_amp_channels(kcontrol);
2581 int dir = get_amp_direction(kcontrol);
2582 int idx = get_amp_index(kcontrol);
2583 long *valp = ucontrol->value.integer.value;
2584
2585 if (chs & 1)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002586 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02002587 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 if (chs & 2)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002589 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02002590 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 return 0;
2592}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002593EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594
Takashi Iwaid5191e52009-11-16 14:58:17 +01002595/**
2596 * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
2597 *
2598 * The control element is supposed to have the private_value field
2599 * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
2600 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002601int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
2602 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603{
2604 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2605 hda_nid_t nid = get_amp_nid(kcontrol);
2606 int chs = get_amp_channels(kcontrol);
2607 int dir = get_amp_direction(kcontrol);
2608 int idx = get_amp_index(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 long *valp = ucontrol->value.integer.value;
2610 int change = 0;
2611
Takashi Iwaicb53c622007-08-10 17:21:45 +02002612 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02002613 if (chs & 1) {
Takashi Iwai4a19fae2005-06-08 14:43:58 +02002614 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02002615 HDA_AMP_MUTE,
2616 *valp ? 0 : HDA_AMP_MUTE);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02002617 valp++;
2618 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02002619 if (chs & 2)
2620 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02002621 HDA_AMP_MUTE,
2622 *valp ? 0 : HDA_AMP_MUTE);
Takashi Iwai9e5341b2010-09-21 09:57:06 +02002623 hda_call_check_power_status(codec, nid);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002624 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 return change;
2626}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002627EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628
Takashi Iwai67d634c2009-11-16 15:35:59 +01002629#ifdef CONFIG_SND_HDA_INPUT_BEEP
Takashi Iwaid5191e52009-11-16 14:58:17 +01002630/**
2631 * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
2632 *
2633 * This function calls snd_hda_enable_beep_device(), which behaves differently
2634 * depending on beep_mode option.
2635 */
Jaroslav Kysela123c07a2009-10-21 14:48:23 +02002636int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
2637 struct snd_ctl_elem_value *ucontrol)
2638{
2639 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2640 long *valp = ucontrol->value.integer.value;
2641
2642 snd_hda_enable_beep_device(codec, *valp);
2643 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2644}
2645EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
Takashi Iwai67d634c2009-11-16 15:35:59 +01002646#endif /* CONFIG_SND_HDA_INPUT_BEEP */
Jaroslav Kysela123c07a2009-10-21 14:48:23 +02002647
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648/*
Takashi Iwai985be542005-11-02 18:26:49 +01002649 * bound volume controls
2650 *
2651 * bind multiple volumes (# indices, from 0)
2652 */
2653
2654#define AMP_VAL_IDX_SHIFT 19
2655#define AMP_VAL_IDX_MASK (0x0f<<19)
2656
Takashi Iwaid5191e52009-11-16 14:58:17 +01002657/**
2658 * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
2659 *
2660 * The control element is supposed to have the private_value field
2661 * set up via HDA_BIND_MUTE*() macros.
2662 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002663int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
2664 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01002665{
2666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2667 unsigned long pval;
2668 int err;
2669
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002670 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002671 pval = kcontrol->private_value;
2672 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
2673 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
2674 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002675 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002676 return err;
2677}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002678EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
Takashi Iwai985be542005-11-02 18:26:49 +01002679
Takashi Iwaid5191e52009-11-16 14:58:17 +01002680/**
2681 * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
2682 *
2683 * The control element is supposed to have the private_value field
2684 * set up via HDA_BIND_MUTE*() macros.
2685 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002686int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
2687 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01002688{
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 unsigned long pval;
2691 int i, indices, err = 0, change = 0;
2692
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002693 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002694 pval = kcontrol->private_value;
2695 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
2696 for (i = 0; i < indices; i++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002697 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
2698 (i << AMP_VAL_IDX_SHIFT);
Takashi Iwai985be542005-11-02 18:26:49 +01002699 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2700 if (err < 0)
2701 break;
2702 change |= err;
2703 }
2704 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002705 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01002706 return err < 0 ? err : change;
2707}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002708EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
Takashi Iwai985be542005-11-02 18:26:49 +01002709
Takashi Iwaid5191e52009-11-16 14:58:17 +01002710/**
2711 * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
2712 *
2713 * The control element is supposed to have the private_value field
2714 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
Takashi Iwai532d5382007-07-27 19:02:40 +02002715 */
2716int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
2717 struct snd_ctl_elem_info *uinfo)
2718{
2719 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2720 struct hda_bind_ctls *c;
2721 int err;
2722
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002723 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002724 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002725 kcontrol->private_value = *c->values;
2726 err = c->ops->info(kcontrol, uinfo);
2727 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002728 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002729 return err;
2730}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002731EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
Takashi Iwai532d5382007-07-27 19:02:40 +02002732
Takashi Iwaid5191e52009-11-16 14:58:17 +01002733/**
2734 * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
2735 *
2736 * The control element is supposed to have the private_value field
2737 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2738 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002739int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
2740 struct snd_ctl_elem_value *ucontrol)
2741{
2742 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2743 struct hda_bind_ctls *c;
2744 int err;
2745
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002746 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002747 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002748 kcontrol->private_value = *c->values;
2749 err = c->ops->get(kcontrol, ucontrol);
2750 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002751 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002752 return err;
2753}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002754EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
Takashi Iwai532d5382007-07-27 19:02:40 +02002755
Takashi Iwaid5191e52009-11-16 14:58:17 +01002756/**
2757 * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
2758 *
2759 * The control element is supposed to have the private_value field
2760 * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
2761 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002762int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
2763 struct snd_ctl_elem_value *ucontrol)
2764{
2765 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2766 struct hda_bind_ctls *c;
2767 unsigned long *vals;
2768 int err = 0, change = 0;
2769
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002770 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002771 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002772 for (vals = c->values; *vals; vals++) {
2773 kcontrol->private_value = *vals;
2774 err = c->ops->put(kcontrol, ucontrol);
2775 if (err < 0)
2776 break;
2777 change |= err;
2778 }
2779 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002780 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002781 return err < 0 ? err : change;
2782}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002783EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
Takashi Iwai532d5382007-07-27 19:02:40 +02002784
Takashi Iwaid5191e52009-11-16 14:58:17 +01002785/**
2786 * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
2787 *
2788 * The control element is supposed to have the private_value field
2789 * set up via HDA_BIND_VOL() macro.
2790 */
Takashi Iwai532d5382007-07-27 19:02:40 +02002791int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2792 unsigned int size, unsigned int __user *tlv)
2793{
2794 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2795 struct hda_bind_ctls *c;
2796 int err;
2797
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002798 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01002799 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02002800 kcontrol->private_value = *c->values;
2801 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
2802 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08002803 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02002804 return err;
2805}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002806EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
Takashi Iwai532d5382007-07-27 19:02:40 +02002807
2808struct hda_ctl_ops snd_hda_bind_vol = {
2809 .info = snd_hda_mixer_amp_volume_info,
2810 .get = snd_hda_mixer_amp_volume_get,
2811 .put = snd_hda_mixer_amp_volume_put,
2812 .tlv = snd_hda_mixer_amp_tlv
2813};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002814EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
Takashi Iwai532d5382007-07-27 19:02:40 +02002815
2816struct hda_ctl_ops snd_hda_bind_sw = {
2817 .info = snd_hda_mixer_amp_switch_info,
2818 .get = snd_hda_mixer_amp_switch_get,
2819 .put = snd_hda_mixer_amp_switch_put,
2820 .tlv = snd_hda_mixer_amp_tlv
2821};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002822EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
Takashi Iwai532d5382007-07-27 19:02:40 +02002823
2824/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 * SPDIF out controls
2826 */
2827
Takashi Iwai0ba21762007-04-16 11:29:14 +02002828static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
2829 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830{
2831 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2832 uinfo->count = 1;
2833 return 0;
2834}
2835
Takashi Iwai0ba21762007-04-16 11:29:14 +02002836static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
2837 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838{
2839 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2840 IEC958_AES0_NONAUDIO |
2841 IEC958_AES0_CON_EMPHASIS_5015 |
2842 IEC958_AES0_CON_NOT_COPYRIGHT;
2843 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
2844 IEC958_AES1_CON_ORIGINAL;
2845 return 0;
2846}
2847
Takashi Iwai0ba21762007-04-16 11:29:14 +02002848static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
2849 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850{
2851 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
2852 IEC958_AES0_NONAUDIO |
2853 IEC958_AES0_PRO_EMPHASIS_5015;
2854 return 0;
2855}
2856
Takashi Iwai0ba21762007-04-16 11:29:14 +02002857static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
2858 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859{
2860 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c9359762011-06-01 11:14:17 -06002861 int idx = kcontrol->private_value;
2862 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863
Stephen Warren7c9359762011-06-01 11:14:17 -06002864 ucontrol->value.iec958.status[0] = spdif->status & 0xff;
2865 ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
2866 ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
2867 ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868
2869 return 0;
2870}
2871
2872/* convert from SPDIF status bits to HDA SPDIF bits
2873 * bit 0 (DigEn) is always set zero (to be filled later)
2874 */
2875static unsigned short convert_from_spdif_status(unsigned int sbits)
2876{
2877 unsigned short val = 0;
2878
2879 if (sbits & IEC958_AES0_PROFESSIONAL)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002880 val |= AC_DIG1_PROFESSIONAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 if (sbits & IEC958_AES0_NONAUDIO)
Takashi Iwai0ba21762007-04-16 11:29:14 +02002882 val |= AC_DIG1_NONAUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002884 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
2885 IEC958_AES0_PRO_EMPHASIS_5015)
2886 val |= AC_DIG1_EMPHASIS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002888 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
2889 IEC958_AES0_CON_EMPHASIS_5015)
2890 val |= AC_DIG1_EMPHASIS;
2891 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
2892 val |= AC_DIG1_COPYRIGHT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
Takashi Iwai0ba21762007-04-16 11:29:14 +02002894 val |= AC_DIG1_LEVEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
2896 }
2897 return val;
2898}
2899
2900/* convert to SPDIF status bits from HDA SPDIF bits
2901 */
2902static unsigned int convert_to_spdif_status(unsigned short val)
2903{
2904 unsigned int sbits = 0;
2905
Takashi Iwai0ba21762007-04-16 11:29:14 +02002906 if (val & AC_DIG1_NONAUDIO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 sbits |= IEC958_AES0_NONAUDIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002908 if (val & AC_DIG1_PROFESSIONAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 sbits |= IEC958_AES0_PROFESSIONAL;
2910 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002911 if (sbits & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
2913 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002914 if (val & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002916 if (!(val & AC_DIG1_COPYRIGHT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002918 if (val & AC_DIG1_LEVEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
2920 sbits |= val & (0x7f << 8);
2921 }
2922 return sbits;
2923}
2924
Takashi Iwai2f728532008-09-25 16:32:41 +02002925/* set digital convert verbs both for the given NID and its slaves */
2926static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2927 int verb, int val)
2928{
Takashi Iwaidda14412011-05-02 11:29:30 +02002929 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02002930
Takashi Iwai9e976972008-11-25 08:17:20 +01002931 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002932 d = codec->slave_dig_outs;
2933 if (!d)
2934 return;
2935 for (; *d; d++)
Takashi Iwai9e976972008-11-25 08:17:20 +01002936 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02002937}
2938
2939static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2940 int dig1, int dig2)
2941{
2942 if (dig1 != -1)
2943 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2944 if (dig2 != -1)
2945 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2946}
2947
Takashi Iwai0ba21762007-04-16 11:29:14 +02002948static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2949 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950{
2951 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c9359762011-06-01 11:14:17 -06002952 int idx = kcontrol->private_value;
2953 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
2954 hda_nid_t nid = spdif->nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 unsigned short val;
2956 int change;
2957
Ingo Molnar62932df2006-01-16 16:34:20 +01002958 mutex_lock(&codec->spdif_mutex);
Stephen Warren7c9359762011-06-01 11:14:17 -06002959 spdif->status = ucontrol->value.iec958.status[0] |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2961 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2962 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
Stephen Warren7c9359762011-06-01 11:14:17 -06002963 val = convert_from_spdif_status(spdif->status);
2964 val |= spdif->ctls & 1;
2965 change = spdif->ctls != val;
2966 spdif->ctls = val;
Stephen Warren74b654c2011-06-01 11:14:18 -06002967 if (change && nid != (u16)-1)
Takashi Iwai2f728532008-09-25 16:32:41 +02002968 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
Ingo Molnar62932df2006-01-16 16:34:20 +01002969 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 return change;
2971}
2972
Takashi Iwaia5ce8892007-07-23 15:42:26 +02002973#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974
Takashi Iwai0ba21762007-04-16 11:29:14 +02002975static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2976 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977{
2978 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c9359762011-06-01 11:14:17 -06002979 int idx = kcontrol->private_value;
2980 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981
Stephen Warren7c9359762011-06-01 11:14:17 -06002982 ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 return 0;
2984}
2985
Stephen Warren74b654c2011-06-01 11:14:18 -06002986static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
2987 int dig1, int dig2)
2988{
2989 set_dig_out_convert(codec, nid, dig1, dig2);
2990 /* unmute amp switch (if any) */
2991 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
2992 (dig1 & AC_DIG1_ENABLE))
2993 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2994 HDA_AMP_MUTE, 0);
2995}
2996
Takashi Iwai0ba21762007-04-16 11:29:14 +02002997static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2998 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999{
3000 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
Stephen Warren7c9359762011-06-01 11:14:17 -06003001 int idx = kcontrol->private_value;
3002 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3003 hda_nid_t nid = spdif->nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 unsigned short val;
3005 int change;
3006
Ingo Molnar62932df2006-01-16 16:34:20 +01003007 mutex_lock(&codec->spdif_mutex);
Stephen Warren7c9359762011-06-01 11:14:17 -06003008 val = spdif->ctls & ~AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009 if (ucontrol->value.integer.value[0])
Takashi Iwai0ba21762007-04-16 11:29:14 +02003010 val |= AC_DIG1_ENABLE;
Stephen Warren7c9359762011-06-01 11:14:17 -06003011 change = spdif->ctls != val;
Stephen Warren74b654c2011-06-01 11:14:18 -06003012 spdif->ctls = val;
3013 if (change && nid != (u16)-1)
3014 set_spdif_ctls(codec, nid, val & 0xff, -1);
Ingo Molnar62932df2006-01-16 16:34:20 +01003015 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 return change;
3017}
3018
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003019static struct snd_kcontrol_new dig_mixes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 {
3021 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003023 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 .info = snd_hda_spdif_mask_info,
3025 .get = snd_hda_spdif_cmask_get,
3026 },
3027 {
3028 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3029 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003030 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 .info = snd_hda_spdif_mask_info,
3032 .get = snd_hda_spdif_pmask_get,
3033 },
3034 {
3035 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003036 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 .info = snd_hda_spdif_mask_info,
3038 .get = snd_hda_spdif_default_get,
3039 .put = snd_hda_spdif_default_put,
3040 },
3041 {
3042 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003043 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044 .info = snd_hda_spdif_out_switch_info,
3045 .get = snd_hda_spdif_out_switch_get,
3046 .put = snd_hda_spdif_out_switch_put,
3047 },
3048 { } /* end */
3049};
3050
3051/**
3052 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
3053 * @codec: the HDA codec
3054 * @nid: audio out widget NID
3055 *
3056 * Creates controls related with the SPDIF output.
3057 * Called from each patch supporting the SPDIF out.
3058 *
3059 * Returns 0 if successful, or a negative error code.
3060 */
Stephen Warren74b654c2011-06-01 11:14:18 -06003061int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
3062 hda_nid_t associated_nid,
3063 hda_nid_t cvt_nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003064{
3065 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003066 struct snd_kcontrol *kctl;
3067 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01003068 int idx;
Stephen Warren7c9359762011-06-01 11:14:17 -06003069 struct hda_spdif_out *spdif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070
Takashi Iwai1afe2062010-12-23 10:17:52 +01003071 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
3072 if (idx < 0) {
Takashi Iwai09f99702008-02-04 12:31:13 +01003073 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
3074 return -EBUSY;
3075 }
Stephen Warren7c9359762011-06-01 11:14:17 -06003076 spdif = snd_array_new(&codec->spdif_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
3078 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaib91f0802008-11-04 08:43:08 +01003079 if (!kctl)
3080 return -ENOMEM;
Takashi Iwai09f99702008-02-04 12:31:13 +01003081 kctl->id.index = idx;
Stephen Warren7c9359762011-06-01 11:14:17 -06003082 kctl->private_value = codec->spdif_out.used - 1;
Stephen Warren74b654c2011-06-01 11:14:18 -06003083 err = snd_hda_ctl_add(codec, associated_nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003084 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 return err;
3086 }
Stephen Warren74b654c2011-06-01 11:14:18 -06003087 spdif->nid = cvt_nid;
3088 spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
Stephen Warren7c9359762011-06-01 11:14:17 -06003089 AC_VERB_GET_DIGI_CONVERT_1, 0);
3090 spdif->status = convert_to_spdif_status(spdif->ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091 return 0;
3092}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003093EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094
Stephen Warren7c9359762011-06-01 11:14:17 -06003095struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
3096 hda_nid_t nid)
3097{
3098 int i;
3099 for (i = 0; i < codec->spdif_out.used; i++) {
3100 struct hda_spdif_out *spdif =
3101 snd_array_elem(&codec->spdif_out, i);
3102 if (spdif->nid == nid)
3103 return spdif;
3104 }
3105 return NULL;
3106}
3107EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
3108
Stephen Warren74b654c2011-06-01 11:14:18 -06003109void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
3110{
3111 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3112
3113 mutex_lock(&codec->spdif_mutex);
3114 spdif->nid = (u16)-1;
3115 mutex_unlock(&codec->spdif_mutex);
3116}
3117EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
3118
3119void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
3120{
3121 struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
3122 unsigned short val;
3123
3124 mutex_lock(&codec->spdif_mutex);
3125 if (spdif->nid != nid) {
3126 spdif->nid = nid;
3127 val = spdif->ctls;
3128 set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
3129 }
3130 mutex_unlock(&codec->spdif_mutex);
3131}
3132EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
3133
Linus Torvalds1da177e2005-04-16 15:20:36 -07003134/*
Takashi Iwai9a081602008-02-12 18:37:26 +01003135 * SPDIF sharing with analog output
3136 */
3137static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
3138 struct snd_ctl_elem_value *ucontrol)
3139{
3140 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3141 ucontrol->value.integer.value[0] = mout->share_spdif;
3142 return 0;
3143}
3144
3145static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
3146 struct snd_ctl_elem_value *ucontrol)
3147{
3148 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
3149 mout->share_spdif = !!ucontrol->value.integer.value[0];
3150 return 0;
3151}
3152
3153static struct snd_kcontrol_new spdif_share_sw = {
3154 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3155 .name = "IEC958 Default PCM Playback Switch",
3156 .info = snd_ctl_boolean_mono_info,
3157 .get = spdif_share_sw_get,
3158 .put = spdif_share_sw_put,
3159};
3160
Takashi Iwaid5191e52009-11-16 14:58:17 +01003161/**
3162 * snd_hda_create_spdif_share_sw - create Default PCM switch
3163 * @codec: the HDA codec
3164 * @mout: multi-out instance
3165 */
Takashi Iwai9a081602008-02-12 18:37:26 +01003166int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
3167 struct hda_multi_out *mout)
3168{
3169 if (!mout->dig_out_nid)
3170 return 0;
3171 /* ATTENTION: here mout is passed as private_data, instead of codec */
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01003172 return snd_hda_ctl_add(codec, mout->dig_out_nid,
3173 snd_ctl_new1(&spdif_share_sw, mout));
Takashi Iwai9a081602008-02-12 18:37:26 +01003174}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003175EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
Takashi Iwai9a081602008-02-12 18:37:26 +01003176
3177/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 * SPDIF input
3179 */
3180
3181#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
3182
Takashi Iwai0ba21762007-04-16 11:29:14 +02003183static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
3184 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003185{
3186 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3187
3188 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
3189 return 0;
3190}
3191
Takashi Iwai0ba21762007-04-16 11:29:14 +02003192static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
3193 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194{
3195 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3196 hda_nid_t nid = kcontrol->private_value;
3197 unsigned int val = !!ucontrol->value.integer.value[0];
3198 int change;
3199
Ingo Molnar62932df2006-01-16 16:34:20 +01003200 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 change = codec->spdif_in_enable != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003202 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 codec->spdif_in_enable = val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003204 snd_hda_codec_write_cache(codec, nid, 0,
3205 AC_VERB_SET_DIGI_CONVERT_1, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003207 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 return change;
3209}
3210
Takashi Iwai0ba21762007-04-16 11:29:14 +02003211static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
3212 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213{
3214 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3215 hda_nid_t nid = kcontrol->private_value;
3216 unsigned short val;
3217 unsigned int sbits;
3218
Andrew Paprocki3982d172007-12-19 12:13:44 +01003219 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220 sbits = convert_to_spdif_status(val);
3221 ucontrol->value.iec958.status[0] = sbits;
3222 ucontrol->value.iec958.status[1] = sbits >> 8;
3223 ucontrol->value.iec958.status[2] = sbits >> 16;
3224 ucontrol->value.iec958.status[3] = sbits >> 24;
3225 return 0;
3226}
3227
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003228static struct snd_kcontrol_new dig_in_ctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 {
3230 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003231 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 .info = snd_hda_spdif_in_switch_info,
3233 .get = snd_hda_spdif_in_switch_get,
3234 .put = snd_hda_spdif_in_switch_put,
3235 },
3236 {
3237 .access = SNDRV_CTL_ELEM_ACCESS_READ,
3238 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003239 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 .info = snd_hda_spdif_mask_info,
3241 .get = snd_hda_spdif_in_status_get,
3242 },
3243 { } /* end */
3244};
3245
3246/**
3247 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
3248 * @codec: the HDA codec
3249 * @nid: audio in widget NID
3250 *
3251 * Creates controls related with the SPDIF input.
3252 * Called from each patch supporting the SPDIF in.
3253 *
3254 * Returns 0 if successful, or a negative error code.
3255 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003256int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257{
3258 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003259 struct snd_kcontrol *kctl;
3260 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01003261 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262
Takashi Iwai1afe2062010-12-23 10:17:52 +01003263 idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch");
3264 if (idx < 0) {
Takashi Iwai09f99702008-02-04 12:31:13 +01003265 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
3266 return -EBUSY;
3267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003268 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
3269 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaic8dcdf82009-02-06 16:21:20 +01003270 if (!kctl)
3271 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272 kctl->private_value = nid;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01003273 err = snd_hda_ctl_add(codec, nid, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003274 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275 return err;
3276 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02003277 codec->spdif_in_enable =
Andrew Paprocki3982d172007-12-19 12:13:44 +01003278 snd_hda_codec_read(codec, nid, 0,
3279 AC_VERB_GET_DIGI_CONVERT_1, 0) &
Takashi Iwai0ba21762007-04-16 11:29:14 +02003280 AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 return 0;
3282}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003283EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284
Takashi Iwai2a439522011-07-26 09:52:50 +02003285#ifdef CONFIG_PM
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003286/*
3287 * command cache
3288 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003290/* build a 32bit cache key with the widget id and the command parameter */
3291#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
3292#define get_cmd_cache_nid(key) ((key) & 0xff)
3293#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
3294
3295/**
3296 * snd_hda_codec_write_cache - send a single command with caching
3297 * @codec: the HDA codec
3298 * @nid: NID to send the command
3299 * @direct: direct flag
3300 * @verb: the verb to send
3301 * @parm: the parameter for the verb
3302 *
3303 * Send a single command without waiting for response.
3304 *
3305 * Returns 0 if successful, or a negative error code.
3306 */
3307int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
3308 int direct, unsigned int verb, unsigned int parm)
3309{
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02003310 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
3311 struct hda_cache_head *c;
3312 u32 key;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003313
Takashi Iwaiaa2936f2009-05-26 16:07:57 +02003314 if (err < 0)
3315 return err;
3316 /* parm may contain the verb stuff for get/set amp */
3317 verb = verb | (parm >> 8);
3318 parm &= 0xff;
3319 key = build_cmd_cache_key(nid, verb);
3320 mutex_lock(&codec->bus->cmd_mutex);
3321 c = get_alloc_hash(&codec->cmd_cache, key);
3322 if (c)
3323 c->val = parm;
3324 mutex_unlock(&codec->bus->cmd_mutex);
3325 return 0;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003326}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003327EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003328
Takashi Iwaid5191e52009-11-16 14:58:17 +01003329/**
Takashi Iwaia68d5a52010-03-30 18:03:44 +02003330 * snd_hda_codec_update_cache - check cache and write the cmd only when needed
3331 * @codec: the HDA codec
3332 * @nid: NID to send the command
3333 * @direct: direct flag
3334 * @verb: the verb to send
3335 * @parm: the parameter for the verb
3336 *
3337 * This function works like snd_hda_codec_write_cache(), but it doesn't send
3338 * command if the parameter is already identical with the cached value.
3339 * If not, it sends the command and refreshes the cache.
3340 *
3341 * Returns 0 if successful, or a negative error code.
3342 */
3343int snd_hda_codec_update_cache(struct hda_codec *codec, hda_nid_t nid,
3344 int direct, unsigned int verb, unsigned int parm)
3345{
3346 struct hda_cache_head *c;
3347 u32 key;
3348
3349 /* parm may contain the verb stuff for get/set amp */
3350 verb = verb | (parm >> 8);
3351 parm &= 0xff;
3352 key = build_cmd_cache_key(nid, verb);
3353 mutex_lock(&codec->bus->cmd_mutex);
3354 c = get_hash(&codec->cmd_cache, key);
3355 if (c && c->val == parm) {
3356 mutex_unlock(&codec->bus->cmd_mutex);
3357 return 0;
3358 }
3359 mutex_unlock(&codec->bus->cmd_mutex);
3360 return snd_hda_codec_write_cache(codec, nid, direct, verb, parm);
3361}
3362EXPORT_SYMBOL_HDA(snd_hda_codec_update_cache);
3363
3364/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01003365 * snd_hda_codec_resume_cache - Resume the all commands from the cache
3366 * @codec: HD-audio codec
3367 *
3368 * Execute all verbs recorded in the command caches to resume.
3369 */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003370void snd_hda_codec_resume_cache(struct hda_codec *codec)
3371{
Takashi Iwai603c4012008-07-30 15:01:44 +02003372 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003373 int i;
3374
Takashi Iwai603c4012008-07-30 15:01:44 +02003375 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003376 u32 key = buffer->key;
3377 if (!key)
3378 continue;
3379 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
3380 get_cmd_cache_cmd(key), buffer->val);
3381 }
3382}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003383EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003384
3385/**
3386 * snd_hda_sequence_write_cache - sequence writes with caching
3387 * @codec: the HDA codec
3388 * @seq: VERB array to send
3389 *
3390 * Send the commands sequentially from the given array.
3391 * Thte commands are recorded on cache for power-save and resume.
3392 * The array must be terminated with NID=0.
3393 */
3394void snd_hda_sequence_write_cache(struct hda_codec *codec,
3395 const struct hda_verb *seq)
3396{
3397 for (; seq->nid; seq++)
3398 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
3399 seq->param);
3400}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003401EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
Takashi Iwai2a439522011-07-26 09:52:50 +02003402#endif /* CONFIG_PM */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02003403
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003404void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
3405 unsigned int power_state,
3406 bool eapd_workaround)
Takashi Iwai54d17402005-11-21 16:33:22 +01003407{
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003408 hda_nid_t nid = codec->start_nid;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003409 int i;
Takashi Iwai54d17402005-11-21 16:33:22 +01003410
Takashi Iwaicb53c622007-08-10 17:21:45 +02003411 for (i = 0; i < codec->num_nodes; i++, nid++) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01003412 unsigned int wcaps = get_wcaps(codec, nid);
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003413 if (!(wcaps & AC_WCAP_POWER))
3414 continue;
3415 /* don't power down the widget if it controls eapd and
3416 * EAPD_BTLENABLE is set.
3417 */
3418 if (eapd_workaround && power_state == AC_PWRST_D3 &&
3419 get_wcaps_type(wcaps) == AC_WID_PIN &&
3420 (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
3421 int eapd = snd_hda_codec_read(codec, nid, 0,
Takashi Iwai7eba5c92007-11-14 14:53:42 +01003422 AC_VERB_GET_EAPD_BTLENABLE, 0);
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003423 if (eapd & 0x02)
3424 continue;
Takashi Iwai1194b5b2007-10-10 10:04:26 +02003425 }
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003426 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
3427 power_state);
Takashi Iwai54d17402005-11-21 16:33:22 +01003428 }
3429
Takashi Iwaicb53c622007-08-10 17:21:45 +02003430 if (power_state == AC_PWRST_D0) {
3431 unsigned long end_time;
3432 int state;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003433 /* wait until the codec reachs to D0 */
3434 end_time = jiffies + msecs_to_jiffies(500);
3435 do {
3436 state = snd_hda_codec_read(codec, fg, 0,
3437 AC_VERB_GET_POWER_STATE, 0);
3438 if (state == power_state)
3439 break;
3440 msleep(1);
3441 } while (time_after_eq(end_time, jiffies));
3442 }
Takashi Iwai54d17402005-11-21 16:33:22 +01003443}
Takashi Iwai4d7fbdb2011-07-26 10:33:10 +02003444EXPORT_SYMBOL_HDA(snd_hda_codec_set_power_to_all);
3445
3446/*
3447 * set power state of the codec
3448 */
3449static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3450 unsigned int power_state)
3451{
3452 if (codec->patch_ops.set_power_state) {
3453 codec->patch_ops.set_power_state(codec, fg, power_state);
3454 return;
3455 }
3456
3457 /* this delay seems necessary to avoid click noise at power-down */
3458 if (power_state == AC_PWRST_D3)
3459 msleep(100);
3460 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
3461 power_state);
3462 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
3463}
Takashi Iwai54d17402005-11-21 16:33:22 +01003464
Takashi Iwai11aeff02008-07-30 15:01:46 +02003465#ifdef CONFIG_SND_HDA_HWDEP
3466/* execute additional init verbs */
3467static void hda_exec_init_verbs(struct hda_codec *codec)
3468{
3469 if (codec->init_verbs.list)
3470 snd_hda_sequence_write(codec, codec->init_verbs.list);
3471}
3472#else
3473static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
3474#endif
3475
Takashi Iwai2a439522011-07-26 09:52:50 +02003476#ifdef CONFIG_PM
Takashi Iwaicb53c622007-08-10 17:21:45 +02003477/*
3478 * call suspend and power-down; used both from PM and power-save
3479 */
3480static void hda_call_codec_suspend(struct hda_codec *codec)
3481{
3482 if (codec->patch_ops.suspend)
3483 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
Takashi Iwaieb541332010-08-06 13:48:11 +02003484 hda_cleanup_all_streams(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003485 hda_set_power_state(codec,
3486 codec->afg ? codec->afg : codec->mfg,
3487 AC_PWRST_D3);
3488#ifdef CONFIG_SND_HDA_POWER_SAVE
Takashi Iwaia2f63092009-11-11 09:34:25 +01003489 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003490 cancel_delayed_work(&codec->power_work);
Takashi Iwai95e99fd2007-08-13 15:29:04 +02003491 codec->power_on = 0;
Takashi Iwaia221e282007-08-16 16:35:33 +02003492 codec->power_transition = 0;
Takashi Iwaia2f63092009-11-11 09:34:25 +01003493 codec->power_jiffies = jiffies;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003494#endif
3495}
3496
3497/*
3498 * kick up codec; used both from PM and power-save
3499 */
3500static void hda_call_codec_resume(struct hda_codec *codec)
3501{
3502 hda_set_power_state(codec,
3503 codec->afg ? codec->afg : codec->mfg,
3504 AC_PWRST_D0);
Takashi Iwai3be14142009-02-20 14:11:16 +01003505 restore_pincfgs(codec); /* restore all current pin configs */
Takashi Iwaiac0547d2010-07-05 16:50:13 +02003506 restore_shutup_pins(codec);
Takashi Iwai11aeff02008-07-30 15:01:46 +02003507 hda_exec_init_verbs(codec);
Takashi Iwai1835a0f2011-10-27 22:12:46 +02003508 snd_hda_jack_set_dirty_all(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003509 if (codec->patch_ops.resume)
3510 codec->patch_ops.resume(codec);
3511 else {
Takashi Iwai9d99f312007-08-14 15:15:52 +02003512 if (codec->patch_ops.init)
3513 codec->patch_ops.init(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003514 snd_hda_codec_resume_amp(codec);
3515 snd_hda_codec_resume_cache(codec);
3516 }
3517}
Takashi Iwai2a439522011-07-26 09:52:50 +02003518#endif /* CONFIG_PM */
Takashi Iwaicb53c622007-08-10 17:21:45 +02003519
Takashi Iwai54d17402005-11-21 16:33:22 +01003520
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521/**
3522 * snd_hda_build_controls - build mixer controls
3523 * @bus: the BUS
3524 *
3525 * Creates mixer controls for each codec included in the bus.
3526 *
3527 * Returns 0 if successful, otherwise a negative error code.
3528 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003529int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003531 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532
Takashi Iwai0ba21762007-04-16 11:29:14 +02003533 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003534 int err = snd_hda_codec_build_controls(codec);
Takashi Iwaif93d4612009-03-02 10:44:15 +01003535 if (err < 0) {
Takashi Iwai28d1a852010-03-15 09:05:46 +01003536 printk(KERN_ERR "hda_codec: cannot build controls "
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003537 "for #%d (error %d)\n", codec->addr, err);
Takashi Iwaif93d4612009-03-02 10:44:15 +01003538 err = snd_hda_codec_reset(codec);
3539 if (err < 0) {
3540 printk(KERN_ERR
3541 "hda_codec: cannot revert codec\n");
3542 return err;
3543 }
3544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003546 return 0;
3547}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003548EXPORT_SYMBOL_HDA(snd_hda_build_controls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003550int snd_hda_codec_build_controls(struct hda_codec *codec)
3551{
3552 int err = 0;
Takashi Iwai11aeff02008-07-30 15:01:46 +02003553 hda_exec_init_verbs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003554 /* continue to initialize... */
3555 if (codec->patch_ops.init)
3556 err = codec->patch_ops.init(codec);
3557 if (!err && codec->patch_ops.build_controls)
3558 err = codec->patch_ops.build_controls(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003559 if (err < 0)
3560 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561 return 0;
3562}
3563
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564/*
3565 * stream formats
3566 */
Takashi Iwaibefdf312005-08-22 13:57:55 +02003567struct hda_rate_tbl {
3568 unsigned int hz;
3569 unsigned int alsa_bits;
3570 unsigned int hda_fmt;
3571};
3572
Takashi Iwai92f10b32010-08-03 14:21:00 +02003573/* rate = base * mult / div */
3574#define HDA_RATE(base, mult, div) \
3575 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
3576 (((div) - 1) << AC_FMT_DIV_SHIFT))
3577
Takashi Iwaibefdf312005-08-22 13:57:55 +02003578static struct hda_rate_tbl rate_bits[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 /* rate in Hz, ALSA rate bitmask, HDA format value */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02003580
3581 /* autodetected value used in snd_hda_query_supported_pcm */
Takashi Iwai92f10b32010-08-03 14:21:00 +02003582 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
3583 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
3584 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
3585 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
3586 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
3587 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
3588 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
3589 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
3590 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
3591 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
3592 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003593#define AC_PAR_PCM_RATE_BITS 11
3594 /* up to bits 10, 384kHZ isn't supported properly */
3595
3596 /* not autodetected value */
Takashi Iwai92f10b32010-08-03 14:21:00 +02003597 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02003598
Takashi Iwaibefdf312005-08-22 13:57:55 +02003599 { 0 } /* terminator */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600};
3601
3602/**
3603 * snd_hda_calc_stream_format - calculate format bitset
3604 * @rate: the sample rate
3605 * @channels: the number of channels
3606 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
3607 * @maxbps: the max. bps
3608 *
3609 * Calculate the format bitset from the given rate, channels and th PCM format.
3610 *
3611 * Return zero if invalid.
3612 */
3613unsigned int snd_hda_calc_stream_format(unsigned int rate,
3614 unsigned int channels,
3615 unsigned int format,
Anssi Hannula32c168c2010-08-03 13:28:57 +03003616 unsigned int maxbps,
3617 unsigned short spdif_ctls)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003618{
3619 int i;
3620 unsigned int val = 0;
3621
Takashi Iwaibefdf312005-08-22 13:57:55 +02003622 for (i = 0; rate_bits[i].hz; i++)
3623 if (rate_bits[i].hz == rate) {
3624 val = rate_bits[i].hda_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625 break;
3626 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02003627 if (!rate_bits[i].hz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628 snd_printdd("invalid rate %d\n", rate);
3629 return 0;
3630 }
3631
3632 if (channels == 0 || channels > 8) {
3633 snd_printdd("invalid channels %d\n", channels);
3634 return 0;
3635 }
3636 val |= channels - 1;
3637
3638 switch (snd_pcm_format_width(format)) {
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003639 case 8:
Takashi Iwai92f10b32010-08-03 14:21:00 +02003640 val |= AC_FMT_BITS_8;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003641 break;
3642 case 16:
Takashi Iwai92f10b32010-08-03 14:21:00 +02003643 val |= AC_FMT_BITS_16;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01003644 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645 case 20:
3646 case 24:
3647 case 32:
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02003648 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003649 val |= AC_FMT_BITS_32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650 else if (maxbps >= 24)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003651 val |= AC_FMT_BITS_24;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652 else
Takashi Iwai92f10b32010-08-03 14:21:00 +02003653 val |= AC_FMT_BITS_20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 break;
3655 default:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003656 snd_printdd("invalid format width %d\n",
3657 snd_pcm_format_width(format));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658 return 0;
3659 }
3660
Anssi Hannula32c168c2010-08-03 13:28:57 +03003661 if (spdif_ctls & AC_DIG1_NONAUDIO)
Takashi Iwai92f10b32010-08-03 14:21:00 +02003662 val |= AC_FMT_TYPE_NON_PCM;
Anssi Hannula32c168c2010-08-03 13:28:57 +03003663
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 return val;
3665}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003666EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003667
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003668static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3669{
3670 unsigned int val = 0;
3671 if (nid != codec->afg &&
3672 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
3673 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
3674 if (!val || val == -1)
3675 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
3676 if (!val || val == -1)
3677 return 0;
3678 return val;
3679}
3680
3681static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
3682{
3683 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
3684 get_pcm_param);
3685}
3686
3687static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
3688{
3689 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
3690 if (!streams || streams == -1)
3691 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
3692 if (!streams || streams == -1)
3693 return 0;
3694 return streams;
3695}
3696
3697static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
3698{
3699 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
3700 get_stream_param);
3701}
3702
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703/**
3704 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
3705 * @codec: the HDA codec
3706 * @nid: NID to query
3707 * @ratesp: the pointer to store the detected rate bitflags
3708 * @formatsp: the pointer to store the detected formats
3709 * @bpsp: the pointer to store the detected format widths
3710 *
3711 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
3712 * or @bsps argument is ignored.
3713 *
3714 * Returns 0 if successful, otherwise a negative error code.
3715 */
Stephen Warren384a48d2011-06-01 11:14:21 -06003716int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003717 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
3718{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003719 unsigned int i, val, wcaps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003721 wcaps = get_wcaps(codec, nid);
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003722 val = query_pcm_param(codec, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003723
3724 if (ratesp) {
3725 u32 rates = 0;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003726 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003727 if (val & (1 << i))
Takashi Iwaibefdf312005-08-22 13:57:55 +02003728 rates |= rate_bits[i].alsa_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003729 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003730 if (rates == 0) {
3731 snd_printk(KERN_ERR "hda_codec: rates == 0 "
3732 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
3733 nid, val,
3734 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
3735 return -EIO;
3736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003737 *ratesp = rates;
3738 }
3739
3740 if (formatsp || bpsp) {
3741 u64 formats = 0;
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003742 unsigned int streams, bps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003744 streams = query_stream_param(codec, nid);
3745 if (!streams)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003746 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003747
3748 bps = 0;
3749 if (streams & AC_SUPFMT_PCM) {
3750 if (val & AC_SUPPCM_BITS_8) {
3751 formats |= SNDRV_PCM_FMTBIT_U8;
3752 bps = 8;
3753 }
3754 if (val & AC_SUPPCM_BITS_16) {
3755 formats |= SNDRV_PCM_FMTBIT_S16_LE;
3756 bps = 16;
3757 }
3758 if (wcaps & AC_WCAP_DIGITAL) {
3759 if (val & AC_SUPPCM_BITS_32)
3760 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
3761 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
3762 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3763 if (val & AC_SUPPCM_BITS_24)
3764 bps = 24;
3765 else if (val & AC_SUPPCM_BITS_20)
3766 bps = 20;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003767 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
3768 AC_SUPPCM_BITS_32)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003769 formats |= SNDRV_PCM_FMTBIT_S32_LE;
3770 if (val & AC_SUPPCM_BITS_32)
3771 bps = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 else if (val & AC_SUPPCM_BITS_24)
3773 bps = 24;
Nicolas Graziano33ef76512006-09-19 14:23:14 +02003774 else if (val & AC_SUPPCM_BITS_20)
3775 bps = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 }
3777 }
Takashi Iwaib5025c52009-07-01 18:05:27 +02003778 if (streams & AC_SUPFMT_FLOAT32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003779 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
Takashi Iwaib0bb3aa2009-07-03 23:25:37 +02003780 if (!bps)
3781 bps = 32;
Takashi Iwaib5025c52009-07-01 18:05:27 +02003782 }
3783 if (streams == AC_SUPFMT_AC3) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02003784 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003785 /* temporary hack: we have still no proper support
3786 * for the direct AC3 stream...
3787 */
3788 formats |= SNDRV_PCM_FMTBIT_U8;
3789 bps = 8;
3790 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003791 if (formats == 0) {
3792 snd_printk(KERN_ERR "hda_codec: formats == 0 "
3793 "(nid=0x%x, val=0x%x, ovrd=%i, "
3794 "streams=0x%x)\n",
3795 nid, val,
3796 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
3797 streams);
3798 return -EIO;
3799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003800 if (formatsp)
3801 *formatsp = formats;
3802 if (bpsp)
3803 *bpsp = bps;
3804 }
3805
3806 return 0;
3807}
Stephen Warren384a48d2011-06-01 11:14:21 -06003808EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809
3810/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01003811 * snd_hda_is_supported_format - Check the validity of the format
3812 * @codec: HD-audio codec
3813 * @nid: NID to check
3814 * @format: the HD-audio format value to check
3815 *
3816 * Check whether the given node supports the format value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003817 *
3818 * Returns 1 if supported, 0 if not.
3819 */
3820int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
3821 unsigned int format)
3822{
3823 int i;
3824 unsigned int val = 0, rate, stream;
3825
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003826 val = query_pcm_param(codec, nid);
3827 if (!val)
3828 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829
3830 rate = format & 0xff00;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003831 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
Takashi Iwaibefdf312005-08-22 13:57:55 +02003832 if (rate_bits[i].hda_fmt == rate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833 if (val & (1 << i))
3834 break;
3835 return 0;
3836 }
Takashi Iwaia961f9f2007-04-12 13:08:09 +02003837 if (i >= AC_PAR_PCM_RATE_BITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 return 0;
3839
Takashi Iwai92c7c8a2009-03-24 07:32:14 +01003840 stream = query_stream_param(codec, nid);
3841 if (!stream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 return 0;
3843
3844 if (stream & AC_SUPFMT_PCM) {
3845 switch (format & 0xf0) {
3846 case 0x00:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003847 if (!(val & AC_SUPPCM_BITS_8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848 return 0;
3849 break;
3850 case 0x10:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003851 if (!(val & AC_SUPPCM_BITS_16))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003852 return 0;
3853 break;
3854 case 0x20:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003855 if (!(val & AC_SUPPCM_BITS_20))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003856 return 0;
3857 break;
3858 case 0x30:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003859 if (!(val & AC_SUPPCM_BITS_24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 return 0;
3861 break;
3862 case 0x40:
Takashi Iwai0ba21762007-04-16 11:29:14 +02003863 if (!(val & AC_SUPPCM_BITS_32))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003864 return 0;
3865 break;
3866 default:
3867 return 0;
3868 }
3869 } else {
3870 /* FIXME: check for float32 and AC3? */
3871 }
3872
3873 return 1;
3874}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003875EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003876
3877/*
3878 * PCM stuff
3879 */
3880static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
3881 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003882 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003883{
3884 return 0;
3885}
3886
3887static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
3888 struct hda_codec *codec,
3889 unsigned int stream_tag,
3890 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003891 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892{
3893 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3894 return 0;
3895}
3896
3897static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
3898 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003899 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003900{
Takashi Iwai888afa12008-03-18 09:57:50 +01003901 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 return 0;
3903}
3904
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02003905static int set_pcm_default_values(struct hda_codec *codec,
3906 struct hda_pcm_stream *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003907{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003908 int err;
3909
Takashi Iwai0ba21762007-04-16 11:29:14 +02003910 /* query support PCM information from the given NID */
3911 if (info->nid && (!info->rates || !info->formats)) {
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003912 err = snd_hda_query_supported_pcm(codec, info->nid,
Takashi Iwai0ba21762007-04-16 11:29:14 +02003913 info->rates ? NULL : &info->rates,
3914 info->formats ? NULL : &info->formats,
3915 info->maxbps ? NULL : &info->maxbps);
Jaroslav Kyselaee504712009-03-17 14:30:31 +01003916 if (err < 0)
3917 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003918 }
3919 if (info->ops.open == NULL)
3920 info->ops.open = hda_pcm_default_open_close;
3921 if (info->ops.close == NULL)
3922 info->ops.close = hda_pcm_default_open_close;
3923 if (info->ops.prepare == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003924 if (snd_BUG_ON(!info->nid))
3925 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926 info->ops.prepare = hda_pcm_default_prepare;
3927 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003928 if (info->ops.cleanup == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02003929 if (snd_BUG_ON(!info->nid))
3930 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003931 info->ops.cleanup = hda_pcm_default_cleanup;
3932 }
3933 return 0;
3934}
3935
Takashi Iwaieb541332010-08-06 13:48:11 +02003936/*
3937 * codec prepare/cleanup entries
3938 */
3939int snd_hda_codec_prepare(struct hda_codec *codec,
3940 struct hda_pcm_stream *hinfo,
3941 unsigned int stream,
3942 unsigned int format,
3943 struct snd_pcm_substream *substream)
3944{
3945 int ret;
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003946 mutex_lock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003947 ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
3948 if (ret >= 0)
3949 purify_inactive_streams(codec);
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003950 mutex_unlock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003951 return ret;
3952}
3953EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
3954
3955void snd_hda_codec_cleanup(struct hda_codec *codec,
3956 struct hda_pcm_stream *hinfo,
3957 struct snd_pcm_substream *substream)
3958{
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003959 mutex_lock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003960 hinfo->ops.cleanup(hinfo, codec, substream);
Takashi Iwai3f50ac62010-08-20 09:44:36 +02003961 mutex_unlock(&codec->bus->prepare_mutex);
Takashi Iwaieb541332010-08-06 13:48:11 +02003962}
3963EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
3964
Takashi Iwaid5191e52009-11-16 14:58:17 +01003965/* global */
Jaroslav Kyselae3303232009-11-10 14:53:02 +01003966const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
3967 "Audio", "SPDIF", "HDMI", "Modem"
3968};
3969
Takashi Iwai176d5332008-07-30 15:01:44 +02003970/*
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003971 * get the empty PCM device number to assign
Takashi Iwaic8936222010-01-28 17:08:53 +01003972 *
3973 * note the max device number is limited by HDA_MAX_PCMS, currently 10
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003974 */
3975static int get_empty_pcm_device(struct hda_bus *bus, int type)
3976{
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003977 /* audio device indices; not linear to keep compatibility */
3978 static int audio_idx[HDA_PCM_NTYPES][5] = {
3979 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
3980 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
Wu Fengguang92608ba2009-10-30 11:40:03 +01003981 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003982 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003983 };
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003984 int i;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003985
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003986 if (type >= HDA_PCM_NTYPES) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01003987 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
3988 return -EINVAL;
3989 }
Wu Fengguangf5d6def2009-10-30 11:38:26 +01003990
3991 for (i = 0; audio_idx[type][i] >= 0 ; i++)
3992 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
3993 return audio_idx[type][i];
3994
Takashi Iwai01b65bf2011-11-24 14:31:46 +01003995 /* non-fixed slots starting from 10 */
3996 for (i = 10; i < 32; i++) {
3997 if (!test_and_set_bit(i, bus->pcm_dev_bits))
3998 return i;
3999 }
4000
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004001 snd_printk(KERN_WARNING "Too many %s devices\n",
4002 snd_hda_pcm_type_name[type]);
Wu Fengguangf5d6def2009-10-30 11:38:26 +01004003 return -EAGAIN;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004004}
4005
4006/*
Takashi Iwai176d5332008-07-30 15:01:44 +02004007 * attach a new PCM stream
4008 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004009static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
Takashi Iwai176d5332008-07-30 15:01:44 +02004010{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004011 struct hda_bus *bus = codec->bus;
Takashi Iwai176d5332008-07-30 15:01:44 +02004012 struct hda_pcm_stream *info;
4013 int stream, err;
4014
Takashi Iwaib91f0802008-11-04 08:43:08 +01004015 if (snd_BUG_ON(!pcm->name))
Takashi Iwai176d5332008-07-30 15:01:44 +02004016 return -EINVAL;
4017 for (stream = 0; stream < 2; stream++) {
4018 info = &pcm->stream[stream];
4019 if (info->substreams) {
4020 err = set_pcm_default_values(codec, info);
4021 if (err < 0)
4022 return err;
4023 }
4024 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004025 return bus->ops.attach_pcm(bus, codec, pcm);
Takashi Iwai176d5332008-07-30 15:01:44 +02004026}
4027
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004028/* assign all PCMs of the given codec */
4029int snd_hda_codec_build_pcms(struct hda_codec *codec)
4030{
4031 unsigned int pcm;
4032 int err;
4033
4034 if (!codec->num_pcms) {
4035 if (!codec->patch_ops.build_pcms)
4036 return 0;
4037 err = codec->patch_ops.build_pcms(codec);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01004038 if (err < 0) {
4039 printk(KERN_ERR "hda_codec: cannot build PCMs"
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004040 "for #%d (error %d)\n", codec->addr, err);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01004041 err = snd_hda_codec_reset(codec);
4042 if (err < 0) {
4043 printk(KERN_ERR
4044 "hda_codec: cannot revert codec\n");
4045 return err;
4046 }
4047 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004048 }
4049 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
4050 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
4051 int dev;
4052
4053 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
Takashi Iwai41b5b012009-01-20 18:21:23 +01004054 continue; /* no substreams assigned */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004055
4056 if (!cpcm->pcm) {
4057 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
4058 if (dev < 0)
Takashi Iwai6e655bf2009-03-02 10:46:03 +01004059 continue; /* no fatal error */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004060 cpcm->device = dev;
4061 err = snd_hda_attach_pcm(codec, cpcm);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01004062 if (err < 0) {
4063 printk(KERN_ERR "hda_codec: cannot attach "
4064 "PCM stream %d for codec #%d\n",
4065 dev, codec->addr);
4066 continue; /* no fatal error */
4067 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004068 }
4069 }
4070 return 0;
4071}
4072
Linus Torvalds1da177e2005-04-16 15:20:36 -07004073/**
4074 * snd_hda_build_pcms - build PCM information
4075 * @bus: the BUS
4076 *
4077 * Create PCM information for each codec included in the bus.
4078 *
4079 * The build_pcms codec patch is requested to set up codec->num_pcms and
4080 * codec->pcm_info properly. The array is referred by the top-level driver
4081 * to create its PCM instances.
4082 * The allocated codec->pcm_info should be released in codec->patch_ops.free
4083 * callback.
4084 *
4085 * At least, substreams, channels_min and channels_max must be filled for
4086 * each stream. substreams = 0 indicates that the stream doesn't exist.
4087 * When rates and/or formats are zero, the supported values are queried
4088 * from the given nid. The nid is used also by the default ops.prepare
4089 * and ops.cleanup callbacks.
4090 *
4091 * The driver needs to call ops.open in its open callback. Similarly,
4092 * ops.close is supposed to be called in the close callback.
4093 * ops.prepare should be called in the prepare or hw_params callback
4094 * with the proper parameters for set up.
4095 * ops.cleanup should be called in hw_free for clean up of streams.
4096 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004097 * This function returns 0 if successful, or a negative error code.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004098 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004099int __devinit snd_hda_build_pcms(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100{
Takashi Iwai0ba21762007-04-16 11:29:14 +02004101 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102
Takashi Iwai0ba21762007-04-16 11:29:14 +02004103 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01004104 int err = snd_hda_codec_build_pcms(codec);
4105 if (err < 0)
4106 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004107 }
4108 return 0;
4109}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004110EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004111
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112/**
4113 * snd_hda_check_board_config - compare the current codec with the config table
4114 * @codec: the HDA codec
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004115 * @num_configs: number of config enums
4116 * @models: array of model name strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 * @tbl: configuration table, terminated by null entries
4118 *
4119 * Compares the modelname or PCI subsystem id of the current codec with the
4120 * given configuration table. If a matching entry is found, returns its
4121 * config value (supposed to be 0 or positive).
4122 *
4123 * If no entries are matching, the function returns a negative value.
4124 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02004125int snd_hda_check_board_config(struct hda_codec *codec,
Takashi Iwaiea734962011-01-17 11:29:34 +01004126 int num_configs, const char * const *models,
Takashi Iwai12f288b2007-08-02 15:51:59 +02004127 const struct snd_pci_quirk *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004128{
Takashi Iwaif44ac832008-07-30 15:01:45 +02004129 if (codec->modelname && models) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004130 int i;
4131 for (i = 0; i < num_configs; i++) {
4132 if (models[i] &&
Takashi Iwaif44ac832008-07-30 15:01:45 +02004133 !strcmp(codec->modelname, models[i])) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004134 snd_printd(KERN_INFO "hda_codec: model '%s' is "
4135 "selected\n", models[i]);
4136 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004137 }
4138 }
4139 }
4140
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004141 if (!codec->bus->pci || !tbl)
4142 return -1;
4143
4144 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
4145 if (!tbl)
4146 return -1;
4147 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwai62cf8722008-05-20 12:15:15 +02004148#ifdef CONFIG_SND_DEBUG_VERBOSE
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004149 char tmp[10];
4150 const char *model = NULL;
4151 if (models)
4152 model = models[tbl->value];
4153 if (!model) {
4154 sprintf(tmp, "#%d", tbl->value);
4155 model = tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004156 }
Takashi Iwaif5fcc132006-11-24 17:07:44 +01004157 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4158 "for config %x:%x (%s)\n",
4159 model, tbl->subvendor, tbl->subdevice,
4160 (tbl->name ? tbl->name : "Unknown device"));
4161#endif
4162 return tbl->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004163 }
4164 return -1;
4165}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004166EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004167
4168/**
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004169 * snd_hda_check_board_codec_sid_config - compare the current codec
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004170 subsystem ID with the
4171 config table
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004172
4173 This is important for Gateway notebooks with SB450 HDA Audio
4174 where the vendor ID of the PCI device is:
4175 ATI Technologies Inc SB450 HDA Audio [1002:437b]
4176 and the vendor/subvendor are found only at the codec.
4177
4178 * @codec: the HDA codec
4179 * @num_configs: number of config enums
4180 * @models: array of model name strings
4181 * @tbl: configuration table, terminated by null entries
4182 *
4183 * Compares the modelname or PCI subsystem id of the current codec with the
4184 * given configuration table. If a matching entry is found, returns its
4185 * config value (supposed to be 0 or positive).
4186 *
4187 * If no entries are matching, the function returns a negative value.
4188 */
4189int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
Takashi Iwaiea734962011-01-17 11:29:34 +01004190 int num_configs, const char * const *models,
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004191 const struct snd_pci_quirk *tbl)
4192{
4193 const struct snd_pci_quirk *q;
4194
4195 /* Search for codec ID */
4196 for (q = tbl; q->subvendor; q++) {
Takashi Iwaie2301a42011-11-22 19:58:56 +01004197 unsigned int mask = 0xffff0000 | q->subdevice_mask;
4198 unsigned int id = (q->subdevice | (q->subvendor << 16)) & mask;
4199 if ((codec->subsystem_id & mask) == id)
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004200 break;
4201 }
4202
4203 if (!q->subvendor)
4204 return -1;
4205
4206 tbl = q;
4207
4208 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwaid94ff6b2009-09-02 00:20:21 +02004209#ifdef CONFIG_SND_DEBUG_VERBOSE
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02004210 char tmp[10];
4211 const char *model = NULL;
4212 if (models)
4213 model = models[tbl->value];
4214 if (!model) {
4215 sprintf(tmp, "#%d", tbl->value);
4216 model = tmp;
4217 }
4218 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
4219 "for config %x:%x (%s)\n",
4220 model, tbl->subvendor, tbl->subdevice,
4221 (tbl->name ? tbl->name : "Unknown device"));
4222#endif
4223 return tbl->value;
4224 }
4225 return -1;
4226}
4227EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
4228
4229/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004230 * snd_hda_add_new_ctls - create controls from the array
4231 * @codec: the HDA codec
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01004232 * @knew: the array of struct snd_kcontrol_new
Linus Torvalds1da177e2005-04-16 15:20:36 -07004233 *
4234 * This helper function creates and add new controls in the given array.
4235 * The array must be terminated with an empty entry as terminator.
4236 *
4237 * Returns 0 if successful, or a negative error code.
4238 */
Takashi Iwai031024e2011-05-02 11:29:30 +02004239int snd_hda_add_new_ctls(struct hda_codec *codec,
4240 const struct snd_kcontrol_new *knew)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004241{
Jaroslav Kysela4d02d1b2009-11-12 10:15:48 +01004242 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004243
4244 for (; knew->name; knew++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004245 struct snd_kcontrol *kctl;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004246 int addr = 0, idx = 0;
Jaroslav Kysela5b0cb1d2009-12-08 16:13:32 +01004247 if (knew->iface == -1) /* skip this codec private value */
4248 continue;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004249 for (;;) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004250 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02004251 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01004252 return -ENOMEM;
Takashi Iwai1afe2062010-12-23 10:17:52 +01004253 if (addr > 0)
4254 kctl->id.device = addr;
4255 if (idx > 0)
4256 kctl->id.index = idx;
Jaroslav Kysela3911a4c2009-11-11 13:43:01 +01004257 err = snd_hda_ctl_add(codec, 0, kctl);
Takashi Iwai1afe2062010-12-23 10:17:52 +01004258 if (!err)
4259 break;
4260 /* try first with another device index corresponding to
4261 * the codec addr; if it still fails (or it's the
4262 * primary codec), then try another control index
4263 */
4264 if (!addr && codec->addr)
4265 addr = codec->addr;
4266 else if (!idx && !knew->index) {
4267 idx = find_empty_mixer_ctl_idx(codec,
4268 knew->name);
4269 if (idx <= 0)
4270 return err;
4271 } else
Takashi Iwai54d17402005-11-21 16:33:22 +01004272 return err;
4273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004274 }
4275 return 0;
4276}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004277EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004278
Takashi Iwaicb53c622007-08-10 17:21:45 +02004279#ifdef CONFIG_SND_HDA_POWER_SAVE
Takashi Iwaicb53c622007-08-10 17:21:45 +02004280static void hda_power_work(struct work_struct *work)
4281{
4282 struct hda_codec *codec =
4283 container_of(work, struct hda_codec, power_work.work);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004284 struct hda_bus *bus = codec->bus;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004285
Maxim Levitsky2e492462007-09-03 15:26:57 +02004286 if (!codec->power_on || codec->power_count) {
4287 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004288 return;
Maxim Levitsky2e492462007-09-03 15:26:57 +02004289 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02004290
Takashi Iwaid66fee52011-08-02 15:39:31 +02004291 trace_hda_power_down(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004292 hda_call_codec_suspend(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004293 if (bus->ops.pm_notify)
4294 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004295}
4296
4297static void hda_keep_power_on(struct hda_codec *codec)
4298{
4299 codec->power_count++;
4300 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01004301 codec->power_jiffies = jiffies;
4302}
4303
Takashi Iwaid5191e52009-11-16 14:58:17 +01004304/* update the power on/off account with the current jiffies */
Takashi Iwaia2f63092009-11-11 09:34:25 +01004305void snd_hda_update_power_acct(struct hda_codec *codec)
4306{
4307 unsigned long delta = jiffies - codec->power_jiffies;
4308 if (codec->power_on)
4309 codec->power_on_acct += delta;
4310 else
4311 codec->power_off_acct += delta;
4312 codec->power_jiffies += delta;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004313}
4314
Takashi Iwaid5191e52009-11-16 14:58:17 +01004315/**
4316 * snd_hda_power_up - Power-up the codec
4317 * @codec: HD-audio codec
4318 *
4319 * Increment the power-up counter and power up the hardware really when
4320 * not turned on yet.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004321 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004322void snd_hda_power_up(struct hda_codec *codec)
4323{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004324 struct hda_bus *bus = codec->bus;
4325
Takashi Iwaicb53c622007-08-10 17:21:45 +02004326 codec->power_count++;
Takashi Iwaia221e282007-08-16 16:35:33 +02004327 if (codec->power_on || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004328 return;
4329
Takashi Iwaid66fee52011-08-02 15:39:31 +02004330 trace_hda_power_up(codec);
Takashi Iwaia2f63092009-11-11 09:34:25 +01004331 snd_hda_update_power_acct(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004332 codec->power_on = 1;
Takashi Iwaia2f63092009-11-11 09:34:25 +01004333 codec->power_jiffies = jiffies;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01004334 if (bus->ops.pm_notify)
4335 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004336 hda_call_codec_resume(codec);
4337 cancel_delayed_work(&codec->power_work);
Takashi Iwaia221e282007-08-16 16:35:33 +02004338 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004339}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004340EXPORT_SYMBOL_HDA(snd_hda_power_up);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01004341
4342#define power_save(codec) \
4343 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004344
Takashi Iwaid5191e52009-11-16 14:58:17 +01004345/**
4346 * snd_hda_power_down - Power-down the codec
4347 * @codec: HD-audio codec
4348 *
4349 * Decrement the power-up counter and schedules the power-off work if
4350 * the counter rearches to zero.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004351 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004352void snd_hda_power_down(struct hda_codec *codec)
4353{
4354 --codec->power_count;
Takashi Iwaia221e282007-08-16 16:35:33 +02004355 if (!codec->power_on || codec->power_count || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02004356 return;
Takashi Iwaifee2fba2008-11-27 12:43:28 +01004357 if (power_save(codec)) {
Takashi Iwaia221e282007-08-16 16:35:33 +02004358 codec->power_transition = 1; /* avoid reentrance */
Takashi Iwaic107b412009-01-13 17:46:37 +01004359 queue_delayed_work(codec->bus->workq, &codec->power_work,
Takashi Iwaifee2fba2008-11-27 12:43:28 +01004360 msecs_to_jiffies(power_save(codec) * 1000));
Takashi Iwaia221e282007-08-16 16:35:33 +02004361 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02004362}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004363EXPORT_SYMBOL_HDA(snd_hda_power_down);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004364
Takashi Iwaid5191e52009-11-16 14:58:17 +01004365/**
4366 * snd_hda_check_amp_list_power - Check the amp list and update the power
4367 * @codec: HD-audio codec
4368 * @check: the object containing an AMP list and the status
4369 * @nid: NID to check / update
4370 *
4371 * Check whether the given NID is in the amp list. If it's in the list,
4372 * check the current AMP status, and update the the power-status according
4373 * to the mute status.
4374 *
4375 * This function is supposed to be set or called from the check_power_status
4376 * patch ops.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004377 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02004378int snd_hda_check_amp_list_power(struct hda_codec *codec,
4379 struct hda_loopback_check *check,
4380 hda_nid_t nid)
4381{
Takashi Iwai031024e2011-05-02 11:29:30 +02004382 const struct hda_amp_list *p;
Takashi Iwaicb53c622007-08-10 17:21:45 +02004383 int ch, v;
4384
4385 if (!check->amplist)
4386 return 0;
4387 for (p = check->amplist; p->nid; p++) {
4388 if (p->nid == nid)
4389 break;
4390 }
4391 if (!p->nid)
4392 return 0; /* nothing changed */
4393
4394 for (p = check->amplist; p->nid; p++) {
4395 for (ch = 0; ch < 2; ch++) {
4396 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
4397 p->idx);
4398 if (!(v & HDA_AMP_MUTE) && v > 0) {
4399 if (!check->power_on) {
4400 check->power_on = 1;
4401 snd_hda_power_up(codec);
4402 }
4403 return 1;
4404 }
4405 }
4406 }
4407 if (check->power_on) {
4408 check->power_on = 0;
4409 snd_hda_power_down(codec);
4410 }
4411 return 0;
4412}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004413EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
Takashi Iwaicb53c622007-08-10 17:21:45 +02004414#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07004415
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01004416/*
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004417 * Channel mode helper
4418 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01004419
4420/**
4421 * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
4422 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004423int snd_hda_ch_mode_info(struct hda_codec *codec,
4424 struct snd_ctl_elem_info *uinfo,
4425 const struct hda_channel_mode *chmode,
4426 int num_chmodes)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004427{
4428 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4429 uinfo->count = 1;
4430 uinfo->value.enumerated.items = num_chmodes;
4431 if (uinfo->value.enumerated.item >= num_chmodes)
4432 uinfo->value.enumerated.item = num_chmodes - 1;
4433 sprintf(uinfo->value.enumerated.name, "%dch",
4434 chmode[uinfo->value.enumerated.item].channels);
4435 return 0;
4436}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004437EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004438
Takashi Iwaid5191e52009-11-16 14:58:17 +01004439/**
4440 * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
4441 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004442int snd_hda_ch_mode_get(struct hda_codec *codec,
4443 struct snd_ctl_elem_value *ucontrol,
4444 const struct hda_channel_mode *chmode,
4445 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004446 int max_channels)
4447{
4448 int i;
4449
4450 for (i = 0; i < num_chmodes; i++) {
4451 if (max_channels == chmode[i].channels) {
4452 ucontrol->value.enumerated.item[0] = i;
4453 break;
4454 }
4455 }
4456 return 0;
4457}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004458EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004459
Takashi Iwaid5191e52009-11-16 14:58:17 +01004460/**
4461 * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
4462 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004463int snd_hda_ch_mode_put(struct hda_codec *codec,
4464 struct snd_ctl_elem_value *ucontrol,
4465 const struct hda_channel_mode *chmode,
4466 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004467 int *max_channelsp)
4468{
4469 unsigned int mode;
4470
4471 mode = ucontrol->value.enumerated.item[0];
Takashi Iwai68ea7b22007-11-15 15:54:38 +01004472 if (mode >= num_chmodes)
4473 return -EINVAL;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004474 if (*max_channelsp == chmode[mode].channels)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004475 return 0;
4476 /* change the current channel setting */
4477 *max_channelsp = chmode[mode].channels;
4478 if (chmode[mode].sequence)
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004479 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004480 return 1;
4481}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004482EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01004483
Linus Torvalds1da177e2005-04-16 15:20:36 -07004484/*
4485 * input MUX helper
4486 */
Takashi Iwaid5191e52009-11-16 14:58:17 +01004487
4488/**
4489 * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
4490 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004491int snd_hda_input_mux_info(const struct hda_input_mux *imux,
4492 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493{
4494 unsigned int index;
4495
4496 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4497 uinfo->count = 1;
4498 uinfo->value.enumerated.items = imux->num_items;
Takashi Iwai5513b0c2007-10-09 11:58:41 +02004499 if (!imux->num_items)
4500 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501 index = uinfo->value.enumerated.item;
4502 if (index >= imux->num_items)
4503 index = imux->num_items - 1;
4504 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
4505 return 0;
4506}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004507EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004508
Takashi Iwaid5191e52009-11-16 14:58:17 +01004509/**
4510 * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
4511 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004512int snd_hda_input_mux_put(struct hda_codec *codec,
4513 const struct hda_input_mux *imux,
4514 struct snd_ctl_elem_value *ucontrol,
4515 hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004516 unsigned int *cur_val)
4517{
4518 unsigned int idx;
4519
Takashi Iwai5513b0c2007-10-09 11:58:41 +02004520 if (!imux->num_items)
4521 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004522 idx = ucontrol->value.enumerated.item[0];
4523 if (idx >= imux->num_items)
4524 idx = imux->num_items - 1;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004525 if (*cur_val == idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004526 return 0;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02004527 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
4528 imux->items[idx].index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529 *cur_val = idx;
4530 return 1;
4531}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004532EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004533
4534
4535/*
4536 * Multi-channel / digital-out PCM helper functions
4537 */
4538
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004539/* setup SPDIF output stream */
4540static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
4541 unsigned int stream_tag, unsigned int format)
4542{
Stephen Warren7c9359762011-06-01 11:14:17 -06004543 struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
4544
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004545 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
Stephen Warren7c9359762011-06-01 11:14:17 -06004546 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004547 set_dig_out_convert(codec, nid,
Stephen Warren7c9359762011-06-01 11:14:17 -06004548 spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
Takashi Iwai2f728532008-09-25 16:32:41 +02004549 -1);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004550 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
Takashi Iwai2f728532008-09-25 16:32:41 +02004551 if (codec->slave_dig_outs) {
Takashi Iwaidda14412011-05-02 11:29:30 +02004552 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02004553 for (d = codec->slave_dig_outs; *d; d++)
4554 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
4555 format);
Matthew Ranostayde51ca12008-09-07 14:31:40 -04004556 }
Takashi Iwai2f728532008-09-25 16:32:41 +02004557 /* turn on again (if needed) */
Stephen Warren7c9359762011-06-01 11:14:17 -06004558 if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
Takashi Iwai2f728532008-09-25 16:32:41 +02004559 set_dig_out_convert(codec, nid,
Stephen Warren7c9359762011-06-01 11:14:17 -06004560 spdif->ctls & 0xff, -1);
Takashi Iwai2f728532008-09-25 16:32:41 +02004561}
Matthew Ranostayde51ca12008-09-07 14:31:40 -04004562
Takashi Iwai2f728532008-09-25 16:32:41 +02004563static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
4564{
4565 snd_hda_codec_cleanup_stream(codec, nid);
4566 if (codec->slave_dig_outs) {
Takashi Iwaidda14412011-05-02 11:29:30 +02004567 const hda_nid_t *d;
Takashi Iwai2f728532008-09-25 16:32:41 +02004568 for (d = codec->slave_dig_outs; *d; d++)
4569 snd_hda_codec_cleanup_stream(codec, *d);
4570 }
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004571}
4572
Takashi Iwaid5191e52009-11-16 14:58:17 +01004573/**
4574 * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
4575 * @bus: HD-audio bus
4576 */
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004577void snd_hda_bus_reboot_notify(struct hda_bus *bus)
4578{
4579 struct hda_codec *codec;
4580
4581 if (!bus)
4582 return;
4583 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwaie581f3d2011-07-26 10:19:20 +02004584 if (hda_codec_is_power_on(codec) &&
4585 codec->patch_ops.reboot_notify)
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004586 codec->patch_ops.reboot_notify(codec);
4587 }
4588}
Takashi Iwai8f217a22009-11-10 18:26:12 +01004589EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
Takashi Iwaifb8d1a32009-11-10 16:02:29 +01004590
Takashi Iwaid5191e52009-11-16 14:58:17 +01004591/**
4592 * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004594int snd_hda_multi_out_dig_open(struct hda_codec *codec,
4595 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596{
Ingo Molnar62932df2006-01-16 16:34:20 +01004597 mutex_lock(&codec->spdif_mutex);
Takashi Iwai5930ca42007-04-16 11:23:56 +02004598 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
4599 /* already opened as analog dup; reset it once */
Takashi Iwai2f728532008-09-25 16:32:41 +02004600 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
Ingo Molnar62932df2006-01-16 16:34:20 +01004602 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004603 return 0;
4604}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004605EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606
Takashi Iwaid5191e52009-11-16 14:58:17 +01004607/**
4608 * snd_hda_multi_out_dig_prepare - prepare the digital out stream
4609 */
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004610int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
4611 struct hda_multi_out *mout,
4612 unsigned int stream_tag,
4613 unsigned int format,
4614 struct snd_pcm_substream *substream)
4615{
4616 mutex_lock(&codec->spdif_mutex);
4617 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
4618 mutex_unlock(&codec->spdif_mutex);
4619 return 0;
4620}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004621EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004622
Takashi Iwaid5191e52009-11-16 14:58:17 +01004623/**
4624 * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
4625 */
Takashi Iwai9411e212009-02-13 11:32:28 +01004626int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
4627 struct hda_multi_out *mout)
4628{
4629 mutex_lock(&codec->spdif_mutex);
4630 cleanup_dig_out_stream(codec, mout->dig_out_nid);
4631 mutex_unlock(&codec->spdif_mutex);
4632 return 0;
4633}
4634EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
4635
Takashi Iwaid5191e52009-11-16 14:58:17 +01004636/**
4637 * snd_hda_multi_out_dig_close - release the digital out stream
Linus Torvalds1da177e2005-04-16 15:20:36 -07004638 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004639int snd_hda_multi_out_dig_close(struct hda_codec *codec,
4640 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004641{
Ingo Molnar62932df2006-01-16 16:34:20 +01004642 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 mout->dig_out_used = 0;
Ingo Molnar62932df2006-01-16 16:34:20 +01004644 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004645 return 0;
4646}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004647EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004648
Takashi Iwaid5191e52009-11-16 14:58:17 +01004649/**
4650 * snd_hda_multi_out_analog_open - open analog outputs
4651 *
4652 * Open analog outputs and set up the hw-constraints.
4653 * If the digital outputs can be opened as slave, open the digital
4654 * outputs, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004655 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004656int snd_hda_multi_out_analog_open(struct hda_codec *codec,
4657 struct hda_multi_out *mout,
Takashi Iwai9a081602008-02-12 18:37:26 +01004658 struct snd_pcm_substream *substream,
4659 struct hda_pcm_stream *hinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004660{
Takashi Iwai9a081602008-02-12 18:37:26 +01004661 struct snd_pcm_runtime *runtime = substream->runtime;
4662 runtime->hw.channels_max = mout->max_channels;
4663 if (mout->dig_out_nid) {
4664 if (!mout->analog_rates) {
4665 mout->analog_rates = hinfo->rates;
4666 mout->analog_formats = hinfo->formats;
4667 mout->analog_maxbps = hinfo->maxbps;
4668 } else {
4669 runtime->hw.rates = mout->analog_rates;
4670 runtime->hw.formats = mout->analog_formats;
4671 hinfo->maxbps = mout->analog_maxbps;
4672 }
4673 if (!mout->spdif_rates) {
4674 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
4675 &mout->spdif_rates,
4676 &mout->spdif_formats,
4677 &mout->spdif_maxbps);
4678 }
4679 mutex_lock(&codec->spdif_mutex);
4680 if (mout->share_spdif) {
Takashi Iwai022b4662009-07-03 23:03:30 +02004681 if ((runtime->hw.rates & mout->spdif_rates) &&
4682 (runtime->hw.formats & mout->spdif_formats)) {
4683 runtime->hw.rates &= mout->spdif_rates;
4684 runtime->hw.formats &= mout->spdif_formats;
4685 if (mout->spdif_maxbps < hinfo->maxbps)
4686 hinfo->maxbps = mout->spdif_maxbps;
4687 } else {
4688 mout->share_spdif = 0;
4689 /* FIXME: need notify? */
4690 }
Takashi Iwai9a081602008-02-12 18:37:26 +01004691 }
Frederik Deweerdteaa99852008-04-14 13:11:44 +02004692 mutex_unlock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01004693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004694 return snd_pcm_hw_constraint_step(substream->runtime, 0,
4695 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
4696}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004697EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004698
Takashi Iwaid5191e52009-11-16 14:58:17 +01004699/**
4700 * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
4701 *
4702 * Set up the i/o for analog out.
4703 * When the digital out is available, copy the front out to digital out, too.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004705int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
4706 struct hda_multi_out *mout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004707 unsigned int stream_tag,
4708 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01004709 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004710{
Takashi Iwaidda14412011-05-02 11:29:30 +02004711 const hda_nid_t *nids = mout->dac_nids;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004712 int chs = substream->runtime->channels;
Stephen Warren7c9359762011-06-01 11:14:17 -06004713 struct hda_spdif_out *spdif =
4714 snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004715 int i;
4716
Ingo Molnar62932df2006-01-16 16:34:20 +01004717 mutex_lock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01004718 if (mout->dig_out_nid && mout->share_spdif &&
4719 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004720 if (chs == 2 &&
Takashi Iwai0ba21762007-04-16 11:29:14 +02004721 snd_hda_is_supported_format(codec, mout->dig_out_nid,
4722 format) &&
Stephen Warren7c9359762011-06-01 11:14:17 -06004723 !(spdif->status & IEC958_AES0_NONAUDIO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004724 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
Takashi Iwai6b97eb42007-04-05 14:51:48 +02004725 setup_dig_out_stream(codec, mout->dig_out_nid,
4726 stream_tag, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004727 } else {
4728 mout->dig_out_used = 0;
Takashi Iwai2f728532008-09-25 16:32:41 +02004729 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004730 }
4731 }
Ingo Molnar62932df2006-01-16 16:34:20 +01004732 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004733
4734 /* front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004735 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
4736 0, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02004737 if (!mout->no_share_stream &&
4738 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
Linus Torvalds1da177e2005-04-16 15:20:36 -07004739 /* headphone out will just decode front left/right (stereo) */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004740 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
4741 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004742 /* extra outputs copied from front */
Takashi Iwaia06dbfc2011-08-23 18:16:13 +02004743 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4744 if (!mout->no_share_stream && mout->hp_out_nid[i])
4745 snd_hda_codec_setup_stream(codec,
4746 mout->hp_out_nid[i],
4747 stream_tag, 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004748 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
Takashi Iwaid29240c2007-10-26 12:35:56 +02004749 if (!mout->no_share_stream && mout->extra_out_nid[i])
Takashi Iwai82bc9552006-03-21 11:24:42 +01004750 snd_hda_codec_setup_stream(codec,
4751 mout->extra_out_nid[i],
4752 stream_tag, 0, format);
4753
Linus Torvalds1da177e2005-04-16 15:20:36 -07004754 /* surrounds */
4755 for (i = 1; i < mout->num_dacs; i++) {
Takashi Iwai4b3acaf2005-06-10 19:48:10 +02004756 if (chs >= (i + 1) * 2) /* independent out */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004757 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4758 i * 2, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02004759 else if (!mout->no_share_stream) /* copy front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004760 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
4761 0, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004762 }
4763 return 0;
4764}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004765EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004766
Takashi Iwaid5191e52009-11-16 14:58:17 +01004767/**
4768 * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
Linus Torvalds1da177e2005-04-16 15:20:36 -07004769 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02004770int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
4771 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004772{
Takashi Iwaidda14412011-05-02 11:29:30 +02004773 const hda_nid_t *nids = mout->dac_nids;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004774 int i;
4775
4776 for (i = 0; i < mout->num_dacs; i++)
Takashi Iwai888afa12008-03-18 09:57:50 +01004777 snd_hda_codec_cleanup_stream(codec, nids[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004778 if (mout->hp_nid)
Takashi Iwai888afa12008-03-18 09:57:50 +01004779 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
Takashi Iwaia06dbfc2011-08-23 18:16:13 +02004780 for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
4781 if (mout->hp_out_nid[i])
4782 snd_hda_codec_cleanup_stream(codec,
4783 mout->hp_out_nid[i]);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004784 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
4785 if (mout->extra_out_nid[i])
Takashi Iwai888afa12008-03-18 09:57:50 +01004786 snd_hda_codec_cleanup_stream(codec,
4787 mout->extra_out_nid[i]);
Ingo Molnar62932df2006-01-16 16:34:20 +01004788 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004789 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
Takashi Iwai2f728532008-09-25 16:32:41 +02004790 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004791 mout->dig_out_used = 0;
4792 }
Ingo Molnar62932df2006-01-16 16:34:20 +01004793 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004794 return 0;
4795}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01004796EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004798/*
Wu Fengguang6b345002008-10-07 14:21:41 +08004799 * Helper for automatic pin configuration
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004800 */
Kailang Yangdf694da2005-12-05 19:42:22 +01004801
Takashi Iwaidda14412011-05-02 11:29:30 +02004802static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list)
Kailang Yangdf694da2005-12-05 19:42:22 +01004803{
4804 for (; *list; list++)
4805 if (*list == nid)
4806 return 1;
4807 return 0;
4808}
4809
Steve Longerbeam81937d32007-05-08 15:33:03 +02004810
4811/*
4812 * Sort an associated group of pins according to their sequence numbers.
4813 */
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004814static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
Steve Longerbeam81937d32007-05-08 15:33:03 +02004815 int num_pins)
4816{
4817 int i, j;
4818 short seq;
4819 hda_nid_t nid;
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004820
Steve Longerbeam81937d32007-05-08 15:33:03 +02004821 for (i = 0; i < num_pins; i++) {
4822 for (j = i + 1; j < num_pins; j++) {
4823 if (sequences[i] > sequences[j]) {
4824 seq = sequences[i];
4825 sequences[i] = sequences[j];
4826 sequences[j] = seq;
4827 nid = pins[i];
4828 pins[i] = pins[j];
4829 pins[j] = nid;
4830 }
4831 }
4832 }
4833}
4834
4835
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004836/* add the found input-pin to the cfg->inputs[] table */
4837static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid,
4838 int type)
4839{
4840 if (cfg->num_inputs < AUTO_CFG_MAX_INS) {
4841 cfg->inputs[cfg->num_inputs].pin = nid;
4842 cfg->inputs[cfg->num_inputs].type = type;
4843 cfg->num_inputs++;
4844 }
4845}
4846
Takashi Iwai4a4d4a62010-09-09 22:22:02 +02004847/* sort inputs in the order of AUTO_PIN_* type */
4848static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg)
4849{
4850 int i, j;
4851
4852 for (i = 0; i < cfg->num_inputs; i++) {
4853 for (j = i + 1; j < cfg->num_inputs; j++) {
4854 if (cfg->inputs[i].type > cfg->inputs[j].type) {
4855 struct auto_pin_cfg_item tmp;
4856 tmp = cfg->inputs[i];
4857 cfg->inputs[i] = cfg->inputs[j];
4858 cfg->inputs[j] = tmp;
4859 }
4860 }
4861 }
4862}
4863
Takashi Iwai8fa7ab42011-10-26 16:06:27 +02004864/* Reorder the surround channels
4865 * ALSA sequence is front/surr/clfe/side
4866 * HDA sequence is:
4867 * 4-ch: front/surr => OK as it is
4868 * 6-ch: front/clfe/surr
4869 * 8-ch: front/clfe/rear/side|fc
4870 */
4871static void reorder_outputs(unsigned int nums, hda_nid_t *pins)
4872{
4873 hda_nid_t nid;
4874
4875 switch (nums) {
4876 case 3:
4877 case 4:
4878 nid = pins[1];
4879 pins[1] = pins[2];
4880 pins[2] = nid;
4881 break;
4882 }
4883}
4884
Takashi Iwai82bc9552006-03-21 11:24:42 +01004885/*
4886 * Parse all pin widgets and store the useful pin nids to cfg
4887 *
4888 * The number of line-outs or any primary output is stored in line_outs,
4889 * and the corresponding output pins are assigned to line_out_pins[],
4890 * in the order of front, rear, CLFE, side, ...
4891 *
4892 * If more extra outputs (speaker and headphone) are found, the pins are
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004893 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
Takashi Iwai82bc9552006-03-21 11:24:42 +01004894 * is detected, one of speaker of HP pins is assigned as the primary
4895 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
4896 * if any analog output exists.
Norberto Lopes28aedaf2010-02-28 20:16:53 +01004897 *
Takashi Iwai86e29592010-09-09 14:50:17 +02004898 * The analog input pins are assigned to inputs array.
Takashi Iwai82bc9552006-03-21 11:24:42 +01004899 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
4900 * respectively.
4901 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02004902int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
4903 struct auto_pin_cfg *cfg,
4904 const hda_nid_t *ignore_nids,
4905 unsigned int cond_flags)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004906{
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004907 hda_nid_t nid, end_nid;
Takashi Iwai965f1b22011-08-19 09:10:29 +02004908 short seq, assoc_line_out;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004909 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
4910 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
Takashi Iwaif889fa92007-10-31 15:49:32 +01004911 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004912 int i;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004913
4914 memset(cfg, 0, sizeof(*cfg));
4915
Steve Longerbeam81937d32007-05-08 15:33:03 +02004916 memset(sequences_line_out, 0, sizeof(sequences_line_out));
4917 memset(sequences_speaker, 0, sizeof(sequences_speaker));
Takashi Iwaif889fa92007-10-31 15:49:32 +01004918 memset(sequences_hp, 0, sizeof(sequences_hp));
Takashi Iwai965f1b22011-08-19 09:10:29 +02004919 assoc_line_out = 0;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004920
Takashi Iwai2f451d22011-11-10 12:36:46 +01004921 codec->ignore_misc_bit = true;
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01004922 end_nid = codec->start_nid + codec->num_nodes;
4923 for (nid = codec->start_nid; nid < end_nid; nid++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01004924 unsigned int wid_caps = get_wcaps(codec, nid);
Takashi Iwaia22d5432009-07-27 12:54:26 +02004925 unsigned int wid_type = get_wcaps_type(wid_caps);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004926 unsigned int def_conf;
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004927 short assoc, loc, conn, dev;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004928
4929 /* read all default configuration for pin complex */
4930 if (wid_type != AC_WID_PIN)
4931 continue;
Kailang Yangdf694da2005-12-05 19:42:22 +01004932 /* ignore the given nids (e.g. pc-beep returns error) */
4933 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
4934 continue;
4935
Takashi Iwaic17a1ab2009-02-23 09:28:12 +01004936 def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai2f451d22011-11-10 12:36:46 +01004937 if (!(get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
4938 AC_DEFCFG_MISC_NO_PRESENCE))
4939 codec->ignore_misc_bit = false;
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004940 conn = get_defcfg_connect(def_conf);
4941 if (conn == AC_JACK_PORT_NONE)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004942 continue;
4943 loc = get_defcfg_location(def_conf);
Takashi Iwai1af7c5f2011-06-24 10:43:03 +02004944 dev = get_defcfg_device(def_conf);
4945
4946 /* workaround for buggy BIOS setups */
4947 if (dev == AC_JACK_LINE_OUT) {
4948 if (conn == AC_JACK_PORT_FIXED)
4949 dev = AC_JACK_SPEAKER;
4950 }
4951
4952 switch (dev) {
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004953 case AC_JACK_LINE_OUT:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004954 seq = get_defcfg_sequence(def_conf);
4955 assoc = get_defcfg_association(def_conf);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01004956
4957 if (!(wid_caps & AC_WCAP_STEREO))
4958 if (!cfg->mono_out_pin)
4959 cfg->mono_out_pin = nid;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004960 if (!assoc)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004961 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +02004962 if (!assoc_line_out)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004963 assoc_line_out = assoc;
4964 else if (assoc_line_out != assoc)
4965 continue;
4966 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
4967 continue;
4968 cfg->line_out_pins[cfg->line_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02004969 sequences_line_out[cfg->line_outs] = seq;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004970 cfg->line_outs++;
4971 break;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004972 case AC_JACK_SPEAKER:
Steve Longerbeam81937d32007-05-08 15:33:03 +02004973 seq = get_defcfg_sequence(def_conf);
4974 assoc = get_defcfg_association(def_conf);
Takashi Iwai82bc9552006-03-21 11:24:42 +01004975 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
4976 continue;
4977 cfg->speaker_pins[cfg->speaker_outs] = nid;
Takashi Iwai965f1b22011-08-19 09:10:29 +02004978 sequences_speaker[cfg->speaker_outs] = (assoc << 4) | seq;
Takashi Iwai82bc9552006-03-21 11:24:42 +01004979 cfg->speaker_outs++;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01004980 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004981 case AC_JACK_HP_OUT:
Takashi Iwaif889fa92007-10-31 15:49:32 +01004982 seq = get_defcfg_sequence(def_conf);
4983 assoc = get_defcfg_association(def_conf);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004984 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
4985 continue;
4986 cfg->hp_pins[cfg->hp_outs] = nid;
Takashi Iwaif889fa92007-10-31 15:49:32 +01004987 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
Takashi Iwaieb06ed82006-09-20 17:10:27 +02004988 cfg->hp_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004989 break;
Takashi Iwai86e29592010-09-09 14:50:17 +02004990 case AC_JACK_MIC_IN:
4991 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004992 break;
Takashi Iwai86e29592010-09-09 14:50:17 +02004993 case AC_JACK_LINE_IN:
4994 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004995 break;
4996 case AC_JACK_CD:
Takashi Iwai75e0eb22010-08-30 12:56:55 +02004997 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02004998 break;
4999 case AC_JACK_AUX:
Takashi Iwai75e0eb22010-08-30 12:56:55 +02005000 add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005001 break;
5002 case AC_JACK_SPDIF_OUT:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01005003 case AC_JACK_DIG_OTHER_OUT:
Takashi Iwai0852d7a2009-02-11 11:35:15 +01005004 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
5005 continue;
5006 cfg->dig_out_pins[cfg->dig_outs] = nid;
5007 cfg->dig_out_type[cfg->dig_outs] =
5008 (loc == AC_JACK_LOC_HDMI) ?
5009 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
5010 cfg->dig_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005011 break;
5012 case AC_JACK_SPDIF_IN:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01005013 case AC_JACK_DIG_OTHER_IN:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005014 cfg->dig_in_pin = nid;
Takashi Iwai2297bd62009-01-20 18:24:13 +01005015 if (loc == AC_JACK_LOC_HDMI)
5016 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
5017 else
5018 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005019 break;
5020 }
5021 }
5022
Takashi Iwai5832fcf2008-02-12 18:30:12 +01005023 /* FIX-UP:
5024 * If no line-out is defined but multiple HPs are found,
5025 * some of them might be the real line-outs.
5026 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02005027 if (!cfg->line_outs && cfg->hp_outs > 1 &&
5028 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) {
Takashi Iwai5832fcf2008-02-12 18:30:12 +01005029 int i = 0;
5030 while (i < cfg->hp_outs) {
5031 /* The real HPs should have the sequence 0x0f */
5032 if ((sequences_hp[i] & 0x0f) == 0x0f) {
5033 i++;
5034 continue;
5035 }
5036 /* Move it to the line-out table */
5037 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
5038 sequences_line_out[cfg->line_outs] = sequences_hp[i];
5039 cfg->line_outs++;
5040 cfg->hp_outs--;
5041 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
5042 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
Takashi Iwai122661b2010-09-08 14:57:04 +02005043 memmove(sequences_hp + i, sequences_hp + i + 1,
Takashi Iwai5832fcf2008-02-12 18:30:12 +01005044 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
5045 }
Takashi Iwai03642c92010-09-08 15:28:19 +02005046 memset(cfg->hp_pins + cfg->hp_outs, 0,
5047 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs));
Takashi Iwaib2d05762011-01-10 14:47:35 +01005048 if (!cfg->hp_outs)
5049 cfg->line_out_type = AUTO_PIN_HP_OUT;
5050
Takashi Iwai5832fcf2008-02-12 18:30:12 +01005051 }
5052
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005053 /* sort by sequence */
Steve Longerbeam81937d32007-05-08 15:33:03 +02005054 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
5055 cfg->line_outs);
5056 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
5057 cfg->speaker_outs);
Takashi Iwaif889fa92007-10-31 15:49:32 +01005058 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
5059 cfg->hp_outs);
Norberto Lopes28aedaf2010-02-28 20:16:53 +01005060
Steve Longerbeam81937d32007-05-08 15:33:03 +02005061 /*
5062 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
5063 * as a primary output
5064 */
Takashi Iwaid025feb2011-08-23 15:24:39 +02005065 if (!cfg->line_outs &&
5066 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) {
Steve Longerbeam81937d32007-05-08 15:33:03 +02005067 if (cfg->speaker_outs) {
5068 cfg->line_outs = cfg->speaker_outs;
5069 memcpy(cfg->line_out_pins, cfg->speaker_pins,
5070 sizeof(cfg->speaker_pins));
5071 cfg->speaker_outs = 0;
5072 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
5073 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
5074 } else if (cfg->hp_outs) {
5075 cfg->line_outs = cfg->hp_outs;
5076 memcpy(cfg->line_out_pins, cfg->hp_pins,
5077 sizeof(cfg->hp_pins));
5078 cfg->hp_outs = 0;
5079 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5080 cfg->line_out_type = AUTO_PIN_HP_OUT;
5081 }
5082 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005083
Takashi Iwai8fa7ab42011-10-26 16:06:27 +02005084 reorder_outputs(cfg->line_outs, cfg->line_out_pins);
5085 reorder_outputs(cfg->hp_outs, cfg->hp_pins);
5086 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005087
Takashi Iwai4a4d4a62010-09-09 22:22:02 +02005088 sort_autocfg_input_pins(cfg);
5089
Takashi Iwai82bc9552006-03-21 11:24:42 +01005090 /*
5091 * debug prints of the parsed results
5092 */
Takashi Iwaic2de1872011-04-29 13:00:40 +02005093 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
Takashi Iwai82bc9552006-03-21 11:24:42 +01005094 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
5095 cfg->line_out_pins[2], cfg->line_out_pins[3],
Takashi Iwaic2de1872011-04-29 13:00:40 +02005096 cfg->line_out_pins[4],
5097 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
5098 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
5099 "speaker" : "line"));
Takashi Iwai82bc9552006-03-21 11:24:42 +01005100 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5101 cfg->speaker_outs, cfg->speaker_pins[0],
5102 cfg->speaker_pins[1], cfg->speaker_pins[2],
5103 cfg->speaker_pins[3], cfg->speaker_pins[4]);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02005104 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
5105 cfg->hp_outs, cfg->hp_pins[0],
5106 cfg->hp_pins[1], cfg->hp_pins[2],
5107 cfg->hp_pins[3], cfg->hp_pins[4]);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01005108 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
Takashi Iwai0852d7a2009-02-11 11:35:15 +01005109 if (cfg->dig_outs)
5110 snd_printd(" dig-out=0x%x/0x%x\n",
5111 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
Takashi Iwai75e0eb22010-08-30 12:56:55 +02005112 snd_printd(" inputs:");
5113 for (i = 0; i < cfg->num_inputs; i++) {
Takashi Iwai0b626732011-05-26 14:10:44 +02005114 snd_printd(" %s=0x%x",
Takashi Iwai10a20af2010-09-09 16:28:02 +02005115 hda_get_autocfg_input_label(codec, cfg, i),
Takashi Iwai75e0eb22010-08-30 12:56:55 +02005116 cfg->inputs[i].pin);
5117 }
5118 snd_printd("\n");
Takashi Iwai32d2c7f2009-02-11 11:33:13 +01005119 if (cfg->dig_in_pin)
Takashi Iwai89ce9e82009-01-20 17:15:57 +01005120 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
Takashi Iwai82bc9552006-03-21 11:24:42 +01005121
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005122 return 0;
5123}
Takashi Iwaid025feb2011-08-23 15:24:39 +02005124EXPORT_SYMBOL_HDA(snd_hda_parse_pin_defcfg);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02005125
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005126int snd_hda_get_input_pin_attr(unsigned int def_conf)
Takashi Iwaia1c98512010-09-09 21:36:27 +02005127{
5128 unsigned int loc = get_defcfg_location(def_conf);
Takashi Iwai41c89ef2010-09-17 10:26:37 +02005129 unsigned int conn = get_defcfg_connect(def_conf);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005130 if (conn == AC_JACK_PORT_NONE)
5131 return INPUT_PIN_ATTR_UNUSED;
Takashi Iwai41c89ef2010-09-17 10:26:37 +02005132 /* Windows may claim the internal mic to be BOTH, too */
5133 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005134 return INPUT_PIN_ATTR_INT;
Takashi Iwai41c89ef2010-09-17 10:26:37 +02005135 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005136 return INPUT_PIN_ATTR_INT;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005137 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005138 return INPUT_PIN_ATTR_DOCK;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005139 if (loc == AC_JACK_LOC_REAR)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005140 return INPUT_PIN_ATTR_REAR;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005141 if (loc == AC_JACK_LOC_FRONT)
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005142 return INPUT_PIN_ATTR_FRONT;
5143 return INPUT_PIN_ATTR_NORMAL;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005144}
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005145EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
Takashi Iwaia1c98512010-09-09 21:36:27 +02005146
Takashi Iwai990061c2010-09-09 22:08:44 +02005147/**
5148 * hda_get_input_pin_label - Give a label for the given input pin
5149 *
5150 * When check_location is true, the function checks the pin location
5151 * for mic and line-in pins, and set an appropriate prefix like "Front",
5152 * "Rear", "Internal".
5153 */
5154
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005155static const char *hda_get_input_pin_label(struct hda_codec *codec,
5156 hda_nid_t pin, bool check_location)
Takashi Iwai10a20af2010-09-09 16:28:02 +02005157{
Takashi Iwaia1c98512010-09-09 21:36:27 +02005158 unsigned int def_conf;
Takashi Iwaiea734962011-01-17 11:29:34 +01005159 static const char * const mic_names[] = {
Takashi Iwaia1c98512010-09-09 21:36:27 +02005160 "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic",
5161 };
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005162 int attr;
Takashi Iwai4a471b72005-12-07 13:56:29 +01005163
Takashi Iwai10a20af2010-09-09 16:28:02 +02005164 def_conf = snd_hda_codec_get_pincfg(codec, pin);
Takashi Iwai10a20af2010-09-09 16:28:02 +02005165
5166 switch (get_defcfg_device(def_conf)) {
5167 case AC_JACK_MIC_IN:
5168 if (!check_location)
5169 return "Mic";
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005170 attr = snd_hda_get_input_pin_attr(def_conf);
5171 if (!attr)
5172 return "None";
5173 return mic_names[attr - 1];
Takashi Iwai10a20af2010-09-09 16:28:02 +02005174 case AC_JACK_LINE_IN:
5175 if (!check_location)
5176 return "Line";
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005177 attr = snd_hda_get_input_pin_attr(def_conf);
5178 if (!attr)
5179 return "None";
5180 if (attr == INPUT_PIN_ATTR_DOCK)
5181 return "Dock Line";
5182 return "Line";
Takashi Iwai10a20af2010-09-09 16:28:02 +02005183 case AC_JACK_AUX:
5184 return "Aux";
5185 case AC_JACK_CD:
5186 return "CD";
5187 case AC_JACK_SPDIF_IN:
5188 return "SPDIF In";
5189 case AC_JACK_DIG_OTHER_IN:
5190 return "Digital In";
5191 default:
5192 return "Misc";
5193 }
5194}
Takashi Iwai10a20af2010-09-09 16:28:02 +02005195
Takashi Iwaia1c98512010-09-09 21:36:27 +02005196/* Check whether the location prefix needs to be added to the label.
5197 * If all mic-jacks are in the same location (e.g. rear panel), we don't
5198 * have to put "Front" prefix to each label. In such a case, returns false.
5199 */
5200static int check_mic_location_need(struct hda_codec *codec,
5201 const struct auto_pin_cfg *cfg,
5202 int input)
5203{
5204 unsigned int defc;
5205 int i, attr, attr2;
5206
5207 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005208 attr = snd_hda_get_input_pin_attr(defc);
Takashi Iwaia1c98512010-09-09 21:36:27 +02005209 /* for internal or docking mics, we need locations */
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005210 if (attr <= INPUT_PIN_ATTR_NORMAL)
Takashi Iwaia1c98512010-09-09 21:36:27 +02005211 return 1;
5212
5213 attr = 0;
5214 for (i = 0; i < cfg->num_inputs; i++) {
5215 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin);
Takashi Iwai99ae28b2010-09-17 14:42:34 +02005216 attr2 = snd_hda_get_input_pin_attr(defc);
5217 if (attr2 >= INPUT_PIN_ATTR_NORMAL) {
Takashi Iwaia1c98512010-09-09 21:36:27 +02005218 if (attr && attr != attr2)
5219 return 1; /* different locations found */
5220 attr = attr2;
5221 }
5222 }
5223 return 0;
5224}
5225
Takashi Iwai990061c2010-09-09 22:08:44 +02005226/**
5227 * hda_get_autocfg_input_label - Get a label for the given input
5228 *
5229 * Get a label for the given input pin defined by the autocfg item.
5230 * Unlike hda_get_input_pin_label(), this function checks all inputs
5231 * defined in autocfg and avoids the redundant mic/line prefix as much as
5232 * possible.
5233 */
Takashi Iwai10a20af2010-09-09 16:28:02 +02005234const char *hda_get_autocfg_input_label(struct hda_codec *codec,
5235 const struct auto_pin_cfg *cfg,
5236 int input)
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005237{
5238 int type = cfg->inputs[input].type;
Takashi Iwai10a20af2010-09-09 16:28:02 +02005239 int has_multiple_pins = 0;
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005240
Takashi Iwai10a20af2010-09-09 16:28:02 +02005241 if ((input > 0 && cfg->inputs[input - 1].type == type) ||
5242 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type))
5243 has_multiple_pins = 1;
Takashi Iwaia1c98512010-09-09 21:36:27 +02005244 if (has_multiple_pins && type == AUTO_PIN_MIC)
5245 has_multiple_pins &= check_mic_location_need(codec, cfg, input);
Takashi Iwai10a20af2010-09-09 16:28:02 +02005246 return hda_get_input_pin_label(codec, cfg->inputs[input].pin,
5247 has_multiple_pins);
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005248}
Takashi Iwai10a20af2010-09-09 16:28:02 +02005249EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
5250
Takashi Iwai358b6e62011-11-21 14:34:20 +01005251/* return the position of NID in the list, or -1 if not found */
5252static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
5253{
5254 int i;
5255 for (i = 0; i < nums; i++)
5256 if (list[i] == nid)
5257 return i;
5258 return -1;
5259}
5260
Takashi Iwai201e06f2011-11-16 15:33:26 +01005261/* get a unique suffix or an index number */
5262static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
5263 int num_pins, int *indexp)
5264{
5265 static const char * const channel_sfx[] = {
Takashi Iwaid6018bb2011-11-21 14:17:16 +01005266 " Front", " Surround", " CLFE", " Side"
Takashi Iwai201e06f2011-11-16 15:33:26 +01005267 };
5268 int i;
5269
Takashi Iwai358b6e62011-11-21 14:34:20 +01005270 i = find_idx_in_nid_list(nid, pins, num_pins);
5271 if (i < 0)
5272 return NULL;
5273 if (num_pins == 1)
5274 return "";
5275 if (num_pins > ARRAY_SIZE(channel_sfx)) {
5276 if (indexp)
5277 *indexp = i;
5278 return "";
Takashi Iwai201e06f2011-11-16 15:33:26 +01005279 }
Takashi Iwai358b6e62011-11-21 14:34:20 +01005280 return channel_sfx[i];
Takashi Iwai201e06f2011-11-16 15:33:26 +01005281}
5282
5283static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
5284 const struct auto_pin_cfg *cfg,
5285 const char *name, char *label, int maxlen,
5286 int *indexp)
5287{
5288 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5289 int attr = snd_hda_get_input_pin_attr(def_conf);
5290 const char *pfx = "", *sfx = "";
5291
5292 /* handle as a speaker if it's a fixed line-out */
Takashi Iwaie49a3432012-03-01 18:14:41 +01005293 if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005294 name = "Speaker";
5295 /* check the location */
5296 switch (attr) {
5297 case INPUT_PIN_ATTR_DOCK:
5298 pfx = "Dock ";
5299 break;
5300 case INPUT_PIN_ATTR_FRONT:
5301 pfx = "Front ";
5302 break;
5303 }
5304 if (cfg) {
5305 /* try to give a unique suffix if needed */
5306 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
5307 indexp);
5308 if (!sfx)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005309 sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
5310 indexp);
Takashi Iwai358b6e62011-11-21 14:34:20 +01005311 if (!sfx) {
5312 /* don't add channel suffix for Headphone controls */
5313 int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
5314 cfg->hp_outs);
5315 if (idx >= 0)
5316 *indexp = idx;
Takashi Iwai201e06f2011-11-16 15:33:26 +01005317 sfx = "";
Takashi Iwai358b6e62011-11-21 14:34:20 +01005318 }
Takashi Iwai201e06f2011-11-16 15:33:26 +01005319 }
5320 snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
5321 return 1;
5322}
5323
Takashi Iwai990061c2010-09-09 22:08:44 +02005324/**
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005325 * snd_hda_get_pin_label - Get a label for the given I/O pin
5326 *
5327 * Get a label for the given pin. This function works for both input and
5328 * output pins. When @cfg is given as non-NULL, the function tries to get
5329 * an optimized label using hda_get_autocfg_input_label().
Takashi Iwai201e06f2011-11-16 15:33:26 +01005330 *
5331 * This function tries to give a unique label string for the pin as much as
5332 * possible. For example, when the multiple line-outs are present, it adds
5333 * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
5334 * If no unique name with a suffix is available and @indexp is non-NULL, the
5335 * index number is stored in the pointer.
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005336 */
Takashi Iwai201e06f2011-11-16 15:33:26 +01005337int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
5338 const struct auto_pin_cfg *cfg,
5339 char *label, int maxlen, int *indexp)
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005340{
5341 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai201e06f2011-11-16 15:33:26 +01005342 const char *name = NULL;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005343 int i;
5344
Takashi Iwai201e06f2011-11-16 15:33:26 +01005345 if (indexp)
5346 *indexp = 0;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005347 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005348 return 0;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005349
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005350 switch (get_defcfg_device(def_conf)) {
5351 case AC_JACK_LINE_OUT:
Takashi Iwaie49a3432012-03-01 18:14:41 +01005352 return fill_audio_out_name(codec, nid, cfg, "Line Out",
Takashi Iwai201e06f2011-11-16 15:33:26 +01005353 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005354 case AC_JACK_SPEAKER:
Takashi Iwai201e06f2011-11-16 15:33:26 +01005355 return fill_audio_out_name(codec, nid, cfg, "Speaker",
5356 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005357 case AC_JACK_HP_OUT:
Takashi Iwai201e06f2011-11-16 15:33:26 +01005358 return fill_audio_out_name(codec, nid, cfg, "Headphone",
5359 label, maxlen, indexp);
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005360 case AC_JACK_SPDIF_OUT:
5361 case AC_JACK_DIG_OTHER_OUT:
5362 if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
Takashi Iwai201e06f2011-11-16 15:33:26 +01005363 name = "HDMI";
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005364 else
Takashi Iwai201e06f2011-11-16 15:33:26 +01005365 name = "SPDIF";
5366 if (cfg && indexp) {
Takashi Iwai358b6e62011-11-21 14:34:20 +01005367 i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
5368 cfg->dig_outs);
5369 if (i >= 0)
5370 *indexp = i;
Takashi Iwai201e06f2011-11-16 15:33:26 +01005371 }
5372 break;
5373 default:
5374 if (cfg) {
5375 for (i = 0; i < cfg->num_inputs; i++) {
5376 if (cfg->inputs[i].pin != nid)
5377 continue;
5378 name = hda_get_autocfg_input_label(codec, cfg, i);
5379 if (name)
5380 break;
5381 }
5382 }
5383 if (!name)
5384 name = hda_get_input_pin_label(codec, nid, true);
5385 break;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005386 }
Takashi Iwai201e06f2011-11-16 15:33:26 +01005387 if (!name)
5388 return 0;
5389 strlcpy(label, name, maxlen);
5390 return 1;
Takashi Iwai04f5ade2011-10-27 20:47:07 +02005391}
5392EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
5393
Takashi Iwai990061c2010-09-09 22:08:44 +02005394/**
5395 * snd_hda_add_imux_item - Add an item to input_mux
5396 *
5397 * When the same label is used already in the existing items, the number
5398 * suffix is appended to the label. This label index number is stored
5399 * to type_idx when non-NULL pointer is given.
5400 */
Takashi Iwai10a20af2010-09-09 16:28:02 +02005401int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
5402 int index, int *type_idx)
5403{
5404 int i, label_idx = 0;
5405 if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
5406 snd_printd(KERN_ERR "hda_codec: Too many imux items!\n");
5407 return -EINVAL;
5408 }
5409 for (i = 0; i < imux->num_items; i++) {
5410 if (!strncmp(label, imux->items[i].label, strlen(label)))
5411 label_idx++;
5412 }
5413 if (type_idx)
5414 *type_idx = label_idx;
5415 if (label_idx > 0)
5416 snprintf(imux->items[imux->num_items].label,
5417 sizeof(imux->items[imux->num_items].label),
5418 "%s %d", label, label_idx);
5419 else
5420 strlcpy(imux->items[imux->num_items].label, label,
5421 sizeof(imux->items[imux->num_items].label));
5422 imux->items[imux->num_items].index = index;
5423 imux->num_items++;
5424 return 0;
5425}
5426EXPORT_SYMBOL_HDA(snd_hda_add_imux_item);
Takashi Iwaid7b1ae92010-08-30 13:00:16 +02005427
Takashi Iwai4a471b72005-12-07 13:56:29 +01005428
Linus Torvalds1da177e2005-04-16 15:20:36 -07005429#ifdef CONFIG_PM
5430/*
5431 * power management
5432 */
5433
5434/**
5435 * snd_hda_suspend - suspend the codecs
5436 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07005437 *
5438 * Returns 0 if successful.
5439 */
Takashi Iwai8dd78332009-06-02 01:16:07 +02005440int snd_hda_suspend(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005441{
Takashi Iwai0ba21762007-04-16 11:29:14 +02005442 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005443
Takashi Iwai0ba21762007-04-16 11:29:14 +02005444 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwaie581f3d2011-07-26 10:19:20 +02005445 if (hda_codec_is_power_on(codec))
5446 hda_call_codec_suspend(codec);
Takashi Iwai785f8572012-03-07 10:58:39 +01005447 else /* forcibly change the power to D3 even if not used */
5448 hda_set_power_state(codec,
5449 codec->afg ? codec->afg : codec->mfg,
5450 AC_PWRST_D3);
Takashi Iwaie581f3d2011-07-26 10:19:20 +02005451 if (codec->patch_ops.post_suspend)
5452 codec->patch_ops.post_suspend(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005453 }
5454 return 0;
5455}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005456EXPORT_SYMBOL_HDA(snd_hda_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005457
5458/**
5459 * snd_hda_resume - resume the codecs
5460 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07005461 *
5462 * Returns 0 if successful.
Takashi Iwaicb53c622007-08-10 17:21:45 +02005463 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005464 * This function is defined only when POWER_SAVE isn't set.
Takashi Iwaicb53c622007-08-10 17:21:45 +02005465 * In the power-save mode, the codec is resumed dynamically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005466 */
5467int snd_hda_resume(struct hda_bus *bus)
5468{
Takashi Iwai0ba21762007-04-16 11:29:14 +02005469 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005470
Takashi Iwai0ba21762007-04-16 11:29:14 +02005471 list_for_each_entry(codec, &bus->codec_list, list) {
Vitaliy Kulikovd02667e2011-07-22 18:18:15 -05005472 if (codec->patch_ops.pre_resume)
5473 codec->patch_ops.pre_resume(codec);
Maxim Levitskyd804ad92007-09-03 15:28:04 +02005474 if (snd_hda_codec_needs_resume(codec))
5475 hda_call_codec_resume(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005477 return 0;
5478}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005479EXPORT_SYMBOL_HDA(snd_hda_resume);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01005480#endif /* CONFIG_PM */
Takashi Iwaib2e18592008-07-30 15:01:44 +02005481
5482/*
5483 * generic arrays
5484 */
5485
Takashi Iwaid5191e52009-11-16 14:58:17 +01005486/**
5487 * snd_array_new - get a new element from the given array
5488 * @array: the array object
Norberto Lopes28aedaf2010-02-28 20:16:53 +01005489 *
Takashi Iwaid5191e52009-11-16 14:58:17 +01005490 * Get a new element from the given array. If it exceeds the
5491 * pre-allocated array size, re-allocate the array.
5492 *
5493 * Returns NULL if allocation failed.
Takashi Iwaib2e18592008-07-30 15:01:44 +02005494 */
5495void *snd_array_new(struct snd_array *array)
5496{
5497 if (array->used >= array->alloced) {
5498 int num = array->alloced + array->alloc_align;
Takashi Iwai3101ba02011-07-12 08:05:16 +02005499 int size = (num + 1) * array->elem_size;
Takashi Iwai00ef9612011-07-14 15:57:27 +02005500 int oldsize = array->alloced * array->elem_size;
Takashi Iwaib910d9a2008-11-07 00:26:52 +01005501 void *nlist;
5502 if (snd_BUG_ON(num >= 4096))
5503 return NULL;
Takashi Iwai3101ba02011-07-12 08:05:16 +02005504 nlist = krealloc(array->list, size, GFP_KERNEL);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005505 if (!nlist)
5506 return NULL;
Takashi Iwai00ef9612011-07-14 15:57:27 +02005507 memset(nlist + oldsize, 0, size - oldsize);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005508 array->list = nlist;
5509 array->alloced = num;
5510 }
Takashi Iwaif43aa022008-11-10 16:24:26 +01005511 return snd_array_elem(array, array->used++);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005512}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005513EXPORT_SYMBOL_HDA(snd_array_new);
Takashi Iwaib2e18592008-07-30 15:01:44 +02005514
Takashi Iwaid5191e52009-11-16 14:58:17 +01005515/**
5516 * snd_array_free - free the given array elements
5517 * @array: the array object
5518 */
Takashi Iwaib2e18592008-07-30 15:01:44 +02005519void snd_array_free(struct snd_array *array)
5520{
5521 kfree(array->list);
5522 array->used = 0;
5523 array->alloced = 0;
5524 array->list = NULL;
5525}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005526EXPORT_SYMBOL_HDA(snd_array_free);
Takashi Iwaib2022262008-11-21 21:24:03 +01005527
Takashi Iwaid5191e52009-11-16 14:58:17 +01005528/**
Takashi Iwaid5191e52009-11-16 14:58:17 +01005529 * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
5530 * @pcm: PCM caps bits
5531 * @buf: the string buffer to write
5532 * @buflen: the max buffer length
5533 *
5534 * used by hda_proc.c and hda_eld.c
5535 */
Takashi Iwaib2022262008-11-21 21:24:03 +01005536void snd_print_pcm_bits(int pcm, char *buf, int buflen)
5537{
5538 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
5539 int i, j;
5540
5541 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
5542 if (pcm & (AC_SUPPCM_BITS_8 << i))
5543 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
5544
5545 buf[j] = '\0'; /* necessary when j == 0 */
5546}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01005547EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01005548
5549MODULE_DESCRIPTION("HDA codec core");
5550MODULE_LICENSE("GPL");