blob: b90a2400f53dfe61b4ecabfabb7b40e4e941ec0f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/slab.h>
25#include <linux/pci.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010026#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <sound/core.h>
28#include "hda_codec.h"
29#include <sound/asoundef.h>
Jaroslav Kysela302e9c52006-07-05 17:39:49 +020030#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <sound/initval.h>
32#include "hda_local.h"
Takashi Iwai28073142007-07-27 18:58:06 +020033#include <sound/hda_hwdep.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Linus Torvalds1da177e2005-04-16 15:20:36 -070035/*
36 * vendor / preset table
37 */
38
39struct hda_vendor_id {
40 unsigned int id;
41 const char *name;
42};
43
44/* codec vendor labels */
45static struct hda_vendor_id hda_vendor_ids[] = {
Takashi Iwaic8cd1282008-02-13 16:59:29 +010046 { 0x1002, "ATI" },
Takashi Iwaia9226252006-09-17 22:05:54 +020047 { 0x1057, "Motorola" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010048 { 0x1095, "Silicon Image" },
Takashi Iwai31117b72008-12-16 14:43:21 +010049 { 0x10de, "Nvidia" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010050 { 0x10ec, "Realtek" },
Joseph Chanc577b8a2006-11-29 15:29:40 +010051 { 0x1106, "VIA" },
Matthew Ranostay7f168592007-10-18 17:38:17 +020052 { 0x111d, "IDT" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010053 { 0x11c1, "LSI" },
Takashi Iwai54b903e2005-05-15 14:30:10 +020054 { 0x11d4, "Analog Devices" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 { 0x13f6, "C-Media" },
Takashi Iwaia9226252006-09-17 22:05:54 +020056 { 0x14f1, "Conexant" },
Takashi Iwaic8cd1282008-02-13 16:59:29 +010057 { 0x17e8, "Chrontel" },
58 { 0x1854, "LG" },
Mark Brown8199de32008-10-28 14:50:13 +000059 { 0x1aec, "Wolfson Microelectronics" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 { 0x434d, "C-Media" },
Takashi Iwai74c61132008-12-18 09:11:33 +010061 { 0x8086, "Intel" },
Matt2f2f4252005-04-13 14:45:30 +020062 { 0x8384, "SigmaTel" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 {} /* terminator */
64};
65
Takashi Iwai1289e9e2008-11-27 15:47:11 +010066static DEFINE_MUTEX(preset_mutex);
67static LIST_HEAD(hda_preset_tables);
68
69int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
70{
71 mutex_lock(&preset_mutex);
72 list_add_tail(&preset->list, &hda_preset_tables);
73 mutex_unlock(&preset_mutex);
74 return 0;
75}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010076EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
Takashi Iwai1289e9e2008-11-27 15:47:11 +010077
78int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
79{
80 mutex_lock(&preset_mutex);
81 list_del(&preset->list);
82 mutex_unlock(&preset_mutex);
83 return 0;
84}
Takashi Iwaiff7a3262008-11-28 15:17:06 +010085EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Takashi Iwaicb53c622007-08-10 17:21:45 +020087#ifdef CONFIG_SND_HDA_POWER_SAVE
88static void hda_power_work(struct work_struct *work);
89static void hda_keep_power_on(struct hda_codec *codec);
90#else
91static inline void hda_keep_power_on(struct hda_codec *codec) {}
92#endif
93
Matthew Ranostay50a9f792008-10-25 01:05:45 -040094const char *snd_hda_get_jack_location(u32 cfg)
95{
96 static char *bases[7] = {
97 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
98 };
99 static unsigned char specials_idx[] = {
100 0x07, 0x08,
101 0x17, 0x18, 0x19,
102 0x37, 0x38
103 };
104 static char *specials[] = {
105 "Rear Panel", "Drive Bar",
106 "Riser", "HDMI", "ATAPI",
107 "Mobile-In", "Mobile-Out"
108 };
109 int i;
110 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
111 if ((cfg & 0x0f) < 7)
112 return bases[cfg & 0x0f];
113 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
114 if (cfg == specials_idx[i])
115 return specials[i];
116 }
117 return "UNKNOWN";
118}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100119EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400120
121const char *snd_hda_get_jack_connectivity(u32 cfg)
122{
123 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
124
125 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
126}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100127EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400128
129const char *snd_hda_get_jack_type(u32 cfg)
130{
131 static char *jack_types[16] = {
132 "Line Out", "Speaker", "HP Out", "CD",
133 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
134 "Line In", "Aux", "Mic", "Telephony",
135 "SPDIF In", "Digitial In", "Reserved", "Other"
136 };
137
138 return jack_types[(cfg & AC_DEFCFG_DEVICE)
139 >> AC_DEFCFG_DEVICE_SHIFT];
140}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100141EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
Matthew Ranostay50a9f792008-10-25 01:05:45 -0400142
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100143/*
144 * Compose a 32bit command word to be sent to the HD-audio controller
145 */
146static inline unsigned int
147make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
148 unsigned int verb, unsigned int parm)
149{
150 u32 val;
151
152 val = (u32)(codec->addr & 0x0f) << 28;
153 val |= (u32)direct << 27;
154 val |= (u32)nid << 20;
155 val |= verb << 8;
156 val |= parm;
157 return val;
158}
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160/**
161 * snd_hda_codec_read - send a command and get the response
162 * @codec: the HDA codec
163 * @nid: NID to send the command
164 * @direct: direct flag
165 * @verb: the verb to send
166 * @parm: the parameter for the verb
167 *
168 * Send a single command and read the corresponding response.
169 *
170 * Returns the obtained response value, or -1 for an error.
171 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200172unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
173 int direct,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 unsigned int verb, unsigned int parm)
175{
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100176 struct hda_bus *bus = codec->bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 unsigned int res;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100178
179 res = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200180 snd_hda_power_up(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100181 mutex_lock(&bus->cmd_mutex);
182 if (!bus->ops.command(bus, res))
183 res = bus->ops.get_response(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 else
185 res = (unsigned int)-1;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100186 mutex_unlock(&bus->cmd_mutex);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200187 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 return res;
189}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100190EXPORT_SYMBOL_HDA(snd_hda_codec_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192/**
193 * snd_hda_codec_write - send a single command without waiting for response
194 * @codec: the HDA codec
195 * @nid: NID to send the command
196 * @direct: direct flag
197 * @verb: the verb to send
198 * @parm: the parameter for the verb
199 *
200 * Send a single command without waiting for response.
201 *
202 * Returns 0 if successful, or a negative error code.
203 */
204int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
205 unsigned int verb, unsigned int parm)
206{
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100207 struct hda_bus *bus = codec->bus;
208 unsigned int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 int err;
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100210
211 res = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200212 snd_hda_power_up(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +0100213 mutex_lock(&bus->cmd_mutex);
214 err = bus->ops.command(bus, res);
215 mutex_unlock(&bus->cmd_mutex);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200216 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return err;
218}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100219EXPORT_SYMBOL_HDA(snd_hda_codec_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221/**
222 * snd_hda_sequence_write - sequence writes
223 * @codec: the HDA codec
224 * @seq: VERB array to send
225 *
226 * Send the commands sequentially from the given array.
227 * The array must be terminated with NID=0.
228 */
229void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
230{
231 for (; seq->nid; seq++)
232 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
233}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100234EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236/**
237 * snd_hda_get_sub_nodes - get the range of sub nodes
238 * @codec: the HDA codec
239 * @nid: NID to parse
240 * @start_id: the pointer to store the start NID
241 *
242 * Parse the NID and store the start NID of its sub-nodes.
243 * Returns the number of sub-nodes.
244 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200245int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
246 hda_nid_t *start_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 unsigned int parm;
249
250 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
Danny Tholene8a7f132007-09-11 21:41:56 +0200251 if (parm == -1)
252 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 *start_id = (parm >> 16) & 0x7fff;
254 return (int)(parm & 0x7fff);
255}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100256EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258/**
259 * snd_hda_get_connections - get connection list
260 * @codec: the HDA codec
261 * @nid: NID to parse
262 * @conn_list: connection list array
263 * @max_conns: max. number of connections to store
264 *
265 * Parses the connection list of the given widget and stores the list
266 * of NIDs.
267 *
268 * Returns the number of connections, or a negative error code.
269 */
270int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
271 hda_nid_t *conn_list, int max_conns)
272{
273 unsigned int parm;
Takashi Iwai54d17402005-11-21 16:33:22 +0100274 int i, conn_len, conns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 unsigned int shift, num_elems, mask;
Takashi Iwai54d17402005-11-21 16:33:22 +0100276 hda_nid_t prev_nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Takashi Iwaida3cec32008-08-08 17:12:14 +0200278 if (snd_BUG_ON(!conn_list || max_conns <= 0))
279 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
282 if (parm & AC_CLIST_LONG) {
283 /* long form */
284 shift = 16;
285 num_elems = 2;
286 } else {
287 /* short form */
288 shift = 8;
289 num_elems = 4;
290 }
291 conn_len = parm & AC_CLIST_LENGTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 mask = (1 << (shift-1)) - 1;
293
Takashi Iwai0ba21762007-04-16 11:29:14 +0200294 if (!conn_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 return 0; /* no connection */
296
297 if (conn_len == 1) {
298 /* single connection */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200299 parm = snd_hda_codec_read(codec, nid, 0,
300 AC_VERB_GET_CONNECT_LIST, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 conn_list[0] = parm & mask;
302 return 1;
303 }
304
305 /* multi connection */
306 conns = 0;
Takashi Iwai54d17402005-11-21 16:33:22 +0100307 prev_nid = 0;
308 for (i = 0; i < conn_len; i++) {
309 int range_val;
310 hda_nid_t val, n;
311
312 if (i % num_elems == 0)
313 parm = snd_hda_codec_read(codec, nid, 0,
314 AC_VERB_GET_CONNECT_LIST, i);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200315 range_val = !!(parm & (1 << (shift-1))); /* ranges */
Takashi Iwai54d17402005-11-21 16:33:22 +0100316 val = parm & mask;
317 parm >>= shift;
318 if (range_val) {
319 /* ranges between the previous and this one */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200320 if (!prev_nid || prev_nid >= val) {
321 snd_printk(KERN_WARNING "hda_codec: "
322 "invalid dep_range_val %x:%x\n",
323 prev_nid, val);
Takashi Iwai54d17402005-11-21 16:33:22 +0100324 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100326 for (n = prev_nid + 1; n <= val; n++) {
327 if (conns >= max_conns) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200328 snd_printk(KERN_ERR
329 "Too many connections\n");
Takashi Iwai54d17402005-11-21 16:33:22 +0100330 return -EINVAL;
331 }
332 conn_list[conns++] = n;
333 }
334 } else {
335 if (conns >= max_conns) {
336 snd_printk(KERN_ERR "Too many connections\n");
337 return -EINVAL;
338 }
339 conn_list[conns++] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
Takashi Iwai54d17402005-11-21 16:33:22 +0100341 prev_nid = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 }
343 return conns;
344}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100345EXPORT_SYMBOL_HDA(snd_hda_get_connections);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347
348/**
349 * snd_hda_queue_unsol_event - add an unsolicited event to queue
350 * @bus: the BUS
351 * @res: unsolicited event (lower 32bit of RIRB entry)
352 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
353 *
354 * Adds the given event to the queue. The events are processed in
355 * the workqueue asynchronously. Call this function in the interrupt
356 * hanlder when RIRB receives an unsolicited event.
357 *
358 * Returns 0 if successful, or a negative error code.
359 */
360int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
361{
362 struct hda_bus_unsolicited *unsol;
363 unsigned int wp;
364
Takashi Iwai0ba21762007-04-16 11:29:14 +0200365 unsol = bus->unsol;
366 if (!unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 return 0;
368
369 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
370 unsol->wp = wp;
371
372 wp <<= 1;
373 unsol->queue[wp] = res;
374 unsol->queue[wp + 1] = res_ex;
375
Takashi Iwai6acaed32009-01-12 10:09:24 +0100376 queue_work(bus->workq, &unsol->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378 return 0;
379}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100380EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382/*
Wu Fengguang5c1d1a92008-10-07 14:17:53 +0800383 * process queued unsolicited events
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 */
David Howellsc4028952006-11-22 14:57:56 +0000385static void process_unsol_events(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
David Howellsc4028952006-11-22 14:57:56 +0000387 struct hda_bus_unsolicited *unsol =
388 container_of(work, struct hda_bus_unsolicited, work);
389 struct hda_bus *bus = unsol->bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 struct hda_codec *codec;
391 unsigned int rp, caddr, res;
392
393 while (unsol->rp != unsol->wp) {
394 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
395 unsol->rp = rp;
396 rp <<= 1;
397 res = unsol->queue[rp];
398 caddr = unsol->queue[rp + 1];
Takashi Iwai0ba21762007-04-16 11:29:14 +0200399 if (!(caddr & (1 << 4))) /* no unsolicited event? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 continue;
401 codec = bus->caddr_tbl[caddr & 0x0f];
402 if (codec && codec->patch_ops.unsol_event)
403 codec->patch_ops.unsol_event(codec, res);
404 }
405}
406
407/*
408 * initialize unsolicited queue
409 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200410static int init_unsol_queue(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 struct hda_bus_unsolicited *unsol;
413
Takashi Iwai9f146bb2005-11-17 11:07:49 +0100414 if (bus->unsol) /* already initialized */
415 return 0;
416
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200417 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200418 if (!unsol) {
419 snd_printk(KERN_ERR "hda_codec: "
420 "can't allocate unsolicited queue\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return -ENOMEM;
422 }
David Howellsc4028952006-11-22 14:57:56 +0000423 INIT_WORK(&unsol->work, process_unsol_events);
424 unsol->bus = bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 bus->unsol = unsol;
426 return 0;
427}
428
429/*
430 * destructor
431 */
432static void snd_hda_codec_free(struct hda_codec *codec);
433
434static int snd_hda_bus_free(struct hda_bus *bus)
435{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200436 struct hda_codec *codec, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Takashi Iwai0ba21762007-04-16 11:29:14 +0200438 if (!bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 return 0;
Takashi Iwai6acaed32009-01-12 10:09:24 +0100440 if (bus->workq)
441 flush_workqueue(bus->workq);
442 if (bus->unsol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 kfree(bus->unsol);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200444 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 snd_hda_codec_free(codec);
446 }
447 if (bus->ops.private_free)
448 bus->ops.private_free(bus);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100449 if (bus->workq)
450 destroy_workqueue(bus->workq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 kfree(bus);
452 return 0;
453}
454
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100455static int snd_hda_bus_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 struct hda_bus *bus = device->device_data;
Takashi Iwaib94d35392008-11-21 09:08:06 +0100458 bus->shutdown = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return snd_hda_bus_free(bus);
460}
461
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200462#ifdef CONFIG_SND_HDA_HWDEP
463static int snd_hda_bus_dev_register(struct snd_device *device)
464{
465 struct hda_bus *bus = device->device_data;
466 struct hda_codec *codec;
467 list_for_each_entry(codec, &bus->codec_list, list) {
468 snd_hda_hwdep_add_sysfs(codec);
469 }
470 return 0;
471}
472#else
473#define snd_hda_bus_dev_register NULL
474#endif
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476/**
477 * snd_hda_bus_new - create a HDA bus
478 * @card: the card entry
479 * @temp: the template for hda_bus information
480 * @busp: the pointer to store the created bus instance
481 *
482 * Returns 0 if successful, or a negative error code.
483 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100484int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
Takashi Iwai756e2b02007-04-16 11:27:07 +0200485 const struct hda_bus_template *temp,
486 struct hda_bus **busp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
488 struct hda_bus *bus;
489 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100490 static struct snd_device_ops dev_ops = {
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200491 .dev_register = snd_hda_bus_dev_register,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 .dev_free = snd_hda_bus_dev_free,
493 };
494
Takashi Iwaida3cec32008-08-08 17:12:14 +0200495 if (snd_BUG_ON(!temp))
496 return -EINVAL;
497 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
498 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500 if (busp)
501 *busp = NULL;
502
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200503 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (bus == NULL) {
505 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
506 return -ENOMEM;
507 }
508
509 bus->card = card;
510 bus->private_data = temp->private_data;
511 bus->pci = temp->pci;
512 bus->modelname = temp->modelname;
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100513 bus->power_save = temp->power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 bus->ops = temp->ops;
515
Ingo Molnar62932df2006-01-16 16:34:20 +0100516 mutex_init(&bus->cmd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 INIT_LIST_HEAD(&bus->codec_list);
518
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100519 snprintf(bus->workq_name, sizeof(bus->workq_name),
520 "hd-audio%d", card->number);
521 bus->workq = create_singlethread_workqueue(bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100522 if (!bus->workq) {
Takashi Iwaie8c0ee52009-02-05 07:34:28 +0100523 snd_printk(KERN_ERR "cannot create workqueue %s\n",
524 bus->workq_name);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100525 kfree(bus);
526 return -ENOMEM;
527 }
528
Takashi Iwai0ba21762007-04-16 11:29:14 +0200529 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
530 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 snd_hda_bus_free(bus);
532 return err;
533 }
534 if (busp)
535 *busp = bus;
536 return 0;
537}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100538EXPORT_SYMBOL_HDA(snd_hda_bus_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Takashi Iwai82467612007-07-27 19:15:54 +0200540#ifdef CONFIG_SND_HDA_GENERIC
541#define is_generic_config(codec) \
Takashi Iwaif44ac832008-07-30 15:01:45 +0200542 (codec->modelname && !strcmp(codec->modelname, "generic"))
Takashi Iwai82467612007-07-27 19:15:54 +0200543#else
544#define is_generic_config(codec) 0
545#endif
546
Takashi Iwai645f10c2008-11-28 15:07:37 +0100547#ifdef MODULE
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100548#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
549#else
Takashi Iwai645f10c2008-11-28 15:07:37 +0100550#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100551#endif
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553/*
554 * find a matching codec preset
555 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200556static const struct hda_codec_preset *
Takashi Iwai756e2b02007-04-16 11:27:07 +0200557find_codec_preset(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100559 struct hda_codec_preset_list *tbl;
560 const struct hda_codec_preset *preset;
561 int mod_requested = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Takashi Iwai82467612007-07-27 19:15:54 +0200563 if (is_generic_config(codec))
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100564 return NULL; /* use the generic parser */
565
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100566 again:
567 mutex_lock(&preset_mutex);
568 list_for_each_entry(tbl, &hda_preset_tables, list) {
569 if (!try_module_get(tbl->owner)) {
570 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
571 continue;
572 }
573 for (preset = tbl->preset; preset->id; preset++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 u32 mask = preset->mask;
Marc Boucherca7cfae2008-01-22 15:32:25 +0100575 if (preset->afg && preset->afg != codec->afg)
576 continue;
577 if (preset->mfg && preset->mfg != codec->mfg)
578 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200579 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 mask = ~0;
Takashi Iwai9c7f8522006-06-28 15:08:22 +0200581 if (preset->id == (codec->vendor_id & mask) &&
Takashi Iwai0ba21762007-04-16 11:29:14 +0200582 (!preset->rev ||
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100583 preset->rev == codec->revision_id)) {
584 mutex_unlock(&preset_mutex);
585 codec->owner = tbl->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 return preset;
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100587 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100589 module_put(tbl->owner);
590 }
591 mutex_unlock(&preset_mutex);
592
593 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
594 char name[32];
595 if (!mod_requested)
596 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
597 codec->vendor_id);
598 else
599 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
600 (codec->vendor_id >> 16) & 0xffff);
601 request_module(name);
602 mod_requested++;
603 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
605 return NULL;
606}
607
608/*
Takashi Iwaif44ac832008-07-30 15:01:45 +0200609 * get_codec_name - store the codec name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200611static int get_codec_name(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
613 const struct hda_vendor_id *c;
614 const char *vendor = NULL;
615 u16 vendor_id = codec->vendor_id >> 16;
Takashi Iwaif44ac832008-07-30 15:01:45 +0200616 char tmp[16], name[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618 for (c = hda_vendor_ids; c->id; c++) {
619 if (c->id == vendor_id) {
620 vendor = c->name;
621 break;
622 }
623 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200624 if (!vendor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 sprintf(tmp, "Generic %04x", vendor_id);
626 vendor = tmp;
627 }
628 if (codec->preset && codec->preset->name)
Takashi Iwaif44ac832008-07-30 15:01:45 +0200629 snprintf(name, sizeof(name), "%s %s", vendor,
630 codec->preset->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 else
Takashi Iwaif44ac832008-07-30 15:01:45 +0200632 snprintf(name, sizeof(name), "%s ID %x", vendor,
Takashi Iwai0ba21762007-04-16 11:29:14 +0200633 codec->vendor_id & 0xffff);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200634 codec->name = kstrdup(name, GFP_KERNEL);
635 if (!codec->name)
636 return -ENOMEM;
637 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
639
640/*
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200641 * look for an AFG and MFG nodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100643static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644{
645 int i, total_nodes;
646 hda_nid_t nid;
647
648 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
649 for (i = 0; i < total_nodes; i++, nid++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200650 unsigned int func;
651 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
652 switch (func & 0xff) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200653 case AC_GRP_AUDIO_FUNCTION:
654 codec->afg = nid;
655 break;
656 case AC_GRP_MODEM_FUNCTION:
657 codec->mfg = nid;
658 break;
659 default:
660 break;
661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663}
664
665/*
Takashi Iwai54d17402005-11-21 16:33:22 +0100666 * read widget caps for each widget and store in cache
667 */
668static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
669{
670 int i;
671 hda_nid_t nid;
672
673 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
674 &codec->start_nid);
675 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200676 if (!codec->wcaps)
Takashi Iwai54d17402005-11-21 16:33:22 +0100677 return -ENOMEM;
678 nid = codec->start_nid;
679 for (i = 0; i < codec->num_nodes; i++, nid++)
680 codec->wcaps[i] = snd_hda_param_read(codec, nid,
681 AC_PAR_AUDIO_WIDGET_CAP);
682 return 0;
683}
684
Takashi Iwai3be14142009-02-20 14:11:16 +0100685/* read all pin default configurations and save codec->init_pins */
686static int read_pin_defaults(struct hda_codec *codec)
687{
688 int i;
689 hda_nid_t nid = codec->start_nid;
690
691 for (i = 0; i < codec->num_nodes; i++, nid++) {
692 struct hda_pincfg *pin;
693 unsigned int wcaps = get_wcaps(codec, nid);
694 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
695 AC_WCAP_TYPE_SHIFT;
696 if (wid_type != AC_WID_PIN)
697 continue;
698 pin = snd_array_new(&codec->init_pins);
699 if (!pin)
700 return -ENOMEM;
701 pin->nid = nid;
702 pin->cfg = snd_hda_codec_read(codec, nid, 0,
703 AC_VERB_GET_CONFIG_DEFAULT, 0);
704 }
705 return 0;
706}
707
708/* look up the given pin config list and return the item matching with NID */
709static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
710 struct snd_array *array,
711 hda_nid_t nid)
712{
713 int i;
714 for (i = 0; i < array->used; i++) {
715 struct hda_pincfg *pin = snd_array_elem(array, i);
716 if (pin->nid == nid)
717 return pin;
718 }
719 return NULL;
720}
721
722/* write a config value for the given NID */
723static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
724 unsigned int cfg)
725{
726 int i;
727 for (i = 0; i < 4; i++) {
728 snd_hda_codec_write(codec, nid, 0,
729 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
730 cfg & 0xff);
731 cfg >>= 8;
732 }
733}
734
735/* set the current pin config value for the given NID.
736 * the value is cached, and read via snd_hda_codec_get_pincfg()
737 */
738int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
739 hda_nid_t nid, unsigned int cfg)
740{
741 struct hda_pincfg *pin;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100742 unsigned int oldcfg;
Takashi Iwai3be14142009-02-20 14:11:16 +0100743
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100744 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +0100745 pin = look_up_pincfg(codec, list, nid);
746 if (!pin) {
747 pin = snd_array_new(list);
748 if (!pin)
749 return -ENOMEM;
750 pin->nid = nid;
751 }
752 pin->cfg = cfg;
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100753
754 /* change only when needed; e.g. if the pincfg is already present
755 * in user_pins[], don't write it
756 */
757 cfg = snd_hda_codec_get_pincfg(codec, nid);
758 if (oldcfg != cfg)
759 set_pincfg(codec, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +0100760 return 0;
761}
762
763int snd_hda_codec_set_pincfg(struct hda_codec *codec,
764 hda_nid_t nid, unsigned int cfg)
765{
Takashi Iwai346ff702009-02-23 09:42:57 +0100766 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
Takashi Iwai3be14142009-02-20 14:11:16 +0100767}
768EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
769
770/* get the current pin config value of the given pin NID */
771unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
772{
773 struct hda_pincfg *pin;
774
Takashi Iwai3be14142009-02-20 14:11:16 +0100775#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +0100776 pin = look_up_pincfg(codec, &codec->user_pins, nid);
Takashi Iwai3be14142009-02-20 14:11:16 +0100777 if (pin)
778 return pin->cfg;
779#endif
Takashi Iwai5e7b8e02009-02-23 09:45:59 +0100780 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
781 if (pin)
782 return pin->cfg;
Takashi Iwai3be14142009-02-20 14:11:16 +0100783 pin = look_up_pincfg(codec, &codec->init_pins, nid);
784 if (pin)
785 return pin->cfg;
786 return 0;
787}
788EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
789
790/* restore all current pin configs */
791static void restore_pincfgs(struct hda_codec *codec)
792{
793 int i;
794 for (i = 0; i < codec->init_pins.used; i++) {
795 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
796 set_pincfg(codec, pin->nid,
797 snd_hda_codec_get_pincfg(codec, pin->nid));
798 }
799}
Takashi Iwai54d17402005-11-21 16:33:22 +0100800
Takashi Iwai01751f52007-08-10 16:59:39 +0200801static void init_hda_cache(struct hda_cache_rec *cache,
802 unsigned int record_size);
Takashi Iwai1fcaee62007-08-23 00:01:09 +0200803static void free_hda_cache(struct hda_cache_rec *cache);
Takashi Iwai01751f52007-08-10 16:59:39 +0200804
Takashi Iwai3be14142009-02-20 14:11:16 +0100805/* restore the initial pin cfgs and release all pincfg lists */
806static void restore_init_pincfgs(struct hda_codec *codec)
807{
Takashi Iwai346ff702009-02-23 09:42:57 +0100808 /* first free driver_pins and user_pins, then call restore_pincfg
Takashi Iwai3be14142009-02-20 14:11:16 +0100809 * so that only the values in init_pins are restored
810 */
Takashi Iwai346ff702009-02-23 09:42:57 +0100811 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +0100812#ifdef CONFIG_SND_HDA_HWDEP
Takashi Iwai346ff702009-02-23 09:42:57 +0100813 snd_array_free(&codec->user_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +0100814#endif
815 restore_pincfgs(codec);
816 snd_array_free(&codec->init_pins);
817}
818
Takashi Iwai54d17402005-11-21 16:33:22 +0100819/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 * codec destructor
821 */
822static void snd_hda_codec_free(struct hda_codec *codec)
823{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200824 if (!codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 return;
Takashi Iwai3be14142009-02-20 14:11:16 +0100826 restore_init_pincfgs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200827#ifdef CONFIG_SND_HDA_POWER_SAVE
828 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100829 flush_workqueue(codec->bus->workq);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200830#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 list_del(&codec->list);
Takashi Iwaid13bd412008-07-30 15:01:45 +0200832 snd_array_free(&codec->mixers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 codec->bus->caddr_tbl[codec->addr] = NULL;
834 if (codec->patch_ops.free)
835 codec->patch_ops.free(codec);
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100836 module_put(codec->owner);
Takashi Iwai01751f52007-08-10 16:59:39 +0200837 free_hda_cache(&codec->amp_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200838 free_hda_cache(&codec->cmd_cache);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200839 kfree(codec->name);
840 kfree(codec->modelname);
Takashi Iwai54d17402005-11-21 16:33:22 +0100841 kfree(codec->wcaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 kfree(codec);
843}
844
Takashi Iwaibb6ac722009-03-13 09:02:42 +0100845static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
846 unsigned int power_state);
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848/**
849 * snd_hda_codec_new - create a HDA codec
850 * @bus: the bus to assign
851 * @codec_addr: the codec address
852 * @codecp: the pointer to store the generated codec
853 *
854 * Returns 0 if successful, or a negative error code.
855 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100856int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100857 int do_init, struct hda_codec **codecp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
859 struct hda_codec *codec;
Jaroslav Kyselaba443682008-08-13 20:55:32 +0200860 char component[31];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 int err;
862
Takashi Iwaida3cec32008-08-08 17:12:14 +0200863 if (snd_BUG_ON(!bus))
864 return -EINVAL;
865 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
866 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 if (bus->caddr_tbl[codec_addr]) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200869 snd_printk(KERN_ERR "hda_codec: "
870 "address 0x%x is already occupied\n", codec_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return -EBUSY;
872 }
873
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200874 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 if (codec == NULL) {
876 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
877 return -ENOMEM;
878 }
879
880 codec->bus = bus;
881 codec->addr = codec_addr;
Ingo Molnar62932df2006-01-16 16:34:20 +0100882 mutex_init(&codec->spdif_mutex);
Wu Fengguang5a9e02e2009-01-09 16:45:24 +0800883 mutex_init(&codec->control_mutex);
Takashi Iwai01751f52007-08-10 16:59:39 +0200884 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200885 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwaid13bd412008-07-30 15:01:45 +0200886 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
Takashi Iwai3be14142009-02-20 14:11:16 +0100887 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai346ff702009-02-23 09:42:57 +0100888 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200889 if (codec->bus->modelname) {
890 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
891 if (!codec->modelname) {
892 snd_hda_codec_free(codec);
893 return -ENODEV;
894 }
895 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Takashi Iwaicb53c622007-08-10 17:21:45 +0200897#ifdef CONFIG_SND_HDA_POWER_SAVE
898 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
899 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
900 * the caller has to power down appropriatley after initialization
901 * phase.
902 */
903 hda_keep_power_on(codec);
904#endif
905
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 list_add_tail(&codec->list, &bus->codec_list);
907 bus->caddr_tbl[codec_addr] = codec;
908
Takashi Iwai0ba21762007-04-16 11:29:14 +0200909 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
910 AC_PAR_VENDOR_ID);
Takashi Iwai111d3af2006-02-16 18:17:58 +0100911 if (codec->vendor_id == -1)
912 /* read again, hopefully the access method was corrected
913 * in the last read...
914 */
915 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
916 AC_PAR_VENDOR_ID);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200917 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
918 AC_PAR_SUBSYSTEM_ID);
919 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
920 AC_PAR_REV_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200922 setup_fg_nodes(codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200923 if (!codec->afg && !codec->mfg) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200924 snd_printdd("hda_codec: no AFG or MFG node found\n");
Takashi Iwai3be14142009-02-20 14:11:16 +0100925 err = -ENODEV;
926 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 }
928
Takashi Iwai3be14142009-02-20 14:11:16 +0100929 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
930 if (err < 0) {
Takashi Iwai54d17402005-11-21 16:33:22 +0100931 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
Takashi Iwai3be14142009-02-20 14:11:16 +0100932 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +0100933 }
Takashi Iwai3be14142009-02-20 14:11:16 +0100934 err = read_pin_defaults(codec);
935 if (err < 0)
936 goto error;
Takashi Iwai54d17402005-11-21 16:33:22 +0100937
Takashi Iwai0ba21762007-04-16 11:29:14 +0200938 if (!codec->subsystem_id) {
Takashi Iwai86284e42005-10-11 15:05:54 +0200939 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200940 codec->subsystem_id =
941 snd_hda_codec_read(codec, nid, 0,
942 AC_VERB_GET_SUBSYSTEM_ID, 0);
Takashi Iwai86284e42005-10-11 15:05:54 +0200943 }
Takashi Iwaif44ac832008-07-30 15:01:45 +0200944 if (bus->modelname)
945 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
Takashi Iwai86284e42005-10-11 15:05:54 +0200946
Takashi Iwaibb6ac722009-03-13 09:02:42 +0100947 /* power-up all before initialization */
948 hda_set_power_state(codec,
949 codec->afg ? codec->afg : codec->mfg,
950 AC_PWRST_D0);
951
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100952 if (do_init) {
953 err = snd_hda_codec_configure(codec);
Takashi Iwai3be14142009-02-20 14:11:16 +0100954 if (err < 0)
955 goto error;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200956 }
957 snd_hda_codec_proc_new(codec);
958
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200959 snd_hda_create_hwdep(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200960
961 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
962 codec->subsystem_id, codec->revision_id);
963 snd_component_add(codec->bus->card, component);
964
965 if (codecp)
966 *codecp = codec;
967 return 0;
Takashi Iwai3be14142009-02-20 14:11:16 +0100968
969 error:
970 snd_hda_codec_free(codec);
971 return err;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200972}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100973EXPORT_SYMBOL_HDA(snd_hda_codec_new);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200974
975int snd_hda_codec_configure(struct hda_codec *codec)
976{
977 int err;
978
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100979 codec->preset = find_codec_preset(codec);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200980 if (!codec->name) {
981 err = get_codec_name(codec);
982 if (err < 0)
983 return err;
984 }
Takashi Iwai43ea1d42007-04-26 19:12:08 +0200985 /* audio codec should override the mixer name */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200986 if (codec->afg || !*codec->bus->card->mixername)
987 strlcpy(codec->bus->card->mixername, codec->name,
988 sizeof(codec->bus->card->mixername));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Takashi Iwai82467612007-07-27 19:15:54 +0200990 if (is_generic_config(codec)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai82467612007-07-27 19:15:54 +0200992 goto patched;
993 }
Takashi Iwai82467612007-07-27 19:15:54 +0200994 if (codec->preset && codec->preset->patch) {
995 err = codec->preset->patch(codec);
996 goto patched;
997 }
998
999 /* call the default parser */
Takashi Iwai82467612007-07-27 19:15:54 +02001000 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai35a1e0c2007-10-19 08:13:40 +02001001 if (err < 0)
1002 printk(KERN_ERR "hda-codec: No codec parser is available\n");
Takashi Iwai82467612007-07-27 19:15:54 +02001003
1004 patched:
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001005 if (!err && codec->patch_ops.unsol_event)
1006 err = init_unsol_queue(codec->bus);
1007 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
1010/**
1011 * snd_hda_codec_setup_stream - set up the codec for streaming
1012 * @codec: the CODEC to set up
1013 * @nid: the NID to set up
1014 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1015 * @channel_id: channel id to pass, zero based.
1016 * @format: stream format.
1017 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001018void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1019 u32 stream_tag,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 int channel_id, int format)
1021{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001022 if (!nid)
Takashi Iwaid21b37e2005-04-20 13:45:55 +02001023 return;
1024
Takashi Iwai0ba21762007-04-16 11:29:14 +02001025 snd_printdd("hda_codec_setup_stream: "
1026 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 nid, stream_tag, channel_id, format);
1028 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1029 (stream_tag << 4) | channel_id);
1030 msleep(1);
1031 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1032}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001033EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
Takashi Iwai888afa12008-03-18 09:57:50 +01001035void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1036{
1037 if (!nid)
1038 return;
1039
1040 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1041 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1042#if 0 /* keep the format */
1043 msleep(1);
1044 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1045#endif
1046}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001047EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
Takashi Iwai888afa12008-03-18 09:57:50 +01001048
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049/*
1050 * amp access functions
1051 */
1052
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001053/* FIXME: more better hash key? */
1054#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055#define INFO_AMP_CAPS (1<<0)
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001056#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058/* initialize the hash table */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001059static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
Takashi Iwai01751f52007-08-10 16:59:39 +02001060 unsigned int record_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
Takashi Iwai01751f52007-08-10 16:59:39 +02001062 memset(cache, 0, sizeof(*cache));
1063 memset(cache->hash, 0xff, sizeof(cache->hash));
Takashi Iwai603c4012008-07-30 15:01:44 +02001064 snd_array_init(&cache->buf, record_size, 64);
Takashi Iwai01751f52007-08-10 16:59:39 +02001065}
1066
Takashi Iwai1fcaee62007-08-23 00:01:09 +02001067static void free_hda_cache(struct hda_cache_rec *cache)
Takashi Iwai01751f52007-08-10 16:59:39 +02001068{
Takashi Iwai603c4012008-07-30 15:01:44 +02001069 snd_array_free(&cache->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070}
1071
1072/* query the hash. allocate an entry if not found. */
Takashi Iwai01751f52007-08-10 16:59:39 +02001073static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1074 u32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
Takashi Iwai01751f52007-08-10 16:59:39 +02001076 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1077 u16 cur = cache->hash[idx];
1078 struct hda_cache_head *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 while (cur != 0xffff) {
Takashi Iwaif43aa022008-11-10 16:24:26 +01001081 info = snd_array_elem(&cache->buf, cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 if (info->key == key)
1083 return info;
1084 cur = info->next;
1085 }
1086
1087 /* add a new hash entry */
Takashi Iwai603c4012008-07-30 15:01:44 +02001088 info = snd_array_new(&cache->buf);
Takashi Iwaic2174292008-11-07 00:23:30 +01001089 if (!info)
1090 return NULL;
Takashi Iwaif43aa022008-11-10 16:24:26 +01001091 cur = snd_array_index(&cache->buf, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 info->key = key;
Takashi Iwai01751f52007-08-10 16:59:39 +02001093 info->val = 0;
1094 info->next = cache->hash[idx];
1095 cache->hash[idx] = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
1097 return info;
1098}
1099
Takashi Iwai01751f52007-08-10 16:59:39 +02001100/* query and allocate an amp hash entry */
1101static inline struct hda_amp_info *
1102get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1103{
1104 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1105}
1106
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107/*
1108 * query AMP capabilities for the given widget and direction
1109 */
Matthew Ranostay09a99952008-01-24 11:49:21 +01001110u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001112 struct hda_amp_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Takashi Iwai0ba21762007-04-16 11:29:14 +02001114 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1115 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 return 0;
Takashi Iwai01751f52007-08-10 16:59:39 +02001117 if (!(info->head.val & INFO_AMP_CAPS)) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001118 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 nid = codec->afg;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001120 info->amp_caps = snd_hda_param_read(codec, nid,
1121 direction == HDA_OUTPUT ?
1122 AC_PAR_AMP_OUT_CAP :
1123 AC_PAR_AMP_IN_CAP);
Takashi Iwaib75e53f2007-05-10 16:56:09 +02001124 if (info->amp_caps)
Takashi Iwai01751f52007-08-10 16:59:39 +02001125 info->head.val |= INFO_AMP_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 }
1127 return info->amp_caps;
1128}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001129EXPORT_SYMBOL_HDA(query_amp_caps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Takashi Iwai897cc182007-05-29 19:01:37 +02001131int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1132 unsigned int caps)
1133{
1134 struct hda_amp_info *info;
1135
1136 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1137 if (!info)
1138 return -EINVAL;
1139 info->amp_caps = caps;
Takashi Iwai01751f52007-08-10 16:59:39 +02001140 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai897cc182007-05-29 19:01:37 +02001141 return 0;
1142}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001143EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
Takashi Iwai897cc182007-05-29 19:01:37 +02001144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145/*
1146 * read the current volume to info
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001147 * if the cache exists, read the cache value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001149static unsigned int get_vol_mute(struct hda_codec *codec,
1150 struct hda_amp_info *info, hda_nid_t nid,
1151 int ch, int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152{
1153 u32 val, parm;
1154
Takashi Iwai01751f52007-08-10 16:59:39 +02001155 if (info->head.val & INFO_AMP_VOL(ch))
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001156 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1159 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1160 parm |= index;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001161 val = snd_hda_codec_read(codec, nid, 0,
1162 AC_VERB_GET_AMP_GAIN_MUTE, parm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 info->vol[ch] = val & 0xff;
Takashi Iwai01751f52007-08-10 16:59:39 +02001164 info->head.val |= INFO_AMP_VOL(ch);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001165 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166}
1167
1168/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001169 * write the current volume in info to the h/w and update the cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 */
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001171static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
Takashi Iwai0ba21762007-04-16 11:29:14 +02001172 hda_nid_t nid, int ch, int direction, int index,
1173 int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174{
1175 u32 parm;
1176
1177 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1178 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1179 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1180 parm |= val;
1181 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001182 info->vol[ch] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183}
1184
1185/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001186 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 */
Takashi Iwai834be882006-03-01 14:16:17 +01001188int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1189 int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001191 struct hda_amp_info *info;
1192 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1193 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001195 return get_vol_mute(codec, info, nid, ch, direction, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001197EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001199/*
1200 * update the AMP value, mask = bit mask to set, val = the value
1201 */
Takashi Iwai834be882006-03-01 14:16:17 +01001202int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1203 int direction, int idx, int mask, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001205 struct hda_amp_info *info;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001206
Takashi Iwai0ba21762007-04-16 11:29:14 +02001207 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1208 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001210 val &= mask;
1211 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001212 if (info->vol[ch] == val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001214 put_vol_mute(codec, info, nid, ch, direction, idx, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 return 1;
1216}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001217EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Takashi Iwai47fd8302007-08-10 17:11:07 +02001219/*
1220 * update the AMP stereo with the same mask and value
1221 */
1222int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1223 int direction, int idx, int mask, int val)
1224{
1225 int ch, ret = 0;
1226 for (ch = 0; ch < 2; ch++)
1227 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1228 idx, mask, val);
1229 return ret;
1230}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001231EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
Takashi Iwai47fd8302007-08-10 17:11:07 +02001232
Takashi Iwaicb53c622007-08-10 17:21:45 +02001233#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001234/* resume the all amp commands from the cache */
1235void snd_hda_codec_resume_amp(struct hda_codec *codec)
1236{
Takashi Iwai603c4012008-07-30 15:01:44 +02001237 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001238 int i;
1239
Takashi Iwai603c4012008-07-30 15:01:44 +02001240 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001241 u32 key = buffer->head.key;
1242 hda_nid_t nid;
1243 unsigned int idx, dir, ch;
1244 if (!key)
1245 continue;
1246 nid = key & 0xff;
1247 idx = (key >> 16) & 0xff;
1248 dir = (key >> 24) & 0xff;
1249 for (ch = 0; ch < 2; ch++) {
1250 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1251 continue;
1252 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1253 buffer->vol[ch]);
1254 }
1255 }
1256}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001257EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001258#endif /* SND_HDA_NEEDS_RESUME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260/* volume */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001261int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1262 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263{
1264 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1265 u16 nid = get_amp_nid(kcontrol);
1266 u8 chs = get_amp_channels(kcontrol);
1267 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001268 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 u32 caps;
1270
1271 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001272 /* num steps */
1273 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1274 if (!caps) {
1275 printk(KERN_WARNING "hda_codec: "
Takashi Iwai9c8f2ab2008-01-11 16:12:23 +01001276 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1277 kcontrol->id.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 return -EINVAL;
1279 }
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001280 if (ofs < caps)
1281 caps -= ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1283 uinfo->count = chs == 3 ? 2 : 1;
1284 uinfo->value.integer.min = 0;
1285 uinfo->value.integer.max = caps;
1286 return 0;
1287}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001288EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001290
1291static inline unsigned int
1292read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1293 int ch, int dir, int idx, unsigned int ofs)
1294{
1295 unsigned int val;
1296 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1297 val &= HDA_AMP_VOLMASK;
1298 if (val >= ofs)
1299 val -= ofs;
1300 else
1301 val = 0;
1302 return val;
1303}
1304
1305static inline int
1306update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1307 int ch, int dir, int idx, unsigned int ofs,
1308 unsigned int val)
1309{
1310 if (val > 0)
1311 val += ofs;
1312 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1313 HDA_AMP_VOLMASK, val);
1314}
1315
Takashi Iwai0ba21762007-04-16 11:29:14 +02001316int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1317 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
1319 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1320 hda_nid_t nid = get_amp_nid(kcontrol);
1321 int chs = get_amp_channels(kcontrol);
1322 int dir = get_amp_direction(kcontrol);
1323 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001324 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 long *valp = ucontrol->value.integer.value;
1326
1327 if (chs & 1)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001328 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001330 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 return 0;
1332}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001333EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Takashi Iwai0ba21762007-04-16 11:29:14 +02001335int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1336 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337{
1338 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1339 hda_nid_t nid = get_amp_nid(kcontrol);
1340 int chs = get_amp_channels(kcontrol);
1341 int dir = get_amp_direction(kcontrol);
1342 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001343 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 long *valp = ucontrol->value.integer.value;
1345 int change = 0;
1346
Takashi Iwaicb53c622007-08-10 17:21:45 +02001347 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001348 if (chs & 1) {
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001349 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001350 valp++;
1351 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001352 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001353 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001354 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 return change;
1356}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001357EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001359int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1360 unsigned int size, unsigned int __user *_tlv)
1361{
1362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1363 hda_nid_t nid = get_amp_nid(kcontrol);
1364 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001365 unsigned int ofs = get_amp_offset(kcontrol);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001366 u32 caps, val1, val2;
1367
1368 if (size < 4 * sizeof(unsigned int))
1369 return -ENOMEM;
1370 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001371 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1372 val2 = (val2 + 1) * 25;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001373 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001374 val1 += ofs;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001375 val1 = ((int)val1) * ((int)val2);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001376 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1377 return -EFAULT;
1378 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1379 return -EFAULT;
1380 if (put_user(val1, _tlv + 2))
1381 return -EFAULT;
1382 if (put_user(val2, _tlv + 3))
1383 return -EFAULT;
1384 return 0;
1385}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001386EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001387
Takashi Iwai2134ea42008-01-10 16:53:55 +01001388/*
1389 * set (static) TLV for virtual master volume; recalculated as max 0dB
1390 */
1391void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1392 unsigned int *tlv)
1393{
1394 u32 caps;
1395 int nums, step;
1396
1397 caps = query_amp_caps(codec, nid, dir);
1398 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1399 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1400 step = (step + 1) * 25;
1401 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1402 tlv[1] = 2 * sizeof(unsigned int);
1403 tlv[2] = -nums * step;
1404 tlv[3] = step;
1405}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001406EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001407
1408/* find a mixer control element with the given name */
Takashi Iwai09f99702008-02-04 12:31:13 +01001409static struct snd_kcontrol *
1410_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1411 const char *name, int idx)
Takashi Iwai2134ea42008-01-10 16:53:55 +01001412{
1413 struct snd_ctl_elem_id id;
1414 memset(&id, 0, sizeof(id));
1415 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
Takashi Iwai09f99702008-02-04 12:31:13 +01001416 id.index = idx;
Takashi Iwai2134ea42008-01-10 16:53:55 +01001417 strcpy(id.name, name);
1418 return snd_ctl_find_id(codec->bus->card, &id);
1419}
1420
Takashi Iwai09f99702008-02-04 12:31:13 +01001421struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1422 const char *name)
1423{
1424 return _snd_hda_find_mixer_ctl(codec, name, 0);
1425}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001426EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
Takashi Iwai09f99702008-02-04 12:31:13 +01001427
Takashi Iwaid13bd412008-07-30 15:01:45 +02001428/* Add a control element and assign to the codec */
1429int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1430{
1431 int err;
1432 struct snd_kcontrol **knewp;
1433
1434 err = snd_ctl_add(codec->bus->card, kctl);
1435 if (err < 0)
1436 return err;
1437 knewp = snd_array_new(&codec->mixers);
1438 if (!knewp)
1439 return -ENOMEM;
1440 *knewp = kctl;
1441 return 0;
1442}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001443EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001444
1445/* Clear all controls assigned to the given codec */
1446void snd_hda_ctls_clear(struct hda_codec *codec)
1447{
1448 int i;
1449 struct snd_kcontrol **kctls = codec->mixers.list;
1450 for (i = 0; i < codec->mixers.used; i++)
1451 snd_ctl_remove(codec->bus->card, kctls[i]);
1452 snd_array_free(&codec->mixers);
1453}
1454
Takashi Iwaia65d6292009-02-23 16:57:04 +01001455/* pseudo device locking
1456 * toggle card->shutdown to allow/disallow the device access (as a hack)
1457 */
1458static int hda_lock_devices(struct snd_card *card)
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001459{
Takashi Iwaia65d6292009-02-23 16:57:04 +01001460 spin_lock(&card->files_lock);
1461 if (card->shutdown) {
1462 spin_unlock(&card->files_lock);
1463 return -EINVAL;
1464 }
1465 card->shutdown = 1;
1466 spin_unlock(&card->files_lock);
1467 return 0;
1468}
1469
1470static void hda_unlock_devices(struct snd_card *card)
1471{
1472 spin_lock(&card->files_lock);
1473 card->shutdown = 0;
1474 spin_unlock(&card->files_lock);
1475}
1476
1477int snd_hda_codec_reset(struct hda_codec *codec)
1478{
1479 struct snd_card *card = codec->bus->card;
1480 int i, pcm;
1481
1482 if (hda_lock_devices(card) < 0)
1483 return -EBUSY;
1484 /* check whether the codec isn't used by any mixer or PCM streams */
1485 if (!list_empty(&card->ctl_files)) {
1486 hda_unlock_devices(card);
1487 return -EBUSY;
1488 }
1489 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1490 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1491 if (!cpcm->pcm)
1492 continue;
1493 if (cpcm->pcm->streams[0].substream_opened ||
1494 cpcm->pcm->streams[1].substream_opened) {
1495 hda_unlock_devices(card);
1496 return -EBUSY;
1497 }
1498 }
1499
1500 /* OK, let it free */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001501
1502#ifdef CONFIG_SND_HDA_POWER_SAVE
1503 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01001504 flush_workqueue(codec->bus->workq);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001505#endif
1506 snd_hda_ctls_clear(codec);
1507 /* relase PCMs */
1508 for (i = 0; i < codec->num_pcms; i++) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001509 if (codec->pcm_info[i].pcm) {
Takashi Iwaia65d6292009-02-23 16:57:04 +01001510 snd_device_free(card, codec->pcm_info[i].pcm);
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001511 clear_bit(codec->pcm_info[i].device,
1512 codec->bus->pcm_dev_bits);
1513 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001514 }
1515 if (codec->patch_ops.free)
1516 codec->patch_ops.free(codec);
Takashi Iwai56d17712008-11-28 14:36:23 +01001517 codec->proc_widget_hook = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001518 codec->spec = NULL;
1519 free_hda_cache(&codec->amp_cache);
1520 free_hda_cache(&codec->cmd_cache);
Takashi Iwai827057f2008-12-19 10:12:02 +01001521 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1522 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwai346ff702009-02-23 09:42:57 +01001523 /* free only driver_pins so that init_pins + user_pins are restored */
1524 snd_array_free(&codec->driver_pins);
Takashi Iwai3be14142009-02-20 14:11:16 +01001525 restore_pincfgs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001526 codec->num_pcms = 0;
1527 codec->pcm_info = NULL;
1528 codec->preset = NULL;
Takashi Iwaid1f1af22009-03-02 10:35:29 +01001529 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1530 codec->slave_dig_outs = NULL;
1531 codec->spdif_status_reset = 0;
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001532 module_put(codec->owner);
1533 codec->owner = NULL;
Takashi Iwaia65d6292009-02-23 16:57:04 +01001534
1535 /* allow device access again */
1536 hda_unlock_devices(card);
1537 return 0;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001538}
1539
Takashi Iwai2134ea42008-01-10 16:53:55 +01001540/* create a virtual master control and add slaves */
1541int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1542 unsigned int *tlv, const char **slaves)
1543{
1544 struct snd_kcontrol *kctl;
1545 const char **s;
1546 int err;
1547
Takashi Iwai2f085542008-02-22 18:43:50 +01001548 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1549 ;
1550 if (!*s) {
1551 snd_printdd("No slave found for %s\n", name);
1552 return 0;
1553 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01001554 kctl = snd_ctl_make_virtual_master(name, tlv);
1555 if (!kctl)
1556 return -ENOMEM;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001557 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001558 if (err < 0)
1559 return err;
1560
1561 for (s = slaves; *s; s++) {
1562 struct snd_kcontrol *sctl;
Takashi Iwai7a411ee2009-03-06 10:08:14 +01001563 int i = 0;
1564 for (;;) {
1565 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1566 if (!sctl) {
1567 if (!i)
1568 snd_printdd("Cannot find slave %s, "
1569 "skipped\n", *s);
1570 break;
1571 }
1572 err = snd_ctl_add_slave(kctl, sctl);
1573 if (err < 0)
1574 return err;
1575 i++;
Takashi Iwai2134ea42008-01-10 16:53:55 +01001576 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01001577 }
1578 return 0;
1579}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001580EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001581
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582/* switch */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001583int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1584 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{
1586 int chs = get_amp_channels(kcontrol);
1587
1588 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1589 uinfo->count = chs == 3 ? 2 : 1;
1590 uinfo->value.integer.min = 0;
1591 uinfo->value.integer.max = 1;
1592 return 0;
1593}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001594EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
Takashi Iwai0ba21762007-04-16 11:29:14 +02001596int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1597 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598{
1599 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1600 hda_nid_t nid = get_amp_nid(kcontrol);
1601 int chs = get_amp_channels(kcontrol);
1602 int dir = get_amp_direction(kcontrol);
1603 int idx = get_amp_index(kcontrol);
1604 long *valp = ucontrol->value.integer.value;
1605
1606 if (chs & 1)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001607 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001608 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 if (chs & 2)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001610 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001611 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 return 0;
1613}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001614EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Takashi Iwai0ba21762007-04-16 11:29:14 +02001616int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1617 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618{
1619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1620 hda_nid_t nid = get_amp_nid(kcontrol);
1621 int chs = get_amp_channels(kcontrol);
1622 int dir = get_amp_direction(kcontrol);
1623 int idx = get_amp_index(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 long *valp = ucontrol->value.integer.value;
1625 int change = 0;
1626
Takashi Iwaicb53c622007-08-10 17:21:45 +02001627 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001628 if (chs & 1) {
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001629 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001630 HDA_AMP_MUTE,
1631 *valp ? 0 : HDA_AMP_MUTE);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001632 valp++;
1633 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001634 if (chs & 2)
1635 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001636 HDA_AMP_MUTE,
1637 *valp ? 0 : HDA_AMP_MUTE);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001638#ifdef CONFIG_SND_HDA_POWER_SAVE
1639 if (codec->patch_ops.check_power_status)
1640 codec->patch_ops.check_power_status(codec, nid);
1641#endif
1642 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 return change;
1644}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001645EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647/*
Takashi Iwai985be542005-11-02 18:26:49 +01001648 * bound volume controls
1649 *
1650 * bind multiple volumes (# indices, from 0)
1651 */
1652
1653#define AMP_VAL_IDX_SHIFT 19
1654#define AMP_VAL_IDX_MASK (0x0f<<19)
1655
Takashi Iwai0ba21762007-04-16 11:29:14 +02001656int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1657 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01001658{
1659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1660 unsigned long pval;
1661 int err;
1662
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001663 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001664 pval = kcontrol->private_value;
1665 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1666 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1667 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001668 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001669 return err;
1670}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001671EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
Takashi Iwai985be542005-11-02 18:26:49 +01001672
Takashi Iwai0ba21762007-04-16 11:29:14 +02001673int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1674 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01001675{
1676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1677 unsigned long pval;
1678 int i, indices, err = 0, change = 0;
1679
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001680 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001681 pval = kcontrol->private_value;
1682 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1683 for (i = 0; i < indices; i++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001684 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1685 (i << AMP_VAL_IDX_SHIFT);
Takashi Iwai985be542005-11-02 18:26:49 +01001686 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1687 if (err < 0)
1688 break;
1689 change |= err;
1690 }
1691 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001692 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001693 return err < 0 ? err : change;
1694}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001695EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
Takashi Iwai985be542005-11-02 18:26:49 +01001696
1697/*
Takashi Iwai532d5382007-07-27 19:02:40 +02001698 * generic bound volume/swtich controls
1699 */
1700int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_info *uinfo)
1702{
1703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1704 struct hda_bind_ctls *c;
1705 int err;
1706
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001707 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001708 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001709 kcontrol->private_value = *c->values;
1710 err = c->ops->info(kcontrol, uinfo);
1711 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001712 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001713 return err;
1714}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001715EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
Takashi Iwai532d5382007-07-27 19:02:40 +02001716
1717int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1718 struct snd_ctl_elem_value *ucontrol)
1719{
1720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1721 struct hda_bind_ctls *c;
1722 int err;
1723
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001724 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001725 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001726 kcontrol->private_value = *c->values;
1727 err = c->ops->get(kcontrol, ucontrol);
1728 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001729 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001730 return err;
1731}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001732EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
Takashi Iwai532d5382007-07-27 19:02:40 +02001733
1734int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1735 struct snd_ctl_elem_value *ucontrol)
1736{
1737 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1738 struct hda_bind_ctls *c;
1739 unsigned long *vals;
1740 int err = 0, change = 0;
1741
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001742 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001743 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001744 for (vals = c->values; *vals; vals++) {
1745 kcontrol->private_value = *vals;
1746 err = c->ops->put(kcontrol, ucontrol);
1747 if (err < 0)
1748 break;
1749 change |= err;
1750 }
1751 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001752 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001753 return err < 0 ? err : change;
1754}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001755EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
Takashi Iwai532d5382007-07-27 19:02:40 +02001756
1757int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1758 unsigned int size, unsigned int __user *tlv)
1759{
1760 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1761 struct hda_bind_ctls *c;
1762 int err;
1763
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001764 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001765 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001766 kcontrol->private_value = *c->values;
1767 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1768 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001769 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001770 return err;
1771}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001772EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
Takashi Iwai532d5382007-07-27 19:02:40 +02001773
1774struct hda_ctl_ops snd_hda_bind_vol = {
1775 .info = snd_hda_mixer_amp_volume_info,
1776 .get = snd_hda_mixer_amp_volume_get,
1777 .put = snd_hda_mixer_amp_volume_put,
1778 .tlv = snd_hda_mixer_amp_tlv
1779};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001780EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
Takashi Iwai532d5382007-07-27 19:02:40 +02001781
1782struct hda_ctl_ops snd_hda_bind_sw = {
1783 .info = snd_hda_mixer_amp_switch_info,
1784 .get = snd_hda_mixer_amp_switch_get,
1785 .put = snd_hda_mixer_amp_switch_put,
1786 .tlv = snd_hda_mixer_amp_tlv
1787};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001788EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
Takashi Iwai532d5382007-07-27 19:02:40 +02001789
1790/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 * SPDIF out controls
1792 */
1793
Takashi Iwai0ba21762007-04-16 11:29:14 +02001794static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1795 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796{
1797 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1798 uinfo->count = 1;
1799 return 0;
1800}
1801
Takashi Iwai0ba21762007-04-16 11:29:14 +02001802static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1803 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
1805 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1806 IEC958_AES0_NONAUDIO |
1807 IEC958_AES0_CON_EMPHASIS_5015 |
1808 IEC958_AES0_CON_NOT_COPYRIGHT;
1809 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1810 IEC958_AES1_CON_ORIGINAL;
1811 return 0;
1812}
1813
Takashi Iwai0ba21762007-04-16 11:29:14 +02001814static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816{
1817 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1818 IEC958_AES0_NONAUDIO |
1819 IEC958_AES0_PRO_EMPHASIS_5015;
1820 return 0;
1821}
1822
Takashi Iwai0ba21762007-04-16 11:29:14 +02001823static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1824 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825{
1826 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1827
1828 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1829 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1830 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1831 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1832
1833 return 0;
1834}
1835
1836/* convert from SPDIF status bits to HDA SPDIF bits
1837 * bit 0 (DigEn) is always set zero (to be filled later)
1838 */
1839static unsigned short convert_from_spdif_status(unsigned int sbits)
1840{
1841 unsigned short val = 0;
1842
1843 if (sbits & IEC958_AES0_PROFESSIONAL)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001844 val |= AC_DIG1_PROFESSIONAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 if (sbits & IEC958_AES0_NONAUDIO)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001846 val |= AC_DIG1_NONAUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001848 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1849 IEC958_AES0_PRO_EMPHASIS_5015)
1850 val |= AC_DIG1_EMPHASIS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001852 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1853 IEC958_AES0_CON_EMPHASIS_5015)
1854 val |= AC_DIG1_EMPHASIS;
1855 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1856 val |= AC_DIG1_COPYRIGHT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
Takashi Iwai0ba21762007-04-16 11:29:14 +02001858 val |= AC_DIG1_LEVEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1860 }
1861 return val;
1862}
1863
1864/* convert to SPDIF status bits from HDA SPDIF bits
1865 */
1866static unsigned int convert_to_spdif_status(unsigned short val)
1867{
1868 unsigned int sbits = 0;
1869
Takashi Iwai0ba21762007-04-16 11:29:14 +02001870 if (val & AC_DIG1_NONAUDIO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 sbits |= IEC958_AES0_NONAUDIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001872 if (val & AC_DIG1_PROFESSIONAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 sbits |= IEC958_AES0_PROFESSIONAL;
1874 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001875 if (sbits & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1877 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001878 if (val & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001880 if (!(val & AC_DIG1_COPYRIGHT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001882 if (val & AC_DIG1_LEVEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1884 sbits |= val & (0x7f << 8);
1885 }
1886 return sbits;
1887}
1888
Takashi Iwai2f728532008-09-25 16:32:41 +02001889/* set digital convert verbs both for the given NID and its slaves */
1890static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1891 int verb, int val)
1892{
1893 hda_nid_t *d;
1894
Takashi Iwai9e976972008-11-25 08:17:20 +01001895 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02001896 d = codec->slave_dig_outs;
1897 if (!d)
1898 return;
1899 for (; *d; d++)
Takashi Iwai9e976972008-11-25 08:17:20 +01001900 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02001901}
1902
1903static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1904 int dig1, int dig2)
1905{
1906 if (dig1 != -1)
1907 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1908 if (dig2 != -1)
1909 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1910}
1911
Takashi Iwai0ba21762007-04-16 11:29:14 +02001912static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1913 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914{
1915 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1916 hda_nid_t nid = kcontrol->private_value;
1917 unsigned short val;
1918 int change;
1919
Ingo Molnar62932df2006-01-16 16:34:20 +01001920 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 codec->spdif_status = ucontrol->value.iec958.status[0] |
1922 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1923 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1924 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1925 val = convert_from_spdif_status(codec->spdif_status);
1926 val |= codec->spdif_ctls & 1;
1927 change = codec->spdif_ctls != val;
1928 codec->spdif_ctls = val;
1929
Takashi Iwai2f728532008-09-25 16:32:41 +02001930 if (change)
1931 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932
Ingo Molnar62932df2006-01-16 16:34:20 +01001933 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 return change;
1935}
1936
Takashi Iwaia5ce8892007-07-23 15:42:26 +02001937#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938
Takashi Iwai0ba21762007-04-16 11:29:14 +02001939static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1940 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941{
1942 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1943
Takashi Iwai0ba21762007-04-16 11:29:14 +02001944 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 return 0;
1946}
1947
Takashi Iwai0ba21762007-04-16 11:29:14 +02001948static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1949 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950{
1951 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1952 hda_nid_t nid = kcontrol->private_value;
1953 unsigned short val;
1954 int change;
1955
Ingo Molnar62932df2006-01-16 16:34:20 +01001956 mutex_lock(&codec->spdif_mutex);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001957 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 if (ucontrol->value.integer.value[0])
Takashi Iwai0ba21762007-04-16 11:29:14 +02001959 val |= AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 change = codec->spdif_ctls != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001961 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 codec->spdif_ctls = val;
Takashi Iwai2f728532008-09-25 16:32:41 +02001963 set_dig_out_convert(codec, nid, val & 0xff, -1);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001964 /* unmute amp switch (if any) */
1965 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
Takashi Iwai47fd8302007-08-10 17:11:07 +02001966 (val & AC_DIG1_ENABLE))
1967 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1968 HDA_AMP_MUTE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 }
Ingo Molnar62932df2006-01-16 16:34:20 +01001970 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 return change;
1972}
1973
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01001974static struct snd_kcontrol_new dig_mixes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 {
1976 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1977 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1978 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1979 .info = snd_hda_spdif_mask_info,
1980 .get = snd_hda_spdif_cmask_get,
1981 },
1982 {
1983 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1985 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1986 .info = snd_hda_spdif_mask_info,
1987 .get = snd_hda_spdif_pmask_get,
1988 },
1989 {
1990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1991 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1992 .info = snd_hda_spdif_mask_info,
1993 .get = snd_hda_spdif_default_get,
1994 .put = snd_hda_spdif_default_put,
1995 },
1996 {
1997 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1998 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1999 .info = snd_hda_spdif_out_switch_info,
2000 .get = snd_hda_spdif_out_switch_get,
2001 .put = snd_hda_spdif_out_switch_put,
2002 },
2003 { } /* end */
2004};
2005
Takashi Iwai09f99702008-02-04 12:31:13 +01002006#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008/**
2009 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2010 * @codec: the HDA codec
2011 * @nid: audio out widget NID
2012 *
2013 * Creates controls related with the SPDIF output.
2014 * Called from each patch supporting the SPDIF out.
2015 *
2016 * Returns 0 if successful, or a negative error code.
2017 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002018int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019{
2020 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002021 struct snd_kcontrol *kctl;
2022 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01002023 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024
Takashi Iwai09f99702008-02-04 12:31:13 +01002025 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2026 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2027 idx))
2028 break;
2029 }
2030 if (idx >= SPDIF_MAX_IDX) {
2031 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2032 return -EBUSY;
2033 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2035 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaib91f0802008-11-04 08:43:08 +01002036 if (!kctl)
2037 return -ENOMEM;
Takashi Iwai09f99702008-02-04 12:31:13 +01002038 kctl->id.index = idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 kctl->private_value = nid;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002040 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002041 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 return err;
2043 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002044 codec->spdif_ctls =
Andrew Paprocki3982d172007-12-19 12:13:44 +01002045 snd_hda_codec_read(codec, nid, 0,
2046 AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2048 return 0;
2049}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002050EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051
2052/*
Takashi Iwai9a081602008-02-12 18:37:26 +01002053 * SPDIF sharing with analog output
2054 */
2055static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2056 struct snd_ctl_elem_value *ucontrol)
2057{
2058 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2059 ucontrol->value.integer.value[0] = mout->share_spdif;
2060 return 0;
2061}
2062
2063static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2064 struct snd_ctl_elem_value *ucontrol)
2065{
2066 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2067 mout->share_spdif = !!ucontrol->value.integer.value[0];
2068 return 0;
2069}
2070
2071static struct snd_kcontrol_new spdif_share_sw = {
2072 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2073 .name = "IEC958 Default PCM Playback Switch",
2074 .info = snd_ctl_boolean_mono_info,
2075 .get = spdif_share_sw_get,
2076 .put = spdif_share_sw_put,
2077};
2078
2079int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2080 struct hda_multi_out *mout)
2081{
2082 if (!mout->dig_out_nid)
2083 return 0;
2084 /* ATTENTION: here mout is passed as private_data, instead of codec */
Takashi Iwaid13bd412008-07-30 15:01:45 +02002085 return snd_hda_ctl_add(codec,
Takashi Iwai9a081602008-02-12 18:37:26 +01002086 snd_ctl_new1(&spdif_share_sw, mout));
2087}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002088EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
Takashi Iwai9a081602008-02-12 18:37:26 +01002089
2090/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 * SPDIF input
2092 */
2093
2094#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2095
Takashi Iwai0ba21762007-04-16 11:29:14 +02002096static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2097 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098{
2099 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2100
2101 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2102 return 0;
2103}
2104
Takashi Iwai0ba21762007-04-16 11:29:14 +02002105static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2106 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107{
2108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2109 hda_nid_t nid = kcontrol->private_value;
2110 unsigned int val = !!ucontrol->value.integer.value[0];
2111 int change;
2112
Ingo Molnar62932df2006-01-16 16:34:20 +01002113 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 change = codec->spdif_in_enable != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002115 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 codec->spdif_in_enable = val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002117 snd_hda_codec_write_cache(codec, nid, 0,
2118 AC_VERB_SET_DIGI_CONVERT_1, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 }
Ingo Molnar62932df2006-01-16 16:34:20 +01002120 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 return change;
2122}
2123
Takashi Iwai0ba21762007-04-16 11:29:14 +02002124static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2125 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126{
2127 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2128 hda_nid_t nid = kcontrol->private_value;
2129 unsigned short val;
2130 unsigned int sbits;
2131
Andrew Paprocki3982d172007-12-19 12:13:44 +01002132 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 sbits = convert_to_spdif_status(val);
2134 ucontrol->value.iec958.status[0] = sbits;
2135 ucontrol->value.iec958.status[1] = sbits >> 8;
2136 ucontrol->value.iec958.status[2] = sbits >> 16;
2137 ucontrol->value.iec958.status[3] = sbits >> 24;
2138 return 0;
2139}
2140
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002141static struct snd_kcontrol_new dig_in_ctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 {
2143 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2144 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2145 .info = snd_hda_spdif_in_switch_info,
2146 .get = snd_hda_spdif_in_switch_get,
2147 .put = snd_hda_spdif_in_switch_put,
2148 },
2149 {
2150 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2152 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2153 .info = snd_hda_spdif_mask_info,
2154 .get = snd_hda_spdif_in_status_get,
2155 },
2156 { } /* end */
2157};
2158
2159/**
2160 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2161 * @codec: the HDA codec
2162 * @nid: audio in widget NID
2163 *
2164 * Creates controls related with the SPDIF input.
2165 * Called from each patch supporting the SPDIF in.
2166 *
2167 * Returns 0 if successful, or a negative error code.
2168 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002169int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170{
2171 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002172 struct snd_kcontrol *kctl;
2173 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01002174 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175
Takashi Iwai09f99702008-02-04 12:31:13 +01002176 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2177 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2178 idx))
2179 break;
2180 }
2181 if (idx >= SPDIF_MAX_IDX) {
2182 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2183 return -EBUSY;
2184 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2186 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaic8dcdf82009-02-06 16:21:20 +01002187 if (!kctl)
2188 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 kctl->private_value = nid;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002190 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002191 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 return err;
2193 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002194 codec->spdif_in_enable =
Andrew Paprocki3982d172007-12-19 12:13:44 +01002195 snd_hda_codec_read(codec, nid, 0,
2196 AC_VERB_GET_DIGI_CONVERT_1, 0) &
Takashi Iwai0ba21762007-04-16 11:29:14 +02002197 AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 return 0;
2199}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002200EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
Takashi Iwaicb53c622007-08-10 17:21:45 +02002202#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002203/*
2204 * command cache
2205 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002207/* build a 32bit cache key with the widget id and the command parameter */
2208#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2209#define get_cmd_cache_nid(key) ((key) & 0xff)
2210#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2211
2212/**
2213 * snd_hda_codec_write_cache - send a single command with caching
2214 * @codec: the HDA codec
2215 * @nid: NID to send the command
2216 * @direct: direct flag
2217 * @verb: the verb to send
2218 * @parm: the parameter for the verb
2219 *
2220 * Send a single command without waiting for response.
2221 *
2222 * Returns 0 if successful, or a negative error code.
2223 */
2224int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2225 int direct, unsigned int verb, unsigned int parm)
2226{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002227 struct hda_bus *bus = codec->bus;
2228 unsigned int res;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002229 int err;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002230
2231 res = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002232 snd_hda_power_up(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002233 mutex_lock(&bus->cmd_mutex);
2234 err = bus->ops.command(bus, res);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002235 if (!err) {
2236 struct hda_cache_head *c;
2237 u32 key = build_cmd_cache_key(nid, verb);
2238 c = get_alloc_hash(&codec->cmd_cache, key);
2239 if (c)
2240 c->val = parm;
2241 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002242 mutex_unlock(&bus->cmd_mutex);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002243 snd_hda_power_down(codec);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002244 return err;
2245}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002246EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002247
2248/* resume the all commands from the cache */
2249void snd_hda_codec_resume_cache(struct hda_codec *codec)
2250{
Takashi Iwai603c4012008-07-30 15:01:44 +02002251 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002252 int i;
2253
Takashi Iwai603c4012008-07-30 15:01:44 +02002254 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002255 u32 key = buffer->key;
2256 if (!key)
2257 continue;
2258 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2259 get_cmd_cache_cmd(key), buffer->val);
2260 }
2261}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002262EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002263
2264/**
2265 * snd_hda_sequence_write_cache - sequence writes with caching
2266 * @codec: the HDA codec
2267 * @seq: VERB array to send
2268 *
2269 * Send the commands sequentially from the given array.
2270 * Thte commands are recorded on cache for power-save and resume.
2271 * The array must be terminated with NID=0.
2272 */
2273void snd_hda_sequence_write_cache(struct hda_codec *codec,
2274 const struct hda_verb *seq)
2275{
2276 for (; seq->nid; seq++)
2277 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2278 seq->param);
2279}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002280EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002281#endif /* SND_HDA_NEEDS_RESUME */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002282
Takashi Iwai54d17402005-11-21 16:33:22 +01002283/*
2284 * set power state of the codec
2285 */
2286static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2287 unsigned int power_state)
2288{
Takashi Iwaicb53c622007-08-10 17:21:45 +02002289 hda_nid_t nid;
2290 int i;
Takashi Iwai54d17402005-11-21 16:33:22 +01002291
2292 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2293 power_state);
Marc Boucherd2595d82008-01-22 15:23:30 +01002294 msleep(10); /* partial workaround for "azx_get_response timeout" */
Takashi Iwai54d17402005-11-21 16:33:22 +01002295
Takashi Iwaicb53c622007-08-10 17:21:45 +02002296 nid = codec->start_nid;
2297 for (i = 0; i < codec->num_nodes; i++, nid++) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002298 unsigned int wcaps = get_wcaps(codec, nid);
2299 if (wcaps & AC_WCAP_POWER) {
2300 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2301 AC_WCAP_TYPE_SHIFT;
2302 if (wid_type == AC_WID_PIN) {
2303 unsigned int pincap;
2304 /*
2305 * don't power down the widget if it controls
2306 * eapd and EAPD_BTLENABLE is set.
2307 */
2308 pincap = snd_hda_param_read(codec, nid,
2309 AC_PAR_PIN_CAP);
2310 if (pincap & AC_PINCAP_EAPD) {
2311 int eapd = snd_hda_codec_read(codec,
2312 nid, 0,
2313 AC_VERB_GET_EAPD_BTLENABLE, 0);
2314 eapd &= 0x02;
2315 if (power_state == AC_PWRST_D3 && eapd)
2316 continue;
2317 }
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002318 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002319 snd_hda_codec_write(codec, nid, 0,
2320 AC_VERB_SET_POWER_STATE,
2321 power_state);
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002322 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002323 }
2324
Takashi Iwaicb53c622007-08-10 17:21:45 +02002325 if (power_state == AC_PWRST_D0) {
2326 unsigned long end_time;
2327 int state;
Takashi Iwai54d17402005-11-21 16:33:22 +01002328 msleep(10);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002329 /* wait until the codec reachs to D0 */
2330 end_time = jiffies + msecs_to_jiffies(500);
2331 do {
2332 state = snd_hda_codec_read(codec, fg, 0,
2333 AC_VERB_GET_POWER_STATE, 0);
2334 if (state == power_state)
2335 break;
2336 msleep(1);
2337 } while (time_after_eq(end_time, jiffies));
2338 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002339}
2340
Takashi Iwai11aeff02008-07-30 15:01:46 +02002341#ifdef CONFIG_SND_HDA_HWDEP
2342/* execute additional init verbs */
2343static void hda_exec_init_verbs(struct hda_codec *codec)
2344{
2345 if (codec->init_verbs.list)
2346 snd_hda_sequence_write(codec, codec->init_verbs.list);
2347}
2348#else
2349static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2350#endif
2351
Takashi Iwaicb53c622007-08-10 17:21:45 +02002352#ifdef SND_HDA_NEEDS_RESUME
2353/*
2354 * call suspend and power-down; used both from PM and power-save
2355 */
2356static void hda_call_codec_suspend(struct hda_codec *codec)
2357{
2358 if (codec->patch_ops.suspend)
2359 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2360 hda_set_power_state(codec,
2361 codec->afg ? codec->afg : codec->mfg,
2362 AC_PWRST_D3);
2363#ifdef CONFIG_SND_HDA_POWER_SAVE
2364 cancel_delayed_work(&codec->power_work);
Takashi Iwai95e99fd2007-08-13 15:29:04 +02002365 codec->power_on = 0;
Takashi Iwaia221e282007-08-16 16:35:33 +02002366 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002367#endif
2368}
2369
2370/*
2371 * kick up codec; used both from PM and power-save
2372 */
2373static void hda_call_codec_resume(struct hda_codec *codec)
2374{
2375 hda_set_power_state(codec,
2376 codec->afg ? codec->afg : codec->mfg,
2377 AC_PWRST_D0);
Takashi Iwai3be14142009-02-20 14:11:16 +01002378 restore_pincfgs(codec); /* restore all current pin configs */
Takashi Iwai11aeff02008-07-30 15:01:46 +02002379 hda_exec_init_verbs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002380 if (codec->patch_ops.resume)
2381 codec->patch_ops.resume(codec);
2382 else {
Takashi Iwai9d99f312007-08-14 15:15:52 +02002383 if (codec->patch_ops.init)
2384 codec->patch_ops.init(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002385 snd_hda_codec_resume_amp(codec);
2386 snd_hda_codec_resume_cache(codec);
2387 }
2388}
2389#endif /* SND_HDA_NEEDS_RESUME */
2390
Takashi Iwai54d17402005-11-21 16:33:22 +01002391
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392/**
2393 * snd_hda_build_controls - build mixer controls
2394 * @bus: the BUS
2395 *
2396 * Creates mixer controls for each codec included in the bus.
2397 *
2398 * Returns 0 if successful, otherwise a negative error code.
2399 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002400int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002402 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403
Takashi Iwai0ba21762007-04-16 11:29:14 +02002404 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002405 int err = snd_hda_codec_build_controls(codec);
Takashi Iwaif93d4612009-03-02 10:44:15 +01002406 if (err < 0) {
2407 printk(KERN_ERR "hda_codec: cannot build controls"
2408 "for #%d (error %d)\n", codec->addr, err);
2409 err = snd_hda_codec_reset(codec);
2410 if (err < 0) {
2411 printk(KERN_ERR
2412 "hda_codec: cannot revert codec\n");
2413 return err;
2414 }
2415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002417 return 0;
2418}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002419EXPORT_SYMBOL_HDA(snd_hda_build_controls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002421int snd_hda_codec_build_controls(struct hda_codec *codec)
2422{
2423 int err = 0;
Takashi Iwai11aeff02008-07-30 15:01:46 +02002424 hda_exec_init_verbs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002425 /* continue to initialize... */
2426 if (codec->patch_ops.init)
2427 err = codec->patch_ops.init(codec);
2428 if (!err && codec->patch_ops.build_controls)
2429 err = codec->patch_ops.build_controls(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002430 if (err < 0)
2431 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 return 0;
2433}
2434
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435/*
2436 * stream formats
2437 */
Takashi Iwaibefdf312005-08-22 13:57:55 +02002438struct hda_rate_tbl {
2439 unsigned int hz;
2440 unsigned int alsa_bits;
2441 unsigned int hda_fmt;
2442};
2443
2444static struct hda_rate_tbl rate_bits[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 /* rate in Hz, ALSA rate bitmask, HDA format value */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002446
2447 /* autodetected value used in snd_hda_query_supported_pcm */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2449 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2450 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2451 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2452 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2453 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2454 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2455 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2456 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2457 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2458 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002459#define AC_PAR_PCM_RATE_BITS 11
2460 /* up to bits 10, 384kHZ isn't supported properly */
2461
2462 /* not autodetected value */
2463 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002464
Takashi Iwaibefdf312005-08-22 13:57:55 +02002465 { 0 } /* terminator */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466};
2467
2468/**
2469 * snd_hda_calc_stream_format - calculate format bitset
2470 * @rate: the sample rate
2471 * @channels: the number of channels
2472 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2473 * @maxbps: the max. bps
2474 *
2475 * Calculate the format bitset from the given rate, channels and th PCM format.
2476 *
2477 * Return zero if invalid.
2478 */
2479unsigned int snd_hda_calc_stream_format(unsigned int rate,
2480 unsigned int channels,
2481 unsigned int format,
2482 unsigned int maxbps)
2483{
2484 int i;
2485 unsigned int val = 0;
2486
Takashi Iwaibefdf312005-08-22 13:57:55 +02002487 for (i = 0; rate_bits[i].hz; i++)
2488 if (rate_bits[i].hz == rate) {
2489 val = rate_bits[i].hda_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 break;
2491 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002492 if (!rate_bits[i].hz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 snd_printdd("invalid rate %d\n", rate);
2494 return 0;
2495 }
2496
2497 if (channels == 0 || channels > 8) {
2498 snd_printdd("invalid channels %d\n", channels);
2499 return 0;
2500 }
2501 val |= channels - 1;
2502
2503 switch (snd_pcm_format_width(format)) {
2504 case 8: val |= 0x00; break;
2505 case 16: val |= 0x10; break;
2506 case 20:
2507 case 24:
2508 case 32:
2509 if (maxbps >= 32)
2510 val |= 0x40;
2511 else if (maxbps >= 24)
2512 val |= 0x30;
2513 else
2514 val |= 0x20;
2515 break;
2516 default:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002517 snd_printdd("invalid format width %d\n",
2518 snd_pcm_format_width(format));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 return 0;
2520 }
2521
2522 return val;
2523}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002524EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525
2526/**
2527 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2528 * @codec: the HDA codec
2529 * @nid: NID to query
2530 * @ratesp: the pointer to store the detected rate bitflags
2531 * @formatsp: the pointer to store the detected formats
2532 * @bpsp: the pointer to store the detected format widths
2533 *
2534 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2535 * or @bsps argument is ignored.
2536 *
2537 * Returns 0 if successful, otherwise a negative error code.
2538 */
Takashi Iwai986862bd2008-11-27 12:40:13 +01002539static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2541{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002542 unsigned int i, val, wcaps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543
2544 val = 0;
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002545 wcaps = get_wcaps(codec, nid);
2546 if (nid != codec->afg && (wcaps & AC_WCAP_FORMAT_OVRD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2548 if (val == -1)
2549 return -EIO;
2550 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002551 if (!val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2553
2554 if (ratesp) {
2555 u32 rates = 0;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002556 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 if (val & (1 << i))
Takashi Iwaibefdf312005-08-22 13:57:55 +02002558 rates |= rate_bits[i].alsa_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002560 if (rates == 0) {
2561 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2562 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2563 nid, val,
2564 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2565 return -EIO;
2566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 *ratesp = rates;
2568 }
2569
2570 if (formatsp || bpsp) {
2571 u64 formats = 0;
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002572 unsigned int streams, bps;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2575 if (streams == -1)
2576 return -EIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002577 if (!streams) {
2578 streams = snd_hda_param_read(codec, codec->afg,
2579 AC_PAR_STREAM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 if (streams == -1)
2581 return -EIO;
2582 }
2583
2584 bps = 0;
2585 if (streams & AC_SUPFMT_PCM) {
2586 if (val & AC_SUPPCM_BITS_8) {
2587 formats |= SNDRV_PCM_FMTBIT_U8;
2588 bps = 8;
2589 }
2590 if (val & AC_SUPPCM_BITS_16) {
2591 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2592 bps = 16;
2593 }
2594 if (wcaps & AC_WCAP_DIGITAL) {
2595 if (val & AC_SUPPCM_BITS_32)
2596 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2597 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2598 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2599 if (val & AC_SUPPCM_BITS_24)
2600 bps = 24;
2601 else if (val & AC_SUPPCM_BITS_20)
2602 bps = 20;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002603 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2604 AC_SUPPCM_BITS_32)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2606 if (val & AC_SUPPCM_BITS_32)
2607 bps = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 else if (val & AC_SUPPCM_BITS_24)
2609 bps = 24;
Nicolas Graziano33ef76512006-09-19 14:23:14 +02002610 else if (val & AC_SUPPCM_BITS_20)
2611 bps = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 }
2613 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002614 else if (streams == AC_SUPFMT_FLOAT32) {
2615 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2617 bps = 32;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002618 } else if (streams == AC_SUPFMT_AC3) {
2619 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 /* temporary hack: we have still no proper support
2621 * for the direct AC3 stream...
2622 */
2623 formats |= SNDRV_PCM_FMTBIT_U8;
2624 bps = 8;
2625 }
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002626 if (formats == 0) {
2627 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2628 "(nid=0x%x, val=0x%x, ovrd=%i, "
2629 "streams=0x%x)\n",
2630 nid, val,
2631 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2632 streams);
2633 return -EIO;
2634 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 if (formatsp)
2636 *formatsp = formats;
2637 if (bpsp)
2638 *bpsp = bps;
2639 }
2640
2641 return 0;
2642}
2643
2644/**
Takashi Iwai0ba21762007-04-16 11:29:14 +02002645 * snd_hda_is_supported_format - check whether the given node supports
2646 * the format val
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 *
2648 * Returns 1 if supported, 0 if not.
2649 */
2650int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2651 unsigned int format)
2652{
2653 int i;
2654 unsigned int val = 0, rate, stream;
2655
2656 if (nid != codec->afg &&
Takashi Iwai54d17402005-11-21 16:33:22 +01002657 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2659 if (val == -1)
2660 return 0;
2661 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002662 if (!val) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2664 if (val == -1)
2665 return 0;
2666 }
2667
2668 rate = format & 0xff00;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002669 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
Takashi Iwaibefdf312005-08-22 13:57:55 +02002670 if (rate_bits[i].hda_fmt == rate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 if (val & (1 << i))
2672 break;
2673 return 0;
2674 }
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002675 if (i >= AC_PAR_PCM_RATE_BITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 return 0;
2677
2678 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2679 if (stream == -1)
2680 return 0;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002681 if (!stream && nid != codec->afg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002683 if (!stream || stream == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 return 0;
2685
2686 if (stream & AC_SUPFMT_PCM) {
2687 switch (format & 0xf0) {
2688 case 0x00:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002689 if (!(val & AC_SUPPCM_BITS_8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 return 0;
2691 break;
2692 case 0x10:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002693 if (!(val & AC_SUPPCM_BITS_16))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 return 0;
2695 break;
2696 case 0x20:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002697 if (!(val & AC_SUPPCM_BITS_20))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 return 0;
2699 break;
2700 case 0x30:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002701 if (!(val & AC_SUPPCM_BITS_24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 return 0;
2703 break;
2704 case 0x40:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002705 if (!(val & AC_SUPPCM_BITS_32))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 return 0;
2707 break;
2708 default:
2709 return 0;
2710 }
2711 } else {
2712 /* FIXME: check for float32 and AC3? */
2713 }
2714
2715 return 1;
2716}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002717EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718
2719/*
2720 * PCM stuff
2721 */
2722static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2723 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002724 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725{
2726 return 0;
2727}
2728
2729static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2730 struct hda_codec *codec,
2731 unsigned int stream_tag,
2732 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002733 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734{
2735 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2736 return 0;
2737}
2738
2739static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2740 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002741 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742{
Takashi Iwai888afa12008-03-18 09:57:50 +01002743 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744 return 0;
2745}
2746
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002747static int set_pcm_default_values(struct hda_codec *codec,
2748 struct hda_pcm_stream *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749{
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002750 int err;
2751
Takashi Iwai0ba21762007-04-16 11:29:14 +02002752 /* query support PCM information from the given NID */
2753 if (info->nid && (!info->rates || !info->formats)) {
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002754 err = snd_hda_query_supported_pcm(codec, info->nid,
Takashi Iwai0ba21762007-04-16 11:29:14 +02002755 info->rates ? NULL : &info->rates,
2756 info->formats ? NULL : &info->formats,
2757 info->maxbps ? NULL : &info->maxbps);
Jaroslav Kyselaee504712009-03-17 14:30:31 +01002758 if (err < 0)
2759 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 }
2761 if (info->ops.open == NULL)
2762 info->ops.open = hda_pcm_default_open_close;
2763 if (info->ops.close == NULL)
2764 info->ops.close = hda_pcm_default_open_close;
2765 if (info->ops.prepare == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02002766 if (snd_BUG_ON(!info->nid))
2767 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 info->ops.prepare = hda_pcm_default_prepare;
2769 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 if (info->ops.cleanup == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02002771 if (snd_BUG_ON(!info->nid))
2772 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 info->ops.cleanup = hda_pcm_default_cleanup;
2774 }
2775 return 0;
2776}
2777
Takashi Iwai176d5332008-07-30 15:01:44 +02002778/*
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002779 * get the empty PCM device number to assign
2780 */
2781static int get_empty_pcm_device(struct hda_bus *bus, int type)
2782{
2783 static const char *dev_name[HDA_PCM_NTYPES] = {
2784 "Audio", "SPDIF", "HDMI", "Modem"
2785 };
2786 /* starting device index for each PCM type */
2787 static int dev_idx[HDA_PCM_NTYPES] = {
2788 [HDA_PCM_TYPE_AUDIO] = 0,
2789 [HDA_PCM_TYPE_SPDIF] = 1,
2790 [HDA_PCM_TYPE_HDMI] = 3,
2791 [HDA_PCM_TYPE_MODEM] = 6
2792 };
2793 /* normal audio device indices; not linear to keep compatibility */
2794 static int audio_idx[4] = { 0, 2, 4, 5 };
2795 int i, dev;
2796
2797 switch (type) {
2798 case HDA_PCM_TYPE_AUDIO:
2799 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2800 dev = audio_idx[i];
2801 if (!test_bit(dev, bus->pcm_dev_bits))
Takashi Iwai82ad39f2009-03-03 15:00:35 +01002802 goto ok;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002803 }
Takashi Iwai82ad39f2009-03-03 15:00:35 +01002804 snd_printk(KERN_WARNING "Too many audio devices\n");
2805 return -EAGAIN;
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002806 case HDA_PCM_TYPE_SPDIF:
2807 case HDA_PCM_TYPE_HDMI:
2808 case HDA_PCM_TYPE_MODEM:
2809 dev = dev_idx[type];
2810 if (test_bit(dev, bus->pcm_dev_bits)) {
2811 snd_printk(KERN_WARNING "%s already defined\n",
2812 dev_name[type]);
2813 return -EAGAIN;
2814 }
2815 break;
2816 default:
2817 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2818 return -EINVAL;
2819 }
Takashi Iwai82ad39f2009-03-03 15:00:35 +01002820 ok:
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002821 set_bit(dev, bus->pcm_dev_bits);
2822 return dev;
2823}
2824
2825/*
Takashi Iwai176d5332008-07-30 15:01:44 +02002826 * attach a new PCM stream
2827 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002828static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
Takashi Iwai176d5332008-07-30 15:01:44 +02002829{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002830 struct hda_bus *bus = codec->bus;
Takashi Iwai176d5332008-07-30 15:01:44 +02002831 struct hda_pcm_stream *info;
2832 int stream, err;
2833
Takashi Iwaib91f0802008-11-04 08:43:08 +01002834 if (snd_BUG_ON(!pcm->name))
Takashi Iwai176d5332008-07-30 15:01:44 +02002835 return -EINVAL;
2836 for (stream = 0; stream < 2; stream++) {
2837 info = &pcm->stream[stream];
2838 if (info->substreams) {
2839 err = set_pcm_default_values(codec, info);
2840 if (err < 0)
2841 return err;
2842 }
2843 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002844 return bus->ops.attach_pcm(bus, codec, pcm);
Takashi Iwai176d5332008-07-30 15:01:44 +02002845}
2846
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002847/* assign all PCMs of the given codec */
2848int snd_hda_codec_build_pcms(struct hda_codec *codec)
2849{
2850 unsigned int pcm;
2851 int err;
2852
2853 if (!codec->num_pcms) {
2854 if (!codec->patch_ops.build_pcms)
2855 return 0;
2856 err = codec->patch_ops.build_pcms(codec);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01002857 if (err < 0) {
2858 printk(KERN_ERR "hda_codec: cannot build PCMs"
2859 "for #%d (error %d)\n", codec->addr, err);
2860 err = snd_hda_codec_reset(codec);
2861 if (err < 0) {
2862 printk(KERN_ERR
2863 "hda_codec: cannot revert codec\n");
2864 return err;
2865 }
2866 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002867 }
2868 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2869 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2870 int dev;
2871
2872 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
Takashi Iwai41b5b012009-01-20 18:21:23 +01002873 continue; /* no substreams assigned */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002874
2875 if (!cpcm->pcm) {
2876 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2877 if (dev < 0)
Takashi Iwai6e655bf2009-03-02 10:46:03 +01002878 continue; /* no fatal error */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002879 cpcm->device = dev;
2880 err = snd_hda_attach_pcm(codec, cpcm);
Takashi Iwai6e655bf2009-03-02 10:46:03 +01002881 if (err < 0) {
2882 printk(KERN_ERR "hda_codec: cannot attach "
2883 "PCM stream %d for codec #%d\n",
2884 dev, codec->addr);
2885 continue; /* no fatal error */
2886 }
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002887 }
2888 }
2889 return 0;
2890}
2891
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892/**
2893 * snd_hda_build_pcms - build PCM information
2894 * @bus: the BUS
2895 *
2896 * Create PCM information for each codec included in the bus.
2897 *
2898 * The build_pcms codec patch is requested to set up codec->num_pcms and
2899 * codec->pcm_info properly. The array is referred by the top-level driver
2900 * to create its PCM instances.
2901 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2902 * callback.
2903 *
2904 * At least, substreams, channels_min and channels_max must be filled for
2905 * each stream. substreams = 0 indicates that the stream doesn't exist.
2906 * When rates and/or formats are zero, the supported values are queried
2907 * from the given nid. The nid is used also by the default ops.prepare
2908 * and ops.cleanup callbacks.
2909 *
2910 * The driver needs to call ops.open in its open callback. Similarly,
2911 * ops.close is supposed to be called in the close callback.
2912 * ops.prepare should be called in the prepare or hw_params callback
2913 * with the proper parameters for set up.
2914 * ops.cleanup should be called in hw_free for clean up of streams.
2915 *
2916 * This function returns 0 if successfull, or a negative error code.
2917 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002918int __devinit snd_hda_build_pcms(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002920 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921
Takashi Iwai0ba21762007-04-16 11:29:14 +02002922 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002923 int err = snd_hda_codec_build_pcms(codec);
2924 if (err < 0)
2925 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 }
2927 return 0;
2928}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002929EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931/**
2932 * snd_hda_check_board_config - compare the current codec with the config table
2933 * @codec: the HDA codec
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002934 * @num_configs: number of config enums
2935 * @models: array of model name strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 * @tbl: configuration table, terminated by null entries
2937 *
2938 * Compares the modelname or PCI subsystem id of the current codec with the
2939 * given configuration table. If a matching entry is found, returns its
2940 * config value (supposed to be 0 or positive).
2941 *
2942 * If no entries are matching, the function returns a negative value.
2943 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002944int snd_hda_check_board_config(struct hda_codec *codec,
2945 int num_configs, const char **models,
2946 const struct snd_pci_quirk *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947{
Takashi Iwaif44ac832008-07-30 15:01:45 +02002948 if (codec->modelname && models) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002949 int i;
2950 for (i = 0; i < num_configs; i++) {
2951 if (models[i] &&
Takashi Iwaif44ac832008-07-30 15:01:45 +02002952 !strcmp(codec->modelname, models[i])) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002953 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2954 "selected\n", models[i]);
2955 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957 }
2958 }
2959
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002960 if (!codec->bus->pci || !tbl)
2961 return -1;
2962
2963 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2964 if (!tbl)
2965 return -1;
2966 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwai62cf8722008-05-20 12:15:15 +02002967#ifdef CONFIG_SND_DEBUG_VERBOSE
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002968 char tmp[10];
2969 const char *model = NULL;
2970 if (models)
2971 model = models[tbl->value];
2972 if (!model) {
2973 sprintf(tmp, "#%d", tbl->value);
2974 model = tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 }
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002976 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2977 "for config %x:%x (%s)\n",
2978 model, tbl->subvendor, tbl->subdevice,
2979 (tbl->name ? tbl->name : "Unknown device"));
2980#endif
2981 return tbl->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982 }
2983 return -1;
2984}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002985EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986
2987/**
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02002988 * snd_hda_check_board_codec_sid_config - compare the current codec
2989 subsystem ID with the
2990 config table
2991
2992 This is important for Gateway notebooks with SB450 HDA Audio
2993 where the vendor ID of the PCI device is:
2994 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2995 and the vendor/subvendor are found only at the codec.
2996
2997 * @codec: the HDA codec
2998 * @num_configs: number of config enums
2999 * @models: array of model name strings
3000 * @tbl: configuration table, terminated by null entries
3001 *
3002 * Compares the modelname or PCI subsystem id of the current codec with the
3003 * given configuration table. If a matching entry is found, returns its
3004 * config value (supposed to be 0 or positive).
3005 *
3006 * If no entries are matching, the function returns a negative value.
3007 */
3008int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3009 int num_configs, const char **models,
3010 const struct snd_pci_quirk *tbl)
3011{
3012 const struct snd_pci_quirk *q;
3013
3014 /* Search for codec ID */
3015 for (q = tbl; q->subvendor; q++) {
3016 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3017
3018 if (vendorid == codec->subsystem_id)
3019 break;
3020 }
3021
3022 if (!q->subvendor)
3023 return -1;
3024
3025 tbl = q;
3026
3027 if (tbl->value >= 0 && tbl->value < num_configs) {
3028#ifdef CONFIG_SND_DEBUG_DETECT
3029 char tmp[10];
3030 const char *model = NULL;
3031 if (models)
3032 model = models[tbl->value];
3033 if (!model) {
3034 sprintf(tmp, "#%d", tbl->value);
3035 model = tmp;
3036 }
3037 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3038 "for config %x:%x (%s)\n",
3039 model, tbl->subvendor, tbl->subdevice,
3040 (tbl->name ? tbl->name : "Unknown device"));
3041#endif
3042 return tbl->value;
3043 }
3044 return -1;
3045}
3046EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3047
3048/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049 * snd_hda_add_new_ctls - create controls from the array
3050 * @codec: the HDA codec
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003051 * @knew: the array of struct snd_kcontrol_new
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 *
3053 * This helper function creates and add new controls in the given array.
3054 * The array must be terminated with an empty entry as terminator.
3055 *
3056 * Returns 0 if successful, or a negative error code.
3057 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003058int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059{
Takashi Iwaicb53c622007-08-10 17:21:45 +02003060 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061
3062 for (; knew->name; knew++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01003063 struct snd_kcontrol *kctl;
3064 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003065 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01003066 return -ENOMEM;
Takashi Iwaid13bd412008-07-30 15:01:45 +02003067 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai54d17402005-11-21 16:33:22 +01003068 if (err < 0) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02003069 if (!codec->addr)
Takashi Iwai54d17402005-11-21 16:33:22 +01003070 return err;
3071 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003072 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01003073 return -ENOMEM;
3074 kctl->id.device = codec->addr;
Takashi Iwaid13bd412008-07-30 15:01:45 +02003075 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003076 if (err < 0)
Takashi Iwai54d17402005-11-21 16:33:22 +01003077 return err;
3078 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003079 }
3080 return 0;
3081}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003082EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083
Takashi Iwaicb53c622007-08-10 17:21:45 +02003084#ifdef CONFIG_SND_HDA_POWER_SAVE
3085static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3086 unsigned int power_state);
3087
3088static void hda_power_work(struct work_struct *work)
3089{
3090 struct hda_codec *codec =
3091 container_of(work, struct hda_codec, power_work.work);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003092 struct hda_bus *bus = codec->bus;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003093
Maxim Levitsky2e492462007-09-03 15:26:57 +02003094 if (!codec->power_on || codec->power_count) {
3095 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003096 return;
Maxim Levitsky2e492462007-09-03 15:26:57 +02003097 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02003098
3099 hda_call_codec_suspend(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003100 if (bus->ops.pm_notify)
3101 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003102}
3103
3104static void hda_keep_power_on(struct hda_codec *codec)
3105{
3106 codec->power_count++;
3107 codec->power_on = 1;
3108}
3109
3110void snd_hda_power_up(struct hda_codec *codec)
3111{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003112 struct hda_bus *bus = codec->bus;
3113
Takashi Iwaicb53c622007-08-10 17:21:45 +02003114 codec->power_count++;
Takashi Iwaia221e282007-08-16 16:35:33 +02003115 if (codec->power_on || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003116 return;
3117
3118 codec->power_on = 1;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01003119 if (bus->ops.pm_notify)
3120 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003121 hda_call_codec_resume(codec);
3122 cancel_delayed_work(&codec->power_work);
Takashi Iwaia221e282007-08-16 16:35:33 +02003123 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02003124}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003125EXPORT_SYMBOL_HDA(snd_hda_power_up);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003126
3127#define power_save(codec) \
3128 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003129
Takashi Iwaifee2fba2008-11-27 12:43:28 +01003130#define power_save(codec) \
3131 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3132
Takashi Iwaicb53c622007-08-10 17:21:45 +02003133void snd_hda_power_down(struct hda_codec *codec)
3134{
3135 --codec->power_count;
Takashi Iwaia221e282007-08-16 16:35:33 +02003136 if (!codec->power_on || codec->power_count || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02003137 return;
Takashi Iwaifee2fba2008-11-27 12:43:28 +01003138 if (power_save(codec)) {
Takashi Iwaia221e282007-08-16 16:35:33 +02003139 codec->power_transition = 1; /* avoid reentrance */
Takashi Iwaic107b412009-01-13 17:46:37 +01003140 queue_delayed_work(codec->bus->workq, &codec->power_work,
Takashi Iwaifee2fba2008-11-27 12:43:28 +01003141 msecs_to_jiffies(power_save(codec) * 1000));
Takashi Iwaia221e282007-08-16 16:35:33 +02003142 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02003143}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003144EXPORT_SYMBOL_HDA(snd_hda_power_down);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003145
3146int snd_hda_check_amp_list_power(struct hda_codec *codec,
3147 struct hda_loopback_check *check,
3148 hda_nid_t nid)
3149{
3150 struct hda_amp_list *p;
3151 int ch, v;
3152
3153 if (!check->amplist)
3154 return 0;
3155 for (p = check->amplist; p->nid; p++) {
3156 if (p->nid == nid)
3157 break;
3158 }
3159 if (!p->nid)
3160 return 0; /* nothing changed */
3161
3162 for (p = check->amplist; p->nid; p++) {
3163 for (ch = 0; ch < 2; ch++) {
3164 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3165 p->idx);
3166 if (!(v & HDA_AMP_MUTE) && v > 0) {
3167 if (!check->power_on) {
3168 check->power_on = 1;
3169 snd_hda_power_up(codec);
3170 }
3171 return 1;
3172 }
3173 }
3174 }
3175 if (check->power_on) {
3176 check->power_on = 0;
3177 snd_hda_power_down(codec);
3178 }
3179 return 0;
3180}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003181EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
Takashi Iwaicb53c622007-08-10 17:21:45 +02003182#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003184/*
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003185 * Channel mode helper
3186 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003187int snd_hda_ch_mode_info(struct hda_codec *codec,
3188 struct snd_ctl_elem_info *uinfo,
3189 const struct hda_channel_mode *chmode,
3190 int num_chmodes)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003191{
3192 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3193 uinfo->count = 1;
3194 uinfo->value.enumerated.items = num_chmodes;
3195 if (uinfo->value.enumerated.item >= num_chmodes)
3196 uinfo->value.enumerated.item = num_chmodes - 1;
3197 sprintf(uinfo->value.enumerated.name, "%dch",
3198 chmode[uinfo->value.enumerated.item].channels);
3199 return 0;
3200}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003201EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003202
Takashi Iwai0ba21762007-04-16 11:29:14 +02003203int snd_hda_ch_mode_get(struct hda_codec *codec,
3204 struct snd_ctl_elem_value *ucontrol,
3205 const struct hda_channel_mode *chmode,
3206 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003207 int max_channels)
3208{
3209 int i;
3210
3211 for (i = 0; i < num_chmodes; i++) {
3212 if (max_channels == chmode[i].channels) {
3213 ucontrol->value.enumerated.item[0] = i;
3214 break;
3215 }
3216 }
3217 return 0;
3218}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003219EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003220
Takashi Iwai0ba21762007-04-16 11:29:14 +02003221int snd_hda_ch_mode_put(struct hda_codec *codec,
3222 struct snd_ctl_elem_value *ucontrol,
3223 const struct hda_channel_mode *chmode,
3224 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003225 int *max_channelsp)
3226{
3227 unsigned int mode;
3228
3229 mode = ucontrol->value.enumerated.item[0];
Takashi Iwai68ea7b22007-11-15 15:54:38 +01003230 if (mode >= num_chmodes)
3231 return -EINVAL;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003232 if (*max_channelsp == chmode[mode].channels)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003233 return 0;
3234 /* change the current channel setting */
3235 *max_channelsp = chmode[mode].channels;
3236 if (chmode[mode].sequence)
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003237 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003238 return 1;
3239}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003240EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003241
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242/*
3243 * input MUX helper
3244 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003245int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3246 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247{
3248 unsigned int index;
3249
3250 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3251 uinfo->count = 1;
3252 uinfo->value.enumerated.items = imux->num_items;
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003253 if (!imux->num_items)
3254 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 index = uinfo->value.enumerated.item;
3256 if (index >= imux->num_items)
3257 index = imux->num_items - 1;
3258 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3259 return 0;
3260}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003261EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262
Takashi Iwai0ba21762007-04-16 11:29:14 +02003263int snd_hda_input_mux_put(struct hda_codec *codec,
3264 const struct hda_input_mux *imux,
3265 struct snd_ctl_elem_value *ucontrol,
3266 hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267 unsigned int *cur_val)
3268{
3269 unsigned int idx;
3270
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003271 if (!imux->num_items)
3272 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273 idx = ucontrol->value.enumerated.item[0];
3274 if (idx >= imux->num_items)
3275 idx = imux->num_items - 1;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003276 if (*cur_val == idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277 return 0;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003278 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3279 imux->items[idx].index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 *cur_val = idx;
3281 return 1;
3282}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003283EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284
3285
3286/*
3287 * Multi-channel / digital-out PCM helper functions
3288 */
3289
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003290/* setup SPDIF output stream */
3291static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3292 unsigned int stream_tag, unsigned int format)
3293{
3294 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
Takashi Iwai2f728532008-09-25 16:32:41 +02003295 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3296 set_dig_out_convert(codec, nid,
3297 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3298 -1);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003299 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
Takashi Iwai2f728532008-09-25 16:32:41 +02003300 if (codec->slave_dig_outs) {
3301 hda_nid_t *d;
3302 for (d = codec->slave_dig_outs; *d; d++)
3303 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3304 format);
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003305 }
Takashi Iwai2f728532008-09-25 16:32:41 +02003306 /* turn on again (if needed) */
3307 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3308 set_dig_out_convert(codec, nid,
3309 codec->spdif_ctls & 0xff, -1);
3310}
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003311
Takashi Iwai2f728532008-09-25 16:32:41 +02003312static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3313{
3314 snd_hda_codec_cleanup_stream(codec, nid);
3315 if (codec->slave_dig_outs) {
3316 hda_nid_t *d;
3317 for (d = codec->slave_dig_outs; *d; d++)
3318 snd_hda_codec_cleanup_stream(codec, *d);
3319 }
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003320}
3321
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322/*
3323 * open the digital out in the exclusive mode
3324 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003325int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3326 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327{
Ingo Molnar62932df2006-01-16 16:34:20 +01003328 mutex_lock(&codec->spdif_mutex);
Takashi Iwai5930ca42007-04-16 11:23:56 +02003329 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3330 /* already opened as analog dup; reset it once */
Takashi Iwai2f728532008-09-25 16:32:41 +02003331 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
Ingo Molnar62932df2006-01-16 16:34:20 +01003333 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 return 0;
3335}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003336EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003338int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3339 struct hda_multi_out *mout,
3340 unsigned int stream_tag,
3341 unsigned int format,
3342 struct snd_pcm_substream *substream)
3343{
3344 mutex_lock(&codec->spdif_mutex);
3345 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3346 mutex_unlock(&codec->spdif_mutex);
3347 return 0;
3348}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003349EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003350
Takashi Iwai9411e212009-02-13 11:32:28 +01003351int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3352 struct hda_multi_out *mout)
3353{
3354 mutex_lock(&codec->spdif_mutex);
3355 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3356 mutex_unlock(&codec->spdif_mutex);
3357 return 0;
3358}
3359EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3360
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361/*
3362 * release the digital out
3363 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003364int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3365 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366{
Ingo Molnar62932df2006-01-16 16:34:20 +01003367 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368 mout->dig_out_used = 0;
Ingo Molnar62932df2006-01-16 16:34:20 +01003369 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370 return 0;
3371}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003372EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373
3374/*
3375 * set up more restrictions for analog out
3376 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003377int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3378 struct hda_multi_out *mout,
Takashi Iwai9a081602008-02-12 18:37:26 +01003379 struct snd_pcm_substream *substream,
3380 struct hda_pcm_stream *hinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381{
Takashi Iwai9a081602008-02-12 18:37:26 +01003382 struct snd_pcm_runtime *runtime = substream->runtime;
3383 runtime->hw.channels_max = mout->max_channels;
3384 if (mout->dig_out_nid) {
3385 if (!mout->analog_rates) {
3386 mout->analog_rates = hinfo->rates;
3387 mout->analog_formats = hinfo->formats;
3388 mout->analog_maxbps = hinfo->maxbps;
3389 } else {
3390 runtime->hw.rates = mout->analog_rates;
3391 runtime->hw.formats = mout->analog_formats;
3392 hinfo->maxbps = mout->analog_maxbps;
3393 }
3394 if (!mout->spdif_rates) {
3395 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3396 &mout->spdif_rates,
3397 &mout->spdif_formats,
3398 &mout->spdif_maxbps);
3399 }
3400 mutex_lock(&codec->spdif_mutex);
3401 if (mout->share_spdif) {
3402 runtime->hw.rates &= mout->spdif_rates;
3403 runtime->hw.formats &= mout->spdif_formats;
3404 if (mout->spdif_maxbps < hinfo->maxbps)
3405 hinfo->maxbps = mout->spdif_maxbps;
3406 }
Frederik Deweerdteaa99852008-04-14 13:11:44 +02003407 mutex_unlock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003408 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3410 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3411}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003412EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003413
3414/*
3415 * set up the i/o for analog out
3416 * when the digital out is available, copy the front out to digital out, too.
3417 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003418int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3419 struct hda_multi_out *mout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003420 unsigned int stream_tag,
3421 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003422 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423{
3424 hda_nid_t *nids = mout->dac_nids;
3425 int chs = substream->runtime->channels;
3426 int i;
3427
Ingo Molnar62932df2006-01-16 16:34:20 +01003428 mutex_lock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003429 if (mout->dig_out_nid && mout->share_spdif &&
3430 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431 if (chs == 2 &&
Takashi Iwai0ba21762007-04-16 11:29:14 +02003432 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3433 format) &&
3434 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003436 setup_dig_out_stream(codec, mout->dig_out_nid,
3437 stream_tag, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 } else {
3439 mout->dig_out_used = 0;
Takashi Iwai2f728532008-09-25 16:32:41 +02003440 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003441 }
3442 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003443 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444
3445 /* front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003446 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3447 0, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003448 if (!mout->no_share_stream &&
3449 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450 /* headphone out will just decode front left/right (stereo) */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003451 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3452 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003453 /* extra outputs copied from front */
3454 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
Takashi Iwaid29240c2007-10-26 12:35:56 +02003455 if (!mout->no_share_stream && mout->extra_out_nid[i])
Takashi Iwai82bc9552006-03-21 11:24:42 +01003456 snd_hda_codec_setup_stream(codec,
3457 mout->extra_out_nid[i],
3458 stream_tag, 0, format);
3459
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460 /* surrounds */
3461 for (i = 1; i < mout->num_dacs; i++) {
Takashi Iwai4b3acaf2005-06-10 19:48:10 +02003462 if (chs >= (i + 1) * 2) /* independent out */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003463 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3464 i * 2, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003465 else if (!mout->no_share_stream) /* copy front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003466 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3467 0, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468 }
3469 return 0;
3470}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003471EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472
3473/*
3474 * clean up the setting for analog out
3475 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003476int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3477 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003478{
3479 hda_nid_t *nids = mout->dac_nids;
3480 int i;
3481
3482 for (i = 0; i < mout->num_dacs; i++)
Takashi Iwai888afa12008-03-18 09:57:50 +01003483 snd_hda_codec_cleanup_stream(codec, nids[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 if (mout->hp_nid)
Takashi Iwai888afa12008-03-18 09:57:50 +01003485 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003486 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3487 if (mout->extra_out_nid[i])
Takashi Iwai888afa12008-03-18 09:57:50 +01003488 snd_hda_codec_cleanup_stream(codec,
3489 mout->extra_out_nid[i]);
Ingo Molnar62932df2006-01-16 16:34:20 +01003490 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
Takashi Iwai2f728532008-09-25 16:32:41 +02003492 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 mout->dig_out_used = 0;
3494 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003495 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 return 0;
3497}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003498EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003500/*
Wu Fengguang6b345002008-10-07 14:21:41 +08003501 * Helper for automatic pin configuration
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003502 */
Kailang Yangdf694da2005-12-05 19:42:22 +01003503
Takashi Iwai12f288b2007-08-02 15:51:59 +02003504static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
Kailang Yangdf694da2005-12-05 19:42:22 +01003505{
3506 for (; *list; list++)
3507 if (*list == nid)
3508 return 1;
3509 return 0;
3510}
3511
Steve Longerbeam81937d32007-05-08 15:33:03 +02003512
3513/*
3514 * Sort an associated group of pins according to their sequence numbers.
3515 */
3516static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3517 int num_pins)
3518{
3519 int i, j;
3520 short seq;
3521 hda_nid_t nid;
3522
3523 for (i = 0; i < num_pins; i++) {
3524 for (j = i + 1; j < num_pins; j++) {
3525 if (sequences[i] > sequences[j]) {
3526 seq = sequences[i];
3527 sequences[i] = sequences[j];
3528 sequences[j] = seq;
3529 nid = pins[i];
3530 pins[i] = pins[j];
3531 pins[j] = nid;
3532 }
3533 }
3534 }
3535}
3536
3537
Takashi Iwai82bc9552006-03-21 11:24:42 +01003538/*
3539 * Parse all pin widgets and store the useful pin nids to cfg
3540 *
3541 * The number of line-outs or any primary output is stored in line_outs,
3542 * and the corresponding output pins are assigned to line_out_pins[],
3543 * in the order of front, rear, CLFE, side, ...
3544 *
3545 * If more extra outputs (speaker and headphone) are found, the pins are
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003546 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
Takashi Iwai82bc9552006-03-21 11:24:42 +01003547 * is detected, one of speaker of HP pins is assigned as the primary
3548 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3549 * if any analog output exists.
3550 *
3551 * The analog input pins are assigned to input_pins array.
3552 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3553 * respectively.
3554 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003555int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3556 struct auto_pin_cfg *cfg,
3557 hda_nid_t *ignore_nids)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003558{
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01003559 hda_nid_t nid, end_nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003560 short seq, assoc_line_out, assoc_speaker;
3561 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3562 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
Takashi Iwaif889fa92007-10-31 15:49:32 +01003563 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003564
3565 memset(cfg, 0, sizeof(*cfg));
3566
Steve Longerbeam81937d32007-05-08 15:33:03 +02003567 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3568 memset(sequences_speaker, 0, sizeof(sequences_speaker));
Takashi Iwaif889fa92007-10-31 15:49:32 +01003569 memset(sequences_hp, 0, sizeof(sequences_hp));
Steve Longerbeam81937d32007-05-08 15:33:03 +02003570 assoc_line_out = assoc_speaker = 0;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003571
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01003572 end_nid = codec->start_nid + codec->num_nodes;
3573 for (nid = codec->start_nid; nid < end_nid; nid++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01003574 unsigned int wid_caps = get_wcaps(codec, nid);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003575 unsigned int wid_type =
3576 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003577 unsigned int def_conf;
3578 short assoc, loc;
3579
3580 /* read all default configuration for pin complex */
3581 if (wid_type != AC_WID_PIN)
3582 continue;
Kailang Yangdf694da2005-12-05 19:42:22 +01003583 /* ignore the given nids (e.g. pc-beep returns error) */
3584 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3585 continue;
3586
Takashi Iwaic17a1ab2009-02-23 09:28:12 +01003587 def_conf = snd_hda_codec_get_pincfg(codec, nid);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003588 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3589 continue;
3590 loc = get_defcfg_location(def_conf);
3591 switch (get_defcfg_device(def_conf)) {
3592 case AC_JACK_LINE_OUT:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003593 seq = get_defcfg_sequence(def_conf);
3594 assoc = get_defcfg_association(def_conf);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01003595
3596 if (!(wid_caps & AC_WCAP_STEREO))
3597 if (!cfg->mono_out_pin)
3598 cfg->mono_out_pin = nid;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003599 if (!assoc)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003600 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003601 if (!assoc_line_out)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003602 assoc_line_out = assoc;
3603 else if (assoc_line_out != assoc)
3604 continue;
3605 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3606 continue;
3607 cfg->line_out_pins[cfg->line_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003608 sequences_line_out[cfg->line_outs] = seq;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003609 cfg->line_outs++;
3610 break;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01003611 case AC_JACK_SPEAKER:
Steve Longerbeam81937d32007-05-08 15:33:03 +02003612 seq = get_defcfg_sequence(def_conf);
3613 assoc = get_defcfg_association(def_conf);
3614 if (! assoc)
3615 continue;
3616 if (! assoc_speaker)
3617 assoc_speaker = assoc;
3618 else if (assoc_speaker != assoc)
3619 continue;
Takashi Iwai82bc9552006-03-21 11:24:42 +01003620 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3621 continue;
3622 cfg->speaker_pins[cfg->speaker_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003623 sequences_speaker[cfg->speaker_outs] = seq;
Takashi Iwai82bc9552006-03-21 11:24:42 +01003624 cfg->speaker_outs++;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01003625 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003626 case AC_JACK_HP_OUT:
Takashi Iwaif889fa92007-10-31 15:49:32 +01003627 seq = get_defcfg_sequence(def_conf);
3628 assoc = get_defcfg_association(def_conf);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003629 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3630 continue;
3631 cfg->hp_pins[cfg->hp_outs] = nid;
Takashi Iwaif889fa92007-10-31 15:49:32 +01003632 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003633 cfg->hp_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003634 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02003635 case AC_JACK_MIC_IN: {
3636 int preferred, alt;
3637 if (loc == AC_JACK_LOC_FRONT) {
3638 preferred = AUTO_PIN_FRONT_MIC;
3639 alt = AUTO_PIN_MIC;
3640 } else {
3641 preferred = AUTO_PIN_MIC;
3642 alt = AUTO_PIN_FRONT_MIC;
3643 }
3644 if (!cfg->input_pins[preferred])
3645 cfg->input_pins[preferred] = nid;
3646 else if (!cfg->input_pins[alt])
3647 cfg->input_pins[alt] = nid;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003648 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02003649 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003650 case AC_JACK_LINE_IN:
3651 if (loc == AC_JACK_LOC_FRONT)
3652 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3653 else
3654 cfg->input_pins[AUTO_PIN_LINE] = nid;
3655 break;
3656 case AC_JACK_CD:
3657 cfg->input_pins[AUTO_PIN_CD] = nid;
3658 break;
3659 case AC_JACK_AUX:
3660 cfg->input_pins[AUTO_PIN_AUX] = nid;
3661 break;
3662 case AC_JACK_SPDIF_OUT:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01003663 case AC_JACK_DIG_OTHER_OUT:
Takashi Iwai0852d7a2009-02-11 11:35:15 +01003664 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3665 continue;
3666 cfg->dig_out_pins[cfg->dig_outs] = nid;
3667 cfg->dig_out_type[cfg->dig_outs] =
3668 (loc == AC_JACK_LOC_HDMI) ?
3669 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3670 cfg->dig_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003671 break;
3672 case AC_JACK_SPDIF_IN:
Takashi Iwai1b52ae72009-01-20 17:17:29 +01003673 case AC_JACK_DIG_OTHER_IN:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003674 cfg->dig_in_pin = nid;
Takashi Iwai2297bd62009-01-20 18:24:13 +01003675 if (loc == AC_JACK_LOC_HDMI)
3676 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3677 else
3678 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003679 break;
3680 }
3681 }
3682
Takashi Iwai5832fcf2008-02-12 18:30:12 +01003683 /* FIX-UP:
3684 * If no line-out is defined but multiple HPs are found,
3685 * some of them might be the real line-outs.
3686 */
3687 if (!cfg->line_outs && cfg->hp_outs > 1) {
3688 int i = 0;
3689 while (i < cfg->hp_outs) {
3690 /* The real HPs should have the sequence 0x0f */
3691 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3692 i++;
3693 continue;
3694 }
3695 /* Move it to the line-out table */
3696 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3697 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3698 cfg->line_outs++;
3699 cfg->hp_outs--;
3700 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3701 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3702 memmove(sequences_hp + i - 1, sequences_hp + i,
3703 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3704 }
3705 }
3706
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003707 /* sort by sequence */
Steve Longerbeam81937d32007-05-08 15:33:03 +02003708 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3709 cfg->line_outs);
3710 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3711 cfg->speaker_outs);
Takashi Iwaif889fa92007-10-31 15:49:32 +01003712 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3713 cfg->hp_outs);
Steve Longerbeam81937d32007-05-08 15:33:03 +02003714
Takashi Iwaif889fa92007-10-31 15:49:32 +01003715 /* if we have only one mic, make it AUTO_PIN_MIC */
3716 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3717 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3718 cfg->input_pins[AUTO_PIN_MIC] =
3719 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3720 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3721 }
3722 /* ditto for line-in */
3723 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3724 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3725 cfg->input_pins[AUTO_PIN_LINE] =
3726 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3727 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3728 }
3729
Steve Longerbeam81937d32007-05-08 15:33:03 +02003730 /*
3731 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3732 * as a primary output
3733 */
3734 if (!cfg->line_outs) {
3735 if (cfg->speaker_outs) {
3736 cfg->line_outs = cfg->speaker_outs;
3737 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3738 sizeof(cfg->speaker_pins));
3739 cfg->speaker_outs = 0;
3740 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3741 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3742 } else if (cfg->hp_outs) {
3743 cfg->line_outs = cfg->hp_outs;
3744 memcpy(cfg->line_out_pins, cfg->hp_pins,
3745 sizeof(cfg->hp_pins));
3746 cfg->hp_outs = 0;
3747 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3748 cfg->line_out_type = AUTO_PIN_HP_OUT;
3749 }
3750 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003751
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003752 /* Reorder the surround channels
3753 * ALSA sequence is front/surr/clfe/side
3754 * HDA sequence is:
3755 * 4-ch: front/surr => OK as it is
3756 * 6-ch: front/clfe/surr
Takashi Iwai9422db42007-04-20 16:11:43 +02003757 * 8-ch: front/clfe/rear/side|fc
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003758 */
3759 switch (cfg->line_outs) {
3760 case 3:
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003761 case 4:
3762 nid = cfg->line_out_pins[1];
Takashi Iwai9422db42007-04-20 16:11:43 +02003763 cfg->line_out_pins[1] = cfg->line_out_pins[2];
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003764 cfg->line_out_pins[2] = nid;
3765 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003766 }
3767
Takashi Iwai82bc9552006-03-21 11:24:42 +01003768 /*
3769 * debug prints of the parsed results
3770 */
3771 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3772 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3773 cfg->line_out_pins[2], cfg->line_out_pins[3],
3774 cfg->line_out_pins[4]);
3775 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3776 cfg->speaker_outs, cfg->speaker_pins[0],
3777 cfg->speaker_pins[1], cfg->speaker_pins[2],
3778 cfg->speaker_pins[3], cfg->speaker_pins[4]);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003779 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3780 cfg->hp_outs, cfg->hp_pins[0],
3781 cfg->hp_pins[1], cfg->hp_pins[2],
3782 cfg->hp_pins[3], cfg->hp_pins[4]);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01003783 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
Takashi Iwai0852d7a2009-02-11 11:35:15 +01003784 if (cfg->dig_outs)
3785 snd_printd(" dig-out=0x%x/0x%x\n",
3786 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003787 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3788 " cd=0x%x, aux=0x%x\n",
3789 cfg->input_pins[AUTO_PIN_MIC],
3790 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3791 cfg->input_pins[AUTO_PIN_LINE],
3792 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3793 cfg->input_pins[AUTO_PIN_CD],
3794 cfg->input_pins[AUTO_PIN_AUX]);
Takashi Iwai32d2c7f2009-02-11 11:33:13 +01003795 if (cfg->dig_in_pin)
Takashi Iwai89ce9e82009-01-20 17:15:57 +01003796 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003797
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003798 return 0;
3799}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003800EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003801
Takashi Iwai4a471b72005-12-07 13:56:29 +01003802/* labels for input pins */
3803const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3804 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3805};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003806EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
Takashi Iwai4a471b72005-12-07 13:56:29 +01003807
3808
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809#ifdef CONFIG_PM
3810/*
3811 * power management
3812 */
3813
3814/**
3815 * snd_hda_suspend - suspend the codecs
3816 * @bus: the HDA bus
3817 * @state: suspsend state
3818 *
3819 * Returns 0 if successful.
3820 */
3821int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3822{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003823 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824
Takashi Iwai0ba21762007-04-16 11:29:14 +02003825 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai0b7a2e92007-08-14 15:18:26 +02003826#ifdef CONFIG_SND_HDA_POWER_SAVE
3827 if (!codec->power_on)
3828 continue;
3829#endif
Takashi Iwaicb53c622007-08-10 17:21:45 +02003830 hda_call_codec_suspend(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831 }
3832 return 0;
3833}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003834EXPORT_SYMBOL_HDA(snd_hda_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003835
3836/**
3837 * snd_hda_resume - resume the codecs
3838 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 *
3840 * Returns 0 if successful.
Takashi Iwaicb53c622007-08-10 17:21:45 +02003841 *
3842 * This fucntion is defined only when POWER_SAVE isn't set.
3843 * In the power-save mode, the codec is resumed dynamically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 */
3845int snd_hda_resume(struct hda_bus *bus)
3846{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003847 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848
Takashi Iwai0ba21762007-04-16 11:29:14 +02003849 list_for_each_entry(codec, &bus->codec_list, list) {
Maxim Levitskyd804ad92007-09-03 15:28:04 +02003850 if (snd_hda_codec_needs_resume(codec))
3851 hda_call_codec_resume(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003852 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853 return 0;
3854}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003855EXPORT_SYMBOL_HDA(snd_hda_resume);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003856#endif /* CONFIG_PM */
Takashi Iwaib2e18592008-07-30 15:01:44 +02003857
3858/*
3859 * generic arrays
3860 */
3861
3862/* get a new element from the given array
3863 * if it exceeds the pre-allocated array size, re-allocate the array
3864 */
3865void *snd_array_new(struct snd_array *array)
3866{
3867 if (array->used >= array->alloced) {
3868 int num = array->alloced + array->alloc_align;
Takashi Iwaib910d9a2008-11-07 00:26:52 +01003869 void *nlist;
3870 if (snd_BUG_ON(num >= 4096))
3871 return NULL;
3872 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003873 if (!nlist)
3874 return NULL;
3875 if (array->list) {
3876 memcpy(nlist, array->list,
3877 array->elem_size * array->alloced);
3878 kfree(array->list);
3879 }
3880 array->list = nlist;
3881 array->alloced = num;
3882 }
Takashi Iwaif43aa022008-11-10 16:24:26 +01003883 return snd_array_elem(array, array->used++);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003884}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003885EXPORT_SYMBOL_HDA(snd_array_new);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003886
3887/* free the given array elements */
3888void snd_array_free(struct snd_array *array)
3889{
3890 kfree(array->list);
3891 array->used = 0;
3892 array->alloced = 0;
3893 array->list = NULL;
3894}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003895EXPORT_SYMBOL_HDA(snd_array_free);
Takashi Iwaib2022262008-11-21 21:24:03 +01003896
3897/*
3898 * used by hda_proc.c and hda_eld.c
3899 */
3900void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3901{
3902 static unsigned int rates[] = {
3903 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3904 96000, 176400, 192000, 384000
3905 };
3906 int i, j;
3907
3908 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3909 if (pcm & (1 << i))
3910 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3911
3912 buf[j] = '\0'; /* necessary when j == 0 */
3913}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003914EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
Takashi Iwaib2022262008-11-21 21:24:03 +01003915
3916void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3917{
3918 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3919 int i, j;
3920
3921 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3922 if (pcm & (AC_SUPPCM_BITS_8 << i))
3923 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3924
3925 buf[j] = '\0'; /* necessary when j == 0 */
3926}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003927EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003928
3929MODULE_DESCRIPTION("HDA codec core");
3930MODULE_LICENSE("GPL");