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