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