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