blob: 0cf2424ada6a0063a185b9364e466746d61820ce [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 Iwai6acaed32009-01-12 10:09:24 +0100490 char qname[8];
Takashi Iwaic8b6bf92005-11-17 14:57:47 +0100491 static struct snd_device_ops dev_ops = {
Takashi Iwaid7ffba12008-07-30 15:01:46 +0200492 .dev_register = snd_hda_bus_dev_register,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 .dev_free = snd_hda_bus_dev_free,
494 };
495
Takashi Iwaida3cec32008-08-08 17:12:14 +0200496 if (snd_BUG_ON(!temp))
497 return -EINVAL;
498 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
499 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 if (busp)
502 *busp = NULL;
503
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200504 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (bus == NULL) {
506 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
507 return -ENOMEM;
508 }
509
510 bus->card = card;
511 bus->private_data = temp->private_data;
512 bus->pci = temp->pci;
513 bus->modelname = temp->modelname;
Takashi Iwaifee2fba2008-11-27 12:43:28 +0100514 bus->power_save = temp->power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 bus->ops = temp->ops;
516
Ingo Molnar62932df2006-01-16 16:34:20 +0100517 mutex_init(&bus->cmd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 INIT_LIST_HEAD(&bus->codec_list);
519
Takashi Iwai6acaed32009-01-12 10:09:24 +0100520 snprintf(qname, sizeof(qname), "hda%d", card->number);
521 bus->workq = create_workqueue(qname);
522 if (!bus->workq) {
523 snd_printk(KERN_ERR "cannot create workqueue %s\n", qname);
524 kfree(bus);
525 return -ENOMEM;
526 }
527
Takashi Iwai0ba21762007-04-16 11:29:14 +0200528 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
529 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 snd_hda_bus_free(bus);
531 return err;
532 }
533 if (busp)
534 *busp = bus;
535 return 0;
536}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100537EXPORT_SYMBOL_HDA(snd_hda_bus_new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Takashi Iwai82467612007-07-27 19:15:54 +0200539#ifdef CONFIG_SND_HDA_GENERIC
540#define is_generic_config(codec) \
Takashi Iwaif44ac832008-07-30 15:01:45 +0200541 (codec->modelname && !strcmp(codec->modelname, "generic"))
Takashi Iwai82467612007-07-27 19:15:54 +0200542#else
543#define is_generic_config(codec) 0
544#endif
545
Takashi Iwai645f10c2008-11-28 15:07:37 +0100546#ifdef MODULE
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100547#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
548#else
Takashi Iwai645f10c2008-11-28 15:07:37 +0100549#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100550#endif
551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552/*
553 * find a matching codec preset
554 */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200555static const struct hda_codec_preset *
Takashi Iwai756e2b02007-04-16 11:27:07 +0200556find_codec_preset(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100558 struct hda_codec_preset_list *tbl;
559 const struct hda_codec_preset *preset;
560 int mod_requested = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Takashi Iwai82467612007-07-27 19:15:54 +0200562 if (is_generic_config(codec))
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100563 return NULL; /* use the generic parser */
564
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100565 again:
566 mutex_lock(&preset_mutex);
567 list_for_each_entry(tbl, &hda_preset_tables, list) {
568 if (!try_module_get(tbl->owner)) {
569 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
570 continue;
571 }
572 for (preset = tbl->preset; preset->id; preset++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 u32 mask = preset->mask;
Marc Boucherca7cfae2008-01-22 15:32:25 +0100574 if (preset->afg && preset->afg != codec->afg)
575 continue;
576 if (preset->mfg && preset->mfg != codec->mfg)
577 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200578 if (!mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 mask = ~0;
Takashi Iwai9c7f8522006-06-28 15:08:22 +0200580 if (preset->id == (codec->vendor_id & mask) &&
Takashi Iwai0ba21762007-04-16 11:29:14 +0200581 (!preset->rev ||
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100582 preset->rev == codec->revision_id)) {
583 mutex_unlock(&preset_mutex);
584 codec->owner = tbl->owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return preset;
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100588 module_put(tbl->owner);
589 }
590 mutex_unlock(&preset_mutex);
591
592 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
593 char name[32];
594 if (!mod_requested)
595 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
596 codec->vendor_id);
597 else
598 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
599 (codec->vendor_id >> 16) & 0xffff);
600 request_module(name);
601 mod_requested++;
602 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
604 return NULL;
605}
606
607/*
Takashi Iwaif44ac832008-07-30 15:01:45 +0200608 * get_codec_name - store the codec name
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200610static int get_codec_name(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
612 const struct hda_vendor_id *c;
613 const char *vendor = NULL;
614 u16 vendor_id = codec->vendor_id >> 16;
Takashi Iwaif44ac832008-07-30 15:01:45 +0200615 char tmp[16], name[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 for (c = hda_vendor_ids; c->id; c++) {
618 if (c->id == vendor_id) {
619 vendor = c->name;
620 break;
621 }
622 }
Takashi Iwai0ba21762007-04-16 11:29:14 +0200623 if (!vendor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 sprintf(tmp, "Generic %04x", vendor_id);
625 vendor = tmp;
626 }
627 if (codec->preset && codec->preset->name)
Takashi Iwaif44ac832008-07-30 15:01:45 +0200628 snprintf(name, sizeof(name), "%s %s", vendor,
629 codec->preset->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 else
Takashi Iwaif44ac832008-07-30 15:01:45 +0200631 snprintf(name, sizeof(name), "%s ID %x", vendor,
Takashi Iwai0ba21762007-04-16 11:29:14 +0200632 codec->vendor_id & 0xffff);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200633 codec->name = kstrdup(name, GFP_KERNEL);
634 if (!codec->name)
635 return -ENOMEM;
636 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637}
638
639/*
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200640 * look for an AFG and MFG nodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100642static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
644 int i, total_nodes;
645 hda_nid_t nid;
646
647 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
648 for (i = 0; i < total_nodes; i++, nid++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200649 unsigned int func;
650 func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);
651 switch (func & 0xff) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200652 case AC_GRP_AUDIO_FUNCTION:
653 codec->afg = nid;
654 break;
655 case AC_GRP_MODEM_FUNCTION:
656 codec->mfg = nid;
657 break;
658 default:
659 break;
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
664/*
Takashi Iwai54d17402005-11-21 16:33:22 +0100665 * read widget caps for each widget and store in cache
666 */
667static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
668{
669 int i;
670 hda_nid_t nid;
671
672 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
673 &codec->start_nid);
674 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200675 if (!codec->wcaps)
Takashi Iwai54d17402005-11-21 16:33:22 +0100676 return -ENOMEM;
677 nid = codec->start_nid;
678 for (i = 0; i < codec->num_nodes; i++, nid++)
679 codec->wcaps[i] = snd_hda_param_read(codec, nid,
680 AC_PAR_AUDIO_WIDGET_CAP);
681 return 0;
682}
683
684
Takashi Iwai01751f52007-08-10 16:59:39 +0200685static void init_hda_cache(struct hda_cache_rec *cache,
686 unsigned int record_size);
Takashi Iwai1fcaee62007-08-23 00:01:09 +0200687static void free_hda_cache(struct hda_cache_rec *cache);
Takashi Iwai01751f52007-08-10 16:59:39 +0200688
Takashi Iwai54d17402005-11-21 16:33:22 +0100689/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 * codec destructor
691 */
692static void snd_hda_codec_free(struct hda_codec *codec)
693{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200694 if (!codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 return;
Takashi Iwaicb53c622007-08-10 17:21:45 +0200696#ifdef CONFIG_SND_HDA_POWER_SAVE
697 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +0100698 flush_workqueue(codec->bus->workq);
Takashi Iwaicb53c622007-08-10 17:21:45 +0200699#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 list_del(&codec->list);
Takashi Iwaid13bd412008-07-30 15:01:45 +0200701 snd_array_free(&codec->mixers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 codec->bus->caddr_tbl[codec->addr] = NULL;
703 if (codec->patch_ops.free)
704 codec->patch_ops.free(codec);
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100705 module_put(codec->owner);
Takashi Iwai01751f52007-08-10 16:59:39 +0200706 free_hda_cache(&codec->amp_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200707 free_hda_cache(&codec->cmd_cache);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200708 kfree(codec->name);
709 kfree(codec->modelname);
Takashi Iwai54d17402005-11-21 16:33:22 +0100710 kfree(codec->wcaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 kfree(codec);
712}
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714/**
715 * snd_hda_codec_new - create a HDA codec
716 * @bus: the bus to assign
717 * @codec_addr: the codec address
718 * @codecp: the pointer to store the generated codec
719 *
720 * Returns 0 if successful, or a negative error code.
721 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100722int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100723 int do_init, struct hda_codec **codecp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
725 struct hda_codec *codec;
Jaroslav Kyselaba443682008-08-13 20:55:32 +0200726 char component[31];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 int err;
728
Takashi Iwaida3cec32008-08-08 17:12:14 +0200729 if (snd_BUG_ON(!bus))
730 return -EINVAL;
731 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
732 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 if (bus->caddr_tbl[codec_addr]) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200735 snd_printk(KERN_ERR "hda_codec: "
736 "address 0x%x is already occupied\n", codec_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 return -EBUSY;
738 }
739
Takashi Iwaie560d8d2005-09-09 14:21:46 +0200740 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (codec == NULL) {
742 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
743 return -ENOMEM;
744 }
745
746 codec->bus = bus;
747 codec->addr = codec_addr;
Ingo Molnar62932df2006-01-16 16:34:20 +0100748 mutex_init(&codec->spdif_mutex);
Wu Fengguang5a9e02e2009-01-09 16:45:24 +0800749 mutex_init(&codec->control_mutex);
Takashi Iwai01751f52007-08-10 16:59:39 +0200750 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
Takashi Iwaib3ac5632007-08-10 17:03:40 +0200751 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwaid13bd412008-07-30 15:01:45 +0200752 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200753 if (codec->bus->modelname) {
754 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
755 if (!codec->modelname) {
756 snd_hda_codec_free(codec);
757 return -ENODEV;
758 }
759 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Takashi Iwaicb53c622007-08-10 17:21:45 +0200761#ifdef CONFIG_SND_HDA_POWER_SAVE
762 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
763 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
764 * the caller has to power down appropriatley after initialization
765 * phase.
766 */
767 hda_keep_power_on(codec);
768#endif
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 list_add_tail(&codec->list, &bus->codec_list);
771 bus->caddr_tbl[codec_addr] = codec;
772
Takashi Iwai0ba21762007-04-16 11:29:14 +0200773 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
774 AC_PAR_VENDOR_ID);
Takashi Iwai111d3af2006-02-16 18:17:58 +0100775 if (codec->vendor_id == -1)
776 /* read again, hopefully the access method was corrected
777 * in the last read...
778 */
779 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
780 AC_PAR_VENDOR_ID);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200781 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
782 AC_PAR_SUBSYSTEM_ID);
783 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
784 AC_PAR_REV_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200786 setup_fg_nodes(codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +0200787 if (!codec->afg && !codec->mfg) {
Sasha Khapyorsky673b6832005-08-11 11:00:16 +0200788 snd_printdd("hda_codec: no AFG or MFG node found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 snd_hda_codec_free(codec);
790 return -ENODEV;
791 }
792
Takashi Iwai54d17402005-11-21 16:33:22 +0100793 if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) {
794 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
795 snd_hda_codec_free(codec);
796 return -ENOMEM;
797 }
798
Takashi Iwai0ba21762007-04-16 11:29:14 +0200799 if (!codec->subsystem_id) {
Takashi Iwai86284e42005-10-11 15:05:54 +0200800 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200801 codec->subsystem_id =
802 snd_hda_codec_read(codec, nid, 0,
803 AC_VERB_GET_SUBSYSTEM_ID, 0);
Takashi Iwai86284e42005-10-11 15:05:54 +0200804 }
Takashi Iwaif44ac832008-07-30 15:01:45 +0200805 if (bus->modelname)
806 codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
Takashi Iwai86284e42005-10-11 15:05:54 +0200807
Takashi Iwaid4d9cd032008-12-19 15:19:11 +0100808 if (do_init) {
809 err = snd_hda_codec_configure(codec);
810 if (err < 0) {
811 snd_hda_codec_free(codec);
812 return err;
813 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200814 }
815 snd_hda_codec_proc_new(codec);
816
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200817 snd_hda_create_hwdep(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200818
819 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
820 codec->subsystem_id, codec->revision_id);
821 snd_component_add(codec->bus->card, component);
822
823 if (codecp)
824 *codecp = codec;
825 return 0;
826}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100827EXPORT_SYMBOL_HDA(snd_hda_codec_new);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200828
829int snd_hda_codec_configure(struct hda_codec *codec)
830{
831 int err;
832
Takashi Iwaid5ad6302007-03-07 15:55:59 +0100833 codec->preset = find_codec_preset(codec);
Takashi Iwaif44ac832008-07-30 15:01:45 +0200834 if (!codec->name) {
835 err = get_codec_name(codec);
836 if (err < 0)
837 return err;
838 }
Takashi Iwai43ea1d42007-04-26 19:12:08 +0200839 /* audio codec should override the mixer name */
Takashi Iwaif44ac832008-07-30 15:01:45 +0200840 if (codec->afg || !*codec->bus->card->mixername)
841 strlcpy(codec->bus->card->mixername, codec->name,
842 sizeof(codec->bus->card->mixername));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Takashi Iwai82467612007-07-27 19:15:54 +0200844 if (is_generic_config(codec)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai82467612007-07-27 19:15:54 +0200846 goto patched;
847 }
Takashi Iwai82467612007-07-27 19:15:54 +0200848 if (codec->preset && codec->preset->patch) {
849 err = codec->preset->patch(codec);
850 goto patched;
851 }
852
853 /* call the default parser */
Takashi Iwai82467612007-07-27 19:15:54 +0200854 err = snd_hda_parse_generic_codec(codec);
Takashi Iwai35a1e0c2007-10-19 08:13:40 +0200855 if (err < 0)
856 printk(KERN_ERR "hda-codec: No codec parser is available\n");
Takashi Iwai82467612007-07-27 19:15:54 +0200857
858 patched:
Takashi Iwai6c1f45e2008-07-30 15:01:45 +0200859 if (!err && codec->patch_ops.unsol_event)
860 err = init_unsol_queue(codec->bus);
861 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862}
863
864/**
865 * snd_hda_codec_setup_stream - set up the codec for streaming
866 * @codec: the CODEC to set up
867 * @nid: the NID to set up
868 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
869 * @channel_id: channel id to pass, zero based.
870 * @format: stream format.
871 */
Takashi Iwai0ba21762007-04-16 11:29:14 +0200872void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
873 u32 stream_tag,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 int channel_id, int format)
875{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200876 if (!nid)
Takashi Iwaid21b37e2005-04-20 13:45:55 +0200877 return;
878
Takashi Iwai0ba21762007-04-16 11:29:14 +0200879 snd_printdd("hda_codec_setup_stream: "
880 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 nid, stream_tag, channel_id, format);
882 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
883 (stream_tag << 4) | channel_id);
884 msleep(1);
885 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
886}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100887EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
Takashi Iwai888afa12008-03-18 09:57:50 +0100889void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
890{
891 if (!nid)
892 return;
893
894 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
895 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
896#if 0 /* keep the format */
897 msleep(1);
898 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
899#endif
900}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100901EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
Takashi Iwai888afa12008-03-18 09:57:50 +0100902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903/*
904 * amp access functions
905 */
906
Takashi Iwai4a19fae2005-06-08 14:43:58 +0200907/* FIXME: more better hash key? */
908#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909#define INFO_AMP_CAPS (1<<0)
Takashi Iwai4a19fae2005-06-08 14:43:58 +0200910#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912/* initialize the hash table */
Takashi Iwai1289e9e2008-11-27 15:47:11 +0100913static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
Takashi Iwai01751f52007-08-10 16:59:39 +0200914 unsigned int record_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
Takashi Iwai01751f52007-08-10 16:59:39 +0200916 memset(cache, 0, sizeof(*cache));
917 memset(cache->hash, 0xff, sizeof(cache->hash));
Takashi Iwai603c4012008-07-30 15:01:44 +0200918 snd_array_init(&cache->buf, record_size, 64);
Takashi Iwai01751f52007-08-10 16:59:39 +0200919}
920
Takashi Iwai1fcaee62007-08-23 00:01:09 +0200921static void free_hda_cache(struct hda_cache_rec *cache)
Takashi Iwai01751f52007-08-10 16:59:39 +0200922{
Takashi Iwai603c4012008-07-30 15:01:44 +0200923 snd_array_free(&cache->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924}
925
926/* query the hash. allocate an entry if not found. */
Takashi Iwai01751f52007-08-10 16:59:39 +0200927static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
928 u32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929{
Takashi Iwai01751f52007-08-10 16:59:39 +0200930 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
931 u16 cur = cache->hash[idx];
932 struct hda_cache_head *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
934 while (cur != 0xffff) {
Takashi Iwaif43aa022008-11-10 16:24:26 +0100935 info = snd_array_elem(&cache->buf, cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 if (info->key == key)
937 return info;
938 cur = info->next;
939 }
940
941 /* add a new hash entry */
Takashi Iwai603c4012008-07-30 15:01:44 +0200942 info = snd_array_new(&cache->buf);
Takashi Iwaic2174292008-11-07 00:23:30 +0100943 if (!info)
944 return NULL;
Takashi Iwaif43aa022008-11-10 16:24:26 +0100945 cur = snd_array_index(&cache->buf, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 info->key = key;
Takashi Iwai01751f52007-08-10 16:59:39 +0200947 info->val = 0;
948 info->next = cache->hash[idx];
949 cache->hash[idx] = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 return info;
952}
953
Takashi Iwai01751f52007-08-10 16:59:39 +0200954/* query and allocate an amp hash entry */
955static inline struct hda_amp_info *
956get_alloc_amp_hash(struct hda_codec *codec, u32 key)
957{
958 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
959}
960
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961/*
962 * query AMP capabilities for the given widget and direction
963 */
Matthew Ranostay09a99952008-01-24 11:49:21 +0100964u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965{
Takashi Iwai0ba21762007-04-16 11:29:14 +0200966 struct hda_amp_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Takashi Iwai0ba21762007-04-16 11:29:14 +0200968 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
969 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 return 0;
Takashi Iwai01751f52007-08-10 16:59:39 +0200971 if (!(info->head.val & INFO_AMP_CAPS)) {
Takashi Iwai0ba21762007-04-16 11:29:14 +0200972 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 nid = codec->afg;
Takashi Iwai0ba21762007-04-16 11:29:14 +0200974 info->amp_caps = snd_hda_param_read(codec, nid,
975 direction == HDA_OUTPUT ?
976 AC_PAR_AMP_OUT_CAP :
977 AC_PAR_AMP_IN_CAP);
Takashi Iwaib75e53f2007-05-10 16:56:09 +0200978 if (info->amp_caps)
Takashi Iwai01751f52007-08-10 16:59:39 +0200979 info->head.val |= INFO_AMP_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 }
981 return info->amp_caps;
982}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100983EXPORT_SYMBOL_HDA(query_amp_caps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Takashi Iwai897cc182007-05-29 19:01:37 +0200985int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
986 unsigned int caps)
987{
988 struct hda_amp_info *info;
989
990 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
991 if (!info)
992 return -EINVAL;
993 info->amp_caps = caps;
Takashi Iwai01751f52007-08-10 16:59:39 +0200994 info->head.val |= INFO_AMP_CAPS;
Takashi Iwai897cc182007-05-29 19:01:37 +0200995 return 0;
996}
Takashi Iwaiff7a3262008-11-28 15:17:06 +0100997EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
Takashi Iwai897cc182007-05-29 19:01:37 +0200998
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999/*
1000 * read the current volume to info
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001001 * if the cache exists, read the cache value.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001003static unsigned int get_vol_mute(struct hda_codec *codec,
1004 struct hda_amp_info *info, hda_nid_t nid,
1005 int ch, int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
1007 u32 val, parm;
1008
Takashi Iwai01751f52007-08-10 16:59:39 +02001009 if (info->head.val & INFO_AMP_VOL(ch))
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001010 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
1012 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1013 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1014 parm |= index;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001015 val = snd_hda_codec_read(codec, nid, 0,
1016 AC_VERB_GET_AMP_GAIN_MUTE, parm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 info->vol[ch] = val & 0xff;
Takashi Iwai01751f52007-08-10 16:59:39 +02001018 info->head.val |= INFO_AMP_VOL(ch);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001019 return info->vol[ch];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
1021
1022/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001023 * write the current volume in info to the h/w and update the cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 */
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001025static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
Takashi Iwai0ba21762007-04-16 11:29:14 +02001026 hda_nid_t nid, int ch, int direction, int index,
1027 int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028{
1029 u32 parm;
1030
1031 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1032 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1033 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1034 parm |= val;
1035 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001036 info->vol[ch] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039/*
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001040 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 */
Takashi Iwai834be882006-03-01 14:16:17 +01001042int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1043 int direction, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001045 struct hda_amp_info *info;
1046 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1047 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001049 return get_vol_mute(codec, info, nid, ch, direction, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001051EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001053/*
1054 * update the AMP value, mask = bit mask to set, val = the value
1055 */
Takashi Iwai834be882006-03-01 14:16:17 +01001056int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1057 int direction, int idx, int mask, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Takashi Iwai0ba21762007-04-16 11:29:14 +02001059 struct hda_amp_info *info;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001060
Takashi Iwai0ba21762007-04-16 11:29:14 +02001061 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1062 if (!info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001064 val &= mask;
1065 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001066 if (info->vol[ch] == val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return 0;
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001068 put_vol_mute(codec, info, nid, ch, direction, idx, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 return 1;
1070}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001071EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Takashi Iwai47fd8302007-08-10 17:11:07 +02001073/*
1074 * update the AMP stereo with the same mask and value
1075 */
1076int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1077 int direction, int idx, int mask, int val)
1078{
1079 int ch, ret = 0;
1080 for (ch = 0; ch < 2; ch++)
1081 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1082 idx, mask, val);
1083 return ret;
1084}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001085EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
Takashi Iwai47fd8302007-08-10 17:11:07 +02001086
Takashi Iwaicb53c622007-08-10 17:21:45 +02001087#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001088/* resume the all amp commands from the cache */
1089void snd_hda_codec_resume_amp(struct hda_codec *codec)
1090{
Takashi Iwai603c4012008-07-30 15:01:44 +02001091 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001092 int i;
1093
Takashi Iwai603c4012008-07-30 15:01:44 +02001094 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02001095 u32 key = buffer->head.key;
1096 hda_nid_t nid;
1097 unsigned int idx, dir, ch;
1098 if (!key)
1099 continue;
1100 nid = key & 0xff;
1101 idx = (key >> 16) & 0xff;
1102 dir = (key >> 24) & 0xff;
1103 for (ch = 0; ch < 2; ch++) {
1104 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1105 continue;
1106 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1107 buffer->vol[ch]);
1108 }
1109 }
1110}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001111EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001112#endif /* SND_HDA_NEEDS_RESUME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114/* volume */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001115int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1116 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
1118 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1119 u16 nid = get_amp_nid(kcontrol);
1120 u8 chs = get_amp_channels(kcontrol);
1121 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001122 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 u32 caps;
1124
1125 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001126 /* num steps */
1127 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1128 if (!caps) {
1129 printk(KERN_WARNING "hda_codec: "
Takashi Iwai9c8f2ab2008-01-11 16:12:23 +01001130 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1131 kcontrol->id.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 return -EINVAL;
1133 }
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001134 if (ofs < caps)
1135 caps -= ofs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1137 uinfo->count = chs == 3 ? 2 : 1;
1138 uinfo->value.integer.min = 0;
1139 uinfo->value.integer.max = caps;
1140 return 0;
1141}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001142EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001144
1145static inline unsigned int
1146read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1147 int ch, int dir, int idx, unsigned int ofs)
1148{
1149 unsigned int val;
1150 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1151 val &= HDA_AMP_VOLMASK;
1152 if (val >= ofs)
1153 val -= ofs;
1154 else
1155 val = 0;
1156 return val;
1157}
1158
1159static inline int
1160update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1161 int ch, int dir, int idx, unsigned int ofs,
1162 unsigned int val)
1163{
1164 if (val > 0)
1165 val += ofs;
1166 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1167 HDA_AMP_VOLMASK, val);
1168}
1169
Takashi Iwai0ba21762007-04-16 11:29:14 +02001170int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1171 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172{
1173 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1174 hda_nid_t nid = get_amp_nid(kcontrol);
1175 int chs = get_amp_channels(kcontrol);
1176 int dir = get_amp_direction(kcontrol);
1177 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001178 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 long *valp = ucontrol->value.integer.value;
1180
1181 if (chs & 1)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001182 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001184 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 return 0;
1186}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001187EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188
Takashi Iwai0ba21762007-04-16 11:29:14 +02001189int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1190 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191{
1192 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1193 hda_nid_t nid = get_amp_nid(kcontrol);
1194 int chs = get_amp_channels(kcontrol);
1195 int dir = get_amp_direction(kcontrol);
1196 int idx = get_amp_index(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001197 unsigned int ofs = get_amp_offset(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 long *valp = ucontrol->value.integer.value;
1199 int change = 0;
1200
Takashi Iwaicb53c622007-08-10 17:21:45 +02001201 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001202 if (chs & 1) {
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001203 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001204 valp++;
1205 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001206 if (chs & 2)
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001207 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001208 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 return change;
1210}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001211EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001213int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1214 unsigned int size, unsigned int __user *_tlv)
1215{
1216 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1217 hda_nid_t nid = get_amp_nid(kcontrol);
1218 int dir = get_amp_direction(kcontrol);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001219 unsigned int ofs = get_amp_offset(kcontrol);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001220 u32 caps, val1, val2;
1221
1222 if (size < 4 * sizeof(unsigned int))
1223 return -ENOMEM;
1224 caps = query_amp_caps(codec, nid, dir);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001225 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1226 val2 = (val2 + 1) * 25;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001227 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
Takashi Iwai29fdbec2009-01-20 13:07:55 +01001228 val1 += ofs;
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001229 val1 = ((int)val1) * ((int)val2);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001230 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1231 return -EFAULT;
1232 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1233 return -EFAULT;
1234 if (put_user(val1, _tlv + 2))
1235 return -EFAULT;
1236 if (put_user(val2, _tlv + 3))
1237 return -EFAULT;
1238 return 0;
1239}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001240EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
Jaroslav Kysela302e9c52006-07-05 17:39:49 +02001241
Takashi Iwai2134ea42008-01-10 16:53:55 +01001242/*
1243 * set (static) TLV for virtual master volume; recalculated as max 0dB
1244 */
1245void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1246 unsigned int *tlv)
1247{
1248 u32 caps;
1249 int nums, step;
1250
1251 caps = query_amp_caps(codec, nid, dir);
1252 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1253 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1254 step = (step + 1) * 25;
1255 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1256 tlv[1] = 2 * sizeof(unsigned int);
1257 tlv[2] = -nums * step;
1258 tlv[3] = step;
1259}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001260EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001261
1262/* find a mixer control element with the given name */
Takashi Iwai09f99702008-02-04 12:31:13 +01001263static struct snd_kcontrol *
1264_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1265 const char *name, int idx)
Takashi Iwai2134ea42008-01-10 16:53:55 +01001266{
1267 struct snd_ctl_elem_id id;
1268 memset(&id, 0, sizeof(id));
1269 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
Takashi Iwai09f99702008-02-04 12:31:13 +01001270 id.index = idx;
Takashi Iwai2134ea42008-01-10 16:53:55 +01001271 strcpy(id.name, name);
1272 return snd_ctl_find_id(codec->bus->card, &id);
1273}
1274
Takashi Iwai09f99702008-02-04 12:31:13 +01001275struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1276 const char *name)
1277{
1278 return _snd_hda_find_mixer_ctl(codec, name, 0);
1279}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001280EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
Takashi Iwai09f99702008-02-04 12:31:13 +01001281
Takashi Iwaid13bd412008-07-30 15:01:45 +02001282/* Add a control element and assign to the codec */
1283int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1284{
1285 int err;
1286 struct snd_kcontrol **knewp;
1287
1288 err = snd_ctl_add(codec->bus->card, kctl);
1289 if (err < 0)
1290 return err;
1291 knewp = snd_array_new(&codec->mixers);
1292 if (!knewp)
1293 return -ENOMEM;
1294 *knewp = kctl;
1295 return 0;
1296}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001297EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001298
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001299#ifdef CONFIG_SND_HDA_RECONFIG
Takashi Iwaid13bd412008-07-30 15:01:45 +02001300/* Clear all controls assigned to the given codec */
1301void snd_hda_ctls_clear(struct hda_codec *codec)
1302{
1303 int i;
1304 struct snd_kcontrol **kctls = codec->mixers.list;
1305 for (i = 0; i < codec->mixers.used; i++)
1306 snd_ctl_remove(codec->bus->card, kctls[i]);
1307 snd_array_free(&codec->mixers);
1308}
1309
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001310void snd_hda_codec_reset(struct hda_codec *codec)
1311{
1312 int i;
1313
1314#ifdef CONFIG_SND_HDA_POWER_SAVE
1315 cancel_delayed_work(&codec->power_work);
Takashi Iwai6acaed32009-01-12 10:09:24 +01001316 flush_workqueue(codec->bus->workq);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001317#endif
1318 snd_hda_ctls_clear(codec);
1319 /* relase PCMs */
1320 for (i = 0; i < codec->num_pcms; i++) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001321 if (codec->pcm_info[i].pcm) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001322 snd_device_free(codec->bus->card,
1323 codec->pcm_info[i].pcm);
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001324 clear_bit(codec->pcm_info[i].device,
1325 codec->bus->pcm_dev_bits);
1326 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001327 }
1328 if (codec->patch_ops.free)
1329 codec->patch_ops.free(codec);
Takashi Iwai56d17712008-11-28 14:36:23 +01001330 codec->proc_widget_hook = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001331 codec->spec = NULL;
1332 free_hda_cache(&codec->amp_cache);
1333 free_hda_cache(&codec->cmd_cache);
Takashi Iwai827057f2008-12-19 10:12:02 +01001334 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1335 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001336 codec->num_pcms = 0;
1337 codec->pcm_info = NULL;
1338 codec->preset = NULL;
Takashi Iwai1289e9e2008-11-27 15:47:11 +01001339 module_put(codec->owner);
1340 codec->owner = NULL;
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001341}
Takashi Iwai529bd6c2008-11-27 14:17:01 +01001342#endif /* CONFIG_SND_HDA_RECONFIG */
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02001343
Takashi Iwai2134ea42008-01-10 16:53:55 +01001344/* create a virtual master control and add slaves */
1345int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1346 unsigned int *tlv, const char **slaves)
1347{
1348 struct snd_kcontrol *kctl;
1349 const char **s;
1350 int err;
1351
Takashi Iwai2f085542008-02-22 18:43:50 +01001352 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1353 ;
1354 if (!*s) {
1355 snd_printdd("No slave found for %s\n", name);
1356 return 0;
1357 }
Takashi Iwai2134ea42008-01-10 16:53:55 +01001358 kctl = snd_ctl_make_virtual_master(name, tlv);
1359 if (!kctl)
1360 return -ENOMEM;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001361 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001362 if (err < 0)
1363 return err;
1364
1365 for (s = slaves; *s; s++) {
1366 struct snd_kcontrol *sctl;
1367
1368 sctl = snd_hda_find_mixer_ctl(codec, *s);
1369 if (!sctl) {
1370 snd_printdd("Cannot find slave %s, skipped\n", *s);
1371 continue;
1372 }
1373 err = snd_ctl_add_slave(kctl, sctl);
1374 if (err < 0)
1375 return err;
1376 }
1377 return 0;
1378}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001379EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
Takashi Iwai2134ea42008-01-10 16:53:55 +01001380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381/* switch */
Takashi Iwai0ba21762007-04-16 11:29:14 +02001382int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1383 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384{
1385 int chs = get_amp_channels(kcontrol);
1386
1387 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1388 uinfo->count = chs == 3 ? 2 : 1;
1389 uinfo->value.integer.min = 0;
1390 uinfo->value.integer.max = 1;
1391 return 0;
1392}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001393EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
Takashi Iwai0ba21762007-04-16 11:29:14 +02001395int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1396 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397{
1398 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1399 hda_nid_t nid = get_amp_nid(kcontrol);
1400 int chs = get_amp_channels(kcontrol);
1401 int dir = get_amp_direction(kcontrol);
1402 int idx = get_amp_index(kcontrol);
1403 long *valp = ucontrol->value.integer.value;
1404
1405 if (chs & 1)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001406 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001407 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 if (chs & 2)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001409 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
Takashi Iwai47fd8302007-08-10 17:11:07 +02001410 HDA_AMP_MUTE) ? 0 : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 return 0;
1412}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001413EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Takashi Iwai0ba21762007-04-16 11:29:14 +02001415int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1416 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1419 hda_nid_t nid = get_amp_nid(kcontrol);
1420 int chs = get_amp_channels(kcontrol);
1421 int dir = get_amp_direction(kcontrol);
1422 int idx = get_amp_index(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 long *valp = ucontrol->value.integer.value;
1424 int change = 0;
1425
Takashi Iwaicb53c622007-08-10 17:21:45 +02001426 snd_hda_power_up(codec);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001427 if (chs & 1) {
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001428 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001429 HDA_AMP_MUTE,
1430 *valp ? 0 : HDA_AMP_MUTE);
Nicolas Grazianob9f5a892005-07-29 12:17:20 +02001431 valp++;
1432 }
Takashi Iwai4a19fae2005-06-08 14:43:58 +02001433 if (chs & 2)
1434 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
Takashi Iwai47fd8302007-08-10 17:11:07 +02001435 HDA_AMP_MUTE,
1436 *valp ? 0 : HDA_AMP_MUTE);
Takashi Iwaicb53c622007-08-10 17:21:45 +02001437#ifdef CONFIG_SND_HDA_POWER_SAVE
1438 if (codec->patch_ops.check_power_status)
1439 codec->patch_ops.check_power_status(codec, nid);
1440#endif
1441 snd_hda_power_down(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 return change;
1443}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001444EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446/*
Takashi Iwai985be542005-11-02 18:26:49 +01001447 * bound volume controls
1448 *
1449 * bind multiple volumes (# indices, from 0)
1450 */
1451
1452#define AMP_VAL_IDX_SHIFT 19
1453#define AMP_VAL_IDX_MASK (0x0f<<19)
1454
Takashi Iwai0ba21762007-04-16 11:29:14 +02001455int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1456 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01001457{
1458 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1459 unsigned long pval;
1460 int err;
1461
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001462 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001463 pval = kcontrol->private_value;
1464 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1465 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1466 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001467 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001468 return err;
1469}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001470EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
Takashi Iwai985be542005-11-02 18:26:49 +01001471
Takashi Iwai0ba21762007-04-16 11:29:14 +02001472int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1473 struct snd_ctl_elem_value *ucontrol)
Takashi Iwai985be542005-11-02 18:26:49 +01001474{
1475 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1476 unsigned long pval;
1477 int i, indices, err = 0, change = 0;
1478
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001479 mutex_lock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001480 pval = kcontrol->private_value;
1481 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1482 for (i = 0; i < indices; i++) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001483 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1484 (i << AMP_VAL_IDX_SHIFT);
Takashi Iwai985be542005-11-02 18:26:49 +01001485 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1486 if (err < 0)
1487 break;
1488 change |= err;
1489 }
1490 kcontrol->private_value = pval;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001491 mutex_unlock(&codec->control_mutex);
Takashi Iwai985be542005-11-02 18:26:49 +01001492 return err < 0 ? err : change;
1493}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001494EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
Takashi Iwai985be542005-11-02 18:26:49 +01001495
1496/*
Takashi Iwai532d5382007-07-27 19:02:40 +02001497 * generic bound volume/swtich controls
1498 */
1499int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1500 struct snd_ctl_elem_info *uinfo)
1501{
1502 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1503 struct hda_bind_ctls *c;
1504 int err;
1505
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001506 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001507 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001508 kcontrol->private_value = *c->values;
1509 err = c->ops->info(kcontrol, uinfo);
1510 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001511 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001512 return err;
1513}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001514EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
Takashi Iwai532d5382007-07-27 19:02:40 +02001515
1516int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1517 struct snd_ctl_elem_value *ucontrol)
1518{
1519 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1520 struct hda_bind_ctls *c;
1521 int err;
1522
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001523 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001524 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001525 kcontrol->private_value = *c->values;
1526 err = c->ops->get(kcontrol, ucontrol);
1527 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001528 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001529 return err;
1530}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001531EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
Takashi Iwai532d5382007-07-27 19:02:40 +02001532
1533int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1534 struct snd_ctl_elem_value *ucontrol)
1535{
1536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1537 struct hda_bind_ctls *c;
1538 unsigned long *vals;
1539 int err = 0, change = 0;
1540
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001541 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001542 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001543 for (vals = c->values; *vals; vals++) {
1544 kcontrol->private_value = *vals;
1545 err = c->ops->put(kcontrol, ucontrol);
1546 if (err < 0)
1547 break;
1548 change |= err;
1549 }
1550 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001551 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001552 return err < 0 ? err : change;
1553}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001554EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
Takashi Iwai532d5382007-07-27 19:02:40 +02001555
1556int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1557 unsigned int size, unsigned int __user *tlv)
1558{
1559 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1560 struct hda_bind_ctls *c;
1561 int err;
1562
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001563 mutex_lock(&codec->control_mutex);
Serge A. Suchkov14c65f92008-02-22 18:43:16 +01001564 c = (struct hda_bind_ctls *)kcontrol->private_value;
Takashi Iwai532d5382007-07-27 19:02:40 +02001565 kcontrol->private_value = *c->values;
1566 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1567 kcontrol->private_value = (long)c;
Wu Fengguang5a9e02e2009-01-09 16:45:24 +08001568 mutex_unlock(&codec->control_mutex);
Takashi Iwai532d5382007-07-27 19:02:40 +02001569 return err;
1570}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001571EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
Takashi Iwai532d5382007-07-27 19:02:40 +02001572
1573struct hda_ctl_ops snd_hda_bind_vol = {
1574 .info = snd_hda_mixer_amp_volume_info,
1575 .get = snd_hda_mixer_amp_volume_get,
1576 .put = snd_hda_mixer_amp_volume_put,
1577 .tlv = snd_hda_mixer_amp_tlv
1578};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001579EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
Takashi Iwai532d5382007-07-27 19:02:40 +02001580
1581struct hda_ctl_ops snd_hda_bind_sw = {
1582 .info = snd_hda_mixer_amp_switch_info,
1583 .get = snd_hda_mixer_amp_switch_get,
1584 .put = snd_hda_mixer_amp_switch_put,
1585 .tlv = snd_hda_mixer_amp_tlv
1586};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001587EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
Takashi Iwai532d5382007-07-27 19:02:40 +02001588
1589/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 * SPDIF out controls
1591 */
1592
Takashi Iwai0ba21762007-04-16 11:29:14 +02001593static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1594 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595{
1596 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1597 uinfo->count = 1;
1598 return 0;
1599}
1600
Takashi Iwai0ba21762007-04-16 11:29:14 +02001601static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1602 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603{
1604 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1605 IEC958_AES0_NONAUDIO |
1606 IEC958_AES0_CON_EMPHASIS_5015 |
1607 IEC958_AES0_CON_NOT_COPYRIGHT;
1608 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1609 IEC958_AES1_CON_ORIGINAL;
1610 return 0;
1611}
1612
Takashi Iwai0ba21762007-04-16 11:29:14 +02001613static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1614 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615{
1616 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1617 IEC958_AES0_NONAUDIO |
1618 IEC958_AES0_PRO_EMPHASIS_5015;
1619 return 0;
1620}
1621
Takashi Iwai0ba21762007-04-16 11:29:14 +02001622static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1623 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624{
1625 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1626
1627 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1628 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1629 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1630 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1631
1632 return 0;
1633}
1634
1635/* convert from SPDIF status bits to HDA SPDIF bits
1636 * bit 0 (DigEn) is always set zero (to be filled later)
1637 */
1638static unsigned short convert_from_spdif_status(unsigned int sbits)
1639{
1640 unsigned short val = 0;
1641
1642 if (sbits & IEC958_AES0_PROFESSIONAL)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001643 val |= AC_DIG1_PROFESSIONAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 if (sbits & IEC958_AES0_NONAUDIO)
Takashi Iwai0ba21762007-04-16 11:29:14 +02001645 val |= AC_DIG1_NONAUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001647 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1648 IEC958_AES0_PRO_EMPHASIS_5015)
1649 val |= AC_DIG1_EMPHASIS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001651 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1652 IEC958_AES0_CON_EMPHASIS_5015)
1653 val |= AC_DIG1_EMPHASIS;
1654 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1655 val |= AC_DIG1_COPYRIGHT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
Takashi Iwai0ba21762007-04-16 11:29:14 +02001657 val |= AC_DIG1_LEVEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1659 }
1660 return val;
1661}
1662
1663/* convert to SPDIF status bits from HDA SPDIF bits
1664 */
1665static unsigned int convert_to_spdif_status(unsigned short val)
1666{
1667 unsigned int sbits = 0;
1668
Takashi Iwai0ba21762007-04-16 11:29:14 +02001669 if (val & AC_DIG1_NONAUDIO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 sbits |= IEC958_AES0_NONAUDIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001671 if (val & AC_DIG1_PROFESSIONAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 sbits |= IEC958_AES0_PROFESSIONAL;
1673 if (sbits & IEC958_AES0_PROFESSIONAL) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001674 if (sbits & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1676 } else {
Takashi Iwai0ba21762007-04-16 11:29:14 +02001677 if (val & AC_DIG1_EMPHASIS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001679 if (!(val & AC_DIG1_COPYRIGHT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
Takashi Iwai0ba21762007-04-16 11:29:14 +02001681 if (val & AC_DIG1_LEVEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1683 sbits |= val & (0x7f << 8);
1684 }
1685 return sbits;
1686}
1687
Takashi Iwai2f728532008-09-25 16:32:41 +02001688/* set digital convert verbs both for the given NID and its slaves */
1689static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1690 int verb, int val)
1691{
1692 hda_nid_t *d;
1693
Takashi Iwai9e976972008-11-25 08:17:20 +01001694 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02001695 d = codec->slave_dig_outs;
1696 if (!d)
1697 return;
1698 for (; *d; d++)
Takashi Iwai9e976972008-11-25 08:17:20 +01001699 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
Takashi Iwai2f728532008-09-25 16:32:41 +02001700}
1701
1702static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1703 int dig1, int dig2)
1704{
1705 if (dig1 != -1)
1706 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1707 if (dig2 != -1)
1708 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1709}
1710
Takashi Iwai0ba21762007-04-16 11:29:14 +02001711static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1712 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713{
1714 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1715 hda_nid_t nid = kcontrol->private_value;
1716 unsigned short val;
1717 int change;
1718
Ingo Molnar62932df2006-01-16 16:34:20 +01001719 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 codec->spdif_status = ucontrol->value.iec958.status[0] |
1721 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
1722 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
1723 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
1724 val = convert_from_spdif_status(codec->spdif_status);
1725 val |= codec->spdif_ctls & 1;
1726 change = codec->spdif_ctls != val;
1727 codec->spdif_ctls = val;
1728
Takashi Iwai2f728532008-09-25 16:32:41 +02001729 if (change)
1730 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
Ingo Molnar62932df2006-01-16 16:34:20 +01001732 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 return change;
1734}
1735
Takashi Iwaia5ce8892007-07-23 15:42:26 +02001736#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
Takashi Iwai0ba21762007-04-16 11:29:14 +02001738static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
1739 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740{
1741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1742
Takashi Iwai0ba21762007-04-16 11:29:14 +02001743 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 return 0;
1745}
1746
Takashi Iwai0ba21762007-04-16 11:29:14 +02001747static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
1748 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749{
1750 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1751 hda_nid_t nid = kcontrol->private_value;
1752 unsigned short val;
1753 int change;
1754
Ingo Molnar62932df2006-01-16 16:34:20 +01001755 mutex_lock(&codec->spdif_mutex);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001756 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 if (ucontrol->value.integer.value[0])
Takashi Iwai0ba21762007-04-16 11:29:14 +02001758 val |= AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 change = codec->spdif_ctls != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001760 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 codec->spdif_ctls = val;
Takashi Iwai2f728532008-09-25 16:32:41 +02001762 set_dig_out_convert(codec, nid, val & 0xff, -1);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001763 /* unmute amp switch (if any) */
1764 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
Takashi Iwai47fd8302007-08-10 17:11:07 +02001765 (val & AC_DIG1_ENABLE))
1766 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1767 HDA_AMP_MUTE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 }
Ingo Molnar62932df2006-01-16 16:34:20 +01001769 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 return change;
1771}
1772
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01001773static struct snd_kcontrol_new dig_mixes[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 {
1775 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1776 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1777 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
1778 .info = snd_hda_spdif_mask_info,
1779 .get = snd_hda_spdif_cmask_get,
1780 },
1781 {
1782 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1783 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1784 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
1785 .info = snd_hda_spdif_mask_info,
1786 .get = snd_hda_spdif_pmask_get,
1787 },
1788 {
1789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1790 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1791 .info = snd_hda_spdif_mask_info,
1792 .get = snd_hda_spdif_default_get,
1793 .put = snd_hda_spdif_default_put,
1794 },
1795 {
1796 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1797 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
1798 .info = snd_hda_spdif_out_switch_info,
1799 .get = snd_hda_spdif_out_switch_get,
1800 .put = snd_hda_spdif_out_switch_put,
1801 },
1802 { } /* end */
1803};
1804
Takashi Iwai09f99702008-02-04 12:31:13 +01001805#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
1806
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807/**
1808 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
1809 * @codec: the HDA codec
1810 * @nid: audio out widget NID
1811 *
1812 * Creates controls related with the SPDIF output.
1813 * Called from each patch supporting the SPDIF out.
1814 *
1815 * Returns 0 if successful, or a negative error code.
1816 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02001817int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818{
1819 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01001820 struct snd_kcontrol *kctl;
1821 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01001822 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
Takashi Iwai09f99702008-02-04 12:31:13 +01001824 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1825 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
1826 idx))
1827 break;
1828 }
1829 if (idx >= SPDIF_MAX_IDX) {
1830 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
1831 return -EBUSY;
1832 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
1834 kctl = snd_ctl_new1(dig_mix, codec);
Takashi Iwaib91f0802008-11-04 08:43:08 +01001835 if (!kctl)
1836 return -ENOMEM;
Takashi Iwai09f99702008-02-04 12:31:13 +01001837 kctl->id.index = idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 kctl->private_value = nid;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001839 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001840 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 return err;
1842 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02001843 codec->spdif_ctls =
Andrew Paprocki3982d172007-12-19 12:13:44 +01001844 snd_hda_codec_read(codec, nid, 0,
1845 AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
1847 return 0;
1848}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001849EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850
1851/*
Takashi Iwai9a081602008-02-12 18:37:26 +01001852 * SPDIF sharing with analog output
1853 */
1854static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
1855 struct snd_ctl_elem_value *ucontrol)
1856{
1857 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1858 ucontrol->value.integer.value[0] = mout->share_spdif;
1859 return 0;
1860}
1861
1862static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
1863 struct snd_ctl_elem_value *ucontrol)
1864{
1865 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
1866 mout->share_spdif = !!ucontrol->value.integer.value[0];
1867 return 0;
1868}
1869
1870static struct snd_kcontrol_new spdif_share_sw = {
1871 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1872 .name = "IEC958 Default PCM Playback Switch",
1873 .info = snd_ctl_boolean_mono_info,
1874 .get = spdif_share_sw_get,
1875 .put = spdif_share_sw_put,
1876};
1877
1878int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
1879 struct hda_multi_out *mout)
1880{
1881 if (!mout->dig_out_nid)
1882 return 0;
1883 /* ATTENTION: here mout is passed as private_data, instead of codec */
Takashi Iwaid13bd412008-07-30 15:01:45 +02001884 return snd_hda_ctl_add(codec,
Takashi Iwai9a081602008-02-12 18:37:26 +01001885 snd_ctl_new1(&spdif_share_sw, mout));
1886}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001887EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
Takashi Iwai9a081602008-02-12 18:37:26 +01001888
1889/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 * SPDIF input
1891 */
1892
1893#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
1894
Takashi Iwai0ba21762007-04-16 11:29:14 +02001895static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
1896 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1899
1900 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
1901 return 0;
1902}
1903
Takashi Iwai0ba21762007-04-16 11:29:14 +02001904static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
1905 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906{
1907 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908 hda_nid_t nid = kcontrol->private_value;
1909 unsigned int val = !!ucontrol->value.integer.value[0];
1910 int change;
1911
Ingo Molnar62932df2006-01-16 16:34:20 +01001912 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 change = codec->spdif_in_enable != val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001914 if (change) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 codec->spdif_in_enable = val;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02001916 snd_hda_codec_write_cache(codec, nid, 0,
1917 AC_VERB_SET_DIGI_CONVERT_1, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 }
Ingo Molnar62932df2006-01-16 16:34:20 +01001919 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 return change;
1921}
1922
Takashi Iwai0ba21762007-04-16 11:29:14 +02001923static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
1924 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925{
1926 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1927 hda_nid_t nid = kcontrol->private_value;
1928 unsigned short val;
1929 unsigned int sbits;
1930
Andrew Paprocki3982d172007-12-19 12:13:44 +01001931 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 sbits = convert_to_spdif_status(val);
1933 ucontrol->value.iec958.status[0] = sbits;
1934 ucontrol->value.iec958.status[1] = sbits >> 8;
1935 ucontrol->value.iec958.status[2] = sbits >> 16;
1936 ucontrol->value.iec958.status[3] = sbits >> 24;
1937 return 0;
1938}
1939
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01001940static struct snd_kcontrol_new dig_in_ctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 {
1942 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1943 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
1944 .info = snd_hda_spdif_in_switch_info,
1945 .get = snd_hda_spdif_in_switch_get,
1946 .put = snd_hda_spdif_in_switch_put,
1947 },
1948 {
1949 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1950 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1951 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1952 .info = snd_hda_spdif_mask_info,
1953 .get = snd_hda_spdif_in_status_get,
1954 },
1955 { } /* end */
1956};
1957
1958/**
1959 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
1960 * @codec: the HDA codec
1961 * @nid: audio in widget NID
1962 *
1963 * Creates controls related with the SPDIF input.
1964 * Called from each patch supporting the SPDIF in.
1965 *
1966 * Returns 0 if successful, or a negative error code.
1967 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02001968int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969{
1970 int err;
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01001971 struct snd_kcontrol *kctl;
1972 struct snd_kcontrol_new *dig_mix;
Takashi Iwai09f99702008-02-04 12:31:13 +01001973 int idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974
Takashi Iwai09f99702008-02-04 12:31:13 +01001975 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
1976 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
1977 idx))
1978 break;
1979 }
1980 if (idx >= SPDIF_MAX_IDX) {
1981 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
1982 return -EBUSY;
1983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
1985 kctl = snd_ctl_new1(dig_mix, codec);
1986 kctl->private_value = nid;
Takashi Iwaid13bd412008-07-30 15:01:45 +02001987 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02001988 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 return err;
1990 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02001991 codec->spdif_in_enable =
Andrew Paprocki3982d172007-12-19 12:13:44 +01001992 snd_hda_codec_read(codec, nid, 0,
1993 AC_VERB_GET_DIGI_CONVERT_1, 0) &
Takashi Iwai0ba21762007-04-16 11:29:14 +02001994 AC_DIG1_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 return 0;
1996}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01001997EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998
Takashi Iwaicb53c622007-08-10 17:21:45 +02001999#ifdef SND_HDA_NEEDS_RESUME
Takashi Iwai82beb8f2007-08-10 17:09:26 +02002000/*
2001 * command cache
2002 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002004/* build a 32bit cache key with the widget id and the command parameter */
2005#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2006#define get_cmd_cache_nid(key) ((key) & 0xff)
2007#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2008
2009/**
2010 * snd_hda_codec_write_cache - send a single command with caching
2011 * @codec: the HDA codec
2012 * @nid: NID to send the command
2013 * @direct: direct flag
2014 * @verb: the verb to send
2015 * @parm: the parameter for the verb
2016 *
2017 * Send a single command without waiting for response.
2018 *
2019 * Returns 0 if successful, or a negative error code.
2020 */
2021int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2022 int direct, unsigned int verb, unsigned int parm)
2023{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002024 struct hda_bus *bus = codec->bus;
2025 unsigned int res;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002026 int err;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002027
2028 res = make_codec_cmd(codec, nid, direct, verb, parm);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002029 snd_hda_power_up(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002030 mutex_lock(&bus->cmd_mutex);
2031 err = bus->ops.command(bus, res);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002032 if (!err) {
2033 struct hda_cache_head *c;
2034 u32 key = build_cmd_cache_key(nid, verb);
2035 c = get_alloc_hash(&codec->cmd_cache, key);
2036 if (c)
2037 c->val = parm;
2038 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002039 mutex_unlock(&bus->cmd_mutex);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002040 snd_hda_power_down(codec);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002041 return err;
2042}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002043EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002044
2045/* resume the all commands from the cache */
2046void snd_hda_codec_resume_cache(struct hda_codec *codec)
2047{
Takashi Iwai603c4012008-07-30 15:01:44 +02002048 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002049 int i;
2050
Takashi Iwai603c4012008-07-30 15:01:44 +02002051 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002052 u32 key = buffer->key;
2053 if (!key)
2054 continue;
2055 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2056 get_cmd_cache_cmd(key), buffer->val);
2057 }
2058}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002059EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002060
2061/**
2062 * snd_hda_sequence_write_cache - sequence writes with caching
2063 * @codec: the HDA codec
2064 * @seq: VERB array to send
2065 *
2066 * Send the commands sequentially from the given array.
2067 * Thte commands are recorded on cache for power-save and resume.
2068 * The array must be terminated with NID=0.
2069 */
2070void snd_hda_sequence_write_cache(struct hda_codec *codec,
2071 const struct hda_verb *seq)
2072{
2073 for (; seq->nid; seq++)
2074 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2075 seq->param);
2076}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002077EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002078#endif /* SND_HDA_NEEDS_RESUME */
Takashi Iwaib3ac5632007-08-10 17:03:40 +02002079
Takashi Iwai54d17402005-11-21 16:33:22 +01002080/*
2081 * set power state of the codec
2082 */
2083static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2084 unsigned int power_state)
2085{
Takashi Iwaicb53c622007-08-10 17:21:45 +02002086 hda_nid_t nid;
2087 int i;
Takashi Iwai54d17402005-11-21 16:33:22 +01002088
2089 snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
2090 power_state);
Marc Boucherd2595d82008-01-22 15:23:30 +01002091 msleep(10); /* partial workaround for "azx_get_response timeout" */
Takashi Iwai54d17402005-11-21 16:33:22 +01002092
Takashi Iwaicb53c622007-08-10 17:21:45 +02002093 nid = codec->start_nid;
2094 for (i = 0; i < codec->num_nodes; i++, nid++) {
Takashi Iwai7eba5c92007-11-14 14:53:42 +01002095 unsigned int wcaps = get_wcaps(codec, nid);
2096 if (wcaps & AC_WCAP_POWER) {
2097 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2098 AC_WCAP_TYPE_SHIFT;
2099 if (wid_type == AC_WID_PIN) {
2100 unsigned int pincap;
2101 /*
2102 * don't power down the widget if it controls
2103 * eapd and EAPD_BTLENABLE is set.
2104 */
2105 pincap = snd_hda_param_read(codec, nid,
2106 AC_PAR_PIN_CAP);
2107 if (pincap & AC_PINCAP_EAPD) {
2108 int eapd = snd_hda_codec_read(codec,
2109 nid, 0,
2110 AC_VERB_GET_EAPD_BTLENABLE, 0);
2111 eapd &= 0x02;
2112 if (power_state == AC_PWRST_D3 && eapd)
2113 continue;
2114 }
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002115 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002116 snd_hda_codec_write(codec, nid, 0,
2117 AC_VERB_SET_POWER_STATE,
2118 power_state);
Takashi Iwai1194b5b2007-10-10 10:04:26 +02002119 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002120 }
2121
Takashi Iwaicb53c622007-08-10 17:21:45 +02002122 if (power_state == AC_PWRST_D0) {
2123 unsigned long end_time;
2124 int state;
Takashi Iwai54d17402005-11-21 16:33:22 +01002125 msleep(10);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002126 /* wait until the codec reachs to D0 */
2127 end_time = jiffies + msecs_to_jiffies(500);
2128 do {
2129 state = snd_hda_codec_read(codec, fg, 0,
2130 AC_VERB_GET_POWER_STATE, 0);
2131 if (state == power_state)
2132 break;
2133 msleep(1);
2134 } while (time_after_eq(end_time, jiffies));
2135 }
Takashi Iwai54d17402005-11-21 16:33:22 +01002136}
2137
Takashi Iwai11aeff02008-07-30 15:01:46 +02002138#ifdef CONFIG_SND_HDA_HWDEP
2139/* execute additional init verbs */
2140static void hda_exec_init_verbs(struct hda_codec *codec)
2141{
2142 if (codec->init_verbs.list)
2143 snd_hda_sequence_write(codec, codec->init_verbs.list);
2144}
2145#else
2146static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2147#endif
2148
Takashi Iwaicb53c622007-08-10 17:21:45 +02002149#ifdef SND_HDA_NEEDS_RESUME
2150/*
2151 * call suspend and power-down; used both from PM and power-save
2152 */
2153static void hda_call_codec_suspend(struct hda_codec *codec)
2154{
2155 if (codec->patch_ops.suspend)
2156 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2157 hda_set_power_state(codec,
2158 codec->afg ? codec->afg : codec->mfg,
2159 AC_PWRST_D3);
2160#ifdef CONFIG_SND_HDA_POWER_SAVE
2161 cancel_delayed_work(&codec->power_work);
Takashi Iwai95e99fd2007-08-13 15:29:04 +02002162 codec->power_on = 0;
Takashi Iwaia221e282007-08-16 16:35:33 +02002163 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002164#endif
2165}
2166
2167/*
2168 * kick up codec; used both from PM and power-save
2169 */
2170static void hda_call_codec_resume(struct hda_codec *codec)
2171{
2172 hda_set_power_state(codec,
2173 codec->afg ? codec->afg : codec->mfg,
2174 AC_PWRST_D0);
Takashi Iwai11aeff02008-07-30 15:01:46 +02002175 hda_exec_init_verbs(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002176 if (codec->patch_ops.resume)
2177 codec->patch_ops.resume(codec);
2178 else {
Takashi Iwai9d99f312007-08-14 15:15:52 +02002179 if (codec->patch_ops.init)
2180 codec->patch_ops.init(codec);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002181 snd_hda_codec_resume_amp(codec);
2182 snd_hda_codec_resume_cache(codec);
2183 }
2184}
2185#endif /* SND_HDA_NEEDS_RESUME */
2186
Takashi Iwai54d17402005-11-21 16:33:22 +01002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188/**
2189 * snd_hda_build_controls - build mixer controls
2190 * @bus: the BUS
2191 *
2192 * Creates mixer controls for each codec included in the bus.
2193 *
2194 * Returns 0 if successful, otherwise a negative error code.
2195 */
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002196int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002198 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
Takashi Iwai0ba21762007-04-16 11:29:14 +02002200 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002201 int err = snd_hda_codec_build_controls(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 if (err < 0)
2203 return err;
2204 }
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002205 return 0;
2206}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002207EXPORT_SYMBOL_HDA(snd_hda_build_controls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002209int snd_hda_codec_build_controls(struct hda_codec *codec)
2210{
2211 int err = 0;
2212 /* fake as if already powered-on */
2213 hda_keep_power_on(codec);
2214 /* then fire up */
2215 hda_set_power_state(codec,
2216 codec->afg ? codec->afg : codec->mfg,
2217 AC_PWRST_D0);
Takashi Iwai11aeff02008-07-30 15:01:46 +02002218 hda_exec_init_verbs(codec);
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002219 /* continue to initialize... */
2220 if (codec->patch_ops.init)
2221 err = codec->patch_ops.init(codec);
2222 if (!err && codec->patch_ops.build_controls)
2223 err = codec->patch_ops.build_controls(codec);
2224 snd_hda_power_down(codec);
2225 if (err < 0)
2226 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 return 0;
2228}
2229
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230/*
2231 * stream formats
2232 */
Takashi Iwaibefdf312005-08-22 13:57:55 +02002233struct hda_rate_tbl {
2234 unsigned int hz;
2235 unsigned int alsa_bits;
2236 unsigned int hda_fmt;
2237};
2238
2239static struct hda_rate_tbl rate_bits[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 /* rate in Hz, ALSA rate bitmask, HDA format value */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002241
2242 /* autodetected value used in snd_hda_query_supported_pcm */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2244 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2245 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2246 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2247 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2248 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2249 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2250 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2251 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2252 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2253 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002254#define AC_PAR_PCM_RATE_BITS 11
2255 /* up to bits 10, 384kHZ isn't supported properly */
2256
2257 /* not autodetected value */
2258 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
Nicolas Graziano9d8f53f2005-08-22 13:47:16 +02002259
Takashi Iwaibefdf312005-08-22 13:57:55 +02002260 { 0 } /* terminator */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261};
2262
2263/**
2264 * snd_hda_calc_stream_format - calculate format bitset
2265 * @rate: the sample rate
2266 * @channels: the number of channels
2267 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2268 * @maxbps: the max. bps
2269 *
2270 * Calculate the format bitset from the given rate, channels and th PCM format.
2271 *
2272 * Return zero if invalid.
2273 */
2274unsigned int snd_hda_calc_stream_format(unsigned int rate,
2275 unsigned int channels,
2276 unsigned int format,
2277 unsigned int maxbps)
2278{
2279 int i;
2280 unsigned int val = 0;
2281
Takashi Iwaibefdf312005-08-22 13:57:55 +02002282 for (i = 0; rate_bits[i].hz; i++)
2283 if (rate_bits[i].hz == rate) {
2284 val = rate_bits[i].hda_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 break;
2286 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002287 if (!rate_bits[i].hz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 snd_printdd("invalid rate %d\n", rate);
2289 return 0;
2290 }
2291
2292 if (channels == 0 || channels > 8) {
2293 snd_printdd("invalid channels %d\n", channels);
2294 return 0;
2295 }
2296 val |= channels - 1;
2297
2298 switch (snd_pcm_format_width(format)) {
2299 case 8: val |= 0x00; break;
2300 case 16: val |= 0x10; break;
2301 case 20:
2302 case 24:
2303 case 32:
2304 if (maxbps >= 32)
2305 val |= 0x40;
2306 else if (maxbps >= 24)
2307 val |= 0x30;
2308 else
2309 val |= 0x20;
2310 break;
2311 default:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002312 snd_printdd("invalid format width %d\n",
2313 snd_pcm_format_width(format));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 return 0;
2315 }
2316
2317 return val;
2318}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002319EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
2321/**
2322 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2323 * @codec: the HDA codec
2324 * @nid: NID to query
2325 * @ratesp: the pointer to store the detected rate bitflags
2326 * @formatsp: the pointer to store the detected formats
2327 * @bpsp: the pointer to store the detected format widths
2328 *
2329 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2330 * or @bsps argument is ignored.
2331 *
2332 * Returns 0 if successful, otherwise a negative error code.
2333 */
Takashi Iwai986862bd2008-11-27 12:40:13 +01002334static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2336{
2337 int i;
2338 unsigned int val, streams;
2339
2340 val = 0;
2341 if (nid != codec->afg &&
Takashi Iwai54d17402005-11-21 16:33:22 +01002342 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2344 if (val == -1)
2345 return -EIO;
2346 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002347 if (!val)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2349
2350 if (ratesp) {
2351 u32 rates = 0;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002352 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 if (val & (1 << i))
Takashi Iwaibefdf312005-08-22 13:57:55 +02002354 rates |= rate_bits[i].alsa_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 }
2356 *ratesp = rates;
2357 }
2358
2359 if (formatsp || bpsp) {
2360 u64 formats = 0;
2361 unsigned int bps;
2362 unsigned int wcaps;
2363
Takashi Iwai54d17402005-11-21 16:33:22 +01002364 wcaps = get_wcaps(codec, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2366 if (streams == -1)
2367 return -EIO;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002368 if (!streams) {
2369 streams = snd_hda_param_read(codec, codec->afg,
2370 AC_PAR_STREAM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 if (streams == -1)
2372 return -EIO;
2373 }
2374
2375 bps = 0;
2376 if (streams & AC_SUPFMT_PCM) {
2377 if (val & AC_SUPPCM_BITS_8) {
2378 formats |= SNDRV_PCM_FMTBIT_U8;
2379 bps = 8;
2380 }
2381 if (val & AC_SUPPCM_BITS_16) {
2382 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2383 bps = 16;
2384 }
2385 if (wcaps & AC_WCAP_DIGITAL) {
2386 if (val & AC_SUPPCM_BITS_32)
2387 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2388 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2389 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2390 if (val & AC_SUPPCM_BITS_24)
2391 bps = 24;
2392 else if (val & AC_SUPPCM_BITS_20)
2393 bps = 20;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002394 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2395 AC_SUPPCM_BITS_32)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2397 if (val & AC_SUPPCM_BITS_32)
2398 bps = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 else if (val & AC_SUPPCM_BITS_24)
2400 bps = 24;
Nicolas Graziano33ef76512006-09-19 14:23:14 +02002401 else if (val & AC_SUPPCM_BITS_20)
2402 bps = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 }
2404 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002405 else if (streams == AC_SUPFMT_FLOAT32) {
2406 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
2408 bps = 32;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002409 } else if (streams == AC_SUPFMT_AC3) {
2410 /* should be exclusive */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 /* temporary hack: we have still no proper support
2412 * for the direct AC3 stream...
2413 */
2414 formats |= SNDRV_PCM_FMTBIT_U8;
2415 bps = 8;
2416 }
2417 if (formatsp)
2418 *formatsp = formats;
2419 if (bpsp)
2420 *bpsp = bps;
2421 }
2422
2423 return 0;
2424}
2425
2426/**
Takashi Iwai0ba21762007-04-16 11:29:14 +02002427 * snd_hda_is_supported_format - check whether the given node supports
2428 * the format val
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 *
2430 * Returns 1 if supported, 0 if not.
2431 */
2432int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2433 unsigned int format)
2434{
2435 int i;
2436 unsigned int val = 0, rate, stream;
2437
2438 if (nid != codec->afg &&
Takashi Iwai54d17402005-11-21 16:33:22 +01002439 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2441 if (val == -1)
2442 return 0;
2443 }
Takashi Iwai0ba21762007-04-16 11:29:14 +02002444 if (!val) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2446 if (val == -1)
2447 return 0;
2448 }
2449
2450 rate = format & 0xff00;
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002451 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
Takashi Iwaibefdf312005-08-22 13:57:55 +02002452 if (rate_bits[i].hda_fmt == rate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 if (val & (1 << i))
2454 break;
2455 return 0;
2456 }
Takashi Iwaia961f9f2007-04-12 13:08:09 +02002457 if (i >= AC_PAR_PCM_RATE_BITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 return 0;
2459
2460 stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2461 if (stream == -1)
2462 return 0;
Takashi Iwai0ba21762007-04-16 11:29:14 +02002463 if (!stream && nid != codec->afg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002465 if (!stream || stream == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 return 0;
2467
2468 if (stream & AC_SUPFMT_PCM) {
2469 switch (format & 0xf0) {
2470 case 0x00:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002471 if (!(val & AC_SUPPCM_BITS_8))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 return 0;
2473 break;
2474 case 0x10:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002475 if (!(val & AC_SUPPCM_BITS_16))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 return 0;
2477 break;
2478 case 0x20:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002479 if (!(val & AC_SUPPCM_BITS_20))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 return 0;
2481 break;
2482 case 0x30:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002483 if (!(val & AC_SUPPCM_BITS_24))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 return 0;
2485 break;
2486 case 0x40:
Takashi Iwai0ba21762007-04-16 11:29:14 +02002487 if (!(val & AC_SUPPCM_BITS_32))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 return 0;
2489 break;
2490 default:
2491 return 0;
2492 }
2493 } else {
2494 /* FIXME: check for float32 and AC3? */
2495 }
2496
2497 return 1;
2498}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002499EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
2501/*
2502 * PCM stuff
2503 */
2504static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2505 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002506 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507{
2508 return 0;
2509}
2510
2511static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2512 struct hda_codec *codec,
2513 unsigned int stream_tag,
2514 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002515 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516{
2517 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2518 return 0;
2519}
2520
2521static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2522 struct hda_codec *codec,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002523 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524{
Takashi Iwai888afa12008-03-18 09:57:50 +01002525 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 return 0;
2527}
2528
Takashi Iwai6c1f45e2008-07-30 15:01:45 +02002529static int set_pcm_default_values(struct hda_codec *codec,
2530 struct hda_pcm_stream *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002532 /* query support PCM information from the given NID */
2533 if (info->nid && (!info->rates || !info->formats)) {
2534 snd_hda_query_supported_pcm(codec, info->nid,
2535 info->rates ? NULL : &info->rates,
2536 info->formats ? NULL : &info->formats,
2537 info->maxbps ? NULL : &info->maxbps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538 }
2539 if (info->ops.open == NULL)
2540 info->ops.open = hda_pcm_default_open_close;
2541 if (info->ops.close == NULL)
2542 info->ops.close = hda_pcm_default_open_close;
2543 if (info->ops.prepare == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02002544 if (snd_BUG_ON(!info->nid))
2545 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 info->ops.prepare = hda_pcm_default_prepare;
2547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 if (info->ops.cleanup == NULL) {
Takashi Iwaida3cec32008-08-08 17:12:14 +02002549 if (snd_BUG_ON(!info->nid))
2550 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 info->ops.cleanup = hda_pcm_default_cleanup;
2552 }
2553 return 0;
2554}
2555
Takashi Iwai176d5332008-07-30 15:01:44 +02002556/*
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002557 * get the empty PCM device number to assign
2558 */
2559static int get_empty_pcm_device(struct hda_bus *bus, int type)
2560{
2561 static const char *dev_name[HDA_PCM_NTYPES] = {
2562 "Audio", "SPDIF", "HDMI", "Modem"
2563 };
2564 /* starting device index for each PCM type */
2565 static int dev_idx[HDA_PCM_NTYPES] = {
2566 [HDA_PCM_TYPE_AUDIO] = 0,
2567 [HDA_PCM_TYPE_SPDIF] = 1,
2568 [HDA_PCM_TYPE_HDMI] = 3,
2569 [HDA_PCM_TYPE_MODEM] = 6
2570 };
2571 /* normal audio device indices; not linear to keep compatibility */
2572 static int audio_idx[4] = { 0, 2, 4, 5 };
2573 int i, dev;
2574
2575 switch (type) {
2576 case HDA_PCM_TYPE_AUDIO:
2577 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2578 dev = audio_idx[i];
2579 if (!test_bit(dev, bus->pcm_dev_bits))
2580 break;
2581 }
2582 if (i >= ARRAY_SIZE(audio_idx)) {
2583 snd_printk(KERN_WARNING "Too many audio devices\n");
2584 return -EAGAIN;
2585 }
2586 break;
2587 case HDA_PCM_TYPE_SPDIF:
2588 case HDA_PCM_TYPE_HDMI:
2589 case HDA_PCM_TYPE_MODEM:
2590 dev = dev_idx[type];
2591 if (test_bit(dev, bus->pcm_dev_bits)) {
2592 snd_printk(KERN_WARNING "%s already defined\n",
2593 dev_name[type]);
2594 return -EAGAIN;
2595 }
2596 break;
2597 default:
2598 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2599 return -EINVAL;
2600 }
2601 set_bit(dev, bus->pcm_dev_bits);
2602 return dev;
2603}
2604
2605/*
Takashi Iwai176d5332008-07-30 15:01:44 +02002606 * attach a new PCM stream
2607 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002608static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
Takashi Iwai176d5332008-07-30 15:01:44 +02002609{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002610 struct hda_bus *bus = codec->bus;
Takashi Iwai176d5332008-07-30 15:01:44 +02002611 struct hda_pcm_stream *info;
2612 int stream, err;
2613
Takashi Iwaib91f0802008-11-04 08:43:08 +01002614 if (snd_BUG_ON(!pcm->name))
Takashi Iwai176d5332008-07-30 15:01:44 +02002615 return -EINVAL;
2616 for (stream = 0; stream < 2; stream++) {
2617 info = &pcm->stream[stream];
2618 if (info->substreams) {
2619 err = set_pcm_default_values(codec, info);
2620 if (err < 0)
2621 return err;
2622 }
2623 }
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002624 return bus->ops.attach_pcm(bus, codec, pcm);
Takashi Iwai176d5332008-07-30 15:01:44 +02002625}
2626
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002627/* assign all PCMs of the given codec */
2628int snd_hda_codec_build_pcms(struct hda_codec *codec)
2629{
2630 unsigned int pcm;
2631 int err;
2632
2633 if (!codec->num_pcms) {
2634 if (!codec->patch_ops.build_pcms)
2635 return 0;
2636 err = codec->patch_ops.build_pcms(codec);
2637 if (err < 0)
2638 return err;
2639 }
2640 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2641 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2642 int dev;
2643
2644 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
2645 return 0; /* no substreams assigned */
2646
2647 if (!cpcm->pcm) {
2648 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2649 if (dev < 0)
2650 return 0;
2651 cpcm->device = dev;
2652 err = snd_hda_attach_pcm(codec, cpcm);
2653 if (err < 0)
2654 return err;
2655 }
2656 }
2657 return 0;
2658}
2659
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660/**
2661 * snd_hda_build_pcms - build PCM information
2662 * @bus: the BUS
2663 *
2664 * Create PCM information for each codec included in the bus.
2665 *
2666 * The build_pcms codec patch is requested to set up codec->num_pcms and
2667 * codec->pcm_info properly. The array is referred by the top-level driver
2668 * to create its PCM instances.
2669 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2670 * callback.
2671 *
2672 * At least, substreams, channels_min and channels_max must be filled for
2673 * each stream. substreams = 0 indicates that the stream doesn't exist.
2674 * When rates and/or formats are zero, the supported values are queried
2675 * from the given nid. The nid is used also by the default ops.prepare
2676 * and ops.cleanup callbacks.
2677 *
2678 * The driver needs to call ops.open in its open callback. Similarly,
2679 * ops.close is supposed to be called in the close callback.
2680 * ops.prepare should be called in the prepare or hw_params callback
2681 * with the proper parameters for set up.
2682 * ops.cleanup should be called in hw_free for clean up of streams.
2683 *
2684 * This function returns 0 if successfull, or a negative error code.
2685 */
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002686int __devinit snd_hda_build_pcms(struct hda_bus *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687{
Takashi Iwai0ba21762007-04-16 11:29:14 +02002688 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689
Takashi Iwai0ba21762007-04-16 11:29:14 +02002690 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai529bd6c2008-11-27 14:17:01 +01002691 int err = snd_hda_codec_build_pcms(codec);
2692 if (err < 0)
2693 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 }
2695 return 0;
2696}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002697EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699/**
2700 * snd_hda_check_board_config - compare the current codec with the config table
2701 * @codec: the HDA codec
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002702 * @num_configs: number of config enums
2703 * @models: array of model name strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704 * @tbl: configuration table, terminated by null entries
2705 *
2706 * Compares the modelname or PCI subsystem id of the current codec with the
2707 * given configuration table. If a matching entry is found, returns its
2708 * config value (supposed to be 0 or positive).
2709 *
2710 * If no entries are matching, the function returns a negative value.
2711 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002712int snd_hda_check_board_config(struct hda_codec *codec,
2713 int num_configs, const char **models,
2714 const struct snd_pci_quirk *tbl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715{
Takashi Iwaif44ac832008-07-30 15:01:45 +02002716 if (codec->modelname && models) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002717 int i;
2718 for (i = 0; i < num_configs; i++) {
2719 if (models[i] &&
Takashi Iwaif44ac832008-07-30 15:01:45 +02002720 !strcmp(codec->modelname, models[i])) {
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002721 snd_printd(KERN_INFO "hda_codec: model '%s' is "
2722 "selected\n", models[i]);
2723 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724 }
2725 }
2726 }
2727
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002728 if (!codec->bus->pci || !tbl)
2729 return -1;
2730
2731 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
2732 if (!tbl)
2733 return -1;
2734 if (tbl->value >= 0 && tbl->value < num_configs) {
Takashi Iwai62cf8722008-05-20 12:15:15 +02002735#ifdef CONFIG_SND_DEBUG_VERBOSE
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002736 char tmp[10];
2737 const char *model = NULL;
2738 if (models)
2739 model = models[tbl->value];
2740 if (!model) {
2741 sprintf(tmp, "#%d", tbl->value);
2742 model = tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 }
Takashi Iwaif5fcc132006-11-24 17:07:44 +01002744 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2745 "for config %x:%x (%s)\n",
2746 model, tbl->subvendor, tbl->subdevice,
2747 (tbl->name ? tbl->name : "Unknown device"));
2748#endif
2749 return tbl->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750 }
2751 return -1;
2752}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002753EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754
2755/**
Mauro Carvalho Chehab2eda3442008-08-11 10:18:39 +02002756 * snd_hda_check_board_codec_sid_config - compare the current codec
2757 subsystem ID with the
2758 config table
2759
2760 This is important for Gateway notebooks with SB450 HDA Audio
2761 where the vendor ID of the PCI device is:
2762 ATI Technologies Inc SB450 HDA Audio [1002:437b]
2763 and the vendor/subvendor are found only at the codec.
2764
2765 * @codec: the HDA codec
2766 * @num_configs: number of config enums
2767 * @models: array of model name strings
2768 * @tbl: configuration table, terminated by null entries
2769 *
2770 * Compares the modelname or PCI subsystem id of the current codec with the
2771 * given configuration table. If a matching entry is found, returns its
2772 * config value (supposed to be 0 or positive).
2773 *
2774 * If no entries are matching, the function returns a negative value.
2775 */
2776int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
2777 int num_configs, const char **models,
2778 const struct snd_pci_quirk *tbl)
2779{
2780 const struct snd_pci_quirk *q;
2781
2782 /* Search for codec ID */
2783 for (q = tbl; q->subvendor; q++) {
2784 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
2785
2786 if (vendorid == codec->subsystem_id)
2787 break;
2788 }
2789
2790 if (!q->subvendor)
2791 return -1;
2792
2793 tbl = q;
2794
2795 if (tbl->value >= 0 && tbl->value < num_configs) {
2796#ifdef CONFIG_SND_DEBUG_DETECT
2797 char tmp[10];
2798 const char *model = NULL;
2799 if (models)
2800 model = models[tbl->value];
2801 if (!model) {
2802 sprintf(tmp, "#%d", tbl->value);
2803 model = tmp;
2804 }
2805 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
2806 "for config %x:%x (%s)\n",
2807 model, tbl->subvendor, tbl->subdevice,
2808 (tbl->name ? tbl->name : "Unknown device"));
2809#endif
2810 return tbl->value;
2811 }
2812 return -1;
2813}
2814EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
2815
2816/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002817 * snd_hda_add_new_ctls - create controls from the array
2818 * @codec: the HDA codec
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002819 * @knew: the array of struct snd_kcontrol_new
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 *
2821 * This helper function creates and add new controls in the given array.
2822 * The array must be terminated with an empty entry as terminator.
2823 *
2824 * Returns 0 if successful, or a negative error code.
2825 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02002826int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827{
Takashi Iwaicb53c622007-08-10 17:21:45 +02002828 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829
2830 for (; knew->name; knew++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01002831 struct snd_kcontrol *kctl;
2832 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002833 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01002834 return -ENOMEM;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002835 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai54d17402005-11-21 16:33:22 +01002836 if (err < 0) {
Takashi Iwai0ba21762007-04-16 11:29:14 +02002837 if (!codec->addr)
Takashi Iwai54d17402005-11-21 16:33:22 +01002838 return err;
2839 kctl = snd_ctl_new1(knew, codec);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002840 if (!kctl)
Takashi Iwai54d17402005-11-21 16:33:22 +01002841 return -ENOMEM;
2842 kctl->id.device = codec->addr;
Takashi Iwaid13bd412008-07-30 15:01:45 +02002843 err = snd_hda_ctl_add(codec, kctl);
Takashi Iwai0ba21762007-04-16 11:29:14 +02002844 if (err < 0)
Takashi Iwai54d17402005-11-21 16:33:22 +01002845 return err;
2846 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 }
2848 return 0;
2849}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002850EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851
Takashi Iwaicb53c622007-08-10 17:21:45 +02002852#ifdef CONFIG_SND_HDA_POWER_SAVE
2853static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2854 unsigned int power_state);
2855
2856static void hda_power_work(struct work_struct *work)
2857{
2858 struct hda_codec *codec =
2859 container_of(work, struct hda_codec, power_work.work);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002860 struct hda_bus *bus = codec->bus;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002861
Maxim Levitsky2e492462007-09-03 15:26:57 +02002862 if (!codec->power_on || codec->power_count) {
2863 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002864 return;
Maxim Levitsky2e492462007-09-03 15:26:57 +02002865 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02002866
2867 hda_call_codec_suspend(codec);
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002868 if (bus->ops.pm_notify)
2869 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002870}
2871
2872static void hda_keep_power_on(struct hda_codec *codec)
2873{
2874 codec->power_count++;
2875 codec->power_on = 1;
2876}
2877
2878void snd_hda_power_up(struct hda_codec *codec)
2879{
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002880 struct hda_bus *bus = codec->bus;
2881
Takashi Iwaicb53c622007-08-10 17:21:45 +02002882 codec->power_count++;
Takashi Iwaia221e282007-08-16 16:35:33 +02002883 if (codec->power_on || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02002884 return;
2885
2886 codec->power_on = 1;
Takashi Iwai33fa35e2008-11-06 16:50:40 +01002887 if (bus->ops.pm_notify)
2888 bus->ops.pm_notify(bus);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002889 hda_call_codec_resume(codec);
2890 cancel_delayed_work(&codec->power_work);
Takashi Iwaia221e282007-08-16 16:35:33 +02002891 codec->power_transition = 0;
Takashi Iwaicb53c622007-08-10 17:21:45 +02002892}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002893EXPORT_SYMBOL_HDA(snd_hda_power_up);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01002894
2895#define power_save(codec) \
2896 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
Takashi Iwaicb53c622007-08-10 17:21:45 +02002897
Takashi Iwaifee2fba2008-11-27 12:43:28 +01002898#define power_save(codec) \
2899 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
2900
Takashi Iwaicb53c622007-08-10 17:21:45 +02002901void snd_hda_power_down(struct hda_codec *codec)
2902{
2903 --codec->power_count;
Takashi Iwaia221e282007-08-16 16:35:33 +02002904 if (!codec->power_on || codec->power_count || codec->power_transition)
Takashi Iwaicb53c622007-08-10 17:21:45 +02002905 return;
Takashi Iwaifee2fba2008-11-27 12:43:28 +01002906 if (power_save(codec)) {
Takashi Iwaia221e282007-08-16 16:35:33 +02002907 codec->power_transition = 1; /* avoid reentrance */
Takashi Iwaic107b412009-01-13 17:46:37 +01002908 queue_delayed_work(codec->bus->workq, &codec->power_work,
Takashi Iwaifee2fba2008-11-27 12:43:28 +01002909 msecs_to_jiffies(power_save(codec) * 1000));
Takashi Iwaia221e282007-08-16 16:35:33 +02002910 }
Takashi Iwaicb53c622007-08-10 17:21:45 +02002911}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002912EXPORT_SYMBOL_HDA(snd_hda_power_down);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002913
2914int snd_hda_check_amp_list_power(struct hda_codec *codec,
2915 struct hda_loopback_check *check,
2916 hda_nid_t nid)
2917{
2918 struct hda_amp_list *p;
2919 int ch, v;
2920
2921 if (!check->amplist)
2922 return 0;
2923 for (p = check->amplist; p->nid; p++) {
2924 if (p->nid == nid)
2925 break;
2926 }
2927 if (!p->nid)
2928 return 0; /* nothing changed */
2929
2930 for (p = check->amplist; p->nid; p++) {
2931 for (ch = 0; ch < 2; ch++) {
2932 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
2933 p->idx);
2934 if (!(v & HDA_AMP_MUTE) && v > 0) {
2935 if (!check->power_on) {
2936 check->power_on = 1;
2937 snd_hda_power_up(codec);
2938 }
2939 return 1;
2940 }
2941 }
2942 }
2943 if (check->power_on) {
2944 check->power_on = 0;
2945 snd_hda_power_down(codec);
2946 }
2947 return 0;
2948}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002949EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
Takashi Iwaicb53c622007-08-10 17:21:45 +02002950#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01002952/*
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002953 * Channel mode helper
2954 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02002955int snd_hda_ch_mode_info(struct hda_codec *codec,
2956 struct snd_ctl_elem_info *uinfo,
2957 const struct hda_channel_mode *chmode,
2958 int num_chmodes)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002959{
2960 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2961 uinfo->count = 1;
2962 uinfo->value.enumerated.items = num_chmodes;
2963 if (uinfo->value.enumerated.item >= num_chmodes)
2964 uinfo->value.enumerated.item = num_chmodes - 1;
2965 sprintf(uinfo->value.enumerated.name, "%dch",
2966 chmode[uinfo->value.enumerated.item].channels);
2967 return 0;
2968}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002969EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002970
Takashi Iwai0ba21762007-04-16 11:29:14 +02002971int snd_hda_ch_mode_get(struct hda_codec *codec,
2972 struct snd_ctl_elem_value *ucontrol,
2973 const struct hda_channel_mode *chmode,
2974 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002975 int max_channels)
2976{
2977 int i;
2978
2979 for (i = 0; i < num_chmodes; i++) {
2980 if (max_channels == chmode[i].channels) {
2981 ucontrol->value.enumerated.item[0] = i;
2982 break;
2983 }
2984 }
2985 return 0;
2986}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01002987EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002988
Takashi Iwai0ba21762007-04-16 11:29:14 +02002989int snd_hda_ch_mode_put(struct hda_codec *codec,
2990 struct snd_ctl_elem_value *ucontrol,
2991 const struct hda_channel_mode *chmode,
2992 int num_chmodes,
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01002993 int *max_channelsp)
2994{
2995 unsigned int mode;
2996
2997 mode = ucontrol->value.enumerated.item[0];
Takashi Iwai68ea7b22007-11-15 15:54:38 +01002998 if (mode >= num_chmodes)
2999 return -EINVAL;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003000 if (*max_channelsp == chmode[mode].channels)
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003001 return 0;
3002 /* change the current channel setting */
3003 *max_channelsp = chmode[mode].channels;
3004 if (chmode[mode].sequence)
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003005 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003006 return 1;
3007}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003008EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
Takashi Iwaid2a6d7d2005-11-17 11:06:29 +01003009
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010/*
3011 * input MUX helper
3012 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003013int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3014 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015{
3016 unsigned int index;
3017
3018 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3019 uinfo->count = 1;
3020 uinfo->value.enumerated.items = imux->num_items;
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003021 if (!imux->num_items)
3022 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 index = uinfo->value.enumerated.item;
3024 if (index >= imux->num_items)
3025 index = imux->num_items - 1;
3026 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3027 return 0;
3028}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003029EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030
Takashi Iwai0ba21762007-04-16 11:29:14 +02003031int snd_hda_input_mux_put(struct hda_codec *codec,
3032 const struct hda_input_mux *imux,
3033 struct snd_ctl_elem_value *ucontrol,
3034 hda_nid_t nid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 unsigned int *cur_val)
3036{
3037 unsigned int idx;
3038
Takashi Iwai5513b0c2007-10-09 11:58:41 +02003039 if (!imux->num_items)
3040 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041 idx = ucontrol->value.enumerated.item[0];
3042 if (idx >= imux->num_items)
3043 idx = imux->num_items - 1;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003044 if (*cur_val == idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 return 0;
Takashi Iwai82beb8f2007-08-10 17:09:26 +02003046 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3047 imux->items[idx].index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 *cur_val = idx;
3049 return 1;
3050}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003051EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052
3053
3054/*
3055 * Multi-channel / digital-out PCM helper functions
3056 */
3057
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003058/* setup SPDIF output stream */
3059static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3060 unsigned int stream_tag, unsigned int format)
3061{
3062 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
Takashi Iwai2f728532008-09-25 16:32:41 +02003063 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3064 set_dig_out_convert(codec, nid,
3065 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3066 -1);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003067 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
Takashi Iwai2f728532008-09-25 16:32:41 +02003068 if (codec->slave_dig_outs) {
3069 hda_nid_t *d;
3070 for (d = codec->slave_dig_outs; *d; d++)
3071 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3072 format);
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003073 }
Takashi Iwai2f728532008-09-25 16:32:41 +02003074 /* turn on again (if needed) */
3075 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3076 set_dig_out_convert(codec, nid,
3077 codec->spdif_ctls & 0xff, -1);
3078}
Matthew Ranostayde51ca12008-09-07 14:31:40 -04003079
Takashi Iwai2f728532008-09-25 16:32:41 +02003080static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3081{
3082 snd_hda_codec_cleanup_stream(codec, nid);
3083 if (codec->slave_dig_outs) {
3084 hda_nid_t *d;
3085 for (d = codec->slave_dig_outs; *d; d++)
3086 snd_hda_codec_cleanup_stream(codec, *d);
3087 }
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003088}
3089
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090/*
3091 * open the digital out in the exclusive mode
3092 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003093int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3094 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095{
Ingo Molnar62932df2006-01-16 16:34:20 +01003096 mutex_lock(&codec->spdif_mutex);
Takashi Iwai5930ca42007-04-16 11:23:56 +02003097 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3098 /* already opened as analog dup; reset it once */
Takashi Iwai2f728532008-09-25 16:32:41 +02003099 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
Ingo Molnar62932df2006-01-16 16:34:20 +01003101 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 return 0;
3103}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003104EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003106int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3107 struct hda_multi_out *mout,
3108 unsigned int stream_tag,
3109 unsigned int format,
3110 struct snd_pcm_substream *substream)
3111{
3112 mutex_lock(&codec->spdif_mutex);
3113 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3114 mutex_unlock(&codec->spdif_mutex);
3115 return 0;
3116}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003117EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003118
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119/*
3120 * release the digital out
3121 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003122int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3123 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124{
Ingo Molnar62932df2006-01-16 16:34:20 +01003125 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003126 mout->dig_out_used = 0;
Ingo Molnar62932df2006-01-16 16:34:20 +01003127 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 return 0;
3129}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003130EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003131
3132/*
3133 * set up more restrictions for analog out
3134 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003135int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3136 struct hda_multi_out *mout,
Takashi Iwai9a081602008-02-12 18:37:26 +01003137 struct snd_pcm_substream *substream,
3138 struct hda_pcm_stream *hinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139{
Takashi Iwai9a081602008-02-12 18:37:26 +01003140 struct snd_pcm_runtime *runtime = substream->runtime;
3141 runtime->hw.channels_max = mout->max_channels;
3142 if (mout->dig_out_nid) {
3143 if (!mout->analog_rates) {
3144 mout->analog_rates = hinfo->rates;
3145 mout->analog_formats = hinfo->formats;
3146 mout->analog_maxbps = hinfo->maxbps;
3147 } else {
3148 runtime->hw.rates = mout->analog_rates;
3149 runtime->hw.formats = mout->analog_formats;
3150 hinfo->maxbps = mout->analog_maxbps;
3151 }
3152 if (!mout->spdif_rates) {
3153 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3154 &mout->spdif_rates,
3155 &mout->spdif_formats,
3156 &mout->spdif_maxbps);
3157 }
3158 mutex_lock(&codec->spdif_mutex);
3159 if (mout->share_spdif) {
3160 runtime->hw.rates &= mout->spdif_rates;
3161 runtime->hw.formats &= mout->spdif_formats;
3162 if (mout->spdif_maxbps < hinfo->maxbps)
3163 hinfo->maxbps = mout->spdif_maxbps;
3164 }
Frederik Deweerdteaa99852008-04-14 13:11:44 +02003165 mutex_unlock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003166 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3168 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3169}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003170EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171
3172/*
3173 * set up the i/o for analog out
3174 * when the digital out is available, copy the front out to digital out, too.
3175 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003176int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3177 struct hda_multi_out *mout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 unsigned int stream_tag,
3179 unsigned int format,
Takashi Iwaic8b6bf92005-11-17 14:57:47 +01003180 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181{
3182 hda_nid_t *nids = mout->dac_nids;
3183 int chs = substream->runtime->channels;
3184 int i;
3185
Ingo Molnar62932df2006-01-16 16:34:20 +01003186 mutex_lock(&codec->spdif_mutex);
Takashi Iwai9a081602008-02-12 18:37:26 +01003187 if (mout->dig_out_nid && mout->share_spdif &&
3188 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 if (chs == 2 &&
Takashi Iwai0ba21762007-04-16 11:29:14 +02003190 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3191 format) &&
3192 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
Takashi Iwai6b97eb42007-04-05 14:51:48 +02003194 setup_dig_out_stream(codec, mout->dig_out_nid,
3195 stream_tag, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196 } else {
3197 mout->dig_out_used = 0;
Takashi Iwai2f728532008-09-25 16:32:41 +02003198 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 }
3200 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003201 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003202
3203 /* front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003204 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3205 0, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003206 if (!mout->no_share_stream &&
3207 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 /* headphone out will just decode front left/right (stereo) */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003209 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3210 0, format);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003211 /* extra outputs copied from front */
3212 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
Takashi Iwaid29240c2007-10-26 12:35:56 +02003213 if (!mout->no_share_stream && mout->extra_out_nid[i])
Takashi Iwai82bc9552006-03-21 11:24:42 +01003214 snd_hda_codec_setup_stream(codec,
3215 mout->extra_out_nid[i],
3216 stream_tag, 0, format);
3217
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 /* surrounds */
3219 for (i = 1; i < mout->num_dacs; i++) {
Takashi Iwai4b3acaf2005-06-10 19:48:10 +02003220 if (chs >= (i + 1) * 2) /* independent out */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003221 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3222 i * 2, format);
Takashi Iwaid29240c2007-10-26 12:35:56 +02003223 else if (!mout->no_share_stream) /* copy front */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003224 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3225 0, format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 }
3227 return 0;
3228}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003229EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003230
3231/*
3232 * clean up the setting for analog out
3233 */
Takashi Iwai0ba21762007-04-16 11:29:14 +02003234int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3235 struct hda_multi_out *mout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236{
3237 hda_nid_t *nids = mout->dac_nids;
3238 int i;
3239
3240 for (i = 0; i < mout->num_dacs; i++)
Takashi Iwai888afa12008-03-18 09:57:50 +01003241 snd_hda_codec_cleanup_stream(codec, nids[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 if (mout->hp_nid)
Takashi Iwai888afa12008-03-18 09:57:50 +01003243 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003244 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3245 if (mout->extra_out_nid[i])
Takashi Iwai888afa12008-03-18 09:57:50 +01003246 snd_hda_codec_cleanup_stream(codec,
3247 mout->extra_out_nid[i]);
Ingo Molnar62932df2006-01-16 16:34:20 +01003248 mutex_lock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
Takashi Iwai2f728532008-09-25 16:32:41 +02003250 cleanup_dig_out_stream(codec, mout->dig_out_nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 mout->dig_out_used = 0;
3252 }
Ingo Molnar62932df2006-01-16 16:34:20 +01003253 mutex_unlock(&codec->spdif_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 return 0;
3255}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003256EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003258/*
Wu Fengguang6b345002008-10-07 14:21:41 +08003259 * Helper for automatic pin configuration
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003260 */
Kailang Yangdf694da2005-12-05 19:42:22 +01003261
Takashi Iwai12f288b2007-08-02 15:51:59 +02003262static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
Kailang Yangdf694da2005-12-05 19:42:22 +01003263{
3264 for (; *list; list++)
3265 if (*list == nid)
3266 return 1;
3267 return 0;
3268}
3269
Steve Longerbeam81937d32007-05-08 15:33:03 +02003270
3271/*
3272 * Sort an associated group of pins according to their sequence numbers.
3273 */
3274static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3275 int num_pins)
3276{
3277 int i, j;
3278 short seq;
3279 hda_nid_t nid;
3280
3281 for (i = 0; i < num_pins; i++) {
3282 for (j = i + 1; j < num_pins; j++) {
3283 if (sequences[i] > sequences[j]) {
3284 seq = sequences[i];
3285 sequences[i] = sequences[j];
3286 sequences[j] = seq;
3287 nid = pins[i];
3288 pins[i] = pins[j];
3289 pins[j] = nid;
3290 }
3291 }
3292 }
3293}
3294
3295
Takashi Iwai82bc9552006-03-21 11:24:42 +01003296/*
3297 * Parse all pin widgets and store the useful pin nids to cfg
3298 *
3299 * The number of line-outs or any primary output is stored in line_outs,
3300 * and the corresponding output pins are assigned to line_out_pins[],
3301 * in the order of front, rear, CLFE, side, ...
3302 *
3303 * If more extra outputs (speaker and headphone) are found, the pins are
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003304 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
Takashi Iwai82bc9552006-03-21 11:24:42 +01003305 * is detected, one of speaker of HP pins is assigned as the primary
3306 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3307 * if any analog output exists.
3308 *
3309 * The analog input pins are assigned to input_pins array.
3310 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3311 * respectively.
3312 */
Takashi Iwai12f288b2007-08-02 15:51:59 +02003313int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3314 struct auto_pin_cfg *cfg,
3315 hda_nid_t *ignore_nids)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003316{
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01003317 hda_nid_t nid, end_nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003318 short seq, assoc_line_out, assoc_speaker;
3319 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3320 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
Takashi Iwaif889fa92007-10-31 15:49:32 +01003321 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003322
3323 memset(cfg, 0, sizeof(*cfg));
3324
Steve Longerbeam81937d32007-05-08 15:33:03 +02003325 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3326 memset(sequences_speaker, 0, sizeof(sequences_speaker));
Takashi Iwaif889fa92007-10-31 15:49:32 +01003327 memset(sequences_hp, 0, sizeof(sequences_hp));
Steve Longerbeam81937d32007-05-08 15:33:03 +02003328 assoc_line_out = assoc_speaker = 0;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003329
Takashi Iwai0ef6ce72008-01-22 15:35:37 +01003330 end_nid = codec->start_nid + codec->num_nodes;
3331 for (nid = codec->start_nid; nid < end_nid; nid++) {
Takashi Iwai54d17402005-11-21 16:33:22 +01003332 unsigned int wid_caps = get_wcaps(codec, nid);
Takashi Iwai0ba21762007-04-16 11:29:14 +02003333 unsigned int wid_type =
3334 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003335 unsigned int def_conf;
3336 short assoc, loc;
3337
3338 /* read all default configuration for pin complex */
3339 if (wid_type != AC_WID_PIN)
3340 continue;
Kailang Yangdf694da2005-12-05 19:42:22 +01003341 /* ignore the given nids (e.g. pc-beep returns error) */
3342 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3343 continue;
3344
Takashi Iwai0ba21762007-04-16 11:29:14 +02003345 def_conf = snd_hda_codec_read(codec, nid, 0,
3346 AC_VERB_GET_CONFIG_DEFAULT, 0);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003347 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3348 continue;
3349 loc = get_defcfg_location(def_conf);
3350 switch (get_defcfg_device(def_conf)) {
3351 case AC_JACK_LINE_OUT:
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003352 seq = get_defcfg_sequence(def_conf);
3353 assoc = get_defcfg_association(def_conf);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01003354
3355 if (!(wid_caps & AC_WCAP_STEREO))
3356 if (!cfg->mono_out_pin)
3357 cfg->mono_out_pin = nid;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003358 if (!assoc)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003359 continue;
Takashi Iwai0ba21762007-04-16 11:29:14 +02003360 if (!assoc_line_out)
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003361 assoc_line_out = assoc;
3362 else if (assoc_line_out != assoc)
3363 continue;
3364 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3365 continue;
3366 cfg->line_out_pins[cfg->line_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003367 sequences_line_out[cfg->line_outs] = seq;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003368 cfg->line_outs++;
3369 break;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01003370 case AC_JACK_SPEAKER:
Steve Longerbeam81937d32007-05-08 15:33:03 +02003371 seq = get_defcfg_sequence(def_conf);
3372 assoc = get_defcfg_association(def_conf);
3373 if (! assoc)
3374 continue;
3375 if (! assoc_speaker)
3376 assoc_speaker = assoc;
3377 else if (assoc_speaker != assoc)
3378 continue;
Takashi Iwai82bc9552006-03-21 11:24:42 +01003379 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3380 continue;
3381 cfg->speaker_pins[cfg->speaker_outs] = nid;
Steve Longerbeam81937d32007-05-08 15:33:03 +02003382 sequences_speaker[cfg->speaker_outs] = seq;
Takashi Iwai82bc9552006-03-21 11:24:42 +01003383 cfg->speaker_outs++;
Takashi Iwai8d88bc32005-11-17 11:09:23 +01003384 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003385 case AC_JACK_HP_OUT:
Takashi Iwaif889fa92007-10-31 15:49:32 +01003386 seq = get_defcfg_sequence(def_conf);
3387 assoc = get_defcfg_association(def_conf);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003388 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3389 continue;
3390 cfg->hp_pins[cfg->hp_outs] = nid;
Takashi Iwaif889fa92007-10-31 15:49:32 +01003391 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003392 cfg->hp_outs++;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003393 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02003394 case AC_JACK_MIC_IN: {
3395 int preferred, alt;
3396 if (loc == AC_JACK_LOC_FRONT) {
3397 preferred = AUTO_PIN_FRONT_MIC;
3398 alt = AUTO_PIN_MIC;
3399 } else {
3400 preferred = AUTO_PIN_MIC;
3401 alt = AUTO_PIN_FRONT_MIC;
3402 }
3403 if (!cfg->input_pins[preferred])
3404 cfg->input_pins[preferred] = nid;
3405 else if (!cfg->input_pins[alt])
3406 cfg->input_pins[alt] = nid;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003407 break;
Takashi Iwai314634b2006-09-21 11:56:18 +02003408 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003409 case AC_JACK_LINE_IN:
3410 if (loc == AC_JACK_LOC_FRONT)
3411 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3412 else
3413 cfg->input_pins[AUTO_PIN_LINE] = nid;
3414 break;
3415 case AC_JACK_CD:
3416 cfg->input_pins[AUTO_PIN_CD] = nid;
3417 break;
3418 case AC_JACK_AUX:
3419 cfg->input_pins[AUTO_PIN_AUX] = nid;
3420 break;
3421 case AC_JACK_SPDIF_OUT:
3422 cfg->dig_out_pin = nid;
3423 break;
3424 case AC_JACK_SPDIF_IN:
3425 cfg->dig_in_pin = nid;
3426 break;
3427 }
3428 }
3429
Takashi Iwai5832fcf2008-02-12 18:30:12 +01003430 /* FIX-UP:
3431 * If no line-out is defined but multiple HPs are found,
3432 * some of them might be the real line-outs.
3433 */
3434 if (!cfg->line_outs && cfg->hp_outs > 1) {
3435 int i = 0;
3436 while (i < cfg->hp_outs) {
3437 /* The real HPs should have the sequence 0x0f */
3438 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3439 i++;
3440 continue;
3441 }
3442 /* Move it to the line-out table */
3443 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3444 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3445 cfg->line_outs++;
3446 cfg->hp_outs--;
3447 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3448 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3449 memmove(sequences_hp + i - 1, sequences_hp + i,
3450 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3451 }
3452 }
3453
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003454 /* sort by sequence */
Steve Longerbeam81937d32007-05-08 15:33:03 +02003455 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3456 cfg->line_outs);
3457 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3458 cfg->speaker_outs);
Takashi Iwaif889fa92007-10-31 15:49:32 +01003459 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3460 cfg->hp_outs);
Steve Longerbeam81937d32007-05-08 15:33:03 +02003461
Takashi Iwaif889fa92007-10-31 15:49:32 +01003462 /* if we have only one mic, make it AUTO_PIN_MIC */
3463 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3464 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3465 cfg->input_pins[AUTO_PIN_MIC] =
3466 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3467 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3468 }
3469 /* ditto for line-in */
3470 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3471 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3472 cfg->input_pins[AUTO_PIN_LINE] =
3473 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3474 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3475 }
3476
Steve Longerbeam81937d32007-05-08 15:33:03 +02003477 /*
3478 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3479 * as a primary output
3480 */
3481 if (!cfg->line_outs) {
3482 if (cfg->speaker_outs) {
3483 cfg->line_outs = cfg->speaker_outs;
3484 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3485 sizeof(cfg->speaker_pins));
3486 cfg->speaker_outs = 0;
3487 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3488 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3489 } else if (cfg->hp_outs) {
3490 cfg->line_outs = cfg->hp_outs;
3491 memcpy(cfg->line_out_pins, cfg->hp_pins,
3492 sizeof(cfg->hp_pins));
3493 cfg->hp_outs = 0;
3494 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3495 cfg->line_out_type = AUTO_PIN_HP_OUT;
3496 }
3497 }
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003498
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003499 /* Reorder the surround channels
3500 * ALSA sequence is front/surr/clfe/side
3501 * HDA sequence is:
3502 * 4-ch: front/surr => OK as it is
3503 * 6-ch: front/clfe/surr
Takashi Iwai9422db42007-04-20 16:11:43 +02003504 * 8-ch: front/clfe/rear/side|fc
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003505 */
3506 switch (cfg->line_outs) {
3507 case 3:
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003508 case 4:
3509 nid = cfg->line_out_pins[1];
Takashi Iwai9422db42007-04-20 16:11:43 +02003510 cfg->line_out_pins[1] = cfg->line_out_pins[2];
Takashi Iwaicb8e2f82005-07-29 11:54:32 +02003511 cfg->line_out_pins[2] = nid;
3512 break;
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003513 }
3514
Takashi Iwai82bc9552006-03-21 11:24:42 +01003515 /*
3516 * debug prints of the parsed results
3517 */
3518 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3519 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3520 cfg->line_out_pins[2], cfg->line_out_pins[3],
3521 cfg->line_out_pins[4]);
3522 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3523 cfg->speaker_outs, cfg->speaker_pins[0],
3524 cfg->speaker_pins[1], cfg->speaker_pins[2],
3525 cfg->speaker_pins[3], cfg->speaker_pins[4]);
Takashi Iwaieb06ed82006-09-20 17:10:27 +02003526 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3527 cfg->hp_outs, cfg->hp_pins[0],
3528 cfg->hp_pins[1], cfg->hp_pins[2],
3529 cfg->hp_pins[3], cfg->hp_pins[4]);
Matthew Ranostay90da78b2008-01-24 11:48:01 +01003530 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
Takashi Iwai82bc9552006-03-21 11:24:42 +01003531 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3532 " cd=0x%x, aux=0x%x\n",
3533 cfg->input_pins[AUTO_PIN_MIC],
3534 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3535 cfg->input_pins[AUTO_PIN_LINE],
3536 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3537 cfg->input_pins[AUTO_PIN_CD],
3538 cfg->input_pins[AUTO_PIN_AUX]);
3539
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003540 return 0;
3541}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003542EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
Takashi Iwaie9edcee2005-06-13 14:16:38 +02003543
Takashi Iwai4a471b72005-12-07 13:56:29 +01003544/* labels for input pins */
3545const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3546 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3547};
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003548EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
Takashi Iwai4a471b72005-12-07 13:56:29 +01003549
3550
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551#ifdef CONFIG_PM
3552/*
3553 * power management
3554 */
3555
3556/**
3557 * snd_hda_suspend - suspend the codecs
3558 * @bus: the HDA bus
3559 * @state: suspsend state
3560 *
3561 * Returns 0 if successful.
3562 */
3563int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
3564{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003565 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566
Takashi Iwai0ba21762007-04-16 11:29:14 +02003567 list_for_each_entry(codec, &bus->codec_list, list) {
Takashi Iwai0b7a2e92007-08-14 15:18:26 +02003568#ifdef CONFIG_SND_HDA_POWER_SAVE
3569 if (!codec->power_on)
3570 continue;
3571#endif
Takashi Iwaicb53c622007-08-10 17:21:45 +02003572 hda_call_codec_suspend(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573 }
3574 return 0;
3575}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003576EXPORT_SYMBOL_HDA(snd_hda_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577
3578/**
3579 * snd_hda_resume - resume the codecs
3580 * @bus: the HDA bus
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 *
3582 * Returns 0 if successful.
Takashi Iwaicb53c622007-08-10 17:21:45 +02003583 *
3584 * This fucntion is defined only when POWER_SAVE isn't set.
3585 * In the power-save mode, the codec is resumed dynamically.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586 */
3587int snd_hda_resume(struct hda_bus *bus)
3588{
Takashi Iwai0ba21762007-04-16 11:29:14 +02003589 struct hda_codec *codec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590
Takashi Iwai0ba21762007-04-16 11:29:14 +02003591 list_for_each_entry(codec, &bus->codec_list, list) {
Maxim Levitskyd804ad92007-09-03 15:28:04 +02003592 if (snd_hda_codec_needs_resume(codec))
3593 hda_call_codec_resume(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 return 0;
3596}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003597EXPORT_SYMBOL_HDA(snd_hda_resume);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003598#endif /* CONFIG_PM */
Takashi Iwaib2e18592008-07-30 15:01:44 +02003599
3600/*
3601 * generic arrays
3602 */
3603
3604/* get a new element from the given array
3605 * if it exceeds the pre-allocated array size, re-allocate the array
3606 */
3607void *snd_array_new(struct snd_array *array)
3608{
3609 if (array->used >= array->alloced) {
3610 int num = array->alloced + array->alloc_align;
Takashi Iwaib910d9a2008-11-07 00:26:52 +01003611 void *nlist;
3612 if (snd_BUG_ON(num >= 4096))
3613 return NULL;
3614 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003615 if (!nlist)
3616 return NULL;
3617 if (array->list) {
3618 memcpy(nlist, array->list,
3619 array->elem_size * array->alloced);
3620 kfree(array->list);
3621 }
3622 array->list = nlist;
3623 array->alloced = num;
3624 }
Takashi Iwaif43aa022008-11-10 16:24:26 +01003625 return snd_array_elem(array, array->used++);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003626}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003627EXPORT_SYMBOL_HDA(snd_array_new);
Takashi Iwaib2e18592008-07-30 15:01:44 +02003628
3629/* free the given array elements */
3630void snd_array_free(struct snd_array *array)
3631{
3632 kfree(array->list);
3633 array->used = 0;
3634 array->alloced = 0;
3635 array->list = NULL;
3636}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003637EXPORT_SYMBOL_HDA(snd_array_free);
Takashi Iwaib2022262008-11-21 21:24:03 +01003638
3639/*
3640 * used by hda_proc.c and hda_eld.c
3641 */
3642void snd_print_pcm_rates(int pcm, char *buf, int buflen)
3643{
3644 static unsigned int rates[] = {
3645 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
3646 96000, 176400, 192000, 384000
3647 };
3648 int i, j;
3649
3650 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
3651 if (pcm & (1 << i))
3652 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
3653
3654 buf[j] = '\0'; /* necessary when j == 0 */
3655}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003656EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
Takashi Iwaib2022262008-11-21 21:24:03 +01003657
3658void snd_print_pcm_bits(int pcm, char *buf, int buflen)
3659{
3660 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
3661 int i, j;
3662
3663 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
3664 if (pcm & (AC_SUPPCM_BITS_8 << i))
3665 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
3666
3667 buf[j] = '\0'; /* necessary when j == 0 */
3668}
Takashi Iwaiff7a3262008-11-28 15:17:06 +01003669EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
Takashi Iwai1289e9e2008-11-27 15:47:11 +01003670
3671MODULE_DESCRIPTION("HDA codec core");
3672MODULE_LICENSE("GPL");