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