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