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