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