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