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