projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda_generic: use AC_WCAP_CONN_LIST check for widget connections
[deliverable/linux.git] / sound / pci / hda / hda_codec.c
CommitLineData
1da177e4
LT		 1/*
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
1da177e4
LT		 22#include <linux/init.h>
23#include <linux/delay.h>
24#include <linux/slab.h>
25#include <linux/pci.h>
62932df8 26#include <linux/mutex.h>
1da177e4
LT		 27#include <sound/core.h>
28#include "hda_codec.h"
29#include <sound/asoundef.h>
302e9c5a 30#include <sound/tlv.h>
1da177e4
LT		 31#include <sound/initval.h>
32#include "hda_local.h"
2807314d 33#include <sound/hda_hwdep.h>
1da177e4 34
1da177e4
LT		 35/*
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[] = {
c8cd1281 46 { 0x1002, "ATI" },
a9226251 47 { 0x1057, "Motorola" },
c8cd1281 48 { 0x1095, "Silicon Image" },
31117b78 49 { 0x10de, "Nvidia" },
c8cd1281 50 { 0x10ec, "Realtek" },
4e01f54b 51 { 0x1102, "Creative" },
c577b8a1 52 { 0x1106, "VIA" },
7f16859a 53 { 0x111d, "IDT" },
c8cd1281 54 { 0x11c1, "LSI" },
54b903ec 55 { 0x11d4, "Analog Devices" },
1da177e4 56 { 0x13f6, "C-Media" },
a9226251 57 { 0x14f1, "Conexant" },
c8cd1281
TI		 58 { 0x17e8, "Chrontel" },
59 { 0x1854, "LG" },
8199de3b 60 { 0x1aec, "Wolfson Microelectronics" },
1da177e4 61 { 0x434d, "C-Media" },
74c61133 62 { 0x8086, "Intel" },
2f2f4251 63 { 0x8384, "SigmaTel" },
1da177e4
LT		 64 {} /* terminator */
65};
66
1289e9e8
TI		 67static DEFINE_MUTEX(preset_mutex);
68static LIST_HEAD(hda_preset_tables);
69
70int snd_hda_add_codec_preset(struct hda_codec_preset_list *preset)
71{
72 mutex_lock(&preset_mutex);
73 list_add_tail(&preset->list, &hda_preset_tables);
74 mutex_unlock(&preset_mutex);
75 return 0;
76}
ff7a3267 77EXPORT_SYMBOL_HDA(snd_hda_add_codec_preset);
1289e9e8
TI		 78
79int snd_hda_delete_codec_preset(struct hda_codec_preset_list *preset)
80{
81 mutex_lock(&preset_mutex);
82 list_del(&preset->list);
83 mutex_unlock(&preset_mutex);
84 return 0;
85}
ff7a3267 86EXPORT_SYMBOL_HDA(snd_hda_delete_codec_preset);
1da177e4 87
cb53c626
TI		 88#ifdef CONFIG_SND_HDA_POWER_SAVE
89static void hda_power_work(struct work_struct *work);
90static void hda_keep_power_on(struct hda_codec *codec);
91#else
92static inline void hda_keep_power_on(struct hda_codec *codec) {}
93#endif
94
50a9f790
MR		 95const char *snd_hda_get_jack_location(u32 cfg)
96{
97 static char *bases[7] = {
98 "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
99 };
100 static unsigned char specials_idx[] = {
101 0x07, 0x08,
102 0x17, 0x18, 0x19,
103 0x37, 0x38
104 };
105 static char *specials[] = {
106 "Rear Panel", "Drive Bar",
107 "Riser", "HDMI", "ATAPI",
108 "Mobile-In", "Mobile-Out"
109 };
110 int i;
111 cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
112 if ((cfg & 0x0f) < 7)
113 return bases[cfg & 0x0f];
114 for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
115 if (cfg == specials_idx[i])
116 return specials[i];
117 }
118 return "UNKNOWN";
119}
ff7a3267 120EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
50a9f790
MR		 121
122const char *snd_hda_get_jack_connectivity(u32 cfg)
123{
124 static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
125
126 return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
127}
ff7a3267 128EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
50a9f790
MR		 129
130const char *snd_hda_get_jack_type(u32 cfg)
131{
132 static char *jack_types[16] = {
133 "Line Out", "Speaker", "HP Out", "CD",
134 "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
135 "Line In", "Aux", "Mic", "Telephony",
136 "SPDIF In", "Digitial In", "Reserved", "Other"
137 };
138
139 return jack_types[(cfg & AC_DEFCFG_DEVICE)
140 >> AC_DEFCFG_DEVICE_SHIFT];
141}
ff7a3267 142EXPORT_SYMBOL_HDA(snd_hda_get_jack_type);
50a9f790 143
33fa35ed
TI		 144/*
145 * Compose a 32bit command word to be sent to the HD-audio controller
146 */
147static inline unsigned int
148make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
149 unsigned int verb, unsigned int parm)
150{
151 u32 val;
152
82e1b804
TI		 153 if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
154 (verb & ~0xfff) || (parm & ~0xffff)) {
6430aeeb
WF		 155 printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
156 codec->addr, direct, nid, verb, parm);
157 return ~0;
158 }
159
160 val = (u32)codec->addr << 28;
33fa35ed
TI		 161 val |= (u32)direct << 27;
162 val |= (u32)nid << 20;
163 val |= verb << 8;
164 val |= parm;
165 return val;
166}
167
aa2936f5
TI		 168/*
169 * Send and receive a verb
170 */
171static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
172 unsigned int *res)
173{
174 struct hda_bus *bus = codec->bus;
8dd78330 175 int err;
aa2936f5 176
6430aeeb
WF		 177 if (cmd == ~0)
178 return -1;
179
aa2936f5
TI		 180 if (res)
181 *res = -1;
8dd78330 182 again:
aa2936f5
TI		 183 snd_hda_power_up(codec);
184 mutex_lock(&bus->cmd_mutex);
aa2936f5 185 err = bus->ops.command(bus, cmd);
8dd78330
TI		 186 if (!err && res)
187 *res = bus->ops.get_response(bus);
aa2936f5
TI		 188 mutex_unlock(&bus->cmd_mutex);
189 snd_hda_power_down(codec);
8dd78330
TI		 190 if (res && *res == -1 && bus->rirb_error) {
191 if (bus->response_reset) {
192 snd_printd("hda_codec: resetting BUS due to "
193 "fatal communication error\n");
194 bus->ops.bus_reset(bus);
195 }
196 goto again;
197 }
198 /* clear reset-flag when the communication gets recovered */
199 if (!err)
200 bus->response_reset = 0;
aa2936f5
TI		 201 return err;
202}
203
1da177e4
LT		 204/**
205 * snd_hda_codec_read - send a command and get the response
206 * @codec: the HDA codec
207 * @nid: NID to send the command
208 * @direct: direct flag
209 * @verb: the verb to send
210 * @parm: the parameter for the verb
211 *
212 * Send a single command and read the corresponding response.
213 *
214 * Returns the obtained response value, or -1 for an error.
215 */
0ba21762
TI		 216unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
217 int direct,
1da177e4
LT		 218 unsigned int verb, unsigned int parm)
219{
aa2936f5
TI		 220 unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
221 unsigned int res;
222 codec_exec_verb(codec, cmd, &res);
1da177e4
LT		 223 return res;
224}
ff7a3267 225EXPORT_SYMBOL_HDA(snd_hda_codec_read);
1da177e4
LT		 226
227/**
228 * snd_hda_codec_write - send a single command without waiting for response
229 * @codec: the HDA codec
230 * @nid: NID to send the command
231 * @direct: direct flag
232 * @verb: the verb to send
233 * @parm: the parameter for the verb
234 *
235 * Send a single command without waiting for response.
236 *
237 * Returns 0 if successful, or a negative error code.
238 */
239int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
240 unsigned int verb, unsigned int parm)
241{
aa2936f5 242 unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
33fa35ed 243 unsigned int res;
b20f3b83
TI		 244 return codec_exec_verb(codec, cmd,
245 codec->bus->sync_write ? &res : NULL);
1da177e4 246}
ff7a3267 247EXPORT_SYMBOL_HDA(snd_hda_codec_write);
1da177e4
LT		 248
249/**
250 * snd_hda_sequence_write - sequence writes
251 * @codec: the HDA codec
252 * @seq: VERB array to send
253 *
254 * Send the commands sequentially from the given array.
255 * The array must be terminated with NID=0.
256 */
257void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
258{
259 for (; seq->nid; seq++)
260 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
261}
ff7a3267 262EXPORT_SYMBOL_HDA(snd_hda_sequence_write);
1da177e4
LT		 263
264/**
265 * snd_hda_get_sub_nodes - get the range of sub nodes
266 * @codec: the HDA codec
267 * @nid: NID to parse
268 * @start_id: the pointer to store the start NID
269 *
270 * Parse the NID and store the start NID of its sub-nodes.
271 * Returns the number of sub-nodes.
272 */
0ba21762
TI		 273int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
274 hda_nid_t *start_id)
1da177e4
LT		 275{
276 unsigned int parm;
277
278 parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);
e8a7f136
DT		 279 if (parm == -1)
280 return 0;
1da177e4
LT		 281 *start_id = (parm >> 16) & 0x7fff;
282 return (int)(parm & 0x7fff);
283}
ff7a3267 284EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
1da177e4
LT		 285
286/**
287 * snd_hda_get_connections - get connection list
288 * @codec: the HDA codec
289 * @nid: NID to parse
290 * @conn_list: connection list array
291 * @max_conns: max. number of connections to store
292 *
293 * Parses the connection list of the given widget and stores the list
294 * of NIDs.
295 *
296 * Returns the number of connections, or a negative error code.
297 */
298int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
299 hda_nid_t *conn_list, int max_conns)
300{
301 unsigned int parm;
54d17403 302 int i, conn_len, conns;
1da177e4 303 unsigned int shift, num_elems, mask;
54d17403 304 hda_nid_t prev_nid;
1da177e4 305
da3cec35
TI		 306 if (snd_BUG_ON(!conn_list || max_conns <= 0))
307 return -EINVAL;
1da177e4
LT		 308
309 parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
310 if (parm & AC_CLIST_LONG) {
311 /* long form */
312 shift = 16;
313 num_elems = 2;
314 } else {
315 /* short form */
316 shift = 8;
317 num_elems = 4;
318 }
319 conn_len = parm & AC_CLIST_LENGTH;
1da177e4
LT		 320 mask = (1 << (shift-1)) - 1;
321
0ba21762 322 if (!conn_len)
1da177e4
LT		 323 return 0; /* no connection */
324
325 if (conn_len == 1) {
326 /* single connection */
0ba21762
TI		 327 parm = snd_hda_codec_read(codec, nid, 0,
328 AC_VERB_GET_CONNECT_LIST, 0);
3c6aae44
TI		 329 if (parm == -1 && codec->bus->rirb_error)
330 return -EIO;
1da177e4
LT		 331 conn_list[0] = parm & mask;
332 return 1;
333 }
334
335 /* multi connection */
336 conns = 0;
54d17403
TI		 337 prev_nid = 0;
338 for (i = 0; i < conn_len; i++) {
339 int range_val;
340 hda_nid_t val, n;
341
3c6aae44 342 if (i % num_elems == 0) {
54d17403
TI		 343 parm = snd_hda_codec_read(codec, nid, 0,
344 AC_VERB_GET_CONNECT_LIST, i);
3c6aae44
TI		 345 if (parm == -1 && codec->bus->rirb_error)
346 return -EIO;
347 }
0ba21762 348 range_val = !!(parm & (1 << (shift-1))); /* ranges */
54d17403 349 val = parm & mask;
2e9bf247
JK		 350 if (val == 0) {
351 snd_printk(KERN_WARNING "hda_codec: "
352 "invalid CONNECT_LIST verb %x[%i]:%x\n",
353 nid, i, parm);
354 return 0;
355 }
54d17403
TI		 356 parm >>= shift;
357 if (range_val) {
358 /* ranges between the previous and this one */
0ba21762
TI		 359 if (!prev_nid || prev_nid >= val) {
360 snd_printk(KERN_WARNING "hda_codec: "
361 "invalid dep_range_val %x:%x\n",
362 prev_nid, val);
54d17403
TI		 363 continue;
364 }
365 for (n = prev_nid + 1; n <= val; n++) {
366 if (conns >= max_conns) {
0ba21762
TI		 367 snd_printk(KERN_ERR
368 "Too many connections\n");
1da177e4 369 return -EINVAL;
54d17403
TI		 370 }
371 conn_list[conns++] = n;
1da177e4 372 }
54d17403
TI		 373 } else {
374 if (conns >= max_conns) {
375 snd_printk(KERN_ERR "Too many connections\n");
376 return -EINVAL;
377 }
378 conn_list[conns++] = val;
1da177e4 379 }
54d17403 380 prev_nid = val;
1da177e4
LT		 381 }
382 return conns;
383}
ff7a3267 384EXPORT_SYMBOL_HDA(snd_hda_get_connections);
1da177e4
LT		 385
386
387/**
388 * snd_hda_queue_unsol_event - add an unsolicited event to queue
389 * @bus: the BUS
390 * @res: unsolicited event (lower 32bit of RIRB entry)
391 * @res_ex: codec addr and flags (upper 32bit or RIRB entry)
392 *
393 * Adds the given event to the queue. The events are processed in
394 * the workqueue asynchronously. Call this function in the interrupt
395 * hanlder when RIRB receives an unsolicited event.
396 *
397 * Returns 0 if successful, or a negative error code.
398 */
399int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
400{
401 struct hda_bus_unsolicited *unsol;
402 unsigned int wp;
403
0ba21762
TI		 404 unsol = bus->unsol;
405 if (!unsol)
1da177e4
LT		 406 return 0;
407
408 wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;
409 unsol->wp = wp;
410
411 wp <<= 1;
412 unsol->queue[wp] = res;
413 unsol->queue[wp + 1] = res_ex;
414
6acaed38 415 queue_work(bus->workq, &unsol->work);
1da177e4
LT		 416
417 return 0;
418}
ff7a3267 419EXPORT_SYMBOL_HDA(snd_hda_queue_unsol_event);
1da177e4
LT		 420
421/*
5c1d1a98 422 * process queued unsolicited events
1da177e4 423 */
c4028958 424static void process_unsol_events(struct work_struct *work)
1da177e4 425{
c4028958
DH		 426 struct hda_bus_unsolicited *unsol =
427 container_of(work, struct hda_bus_unsolicited, work);
428 struct hda_bus *bus = unsol->bus;
1da177e4
LT		 429 struct hda_codec *codec;
430 unsigned int rp, caddr, res;
431
432 while (unsol->rp != unsol->wp) {
433 rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;
434 unsol->rp = rp;
435 rp <<= 1;
436 res = unsol->queue[rp];
437 caddr = unsol->queue[rp + 1];
0ba21762 438 if (!(caddr & (1 << 4))) /* no unsolicited event? */
1da177e4
LT		 439 continue;
440 codec = bus->caddr_tbl[caddr & 0x0f];
441 if (codec && codec->patch_ops.unsol_event)
442 codec->patch_ops.unsol_event(codec, res);
443 }
444}
445
446/*
447 * initialize unsolicited queue
448 */
6c1f45ea 449static int init_unsol_queue(struct hda_bus *bus)
1da177e4
LT		 450{
451 struct hda_bus_unsolicited *unsol;
452
9f146bb6
TI		 453 if (bus->unsol) /* already initialized */
454 return 0;
455
e560d8d8 456 unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);
0ba21762
TI		 457 if (!unsol) {
458 snd_printk(KERN_ERR "hda_codec: "
459 "can't allocate unsolicited queue\n");
1da177e4
LT		 460 return -ENOMEM;
461 }
c4028958
DH		 462 INIT_WORK(&unsol->work, process_unsol_events);
463 unsol->bus = bus;
1da177e4
LT		 464 bus->unsol = unsol;
465 return 0;
466}
467
468/*
469 * destructor
470 */
471static void snd_hda_codec_free(struct hda_codec *codec);
472
473static int snd_hda_bus_free(struct hda_bus *bus)
474{
0ba21762 475 struct hda_codec *codec, *n;
1da177e4 476
0ba21762 477 if (!bus)
1da177e4 478 return 0;
6acaed38
TI		 479 if (bus->workq)
480 flush_workqueue(bus->workq);
481 if (bus->unsol)
1da177e4 482 kfree(bus->unsol);
0ba21762 483 list_for_each_entry_safe(codec, n, &bus->codec_list, list) {
1da177e4
LT		 484 snd_hda_codec_free(codec);
485 }
486 if (bus->ops.private_free)
487 bus->ops.private_free(bus);
6acaed38
TI		 488 if (bus->workq)
489 destroy_workqueue(bus->workq);
1da177e4
LT		 490 kfree(bus);
491 return 0;
492}
493
c8b6bf9b 494static int snd_hda_bus_dev_free(struct snd_device *device)
1da177e4
LT		 495{
496 struct hda_bus *bus = device->device_data;
b94d3539 497 bus->shutdown = 1;
1da177e4
LT		 498 return snd_hda_bus_free(bus);
499}
500
d7ffba19
TI		 501#ifdef CONFIG_SND_HDA_HWDEP
502static int snd_hda_bus_dev_register(struct snd_device *device)
503{
504 struct hda_bus *bus = device->device_data;
505 struct hda_codec *codec;
506 list_for_each_entry(codec, &bus->codec_list, list) {
507 snd_hda_hwdep_add_sysfs(codec);
508 }
509 return 0;
510}
511#else
512#define snd_hda_bus_dev_register NULL
513#endif
514
1da177e4
LT		 515/**
516 * snd_hda_bus_new - create a HDA bus
517 * @card: the card entry
518 * @temp: the template for hda_bus information
519 * @busp: the pointer to store the created bus instance
520 *
521 * Returns 0 if successful, or a negative error code.
522 */
1289e9e8 523int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
756e2b01
TI		 524 const struct hda_bus_template *temp,
525 struct hda_bus **busp)
1da177e4
LT		 526{
527 struct hda_bus *bus;
528 int err;
c8b6bf9b 529 static struct snd_device_ops dev_ops = {
d7ffba19 530 .dev_register = snd_hda_bus_dev_register,
1da177e4
LT		 531 .dev_free = snd_hda_bus_dev_free,
532 };
533
da3cec35
TI		 534 if (snd_BUG_ON(!temp))
535 return -EINVAL;
536 if (snd_BUG_ON(!temp->ops.command || !temp->ops.get_response))
537 return -EINVAL;
1da177e4
LT		 538
539 if (busp)
540 *busp = NULL;
541
e560d8d8 542 bus = kzalloc(sizeof(*bus), GFP_KERNEL);
1da177e4
LT		 543 if (bus == NULL) {
544 snd_printk(KERN_ERR "can't allocate struct hda_bus\n");
545 return -ENOMEM;
546 }
547
548 bus->card = card;
549 bus->private_data = temp->private_data;
550 bus->pci = temp->pci;
551 bus->modelname = temp->modelname;
fee2fba3 552 bus->power_save = temp->power_save;
1da177e4
LT		 553 bus->ops = temp->ops;
554
62932df8 555 mutex_init(&bus->cmd_mutex);
1da177e4
LT		 556 INIT_LIST_HEAD(&bus->codec_list);
557
e8c0ee5d
TI		 558 snprintf(bus->workq_name, sizeof(bus->workq_name),
559 "hd-audio%d", card->number);
560 bus->workq = create_singlethread_workqueue(bus->workq_name);
6acaed38 561 if (!bus->workq) {
e8c0ee5d
TI		 562 snd_printk(KERN_ERR "cannot create workqueue %s\n",
563 bus->workq_name);
6acaed38
TI		 564 kfree(bus);
565 return -ENOMEM;
566 }
567
0ba21762
TI		 568 err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);
569 if (err < 0) {
1da177e4
LT		 570 snd_hda_bus_free(bus);
571 return err;
572 }
573 if (busp)
574 *busp = bus;
575 return 0;
576}
ff7a3267 577EXPORT_SYMBOL_HDA(snd_hda_bus_new);
1da177e4 578
82467611
TI		 579#ifdef CONFIG_SND_HDA_GENERIC
580#define is_generic_config(codec) \
f44ac837 581 (codec->modelname && !strcmp(codec->modelname, "generic"))
82467611
TI		 582#else
583#define is_generic_config(codec) 0
584#endif
585
645f10c1 586#ifdef MODULE
1289e9e8
TI		 587#define HDA_MODREQ_MAX_COUNT 2 /* two request_modules()'s */
588#else
645f10c1 589#define HDA_MODREQ_MAX_COUNT 0 /* all presets are statically linked */
1289e9e8
TI		 590#endif
591
1da177e4
LT		 592/*
593 * find a matching codec preset
594 */
6c1f45ea 595static const struct hda_codec_preset *
756e2b01 596find_codec_preset(struct hda_codec *codec)
1da177e4 597{
1289e9e8
TI		 598 struct hda_codec_preset_list *tbl;
599 const struct hda_codec_preset *preset;
600 int mod_requested = 0;
1da177e4 601
82467611 602 if (is_generic_config(codec))
d5ad630b
TI		 603 return NULL; /* use the generic parser */
604
1289e9e8
TI		 605 again:
606 mutex_lock(&preset_mutex);
607 list_for_each_entry(tbl, &hda_preset_tables, list) {
608 if (!try_module_get(tbl->owner)) {
609 snd_printk(KERN_ERR "hda_codec: cannot module_get\n");
610 continue;
611 }
612 for (preset = tbl->preset; preset->id; preset++) {
1da177e4 613 u32 mask = preset->mask;
ca7cfae9
MB		 614 if (preset->afg && preset->afg != codec->afg)
615 continue;
616 if (preset->mfg && preset->mfg != codec->mfg)
617 continue;
0ba21762 618 if (!mask)
1da177e4 619 mask = ~0;
9c7f852e 620 if (preset->id == (codec->vendor_id & mask) &&
0ba21762 621 (!preset->rev ||
1289e9e8
TI		 622 preset->rev == codec->revision_id)) {
623 mutex_unlock(&preset_mutex);
624 codec->owner = tbl->owner;
1da177e4 625 return preset;
1289e9e8 626 }
1da177e4 627 }
1289e9e8
TI		 628 module_put(tbl->owner);
629 }
630 mutex_unlock(&preset_mutex);
631
632 if (mod_requested < HDA_MODREQ_MAX_COUNT) {
633 char name[32];
634 if (!mod_requested)
635 snprintf(name, sizeof(name), "snd-hda-codec-id:%08x",
636 codec->vendor_id);
637 else
638 snprintf(name, sizeof(name), "snd-hda-codec-id:%04x*",
639 (codec->vendor_id >> 16) & 0xffff);
640 request_module(name);
641 mod_requested++;
642 goto again;
1da177e4
LT		 643 }
644 return NULL;
645}
646
647/*
f44ac837 648 * get_codec_name - store the codec name
1da177e4 649 */
f44ac837 650static int get_codec_name(struct hda_codec *codec)
1da177e4
LT		 651{
652 const struct hda_vendor_id *c;
653 const char *vendor = NULL;
654 u16 vendor_id = codec->vendor_id >> 16;
812a2cca
TI		 655 char tmp[16];
656
657 if (codec->vendor_name)
658 goto get_chip_name;
1da177e4
LT		 659
660 for (c = hda_vendor_ids; c->id; c++) {
661 if (c->id == vendor_id) {
662 vendor = c->name;
663 break;
664 }
665 }
0ba21762 666 if (!vendor) {
1da177e4
LT		 667 sprintf(tmp, "Generic %04x", vendor_id);
668 vendor = tmp;
669 }
812a2cca
TI		 670 codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
671 if (!codec->vendor_name)
672 return -ENOMEM;
673
674 get_chip_name:
675 if (codec->chip_name)
676 return 0;
677
1da177e4 678 if (codec->preset && codec->preset->name)
812a2cca
TI		 679 codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
680 else {
681 sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
682 codec->chip_name = kstrdup(tmp, GFP_KERNEL);
683 }
684 if (!codec->chip_name)
f44ac837
TI		 685 return -ENOMEM;
686 return 0;
1da177e4
LT		 687}
688
689/*
673b683a 690 * look for an AFG and MFG nodes
1da177e4 691 */
1289e9e8 692static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
1da177e4 693{
93e82ae7 694 int i, total_nodes, function_id;
1da177e4
LT		 695 hda_nid_t nid;
696
697 total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
698 for (i = 0; i < total_nodes; i++, nid++) {
93e82ae7 699 function_id = snd_hda_param_read(codec, nid,
234b4346 700 AC_PAR_FUNCTION_TYPE) & 0xff;
93e82ae7 701 switch (function_id) {
673b683a
SK		 702 case AC_GRP_AUDIO_FUNCTION:
703 codec->afg = nid;
93e82ae7 704 codec->function_id = function_id;
673b683a
SK		 705 break;
706 case AC_GRP_MODEM_FUNCTION:
707 codec->mfg = nid;
93e82ae7 708 codec->function_id = function_id;
673b683a
SK		 709 break;
710 default:
711 break;
712 }
1da177e4 713 }
1da177e4
LT		 714}
715
54d17403
TI		 716/*
717 * read widget caps for each widget and store in cache
718 */
719static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
720{
721 int i;
722 hda_nid_t nid;
723
724 codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node,
725 &codec->start_nid);
726 codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL);
0ba21762 727 if (!codec->wcaps)
54d17403
TI		 728 return -ENOMEM;
729 nid = codec->start_nid;
730 for (i = 0; i < codec->num_nodes; i++, nid++)
731 codec->wcaps[i] = snd_hda_param_read(codec, nid,
732 AC_PAR_AUDIO_WIDGET_CAP);
733 return 0;
734}
735
3be14149
TI		 736/* read all pin default configurations and save codec->init_pins */
737static int read_pin_defaults(struct hda_codec *codec)
738{
739 int i;
740 hda_nid_t nid = codec->start_nid;
741
742 for (i = 0; i < codec->num_nodes; i++, nid++) {
743 struct hda_pincfg *pin;
744 unsigned int wcaps = get_wcaps(codec, nid);
745 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
746 AC_WCAP_TYPE_SHIFT;
747 if (wid_type != AC_WID_PIN)
748 continue;
749 pin = snd_array_new(&codec->init_pins);
750 if (!pin)
751 return -ENOMEM;
752 pin->nid = nid;
753 pin->cfg = snd_hda_codec_read(codec, nid, 0,
754 AC_VERB_GET_CONFIG_DEFAULT, 0);
755 }
756 return 0;
757}
758
759/* look up the given pin config list and return the item matching with NID */
760static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
761 struct snd_array *array,
762 hda_nid_t nid)
763{
764 int i;
765 for (i = 0; i < array->used; i++) {
766 struct hda_pincfg *pin = snd_array_elem(array, i);
767 if (pin->nid == nid)
768 return pin;
769 }
770 return NULL;
771}
772
773/* write a config value for the given NID */
774static void set_pincfg(struct hda_codec *codec, hda_nid_t nid,
775 unsigned int cfg)
776{
777 int i;
778 for (i = 0; i < 4; i++) {
779 snd_hda_codec_write(codec, nid, 0,
780 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
781 cfg & 0xff);
782 cfg >>= 8;
783 }
784}
785
786/* set the current pin config value for the given NID.
787 * the value is cached, and read via snd_hda_codec_get_pincfg()
788 */
789int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
790 hda_nid_t nid, unsigned int cfg)
791{
792 struct hda_pincfg *pin;
5e7b8e0d 793 unsigned int oldcfg;
3be14149 794
5e7b8e0d 795 oldcfg = snd_hda_codec_get_pincfg(codec, nid);
3be14149
TI		 796 pin = look_up_pincfg(codec, list, nid);
797 if (!pin) {
798 pin = snd_array_new(list);
799 if (!pin)
800 return -ENOMEM;
801 pin->nid = nid;
802 }
803 pin->cfg = cfg;
5e7b8e0d
TI		 804
805 /* change only when needed; e.g. if the pincfg is already present
806 * in user_pins[], don't write it
807 */
808 cfg = snd_hda_codec_get_pincfg(codec, nid);
809 if (oldcfg != cfg)
810 set_pincfg(codec, nid, cfg);
3be14149
TI		 811 return 0;
812}
813
814int snd_hda_codec_set_pincfg(struct hda_codec *codec,
815 hda_nid_t nid, unsigned int cfg)
816{
346ff70f 817 return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
3be14149
TI		 818}
819EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
820
821/* get the current pin config value of the given pin NID */
822unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
823{
824 struct hda_pincfg *pin;
825
3be14149 826#ifdef CONFIG_SND_HDA_HWDEP
346ff70f 827 pin = look_up_pincfg(codec, &codec->user_pins, nid);
3be14149
TI		 828 if (pin)
829 return pin->cfg;
830#endif
5e7b8e0d
TI		 831 pin = look_up_pincfg(codec, &codec->driver_pins, nid);
832 if (pin)
833 return pin->cfg;
3be14149
TI		 834 pin = look_up_pincfg(codec, &codec->init_pins, nid);
835 if (pin)
836 return pin->cfg;
837 return 0;
838}
839EXPORT_SYMBOL_HDA(snd_hda_codec_get_pincfg);
840
841/* restore all current pin configs */
842static void restore_pincfgs(struct hda_codec *codec)
843{
844 int i;
845 for (i = 0; i < codec->init_pins.used; i++) {
846 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
847 set_pincfg(codec, pin->nid,
848 snd_hda_codec_get_pincfg(codec, pin->nid));
849 }
850}
54d17403 851
01751f54
TI		 852static void init_hda_cache(struct hda_cache_rec *cache,
853 unsigned int record_size);
1fcaee6e 854static void free_hda_cache(struct hda_cache_rec *cache);
01751f54 855
3be14149
TI		 856/* restore the initial pin cfgs and release all pincfg lists */
857static void restore_init_pincfgs(struct hda_codec *codec)
858{
346ff70f 859 /* first free driver_pins and user_pins, then call restore_pincfg
3be14149
TI		 860 * so that only the values in init_pins are restored
861 */
346ff70f 862 snd_array_free(&codec->driver_pins);
3be14149 863#ifdef CONFIG_SND_HDA_HWDEP
346ff70f 864 snd_array_free(&codec->user_pins);
3be14149
TI		 865#endif
866 restore_pincfgs(codec);
867 snd_array_free(&codec->init_pins);
868}
869
1da177e4
LT		 870/*
871 * codec destructor
872 */
873static void snd_hda_codec_free(struct hda_codec *codec)
874{
0ba21762 875 if (!codec)
1da177e4 876 return;
3be14149 877 restore_init_pincfgs(codec);
cb53c626
TI		 878#ifdef CONFIG_SND_HDA_POWER_SAVE
879 cancel_delayed_work(&codec->power_work);
6acaed38 880 flush_workqueue(codec->bus->workq);
cb53c626 881#endif
1da177e4 882 list_del(&codec->list);
d13bd412 883 snd_array_free(&codec->mixers);
1da177e4
LT		 884 codec->bus->caddr_tbl[codec->addr] = NULL;
885 if (codec->patch_ops.free)
886 codec->patch_ops.free(codec);
1289e9e8 887 module_put(codec->owner);
01751f54 888 free_hda_cache(&codec->amp_cache);
b3ac5636 889 free_hda_cache(&codec->cmd_cache);
812a2cca
TI		 890 kfree(codec->vendor_name);
891 kfree(codec->chip_name);
f44ac837 892 kfree(codec->modelname);
54d17403 893 kfree(codec->wcaps);
1da177e4
LT		 894 kfree(codec);
895}
896
bb6ac72f
TI		 897static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
898 unsigned int power_state);
899
1da177e4
LT		 900/**
901 * snd_hda_codec_new - create a HDA codec
902 * @bus: the bus to assign
903 * @codec_addr: the codec address
904 * @codecp: the pointer to store the generated codec
905 *
906 * Returns 0 if successful, or a negative error code.
907 */
1289e9e8 908int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
a1e21c90 909 struct hda_codec **codecp)
1da177e4
LT		 910{
911 struct hda_codec *codec;
ba443687 912 char component[31];
1da177e4
LT		 913 int err;
914
da3cec35
TI		 915 if (snd_BUG_ON(!bus))
916 return -EINVAL;
917 if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
918 return -EINVAL;
1da177e4
LT		 919
920 if (bus->caddr_tbl[codec_addr]) {
0ba21762
TI		 921 snd_printk(KERN_ERR "hda_codec: "
922 "address 0x%x is already occupied\n", codec_addr);
1da177e4
LT		 923 return -EBUSY;
924 }
925
e560d8d8 926 codec = kzalloc(sizeof(*codec), GFP_KERNEL);
1da177e4
LT		 927 if (codec == NULL) {
928 snd_printk(KERN_ERR "can't allocate struct hda_codec\n");
929 return -ENOMEM;
930 }
931
932 codec->bus = bus;
933 codec->addr = codec_addr;
62932df8 934 mutex_init(&codec->spdif_mutex);
5a9e02e9 935 mutex_init(&codec->control_mutex);
01751f54 936 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
b3ac5636 937 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
d13bd412 938 snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
3be14149 939 snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
346ff70f 940 snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
6c1f45ea
TI		 941 if (codec->bus->modelname) {
942 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
943 if (!codec->modelname) {
944 snd_hda_codec_free(codec);
945 return -ENODEV;
946 }
947 }
1da177e4 948
cb53c626
TI		 949#ifdef CONFIG_SND_HDA_POWER_SAVE
950 INIT_DELAYED_WORK(&codec->power_work, hda_power_work);
951 /* snd_hda_codec_new() marks the codec as power-up, and leave it as is.
952 * the caller has to power down appropriatley after initialization
953 * phase.
954 */
955 hda_keep_power_on(codec);
956#endif
957
1da177e4
LT		 958 list_add_tail(&codec->list, &bus->codec_list);
959 bus->caddr_tbl[codec_addr] = codec;
960
0ba21762
TI		 961 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
962 AC_PAR_VENDOR_ID);
111d3af5
TI		 963 if (codec->vendor_id == -1)
964 /* read again, hopefully the access method was corrected
965 * in the last read...
966 */
967 codec->vendor_id = snd_hda_param_read(codec, AC_NODE_ROOT,
968 AC_PAR_VENDOR_ID);
0ba21762
TI		 969 codec->subsystem_id = snd_hda_param_read(codec, AC_NODE_ROOT,
970 AC_PAR_SUBSYSTEM_ID);
971 codec->revision_id = snd_hda_param_read(codec, AC_NODE_ROOT,
972 AC_PAR_REV_ID);
1da177e4 973
673b683a 974 setup_fg_nodes(codec);
0ba21762 975 if (!codec->afg && !codec->mfg) {
673b683a 976 snd_printdd("hda_codec: no AFG or MFG node found\n");
3be14149
TI		 977 err = -ENODEV;
978 goto error;
1da177e4
LT		 979 }
980
3be14149
TI		 981 err = read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg);
982 if (err < 0) {
54d17403 983 snd_printk(KERN_ERR "hda_codec: cannot malloc\n");
3be14149 984 goto error;
54d17403 985 }
3be14149
TI		 986 err = read_pin_defaults(codec);
987 if (err < 0)
988 goto error;
54d17403 989
0ba21762 990 if (!codec->subsystem_id) {
86284e45 991 hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
0ba21762
TI		 992 codec->subsystem_id =
993 snd_hda_codec_read(codec, nid, 0,
994 AC_VERB_GET_SUBSYSTEM_ID, 0);
86284e45
TI		 995 }
996
bb6ac72f
TI		 997 /* power-up all before initialization */
998 hda_set_power_state(codec,
999 codec->afg ? codec->afg : codec->mfg,
1000 AC_PWRST_D0);
1001
6c1f45ea
TI		 1002 snd_hda_codec_proc_new(codec);
1003
6c1f45ea 1004 snd_hda_create_hwdep(codec);
6c1f45ea
TI		 1005
1006 sprintf(component, "HDA:%08x,%08x,%08x", codec->vendor_id,
1007 codec->subsystem_id, codec->revision_id);
1008 snd_component_add(codec->bus->card, component);
1009
1010 if (codecp)
1011 *codecp = codec;
1012 return 0;
3be14149
TI		 1013
1014 error:
1015 snd_hda_codec_free(codec);
1016 return err;
6c1f45ea 1017}
ff7a3267 1018EXPORT_SYMBOL_HDA(snd_hda_codec_new);
6c1f45ea
TI		 1019
1020int snd_hda_codec_configure(struct hda_codec *codec)
1021{
1022 int err;
1023
d5ad630b 1024 codec->preset = find_codec_preset(codec);
812a2cca 1025 if (!codec->vendor_name || !codec->chip_name) {
f44ac837
TI		 1026 err = get_codec_name(codec);
1027 if (err < 0)
1028 return err;
1029 }
43ea1d47 1030 /* audio codec should override the mixer name */
f44ac837 1031 if (codec->afg || !*codec->bus->card->mixername)
812a2cca
TI		 1032 snprintf(codec->bus->card->mixername,
1033 sizeof(codec->bus->card->mixername),
1034 "%s %s", codec->vendor_name, codec->chip_name);
1da177e4 1035
82467611 1036 if (is_generic_config(codec)) {
1da177e4 1037 err = snd_hda_parse_generic_codec(codec);
82467611
TI		 1038 goto patched;
1039 }
82467611
TI		 1040 if (codec->preset && codec->preset->patch) {
1041 err = codec->preset->patch(codec);
1042 goto patched;
1043 }
1044
1045 /* call the default parser */
82467611 1046 err = snd_hda_parse_generic_codec(codec);
35a1e0cc
TI		 1047 if (err < 0)
1048 printk(KERN_ERR "hda-codec: No codec parser is available\n");
82467611
TI		 1049
1050 patched:
6c1f45ea
TI		 1051 if (!err && codec->patch_ops.unsol_event)
1052 err = init_unsol_queue(codec->bus);
1053 return err;
1da177e4 1054}
a1e21c90 1055EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
1da177e4
LT		 1056
1057/**
1058 * snd_hda_codec_setup_stream - set up the codec for streaming
1059 * @codec: the CODEC to set up
1060 * @nid: the NID to set up
1061 * @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
1062 * @channel_id: channel id to pass, zero based.
1063 * @format: stream format.
1064 */
0ba21762
TI		 1065void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
1066 u32 stream_tag,
1da177e4
LT		 1067 int channel_id, int format)
1068{
0ba21762 1069 if (!nid)
d21b37ea
TI		 1070 return;
1071
0ba21762
TI		 1072 snd_printdd("hda_codec_setup_stream: "
1073 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
1da177e4
LT		 1074 nid, stream_tag, channel_id, format);
1075 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
1076 (stream_tag << 4) | channel_id);
1077 msleep(1);
1078 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
1079}
ff7a3267 1080EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
1da177e4 1081
888afa15
TI		 1082void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
1083{
1084 if (!nid)
1085 return;
1086
1087 snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
1088 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
1089#if 0 /* keep the format */
1090 msleep(1);
1091 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
1092#endif
1093}
ff7a3267 1094EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
888afa15 1095
1da177e4
LT		 1096/*
1097 * amp access functions
1098 */
1099
4a19faee
TI		 1100/* FIXME: more better hash key? */
1101#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
1327a32b 1102#define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
92c7c8a7
TI		 1103#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
1104#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
1da177e4 1105#define INFO_AMP_CAPS (1<<0)
4a19faee 1106#define INFO_AMP_VOL(ch) (1 << (1 + (ch)))
1da177e4
LT		 1107
1108/* initialize the hash table */
1289e9e8 1109static void /*__devinit*/ init_hda_cache(struct hda_cache_rec *cache,
01751f54
TI		 1110 unsigned int record_size)
1111{
1112 memset(cache, 0, sizeof(*cache));
1113 memset(cache->hash, 0xff, sizeof(cache->hash));
603c4019 1114 snd_array_init(&cache->buf, record_size, 64);
01751f54
TI		 1115}
1116
1fcaee6e 1117static void free_hda_cache(struct hda_cache_rec *cache)
1da177e4 1118{
603c4019 1119 snd_array_free(&cache->buf);
1da177e4
LT		 1120}
1121
1122/* query the hash. allocate an entry if not found. */
01751f54
TI		 1123static struct hda_cache_head *get_alloc_hash(struct hda_cache_rec *cache,
1124 u32 key)
1da177e4 1125{
01751f54
TI		 1126 u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
1127 u16 cur = cache->hash[idx];
1128 struct hda_cache_head *info;
1da177e4
LT		 1129
1130 while (cur != 0xffff) {
f43aa025 1131 info = snd_array_elem(&cache->buf, cur);
1da177e4
LT		 1132 if (info->key == key)
1133 return info;
1134 cur = info->next;
1135 }
1136
1137 /* add a new hash entry */
603c4019 1138 info = snd_array_new(&cache->buf);
c217429b
TI		 1139 if (!info)
1140 return NULL;
f43aa025 1141 cur = snd_array_index(&cache->buf, info);
1da177e4 1142 info->key = key;
01751f54
TI		 1143 info->val = 0;
1144 info->next = cache->hash[idx];
1145 cache->hash[idx] = cur;
1da177e4
LT		 1146
1147 return info;
1148}
1149
01751f54
TI		 1150/* query and allocate an amp hash entry */
1151static inline struct hda_amp_info *
1152get_alloc_amp_hash(struct hda_codec *codec, u32 key)
1153{
1154 return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
1155}
1156
1da177e4
LT		 1157/*
1158 * query AMP capabilities for the given widget and direction
1159 */
09a99959 1160u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
1da177e4 1161{
0ba21762 1162 struct hda_amp_info *info;
1da177e4 1163
0ba21762
TI		 1164 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, 0));
1165 if (!info)
1da177e4 1166 return 0;
01751f54 1167 if (!(info->head.val & INFO_AMP_CAPS)) {
0ba21762 1168 if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
1da177e4 1169 nid = codec->afg;
0ba21762
TI		 1170 info->amp_caps = snd_hda_param_read(codec, nid,
1171 direction == HDA_OUTPUT ?
1172 AC_PAR_AMP_OUT_CAP :
1173 AC_PAR_AMP_IN_CAP);
b75e53f0 1174 if (info->amp_caps)
01751f54 1175 info->head.val |= INFO_AMP_CAPS;
1da177e4
LT		 1176 }
1177 return info->amp_caps;
1178}
ff7a3267 1179EXPORT_SYMBOL_HDA(query_amp_caps);
1da177e4 1180
897cc188
TI		 1181int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
1182 unsigned int caps)
1183{
1184 struct hda_amp_info *info;
1185
1186 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, dir, 0));
1187 if (!info)
1188 return -EINVAL;
1189 info->amp_caps = caps;
01751f54 1190 info->head.val |= INFO_AMP_CAPS;
897cc188
TI		 1191 return 0;
1192}
ff7a3267 1193EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
1327a32b 1194
92c7c8a7
TI		 1195static unsigned int
1196query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
1197 unsigned int (*func)(struct hda_codec *, hda_nid_t))
1327a32b
TI		 1198{
1199 struct hda_amp_info *info;
1200
92c7c8a7 1201 info = get_alloc_amp_hash(codec, key);
1327a32b
TI		 1202 if (!info)
1203 return 0;
1204 if (!info->head.val) {
1327a32b 1205 info->head.val |= INFO_AMP_CAPS;
92c7c8a7 1206 info->amp_caps = func(codec, nid);
1327a32b
TI		 1207 }
1208 return info->amp_caps;
1209}
92c7c8a7
TI		 1210
1211static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
1212{
1213 return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
1214}
1215
1216u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
1217{
1218 return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
1219 read_pin_cap);
1220}
1327a32b 1221EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
897cc188 1222
1da177e4
LT		 1223/*
1224 * read the current volume to info
4a19faee 1225 * if the cache exists, read the cache value.
1da177e4 1226 */
0ba21762
TI		 1227static unsigned int get_vol_mute(struct hda_codec *codec,
1228 struct hda_amp_info *info, hda_nid_t nid,
1229 int ch, int direction, int index)
1da177e4
LT		 1230{
1231 u32 val, parm;
1232
01751f54 1233 if (info->head.val & INFO_AMP_VOL(ch))
4a19faee 1234 return info->vol[ch];
1da177e4
LT		 1235
1236 parm = ch ? AC_AMP_GET_RIGHT : AC_AMP_GET_LEFT;
1237 parm |= direction == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
1238 parm |= index;
0ba21762
TI		 1239 val = snd_hda_codec_read(codec, nid, 0,
1240 AC_VERB_GET_AMP_GAIN_MUTE, parm);
1da177e4 1241 info->vol[ch] = val & 0xff;
01751f54 1242 info->head.val |= INFO_AMP_VOL(ch);
4a19faee 1243 return info->vol[ch];
1da177e4
LT		 1244}
1245
1246/*
4a19faee 1247 * write the current volume in info to the h/w and update the cache
1da177e4 1248 */
4a19faee 1249static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
0ba21762
TI		 1250 hda_nid_t nid, int ch, int direction, int index,
1251 int val)
1da177e4
LT		 1252{
1253 u32 parm;
1254
1255 parm = ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT;
1256 parm |= direction == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT;
1257 parm |= index << AC_AMP_SET_INDEX_SHIFT;
1258 parm |= val;
1259 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, parm);
4a19faee 1260 info->vol[ch] = val;
1da177e4
LT		 1261}
1262
1263/*
4a19faee 1264 * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit.
1da177e4 1265 */
834be88d
TI		 1266int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
1267 int direction, int index)
1da177e4 1268{
0ba21762
TI		 1269 struct hda_amp_info *info;
1270 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, index));
1271 if (!info)
1da177e4 1272 return 0;
4a19faee 1273 return get_vol_mute(codec, info, nid, ch, direction, index);
1da177e4 1274}
ff7a3267 1275EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
1da177e4 1276
4a19faee
TI		 1277/*
1278 * update the AMP value, mask = bit mask to set, val = the value
1279 */
834be88d
TI		 1280int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
1281 int direction, int idx, int mask, int val)
1da177e4 1282{
0ba21762 1283 struct hda_amp_info *info;
4a19faee 1284
0ba21762
TI		 1285 info = get_alloc_amp_hash(codec, HDA_HASH_KEY(nid, direction, idx));
1286 if (!info)
1da177e4 1287 return 0;
4a19faee
TI		 1288 val &= mask;
1289 val |= get_vol_mute(codec, info, nid, ch, direction, idx) & ~mask;
82beb8fd 1290 if (info->vol[ch] == val)
1da177e4 1291 return 0;
4a19faee 1292 put_vol_mute(codec, info, nid, ch, direction, idx, val);
1da177e4
LT		 1293 return 1;
1294}
ff7a3267 1295EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
1da177e4 1296
47fd830a
TI		 1297/*
1298 * update the AMP stereo with the same mask and value
1299 */
1300int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
1301 int direction, int idx, int mask, int val)
1302{
1303 int ch, ret = 0;
1304 for (ch = 0; ch < 2; ch++)
1305 ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
1306 idx, mask, val);
1307 return ret;
1308}
ff7a3267 1309EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
47fd830a 1310
cb53c626 1311#ifdef SND_HDA_NEEDS_RESUME
b3ac5636
TI		 1312/* resume the all amp commands from the cache */
1313void snd_hda_codec_resume_amp(struct hda_codec *codec)
1314{
603c4019 1315 struct hda_amp_info *buffer = codec->amp_cache.buf.list;
b3ac5636
TI		 1316 int i;
1317
603c4019 1318 for (i = 0; i < codec->amp_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 1319 u32 key = buffer->head.key;
1320 hda_nid_t nid;
1321 unsigned int idx, dir, ch;
1322 if (!key)
1323 continue;
1324 nid = key & 0xff;
1325 idx = (key >> 16) & 0xff;
1326 dir = (key >> 24) & 0xff;
1327 for (ch = 0; ch < 2; ch++) {
1328 if (!(buffer->head.val & INFO_AMP_VOL(ch)))
1329 continue;
1330 put_vol_mute(codec, buffer, nid, ch, dir, idx,
1331 buffer->vol[ch]);
1332 }
1333 }
1334}
ff7a3267 1335EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
cb53c626 1336#endif /* SND_HDA_NEEDS_RESUME */
1da177e4 1337
1da177e4 1338/* volume */
0ba21762
TI		 1339int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
1340 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1341{
1342 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1343 u16 nid = get_amp_nid(kcontrol);
1344 u8 chs = get_amp_channels(kcontrol);
1345 int dir = get_amp_direction(kcontrol);
29fdbec2 1346 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1347 u32 caps;
1348
1349 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 1350 /* num steps */
1351 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1352 if (!caps) {
1353 printk(KERN_WARNING "hda_codec: "
9c8f2abd
TI		 1354 "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
1355 kcontrol->id.name);
1da177e4
LT		 1356 return -EINVAL;
1357 }
29fdbec2
TI		 1358 if (ofs < caps)
1359 caps -= ofs;
1da177e4
LT		 1360 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1361 uinfo->count = chs == 3 ? 2 : 1;
1362 uinfo->value.integer.min = 0;
1363 uinfo->value.integer.max = caps;
1364 return 0;
1365}
ff7a3267 1366EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
1da177e4 1367
29fdbec2
TI		 1368
1369static inline unsigned int
1370read_amp_value(struct hda_codec *codec, hda_nid_t nid,
1371 int ch, int dir, int idx, unsigned int ofs)
1372{
1373 unsigned int val;
1374 val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
1375 val &= HDA_AMP_VOLMASK;
1376 if (val >= ofs)
1377 val -= ofs;
1378 else
1379 val = 0;
1380 return val;
1381}
1382
1383static inline int
1384update_amp_value(struct hda_codec *codec, hda_nid_t nid,
1385 int ch, int dir, int idx, unsigned int ofs,
1386 unsigned int val)
1387{
1388 if (val > 0)
1389 val += ofs;
1390 return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
1391 HDA_AMP_VOLMASK, val);
1392}
1393
0ba21762
TI		 1394int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
1395 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1396{
1397 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1398 hda_nid_t nid = get_amp_nid(kcontrol);
1399 int chs = get_amp_channels(kcontrol);
1400 int dir = get_amp_direction(kcontrol);
1401 int idx = get_amp_index(kcontrol);
29fdbec2 1402 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1403 long *valp = ucontrol->value.integer.value;
1404
1405 if (chs & 1)
29fdbec2 1406 *valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
1da177e4 1407 if (chs & 2)
29fdbec2 1408 *valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
1da177e4
LT		 1409 return 0;
1410}
ff7a3267 1411EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
1da177e4 1412
0ba21762
TI		 1413int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
1414 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1415{
1416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1417 hda_nid_t nid = get_amp_nid(kcontrol);
1418 int chs = get_amp_channels(kcontrol);
1419 int dir = get_amp_direction(kcontrol);
1420 int idx = get_amp_index(kcontrol);
29fdbec2 1421 unsigned int ofs = get_amp_offset(kcontrol);
1da177e4
LT		 1422 long *valp = ucontrol->value.integer.value;
1423 int change = 0;
1424
cb53c626 1425 snd_hda_power_up(codec);
b9f5a89c 1426 if (chs & 1) {
29fdbec2 1427 change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
b9f5a89c
NG		 1428 valp++;
1429 }
4a19faee 1430 if (chs & 2)
29fdbec2 1431 change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
cb53c626 1432 snd_hda_power_down(codec);
1da177e4
LT		 1433 return change;
1434}
ff7a3267 1435EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
1da177e4 1436
302e9c5a
JK		 1437int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1438 unsigned int size, unsigned int __user *_tlv)
1439{
1440 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1441 hda_nid_t nid = get_amp_nid(kcontrol);
1442 int dir = get_amp_direction(kcontrol);
29fdbec2 1443 unsigned int ofs = get_amp_offset(kcontrol);
302e9c5a
JK		 1444 u32 caps, val1, val2;
1445
1446 if (size < 4 * sizeof(unsigned int))
1447 return -ENOMEM;
1448 caps = query_amp_caps(codec, nid, dir);
0ba21762
TI		 1449 val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1450 val2 = (val2 + 1) * 25;
302e9c5a 1451 val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
29fdbec2 1452 val1 += ofs;
302e9c5a 1453 val1 = ((int)val1) * ((int)val2);
302e9c5a
JK		 1454 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
1455 return -EFAULT;
1456 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
1457 return -EFAULT;
1458 if (put_user(val1, _tlv + 2))
1459 return -EFAULT;
1460 if (put_user(val2, _tlv + 3))
1461 return -EFAULT;
1462 return 0;
1463}
ff7a3267 1464EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
302e9c5a 1465
2134ea4f
TI		 1466/*
1467 * set (static) TLV for virtual master volume; recalculated as max 0dB
1468 */
1469void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
1470 unsigned int *tlv)
1471{
1472 u32 caps;
1473 int nums, step;
1474
1475 caps = query_amp_caps(codec, nid, dir);
1476 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1477 step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
1478 step = (step + 1) * 25;
1479 tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
1480 tlv[1] = 2 * sizeof(unsigned int);
1481 tlv[2] = -nums * step;
1482 tlv[3] = step;
1483}
ff7a3267 1484EXPORT_SYMBOL_HDA(snd_hda_set_vmaster_tlv);
2134ea4f
TI		 1485
1486/* find a mixer control element with the given name */
09f99701
TI		 1487static struct snd_kcontrol *
1488_snd_hda_find_mixer_ctl(struct hda_codec *codec,
1489 const char *name, int idx)
2134ea4f
TI		 1490{
1491 struct snd_ctl_elem_id id;
1492 memset(&id, 0, sizeof(id));
1493 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
09f99701 1494 id.index = idx;
18cb7109
TI		 1495 if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
1496 return NULL;
2134ea4f
TI		 1497 strcpy(id.name, name);
1498 return snd_ctl_find_id(codec->bus->card, &id);
1499}
1500
09f99701
TI		 1501struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
1502 const char *name)
1503{
1504 return _snd_hda_find_mixer_ctl(codec, name, 0);
1505}
ff7a3267 1506EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
09f99701 1507
d13bd412
TI		 1508/* Add a control element and assign to the codec */
1509int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
1510{
1511 int err;
1512 struct snd_kcontrol **knewp;
1513
1514 err = snd_ctl_add(codec->bus->card, kctl);
1515 if (err < 0)
1516 return err;
1517 knewp = snd_array_new(&codec->mixers);
1518 if (!knewp)
1519 return -ENOMEM;
1520 *knewp = kctl;
1521 return 0;
1522}
ff7a3267 1523EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
d13bd412
TI		 1524
1525/* Clear all controls assigned to the given codec */
1526void snd_hda_ctls_clear(struct hda_codec *codec)
1527{
1528 int i;
1529 struct snd_kcontrol **kctls = codec->mixers.list;
1530 for (i = 0; i < codec->mixers.used; i++)
1531 snd_ctl_remove(codec->bus->card, kctls[i]);
1532 snd_array_free(&codec->mixers);
1533}
1534
a65d629c
TI		 1535/* pseudo device locking
1536 * toggle card->shutdown to allow/disallow the device access (as a hack)
1537 */
1538static int hda_lock_devices(struct snd_card *card)
6c1f45ea 1539{
a65d629c
TI		 1540 spin_lock(&card->files_lock);
1541 if (card->shutdown) {
1542 spin_unlock(&card->files_lock);
1543 return -EINVAL;
1544 }
1545 card->shutdown = 1;
1546 spin_unlock(&card->files_lock);
1547 return 0;
1548}
1549
1550static void hda_unlock_devices(struct snd_card *card)
1551{
1552 spin_lock(&card->files_lock);
1553 card->shutdown = 0;
1554 spin_unlock(&card->files_lock);
1555}
1556
1557int snd_hda_codec_reset(struct hda_codec *codec)
1558{
1559 struct snd_card *card = codec->bus->card;
1560 int i, pcm;
1561
1562 if (hda_lock_devices(card) < 0)
1563 return -EBUSY;
1564 /* check whether the codec isn't used by any mixer or PCM streams */
1565 if (!list_empty(&card->ctl_files)) {
1566 hda_unlock_devices(card);
1567 return -EBUSY;
1568 }
1569 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1570 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1571 if (!cpcm->pcm)
1572 continue;
1573 if (cpcm->pcm->streams[0].substream_opened ||
1574 cpcm->pcm->streams[1].substream_opened) {
1575 hda_unlock_devices(card);
1576 return -EBUSY;
1577 }
1578 }
1579
1580 /* OK, let it free */
6c1f45ea
TI		 1581
1582#ifdef CONFIG_SND_HDA_POWER_SAVE
1583 cancel_delayed_work(&codec->power_work);
6acaed38 1584 flush_workqueue(codec->bus->workq);
6c1f45ea
TI		 1585#endif
1586 snd_hda_ctls_clear(codec);
1587 /* relase PCMs */
1588 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 1589 if (codec->pcm_info[i].pcm) {
a65d629c 1590 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4
TI		 1591 clear_bit(codec->pcm_info[i].device,
1592 codec->bus->pcm_dev_bits);
1593 }
6c1f45ea
TI		 1594 }
1595 if (codec->patch_ops.free)
1596 codec->patch_ops.free(codec);
56d17712 1597 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 1598 codec->spec = NULL;
1599 free_hda_cache(&codec->amp_cache);
1600 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 1601 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1602 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 1603 /* free only driver_pins so that init_pins + user_pins are restored */
1604 snd_array_free(&codec->driver_pins);
3be14149 1605 restore_pincfgs(codec);
6c1f45ea
TI		 1606 codec->num_pcms = 0;
1607 codec->pcm_info = NULL;
1608 codec->preset = NULL;
d1f1af2d
TI		 1609 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1610 codec->slave_dig_outs = NULL;
1611 codec->spdif_status_reset = 0;
1289e9e8
TI		 1612 module_put(codec->owner);
1613 codec->owner = NULL;
a65d629c
TI		 1614
1615 /* allow device access again */
1616 hda_unlock_devices(card);
1617 return 0;
6c1f45ea
TI		 1618}
1619
2134ea4f
TI		 1620/* create a virtual master control and add slaves */
1621int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1622 unsigned int *tlv, const char **slaves)
1623{
1624 struct snd_kcontrol *kctl;
1625 const char **s;
1626 int err;
1627
2f085549
TI		 1628 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1629 ;
1630 if (!*s) {
1631 snd_printdd("No slave found for %s\n", name);
1632 return 0;
1633 }
2134ea4f
TI		 1634 kctl = snd_ctl_make_virtual_master(name, tlv);
1635 if (!kctl)
1636 return -ENOMEM;
d13bd412 1637 err = snd_hda_ctl_add(codec, kctl);
2134ea4f
TI		 1638 if (err < 0)
1639 return err;
1640
1641 for (s = slaves; *s; s++) {
1642 struct snd_kcontrol *sctl;
7a411ee0
TI		 1643 int i = 0;
1644 for (;;) {
1645 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1646 if (!sctl) {
1647 if (!i)
1648 snd_printdd("Cannot find slave %s, "
1649 "skipped\n", *s);
1650 break;
1651 }
1652 err = snd_ctl_add_slave(kctl, sctl);
1653 if (err < 0)
1654 return err;
1655 i++;
2134ea4f 1656 }
2134ea4f
TI		 1657 }
1658 return 0;
1659}
ff7a3267 1660EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2134ea4f 1661
1da177e4 1662/* switch */
0ba21762
TI		 1663int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1664 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1665{
1666 int chs = get_amp_channels(kcontrol);
1667
1668 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1669 uinfo->count = chs == 3 ? 2 : 1;
1670 uinfo->value.integer.min = 0;
1671 uinfo->value.integer.max = 1;
1672 return 0;
1673}
ff7a3267 1674EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 1675
0ba21762
TI		 1676int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1677 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1678{
1679 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1680 hda_nid_t nid = get_amp_nid(kcontrol);
1681 int chs = get_amp_channels(kcontrol);
1682 int dir = get_amp_direction(kcontrol);
1683 int idx = get_amp_index(kcontrol);
1684 long *valp = ucontrol->value.integer.value;
1685
1686 if (chs & 1)
0ba21762 1687 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 1688 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 1689 if (chs & 2)
0ba21762 1690 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 1691 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 1692 return 0;
1693}
ff7a3267 1694EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 1695
0ba21762
TI		 1696int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1697 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1698{
1699 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1700 hda_nid_t nid = get_amp_nid(kcontrol);
1701 int chs = get_amp_channels(kcontrol);
1702 int dir = get_amp_direction(kcontrol);
1703 int idx = get_amp_index(kcontrol);
1da177e4
LT		 1704 long *valp = ucontrol->value.integer.value;
1705 int change = 0;
1706
cb53c626 1707 snd_hda_power_up(codec);
b9f5a89c 1708 if (chs & 1) {
4a19faee 1709 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 1710 HDA_AMP_MUTE,
1711 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 1712 valp++;
1713 }
4a19faee
TI		 1714 if (chs & 2)
1715 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 1716 HDA_AMP_MUTE,
1717 *valp ? 0 : HDA_AMP_MUTE);
cb53c626
TI		 1718#ifdef CONFIG_SND_HDA_POWER_SAVE
1719 if (codec->patch_ops.check_power_status)
1720 codec->patch_ops.check_power_status(codec, nid);
1721#endif
1722 snd_hda_power_down(codec);
1da177e4
LT		 1723 return change;
1724}
ff7a3267 1725EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 1726
985be54b
TI		 1727/*
1728 * bound volume controls
1729 *
1730 * bind multiple volumes (# indices, from 0)
1731 */
1732
1733#define AMP_VAL_IDX_SHIFT 19
1734#define AMP_VAL_IDX_MASK (0x0f<<19)
1735
0ba21762
TI		 1736int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1737 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1738{
1739 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1740 unsigned long pval;
1741 int err;
1742
5a9e02e9 1743 mutex_lock(&codec->control_mutex);
985be54b
TI		 1744 pval = kcontrol->private_value;
1745 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1746 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1747 kcontrol->private_value = pval;
5a9e02e9 1748 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1749 return err;
1750}
ff7a3267 1751EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 1752
0ba21762
TI		 1753int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1755{
1756 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1757 unsigned long pval;
1758 int i, indices, err = 0, change = 0;
1759
5a9e02e9 1760 mutex_lock(&codec->control_mutex);
985be54b
TI		 1761 pval = kcontrol->private_value;
1762 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1763 for (i = 0; i < indices; i++) {
0ba21762
TI		 1764 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1765 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 1766 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1767 if (err < 0)
1768 break;
1769 change |= err;
1770 }
1771 kcontrol->private_value = pval;
5a9e02e9 1772 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1773 return err < 0 ? err : change;
1774}
ff7a3267 1775EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 1776
532d5381
TI		 1777/*
1778 * generic bound volume/swtich controls
1779 */
1780int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1781 struct snd_ctl_elem_info *uinfo)
1782{
1783 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1784 struct hda_bind_ctls *c;
1785 int err;
1786
5a9e02e9 1787 mutex_lock(&codec->control_mutex);
14c65f98 1788 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1789 kcontrol->private_value = *c->values;
1790 err = c->ops->info(kcontrol, uinfo);
1791 kcontrol->private_value = (long)c;
5a9e02e9 1792 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1793 return err;
1794}
ff7a3267 1795EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381
TI		 1796
1797int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1798 struct snd_ctl_elem_value *ucontrol)
1799{
1800 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1801 struct hda_bind_ctls *c;
1802 int err;
1803
5a9e02e9 1804 mutex_lock(&codec->control_mutex);
14c65f98 1805 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1806 kcontrol->private_value = *c->values;
1807 err = c->ops->get(kcontrol, ucontrol);
1808 kcontrol->private_value = (long)c;
5a9e02e9 1809 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1810 return err;
1811}
ff7a3267 1812EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381
TI		 1813
1814int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1815 struct snd_ctl_elem_value *ucontrol)
1816{
1817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1818 struct hda_bind_ctls *c;
1819 unsigned long *vals;
1820 int err = 0, change = 0;
1821
5a9e02e9 1822 mutex_lock(&codec->control_mutex);
14c65f98 1823 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1824 for (vals = c->values; *vals; vals++) {
1825 kcontrol->private_value = *vals;
1826 err = c->ops->put(kcontrol, ucontrol);
1827 if (err < 0)
1828 break;
1829 change |= err;
1830 }
1831 kcontrol->private_value = (long)c;
5a9e02e9 1832 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1833 return err < 0 ? err : change;
1834}
ff7a3267 1835EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381
TI		 1836
1837int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1838 unsigned int size, unsigned int __user *tlv)
1839{
1840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1841 struct hda_bind_ctls *c;
1842 int err;
1843
5a9e02e9 1844 mutex_lock(&codec->control_mutex);
14c65f98 1845 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1846 kcontrol->private_value = *c->values;
1847 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1848 kcontrol->private_value = (long)c;
5a9e02e9 1849 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1850 return err;
1851}
ff7a3267 1852EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 1853
1854struct hda_ctl_ops snd_hda_bind_vol = {
1855 .info = snd_hda_mixer_amp_volume_info,
1856 .get = snd_hda_mixer_amp_volume_get,
1857 .put = snd_hda_mixer_amp_volume_put,
1858 .tlv = snd_hda_mixer_amp_tlv
1859};
ff7a3267 1860EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 1861
1862struct hda_ctl_ops snd_hda_bind_sw = {
1863 .info = snd_hda_mixer_amp_switch_info,
1864 .get = snd_hda_mixer_amp_switch_get,
1865 .put = snd_hda_mixer_amp_switch_put,
1866 .tlv = snd_hda_mixer_amp_tlv
1867};
ff7a3267 1868EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 1869
1da177e4
LT		 1870/*
1871 * SPDIF out controls
1872 */
1873
0ba21762
TI		 1874static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1875 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1876{
1877 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1878 uinfo->count = 1;
1879 return 0;
1880}
1881
0ba21762
TI		 1882static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1883 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1884{
1885 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1886 IEC958_AES0_NONAUDIO |
1887 IEC958_AES0_CON_EMPHASIS_5015 |
1888 IEC958_AES0_CON_NOT_COPYRIGHT;
1889 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1890 IEC958_AES1_CON_ORIGINAL;
1891 return 0;
1892}
1893
0ba21762
TI		 1894static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1895 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1896{
1897 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1898 IEC958_AES0_NONAUDIO |
1899 IEC958_AES0_PRO_EMPHASIS_5015;
1900 return 0;
1901}
1902
0ba21762
TI		 1903static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1904 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1905{
1906 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1907
1908 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1909 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1910 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1911 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1912
1913 return 0;
1914}
1915
1916/* convert from SPDIF status bits to HDA SPDIF bits
1917 * bit 0 (DigEn) is always set zero (to be filled later)
1918 */
1919static unsigned short convert_from_spdif_status(unsigned int sbits)
1920{
1921 unsigned short val = 0;
1922
1923 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 1924 val |= AC_DIG1_PROFESSIONAL;
1da177e4 1925 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 1926 val |= AC_DIG1_NONAUDIO;
1da177e4 1927 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 1928 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1929 IEC958_AES0_PRO_EMPHASIS_5015)
1930 val |= AC_DIG1_EMPHASIS;
1da177e4 1931 } else {
0ba21762
TI		 1932 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1933 IEC958_AES0_CON_EMPHASIS_5015)
1934 val |= AC_DIG1_EMPHASIS;
1935 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1936 val |= AC_DIG1_COPYRIGHT;
1da177e4 1937 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 1938 val |= AC_DIG1_LEVEL;
1da177e4
LT		 1939 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1940 }
1941 return val;
1942}
1943
1944/* convert to SPDIF status bits from HDA SPDIF bits
1945 */
1946static unsigned int convert_to_spdif_status(unsigned short val)
1947{
1948 unsigned int sbits = 0;
1949
0ba21762 1950 if (val & AC_DIG1_NONAUDIO)
1da177e4 1951 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 1952 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 1953 sbits |= IEC958_AES0_PROFESSIONAL;
1954 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 1955 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 1956 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1957 } else {
0ba21762 1958 if (val & AC_DIG1_EMPHASIS)
1da177e4 1959 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 1960 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 1961 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 1962 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 1963 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1964 sbits |= val & (0x7f << 8);
1965 }
1966 return sbits;
1967}
1968
2f72853c
TI		 1969/* set digital convert verbs both for the given NID and its slaves */
1970static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
1971 int verb, int val)
1972{
1973 hda_nid_t *d;
1974
9e976976 1975 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 1976 d = codec->slave_dig_outs;
1977 if (!d)
1978 return;
1979 for (; *d; d++)
9e976976 1980 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 1981}
1982
1983static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
1984 int dig1, int dig2)
1985{
1986 if (dig1 != -1)
1987 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
1988 if (dig2 != -1)
1989 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
1990}
1991
0ba21762
TI		 1992static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
1993 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1994{
1995 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1996 hda_nid_t nid = kcontrol->private_value;
1997 unsigned short val;
1998 int change;
1999
62932df8 2000 mutex_lock(&codec->spdif_mutex);
1da177e4
LT		 2001 codec->spdif_status = ucontrol->value.iec958.status[0] |
2002 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2003 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2004 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2005 val = convert_from_spdif_status(codec->spdif_status);
2006 val |= codec->spdif_ctls & 1;
2007 change = codec->spdif_ctls != val;
2008 codec->spdif_ctls = val;
2009
2f72853c
TI		 2010 if (change)
2011 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1da177e4 2012
62932df8 2013 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2014 return change;
2015}
2016
a5ce8890 2017#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 2018
0ba21762
TI		 2019static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2020 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2021{
2022 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2023
0ba21762 2024 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1da177e4
LT		 2025 return 0;
2026}
2027
0ba21762
TI		 2028static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2029 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2030{
2031 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2032 hda_nid_t nid = kcontrol->private_value;
2033 unsigned short val;
2034 int change;
2035
62932df8 2036 mutex_lock(&codec->spdif_mutex);
0ba21762 2037 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1da177e4 2038 if (ucontrol->value.integer.value[0])
0ba21762 2039 val |= AC_DIG1_ENABLE;
1da177e4 2040 change = codec->spdif_ctls != val;
82beb8fd 2041 if (change) {
1da177e4 2042 codec->spdif_ctls = val;
2f72853c 2043 set_dig_out_convert(codec, nid, val & 0xff, -1);
0ba21762
TI		 2044 /* unmute amp switch (if any) */
2045 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
47fd830a
TI		 2046 (val & AC_DIG1_ENABLE))
2047 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2048 HDA_AMP_MUTE, 0);
1da177e4 2049 }
62932df8 2050 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2051 return change;
2052}
2053
c8b6bf9b 2054static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2055 {
2056 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2057 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2058 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2059 .info = snd_hda_spdif_mask_info,
2060 .get = snd_hda_spdif_cmask_get,
2061 },
2062 {
2063 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2064 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2065 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2066 .info = snd_hda_spdif_mask_info,
2067 .get = snd_hda_spdif_pmask_get,
2068 },
2069 {
2070 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2071 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2072 .info = snd_hda_spdif_mask_info,
2073 .get = snd_hda_spdif_default_get,
2074 .put = snd_hda_spdif_default_put,
2075 },
2076 {
2077 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2078 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2079 .info = snd_hda_spdif_out_switch_info,
2080 .get = snd_hda_spdif_out_switch_get,
2081 .put = snd_hda_spdif_out_switch_put,
2082 },
2083 { } /* end */
2084};
2085
09f99701
TI		 2086#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2087
1da177e4
LT		 2088/**
2089 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2090 * @codec: the HDA codec
2091 * @nid: audio out widget NID
2092 *
2093 * Creates controls related with the SPDIF output.
2094 * Called from each patch supporting the SPDIF out.
2095 *
2096 * Returns 0 if successful, or a negative error code.
2097 */
12f288bf 2098int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2099{
2100 int err;
c8b6bf9b
TI		 2101 struct snd_kcontrol *kctl;
2102 struct snd_kcontrol_new *dig_mix;
09f99701 2103 int idx;
1da177e4 2104
09f99701
TI		 2105 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2106 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2107 idx))
2108 break;
2109 }
2110 if (idx >= SPDIF_MAX_IDX) {
2111 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2112 return -EBUSY;
2113 }
1da177e4
LT		 2114 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2115 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 2116 if (!kctl)
2117 return -ENOMEM;
09f99701 2118 kctl->id.index = idx;
1da177e4 2119 kctl->private_value = nid;
d13bd412 2120 err = snd_hda_ctl_add(codec, kctl);
0ba21762 2121 if (err < 0)
1da177e4
LT		 2122 return err;
2123 }
0ba21762 2124 codec->spdif_ctls =
3982d17e
AP		 2125 snd_hda_codec_read(codec, nid, 0,
2126 AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2127 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2128 return 0;
2129}
ff7a3267 2130EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 2131
9a08160b
TI		 2132/*
2133 * SPDIF sharing with analog output
2134 */
2135static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2136 struct snd_ctl_elem_value *ucontrol)
2137{
2138 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2139 ucontrol->value.integer.value[0] = mout->share_spdif;
2140 return 0;
2141}
2142
2143static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2144 struct snd_ctl_elem_value *ucontrol)
2145{
2146 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2147 mout->share_spdif = !!ucontrol->value.integer.value[0];
2148 return 0;
2149}
2150
2151static struct snd_kcontrol_new spdif_share_sw = {
2152 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2153 .name = "IEC958 Default PCM Playback Switch",
2154 .info = snd_ctl_boolean_mono_info,
2155 .get = spdif_share_sw_get,
2156 .put = spdif_share_sw_put,
2157};
2158
2159int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2160 struct hda_multi_out *mout)
2161{
2162 if (!mout->dig_out_nid)
2163 return 0;
2164 /* ATTENTION: here mout is passed as private_data, instead of codec */
d13bd412 2165 return snd_hda_ctl_add(codec,
9a08160b
TI		 2166 snd_ctl_new1(&spdif_share_sw, mout));
2167}
ff7a3267 2168EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 2169
1da177e4
LT		 2170/*
2171 * SPDIF input
2172 */
2173
2174#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2175
0ba21762
TI		 2176static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2177 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2178{
2179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2180
2181 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2182 return 0;
2183}
2184
0ba21762
TI		 2185static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2186 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2187{
2188 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2189 hda_nid_t nid = kcontrol->private_value;
2190 unsigned int val = !!ucontrol->value.integer.value[0];
2191 int change;
2192
62932df8 2193 mutex_lock(&codec->spdif_mutex);
1da177e4 2194 change = codec->spdif_in_enable != val;
82beb8fd 2195 if (change) {
1da177e4 2196 codec->spdif_in_enable = val;
82beb8fd
TI		 2197 snd_hda_codec_write_cache(codec, nid, 0,
2198 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 2199 }
62932df8 2200 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2201 return change;
2202}
2203
0ba21762
TI		 2204static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2205 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2206{
2207 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2208 hda_nid_t nid = kcontrol->private_value;
2209 unsigned short val;
2210 unsigned int sbits;
2211
3982d17e 2212 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2213 sbits = convert_to_spdif_status(val);
2214 ucontrol->value.iec958.status[0] = sbits;
2215 ucontrol->value.iec958.status[1] = sbits >> 8;
2216 ucontrol->value.iec958.status[2] = sbits >> 16;
2217 ucontrol->value.iec958.status[3] = sbits >> 24;
2218 return 0;
2219}
2220
c8b6bf9b 2221static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 2222 {
2223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2224 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2225 .info = snd_hda_spdif_in_switch_info,
2226 .get = snd_hda_spdif_in_switch_get,
2227 .put = snd_hda_spdif_in_switch_put,
2228 },
2229 {
2230 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2231 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2232 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2233 .info = snd_hda_spdif_mask_info,
2234 .get = snd_hda_spdif_in_status_get,
2235 },
2236 { } /* end */
2237};
2238
2239/**
2240 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2241 * @codec: the HDA codec
2242 * @nid: audio in widget NID
2243 *
2244 * Creates controls related with the SPDIF input.
2245 * Called from each patch supporting the SPDIF in.
2246 *
2247 * Returns 0 if successful, or a negative error code.
2248 */
12f288bf 2249int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2250{
2251 int err;
c8b6bf9b
TI		 2252 struct snd_kcontrol *kctl;
2253 struct snd_kcontrol_new *dig_mix;
09f99701 2254 int idx;
1da177e4 2255
09f99701
TI		 2256 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2257 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2258 idx))
2259 break;
2260 }
2261 if (idx >= SPDIF_MAX_IDX) {
2262 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2263 return -EBUSY;
2264 }
1da177e4
LT		 2265 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2266 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 2267 if (!kctl)
2268 return -ENOMEM;
1da177e4 2269 kctl->private_value = nid;
d13bd412 2270 err = snd_hda_ctl_add(codec, kctl);
0ba21762 2271 if (err < 0)
1da177e4
LT		 2272 return err;
2273 }
0ba21762 2274 codec->spdif_in_enable =
3982d17e
AP		 2275 snd_hda_codec_read(codec, nid, 0,
2276 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 2277 AC_DIG1_ENABLE;
1da177e4
LT		 2278 return 0;
2279}
ff7a3267 2280EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 2281
cb53c626 2282#ifdef SND_HDA_NEEDS_RESUME
82beb8fd
TI		 2283/*
2284 * command cache
2285 */
1da177e4 2286
b3ac5636
TI		 2287/* build a 32bit cache key with the widget id and the command parameter */
2288#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2289#define get_cmd_cache_nid(key) ((key) & 0xff)
2290#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2291
2292/**
2293 * snd_hda_codec_write_cache - send a single command with caching
2294 * @codec: the HDA codec
2295 * @nid: NID to send the command
2296 * @direct: direct flag
2297 * @verb: the verb to send
2298 * @parm: the parameter for the verb
2299 *
2300 * Send a single command without waiting for response.
2301 *
2302 * Returns 0 if successful, or a negative error code.
2303 */
2304int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2305 int direct, unsigned int verb, unsigned int parm)
2306{
aa2936f5
TI		 2307 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2308 struct hda_cache_head *c;
2309 u32 key;
33fa35ed 2310
aa2936f5
TI		 2311 if (err < 0)
2312 return err;
2313 /* parm may contain the verb stuff for get/set amp */
2314 verb = verb | (parm >> 8);
2315 parm &= 0xff;
2316 key = build_cmd_cache_key(nid, verb);
2317 mutex_lock(&codec->bus->cmd_mutex);
2318 c = get_alloc_hash(&codec->cmd_cache, key);
2319 if (c)
2320 c->val = parm;
2321 mutex_unlock(&codec->bus->cmd_mutex);
2322 return 0;
b3ac5636 2323}
ff7a3267 2324EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636
TI		 2325
2326/* resume the all commands from the cache */
2327void snd_hda_codec_resume_cache(struct hda_codec *codec)
2328{
603c4019 2329 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 2330 int i;
2331
603c4019 2332 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 2333 u32 key = buffer->key;
2334 if (!key)
2335 continue;
2336 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2337 get_cmd_cache_cmd(key), buffer->val);
2338 }
2339}
ff7a3267 2340EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 2341
2342/**
2343 * snd_hda_sequence_write_cache - sequence writes with caching
2344 * @codec: the HDA codec
2345 * @seq: VERB array to send
2346 *
2347 * Send the commands sequentially from the given array.
2348 * Thte commands are recorded on cache for power-save and resume.
2349 * The array must be terminated with NID=0.
2350 */
2351void snd_hda_sequence_write_cache(struct hda_codec *codec,
2352 const struct hda_verb *seq)
2353{
2354 for (; seq->nid; seq++)
2355 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2356 seq->param);
2357}
ff7a3267 2358EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
cb53c626 2359#endif /* SND_HDA_NEEDS_RESUME */
b3ac5636 2360
54d17403
TI		 2361/*
2362 * set power state of the codec
2363 */
2364static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2365 unsigned int power_state)
2366{
cb53c626
TI		 2367 hda_nid_t nid;
2368 int i;
54d17403 2369
05ff7e11
TI		 2370 /* this delay seems necessary to avoid click noise at power-down */
2371 if (power_state == AC_PWRST_D3)
2372 msleep(100);
2373 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
54d17403 2374 power_state);
05ff7e11
TI		 2375 /* partial workaround for "azx_get_response timeout" */
2376 if (power_state == AC_PWRST_D0)
2377 msleep(10);
54d17403 2378
cb53c626
TI		 2379 nid = codec->start_nid;
2380 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d
TI		 2381 unsigned int wcaps = get_wcaps(codec, nid);
2382 if (wcaps & AC_WCAP_POWER) {
2383 unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
2384 AC_WCAP_TYPE_SHIFT;
a3b48c88
TI		 2385 if (power_state == AC_PWRST_D3 &&
2386 wid_type == AC_WID_PIN) {
7eba5c9d
TI		 2387 unsigned int pincap;
2388 /*
2389 * don't power down the widget if it controls
2390 * eapd and EAPD_BTLENABLE is set.
2391 */
14bafe32 2392 pincap = snd_hda_query_pin_caps(codec, nid);
7eba5c9d
TI		 2393 if (pincap & AC_PINCAP_EAPD) {
2394 int eapd = snd_hda_codec_read(codec,
2395 nid, 0,
2396 AC_VERB_GET_EAPD_BTLENABLE, 0);
2397 eapd &= 0x02;
a3b48c88 2398 if (eapd)
7eba5c9d
TI		 2399 continue;
2400 }
1194b5b7 2401 }
54d17403
TI		 2402 snd_hda_codec_write(codec, nid, 0,
2403 AC_VERB_SET_POWER_STATE,
2404 power_state);
1194b5b7 2405 }
54d17403
TI		 2406 }
2407
cb53c626
TI		 2408 if (power_state == AC_PWRST_D0) {
2409 unsigned long end_time;
2410 int state;
54d17403 2411 msleep(10);
cb53c626
TI		 2412 /* wait until the codec reachs to D0 */
2413 end_time = jiffies + msecs_to_jiffies(500);
2414 do {
2415 state = snd_hda_codec_read(codec, fg, 0,
2416 AC_VERB_GET_POWER_STATE, 0);
2417 if (state == power_state)
2418 break;
2419 msleep(1);
2420 } while (time_after_eq(end_time, jiffies));
2421 }
2422}
2423
11aeff08
TI		 2424#ifdef CONFIG_SND_HDA_HWDEP
2425/* execute additional init verbs */
2426static void hda_exec_init_verbs(struct hda_codec *codec)
2427{
2428 if (codec->init_verbs.list)
2429 snd_hda_sequence_write(codec, codec->init_verbs.list);
2430}
2431#else
2432static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2433#endif
2434
cb53c626
TI		 2435#ifdef SND_HDA_NEEDS_RESUME
2436/*
2437 * call suspend and power-down; used both from PM and power-save
2438 */
2439static void hda_call_codec_suspend(struct hda_codec *codec)
2440{
2441 if (codec->patch_ops.suspend)
2442 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2443 hda_set_power_state(codec,
2444 codec->afg ? codec->afg : codec->mfg,
2445 AC_PWRST_D3);
2446#ifdef CONFIG_SND_HDA_POWER_SAVE
2447 cancel_delayed_work(&codec->power_work);
95e99fda 2448 codec->power_on = 0;
a221e287 2449 codec->power_transition = 0;
cb53c626 2450#endif
54d17403
TI		 2451}
2452
cb53c626
TI		 2453/*
2454 * kick up codec; used both from PM and power-save
2455 */
2456static void hda_call_codec_resume(struct hda_codec *codec)
2457{
2458 hda_set_power_state(codec,
2459 codec->afg ? codec->afg : codec->mfg,
2460 AC_PWRST_D0);
3be14149 2461 restore_pincfgs(codec); /* restore all current pin configs */
11aeff08 2462 hda_exec_init_verbs(codec);
cb53c626
TI		 2463 if (codec->patch_ops.resume)
2464 codec->patch_ops.resume(codec);
2465 else {
9d99f312
TI		 2466 if (codec->patch_ops.init)
2467 codec->patch_ops.init(codec);
cb53c626
TI		 2468 snd_hda_codec_resume_amp(codec);
2469 snd_hda_codec_resume_cache(codec);
2470 }
2471}
2472#endif /* SND_HDA_NEEDS_RESUME */
2473
54d17403 2474
1da177e4
LT		 2475/**
2476 * snd_hda_build_controls - build mixer controls
2477 * @bus: the BUS
2478 *
2479 * Creates mixer controls for each codec included in the bus.
2480 *
2481 * Returns 0 if successful, otherwise a negative error code.
2482 */
1289e9e8 2483int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 2484{
0ba21762 2485 struct hda_codec *codec;
1da177e4 2486
0ba21762 2487 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 2488 int err = snd_hda_codec_build_controls(codec);
f93d461b
TI		 2489 if (err < 0) {
2490 printk(KERN_ERR "hda_codec: cannot build controls"
2491 "for #%d (error %d)\n", codec->addr, err);
2492 err = snd_hda_codec_reset(codec);
2493 if (err < 0) {
2494 printk(KERN_ERR
2495 "hda_codec: cannot revert codec\n");
2496 return err;
2497 }
2498 }
1da177e4 2499 }
6c1f45ea
TI		 2500 return 0;
2501}
ff7a3267 2502EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 2503
6c1f45ea
TI		 2504int snd_hda_codec_build_controls(struct hda_codec *codec)
2505{
2506 int err = 0;
11aeff08 2507 hda_exec_init_verbs(codec);
6c1f45ea
TI		 2508 /* continue to initialize... */
2509 if (codec->patch_ops.init)
2510 err = codec->patch_ops.init(codec);
2511 if (!err && codec->patch_ops.build_controls)
2512 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 2513 if (err < 0)
2514 return err;
1da177e4
LT		 2515 return 0;
2516}
2517
1da177e4
LT		 2518/*
2519 * stream formats
2520 */
befdf316
TI		 2521struct hda_rate_tbl {
2522 unsigned int hz;
2523 unsigned int alsa_bits;
2524 unsigned int hda_fmt;
2525};
2526
2527static struct hda_rate_tbl rate_bits[] = {
1da177e4 2528 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 2529
2530 /* autodetected value used in snd_hda_query_supported_pcm */
1da177e4
LT		 2531 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2532 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2533 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2534 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2535 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2536 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2537 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2538 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2539 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2540 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2541 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
a961f9fe
TI		 2542#define AC_PAR_PCM_RATE_BITS 11
2543 /* up to bits 10, 384kHZ isn't supported properly */
2544
2545 /* not autodetected value */
2546 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
9d8f53f2 2547
befdf316 2548 { 0 } /* terminator */
1da177e4
LT		 2549};
2550
2551/**
2552 * snd_hda_calc_stream_format - calculate format bitset
2553 * @rate: the sample rate
2554 * @channels: the number of channels
2555 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2556 * @maxbps: the max. bps
2557 *
2558 * Calculate the format bitset from the given rate, channels and th PCM format.
2559 *
2560 * Return zero if invalid.
2561 */
2562unsigned int snd_hda_calc_stream_format(unsigned int rate,
2563 unsigned int channels,
2564 unsigned int format,
2565 unsigned int maxbps)
2566{
2567 int i;
2568 unsigned int val = 0;
2569
befdf316
TI		 2570 for (i = 0; rate_bits[i].hz; i++)
2571 if (rate_bits[i].hz == rate) {
2572 val = rate_bits[i].hda_fmt;
1da177e4
LT		 2573 break;
2574 }
0ba21762 2575 if (!rate_bits[i].hz) {
1da177e4
LT		 2576 snd_printdd("invalid rate %d\n", rate);
2577 return 0;
2578 }
2579
2580 if (channels == 0 || channels > 8) {
2581 snd_printdd("invalid channels %d\n", channels);
2582 return 0;
2583 }
2584 val |= channels - 1;
2585
2586 switch (snd_pcm_format_width(format)) {
2587 case 8: val |= 0x00; break;
2588 case 16: val |= 0x10; break;
2589 case 20:
2590 case 24:
2591 case 32:
b0bb3aa6 2592 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
1da177e4
LT		 2593 val |= 0x40;
2594 else if (maxbps >= 24)
2595 val |= 0x30;
2596 else
2597 val |= 0x20;
2598 break;
2599 default:
0ba21762
TI		 2600 snd_printdd("invalid format width %d\n",
2601 snd_pcm_format_width(format));
1da177e4
LT		 2602 return 0;
2603 }
2604
2605 return val;
2606}
ff7a3267 2607EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 2608
92c7c8a7
TI		 2609static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2610{
2611 unsigned int val = 0;
2612 if (nid != codec->afg &&
2613 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2614 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2615 if (!val || val == -1)
2616 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2617 if (!val || val == -1)
2618 return 0;
2619 return val;
2620}
2621
2622static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2623{
2624 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2625 get_pcm_param);
2626}
2627
2628static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2629{
2630 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2631 if (!streams || streams == -1)
2632 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2633 if (!streams || streams == -1)
2634 return 0;
2635 return streams;
2636}
2637
2638static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2639{
2640 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2641 get_stream_param);
2642}
2643
1da177e4
LT		 2644/**
2645 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2646 * @codec: the HDA codec
2647 * @nid: NID to query
2648 * @ratesp: the pointer to store the detected rate bitflags
2649 * @formatsp: the pointer to store the detected formats
2650 * @bpsp: the pointer to store the detected format widths
2651 *
2652 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2653 * or @bsps argument is ignored.
2654 *
2655 * Returns 0 if successful, otherwise a negative error code.
2656 */
986862bd 2657static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 2658 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2659{
ee504710 2660 unsigned int i, val, wcaps;
1da177e4 2661
ee504710 2662 wcaps = get_wcaps(codec, nid);
92c7c8a7 2663 val = query_pcm_param(codec, nid);
1da177e4
LT		 2664
2665 if (ratesp) {
2666 u32 rates = 0;
a961f9fe 2667 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 2668 if (val & (1 << i))
befdf316 2669 rates |= rate_bits[i].alsa_bits;
1da177e4 2670 }
ee504710
JK		 2671 if (rates == 0) {
2672 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2673 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2674 nid, val,
2675 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2676 return -EIO;
2677 }
1da177e4
LT		 2678 *ratesp = rates;
2679 }
2680
2681 if (formatsp || bpsp) {
2682 u64 formats = 0;
ee504710 2683 unsigned int streams, bps;
1da177e4 2684
92c7c8a7
TI		 2685 streams = query_stream_param(codec, nid);
2686 if (!streams)
1da177e4 2687 return -EIO;
1da177e4
LT		 2688
2689 bps = 0;
2690 if (streams & AC_SUPFMT_PCM) {
2691 if (val & AC_SUPPCM_BITS_8) {
2692 formats |= SNDRV_PCM_FMTBIT_U8;
2693 bps = 8;
2694 }
2695 if (val & AC_SUPPCM_BITS_16) {
2696 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2697 bps = 16;
2698 }
2699 if (wcaps & AC_WCAP_DIGITAL) {
2700 if (val & AC_SUPPCM_BITS_32)
2701 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2702 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2703 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2704 if (val & AC_SUPPCM_BITS_24)
2705 bps = 24;
2706 else if (val & AC_SUPPCM_BITS_20)
2707 bps = 20;
0ba21762
TI		 2708 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2709 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 2710 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2711 if (val & AC_SUPPCM_BITS_32)
2712 bps = 32;
1da177e4
LT		 2713 else if (val & AC_SUPPCM_BITS_24)
2714 bps = 24;
33ef7651
NG		 2715 else if (val & AC_SUPPCM_BITS_20)
2716 bps = 20;
1da177e4
LT		 2717 }
2718 }
b5025c50 2719 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 2720 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 2721 if (!bps)
2722 bps = 32;
b5025c50
TI		 2723 }
2724 if (streams == AC_SUPFMT_AC3) {
0ba21762 2725 /* should be exclusive */
1da177e4
LT		 2726 /* temporary hack: we have still no proper support
2727 * for the direct AC3 stream...
2728 */
2729 formats |= SNDRV_PCM_FMTBIT_U8;
2730 bps = 8;
2731 }
ee504710
JK		 2732 if (formats == 0) {
2733 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2734 "(nid=0x%x, val=0x%x, ovrd=%i, "
2735 "streams=0x%x)\n",
2736 nid, val,
2737 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2738 streams);
2739 return -EIO;
2740 }
1da177e4
LT		 2741 if (formatsp)
2742 *formatsp = formats;
2743 if (bpsp)
2744 *bpsp = bps;
2745 }
2746
2747 return 0;
2748}
2749
2750/**
0ba21762
TI		 2751 * snd_hda_is_supported_format - check whether the given node supports
2752 * the format val
1da177e4
LT		 2753 *
2754 * Returns 1 if supported, 0 if not.
2755 */
2756int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2757 unsigned int format)
2758{
2759 int i;
2760 unsigned int val = 0, rate, stream;
2761
92c7c8a7
TI		 2762 val = query_pcm_param(codec, nid);
2763 if (!val)
2764 return 0;
1da177e4
LT		 2765
2766 rate = format & 0xff00;
a961f9fe 2767 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 2768 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 2769 if (val & (1 << i))
2770 break;
2771 return 0;
2772 }
a961f9fe 2773 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 2774 return 0;
2775
92c7c8a7
TI		 2776 stream = query_stream_param(codec, nid);
2777 if (!stream)
1da177e4
LT		 2778 return 0;
2779
2780 if (stream & AC_SUPFMT_PCM) {
2781 switch (format & 0xf0) {
2782 case 0x00:
0ba21762 2783 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 2784 return 0;
2785 break;
2786 case 0x10:
0ba21762 2787 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 2788 return 0;
2789 break;
2790 case 0x20:
0ba21762 2791 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 2792 return 0;
2793 break;
2794 case 0x30:
0ba21762 2795 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 2796 return 0;
2797 break;
2798 case 0x40:
0ba21762 2799 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 2800 return 0;
2801 break;
2802 default:
2803 return 0;
2804 }
2805 } else {
2806 /* FIXME: check for float32 and AC3? */
2807 }
2808
2809 return 1;
2810}
ff7a3267 2811EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 2812
2813/*
2814 * PCM stuff
2815 */
2816static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2817 struct hda_codec *codec,
c8b6bf9b 2818 struct snd_pcm_substream *substream)
1da177e4
LT		 2819{
2820 return 0;
2821}
2822
2823static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2824 struct hda_codec *codec,
2825 unsigned int stream_tag,
2826 unsigned int format,
c8b6bf9b 2827 struct snd_pcm_substream *substream)
1da177e4
LT		 2828{
2829 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2830 return 0;
2831}
2832
2833static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2834 struct hda_codec *codec,
c8b6bf9b 2835 struct snd_pcm_substream *substream)
1da177e4 2836{
888afa15 2837 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 2838 return 0;
2839}
2840
6c1f45ea
TI		 2841static int set_pcm_default_values(struct hda_codec *codec,
2842 struct hda_pcm_stream *info)
1da177e4 2843{
ee504710
JK		 2844 int err;
2845
0ba21762
TI		 2846 /* query support PCM information from the given NID */
2847 if (info->nid && (!info->rates || !info->formats)) {
ee504710 2848 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 2849 info->rates ? NULL : &info->rates,
2850 info->formats ? NULL : &info->formats,
2851 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 2852 if (err < 0)
2853 return err;
1da177e4
LT		 2854 }
2855 if (info->ops.open == NULL)
2856 info->ops.open = hda_pcm_default_open_close;
2857 if (info->ops.close == NULL)
2858 info->ops.close = hda_pcm_default_open_close;
2859 if (info->ops.prepare == NULL) {
da3cec35
TI		 2860 if (snd_BUG_ON(!info->nid))
2861 return -EINVAL;
1da177e4
LT		 2862 info->ops.prepare = hda_pcm_default_prepare;
2863 }
1da177e4 2864 if (info->ops.cleanup == NULL) {
da3cec35
TI		 2865 if (snd_BUG_ON(!info->nid))
2866 return -EINVAL;
1da177e4
LT		 2867 info->ops.cleanup = hda_pcm_default_cleanup;
2868 }
2869 return 0;
2870}
2871
529bd6c4
TI		 2872/*
2873 * get the empty PCM device number to assign
2874 */
2875static int get_empty_pcm_device(struct hda_bus *bus, int type)
2876{
2877 static const char *dev_name[HDA_PCM_NTYPES] = {
2878 "Audio", "SPDIF", "HDMI", "Modem"
2879 };
2880 /* starting device index for each PCM type */
2881 static int dev_idx[HDA_PCM_NTYPES] = {
2882 [HDA_PCM_TYPE_AUDIO] = 0,
2883 [HDA_PCM_TYPE_SPDIF] = 1,
2884 [HDA_PCM_TYPE_HDMI] = 3,
2885 [HDA_PCM_TYPE_MODEM] = 6
2886 };
2887 /* normal audio device indices; not linear to keep compatibility */
2888 static int audio_idx[4] = { 0, 2, 4, 5 };
2889 int i, dev;
2890
2891 switch (type) {
2892 case HDA_PCM_TYPE_AUDIO:
2893 for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
2894 dev = audio_idx[i];
2895 if (!test_bit(dev, bus->pcm_dev_bits))
82ad39f9 2896 goto ok;
529bd6c4 2897 }
82ad39f9
TI		 2898 snd_printk(KERN_WARNING "Too many audio devices\n");
2899 return -EAGAIN;
529bd6c4
TI		 2900 case HDA_PCM_TYPE_SPDIF:
2901 case HDA_PCM_TYPE_HDMI:
2902 case HDA_PCM_TYPE_MODEM:
2903 dev = dev_idx[type];
2904 if (test_bit(dev, bus->pcm_dev_bits)) {
2905 snd_printk(KERN_WARNING "%s already defined\n",
2906 dev_name[type]);
2907 return -EAGAIN;
2908 }
2909 break;
2910 default:
2911 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2912 return -EINVAL;
2913 }
82ad39f9 2914 ok:
529bd6c4
TI		 2915 set_bit(dev, bus->pcm_dev_bits);
2916 return dev;
2917}
2918
176d5335
TI		 2919/*
2920 * attach a new PCM stream
2921 */
529bd6c4 2922static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 2923{
33fa35ed 2924 struct hda_bus *bus = codec->bus;
176d5335
TI		 2925 struct hda_pcm_stream *info;
2926 int stream, err;
2927
b91f080f 2928 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 2929 return -EINVAL;
2930 for (stream = 0; stream < 2; stream++) {
2931 info = &pcm->stream[stream];
2932 if (info->substreams) {
2933 err = set_pcm_default_values(codec, info);
2934 if (err < 0)
2935 return err;
2936 }
2937 }
33fa35ed 2938 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 2939}
2940
529bd6c4
TI		 2941/* assign all PCMs of the given codec */
2942int snd_hda_codec_build_pcms(struct hda_codec *codec)
2943{
2944 unsigned int pcm;
2945 int err;
2946
2947 if (!codec->num_pcms) {
2948 if (!codec->patch_ops.build_pcms)
2949 return 0;
2950 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 2951 if (err < 0) {
2952 printk(KERN_ERR "hda_codec: cannot build PCMs"
2953 "for #%d (error %d)\n", codec->addr, err);
2954 err = snd_hda_codec_reset(codec);
2955 if (err < 0) {
2956 printk(KERN_ERR
2957 "hda_codec: cannot revert codec\n");
2958 return err;
2959 }
2960 }
529bd6c4
TI		 2961 }
2962 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2963 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2964 int dev;
2965
2966 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 2967 continue; /* no substreams assigned */
529bd6c4
TI		 2968
2969 if (!cpcm->pcm) {
2970 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2971 if (dev < 0)
6e655bf2 2972 continue; /* no fatal error */
529bd6c4
TI		 2973 cpcm->device = dev;
2974 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 2975 if (err < 0) {
2976 printk(KERN_ERR "hda_codec: cannot attach "
2977 "PCM stream %d for codec #%d\n",
2978 dev, codec->addr);
2979 continue; /* no fatal error */
2980 }
529bd6c4
TI		 2981 }
2982 }
2983 return 0;
2984}
2985
1da177e4
LT		 2986/**
2987 * snd_hda_build_pcms - build PCM information
2988 * @bus: the BUS
2989 *
2990 * Create PCM information for each codec included in the bus.
2991 *
2992 * The build_pcms codec patch is requested to set up codec->num_pcms and
2993 * codec->pcm_info properly. The array is referred by the top-level driver
2994 * to create its PCM instances.
2995 * The allocated codec->pcm_info should be released in codec->patch_ops.free
2996 * callback.
2997 *
2998 * At least, substreams, channels_min and channels_max must be filled for
2999 * each stream. substreams = 0 indicates that the stream doesn't exist.
3000 * When rates and/or formats are zero, the supported values are queried
3001 * from the given nid. The nid is used also by the default ops.prepare
3002 * and ops.cleanup callbacks.
3003 *
3004 * The driver needs to call ops.open in its open callback. Similarly,
3005 * ops.close is supposed to be called in the close callback.
3006 * ops.prepare should be called in the prepare or hw_params callback
3007 * with the proper parameters for set up.
3008 * ops.cleanup should be called in hw_free for clean up of streams.
3009 *
3010 * This function returns 0 if successfull, or a negative error code.
3011 */
529bd6c4 3012int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 3013{
0ba21762 3014 struct hda_codec *codec;
1da177e4 3015
0ba21762 3016 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 3017 int err = snd_hda_codec_build_pcms(codec);
3018 if (err < 0)
3019 return err;
1da177e4
LT		 3020 }
3021 return 0;
3022}
ff7a3267 3023EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 3024
1da177e4
LT		 3025/**
3026 * snd_hda_check_board_config - compare the current codec with the config table
3027 * @codec: the HDA codec
f5fcc13c
TI		 3028 * @num_configs: number of config enums
3029 * @models: array of model name strings
1da177e4
LT		 3030 * @tbl: configuration table, terminated by null entries
3031 *
3032 * Compares the modelname or PCI subsystem id of the current codec with the
3033 * given configuration table. If a matching entry is found, returns its
3034 * config value (supposed to be 0 or positive).
3035 *
3036 * If no entries are matching, the function returns a negative value.
3037 */
12f288bf
TI		 3038int snd_hda_check_board_config(struct hda_codec *codec,
3039 int num_configs, const char **models,
3040 const struct snd_pci_quirk *tbl)
1da177e4 3041{
f44ac837 3042 if (codec->modelname && models) {
f5fcc13c
TI		 3043 int i;
3044 for (i = 0; i < num_configs; i++) {
3045 if (models[i] &&
f44ac837 3046 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 3047 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3048 "selected\n", models[i]);
3049 return i;
1da177e4
LT		 3050 }
3051 }
3052 }
3053
f5fcc13c
TI		 3054 if (!codec->bus->pci || !tbl)
3055 return -1;
3056
3057 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3058 if (!tbl)
3059 return -1;
3060 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 3061#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 3062 char tmp[10];
3063 const char *model = NULL;
3064 if (models)
3065 model = models[tbl->value];
3066 if (!model) {
3067 sprintf(tmp, "#%d", tbl->value);
3068 model = tmp;
1da177e4 3069 }
f5fcc13c
TI		 3070 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3071 "for config %x:%x (%s)\n",
3072 model, tbl->subvendor, tbl->subdevice,
3073 (tbl->name ? tbl->name : "Unknown device"));
3074#endif
3075 return tbl->value;
1da177e4
LT		 3076 }
3077 return -1;
3078}
ff7a3267 3079EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 3080
2eda3445
MCC		 3081/**
3082 * snd_hda_check_board_codec_sid_config - compare the current codec
3083 subsystem ID with the
3084 config table
3085
3086 This is important for Gateway notebooks with SB450 HDA Audio
3087 where the vendor ID of the PCI device is:
3088 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3089 and the vendor/subvendor are found only at the codec.
3090
3091 * @codec: the HDA codec
3092 * @num_configs: number of config enums
3093 * @models: array of model name strings
3094 * @tbl: configuration table, terminated by null entries
3095 *
3096 * Compares the modelname or PCI subsystem id of the current codec with the
3097 * given configuration table. If a matching entry is found, returns its
3098 * config value (supposed to be 0 or positive).
3099 *
3100 * If no entries are matching, the function returns a negative value.
3101 */
3102int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3103 int num_configs, const char **models,
3104 const struct snd_pci_quirk *tbl)
3105{
3106 const struct snd_pci_quirk *q;
3107
3108 /* Search for codec ID */
3109 for (q = tbl; q->subvendor; q++) {
3110 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3111
3112 if (vendorid == codec->subsystem_id)
3113 break;
3114 }
3115
3116 if (!q->subvendor)
3117 return -1;
3118
3119 tbl = q;
3120
3121 if (tbl->value >= 0 && tbl->value < num_configs) {
3122#ifdef CONFIG_SND_DEBUG_DETECT
3123 char tmp[10];
3124 const char *model = NULL;
3125 if (models)
3126 model = models[tbl->value];
3127 if (!model) {
3128 sprintf(tmp, "#%d", tbl->value);
3129 model = tmp;
3130 }
3131 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3132 "for config %x:%x (%s)\n",
3133 model, tbl->subvendor, tbl->subdevice,
3134 (tbl->name ? tbl->name : "Unknown device"));
3135#endif
3136 return tbl->value;
3137 }
3138 return -1;
3139}
3140EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3141
1da177e4
LT		 3142/**
3143 * snd_hda_add_new_ctls - create controls from the array
3144 * @codec: the HDA codec
c8b6bf9b 3145 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 3146 *
3147 * This helper function creates and add new controls in the given array.
3148 * The array must be terminated with an empty entry as terminator.
3149 *
3150 * Returns 0 if successful, or a negative error code.
3151 */
12f288bf 3152int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
1da177e4 3153{
cb53c626 3154 int err;
1da177e4
LT		 3155
3156 for (; knew->name; knew++) {
54d17403
TI		 3157 struct snd_kcontrol *kctl;
3158 kctl = snd_ctl_new1(knew, codec);
0ba21762 3159 if (!kctl)
54d17403 3160 return -ENOMEM;
d13bd412 3161 err = snd_hda_ctl_add(codec, kctl);
54d17403 3162 if (err < 0) {
0ba21762 3163 if (!codec->addr)
54d17403
TI		 3164 return err;
3165 kctl = snd_ctl_new1(knew, codec);
0ba21762 3166 if (!kctl)
54d17403
TI		 3167 return -ENOMEM;
3168 kctl->id.device = codec->addr;
d13bd412 3169 err = snd_hda_ctl_add(codec, kctl);
0ba21762 3170 if (err < 0)
54d17403
TI		 3171 return err;
3172 }
1da177e4
LT		 3173 }
3174 return 0;
3175}
ff7a3267 3176EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 3177
cb53c626
TI		 3178#ifdef CONFIG_SND_HDA_POWER_SAVE
3179static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3180 unsigned int power_state);
3181
3182static void hda_power_work(struct work_struct *work)
3183{
3184 struct hda_codec *codec =
3185 container_of(work, struct hda_codec, power_work.work);
33fa35ed 3186 struct hda_bus *bus = codec->bus;
cb53c626 3187
2e492462
ML		 3188 if (!codec->power_on || codec->power_count) {
3189 codec->power_transition = 0;
cb53c626 3190 return;
2e492462 3191 }
cb53c626
TI		 3192
3193 hda_call_codec_suspend(codec);
33fa35ed
TI		 3194 if (bus->ops.pm_notify)
3195 bus->ops.pm_notify(bus);
cb53c626
TI		 3196}
3197
3198static void hda_keep_power_on(struct hda_codec *codec)
3199{
3200 codec->power_count++;
3201 codec->power_on = 1;
3202}
3203
3204void snd_hda_power_up(struct hda_codec *codec)
3205{
33fa35ed
TI		 3206 struct hda_bus *bus = codec->bus;
3207
cb53c626 3208 codec->power_count++;
a221e287 3209 if (codec->power_on || codec->power_transition)
cb53c626
TI		 3210 return;
3211
3212 codec->power_on = 1;
33fa35ed
TI		 3213 if (bus->ops.pm_notify)
3214 bus->ops.pm_notify(bus);
cb53c626
TI		 3215 hda_call_codec_resume(codec);
3216 cancel_delayed_work(&codec->power_work);
a221e287 3217 codec->power_transition = 0;
cb53c626 3218}
ff7a3267 3219EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 3220
3221#define power_save(codec) \
3222 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 3223
fee2fba3
TI		 3224#define power_save(codec) \
3225 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3226
cb53c626
TI		 3227void snd_hda_power_down(struct hda_codec *codec)
3228{
3229 --codec->power_count;
a221e287 3230 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 3231 return;
fee2fba3 3232 if (power_save(codec)) {
a221e287 3233 codec->power_transition = 1; /* avoid reentrance */
c107b41c 3234 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 3235 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 3236 }
cb53c626 3237}
ff7a3267 3238EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626
TI		 3239
3240int snd_hda_check_amp_list_power(struct hda_codec *codec,
3241 struct hda_loopback_check *check,
3242 hda_nid_t nid)
3243{
3244 struct hda_amp_list *p;
3245 int ch, v;
3246
3247 if (!check->amplist)
3248 return 0;
3249 for (p = check->amplist; p->nid; p++) {
3250 if (p->nid == nid)
3251 break;
3252 }
3253 if (!p->nid)
3254 return 0; /* nothing changed */
3255
3256 for (p = check->amplist; p->nid; p++) {
3257 for (ch = 0; ch < 2; ch++) {
3258 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3259 p->idx);
3260 if (!(v & HDA_AMP_MUTE) && v > 0) {
3261 if (!check->power_on) {
3262 check->power_on = 1;
3263 snd_hda_power_up(codec);
3264 }
3265 return 1;
3266 }
3267 }
3268 }
3269 if (check->power_on) {
3270 check->power_on = 0;
3271 snd_hda_power_down(codec);
3272 }
3273 return 0;
3274}
ff7a3267 3275EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 3276#endif
1da177e4 3277
c8b6bf9b 3278/*
d2a6d7dc
TI		 3279 * Channel mode helper
3280 */
0ba21762
TI		 3281int snd_hda_ch_mode_info(struct hda_codec *codec,
3282 struct snd_ctl_elem_info *uinfo,
3283 const struct hda_channel_mode *chmode,
3284 int num_chmodes)
d2a6d7dc
TI		 3285{
3286 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3287 uinfo->count = 1;
3288 uinfo->value.enumerated.items = num_chmodes;
3289 if (uinfo->value.enumerated.item >= num_chmodes)
3290 uinfo->value.enumerated.item = num_chmodes - 1;
3291 sprintf(uinfo->value.enumerated.name, "%dch",
3292 chmode[uinfo->value.enumerated.item].channels);
3293 return 0;
3294}
ff7a3267 3295EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 3296
0ba21762
TI		 3297int snd_hda_ch_mode_get(struct hda_codec *codec,
3298 struct snd_ctl_elem_value *ucontrol,
3299 const struct hda_channel_mode *chmode,
3300 int num_chmodes,
d2a6d7dc
TI		 3301 int max_channels)
3302{
3303 int i;
3304
3305 for (i = 0; i < num_chmodes; i++) {
3306 if (max_channels == chmode[i].channels) {
3307 ucontrol->value.enumerated.item[0] = i;
3308 break;
3309 }
3310 }
3311 return 0;
3312}
ff7a3267 3313EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 3314
0ba21762
TI		 3315int snd_hda_ch_mode_put(struct hda_codec *codec,
3316 struct snd_ctl_elem_value *ucontrol,
3317 const struct hda_channel_mode *chmode,
3318 int num_chmodes,
d2a6d7dc
TI		 3319 int *max_channelsp)
3320{
3321 unsigned int mode;
3322
3323 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 3324 if (mode >= num_chmodes)
3325 return -EINVAL;
82beb8fd 3326 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 3327 return 0;
3328 /* change the current channel setting */
3329 *max_channelsp = chmode[mode].channels;
3330 if (chmode[mode].sequence)
82beb8fd 3331 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 3332 return 1;
3333}
ff7a3267 3334EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 3335
1da177e4
LT		 3336/*
3337 * input MUX helper
3338 */
0ba21762
TI		 3339int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3340 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3341{
3342 unsigned int index;
3343
3344 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3345 uinfo->count = 1;
3346 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 3347 if (!imux->num_items)
3348 return 0;
1da177e4
LT		 3349 index = uinfo->value.enumerated.item;
3350 if (index >= imux->num_items)
3351 index = imux->num_items - 1;
3352 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3353 return 0;
3354}
ff7a3267 3355EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 3356
0ba21762
TI		 3357int snd_hda_input_mux_put(struct hda_codec *codec,
3358 const struct hda_input_mux *imux,
3359 struct snd_ctl_elem_value *ucontrol,
3360 hda_nid_t nid,
1da177e4
LT		 3361 unsigned int *cur_val)
3362{
3363 unsigned int idx;
3364
5513b0c5
TI		 3365 if (!imux->num_items)
3366 return 0;
1da177e4
LT		 3367 idx = ucontrol->value.enumerated.item[0];
3368 if (idx >= imux->num_items)
3369 idx = imux->num_items - 1;
82beb8fd 3370 if (*cur_val == idx)
1da177e4 3371 return 0;
82beb8fd
TI		 3372 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3373 imux->items[idx].index);
1da177e4
LT		 3374 *cur_val = idx;
3375 return 1;
3376}
ff7a3267 3377EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 3378
3379
3380/*
3381 * Multi-channel / digital-out PCM helper functions
3382 */
3383
6b97eb45
TI		 3384/* setup SPDIF output stream */
3385static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3386 unsigned int stream_tag, unsigned int format)
3387{
3388 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2f72853c
TI		 3389 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3390 set_dig_out_convert(codec, nid,
3391 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3392 -1);
6b97eb45 3393 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c
TI		 3394 if (codec->slave_dig_outs) {
3395 hda_nid_t *d;
3396 for (d = codec->slave_dig_outs; *d; d++)
3397 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3398 format);
3399 }
6b97eb45 3400 /* turn on again (if needed) */
2f72853c
TI		 3401 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3402 set_dig_out_convert(codec, nid,
3403 codec->spdif_ctls & 0xff, -1);
3404}
de51ca12 3405
2f72853c
TI		 3406static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3407{
3408 snd_hda_codec_cleanup_stream(codec, nid);
3409 if (codec->slave_dig_outs) {
3410 hda_nid_t *d;
3411 for (d = codec->slave_dig_outs; *d; d++)
3412 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 3413 }
6b97eb45
TI		 3414}
3415
1da177e4
LT		 3416/*
3417 * open the digital out in the exclusive mode
3418 */
0ba21762
TI		 3419int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3420 struct hda_multi_out *mout)
1da177e4 3421{
62932df8 3422 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 3423 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3424 /* already opened as analog dup; reset it once */
2f72853c 3425 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 3426 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 3427 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3428 return 0;
3429}
ff7a3267 3430EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 3431
6b97eb45
TI		 3432int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3433 struct hda_multi_out *mout,
3434 unsigned int stream_tag,
3435 unsigned int format,
3436 struct snd_pcm_substream *substream)
3437{
3438 mutex_lock(&codec->spdif_mutex);
3439 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3440 mutex_unlock(&codec->spdif_mutex);
3441 return 0;
3442}
ff7a3267 3443EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 3444
9411e21c
TI		 3445int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3446 struct hda_multi_out *mout)
3447{
3448 mutex_lock(&codec->spdif_mutex);
3449 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3450 mutex_unlock(&codec->spdif_mutex);
3451 return 0;
3452}
3453EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3454
1da177e4
LT		 3455/*
3456 * release the digital out
3457 */
0ba21762
TI		 3458int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3459 struct hda_multi_out *mout)
1da177e4 3460{
62932df8 3461 mutex_lock(&codec->spdif_mutex);
1da177e4 3462 mout->dig_out_used = 0;
62932df8 3463 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3464 return 0;
3465}
ff7a3267 3466EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4
LT		 3467
3468/*
3469 * set up more restrictions for analog out
3470 */
0ba21762
TI		 3471int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3472 struct hda_multi_out *mout,
9a08160b
TI		 3473 struct snd_pcm_substream *substream,
3474 struct hda_pcm_stream *hinfo)
3475{
3476 struct snd_pcm_runtime *runtime = substream->runtime;
3477 runtime->hw.channels_max = mout->max_channels;
3478 if (mout->dig_out_nid) {
3479 if (!mout->analog_rates) {
3480 mout->analog_rates = hinfo->rates;
3481 mout->analog_formats = hinfo->formats;
3482 mout->analog_maxbps = hinfo->maxbps;
3483 } else {
3484 runtime->hw.rates = mout->analog_rates;
3485 runtime->hw.formats = mout->analog_formats;
3486 hinfo->maxbps = mout->analog_maxbps;
3487 }
3488 if (!mout->spdif_rates) {
3489 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3490 &mout->spdif_rates,
3491 &mout->spdif_formats,
3492 &mout->spdif_maxbps);
3493 }
3494 mutex_lock(&codec->spdif_mutex);
3495 if (mout->share_spdif) {
022b466f
TI		 3496 if ((runtime->hw.rates & mout->spdif_rates) &&
3497 (runtime->hw.formats & mout->spdif_formats)) {
3498 runtime->hw.rates &= mout->spdif_rates;
3499 runtime->hw.formats &= mout->spdif_formats;
3500 if (mout->spdif_maxbps < hinfo->maxbps)
3501 hinfo->maxbps = mout->spdif_maxbps;
3502 } else {
3503 mout->share_spdif = 0;
3504 /* FIXME: need notify? */
3505 }
9a08160b 3506 }
eaa9985b 3507 mutex_unlock(&codec->spdif_mutex);
9a08160b 3508 }
1da177e4
LT		 3509 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3510 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3511}
ff7a3267 3512EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4
LT		 3513
3514/*
3515 * set up the i/o for analog out
3516 * when the digital out is available, copy the front out to digital out, too.
3517 */
0ba21762
TI		 3518int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3519 struct hda_multi_out *mout,
1da177e4
LT		 3520 unsigned int stream_tag,
3521 unsigned int format,
c8b6bf9b 3522 struct snd_pcm_substream *substream)
1da177e4
LT		 3523{
3524 hda_nid_t *nids = mout->dac_nids;
3525 int chs = substream->runtime->channels;
3526 int i;
3527
62932df8 3528 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 3529 if (mout->dig_out_nid && mout->share_spdif &&
3530 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 3531 if (chs == 2 &&
0ba21762
TI		 3532 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3533 format) &&
3534 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
1da177e4 3535 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 3536 setup_dig_out_stream(codec, mout->dig_out_nid,
3537 stream_tag, format);
1da177e4
LT		 3538 } else {
3539 mout->dig_out_used = 0;
2f72853c 3540 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3541 }
3542 }
62932df8 3543 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3544
3545 /* front */
0ba21762
TI		 3546 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3547 0, format);
d29240ce
TI		 3548 if (!mout->no_share_stream &&
3549 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 3550 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 3551 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3552 0, format);
82bc955f
TI		 3553 /* extra outputs copied from front */
3554 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 3555 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 3556 snd_hda_codec_setup_stream(codec,
3557 mout->extra_out_nid[i],
3558 stream_tag, 0, format);
3559
1da177e4
LT		 3560 /* surrounds */
3561 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 3562 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 3563 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3564 i * 2, format);
d29240ce 3565 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 3566 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3567 0, format);
1da177e4
LT		 3568 }
3569 return 0;
3570}
ff7a3267 3571EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4
LT		 3572
3573/*
3574 * clean up the setting for analog out
3575 */
0ba21762
TI		 3576int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3577 struct hda_multi_out *mout)
1da177e4
LT		 3578{
3579 hda_nid_t *nids = mout->dac_nids;
3580 int i;
3581
3582 for (i = 0; i < mout->num_dacs; i++)
888afa15 3583 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 3584 if (mout->hp_nid)
888afa15 3585 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
82bc955f
TI		 3586 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3587 if (mout->extra_out_nid[i])
888afa15
TI		 3588 snd_hda_codec_cleanup_stream(codec,
3589 mout->extra_out_nid[i]);
62932df8 3590 mutex_lock(&codec->spdif_mutex);
1da177e4 3591 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 3592 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3593 mout->dig_out_used = 0;
3594 }
62932df8 3595 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3596 return 0;
3597}
ff7a3267 3598EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 3599
e9edcee0 3600/*
6b34500c 3601 * Helper for automatic pin configuration
e9edcee0 3602 */
df694daa 3603
12f288bf 3604static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
df694daa
KY		 3605{
3606 for (; *list; list++)
3607 if (*list == nid)
3608 return 1;
3609 return 0;
3610}
3611
81937d3b
SL		 3612
3613/*
3614 * Sort an associated group of pins according to their sequence numbers.
3615 */
3616static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3617 int num_pins)
3618{
3619 int i, j;
3620 short seq;
3621 hda_nid_t nid;
3622
3623 for (i = 0; i < num_pins; i++) {
3624 for (j = i + 1; j < num_pins; j++) {
3625 if (sequences[i] > sequences[j]) {
3626 seq = sequences[i];
3627 sequences[i] = sequences[j];
3628 sequences[j] = seq;
3629 nid = pins[i];
3630 pins[i] = pins[j];
3631 pins[j] = nid;
3632 }
3633 }
3634 }
3635}
3636
3637
82bc955f
TI		 3638/*
3639 * Parse all pin widgets and store the useful pin nids to cfg
3640 *
3641 * The number of line-outs or any primary output is stored in line_outs,
3642 * and the corresponding output pins are assigned to line_out_pins[],
3643 * in the order of front, rear, CLFE, side, ...
3644 *
3645 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 3646 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 3647 * is detected, one of speaker of HP pins is assigned as the primary
3648 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3649 * if any analog output exists.
3650 *
3651 * The analog input pins are assigned to input_pins array.
3652 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3653 * respectively.
3654 */
12f288bf
TI		 3655int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3656 struct auto_pin_cfg *cfg,
3657 hda_nid_t *ignore_nids)
e9edcee0 3658{
0ef6ce7b 3659 hda_nid_t nid, end_nid;
81937d3b
SL		 3660 short seq, assoc_line_out, assoc_speaker;
3661 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3662 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 3663 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
e9edcee0
TI		 3664
3665 memset(cfg, 0, sizeof(*cfg));
3666
81937d3b
SL		 3667 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3668 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 3669 memset(sequences_hp, 0, sizeof(sequences_hp));
81937d3b 3670 assoc_line_out = assoc_speaker = 0;
e9edcee0 3671
0ef6ce7b
TI		 3672 end_nid = codec->start_nid + codec->num_nodes;
3673 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 3674 unsigned int wid_caps = get_wcaps(codec, nid);
0ba21762
TI		 3675 unsigned int wid_type =
3676 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
e9edcee0
TI		 3677 unsigned int def_conf;
3678 short assoc, loc;
3679
3680 /* read all default configuration for pin complex */
3681 if (wid_type != AC_WID_PIN)
3682 continue;
df694daa
KY		 3683 /* ignore the given nids (e.g. pc-beep returns error) */
3684 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3685 continue;
3686
c17a1aba 3687 def_conf = snd_hda_codec_get_pincfg(codec, nid);
e9edcee0
TI		 3688 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3689 continue;
3690 loc = get_defcfg_location(def_conf);
3691 switch (get_defcfg_device(def_conf)) {
3692 case AC_JACK_LINE_OUT:
e9edcee0
TI		 3693 seq = get_defcfg_sequence(def_conf);
3694 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 3695
3696 if (!(wid_caps & AC_WCAP_STEREO))
3697 if (!cfg->mono_out_pin)
3698 cfg->mono_out_pin = nid;
0ba21762 3699 if (!assoc)
e9edcee0 3700 continue;
0ba21762 3701 if (!assoc_line_out)
e9edcee0
TI		 3702 assoc_line_out = assoc;
3703 else if (assoc_line_out != assoc)
3704 continue;
3705 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3706 continue;
3707 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 3708 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 3709 cfg->line_outs++;
3710 break;
8d88bc3d 3711 case AC_JACK_SPEAKER:
81937d3b
SL		 3712 seq = get_defcfg_sequence(def_conf);
3713 assoc = get_defcfg_association(def_conf);
3714 if (! assoc)
3715 continue;
3716 if (! assoc_speaker)
3717 assoc_speaker = assoc;
3718 else if (assoc_speaker != assoc)
3719 continue;
82bc955f
TI		 3720 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3721 continue;
3722 cfg->speaker_pins[cfg->speaker_outs] = nid;
81937d3b 3723 sequences_speaker[cfg->speaker_outs] = seq;
82bc955f 3724 cfg->speaker_outs++;
8d88bc3d 3725 break;
e9edcee0 3726 case AC_JACK_HP_OUT:
f889fa91
TI		 3727 seq = get_defcfg_sequence(def_conf);
3728 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 3729 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3730 continue;
3731 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 3732 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 3733 cfg->hp_outs++;
e9edcee0 3734 break;
314634bc
TI		 3735 case AC_JACK_MIC_IN: {
3736 int preferred, alt;
3737 if (loc == AC_JACK_LOC_FRONT) {
3738 preferred = AUTO_PIN_FRONT_MIC;
3739 alt = AUTO_PIN_MIC;
3740 } else {
3741 preferred = AUTO_PIN_MIC;
3742 alt = AUTO_PIN_FRONT_MIC;
3743 }
3744 if (!cfg->input_pins[preferred])
3745 cfg->input_pins[preferred] = nid;
3746 else if (!cfg->input_pins[alt])
3747 cfg->input_pins[alt] = nid;
e9edcee0 3748 break;
314634bc 3749 }
e9edcee0
TI		 3750 case AC_JACK_LINE_IN:
3751 if (loc == AC_JACK_LOC_FRONT)
3752 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3753 else
3754 cfg->input_pins[AUTO_PIN_LINE] = nid;
3755 break;
3756 case AC_JACK_CD:
3757 cfg->input_pins[AUTO_PIN_CD] = nid;
3758 break;
3759 case AC_JACK_AUX:
3760 cfg->input_pins[AUTO_PIN_AUX] = nid;
3761 break;
3762 case AC_JACK_SPDIF_OUT:
1b52ae70 3763 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 3764 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3765 continue;
3766 cfg->dig_out_pins[cfg->dig_outs] = nid;
3767 cfg->dig_out_type[cfg->dig_outs] =
3768 (loc == AC_JACK_LOC_HDMI) ?
3769 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3770 cfg->dig_outs++;
e9edcee0
TI		 3771 break;
3772 case AC_JACK_SPDIF_IN:
1b52ae70 3773 case AC_JACK_DIG_OTHER_IN:
e9edcee0 3774 cfg->dig_in_pin = nid;
2297bd6e
TI		 3775 if (loc == AC_JACK_LOC_HDMI)
3776 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3777 else
3778 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 3779 break;
3780 }
3781 }
3782
5832fcf8
TI		 3783 /* FIX-UP:
3784 * If no line-out is defined but multiple HPs are found,
3785 * some of them might be the real line-outs.
3786 */
3787 if (!cfg->line_outs && cfg->hp_outs > 1) {
3788 int i = 0;
3789 while (i < cfg->hp_outs) {
3790 /* The real HPs should have the sequence 0x0f */
3791 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3792 i++;
3793 continue;
3794 }
3795 /* Move it to the line-out table */
3796 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3797 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3798 cfg->line_outs++;
3799 cfg->hp_outs--;
3800 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3801 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3802 memmove(sequences_hp + i - 1, sequences_hp + i,
3803 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3804 }
3805 }
3806
e9edcee0 3807 /* sort by sequence */
81937d3b
SL		 3808 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3809 cfg->line_outs);
3810 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3811 cfg->speaker_outs);
f889fa91
TI		 3812 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3813 cfg->hp_outs);
81937d3b 3814
f889fa91
TI		 3815 /* if we have only one mic, make it AUTO_PIN_MIC */
3816 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3817 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3818 cfg->input_pins[AUTO_PIN_MIC] =
3819 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3820 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3821 }
3822 /* ditto for line-in */
3823 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3824 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3825 cfg->input_pins[AUTO_PIN_LINE] =
3826 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3827 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3828 }
3829
81937d3b
SL		 3830 /*
3831 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3832 * as a primary output
3833 */
3834 if (!cfg->line_outs) {
3835 if (cfg->speaker_outs) {
3836 cfg->line_outs = cfg->speaker_outs;
3837 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3838 sizeof(cfg->speaker_pins));
3839 cfg->speaker_outs = 0;
3840 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3841 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3842 } else if (cfg->hp_outs) {
3843 cfg->line_outs = cfg->hp_outs;
3844 memcpy(cfg->line_out_pins, cfg->hp_pins,
3845 sizeof(cfg->hp_pins));
3846 cfg->hp_outs = 0;
3847 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3848 cfg->line_out_type = AUTO_PIN_HP_OUT;
3849 }
3850 }
e9edcee0 3851
cb8e2f83
TI		 3852 /* Reorder the surround channels
3853 * ALSA sequence is front/surr/clfe/side
3854 * HDA sequence is:
3855 * 4-ch: front/surr => OK as it is
3856 * 6-ch: front/clfe/surr
9422db40 3857 * 8-ch: front/clfe/rear/side|fc
cb8e2f83
TI		 3858 */
3859 switch (cfg->line_outs) {
3860 case 3:
cb8e2f83
TI		 3861 case 4:
3862 nid = cfg->line_out_pins[1];
9422db40 3863 cfg->line_out_pins[1] = cfg->line_out_pins[2];
cb8e2f83
TI		 3864 cfg->line_out_pins[2] = nid;
3865 break;
e9edcee0
TI		 3866 }
3867
82bc955f
TI		 3868 /*
3869 * debug prints of the parsed results
3870 */
3871 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3872 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3873 cfg->line_out_pins[2], cfg->line_out_pins[3],
3874 cfg->line_out_pins[4]);
3875 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3876 cfg->speaker_outs, cfg->speaker_pins[0],
3877 cfg->speaker_pins[1], cfg->speaker_pins[2],
3878 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 3879 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3880 cfg->hp_outs, cfg->hp_pins[0],
3881 cfg->hp_pins[1], cfg->hp_pins[2],
3882 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 3883 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 3884 if (cfg->dig_outs)
3885 snd_printd(" dig-out=0x%x/0x%x\n",
3886 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
82bc955f
TI		 3887 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3888 " cd=0x%x, aux=0x%x\n",
3889 cfg->input_pins[AUTO_PIN_MIC],
3890 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3891 cfg->input_pins[AUTO_PIN_LINE],
3892 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3893 cfg->input_pins[AUTO_PIN_CD],
3894 cfg->input_pins[AUTO_PIN_AUX]);
32d2c7fa 3895 if (cfg->dig_in_pin)
89ce9e87 3896 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 3897
e9edcee0
TI		 3898 return 0;
3899}
ff7a3267 3900EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
e9edcee0 3901
4a471b7d
TI		 3902/* labels for input pins */
3903const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3904 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3905};
ff7a3267 3906EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4a471b7d
TI		 3907
3908
1da177e4
LT		 3909#ifdef CONFIG_PM
3910/*
3911 * power management
3912 */
3913
3914/**
3915 * snd_hda_suspend - suspend the codecs
3916 * @bus: the HDA bus
1da177e4
LT		 3917 *
3918 * Returns 0 if successful.
3919 */
8dd78330 3920int snd_hda_suspend(struct hda_bus *bus)
1da177e4 3921{
0ba21762 3922 struct hda_codec *codec;
1da177e4 3923
0ba21762 3924 list_for_each_entry(codec, &bus->codec_list, list) {
0b7a2e9c
TI		 3925#ifdef CONFIG_SND_HDA_POWER_SAVE
3926 if (!codec->power_on)
3927 continue;
3928#endif
cb53c626 3929 hda_call_codec_suspend(codec);
1da177e4
LT		 3930 }
3931 return 0;
3932}
ff7a3267 3933EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 3934
3935/**
3936 * snd_hda_resume - resume the codecs
3937 * @bus: the HDA bus
1da177e4
LT		 3938 *
3939 * Returns 0 if successful.
cb53c626
TI		 3940 *
3941 * This fucntion is defined only when POWER_SAVE isn't set.
3942 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 3943 */
3944int snd_hda_resume(struct hda_bus *bus)
3945{
0ba21762 3946 struct hda_codec *codec;
1da177e4 3947
0ba21762 3948 list_for_each_entry(codec, &bus->codec_list, list) {
d804ad92
ML		 3949 if (snd_hda_codec_needs_resume(codec))
3950 hda_call_codec_resume(codec);
1da177e4 3951 }
1da177e4
LT		 3952 return 0;
3953}
ff7a3267 3954EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 3955#endif /* CONFIG_PM */
b2e18597
TI		 3956
3957/*
3958 * generic arrays
3959 */
3960
3961/* get a new element from the given array
3962 * if it exceeds the pre-allocated array size, re-allocate the array
3963 */
3964void *snd_array_new(struct snd_array *array)
3965{
3966 if (array->used >= array->alloced) {
3967 int num = array->alloced + array->alloc_align;
b910d9ae
TI		 3968 void *nlist;
3969 if (snd_BUG_ON(num >= 4096))
3970 return NULL;
3971 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
b2e18597
TI		 3972 if (!nlist)
3973 return NULL;
3974 if (array->list) {
3975 memcpy(nlist, array->list,
3976 array->elem_size * array->alloced);
3977 kfree(array->list);
3978 }
3979 array->list = nlist;
3980 array->alloced = num;
3981 }
f43aa025 3982 return snd_array_elem(array, array->used++);
b2e18597 3983}
ff7a3267 3984EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597
TI		 3985
3986/* free the given array elements */
3987void snd_array_free(struct snd_array *array)
3988{
3989 kfree(array->list);
3990 array->used = 0;
3991 array->alloced = 0;
3992 array->list = NULL;
3993}
ff7a3267 3994EXPORT_SYMBOL_HDA(snd_array_free);
b2022266
TI		 3995
3996/*
3997 * used by hda_proc.c and hda_eld.c
3998 */
3999void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4000{
4001 static unsigned int rates[] = {
4002 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4003 96000, 176400, 192000, 384000
4004 };
4005 int i, j;
4006
4007 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4008 if (pcm & (1 << i))
4009 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4010
4011 buf[j] = '\0'; /* necessary when j == 0 */
4012}
ff7a3267 4013EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
b2022266
TI		 4014
4015void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4016{
4017 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4018 int i, j;
4019
4020 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4021 if (pcm & (AC_SUPPCM_BITS_8 << i))
4022 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4023
4024 buf[j] = '\0'; /* necessary when j == 0 */
4025}
ff7a3267 4026EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 4027
4028MODULE_DESCRIPTION("HDA codec core");
4029MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.745203 seconds and 5 git commands to generate.