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