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