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