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