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