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