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