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