projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - move snd_hda_pcm_type_name from hda_codec.h to hda_local.h
[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 1525
9c96fa59 1526 if (kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) {
4d02d1b6
JK		 1527 if (nid == 0)
1528 nid = kctl->id.subdevice & 0xffff;
1529 kctl->id.subdevice = 0;
1530 }
d13bd412
TI		 1531 err = snd_ctl_add(codec->bus->card, kctl);
1532 if (err < 0)
1533 return err;
3911a4c1
JK		 1534 item = snd_array_new(&codec->mixers);
1535 if (!item)
d13bd412 1536 return -ENOMEM;
3911a4c1
JK		 1537 item->kctl = kctl;
1538 item->nid = nid;
d13bd412
TI		 1539 return 0;
1540}
ff7a3267 1541EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
d13bd412
TI		 1542
1543/* Clear all controls assigned to the given codec */
1544void snd_hda_ctls_clear(struct hda_codec *codec)
1545{
1546 int i;
3911a4c1 1547 struct hda_nid_item *items = codec->mixers.list;
d13bd412 1548 for (i = 0; i < codec->mixers.used; i++)
3911a4c1 1549 snd_ctl_remove(codec->bus->card, items[i].kctl);
d13bd412
TI		 1550 snd_array_free(&codec->mixers);
1551}
1552
a65d629c
TI		 1553/* pseudo device locking
1554 * toggle card->shutdown to allow/disallow the device access (as a hack)
1555 */
1556static int hda_lock_devices(struct snd_card *card)
6c1f45ea 1557{
a65d629c
TI		 1558 spin_lock(&card->files_lock);
1559 if (card->shutdown) {
1560 spin_unlock(&card->files_lock);
1561 return -EINVAL;
1562 }
1563 card->shutdown = 1;
1564 spin_unlock(&card->files_lock);
1565 return 0;
1566}
1567
1568static void hda_unlock_devices(struct snd_card *card)
1569{
1570 spin_lock(&card->files_lock);
1571 card->shutdown = 0;
1572 spin_unlock(&card->files_lock);
1573}
1574
1575int snd_hda_codec_reset(struct hda_codec *codec)
1576{
1577 struct snd_card *card = codec->bus->card;
1578 int i, pcm;
1579
1580 if (hda_lock_devices(card) < 0)
1581 return -EBUSY;
1582 /* check whether the codec isn't used by any mixer or PCM streams */
1583 if (!list_empty(&card->ctl_files)) {
1584 hda_unlock_devices(card);
1585 return -EBUSY;
1586 }
1587 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
1588 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
1589 if (!cpcm->pcm)
1590 continue;
1591 if (cpcm->pcm->streams[0].substream_opened ||
1592 cpcm->pcm->streams[1].substream_opened) {
1593 hda_unlock_devices(card);
1594 return -EBUSY;
1595 }
1596 }
1597
1598 /* OK, let it free */
6c1f45ea
TI		 1599
1600#ifdef CONFIG_SND_HDA_POWER_SAVE
1601 cancel_delayed_work(&codec->power_work);
6acaed38 1602 flush_workqueue(codec->bus->workq);
6c1f45ea
TI		 1603#endif
1604 snd_hda_ctls_clear(codec);
1605 /* relase PCMs */
1606 for (i = 0; i < codec->num_pcms; i++) {
529bd6c4 1607 if (codec->pcm_info[i].pcm) {
a65d629c 1608 snd_device_free(card, codec->pcm_info[i].pcm);
529bd6c4
TI		 1609 clear_bit(codec->pcm_info[i].device,
1610 codec->bus->pcm_dev_bits);
1611 }
6c1f45ea
TI		 1612 }
1613 if (codec->patch_ops.free)
1614 codec->patch_ops.free(codec);
56d17712 1615 codec->proc_widget_hook = NULL;
6c1f45ea
TI		 1616 codec->spec = NULL;
1617 free_hda_cache(&codec->amp_cache);
1618 free_hda_cache(&codec->cmd_cache);
827057f5
TI		 1619 init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
1620 init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
346ff70f
TI		 1621 /* free only driver_pins so that init_pins + user_pins are restored */
1622 snd_array_free(&codec->driver_pins);
3be14149 1623 restore_pincfgs(codec);
6c1f45ea
TI		 1624 codec->num_pcms = 0;
1625 codec->pcm_info = NULL;
1626 codec->preset = NULL;
d1f1af2d
TI		 1627 memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
1628 codec->slave_dig_outs = NULL;
1629 codec->spdif_status_reset = 0;
1289e9e8
TI		 1630 module_put(codec->owner);
1631 codec->owner = NULL;
a65d629c
TI		 1632
1633 /* allow device access again */
1634 hda_unlock_devices(card);
1635 return 0;
6c1f45ea
TI		 1636}
1637
2134ea4f
TI		 1638/* create a virtual master control and add slaves */
1639int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
1640 unsigned int *tlv, const char **slaves)
1641{
1642 struct snd_kcontrol *kctl;
1643 const char **s;
1644 int err;
1645
2f085549
TI		 1646 for (s = slaves; *s && !snd_hda_find_mixer_ctl(codec, *s); s++)
1647 ;
1648 if (!*s) {
1649 snd_printdd("No slave found for %s\n", name);
1650 return 0;
1651 }
2134ea4f
TI		 1652 kctl = snd_ctl_make_virtual_master(name, tlv);
1653 if (!kctl)
1654 return -ENOMEM;
3911a4c1 1655 err = snd_hda_ctl_add(codec, 0, kctl);
2134ea4f
TI		 1656 if (err < 0)
1657 return err;
1658
1659 for (s = slaves; *s; s++) {
1660 struct snd_kcontrol *sctl;
7a411ee0
TI		 1661 int i = 0;
1662 for (;;) {
1663 sctl = _snd_hda_find_mixer_ctl(codec, *s, i);
1664 if (!sctl) {
1665 if (!i)
1666 snd_printdd("Cannot find slave %s, "
1667 "skipped\n", *s);
1668 break;
1669 }
1670 err = snd_ctl_add_slave(kctl, sctl);
1671 if (err < 0)
1672 return err;
1673 i++;
2134ea4f 1674 }
2134ea4f
TI		 1675 }
1676 return 0;
1677}
ff7a3267 1678EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
2134ea4f 1679
1da177e4 1680/* switch */
0ba21762
TI		 1681int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
1682 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1683{
1684 int chs = get_amp_channels(kcontrol);
1685
1686 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1687 uinfo->count = chs == 3 ? 2 : 1;
1688 uinfo->value.integer.min = 0;
1689 uinfo->value.integer.max = 1;
1690 return 0;
1691}
ff7a3267 1692EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
1da177e4 1693
0ba21762
TI		 1694int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
1695 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1696{
1697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1698 hda_nid_t nid = get_amp_nid(kcontrol);
1699 int chs = get_amp_channels(kcontrol);
1700 int dir = get_amp_direction(kcontrol);
1701 int idx = get_amp_index(kcontrol);
1702 long *valp = ucontrol->value.integer.value;
1703
1704 if (chs & 1)
0ba21762 1705 *valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
47fd830a 1706 HDA_AMP_MUTE) ? 0 : 1;
1da177e4 1707 if (chs & 2)
0ba21762 1708 *valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
47fd830a 1709 HDA_AMP_MUTE) ? 0 : 1;
1da177e4
LT		 1710 return 0;
1711}
ff7a3267 1712EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
1da177e4 1713
0ba21762
TI		 1714int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
1715 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1716{
1717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1718 hda_nid_t nid = get_amp_nid(kcontrol);
1719 int chs = get_amp_channels(kcontrol);
1720 int dir = get_amp_direction(kcontrol);
1721 int idx = get_amp_index(kcontrol);
1da177e4
LT		 1722 long *valp = ucontrol->value.integer.value;
1723 int change = 0;
1724
cb53c626 1725 snd_hda_power_up(codec);
b9f5a89c 1726 if (chs & 1) {
4a19faee 1727 change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
47fd830a
TI		 1728 HDA_AMP_MUTE,
1729 *valp ? 0 : HDA_AMP_MUTE);
b9f5a89c
NG		 1730 valp++;
1731 }
4a19faee
TI		 1732 if (chs & 2)
1733 change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
47fd830a
TI		 1734 HDA_AMP_MUTE,
1735 *valp ? 0 : HDA_AMP_MUTE);
cb53c626
TI		 1736#ifdef CONFIG_SND_HDA_POWER_SAVE
1737 if (codec->patch_ops.check_power_status)
1738 codec->patch_ops.check_power_status(codec, nid);
1739#endif
1740 snd_hda_power_down(codec);
1da177e4
LT		 1741 return change;
1742}
ff7a3267 1743EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
1da177e4 1744
123c07ae
JK		 1745int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
1746 struct snd_ctl_elem_value *ucontrol)
1747{
1748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1749 long *valp = ucontrol->value.integer.value;
1750
1751 snd_hda_enable_beep_device(codec, *valp);
1752 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1753}
1754EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
1755
985be54b
TI		 1756/*
1757 * bound volume controls
1758 *
1759 * bind multiple volumes (# indices, from 0)
1760 */
1761
1762#define AMP_VAL_IDX_SHIFT 19
1763#define AMP_VAL_IDX_MASK (0x0f<<19)
1764
0ba21762
TI		 1765int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
1766 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1767{
1768 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1769 unsigned long pval;
1770 int err;
1771
5a9e02e9 1772 mutex_lock(&codec->control_mutex);
985be54b
TI		 1773 pval = kcontrol->private_value;
1774 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1775 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1776 kcontrol->private_value = pval;
5a9e02e9 1777 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1778 return err;
1779}
ff7a3267 1780EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
985be54b 1781
0ba21762
TI		 1782int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
1783 struct snd_ctl_elem_value *ucontrol)
985be54b
TI		 1784{
1785 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1786 unsigned long pval;
1787 int i, indices, err = 0, change = 0;
1788
5a9e02e9 1789 mutex_lock(&codec->control_mutex);
985be54b
TI		 1790 pval = kcontrol->private_value;
1791 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1792 for (i = 0; i < indices; i++) {
0ba21762
TI		 1793 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1794 (i << AMP_VAL_IDX_SHIFT);
985be54b
TI		 1795 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1796 if (err < 0)
1797 break;
1798 change |= err;
1799 }
1800 kcontrol->private_value = pval;
5a9e02e9 1801 mutex_unlock(&codec->control_mutex);
985be54b
TI		 1802 return err < 0 ? err : change;
1803}
ff7a3267 1804EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
985be54b 1805
532d5381
TI		 1806/*
1807 * generic bound volume/swtich controls
1808 */
1809int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
1810 struct snd_ctl_elem_info *uinfo)
1811{
1812 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1813 struct hda_bind_ctls *c;
1814 int err;
1815
5a9e02e9 1816 mutex_lock(&codec->control_mutex);
14c65f98 1817 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1818 kcontrol->private_value = *c->values;
1819 err = c->ops->info(kcontrol, uinfo);
1820 kcontrol->private_value = (long)c;
5a9e02e9 1821 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1822 return err;
1823}
ff7a3267 1824EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
532d5381
TI		 1825
1826int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
1827 struct snd_ctl_elem_value *ucontrol)
1828{
1829 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1830 struct hda_bind_ctls *c;
1831 int err;
1832
5a9e02e9 1833 mutex_lock(&codec->control_mutex);
14c65f98 1834 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1835 kcontrol->private_value = *c->values;
1836 err = c->ops->get(kcontrol, ucontrol);
1837 kcontrol->private_value = (long)c;
5a9e02e9 1838 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1839 return err;
1840}
ff7a3267 1841EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
532d5381
TI		 1842
1843int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
1844 struct snd_ctl_elem_value *ucontrol)
1845{
1846 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1847 struct hda_bind_ctls *c;
1848 unsigned long *vals;
1849 int err = 0, change = 0;
1850
5a9e02e9 1851 mutex_lock(&codec->control_mutex);
14c65f98 1852 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1853 for (vals = c->values; *vals; vals++) {
1854 kcontrol->private_value = *vals;
1855 err = c->ops->put(kcontrol, ucontrol);
1856 if (err < 0)
1857 break;
1858 change |= err;
1859 }
1860 kcontrol->private_value = (long)c;
5a9e02e9 1861 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1862 return err < 0 ? err : change;
1863}
ff7a3267 1864EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
532d5381
TI		 1865
1866int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1867 unsigned int size, unsigned int __user *tlv)
1868{
1869 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1870 struct hda_bind_ctls *c;
1871 int err;
1872
5a9e02e9 1873 mutex_lock(&codec->control_mutex);
14c65f98 1874 c = (struct hda_bind_ctls *)kcontrol->private_value;
532d5381
TI		 1875 kcontrol->private_value = *c->values;
1876 err = c->ops->tlv(kcontrol, op_flag, size, tlv);
1877 kcontrol->private_value = (long)c;
5a9e02e9 1878 mutex_unlock(&codec->control_mutex);
532d5381
TI		 1879 return err;
1880}
ff7a3267 1881EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_tlv);
532d5381
TI		 1882
1883struct hda_ctl_ops snd_hda_bind_vol = {
1884 .info = snd_hda_mixer_amp_volume_info,
1885 .get = snd_hda_mixer_amp_volume_get,
1886 .put = snd_hda_mixer_amp_volume_put,
1887 .tlv = snd_hda_mixer_amp_tlv
1888};
ff7a3267 1889EXPORT_SYMBOL_HDA(snd_hda_bind_vol);
532d5381
TI		 1890
1891struct hda_ctl_ops snd_hda_bind_sw = {
1892 .info = snd_hda_mixer_amp_switch_info,
1893 .get = snd_hda_mixer_amp_switch_get,
1894 .put = snd_hda_mixer_amp_switch_put,
1895 .tlv = snd_hda_mixer_amp_tlv
1896};
ff7a3267 1897EXPORT_SYMBOL_HDA(snd_hda_bind_sw);
532d5381 1898
1da177e4
LT		 1899/*
1900 * SPDIF out controls
1901 */
1902
0ba21762
TI		 1903static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
1904 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 1905{
1906 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1907 uinfo->count = 1;
1908 return 0;
1909}
1910
0ba21762
TI		 1911static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
1912 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1913{
1914 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1915 IEC958_AES0_NONAUDIO |
1916 IEC958_AES0_CON_EMPHASIS_5015 |
1917 IEC958_AES0_CON_NOT_COPYRIGHT;
1918 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
1919 IEC958_AES1_CON_ORIGINAL;
1920 return 0;
1921}
1922
0ba21762
TI		 1923static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
1924 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1925{
1926 ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
1927 IEC958_AES0_NONAUDIO |
1928 IEC958_AES0_PRO_EMPHASIS_5015;
1929 return 0;
1930}
1931
0ba21762
TI		 1932static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
1933 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 1934{
1935 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1936
1937 ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
1938 ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
1939 ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
1940 ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
1941
1942 return 0;
1943}
1944
1945/* convert from SPDIF status bits to HDA SPDIF bits
1946 * bit 0 (DigEn) is always set zero (to be filled later)
1947 */
1948static unsigned short convert_from_spdif_status(unsigned int sbits)
1949{
1950 unsigned short val = 0;
1951
1952 if (sbits & IEC958_AES0_PROFESSIONAL)
0ba21762 1953 val |= AC_DIG1_PROFESSIONAL;
1da177e4 1954 if (sbits & IEC958_AES0_NONAUDIO)
0ba21762 1955 val |= AC_DIG1_NONAUDIO;
1da177e4 1956 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762
TI		 1957 if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
1958 IEC958_AES0_PRO_EMPHASIS_5015)
1959 val |= AC_DIG1_EMPHASIS;
1da177e4 1960 } else {
0ba21762
TI		 1961 if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
1962 IEC958_AES0_CON_EMPHASIS_5015)
1963 val |= AC_DIG1_EMPHASIS;
1964 if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
1965 val |= AC_DIG1_COPYRIGHT;
1da177e4 1966 if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
0ba21762 1967 val |= AC_DIG1_LEVEL;
1da177e4
LT		 1968 val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
1969 }
1970 return val;
1971}
1972
1973/* convert to SPDIF status bits from HDA SPDIF bits
1974 */
1975static unsigned int convert_to_spdif_status(unsigned short val)
1976{
1977 unsigned int sbits = 0;
1978
0ba21762 1979 if (val & AC_DIG1_NONAUDIO)
1da177e4 1980 sbits |= IEC958_AES0_NONAUDIO;
0ba21762 1981 if (val & AC_DIG1_PROFESSIONAL)
1da177e4
LT		 1982 sbits |= IEC958_AES0_PROFESSIONAL;
1983 if (sbits & IEC958_AES0_PROFESSIONAL) {
0ba21762 1984 if (sbits & AC_DIG1_EMPHASIS)
1da177e4
LT		 1985 sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
1986 } else {
0ba21762 1987 if (val & AC_DIG1_EMPHASIS)
1da177e4 1988 sbits |= IEC958_AES0_CON_EMPHASIS_5015;
0ba21762 1989 if (!(val & AC_DIG1_COPYRIGHT))
1da177e4 1990 sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
0ba21762 1991 if (val & AC_DIG1_LEVEL)
1da177e4
LT		 1992 sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
1993 sbits |= val & (0x7f << 8);
1994 }
1995 return sbits;
1996}
1997
2f72853c
TI		 1998/* set digital convert verbs both for the given NID and its slaves */
1999static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
2000 int verb, int val)
2001{
2002 hda_nid_t *d;
2003
9e976976 2004 snd_hda_codec_write_cache(codec, nid, 0, verb, val);
2f72853c
TI		 2005 d = codec->slave_dig_outs;
2006 if (!d)
2007 return;
2008 for (; *d; d++)
9e976976 2009 snd_hda_codec_write_cache(codec, *d, 0, verb, val);
2f72853c
TI		 2010}
2011
2012static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
2013 int dig1, int dig2)
2014{
2015 if (dig1 != -1)
2016 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_1, dig1);
2017 if (dig2 != -1)
2018 set_dig_out(codec, nid, AC_VERB_SET_DIGI_CONVERT_2, dig2);
2019}
2020
0ba21762
TI		 2021static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
2022 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2023{
2024 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2025 hda_nid_t nid = kcontrol->private_value;
2026 unsigned short val;
2027 int change;
2028
62932df8 2029 mutex_lock(&codec->spdif_mutex);
1da177e4
LT		 2030 codec->spdif_status = ucontrol->value.iec958.status[0] |
2031 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
2032 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
2033 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
2034 val = convert_from_spdif_status(codec->spdif_status);
2035 val |= codec->spdif_ctls & 1;
2036 change = codec->spdif_ctls != val;
2037 codec->spdif_ctls = val;
2038
2f72853c
TI		 2039 if (change)
2040 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
1da177e4 2041
62932df8 2042 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2043 return change;
2044}
2045
a5ce8890 2046#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
1da177e4 2047
0ba21762
TI		 2048static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
2049 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2050{
2051 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2052
0ba21762 2053 ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
1da177e4
LT		 2054 return 0;
2055}
2056
0ba21762
TI		 2057static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
2058 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2059{
2060 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2061 hda_nid_t nid = kcontrol->private_value;
2062 unsigned short val;
2063 int change;
2064
62932df8 2065 mutex_lock(&codec->spdif_mutex);
0ba21762 2066 val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
1da177e4 2067 if (ucontrol->value.integer.value[0])
0ba21762 2068 val |= AC_DIG1_ENABLE;
1da177e4 2069 change = codec->spdif_ctls != val;
82beb8fd 2070 if (change) {
1da177e4 2071 codec->spdif_ctls = val;
2f72853c 2072 set_dig_out_convert(codec, nid, val & 0xff, -1);
0ba21762
TI		 2073 /* unmute amp switch (if any) */
2074 if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
47fd830a
TI		 2075 (val & AC_DIG1_ENABLE))
2076 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2077 HDA_AMP_MUTE, 0);
1da177e4 2078 }
62932df8 2079 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2080 return change;
2081}
2082
c8b6bf9b 2083static struct snd_kcontrol_new dig_mixes[] = {
1da177e4
LT		 2084 {
2085 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2086 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2087 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
2088 .info = snd_hda_spdif_mask_info,
2089 .get = snd_hda_spdif_cmask_get,
2090 },
2091 {
2092 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2093 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2094 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
2095 .info = snd_hda_spdif_mask_info,
2096 .get = snd_hda_spdif_pmask_get,
2097 },
2098 {
2099 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2100 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2101 .info = snd_hda_spdif_mask_info,
2102 .get = snd_hda_spdif_default_get,
2103 .put = snd_hda_spdif_default_put,
2104 },
2105 {
2106 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2107 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2108 .info = snd_hda_spdif_out_switch_info,
2109 .get = snd_hda_spdif_out_switch_get,
2110 .put = snd_hda_spdif_out_switch_put,
2111 },
2112 { } /* end */
2113};
2114
09f99701
TI		 2115#define SPDIF_MAX_IDX 4 /* 4 instances should be enough to probe */
2116
1da177e4
LT		 2117/**
2118 * snd_hda_create_spdif_out_ctls - create Output SPDIF-related controls
2119 * @codec: the HDA codec
2120 * @nid: audio out widget NID
2121 *
2122 * Creates controls related with the SPDIF output.
2123 * Called from each patch supporting the SPDIF out.
2124 *
2125 * Returns 0 if successful, or a negative error code.
2126 */
12f288bf 2127int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2128{
2129 int err;
c8b6bf9b
TI		 2130 struct snd_kcontrol *kctl;
2131 struct snd_kcontrol_new *dig_mix;
09f99701 2132 int idx;
1da177e4 2133
09f99701
TI		 2134 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2135 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Playback Switch",
2136 idx))
2137 break;
2138 }
2139 if (idx >= SPDIF_MAX_IDX) {
2140 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
2141 return -EBUSY;
2142 }
1da177e4
LT		 2143 for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
2144 kctl = snd_ctl_new1(dig_mix, codec);
b91f080f
TI		 2145 if (!kctl)
2146 return -ENOMEM;
09f99701 2147 kctl->id.index = idx;
1da177e4 2148 kctl->private_value = nid;
3911a4c1 2149 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 2150 if (err < 0)
1da177e4
LT		 2151 return err;
2152 }
0ba21762 2153 codec->spdif_ctls =
3982d17e
AP		 2154 snd_hda_codec_read(codec, nid, 0,
2155 AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2156 codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
2157 return 0;
2158}
ff7a3267 2159EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
1da177e4 2160
9a08160b
TI		 2161/*
2162 * SPDIF sharing with analog output
2163 */
2164static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
2165 struct snd_ctl_elem_value *ucontrol)
2166{
2167 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2168 ucontrol->value.integer.value[0] = mout->share_spdif;
2169 return 0;
2170}
2171
2172static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
2173 struct snd_ctl_elem_value *ucontrol)
2174{
2175 struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
2176 mout->share_spdif = !!ucontrol->value.integer.value[0];
2177 return 0;
2178}
2179
2180static struct snd_kcontrol_new spdif_share_sw = {
2181 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2182 .name = "IEC958 Default PCM Playback Switch",
2183 .info = snd_ctl_boolean_mono_info,
2184 .get = spdif_share_sw_get,
2185 .put = spdif_share_sw_put,
2186};
2187
2188int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
2189 struct hda_multi_out *mout)
2190{
2191 if (!mout->dig_out_nid)
2192 return 0;
2193 /* ATTENTION: here mout is passed as private_data, instead of codec */
3911a4c1
JK		 2194 return snd_hda_ctl_add(codec, mout->dig_out_nid,
2195 snd_ctl_new1(&spdif_share_sw, mout));
9a08160b 2196}
ff7a3267 2197EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
9a08160b 2198
1da177e4
LT		 2199/*
2200 * SPDIF input
2201 */
2202
2203#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
2204
0ba21762
TI		 2205static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
2206 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2207{
2208 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2209
2210 ucontrol->value.integer.value[0] = codec->spdif_in_enable;
2211 return 0;
2212}
2213
0ba21762
TI		 2214static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
2215 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2216{
2217 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2218 hda_nid_t nid = kcontrol->private_value;
2219 unsigned int val = !!ucontrol->value.integer.value[0];
2220 int change;
2221
62932df8 2222 mutex_lock(&codec->spdif_mutex);
1da177e4 2223 change = codec->spdif_in_enable != val;
82beb8fd 2224 if (change) {
1da177e4 2225 codec->spdif_in_enable = val;
82beb8fd
TI		 2226 snd_hda_codec_write_cache(codec, nid, 0,
2227 AC_VERB_SET_DIGI_CONVERT_1, val);
1da177e4 2228 }
62932df8 2229 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 2230 return change;
2231}
2232
0ba21762
TI		 2233static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
2234 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 2235{
2236 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2237 hda_nid_t nid = kcontrol->private_value;
2238 unsigned short val;
2239 unsigned int sbits;
2240
3982d17e 2241 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DIGI_CONVERT_1, 0);
1da177e4
LT		 2242 sbits = convert_to_spdif_status(val);
2243 ucontrol->value.iec958.status[0] = sbits;
2244 ucontrol->value.iec958.status[1] = sbits >> 8;
2245 ucontrol->value.iec958.status[2] = sbits >> 16;
2246 ucontrol->value.iec958.status[3] = sbits >> 24;
2247 return 0;
2248}
2249
c8b6bf9b 2250static struct snd_kcontrol_new dig_in_ctls[] = {
1da177e4
LT		 2251 {
2252 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2253 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
2254 .info = snd_hda_spdif_in_switch_info,
2255 .get = snd_hda_spdif_in_switch_get,
2256 .put = snd_hda_spdif_in_switch_put,
2257 },
2258 {
2259 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2260 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2261 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
2262 .info = snd_hda_spdif_mask_info,
2263 .get = snd_hda_spdif_in_status_get,
2264 },
2265 { } /* end */
2266};
2267
2268/**
2269 * snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
2270 * @codec: the HDA codec
2271 * @nid: audio in widget NID
2272 *
2273 * Creates controls related with the SPDIF input.
2274 * Called from each patch supporting the SPDIF in.
2275 *
2276 * Returns 0 if successful, or a negative error code.
2277 */
12f288bf 2278int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
1da177e4
LT		 2279{
2280 int err;
c8b6bf9b
TI		 2281 struct snd_kcontrol *kctl;
2282 struct snd_kcontrol_new *dig_mix;
09f99701 2283 int idx;
1da177e4 2284
09f99701
TI		 2285 for (idx = 0; idx < SPDIF_MAX_IDX; idx++) {
2286 if (!_snd_hda_find_mixer_ctl(codec, "IEC958 Capture Switch",
2287 idx))
2288 break;
2289 }
2290 if (idx >= SPDIF_MAX_IDX) {
2291 printk(KERN_ERR "hda_codec: too many IEC958 inputs\n");
2292 return -EBUSY;
2293 }
1da177e4
LT		 2294 for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
2295 kctl = snd_ctl_new1(dig_mix, codec);
c8dcdf82
TI		 2296 if (!kctl)
2297 return -ENOMEM;
1da177e4 2298 kctl->private_value = nid;
3911a4c1 2299 err = snd_hda_ctl_add(codec, nid, kctl);
0ba21762 2300 if (err < 0)
1da177e4
LT		 2301 return err;
2302 }
0ba21762 2303 codec->spdif_in_enable =
3982d17e
AP		 2304 snd_hda_codec_read(codec, nid, 0,
2305 AC_VERB_GET_DIGI_CONVERT_1, 0) &
0ba21762 2306 AC_DIG1_ENABLE;
1da177e4
LT		 2307 return 0;
2308}
ff7a3267 2309EXPORT_SYMBOL_HDA(snd_hda_create_spdif_in_ctls);
1da177e4 2310
cb53c626 2311#ifdef SND_HDA_NEEDS_RESUME
82beb8fd
TI		 2312/*
2313 * command cache
2314 */
1da177e4 2315
b3ac5636
TI		 2316/* build a 32bit cache key with the widget id and the command parameter */
2317#define build_cmd_cache_key(nid, verb) ((verb << 8) | nid)
2318#define get_cmd_cache_nid(key) ((key) & 0xff)
2319#define get_cmd_cache_cmd(key) (((key) >> 8) & 0xffff)
2320
2321/**
2322 * snd_hda_codec_write_cache - send a single command with caching
2323 * @codec: the HDA codec
2324 * @nid: NID to send the command
2325 * @direct: direct flag
2326 * @verb: the verb to send
2327 * @parm: the parameter for the verb
2328 *
2329 * Send a single command without waiting for response.
2330 *
2331 * Returns 0 if successful, or a negative error code.
2332 */
2333int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
2334 int direct, unsigned int verb, unsigned int parm)
2335{
aa2936f5
TI		 2336 int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
2337 struct hda_cache_head *c;
2338 u32 key;
33fa35ed 2339
aa2936f5
TI		 2340 if (err < 0)
2341 return err;
2342 /* parm may contain the verb stuff for get/set amp */
2343 verb = verb | (parm >> 8);
2344 parm &= 0xff;
2345 key = build_cmd_cache_key(nid, verb);
2346 mutex_lock(&codec->bus->cmd_mutex);
2347 c = get_alloc_hash(&codec->cmd_cache, key);
2348 if (c)
2349 c->val = parm;
2350 mutex_unlock(&codec->bus->cmd_mutex);
2351 return 0;
b3ac5636 2352}
ff7a3267 2353EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
b3ac5636
TI		 2354
2355/* resume the all commands from the cache */
2356void snd_hda_codec_resume_cache(struct hda_codec *codec)
2357{
603c4019 2358 struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
b3ac5636
TI		 2359 int i;
2360
603c4019 2361 for (i = 0; i < codec->cmd_cache.buf.used; i++, buffer++) {
b3ac5636
TI		 2362 u32 key = buffer->key;
2363 if (!key)
2364 continue;
2365 snd_hda_codec_write(codec, get_cmd_cache_nid(key), 0,
2366 get_cmd_cache_cmd(key), buffer->val);
2367 }
2368}
ff7a3267 2369EXPORT_SYMBOL_HDA(snd_hda_codec_resume_cache);
b3ac5636
TI		 2370
2371/**
2372 * snd_hda_sequence_write_cache - sequence writes with caching
2373 * @codec: the HDA codec
2374 * @seq: VERB array to send
2375 *
2376 * Send the commands sequentially from the given array.
2377 * Thte commands are recorded on cache for power-save and resume.
2378 * The array must be terminated with NID=0.
2379 */
2380void snd_hda_sequence_write_cache(struct hda_codec *codec,
2381 const struct hda_verb *seq)
2382{
2383 for (; seq->nid; seq++)
2384 snd_hda_codec_write_cache(codec, seq->nid, 0, seq->verb,
2385 seq->param);
2386}
ff7a3267 2387EXPORT_SYMBOL_HDA(snd_hda_sequence_write_cache);
cb53c626 2388#endif /* SND_HDA_NEEDS_RESUME */
b3ac5636 2389
54d17403
TI		 2390/*
2391 * set power state of the codec
2392 */
2393static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
2394 unsigned int power_state)
2395{
cb53c626
TI		 2396 hda_nid_t nid;
2397 int i;
54d17403 2398
05ff7e11
TI		 2399 /* this delay seems necessary to avoid click noise at power-down */
2400 if (power_state == AC_PWRST_D3)
2401 msleep(100);
2402 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
54d17403 2403 power_state);
05ff7e11
TI		 2404 /* partial workaround for "azx_get_response timeout" */
2405 if (power_state == AC_PWRST_D0)
2406 msleep(10);
54d17403 2407
cb53c626
TI		 2408 nid = codec->start_nid;
2409 for (i = 0; i < codec->num_nodes; i++, nid++) {
7eba5c9d
TI		 2410 unsigned int wcaps = get_wcaps(codec, nid);
2411 if (wcaps & AC_WCAP_POWER) {
a22d543a 2412 unsigned int wid_type = get_wcaps_type(wcaps);
a3b48c88
TI		 2413 if (power_state == AC_PWRST_D3 &&
2414 wid_type == AC_WID_PIN) {
7eba5c9d
TI		 2415 unsigned int pincap;
2416 /*
2417 * don't power down the widget if it controls
2418 * eapd and EAPD_BTLENABLE is set.
2419 */
14bafe32 2420 pincap = snd_hda_query_pin_caps(codec, nid);
7eba5c9d
TI		 2421 if (pincap & AC_PINCAP_EAPD) {
2422 int eapd = snd_hda_codec_read(codec,
2423 nid, 0,
2424 AC_VERB_GET_EAPD_BTLENABLE, 0);
2425 eapd &= 0x02;
a3b48c88 2426 if (eapd)
7eba5c9d
TI		 2427 continue;
2428 }
1194b5b7 2429 }
54d17403
TI		 2430 snd_hda_codec_write(codec, nid, 0,
2431 AC_VERB_SET_POWER_STATE,
2432 power_state);
1194b5b7 2433 }
54d17403
TI		 2434 }
2435
cb53c626
TI		 2436 if (power_state == AC_PWRST_D0) {
2437 unsigned long end_time;
2438 int state;
54d17403 2439 msleep(10);
cb53c626
TI		 2440 /* wait until the codec reachs to D0 */
2441 end_time = jiffies + msecs_to_jiffies(500);
2442 do {
2443 state = snd_hda_codec_read(codec, fg, 0,
2444 AC_VERB_GET_POWER_STATE, 0);
2445 if (state == power_state)
2446 break;
2447 msleep(1);
2448 } while (time_after_eq(end_time, jiffies));
2449 }
2450}
2451
11aeff08
TI		 2452#ifdef CONFIG_SND_HDA_HWDEP
2453/* execute additional init verbs */
2454static void hda_exec_init_verbs(struct hda_codec *codec)
2455{
2456 if (codec->init_verbs.list)
2457 snd_hda_sequence_write(codec, codec->init_verbs.list);
2458}
2459#else
2460static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
2461#endif
2462
cb53c626
TI		 2463#ifdef SND_HDA_NEEDS_RESUME
2464/*
2465 * call suspend and power-down; used both from PM and power-save
2466 */
2467static void hda_call_codec_suspend(struct hda_codec *codec)
2468{
2469 if (codec->patch_ops.suspend)
2470 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
2471 hda_set_power_state(codec,
2472 codec->afg ? codec->afg : codec->mfg,
2473 AC_PWRST_D3);
2474#ifdef CONFIG_SND_HDA_POWER_SAVE
a2f6309e 2475 snd_hda_update_power_acct(codec);
cb53c626 2476 cancel_delayed_work(&codec->power_work);
95e99fda 2477 codec->power_on = 0;
a221e287 2478 codec->power_transition = 0;
a2f6309e 2479 codec->power_jiffies = jiffies;
cb53c626 2480#endif
54d17403
TI		 2481}
2482
cb53c626
TI		 2483/*
2484 * kick up codec; used both from PM and power-save
2485 */
2486static void hda_call_codec_resume(struct hda_codec *codec)
2487{
2488 hda_set_power_state(codec,
2489 codec->afg ? codec->afg : codec->mfg,
2490 AC_PWRST_D0);
3be14149 2491 restore_pincfgs(codec); /* restore all current pin configs */
11aeff08 2492 hda_exec_init_verbs(codec);
cb53c626
TI		 2493 if (codec->patch_ops.resume)
2494 codec->patch_ops.resume(codec);
2495 else {
9d99f312
TI		 2496 if (codec->patch_ops.init)
2497 codec->patch_ops.init(codec);
cb53c626
TI		 2498 snd_hda_codec_resume_amp(codec);
2499 snd_hda_codec_resume_cache(codec);
2500 }
2501}
2502#endif /* SND_HDA_NEEDS_RESUME */
2503
54d17403 2504
1da177e4
LT		 2505/**
2506 * snd_hda_build_controls - build mixer controls
2507 * @bus: the BUS
2508 *
2509 * Creates mixer controls for each codec included in the bus.
2510 *
2511 * Returns 0 if successful, otherwise a negative error code.
2512 */
1289e9e8 2513int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
1da177e4 2514{
0ba21762 2515 struct hda_codec *codec;
1da177e4 2516
0ba21762 2517 list_for_each_entry(codec, &bus->codec_list, list) {
6c1f45ea 2518 int err = snd_hda_codec_build_controls(codec);
f93d461b
TI		 2519 if (err < 0) {
2520 printk(KERN_ERR "hda_codec: cannot build controls"
2521 "for #%d (error %d)\n", codec->addr, err);
2522 err = snd_hda_codec_reset(codec);
2523 if (err < 0) {
2524 printk(KERN_ERR
2525 "hda_codec: cannot revert codec\n");
2526 return err;
2527 }
2528 }
1da177e4 2529 }
6c1f45ea
TI		 2530 return 0;
2531}
ff7a3267 2532EXPORT_SYMBOL_HDA(snd_hda_build_controls);
cb53c626 2533
6c1f45ea
TI		 2534int snd_hda_codec_build_controls(struct hda_codec *codec)
2535{
2536 int err = 0;
11aeff08 2537 hda_exec_init_verbs(codec);
6c1f45ea
TI		 2538 /* continue to initialize... */
2539 if (codec->patch_ops.init)
2540 err = codec->patch_ops.init(codec);
2541 if (!err && codec->patch_ops.build_controls)
2542 err = codec->patch_ops.build_controls(codec);
6c1f45ea
TI		 2543 if (err < 0)
2544 return err;
1da177e4
LT		 2545 return 0;
2546}
2547
1da177e4
LT		 2548/*
2549 * stream formats
2550 */
befdf316
TI		 2551struct hda_rate_tbl {
2552 unsigned int hz;
2553 unsigned int alsa_bits;
2554 unsigned int hda_fmt;
2555};
2556
2557static struct hda_rate_tbl rate_bits[] = {
1da177e4 2558 /* rate in Hz, ALSA rate bitmask, HDA format value */
9d8f53f2
NG		 2559
2560 /* autodetected value used in snd_hda_query_supported_pcm */
1da177e4
LT		 2561 { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
2562 { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
2563 { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
2564 { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
2565 { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
2566 { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
2567 { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
2568 { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
2569 { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
2570 { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
2571 { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
a961f9fe
TI		 2572#define AC_PAR_PCM_RATE_BITS 11
2573 /* up to bits 10, 384kHZ isn't supported properly */
2574
2575 /* not autodetected value */
2576 { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
9d8f53f2 2577
befdf316 2578 { 0 } /* terminator */
1da177e4
LT		 2579};
2580
2581/**
2582 * snd_hda_calc_stream_format - calculate format bitset
2583 * @rate: the sample rate
2584 * @channels: the number of channels
2585 * @format: the PCM format (SNDRV_PCM_FORMAT_XXX)
2586 * @maxbps: the max. bps
2587 *
2588 * Calculate the format bitset from the given rate, channels and th PCM format.
2589 *
2590 * Return zero if invalid.
2591 */
2592unsigned int snd_hda_calc_stream_format(unsigned int rate,
2593 unsigned int channels,
2594 unsigned int format,
2595 unsigned int maxbps)
2596{
2597 int i;
2598 unsigned int val = 0;
2599
befdf316
TI		 2600 for (i = 0; rate_bits[i].hz; i++)
2601 if (rate_bits[i].hz == rate) {
2602 val = rate_bits[i].hda_fmt;
1da177e4
LT		 2603 break;
2604 }
0ba21762 2605 if (!rate_bits[i].hz) {
1da177e4
LT		 2606 snd_printdd("invalid rate %d\n", rate);
2607 return 0;
2608 }
2609
2610 if (channels == 0 || channels > 8) {
2611 snd_printdd("invalid channels %d\n", channels);
2612 return 0;
2613 }
2614 val |= channels - 1;
2615
2616 switch (snd_pcm_format_width(format)) {
2617 case 8: val |= 0x00; break;
2618 case 16: val |= 0x10; break;
2619 case 20:
2620 case 24:
2621 case 32:
b0bb3aa6 2622 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
1da177e4
LT		 2623 val |= 0x40;
2624 else if (maxbps >= 24)
2625 val |= 0x30;
2626 else
2627 val |= 0x20;
2628 break;
2629 default:
0ba21762
TI		 2630 snd_printdd("invalid format width %d\n",
2631 snd_pcm_format_width(format));
1da177e4
LT		 2632 return 0;
2633 }
2634
2635 return val;
2636}
ff7a3267 2637EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
1da177e4 2638
92c7c8a7
TI		 2639static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2640{
2641 unsigned int val = 0;
2642 if (nid != codec->afg &&
2643 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
2644 val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
2645 if (!val || val == -1)
2646 val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
2647 if (!val || val == -1)
2648 return 0;
2649 return val;
2650}
2651
2652static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
2653{
2654 return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
2655 get_pcm_param);
2656}
2657
2658static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
2659{
2660 unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
2661 if (!streams || streams == -1)
2662 streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
2663 if (!streams || streams == -1)
2664 return 0;
2665 return streams;
2666}
2667
2668static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
2669{
2670 return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
2671 get_stream_param);
2672}
2673
1da177e4
LT		 2674/**
2675 * snd_hda_query_supported_pcm - query the supported PCM rates and formats
2676 * @codec: the HDA codec
2677 * @nid: NID to query
2678 * @ratesp: the pointer to store the detected rate bitflags
2679 * @formatsp: the pointer to store the detected formats
2680 * @bpsp: the pointer to store the detected format widths
2681 *
2682 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp
2683 * or @bsps argument is ignored.
2684 *
2685 * Returns 0 if successful, otherwise a negative error code.
2686 */
986862bd 2687static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
1da177e4
LT		 2688 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
2689{
ee504710 2690 unsigned int i, val, wcaps;
1da177e4 2691
ee504710 2692 wcaps = get_wcaps(codec, nid);
92c7c8a7 2693 val = query_pcm_param(codec, nid);
1da177e4
LT		 2694
2695 if (ratesp) {
2696 u32 rates = 0;
a961f9fe 2697 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {
1da177e4 2698 if (val & (1 << i))
befdf316 2699 rates |= rate_bits[i].alsa_bits;
1da177e4 2700 }
ee504710
JK		 2701 if (rates == 0) {
2702 snd_printk(KERN_ERR "hda_codec: rates == 0 "
2703 "(nid=0x%x, val=0x%x, ovrd=%i)\n",
2704 nid, val,
2705 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);
2706 return -EIO;
2707 }
1da177e4
LT		 2708 *ratesp = rates;
2709 }
2710
2711 if (formatsp || bpsp) {
2712 u64 formats = 0;
ee504710 2713 unsigned int streams, bps;
1da177e4 2714
92c7c8a7
TI		 2715 streams = query_stream_param(codec, nid);
2716 if (!streams)
1da177e4 2717 return -EIO;
1da177e4
LT		 2718
2719 bps = 0;
2720 if (streams & AC_SUPFMT_PCM) {
2721 if (val & AC_SUPPCM_BITS_8) {
2722 formats |= SNDRV_PCM_FMTBIT_U8;
2723 bps = 8;
2724 }
2725 if (val & AC_SUPPCM_BITS_16) {
2726 formats |= SNDRV_PCM_FMTBIT_S16_LE;
2727 bps = 16;
2728 }
2729 if (wcaps & AC_WCAP_DIGITAL) {
2730 if (val & AC_SUPPCM_BITS_32)
2731 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
2732 if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24))
2733 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2734 if (val & AC_SUPPCM_BITS_24)
2735 bps = 24;
2736 else if (val & AC_SUPPCM_BITS_20)
2737 bps = 20;
0ba21762
TI		 2738 } else if (val & (AC_SUPPCM_BITS_20|AC_SUPPCM_BITS_24|
2739 AC_SUPPCM_BITS_32)) {
1da177e4
LT		 2740 formats |= SNDRV_PCM_FMTBIT_S32_LE;
2741 if (val & AC_SUPPCM_BITS_32)
2742 bps = 32;
1da177e4
LT		 2743 else if (val & AC_SUPPCM_BITS_24)
2744 bps = 24;
33ef7651
NG		 2745 else if (val & AC_SUPPCM_BITS_20)
2746 bps = 20;
1da177e4
LT		 2747 }
2748 }
b5025c50 2749 if (streams & AC_SUPFMT_FLOAT32) {
1da177e4 2750 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
b0bb3aa6
TI		 2751 if (!bps)
2752 bps = 32;
b5025c50
TI		 2753 }
2754 if (streams == AC_SUPFMT_AC3) {
0ba21762 2755 /* should be exclusive */
1da177e4
LT		 2756 /* temporary hack: we have still no proper support
2757 * for the direct AC3 stream...
2758 */
2759 formats |= SNDRV_PCM_FMTBIT_U8;
2760 bps = 8;
2761 }
ee504710
JK		 2762 if (formats == 0) {
2763 snd_printk(KERN_ERR "hda_codec: formats == 0 "
2764 "(nid=0x%x, val=0x%x, ovrd=%i, "
2765 "streams=0x%x)\n",
2766 nid, val,
2767 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,
2768 streams);
2769 return -EIO;
2770 }
1da177e4
LT		 2771 if (formatsp)
2772 *formatsp = formats;
2773 if (bpsp)
2774 *bpsp = bps;
2775 }
2776
2777 return 0;
2778}
2779
2780/**
0ba21762
TI		 2781 * snd_hda_is_supported_format - check whether the given node supports
2782 * the format val
1da177e4
LT		 2783 *
2784 * Returns 1 if supported, 0 if not.
2785 */
2786int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
2787 unsigned int format)
2788{
2789 int i;
2790 unsigned int val = 0, rate, stream;
2791
92c7c8a7
TI		 2792 val = query_pcm_param(codec, nid);
2793 if (!val)
2794 return 0;
1da177e4
LT		 2795
2796 rate = format & 0xff00;
a961f9fe 2797 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)
befdf316 2798 if (rate_bits[i].hda_fmt == rate) {
1da177e4
LT		 2799 if (val & (1 << i))
2800 break;
2801 return 0;
2802 }
a961f9fe 2803 if (i >= AC_PAR_PCM_RATE_BITS)
1da177e4
LT		 2804 return 0;
2805
92c7c8a7
TI		 2806 stream = query_stream_param(codec, nid);
2807 if (!stream)
1da177e4
LT		 2808 return 0;
2809
2810 if (stream & AC_SUPFMT_PCM) {
2811 switch (format & 0xf0) {
2812 case 0x00:
0ba21762 2813 if (!(val & AC_SUPPCM_BITS_8))
1da177e4
LT		 2814 return 0;
2815 break;
2816 case 0x10:
0ba21762 2817 if (!(val & AC_SUPPCM_BITS_16))
1da177e4
LT		 2818 return 0;
2819 break;
2820 case 0x20:
0ba21762 2821 if (!(val & AC_SUPPCM_BITS_20))
1da177e4
LT		 2822 return 0;
2823 break;
2824 case 0x30:
0ba21762 2825 if (!(val & AC_SUPPCM_BITS_24))
1da177e4
LT		 2826 return 0;
2827 break;
2828 case 0x40:
0ba21762 2829 if (!(val & AC_SUPPCM_BITS_32))
1da177e4
LT		 2830 return 0;
2831 break;
2832 default:
2833 return 0;
2834 }
2835 } else {
2836 /* FIXME: check for float32 and AC3? */
2837 }
2838
2839 return 1;
2840}
ff7a3267 2841EXPORT_SYMBOL_HDA(snd_hda_is_supported_format);
1da177e4
LT		 2842
2843/*
2844 * PCM stuff
2845 */
2846static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
2847 struct hda_codec *codec,
c8b6bf9b 2848 struct snd_pcm_substream *substream)
1da177e4
LT		 2849{
2850 return 0;
2851}
2852
2853static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
2854 struct hda_codec *codec,
2855 unsigned int stream_tag,
2856 unsigned int format,
c8b6bf9b 2857 struct snd_pcm_substream *substream)
1da177e4
LT		 2858{
2859 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
2860 return 0;
2861}
2862
2863static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
2864 struct hda_codec *codec,
c8b6bf9b 2865 struct snd_pcm_substream *substream)
1da177e4 2866{
888afa15 2867 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1da177e4
LT		 2868 return 0;
2869}
2870
6c1f45ea
TI		 2871static int set_pcm_default_values(struct hda_codec *codec,
2872 struct hda_pcm_stream *info)
1da177e4 2873{
ee504710
JK		 2874 int err;
2875
0ba21762
TI		 2876 /* query support PCM information from the given NID */
2877 if (info->nid && (!info->rates || !info->formats)) {
ee504710 2878 err = snd_hda_query_supported_pcm(codec, info->nid,
0ba21762
TI		 2879 info->rates ? NULL : &info->rates,
2880 info->formats ? NULL : &info->formats,
2881 info->maxbps ? NULL : &info->maxbps);
ee504710
JK		 2882 if (err < 0)
2883 return err;
1da177e4
LT		 2884 }
2885 if (info->ops.open == NULL)
2886 info->ops.open = hda_pcm_default_open_close;
2887 if (info->ops.close == NULL)
2888 info->ops.close = hda_pcm_default_open_close;
2889 if (info->ops.prepare == NULL) {
da3cec35
TI		 2890 if (snd_BUG_ON(!info->nid))
2891 return -EINVAL;
1da177e4
LT		 2892 info->ops.prepare = hda_pcm_default_prepare;
2893 }
1da177e4 2894 if (info->ops.cleanup == NULL) {
da3cec35
TI		 2895 if (snd_BUG_ON(!info->nid))
2896 return -EINVAL;
1da177e4
LT		 2897 info->ops.cleanup = hda_pcm_default_cleanup;
2898 }
2899 return 0;
2900}
2901
e3303235
JK		 2902const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
2903 "Audio", "SPDIF", "HDMI", "Modem"
2904};
2905
529bd6c4
TI		 2906/*
2907 * get the empty PCM device number to assign
2908 */
2909static int get_empty_pcm_device(struct hda_bus *bus, int type)
2910{
f5d6def5
WF		 2911 /* audio device indices; not linear to keep compatibility */
2912 static int audio_idx[HDA_PCM_NTYPES][5] = {
2913 [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
2914 [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
92608bad 2915 [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
f5d6def5 2916 [HDA_PCM_TYPE_MODEM] = { 6, -1 },
529bd6c4 2917 };
f5d6def5
WF		 2918 int i;
2919
2920 if (type >= HDA_PCM_NTYPES) {
529bd6c4
TI		 2921 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
2922 return -EINVAL;
2923 }
f5d6def5
WF		 2924
2925 for (i = 0; audio_idx[type][i] >= 0 ; i++)
2926 if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
2927 return audio_idx[type][i];
2928
e3303235 2929 snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]);
f5d6def5 2930 return -EAGAIN;
529bd6c4
TI		 2931}
2932
176d5335
TI		 2933/*
2934 * attach a new PCM stream
2935 */
529bd6c4 2936static int snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
176d5335 2937{
33fa35ed 2938 struct hda_bus *bus = codec->bus;
176d5335
TI		 2939 struct hda_pcm_stream *info;
2940 int stream, err;
2941
b91f080f 2942 if (snd_BUG_ON(!pcm->name))
176d5335
TI		 2943 return -EINVAL;
2944 for (stream = 0; stream < 2; stream++) {
2945 info = &pcm->stream[stream];
2946 if (info->substreams) {
2947 err = set_pcm_default_values(codec, info);
2948 if (err < 0)
2949 return err;
2950 }
2951 }
33fa35ed 2952 return bus->ops.attach_pcm(bus, codec, pcm);
176d5335
TI		 2953}
2954
529bd6c4
TI		 2955/* assign all PCMs of the given codec */
2956int snd_hda_codec_build_pcms(struct hda_codec *codec)
2957{
2958 unsigned int pcm;
2959 int err;
2960
2961 if (!codec->num_pcms) {
2962 if (!codec->patch_ops.build_pcms)
2963 return 0;
2964 err = codec->patch_ops.build_pcms(codec);
6e655bf2
TI		 2965 if (err < 0) {
2966 printk(KERN_ERR "hda_codec: cannot build PCMs"
2967 "for #%d (error %d)\n", codec->addr, err);
2968 err = snd_hda_codec_reset(codec);
2969 if (err < 0) {
2970 printk(KERN_ERR
2971 "hda_codec: cannot revert codec\n");
2972 return err;
2973 }
2974 }
529bd6c4
TI		 2975 }
2976 for (pcm = 0; pcm < codec->num_pcms; pcm++) {
2977 struct hda_pcm *cpcm = &codec->pcm_info[pcm];
2978 int dev;
2979
2980 if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
41b5b01a 2981 continue; /* no substreams assigned */
529bd6c4
TI		 2982
2983 if (!cpcm->pcm) {
2984 dev = get_empty_pcm_device(codec->bus, cpcm->pcm_type);
2985 if (dev < 0)
6e655bf2 2986 continue; /* no fatal error */
529bd6c4
TI		 2987 cpcm->device = dev;
2988 err = snd_hda_attach_pcm(codec, cpcm);
6e655bf2
TI		 2989 if (err < 0) {
2990 printk(KERN_ERR "hda_codec: cannot attach "
2991 "PCM stream %d for codec #%d\n",
2992 dev, codec->addr);
2993 continue; /* no fatal error */
2994 }
529bd6c4
TI		 2995 }
2996 }
2997 return 0;
2998}
2999
1da177e4
LT		 3000/**
3001 * snd_hda_build_pcms - build PCM information
3002 * @bus: the BUS
3003 *
3004 * Create PCM information for each codec included in the bus.
3005 *
3006 * The build_pcms codec patch is requested to set up codec->num_pcms and
3007 * codec->pcm_info properly. The array is referred by the top-level driver
3008 * to create its PCM instances.
3009 * The allocated codec->pcm_info should be released in codec->patch_ops.free
3010 * callback.
3011 *
3012 * At least, substreams, channels_min and channels_max must be filled for
3013 * each stream. substreams = 0 indicates that the stream doesn't exist.
3014 * When rates and/or formats are zero, the supported values are queried
3015 * from the given nid. The nid is used also by the default ops.prepare
3016 * and ops.cleanup callbacks.
3017 *
3018 * The driver needs to call ops.open in its open callback. Similarly,
3019 * ops.close is supposed to be called in the close callback.
3020 * ops.prepare should be called in the prepare or hw_params callback
3021 * with the proper parameters for set up.
3022 * ops.cleanup should be called in hw_free for clean up of streams.
3023 *
3024 * This function returns 0 if successfull, or a negative error code.
3025 */
529bd6c4 3026int __devinit snd_hda_build_pcms(struct hda_bus *bus)
1da177e4 3027{
0ba21762 3028 struct hda_codec *codec;
1da177e4 3029
0ba21762 3030 list_for_each_entry(codec, &bus->codec_list, list) {
529bd6c4
TI		 3031 int err = snd_hda_codec_build_pcms(codec);
3032 if (err < 0)
3033 return err;
1da177e4
LT		 3034 }
3035 return 0;
3036}
ff7a3267 3037EXPORT_SYMBOL_HDA(snd_hda_build_pcms);
1da177e4 3038
1da177e4
LT		 3039/**
3040 * snd_hda_check_board_config - compare the current codec with the config table
3041 * @codec: the HDA codec
f5fcc13c
TI		 3042 * @num_configs: number of config enums
3043 * @models: array of model name strings
1da177e4
LT		 3044 * @tbl: configuration table, terminated by null entries
3045 *
3046 * Compares the modelname or PCI subsystem id of the current codec with the
3047 * given configuration table. If a matching entry is found, returns its
3048 * config value (supposed to be 0 or positive).
3049 *
3050 * If no entries are matching, the function returns a negative value.
3051 */
12f288bf
TI		 3052int snd_hda_check_board_config(struct hda_codec *codec,
3053 int num_configs, const char **models,
3054 const struct snd_pci_quirk *tbl)
1da177e4 3055{
f44ac837 3056 if (codec->modelname && models) {
f5fcc13c
TI		 3057 int i;
3058 for (i = 0; i < num_configs; i++) {
3059 if (models[i] &&
f44ac837 3060 !strcmp(codec->modelname, models[i])) {
f5fcc13c
TI		 3061 snd_printd(KERN_INFO "hda_codec: model '%s' is "
3062 "selected\n", models[i]);
3063 return i;
1da177e4
LT		 3064 }
3065 }
3066 }
3067
f5fcc13c
TI		 3068 if (!codec->bus->pci || !tbl)
3069 return -1;
3070
3071 tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
3072 if (!tbl)
3073 return -1;
3074 if (tbl->value >= 0 && tbl->value < num_configs) {
62cf872a 3075#ifdef CONFIG_SND_DEBUG_VERBOSE
f5fcc13c
TI		 3076 char tmp[10];
3077 const char *model = NULL;
3078 if (models)
3079 model = models[tbl->value];
3080 if (!model) {
3081 sprintf(tmp, "#%d", tbl->value);
3082 model = tmp;
1da177e4 3083 }
f5fcc13c
TI		 3084 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3085 "for config %x:%x (%s)\n",
3086 model, tbl->subvendor, tbl->subdevice,
3087 (tbl->name ? tbl->name : "Unknown device"));
3088#endif
3089 return tbl->value;
1da177e4
LT		 3090 }
3091 return -1;
3092}
ff7a3267 3093EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
1da177e4 3094
2eda3445
MCC		 3095/**
3096 * snd_hda_check_board_codec_sid_config - compare the current codec
3097 subsystem ID with the
3098 config table
3099
3100 This is important for Gateway notebooks with SB450 HDA Audio
3101 where the vendor ID of the PCI device is:
3102 ATI Technologies Inc SB450 HDA Audio [1002:437b]
3103 and the vendor/subvendor are found only at the codec.
3104
3105 * @codec: the HDA codec
3106 * @num_configs: number of config enums
3107 * @models: array of model name strings
3108 * @tbl: configuration table, terminated by null entries
3109 *
3110 * Compares the modelname or PCI subsystem id of the current codec with the
3111 * given configuration table. If a matching entry is found, returns its
3112 * config value (supposed to be 0 or positive).
3113 *
3114 * If no entries are matching, the function returns a negative value.
3115 */
3116int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
3117 int num_configs, const char **models,
3118 const struct snd_pci_quirk *tbl)
3119{
3120 const struct snd_pci_quirk *q;
3121
3122 /* Search for codec ID */
3123 for (q = tbl; q->subvendor; q++) {
3124 unsigned long vendorid = (q->subdevice) | (q->subvendor << 16);
3125
3126 if (vendorid == codec->subsystem_id)
3127 break;
3128 }
3129
3130 if (!q->subvendor)
3131 return -1;
3132
3133 tbl = q;
3134
3135 if (tbl->value >= 0 && tbl->value < num_configs) {
d94ff6b7 3136#ifdef CONFIG_SND_DEBUG_VERBOSE
2eda3445
MCC		 3137 char tmp[10];
3138 const char *model = NULL;
3139 if (models)
3140 model = models[tbl->value];
3141 if (!model) {
3142 sprintf(tmp, "#%d", tbl->value);
3143 model = tmp;
3144 }
3145 snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
3146 "for config %x:%x (%s)\n",
3147 model, tbl->subvendor, tbl->subdevice,
3148 (tbl->name ? tbl->name : "Unknown device"));
3149#endif
3150 return tbl->value;
3151 }
3152 return -1;
3153}
3154EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
3155
1da177e4
LT		 3156/**
3157 * snd_hda_add_new_ctls - create controls from the array
3158 * @codec: the HDA codec
c8b6bf9b 3159 * @knew: the array of struct snd_kcontrol_new
1da177e4
LT		 3160 *
3161 * This helper function creates and add new controls in the given array.
3162 * The array must be terminated with an empty entry as terminator.
3163 *
3164 * Returns 0 if successful, or a negative error code.
3165 */
12f288bf 3166int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
1da177e4 3167{
4d02d1b6 3168 int err;
1da177e4
LT		 3169
3170 for (; knew->name; knew++) {
54d17403
TI		 3171 struct snd_kcontrol *kctl;
3172 kctl = snd_ctl_new1(knew, codec);
0ba21762 3173 if (!kctl)
54d17403 3174 return -ENOMEM;
3911a4c1 3175 err = snd_hda_ctl_add(codec, 0, kctl);
54d17403 3176 if (err < 0) {
0ba21762 3177 if (!codec->addr)
54d17403
TI		 3178 return err;
3179 kctl = snd_ctl_new1(knew, codec);
0ba21762 3180 if (!kctl)
54d17403
TI		 3181 return -ENOMEM;
3182 kctl->id.device = codec->addr;
3911a4c1 3183 err = snd_hda_ctl_add(codec, 0, kctl);
0ba21762 3184 if (err < 0)
54d17403
TI		 3185 return err;
3186 }
1da177e4
LT		 3187 }
3188 return 0;
3189}
ff7a3267 3190EXPORT_SYMBOL_HDA(snd_hda_add_new_ctls);
1da177e4 3191
cb53c626
TI		 3192#ifdef CONFIG_SND_HDA_POWER_SAVE
3193static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
3194 unsigned int power_state);
3195
3196static void hda_power_work(struct work_struct *work)
3197{
3198 struct hda_codec *codec =
3199 container_of(work, struct hda_codec, power_work.work);
33fa35ed 3200 struct hda_bus *bus = codec->bus;
cb53c626 3201
2e492462
ML		 3202 if (!codec->power_on || codec->power_count) {
3203 codec->power_transition = 0;
cb53c626 3204 return;
2e492462 3205 }
cb53c626
TI		 3206
3207 hda_call_codec_suspend(codec);
33fa35ed
TI		 3208 if (bus->ops.pm_notify)
3209 bus->ops.pm_notify(bus);
cb53c626
TI		 3210}
3211
3212static void hda_keep_power_on(struct hda_codec *codec)
3213{
3214 codec->power_count++;
3215 codec->power_on = 1;
a2f6309e
TI		 3216 codec->power_jiffies = jiffies;
3217}
3218
3219void snd_hda_update_power_acct(struct hda_codec *codec)
3220{
3221 unsigned long delta = jiffies - codec->power_jiffies;
3222 if (codec->power_on)
3223 codec->power_on_acct += delta;
3224 else
3225 codec->power_off_acct += delta;
3226 codec->power_jiffies += delta;
cb53c626
TI		 3227}
3228
3229void snd_hda_power_up(struct hda_codec *codec)
3230{
33fa35ed
TI		 3231 struct hda_bus *bus = codec->bus;
3232
cb53c626 3233 codec->power_count++;
a221e287 3234 if (codec->power_on || codec->power_transition)
cb53c626
TI		 3235 return;
3236
a2f6309e 3237 snd_hda_update_power_acct(codec);
cb53c626 3238 codec->power_on = 1;
a2f6309e 3239 codec->power_jiffies = jiffies;
33fa35ed
TI		 3240 if (bus->ops.pm_notify)
3241 bus->ops.pm_notify(bus);
cb53c626
TI		 3242 hda_call_codec_resume(codec);
3243 cancel_delayed_work(&codec->power_work);
a221e287 3244 codec->power_transition = 0;
cb53c626 3245}
ff7a3267 3246EXPORT_SYMBOL_HDA(snd_hda_power_up);
1289e9e8
TI		 3247
3248#define power_save(codec) \
3249 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
cb53c626 3250
fee2fba3
TI		 3251#define power_save(codec) \
3252 ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
3253
cb53c626
TI		 3254void snd_hda_power_down(struct hda_codec *codec)
3255{
3256 --codec->power_count;
a221e287 3257 if (!codec->power_on || codec->power_count || codec->power_transition)
cb53c626 3258 return;
fee2fba3 3259 if (power_save(codec)) {
a221e287 3260 codec->power_transition = 1; /* avoid reentrance */
c107b41c 3261 queue_delayed_work(codec->bus->workq, &codec->power_work,
fee2fba3 3262 msecs_to_jiffies(power_save(codec) * 1000));
a221e287 3263 }
cb53c626 3264}
ff7a3267 3265EXPORT_SYMBOL_HDA(snd_hda_power_down);
cb53c626
TI		 3266
3267int snd_hda_check_amp_list_power(struct hda_codec *codec,
3268 struct hda_loopback_check *check,
3269 hda_nid_t nid)
3270{
3271 struct hda_amp_list *p;
3272 int ch, v;
3273
3274 if (!check->amplist)
3275 return 0;
3276 for (p = check->amplist; p->nid; p++) {
3277 if (p->nid == nid)
3278 break;
3279 }
3280 if (!p->nid)
3281 return 0; /* nothing changed */
3282
3283 for (p = check->amplist; p->nid; p++) {
3284 for (ch = 0; ch < 2; ch++) {
3285 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
3286 p->idx);
3287 if (!(v & HDA_AMP_MUTE) && v > 0) {
3288 if (!check->power_on) {
3289 check->power_on = 1;
3290 snd_hda_power_up(codec);
3291 }
3292 return 1;
3293 }
3294 }
3295 }
3296 if (check->power_on) {
3297 check->power_on = 0;
3298 snd_hda_power_down(codec);
3299 }
3300 return 0;
3301}
ff7a3267 3302EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
cb53c626 3303#endif
1da177e4 3304
c8b6bf9b 3305/*
d2a6d7dc
TI		 3306 * Channel mode helper
3307 */
0ba21762
TI		 3308int snd_hda_ch_mode_info(struct hda_codec *codec,
3309 struct snd_ctl_elem_info *uinfo,
3310 const struct hda_channel_mode *chmode,
3311 int num_chmodes)
d2a6d7dc
TI		 3312{
3313 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3314 uinfo->count = 1;
3315 uinfo->value.enumerated.items = num_chmodes;
3316 if (uinfo->value.enumerated.item >= num_chmodes)
3317 uinfo->value.enumerated.item = num_chmodes - 1;
3318 sprintf(uinfo->value.enumerated.name, "%dch",
3319 chmode[uinfo->value.enumerated.item].channels);
3320 return 0;
3321}
ff7a3267 3322EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
d2a6d7dc 3323
0ba21762
TI		 3324int snd_hda_ch_mode_get(struct hda_codec *codec,
3325 struct snd_ctl_elem_value *ucontrol,
3326 const struct hda_channel_mode *chmode,
3327 int num_chmodes,
d2a6d7dc
TI		 3328 int max_channels)
3329{
3330 int i;
3331
3332 for (i = 0; i < num_chmodes; i++) {
3333 if (max_channels == chmode[i].channels) {
3334 ucontrol->value.enumerated.item[0] = i;
3335 break;
3336 }
3337 }
3338 return 0;
3339}
ff7a3267 3340EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
d2a6d7dc 3341
0ba21762
TI		 3342int snd_hda_ch_mode_put(struct hda_codec *codec,
3343 struct snd_ctl_elem_value *ucontrol,
3344 const struct hda_channel_mode *chmode,
3345 int num_chmodes,
d2a6d7dc
TI		 3346 int *max_channelsp)
3347{
3348 unsigned int mode;
3349
3350 mode = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 3351 if (mode >= num_chmodes)
3352 return -EINVAL;
82beb8fd 3353 if (*max_channelsp == chmode[mode].channels)
d2a6d7dc
TI		 3354 return 0;
3355 /* change the current channel setting */
3356 *max_channelsp = chmode[mode].channels;
3357 if (chmode[mode].sequence)
82beb8fd 3358 snd_hda_sequence_write_cache(codec, chmode[mode].sequence);
d2a6d7dc
TI		 3359 return 1;
3360}
ff7a3267 3361EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
d2a6d7dc 3362
1da177e4
LT		 3363/*
3364 * input MUX helper
3365 */
0ba21762
TI		 3366int snd_hda_input_mux_info(const struct hda_input_mux *imux,
3367 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 3368{
3369 unsigned int index;
3370
3371 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3372 uinfo->count = 1;
3373 uinfo->value.enumerated.items = imux->num_items;
5513b0c5
TI		 3374 if (!imux->num_items)
3375 return 0;
1da177e4
LT		 3376 index = uinfo->value.enumerated.item;
3377 if (index >= imux->num_items)
3378 index = imux->num_items - 1;
3379 strcpy(uinfo->value.enumerated.name, imux->items[index].label);
3380 return 0;
3381}
ff7a3267 3382EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
1da177e4 3383
0ba21762
TI		 3384int snd_hda_input_mux_put(struct hda_codec *codec,
3385 const struct hda_input_mux *imux,
3386 struct snd_ctl_elem_value *ucontrol,
3387 hda_nid_t nid,
1da177e4
LT		 3388 unsigned int *cur_val)
3389{
3390 unsigned int idx;
3391
5513b0c5
TI		 3392 if (!imux->num_items)
3393 return 0;
1da177e4
LT		 3394 idx = ucontrol->value.enumerated.item[0];
3395 if (idx >= imux->num_items)
3396 idx = imux->num_items - 1;
82beb8fd 3397 if (*cur_val == idx)
1da177e4 3398 return 0;
82beb8fd
TI		 3399 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
3400 imux->items[idx].index);
1da177e4
LT		 3401 *cur_val = idx;
3402 return 1;
3403}
ff7a3267 3404EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
1da177e4
LT		 3405
3406
3407/*
3408 * Multi-channel / digital-out PCM helper functions
3409 */
3410
6b97eb45
TI		 3411/* setup SPDIF output stream */
3412static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
3413 unsigned int stream_tag, unsigned int format)
3414{
3415 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
2f72853c
TI		 3416 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3417 set_dig_out_convert(codec, nid,
3418 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
3419 -1);
6b97eb45 3420 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f72853c
TI		 3421 if (codec->slave_dig_outs) {
3422 hda_nid_t *d;
3423 for (d = codec->slave_dig_outs; *d; d++)
3424 snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
3425 format);
3426 }
6b97eb45 3427 /* turn on again (if needed) */
2f72853c
TI		 3428 if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
3429 set_dig_out_convert(codec, nid,
3430 codec->spdif_ctls & 0xff, -1);
3431}
de51ca12 3432
2f72853c
TI		 3433static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
3434{
3435 snd_hda_codec_cleanup_stream(codec, nid);
3436 if (codec->slave_dig_outs) {
3437 hda_nid_t *d;
3438 for (d = codec->slave_dig_outs; *d; d++)
3439 snd_hda_codec_cleanup_stream(codec, *d);
de51ca12 3440 }
6b97eb45
TI		 3441}
3442
fb8d1a34
TI		 3443/* call each reboot notifier */
3444void snd_hda_bus_reboot_notify(struct hda_bus *bus)
3445{
3446 struct hda_codec *codec;
3447
3448 if (!bus)
3449 return;
3450 list_for_each_entry(codec, &bus->codec_list, list) {
3451#ifdef CONFIG_SND_HDA_POWER_SAVE
3452 if (!codec->power_on)
3453 continue;
3454#endif
3455 if (codec->patch_ops.reboot_notify)
3456 codec->patch_ops.reboot_notify(codec);
3457 }
3458}
8f217a22 3459EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
fb8d1a34 3460
1da177e4
LT		 3461/*
3462 * open the digital out in the exclusive mode
3463 */
0ba21762
TI		 3464int snd_hda_multi_out_dig_open(struct hda_codec *codec,
3465 struct hda_multi_out *mout)
1da177e4 3466{
62932df8 3467 mutex_lock(&codec->spdif_mutex);
5930ca41
TI		 3468 if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
3469 /* already opened as analog dup; reset it once */
2f72853c 3470 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4 3471 mout->dig_out_used = HDA_DIG_EXCLUSIVE;
62932df8 3472 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3473 return 0;
3474}
ff7a3267 3475EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
1da177e4 3476
6b97eb45
TI		 3477int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
3478 struct hda_multi_out *mout,
3479 unsigned int stream_tag,
3480 unsigned int format,
3481 struct snd_pcm_substream *substream)
3482{
3483 mutex_lock(&codec->spdif_mutex);
3484 setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
3485 mutex_unlock(&codec->spdif_mutex);
3486 return 0;
3487}
ff7a3267 3488EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
6b97eb45 3489
9411e21c
TI		 3490int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
3491 struct hda_multi_out *mout)
3492{
3493 mutex_lock(&codec->spdif_mutex);
3494 cleanup_dig_out_stream(codec, mout->dig_out_nid);
3495 mutex_unlock(&codec->spdif_mutex);
3496 return 0;
3497}
3498EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
3499
1da177e4
LT		 3500/*
3501 * release the digital out
3502 */
0ba21762
TI		 3503int snd_hda_multi_out_dig_close(struct hda_codec *codec,
3504 struct hda_multi_out *mout)
1da177e4 3505{
62932df8 3506 mutex_lock(&codec->spdif_mutex);
1da177e4 3507 mout->dig_out_used = 0;
62932df8 3508 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3509 return 0;
3510}
ff7a3267 3511EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
1da177e4
LT		 3512
3513/*
3514 * set up more restrictions for analog out
3515 */
0ba21762
TI		 3516int snd_hda_multi_out_analog_open(struct hda_codec *codec,
3517 struct hda_multi_out *mout,
9a08160b
TI		 3518 struct snd_pcm_substream *substream,
3519 struct hda_pcm_stream *hinfo)
3520{
3521 struct snd_pcm_runtime *runtime = substream->runtime;
3522 runtime->hw.channels_max = mout->max_channels;
3523 if (mout->dig_out_nid) {
3524 if (!mout->analog_rates) {
3525 mout->analog_rates = hinfo->rates;
3526 mout->analog_formats = hinfo->formats;
3527 mout->analog_maxbps = hinfo->maxbps;
3528 } else {
3529 runtime->hw.rates = mout->analog_rates;
3530 runtime->hw.formats = mout->analog_formats;
3531 hinfo->maxbps = mout->analog_maxbps;
3532 }
3533 if (!mout->spdif_rates) {
3534 snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
3535 &mout->spdif_rates,
3536 &mout->spdif_formats,
3537 &mout->spdif_maxbps);
3538 }
3539 mutex_lock(&codec->spdif_mutex);
3540 if (mout->share_spdif) {
022b466f
TI		 3541 if ((runtime->hw.rates & mout->spdif_rates) &&
3542 (runtime->hw.formats & mout->spdif_formats)) {
3543 runtime->hw.rates &= mout->spdif_rates;
3544 runtime->hw.formats &= mout->spdif_formats;
3545 if (mout->spdif_maxbps < hinfo->maxbps)
3546 hinfo->maxbps = mout->spdif_maxbps;
3547 } else {
3548 mout->share_spdif = 0;
3549 /* FIXME: need notify? */
3550 }
9a08160b 3551 }
eaa9985b 3552 mutex_unlock(&codec->spdif_mutex);
9a08160b 3553 }
1da177e4
LT		 3554 return snd_pcm_hw_constraint_step(substream->runtime, 0,
3555 SNDRV_PCM_HW_PARAM_CHANNELS, 2);
3556}
ff7a3267 3557EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
1da177e4
LT		 3558
3559/*
3560 * set up the i/o for analog out
3561 * when the digital out is available, copy the front out to digital out, too.
3562 */
0ba21762
TI		 3563int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
3564 struct hda_multi_out *mout,
1da177e4
LT		 3565 unsigned int stream_tag,
3566 unsigned int format,
c8b6bf9b 3567 struct snd_pcm_substream *substream)
1da177e4
LT		 3568{
3569 hda_nid_t *nids = mout->dac_nids;
3570 int chs = substream->runtime->channels;
3571 int i;
3572
62932df8 3573 mutex_lock(&codec->spdif_mutex);
9a08160b
TI		 3574 if (mout->dig_out_nid && mout->share_spdif &&
3575 mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1da177e4 3576 if (chs == 2 &&
0ba21762
TI		 3577 snd_hda_is_supported_format(codec, mout->dig_out_nid,
3578 format) &&
3579 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
1da177e4 3580 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
6b97eb45
TI		 3581 setup_dig_out_stream(codec, mout->dig_out_nid,
3582 stream_tag, format);
1da177e4
LT		 3583 } else {
3584 mout->dig_out_used = 0;
2f72853c 3585 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3586 }
3587 }
62932df8 3588 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3589
3590 /* front */
0ba21762
TI		 3591 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
3592 0, format);
d29240ce
TI		 3593 if (!mout->no_share_stream &&
3594 mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
1da177e4 3595 /* headphone out will just decode front left/right (stereo) */
0ba21762
TI		 3596 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
3597 0, format);
82bc955f
TI		 3598 /* extra outputs copied from front */
3599 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
d29240ce 3600 if (!mout->no_share_stream && mout->extra_out_nid[i])
82bc955f
TI		 3601 snd_hda_codec_setup_stream(codec,
3602 mout->extra_out_nid[i],
3603 stream_tag, 0, format);
3604
1da177e4
LT		 3605 /* surrounds */
3606 for (i = 1; i < mout->num_dacs; i++) {
4b3acaf5 3607 if (chs >= (i + 1) * 2) /* independent out */
0ba21762
TI		 3608 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3609 i * 2, format);
d29240ce 3610 else if (!mout->no_share_stream) /* copy front */
0ba21762
TI		 3611 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
3612 0, format);
1da177e4
LT		 3613 }
3614 return 0;
3615}
ff7a3267 3616EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
1da177e4
LT		 3617
3618/*
3619 * clean up the setting for analog out
3620 */
0ba21762
TI		 3621int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
3622 struct hda_multi_out *mout)
1da177e4
LT		 3623{
3624 hda_nid_t *nids = mout->dac_nids;
3625 int i;
3626
3627 for (i = 0; i < mout->num_dacs; i++)
888afa15 3628 snd_hda_codec_cleanup_stream(codec, nids[i]);
1da177e4 3629 if (mout->hp_nid)
888afa15 3630 snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
82bc955f
TI		 3631 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
3632 if (mout->extra_out_nid[i])
888afa15
TI		 3633 snd_hda_codec_cleanup_stream(codec,
3634 mout->extra_out_nid[i]);
62932df8 3635 mutex_lock(&codec->spdif_mutex);
1da177e4 3636 if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
2f72853c 3637 cleanup_dig_out_stream(codec, mout->dig_out_nid);
1da177e4
LT		 3638 mout->dig_out_used = 0;
3639 }
62932df8 3640 mutex_unlock(&codec->spdif_mutex);
1da177e4
LT		 3641 return 0;
3642}
ff7a3267 3643EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_cleanup);
1da177e4 3644
e9edcee0 3645/*
6b34500c 3646 * Helper for automatic pin configuration
e9edcee0 3647 */
df694daa 3648
12f288bf 3649static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
df694daa
KY		 3650{
3651 for (; *list; list++)
3652 if (*list == nid)
3653 return 1;
3654 return 0;
3655}
3656
81937d3b
SL		 3657
3658/*
3659 * Sort an associated group of pins according to their sequence numbers.
3660 */
3661static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
3662 int num_pins)
3663{
3664 int i, j;
3665 short seq;
3666 hda_nid_t nid;
3667
3668 for (i = 0; i < num_pins; i++) {
3669 for (j = i + 1; j < num_pins; j++) {
3670 if (sequences[i] > sequences[j]) {
3671 seq = sequences[i];
3672 sequences[i] = sequences[j];
3673 sequences[j] = seq;
3674 nid = pins[i];
3675 pins[i] = pins[j];
3676 pins[j] = nid;
3677 }
3678 }
3679 }
3680}
3681
3682
82bc955f
TI		 3683/*
3684 * Parse all pin widgets and store the useful pin nids to cfg
3685 *
3686 * The number of line-outs or any primary output is stored in line_outs,
3687 * and the corresponding output pins are assigned to line_out_pins[],
3688 * in the order of front, rear, CLFE, side, ...
3689 *
3690 * If more extra outputs (speaker and headphone) are found, the pins are
eb06ed8f 3691 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack
82bc955f
TI		 3692 * is detected, one of speaker of HP pins is assigned as the primary
3693 * output, i.e. to line_out_pins[0]. So, line_outs is always positive
3694 * if any analog output exists.
3695 *
3696 * The analog input pins are assigned to input_pins array.
3697 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
3698 * respectively.
3699 */
12f288bf
TI		 3700int snd_hda_parse_pin_def_config(struct hda_codec *codec,
3701 struct auto_pin_cfg *cfg,
3702 hda_nid_t *ignore_nids)
e9edcee0 3703{
0ef6ce7b 3704 hda_nid_t nid, end_nid;
81937d3b
SL		 3705 short seq, assoc_line_out, assoc_speaker;
3706 short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)];
3707 short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)];
f889fa91 3708 short sequences_hp[ARRAY_SIZE(cfg->hp_pins)];
e9edcee0
TI		 3709
3710 memset(cfg, 0, sizeof(*cfg));
3711
81937d3b
SL		 3712 memset(sequences_line_out, 0, sizeof(sequences_line_out));
3713 memset(sequences_speaker, 0, sizeof(sequences_speaker));
f889fa91 3714 memset(sequences_hp, 0, sizeof(sequences_hp));
81937d3b 3715 assoc_line_out = assoc_speaker = 0;
e9edcee0 3716
0ef6ce7b
TI		 3717 end_nid = codec->start_nid + codec->num_nodes;
3718 for (nid = codec->start_nid; nid < end_nid; nid++) {
54d17403 3719 unsigned int wid_caps = get_wcaps(codec, nid);
a22d543a 3720 unsigned int wid_type = get_wcaps_type(wid_caps);
e9edcee0
TI		 3721 unsigned int def_conf;
3722 short assoc, loc;
3723
3724 /* read all default configuration for pin complex */
3725 if (wid_type != AC_WID_PIN)
3726 continue;
df694daa
KY		 3727 /* ignore the given nids (e.g. pc-beep returns error) */
3728 if (ignore_nids && is_in_nid_list(nid, ignore_nids))
3729 continue;
3730
c17a1aba 3731 def_conf = snd_hda_codec_get_pincfg(codec, nid);
e9edcee0
TI		 3732 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3733 continue;
3734 loc = get_defcfg_location(def_conf);
3735 switch (get_defcfg_device(def_conf)) {
3736 case AC_JACK_LINE_OUT:
e9edcee0
TI		 3737 seq = get_defcfg_sequence(def_conf);
3738 assoc = get_defcfg_association(def_conf);
90da78bf
MR		 3739
3740 if (!(wid_caps & AC_WCAP_STEREO))
3741 if (!cfg->mono_out_pin)
3742 cfg->mono_out_pin = nid;
0ba21762 3743 if (!assoc)
e9edcee0 3744 continue;
0ba21762 3745 if (!assoc_line_out)
e9edcee0
TI		 3746 assoc_line_out = assoc;
3747 else if (assoc_line_out != assoc)
3748 continue;
3749 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins))
3750 continue;
3751 cfg->line_out_pins[cfg->line_outs] = nid;
81937d3b 3752 sequences_line_out[cfg->line_outs] = seq;
e9edcee0
TI		 3753 cfg->line_outs++;
3754 break;
8d88bc3d 3755 case AC_JACK_SPEAKER:
81937d3b
SL		 3756 seq = get_defcfg_sequence(def_conf);
3757 assoc = get_defcfg_association(def_conf);
3758 if (! assoc)
3759 continue;
3760 if (! assoc_speaker)
3761 assoc_speaker = assoc;
3762 else if (assoc_speaker != assoc)
3763 continue;
82bc955f
TI		 3764 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins))
3765 continue;
3766 cfg->speaker_pins[cfg->speaker_outs] = nid;
81937d3b 3767 sequences_speaker[cfg->speaker_outs] = seq;
82bc955f 3768 cfg->speaker_outs++;
8d88bc3d 3769 break;
e9edcee0 3770 case AC_JACK_HP_OUT:
f889fa91
TI		 3771 seq = get_defcfg_sequence(def_conf);
3772 assoc = get_defcfg_association(def_conf);
eb06ed8f
TI		 3773 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
3774 continue;
3775 cfg->hp_pins[cfg->hp_outs] = nid;
f889fa91 3776 sequences_hp[cfg->hp_outs] = (assoc << 4) | seq;
eb06ed8f 3777 cfg->hp_outs++;
e9edcee0 3778 break;
314634bc
TI		 3779 case AC_JACK_MIC_IN: {
3780 int preferred, alt;
3781 if (loc == AC_JACK_LOC_FRONT) {
3782 preferred = AUTO_PIN_FRONT_MIC;
3783 alt = AUTO_PIN_MIC;
3784 } else {
3785 preferred = AUTO_PIN_MIC;
3786 alt = AUTO_PIN_FRONT_MIC;
3787 }
3788 if (!cfg->input_pins[preferred])
3789 cfg->input_pins[preferred] = nid;
3790 else if (!cfg->input_pins[alt])
3791 cfg->input_pins[alt] = nid;
e9edcee0 3792 break;
314634bc 3793 }
e9edcee0
TI		 3794 case AC_JACK_LINE_IN:
3795 if (loc == AC_JACK_LOC_FRONT)
3796 cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid;
3797 else
3798 cfg->input_pins[AUTO_PIN_LINE] = nid;
3799 break;
3800 case AC_JACK_CD:
3801 cfg->input_pins[AUTO_PIN_CD] = nid;
3802 break;
3803 case AC_JACK_AUX:
3804 cfg->input_pins[AUTO_PIN_AUX] = nid;
3805 break;
3806 case AC_JACK_SPDIF_OUT:
1b52ae70 3807 case AC_JACK_DIG_OTHER_OUT:
0852d7a6
TI		 3808 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins))
3809 continue;
3810 cfg->dig_out_pins[cfg->dig_outs] = nid;
3811 cfg->dig_out_type[cfg->dig_outs] =
3812 (loc == AC_JACK_LOC_HDMI) ?
3813 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF;
3814 cfg->dig_outs++;
e9edcee0
TI		 3815 break;
3816 case AC_JACK_SPDIF_IN:
1b52ae70 3817 case AC_JACK_DIG_OTHER_IN:
e9edcee0 3818 cfg->dig_in_pin = nid;
2297bd6e
TI		 3819 if (loc == AC_JACK_LOC_HDMI)
3820 cfg->dig_in_type = HDA_PCM_TYPE_HDMI;
3821 else
3822 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
e9edcee0
TI		 3823 break;
3824 }
3825 }
3826
5832fcf8
TI		 3827 /* FIX-UP:
3828 * If no line-out is defined but multiple HPs are found,
3829 * some of them might be the real line-outs.
3830 */
3831 if (!cfg->line_outs && cfg->hp_outs > 1) {
3832 int i = 0;
3833 while (i < cfg->hp_outs) {
3834 /* The real HPs should have the sequence 0x0f */
3835 if ((sequences_hp[i] & 0x0f) == 0x0f) {
3836 i++;
3837 continue;
3838 }
3839 /* Move it to the line-out table */
3840 cfg->line_out_pins[cfg->line_outs] = cfg->hp_pins[i];
3841 sequences_line_out[cfg->line_outs] = sequences_hp[i];
3842 cfg->line_outs++;
3843 cfg->hp_outs--;
3844 memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
3845 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
3846 memmove(sequences_hp + i - 1, sequences_hp + i,
3847 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
3848 }
3849 }
3850
e9edcee0 3851 /* sort by sequence */
81937d3b
SL		 3852 sort_pins_by_sequence(cfg->line_out_pins, sequences_line_out,
3853 cfg->line_outs);
3854 sort_pins_by_sequence(cfg->speaker_pins, sequences_speaker,
3855 cfg->speaker_outs);
f889fa91
TI		 3856 sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
3857 cfg->hp_outs);
81937d3b 3858
f889fa91
TI		 3859 /* if we have only one mic, make it AUTO_PIN_MIC */
3860 if (!cfg->input_pins[AUTO_PIN_MIC] &&
3861 cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
3862 cfg->input_pins[AUTO_PIN_MIC] =
3863 cfg->input_pins[AUTO_PIN_FRONT_MIC];
3864 cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0;
3865 }
3866 /* ditto for line-in */
3867 if (!cfg->input_pins[AUTO_PIN_LINE] &&
3868 cfg->input_pins[AUTO_PIN_FRONT_LINE]) {
3869 cfg->input_pins[AUTO_PIN_LINE] =
3870 cfg->input_pins[AUTO_PIN_FRONT_LINE];
3871 cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0;
3872 }
3873
81937d3b
SL		 3874 /*
3875 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin
3876 * as a primary output
3877 */
3878 if (!cfg->line_outs) {
3879 if (cfg->speaker_outs) {
3880 cfg->line_outs = cfg->speaker_outs;
3881 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3882 sizeof(cfg->speaker_pins));
3883 cfg->speaker_outs = 0;
3884 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3885 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3886 } else if (cfg->hp_outs) {
3887 cfg->line_outs = cfg->hp_outs;
3888 memcpy(cfg->line_out_pins, cfg->hp_pins,
3889 sizeof(cfg->hp_pins));
3890 cfg->hp_outs = 0;
3891 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3892 cfg->line_out_type = AUTO_PIN_HP_OUT;
3893 }
3894 }
e9edcee0 3895
cb8e2f83
TI		 3896 /* Reorder the surround channels
3897 * ALSA sequence is front/surr/clfe/side
3898 * HDA sequence is:
3899 * 4-ch: front/surr => OK as it is
3900 * 6-ch: front/clfe/surr
9422db40 3901 * 8-ch: front/clfe/rear/side|fc
cb8e2f83
TI		 3902 */
3903 switch (cfg->line_outs) {
3904 case 3:
cb8e2f83
TI		 3905 case 4:
3906 nid = cfg->line_out_pins[1];
9422db40 3907 cfg->line_out_pins[1] = cfg->line_out_pins[2];
cb8e2f83
TI		 3908 cfg->line_out_pins[2] = nid;
3909 break;
e9edcee0
TI		 3910 }
3911
82bc955f
TI		 3912 /*
3913 * debug prints of the parsed results
3914 */
3915 snd_printd("autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3916 cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
3917 cfg->line_out_pins[2], cfg->line_out_pins[3],
3918 cfg->line_out_pins[4]);
3919 snd_printd(" speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3920 cfg->speaker_outs, cfg->speaker_pins[0],
3921 cfg->speaker_pins[1], cfg->speaker_pins[2],
3922 cfg->speaker_pins[3], cfg->speaker_pins[4]);
eb06ed8f
TI		 3923 snd_printd(" hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3924 cfg->hp_outs, cfg->hp_pins[0],
3925 cfg->hp_pins[1], cfg->hp_pins[2],
3926 cfg->hp_pins[3], cfg->hp_pins[4]);
90da78bf 3927 snd_printd(" mono: mono_out=0x%x\n", cfg->mono_out_pin);
0852d7a6
TI		 3928 if (cfg->dig_outs)
3929 snd_printd(" dig-out=0x%x/0x%x\n",
3930 cfg->dig_out_pins[0], cfg->dig_out_pins[1]);
82bc955f
TI		 3931 snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
3932 " cd=0x%x, aux=0x%x\n",
3933 cfg->input_pins[AUTO_PIN_MIC],
3934 cfg->input_pins[AUTO_PIN_FRONT_MIC],
3935 cfg->input_pins[AUTO_PIN_LINE],
3936 cfg->input_pins[AUTO_PIN_FRONT_LINE],
3937 cfg->input_pins[AUTO_PIN_CD],
3938 cfg->input_pins[AUTO_PIN_AUX]);
32d2c7fa 3939 if (cfg->dig_in_pin)
89ce9e87 3940 snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin);
82bc955f 3941
e9edcee0
TI		 3942 return 0;
3943}
ff7a3267 3944EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config);
e9edcee0 3945
4a471b7d
TI		 3946/* labels for input pins */
3947const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = {
3948 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux"
3949};
ff7a3267 3950EXPORT_SYMBOL_HDA(auto_pin_cfg_labels);
4a471b7d
TI		 3951
3952
1da177e4
LT		 3953#ifdef CONFIG_PM
3954/*
3955 * power management
3956 */
3957
3958/**
3959 * snd_hda_suspend - suspend the codecs
3960 * @bus: the HDA bus
1da177e4
LT		 3961 *
3962 * Returns 0 if successful.
3963 */
8dd78330 3964int snd_hda_suspend(struct hda_bus *bus)
1da177e4 3965{
0ba21762 3966 struct hda_codec *codec;
1da177e4 3967
0ba21762 3968 list_for_each_entry(codec, &bus->codec_list, list) {
0b7a2e9c
TI		 3969#ifdef CONFIG_SND_HDA_POWER_SAVE
3970 if (!codec->power_on)
3971 continue;
3972#endif
cb53c626 3973 hda_call_codec_suspend(codec);
1da177e4
LT		 3974 }
3975 return 0;
3976}
ff7a3267 3977EXPORT_SYMBOL_HDA(snd_hda_suspend);
1da177e4
LT		 3978
3979/**
3980 * snd_hda_resume - resume the codecs
3981 * @bus: the HDA bus
1da177e4
LT		 3982 *
3983 * Returns 0 if successful.
cb53c626
TI		 3984 *
3985 * This fucntion is defined only when POWER_SAVE isn't set.
3986 * In the power-save mode, the codec is resumed dynamically.
1da177e4
LT		 3987 */
3988int snd_hda_resume(struct hda_bus *bus)
3989{
0ba21762 3990 struct hda_codec *codec;
1da177e4 3991
0ba21762 3992 list_for_each_entry(codec, &bus->codec_list, list) {
d804ad92
ML		 3993 if (snd_hda_codec_needs_resume(codec))
3994 hda_call_codec_resume(codec);
1da177e4 3995 }
1da177e4
LT		 3996 return 0;
3997}
ff7a3267 3998EXPORT_SYMBOL_HDA(snd_hda_resume);
1289e9e8 3999#endif /* CONFIG_PM */
b2e18597
TI		 4000
4001/*
4002 * generic arrays
4003 */
4004
4005/* get a new element from the given array
4006 * if it exceeds the pre-allocated array size, re-allocate the array
4007 */
4008void *snd_array_new(struct snd_array *array)
4009{
4010 if (array->used >= array->alloced) {
4011 int num = array->alloced + array->alloc_align;
b910d9ae
TI		 4012 void *nlist;
4013 if (snd_BUG_ON(num >= 4096))
4014 return NULL;
4015 nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
b2e18597
TI		 4016 if (!nlist)
4017 return NULL;
4018 if (array->list) {
4019 memcpy(nlist, array->list,
4020 array->elem_size * array->alloced);
4021 kfree(array->list);
4022 }
4023 array->list = nlist;
4024 array->alloced = num;
4025 }
f43aa025 4026 return snd_array_elem(array, array->used++);
b2e18597 4027}
ff7a3267 4028EXPORT_SYMBOL_HDA(snd_array_new);
b2e18597
TI		 4029
4030/* free the given array elements */
4031void snd_array_free(struct snd_array *array)
4032{
4033 kfree(array->list);
4034 array->used = 0;
4035 array->alloced = 0;
4036 array->list = NULL;
4037}
ff7a3267 4038EXPORT_SYMBOL_HDA(snd_array_free);
b2022266
TI		 4039
4040/*
4041 * used by hda_proc.c and hda_eld.c
4042 */
4043void snd_print_pcm_rates(int pcm, char *buf, int buflen)
4044{
4045 static unsigned int rates[] = {
4046 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
4047 96000, 176400, 192000, 384000
4048 };
4049 int i, j;
4050
4051 for (i = 0, j = 0; i < ARRAY_SIZE(rates); i++)
4052 if (pcm & (1 << i))
4053 j += snprintf(buf + j, buflen - j, " %d", rates[i]);
4054
4055 buf[j] = '\0'; /* necessary when j == 0 */
4056}
ff7a3267 4057EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
b2022266
TI		 4058
4059void snd_print_pcm_bits(int pcm, char *buf, int buflen)
4060{
4061 static unsigned int bits[] = { 8, 16, 20, 24, 32 };
4062 int i, j;
4063
4064 for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
4065 if (pcm & (AC_SUPPCM_BITS_8 << i))
4066 j += snprintf(buf + j, buflen - j, " %d", bits[i]);
4067
4068 buf[j] = '\0'; /* necessary when j == 0 */
4069}
ff7a3267 4070EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
1289e9e8
TI		 4071
4072MODULE_DESCRIPTION("HDA codec core");
4073MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)