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